From da5da8ec9f4a67709aaa891d5195fb5e78837fd6 Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Thu, 1 Sep 2016 20:51:58 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 3100-3199 --- HDOJ/3100_autoAC.cpp | 68 +++++++++++++ HDOJ/3101_autoAC.cpp | 77 +++++++++++++++ HDOJ/3102_autoAC.cpp | 30 ++++++ HDOJ/3103_autoAC.cpp | 101 ++++++++++++++++++++ HDOJ/3104_autoAC.cpp | 29 ++++++ HDOJ/3105_autoAC.cpp | 16 ++++ HDOJ/3106_autoAC.cpp | 114 ++++++++++++++++++++++ HDOJ/3109_autoAC.cpp | 65 +++++++++++++ HDOJ/3110_autoAC.cpp | 44 +++++++++ HDOJ/3111_autoAC.cpp | 210 ++++++++++++++++++++++++++++++++++++++++ HDOJ/3113_autoAC.cpp | 123 ++++++++++++++++++++++++ HDOJ/3117_autoAC.cpp | 36 +++++++ HDOJ/3118_autoAC.cpp | 48 ++++++++++ HDOJ/3119_autoAC.cpp | 119 +++++++++++++++++++++++ HDOJ/3120_autoAC.cpp | 164 +++++++++++++++++++++++++++++++ HDOJ/3121_autoAC.cpp | 153 +++++++++++++++++++++++++++++ HDOJ/3123_autoAC.cpp | 37 +++++++ HDOJ/3124_autoAC.cpp | 113 ++++++++++++++++++++++ HDOJ/3125_autoAC.cpp | 75 +++++++++++++++ HDOJ/3126_autoAC.cpp | 200 ++++++++++++++++++++++++++++++++++++++ HDOJ/3127_autoAC.cpp | 36 +++++++ HDOJ/3128_autoAC.cpp | 36 +++++++ HDOJ/3129_autoAC.cpp | 45 +++++++++ HDOJ/3130_autoAC.cpp | 20 ++++ HDOJ/3131_autoAC.cpp | 94 ++++++++++++++++++ HDOJ/3132_autoAC.cpp | 1 + HDOJ/3134_autoAC.cpp | 68 +++++++++++++ HDOJ/3137_autoAC.cpp | 10 ++ HDOJ/3138_autoAC.cpp | 132 +++++++++++++++++++++++++ HDOJ/3139_autoAC.cpp | 9 ++ HDOJ/3143_autoAC.cpp | 103 ++++++++++++++++++++ HDOJ/3146_autoAC.cpp | 113 ++++++++++++++++++++++ HDOJ/3147_autoAC.cpp | 88 +++++++++++++++++ HDOJ/3150_autoAC.cpp | 60 ++++++++++++ HDOJ/3151_autoAC.cpp | 161 +++++++++++++++++++++++++++++++ HDOJ/3152_autoAC.cpp | 60 ++++++++++++ HDOJ/3153_autoAC.cpp | 5 + HDOJ/3154_autoAC.cpp | 109 +++++++++++++++++++++ HDOJ/3155_autoAC.cpp | 112 ++++++++++++++++++++++ HDOJ/3156_autoAC.cpp | 223 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/3157_autoAC.cpp | 142 +++++++++++++++++++++++++++ HDOJ/3158_autoAC.cpp | 72 ++++++++++++++ HDOJ/3159_autoAC.cpp | 4 + HDOJ/3160_autoAC.cpp | 47 +++++++++ HDOJ/3162_autoAC.cpp | 36 +++++++ HDOJ/3163_autoAC.cpp | 64 +++++++++++++ HDOJ/3164_autoAC.cpp | 22 +++++ HDOJ/3165_autoAC.cpp | 79 +++++++++++++++ HDOJ/3168_autoAC.cpp | 49 ++++++++++ HDOJ/3169_autoAC.cpp | 1 + HDOJ/3171_autoAC.cpp | 54 +++++++++++ HDOJ/3172_autoAC.cpp | 49 ++++++++++ HDOJ/3174_autoAC.cpp | 1 + HDOJ/3176_autoAC.cpp | 19 ++++ HDOJ/3177_autoAC.cpp | 46 +++++++++ HDOJ/3178_autoAC.cpp | 36 +++++++ HDOJ/3181_autoAC.cpp | 27 ++++++ HDOJ/3182_autoAC.cpp | 84 ++++++++++++++++ HDOJ/3183_autoAC.cpp | 51 ++++++++++ HDOJ/3184_autoAC.cpp | 58 +++++++++++ HDOJ/3187_autoAC.cpp | 75 +++++++++++++++ HDOJ/3188_autoAC.cpp | 17 ++++ HDOJ/3189_autoAC.cpp | 53 ++++++++++ HDOJ/3191_autoAC.cpp | 85 +++++++++++++++++ HDOJ/3193_autoAC.cpp | 72 ++++++++++++++ HDOJ/3195_autoAC.cpp | 47 +++++++++ HDOJ/3197_autoAC.cpp | 56 +++++++++++ HDOJ/3199_autoAC.cpp | 30 ++++++ 68 files changed, 4683 insertions(+) create mode 100644 HDOJ/3100_autoAC.cpp create mode 100644 HDOJ/3101_autoAC.cpp create mode 100644 HDOJ/3102_autoAC.cpp create mode 100644 HDOJ/3103_autoAC.cpp create mode 100644 HDOJ/3104_autoAC.cpp create mode 100644 HDOJ/3105_autoAC.cpp create mode 100644 HDOJ/3106_autoAC.cpp create mode 100644 HDOJ/3109_autoAC.cpp create mode 100644 HDOJ/3110_autoAC.cpp create mode 100644 HDOJ/3111_autoAC.cpp create mode 100644 HDOJ/3113_autoAC.cpp create mode 100644 HDOJ/3117_autoAC.cpp create mode 100644 HDOJ/3118_autoAC.cpp create mode 100644 HDOJ/3119_autoAC.cpp create mode 100644 HDOJ/3120_autoAC.cpp create mode 100644 HDOJ/3121_autoAC.cpp create mode 100644 HDOJ/3123_autoAC.cpp create mode 100644 HDOJ/3124_autoAC.cpp create mode 100644 HDOJ/3125_autoAC.cpp create mode 100644 HDOJ/3126_autoAC.cpp create mode 100644 HDOJ/3127_autoAC.cpp create mode 100644 HDOJ/3128_autoAC.cpp create mode 100644 HDOJ/3129_autoAC.cpp create mode 100644 HDOJ/3130_autoAC.cpp create mode 100644 HDOJ/3131_autoAC.cpp create mode 100644 HDOJ/3132_autoAC.cpp create mode 100644 HDOJ/3134_autoAC.cpp create mode 100644 HDOJ/3137_autoAC.cpp create mode 100644 HDOJ/3138_autoAC.cpp create mode 100644 HDOJ/3139_autoAC.cpp create mode 100644 HDOJ/3143_autoAC.cpp create mode 100644 HDOJ/3146_autoAC.cpp create mode 100644 HDOJ/3147_autoAC.cpp create mode 100644 HDOJ/3150_autoAC.cpp create mode 100644 HDOJ/3151_autoAC.cpp create mode 100644 HDOJ/3152_autoAC.cpp create mode 100644 HDOJ/3153_autoAC.cpp create mode 100644 HDOJ/3154_autoAC.cpp create mode 100644 HDOJ/3155_autoAC.cpp create mode 100644 HDOJ/3156_autoAC.cpp create mode 100644 HDOJ/3157_autoAC.cpp create mode 100644 HDOJ/3158_autoAC.cpp create mode 100644 HDOJ/3159_autoAC.cpp create mode 100644 HDOJ/3160_autoAC.cpp create mode 100644 HDOJ/3162_autoAC.cpp create mode 100644 HDOJ/3163_autoAC.cpp create mode 100644 HDOJ/3164_autoAC.cpp create mode 100644 HDOJ/3165_autoAC.cpp create mode 100644 HDOJ/3168_autoAC.cpp create mode 100644 HDOJ/3169_autoAC.cpp create mode 100644 HDOJ/3171_autoAC.cpp create mode 100644 HDOJ/3172_autoAC.cpp create mode 100644 HDOJ/3174_autoAC.cpp create mode 100644 HDOJ/3176_autoAC.cpp create mode 100644 HDOJ/3177_autoAC.cpp create mode 100644 HDOJ/3178_autoAC.cpp create mode 100644 HDOJ/3181_autoAC.cpp create mode 100644 HDOJ/3182_autoAC.cpp create mode 100644 HDOJ/3183_autoAC.cpp create mode 100644 HDOJ/3184_autoAC.cpp create mode 100644 HDOJ/3187_autoAC.cpp create mode 100644 HDOJ/3188_autoAC.cpp create mode 100644 HDOJ/3189_autoAC.cpp create mode 100644 HDOJ/3191_autoAC.cpp create mode 100644 HDOJ/3193_autoAC.cpp create mode 100644 HDOJ/3195_autoAC.cpp create mode 100644 HDOJ/3197_autoAC.cpp create mode 100644 HDOJ/3199_autoAC.cpp diff --git a/HDOJ/3100_autoAC.cpp b/HDOJ/3100_autoAC.cpp new file mode 100644 index 0000000..cba48d2 --- /dev/null +++ b/HDOJ/3100_autoAC.cpp @@ -0,0 +1,68 @@ +#include +#include +#include +#include +using namespace std; +vector adj[26][26]; +int deg[26]; +int main() { + int n; + while (cin >> n, n) { + char v, w; double r; + for (int i = 0; i < 26; i++) { + for (int j = 0; j < 26; j++) { + adj[i][j].clear(); + } + } + for (int i = 0; i < n; i++) { + cin >> v >> w >> r; + adj[v-'A'][w-'A'].push_back(r); + adj[w-'A'][v-'A'].push_back(r); + } + for (int k = 0; k < n; k++) { + for (int i = 0; i < 26; i++) { + for (int j = 0; j < 26; j++) { + if (adj[i][j].size() > 1) { + double inv_sum = 0; + for (int s = 0; s < adj[i][j].size(); s++) { + inv_sum += 1.0/adj[i][j][s]; + } + adj[i][j].clear(); adj[j][i].clear(); + adj[i][j].push_back(1.0/inv_sum); adj[j][i].push_back(1.0/inv_sum); + } + } + } + memset(deg, 0, sizeof deg); + for (int i = 0; i < 26; i++) { + for (int j = 0; j < 26; j++) { + if (adj[i][j].size()) deg[i]++; + } + } + for (int i = 0; i < 26; i++) { + for (int j = 0; j < 26; j++) { + for (int l = 0; l < 26; l++) { + if (i == l || i == j || j == l) continue; + if (j == 0 || j == 25) continue; + if (adj[i][j].size() && adj[j][l].size()) { + if (deg[j] != 2) break; + double r = adj[i][j][0] + adj[j][l][0]; + adj[i][j].clear(); adj[j][i].clear(); + adj[j][l].clear(); adj[l][j].clear(); + adj[i][l].push_back(r); adj[l][i].push_back(r); + deg[j] = 0; deg[i]++; deg[l]++; + } + } + } + } + } + bool reduced = true; + for (int i = 1; i < 25; i++) { + if (deg[i] != 0) reduced = false; + } + double ans = 0; + if (!reduced || adj[0][25].empty()) ans = -1; + else ans = adj[0][25][0]; + cout << fixed << setprecision(3) << ans << endl; + } + return 0; +} diff --git a/HDOJ/3101_autoAC.cpp b/HDOJ/3101_autoAC.cpp new file mode 100644 index 0000000..c664b56 --- /dev/null +++ b/HDOJ/3101_autoAC.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#include +#include +#include +#include +#include +#include +#include ; +#define cler(arr, val) memset(arr, val, sizeof(arr)) +#define FOR(i,a,b) for(int i=a;i<=b;i++) +typedef long long LL; +const int MAXN = 1032; +const int MAXM = 444; +const int INF = 0x3f3f3f3f; +const int mod = 1000000007; +vectorG[MAXN]; +int val[MAXN],vis[MAXN],ans,num,orz[MAXN],man; +void init() +{ + for(int i=0; iq; + for(int i=0; i +#include +#define Min(a,b) a=0;j--){ + for(k=i-1;k +#include +#include +#include +using namespace std; +const double eps = 1e-5; +const double PI = acos(-1.0); +struct point +{ + double x, y; +}; +struct gao +{ + double mz,zc; +}; +struct gao gg[10]; +bool cmp(gao a,gao b) +{ + if(a.mz!=b.mz) + return a.mz>b.mz; + return a.zc>b.zc; +} +double xmult(double x1,double y1,double x2,double y2,double x0,double y0) +{ + return (x1-x0)*(y2-y0)-(x2-x0)*(y1-y0); +} +int same_side(point p1,point p2,point l1,point l2) +{ + return xmult(l1.x,l1.y,p1.x,p1.y,l2.x,l2.y)*xmult(l1.x,l1.y,p2.x,p2.y,l2.x,l2.y)>0; +} +double dis(point a,point b) +{ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); +} +point intersection(point u1,point u2,point v1,point v2) +{ + point ret=u1; + double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x)) + /((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x)); + ret.x+=(u2.x-u1.x)*t; + ret.y+=(u2.y-u1.y)*t; + return ret; +} +double aera(point a,point b,point c) +{ + double aa,bb,cc,q; + aa=dis(c,b); + bb=dis(a,c); + cc=dis(b,a); + q=(aa+bb+cc)/2; + double h=sqrt(q*(q-aa)*(q-bb)*(q-cc)); + h=(int)(h*1000+0.5); + return h*0.001; +} +double get_zc(point a,point b,point c) +{ + double aa,bb,cc,q; + aa=dis(c,b); + bb=dis(a,c); + cc=dis(b,a); + q=(aa+bb+cc); + return q; +} +int main() +{ + int i; + double x1,y1,x2,y2,x3,y3,x4,y4; + point a,b,c,d,e; + while(scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4)!=EOF) + { + if(x1==0 && y1==0 && x2==0 && y2==0 && x3==0 && y3==0 && x4==0 && y4==0) + break; + a.x=x1; + a.y=y1; + b.x=x2; + b.y=y2; + c.x=x3; + c.y=y3; + d.x=x4; + d.y=y4; + if(same_side(a, b, c,d)==0) + e = intersection(d,c,a,b); + else if(same_side(d, b, c, a)==0) + e = intersection(d,b,c,a); + else + e = intersection(b,c,d,a); + gg[0].mz=aera(a,b,e); + gg[1].mz=aera(b,c,e); + gg[2].mz=aera(c,d,e); + gg[3].mz=aera(a,d,e); + gg[0].zc=get_zc(a,b,e); + gg[1].zc=get_zc(b,c,e); + gg[2].zc=get_zc(c,d,e); + gg[3].zc=get_zc(a,d,e); + sort(gg,gg+4,cmp); + for(i=0; i<3; i++) + printf("%.3lf %.3lf ",gg[i].mz,gg[i].zc); + printf("%.3lf %.3lf\n",gg[i].mz,gg[i].zc); + } + return 0; +} diff --git a/HDOJ/3104_autoAC.cpp b/HDOJ/3104_autoAC.cpp new file mode 100644 index 0000000..c0ab912 --- /dev/null +++ b/HDOJ/3104_autoAC.cpp @@ -0,0 +1,29 @@ +#include +int main() +{ + int n; + int a1,a2,a3; + int ans; + while(~scanf("%d%d%d%d",&n,&a1,&a2,&a3)) + { + if(n==0 && a1==0 && a2==0 && a3==0) + break; + ans = 4*n-1; + if(a2>a1) + { + ans+=a2-a1; + } + else + { + ans+=n+a2-a1; + } + if(a3 +int main(){ + int n,i,a; + int f[50]; + while(scanf("%d",&n),n){ + for(i=0;i<50;i++) + f[i]=0; + for(i=0;i55?"No":"Yes"); + } +} diff --git a/HDOJ/3106_autoAC.cpp b/HDOJ/3106_autoAC.cpp new file mode 100644 index 0000000..bd5a777 --- /dev/null +++ b/HDOJ/3106_autoAC.cpp @@ -0,0 +1,114 @@ +#include +#include +#include +char a[1000]; +char einput[1000]="JOKER"; +int gnum(char x){ + if(x == 'K') return 10; + if(x == 'Q') return 10; + if(x == 'J') return 10; + if(x == 'T') return 10; + if(x == 'A') return 1; + return int(x) - 48; +} +int len; +int p, d; +int tp, td; +int sum; +bool flagp, flagd; +bool ans; +int getp(int s, int t, bool flag){ + int result = p; + for(int i = s; i <= t; i++){ + if(a[i] == 'A') + flag = true; + result += gnum(a[i]); + } + if(result <= 11 && flag) + result += 10; + return result; +} +int getd(int s, int t, bool flag){ + int result = d; + if(result >= 17) + return result; + if(flag && result <= 11 && result + 10 >= 17) + return result + 10; + for(int i = s; i <= t; i++) + if(result < 17){ + if(a[i] == 'A') + flag = true; + result += gnum(a[i]); + if(flag && result <= 11 &result + 10 >= 17) + return result + 10; + } + else + return result; + return result; +} +int main(){ + while(1){ + memset(a, 0, sizeof(a)); + fgets(a, 1000, stdin); + flagp = false; + flagd = false; + ans = false; + if(a[strlen(a) - 1] == '\n') + a[strlen(a) - 1] = '\0'; + len = strlen(a); + if(strcmp(a, einput) == 0) + break; + p = gnum(a[0]) + gnum(a[2]); + d = gnum(a[1]) + gnum(a[3]); + if(a[0] == 'A') + flagp = true; + if(a[2] == 'A') + flagp = true; + if(a[1] == 'A') + flagd = true; + if(a[3] == 'A') + flagd = true; + if(len == 4){ + if(flagp && p <= 11) + p += 10; + if(flagd && d <= 11) + d += 10; + if(p>=d) + printf("Yes\n"); + else + printf("No\n"); + } + else{ + sum = p; + ans = false; + tp = p; + if(flagp && tp <= 11) + tp += 10; + td = getd(4, len-1, flagd); + if(tp <= 21) + if(tp >= td || td > 21) + { + ans = true; + } + for(int i = 4; i <= len - 1; i++){ + if(ans) + break; + sum += gnum(a[i]); + if(sum > 21) + break; + tp = getp(4, i , flagp); + td = getd(i + 1, len -1, flagd); + if(tp <= 21) + if(tp >= td || td > 21){ + ans = true; + break; + } + } + if(ans) + printf("Yes\n"); + else + printf("No\n"); + } + } + return 0; +} diff --git a/HDOJ/3109_autoAC.cpp b/HDOJ/3109_autoAC.cpp new file mode 100644 index 0000000..2495714 --- /dev/null +++ b/HDOJ/3109_autoAC.cpp @@ -0,0 +1,65 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +vector Org[30][30]; +char Trs[90][5]; +char st[60]; +int f[60][60][30]; +int Max2(int a,int b) +{ + return a>b?a:b; +} +int main() +{ + int N,i,j,k,t,L,Ans; + for (;;) + { + scanf("%d",&N); + if (N==0) break; + for (i=0;i<='T'-'A';i++) + for (j=0;j<='T'-'A';j++) + Org[i][j].clear(); + for (i=0;iMax2(f[k+1][i+j][Trs[t][2]-'A'],f[i][k][Trs[t][1]-'A'])+1)) + f[i][i+j][Trs[t][0]-'A']=Max2(f[k+1][i+j][Trs[t][2]-'A'],f[i][k][Trs[t][1]-'A'])+1; + } + } + Ans=-1; + for (i=0;i<='T'-'A';i++) + if (Ans==-1 || (f[0][L-1][i]!=-1 && Ans>f[0][L-1][i])) + Ans=f[0][L-1][i]; + printf("%d\n",Ans); + } +} diff --git a/HDOJ/3110_autoAC.cpp b/HDOJ/3110_autoAC.cpp new file mode 100644 index 0000000..9a7f188 --- /dev/null +++ b/HDOJ/3110_autoAC.cpp @@ -0,0 +1,44 @@ +#include +using namespace std; +int dp[1010][1010], price[1010],need[1010]; +int main() +{ + int week,basecost,cell,storecost,i,j,k,min,mini; + while(cin>>week) + { + if(week==0) + break; + cin>>basecost>>storecost>>cell; + for(i=1;i<=week;i++) + cin>>price[i]>>need[i]; + for(j=0;j<=cell;j++) + { + dp[1][j]=(j+need[1])*price[1]+basecost+j*storecost; + if(need[1]==0) + dp[1][0]=0; + } + for(i=2;i<=week;i++) + for(j=0;j<=cell;j++) + { + min=10000000; + for(k=0;k<=cell;k++) + { + if(k<=j+need[i]) + { + if(j==k-need[i]) + mini=dp[i-1][k]+j*storecost; + else mini=dp[i-1][k]+basecost+(j-k+need[i])*price[i]+j*storecost; + if(mini +#include +#include +using namespace std; +const int INF = 0x7fffffff; +const int NN = 350; +const int MM = 750; +int n,m; +int cntc[NN]; +int L[NN*MM],R[NN*MM],U[NN*MM],D[NN*MM]; +int C[NN*MM]; +int head; +int mx[MM][NN]; +int O[MM],idx; +int ans[10][10]; +void remove(int c) +{ + int i,j; + L[R[c]] = L[c]; + R[L[c]] = R[c]; + for(i = D[c]; i != c; i = D[i]) + { + for(j = R[i]; j != i; j = R[j]) + { + U[D[j]] = U[j]; + D[U[j]] = D[j]; + cntc[C[j]]--; + } + } +} +void resume(int c) +{ + int i,j; + R[L[c]] = c; + L[R[c]] = c; + for(i = D[c]; i != c; i = D[i]) + { + for(j = R[i]; j != i; j = R[j]) + { + U[D[j]] = j; + D[U[j]] = j; + cntc[C[j]]++; + } + } +} +bool dfs() +{ + int i,j,c; + if(R[head] == head) + return true; + int min = INF; + for(i = R[head]; i != head; i = R[i]) + { + if(cntc[i] < min) + { + min = cntc[i]; + c = i; + } + } + remove(c); + for(i = D[c]; i != c; i = D[i]) + { + O[idx++] = (i-1)/n; + for(j = R[i]; j != i; j = R[j]) + remove(C[j]); + if(dfs()) + return true; + for(j = L[i]; j != i; j = L[j]) + resume(C[j]); + idx--; + } + resume(c); + return false; +} +bool build() +{ + int i,j,now,pre,first; + idx = head = 0; + for(i = 0; i < n; i++) + { + R[i] = i+1; + L[i+1] = i; + } + R[n] = 0; + L[0] = n; + for(j = 1; j <= n; j++) + { + pre = j; + cntc[j] = 0; + for(i = 1; i <= m; i++) + { + if(mx[i][j]) + { + cntc[j]++; + now = i*n+j; + C[now] = j; + D[pre] = now; + U[now] = pre; + pre = now; + } + } + U[j] = pre; + D[pre] = j; + if(cntc[j] == 0) + return false; + } + for(i = 1; i <= m; i++) + { + pre = first = -1; + for(j = 1; j <= n; j++) + { + if(mx[i][j]) + { + now = i*n+j; + if(pre == -1) + first = now; + else + { + R[pre] = now; + L[now] = pre; + } + pre = now; + } + } + if(first != -1) + { + R[pre] = first; + L[first] = pre; + } + } + return true; +} +int T; +void print() +{ + int i,j; + int x,y,k; + for(i = 0; i < idx; i++) + { + int r = O[i]; + k = r%9; + if(k==0) k = 9; + int num = (r - k)/9 + 1; + y = num%9; + if(y == 0) y = 9; + x = (num-y)/9 + 1; + ans[x][y] = k; + } + if(idx == 0) + printf("impossible\n"); + else + { + for(i = 1; i <= 9; i++) + { + for(j = 1; j <= 9; j++) + printf("%d",ans[i][j]); + printf("\n"); + } + } + if(T!=0) + printf("---\n"); +} +int main() +{ + int i,j,k; + int cases; + char cao[12]; + char s[12][12]; + scanf("%d",&cases); + T = cases; + while(T--) + { + if(T < cases-1) + scanf("%s",cao); + for(i = 1; i <= 9; i++) + scanf("%s",&s[i][1]); + memset(mx,0,sizeof(mx)); + for(i = 1; i <= 9; i++) + { + for(j = 1; j <= 9; j++) + { + int t = (i-1)*9 + j; + if(s[i][j] == '?') + { + for(k = 1; k <= 9; k++) + { + mx[9*(t-1)+k][t] = 1; + mx[9*(t-1)+k][81+(i-1)*9+k] = 1; + mx[9*(t-1)+k][162+(j-1)*9+k] = 1; + mx[9*(t-1)+k][243+((i-1)/3*3+(j+2)/3-1)*9+k] = 1; + } + } + else + { + k = s[i][j] - '0'; + mx[9*(t-1)+k][t] = 1; + mx[9*(t-1)+k][81+(i-1)*9+k] = 1; + mx[9*(t-1)+k][162+(j-1)*9+k] = 1; + mx[9*(t-1)+k][243+((i-1)/3*3+(j+2)/3-1)*9+k] = 1; + } + } + } + n = 324; + m = 729; + build(); + dfs(); + print(); + } + return 0; +} diff --git a/HDOJ/3113_autoAC.cpp b/HDOJ/3113_autoAC.cpp new file mode 100644 index 0000000..4fa04ab --- /dev/null +++ b/HDOJ/3113_autoAC.cpp @@ -0,0 +1,123 @@ +#include +#include +#include +#include +#include +using namespace std; +const int N = 1000005; +const int INF = 1 << 30; +const int M = 1005; +bool prime[N]; +int p[N]; +int pri[M],num[M]; +int arr[M]; +int k,cnt,ct; +void isprime() +{ + k = 0; + memset(prime,true,sizeof(prime)); + for(int i=2;i 1) + { + pri[cnt] = n; + num[cnt] = 1; + cnt++; + } +} +void dfs(int dept,int product = 1) +{ + if(dept == cnt) + { + arr[ct++] = product; + return; + } + for(int i=0;i<=num[dept];i++) + { + dfs(dept+1,product); + product *= pri[dept]; + } +} +void Work(int n) +{ + ct = 0; + Divide(n); + dfs(0,1); + sort(arr,arr+ct); + int ctt = 0; + int ansx = INF; + int ansy = INF; + int tmpx = 0; + int tmpy = 0; + for(int i=0;i= 0) + { + int tmp = (int)sqrt(t * 1.0); + if(tmp * tmp == t) + { + if((3*arr[i] - tmp)%6==0) + { + ctt++; + tmpx = (3*arr[i] - tmp) / 6; + if(tmpx < ansx) + { + ansx = tmpx; + ansy = arr[i] - tmpx; + } + } + if((3*arr[i] + tmp)%6==0) + { + ctt++; + tmpx = (3*arr[i] + tmp) / 6; + if(tmpx < ansx) + { + ansx = tmpx; + ansy = arr[i] - tmpx; + } + } + } + } + } + if(ctt == 0) puts("Impossible"); + else printf("%d %d\n",ansx,ansy); +} +int main() +{ + int n; + isprime(); + while(~scanf("%d",&n)) + { + if(n == 0) break; + Work(n); + } + return 0; +} diff --git a/HDOJ/3117_autoAC.cpp b/HDOJ/3117_autoAC.cpp new file mode 100644 index 0000000..a84258b --- /dev/null +++ b/HDOJ/3117_autoAC.cpp @@ -0,0 +1,36 @@ +#include +#include +using namespace std; +const int MAX = 16000; +int mod = 10000; +int fiblast[MAX] = {0, 1, 1}, fib[MAX] = {0, 1, 1}; +double N1 = (1.0 + sqrt(5.0)) / 2.0; +void pre_init() +{ + for(int i = 3; i < MAX; i++) + { + fiblast[i] = (fiblast[i - 1] + fiblast[i - 2]) % mod; + if(fiblast[i] == fiblast[1] && fiblast[i - 1] == fiblast[0]) + break; + fib[i] = fib[i - 1] + fib[i - 2]; + } + return ; +} +int main(void) +{ + pre_init(); + int n; + while(scanf("%d", &n) == 1) + { + if(n < 40) + { + printf("%d\n", fib[n]); + continue; + } + double k = log10(1.0/sqrt(5.0)) + (double)n * log10(N1); + double tmp = k; + tmp = k - (int)tmp; + printf("%d...%0.4d\n", (int)(1000.0 * pow(10.0, tmp)), fiblast[n % 15000]); + } + return 0; +} diff --git a/HDOJ/3118_autoAC.cpp b/HDOJ/3118_autoAC.cpp new file mode 100644 index 0000000..5cdf0fe --- /dev/null +++ b/HDOJ/3118_autoAC.cpp @@ -0,0 +1,48 @@ +#include +#include +#define INF 1000000000 +int tou[305],wei[305]; +int ji1[20],ji2[20]; +int poww(int a,int b) +{ + int sum=1; + for(int i=0;imin) break; + } + if(sum +#include +#include +#define PI 3.14159265358979323846 +#define eps 1e-8 +using namespace std; +inline int SGN(double x){return x < -eps ? -1 : x < eps ? 0 : 1;} +inline double SQR(double x){return x * x;} +struct pt +{ + double x, y; + pt(){} + pt(double _x, double _y):x(_x), y(_y){} + pt operator - (const pt p1){return pt(x - p1.x, y - p1.y);} + pt operator + (const pt p1){return pt(x + p1.x, y + p1.y);} + pt operator * (double r){return pt(x * r, y * r);} + pt operator / (double r){return pt(x / r, y / r);} + void read(){scanf("%lf %lf", &x, &y);} +}; +inline double cpr(const pt &a,const pt &b){return a.x*b.y-a.y*b.x;} +inline double dis(const pt &a, const pt &b){return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));} +inline double dis2(const pt &a, const pt &b){return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);} +inline void intersection_circle_circle(pt &c1, double r1, pt &c2, double r2, pt &p1, pt &p2) +{ + double d2 = (c1.x - c2.x) * (c1.x - c2.x) + (c1.y - c2.y) * (c1.y - c2.y); + double cos = (r1 * r1 + d2 - r2 * r2) / (2 * r1 * sqrt(d2)); + pt v1 = (c2 - c1) / dis(c1, c2), v2 = pt(-v1.y, v1.x) * (r1 * sqrt(1 - cos * cos)); + pt X = c1 + v1 * (r1 * cos); + p1 = X + v2; + p2 = X - v2; +} +struct Event +{ + double pos; + int del; + pt X; + bool operator < (const Event e)const{return pos < e.pos;} +}; +int n; +pt o[400]; +double r[400]; +Event e[800]; +int cnt; +double ans[10]; +int sc[400]; +inline int rlt(int a, int b) +{ + double d = dis2(o[a], o[b]), df = SGN(d - SQR(r[a] - r[b])); + if (df <= 0)return !SGN(r[a] - r[b]) ? a < b : r[a] < r[b]; + return d < SQR(r[a] + r[b]) - eps ? 2 : 3; +} +inline double arcArea(double r, Event e1, Event e2) +{ + double dif = e2.pos - e1.pos; + return (cpr(e1.X, e2.X) + (dif - sin(dif)) * r * r) * 0.5; +} +void solve() +{ + double center, d2, ang, angX, angY; + pt X, Y, L; + Event last; + memset(ans, 0, sizeof(ans)); + for (int i = 0; i < n; i++) if (r[i] > eps) + { + int acc[4] = {0}; + cnt = 0; + L = pt(o[i].x - r[i], o[i].y); + e[cnt].pos = -PI, e[cnt].del = sc[i], e[cnt++].X = L; + e[cnt].pos = PI, e[cnt].del = -sc[i], e[cnt++].X = L; + for (int j = 0; j < n; j++) if (i != j && r[j] > eps) + { + int rel = rlt(i, j); + if (rel == 1) + { + e[cnt].pos = -PI, e[cnt].del = sc[j], e[cnt++].X = L; + e[cnt].pos = PI, e[cnt].del = -sc[j], e[cnt++].X = L; + } else if (rel == 2) + { + intersection_circle_circle(o[i], r[i], o[j], r[j], X, Y); + angX = atan2(X.y - o[i].y, X.x - o[i].x); + angY = atan2(Y.y - o[i].y, Y.x - o[i].x); + if (angX < angY) acc[sc[j]]++; + e[cnt].pos = angY, e[cnt].del = sc[j], e[cnt++].X = Y; + e[cnt].pos = angX, e[cnt].del = -sc[j], e[cnt++].X = X; + } + } + sort(e, e + cnt); + last.pos = -PI, last.X = pt(o[i].x - r[i], o[i].y); + for (int j = 0; j < cnt; j++) + { + double tmp = arcArea(r[i], last, e[j]); + ans[!!acc[1] + 2 * !!acc[2] + 4 * !!acc[3]] += tmp; + ans[!!(acc[1] - (sc[i] == 1)) + 2 * !!(acc[2] - (sc[i] == 2)) + 4 * !!(acc[3] - (sc[i] == 3))] -= tmp; + acc[abs(e[j].del)] += SGN(e[j].del); + last = e[j]; + } + } +} +void fun() +{ + int n1, n2, n3; + scanf("%d %d %d", &n1, &n2, &n3); + n = n1 + n2 + n3; + for (int i = 0; i < n; i++) + { + o[i].read(); + scanf("%lf", &r[i]); + sc[i] = i < n1 ? 1 : i < n1 + n2 ? 2 : 3; + } + solve(); + printf("%.2f %.2f %.2f %.2f %.2f %.2f %.2f\n", fabs(ans[1]), fabs(ans[2]), fabs(ans[4]), fabs(ans[7]), fabs(ans[3]), fabs(ans[5]), fabs(ans[6])); +} +int main() +{ + int tc; + scanf ("%d", &tc); + while (tc--)fun(); + return 0; +} diff --git a/HDOJ/3120_autoAC.cpp b/HDOJ/3120_autoAC.cpp new file mode 100644 index 0000000..64d7fc7 --- /dev/null +++ b/HDOJ/3120_autoAC.cpp @@ -0,0 +1,164 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAX=1005; +const int inf=1<<26; +struct node +{ + int v,w,next; +}g[MAX*100]; +int adj[MAX],e,vis1[MAX],vis2[MAX],kind[MAX],n,m; +int dis[MAX],fa[MAX],pre[MAX]; +int flag[MAX]; +bool pos[MAX],found; +void add(int u,int v,int w) +{ + g[e].v=v; g[e].w=w; g[e].next=adj[u]; adj[u]=e++; +} +void spfa(int s,int t,int k) +{ + int i,u,v; + queueque; + for(i=0;i<=n;i++) + dis[i]=inf; + if(k) + memset(pre,-1,sizeof(pre)); + dis[s]=0; + memset(vis1,0,sizeof(vis1)); + vis1[s]=1; + que.push(s); + while(!que.empty()) + { + u=que.front(); + que.pop(); + vis1[u]=0; + for(i=adj[u];i!=-1;i=g[i].next) + { + v=g[i].v; + if(vis2[kind[v]]) + continue; + if(dis[v]>dis[u]+g[i].w) + { + dis[v]=dis[u]+g[i].w; + pre[v]=u; + if(!vis1[v]) + { + vis1[v]=1; + que.push(v); + } + } + } + } +} +bool check() +{ + for(int i=0;i1) + return false; + return true; +} +bool dfs(int u,int now,int limit,int t) +{ + if(now>limit) + return false; + if(u==t) + return true; + spfa(u,t,0); + if(now+dis[t]>limit) + return false; + int i,v; + for(i=adj[u];i!=-1;i=g[i].next) + { + v=g[i].v; + if(vis2[kind[v]]) + continue; + vis2[kind[v]]=1; + if(dfs(v,now+g[i].w,limit,t)) + return true; + vis2[kind[v]]=0; + } + return false; +} +void solve(int s,int t,int sum) +{ + int l=1,r=sum,ans=-1,mid; + while(l<=r) + { + mid=(l+r)>>1; + memset(vis2,0,sizeof(vis2)); + vis2[kind[s]]=1; + if(dfs(s,0,mid,t)) + { + ans=mid; + r=mid-1; + } + else + l=mid+1; + } + printf("%d\n",ans); +} +inline int nextInt() +{ + int res = 0; char ch; + bool neg = false; + while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-'); + if (ch == '-') neg = true; + else res = ch - '0'; + while (ch = getchar(), ch >= '0' && ch <= '9') res = res * 10 + ch - '0'; + if (neg) res = - res; + return res; +} +int main() +{ + int i,j,k,T,s,t,sum=0; + scanf("%d",&T); + while(T--) + { + scanf("%d%d%d%d",&n,&m,&s,&t); + memset(adj,-1,sizeof(adj)); + e=0; + while(m--) + { + i=nextInt(); j=nextInt(); k=nextInt(); + add(i,j,k); add(j,i,k); + sum+=k; + } + for(i=0;i +#include +#include +using namespace std; +#define MIN(x,y) (xdep-d) break; + } + if(cnt+ddep-d) break; + } + if(cnt+ddep-d) break; + } + if(cnt+d +#include +#include +#include +#include +#include +using namespace std; +char s[200000]; +int main() +{ + int t; + __int64 n,m,i,j,ans,carry; + scanf("%d",&t); + while(t--) + { + scanf("%s %I64d",s,&m); + n=0; + for(i=0;s[i];i++) + { + n=n*10+s[i]-'0'; + if(n>=m) + { + n=m-1; + break; + } + } + ans=1; + carry=1; + for(i=1;i<=n;i++) + { + carry=(carry*i)%m; + ans=(ans+carry)%m; + } + printf("%I64d\n",ans%m); + } + return 0; +} diff --git a/HDOJ/3124_autoAC.cpp b/HDOJ/3124_autoAC.cpp new file mode 100644 index 0000000..45ef59e --- /dev/null +++ b/HDOJ/3124_autoAC.cpp @@ -0,0 +1,113 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +#define left Left +#define right Right +#define eps 1e-8 +#define maxn 60000 +double x[maxn],y[maxn],r[maxn]; +int left[maxn],right[maxn],up[maxn],rank_up[maxn]; +int n; +set my_set; +double mid; +bool cmp_left(const int &a,const int &b) +{ + return x[a]-r[a] < x[b]-r[b]; +} +bool cmp_right(const int &a,const int &b) +{ + return x[a]+r[a] < x[b]+r[b]; +} +bool cmp_up(const int &a,const int &b) +{ + if(y[a]==y[b]) + return x[a] < x[b]; + else return y[a] < y[b]; +} +double my_sqr(double a) +{ + return a*a; +} +bool is_cross(int a,int b) +{ + a=up[a],b=up[b]; + double t1,t2; + t1=my_sqr(x[a]-x[b])+my_sqr(y[a]-y[b]),t2=my_sqr(r[a]+r[b]+mid+mid); + if(t1<=t2) + return true; + return false; +} +bool insert(int a) +{ + set::iterator it=my_set.insert(a).first; + if(it!=my_set.begin()) + { + if(is_cross(a,*--it)) + return true; + it++; + } + if(++it!=my_set.end()) + { + if(is_cross(a,*it)) + return true; + } + return false; +} +bool is_ok() +{ + my_set.clear(); + int i=0,j=0; + while(i +#include +#include +#include +int Check(char s[]) +{ + int i,len; + len=strlen(s); + if(s[0]=='\\'||s[0]=='/') + { + return (1); + } + for(i=0;i +#include +#include +#include +#include +using namespace std; +typedef double db; +const db eps=1e-7; +const int MAXN=1005; +const int MAXM=100005; +const int INF=0x3f3f3f3f; +struct Edge +{ + int to,next,cap,flow; +}edge[MAXM]; +int tol,head[MAXN]; +int gap[MAXN],dep[MAXN],pre[MAXN],cur[MAXN]; +void init() +{ + tol=0; + memset(head,-1,sizeof(head)); +} +void addedge(int u,int v,int w,int rw=0) +{ + edge[tol].to=v; + edge[tol].cap=w; + edge[tol].next=head[u]; + edge[tol].flow=0; + head[u]=tol++; + edge[tol].to=u; + edge[tol].cap=rw; + edge[tol].next=head[v]; + edge[tol].flow=0; + head[v]=tol++; +} +int sap(int st,int ed,int N) +{ + memset(gap,0,sizeof(gap)); + memset(dep,0,sizeof(dep)); + memcpy(cur,head,sizeof(head)); + int u=st; + pre[u]=-1; + gap[0]=N; + int ans=0; + while(dep[st]edge[i].cap-edge[i].flow) + Min=edge[i].cap-edge[i].flow; + for(int i=pre[u];i!=-1;i=pre[edge[i^1].to]) + { + edge[i].flow+=Min; + edge[i^1].flow-=Min; + } + u=st; + ans+=Min; + continue; + } + bool flag=0; + int v; + for(int i=cur[u];i!=-1;i=edge[i].next) + { + v=edge[i].to; + if(edge[i].cap-edge[i].flow && dep[v]+1==dep[u]) + { + flag=1; + cur[u]=pre[v]=i; + break; + } + } + if(flag) + { + u=v; + continue; + } + int Min=N; + for(int i=head[u];i!=-1;i=edge[i].next) + if(edge[i].cap-edge[i].flow && dep[edge[i].to]=0 && t<=1) + { + result=L.s+(L.e-L.s)*t; + } + else + { + if((P-L.s).len()<(P-L.e).len())result=L.s; + else result=L.e; + } + return result; +} +struct Circle +{ + Point o; + db r; + Circle(){} + Circle(Point _o,db _r):o(_o),r(_r){} +}c[205],tr[205]; +int v[205]; +vector >e; +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + int n,m,k; + scanf("%d%d%d",&n,&m,&k); + int Max=0; + for(int i=1;i<=n;i++) + scanf("%lf%lf%lf%d",&c[i].o.x,&c[i].o.y,&c[i].r,&v[i]); + for(int i=1;i<=m;i++) + scanf("%lf%lf",&p[i].x,&p[i].y); + for(int i=1;i<=k;i++) + scanf("%lf%lf%lf",&tr[i].o.x,&tr[i].o.y,&tr[i].r); + for(int i=1;i<=n;i++) + Max=max(Max,v[i]); + e.clear(); + for(int i=1;i<=n;i++) + for(int j=1;j<=m;j++) + if((c[i].o-p[j]).len()>1; + init(); + for(int i=1;i<=n;i++) + addedge(0,i,tt/v[i]+1); + for(int i=0;i<(int)e.size();i++) + addedge(e[i].first,e[i].second,1); + for(int i=1;i<=m;i++) + addedge(n+i,n+m+1,1); + if(sap(0,n+m+1,n+m+2) +#include +#include +using namespace std; +struct node +{ + int x,y,v; +}a[20]; +int dp[1005][1005]; +int main() +{ + int i,j,k,n,X,Y,t; + scanf("%d",&t); + while(t--) + { + scanf("%d%d%d",&n,&X,&Y); + for(i = 0;i=a[k].x && j>=a[k].y) + dp[i][j] = max(dp[i][j],max((dp[i-a[k].x][j]+dp[a[k].x][j-a[k].y]),(dp[i][j-a[k].y]+dp[i-a[k].x][a[k].y]))+a[k].v); + if(i>=a[k].y && j>=a[k].x) + dp[i][j] = max(dp[i][j],max((dp[i-a[k].y][j]+dp[a[k].y][j-a[k].x]),(dp[i][j-a[k].x]+dp[i-a[k].y][a[k].x]))+a[k].v); + } + } + } + printf("%d\n",dp[X][Y]); + } + return 0; +} diff --git a/HDOJ/3128_autoAC.cpp b/HDOJ/3128_autoAC.cpp new file mode 100644 index 0000000..c899e9f --- /dev/null +++ b/HDOJ/3128_autoAC.cpp @@ -0,0 +1,36 @@ +#include +#include +int main() +{ + double n, m; + char s[17]; + double time; + while(~scanf("%lf%lf",&n,&m)) + { + double sum1 = 0; + double sum2 = 0; + double v1 = 0; + double v2 = 0; + for(int i = 0; i < 20; i++) + { + scanf("%s%lf",s,&time); + if(s[0]=='A' || s[0]=='a') + { + sum1 += time; + v1 += n/time; + } + else + { + sum2 += time; + v2 += m/time; + } + } + printf("Method 1\n"); + printf("African: %.2lf furlongs per hour\n",n*10.0/sum1); + printf("European: %.2lf furlongs per hour\n",m*10.0/sum2); + printf("Method 2\n"); + printf("African: %.2lf furlongs per hour\n",v1/10.0); + printf("European: %.2lf furlongs per hour\n",v2/10.0); + } + return 0; +} diff --git a/HDOJ/3129_autoAC.cpp b/HDOJ/3129_autoAC.cpp new file mode 100644 index 0000000..05a624e --- /dev/null +++ b/HDOJ/3129_autoAC.cpp @@ -0,0 +1,45 @@ +#include +#include +#include +#include +using namespace std; +int main() +{ + char s[1017]; + int tt = 0; + while(gets(s)) + { + tt++; + int len = strlen(s); + for(int i = 0; i < len; i++) + { + if(i == 0 && tt > 1) + { + while(s[i]==' ' || s[i]=='(' || s[i]==')') + { + i++; + if(i >= len) + break; + } + s[i] = toupper(s[i]); + } + else if(s[i]=='.' || s[i]=='!' || s[i]=='?') + { + i++; + while(s[i]==' ' || s[i]=='(' || s[i]==')') + { + i++; + if(i >= len) + break; + } + s[i] = toupper(s[i]); + } + else + { + s[i] = tolower(s[i]); + } + } + printf("%s\n",s); + } + return 0; +} diff --git a/HDOJ/3130_autoAC.cpp b/HDOJ/3130_autoAC.cpp new file mode 100644 index 0000000..db020d0 --- /dev/null +++ b/HDOJ/3130_autoAC.cpp @@ -0,0 +1,20 @@ +#include +#include +int main() +{ + for(int i = 100; i <= 999; i++) + { + for(int j = 100; j <= 999; j++) + { + int t1 = (i-i%10)/10; + int t2 = j-j/100*100; + int x1 = i%10; + int x2 = j/100; + if(x1==x2 && i/(j*1.0)==t1/(t2*1.0) && i != j) + { + printf("%d / %d = %d / %d\n",i,j,t1,t2); + } + } + } + return 0; +} diff --git a/HDOJ/3131_autoAC.cpp b/HDOJ/3131_autoAC.cpp new file mode 100644 index 0000000..efcb5ec --- /dev/null +++ b/HDOJ/3131_autoAC.cpp @@ -0,0 +1,94 @@ +#include +#include +#include +#include +#define LL __int64 +using namespace std; +LL a[20],cnt,k; +map ans; +map::iterator it; +bool cmp(LL a,LL b) +{ + return a>b; +} +LL cal(LL sum,LL temp,LL op) +{ + if(op==0) + return sum+temp; + if(op==1) + return sum-temp>0? sum-temp:temp-sum; + if(op==2) + return sum*temp; + if(op==3) + return sum/temp; +} +void dfs(LL x,LL sum) +{ + if(x==cnt) + { + LL tempsum=sum; + while(tempsum) + { + if(tempsum%10==3) + { + ans[sum]++; + k++; + break; + } + tempsum/=10; + } + return ; + } + for(LL i=0;i<4;i++) + { + if(i==3 && a[x]==0) + continue; + LL temp=cal(sum,a[x],i); + dfs(x+1,temp); + } +} +int main() +{ + char s[100]; + LL len,i; + while(gets(s)) + { + if(s[0]=='#') + break; + ans.clear(); + len=strlen(s); + LL temp; + cnt=temp=0; + for(i=0;isecond)) + { + maxt=it->second; + maxans=it->first; + if((it->first)>maxans) + maxans=it->first; + } + } + printf("%I64d\n",maxans); + } + else + printf("No result\n"); + } + return 0; +} diff --git a/HDOJ/3132_autoAC.cpp b/HDOJ/3132_autoAC.cpp new file mode 100644 index 0000000..83454b5 --- /dev/null +++ b/HDOJ/3132_autoAC.cpp @@ -0,0 +1 @@ +0.00 to 365.25: 2099.8021 diff --git a/HDOJ/3134_autoAC.cpp b/HDOJ/3134_autoAC.cpp new file mode 100644 index 0000000..14e91ed --- /dev/null +++ b/HDOJ/3134_autoAC.cpp @@ -0,0 +1,68 @@ +#include +#include +#include +#include +using namespace std; +const double EPS = 1e-3; +const double PAI = 4 * atan(1.0); +const float FLOAT_MAX = 1.0e38, FLOAT_MIN = -1.0e38; +const double DOUBLE_MAX = 1.79e308, DOUBLE_MIN = -1.79e308; +const int N = 3005; +struct node{ + int x, y, z, id; +}; +node a[N]; +int f[N]; +int n, l; +void add(int x, int y, int z, int id){ + a[l].x = x; + a[l].y = y; + a[l].z = z; + a[l].id = id; + l++; +} +void input(){ + int i, x, y, z; + l = 0; + add(-1,-1, -1, 0); + for(i = 1; i <= n; i++){ + scanf("%d x %d x %d", &x, &y, &z); + add(x,y,z,i); + add(x,z,y,i); + add(y,x,z,i); + add(y,z,x,i); + add(z,x,y,i); + add(z,y,x,i); + } +} +bool cmp(const node &a, const node &b){ + if(a.x != b.x) + return a.x < b.x; + if(a.y != b.y) + return a.y < b.y; + return a.z < b.z; +} +void solve() +{ + int i,j, res; + sort(a, a+1, cmp); + res = 0; + f[0] = 0; + for(i = 1; i < l; i++) + { + f[i] = 1; + for(j = 1; j < i; j++) + if(a[i].id != a[j].id && a[j].x < a[i].x && a[j].y < a[i].y && a[j].z < a[i].z) + f[i] = max(f[i],f[j]+1); + res = max(res, f[i]); + } + printf("%d\n", res); +} +int main() +{ + while(scanf("%d", &n) && n != -1){ + input(); + solve(); + } + return 0; +} diff --git a/HDOJ/3137_autoAC.cpp b/HDOJ/3137_autoAC.cpp new file mode 100644 index 0000000..196b3cd --- /dev/null +++ b/HDOJ/3137_autoAC.cpp @@ -0,0 +1,10 @@ +XXXXXXXXXXXXXX +X XXX +X XFXXXXX X +XXX XX XX X +X S X +XX XXXXXX X X +X X X X +X X X X X +XXX XX X +XXXXXXXXXXXXXX diff --git a/HDOJ/3138_autoAC.cpp b/HDOJ/3138_autoAC.cpp new file mode 100644 index 0000000..c2492c0 --- /dev/null +++ b/HDOJ/3138_autoAC.cpp @@ -0,0 +1,132 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#include +#include +#include +#include +#include +#define cler(arr, val) memset(arr, val, sizeof(arr)) +typedef long long LL; +const int MAXN = 543; +const int MAXM = 260110; +const int INF = 0x3f3f3f3f; +const int mod = 1000000007; +struct Edge +{ + int to,next,cap,flow; +}edge[MAXM]; +int tol; +int head[MAXN]; +int gap[MAXN],dep[MAXN],pre[MAXN],cur[MAXN]; +void init() +{ + tol = 0; + memset(head,-1,sizeof (head)); +} +void addedge (int u,int v,int w,int rw=0) +{ + edge[tol].to = v;edge[tol].cap = w;edge[tol].next = head[u]; + edge[tol].flow = 0;head[u] = tol++; + edge[tol].to = u;edge[tol].cap = rw;edge[tol]. next = head[v]; + edge[tol].flow = 0;head[v]=tol++; +} +int sap(int start,int end, int N) +{ + memset(gap,0,sizeof(gap)); + memset(dep,0,sizeof(dep)); + memcpy(cur,head,sizeof(head)); + int u = start; + pre[u] = -1; + gap[0] = N; + int ans = 0; + int i; + while(dep[start] < N) + { + if(u == end) + { + int Min = INF; + for( i = pre[u];i != -1; i = pre[edge[i^1]. to]) + { + if(Min > edge[i].cap - edge[i]. flow) + Min = edge[i].cap - edge[i].flow; + } + for( i = pre[u];i != -1; i = pre[edge[i^1]. to]) + { + edge[i].flow += Min; + edge[i^1].flow -= Min; + } + u = start; + ans += Min; + continue; + } + bool flag = false; + int v; + for( i = cur[u]; i != -1;i = edge[i].next) + { + v = edge[i]. to; + if(edge[i].cap - edge[i].flow && dep[v]+1 == dep[u]) + { + flag = true; + cur[u] = pre[v] = i; + break; + } + } + if(flag) + { + u = v; + continue; + } + int Min = N; + for( i = head[u]; i != -1;i = edge[i]. next) + { + if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min) + { + Min = dep[edge[i].to]; + cur[u] = i; + } + } + gap[dep[u]]--; + if(!gap[dep[u]]) return ans; + dep[u] = Min+1; + gap[dep[u]]++; + if(u != start) u = edge[pre[u]^1].to; + } + return ans; +} +int n,m,s,e; +void build() +{ + init(); + s=n+1,e=n+2; + int u,v,w; + for(int i=1;i<=n;i++) + { + scanf("%d",&w); + if(w==0) + addedge(s,i,1); + else + addedge(i,e,1); + } + for(int i=1;i<=m;i++) + { + scanf("%d%d",&u,&v); + addedge(u,v,1); + addedge(v,u,1); + } +} +int main() +{ + while(scanf("%d%d",&n,&m),n+m) + { + build(); + printf("%d\n",sap(s,e,n+2)); + } + return 0; +} diff --git a/HDOJ/3139_autoAC.cpp b/HDOJ/3139_autoAC.cpp new file mode 100644 index 0000000..3fb2776 --- /dev/null +++ b/HDOJ/3139_autoAC.cpp @@ -0,0 +1,9 @@ +#include +int main(){ + int a,e,f,c,b; + while(~scanf("%d%d%d",&e,&f,&c)){ + for(a=e+f,b=0;a>=c;a=a%c+a/c) + b+=a/c; + printf("%d\n",b); + } +} diff --git a/HDOJ/3143_autoAC.cpp b/HDOJ/3143_autoAC.cpp new file mode 100644 index 0000000..fc18db6 --- /dev/null +++ b/HDOJ/3143_autoAC.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include +using namespace std; +const int N = 100+5; +int head[N],cnt,n,e,p,d; +#define pc 160 +#define eps 1e-8 +#define INF 0x3f3f3f3f +double dist1[N],dist2[N]; +bool out[N]; +struct edges +{ + int u,cost,next; + edges(){} + edges(int a,int b,int c):u(a),cost(b),next(c){} +}edge[N*N]; +void init(){ + memset(head,-1,sizeof(head)); + memset(out,0,sizeof(out)); + cnt = 0; +} +void add_edge(int a,int b,int c){ + edge[cnt] = edges(b,c,head[a]); + head[a] = cnt++; +} +bool inQue[N]; +queueque; +void spfa(double dist[],int src) +{ + for(int i = 1; i <= n; ++i) dist[i] = INF,inQue[i] = 0; + while(!que.empty()) que.pop(); + que.push(src); + dist[src] = 0; + inQue[src] = true; + while(!que.empty()) + { + int u = que.front();que.pop(); + for(int i = head[u]; i + 1 ; i =edge[i].next) + { + int v = edge[i].u; + int val = edge[i].cost; + if(src == p && v == d) continue; + if(dist[u] + val < dist[v]) + { + dist[v] = dist[u] + val; + if(!inQue[v]) que.push(v),inQue[v] = true; + } + } + inQue[u] = false; + } +} +queueqq; +bool has[N]; +bool bfs(double vi) +{ + while(!qq.empty()) qq.pop(); + qq.push(p); + for(int i = 1; i <= n; ++i) has[i] = 0; + while(!qq.empty()) + { + int u = qq.front(); + if(out[u]) return true; + qq.pop(); + for(int i = head[u]; i + 1; i = edge[i].next) + { + int v = edge[i].u; + if(has[v]||dist1[v]*pc>=dist2[v]*vi) continue; + qq.push(v); + has[v] = 1; + } + } + return false; +} +int main() +{ + int m; + while(scanf("%d%d%d",&n,&m,&e)!=EOF) + { + init(); + for(int i = 0,x,y,z; i < m; ++i) + { + scanf("%d%d%d",&x,&y,&z); + add_edge(x,y,z); + add_edge(y,x,z); + } + for(int i = 0; i < e; ++i) scanf("%d",&p),out[p]=1; + scanf("%d%d",&p,&d); + spfa(dist1,p); + spfa(dist2,d); + double left = 0,right = INF,ans = -1; + while(left+eps +#include +#include +#include +#include +using namespace std; +map s; +map::iterator it; +double eps=1e-10; +int n,m; +const double pi=acos(-1.0); +int fa[1001],x[1001],y[1001],cx[1001],cy[1001],r[1001]; +struct Eve +{ + double ang; + int id,L,f; + bool operator<(const Eve &b)const + { + if(fabs(ang-b.ang)>eps)return angb.f; + } +}p[8001]; +int find(int x) +{ + if(x==fa[x])return x; + return fa[x]=find(fa[x]); +} +void U(int i,int j) +{ + fa[find(i)]=find(j); +} +int main() +{ + while(~scanf("%d%d",&n,&m)) + { + for(int i=0;ifirst>p[j].L)U(i,p[j].id); + } + } + else if(p[j].f==1) + { + s[p[j].L]++; + ++tot; + } + else + { + s[p[j].L]--; + if(s[p[j].L]==0)s.erase(p[j].L); + --tot; + } + } + } + int cnt=0; + for(int i=0;i +#include +#include +#include +#include +using namespace std; +#define maxn 10010 +#define maxm 1000010 +#define inf 0x3f3f3f3f +char table[11][11]; +int row[333], col[333]; +void change(char &c1, char &c2){ + if(row[c1] == row[c2]) + c1 = table[row[c1]][col[c1]+1], c2 = table[row[c2]][col[c2]+1]; + else if(col[c1] == col[c2]) + c1 = table[row[c1]+1][col[c1]], c2 = table[row[c2]+1][col[c2]]; + else{ + int r1 = row[c1], co1 = col[c1]; + int r2 = row[c2], co2 = col[c2]; + c1 = table[r1][co2], c2 = table[r2][co1]; + } +} +void update(char c, int &x, int &y){ + table[x][y] = c; + row[c] = x; + col[c] = y; + y++; + if(y == 6) + x++, y = 1; +} +int main() +{ + int t; + char s[2222]; + while(gets(s)){ + memset(table, 0, sizeof(table)); + memset(row, 0, sizeof(row)); + memset(col, 0, sizeof(col)); + int curi = 1, curj = 1; + int l1 = strlen(s); + for(int i = 0; i < l1; ++i){ + if(s[i] == 'q' || s[i] <'a' || s[i] >'z') + continue; + if(row[s[i]] == 0){ + update(s[i],curi, curj); + } + } + if(curi < 6) + for(int i = 0; i < 26; ++i) + if(row['a'+i] == 0 && 'a' + i != 'q') + update('a'+i, curi, curj); + for(int j = 1; j <= 5; ++j) + table[6][j] = table[1][j]; + for(int i = 1; i <= 5; ++i) + table[i][6] = table[i][1]; + char c1 = 0, c2 = 0; + gets(s); + int l = 0, r = strlen(s); + while(l'z'){ + l++; + continue; + } + if(c1 == 0){ + c1 = s[l++]; + continue; + } + if(c1 && c1 !=s[l]) + c2 = s[l++]; + else if(c1) + c2 = 'x'; + change(c1, c2); + printf("%c%c", c1-'a'+'A', c2-'a'+'A'); + c1 = c2 = 0; + } + if(c1){ + c2 = 'x'; + change(c1, c2); + printf("%c%c", c1-'a'+'A', c2-'a'+'A'); + } + puts(""); + } + return 0; +} diff --git a/HDOJ/3150_autoAC.cpp b/HDOJ/3150_autoAC.cpp new file mode 100644 index 0000000..56b7b82 --- /dev/null +++ b/HDOJ/3150_autoAC.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +mapmm; +int main() +{ + string name[117]; + int t; + int n; + int cas = 0; + scanf("%d",&t); + while(t--) + { + scanf("%d",&n); + mm.clear(); + for(int i = 0; i < n; i++) + { + cin>>name[i]; + } + int m; + scanf("%d",&m); + char s[1000]; + string ss=""; + for(int i = 0; i < m; i++) + { + getchar(); + gets(s); + for(int j = 0; j < strlen(s); j++) + { + if(s[j]==' ') + { + mm[ss]++; + ss=""; + continue; + } + ss+=s[j]; + } + mm[ss]++; + ss=""; + } + printf("Test set %d:\n",++cas); + for(int i = 0 ; i < n; i++) + { + if(mm[name[i]]) + { + cout< +#include +#include +#include +#include +using namespace std; +#define INF 1000000000 +const double eps = 1e-8; +const double pi = acos(-1.0); +int cmp(double x) +{ + if (fabs(x) < eps) return 0; + if (x > 0) return 1; + return -1; +} +inline double sqr(double x){return x*x;} +struct point +{ + double x,y; + point(){} + point(double a,double b):x(a),y(b){} + void input() + { + scanf("%lf%lf",&x,&y); + } + friend point operator + (const point &a, const point &b) + { + return point(a.x+b.x, a.y+b.y); + } + friend point operator - (const point &a, const point &b) + { + return point(a.x-b.x, a.y-b.y); + } + friend bool operator == (const point &a, const point &b) + { + return cmp(a.x-b.x)==0 && cmp(a.y-b.y)==0; + } + friend point operator * (const point &a, const double &b) + { + return point(a.x*b, a.y*b); + } + friend point operator * (const double &a, const point &b) + { + return point(a*b.x, a*b.y); + } + friend point operator / (const point &a, const double &b) + { + return point(a.x/b, a.y/b); + } + bool operator<(const point& a)const + { + if (cmp(x-a.x)!=0) return x con[110]; +double dis[110][110]; +int fa[110]; +int get_fa(int x) +{ + if (fa[x] == x) return x; + fa[x] = get_fa(fa[x]); + return fa[x]; +} +void merge(int x,int y) +{ + x=get_fa(x);y=get_fa(y); + fa[x] = y; +} +bool check(double d) +{ + for (int i=0; ieps) + { + mid=(L+r)/2.0; + if (check(mid)) L=mid; + else r=mid; + } + if (cmp(L)>0) printf("%.2lf\n",L/2.0); + else printf("impossible\n"); + } + return 0; +} diff --git a/HDOJ/3152_autoAC.cpp b/HDOJ/3152_autoAC.cpp new file mode 100644 index 0000000..c5fbe51 --- /dev/null +++ b/HDOJ/3152_autoAC.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#define maxn 125+5 +using namespace std; +int n; +int casee=1; +int mapp[maxn][maxn]; +int visit[maxn][maxn]; +int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}}; +struct stu +{ + int x,y; + int sum; + friend bool operator<(stu x,stu y) + { + return x.sum>y.sum; + } +}; +void bfs() +{ + stu x,y; + priority_queueroot; + x.x=0; + x.y=0; + x.sum=mapp[0][0]; + visit[0][0]=1; + root.push(x); + while(root.size()) + { + x=root.top(); + root.pop(); + if(x.x==n-1&&x.y==n-1){cout<<"Problem "<=n||y.y<0||y.y>=n||visit[y.x][y.y]){continue;} + y.sum=x.sum+mapp[y.x][y.y]; + root.push(y); + visit[y.x][y.y]=1; + } + } +} +int main() +{ + while(cin>>n&&n) + { + for(int i=0;i>mapp[i][j]; + } + } + memset(visit,0,sizeof(visit)); + bfs(); + } + return 0; +} diff --git a/HDOJ/3153_autoAC.cpp b/HDOJ/3153_autoAC.cpp new file mode 100644 index 0000000..5ee9b9d --- /dev/null +++ b/HDOJ/3153_autoAC.cpp @@ -0,0 +1,5 @@ +Case n: +nn pencils for nn cents +nn at four cents each +nn at two for a penny +nn at four for a penny diff --git a/HDOJ/3154_autoAC.cpp b/HDOJ/3154_autoAC.cpp new file mode 100644 index 0000000..ff1f37d --- /dev/null +++ b/HDOJ/3154_autoAC.cpp @@ -0,0 +1,109 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +typedef pairPII; +typedef pairPII2; +PII in[20]; +int n; +int maxSolve = 0, minnTime; +PII order[20]; +PII ans[20]; +void search(int a, int b, int c, int at, int t) +{ + if(a > 300) return ; + if(b > 300) return ; + if(c > 300) return ; + if(at > maxSolve) + { + maxSolve = at; + minnTime = t; + for(int i = 0; i < at; i++ ) + ans[i] = order[i]; + } + else if(at == maxSolve) + { + if(t < minnTime) + { + minnTime = t; + for(int i = 0; i < at; i++ ) + ans[i] = order[i]; + } + else if(t == minnTime) + { + sort(ans, ans + maxSolve); + PII temp[20]; + for(int i = 0; i < maxSolve; i++ ) temp[i] = order[i]; + sort(temp, temp + maxSolve); + int swap = 0; + for(int i = 0; i < maxSolve; i++ ) + { + if(temp[i].second < ans[i].second) + { + swap = 1; + break; + } + else if(temp[i].second > ans[i].second) + { + break; + } + } + if(swap) + { + for(int i = 0; i < maxSolve; i++ ) ans[i] = temp[i]; + } + } + } + if(at == n) return ; + order[at] = PII(a + in[at].first, in[at].second); + search(a + in[at].first, b, c, at + 1, t + a + in[at].first); + order[at] = PII(b + in[at].first, in[at].second); + search(a, b + in[at].first, c, at + 1, t + b + in[at].first); + order[at] = PII(c + in[at].first, in[at].second); + search(a, b, c + in[at].first, at + 1, t + c + in[at].first); +} +class Solve +{ + public: + void main2() + { + cin >> n; + for(int i = 0; i < n; i++ ) + { + cin >> in[i].first; + in[i].second = 'A' + i; + } + sort(in, in + n); + maxSolve = 1; + minnTime = in[0].first; + order[0] = PII(in[0].first, in[0].second); + search(in[0].first, 0, 0, 1, in[0].first); + sort(ans, ans + maxSolve); + for(int i = 0; i < maxSolve; i++ ) printf("%c ", ans[i].second); + printf("%d %d\n", maxSolve, minnTime); + } +}; +int main() +{ + int Test; + scanf("%d", &Test); + for(int t = 1; t <= Test; t++ ) + { + Solve ___test; + printf("Data set %d: ", t); + ___test.main2(); + } +return 0; +} diff --git a/HDOJ/3155_autoAC.cpp b/HDOJ/3155_autoAC.cpp new file mode 100644 index 0000000..0152a74 --- /dev/null +++ b/HDOJ/3155_autoAC.cpp @@ -0,0 +1,112 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +typedef pairPII; +typedef pairPII2; +string s; +int n; +int len; +mapval; +int value[20]; +int at; +int good; +int eva() +{ + // cout << at << " " << s[at] << endl; + if(good != 1) return 0; + if(at >= len) + { + good = -2; + } + else if(s[at] >= 'a' && s[at] <= 'z') + { + return value[val[s[at++]]]; + } + else if(s[at] >= 'A' && s[at] <= 'Z') + { + at++; + int x, y; + switch(s[at - 1]) + { + case 'C': x = eva(); y = eva(); if(x && !y) return 0; else return 1; + case 'N': x = eva(); return x ^ 1; + case 'K': x = eva(); y = eva(); return x & y; + case 'A': x = eva(); y = eva(); return x | y; + case 'D': x = eva(); y = eva(); return !(x & y); + case 'E': x = eva(); y = eva(); return (x == y); + case 'J': x = eva(); y = eva(); return x ^ y; + default: good = -1; break; + } + } + else + { + good = -1; + } +} +int main() +{ + while(cin >> s) + { + good = 1; + len = s.length(); + n = 0; + val.clear(); + for(int i = 0; i < len; i++ ) + { + if(s[i] >= 'a' && s[i] <= 'z' && val.find(s[i]) == val.end()) + { + val[s[i]] = n++; + } + } + int ct = 0, cn = 0; + for(int i = 0; i < 1< +#include +#include +#include +const int CCC=20; +const int RR=400; +const int V=8000; +const double eps=1e-7; +const int N=65550; +bool hash[N]; +int st[N]; +const double pi = acos(-1.0); +int U[V],D[V]; +int L[V],R[V]; +int C[V]; +int size,S[CCC],H[RR],n,m; +int dir[17]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536}; +struct node{ + double x,y; +}s[20]; +struct point{ + double x,y; +}cnt,cnt1; +double Dis(point a,point b){ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); +} +point Whirl(double cosl, double sinl, point a, point b) +{ + b.x -= a.x; b.y -= a.y; + point c; + c.x = b.x * cosl - b.y * sinl + a.x; + c.y = b.x * sinl + b.y * cosl + a.y; + return c; +} +point inst(point u1,point u2,point v1,point v2) +{ + point ans = u1; + double t = ((u1.x - v1.x)*(v1.y - v2.y) - (u1.y - v1.y)*(v1.x - v2.x))/ + ((u1.x - u2.x)*(v1.y - v2.y) - (u1.y - u2.y)*(v1.x - v2.x)); + ans.x += (u2.x - u1.x)*t; + ans.y += (u2.y - u1.y)*t; + return ans; +} +point fun(point a,point b,double r) +{ + double l=Dis(a,b); + double ans=acos((l/2)/r); + point k1=Whirl(cos(ans),sin(ans),a,b); + point k2=Whirl(cos(ans),-sin(ans),b,a); + point cent=inst(a,k1,b,k2); + return cent; +} +void Link(int r,int c) +{ + S[c]++;C[size]=c; + U[size]=U[c];D[U[c]]=size; + D[size]=c;U[c]=size; + if(H[r]==-1) H[r]=L[size]=R[size]=size; + else + { + L[size]=L[H[r]];R[L[H[r]]]=size; + R[size]=H[r];L[H[r]]=size; + } + size++; +} +void remove(int c) +{ + int i; + for(i=D[c];i!=c;i=D[i]) + L[R[i]]=L[i],R[L[i]]=R[i]; +} +void resume(int c) +{ + int i; + for(i=U[c];i!=c;i=U[i]) + L[R[i]]=R[L[i]]=i; +} +int h() +{ + int i,j,k,count=0; + bool visit[20]; + memset(visit,0,sizeof(visit)); + for(i=R[0];i;i=R[i]) + { + if(visit[i]) continue; + count++; + visit[i]=1; + for(j=D[i];j!=i;j=D[j]) + { + for(k=R[j];k!=j;k=R[k]) + visit[C[k]]=1; + } + } + return count; +} +int Dance(int k) +{ + int i,j,Min,c; + if(k+h()>m) return 0; + if(!R[0]) return 1; + for(Min=RR,i=R[0];i;i=R[i]) + if(S[i]=left) + { + for(i=0;i<=n;i++) + { + S[i]=0; + U[i]=D[i]=i; + L[i+1]=i;R[i]=i+1; + }R[n]=0; + size=n+1; + memset(H,-1,sizeof(H)); + memset(hash,0,sizeof(hash)); + mid=(left+right)/2; + r=0; + sum=0; + for(i=1;i<=n;i++) + { + ansx=s[i].x;ansy=s[i].y; + bit=0; + for(j=1;j<=n;j++) + if(dis(s[j].x,s[j].y,ansx,ansy)<=mid) bit+=dir[j-1]; + if(!hash[bit]) {hash[bit]=1;st[++sum]=bit;} + } + for(i=1;i<=n;i++) + { + for(j=i+1;j<=n;j++) + { + num=dis(s[i].x,s[i].y,s[j].x,s[j].y); + if(num<2*mid) + { + a.x=s[i].x;a.y=s[i].y; + b.x=s[j].x;b.y=s[j].y; + cnt=fun(a,b,mid); + ansx=(a.x+b.x)/2; + ansy=(a.y+b.y)/2; + cnt1.x=2*ansx-cnt.x; + cnt1.y=2*ansy-cnt.y; + bit=0; + for(k=1;k<=n;k++) + { + if(k==i) {bit+=dir[i-1];continue;} + if(k==j) {bit+=dir[j-1];continue;} + if(dis(s[k].x,s[k].y,cnt.x,cnt.y)<=mid) bit+=dir[k-1]; + } + if(!hash[bit]) {hash[bit]=1;st[++sum]=bit;} + bit=0; + for(k=1;k<=n;k++) + { + if(k==i) {bit+=dir[i-1];continue;} + if(k==j) {bit+=dir[j-1];continue;} + if(dis(s[k].x,s[k].y,cnt1.x,cnt1.y)<=mid) bit+=dir[k-1]; + } + if(!hash[bit]) {hash[bit]=1;st[++sum]=bit;} + } + else if(num==2*mid) + { + ansx=(s[i].x+s[j].x)/2; + ansy=(s[i].y+s[j].y)/2; + bit=0; + for(k=1;k<=n;k++) + { + if(k==i) {bit+=dir[i-1];continue;} + if(k==j) {bit+=dir[j-1];continue;} + if(dis(s[k].x,s[k].y,ansx,ansy)<=mid) bit+=dir[k-1]; + } + if(!hash[bit]) {hash[bit]=1;st[++sum]=bit;} + } + } + } + qsort(st+1,sum,sizeof(st[1]),cmp); + for(i=sum;i>=1;i--) + { + for(j=1;j<=n;j++) + if(st[i]&dir[j-1]) hash[st[i]-dir[j-1]]=0; + if(hash[st[i]]==0) continue; + r++; + for(j=1;j<=n;j++) + if(st[i]&dir[j-1]) {Link(r,j);hash[dir[j-1]]=0;} + } + if(Dance(0)) {ans=mid;right=mid-eps;} + else left=mid+eps; + } + printf("%.6lf\n",ans); + } + return 0; +} diff --git a/HDOJ/3157_autoAC.cpp b/HDOJ/3157_autoAC.cpp new file mode 100644 index 0000000..a9fcc00 --- /dev/null +++ b/HDOJ/3157_autoAC.cpp @@ -0,0 +1,142 @@ +#include +#include +#include +#include +#include +#include +#include +#define inf 0x7fffffff +using namespace std; +const int maxn=600; +const int M = 100000+10; +struct Edge +{ + int to,cap,next; +}edge[M*2]; +int head[maxn],edgenum; +int n,m,from,to,vnum,s,t; +void add(int u,int v,int cap) +{ + edge[edgenum].to=v; + edge[edgenum].cap=cap; + edge[edgenum].next=head[u]; + head[u]=edgenum++; + edge[edgenum].to=u; + edge[edgenum].cap=0; + edge[edgenum].next=head[v]; + head[v]=edgenum++; +} +int level[maxn]; +int gap[maxn]; +void bfs(int to) +{ + memset(level,-1,sizeof(level)); + memset(gap,0,sizeof(gap)); + level[to]=0; + gap[level[to] ]++; + queue Q; + Q.push(to); + while (!Q.empty()) + { + int u=Q.front() ;Q.pop() ; + for (int i=head[u] ;i!=-1 ;i=edge[i].next) + { + int v=edge[i].to; + if (level[v] != -1) continue; + level[v]=level[u]+1; + gap[level[v] ]++; + Q.push(v); + } + } +} +int cur[maxn]; +int pre[maxn]; +int SAP(int from,int to) +{ + bfs(to); + memset(pre,-1,sizeof(pre)); + memcpy(cur,head,sizeof(head)); + int u=pre[from]=from,flow=0,aug=inf; + gap[from]=vnum; + while (level[from] +#include +#include +using namespace std; +const double dd = sqrt(2.0)/2*10; +int ti; +double x,y; +double d; +double dis(double x1, double y1, double x2, double y2) +{ + return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)); +} +void dfs(double x1,double y1,int dir,int tt) +{ + double aa; + dir %= 8; + aa=dis(x1,y1,x,y); + if(aa < d) + { + d = aa; + } + if(tt==ti ||(aa-10*(ti-tt)>d)) + { + return ; + } + if(dir == 0) + { + dfs(x1+10,y1,dir,tt+1); + } + else if(dir == 1) + { + dfs(x1+dd,y1-dd,dir,tt+1); + } + else if(dir == 2) + { + dfs(x1,y1-10,dir,tt+1); + } + else if(dir == 3) + { + dfs(x1-dd,y1-dd,dir,tt+1); + } + else if(dir == 4) + { + dfs(x1-10,y1,dir,tt+1); + } + else if(dir == 5) + { + dfs(x1-dd,y1+dd,dir,tt+1); + } + else if(dir == 6) + { + dfs(x1,y1+10,dir,tt+1); + } + else if(dir == 7) + { + dfs(x1+dd,y1+dd,dir,tt+1); + } + dfs(x1,y1,dir+1,tt+1); +} +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + scanf("%d%lf%lf",&ti,&x,&y); + d = dis(0,0,x,y); + dfs(0,0,0,0); + printf("%.6lf\n",d); + } + return 0; +} diff --git a/HDOJ/3159_autoAC.cpp b/HDOJ/3159_autoAC.cpp new file mode 100644 index 0000000..1a687e6 --- /dev/null +++ b/HDOJ/3159_autoAC.cpp @@ -0,0 +1,4 @@ +Digit 7 3 segments lit = 15 milliamps +Digit 9 6 segments lit = 30 milliamps +Digit 8 7 segments lit = 35 milliamps +Total = 80 milliamps diff --git a/HDOJ/3160_autoAC.cpp b/HDOJ/3160_autoAC.cpp new file mode 100644 index 0000000..dddad2e --- /dev/null +++ b/HDOJ/3160_autoAC.cpp @@ -0,0 +1,47 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN = 15+2; +int id[32786]; +char s[MAXN][MAXN]; +int gmax(int a,int b){return a>b?a:b;} +int gmin(int a,int b){return a>1] + (i&1); + } + while(scanf("%s",s[0])!=EOF){ + if(s[0][0]=='E') + return 0; + for(i=1; i<15; i++){ + scanf("%s",s[i]); + } + int ans = 15; + for(i=0; i<(1<<15); i++){ + int col[15]; + memset(col,0,sizeof(col)); + for(j=0; j<15; j++){ + if((i&(1< +#include +#include +#include +#include +#include +using namespace std; +double eps = 1e-8; +bool cal(double n){ + if(1-n < eps) + return true; + int inter; + double now, org = n; + while(1){ + inter = n * 3; + if(inter == 1) + return false; + n = n * 3 - inter; + if(fabs(org - n) < eps) + break; + } + return true; +} +int main() +{ + double n; + char temp[10]; + while(scanf("%s", temp) != EOF && temp[0] != 'E'){ + sscanf(temp, "%lf", &n); + if(cal(n)) + puts("MEMBER"); + else + puts("NON-MEMBER"); + } + return 0; +} diff --git a/HDOJ/3163_autoAC.cpp b/HDOJ/3163_autoAC.cpp new file mode 100644 index 0000000..d53ccc1 --- /dev/null +++ b/HDOJ/3163_autoAC.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +using namespace std; +template inline void checkmax(T &a, T b) +{if (b > a) a = b;} +template inline void checkmin(T &a, T b) +{if (b < a) a = b;} +inline double sqr(double x) +{return x * x;} +struct Point { + double x, y; +} pt[35]; +int n; +double tx, ty, v, c, sx, sy, dx, dy; +double get(double p) +{ + double cx = sx + dx * p; + double cy = sy + dy * p; + double cur = cy / v + sqrt(sqr(cx - tx) + sqr(cy - ty)) / c; + return cur; +} +int ansidx; +double ansp; +void work() +{ + for (int i = 1; i <= n; ++i) scanf("%lf%lf", &pt[i].x, &pt[i].y); + pt[n + 1] = pt[1]; + double ans = 1e9; + for (int i = 1; i <= n; ++i) { + dx = pt[i + 1].x - pt[i].x; + dy = pt[i + 1].y - pt[i].y; + sx = pt[i].x; + sy = pt[i].y; + for (int iter = 1; iter <= 35; ++iter) { + double p = 0; + for (double len = 1; len > 1e-9; len /= 1.5) for (int iter1 = 1; iter1 <= 35; ++iter1) { + if (rand() & 1) p += len; else p -= len; + checkmax(p, 0.0); + checkmin(p, 1.0); + double tmp = get(p); + if (tmp < ans) { + ans = tmp; + ansidx = i; + ansp = p; + } + } + } + } + double trueans = ans; + ansp -= 5000 * 1e-7; + for (int i = 0; i < 10000; ++i, ansp += 1e-7) { + dx = pt[ansidx + 1].x - pt[ansidx].x; + dy = pt[ansidx + 1].y - pt[ansidx].y; + sx = pt[ansidx].x; + sy = pt[ansidx].y; + if (ansp > -1e-7 && ansp < 1 + 1e-7) checkmin(trueans, get(ansp)); + } + printf("%0.4lf\n", trueans); +} +int main() +{ + while (scanf("%d%lf%lf%lf%lf", &n, &tx, &ty, &v, &c), n) work(); +} diff --git a/HDOJ/3164_autoAC.cpp b/HDOJ/3164_autoAC.cpp new file mode 100644 index 0000000..e1b74a0 --- /dev/null +++ b/HDOJ/3164_autoAC.cpp @@ -0,0 +1,22 @@ +#include +#include +int d[1000050]={1}; +int f(int i) +{ + if(d[i]==0) + { + double a=sin(i); + d[i]=f((int)(i-sqrt(i+0.0)))+f((int)log(i+0.0))+f((int)(i*a*a)); + d[i]%=1000000; + } + return d[i]; +} +int main() +{ + int n; + while(scanf("%d",&n)&&n!=-1) + { + printf("%d\n",f(n)); + } + return 0; +} diff --git a/HDOJ/3165_autoAC.cpp b/HDOJ/3165_autoAC.cpp new file mode 100644 index 0000000..aeccbab --- /dev/null +++ b/HDOJ/3165_autoAC.cpp @@ -0,0 +1,79 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAX=2005,INF=1<<30; +int a[MAX],c[MAX], + n,len; +int bsearchLDS(const int &v){ + int l=1,r=len+1,m; + while(lv) l=m+1; + else r=m; + } + return l; +} +int bsearchLIS(const int &v){ + int l=1,r=len+1,m; + while(llen) + len=pos; + } + return len; +} +int LIS(const int &i){ + int pos; + len=1; + c[len]=a[i]; + for(int j=i+1;jlen) + len=pos; + } + return len; +} +int main() +{ + int nCase,t1,t2,l,maxVal; + while(cin>>n){ + maxVal=0; + for(int i=0;i>a[i]; + for(int i=0;imaxVal) + maxVal=l; + } + cout< +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAX=1000005,MAXN=105,INF=1<<30; +int n,b,c; +int has[MAXN], +pos[MAX]; +int main() +{ + bool endFlag; + int u,v,p,adv,ft; + while(scanf("%d %d %d",&n,&b,&c)==3){ + memset(has,0,sizeof(has)); + for(int i=0;i +#include +#include +using namespace std; +inline +double solve(double S, double T, double C, double t) +{ + return T / C * (-log(S / C - t)) - 9.8 * t; +} +const double E = 1e-12; +inline +int dblcmp(double x) +{ + if (x > -E && x < E) + return 0; + return x > 0 ? 1 : -1; +} +struct NN { + long long S, L, T, C; +}; +NN aa[1010]; +double dp[2][10100]; +int main() +{ + int cn, cns; + while (scanf("%d", &cns) == 1) { + for (cn = 0; cn < cns; cn++) { + int n; + scanf("%d", &n); + for (int i = 1; i <= n; i++) { + scanf("%I64d%I64d%I64d%I64d", &aa[i].S, &aa[i].L, &aa[i].T, &aa[i].C); + } + for (int j = 0; j <= 10000; j++) { + dp[0][j] = 0; + } + double maxv = 0; + for (int i = 1; i <= n; i++) { + for (int j = 0; j <= 10000; j++) { + int xx = i % 2, yy = (i - 1) % 2; + dp[xx][j] = 0; + dp[xx][j] = max(dp[xx][j], dp[yy][j]); + if (j >= aa[i].S + aa[i].L && (aa[i].T - 9.8 * j) >= 0) + dp[xx][j] = max(dp[xx][j], dp[yy][j - aa[i].S - aa[i].L] + + solve(j, aa[i].T, aa[i].C, (double)aa[i].L / aa[i].C) - solve(j, aa[i].T, aa[i].C, 0)); + if (maxv < dp[xx][j]) { + maxv = dp[xx][j]; + } + } + } + printf("%.0lf\n", floor(maxv + 0.5)); + } + } + return 0; +} diff --git a/HDOJ/3172_autoAC.cpp b/HDOJ/3172_autoAC.cpp new file mode 100644 index 0000000..7e65d23 --- /dev/null +++ b/HDOJ/3172_autoAC.cpp @@ -0,0 +1,49 @@ +#include +#include +using namespace std; +int gx[200005],sz[200005]; +char s1[200005][25],s2[200005][25]; +int find(int p) +{ + if(p!=gx[p]) + { + gx[p]=find(gx[p]); + } + return gx[p]; +} +int unions(int p,int q) +{ + int i=find(p),j=find(q); + if(i==j) return sz[j]; + gx[i]=j; + sz[j]+=sz[i]; + return sz[j]; +} +int main() +{ + int n,f,num,i; + mapmymap; + while(~scanf("%d",&n)) + { + while(n--) + { + scanf("%d",&f); + mymap.clear(); + num=0; + for(i=1;i<=f;i++) + { + scanf("%s%s",s1[i],s2[i]); + if(!mymap[s1[i]]) mymap[s1[i]]=++num; + if(!mymap[s2[i]]) mymap[s2[i]]=++num; + } + for(i=1;i<=num;i++) + { + gx[i]=i; + sz[i]=1; + } + for(i=1;i<=f;i++) + printf("%d\n",unions(mymap[s1[i]],mymap[s2[i]])); + } + } + return 0; +} diff --git a/HDOJ/3174_autoAC.cpp b/HDOJ/3174_autoAC.cpp new file mode 100644 index 0000000..99382b5 --- /dev/null +++ b/HDOJ/3174_autoAC.cpp @@ -0,0 +1 @@ +fd 100 lt 120 fd 100 lt 120 fd 100 diff --git a/HDOJ/3176_autoAC.cpp b/HDOJ/3176_autoAC.cpp new file mode 100644 index 0000000..1df01a4 --- /dev/null +++ b/HDOJ/3176_autoAC.cpp @@ -0,0 +1,19 @@ +#include"iostream" +#include"cstdio" +#include"cstring" +using namespace std; +int main() +{ + printf("...............................................................................................\n"); + printf("..#.........................#...........#.........................#............................\n"); + printf(".#...#####...#...........#...#.........#...#####...#...........#...#..............#####...#....\n"); + printf("#........#...#.....#.....#....#.......#........#...#...........#....#.................#...#....\n"); + printf("#.......#....#.....#.....#....#.......#.......#....#...........#....#....#####.......#....#....\n"); + printf("#......#.....#...#####...#....#...#...#......#.....#...#####...#....#...............#.....#....\n"); + printf("#.....#......#.....#.....#....#.......#.....#......#...........#....#....#####.....#......#....\n"); + printf("#.....#......#.....#.....#....#.......#.....#......#...........#....#..............#...........\n"); + printf(".#....#......#...........#....#........#....#......#...........#....#..............#......#....\n"); + printf("..#..........................#..........#..........................#...........................\n"); + printf("...............................................................................................\n"); + return 0; +} diff --git a/HDOJ/3177_autoAC.cpp b/HDOJ/3177_autoAC.cpp new file mode 100644 index 0000000..4e99893 --- /dev/null +++ b/HDOJ/3177_autoAC.cpp @@ -0,0 +1,46 @@ +#include +#include +using namespace std; +int main(int argc, char *argv[]) +{ + int a[1005],b[1005]; + int i,j,e; + int n,v,c; + cin>>n; + for(e=1;e<=n;e++) + { + cin>>v>>c; + for(i=0;i>a[i]>>b[i]; + } + for(i=0;i=b[i]) + { + v=v-a[i]; + } + else + { + v=-1; + break; + } + } + if(v==-1) + { + cout<<"No"< +#include +using namespace std; +#define N 1005 +#define L 0.0000001 +double a[N]; +double b[N]; +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + int n; + scanf("%d",&n); + int i = 0; + for(i = 1; i <= n; i++) + scanf("%lf%lf",&a[i],&b[i]); + int p1,p2; + scanf("%d%d",&p1,&p2); + double x1 = a[p2] - a[p1]; + double y1 = b[p2] - b[p1]; + for(i = 1; i <= n; i++) + { + double x2 = a[i] - a[p1]; + double y2 = b[i] - b[p1]; + double sum = x1*y2 - x2*y1; + if(sum < -L) + printf("Right\n"); + else if(sum > L) + printf("Left\n"); + else printf("On\n"); + } + } + return 0; +} diff --git a/HDOJ/3181_autoAC.cpp b/HDOJ/3181_autoAC.cpp new file mode 100644 index 0000000..694ca1f --- /dev/null +++ b/HDOJ/3181_autoAC.cpp @@ -0,0 +1,27 @@ +#include +#include +int a[10002]; +int dg(long n) +{ + if(n==1||n==2||n==0) + return 0; + if(n%2==0) + return dg(n/2)*2; + else + return dg(n/2)+dg(n-n/2)+1; +} +int main(int argc, char* argv[]) +{ + int n; + int i; + long num; + scanf("%d", &n); + memset(a,-1, sizeof(a)); + a[0]=a[1]=a[2]= 0; + for (i = 0; i < n; i++) + { + scanf("%ld", &num); + printf("%ld\n", dg(num)); + } + return 0; +} diff --git a/HDOJ/3182_autoAC.cpp b/HDOJ/3182_autoAC.cpp new file mode 100644 index 0000000..ef604e7 --- /dev/null +++ b/HDOJ/3182_autoAC.cpp @@ -0,0 +1,84 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#include +#include +#include +#include +#define cler(arr, val) memset(arr, val, sizeof(arr)) +typedef long long LL; +const int MAXN = 15; +const int MAXM = 6000010; +const int INF = 0x3f3f3f3f; +const int mod = 1000000007; +int val[MAXN],cost[1<G[MAXN]; +int n,m; +void init() +{ + cler(last,0); + cler(cost,0); + cler(dp,-1); + for(int i=0;i>t; + while(t--) + { + cin>>n>>m; + for(int i=0;i>val[i]; + for(int i=0;i>E[i]; + init(); + for(int i=0;i>y; + y--; + last[i]|=1< +#include +#include +char s[1010]; +char ans[1020]; +int st[1010][20]; +int Min(int x,int y) +{ + return s[x] <= s[y] ? x : y; +} +void RMQ_Init(int len) +{ + for(int i = 0; i < len; i++) + st[i][0] = i; + for(int j = 1; (1< +#include +using namespace std; +int main() +{ + int t; + int T,b; + int ans; + scanf("%d",&t); + while(t--) + { + scanf("%d %d",&T,&b); + ans = 0; + if(90 % b) + { + cout<<"Impossible!"<=1; i--) + { + if(i % b == 0) + { + ans = i; + break; + } + } + if(ans) + { + cout<=10; i--) + { + if(i % b == 0) + { + ans = i; + break; + } + } + for(int k=3; k<=T; k++) + { + cout<<"9"; + } + cout< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +vector prime; +int ans; +bool isPrime(int n){ + for(int p = 2; p <= n/p ; p++){ + if(n % p == 0){ + return false; + } + } + return true; +} +void dfs(int next, vector with, int n){ + int nn = n; + bool can = true; + for(vector::iterator it = with.begin() ; it != with.end() ; it++){ + if(n % (*it-1) == 0) { + n /= (*it-1); + }else { + can = false; + break; + } + } + if(can){ + for(vector::iterator it = with.begin() ; it != with.end() ; it++){ + while(n % *it == 0){ + n /= *it; + } + } + if(n == 1)ans++; + if(with.size() == 3){ + return; + } + for(int i = next ; i < prime.size(); i++){ + with.push_back(prime[i]); + dfs(i+1, with, nn); + with.pop_back(); + } + } +} +int main() +{ + for(int n; ~scanf("%d", &n); ){ + prime.clear(); + for(int i = 1 ; i <= n / i; i++){ + if(n % i == 0){ + if(isPrime(i+1)){ + prime.push_back(i+1); + } + if(n/i != i && isPrime(n/i+1)){ + prime.push_back(n/i+1); + } + } + } + ans = 0; + dfs(0, vector(), n); + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/3188_autoAC.cpp b/HDOJ/3188_autoAC.cpp new file mode 100644 index 0000000..a9dae2d --- /dev/null +++ b/HDOJ/3188_autoAC.cpp @@ -0,0 +1,17 @@ +#include +int main() +{ + int n,a,b,c; + scanf("%d",&n); + while(n--) + { + scanf("%d%d%d",&a,&b,&c); + if(a*a==b*b+c*c||b*b==a*a+c*c||c*c==a*a+b*b) + printf("good\n"); + else if(a==b||a==c||b==c) + printf("perfect\n"); + else + printf("just a triangle\n"); + } + return 0; +} diff --git a/HDOJ/3189_autoAC.cpp b/HDOJ/3189_autoAC.cpp new file mode 100644 index 0000000..27fb13f --- /dev/null +++ b/HDOJ/3189_autoAC.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define maxn 1005 +using namespace std; +int a[maxn]; +void csh() +{ + int i; + for(int i=1;i<=1000;i++) + { + int p=(int) sqrt(i); + for(int j=1;j<=p;j++) + { + if(i%j==0) + { + if(j==i/j) + a[i]++; + else + a[i]+=2; + } + } + } +} +int answer(int b) +{ + for(int i=1;i<=1000;i++) + { + if(a[i]==b) + return i; + } + return -1; +} +int main() +{ + int t; + memset(a,0,sizeof(a)); + csh(); + cin>>t; + while(t--) + { + int k; + cin>>k; + int ans=answer(k); + cout< +#include +#include +#define N 55 +#define M 10000 +#define inf 0x7fffffff +using namespace std; +int cnt[N][2],dis[N][2]; +bool h[N][2]; +int NE,head[N]; +int n,m; +struct node{ + int next,v,w; + node(){}; + node(int a,int b,int c){ + next=a;v=b;w=c; + } +}E[M]; +void init(){ + NE=0; + memset(head,-1,sizeof(head)); +} +void insert(int u,int v,int w){ + E[NE]=node(head[u],v,w); + head[u]=NE++; +} +void dijkstra(int beg,int end){ + for(int i=0;i<=n;i++){ + dis[i][0]=dis[i][1]=inf; + cnt[i][0]=cnt[i][1]=0; + } + memset(h,0,sizeof(h)); + dis[beg][0]=0; + cnt[beg][0]=1; + while(true){ + int u,flag; + int Min=inf; + for(int i=0;iw){ + if(dis[v][0]!=inf){ + dis[v][1]=dis[v][0]; + cnt[v][1]=cnt[v][0]; + } + dis[v][0]=w; + cnt[v][0]=cnt[u][flag]; + } + else if(dis[v][0]==w) + cnt[v][0]+=cnt[u][flag]; + else if(dis[v][1]>w){ + dis[v][1]=w; + cnt[v][1]=cnt[u][flag]; + } + else if(dis[v][1]==w) + cnt[v][1]+=cnt[u][flag]; + } + } + printf("%d %d\n",dis[end][1],cnt[end][1]); +} +int main(void){ + int s,t; + while(~scanf("%d%d%d%d",&n,&m,&s,&t)){ + init(); + while(m--){ + int x,y,w; + scanf("%d%d%d",&x,&y,&w); + insert(x,y,w); + } + dijkstra(s,t); + } +} diff --git a/HDOJ/3193_autoAC.cpp b/HDOJ/3193_autoAC.cpp new file mode 100644 index 0000000..cf7f095 --- /dev/null +++ b/HDOJ/3193_autoAC.cpp @@ -0,0 +1,72 @@ +#include +#include +#include +using namespace std; +const int MAXN =10000+100; +int a[MAXN]; +int dmin[MAXN][20]; +void initMin(int n,int d[]) +{ + for(int i=0; i<=n; i++)dmin[i][0]=d[i]; + for(int j=1; (1< +#include +#include +#include +#include +using namespace std; +long long num[27]; +void cal() +{ + int front=1,tail; + long long wei=1; + num[0]=0; + while(1) + { + int k=front; + tail=0; + for(int i=1;i<10;i++) + { + for(int j=0;j0;m/=10) + { + long long d=(b/m-(b/(10*m))*10)*m,e=b%(10*wei/m); + c+=(d*e); + } + c%=(wei*10); + if(c==b) + { + num[front++]=b; + if(front>25) return; + } + } + } + wei*=10; + } +} +int main() +{ + cal(); + int n; + while(scanf("%d",&n)==1) + { + printf("%I64d\n",num[n-1]); + } + return 0; +} diff --git a/HDOJ/3197_autoAC.cpp b/HDOJ/3197_autoAC.cpp new file mode 100644 index 0000000..219ddd2 --- /dev/null +++ b/HDOJ/3197_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include +using namespace std; +vector V[1010]; +stack S; +int N; +int dfs(int v,int pre) //涓寮 +{ + int i,t; + int sum=0; + for(i=0;i +#include +using namespace std; +__int64 x[100001]={0}; +void set(__int64 p1,__int64 p2,__int64 p3,__int64 n) +{ + __int64 a=1,b=1,c=1,k=2,s[3]; + x[1]=1; + while(k<=n+1) + { + s[0]=x[a]*p1;s[1]=x[b]*p2;s[2]=x[c]*p3; + sort(s,s+3); + x[k]=s[0]; + if(n+1==k)printf("%I64d\n",x[k]); + if(s[0]==x[a]*p1) + a++; + if(s[0]==x[b]*p2) + b++; + if(s[0]==x[c]*p3) + c++; + k++; + } +} +int main() +{ + __int64 p1,p2,p3,i; + while(scanf("%I64d%I64d%I64d%I64d",&p1,&p2,&p3,&i)!=EOF) + set(p1,p2,p3,i); + return 0; +}