KiritoTRw
GitHub
parent
27767e72ab
commit
46c0830804
|
|
@ -0,0 +1,89 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
const int maxN=305;
|
||||
const int maxM=35;
|
||||
typedef double db;
|
||||
const db eps=1e-12;
|
||||
db dp[maxN][maxM];
|
||||
int pre[maxN][maxM];
|
||||
db cur[maxM][maxM];
|
||||
db Prev[maxM][maxM];
|
||||
int shot[500],N;
|
||||
int inv[maxM];
|
||||
int main()
|
||||
{
|
||||
int T;scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&N);
|
||||
memset(shot,-1,sizeof(shot));
|
||||
for(int i=0;i<N;++i)
|
||||
{
|
||||
char a[2];scanf("%s",a);
|
||||
shot[a[0]]=i;
|
||||
inv[i]=a[0];
|
||||
}
|
||||
for(int i=0;i<N;++i)
|
||||
for(int j=0;j<N;++j){
|
||||
scanf("%lf",&cur[i][j]);
|
||||
cur[i][j]=log(cur[i][j]);
|
||||
}
|
||||
for(int i=0;i<N;++i)
|
||||
for(int j=0;j<N;++j) {
|
||||
scanf("%lf",&Prev[i][j]);
|
||||
Prev[i][j]=log(Prev[i][j]);
|
||||
}
|
||||
int M;scanf("%d",&M);
|
||||
while(M--)
|
||||
{
|
||||
char ss[500];scanf("%s",ss);
|
||||
int l=strlen(ss);
|
||||
for(int i=0;i<=l;++i)
|
||||
for(int j=0;j<N;++j)
|
||||
dp[i][j]=-1e200,pre[i][j]=-1;
|
||||
dp[0][0]=0;
|
||||
for(int i=0;i<l;++i)
|
||||
{
|
||||
int hj=shot[ss[i]];
|
||||
for(int j=0;j<N;++j)
|
||||
{
|
||||
for(int k=0;k<N;++k)
|
||||
{
|
||||
db tmp=dp[i][j]+cur[k][hj];
|
||||
if(i!=0) tmp=tmp+Prev[j][k];
|
||||
if(tmp>dp[i+1][k])
|
||||
{
|
||||
pre[i+1][k]=j;
|
||||
dp[i+1][k]=tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
db maxx=-1e200;
|
||||
int idx=-1;
|
||||
for(int i=0;i<N;++i)
|
||||
{
|
||||
if(dp[l][i]>maxx)
|
||||
{
|
||||
maxx=dp[l][i];
|
||||
idx=i;
|
||||
}
|
||||
}
|
||||
int ans[500];
|
||||
int mm=l;
|
||||
while(mm)
|
||||
{
|
||||
ans[mm]=idx;
|
||||
idx=pre[mm][idx];
|
||||
mm--;
|
||||
}
|
||||
for(int i=1;i<=l;++i)
|
||||
printf("%c",inv[ans[i]]);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
struct Edge
|
||||
{
|
||||
int l,r,w;
|
||||
bool operator<(const Edge &b)const
|
||||
{
|
||||
return w>b.w;
|
||||
}
|
||||
};
|
||||
Edge p[100005];
|
||||
int set[105];
|
||||
int m;
|
||||
int map[105][105],w[105];
|
||||
int find(int x)
|
||||
{
|
||||
if(x==set[x])return x;
|
||||
return set[x]=find(set[x]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&m);
|
||||
memset(map,0,sizeof(map));
|
||||
for(int i=0;i<m;i++)
|
||||
{
|
||||
int j,t,k;
|
||||
scanf("%d",&j);
|
||||
scanf("%d%d",&w[j],&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&k);
|
||||
map[j][k]=map[k][j]=1;
|
||||
}
|
||||
}
|
||||
Edge tmp;
|
||||
int tot=0,sum=0;
|
||||
for(int i=0;i<m;i++)
|
||||
for(int j=i+1;j<m;j++)
|
||||
if(map[i][j])
|
||||
{
|
||||
tmp.l=i;
|
||||
tmp.r=j;
|
||||
tmp.w=(w[i]+w[j]);
|
||||
p[tot++]=tmp;
|
||||
sum+=w[i]+w[j];
|
||||
}
|
||||
sort(p,p+tot);
|
||||
for(int i=0;i<m;i++)set[i]=i;
|
||||
int cnt=0,ret=0;
|
||||
for(int i=0;i<tot;i++)
|
||||
{
|
||||
int l=find(p[i].l);
|
||||
int r=find(p[i].r);
|
||||
if(l==r)continue;
|
||||
set[l]=r;
|
||||
ret+=p[i].w;
|
||||
}
|
||||
printf("%d\n",sum-ret);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int oo = 1000000000;
|
||||
char s[10010], cards[2][50];
|
||||
int dp[10010], nc[2], value[300];
|
||||
void update(int& x, int y)
|
||||
{
|
||||
if (y > x) x = y;
|
||||
}
|
||||
int lv(int u)
|
||||
{
|
||||
int ret = 0;
|
||||
for (int i = 0; i < nc[u]; ++i) ret += value[cards[u][i]];
|
||||
return ret;
|
||||
}
|
||||
int hv(int u)
|
||||
{
|
||||
int ret = 0, x = 0;
|
||||
for (int i = 0; i < nc[u]; ++i)
|
||||
if (cards[u][i] == 'A') ++x, ret += 11;
|
||||
else ret += value[cards[u][i]];
|
||||
while (ret > 21 && x > 0) ret -= 10, --x;
|
||||
return ret;
|
||||
}
|
||||
void getCard(int u, int& cur)
|
||||
{
|
||||
cards[u][nc[u]++] = s[cur++];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
for (int i = '2'; i <= '9'; ++i) value[i] = i-'0';
|
||||
value['T'] = value['J'] = value['Q'] = value['K'] = 10;
|
||||
value['A'] = 1;
|
||||
int T, n, p, q, l[2];
|
||||
scanf("%d", &T);
|
||||
while (T--) {
|
||||
scanf("%d%d%d", &n, &p, &q);
|
||||
int cur = 0;
|
||||
while (cur < n) {
|
||||
scanf("%s", s+1+cur);
|
||||
cur += strlen(s+1+cur);
|
||||
}
|
||||
for (int i = 1; i <= n; ++i) dp[i] = -oo;
|
||||
dp[0] = 0;
|
||||
for (int i = 0; i < n; ++i) if(dp[i] != -oo) {
|
||||
if (i+4 > n) {
|
||||
update(dp[n], dp[i]);
|
||||
continue;
|
||||
}
|
||||
int cur = i + 1;
|
||||
nc[0] = nc[1] = 0;
|
||||
getCard(0, cur);
|
||||
getCard(1, cur);
|
||||
getCard(0, cur);
|
||||
getCard(1, cur);
|
||||
l[0] = value[cards[0][0]]+value[cards[0][1]];
|
||||
while(1) {
|
||||
if (l[0] > 21) {
|
||||
update(dp[cur-1], dp[i] - p);
|
||||
break;
|
||||
}
|
||||
int pre = cur;
|
||||
nc[1] = 2;
|
||||
while (pre <= n && hv(1) < 17) getCard(1, pre);
|
||||
if (hv(1) < 17) update(dp[n], dp[i]);
|
||||
else {
|
||||
int h[2] = {hv(0), hv(1)};
|
||||
if (lv(1) > 21) update(dp[pre-1], dp[i] + q);
|
||||
else if (h[0] > h[1]) update(dp[pre-1], dp[i] + q);
|
||||
else if (h[0] < h[1]) update(dp[pre-1], dp[i] - p);
|
||||
else update(dp[pre-1], dp[i]);
|
||||
}
|
||||
if (cur <= n) {
|
||||
l[0] += value[s[cur]];
|
||||
getCard(0, cur);
|
||||
}
|
||||
else {
|
||||
update(dp[n], dp[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n", dp[n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
typedef double db;
|
||||
const db PI = acos(-1.0);
|
||||
const db eps = 1e-15;
|
||||
const db oo = 1e100;
|
||||
struct pt{
|
||||
db x,y;
|
||||
pt(){}pt(db x,db y):x(x),y(y){}
|
||||
pt operator -(pt a){return pt(x-a.x,y-a.y);}
|
||||
db operator *(pt a){return x*a.x+y*a.y;}
|
||||
db operator &(pt a){return x*a.y-y*a.x;}
|
||||
db len(){return sqrt(x*x+y*y);}
|
||||
db ang(){return atan2(y,x);}
|
||||
void getP(){scanf("%lf%lf",&x,&y);}
|
||||
};
|
||||
struct circle{
|
||||
pt o;
|
||||
db r,a,l;
|
||||
void getC(){o.getP();l = o.len();a = o.ang();scanf("%lf",&r);}
|
||||
};
|
||||
struct box{
|
||||
db s,d,c;
|
||||
};
|
||||
const int MaxC = 1024;
|
||||
circle cl[MaxC];
|
||||
box fm[MaxC][MaxC];
|
||||
db dis[MaxC],w[MaxC];
|
||||
bool U[MaxC];
|
||||
int sign(db x){return (x > eps)-(x < -eps);}
|
||||
db calTime(int x,int y,db ct){
|
||||
box &cb = fm[x][y];
|
||||
if (cb.c > oo / 2)
|
||||
return oo;
|
||||
if (sign(cb.c) == 0)
|
||||
return ct;
|
||||
db ft = cb.s+floor((ct-cb.s) / cb.c-1.0)*cb.c;
|
||||
while (sign(ft-ct) < 0 && sign(ct-ft-cb.d) > 0)
|
||||
ft += cb.c;
|
||||
return max(ft,ct);
|
||||
}
|
||||
int main(){
|
||||
int tCase;
|
||||
scanf("%d",&tCase);
|
||||
for (int ct = 1;ct <= tCase;ct++){
|
||||
int N;
|
||||
scanf("%d",&N);
|
||||
for (int i = 0;i < N;i++){
|
||||
cl[i].getC();
|
||||
scanf("%lf",&w[i]);
|
||||
}
|
||||
for (int i = 0;i < N;i++)
|
||||
for (int j = 0;j < N;j++)if (i != j){
|
||||
box &cb = fm[i][j];
|
||||
db a = cl[i].l,b = cl[j].l,c = cl[j].r;
|
||||
if (sign(c-fabs(a-b)) < 0){
|
||||
cb.c = oo;
|
||||
continue;
|
||||
}
|
||||
if (sign(c-a-b) >= 0){
|
||||
cb.c = 0.0;
|
||||
continue;
|
||||
}
|
||||
db cd = (a*a+b*b-c*c) / (2.0*a*b);
|
||||
if (sign(cd-1.0) >= 0) cd = 1.0;
|
||||
if (sign(cd+1.0) <= 0) cd = -1.0;
|
||||
db da = acos(cd);
|
||||
db cw = w[i]-w[j];
|
||||
db ca = cl[j].a-cl[i].a;
|
||||
while (sign(ca+PI) < 0) ca += PI*2;
|
||||
if (sign(cw) == 0){
|
||||
if (sign(fabs(ca)-da) <= 0)
|
||||
cb.c = 0.0;
|
||||
else
|
||||
cb.c = oo;
|
||||
continue;
|
||||
}
|
||||
cb.c = PI*2.0 / fabs(cw);
|
||||
cb.d = da*2.0 / fabs(cw);
|
||||
cb.s = ca / cw-cb.d*0.5;
|
||||
}
|
||||
memset(U,0,sizeof(U[0])*N);
|
||||
dis[0] = 0.0;
|
||||
for (int j = 1;j < N;j++)
|
||||
dis[j] = calTime(0,j,0.0);
|
||||
U[0] = true;
|
||||
for (int i = 1;i < N;i++){
|
||||
int mj = -1;
|
||||
db md = oo;
|
||||
for (int j = 0;j < N;j++)
|
||||
if (!U[j] && dis[j] < md)
|
||||
md = dis[mj = j];
|
||||
if (mj == N-1) break;
|
||||
U[mj] = true;
|
||||
for (int j = 0;j < N;j++)
|
||||
if (!U[j]){
|
||||
db nd = calTime(mj,j,md);
|
||||
dis[j] = min(nd,dis[j]);
|
||||
}
|
||||
}
|
||||
if (dis[N-1] > oo / 2) while(1);
|
||||
printf("%.f\n",ceil(dis[N-1]));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
struct aa
|
||||
{
|
||||
int x,y;
|
||||
int t;
|
||||
}a1[105],a2[105];
|
||||
bool camp(aa a,aa b)
|
||||
{
|
||||
return a.y<b.y||a.y==b.y&&a.x<b.x;
|
||||
}
|
||||
bool fx(aa A,aa B,aa C)
|
||||
{
|
||||
return (B.x-A.x)*(C.y-A.y)>(B.y-A.y)*(C.x-A.x);
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
int i,t,mt,n,s,tt,p,q;
|
||||
bool mark[105][105];
|
||||
scanf("%d",&tt);
|
||||
while(tt--)
|
||||
{
|
||||
scanf("%d%d%d",&p,&q,&n);
|
||||
memset(mark,0,sizeof(mark));
|
||||
for(i=1;i<n;i++)
|
||||
{
|
||||
mark[i][i+1]=1;
|
||||
mark[i+1][i]=1;
|
||||
}
|
||||
mark[1][n]=mark[n][1]=1;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d%d",&a1[i].x,&a1[i].y);
|
||||
a1[i].t=i;
|
||||
}
|
||||
sort(a1+1,a1+n+1,camp);
|
||||
a2[1]=a1[1];
|
||||
for(t=1,i=2;i<=n;i++)
|
||||
{
|
||||
while(t!=1&&!fx(a2[t-1],a2[t],a1[i]))
|
||||
t--;
|
||||
a2[++t]=a1[i];
|
||||
}
|
||||
mt=t;
|
||||
a2[++t]=a1[n-1];
|
||||
for(i=n-2;i>=1;i--)
|
||||
{
|
||||
while(t!=mt&&!fx(a2[t-1],a2[t],a1[i]))
|
||||
t--;
|
||||
a2[++t]=a1[i];
|
||||
}
|
||||
for(s=0,t--,i=1;i<t;i++)
|
||||
if(!mark[a2[i].t][a2[i+1].t])
|
||||
s++;
|
||||
if(!mark[a2[1].t][a2[t].t])
|
||||
s++;
|
||||
int ans=-p*s+q*(t-s);
|
||||
if(ans>0)
|
||||
printf("%d\n",ans);
|
||||
else
|
||||
printf("0\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
int n, w;
|
||||
int data[1000];
|
||||
int interval [1000];
|
||||
void solve()
|
||||
{
|
||||
int k = 0;
|
||||
double sum = 0.01;
|
||||
sort(data + 1, data + n + 1);
|
||||
while(!(data[n] >= k*w && data[n] <= (k+1)*w-1))
|
||||
{
|
||||
k++;
|
||||
}
|
||||
memset(interval, 0, sizeof(interval));
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
int kk = 0;
|
||||
while(kk <= k)
|
||||
{
|
||||
if(data[i] >= kk*w && data[i] <= (kk+1)*w-1)
|
||||
{
|
||||
interval[kk] ++;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
kk++;
|
||||
}
|
||||
}
|
||||
}
|
||||
int max = 0;
|
||||
for(int i = 0; i <= k; i++)
|
||||
{
|
||||
if(max < interval[i])
|
||||
{
|
||||
max = interval[i];
|
||||
}
|
||||
}
|
||||
for(int i = 0; i <= k; i++)
|
||||
{
|
||||
sum += ((double)interval[i]) / ((double)max) * (k-i) / k;
|
||||
}
|
||||
printf("%.6lf\n", sum);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(1)
|
||||
{
|
||||
scanf("%d%d", &n, &w);
|
||||
if(n == 0 && w == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
scanf("%d", &data[i]);
|
||||
}
|
||||
}
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int num[2][100000];
|
||||
int main()
|
||||
{
|
||||
int n,m,k;
|
||||
while(scanf("%d%d%d",&n,&m,&k)!=EOF&&(n||m||k))
|
||||
{
|
||||
memset(num,0,sizeof(num));
|
||||
for(int i=1; i<=m; i++)
|
||||
num[1][i]=1;
|
||||
for(int i=2; i<=n; i++)
|
||||
{
|
||||
for(int j=1; j<=i*m; j++)
|
||||
for(int l=1; l<=m; l++)
|
||||
num[i%2][j+l]+=num[(i-1)%2][j];
|
||||
memset(num[(i-1)%2],0,sizeof(num[(i-1)%2]));
|
||||
}
|
||||
double res=0.0;
|
||||
int i,j;
|
||||
for(i=1; i<=k+1; i++)
|
||||
res+=num[n%2][i];
|
||||
for(j=2;i<=n*m; i++,j++)
|
||||
res+=num[n%2][i]*j;
|
||||
int count=1;
|
||||
for(int i=1;i<=n;i++)
|
||||
count*=m;
|
||||
res/=count;
|
||||
printf("%.8lf\n",res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
int st[20][50000];
|
||||
int a[20][5];
|
||||
int s[20];
|
||||
int ans,ans1,ans2;
|
||||
void work(int h,int m,int s,int x)
|
||||
{
|
||||
int i,j,k,l;
|
||||
if(!(m>=(h%5)*12&&m<(h%5+1)*12)) return;
|
||||
st[x][h/5*3600+m*60+s]=1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,i,j,k,l,m,q,w,e,r,t,num;
|
||||
while (scanf("%d",&n)!=EOF)
|
||||
{
|
||||
memset(st,0,sizeof(st));
|
||||
if (n==0) break;
|
||||
for (i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d%d%d",&a[i][1],&a[i][2],&a[i][3]);
|
||||
for (j=1;j<=60;j++)
|
||||
{
|
||||
work(a[i][1],a[i][2],a[i][3],i);
|
||||
work(a[i][1],a[i][3],a[i][2],i);
|
||||
work(a[i][2],a[i][1],a[i][3],i);
|
||||
work(a[i][2],a[i][3],a[i][1],i);
|
||||
work(a[i][3],a[i][2],a[i][1],i);
|
||||
work(a[i][3],a[i][1],a[i][2],i);
|
||||
a[i][1]=(a[i][1]+1)%60;
|
||||
a[i][2]=(a[i][2]+1)%60;
|
||||
a[i][3]=(a[i][3]+1)%60;
|
||||
}
|
||||
}
|
||||
num=0;
|
||||
j=0;
|
||||
i=0;
|
||||
memset(s,0,sizeof(s));
|
||||
while (1)
|
||||
{
|
||||
for (j=1;j<=n;j++)
|
||||
{
|
||||
if (st[j][i]==1)
|
||||
{
|
||||
if (s[j]==0) num++;
|
||||
s[j]++;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
if (num==n) break;
|
||||
}
|
||||
i--;j=0;
|
||||
int flag=0;
|
||||
while (1)
|
||||
{
|
||||
for (k=1;k<=n;k++)
|
||||
{
|
||||
if (st[k][j]==1)
|
||||
{
|
||||
if (s[k]==1)
|
||||
{
|
||||
flag=1;
|
||||
num--;
|
||||
}
|
||||
s[k]--;
|
||||
}
|
||||
}
|
||||
if (flag) break;
|
||||
j++;
|
||||
}
|
||||
for (k=1;k<=n;k++)
|
||||
{
|
||||
if (st[k][j]==1)
|
||||
{
|
||||
if (s[k]==0)
|
||||
{
|
||||
num++;
|
||||
}
|
||||
s[k]++;
|
||||
}
|
||||
}
|
||||
ans=i-j+1;
|
||||
ans1=j;
|
||||
ans2=i;
|
||||
while (1)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
for (k=1;k<=n;k++)
|
||||
{
|
||||
if (st[k][j]==1)
|
||||
{
|
||||
if (s[k]==1)
|
||||
{
|
||||
num--;
|
||||
}
|
||||
s[k]--;
|
||||
}
|
||||
}
|
||||
j++;
|
||||
if (num<n) break;
|
||||
}
|
||||
if (i-j+2<ans)
|
||||
{
|
||||
ans=i-j+2;
|
||||
ans1=j-1;
|
||||
ans2=i;
|
||||
}
|
||||
while (1)
|
||||
{
|
||||
i++;
|
||||
if (i>45000)break;
|
||||
for (k=1;k<=n;k++)
|
||||
{
|
||||
if (st[k][i]==1)
|
||||
{
|
||||
if (s[k]==0)
|
||||
{
|
||||
num++;
|
||||
}
|
||||
s[k]++;
|
||||
}
|
||||
}
|
||||
if (num==n)break;
|
||||
}
|
||||
if (i>45000)break;
|
||||
}
|
||||
int h1,m1,s1,h2,m2,s2;
|
||||
h1=ans1/3600;
|
||||
m1=ans1-h1*3600;
|
||||
m1=m1/60;
|
||||
s1=ans1-h1*3600-m1*60;
|
||||
h2=ans2/3600;
|
||||
m2=ans2-h2*3600;
|
||||
m2=m2/60;
|
||||
s2=ans2-h2*3600-m2*60;
|
||||
printf("%02d:%02d:%02d %02d:%02d:%02d\n",h1,m1,s1,h2,m2,s2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#include<iostream>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
struct point{
|
||||
double x,y,z;
|
||||
point(double xx=0,double yy=0,double zz=0){
|
||||
x=xx,y=yy,z=zz;
|
||||
}
|
||||
point operator ^(double h){
|
||||
return point(x*h,y*h,z*h);
|
||||
}
|
||||
double operator ^(point h){
|
||||
return x*h.x+y*h.y+z*h.z;
|
||||
}
|
||||
point operator +(point h){
|
||||
return point(x+h.x,y+h.y,z+h.z);
|
||||
}
|
||||
point operator -(point h){
|
||||
return point(x-h.x,y-h.y,z-h.z);
|
||||
}
|
||||
point operator *(point b){
|
||||
return point(y*b.z-b.y*z, z*b.x-b.z*x, x*b.y-b.x*y);
|
||||
}
|
||||
double len2()const{
|
||||
return x*x+y*y+z*z;
|
||||
}
|
||||
double len()const{
|
||||
return sqrt(len2());
|
||||
}
|
||||
point turnlen(double l)const {
|
||||
double r=l/len();
|
||||
return point(x*r,y*r,z*r);
|
||||
}
|
||||
void input()
|
||||
{
|
||||
scanf("%lf%lf%lf",&x,&y,&z);
|
||||
}
|
||||
}p1,p2,ans;
|
||||
struct sphere{
|
||||
point c;
|
||||
double r;
|
||||
void input(){
|
||||
c.input();
|
||||
scanf("%lf",&r);
|
||||
}
|
||||
}sph[110];
|
||||
int n;
|
||||
const double eps=1e-8;
|
||||
int sgn(double x)
|
||||
{
|
||||
if(fabs(x)<eps) return 0;
|
||||
return x>0?1:-1;
|
||||
}
|
||||
bool intersection(sphere s,point p1,point p2,point &c)
|
||||
{
|
||||
double d=((p1-s.c)*(p2-s.c)).len()/(p1-p2).len();
|
||||
if(sgn(d-s.r)>=0)
|
||||
return false;
|
||||
point pp=(sgn(d)==0? s.c:s.c+((p1-s.c)*(p2-s.c)*(p1-p2)).turnlen(d) ); if(sgn((pp-p1)^(p2-p1))<=0)
|
||||
return false;
|
||||
c=pp+(p1-p2).turnlen(sqrt(s.r*s.r-d*d));
|
||||
return true;
|
||||
}
|
||||
point reflection(point p1,point rep,point c)
|
||||
{
|
||||
double d=((rep-p1)*(c-p1)).len()/(rep-c).len();
|
||||
return p1+((rep-p1)*(c-p1)*(rep-c)).turnlen(d*2.0);
|
||||
}
|
||||
void compute()
|
||||
{
|
||||
while(true){
|
||||
point c;
|
||||
int k=-1;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
point tmp;
|
||||
if(intersection(sph[i],p1,p2,tmp)){
|
||||
if(k==-1 || sgn((tmp-p1).len()-(c-p1).len())<0){
|
||||
c=tmp;
|
||||
k=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(k==-1)
|
||||
break;
|
||||
p2=reflection(p1,sph[k].c,c);
|
||||
p1=c;
|
||||
}
|
||||
ans=p1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
p1=point();
|
||||
p2.input();
|
||||
for(int i=0;i<n;i++)
|
||||
sph[i].input();
|
||||
compute();
|
||||
printf("%.8lf %.8lf %.8lf\n",ans.x,ans.y,ans.z);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,201 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
#include<queue>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
bool vis[35][35][300][7];
|
||||
struct node
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
int z;
|
||||
int w;
|
||||
int step;
|
||||
};
|
||||
int x,y,ans;
|
||||
int dx[4]={1,0,-1,0};
|
||||
int dy[4]={0,1,0,-1};
|
||||
char map[35][35];
|
||||
char res[10];
|
||||
void init()
|
||||
{
|
||||
memset(map,0,sizeof(map));
|
||||
memset(vis,0,sizeof(vis));
|
||||
}
|
||||
int tomy(int sta)
|
||||
{
|
||||
int a, b, c;
|
||||
a=sta%6; b=sta/6%6; c=sta/36%6;
|
||||
int d, e, f;
|
||||
d=5-a, e=5-b, f=5-c;
|
||||
return a+d*6+e*36+b*216+c*1296+f*7776;
|
||||
}
|
||||
int top(int sta)
|
||||
{
|
||||
return sta%6;
|
||||
}
|
||||
int bt(int sta)
|
||||
{
|
||||
return sta/6%6;
|
||||
}
|
||||
int nor(int sta)
|
||||
{
|
||||
return sta/36%6;
|
||||
}
|
||||
int sou(int sta)
|
||||
{
|
||||
return sta/216%6;
|
||||
}
|
||||
int wes(int sta)
|
||||
{
|
||||
return sta/1296%6;
|
||||
}
|
||||
int eas(int sta)
|
||||
{
|
||||
return sta/7776%6;
|
||||
}
|
||||
int up(int sta)
|
||||
{
|
||||
int t1, n1, s1, b1, e1, w1;
|
||||
t1=sou(sta);
|
||||
n1=top(sta);
|
||||
s1=bt(sta);
|
||||
b1=nor(sta);
|
||||
e1=eas(sta);
|
||||
w1=wes(sta);
|
||||
return t1+s1*6+w1*36;
|
||||
}
|
||||
int down(int sta)
|
||||
{
|
||||
int t1, n1, s1, b1, e1, w1;
|
||||
t1=nor(sta);
|
||||
n1=bt(sta);
|
||||
s1=top(sta);
|
||||
b1=sou(sta);
|
||||
e1=eas(sta);
|
||||
w1=wes(sta);
|
||||
return t1+s1*6+w1*36;
|
||||
}
|
||||
int left(int sta)
|
||||
{
|
||||
int t1, n1, s1, b1, e1, w1;
|
||||
t1=eas(sta);
|
||||
w1=top(sta);
|
||||
b1=wes(sta);
|
||||
e1=bt(sta);
|
||||
n1=nor(sta);
|
||||
s1=sou(sta);
|
||||
return t1+s1*6+w1*36;
|
||||
}
|
||||
int right(int sta)
|
||||
{
|
||||
int t1, n1, s1, b1, e1, w1;
|
||||
t1=wes(sta);
|
||||
w1=bt(sta);
|
||||
b1=eas(sta);
|
||||
e1=top(sta);
|
||||
n1=nor(sta);
|
||||
s1=sou(sta);
|
||||
return t1+s1*6+w1*36;
|
||||
}
|
||||
char s[]="rmybgc";
|
||||
bool bfs()
|
||||
{
|
||||
node n1,n2;
|
||||
n1.x=x;
|
||||
n1.y=y;
|
||||
n1.z=0;
|
||||
n1.w=78;
|
||||
n1.step=0;
|
||||
vis[x][y][78][0]=1;
|
||||
queue<node> q;
|
||||
q.push(n1);
|
||||
while(!q.empty())
|
||||
{
|
||||
node n2=q.front();
|
||||
if(n2.z==6)
|
||||
{
|
||||
ans=n2.step;
|
||||
return true;
|
||||
}
|
||||
q.pop();
|
||||
int t=tomy(n2.w);
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
int tmpx=dx[i]+n2.x;
|
||||
int tmpy=dy[i]+n2.y;
|
||||
if(map[tmpx][tmpy]=='w')
|
||||
{
|
||||
int temp;
|
||||
if(i==0)
|
||||
temp=right(t);
|
||||
else if(i==1)
|
||||
temp=down(t);
|
||||
else if(i==2)
|
||||
temp=left(t);
|
||||
else
|
||||
temp=up(t);
|
||||
if(vis[tmpx][tmpy][temp][n2.z]==0)
|
||||
{
|
||||
vis[tmpx][tmpy][temp][n2.z]=1;
|
||||
n1.x=tmpx;
|
||||
n1.y=tmpy;
|
||||
n1.w=temp;
|
||||
n1.z=n2.z;
|
||||
n1.step=n2.step+1;
|
||||
q.push(n1);
|
||||
}
|
||||
}
|
||||
else if(map[tmpx][tmpy]==res[n2.z])
|
||||
{
|
||||
int temp;
|
||||
if(i==0)
|
||||
temp=right(t);
|
||||
else if(i==1)
|
||||
temp=down(t);
|
||||
else if(i==2)
|
||||
temp=left(t);
|
||||
else
|
||||
temp=up(t);
|
||||
int top=temp%6;
|
||||
if(vis[tmpx][tmpy][temp][n2.z+1]==0&&s[top]==res[n2.z])
|
||||
{
|
||||
n1.x=tmpx;
|
||||
n1.y=tmpy;
|
||||
n1.w=temp;
|
||||
n1.z=n2.z+1;
|
||||
n1.step=n2.step+1;
|
||||
vis[tmpx][tmpy][temp][n2.z+1]=1;
|
||||
q.push(n1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,d;
|
||||
while(scanf("%d%d",&n,&d)!=EOF&&n+d)
|
||||
{
|
||||
init();
|
||||
for(int i=1;i<=d;i++)
|
||||
for(int j=1;j<=n;j++)
|
||||
{
|
||||
scanf(" %c",&map[j][i]);
|
||||
if(map[j][i]=='#')
|
||||
{
|
||||
x=j;
|
||||
y=i;
|
||||
map[j][i]='w';
|
||||
}
|
||||
}
|
||||
scanf(" %s",res);
|
||||
if(bfs())
|
||||
printf("%d\n",ans);
|
||||
else
|
||||
printf("unreachable\n");
|
||||
}
|
||||
return 0 ;
|
||||
}
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
typedef vector<int> VI;
|
||||
char buf[10005];
|
||||
int th;
|
||||
void out(VI v){
|
||||
for(int i = 0; i < (int)v.size(); i ++) printf("%d ", v[i]);
|
||||
printf("\n");
|
||||
}
|
||||
VI mul(VI v1, VI v2){
|
||||
int n = (v1.size())*(v2.size())+1;
|
||||
VI ret(n, 0);
|
||||
for(int i = 0; i < (int)v1.size(); i ++){
|
||||
for(int j = 0; j < (int)v2.size(); j ++){
|
||||
ret[i+j] += v1[i]*v2[j];
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
VI add(VI v1, VI v2){
|
||||
int n = max(v1.size(), v2.size());
|
||||
VI ret(n, 0);
|
||||
for(int i = 0; i < (int)v1.size(); i ++) ret[i] += v1[i];
|
||||
for(int i = 0; i < (int)v2.size(); i ++) ret[i] += v2[i];
|
||||
return ret;
|
||||
}
|
||||
VI getE();
|
||||
VI getP(){
|
||||
if(buf[th] == 'x'){
|
||||
VI ret(2, 0);
|
||||
ret[1] = 1;
|
||||
th ++;
|
||||
return ret;
|
||||
}
|
||||
if(buf[th] == '('){
|
||||
th ++;
|
||||
VI ret = getE();
|
||||
th ++;
|
||||
return ret;
|
||||
}
|
||||
int v = 0;
|
||||
while(buf[th] >= '0' && buf[th] <= '9'){
|
||||
v = v*10 + buf[th] - '0';
|
||||
th ++;
|
||||
}
|
||||
return VI(1, v);
|
||||
}
|
||||
VI getF(){
|
||||
VI ret = getP();
|
||||
if(buf[th] == '^'){
|
||||
th ++;
|
||||
VI tmp = getP(), t2 = ret;
|
||||
for(int i = 1; i < (int)tmp[0]; i ++){
|
||||
ret = mul(ret, t2);
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
VI getT(){
|
||||
VI ret;
|
||||
ret.push_back(1);
|
||||
while(buf[th] && buf[th] != '+' && buf[th] != '-' && buf[th] != ')'){
|
||||
VI tmp = getF();
|
||||
ret = mul(ret, tmp);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
VI getE(){
|
||||
VI ret;
|
||||
int sign = 0;
|
||||
while(buf[th]){
|
||||
if(sign != 0 && buf[th] != '+' && buf[th] != '-') break;
|
||||
sign = 1;
|
||||
if(buf[th] == '-') sign = -1;
|
||||
if(buf[th] == '+' || buf[th] == '-') th ++;
|
||||
VI tmp = getT();
|
||||
if(sign == -1) for(int i = 0; i < (int)tmp.size(); i ++) tmp[i] = -tmp[i];
|
||||
ret = add(ret, tmp);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int gcd(int a, int b){
|
||||
return a == 0 ? b : gcd(b%a, a);
|
||||
}
|
||||
void normal(VI& v){
|
||||
while(v.size() && v.back() == 0) v.pop_back();
|
||||
int by = v[0];
|
||||
for(int i = 1; i < (int)v.size(); i ++) by = gcd(by, v[i]);
|
||||
for(int i = 0; i < (int)v.size(); i ++) v[i] /= by;
|
||||
if(v.size() && v.back() < 0) for(int i = 0; i < (int)v.size(); i ++) v[i] = -v[i];
|
||||
}
|
||||
void output(VI v){
|
||||
bool first = true;
|
||||
for(int i = (int)v.size()-1; i >= 0; i --){
|
||||
if(v[i] == 0) continue;
|
||||
if((v[i] == 1 || v[i] == -1) && i != 0){
|
||||
if(v[i] == 1) if(!first) printf("+");
|
||||
if(v[i] == -1) printf("-");
|
||||
}else{
|
||||
if(first){
|
||||
if(v[i] < 0){
|
||||
printf("-");
|
||||
v[i] = -v[i];
|
||||
}
|
||||
printf("%d", v[i]);
|
||||
first = false;
|
||||
}else{
|
||||
printf("%+d", v[i]);
|
||||
}
|
||||
}
|
||||
if(i == 0){
|
||||
}else if(i == 1){
|
||||
printf("x");
|
||||
}else printf("x^%d", i);
|
||||
first = false;
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
int main() {
|
||||
while(scanf("%s", buf)){
|
||||
if(strlen(buf) == 1 && buf[0] == '.') break;
|
||||
th = 0;
|
||||
VI v1 = getE();
|
||||
scanf("%s", buf);
|
||||
th = 0;
|
||||
VI v2 = getE();
|
||||
normal(v1);
|
||||
normal(v2);
|
||||
while(1){
|
||||
if(v1.size() < v2.size()) swap(v1, v2);
|
||||
if(v2.size() == 0) break;
|
||||
int l1 = v1.back(), l2 = v2.back();
|
||||
int by = gcd(l1, l2);
|
||||
for(int i = v1.size()-1; i >= 0; i --){
|
||||
int tmp = v2.size()-1-(v1.size()-1-i), vt;
|
||||
if(tmp < 0) vt = 0;
|
||||
else vt = v2[tmp];
|
||||
v1[i] = v1[i]*(l2/by) - vt*(l1/by);
|
||||
}
|
||||
normal(v1);
|
||||
}
|
||||
output(v1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
const double eps = 1e-8;
|
||||
const double pi = acos(-1.0);
|
||||
int sgn(double d) {
|
||||
if (d > eps)
|
||||
return 1;
|
||||
if (d < -eps)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
struct point {
|
||||
double x, y;
|
||||
point(double _x = 0, double _y = 0): x(_x), y(_y) {
|
||||
}
|
||||
void input() {
|
||||
scanf("%lf%lf", &x, &y);
|
||||
}
|
||||
double len() const {
|
||||
return sqrt(x * x + y * y);
|
||||
}
|
||||
point trunc(double l) const {
|
||||
double r = l / len();
|
||||
return point(x * r, y * r);
|
||||
}
|
||||
point rotate_left() const {
|
||||
return point(-y, x);
|
||||
}
|
||||
point rotate_right() const {
|
||||
return point(y, -x);
|
||||
}
|
||||
};
|
||||
bool operator==(const point& p1, const point& p2) {
|
||||
return sgn(p1.x - p2.x) == 0 && sgn(p1.y - p2.y) == 0;
|
||||
}
|
||||
bool operator<(const point& p1, const point& p2) {
|
||||
return sgn(p1.x - p2.x) == 0 ? sgn(p1.y - p2.y) < 0 : p1.x < p2.x;
|
||||
}
|
||||
point operator+(const point& p1, const point& p2) {
|
||||
return point(p1.x + p2.x, p1.y + p2.y);
|
||||
}
|
||||
point operator-(const point& p1, const point& p2) {
|
||||
return point(p1.x - p2.x, p1.y - p2.y);
|
||||
}
|
||||
double operator^(const point& p1, const point& p2) {
|
||||
return p1.x * p2.x + p1.y * p2.y;
|
||||
}
|
||||
double operator*(const point& p1, const point& p2) {
|
||||
return p1.x * p2.y - p1.y * p2.x;
|
||||
}
|
||||
bool get_intersection(const point& p1, const point& p2, const point& p3, const point& p4, point& c) {
|
||||
double d1 = (p2 - p1) * (p3 - p1), d2 = (p2 - p1) * (p4 - p1);
|
||||
if (sgn(d1 - d2) == 0)
|
||||
return false;
|
||||
c = point((p3.x * d2 - p4.x * d1) / (d2 - d1), (p3.y * d2 - p4.y * d1) / (d2 - d1));
|
||||
return true;
|
||||
}
|
||||
int n;
|
||||
point p[16];
|
||||
pair<int, double> dp[1 << 11][11][11], ans;
|
||||
bool solve();
|
||||
void compute();
|
||||
int main() {
|
||||
while (solve());
|
||||
return 0;
|
||||
}
|
||||
bool solve() {
|
||||
scanf("%d", &n);
|
||||
if (n == 0)
|
||||
return false;
|
||||
for (int i = 0; i < n; ++i)
|
||||
p[i].input();
|
||||
sort(p, p + n);
|
||||
n = unique(p, p + n) - p;
|
||||
if (n < 2) {
|
||||
puts("0 0.0000000");
|
||||
return true;
|
||||
}
|
||||
compute();
|
||||
printf("%d %.8lf\n", ans.first, ans.second);
|
||||
return true;
|
||||
}
|
||||
void compute() {
|
||||
for (int i = 0; i < (1 << n); ++i)
|
||||
for (int j = 0; j < n; ++j)
|
||||
for (int k = 0; k < n; ++k)
|
||||
dp[i][j][k].first = 256;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
for (int j = 0; j < n; ++j) {
|
||||
if (i == j)
|
||||
continue;
|
||||
dp[(1 << i) | (1 << j)][i][j] = make_pair(0, (p[j] - p[i]).len());
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < (1 << n); ++i) {
|
||||
for (int x = 0; x < n; ++x) {
|
||||
if (((i >> x) & 1) == 0)
|
||||
continue;
|
||||
for (int y = 0; y < n; ++y) {
|
||||
if (y == x || ((i >> y) & 1) == 0)
|
||||
continue;
|
||||
if (dp[i][x][y].first == 256)
|
||||
continue;
|
||||
pair<int, double>& cur = dp[i][x][y];
|
||||
for (int j = 0; j < n; ++j) {
|
||||
if (((i >> j) & 1) == 1)
|
||||
continue;
|
||||
pair<int, double>& res = dp[i | (1 << j)][y][j];
|
||||
if (sgn((p[j] - p[x]) * (p[y] - p[x])) == 0) {
|
||||
if (sgn((p[j] - p[y]) ^ (p[x] - p[y])) < 0) {
|
||||
res = min(res, make_pair(cur.first, cur.second + (p[j] - p[y]).len()));
|
||||
} else {
|
||||
res = min(res, make_pair(cur.first + 1, cur.second + (p[j] - p[y]).len()));
|
||||
}
|
||||
} else {
|
||||
res = min(res, make_pair(cur.first + 1, cur.second + (p[j] - p[y]).len()));
|
||||
}
|
||||
}
|
||||
for (int j = 0; j < n; ++j) {
|
||||
if (((i >> j) & 1) == 1)
|
||||
continue;
|
||||
for (int k = 0; k < n; ++k) {
|
||||
if (k == j || ((i >> k) & 1) == 1)
|
||||
continue;
|
||||
pair<int, double>& res = dp[i | (1 << j) | (1 << k)][j][k];
|
||||
point c;
|
||||
if (get_intersection(p[x], p[y], p[j], p[k], c)) {
|
||||
if (sgn((p[x] - p[y]) ^ (c - p[y])) < 0 && sgn((p[k] - p[j]) ^ (c - p[j])) < 0) {
|
||||
res = min(res, make_pair(cur.first + 1, cur.second + (c - p[y]).len() + (c - p[k]).len()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ans.first = 256;
|
||||
for (int i = 0; i < n; ++i)
|
||||
for (int j = 0; j < n; ++j)
|
||||
ans = min(ans, dp[(1 << n) - 1][i][j]);
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
char s[20];
|
||||
int map[15],r,step;
|
||||
int check(int a[])
|
||||
{
|
||||
int i;
|
||||
for(i = 1; i<=9; i++)
|
||||
if(a[i] != i)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
void swap(int s[],int a,int b,int c,int d)
|
||||
{
|
||||
int t=s[a];
|
||||
s[a]=s[b],s[b]=s[c],s[c]=s[d];
|
||||
s[d]=t;
|
||||
}
|
||||
void work(int a[],int id)
|
||||
{
|
||||
if(id==1) swap(a,1,2,5,4);
|
||||
if(id==2) swap(a,2,3,6,5);
|
||||
if(id==3) swap(a,4,5,8,7);
|
||||
if(id==4) swap(a,5,6,9,8);
|
||||
if(id==5) swap(a,8,9,6,5);
|
||||
if(id==6) swap(a,7,8,5,4);
|
||||
if(id==7) swap(a,5,6,3,2);
|
||||
if(id==8) swap(a,4,5,2,1);
|
||||
}
|
||||
int dfs(int a[],int deep)
|
||||
{
|
||||
if(check(a))
|
||||
return 1;
|
||||
if(deep>=step)
|
||||
return 0;
|
||||
for(int i = 1; i<=8; i++)
|
||||
{
|
||||
work(a,i);
|
||||
if(dfs(a,deep+1)) return 1;
|
||||
work(a,9-i);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,cas = 1;
|
||||
while(~scanf("%s",s))
|
||||
{
|
||||
if(!strcmp(s,"0000000000"))
|
||||
break;
|
||||
r = s[0]-'0';
|
||||
for(i = 1; i<=9; i++)
|
||||
map[i] = s[i]-'0';
|
||||
step = 0;
|
||||
while(step<=r)
|
||||
{
|
||||
if(dfs(map,0))break;
|
||||
step++;
|
||||
}
|
||||
if(step<=r)
|
||||
printf("%d. %d\n",cas++,step);
|
||||
else
|
||||
printf("%d. -1\n",cas++);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iomanip>
|
||||
#define INF 99999999
|
||||
using namespace std;
|
||||
const int MAX=30+10;
|
||||
int hash1[200],hash2[10];
|
||||
char a[MAX],b[MAX];
|
||||
void Map(){
|
||||
hash2[0]=63,hash1[63]=0;
|
||||
hash2[1]=10,hash1[10]=1;
|
||||
hash2[2]=93,hash1[93]=2;
|
||||
hash2[3]=79,hash1[79]=3;
|
||||
hash2[4]=106,hash1[106]=4;
|
||||
hash2[5]=103,hash1[103]=5;
|
||||
hash2[6]=119,hash1[119]=6;
|
||||
hash2[7]=11,hash1[11]=7;
|
||||
hash2[8]=127,hash1[127]=8;
|
||||
hash2[9]=107,hash1[107]=9;
|
||||
}
|
||||
int main(){
|
||||
Map();
|
||||
int lena,lenb,sum=0,i,j,p,temp=1;
|
||||
while(~scanf("%s",a),strcmp(a,"BYE")){
|
||||
i=j=sum=0,temp=1;
|
||||
while(a[i++] != '+');
|
||||
lena=i-1;
|
||||
while(a[i] != '=')b[j++]=a[i++];
|
||||
lenb=j;
|
||||
for(i=lena-3,j=lenb-3;i>=0 && j>=0;i-=3,j-=3){
|
||||
p=(a[i]-'0')*100+(a[i+1]-'0')*10+a[i+2]-'0';
|
||||
sum+=hash1[p]*temp;
|
||||
p=(b[j]-'0')*100+(b[j+1]-'0')*10+b[j+2]-'0';
|
||||
sum+=hash1[p]*temp;
|
||||
temp*=10;
|
||||
}
|
||||
while(i>=0){
|
||||
p=(a[i]-'0')*100+(a[i+1]-'0')*10+a[i+2]-'0';
|
||||
sum+=hash1[p]*temp;
|
||||
temp*=10;
|
||||
i-=3;
|
||||
}
|
||||
while(j>=0){
|
||||
p=(b[j]-'0')*100+(b[j+1]-'0')*10+b[j+2]-'0';
|
||||
sum+=hash1[p]*temp;
|
||||
temp*=10;
|
||||
j-=3;
|
||||
}
|
||||
printf("%s",a);
|
||||
while(temp>sum)temp/=10;
|
||||
while(temp){
|
||||
printf("%03d",hash2[sum/temp]);
|
||||
sum=sum%temp;
|
||||
temp=temp/10;
|
||||
}
|
||||
cout<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
using namespace std;
|
||||
#define ll long long
|
||||
#define N 105000
|
||||
struct Obj
|
||||
{
|
||||
int sign,len;
|
||||
ll val;
|
||||
}obj[N];
|
||||
ll p[N],ha[N];
|
||||
int tot;
|
||||
void init(char *s)
|
||||
{
|
||||
int len=strlen(s);
|
||||
tot=0;
|
||||
for(int i=0,nxt=0;i<len;i=nxt)
|
||||
{
|
||||
if(s[i]=='#') obj[tot++].sign=1,nxt=i+1;
|
||||
else if(s[i]=='*') obj[tot++].sign=0,nxt=i+1;
|
||||
else
|
||||
{
|
||||
ll t=0;
|
||||
while(nxt<len&&s[nxt]!='#'&&s[nxt]!='*')
|
||||
{
|
||||
t=t*133+s[nxt];
|
||||
nxt++;
|
||||
}
|
||||
obj[tot].sign=-1;
|
||||
obj[tot].val=t;
|
||||
obj[tot++].len=nxt-i;
|
||||
}
|
||||
}
|
||||
}
|
||||
bool solve(char *s)
|
||||
{
|
||||
int len=strlen(s+1);
|
||||
ha[0]=0;
|
||||
for(int i=1;i<=len;++i) ha[i]=ha[i-1]*133+s[i];
|
||||
int cur=1;
|
||||
for(int i=0;i<tot&&cur<=len+1;++i)
|
||||
{
|
||||
if(obj[i].sign==1) cur++;
|
||||
else if(obj[i].sign<0)
|
||||
{
|
||||
if(i==0)
|
||||
{
|
||||
if(obj[i].len>len || ha[obj[i].len]!=obj[i].val) return false;
|
||||
cur+=obj[i].len;
|
||||
continue;
|
||||
}
|
||||
if(i==tot-1)
|
||||
{
|
||||
if(cur+obj[i].len>len+1) return false;
|
||||
if((len+1-(cur+obj[i].len))%2) return false;
|
||||
cur=len+1-obj[i].len;
|
||||
return ha[cur+obj[i].len-1]-ha[cur-1]*p[obj[i].len]==obj[i].val;
|
||||
}
|
||||
while(cur<=len+1&&cur+obj[i].len<=len+1)
|
||||
{
|
||||
if(ha[cur+obj[i].len-1]-ha[cur-1]*p[obj[i].len]==obj[i].val) break;
|
||||
cur+=2;
|
||||
}
|
||||
if(cur>len+1||cur+obj[i].len>len+1) return false;
|
||||
cur+=obj[i].len;
|
||||
}
|
||||
}
|
||||
--cur;
|
||||
return cur<=len&&(len-cur)%2==0;
|
||||
}
|
||||
char s[N];
|
||||
int main ()
|
||||
{
|
||||
p[0]=1;
|
||||
for(int i=1;i<N;++i) p[i]=p[i-1]*133;
|
||||
int ncase1=0,ncase2=0;
|
||||
while(scanf("%s",s) && s[0]!='Q')
|
||||
{
|
||||
init(s);
|
||||
ncase1++;ncase2=0;
|
||||
while(scanf("%s",s+1) && s[1]!='E' && s[1]!='Q')
|
||||
{
|
||||
printf("%d.%d. ",ncase1,++ncase2);
|
||||
if(solve(s)) printf("match\n");
|
||||
else printf("not\n");
|
||||
}
|
||||
if(s[1]=='Q') break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<map>
|
||||
#include<cmath>
|
||||
using namespace std;
|
||||
int f[410][820], val[410][810];
|
||||
int main()
|
||||
{
|
||||
int n, kase = 0;
|
||||
while (cin >> n)
|
||||
{
|
||||
if (n == 0) break;
|
||||
for (int i = 1; i <= n; i++)
|
||||
{
|
||||
f[i][0] = 0;
|
||||
for (int j = 1; j <= 2 * i - 1; j++)
|
||||
{
|
||||
scanf("%d", &val[i][j]);
|
||||
f[i][j] = f[i][j - 1] + val[i][j];
|
||||
}
|
||||
}
|
||||
int ans = -0x3f3f3f3f;
|
||||
for (int i = 1; i <= n; i++)
|
||||
for (int j = 1; j <= 2 * i - 1; j += 2)
|
||||
{
|
||||
int tmp = 0;
|
||||
for (int k = i; k <= n; k++)
|
||||
{
|
||||
if (j + 2 * (k - i) > 2 * k - 1) break;
|
||||
tmp += f[k][j + 2 * (k - i)] - f[k][j - 1];
|
||||
if (tmp > ans) ans = tmp;
|
||||
}
|
||||
}
|
||||
for (int i = n; i >= 1; i--)
|
||||
{
|
||||
for (int j = 2; j <= 2 * i - 1; j += 2)
|
||||
{
|
||||
int tmp = 0;
|
||||
for (int k = i; k >= 1; k--)
|
||||
{
|
||||
if (j - 2 * (i - k) < 1) break;
|
||||
if (j > 2 * k - 1) break;
|
||||
tmp += f[k][j] - f[k][j - 2 * (i - k) - 1];
|
||||
if (tmp > ans) ans = tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
kase++;
|
||||
cout << kase << ". " << ans << endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
#include<stdio.h>
|
||||
int main()
|
||||
{
|
||||
int a,b,ans;
|
||||
while(scanf("%d%d",&a,&b),a!=-1|| b!=-1)
|
||||
{
|
||||
ans=0;
|
||||
if(a==1 || b==1) ans=1;
|
||||
if(ans) printf("%d+%d=%d\n",a,b,a+b);
|
||||
else printf("%d+%d!=%d\n",a,b,a+b);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
const int M = 1010;
|
||||
int Map[M][M];
|
||||
int C[M];
|
||||
int R[M];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int k = 0;
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
memset(C,0,sizeof(C));
|
||||
memset(R,0,sizeof(R));
|
||||
int ans = 0;
|
||||
int res = 0;
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
for(int j = 1; j <= n; j++)
|
||||
{
|
||||
cin>>Map[i][j];
|
||||
ans += Map[i][j];
|
||||
C[i] += Map[i][j];
|
||||
}
|
||||
}
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
for(int j = 1; j <= n; j++)
|
||||
{
|
||||
R[i] += Map[j][i];
|
||||
}
|
||||
int cnt = C[i] - R[i];
|
||||
if(cnt > 0)
|
||||
{
|
||||
res += cnt;
|
||||
}
|
||||
}
|
||||
printf("%d. %d %d\n",++k,ans,res);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <stdlib.h>
|
||||
#include <memory.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n,d,w;
|
||||
while(cin>>n>>d)
|
||||
{
|
||||
if(n==0&&d==0) break;
|
||||
int ans=0;
|
||||
for(int i=2;i<=n;i++)
|
||||
ans=(ans+d)%i;
|
||||
cout<<n<<" "<<d<<" "<<ans+1<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
__int64 f[70];
|
||||
__int64 work(int n,__int64 r,__int64 st,__int64 ed)
|
||||
{
|
||||
__int64 sum=0,num;
|
||||
if(n==0)return 1;
|
||||
num=f[n]/2;
|
||||
if(r<=num){
|
||||
if(ed<=num){
|
||||
sum=work(n-1,r,st,ed);
|
||||
}else if(st>num){
|
||||
sum=work(n-1,r,st-num,ed-num);
|
||||
}else {
|
||||
sum=work(n-1,r,st,num);
|
||||
sum+=work(n-1,r,1,ed-num);
|
||||
}
|
||||
}else{
|
||||
if(ed<=num){
|
||||
sum=work(n-1,r-num,st,ed);
|
||||
}else if(st>num){
|
||||
sum=-work(n-1,r-num,st-num,ed-num);
|
||||
}else {
|
||||
sum=work(n-1,r-num,st,num);
|
||||
sum-=work(n-1,r-num,1,ed-num);
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j;
|
||||
int n;
|
||||
__int64 r,st,ed,ans;
|
||||
f[0]=1;
|
||||
for(i=1;i<=60;i++){
|
||||
f[i]=f[i-1]*2;
|
||||
}
|
||||
while(scanf("%d%I64d%I64d%I64d",&n,&r,&st,&ed)){
|
||||
if(n==-1&&r==-1&&st==-1&&ed==-1)break;
|
||||
ans=work(n,r+1,st+1,ed+1);
|
||||
printf("%I64d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,138 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
int num[3],tot,n,f;
|
||||
char s[3][100],ans[3][100];
|
||||
int check()
|
||||
{
|
||||
char str[100];
|
||||
int a=0,b=0,c;
|
||||
for(int i=0;i<num[0];i++)
|
||||
a=a*10+s[0][i]-'0';
|
||||
for(int i=0;i<num[1];i++)
|
||||
b=b*10+s[1][i]-'0';
|
||||
c=a*b;
|
||||
for(int i=num[2]-1;i>=0;i--)
|
||||
{
|
||||
str[i]='0'+c%10;
|
||||
c/=10;
|
||||
}
|
||||
if(c>0||str[0]=='0')
|
||||
return 0;
|
||||
for(int i=0;i<num[2];i++)
|
||||
if(s[2][i]!=str[i]&&s[2][i]!='*')
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
void dfs(int a,int b)
|
||||
{
|
||||
if(b>=num[a])
|
||||
{
|
||||
b=0;
|
||||
a++;
|
||||
}
|
||||
if(a==2)
|
||||
{
|
||||
if(check())
|
||||
tot++;
|
||||
return;
|
||||
}
|
||||
if(s[a][b]!='*')
|
||||
dfs(a,b+1);
|
||||
else
|
||||
{
|
||||
for(int i=0;i<10;i++)
|
||||
{
|
||||
if(b==0&&i==0)
|
||||
continue;
|
||||
s[a][b]='0'+i;
|
||||
dfs(a,b+1);
|
||||
if(tot>1)
|
||||
{
|
||||
s[a][b]='*';
|
||||
return;
|
||||
}
|
||||
}
|
||||
s[a][b]='*';
|
||||
}
|
||||
}
|
||||
void search(int a,int b,int c)
|
||||
{
|
||||
if(b>=num[a])
|
||||
{
|
||||
b=0;
|
||||
a++;
|
||||
}
|
||||
if(c==n)
|
||||
{
|
||||
tot=0;
|
||||
dfs(0,0);
|
||||
if(tot==1)
|
||||
{
|
||||
f=1;
|
||||
for(int i=0;i<3;i++)
|
||||
strcpy(ans[i],s[i]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if(a>=3)
|
||||
return;
|
||||
char ch=s[a][b],tc;
|
||||
for(int i=0;i<=10;i++)
|
||||
{
|
||||
if(i==1&&b==0)
|
||||
continue;
|
||||
if(!i)
|
||||
tc='*';
|
||||
else
|
||||
tc='0'+i-1;
|
||||
if(tc==s[a][b])
|
||||
search(a,b+1,c);
|
||||
else
|
||||
{
|
||||
s[a][b]=tc;
|
||||
search(a,b+1,c+1);
|
||||
}
|
||||
if(f)
|
||||
{
|
||||
s[a][b]=ch;
|
||||
return;
|
||||
}
|
||||
s[a][b]=ch;
|
||||
}
|
||||
}
|
||||
void work()
|
||||
{
|
||||
int m=0;
|
||||
for(int i=0;i<3;i++)
|
||||
m+=num[i];
|
||||
for(n=1;n<=m;n++)
|
||||
{
|
||||
f=0;;
|
||||
search(0,0,0);
|
||||
if(f)
|
||||
return;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cas=1;
|
||||
memset(s,0,sizeof(s));
|
||||
while(scanf("%s",s[0])&&s[0][0]!='0')
|
||||
{
|
||||
scanf("%s%s",s[1],s[2]);
|
||||
for(int i=0;i<3;i++)
|
||||
num[i]=strlen(s[i]);
|
||||
tot=0;
|
||||
dfs(0,0);
|
||||
printf("Case %d: ",cas++);
|
||||
if(tot==1)
|
||||
printf("%s %s %s\n",s[0],s[1],s[2]);
|
||||
else
|
||||
{
|
||||
work();
|
||||
printf("%s %s %s\n",ans[0],ans[1],ans[2]);
|
||||
}
|
||||
memset(s,0,sizeof(s));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
const int maxn = 17;
|
||||
const int MAXN = 100017;
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int cas = 0;
|
||||
int a[maxn], b[maxn], c[maxn];
|
||||
while(scanf("%d",&n)&&n)
|
||||
{
|
||||
for(int i = 1; i <= n; i++)
|
||||
scanf("%d%d%d", &a[i], &b[i], &c[i]);
|
||||
int ans;
|
||||
int cont = 0;
|
||||
for(ans = 1; ans < MAXN; ans++)
|
||||
{
|
||||
cont = 0;
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
if(c[i] <= a[i])
|
||||
cont++;
|
||||
}
|
||||
if(cont == n)
|
||||
break;
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
if(c[i] == a[i]+b[i] || (c[i] == a[i] && cont > n-cont))
|
||||
{
|
||||
c[i] = 0;
|
||||
}
|
||||
c[i]++;
|
||||
}
|
||||
}
|
||||
if(ans == MAXN)
|
||||
ans = -1;
|
||||
printf("Case %d: %d\n", ++cas, ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#include <stdio.h>
|
||||
#include <string>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
struct P
|
||||
{
|
||||
double x,y;
|
||||
}c[25],d[25];
|
||||
int ans[25];
|
||||
bool operator<(P a,P b)
|
||||
{
|
||||
if(a.x!=b.x)return a.x<b.x;
|
||||
return a.y<b.y;
|
||||
}
|
||||
int ctd[255];
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
int T=0;
|
||||
char a,b;
|
||||
double pi=acos(-1.0);
|
||||
double eps=1e-7;
|
||||
ctd['C']=0,ctd['D']=1,ctd['E']=2;
|
||||
ctd['F']=3,ctd['G']=4,ctd['A']=5;
|
||||
ctd['B']=6;
|
||||
char dtc[10];
|
||||
dtc[0]='C',dtc[1]='D',dtc[2]='E';
|
||||
dtc[3]='F',dtc[4]='G',dtc[5]='A';
|
||||
dtc[6]='B';
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
scanf(" %c %c",&a,&b);
|
||||
int i,j;
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%lf %lf",&c[i].x,&c[i].y);
|
||||
for(double i=-60.0;i<61.0;i+=0.005)
|
||||
{
|
||||
double ang;
|
||||
ang=i*pi/180.0;
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
d[j].x=c[j].x*cos(ang)+c[j].y*sin(ang);
|
||||
d[j].y=-c[j].x*sin(ang)+c[j].y*cos(ang);
|
||||
}
|
||||
sort(d,d+n);
|
||||
double sd=(d[n-1].y-d[0].y)/(ctd[b]-ctd[a]);
|
||||
double ssd=sd*2;
|
||||
if(ssd+eps<1.0 || ssd>5.0+eps)
|
||||
continue;
|
||||
ans[0]=ctd[a];
|
||||
for(j=1;j<n;j++)
|
||||
{
|
||||
if(d[j].x-d[j-1].x>5*ssd+eps || d[j].x-d[j-1].x+eps<ssd)
|
||||
break;
|
||||
if(d[j].y-d[j-1].y>(6-ans[j-1])*sd+eps)
|
||||
break;
|
||||
if(d[j-1].y-d[j].y>ans[j-1]*sd+eps)
|
||||
break;
|
||||
double dis=d[j].y-d[j-1].y;
|
||||
int tmp=(int)(dis/sd);
|
||||
if(dis>=0)
|
||||
{
|
||||
if(tmp*sd-dis+eps<0)
|
||||
tmp++;
|
||||
if(tmp*sd-dis>0+eps)
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(tmp*sd-dis>0+eps)
|
||||
tmp--;
|
||||
if(tmp*sd-dis+eps<0)
|
||||
break;
|
||||
}
|
||||
ans[j]=tmp+ans[j-1];
|
||||
}
|
||||
if(j==n)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
printf("Case %d: ",++T);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
printf("%c",dtc[ans[i]]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,186 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
#include<string>
|
||||
#include<sstream>
|
||||
#include<set>
|
||||
#include<vector>
|
||||
#include<stack>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<deque>
|
||||
#include<cstdlib>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<ctime>
|
||||
#include<cctype>
|
||||
#include<functional>
|
||||
using namespace std;
|
||||
#define me(s) memset(s,0,sizeof(s))
|
||||
#define pb push_back
|
||||
typedef long long ll;
|
||||
typedef unsigned int uint;
|
||||
typedef unsigned long long ull;
|
||||
typedef pair <int, int> P;
|
||||
const int N=256;
|
||||
int n,m,target;
|
||||
map<string,string>sol;
|
||||
queue<string>q;
|
||||
bool icy[N];
|
||||
char link_l[N],link_r[N],clear_l[N],clear_r[N];
|
||||
void init()
|
||||
{
|
||||
memset(icy,0,sizeof(icy));
|
||||
icy['O']=icy['[']=icy[']']=icy['=']=true;
|
||||
memset(link_l,' ',sizeof(link_l));
|
||||
link_l['O']=']';link_l['[']='=';
|
||||
memset(link_r,' ',sizeof(link_r));
|
||||
link_r['O']='[';link_r[']']='=';
|
||||
memset(clear_l,' ',sizeof(clear_l));
|
||||
clear_l[']']='O';clear_l['=']='[';clear_l['O']='O';clear_l['[']='[';
|
||||
memset(clear_r,' ',sizeof(clear_r));
|
||||
clear_r['[']='O';clear_r['=']=']';clear_r['O']='O';clear_r[']']=']';
|
||||
}
|
||||
string fall(string s)
|
||||
{
|
||||
int k,r,p;
|
||||
for(int i=n-1;i>=0;i--)
|
||||
for(int j=0;j<m;j++)
|
||||
{
|
||||
char ch=s[i*m+j];
|
||||
if(ch=='O'||ch=='@')
|
||||
{
|
||||
for(k=i+1;k<n;k++)if(s[k*m+j]!='.')break;
|
||||
s[i*m+j]='.';s[(k-1)*m+j]=ch;
|
||||
}
|
||||
else if(ch=='[')
|
||||
{
|
||||
for(r=j+1;r<m;r++)if(s[i*m+r]=='X'||s[i*m+r]==']')break;
|
||||
if(s[i*m+r]==']')
|
||||
{
|
||||
for(k=i+1;k<n;k++)
|
||||
{
|
||||
bool found=false;
|
||||
for(p=j;p<=r;p++)if(s[k*m+p]!='.'){found=true;break;}
|
||||
if(found)break;
|
||||
}
|
||||
for(p=j;p<=r;p++)s[i*m+p]='.';
|
||||
for(p=j+1;p<r;p++)s[(k-1)*m+p]='=';
|
||||
s[(k-1)*m+j]='[';s[(k-1)*m+r]=']';
|
||||
}
|
||||
j=r;
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
int h(string s)
|
||||
{
|
||||
int a,b,x=s.find('@');
|
||||
a=x%m-target%m; if(a<0)a=-a;
|
||||
if(x/m>target/m)b=x/m-target/m;
|
||||
else b=(x/m<target/m?1:0);
|
||||
return a>b?a:b;
|
||||
}
|
||||
bool expand(string s,char cmd)
|
||||
{
|
||||
string seq=sol[s]+cmd;
|
||||
int x=s.find('@');
|
||||
s[x]='.';
|
||||
if(cmd=='<'||cmd=='>')
|
||||
{
|
||||
s[x]='@';
|
||||
int p=(cmd=='<'?x+m-1:x+m+1);
|
||||
if(s[p]=='X')return false;
|
||||
else if(s[p]=='.')
|
||||
{
|
||||
s[p]='O';
|
||||
if(icy[s[p-1]])s[p-1]=link_r[s[p-1]];
|
||||
if(s[p-1]!='.')s[p]=link_l[s[p]];
|
||||
if(icy[s[p+1]])s[p+1]=link_l[s[p+1]];
|
||||
if(s[p+1]!='.')s[p]=link_r[s[p]];
|
||||
}
|
||||
else
|
||||
{
|
||||
s[p]='.';
|
||||
if(icy[s[p-1]])s[p-1]=clear_r[s[p-1]];
|
||||
if(icy[s[p+1]])s[p+1]=clear_l[s[p+1]];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int p=(cmd=='L'?x-1:x+1);
|
||||
if(s[p]=='.')s[p]='@';
|
||||
else
|
||||
{
|
||||
if(s[p]=='O')
|
||||
{
|
||||
int k;
|
||||
if(cmd=='L'&&s[p-1]=='.')
|
||||
{
|
||||
for(k=p-1;k>0;k--)if(s[k-1]!='.'||s[k+m]=='.')break;
|
||||
s[p]='.';s[k]='O';s[x]='@';
|
||||
}
|
||||
if(cmd=='R'&&s[p+1]=='.')
|
||||
{
|
||||
for(k=p+1;k<n*m;k++)if(s[k+1]!='.'||s[k+m]=='.')break;
|
||||
s[p]='.';s[k]='O';s[x]='@';
|
||||
}
|
||||
}
|
||||
if(s[p]!='.')
|
||||
{
|
||||
if(s[p-m]=='.'&&s[x-m]=='.')s[p-m]='@';
|
||||
else s[x]='@';
|
||||
}
|
||||
}
|
||||
}
|
||||
s=fall(s);
|
||||
if(h(s)+seq.length()>15)return false;
|
||||
if(s.find('@')==target)
|
||||
{
|
||||
printf("%s\n",seq.c_str());
|
||||
return true;
|
||||
}
|
||||
if(!sol.count(s))
|
||||
{
|
||||
sol[s]=seq;
|
||||
q.push(s);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int rnd=0;
|
||||
init();
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
if(!n)break;
|
||||
char mp[20][20];
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%s",mp[i]);
|
||||
string s="";
|
||||
for(int i=0;i<n;i++)
|
||||
for(int j=0;j<m;j++)
|
||||
{
|
||||
if(mp[i][j]=='#')
|
||||
{
|
||||
target=i*m+j;
|
||||
mp[i][j]='.';
|
||||
}
|
||||
s+=mp[i][j];
|
||||
}
|
||||
q.push(s);
|
||||
sol.clear();
|
||||
sol[s]="";
|
||||
printf("Case %d: ",++rnd);
|
||||
while(!q.empty())
|
||||
{
|
||||
string s=q.front();
|
||||
q.pop();
|
||||
if(expand(s,'<'))break;
|
||||
if(expand(s,'>'))break;
|
||||
if(expand(s,'L'))break;
|
||||
if(expand(s,'R'))break;
|
||||
}
|
||||
while(!q.empty())q.pop();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
char tg[10][10] = {
|
||||
" _ _ ",
|
||||
"| |",
|
||||
"|_ _|"
|
||||
};
|
||||
struct Grid{
|
||||
char s[5][12];
|
||||
bool input(){
|
||||
for(int i = 0; i < 5; i ++) if(!gets(s[i])) return false;
|
||||
return true;
|
||||
}
|
||||
void output(){
|
||||
for(int i = 0; i < 5; i ++) printf("%s\n", s[i]);
|
||||
printf("\n");
|
||||
}
|
||||
bool move(int x, int y){
|
||||
for(int i = 0; i <= 2; i ++){
|
||||
for(int j = 0; j <= 4; j ++){
|
||||
if(i == 0 && (j == 0 || j == 2 || j == 4)) continue;
|
||||
if(s[x+i][y+j] == tg[i][j]) s[x+i][y+j] = '.';
|
||||
if(s[x+i][y+j] == '.') continue;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool ok(){
|
||||
for(int i = 0; i < 5; i ++){
|
||||
for(int j = 0; j < 9; j ++){
|
||||
if(s[i][j] != '.' && s[i][j] != ' ') return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}g[8];
|
||||
bool dfs(int th){
|
||||
if(g[th].ok()) return true;
|
||||
if(th == 6) return false;
|
||||
for(int i = 0; i + 2 < 5; i ++){
|
||||
for(int j = 0; j + 4 < 9; j += 2){
|
||||
g[th+1] = g[th];
|
||||
if(g[th+1].move(i, j)){
|
||||
if(dfs(th+1)) return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main() {
|
||||
int cas = 0;
|
||||
while(g[0].input()){
|
||||
printf("Case %d: ", ++cas);
|
||||
printf("%s\n", dfs(0) ? "Yes" : "No");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
#define Max 2000
|
||||
int num[Max], pre[Max];
|
||||
void init()
|
||||
{
|
||||
memset(num, 0, sizeof(num));
|
||||
memset(pre, 0, sizeof(pre));
|
||||
pre[0] = 1;
|
||||
for(int i = 2; i <= 110; i++)
|
||||
{
|
||||
int c = 0;
|
||||
for(int j = 0; j < Max; j++)
|
||||
{
|
||||
int sum = pre[j]*i + c;
|
||||
pre[j] = sum%16;
|
||||
c = sum/16;
|
||||
}
|
||||
int k;
|
||||
for(k = Max-1; k >= 0; k--) if(pre[k])
|
||||
break;
|
||||
for(int j = 0; j <= k; j++) if(!pre[j])
|
||||
num[i]++;
|
||||
}
|
||||
}
|
||||
int main(void)
|
||||
{
|
||||
int n;
|
||||
init();
|
||||
while(cin>>n && n >= 0)
|
||||
{
|
||||
cout<<num[n]<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#include<stdio.h>
|
||||
int main()
|
||||
{
|
||||
int i,n,t,a[102];
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
t=a[0]+a[n-1];
|
||||
if(n%2!=0)
|
||||
printf("No\n");
|
||||
else
|
||||
{
|
||||
for(i=1;i<n/2;i++)
|
||||
if(a[i]+a[n-i-1]!=t)
|
||||
break;
|
||||
if(i==n/2)
|
||||
printf("Yes\n");
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
__int64 p[21][21];
|
||||
__int64 gcd(__int64 a, __int64 b)
|
||||
{
|
||||
return b ? gcd(b, a % b) : a;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
int i, j;
|
||||
for (i = 0; i <= 20; ++i)
|
||||
{
|
||||
p[i][0] = 1;
|
||||
p[i][i] = 0;
|
||||
}
|
||||
for (i = 2; i <= 20; ++i)
|
||||
for (j = 1; j < i; ++j)
|
||||
p[i][j] = p[i - 1][j] + p[i - 1][j - 1] * (i - 1);
|
||||
}
|
||||
void solve(int s, int n)
|
||||
{
|
||||
__int64 sum = 0, total = 0 , g;
|
||||
int i;
|
||||
for (i = 0; i < s; ++i)
|
||||
sum += p[n][i];
|
||||
total = sum;
|
||||
for ( ; i < n; ++i)
|
||||
total += p[n][i];
|
||||
g = gcd(sum, total);
|
||||
sum /= g;
|
||||
total /= g;
|
||||
if (total == 1 && sum == 1)
|
||||
printf("1\n");
|
||||
else if (sum == 0)
|
||||
printf("0\n");
|
||||
else printf("%I64d/%I64d\n", sum, total);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int tcase, w, h, n, s;
|
||||
scanf("%d", &tcase);
|
||||
while (tcase--)
|
||||
{
|
||||
scanf("%d%d%d", &w, &h, &s);
|
||||
solve(s, w * h);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,180 @@
|
|||
#include <map>
|
||||
#include <set>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
#include <cmath>
|
||||
#include <ctime>
|
||||
#include <vector>
|
||||
#include <cstdio>
|
||||
#include <cctype>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define eps 1e-12
|
||||
#define MAXN 55
|
||||
#define INF 1e30
|
||||
#define mem0(a) memset(a,0, sizeof(a))
|
||||
#define mem1(a) memset(a,-1,sizeof(a))
|
||||
double MAX(double a, double b) {return a > b ? a : b;}
|
||||
double MIn(double a, double b) {return a < b ? a : b;}
|
||||
typedef long long LL;
|
||||
struct Point{
|
||||
double x,y;
|
||||
Point(double x=0, double y=0):x(x),y(y){}
|
||||
};
|
||||
struct Polygon
|
||||
{
|
||||
Point p[MAXN];
|
||||
int Size;
|
||||
};
|
||||
struct Circle
|
||||
{
|
||||
Point o;
|
||||
double r;
|
||||
Circle(){}
|
||||
Circle(Point _o, double _r):o(_o),r(_r){}
|
||||
};
|
||||
Point operator + (Point A, Point B) {return Point(A.x+B.x, A.y+B.y);}
|
||||
Point operator - (Point A, Point B) {return Point(A.x-B.x, A.y-B.y);}
|
||||
Point operator * (Point A, double p) {return Point(A.x*p, A.y*p);}
|
||||
Point operator / (Point A, double p) {return Point(A.x/p, A.y/p);}
|
||||
int dcmp(double x) {
|
||||
if(fabs(x) < eps) return 0;
|
||||
else return x < 0 ? -1 : 1;
|
||||
}
|
||||
bool operator == (const Point &A, const Point &B) {
|
||||
return dcmp(A.x-B.x) == 0 && dcmp(A.y-B.y) == 0;
|
||||
}
|
||||
double Dot(Point A, Point B) { return A.x*B.x + B.y*B.y;}
|
||||
double Length(Point A) { return sqrt(Dot(A,A));}
|
||||
double Angle(Point A, Point B) {return acos(Dot(A,B) / Length(A) / Length(B));}
|
||||
double cross(Point A, Point B) {return A.x*B.y - A.y*B.x;}
|
||||
bool crossed(Point a, Point b, Point c, Point d)
|
||||
{
|
||||
if(cross(a-c, d-c)*cross(b-c, d-c)<=0 && cross(c-a, b-a)*cross(d-a, b-a)<=0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool isPointOnSegent(Point p, Point s, Point e)
|
||||
{
|
||||
double d = (p.x-s.x) * (e.x-p.x);
|
||||
double a = (p.y-s.y) / (p.x-s.x);
|
||||
double b = (e.y-p.y) / (e.x-p.x);
|
||||
if(dcmp(d)==1 && dcmp(a-b)==0)return true;
|
||||
return false;
|
||||
}
|
||||
int isPointInPolygon(Point p, Polygon poly)
|
||||
{
|
||||
int w = 0;
|
||||
int n = poly.Size;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
if(isPointOnSegent(p, poly.p[i], poly.p[(i+1)%n])) return 1;
|
||||
int k = dcmp(cross(poly.p[(i+1)%n]-poly.p[i], p-poly.p[i]));
|
||||
int d1 = dcmp(poly.p[i].y - p.y);
|
||||
int d2 = dcmp(poly.p[(i+1)%n].y - p.y);
|
||||
if(k > 0 && d1 <= 0 && d2 > 0) w++;
|
||||
if(k < 0 && d2 <= 0 && d1 > 0) w--;
|
||||
}
|
||||
if(w != 0) return 1;
|
||||
return 0;
|
||||
}
|
||||
struct R
|
||||
{
|
||||
Point a, b;
|
||||
R(){}
|
||||
R(Point _a, Point _b)
|
||||
{
|
||||
a = _a;
|
||||
b = _b;
|
||||
}
|
||||
}r[1001];
|
||||
struct T
|
||||
{
|
||||
Point a, b, c;
|
||||
T(){}
|
||||
T(Point _a, Point _b, Point _c) {
|
||||
a = _a; b = _b; c = _c;
|
||||
}
|
||||
}t[1001];
|
||||
Circle c[1001];
|
||||
int S, N;
|
||||
int cntC = 0, cntT = 0, cntR = 0;
|
||||
int calc(double x, double y)
|
||||
{
|
||||
Point p = Point(x, y);
|
||||
int ans = 0;
|
||||
for(int i=0;i<cntC;i++)
|
||||
{
|
||||
if(Length(p-c[i].o) <= c[i].r) ans ++;
|
||||
}
|
||||
for(int i=0;i<cntT;i++)
|
||||
{
|
||||
if( cross(t[i].c-t[i].a, p-t[i].a)*cross(t[i].b-t[i].a, p-t[i].a)<=0
|
||||
&& cross(t[i].a-t[i].b, p-t[i].b)*cross(t[i].c-t[i].b, p-t[i].b)<=0 ) ans ++;
|
||||
}
|
||||
for(int i=0;i<cntR;i++)
|
||||
{
|
||||
if(x>=r[i].a.x&&x<=r[i].b.x && y>=r[i].a.y&&y<=r[i].b.y) ans ++;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
char ch;double x, y, rr;
|
||||
while(~scanf("%d%*c", &S))
|
||||
{
|
||||
cntT = cntC = cntR = 0;
|
||||
for(int i=0;i<S;i++)
|
||||
{
|
||||
scanf("%c", &ch);
|
||||
if(ch == 'C')
|
||||
{
|
||||
scanf("%lf %lf %lf%*c", &x, &y, &rr);
|
||||
c[cntC++] = Circle(Point(x, y), rr);
|
||||
continue;
|
||||
}
|
||||
else if(ch == 'T')
|
||||
{
|
||||
Point aa[3];
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
scanf("%lf%*c%lf%*c", &x, &y);
|
||||
aa[j] = Point(x, y);
|
||||
}
|
||||
t[cntT++] = T(aa[0],aa[1],aa[2]);
|
||||
}
|
||||
else
|
||||
{
|
||||
Point aa[2];
|
||||
for(int j=0;j<2;j++)
|
||||
{
|
||||
scanf("%lf%*c%lf%*c", &x, &y);
|
||||
aa[j] = Point(x, y);
|
||||
}
|
||||
r[cntR++] = R(aa[0], aa[1]);
|
||||
}
|
||||
}
|
||||
scanf("%d", &N);
|
||||
for(int i=0;i<N;i++)
|
||||
{
|
||||
int cntA = 0, cntB = 0;
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
scanf("%lf %lf", &x, &y);
|
||||
cntA += calc(x, y);
|
||||
}
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
scanf("%lf %lf", &x, &y);
|
||||
cntB += calc(x, y);
|
||||
}
|
||||
printf("%s\n", cntA > cntB ? "Bob" : (cntA == cntB ? "Tied" : "Hannah"));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <cctype>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <stack>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
typedef pair<int,int> PII;
|
||||
typedef vector<int> VI;
|
||||
#define PB push_back
|
||||
#define MP make_pair
|
||||
#define clr(a,b) (memset(a,b,sizeof(a)))
|
||||
#define rep(i,a) for(int i=0; i<(int)a.size(); i++)
|
||||
const int INF = 0x3f3f3f3f;
|
||||
const double eps = 1E-8;
|
||||
int T;
|
||||
int n,l,r;
|
||||
char s[200010];
|
||||
int num[200010];
|
||||
LL tot = 1ll*n*(n+1)/2;
|
||||
double fun1(int lim)
|
||||
{
|
||||
double ret = 0;
|
||||
int ed = 1,sum = num[1];
|
||||
for(int st=1; st<=n; st++)
|
||||
{
|
||||
while(sum <= lim && ed < n)
|
||||
{
|
||||
ed ++;
|
||||
sum += num[ed];
|
||||
}
|
||||
if(sum > lim) ret += 1.0*(n - ed + 1)/(1ll*n*(n-st+1)) ;
|
||||
sum -= num[st];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
double fun2(int lim)
|
||||
{
|
||||
double ret = 0;
|
||||
int ed = 1,sum = num[1];
|
||||
for(int st=1; st<=n; st++)
|
||||
{
|
||||
while(sum < lim && ed < n)
|
||||
{
|
||||
ed ++;
|
||||
sum += num[ed];
|
||||
}
|
||||
if(sum >= lim)
|
||||
{
|
||||
if(ed-1 >= st) ret += 1.0*(ed - st)/(1ll*n*(n-st+1));
|
||||
}
|
||||
else
|
||||
{
|
||||
ret += 1.0*(ed - st + 1)/(1ll*n*(n-st+1));
|
||||
}
|
||||
sum -= num[st];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
scanf("%s",s+1);
|
||||
scanf("%d%d",&l,&r);
|
||||
num[0] = 0;
|
||||
for(int i=1; i<=n; i++) num[i] = s[i] - 'A';
|
||||
double a,b,c;
|
||||
c = fun1(r);
|
||||
a = fun2(l);
|
||||
b = 1 - a - c;
|
||||
printf("%lf %lf %lf\n",b,a,c);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
char s1[1000],s2[1000];
|
||||
int T;
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%s%s",s1,s2);
|
||||
if(strcmp(s1,s2) == 0) puts("OK");
|
||||
else puts("ERROR");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
int H,W;
|
||||
char Map[105][105];
|
||||
int direct[][2] = {{-1,0}, {1,0}, {0,-1}, {0, 1}};
|
||||
void DFS(int i, int j) {
|
||||
if(i<1 || i>H || j<1 || j>W)
|
||||
return;
|
||||
Map[i][j] = '.';
|
||||
for(int k=0; k<4; ++k)
|
||||
if(Map[i+direct[k][0]][j+direct[k][1]] == '#')
|
||||
DFS(i+direct[k][0], j+direct[k][1]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
cin >> T;
|
||||
while(cin >> H >> W) {
|
||||
for(int i=1; i<=H; ++i)
|
||||
for(int j=1; j<=W; ++j)
|
||||
cin >> Map[i][j];
|
||||
int counts = 0;
|
||||
for(int i=1; i<=H; ++i)
|
||||
for(int j=1; j<=W; ++j)
|
||||
if(Map[i][j] == '#') {
|
||||
DFS(i, j);
|
||||
++counts;
|
||||
}
|
||||
cout << counts << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<map>
|
||||
#include<queue>
|
||||
#include<cstdlib>
|
||||
using namespace std;
|
||||
int cvr[6][12]={
|
||||
{4,12,13,5,3,2,11,19,20,21,14,6},
|
||||
{12,13,5,4,11,19,20,21,14,6,3,2},
|
||||
{7,6,14,15,1,3,5,13,21,23,16,8},
|
||||
{6,14,15,7,5,13,21,23,16,8,1,3},
|
||||
{1,0,2,3,8,9,10,11,4,5,6,7},
|
||||
{0,2,3,1,10,11,4,5,6,7,8,9}};
|
||||
int block[8][3]={
|
||||
{3,5,6},{1,7,8},{0,9,10},{2,4,11},
|
||||
{12,19,20},{13,14,21},{15,16,23},{17,18,22}};
|
||||
struct S{
|
||||
char s[30];
|
||||
friend bool operator< (const S& a,const S& b){
|
||||
return strcmp(a.s,b.s)<0;
|
||||
}
|
||||
void change(){
|
||||
map<char,char> col;
|
||||
map<char,bool> flag;
|
||||
col[s[17]]='B'; flag[s[17]]=true;
|
||||
col[s[18]]='W'; flag[s[18]]=true;
|
||||
col[s[22]]='Y'; flag[s[22]]=true;
|
||||
for(int i=0;i<7;i++){
|
||||
int cnt=0,sum=0,has=3;
|
||||
if(flag[s[block[i][0]]]){cnt++;sum+=col[s[block[i][0]]];has-=0;}
|
||||
if(flag[s[block[i][1]]]){cnt++;sum+=col[s[block[i][1]]];has-=1;}
|
||||
if(flag[s[block[i][2]]]){cnt++;sum+=col[s[block[i][2]]];has-=2;}
|
||||
if(cnt!=2) continue;
|
||||
if(sum=='B'+'W') col[s[block[i][has]]]='O';
|
||||
if(sum=='B'+'Y') col[s[block[i][has]]]='G';
|
||||
if(sum=='Y'+'W') col[s[block[i][has]]]='R';
|
||||
}
|
||||
for(int i=0;i<24;i++){
|
||||
s[i]=col[s[i]];
|
||||
}
|
||||
}
|
||||
}s;
|
||||
map<S,int> step;
|
||||
void in(char &c){
|
||||
c=getchar();
|
||||
while(c<=32) c=getchar();
|
||||
}
|
||||
void bfs0(){
|
||||
strcpy(s.s,"OOOORRGGBBWWRRGGBBWWYYYY");
|
||||
step.clear();
|
||||
step[s]=-1;
|
||||
queue<pair<S,int> > que;
|
||||
que.push(make_pair(s,0));
|
||||
while(!que.empty()){
|
||||
S u=que.front().first;
|
||||
int d=que.front().second;
|
||||
que.pop();
|
||||
for(int i=0;i<6;i++){
|
||||
S v=u;
|
||||
for(int j=0;j<12;j++){
|
||||
v.s[cvr[i][j]]=u.s[cvr[i^1][j]];
|
||||
}
|
||||
if(step[v]) continue;
|
||||
step[v]=d+1;
|
||||
if(d<6){
|
||||
que.push(make_pair(v,d+1));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
map<S,bool> vis;
|
||||
int bfs1(){
|
||||
s.change();
|
||||
if(step[s]){
|
||||
if(step[s]==-1) return 0;
|
||||
else return step[s];
|
||||
}
|
||||
vis.clear();
|
||||
vis[s]=true;
|
||||
queue<pair<S,int> > que;
|
||||
que.push(make_pair(s,0));
|
||||
while(!que.empty()){
|
||||
S u=que.front().first;
|
||||
int d=que.front().second;
|
||||
que.pop();
|
||||
for(int i=0;i<6;i++){
|
||||
S v=u;
|
||||
for(int j=0;j<12;j++){
|
||||
v.s[cvr[i][j]]=u.s[cvr[i^1][j]];
|
||||
}
|
||||
if(vis[v]) continue;
|
||||
vis[v]=true;
|
||||
if(step[v]){
|
||||
if(step[v]==-1) return d+1;
|
||||
else return step[v]+d+1;
|
||||
}
|
||||
que.push(make_pair(v,d+1));
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int main(){
|
||||
bfs0();
|
||||
int t;
|
||||
scanf("%d",&t);
|
||||
while(t--){
|
||||
for(int i=0;i<24;i++){
|
||||
in(s.s[i]);
|
||||
}
|
||||
int ans=bfs1();
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstdlib>
|
||||
#include<cstring>
|
||||
#include<string>
|
||||
#include<queue>
|
||||
#include<algorithm>
|
||||
#include<map>
|
||||
#include<iomanip>
|
||||
#define INF 99999999
|
||||
using namespace std;
|
||||
const int MAX=10;
|
||||
int main(){
|
||||
int t,b,w;
|
||||
cin>>t;
|
||||
while(t--){
|
||||
cin>>b>>w;
|
||||
if(w&1)printf("0.00 1.00\n");
|
||||
else printf("1.00 0.00\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <string.h>
|
||||
#include <cmath>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <stack>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
struct bank
|
||||
{
|
||||
int mon;
|
||||
float pro;
|
||||
}b[110];
|
||||
int n;
|
||||
int main ()
|
||||
{
|
||||
int T,i,j;
|
||||
cin>>T;
|
||||
int sum;
|
||||
double dp[100010];
|
||||
while(T--)
|
||||
{
|
||||
float p;
|
||||
cin>>p>>n;
|
||||
sum=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
cin>>b[i].mon>>b[i].pro;
|
||||
sum+=b[i].mon;
|
||||
}
|
||||
memset(dp,0,sizeof(dp));
|
||||
dp[0]=1;
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=sum;j>=b[i].mon;j--)
|
||||
{
|
||||
if(dp[j]<dp[j-b[i].mon]*(1-b[i].pro))
|
||||
dp[j]=dp[j-b[i].mon]*(1-b[i].pro);
|
||||
}
|
||||
for(i=sum;i>=0&&dp[i]<(1-p);i--);
|
||||
cout<<i<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
double a[4];
|
||||
while(cin>>a[0]>>a[1]>>a[2]>>a[3],(a[0]+a[1]+a[2]+a[3])!=0)
|
||||
{
|
||||
double min=0,max=0;
|
||||
int i;
|
||||
double l[3],r[3];
|
||||
l[0]=a[1]-0.5;
|
||||
l[1]=a[2]-0.5;
|
||||
l[2]=a[3]-0.5;
|
||||
if(l[0]<0)
|
||||
l[0]=0.0;
|
||||
if(l[1]<0)
|
||||
l[1]=0.0;
|
||||
if(l[2]<0)
|
||||
l[2]=0.0;
|
||||
for(i=0;i<3;i++)
|
||||
{
|
||||
r[i]=a[i+1]+0.499999;
|
||||
}
|
||||
min=l[0]*9+l[1]*4+l[2]*4;
|
||||
max=r[0]*9+r[1]*4+r[2]*4;
|
||||
if(a[0]<=max&&a[0]>=min)
|
||||
cout<<"yes"<<endl;
|
||||
else
|
||||
cout<<"no"<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
using namespace std;
|
||||
#define M 1005
|
||||
struct dance{
|
||||
char s[105];
|
||||
}p[M];
|
||||
int k;
|
||||
bool judge1 (int i)
|
||||
{
|
||||
if (i-1 >= 0 && !strcmp (p[i-1].s, "jiggle") ||
|
||||
i-2 >= 0 && !strcmp (p[i-2].s, "jiggle") ||
|
||||
i+1 < k && !strcmp (p[i+1].s, "twirl"))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
bool judge2 ()
|
||||
{
|
||||
if (k < 3) return false;
|
||||
if (strcmp (p[k-1].s, "clap") != 0 ||
|
||||
strcmp (p[k-2].s, "stomp") != 0 ||
|
||||
strcmp (p[k-3].s, "clap") != 0)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
void solve ()
|
||||
{
|
||||
int i, j, tw = 0, ho = 0, dip = 0, ans[10], has[10];
|
||||
memset (has, 0, sizeof(has));
|
||||
for (i = 0; i < k; i++)
|
||||
{
|
||||
if (!strcmp (p[i].s, "dip"))
|
||||
{
|
||||
if (!judge1 (i))
|
||||
{
|
||||
has[1] = 1;
|
||||
for (j = 0; j < 3; j++) p[i].s[j] -= 32;
|
||||
}
|
||||
dip = 1;
|
||||
}
|
||||
if (!strcmp (p[i].s, "twirl")) tw = 1;
|
||||
if (!strcmp (p[i].s, "hop")) ho = 1;
|
||||
}
|
||||
if (tw && !ho) has[3] = 1;
|
||||
if (!judge2 ()) has[2] = 1;
|
||||
if (!strcmp (p[0].s, "jiggle")) has[4] = 1;
|
||||
if (!dip) has[5] = 1;
|
||||
int id = 0;
|
||||
for (i = 1; i <= 5; i++)
|
||||
if (has[i])
|
||||
ans[id++] = i;
|
||||
if (id == 0) printf ("form ok:");
|
||||
else if (id == 1) printf ("form error %d:", ans[0]);
|
||||
else
|
||||
{
|
||||
printf ("form errors %d", ans[0]);
|
||||
for (i = 1; i < id-1; i++)
|
||||
printf (", %d", ans[i]);
|
||||
printf (" and %d:", ans[id-1]);
|
||||
}
|
||||
for (i = 0; i < k; i++)
|
||||
printf (" %s", p[i].s);
|
||||
printf ("\n");
|
||||
}
|
||||
int main ()
|
||||
{
|
||||
while (~scanf ("%s", p[0].s))
|
||||
{
|
||||
k = 1;
|
||||
while (1)
|
||||
{
|
||||
char ch = getchar ();
|
||||
if (ch == '\n') break;
|
||||
scanf ("%s", p[k++].s);
|
||||
}
|
||||
solve ();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
const int SIZE = 10010;
|
||||
const int INF = 0xfffffff;
|
||||
int u[5*SIZE], v[5*SIZE], w[5*SIZE], nex[5*SIZE], h[5*SIZE];
|
||||
int first[SIZE], d[SIZE];
|
||||
int n, m, cnt;
|
||||
int s, e;
|
||||
void read_graph(int u1, int v1, int w1, int h1)
|
||||
{
|
||||
u[cnt] = u1; v[cnt] = v1; w[cnt] = w1; h[cnt] = h1;
|
||||
nex[cnt] = first[u[cnt]];
|
||||
first[u[cnt]] = cnt++;
|
||||
}
|
||||
int spfa(int src, int mid)
|
||||
{
|
||||
queue<int> q;
|
||||
bool inq[SIZE] = {0};
|
||||
for(int i = 1; i <= n; i++) d[i] = (i == src)?0:INF;
|
||||
q.push(src);
|
||||
while(!q.empty())
|
||||
{
|
||||
int x = q.front(); q.pop();
|
||||
inq[x] = 0;
|
||||
for(int e = first[x]; e!=-1; e = nex[e]) if(d[v[e]] > d[x]+w[e] && mid <= h[e])
|
||||
{
|
||||
d[v[e]] = d[x] + w[e];
|
||||
if(!inq[v[e]])
|
||||
{
|
||||
inq[v[e]] = 1;
|
||||
q.push(v[e]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(d[e] == INF) return 0;
|
||||
return 1;
|
||||
}
|
||||
void init()
|
||||
{
|
||||
memset(first, -1, sizeof(first));
|
||||
cnt = 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int times = 0;
|
||||
while(~scanf("%d%d", &n, &m), n, m)
|
||||
{
|
||||
init();
|
||||
while(m--)
|
||||
{
|
||||
int u1, v1, w1, h1;
|
||||
scanf("%d%d%d%d", &u1, &v1, &h1, &w1);
|
||||
if(h1 == -1) h1 = INF;
|
||||
read_graph(u1, v1, w1, h1);
|
||||
read_graph(v1, u1, w1, h1);
|
||||
}
|
||||
int x = 0, y, ans = INF, mid, h;
|
||||
scanf("%d%d%d", &s, &e, &y);
|
||||
while(x <= y)
|
||||
{
|
||||
mid = (x+y)>>1;
|
||||
if(spfa(s, mid))
|
||||
{
|
||||
x = mid+1;
|
||||
ans = d[e];
|
||||
h = mid;
|
||||
}
|
||||
else y = mid-1;
|
||||
}
|
||||
if(times) printf("\n");
|
||||
printf("Case %d:\n", ++times);
|
||||
if(ans != INF)
|
||||
{
|
||||
printf("maximum height = %d\n", h);
|
||||
printf("length of shortest route = %d\n", ans);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("cannot reach destination\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
using namespace std;
|
||||
const int prime[21]= {2,3,5,7,11,13,17,19,23,29,31,37,39,41,43,47,51,53,57,59};
|
||||
int a[21];
|
||||
__int64 bases[21];
|
||||
int main()
|
||||
{
|
||||
bases[0]=1;
|
||||
for(int i=1; i<=20; i++)
|
||||
bases[i]=bases[i-1]*prime[i-1];
|
||||
int n,r;
|
||||
while(cin>>n&&n)
|
||||
{
|
||||
for(int i=0; i<=20; i++)
|
||||
{
|
||||
if(bases[i]<=n && bases[i+1]>n)
|
||||
{
|
||||
r=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
memset(a,0,sizeof(a));
|
||||
int m=n;
|
||||
for(int i=r; i>=0; i--)
|
||||
{
|
||||
a[i]=n/bases[i];
|
||||
n=n%bases[i];
|
||||
}
|
||||
cout<<m<<" = ";
|
||||
for(int i=0; i<=r; i++)
|
||||
{
|
||||
if(a[i])
|
||||
{
|
||||
cout<<a[i];
|
||||
for(int j=0; j<i; j++)
|
||||
cout<<"*"<<prime[j];
|
||||
if(i!=r)
|
||||
cout<<" + ";
|
||||
}
|
||||
}
|
||||
cout<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
#include<stdio.h>
|
||||
typedef long long LL;
|
||||
LL getgcd(LL a,LL b)
|
||||
{
|
||||
if(!b)return a;
|
||||
return getgcd(b,a%b);
|
||||
}
|
||||
void gcd(LL a,LL b,LL& d,LL& x,LL& y)
|
||||
{
|
||||
if(!b){d=a;x=1;y=0;}
|
||||
else
|
||||
{
|
||||
gcd(b,a%b,d,y,x);
|
||||
y-=x*(a/b);
|
||||
}
|
||||
}
|
||||
bool calcu(LL a,LL b,LL x,LL y)
|
||||
{
|
||||
if(x<0)
|
||||
{
|
||||
while(x<0)
|
||||
{
|
||||
x+=b;
|
||||
y-=a;
|
||||
}
|
||||
if(y>0)
|
||||
return true;
|
||||
}
|
||||
else if(y<0)
|
||||
{
|
||||
while(y<0)
|
||||
{
|
||||
x-=b;
|
||||
y+=a;
|
||||
}
|
||||
if(x>0)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
LL a,b,c,d;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%I64d%I64d%I64d%I64d",&a,&b,&c,&d);
|
||||
if(c%a==0&&d%b==0||c%b==0&&d%a==0)
|
||||
printf("YES\n");
|
||||
else
|
||||
{
|
||||
LL p=getgcd(a,b);
|
||||
if(c%p||d%p)
|
||||
printf("NO\n");
|
||||
else
|
||||
{
|
||||
a/=p;b/=p;
|
||||
c/=p;d/=p;
|
||||
LL x,y,gg=a*b,v;
|
||||
if(c%gg==0)
|
||||
{
|
||||
gcd(a,b,v,x,y);
|
||||
if(calcu(a,b,x*d,y*d))
|
||||
{
|
||||
printf("YES\n");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if(d%gg==0)
|
||||
{
|
||||
gcd(a,b,v,x,y);
|
||||
if(calcu(a,b,x*c,y*c))
|
||||
{
|
||||
printf("YES\n");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
printf("NO\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
const int N = 111111;
|
||||
struct Point {
|
||||
LL x[3];
|
||||
} p[N], ori[N];
|
||||
int split[20], cur, dim;
|
||||
bool cmp(Point a, Point b) {
|
||||
return a.x[cur] < b.x[cur];
|
||||
}
|
||||
#define lson l, m - 1, depth + 1
|
||||
#define rson m + 1, r, depth + 1
|
||||
void build(int l, int r, int depth) {
|
||||
if (l >= r) return ;
|
||||
int m = l + r >> 1;
|
||||
cur = depth % dim;
|
||||
nth_element(p + l, p + m, p + r + 1, cmp);
|
||||
build(lson);
|
||||
build(rson);
|
||||
}
|
||||
template <class T> T sqr(T x) { return x * x;}
|
||||
const LL inf = 0x7777777777777777ll;
|
||||
LL dist(Point x, Point y) {
|
||||
LL ret = 0;
|
||||
for (int i = 0; i < dim; i++) {
|
||||
ret += sqr(x.x[i] - y.x[i]);
|
||||
}
|
||||
return ret ? ret : inf;
|
||||
}
|
||||
LL find(Point x, int l, int r, int depth) {
|
||||
int cur = depth % dim;
|
||||
if (l >= r) {
|
||||
if (l == r) return dist(x, p[l]);
|
||||
return inf;
|
||||
}
|
||||
int m = l + r >> 1;
|
||||
LL ret = dist(x, p[m]), tmp;
|
||||
if (x.x[cur] < p[m].x[cur]) {
|
||||
tmp = find(x, lson);
|
||||
if (tmp > sqr(x.x[cur] - p[m].x[cur])) {
|
||||
tmp = min(tmp, find(x, rson));
|
||||
}
|
||||
} else {
|
||||
tmp = find(x, rson);
|
||||
if (tmp > sqr(x.x[cur] - p[m].x[cur])) {
|
||||
tmp = min(tmp, find(x, lson));
|
||||
}
|
||||
}
|
||||
return min(ret, tmp);
|
||||
}
|
||||
int main() {
|
||||
int n, T;
|
||||
scanf("%d", &T);
|
||||
while (T-- && scanf("%d", &n)) {
|
||||
dim = 2;
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < 2; j++) {
|
||||
scanf("%I64d", &ori[i].x[j]);
|
||||
}
|
||||
p[i] = ori[i];
|
||||
}
|
||||
build(0, n - 1, 0);
|
||||
for (int i = 0; i < n; i++) {
|
||||
printf("%I64d\n", find(ori[i], 0, n - 1, 0));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn=110;
|
||||
char s[maxn][maxn];
|
||||
int visit[maxn];
|
||||
int n;
|
||||
int len[maxn];
|
||||
int ans[maxn];
|
||||
int en[maxn],fa[maxn];
|
||||
int solve(int dep,int num)
|
||||
{
|
||||
if (en[dep]!=0) return en[dep]-1;
|
||||
visit[dep]=num;
|
||||
for(int i=0;i<len[dep];i++)
|
||||
{
|
||||
ans[dep]=i;
|
||||
int t=s[dep][i]-'a';
|
||||
if (visit[t])
|
||||
{
|
||||
int maxs=0;
|
||||
int counts=0;
|
||||
for(int j=0;j<n;j++)
|
||||
if (visit[j]>=visit[t])
|
||||
{
|
||||
if (ans[j]>0) return 1;
|
||||
if (len[j]>maxs) maxs=len[j];
|
||||
counts++;
|
||||
}
|
||||
if (counts>1) return 2;
|
||||
if (maxs>1) return 1;
|
||||
return 0;
|
||||
}
|
||||
int now=solve(t,num+1);
|
||||
if (now==0) continue;
|
||||
return now;
|
||||
}
|
||||
visit[dep]=0;
|
||||
return 0;
|
||||
}
|
||||
int find_fa(int u)
|
||||
{
|
||||
if (fa[u]!=u) fa[u]=find_fa(fa[u]);
|
||||
return fa[u];
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int cas;
|
||||
scanf("%d",&cas);
|
||||
while(cas--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%s",s[i]);
|
||||
len[i]=strlen(s[i]);
|
||||
}
|
||||
memset(en,0,sizeof(en));
|
||||
for(int i=0;i<n;i++) fa[i]=i;
|
||||
for(int i=0;i<n;i++)
|
||||
{
|
||||
int have=0;
|
||||
for(int j=0;j<n;j++)
|
||||
{
|
||||
if (en[j]!=0) continue;
|
||||
bool flag=1;
|
||||
for(int k=1;k<len[j];k++)
|
||||
if (find_fa(s[j][0]-'a')!=find_fa(s[j][k]-'a')) flag=0;
|
||||
if (flag)
|
||||
{
|
||||
int t1=find_fa(j);
|
||||
int t2=find_fa(s[j][0]-'a');
|
||||
if (t1!=t2)
|
||||
{
|
||||
if (en[t2]==0) continue;
|
||||
if (len[t2]==1) en[t1]=1;
|
||||
else en[t1]=2;
|
||||
fa[t1]=t2;
|
||||
have++;
|
||||
} else
|
||||
{
|
||||
if (len[t2]==1) en[t1]=1;
|
||||
else en[t1]=2;
|
||||
have++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (have==0) break;
|
||||
}
|
||||
memset(visit,0,sizeof(visit));
|
||||
memset(ans,-1,sizeof(ans));
|
||||
int ans=solve(0,1);
|
||||
if (ans==2) puts("NO");
|
||||
else puts("YES");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include<stdio.h>
|
||||
#include<set>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
struct P{
|
||||
int l;
|
||||
int i;
|
||||
P(){}
|
||||
}p[1000000],q[1000000];
|
||||
bool cmp(P a,P b){
|
||||
return a.l<b.l;
|
||||
}
|
||||
int in(){
|
||||
int r=0;
|
||||
char c=getchar();
|
||||
while(c>'9'||c<'0')c=getchar();
|
||||
do{
|
||||
r=r*10+c-'0';
|
||||
c=getchar();
|
||||
}while(c>='0'&&c<='9');
|
||||
return r;
|
||||
}
|
||||
int res[1000000];
|
||||
bool fl[1000000];
|
||||
int main(){
|
||||
int ca;
|
||||
scanf("%d",&ca);
|
||||
while(ca-->0){
|
||||
int n,d;
|
||||
scanf("%d%d",&n,&d);
|
||||
for(int i=0;i<n;i++){
|
||||
p[i].l=in();
|
||||
p[i].i=i;
|
||||
}
|
||||
for(int i=0;i<d;i++){
|
||||
q[i].l=in();
|
||||
q[i].i=i;
|
||||
}
|
||||
sort(p,p+n,cmp);
|
||||
sort(q,q+d,cmp);
|
||||
memset(fl,false,sizeof(fl));
|
||||
int cnt=0;
|
||||
for(int i=d-1,j=n-1;i>=0;i--){
|
||||
while(j>=0&&p[j].l>q[i].l){
|
||||
int fr=p[j].i;
|
||||
fl[fr]=true;
|
||||
if(fr>0&&fr<n-1&&fl[fr-1]&&fl[fr+1])cnt--;
|
||||
else if(fr>0&&fl[fr-1]);
|
||||
else if(fr<n-1&&fl[fr+1]);
|
||||
else cnt++;
|
||||
j--;
|
||||
}
|
||||
res[q[i].i]=cnt;
|
||||
}
|
||||
for(int i=0;i<d;i++){
|
||||
printf("%d ",res[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<string>
|
||||
#include<cstring>
|
||||
#include<vector>
|
||||
#include<cmath>
|
||||
#include<queue>
|
||||
#include<stack>
|
||||
#include<map>
|
||||
#include<set>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int maxn=600010;
|
||||
int sa[maxn],Rank[maxn];
|
||||
char s[maxn];
|
||||
int N;
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%d",&N);
|
||||
for(int i=1;i<=N;i++)
|
||||
{
|
||||
scanf("%d",&sa[i]);
|
||||
Rank[sa[i]]=i;
|
||||
}
|
||||
Rank[N+1]=-1;
|
||||
int k=0;
|
||||
s[sa[1]]=k+'a';
|
||||
for(int i=2;i<=N;i++)
|
||||
{
|
||||
int x=sa[i-1],y=sa[i];
|
||||
if(Rank[x+1]>Rank[y+1])k++;
|
||||
s[sa[i]]=k+'a';
|
||||
}
|
||||
if(k>=26)printf("-1\n");
|
||||
else
|
||||
{
|
||||
s[N+1]=0;
|
||||
printf("%s\n",s+1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#define MAXD 4
|
||||
int N, M, a2;
|
||||
struct Matrix
|
||||
{
|
||||
int a[MAXD][MAXD];
|
||||
Matrix()
|
||||
{
|
||||
memset(a, 0, sizeof(a));
|
||||
}
|
||||
};
|
||||
Matrix multiply(Matrix &x, Matrix &y)
|
||||
{
|
||||
int i, j, k;
|
||||
Matrix z;
|
||||
for(k = 0; k < 4; k ++)
|
||||
for(i = 0; i < 4; i ++)
|
||||
if(x.a[i][k])
|
||||
{
|
||||
for(j = 0; j < 4; j ++)
|
||||
if(y.a[k][j])
|
||||
z.a[i][j] = (z.a[i][j] + (long long)x.a[i][k] * y.a[k][j]) % M;
|
||||
}
|
||||
return z;
|
||||
}
|
||||
void powmod(Matrix &unit, Matrix &mat, int n)
|
||||
{
|
||||
while(n)
|
||||
{
|
||||
if(n & 1)
|
||||
unit = multiply(mat, unit);
|
||||
n >>= 1;
|
||||
mat = multiply(mat, mat);
|
||||
}
|
||||
}
|
||||
void solve()
|
||||
{
|
||||
Matrix mat, unit;
|
||||
unit.a[0][0] = unit.a[2][0] = 1, unit.a[1][0] = ((long long)a2 * a2) % M, unit.a[3][0] = a2;
|
||||
mat.a[0][0] = mat.a[0][1] = 1;
|
||||
mat.a[1][1] = (4ll * a2 * a2) % M, mat.a[1][2] = 1, mat.a[1][3] = ((-4ll * a2) % M + M) % M;
|
||||
mat.a[2][1] = 1;
|
||||
mat.a[3][1] = (2ll * a2) % M, mat.a[3][3] = M - 1;
|
||||
powmod(unit, mat, N - 1);
|
||||
printf("%d\n", unit.a[0][0]);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while(t --)
|
||||
{
|
||||
scanf("%d%d%d", &a2, &N, &M);
|
||||
solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
#include <stdio.h>
|
||||
#include <queue>
|
||||
#include <algorithm>
|
||||
#include <string.h>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int l,r,id,flag;
|
||||
bool operator < (const node &b) const
|
||||
{
|
||||
return r>b.r;
|
||||
}
|
||||
};
|
||||
priority_queue <node> q;
|
||||
bool cmp(const node &a,const node &b)
|
||||
{
|
||||
if (a.l!=b.l) return a.l<b.l;
|
||||
return a.id>b.id;
|
||||
}
|
||||
node a[100010];
|
||||
int main()
|
||||
{
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while (T--)
|
||||
{
|
||||
int n;
|
||||
scanf("%d",&n);
|
||||
for (int i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d%d",&a[i].l,&a[i].r);
|
||||
a[i].id=i+1;
|
||||
a[i].flag=0;
|
||||
}
|
||||
bool good=0;
|
||||
if (max(a[0].l,a[1].l)<min(a[0].r,a[1].r)) good=1;
|
||||
a[1].flag=1;
|
||||
a[0].flag=1;
|
||||
sort(a,a+n,cmp);
|
||||
while (!q.empty()) q.pop();
|
||||
int ans=0;
|
||||
int numa=0;
|
||||
int numb=0;
|
||||
int now=0;
|
||||
int bad=0;
|
||||
int maxs=0;
|
||||
for (int i=0;i<n;i++)
|
||||
{
|
||||
while(!q.empty()&&q.top().r<=a[i].l)
|
||||
{
|
||||
node s=q.top();
|
||||
q.pop();
|
||||
if (s.flag) numb++;
|
||||
else numa++;
|
||||
now--;
|
||||
}
|
||||
if (bad!=1)
|
||||
{
|
||||
numa+=numb;
|
||||
numb=0;
|
||||
if (numa)
|
||||
{
|
||||
numa--;
|
||||
}
|
||||
} else
|
||||
{
|
||||
if (numa&&numb) good=1;
|
||||
if (numa)
|
||||
{
|
||||
numa--;
|
||||
if (a[i].flag) good=1;
|
||||
} else
|
||||
if (numb)
|
||||
{
|
||||
a[i].flag=1;
|
||||
numb--;
|
||||
} else
|
||||
if (a[i].flag) good=1;
|
||||
}
|
||||
q.push(a[i]);
|
||||
now++;
|
||||
if (a[i].id<=2) bad++;
|
||||
if (now+numa+numb>ans) ans=now+numa+numb;
|
||||
if (bad==1)
|
||||
if (now+numa+numb>maxs) maxs=now+numa+numb;
|
||||
}
|
||||
maxs+=!good;
|
||||
if (maxs>ans) ans=maxs;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include<iostream>
|
||||
#include<string.h>
|
||||
#include<cstdio>
|
||||
using namespace std;
|
||||
#define LL long long
|
||||
#define M 3100300
|
||||
int tag[M],p[M];
|
||||
void Prime()
|
||||
{
|
||||
memset(tag,0,sizeof(tag));
|
||||
memset(p,0,sizeof(p));
|
||||
int cnt=0,i,j;
|
||||
for( i=2;i<M;i++)
|
||||
{
|
||||
if(!tag[i])
|
||||
p[cnt++]=i;
|
||||
for( j=0;j<cnt&&p[j]*i<M;j++)
|
||||
{
|
||||
tag[i*p[j]]=1;
|
||||
if(i%p[j]==0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
memset(p,0,sizeof(p));
|
||||
for( i=1;i<M/3;i++)
|
||||
{
|
||||
LL t=3*i+7;
|
||||
if(tag[t]==0)
|
||||
p[i]=p[i-1]+1;
|
||||
else
|
||||
p[i]=p[i-1];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,t;
|
||||
Prime();
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
printf("%d\n",p[n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <queue>
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
const int MAX = 510000;
|
||||
int pre[MAX], cnt[MAX];
|
||||
int isleaf[MAX];
|
||||
queue<int> q;
|
||||
long long n, mod;
|
||||
int prime[MAX], num_prime, cprime[MAX], isprime[MAX];
|
||||
void init()
|
||||
{
|
||||
scanf("%d%d", &n, &mod);
|
||||
pre[1] = -1;
|
||||
memset(isleaf, 0, sizeof(isleaf));
|
||||
for (int i = 2; i <= n; i++)
|
||||
{
|
||||
scanf("%d", &pre[i]);
|
||||
isleaf[pre[i]]++;
|
||||
}
|
||||
for (int i = 1; i <= n; i++)
|
||||
if (!isleaf[i])
|
||||
q.push(i);
|
||||
}
|
||||
void bfs()
|
||||
{
|
||||
for (int i = 1; i <= n; i++)
|
||||
cnt[i] = 1;
|
||||
while (!q.empty())
|
||||
{
|
||||
int u = q.front();
|
||||
q.pop();
|
||||
if (u == 1)
|
||||
continue;
|
||||
cnt[pre[u]] += cnt[u];
|
||||
isleaf[pre[u]]--;
|
||||
if (!isleaf[pre[u]])
|
||||
q.push(pre[u]);
|
||||
}
|
||||
}
|
||||
void prime_init()
|
||||
{
|
||||
memset(isprime, 1, sizeof(isprime));
|
||||
int cnt = 0;
|
||||
isprime[0] = isprime[1] = -1;
|
||||
for (int i = 2; i < MAX; i++)
|
||||
if (isprime[i] != -1)
|
||||
{
|
||||
isprime[i] = cnt++;
|
||||
for (int j = 2; j * i < MAX; j++)
|
||||
isprime[i * j] = -1;
|
||||
}
|
||||
num_prime = 0;
|
||||
for (int i = 2; i <= MAX; i++)
|
||||
if (isprime[i] != -1)
|
||||
prime[num_prime++] = i;
|
||||
}
|
||||
void fac(int a, int v)
|
||||
{
|
||||
for (int i = 0; a != 1; i++)
|
||||
{
|
||||
while (a % prime[i] == 0)
|
||||
cprime[i] += v, a /= prime[i];
|
||||
if (isprime[a] != -1)
|
||||
cprime[isprime[a]] += v, a = 1;
|
||||
}
|
||||
}
|
||||
long long pow(int a, int b)
|
||||
{
|
||||
long long x = a, r = 1;
|
||||
while (b)
|
||||
{
|
||||
if (b & 1)
|
||||
r = (r * x) % mod;
|
||||
x = (x * x) % mod;
|
||||
b >>= 1;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
long long solve()
|
||||
{
|
||||
memset(cprime, 0, sizeof(cprime));
|
||||
for (int i = 2; i < n; i++)
|
||||
fac(i, 1);
|
||||
for (int i = 2; i <= n; i++)
|
||||
fac(cnt[i], -1);
|
||||
long long res = 1;
|
||||
for (int i = 0; i <= n && res != 0; i++)
|
||||
if (cprime[i])
|
||||
res = (res * pow(prime[i], cprime[i])) % mod;
|
||||
return res;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
prime_init();
|
||||
int t;
|
||||
scanf("%d", &t);
|
||||
while (t--)
|
||||
{
|
||||
init();
|
||||
bfs();
|
||||
cout << solve() << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
const int N = 2000009;
|
||||
int visit[N];
|
||||
struct node{
|
||||
int a[5];
|
||||
} re[N];
|
||||
int ans[N];
|
||||
int map[4][4];
|
||||
void makemap(int k)
|
||||
{
|
||||
for(int i=0;i<3;i++)
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
map[i][j]=k%5;
|
||||
k/=5;
|
||||
}
|
||||
}
|
||||
struct quenod{
|
||||
int s,step;
|
||||
};
|
||||
queue<quenod> que;
|
||||
bool v[5];
|
||||
bool oor(int x,int y)
|
||||
{
|
||||
if(x<0||x>2) return false;
|
||||
if(y<0||y>2) return false;
|
||||
return true;
|
||||
}
|
||||
int dx[]={0,0,-1,1};
|
||||
int dy[]={-1,1,0,0};
|
||||
bool ok(int x,int y,int n)
|
||||
{
|
||||
memset(v,0,sizeof(v));
|
||||
int tx,ty;
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
tx = x+dx[i],ty=y+dy[i];
|
||||
if(!oor(tx,ty)) continue;
|
||||
v[map[tx][ty]]=true;
|
||||
}
|
||||
for(int i=1;i<n;i++)
|
||||
if(!v[i]) return false;
|
||||
return true;
|
||||
}
|
||||
int cnt = 1;
|
||||
int zip[]={1,5,25,125,625,3125,15625,78125,390625,1953125};
|
||||
void init()
|
||||
{
|
||||
while(!que.empty()) que.pop();
|
||||
quenod e,t;
|
||||
e.s=0;e.step=0;
|
||||
que.push(e);
|
||||
visit[0] = true;
|
||||
while(!que.empty())
|
||||
{
|
||||
e = que.front();que.pop();
|
||||
makemap(e.s);
|
||||
for(int i=0;i<3;i++)
|
||||
for(int j=0;j<3;j++)
|
||||
{
|
||||
for(int k=map[i][j]+1;k<5;k++)
|
||||
if(ok(i,j,k))
|
||||
{
|
||||
t.s = e.s+zip[i*3+j]*(k-map[i][j]);
|
||||
if(visit[t.s])continue;
|
||||
visit[t.s] = true;
|
||||
memset(re[cnt].a,0,sizeof(re[cnt].a));
|
||||
for(int ii=0;ii<3;ii++)
|
||||
for(int jj=0;jj<3;jj++)
|
||||
if(map[ii][jj]) re[cnt].a[map[ii][jj]]++;
|
||||
re[cnt].a[map[i][j]]--;
|
||||
re[cnt].a[k]++;
|
||||
t.step=e.step+1;
|
||||
ans[cnt]=t.step;
|
||||
cnt++;
|
||||
que.push(t);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
int a[5],w,sum,T=1;
|
||||
while(~scanf("%d",&a[1])&&a[1])
|
||||
{
|
||||
for(int i=2;i<5;i++)scanf("%d",&a[i]);
|
||||
scanf("%d",&w);
|
||||
bool ou = false;
|
||||
for(int i=0;i<cnt;i++)
|
||||
{
|
||||
sum=0;
|
||||
for(int j=1;j<5;j++)
|
||||
sum+=re[i].a[j]*a[j];
|
||||
if(sum>=w)
|
||||
{
|
||||
ou = true;
|
||||
printf("Case %d: %d\n",T++,ans[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!ou)
|
||||
{
|
||||
printf("Case %d: Impossible\n",T++);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#define OP(s) cout<<#s<<"="<<s<<" ";
|
||||
#define PP(s) cout<<#s<<"="<<s<<endl;
|
||||
#define SET(s,x) memset(s,x,sizeof(s));
|
||||
using namespace std;
|
||||
typedef long long LL;
|
||||
struct Node
|
||||
{
|
||||
int yes,count;
|
||||
string str;
|
||||
}a[10010];
|
||||
int tota = 0;
|
||||
int main()
|
||||
{
|
||||
int n,m,k;
|
||||
while (~scanf("%d",&n),n)
|
||||
{
|
||||
static int cas = 0;
|
||||
printf("Case %d: ",++cas);
|
||||
tota = 0;
|
||||
int m,k;
|
||||
cin>>m>>k;
|
||||
string s1,s2;
|
||||
map<string,int> mp;
|
||||
while (n--)
|
||||
{
|
||||
map<string,bool> vd;
|
||||
cin>>s1>>s2;
|
||||
int len = s1.length();
|
||||
for (int i = 0;i <= len-k;i++)
|
||||
{
|
||||
string tmp = "";
|
||||
for (int j =0;j < k;j++) tmp += s1[i+j];
|
||||
if (!vd[tmp])
|
||||
{
|
||||
vd[tmp] = 1;
|
||||
int id;
|
||||
if (mp[tmp] == 0)
|
||||
{
|
||||
mp[tmp] = ++tota;
|
||||
id = tota;
|
||||
a[id].count = 0;
|
||||
a[id].yes = 0;
|
||||
a[id].str = tmp;
|
||||
}
|
||||
else id = mp[tmp];
|
||||
a[id].count++;
|
||||
if (s2 == "Yes") a[id].yes++;
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans = -1,ansc = 1,ansy = 2;
|
||||
for (int i = 1;i <= tota;i++)
|
||||
{
|
||||
if (a[i].count < m) continue;
|
||||
int y1 = a[i].yes,c1 = a[i].count;
|
||||
if (y1 * ansc < ansy*c1
|
||||
|| y1*ansc == ansy*c1 && c1 > ansc
|
||||
|| y1*ansc == ansy*c1 && c1 == ansc && a[i].str < a[ans].str
|
||||
)
|
||||
{
|
||||
ans = i,ansy = y1,ansc = c1;
|
||||
}
|
||||
}
|
||||
if (ans == -1) cout<<"No solution\n";
|
||||
else cout<<a[ans].str<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
#include<stdio.h>
|
||||
#include<assert.h>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define maxm 210
|
||||
#define maxn 5
|
||||
double inf = 1e100;
|
||||
double eps = 1e-5;
|
||||
void pivot(int m,int n, double a[maxm][maxn], int B[maxm], int N[maxn], int r, int c){
|
||||
int i, j;
|
||||
swap(N[c], B[r]);
|
||||
a[r][c] = 1 / a[r][c];
|
||||
for(j = 0; j <= n; j++)
|
||||
if(j != c)
|
||||
a[r][j] *= a[r][c];
|
||||
for(i = 0; i <= m; i++)
|
||||
if(i != r){
|
||||
for(j = 0; j <= n; j++)
|
||||
if(j != c)
|
||||
a[i][j] -= a[i][c] * a[r][j];
|
||||
a[i][c] = -a[i][c] * a[r][c];
|
||||
}
|
||||
}
|
||||
int feasible(int m, int n, double a[maxm][maxn],int B[maxm], int N[maxn]){
|
||||
int r, c, i;
|
||||
double p, v;
|
||||
while(1){
|
||||
for(p = inf, i = 0; i < m; i++)
|
||||
if(a[i][n] < p)
|
||||
p = a[r=i][n];
|
||||
if(p > -eps)
|
||||
return 1;
|
||||
for(p = 0, i = 0; i < n; i++)
|
||||
if(a[r][i] < p)
|
||||
p = a[r][c=i];
|
||||
if(p > -eps)
|
||||
return 0;
|
||||
p = a[r][n] / a[r][c];
|
||||
for(i = r + 1; i < m; i++)
|
||||
if(a[i][c] > eps){
|
||||
v = a[i][n] / a[i][c];
|
||||
if(v < p)
|
||||
r = i, p = v;
|
||||
}
|
||||
pivot(m, n, a, B, N, r, c);
|
||||
}
|
||||
}
|
||||
int simplex(int m, int n, double a[maxm][maxn], double b[maxn], double &ret){
|
||||
int B[maxm], N[maxn], r, c, i;
|
||||
double p, v;
|
||||
for(i = 0; i <n; i++)
|
||||
N[i] = i;
|
||||
for(i = 0; i < m; i++)
|
||||
B[i] = n + i;
|
||||
if(!feasible(m, n, a, B, N))
|
||||
return 0;
|
||||
while(1){
|
||||
for(p = 0,i = 0; i < n; i++)
|
||||
if(a[m][i] > p)
|
||||
p = a[m][c=i];
|
||||
if(p < eps){
|
||||
for(i = 0; i < n; i++)
|
||||
if(N[i] < n)
|
||||
b[N[i]] = 0;
|
||||
for(i = 0; i < m; i++)
|
||||
if(B[i] < n)
|
||||
b[B[i]] = a[i][n];
|
||||
ret = -a[m][n];
|
||||
return 1;
|
||||
}
|
||||
for(p = inf, i = 0; i < m; i++)
|
||||
if(a[i][c] > eps){
|
||||
v = a[i][n] / a[i][c];
|
||||
if(v < p)
|
||||
p= v, r = i;
|
||||
}
|
||||
if(p == inf)
|
||||
return -1;
|
||||
pivot(m, n, a, B, N, r, c);
|
||||
}
|
||||
}
|
||||
double A[maxm][maxn], B[maxn];
|
||||
int main()
|
||||
{
|
||||
int n , ca = 1, L, R;
|
||||
while(scanf("%d", &n) != EOF){
|
||||
if(n == 0)
|
||||
break;
|
||||
scanf("%d%d", &L, &R);
|
||||
for(int i = 0; i < n; i++){
|
||||
int x, y, z, p;
|
||||
scanf("%d%d%d%d", &x, &y, &z, &p);
|
||||
A[2*i][0] = x;
|
||||
A[2*i][1] = y;
|
||||
A[2*i][2] = z;
|
||||
A[2*i][3] = p - L;
|
||||
A[2*i+1][0] = -x;
|
||||
A[2*i+1][1] = -y;
|
||||
A[2*i+1][2] = -z;
|
||||
A[2*i+1][3] = R - p;
|
||||
}
|
||||
A[2*n][0] = 1.0;
|
||||
A[2*n][1] = -1.0;
|
||||
A[2*n][2] = 0.0;
|
||||
A[2*n][3] = 0;
|
||||
A[2*n+1][0] = 0.0;
|
||||
A[2*n+1][1] = 1.0;
|
||||
A[2*n+1][2] = -1.0;
|
||||
A[2*n+1][3] = 0;
|
||||
A[2*n+2][0] = -1.0;
|
||||
A[2*n+2][1] = 0.0;
|
||||
A[2*n+2][2] = 0.0;
|
||||
A[2*n+2][3] = 0;
|
||||
scanf("%lf%lf%lf", &A[2*n+3][0], &A[2*n+3][1], &A[2*n+3][2]);
|
||||
A[2*n+3][3] = -R;
|
||||
double ret;
|
||||
int sta = simplex(2*n+3, 3, A, B, ret);
|
||||
printf("Case %d: ", ca++);
|
||||
if(sta == -1)
|
||||
printf("Too expensive!\n");
|
||||
else if(sta == 0)
|
||||
printf("Inconsistent data\n");
|
||||
else
|
||||
printf("%.4lf\n",ret);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
double r,w,t;
|
||||
char buf[500];
|
||||
const double eps = 1e-8;
|
||||
const double pi = acos(-1.0);
|
||||
struct Point
|
||||
{
|
||||
double x,y;
|
||||
Point() {}
|
||||
Point(double _x,double _y)
|
||||
{
|
||||
x = _x;
|
||||
y = _y;
|
||||
}
|
||||
Point(Point _a,Point _b)
|
||||
{
|
||||
x = _b.x-_a.x;
|
||||
y = _b.y-_a.y;
|
||||
}
|
||||
void transXY(double B)
|
||||
{
|
||||
double tx = x,ty = y;
|
||||
x = tx*cos(B) - ty*sin(B);
|
||||
y = tx*sin(B) + ty*cos(B);
|
||||
}
|
||||
double Length()
|
||||
{
|
||||
return sqrt(eps+x*x+y*y);
|
||||
}
|
||||
};
|
||||
int cmp(double a,double b)
|
||||
{
|
||||
if (fabs(a-b) < eps) return 0;
|
||||
if (a < b) return -1;
|
||||
return 1;
|
||||
}
|
||||
double sqr(double a)
|
||||
{
|
||||
return a*a;
|
||||
}
|
||||
Point p[4],res[4];
|
||||
int main()
|
||||
{
|
||||
int ft = 0;
|
||||
while (true)
|
||||
{
|
||||
gets(buf);
|
||||
if (strlen(buf) == 1) break;
|
||||
sscanf(buf,"%lf%lf%lf%lf%lf%lf%lf%lf",&p[0].x,&p[0].y,&p[1].x,&p[1].y,&p[2].x,&p[2].y,&p[3].x,&p[3].y);
|
||||
scanf("%lf%lf%lf",&r,&t,&w);
|
||||
gets(buf);
|
||||
w = pi*w/180;
|
||||
double theta = w*t;
|
||||
theta = theta-2*pi*floor(theta/(2*pi));
|
||||
double l = r*w*t;
|
||||
double totl = 0;
|
||||
Point tv;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
tv = Point(p[i],p[(i+1)%4]);
|
||||
totl += tv.Length()-2*r;
|
||||
}
|
||||
res[0] = p[0];
|
||||
for (int i = 1;i < 4;i++)
|
||||
{
|
||||
tv = Point(p[i-1],p[i]);
|
||||
tv.transXY(-theta);
|
||||
res[i] = Point(res[i-1].x+tv.x,res[i-1].y+tv.y);
|
||||
}
|
||||
l = l-totl*floor(l/totl);
|
||||
double pre = 0.0,len;
|
||||
Point prep,nowp,xp;
|
||||
tv = Point(p[0],p[1]);
|
||||
len = tv.Length();
|
||||
xp = Point(p[0].x+tv.x*r/len,p[0].y+tv.y*r/len);
|
||||
prep = Point(xp.x+tv.y*r/len,xp.y-tv.x*r/len);
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
tv = Point(res[i],res[(i+1)%4]);
|
||||
len = tv.Length();
|
||||
if (cmp(pre+len-2*r,l) >= 0)
|
||||
{
|
||||
l -= pre;
|
||||
l += r;
|
||||
xp = Point(res[i].x+tv.x*l/len,res[i].y+tv.y*l/len);
|
||||
nowp = Point(xp.x+tv.y*r/len,xp.y-tv.x*r/len);
|
||||
tv = Point(nowp,prep);
|
||||
for (int j = 0;j < 4;j++)
|
||||
res[j] = Point(res[j].x+tv.x,res[j].y+tv.y);
|
||||
break;
|
||||
}
|
||||
pre += len-2*r;
|
||||
}
|
||||
ft++;
|
||||
printf("Case %d:",ft);
|
||||
for (int i = 0;i < 4;i++)
|
||||
printf(" %.3f %.3f",res[i].x,res[i].y);
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,141 @@
|
|||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <vector>
|
||||
#include <math.h>
|
||||
#include <deque>
|
||||
#define LL long long
|
||||
#define pii pair<int,int>
|
||||
#define pdi pair<double,int>
|
||||
#define INF 0x7f7f7f7f
|
||||
using namespace std;
|
||||
const int N=200;
|
||||
int x[N], y[N], rudu[N];
|
||||
int earn, lost, n;
|
||||
vector<int> vect[N], vec[N];
|
||||
double sum;
|
||||
struct node
|
||||
{
|
||||
int from, to, cap, flow;
|
||||
double val;
|
||||
node(){};
|
||||
node(int from,int to,double val,int cap,int flow):from(from),to(to),val(val),cap(cap),flow(flow){};
|
||||
}edge[90000];
|
||||
int edge_cnt;
|
||||
void add_node(int from,int to,double val,int cap,int flow)
|
||||
{
|
||||
edge[edge_cnt]=node(from, to, val, cap, flow );
|
||||
vec[from].push_back(edge_cnt++);
|
||||
}
|
||||
void build_graph()
|
||||
{
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
for(int j=0; j<vect[i].size(); j++)
|
||||
{
|
||||
int t=vect[i][j];
|
||||
double v= lost - sqrt( pow(x[i]-x[t],2)+pow(y[i]-y[t],2) )*earn;
|
||||
if(v<0)
|
||||
{
|
||||
add_node(t, i, -v, 1, 0 );
|
||||
add_node(i, t, v, 0, 0 );
|
||||
sum+=v;
|
||||
rudu[t]++,rudu[i]--;
|
||||
}
|
||||
else
|
||||
{
|
||||
add_node(i, t, v, 1, 0);
|
||||
add_node(t, i, -v, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
if(rudu[i]>0)
|
||||
{
|
||||
add_node(0, i, 0, rudu[i], 0);
|
||||
add_node(i, 0, 0, 0, 0);
|
||||
}
|
||||
if(rudu[i]<0)
|
||||
{
|
||||
add_node(i, n+1, 0, -rudu[i], 0);
|
||||
add_node(n+1, i, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
int flow[N], path[N], inq[N];
|
||||
double cost[N];
|
||||
double spfa(int s,int e)
|
||||
{
|
||||
deque<int> que(1,s);
|
||||
cost[s]=0;
|
||||
flow[s]=INF;
|
||||
inq[s]=1;
|
||||
while(!que.empty())
|
||||
{
|
||||
int x=que.front();
|
||||
que.pop_front();
|
||||
inq[x]=0;
|
||||
for(int i=0; i<vec[x].size(); i++)
|
||||
{
|
||||
node e=edge[vec[x][i]];
|
||||
if(e.cap>e.flow && cost[e.to]>cost[e.from]+e.val )
|
||||
{
|
||||
flow[e.to]=min(flow[e.from],e.cap-e.flow);
|
||||
cost[e.to]=cost[e.from]+e.val;
|
||||
path[e.to]=vec[x][i];
|
||||
if(!inq[e.to])
|
||||
{
|
||||
inq[e.to]=1;
|
||||
que.push_back(e.to);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return cost[e];
|
||||
}
|
||||
double mcmf(int s,int e)
|
||||
{
|
||||
double ans_cost=0.0;
|
||||
while(true)
|
||||
{
|
||||
memset(flow,0,sizeof(flow));
|
||||
memset(inq,0,sizeof(inq));
|
||||
memset(path,0,sizeof(path));
|
||||
for(int i=0; i<=e; i++) cost[i]=1e39;
|
||||
double tmp=spfa(s,e);
|
||||
if(tmp>1e38) return ans_cost;
|
||||
ans_cost+=tmp;
|
||||
int ed=e;
|
||||
while(ed!=s)
|
||||
{
|
||||
int t=path[ed];
|
||||
edge[t].flow+=flow[n+1];
|
||||
edge[t^1].flow-=flow[n+1];
|
||||
ed=edge[t].from;
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int b, j=0;
|
||||
while(scanf("%d", &n), n)
|
||||
{
|
||||
scanf("%d%d",&earn,&lost);
|
||||
for(int i=0; i<=n+1; i++) vect[i].clear();
|
||||
for(int i=0; i<=n+1; i++) vec[i].clear();
|
||||
memset(edge,0,sizeof(edge));
|
||||
memset(rudu,0,sizeof(rudu));
|
||||
edge_cnt=0;
|
||||
sum=0;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
scanf("%d%d",&x[i],&y[i]);
|
||||
while(scanf("%d",&b), b) vect[i].push_back(b);
|
||||
}
|
||||
build_graph();
|
||||
printf("Case %d: %.2f\n", ++j, -(mcmf(0,n+1)+sum)+0.0000001 );
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#define EPS (1e-8)
|
||||
double dp[1010];
|
||||
using namespace std;
|
||||
double cal(double a,double b,double pre,double p) {
|
||||
return (p-pre)/(1+pow(p-a,b));
|
||||
}
|
||||
double get_max(int a,double b,double pre) {
|
||||
double l = a+1 ,r = 1e10;
|
||||
while(abs(l-r)>EPS) {
|
||||
double mid = (l+r)/2.0,mmid = (r+mid)/2.0;
|
||||
if(cal(a,b,pre,mmid)<cal(a,b,pre,mid)) r = mmid;
|
||||
else l = mid;
|
||||
}
|
||||
int ans = l;
|
||||
return cal(a,b,pre,ans)>cal(a,b,pre,ans+1)?cal(a,b,pre,ans):cal(a,b,pre,ans+1);
|
||||
}
|
||||
double get(double a,double b,int n) {
|
||||
dp[0] = a;
|
||||
for(int i(1);i!=n;++i)
|
||||
dp[i] = dp[i-1] + get_max(a,b,dp[i-1]);
|
||||
return dp[n-1];
|
||||
}
|
||||
int main() {
|
||||
double a,b,n;
|
||||
int t(0);
|
||||
while(cin>>n) {
|
||||
if(n==0) break;
|
||||
cin>>a>>b;
|
||||
printf("Case %d: %.2lf\n",++t,get(a,b,n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
int a[10010];
|
||||
int gcd(int a, int b)
|
||||
{
|
||||
return b > 0 ? gcd(b, a%b) : a;
|
||||
}
|
||||
int n, m;
|
||||
void Solve()
|
||||
{
|
||||
while(~scanf("%d%d", &n, &m))
|
||||
{
|
||||
if(!n && !m)
|
||||
{
|
||||
break;
|
||||
}
|
||||
int sum = 0;
|
||||
for(int i = 0; i < n; ++i)
|
||||
{
|
||||
for(int j = 0; j < m; ++j)
|
||||
{
|
||||
scanf("%d", &a[i]);
|
||||
}
|
||||
sum += a[i];
|
||||
}
|
||||
for(int i = 0; i < n; ++i)
|
||||
{
|
||||
int t = gcd(sum, a[i]);
|
||||
printf("%d / %d\n", a[i]/t, sum/t);
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
Solve();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
map<string, int> val;
|
||||
int con(char *str) {
|
||||
int a, b;
|
||||
sscanf(str, "%d.%d", &a, &b);
|
||||
return a * 10 + b;
|
||||
}
|
||||
bool check(int a, int b, char *p) {
|
||||
if (!strcmp(p, "=")) return a == b;
|
||||
if (!strcmp(p, "<=")) return a <= b;
|
||||
if (!strcmp(p, ">=")) return a >= b;
|
||||
if (!strcmp(p, "<")) return a < b;
|
||||
if (!strcmp(p, ">")) return a > b;
|
||||
return false;
|
||||
}
|
||||
int main() {
|
||||
int n, m;
|
||||
char buf[2][100];
|
||||
while (cin >> n >> m) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int i = 0; i < 2; i++) cin >> buf[i];
|
||||
val[buf[0]] = con(buf[1]);
|
||||
}
|
||||
for (int cas = 1; cas <= m; cas++) {
|
||||
int sum = 0;
|
||||
while (true) {
|
||||
cin >> buf[0];
|
||||
sum += val[buf[0]];
|
||||
cin >> buf[0];
|
||||
if (buf[0][0] != '+') break;
|
||||
}
|
||||
int x;
|
||||
cin >> x;
|
||||
cout << "Guess #" << cas << " was " << (check(sum, x * 10, buf[0]) ? "correct." : "incorrect.") << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define maxn 200010
|
||||
struct node{
|
||||
int u,v,w;
|
||||
}edge[maxn];
|
||||
int parent[maxn];
|
||||
int n,m,ans,sum;
|
||||
int cmp(const node &p,const node &q){
|
||||
return p.w<q.w;
|
||||
}
|
||||
int Find(int x){
|
||||
int i;
|
||||
for(i=x;parent[i]>=0;i=parent[i])
|
||||
;
|
||||
while(i!=x){
|
||||
int tmp=parent[x];
|
||||
parent[x]=i;
|
||||
x=tmp;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
void Union(int x,int y){
|
||||
int r1=Find(x),r2=Find(y);
|
||||
if(r1==r2) return;
|
||||
if(parent[r1]<parent[r2]){
|
||||
parent[r1]+=parent[r2];
|
||||
parent[r2]=r1;
|
||||
}else {
|
||||
parent[r2]+=parent[r1];
|
||||
parent[r1]=r2;
|
||||
}
|
||||
}
|
||||
int Kruskal(){
|
||||
int s=0;
|
||||
for(int i=0;i<m;i++){
|
||||
int u=edge[i].u,v=edge[i].v,w=edge[i].w;
|
||||
if(Find(u)!=Find(v)){
|
||||
s+=w;
|
||||
Union(u,v);
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
int main(){
|
||||
while(~scanf("%d %d",&n,&m)&&m+n){
|
||||
memset(parent,-1,sizeof(parent));
|
||||
ans=0;
|
||||
for(int i=0;i<m;i++){
|
||||
scanf("%d %d %d",&edge[i].u,&edge[i].v,&edge[i].w);
|
||||
ans+=edge[i].w;
|
||||
}
|
||||
sort(edge,edge+m,cmp);
|
||||
sum=Kruskal();
|
||||
printf("%d\n",ans-sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int dp[200][200],a[200],sum,temp;
|
||||
int main()
|
||||
{
|
||||
int i,j,k,n,min;
|
||||
while(cin>>n&&n)
|
||||
{
|
||||
min=0;
|
||||
sum=0;
|
||||
for(i=1;i<=n;i++)
|
||||
cin>>a[i];
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
sum+=a[i];
|
||||
dp[1][i]=(1+i)*sum;
|
||||
}
|
||||
for(i=2;i<=n;i++)
|
||||
for(j=i;j<=n;j++)
|
||||
{
|
||||
sum=0;min=100000000;
|
||||
for(k=j;k>=i;k--)
|
||||
{
|
||||
sum+=(i+j)*a[k];
|
||||
temp=dp[i-1][k-1]+sum;
|
||||
if(temp<min)
|
||||
min=temp;
|
||||
}
|
||||
dp[i][j]=min;
|
||||
}
|
||||
min=1000000000;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
if(min>dp[i][n])
|
||||
min=dp[i][n];
|
||||
}
|
||||
cout<<min<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int ans;
|
||||
int n, a, b, y[1005];
|
||||
void cal(int x){
|
||||
int ret1 = 0, ret2 = 0;
|
||||
for(int i = 1; i <= n; i++)
|
||||
{
|
||||
ret1 += y[i] / x;
|
||||
if(y[i] % x){
|
||||
ret1++;
|
||||
ret2 += x - y[i] % x;
|
||||
}
|
||||
}
|
||||
if(b * ret1 * 6 + a * ret2 < ans){
|
||||
ans = b * ret1 * 6 + a * ret2;
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d", &n) != EOF &&n){
|
||||
scanf("%d%d", &a, &b);
|
||||
int Max = -1;
|
||||
for(int i = 1; i <= n; i++){
|
||||
scanf("%d", &y[i]);
|
||||
y[i] = y[i] * 6;
|
||||
if(Max < y[i]){
|
||||
Max = y[i];
|
||||
}
|
||||
}
|
||||
Max = Max / 3;
|
||||
ans = 0x7fffffff;
|
||||
for(int i = 1; i <= n; i++)
|
||||
for(int j = 1; j <= 3; j++)
|
||||
if(y[i] / j >= Max) {
|
||||
cal(y[i] / j);
|
||||
}
|
||||
int tmp = 6;
|
||||
if(ans % 2 == 0)
|
||||
ans /= 2, tmp /= 2;
|
||||
if(ans % 3 == 0)
|
||||
ans /= 3, tmp /= 3;
|
||||
printf("%d", ans);
|
||||
if(tmp != 1)
|
||||
printf(" / %d", tmp);
|
||||
cout << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
const int MAXN=10030;
|
||||
int a[MAXN];
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
long n;
|
||||
while(scanf("%ld",&n) && n)
|
||||
{
|
||||
int count=1;
|
||||
memset(a,0,sizeof(a));
|
||||
a[n]=1;
|
||||
while(1)
|
||||
{
|
||||
long t=n*n/100;
|
||||
n=t%10000;
|
||||
a[n]++;
|
||||
if(a[n]==2) break;
|
||||
count++;
|
||||
}
|
||||
printf("%d\n",count);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
const int maxn=10005;
|
||||
const int INF=0x3fffffff;
|
||||
int que[maxn];
|
||||
int st[110];
|
||||
int g[110][110];
|
||||
int inque[maxn];
|
||||
int dis[maxn];
|
||||
int n, num;
|
||||
struct Node
|
||||
{
|
||||
int v, cost;
|
||||
Node(int v_,int cost_)
|
||||
{
|
||||
v=v_, cost=cost_;
|
||||
}
|
||||
};
|
||||
map<int,int>mp;
|
||||
vector<Node>vt[maxn];
|
||||
void spfa(int start)
|
||||
{
|
||||
int h=0, t=0;
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
dis[i]=INF;
|
||||
inque[i]=0;
|
||||
}
|
||||
dis[start]=0;
|
||||
inque[start]=1;
|
||||
que[t++]=start;
|
||||
while(h!=t)
|
||||
{
|
||||
int u=que[h++];
|
||||
inque[u]=0;
|
||||
if(h==maxn) h=0;
|
||||
for(int i=0; i<vt[u].size(); i++)
|
||||
{
|
||||
int v=vt[u][i].v, cost=vt[u][i].cost;
|
||||
if(dis[v]>dis[u]+cost)
|
||||
{
|
||||
dis[v]=dis[u]+cost;
|
||||
if(!inque[v])
|
||||
{
|
||||
inque[v]=1;
|
||||
que[t++]=v;
|
||||
if(t==maxn) t=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for(int i=1; i<=n; i++)
|
||||
{
|
||||
if(dis[i]<=600)
|
||||
{
|
||||
g[mp[start]][mp[i]]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
void floyd()
|
||||
{
|
||||
for(int k=0; k<=num+1; k++)
|
||||
for(int i=0; i<=num+1; i++)
|
||||
for(int j=0; j<=num+1; j++)
|
||||
{
|
||||
if(g[i][j]>g[i][k]+g[k][j])
|
||||
g[i][j]=g[i][k]+g[k][j];
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int h, m, u, v, cost;
|
||||
while(cin >> n, n)
|
||||
{
|
||||
cin >> num;
|
||||
mp.clear();
|
||||
for(int i=0; i<=n; i++)
|
||||
vt[i].clear();
|
||||
for(int i=0; i<=num+2; i++)
|
||||
for(int j=0; j<=num+2; j++)
|
||||
{
|
||||
g[i][j]=INF;
|
||||
if(i==j) g[i][j]=0;
|
||||
}
|
||||
for(int i=1; i<=num; i++)
|
||||
{
|
||||
scanf("%d",st+i);
|
||||
mp[st[i]]=i;
|
||||
}
|
||||
st[0]=1;
|
||||
mp[1]=0;
|
||||
st[num+1]=n;
|
||||
mp[n]=num+1;
|
||||
cin >> m;
|
||||
for(int i=0; i<m; i++)
|
||||
{
|
||||
scanf("%d%d%d",&u,&v,&cost);
|
||||
vt[u].push_back(Node(v,cost));
|
||||
vt[v].push_back(Node(u,cost));
|
||||
}
|
||||
for(int i=0; i<=num; i++)
|
||||
spfa(st[i]);
|
||||
floyd();
|
||||
if(g[0][num+1]==INF)
|
||||
cout << -1 <<endl;
|
||||
else
|
||||
cout << g[0][num+1]-1 <<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
const int maxn=50;
|
||||
const __int64 INF=(__int64)1<<60;
|
||||
typedef __int64 lld;
|
||||
typedef struct node
|
||||
{
|
||||
lld v[maxn][maxn];
|
||||
}node;
|
||||
node d,e1,e2,e;
|
||||
int n,tmin,tmax;
|
||||
node mul1(node a,node b)
|
||||
{
|
||||
int i,j,k;
|
||||
node c;
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
c.v[i][j]=-INF;
|
||||
for(k=0;k<n;k++)
|
||||
{
|
||||
if(a.v[i][k]==-INF||b.v[k][j]==-INF)continue;
|
||||
c.v[i][j]=max(c.v[i][j],a.v[i][k]+b.v[k][j]);
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
node fen1(int k)
|
||||
{
|
||||
if(k==0)return e;
|
||||
if(k==1)return d;
|
||||
node p=d,t;
|
||||
int c=0;
|
||||
while(k)
|
||||
{
|
||||
if(k&1)
|
||||
{
|
||||
if(c==0)t=p;
|
||||
else t=mul1(t,p);
|
||||
c++;
|
||||
}
|
||||
p=mul1(p,p);
|
||||
k>>=1;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
node mul2(node a,node b)
|
||||
{
|
||||
int i,j,k;
|
||||
node c=a;
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
for(k=0;k<n;k++)
|
||||
{
|
||||
if(a.v[i][k]==-INF||b.v[k][j]==-INF)continue;
|
||||
c.v[i][j]=max(c.v[i][j],a.v[i][k]+b.v[k][j]);
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
node fen2(int k)
|
||||
{
|
||||
if(k==0)return e;
|
||||
if(k==1)return d;
|
||||
node p=d,t;
|
||||
int c=0;
|
||||
while(k)
|
||||
{
|
||||
if(k&1)
|
||||
{
|
||||
if(c==0)t=p;
|
||||
else t=mul2(t,p);
|
||||
c++;
|
||||
}
|
||||
p=mul2(p,p);
|
||||
k>>=1;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,k;
|
||||
for(i=0;i<50;i++)for(j=0;j<50;j++)e.v[i][j]=0;
|
||||
for(i=0;i<50;i++)e.v[i][i]=1;
|
||||
while(scanf("%d%d%d",&n,&tmin,&tmax)!=EOF)
|
||||
{
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
scanf("%I64d",&d.v[i][j]);
|
||||
if(d.v[i][j]==-500)d.v[i][j]=-INF;
|
||||
}
|
||||
e1=fen1(tmin);
|
||||
d.v[n-1][n-1]=0;
|
||||
e2=fen2(tmax-tmin);
|
||||
lld ans=-INF;
|
||||
if(tmax==tmin)ans=e1.v[0][n-1];
|
||||
else
|
||||
{
|
||||
for(k=0;k<n;k++)if(e1.v[0][k]!=-INF&&e2.v[k][n-1]!=-INF)ans=max(ans,e1.v[0][k]+e2.v[k][n-1]);
|
||||
}
|
||||
if(ans==-INF)printf("IMPOSSIBLE\n");
|
||||
else cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#define N 10005
|
||||
#define LL long long
|
||||
#define inf 1<<29
|
||||
#define eps 1e-7
|
||||
using namespace std;
|
||||
int n,a[100],m,k,cnt,sg[1005];
|
||||
int get_sg(int n){
|
||||
if(sg[n]!=-1)
|
||||
return sg[n];
|
||||
int vis[10000];
|
||||
memset(vis,0,sizeof(vis));
|
||||
for(int i=0;i<cnt&&a[i]<=n;i++){
|
||||
for(int j=0;j<=(n-a[i]);j++){
|
||||
if(sg[j]==-1)
|
||||
sg[j]=get_sg(j);
|
||||
if(sg[n-j-a[i]]==-1)
|
||||
sg[n-j-a[i]]=get_sg(n-j-a[i]);
|
||||
vis[sg[j]^sg[n-j-a[i]]]=1;
|
||||
}
|
||||
}
|
||||
for(int i=0;;i++)
|
||||
if(vis[i]==0)
|
||||
return i;
|
||||
}
|
||||
int main(){
|
||||
while(scanf("%d",&n)!=EOF){
|
||||
for(int i=0;i<n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
sort(a,a+n);
|
||||
cnt=1;
|
||||
for(int i=1;i<n;i++)
|
||||
if(a[i]!=a[cnt-1])
|
||||
a[cnt++]=a[i];
|
||||
int q;
|
||||
scanf("%d",&q);
|
||||
memset(sg,-1,sizeof(sg));
|
||||
while(q--){
|
||||
scanf("%d",&k);
|
||||
if(sg[k]==-1)
|
||||
sg[k]=get_sg(k);
|
||||
if(sg[k])
|
||||
puts("1");
|
||||
else
|
||||
puts("2");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue