From c9791a72c956b1efe128936040eab537e837fb38 Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Tue, 6 Sep 2016 13:32:33 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 4500-4599 --- HDOJ/4500_autoAC.cpp | 64 +++++++++ HDOJ/4501_autoAC.cpp | 41 ++++++ HDOJ/4502_autoAC.cpp | 29 ++++ HDOJ/4503_autoAC.cpp | 20 +++ HDOJ/4504_autoAC.cpp | 44 ++++++ HDOJ/4505_autoAC.cpp | 28 ++++ HDOJ/4506_autoAC.cpp | 32 +++++ HDOJ/4507_autoAC.cpp | 66 +++++++++ HDOJ/4508_autoAC.cpp | 27 ++++ HDOJ/4509_autoAC.cpp | 53 +++++++ HDOJ/4510_autoAC.cpp | 34 +++++ HDOJ/4511_autoAC.cpp | 127 +++++++++++++++++ HDOJ/4512_autoAC.cpp | 40 ++++++ HDOJ/4513_autoAC.cpp | 61 ++++++++ HDOJ/4514_autoAC.cpp | 64 +++++++++ HDOJ/4515_autoAC.cpp | 68 +++++++++ HDOJ/4516_autoAC.cpp | 122 ++++++++++++++++ HDOJ/4517_autoAC.cpp | 76 ++++++++++ HDOJ/4518_autoAC.cpp | 137 ++++++++++++++++++ HDOJ/4519_autoAC.cpp | 23 +++ HDOJ/4520_autoAC.cpp | 37 +++++ HDOJ/4521_autoAC.cpp | 51 +++++++ HDOJ/4522_autoAC.cpp | 113 +++++++++++++++ HDOJ/4523_autoAC.cpp | 58 ++++++++ HDOJ/4524_autoAC.cpp | 30 ++++ HDOJ/4525_autoAC.cpp | 52 +++++++ HDOJ/4526_autoAC.cpp | 62 ++++++++ HDOJ/4527_autoAC.cpp | 83 +++++++++++ HDOJ/4528_autoAC.cpp | 96 +++++++++++++ HDOJ/4529_autoAC.cpp | 95 +++++++++++++ HDOJ/4530_autoAC.cpp | 26 ++++ HDOJ/4531_autoAC.cpp | 328 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/4532_autoAC.cpp | 47 +++++++ HDOJ/4533_autoAC.cpp | 62 ++++++++ HDOJ/4534_autoAC.cpp | 144 +++++++++++++++++++ HDOJ/4535_autoAC.cpp | 26 ++++ HDOJ/4536_autoAC.cpp | 67 +++++++++ HDOJ/4538_autoAC.cpp | 15 ++ HDOJ/4539_autoAC.cpp | 109 ++++++++++++++ HDOJ/4540_autoAC.cpp | 32 +++++ HDOJ/4541_autoAC.cpp | 73 ++++++++++ HDOJ/4542_autoAC.cpp | 112 +++++++++++++++ HDOJ/4543_autoAC.cpp | 131 +++++++++++++++++ HDOJ/4544_autoAC.cpp | 65 +++++++++ HDOJ/4545_autoAC.cpp | 65 +++++++++ HDOJ/4546_autoAC.cpp | 52 +++++++ HDOJ/4547_autoAC.cpp | 128 +++++++++++++++++ HDOJ/4548_autoAC.cpp | 56 ++++++++ HDOJ/4549_autoAC.cpp | 70 +++++++++ HDOJ/4550_autoAC.cpp | 39 +++++ HDOJ/4551_autoAC.cpp | 48 +++++++ HDOJ/4553_autoAC.cpp | 196 ++++++++++++++++++++++++++ HDOJ/4554_autoAC.cpp | 41 ++++++ HDOJ/4556_autoAC.cpp | 33 +++++ HDOJ/4557_autoAC.cpp | 60 ++++++++ HDOJ/4558_autoAC.cpp | 50 +++++++ HDOJ/4559_autoAC.cpp | 54 +++++++ HDOJ/4560_autoAC.cpp | 104 ++++++++++++++ HDOJ/4561_autoAC.cpp | 72 ++++++++++ HDOJ/4562_autoAC.cpp | 99 +++++++++++++ HDOJ/4563_autoAC.cpp | 72 ++++++++++ HDOJ/4565_autoAC.cpp | 24 ++++ HDOJ/4566_autoAC.cpp | 106 ++++++++++++++ HDOJ/4567_autoAC.cpp | 34 +++++ HDOJ/4568_autoAC.cpp | 92 ++++++++++++ HDOJ/4569_autoAC.cpp | 51 +++++++ HDOJ/4570_autoAC.cpp | 45 ++++++ HDOJ/4571_autoAC.cpp | 102 ++++++++++++++ HDOJ/4572_autoAC.cpp | 14 ++ HDOJ/4573_autoAC.cpp | 121 ++++++++++++++++ HDOJ/4574_autoAC.cpp | 84 +++++++++++ HDOJ/4575_autoAC.cpp | 196 ++++++++++++++++++++++++++ HDOJ/4576_autoAC.cpp | 34 +++++ HDOJ/4578_autoAC.cpp | 147 +++++++++++++++++++ HDOJ/4579_autoAC.cpp | 76 ++++++++++ HDOJ/4582_autoAC.cpp | 51 +++++++ HDOJ/4583_autoAC.cpp | 60 ++++++++ HDOJ/4584_autoAC.cpp | 58 ++++++++ HDOJ/4585_autoAC.cpp | 28 ++++ HDOJ/4586_autoAC.cpp | 53 +++++++ HDOJ/4587_autoAC.cpp | 70 +++++++++ HDOJ/4588_autoAC.cpp | 44 ++++++ HDOJ/4593_autoAC.cpp | 27 ++++ HDOJ/4594_autoAC.cpp | 210 +++++++++++++++++++++++++++ HDOJ/4595_autoAC.cpp | 67 +++++++++ HDOJ/4596_autoAC.cpp | 55 ++++++++ HDOJ/4597_autoAC.cpp | 64 +++++++++ HDOJ/4598_autoAC.cpp | 129 +++++++++++++++++ HDOJ/4599_autoAC.cpp | 76 ++++++++++ 89 files changed, 6427 insertions(+) create mode 100644 HDOJ/4500_autoAC.cpp create mode 100644 HDOJ/4501_autoAC.cpp create mode 100644 HDOJ/4502_autoAC.cpp create mode 100644 HDOJ/4503_autoAC.cpp create mode 100644 HDOJ/4504_autoAC.cpp create mode 100644 HDOJ/4505_autoAC.cpp create mode 100644 HDOJ/4506_autoAC.cpp create mode 100644 HDOJ/4507_autoAC.cpp create mode 100644 HDOJ/4508_autoAC.cpp create mode 100644 HDOJ/4509_autoAC.cpp create mode 100644 HDOJ/4510_autoAC.cpp create mode 100644 HDOJ/4511_autoAC.cpp create mode 100644 HDOJ/4512_autoAC.cpp create mode 100644 HDOJ/4513_autoAC.cpp create mode 100644 HDOJ/4514_autoAC.cpp create mode 100644 HDOJ/4515_autoAC.cpp create mode 100644 HDOJ/4516_autoAC.cpp create mode 100644 HDOJ/4517_autoAC.cpp create mode 100644 HDOJ/4518_autoAC.cpp create mode 100644 HDOJ/4519_autoAC.cpp create mode 100644 HDOJ/4520_autoAC.cpp create mode 100644 HDOJ/4521_autoAC.cpp create mode 100644 HDOJ/4522_autoAC.cpp create mode 100644 HDOJ/4523_autoAC.cpp create mode 100644 HDOJ/4524_autoAC.cpp create mode 100644 HDOJ/4525_autoAC.cpp create mode 100644 HDOJ/4526_autoAC.cpp create mode 100644 HDOJ/4527_autoAC.cpp create mode 100644 HDOJ/4528_autoAC.cpp create mode 100644 HDOJ/4529_autoAC.cpp create mode 100644 HDOJ/4530_autoAC.cpp create mode 100644 HDOJ/4531_autoAC.cpp create mode 100644 HDOJ/4532_autoAC.cpp create mode 100644 HDOJ/4533_autoAC.cpp create mode 100644 HDOJ/4534_autoAC.cpp create mode 100644 HDOJ/4535_autoAC.cpp create mode 100644 HDOJ/4536_autoAC.cpp create mode 100644 HDOJ/4538_autoAC.cpp create mode 100644 HDOJ/4539_autoAC.cpp create mode 100644 HDOJ/4540_autoAC.cpp create mode 100644 HDOJ/4541_autoAC.cpp create mode 100644 HDOJ/4542_autoAC.cpp create mode 100644 HDOJ/4543_autoAC.cpp create mode 100644 HDOJ/4544_autoAC.cpp create mode 100644 HDOJ/4545_autoAC.cpp create mode 100644 HDOJ/4546_autoAC.cpp create mode 100644 HDOJ/4547_autoAC.cpp create mode 100644 HDOJ/4548_autoAC.cpp create mode 100644 HDOJ/4549_autoAC.cpp create mode 100644 HDOJ/4550_autoAC.cpp create mode 100644 HDOJ/4551_autoAC.cpp create mode 100644 HDOJ/4553_autoAC.cpp create mode 100644 HDOJ/4554_autoAC.cpp create mode 100644 HDOJ/4556_autoAC.cpp create mode 100644 HDOJ/4557_autoAC.cpp create mode 100644 HDOJ/4558_autoAC.cpp create mode 100644 HDOJ/4559_autoAC.cpp create mode 100644 HDOJ/4560_autoAC.cpp create mode 100644 HDOJ/4561_autoAC.cpp create mode 100644 HDOJ/4562_autoAC.cpp create mode 100644 HDOJ/4563_autoAC.cpp create mode 100644 HDOJ/4565_autoAC.cpp create mode 100644 HDOJ/4566_autoAC.cpp create mode 100644 HDOJ/4567_autoAC.cpp create mode 100644 HDOJ/4568_autoAC.cpp create mode 100644 HDOJ/4569_autoAC.cpp create mode 100644 HDOJ/4570_autoAC.cpp create mode 100644 HDOJ/4571_autoAC.cpp create mode 100644 HDOJ/4572_autoAC.cpp create mode 100644 HDOJ/4573_autoAC.cpp create mode 100644 HDOJ/4574_autoAC.cpp create mode 100644 HDOJ/4575_autoAC.cpp create mode 100644 HDOJ/4576_autoAC.cpp create mode 100644 HDOJ/4578_autoAC.cpp create mode 100644 HDOJ/4579_autoAC.cpp create mode 100644 HDOJ/4582_autoAC.cpp create mode 100644 HDOJ/4583_autoAC.cpp create mode 100644 HDOJ/4584_autoAC.cpp create mode 100644 HDOJ/4585_autoAC.cpp create mode 100644 HDOJ/4586_autoAC.cpp create mode 100644 HDOJ/4587_autoAC.cpp create mode 100644 HDOJ/4588_autoAC.cpp create mode 100644 HDOJ/4593_autoAC.cpp create mode 100644 HDOJ/4594_autoAC.cpp create mode 100644 HDOJ/4595_autoAC.cpp create mode 100644 HDOJ/4596_autoAC.cpp create mode 100644 HDOJ/4597_autoAC.cpp create mode 100644 HDOJ/4598_autoAC.cpp create mode 100644 HDOJ/4599_autoAC.cpp diff --git a/HDOJ/4500_autoAC.cpp b/HDOJ/4500_autoAC.cpp new file mode 100644 index 0000000..d73695d --- /dev/null +++ b/HDOJ/4500_autoAC.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +#include +using namespace std; +int n,m; +int i,j; +struct node{ + int x,y,sum; +}s[520]; +int a[22][22]; +int cmp(node a,node b) +{ + if(a.sum!=b.sum) + return a.sum>b.sum; + else if(a.x!=b.x) + return a.x +#include +#include +using namespace std; +int dp[2][105][105][10]; +int val[105]; +int c1[105]; +int c2[105]; +int main() +{ + int n,v1,v2,k; + while(scanf("%d%d%d%d",&n,&v1,&v2,&k)!=EOF) + { + int i; + for(i=1;i<=n;i++) + scanf("%d%d%d",&c1[i],&c2[i],&val[i]); + memset(dp,0,sizeof(dp)); + int now=0; + for(i=1;i<=n;i++) + { + now=now^1; + for(int j=0;j<=v1;j++) + { + for(int l1=0;l1<=v2;l1++) + { + for(int l2=0;l2<=k;l2++) + { + dp[now][j][l1][l2]=dp[now^1][j][l1][l2]; + if(j>=c1[i]&&dp[now][j][l1][l2]=c2[i]&&dp[now][j][l1][l2]=1&&dp[now][j][l1][l2] +#include +#include +using namespace std; +int main() +{ + int n,m,i,j,t; + int a[105][105],dp[105]; + scanf("%d",&t); + while(t--) + { + memset(a,0,sizeof(a)); + memset(dp,0,sizeof(dp)); + scanf("%d%d",&n,&m); + for(i = 1;i<=m;i++) + { + int x,y,c; + scanf("%d%d%d",&x,&y,&c); + a[x][y] = max(a[x][y],c); + } + for(i = 1;i<=n;i++) + { + for(j = i;j>=1;j--) + dp[i] = max(dp[i],dp[j-1]+a[j][i]); + } + printf("%d\n",dp[n]); + } + return 0; +} diff --git a/HDOJ/4503_autoAC.cpp b/HDOJ/4503_autoAC.cpp new file mode 100644 index 0000000..03aa70e --- /dev/null +++ b/HDOJ/4503_autoAC.cpp @@ -0,0 +1,20 @@ +#include +#include +#include +using namespace std; +int n,num[1010]; +int main(){ + int t; + scanf("%d",&t); + while(t--){ + scanf("%d",&n); + int ans=0; + for(int i=0;i +#include +#include +#include +#include +using namespace std; +__int64 d[100][300]; +int main() +{ + __int64 A,B,t; + while(scanf("%I64d%I64d%I64d",&A,&B,&t)!=-1) + { + t/=15; + B+=t/2; + t=(t+1)/2; + d[0][0]=1; + for(__int64 j=1;j<=3*t;j++) + { + d[0][j]=0; + } + for(__int64 i=1;i<=t;i++) + { + d[i][0]=0; + d[i][1]=d[i-1][0]; + d[i][2]=d[i-1][0]+d[i-1][1]; + for(__int64 j=3;j<=3*t;j++) + { + d[i][j]=d[i-1][j-1]+d[i-1][j-2]+d[i-1][j-3]; + } + } + __int64 ans=0; + __int64 j=B-A+1; + if(j<0) + { + j=0; + } + for(;j<=3*t;j++) + { + ans+=d[t][j]; + } + printf("%I64d\n",ans); + } + return 0; +} diff --git a/HDOJ/4505_autoAC.cpp b/HDOJ/4505_autoAC.cpp new file mode 100644 index 0000000..da57045 --- /dev/null +++ b/HDOJ/4505_autoAC.cpp @@ -0,0 +1,28 @@ +#include +#include +int main() +{ + int a, i, c, n, cnt[105]; + scanf("%d",&c); + while(c--) + { + scanf("%d",&n); + memset(cnt, 0, sizeof(cnt)); + int Max = 0; + for(i = 0; i < n; i++) + { + scanf("%d",&a); + cnt[a]++; + if(a > Max) + Max = a; + } + int ans = Max * 10; + for(i = 1; i <= Max; i++) + { + if(cnt[i]) + ans += 5 + cnt[i]; + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4506_autoAC.cpp b/HDOJ/4506_autoAC.cpp new file mode 100644 index 0000000..356bc16 --- /dev/null +++ b/HDOJ/4506_autoAC.cpp @@ -0,0 +1,32 @@ +#include +#include +#include +using namespace std; +const int mod=1e9+7; +long long n,t,k; +long long num[10010],res[10010]; +int main(){ + int T; + scanf("%d",&T); + while(T--){ + scanf("%I64d%I64d%I64d",&n,&t,&k); + long long tmpt=t,tmpk=1; + while(tmpt){ + if(tmpt&1) + tmpk=(tmpk*k)%mod; + tmpt>>=1; + k=(k*k)%mod; + } + for(int i=0;i +#include +#include +#include +using namespace std; +typedef long long LL; +typedef pair< int,pair > PILL; +#define F first +#define S second +#define MP make_pair +const int mod = 1e9 + 7; +int digit[20]; +LL pow10[20]; +PILL dp[20][7][7][2]; +bool vis[20][7][7][2]; +PILL dfs(int len,int sum,int remain,bool contain,bool fp) +{ + if(!len) + if(!contain && sum && remain) + return MP(1,MP(0LL,0LL)); + else + return MP(0,MP(0LL,0LL)); + if(!fp && vis[len][sum][remain][contain]) + return dp[len][sum][remain][contain]; + PILL ret = MP(0,MP(0,0)); + int fpmax = fp ? digit[len] : 9; + for(int i=0;i<=fpmax;i++) + { + PILL nxt = dfs(len-1,(sum + i) % 7,(remain * 10 + i) % 7,contain | (i == 7),fp && i == fpmax); + LL pref = i * pow10[len-1] % mod; + (ret.F += nxt.F) %= mod; + (ret.S.F += nxt.S.F + pref * nxt.F) %= mod; + (ret.S.S += nxt.S.S + pref * pref % mod * nxt.F + 2 * pref * nxt.S.F) %= mod; + } + if(!fp) + { + vis[len][sum][remain][contain] = true; + dp[len][sum][remain][contain] = ret; + } + return ret; +} +long long f(long long n) +{ + int len = 0; + while(n) + { + digit[++len] = n % 10; + n /= 10; + } + return dfs(len,0,0,0,true).S.S; +} +int main() +{ + pow10[0] = 1; + for(int i=1;i<20;i++) + pow10[i] = pow10[i-1] * 10 % mod; + int T; + scanf("%d",&T); + while(T--) + { + long long a,b; + scanf("%I64d%I64d",&a,&b); + printf("%I64d\n",(f(b) - f(a-1) + mod) % mod); + } + return 0; +} diff --git a/HDOJ/4508_autoAC.cpp b/HDOJ/4508_autoAC.cpp new file mode 100644 index 0000000..5fe2fe5 --- /dev/null +++ b/HDOJ/4508_autoAC.cpp @@ -0,0 +1,27 @@ +#include +#include +const int N=110; +using namespace std; +int dp[N*N*10]; +struct Node{ + int a,b; +}node[N]; +int main(){ + int n; + while(~scanf("%d",&n)){ + for(int i=0;i +#include +const int maxn=500005; +struct time +{ + int start; + int end; +}t[maxn]; +int cmp(const void*a,const void*b) +{ + time*c=(time*)a; + time*d=(time*)b; + return c->start-d->start; +} +int max(int a,int b) +{ + return a>b?a:b; +} +int main() +{ + int N; + while(~scanf("%d",&N)) + { + int a,b,c,d; + char ss; + int i; + for(i=0;i +int main(){ + int h,m,s,a,b,c,T; + scanf("%d",&T); + while(T--) { + scanf("%d%*c%d%*c%d",&h,&m,&s); + scanf("%d%*c%d%*c%d",&a,&b,&c); + a=a%12; + s=s-c; + if(s<0) { + s+=60; + m--; + if(m<0){ + m+=60; + h--; + if(h<0) h+=12; + } + } + m-=b; + if(m<0){ + m+=60; + h--; + if(h<0) h+=12; + } + h=(h-a+12)%12; + if(h<10) printf("0%d:",h); + else printf("%d:",h); + if(m<10) printf("0%d:",m); + else printf("%d:",m); + if(s<10) printf("0%d\n",s); + else printf("%d\n",s); + } + return 0; +} diff --git a/HDOJ/4511_autoAC.cpp b/HDOJ/4511_autoAC.cpp new file mode 100644 index 0000000..4441cf5 --- /dev/null +++ b/HDOJ/4511_autoAC.cpp @@ -0,0 +1,127 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const double INF = 1e20; +int n; +pair p[100]; +double dis(paira,pairb) +{ + return sqrt((double)(1.0 * a.first - b.first) * (1.0 * a.first - b.first) + (double)(1.0 * a.second - b.second)*(1.0 * a.second - b.second)); +} +double dp[55][1000]; +void CheckMin(double &a,double b) +{ + a = min(a,b); +} +struct Trie +{ + int next[1000][55],fail[1000],end[1000]; + int root,L; + int newnode() + { + for(int i = 1; i <= n;i++) + next[L][i] = -1; + end[L++] = 0; + return L-1; + } + void init() + { + L = 0; + root = newnode(); + } + void insert(int a[],int cnt) + { + int now = root; + for(int i = 0;i < cnt;i++) + { + if(next[now][a[i]] == -1) + next[now][a[i]] = newnode(); + now = next[now][a[i]]; + } + end[now] = 1; + } + void build() + { + queueQ; + fail[root] = root; + for(int i = 1;i <= n;i++) + if(next[root][i] == -1) + next[root][i] = root; + else + { + fail[next[root][i]] = root; + Q.push(next[root][i]); + } + while(!Q.empty()) + { + int now = Q.front(); + Q.pop(); + end[now] |= end[fail[now]]; + for(int i = 1;i <= n;i++) + if(next[now][i] == -1) + next[now][i] = next[fail[now]][i]; + else + { + fail[next[now][i]] = next[fail[now]][i]; + Q.push(next[now][i]); + } + } + } + void solve() + { + for(int i = 1;i <= n;i++) + for(int j = 0;j < L;j++) + dp[i][j] = INF; + dp[1][next[root][1]] = 0; + for(int i = 1;i < n;i++) + for(int j = 0;j < L;j++) + if(dp[i][j] < INF) + { + for(int k = i+1;k <= n;k++) + { + int ss = next[j][k]; + if(end[ss])continue; + CheckMin(dp[k][ss],dp[i][j] + dis(p[i],p[k])); + } + } + double ans = INF; + for(int i = 0;i < L;i++) + if(dp[n][i] < INF) + CheckMin(ans,dp[n][i]); + if(ans == INF)printf("Can not be reached!\n"); + else printf("%.2f\n",ans); + } +}ac; +int a[10]; +int main() +{ + int m; + while(scanf("%d%d",&n,&m) == 2) + { + if(n == 0 && m == 0)break; + for(int i = 1;i <= n;i++) + scanf("%d%d",&p[i].first,&p[i].second); + ac.init(); + int k; + while(m--) + { + scanf("%d",&k); + for(int i = 0;i < k;i++) + scanf("%d",&a[i]); + ac.insert(a,k); + } + ac.build(); + ac.solve(); + } + return 0; +} diff --git a/HDOJ/4512_autoAC.cpp b/HDOJ/4512_autoAC.cpp new file mode 100644 index 0000000..a3b6e69 --- /dev/null +++ b/HDOJ/4512_autoAC.cpp @@ -0,0 +1,40 @@ +#include +#include +#include +#define MAXN 205 +int a[MAXN]; +int f[MAXN][MAXN]; +int main() +{ + int T, N; + for(scanf("%d", &T); T--; ) + { + scanf("%d", &N); + for(int i = 1; i <= N; ++i) + scanf("%d", &a[i]); + memset(f, 0, sizeof(f)); + int ans = 1; + for(int i = 1; i <= N; ++i) + { + int max = 0; + for(int j = N; i < j; --j) + { + f[i][j] = f[i-1][j]; + if((a[i] == a[j]) && (f[i][j] < max + 1)) + f[i][j] = max + 1; + else if((a[i] > a[j]) &&(f[i-1][j] > max)) max = f[i-1][j]; + if(f[i][j] * 2 > ans) ans = f[i][j] * 2; + for(int k = i + 1; k < j; ++k) + { + if(a[k] > a[j]) + { + if(2 * f[i][j] + 1 > ans) + ans = 2 * f[i][j] + 1; + } + } + } + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/4513_autoAC.cpp b/HDOJ/4513_autoAC.cpp new file mode 100644 index 0000000..5ac0b2f --- /dev/null +++ b/HDOJ/4513_autoAC.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#define MAXN 100005 +int a[MAXN * 2]; +struct Rem{ + int left; + int right; +}rem; +int odd[2 * MAXN]; +int min(int a, int b) +{ + return (a < b) ? a : b; +} +int fun(int i, int m, int N) +{ + int l = i - m - 1, r = i + m + 1; + int ret = 0; + for(;(l > 0)&&(r <= N);--l, ++r) + { + if((a[r] == -1) || ((a[l] == a[r]) && ((r - l == 2)||(a[r] <= a[r - 2]) ))) + ++ret; + else break; + } + return ret; +} +int main() +{ + int T, N; + for(scanf("%d", &T); T--; ) + { + scanf("%d", &N); + int i = 0; + a[++i] = -1; + while(N--) + { + scanf("%d", &a[++i]); + a[++i] = -1; + } + N = i; + rem.left = rem.right = 0; + int ans = 1; + memset(odd, 0, sizeof(odd)); + for(int i = 1; i <= N; ++i) + { + int m = 0; + if(rem.right > i) + m = min(rem.right - i, odd[rem.left + (rem.right - i)]); + odd[i] = m + fun(i, m, N); + if(i + odd[i] > rem.right) + { + rem.left = i - odd[i]; + rem.right = i + odd[i]; + } + if(odd[i] > ans) + ans = odd[i]; + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/4514_autoAC.cpp b/HDOJ/4514_autoAC.cpp new file mode 100644 index 0000000..ed08fa4 --- /dev/null +++ b/HDOJ/4514_autoAC.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +#include +#include +#pragma comment(linker, "/STACK:1024000000,1024000000") +using namespace std; +const int N = 100005; +int n, m, ans; +int set[N]; +int dp[N]; +struct Edge { + int v, f; + Edge() {} + Edge(int _v, int _f) : v(_v), f(_f) {} +}; +vectorvt[N]; +int find(int x) { + return x == set[x] ? x : x = find(set[x]); +} +void dfs(int p, int u) { + int forkmax = 0; + for (int i = 0; i < (int)vt[u].size(); ++i) { + int v = vt[u][i].v, f = vt[u][i].f; + if (v == p) continue; + dfs(u, v); + ans = max(ans, dp[v]+f+forkmax); + forkmax = max(forkmax, dp[v] + f); + } + dp[u] = forkmax; +} +void solve() { + for (int i = 1; i <= n; ++i) { + if (dp[i] == -1) dfs(0, i); + } + printf("%d\n", ans); +} +int main() { + while (scanf("%d %d", &n, &m) != EOF) { + int a, b, c, x, y; + bool loop = false; + ans = 0; + for (int i = 1; i <= n; ++i) { + dp[i] = -1; + set[i] = i; + vt[i].clear(); + } + for (int i = 0; i < m; ++i) { + scanf("%d %d %d", &a, &b, &c); + if (loop) continue; + x = find(a), y = find(b); + if (x != y) set[x] = y; + else loop = true; + vt[a].push_back(Edge(b, c)); + vt[b].push_back(Edge(a, c)); + } + if (loop) { + puts("YES"); + continue; + } + solve(); + } + return 0; +} diff --git a/HDOJ/4515_autoAC.cpp b/HDOJ/4515_autoAC.cpp new file mode 100644 index 0000000..8ba3b97 --- /dev/null +++ b/HDOJ/4515_autoAC.cpp @@ -0,0 +1,68 @@ +#include +int a[] = {0,31,28,31,30,31,30,31,31,30,31,30,31}; +const int Y = 2013,M = 3,D = 24; +int leap(int y) +{ + if(y%400 == 0 || (y%4==0 && y%100!=0)) + return 1; + return 0; +} +void deal1(int k) +{ + int y = Y,m = M,d = D; + while(k--) + { + if(leap(y)) + a[2] = 29; + else + a[2] = 28; + d--; + if(d<=0) + { + m--; + if(m<=0) + { + m = 12; + y--; + } + d = a[m]; + } + } + printf("%04d/%02d/%02d",y,m,d); +} +void deal2(int k) +{ + int y = Y,m = M,d = D; + while(k--) + { + if(leap(y)) + a[2] = 29; + else + a[2] = 28; + d++; + if(d>a[m]) + { + m++; + if(m>12) + { + m = 1; + y++; + } + d = 1; + } + } + printf("%04d/%02d/%02d ",y,m,d); +} +int main() +{ + int n,m; + scanf("%d",&n); + while(n--) + { + scanf("%d",&m); + deal2(m); + deal1(m); + printf("\n"); + } + return 0; +} diff --git a/HDOJ/4516_autoAC.cpp b/HDOJ/4516_autoAC.cpp new file mode 100644 index 0000000..55d50f1 --- /dev/null +++ b/HDOJ/4516_autoAC.cpp @@ -0,0 +1,122 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +char str[500]; +int seq[10]; +long long _pow(int a, int b) { + long long ret = 1; + for (int i = 0; i < b; ++i) { + ret *= a; + } + return ret; +} +int jiechen[10] = {1, 1, 2, 6, 24, 120}; +void qiudao(int *rec, int k) { + for (int i = k; i <= 5; ++i) { + rec[i-k] = jiechen[i] / jiechen[i-k] * seq[i]; + } +} +bool judge(int rec[], int x) { + long long sum = 0; + for (int i = 0; i <= 5; ++i) { + sum += 1LL * rec[i] * _pow(x, i); + } + return sum == 0; +} +void gao(char ts[]) { + int len = strlen(ts); + int p = -1, a, b; + for (int i = 0; i < len; ++i) { + if (ts[i] == 'x') { + if (isdigit(ts[i-1])) { + ts[i] = '\0'; + } else { + ts[i] = '1'; + } + p = -2; + } else if (ts[i] == '^') { + ts[i] = '\0'; + p = i+1; + } + } + a = atoi(ts); + if (!a && p != -1) a = 1; + if (p == -1) { + b = 0; + } else if (p == -2) { + b = 1; + }else { + b = atoi(ts+p); + } + seq[b] += a; +} +void solve() { + vectorv; + int cnt = 0; + memset(seq, 0, sizeof (seq)); + char ts[50], *p; + p = strtok(str, "+"); + while (p) { + strcpy(ts, p); + gao(ts); + p = strtok(NULL, "+"); + } + for (int i = 5; i >= 0; --i) { + if (seq[i] != 0) { + cnt = i; + break; + } + } + for (int i = -1000; i <= 1000; ++i) { + for (int j = 0; j < cnt; ++j) { + int rec[10] = {0}; + qiudao(rec, j); + if (judge(rec, i)) { + v.push_back(i); + } else { + break; + } + } + } + if (v.size() != cnt || seq[cnt] != 1 || cnt == 0) { + printf("-1\n"); + } else { + sort(v.begin(), v.end()); + for (int i = v.size()-1; i >= 0; --i) { + if (v[i] < 0) { + printf("(x+%d)", -v[i]); + } else if (v[i] == 0) { + printf("x"); + } else { + printf("(x-%d)", v[i]); + } + } + puts(""); + } +} +int main() { + int T, ca = 0; + scanf("%d", &T); + while (T--) { + scanf("%s", str); + int len = strlen(str); + for (int i = 0; i < len; ++i) { + if (str[i] == '-') { + for (int j = len-1; j >= i; --j) { + str[j+1] = str[j]; + } + str[i] = '+'; + len += 1; + ++i; + str[len] = '\0'; + } + } + printf("Case #%d: ", ++ca); + solve(); + } + return 0; +} diff --git a/HDOJ/4517_autoAC.cpp b/HDOJ/4517_autoAC.cpp new file mode 100644 index 0000000..b8d89c4 --- /dev/null +++ b/HDOJ/4517_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +#define REP(i,n) for(int i=0;i < (n);i++) +#define REPD(i,n) for(int i=(n-1);i >= 0;i--) +#define FOR(i,s,t) for(int i = (s);i <= (t);i++) +#define FORD(i,s,t) for(int i = (s);i >= (t);i--) +#define PII pair +#define PB push_back +#define MP make_pair +#define ft first +#define sd second +#define lowbit(x) (x&(-x)) +#define INF (1<<30) +int n,m; +int C[2011][2011]; +char str[2011][2011]; +void fun(){ + C[0][0] = 0; + FOR(i,1,n){ + C[i][0] = 0; + FOR(j,1,m){ + C[i][j] = C[i][j-1]+(str[i][j]=='*'?1:0); + } + } + FOR(i,2,n){ + FOR(j,1,m){ + C[i][j] += C[i-1][j]; + } + } +} +int Area(int x1,int y1,int x2,int y2){ + if(x1>x2)swap(x1,x2); + if(y1>y2)swap(y1,y2); + return C[x2][y2]-C[x2][y1-1]-C[x1-1][y2]+C[x1-1][y1-1]; +} + int main() +{ + while(~scanf("%d%d",&n,&m),n,m){ + int x,y; + scanf("%d%d",&x,&y); + FOR(i,1,n)scanf("%s",str[i]+1); + fun(); + int ans = 0; + FOR(i,1,n){ + FOR(j,1,m){ + if(str[i][j] != '*')continue; + int xx1 = i+x-1; + int yy1 = j+y-1; + if(!(xx1<1||yy1<1||xx1>n||yy1>m)){ + if(Area(i,j,xx1,yy1) == x*y)ans++; + } + int xx2 = i+y-1; + int yy2 = j+x-1; + if(xx2 == xx1 && yy2==yy1)continue; + if(xx2<1||yy2<1||xx2>n||yy2>m)continue; + if(Area(i,j,xx2,yy2) == x*y)ans++; + } + } + printf("%d\n",ans); + } + return 0; + } diff --git a/HDOJ/4518_autoAC.cpp b/HDOJ/4518_autoAC.cpp new file mode 100644 index 0000000..5a659c4 --- /dev/null +++ b/HDOJ/4518_autoAC.cpp @@ -0,0 +1,137 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int N = 600; +LL n; +int bit[20]; +LL f[60]; +LL dp[15][N]; +LL POW[15]; +LL seq[60]; +LL suf[20]; +queueq; +struct Ac_Auto{ + int ch[N][10]; + int fail[N]; + bool flag[N]; + int idx, root; + int newnd() { + memset(ch[idx], 0, sizeof (ch[idx])); + flag[idx] = false, fail[idx] = 0; + return idx++; + } + void init() { + idx = 0, root = newnd(); + } + void insert(LL x) { + int id = 0; + while (x) bit[id++] = x%10, x/=10; + int p = root; + for (int i = id-1; i >= 0; --i) { + if (!ch[p][bit[i]]) ch[p][bit[i]] = newnd(); + p = ch[p][bit[i]]; + } + flag[p] = true; + } + void build() { + for (int i = 0; i < 10; ++i) { + if (ch[root][i]) { + q.push(ch[root][i]); + } + } + while (!q.empty()) { + int u = q.front(); + q.pop(); + for (int i = 0; i < 10; ++i) { + int &v = ch[u][i]; + int x = fail[u]; + if (v) { + q.push(v); + while (x && !ch[x][i]) x = fail[x]; + fail[v] = ch[x][i]; + flag[v] = flag[v] || flag[fail[v]]; + } else { + v = ch[x][i]; + } + } + } + } + void find(LL x) { + int id = 0; + while (x) bit[id++] = x%10, x/=10; + int p = root; + for (int i = id-1; i >= 0; --i) { + p = ch[p][bit[i]]; + if (flag[p]) { + cout << "OMG" << endl; + return; + } + } + } +}; +Ac_Auto ac; +LL count(int p, int sta, bool bound) { + if (p == 0) return 0; + if (!bound && ~dp[p][sta]) return dp[p][sta]; + int y = bound ? bit[p] : 9; + LL sum = 0; + int tsta; + for (int i = 0; i <= y; ++i) { + tsta = ac.ch[sta][i]; + if (ac.flag[tsta]) { + if (bound&&i==y) sum += suf[p-1]+1; + else sum += POW[p-1]; + continue; + } + sum += ::count(p-1, tsta, bound&&i==y); + } + if (!bound) dp[p][sta] = sum; + return sum; +} +LL cal(LL x) { + int idx = 1; + while (x) suf[idx] = suf[idx-1]+x%10*POW[idx-1], bit[idx++] = x%10, x/=10; + return ::count(idx-1, ac.root, true); +} +void prepare() { + f[1] = 1, f[2] = 1; + for (int i = 3; i <= 55; ++i) { + f[i] = f[i-1] + f[i-2]; + } + ac.init(); + for (int i = 7; i <= 55; ++i) { + ac.insert(f[i]); + } + ac.build(); + POW[0] = 1; + for (int i = 1; i < 15; ++i) POW[i] = POW[i-1] * 10; + memset(dp, 0xff, sizeof (dp)); + LL tmp; + for (int i = 2; i <= 55; ++i) { + LL l = 13, r = POW[12], mid; + while (l <= r) { + mid = (l + r) >> 1; + if ((tmp=cal(mid)) < f[i]) l = mid + 1; + else if (tmp > f[i]) r = mid - 1; + else seq[i] = mid, r = mid - 1; + } + } +} +int main() { + prepare(); + while (cin >> n, n != -1) { + LL ret = 1LL << 60; + for (int i = 2; i <= 55; ++i) { + LL t = seq[i] - n; + if (t < 0) t = -t; + ret = min(ret, t); + } + cout << ret << endl; + } + return 0; +} diff --git a/HDOJ/4519_autoAC.cpp b/HDOJ/4519_autoAC.cpp new file mode 100644 index 0000000..1792530 --- /dev/null +++ b/HDOJ/4519_autoAC.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; +int main() +{ + int n,k,m,t; + cin >> t; + while(t--) + { + cin >> n >> k >> m; + if(m>n) + cout << k<< endl; + else + { + int sub = n*k; + if(sub%m==0) + cout << sub/m; + else + cout << sub/m+1; + cout << endl; + } + } + return 0; +} diff --git a/HDOJ/4520_autoAC.cpp b/HDOJ/4520_autoAC.cpp new file mode 100644 index 0000000..3b00df1 --- /dev/null +++ b/HDOJ/4520_autoAC.cpp @@ -0,0 +1,37 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +double s[25],temp[25]; +int main() +{ + int n; + while(scanf("%d", &n) && n) + { + for(int i = 1; i <= n; ++i) + { + scanf("%lf", &s[i]); + temp[i] = s[i]; + } + sort(temp + 1, temp + n + 1); + double sum = 0; + for(int i = 2; i < n; ++i) + sum += temp[i]; + sum /= (n - 2); + double min = 10000000; + int ans; + for(int i = 1; i <= n; ++i) + { + if(fabs(s[i] - sum) < min) + { + min = fabs(s[i] - sum); + ans = i; + } + } + printf("%d\n", ans); + } + return 0; +} diff --git a/HDOJ/4521_autoAC.cpp b/HDOJ/4521_autoAC.cpp new file mode 100644 index 0000000..c8f322c --- /dev/null +++ b/HDOJ/4521_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +#include +#include +using namespace std; +#define lz 2*u,l,mid +#define rz 2*u+1,mid+1,r +const int maxn=110000; +int sum[2*maxn], dp[maxn+5], a[maxn+5]; +void Update(int u, int l, int r, int p, int c) +{ + sum[u]=max(sum[u],c); + if(l==r)return ; + int mid=(l+r)>>1; + if(p<=mid) Update(lz,p,c); + else Update(rz,p,c); +} +int Query(int u, int l, int r, int tl, int tr) +{ + if(tl>tr) return 0; + if(tl<=l&&r<=tr) return sum[u]; + int mid=(l+r)>>1; + if(tr<=mid) return Query(lz,tl,tr); + else if(tl>mid) return Query(rz,tl,tr); + else + { + int t1=Query(lz,tl,mid); + int t2=Query(rz,mid+1,tr); + return max(t1,t2); + } +} +int main() +{ + int n, d; + while(scanf("%d%d",&n,&d)!=EOF) + { + memset(sum,0,sizeof(sum)); + for(int i=1; i<=n; i++) + scanf("%d",a+i); + int maxx=0; + for(int i=1; i<=n; i++) + { + if(i>d+1) Update(1,1,maxn,a[i-d-1]+1,dp[i-d-1]); + dp[i]=Query(1,1,maxn,1,a[i])+1; + maxx=max(dp[i],maxx); + } + printf("%d\n",maxx); + } + return 0; +} diff --git a/HDOJ/4522_autoAC.cpp b/HDOJ/4522_autoAC.cpp new file mode 100644 index 0000000..26eab3c --- /dev/null +++ b/HDOJ/4522_autoAC.cpp @@ -0,0 +1,113 @@ +#include +#include +#include +const int N=207; +const int inf=1e7; +using namespace std; +int dist1[N]; +int dist0[N]; +int visited[N]; +int edge1[N][N]; +int edge0[N][N]; +int n,m,k; +void Dijkstra1(int u){ + memset(visited,0,sizeof(visited)); + for(int i=1;i<=n;i++){ + dist1[i]=edge1[u][i]; + } + visited[u]=1; + for(int i=1;i +#include +char n[111],m[111],p[111],mid[111]; +int compare(char *s1,char *s2) +{ + int len1=strlen(s1); + int len2=strlen(s2); + if(len1>len2) return 1; + else if(len1s2[i]) return 1; + else if(s2[i]>s1[i]) return 0; + } + return 1; +} +void solve(char *s1,char *s2) +{ + int len=strlen(s2); + int len1=strlen(s1); + strrev(s1); + strrev(s2); + for(int i=0;i'9') + { + s1[i]=s1[i]-10; + if(i+1==len1) {s1[len1]='1';s1[len1+1]='\0';} + else + s1[i+1]++; + } + } + strrev(s1); + if(compare(s1,m)) printf("YES\n"); + else printf("NO\n"); +} +int main() +{ + while(scanf("%s %s %s",n,m,p)!=EOF) + { + if(strlen(m)==1&&m[0]-'0'<3) {printf("NO\n");continue;} + if(strcmp(p,"0")==0) + { + if(strcmp(n,m)==0) printf("YES\n"); + else printf("NO\n"); + continue; + } + if(compare(n,m)) {printf("YES\n"); continue;} + if(strlen(p)>strlen(n)) + solve(p,n); + else solve(n,p); + } + return 0; +} diff --git a/HDOJ/4524_autoAC.cpp b/HDOJ/4524_autoAC.cpp new file mode 100644 index 0000000..2a60c36 --- /dev/null +++ b/HDOJ/4524_autoAC.cpp @@ -0,0 +1,30 @@ +#include +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + int n; + scanf("%d",&n); + __int64 a,t = 0; + int flag = 1; + while(n--) + { + scanf("%I64d",&a); + if(flag) + { + t = a - t; + if(t<0) + { + flag = 0; + } + } + } + if(flag && !t) + printf("yeah~ I escaped ^_^\n"); + else + printf("I will never go out T_T\n"); + } + return 0; +} diff --git a/HDOJ/4525_autoAC.cpp b/HDOJ/4525_autoAC.cpp new file mode 100644 index 0000000..ccca986 --- /dev/null +++ b/HDOJ/4525_autoAC.cpp @@ -0,0 +1,52 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int N = 10005; +int n; +int seq[N]; +int k1, k2; +LL K; +int main() { + int T, ca = 0; + scanf("%d", &T); + while (T--) { + LL sum = 0; + int c; + scanf("%d %d %d %I64d", &n, &k1, &k2, &K); + for (int i = 0; i < n; ++i) { + scanf("%d", &c); + sum += c; + } + printf("Case #%d: ", ++ca); + if (sum > K) { + puts("0"); + continue; + } + int k3 = k1 + k2; + if (k3 >= 0) { + if (k3 <= 1) { + puts("inf"); + } else { + int d = 1; + while ((long double)1.0*sum <= (long double)1.0*K/k3) ++d, sum*=k3; + printf("%d\n", d); + } + } else { + if (k3 == -1) { + puts("inf"); + } else { + k3 *= -1; + int d = 1; + while ((long double)1.0*sum <= (long double)1.0*K/k3) ++d, sum*=k3; + if (d & 1) printf("%d\n", d+1); + else printf("%d\n", d); + } + } + } + return 0; +} diff --git a/HDOJ/4526_autoAC.cpp b/HDOJ/4526_autoAC.cpp new file mode 100644 index 0000000..66352de --- /dev/null +++ b/HDOJ/4526_autoAC.cpp @@ -0,0 +1,62 @@ +#include +#include +#include +#include +#include +using namespace std; +const int MaX = 105; +int N, K, D, S; +struct Node { + int ti; + int qz; +}seq[MaX]; +int dp[MaX][MaX]; +void solve() { + memset(dp, 0xff, sizeof (dp)); + dp[0][N] = 0; + for (int i = 1; i <= K; ++i) { + const int &ti = seq[i].ti; + const int &qz = seq[i].qz; + for (int j = 0; j <= N; ++j) { + if (dp[i-1][j] != -1) dp[i][j] = dp[i-1][j] + j*(ti-seq[i-1].ti); + if (j == 0) { + for (int k = 1; k <= qz; ++k) { + if (k <= N && dp[i-1][k] != -1) { + if (dp[i][0] == -1) { + dp[i][0] = D + dp[i-1][k] + k*(ti-seq[i-1].ti); + } else { + dp[i][0] = min(dp[i][0], D + dp[i-1][k] + k*(ti-seq[i-1].ti)); + } + } + } + } else { + if ((j+qz) <= N && dp[i-1][j+qz] != -1) { + if (dp[i][j] == -1) { + dp[i][j] = D + dp[i-1][j+qz] + (j+qz)*(ti-seq[i-1].ti); + } else { + dp[i][j] = min(dp[i][j], D + dp[i-1][j+qz] + (j+qz)*(ti-seq[i-1].ti)); + } + } + } + } + } + printf("%d\n", dp[K][0]); +} +int main() { + int T; + scanf("%d", &T); + while (T--) { + scanf("%d %d %d %d", &N, &K, &D, &S); + int sum = 0; + for (int i = 1; i <= K; ++i) { + scanf("%d %d", &seq[i].ti, &seq[i].qz); + sum += seq[i].qz; + } + if (sum < N) { + puts("impossible"); + continue; + } + solve(); + } + return 0; +} diff --git a/HDOJ/4527_autoAC.cpp b/HDOJ/4527_autoAC.cpp new file mode 100644 index 0000000..74a898e --- /dev/null +++ b/HDOJ/4527_autoAC.cpp @@ -0,0 +1,83 @@ +#include +#include +#include +#include +#include +using namespace std; +typedef long long int64; +const int INF = 0x3f3f3f3f; +const int MAXN = 10010; +int m; +int mat[8][8]; +int blast[8][8]; +const int dir[][2] = {{-1,0},{1,0},{0,-1},{0,1}}; +struct Node{ + int x, y; + int cnt; + int dir; +}Q[500000]; +void addQue(int x, int y, int cnt, int& rear){ + mat[x][y] = 0; + for(int i=0; i<4; ++i){ + int dx = x + dir[i][0]; + int dy = y + dir[i][1]; + if(dx>=1&&dx<=6&&dy>=1&&dy<=6){ + Q[rear].x = dx; + Q[rear].y = dy; + Q[rear].cnt = cnt; + Q[rear++].dir = i; + } + } +} +void bfs(int x, int y){ + int front=0, rear=0; + addQue(x, y, 0, rear); + int cur = 0; + while(front < rear){ + while(front < rear && Q[front].cnt==cur){ + Node &t = Q[front++]; + if(mat[t.x][t.y]){ + ++mat[t.x][t.y]; + } else{ + Node& now = Q[rear]; + now.x = t.x + dir[t.dir][0]; + now.y = t.y + dir[t.dir][1]; + now.cnt = t.cnt + 1; + now.dir = t.dir; + if(now.x>=1&&now.x<=6&&now.y>=1&&now.y<=6) + ++rear; + } + } + for(int i=1; i<=6; ++i){ + for(int j=1; j<=6; ++j)if(mat[i][j]>4){ + addQue(i,j,cur+1,rear); + } + } + ++cur; + } +} +int main(){ + int x, y; + while(~scanf("%d", &mat[1][1])){ + for(int i=1; i<=6; ++i){ + for(int j=(i==1?2:1); j<=6; ++j){ + scanf("%d", &mat[i][j]); + } + } + scanf("%d", &m); + for(int i=0; i4){ + bfs(x, y); + } + } + for(int i=1; i<=6; ++i){ + for(int j=1; j<=6; ++j) + if(j!=1) printf(" %d", mat[i][j]); + else printf("%d", mat[i][j]); + putchar('\n'); + } + putchar('\n'); + } + return 0; +} diff --git a/HDOJ/4528_autoAC.cpp b/HDOJ/4528_autoAC.cpp new file mode 100644 index 0000000..5a242df --- /dev/null +++ b/HDOJ/4528_autoAC.cpp @@ -0,0 +1,96 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int N = 100 + 10; +char g[N][N]; +int n, m, t; +int sx, sy, dx, dy, ex, ey; +bool vis[N][N][4]; +int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; +struct node +{ + int x, y, step; + int state; + node(){} + node(int xx, int yy, int st):x(xx), y(yy), step(st){ state = 0;} +}; +int BFS() +{ + memset(vis, false, sizeof(vis)); + queue Q; + Q.push(node(sx, sy, 0)); + vis[sx][sy][0] = true; + while(!Q.empty()) + { + node cur = Q.front(); + Q.pop(); + if(cur.step > t) return -1; + for(int k = 0; k < 4; ++k) + { + int x = cur.x + dir[k][0], y = cur.y + dir[k][1]; + if(x < 0 || x >= n || y < 0 || y >= m) continue; + bool flag = false; + if(!(cur.state & 1) && (dx == cur.x || dy == cur.y)) flag = true; + if(!(cur.state & 2) && (ex == cur.x || ey == cur.y)) flag = true; + if(!flag) continue; + while(true) + { + if(g[x][y] == 'X') break; + if(g[x][y] == 'D') { + cur.state |= 1; + break; + } + if(g[x][y] == 'E') { + cur.state |= 2; + break; + } + x += dir[k][0], y += dir[k][1]; + if(x < 0 || x >= n || y < 0 || y >= m) break; + } + } + if(cur.state == 3) { + return cur.step; + } + for(int k = 0; k < 4; ++k) + { + int x = cur.x + dir[k][0], y = cur.y + dir[k][1]; + if(x < 0 || x >= n || y < 0 || y >= m || vis[x][y][cur.state] || g[x][y] == 'X') continue; + if(g[x][y] == 'D' || g[x][y] == 'E') continue; + vis[x][y][cur.state] = true; + node tmp = node(x, y, cur.step + 1); + tmp.state = cur.state; + Q.push(tmp); + } + } + return -1; +} +int main() +{ + int T, cas = 0; + scanf("%d",&T); + while(T--) + { + scanf("%d %d %d",&n, &m, &t); + for(int i = 0; i < n; ++i) + { + scanf("%s",g[i]); + for(int j = 0; j < m; ++j) + { + if(g[i][j] == 'S') + sx = i, sy = j; + if(g[i][j] == 'E') + ex = i, ey = j; + if(g[i][j] == 'D') + dx = i, dy = j; + } + } + g[sx][sy] = '.'; + int ans = BFS(); + printf("Case %d:\n%d\n", ++cas, ans); + } + return 0; +} diff --git a/HDOJ/4529_autoAC.cpp b/HDOJ/4529_autoAC.cpp new file mode 100644 index 0000000..c873fc5 --- /dev/null +++ b/HDOJ/4529_autoAC.cpp @@ -0,0 +1,95 @@ +#include +#include +#include +using namespace std; +int t,N; +char s[10][10]; +bool suit[10][1<<8+5]; +int dp[8][11][1<<8][1<<8]; +int one[1<<8+5]; +inline void init() +{ + memset(suit,0,sizeof(suit)); + for(int i=0;i<8;i++) + { + for(int j=0;j< 1<<8;j++) + { + int tag=1; + for(int k=0;k<8;k++) + { + if(s[i][k]=='*'&&(j&(1<n) continue; + if(!suit[i][j]) continue; + for(int k=0;k< 1<<8;k++) + { + if(one[k]+one[j]>n) continue; + if(k&(j<<2)) continue; + if(k&(j>>2)) continue; + for(int r=0;r< 1<<8;r++) + { + if(one[k]+one[j]+one[r]>n) continue; + if(r&(j<<1)) continue; + if(r&(j>>1)) continue; + dp[i][n][j][k]+=dp[i-1][n-one[j]][k][r]; + } + } + } + int ans=0; + for(int i=0;i< 1<<8;i++) + { + if(suit[7][i]) + { + for(int j=0;j< 1<<8;j++) + { + if(suit[6][j]) + { + ans+=dp[7][N][i][j]; + } + } + } + } + printf("%d\n",ans); + } +} diff --git a/HDOJ/4530_autoAC.cpp b/HDOJ/4530_autoAC.cpp new file mode 100644 index 0000000..3c2e60a --- /dev/null +++ b/HDOJ/4530_autoAC.cpp @@ -0,0 +1,26 @@ +#include +#include +#include +using namespace std; +int main() +{ + int t,q,a,b,i; + double x,ans; + scanf("%d",&t); + while(t--) + { + scanf("%lf%d",&x,&q); + for(i = 1; i<=q; i++) + { + scanf("%d%d",&a,&b); + if(a == 1) + ans = b*60.0-b*x; + else if(a == 2) + ans = b*3600.0/(60.0-x); + else if(a == 3) + ans = 43200*b*60/x; + printf("%.2lf\n",ans); + } + } + return 0; +} diff --git a/HDOJ/4531_autoAC.cpp b/HDOJ/4531_autoAC.cpp new file mode 100644 index 0000000..1b064fb --- /dev/null +++ b/HDOJ/4531_autoAC.cpp @@ -0,0 +1,328 @@ +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +char str[3][3][6]; +char g[3][3][6]; +mapmp; +queueq; +bool mo[6]; +int F[50]; +int find(int x) +{ + if(F[x]==-1)return x; + return F[x]=find(F[x]); +} +void bing(int x,int y) +{ + int t1=find(x); + int t2=find(y); + if(t1!=t2)F[t1]=t2; +} +bool judge(int state) +{ + char temp[10]; + int t[10]; + sprintf(temp,"%09d",state); + for(int i=0;i<9;i++)t[i]=temp[i]-'0'; + for(int i=0;i<3;i++) + for(int j=0;j<3;j++) + { + int p=t[3*i+j]; + int x=p/3; + int y=p%3; + strcpy(g[i][j],str[x][y]); + } + memset(F,-1,sizeof(F)); + for(int i=0;i<3;i++) + for(int j=0;j<3;j++) + { + if(g[i][j][0]==g[i][j][2])bing(12*i+4*j,12*i+4*j+2); + if(g[i][j][0]==g[i][j][3])bing(12*i+4*j,12*i+4*j+3); + if(g[i][j][1]==g[i][j][2])bing(12*i+4*j+1,12*i+4*j+2); + if(g[i][j][1]==g[i][j][3])bing(12*i+4*j+1,12*i+4*j+3); + } + for(int i=0;i<3;i++) + { + if(g[i][0][3]==g[i][1][2])bing(12*i+3,12*i+4+2); + if(g[i][1][3]==g[i][2][2])bing(12*i+4+3,12*i+8+2); + } + for(int j=0;j<3;j++) + { + if(g[0][j][1]==g[1][j][0])bing(4*j+1,12+4*j+0); + if(g[1][j][1]==g[2][j][0])bing(12+4*j+1,24+4*j+0); + } + int R=-1,G=-1,B=-1,O=-1; + for(int i=0;i<3;i++) + for(int j=0;j<3;j++) + for(int k=0;k<4;k++) + { + int t1=find(12*i+4*j+k); + if(g[i][j][k]=='R') + { + if(R==-1)R=t1; + else if(t1!=R)return false; + } + else if(g[i][j][k]=='G') + { + if(G==-1)G=t1; + else if(t1!=G)return false; + } + else if(g[i][j][k]=='B') + { + if(B==-1)B=t1; + else if(t1!=B)return false; + } + else + { + if(O==-1)O=t1; + else if(t1!=O)return false; + } + } + return true; +} +int bfs() +{ + mp.clear(); + while(!q.empty())q.pop(); + int tmp,now; + char ss1[10],ss2[10]; + tmp=12345678; + mp[tmp]=0; + q.push(tmp); + while(!q.empty()) + { + tmp=q.front(); + q.pop(); + if(judge(tmp))return mp[tmp]; + sprintf(ss1,"%09d",tmp); + for(int i=0;i<3;i++) + for(int j=0;j<3;j++) + { + int t=ss1[3*i+j]-'0'; + strcpy(g[i][j],str[t/3][t%3]); + } + if(mo[0]) + { + strcpy(ss2,ss1); + ss2[0]=ss1[1]; + ss2[1]=ss1[2]; + ss2[2]=ss1[0]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + ss2[0]=ss1[2]; + ss2[1]=ss1[0]; + ss2[2]=ss1[1]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + } + if(mo[1]) + { + strcpy(ss2,ss1); + ss2[3]=ss1[4]; + ss2[4]=ss1[5]; + ss2[5]=ss1[3]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + ss2[3]=ss1[5]; + ss2[4]=ss1[3]; + ss2[5]=ss1[4]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + } + if(mo[2]) + { + strcpy(ss2,ss1); + ss2[6]=ss1[7]; + ss2[7]=ss1[8]; + ss2[8]=ss1[6]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + ss2[6]=ss1[8]; + ss2[7]=ss1[6]; + ss2[8]=ss1[7]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + } + if(mo[3]) + { + strcpy(ss2,ss1); + ss2[0]=ss1[3]; + ss2[3]=ss1[6]; + ss2[6]=ss1[0]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + ss2[0]=ss1[6]; + ss2[3]=ss1[0]; + ss2[6]=ss1[3]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + } + if(mo[4]) + { + strcpy(ss2,ss1); + ss2[1]=ss1[4]; + ss2[4]=ss1[7]; + ss2[7]=ss1[1]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + ss2[1]=ss1[7]; + ss2[4]=ss1[1]; + ss2[7]=ss1[4]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + } + if(mo[5]) + { + strcpy(ss2,ss1); + ss2[2]=ss1[5]; + ss2[5]=ss1[8]; + ss2[8]=ss1[2]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + ss2[2]=ss1[8]; + ss2[5]=ss1[2]; + ss2[8]=ss1[5]; + now=0; + for(int i=0;i<9;i++) + { + now*=10; + now+=ss2[i]-'0'; + } + if(mp.find(now)==mp.end()) + { + mp[now]=mp[tmp]+1; + q.push(now); + } + } + } + return -1; +} +int main() +{ + int T; + scanf("%d",&T); + int iCase=0; + while(T--) + { + iCase++; + printf("Case #%d: ",iCase); + for(int i=0;i<6;i++)mo[i]=true; + for(int i=0;i<3;i++) + for(int j=0;j<3;j++) + { + scanf("%s",&str[i][j]); + if(str[i][j][4]=='1') + { + mo[i]=false; + mo[3+j]=false; + } + } + printf("%d\n",bfs()); + } + return 0; +} diff --git a/HDOJ/4532_autoAC.cpp b/HDOJ/4532_autoAC.cpp new file mode 100644 index 0000000..0d799c0 --- /dev/null +++ b/HDOJ/4532_autoAC.cpp @@ -0,0 +1,47 @@ +#include +#include +#include +using namespace std; +const int mod=1000000007; +long long dp[50][520]; +long long C[520][520]; +long long A[520]; +int a[50]; +void Init(){ + C[0][0]=1; + for(int i=1;i<480;i++){ + C[i][0]=1; + for(int j=1;j +#include +const int v = 200005; +int T, N, x; +__int64 a, b, c, A[v], B[v], C[v]; +void f(int s, int t) { + A[s] += a; + B[s] += b; + C[s] += c; + A[t + 1] += -a; + B[t + 1] += -b; + C[t + 1] += -c; +} +void insert(__int64 x1, __int64 y1, __int64 x2, __int64 y2) { + int m = x1 > y1 ? x1 : y1, t = x2 > y2 ? x2 : y2, t2 = x2 > y2 ? y2 : x2; + a = b = c = 0; + c = (x2 - x1) * (y2 - y1); + f(t + 1, v - 5); + a = 1; + b = -(x1 + y1); + c = x1 * y1; + if(t2 >= m) + f(m + 1, t2); + else + t2 = m; + if(y2 > x2) { + a -= 1; + b += x2 + y1; + c -= x2 * y1; + } + else if(x2 > y2) { + a -= 1; + b += x1 + y2; + c -= x1 * y2; + } + f(t2 + 1, t); +} +int main() { + scanf("%d", &T); + while(T--) { + memset(A, 0, sizeof(A)); + memset(B, 0, sizeof(B)); + memset(C, 0, sizeof(C)); + scanf("%d", &N); + for(int i = 0; i < N; ++i) { + __int64 x1, y1, x2, y2; + scanf("%I64d%I64d%I64d%I64d", &x1, &y1, &x2, &y2); + insert(x1, y1, x2, y2); + } + for(int i = 1; i < v; ++i) { + A[i] += A[i-1]; + B[i] += B[i-1]; + C[i] += C[i-1]; + } + scanf("%d", &x); + while(x--) { + __int64 t; + scanf("%I64d", &t); + printf("%I64d\n", t * t * A[t] + t * B[t] + C[t]); + } + } +} diff --git a/HDOJ/4534_autoAC.cpp b/HDOJ/4534_autoAC.cpp new file mode 100644 index 0000000..97473d2 --- /dev/null +++ b/HDOJ/4534_autoAC.cpp @@ -0,0 +1,144 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int N = 1605; +const int inf = 0x3f3f3f3f; +int n; +int sz; +char str[105]; +int del[2][N][1<<8]; +int sco[2][N][1<<8]; +struct Ac_auto { + int ch[N][26]; + int fail[N]; + int sta[N]; + int gain[N]; + char kill[N]; + int idx, root; + int newnd() { + memset(ch[idx], 0, sizeof (ch[idx])); + gain[idx] = sta[idx] = fail[idx] = kill[idx] = 0; + return idx++; + } + void init() { + idx = 0, root = newnd(); + } + void insert(char ss[], int val) { + int len = strlen(ss); + int p = root; + for (int i = 0; i < len; ++i) { + char c = ss[i]-'a'; + if (!ch[p][c]) ch[p][c] = newnd(); + p = ch[p][c]; + } + if (val == 999) sta[p] = 1 << sz; + else if (val == -999) kill[p] = 1; + else gain[p] = val; + } + void build() { + queueq; + for (int i = 0; i < 26; ++i) { + if (ch[root][i]) { + q.push(ch[root][i]); + } + } + while (!q.empty()) { + int p = q.front(); + q.pop(); + for (int i = 0; i < 26; ++i) { + int v = ch[p][i]; + int x = fail[p]; + if (v) { + q.push(v); + while (x && !ch[x][i]) x = fail[x]; + fail[v] = ch[x][i]; + kill[v] |= kill[fail[v]]; + sta[v] |= sta[fail[v]]; + gain[v] += gain[fail[v]]; + } else { + ch[p][i] = ch[x][i]; + } + } + } + } +}; +Ac_auto ac; +void solve() { + memset(del, 0x3f, sizeof (del)); + memset(sco, 0x80, sizeof (sco)); + int cur = 0, nxt = 1; + del[cur][0][0] = 0; + sco[cur][0][0] = 0; + int len = strlen(str); + int lim = 1 << sz; + const int &idx = ac.idx; + for (int i = 0; i < len; ++i) { + int c = str[i]-'a'; + memset(del[nxt], 0x3f, sizeof (del[nxt])); + memset(sco[nxt], 0x80, sizeof (sco[nxt])); + for (int j = 0; j < idx; ++j) { + for (int k = 0; k < lim; ++k) { + if (del[cur][j][k] == inf) continue; + if (del[nxt][j][k] > del[cur][j][k] + 1) { + del[nxt][j][k] = del[cur][j][k] + 1; + sco[nxt][j][k] = sco[cur][j][k]; + } else if (del[nxt][j][k] == del[cur][j][k] + 1) { + if (sco[nxt][j][k] < sco[cur][j][k]) { + sco[nxt][j][k] = sco[cur][j][k]; + } + } + int np = ac.ch[j][c]; + if (ac.kill[np]) continue; + int gain = ac.gain[np]; + int nsta = k|ac.sta[np]; + if (del[nxt][np][nsta] > del[cur][j][k]) { + del[nxt][np][nsta] = del[cur][j][k]; + sco[nxt][np][nsta] = sco[cur][j][k] + gain; + } else if (del[nxt][np][nsta] == del[cur][j][k]) { + if (sco[nxt][np][nsta] < sco[cur][j][k] + gain) { + sco[nxt][np][nsta] = sco[cur][j][k] + gain; + } + } + } + } + swap(cur, nxt); + } + int xdel = inf, xsco; + for (int i = 0; i < idx; ++i) { + if (xdel > del[cur][i][lim-1]) { + xdel = del[cur][i][lim-1]; + xsco = sco[cur][i][lim-1]; + } else if (xdel == del[cur][i][lim-1]) { + xsco = max(xsco, sco[cur][i][lim-1]); + } + } + if (xdel == inf) { + puts("Banned"); + } else { + printf("%d %d\n", xdel, xsco); + } +} +int main() { + int T, ca = 0; + scanf("%d", &T); + while (T--) { + int val; + sz = 0; + ac.init(); + scanf("%d", &n); + for (int i = 0; i < n; ++i) { + scanf("%s %d", str, &val); + ac.insert(str, val); + if (val == 999) ++sz; + } + ac.build(); + scanf("%s", str); + printf("Case %d: ", ++ca); + solve(); + } + return 0; +} diff --git a/HDOJ/4535_autoAC.cpp b/HDOJ/4535_autoAC.cpp new file mode 100644 index 0000000..ce3bffd --- /dev/null +++ b/HDOJ/4535_autoAC.cpp @@ -0,0 +1,26 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define MAXN (100+10) +__int64 f[MAXN]={0,0,1}; +__int64 h = 1000000007; +int main() +{ + int t; + int n; + for (int i=3;i<=100;i++) + { + f[i]=((i-1)*f[i-1]%h+f[i-2]*(i-1)%h)%h; + } + scanf(" %d",&t); + while (t--) + { + scanf(" %d",&n); + printf("%I64d\n",f[n]); + } +} diff --git a/HDOJ/4536_autoAC.cpp b/HDOJ/4536_autoAC.cpp new file mode 100644 index 0000000..72dafb8 --- /dev/null +++ b/HDOJ/4536_autoAC.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +#include +using namespace std; +const int maxn = 20; +int p[maxn], nervous[maxn], n, m, k, max_cnt; +int att[110][3]; +void dfs(int cn) { + if(max_cnt >= k) return ; + if(cn >= k) { + max_cnt = k; return ; + } + int a[3], bak[3]; + for(int v=0; v<3; v++) { + a[0] = att[cn][v]; + a[1] = att[cn][(v+1)%3]; + a[2] = att[cn][(v+2)%3]; + bak[0] = nervous[a[0]]; + bak[1] = nervous[a[1]]; + bak[2] = nervous[a[2]]; + nervous[a[0]] -= 2; + if(nervous[a[0]] < 1) nervous[a[0]] = 1; + nervous[a[1]] += 2; + nervous[a[2]] += 2; + for(int i=0; i 5) { + max_cnt = max(max_cnt, cn); + flag = false; + } + } + if(flag) dfs(cn+1); + for(int i=0; i +#include +#include +#include +#include +using namespace std; +int N, M, idx; +int sta[175], num[175]; +int cnt[15], mp[105]; +int f[105][175][175]; +void print(int x) { + int rec[50] = {0}, p = 0; + while (x) { + rec[p++] = x % 2; + x /= 2; + } + for (int i = 9; i >= 0; --i) { + printf(i == 0 ? "%d\n" : "%d", rec[i]); + } +} +inline bool legal(int x) { + if (x & (x << 2)) return false; + return true; +} +void init() { + int lim; + idx = 1; + for (int k = 1; k <= 10; ++k) { + lim = 1 << k; + for (int i = 1<<(k-1); i < lim; ++i) { + if (legal(i)) { + sta[idx] = i; + for (int j = 0; j < k; ++j) { + if (i & (1 << j)) ++num[idx]; + } + idx++; + } + } + cnt[k] = idx; + } +} +inline bool place(int x, int y) { + return (x & y) == x; +} +inline bool judge_1(int x, int y) { + if ((x << 1) & y || (x >> 1) & y) return false; + return true; +} +inline bool judge_2(int x, int y) { + if (x & y) return false; + return true; +} +int solve() { + int ret = 0; + memset(f, 0, sizeof (f)); + if (N == 1) { + for (int i = 0; i < cnt[M]; ++i) { + if (place(sta[i], mp[1])) { + ret = max(ret, num[i]); + } + } + return ret; + } + for (int i = 0; i < cnt[M]; ++i) { + if (!place(sta[i], mp[2])) continue; + for (int j = 0; j < cnt[M]; ++j) { + if (!place(sta[j], mp[1])) continue; + if (judge_1(sta[i], sta[j])) { + f[2][i][j] = num[i] + num[j]; + } + } + } + for (int i = 3; i <= N; ++i) { + for (int j = 0; j < cnt[M]; ++j) { + if (!place(sta[j], mp[i])) continue; + for (int k = 0; k < cnt[M]; ++k) { + if (!place(sta[k], mp[i-1]) || !judge_1(sta[j], sta[k])) continue; + for (int h = 0; h < cnt[M]; ++h) { + if (!place(sta[h], mp[i-2]) || !judge_1(sta[k], sta[h])) continue; + if (judge_2(sta[j], sta[h])) { + f[i][j][k] = max(f[i][j][k], f[i-1][k][h] + num[j]); + } + } + } + } + } + for (int i = 0; i < cnt[M]; ++i) { + for (int j = 0; j < cnt[M]; ++j) { + ret = max(ret, f[N][i][j]); + } + } + return ret; +} +int main() { + init(); + int c; + while (scanf("%d %d", &N, &M) != EOF) { + memset(mp, 0, sizeof (mp)); + for (int i = 1; i <= N; ++i) { + for (int j = 1; j <= M; ++j) { + scanf("%d", &c); + mp[i] <<= 1; + mp[i] |= c; + } + } + printf("%d\n", solve()); + } + return 0; +} diff --git a/HDOJ/4540_autoAC.cpp b/HDOJ/4540_autoAC.cpp new file mode 100644 index 0000000..2744015 --- /dev/null +++ b/HDOJ/4540_autoAC.cpp @@ -0,0 +1,32 @@ +#include +const int inf=1<<30; +using namespace std; +int map[22][22]; +int dp[22][22]; +int n,m; +int main(){ + while(~scanf("%d%d",&n,&m)){ + for(int i=1;i<=n;i++){ + for(int j=1;j<=m;j++){ + scanf("%d",&map[i][j]); + dp[i][j]=inf; + } + } + for(int i=1;i<=m;i++){ + dp[1][i]=0; + } + for(int i=2;i<=n;i++){ + for(int j=1;j<=m;j++){ + for(int k=1;k<=m;k++){ + dp[i][j]=min(dp[i][j],dp[i-1][k]+abs(map[i][j]-map[i-1][k])); + } + } + } + int ans=inf; + for(int i=1;i<=m;i++){ + ans=min(ans,dp[n][i]); + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4541_autoAC.cpp b/HDOJ/4541_autoAC.cpp new file mode 100644 index 0000000..8ea2bd2 --- /dev/null +++ b/HDOJ/4541_autoAC.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +int s[20][100]; +void inite() +{ + s[3][0]= 4; s[3][1] = 1, s[3][2] = 2, s[3][3] = 6, s[3][4] = 10; + s[4][0] = 4;s[4][1] = 0, s[4][2] = 4, s[4][3] = 5, s[4][4] = 9; + s[5][0] = 6; s[5][1] = 3, s[5][2] = 7, s[5][3] = 8, s[5][4] = 40; + s[5][5] = 50, s[5][6] = 60; + s[6][0] = 6, s[6][1] = 11, s[6][2] = 12, s[6][3] = 20, s[6][4] = 30; + s[6][5] = 80, s[6][6] = 90; + s[7][0] = 3, s[7][1] = 15, s[7][2] = 16, s[7][3] = 70; + s[8][0] = 13, s[8][1] = 13, s[8][2] = 14, s[8][3] = 18, s[8][4] = 19; + s[8][5] = 41, s[8][6] = 42, s[8][7] = 46, s[8][8] = 51, s[8][9] = 52; + s[8][10] = 56,s[8][11] =61 ,s[8][12] = 62,s[8][13] = 66; + s[9][0] = 22, s[9][1] = 17,s[9][2] = 21, s[9][3] = 22,s[9][4] = 26; + s[9][5] = 31, s[9][6] = 32,s[9][7] = 36, s[9][8] = 44,s[9][9] = 45; + s[9][10] = 49,s[9][11] = 54,s[9][12] = 55, s[9][13] = 59,s[9][14] = 64; + s[9][15] = 65, s[9][16] = 69,s[9][17] = 81, s[9][18] = 82,s[9][19] = 86; + s[9][20] = 91, s[9][21] = 92, s[9][22] = 96; + s[10][0] = 25, s[10][1] = 24,s[10][2] = 25, s[10][3] = 29,s[10][4] = 34; + s[10][5] = 35, s[10][6] = 39,s[10][7] = 43, s[10][8] = 47,s[10][9] = 48; + s[10][10] = 53, s[10][11] = 57,s[10][12] = 58, s[10][13] = 63,s[10][14] = 67; + s[10][15] = 68, s[10][16] = 71,s[10][17] = 72, s[10][18] = 76,s[10][19] = 84; + s[10][20] = 85, s[10][21] = 89,s[10][22] = 94, s[10][23] = 95,s[10][24] = 99; + s[10][25] = 100; + s[11][0] = 15, s[11][1] = 23,s[11][2] = 27,s[11][3] = 28,s[11][4] = 33; + s[11][5] = 37, s[11][6] = 38,s[11][7] = 74,s[11][8] = 75,s[11][9] = 79; + s[11][10] = 83, s[11][11] = 87,s[11][12] = 88,s[11][13] = 93,s[11][14] = 97; + s[11][15] = 98; + s[12][0] = 3,s[12][1] = 73,s[12][2] = 77,s[12][3] = 78; +} +int main() +{ + inite(); + int T, cas = 0; + for(scanf("%d", &T); T--; ) + { + int a, b; + scanf("%d%d", &a, &b); + if((a < 3) || a > 12) + printf("Case #%d: -1\n", ++cas); + else + { + if(((s[a][0] < b) && (a != 9)) || ((a == 9) && (s[a][0] + 4< b))) + printf("Case #%d: -1\n", ++cas); + else + { + if(a == 9) + { + if(b <= 22) + printf("Case #%d: %d\n", ++cas, s[a][b]); + else if(b == 23) + printf("Case #%d: 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas); + else if(b == 24) + printf("Case #%d: 20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas); + else if(b == 25) + printf("Case #%d: 60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas); + else if(b == 26) + printf("Case #%d: 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas); + } + else + printf("Case #%d: %d\n", ++cas, s[a][b]); + } + } + } + return 0; +} diff --git a/HDOJ/4542_autoAC.cpp b/HDOJ/4542_autoAC.cpp new file mode 100644 index 0000000..89bef63 --- /dev/null +++ b/HDOJ/4542_autoAC.cpp @@ -0,0 +1,112 @@ +#include +#include +#include +#include +using namespace std; +const int MAXN=100000; +int prime[MAXN+1]; +void getPrime() +{ + memset(prime,0,sizeof(prime)); + for(int i=2;i<=MAXN;i++) + { + if(!prime[i])prime[++prime[0]]=i; + for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++) + { + prime[prime[j]*i]=1; + if(i%prime[j]==0)break; + } + } +} +long long factor[100][2]; +int fatCnt; +int getFactors(long long x) +{ + fatCnt=0; + long long tmp=x; + for(int i=1;prime[i]<=tmp/prime[i];i++) + { + factor[fatCnt][1]=0; + if(tmp%prime[i]==0) + { + factor[fatCnt][0]=prime[i]; + while(tmp%prime[i]==0) + { + factor[fatCnt][1]++; + tmp/=prime[i]; + } + fatCnt++; + } + } + if(tmp!=1) + { + factor[fatCnt][0]=tmp; + factor[fatCnt++][1]=1; + } + return fatCnt; +} +const long long INF=(1LL<<62)+1; +int N; +long long ans; +long long a[47787]; +void dfs(int i,long long x,int n) +{ + if(n>47777)return; + if(xx))a[n]=x; + for(int j=1;j<=62;j++) + { + if(INF/prime[i]=INF)break; + dfs(i+1,x,n*(j+1)); + } +} +int get(int x) +{ + getFactors(x); + int ans=1; + for(int i=0;i +#include +#include +#include +using namespace std; +struct P{ + int x,y,dis; +}; +int N,M,pnum; +int map[80][80],a[80][80]; +P queue[100000]; +int front,rear; +char s[200]; +P point[10000]; +void push(P p){ + queue[rear++] = p; +} +P pop(){ + ++front; + return queue[front - 1]; +} +P D(P p,int dir){ + P p2 = p; + if(dir == 0) --p2.x; + else if(dir == 1) ++ p2.x; + else if(dir == 2) -- p2.y; + else ++p2.y; + return p2; +} +bool check(P p){ + if(p.x >=0 && p.x < N && p.y >=0 && p.y < M && a[p.x][p.y] == 0) + return true; + return false; +} +void BFS() +{ + rear = front = 0; + for(int i=0; i front){ + P p = pop(); + for(int dir =0; dir < 4; dir ++){ + P p2; + p2 = D(p,dir); + if(check(p2)){ + a[p2.x][p2.y] = a[p.x][p.y] + 1; + push(p2); + } + } + } +} +bool cmp(P p1, P p2){ + return p1.dis < p2.dis; +} +int DIS(P p1,P p2){ + return abs(p1.x - p2.x) + abs(p1.y - p2.y); +} +int solve() +{ + BFS(); + pnum = 0; + for(int i=0; i 1){ + P p; + p.x = i; + p.y = j; + p.dis = a[i][j] - 1; + point[pnum++] = p; + } + } + } + if(pnum == 0){ + if(N == 1) return (M-1) / 2; + if(M == 1) return (N-1) / 2; + return (2*N + 2*M - 4)/3; + } + sort(point,point+pnum,cmp); + int q = 0,d = 1; + while(q < pnum){ + bool flag = false; + for(int i=q; i= d && + DIS(point[j],point[k]) >= d){ + flag = true; + break; + } + } + if(flag) break; + } + if(flag) break; + } + if(flag == false) break; + ++d; + while(q < pnum && point[q].dis < d){ + ++q; + } + } + return d-1; +} +int main() +{ + int T,cas = 0; + scanf("%d",&T); + while(T--){ + ++cas; + int ans = 1; + scanf("%d %d",&N,&M); + gets(s); + for(int i=0; i +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +typedef __int64 int64; +const int maxn = 2000005; +const int inf = 0x7fffffff; +const double pi=acos(-1.0); +const double eps = 1e-8; +struct node{ + int pi,di; +}a[ maxn ]; +int cmp( node a,node b ){ + if( a.di!=b.di ) return a.di>b.di; + else return a.pi,greater > q; + for( int i=0;i +#include +#define N 1005 +int main() +{ + char s1[N],s2[N]; + int mark[27][27]; + int i,j; + int flag; + int T; + char x,y; + scanf("%d",&T); + int count=1; + while(T--) + { + getchar(); + gets(s1); + gets(s2); + int n; + scanf("%d",&n); + memset(mark,0,sizeof(mark)); + while(n--) + { + getchar(); + scanf("%c %c",&x,&y); + mark[x-'a'+1][y-'a'+1]=1; + } + int ln1,ln2; + ln1=strlen(s1); + ln2=strlen(s2); + i=0; + j=0; + flag=0; + for(i=0;i +#include +#include +#include +#include +using namespace std; +int n, m; +const int maxn = 10011; +struct Node +{ + int sum; + int nex; + int ith; + Node(){} + Node(int sum_, int nex_, int ith_){sum = sum_, nex = nex_, ith = ith_;} + bool operator<(const Node &b)const + {return b.nex < nex;} +}; +int a[maxn]; +int Cal(int m) +{ + priority_queue q; + Node lin; + lin.sum = 0, lin.nex = a[0], lin.ith = 0; + q.push(lin); + int cnt = 0; + a[n] = 0; + while(cnt < m) + { + lin = q.top(); q.pop(); + if(lin.ith >= n) continue; + q.push(Node(lin.sum, lin.sum + a[lin.ith + 1], lin.ith + 1)); + q.push(Node(lin.nex, lin.nex + a[lin.ith + 1], lin.ith + 1)); + cnt += 1; + } + for(m = 0; !q.empty(); m ++) a[m] = q.top().sum, q.pop(); + sort(a, a + m); + return a[m - 1]; +} +int main() +{ + int i, t, ca; + for(scanf("%d", &t), ca = 1; ca <= t; ca ++) + { + scanf("%d%d", &n, &m); + for(i = 0; i < n; i ++) + scanf("%d", &a[i]); + sort(a, a + n); + printf("Case #%d: %d\n", ca, Cal(m)); + } + return 0; +} diff --git a/HDOJ/4547_autoAC.cpp b/HDOJ/4547_autoAC.cpp new file mode 100644 index 0000000..d87b1d7 --- /dev/null +++ b/HDOJ/4547_autoAC.cpp @@ -0,0 +1,128 @@ +#include +#include +#include +#include +#include +using namespace std; +const int MAX_ = 400010; +mapmp; +struct point { + int to,next, num; +} edge[MAX_], qedge[MAX_]; +struct query { + int u,v,lca; +} q[MAX_]; +int V[MAX_], head[MAX_], d[MAX_], fa[MAX_], ind[MAX_]; +bool vis[MAX_]; +int M,L, T; +int n, m; +void adde(int from,int to,int c) { + edge[M].to = to; + edge[M].num = c; + edge[M].next = V[from]; + V[from] = M++; +} +void addq(int from,int to,int c) { + qedge[L].to = to; + qedge[L].num = c; + qedge[L].next = head[from]; + head[from] = L++; +} +int find(int x) { + if(fa[x] == x)return fa[x]; + else return fa[x] = find(fa[x]); +} +void dfs(int k,int pri,int x) { + d[x] = k; + for(int i = V[x]; i != -1; i = edge[i].next) { + if(edge[i].to != pri) { + dfs(k+1,x,edge[i].to); + } + } +} +void tarjan(int x) { + fa[x] = x; + vis[x] = 1; + for(int i = V[x]; i != -1; i = edge[i].next) { + if(!vis[edge[i].to]) { + tarjan(edge[i].to); + fa[edge[i].to] = x; + } + } + for(int i = head[x]; i != -1; i = qedge[i].next) { + if(vis[qedge[i].to]) { + q[qedge[i].num].lca = find(qedge[i].to); + } + } +} +void solve() { + for(int i = 1; i <= n; i++) { + if(ind[i] == 0) { + dfs(0,-1,i); + tarjan(i); + break; + } + } +} +int capture(char s[]) { + if(mp.find(s) == mp.end()) { + return mp[s] = ++T; + } else return mp[s]; +} +void init() { + memset(V,-1,sizeof(V)); + memset(head,-1,sizeof(head)); + memset(ind,0,sizeof(ind)); + memset(vis,0,sizeof(vis)); + M = L = T = 0; + mp.clear(); + for(int i = 0; i <= n; i++) { + fa[i] = i; + } +} +void read() { + int s,t; + char c1[50],c2[50]; + for(int i = 1; i < n; i++) { + scanf("%s",c1); + scanf("%s",c2); + t = capture(c1); + s = capture(c2); + adde(s,t,1); + adde(t,s,1); + ind[t]++; + } + for(int i = 0; i < m; i++) { + scanf("%s",c1); + scanf("%s",c2); + t = capture(c1); + s = capture(c2); + addq(s,t,i); + addq(t,s,i); + q[i].u = t; + q[i].v = s; + } +} +void print_ans() { + for(int i = 0; i < m; i++) { + int t; + t = d[q[i].u] - d[q[i].lca]; + if(q[i].v != q[i].lca) { + t++; + } + if(q[i].u == q[i].v) t = 0; + printf("%d\n",t); + } +} +int main() { + int Case; + scanf("%d",&Case); + while(Case--) { + scanf("%d%d",&n,&m); + init(); + read(); + solve(); + print_ans(); + } + return 0; +} diff --git a/HDOJ/4548_autoAC.cpp b/HDOJ/4548_autoAC.cpp new file mode 100644 index 0000000..abf1214 --- /dev/null +++ b/HDOJ/4548_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +using namespace std; +bool mark[1000010]; +int num[1000010]; +int k; +int Judge(int n){ + int ans=0; + while(n){ + ans+=n%10; + n/=10; + } + return ans; +} +void IsPrime(){ + memset(mark,true,sizeof(mark)); + mark[0]=mark[1]=false; + k=0; + for(int i=2;i*i<1000000;i++){ + if(mark[i]){ + for(int j=i*i;j<1000000;j+=i) + mark[j]=false; + } + } + for(int i=2;i<=1000010;i++){ + if(mark[i]&&mark[Judge(i)]){ + num[++k]=i; + } + } +} +int Binary_Search(int l,int h,int number){ + while(l<=h){ + int mid=(l+h)/2; + if(num[mid]==number)return mid; + else if(num[mid]>number)h=mid-1; + else l=mid+1; + } + return l; +} +int main(){ + IsPrime(); + int _case,n,m,t=1; + scanf("%d",&_case); + while(_case--){ + scanf("%d%d",&n,&m); + int cnt=0; + int pos1=Binary_Search(1,k,n); + int pos2=Binary_Search(1,k,m); + pos1--; + if(num[pos2]==m)pos2++; + cnt=pos2-pos1-1; + printf("Case #%d: %d\n",t++,cnt); + } + return 0; +} diff --git a/HDOJ/4549_autoAC.cpp b/HDOJ/4549_autoAC.cpp new file mode 100644 index 0000000..c44ce16 --- /dev/null +++ b/HDOJ/4549_autoAC.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +using namespace std; +const int MOD=1e9+7; +struct Matrix +{ + long long mat[2][2]; +}; +Matrix mul(Matrix a,Matrix b) +{ + Matrix ret; + for(int i=0;i<2;i++) + for(int j=0;j<2;j++) + { + ret.mat[i][j]=0; + for(int k=0;k<2;k++) + { + ret.mat[i][j]+=a.mat[i][k]*b.mat[k][j]; + ret.mat[i][j]%=(MOD-1); + } + } + return ret; +} +Matrix pow_M(Matrix a,int n) +{ + Matrix ret; + memset(ret.mat,0,sizeof(ret.mat)); + ret.mat[0][0]=ret.mat[1][1]=1; + Matrix temp=a; + while(n) + { + if(n&1)ret=mul(ret,temp); + temp=mul(temp,temp); + n>>=1; + } + return ret; +} +long long pow_m(long long a,long long n) +{ + long long ret=1; + long long temp=a%MOD; + while(n) + { + if(n&1) + { + ret*=temp; + ret%=MOD; + } + temp*=temp; + temp%=MOD; + n>>=1; + } + return ret; +} +int main() +{ + int a,b,n; + Matrix tmp; + tmp.mat[0][0]=0; + tmp.mat[0][1]=tmp.mat[1][0]=tmp.mat[1][1]=1; + while(scanf("%d%d%d",&a,&b,&n)==3) + { + Matrix p=pow_M(tmp,n); + int ans=(pow_m(a,p.mat[0][0])*pow_m(b,p.mat[1][0]))%MOD; + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4550_autoAC.cpp b/HDOJ/4550_autoAC.cpp new file mode 100644 index 0000000..7d6cc1c --- /dev/null +++ b/HDOJ/4550_autoAC.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +#include +using namespace std; +const int MAXN=110; +char str[MAXN]; +char sta1[MAXN],sta2[MAXN]; +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + scanf("%s",&str); + int n=strlen(str); + int t1=0,t2=0; + int t=n-1; + while(t>0 && str[t]=='0')t--; + for(int i=t;i>=0;i--) + if(str[i]!='0'&&str[i]t;i--)sta2[t2++]=str[i]; + while(t1+t20) + { + int tmp=t-1; + for(int j=tmp-1;j>=0;j--) + if(str[j]tmp;i--)sta2[t2++]=str[i]; + t=tmp; + } + for(int i=0;i=0;i--)printf("%c",sta2[i]); + printf("\n"); + } +} diff --git a/HDOJ/4551_autoAC.cpp b/HDOJ/4551_autoAC.cpp new file mode 100644 index 0000000..dc8eaf1 --- /dev/null +++ b/HDOJ/4551_autoAC.cpp @@ -0,0 +1,48 @@ +#include +#include +using namespace std; +int gcd(int a,int b) +{ + if(b==0) return a; + return gcd(b,a%b); +} +bool run_year(int z) +{ + if((z%4==0&&z%100!=0)||(z%400==0)) + return true; + else + return false; +} +int month[]={0,31,29,31,30,31,30,31,31,30,31,30,31}; +int main() +{ + int T,num=0; + scanf("%d",&T); + while(T--) + { + num++; + int x,y,z; + int fx,fy; + int a,b; + scanf("%d%d%d",&a,&b,&z); + int ans=0; + for(x=1;x<=12;x++) + { + for(y=1;y<=month[x];y++) + { + int g=gcd(x,y); + if(a==g&&(b==(x*y)/g)) + { + if(x==2&&y==29&&!run_year(z)) continue; + ans++; + fx=x;fy=y; + } + } + } + if(ans==0) printf("Case #%d: -1\n",num); + else if(ans==1) printf("Case #%d: %04d/%02d/%02d\n",num,z,fx,fy); + else + printf("Case #%d: 1\n",num); + } + return 0; +} diff --git a/HDOJ/4553_autoAC.cpp b/HDOJ/4553_autoAC.cpp new file mode 100644 index 0000000..928e48d --- /dev/null +++ b/HDOJ/4553_autoAC.cpp @@ -0,0 +1,196 @@ +#include +#include +#include +using namespace std; +const int L = 100000+10; +struct node +{ + int d,n,s; + int ls,rs,ms; + int nsl,nsr,nsm; +} a[L<<2]; +void diaosi(int l,int r,int i) +{ + a[i].d = 1; + a[i].ls = a[i].rs = a[i].ms = 0; +} +void nvshen(int l,int r,int i) +{ + a[i].n = 1; + a[i].d = 0; + a[i].ls = a[i].rs = a[i].ms = 0; + a[i].nsl = a[i].nsr = a[i].nsm = 0; +} +void xuexi(int l,int r,int i) +{ + a[i].s = 1; + a[i].d = a[i].n = 0; + a[i].ls = a[i].rs = a[i].ms = r-l+1; + a[i].nsl = a[i].nsr = a[i].nsm = r-l+1; +} +void pushup(int l,int r,int i) +{ + int mid = (l+r)>>1; + a[i].ms = max(a[2*i].ms,a[2*i+1].ms); + a[i].ms = max(a[i].ms,a[2*i].rs+a[2*i+1].ls); + a[i].ls = a[2*i].ls; + a[i].rs = a[2*i+1].rs; + if(a[2*i].ls == mid-l+1) + a[i].ls+=a[2*i+1].ls; + if(a[2*i+1].rs == r-mid) + a[i].rs+= a[2*i].rs; + a[i].nsm = max(a[2*i].nsm,a[2*i+1].nsm); + a[i].nsm = max(a[i].nsm,a[2*i].nsr+a[2*i+1].nsl); + a[i].nsl = a[2*i].nsl; + a[i].nsr = a[2*i+1].nsr; + if(a[2*i].nsl == mid-l+1) + a[i].nsl+=a[2*i+1].nsl; + if(a[2*i+1].nsr == r-mid) + a[i].nsr+= a[2*i].nsr; +} +void pushdown(int l,int r,int i) +{ + int mid = (l+r)>>1; + if(a[i].s) + { + xuexi(l,mid,2*i); + xuexi(mid+1,r,2*i+1); + a[i].s = 0; + } + if(a[i].d) + { + diaosi(l,mid,2*i); + diaosi(mid+1,r,2*i+1); + a[i].d = 0; + } + if(a[i].n) + { + nvshen(l,mid,2*i); + nvshen(mid+1,r,2*i+1); + a[i].n = 0; + } +} +void study(int L,int R,int l,int r,int i) +{ + if(L == l && R == r) + { + xuexi(l,r,i); + return ; + } + int mid = (l+r)>>1; + pushdown(l,r,i); + if(R<=mid) + study(L,R,l,mid,2*i); + else if(L>mid) + study(L,R,mid+1,r,2*i+1); + else + { + study(L,mid,l,mid,2*i); + study(mid+1,R,mid+1,r,2*i+1); + } + pushup(l,r,i); +} +void insert(int flag,int L,int R,int l,int r,int i) +{ + if(l == L && r == R) + { + if(!flag) + diaosi(l,r,i); + else + nvshen(l,r,i); + return ; + } + int mid = (l+r)>>1; + pushdown(l,r,i); + if(R<=mid) + insert(flag,L,R,l,mid,2*i); + else if(L>mid) + insert(flag,L,R,mid+1,r,2*i+1); + else + { + insert(flag,L,mid,l,mid,2*i); + insert(flag,mid+1,R,mid+1,r,2*i+1); + } + pushup(l,r,i); +} +int query(int flag,int t,int l,int r,int i) +{ + if(l==r) + return l; + int mid = (l+r)>>1; + pushdown(l,r,i); + if(!flag) + { + if(a[2*i].ms>=t) + return query(flag,t,l,mid,2*i); + else if(a[2*i].rs+a[2*i+1].ls>=t) + return mid-a[2*i].rs+1; + else + return query(flag,t,mid+1,r,2*i+1); + } + else + { + if(a[2*i].nsm>=t) + return query(flag,t,l,mid,2*i); + else if(a[2*i].nsr+a[2*i+1].nsl>=t) + return mid-a[2*i].nsr+1; + else + return query(flag,t,mid+1,r,2*i+1); + } +} +int main() +{ + int t,i,x,y,ans,cas = 1,n,m; + char str[20]; + scanf("%d",&t); + while(t--) + { + scanf("%d%d",&n,&m); + printf("Case %d:\n",cas++); + study(1,n,1,n,1); + while(m--) + { + scanf("%s",str); + if(str[0] == 'D') + { + scanf("%d",&x); + if(a[1].ms +#include +#include +#include +using namespace std; +int numa[11],numb[11]; +int main() +{ + int T,a,b; + scanf("%d",&T); + while(T--) + { + scanf("%d%d",&a,&b); + int x=(a+b)/2; + int y=a-x; + int coua=0,coub=0; + int ita=abs(x); + int itb=abs(y); + while(ita) + { + numa[coua++]=ita%10; + ita/=10; + } + while(itb) + { + numb[coub++]=itb%10; + itb/=10; + } + int xx=0,yy=0; + for(int i=0;i +#include +#include +using namespace std; +const int maxn=1000011; +int n; +long long ans[maxn],phi[maxn]; +void Phi(int n) +{ + phi[1]=1; + for(int i=2;i<=n;i++) + if(!phi[i]) + for(int j=i;j<=n;j+=i) + { + if(!phi[j]) + phi[j]=j; + phi[j]=phi[j]/i*(i-1); + } +} +int main() +{ + Phi(maxn-1); + ans[1]=2; + ans[2]=3; + for(int i=3;i +#include +#include +#include +using namespace std; +struct node +{ + string name; + int grade; + int time; + node(string s,int a,int b):name(s),grade(a),time(b){} + friend bool operator<(const node& a,const node& b) + { + if(a.grade!=b.grade) + return a.grade=b.grade; + } +}; +int main() +{ + int cas,n,num; + cin>>cas; + string op,name; + int time; + for(int c=1;c<=cas;c++) + { + cin>>n;printf("Case #%d:\n",c); + listli; + time=1; + for(int i=0;i>op; + if(op[0]=='A') + { + cin>>name>>num; + li.push_back(node(name,num,i)); + li.sort(); + cout<>num; + list::iterator iter=find(li.begin(),li.end(),node("",num,0)); + if(iter!=li.end()) + { + cout<name< +#include +#include +#include +#define MP make_pair +#define SQ(x) ((x)*(x)) +typedef long long int64; +const double PI = acos(-1.0); +const int MAXN = 110; +const int INF = 0x3f3f3f3f; +using namespace std; +const int MOD = 1000000007; +int n, m; +int f[2][480][22][2]; +int mat[480][480]; +char str[1000]; +int main(){ + int nCase, cas=1; + scanf("%d", &nCase); + while(nCase--){ + scanf("%d%d%*c", &n, &m); + for(int i=1; i<=n; ++i){ + gets(str); + for(int j=1; j<=m; ++j) + mat[i][j] = str[j-1]-'0'; + } + memset(f, 0, sizeof(f)); + int ans = 0; + bool p = 0; + for(int i=1; i<=n; ++i){ + p = !p; + memset(f[p], 0, sizeof(f[p])); + for(int j=1; j<=m; ++j){ + for(int k=0; k<=10; ++k){ + int x1 = (k+mat[i][j])%11; + int x2 = (k-mat[i][j]+11)%11; + f[p][j][k][0] += ((f[!p][j][x1][1]+f[p][j-1][x1][1])%MOD)%MOD; + f[p][j][k][1] += ((f[!p][j][x2][0]+f[p][j-1][x2][0])%MOD)%MOD; + } + ++f[p][j][11-mat[i][j]][0]; + } + for(int j=1; j<=m; ++j){ + ans += (f[p][j][0][0] + f[p][j][0][1])%MOD; + ans %= MOD; + } + } + printf("Case %d: %d\n",cas++, ans); + } + return 0; +} diff --git a/HDOJ/4559_autoAC.cpp b/HDOJ/4559_autoAC.cpp new file mode 100644 index 0000000..85177e3 --- /dev/null +++ b/HDOJ/4559_autoAC.cpp @@ -0,0 +1,54 @@ +#include +#include +#include +#include +#include +#include +#include +#define ll __int64 +#define pi acos(-1.0) +#define MAX 5000 +using namespace std; +int an[2][MAX],sg[MAX]; +bool vis[MAX]; +int getsg(int x) +{ + int i; + if(sg[x]>=0) return sg[x]; + memset(vis,0,sizeof(vis)); + for(i=0;i<=x-i-1;i++) + vis[getsg(i)^getsg(x-i-1)^1]=1; + for(i=0;i<=x-i-2;i++) + vis[getsg(i)^getsg(x-i-2)]=1; + i=0; + while(vis[i]) i++; + return sg[x]=i; +} +int main(){ + int t,m,n,s,c,ans,i,k=0,len; + memset(sg,-1,sizeof(sg)); + sg[0]=0; + for(i=1;i<=4747;i++) sg[i]=getsg(i); + scanf("%d",&t); + while(t--){ + scanf("%d %d",&n,&m); + memset(an,0,sizeof(an)); + for(i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN=1100; +int maze[MAXN][MAXN]; +int gap[MAXN],dis[MAXN],pre[MAXN],cur[MAXN]; +int flow[MAXN][MAXN]; +int sap(int start,int end,int nodenum) +{ + memset(cur,0,sizeof(cur)); + memset(dis,0,sizeof(dis)); + memset(gap,0,sizeof(gap)); + memset(flow,0,sizeof(flow)); + int u=pre[start]=start,maxflow=0,aug=-1; + gap[0]=nodenum; + while(dis[start]maze[u][v]-flow[u][v])aug=maze[u][v]-flow[u][v]; + pre[v]=u; + u=cur[u]=v; + if(v==end) + { + maxflow+=aug; + for(u=pre[u];v!=start;v=u,u=pre[u]) + { + flow[u][v]+=aug; + flow[v][u]-=aug; + } + aug=-1; + } + goto loop; + } + int mindis=nodenum-1; + for(int v=0;vdis[v]) + { + cur[u]=v; + mindis=dis[v]; + } + if((--gap[dis[u]])==0)break; + gap[dis[u]=mindis+1]++; + u=pre[u]; + } + return maxflow; +} +bool used[MAXN][MAXN]; +int main() +{ + int T; + int N,M,L,K; + scanf("%d",&T); + int iCase=0; + while(T--) + { + iCase++; + scanf("%d%d%d%d",&N,&M,&L,&K); + memset(maze,0,sizeof(maze)); + int u,v; + memset(used,false,sizeof(used)); + while(L--) + { + scanf("%d%d",&u,&v); + used[u][v]=true; + } + for(int i=N+1;i<=N+M;i++)maze[i][i+M]=K; + for(int i=1;i<=N;i++) + for(int j=1;j<=M;j++) + { + if(used[i][j]) + { + maze[i][j+N+M]=1; + } + else maze[i][j+N]=1; + } + int ans=0; + int l=0,r=M; + while(l<=r) + { + int mid=(l+r)/2; + for(int i=1;i<=N;i++)maze[0][i]=mid; + for(int i=N+M+1;i<=N+2*M;i++)maze[i][N+2*M+1]=mid; + if(sap(0,N+2*M+1,N+2*M+2)==mid*N) + { + ans=mid; + l=mid+1; + } + else r=mid-1; + } + printf("Case %d: %d\n",iCase,ans); + } + return 0; +} diff --git a/HDOJ/4561_autoAC.cpp b/HDOJ/4561_autoAC.cpp new file mode 100644 index 0000000..41a7ebc --- /dev/null +++ b/HDOJ/4561_autoAC.cpp @@ -0,0 +1,72 @@ +#include +#include +#include +using namespace std; +int tCase,n,a[10000+1]; +int num[10000+1]; +int z,f,o; +int solve(int s,int t) +{ + f=0; + for(int i=s;i=s;i--) + { + if(a[i]<0) + { + tag2=i; + break; + } + } + a2=tag2-s; + a4=t-1-tag2; + if(a2 +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN=1010; +struct Node +{ + int x,y; + int r; +}; +bool cmp(Node a,Node b) +{ + return a.rnode[i].r*node[i].r&&d2>node[i].r*node[i].r)continue; + if(d1node1[j].r && d<(node1[i].r-node1[j].r)*(node1[i].r-node1[j].r)) + dp1[i]=max(dp1[i],dp1[j]+1); + } + ans1=max(ans1,dp1[i]); + } + for(int i=0;inode2[j].r && d<(node2[i].r-node2[j].r)*(node2[i].r-node2[j].r)) + dp2[i]=max(dp2[i],dp2[j]+1); + } + ans2=max(ans2,dp2[i]); + } + int ans=max(ans1,ans2); + for(int i=0;i(node1[i].r+node2[j].r)*(node1[i].r+node2[j].r)) + ans=max(ans,dp1[i]+dp2[j]); + } + printf("%d\n",ans); + } + return 0; +} diff --git a/HDOJ/4563_autoAC.cpp b/HDOJ/4563_autoAC.cpp new file mode 100644 index 0000000..739bc8e --- /dev/null +++ b/HDOJ/4563_autoAC.cpp @@ -0,0 +1,72 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define N 100010 +#define E 100010 +#define ll long long +const int INF =0x3fffffff; +const int PRIME =999983; +const int MOD =1000000007; +const int MULTI =1000000007; +const double EPS=1e-8; +#define CUBE(x) ((x)*(x)*(x)) +#define SQ(x) ((x)*(x)) +#define ALL(x) x.begin(),x.end() +#define CLR(x,a) memset(x,a,sizeof(x)) +#define maxAry(a,n) max_element(a,a+(n)) +#define minAry(a,n) min_element(a,a+(n)) +inline bool isodd(int x){return x&1;} +inline bool isodd(ll x) {return x&1;} +double dp[110]; +int vx[110],vy[110]; +int n,L; +double gao(int x) +{ + fill(dp,dp+L+1,-1); + dp[0]=0; + for(int i=0;i=0;j--){ + for(int k=0;k<=100;k++){ + if(j-vx[i]*k<0 || dp[j-vx[i]*k]==-1) continue; + if(dp[j]==-1) dp[j]=dp[j-vx[i]*k]+vy[i]*k-0.5*9.8*SQ(k); + else dp[j]=max(dp[j],dp[j-vx[i]*k]+vy[i]*k-0.5*9.8*SQ(k)); + } + } + } + double ans=-INF; + for(int i=0;i<=L;i++){ + if(dp[i]==-1) continue; + double t=1.0*(L-i)/vx[x]; + ans=max(ans,dp[i]+vy[x]*t-0.5*9.8*SQ(t)); + } + return ans; +} +int main() +{ + int re,Case=1; + double ans; + scanf("%d",&re); + while(re--){ + scanf("%d%d",&n,&L); + for(int i=0;i +typedef long long llg; +llg a,b,n,m; +void solve(){ + llg ans1(1),ans2(0),t1(a),t2(1); + llg tmp; + while(n){ + if(n&1){ + tmp = ans1; + ans1 = (ans1*t1+ans2*t2*b)%m; + ans2 = (tmp*t2+ans2*t1)%m; + } + tmp = t1; + t1 = (t1*t1+t2*t2*b)%m; + t2 = 2*tmp*t2%m; + n >>= 1; + } + printf("%lld\n",ans1*2%m); +} +int main(){ + while(~scanf("%lld%lld%lld%lld",&a,&b,&n,&m)) + solve(); + return 0; +} diff --git a/HDOJ/4566_autoAC.cpp b/HDOJ/4566_autoAC.cpp new file mode 100644 index 0000000..c98fa73 --- /dev/null +++ b/HDOJ/4566_autoAC.cpp @@ -0,0 +1,106 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int N = 100000; +const int M = 50; +const LL MAXS = 1LL<<50; +const LL MAXT = (LL)1e16; +inline LL two( int x ) { return 1LL<0; + bitt[i] = (t&two(i))>0; + } + ran[0][0][0] = n; + ran[0][1][0] = 0; + for( int i = 1; i <= n; ++i ) { + ran[0][0][i] = i-1; + } + for( int i = 1; i <= m; ++i ) { + int cur = i&1, pre = cur^1 ; + fill( f[i], f[i]+n+1, 0 ); + fill( g[i], g[i]+n+1, 0 ); + for( int j = 0 ; j < 2; ++j ) ran[cur][j][0] = 0; + for( int j = 1 ; j >= 0; --j ) { + for( int k = 1 ; k <= ran[pre][j][0]; ++k ) { + int idx = ran[pre][j][k]; + if( a[idx] & two(i-1) ) ran[cur][1][ ++ran[cur][1][0] ] = idx ; + else ran[cur][0][ ++ran[cur][0][0] ] = idx ; + } + } + int oneCnt = 0, curOnes = ran[cur][1][0], curZeros = ran[cur][0][0]; + for( int j = 0; j <= n; ++j ) { + int idx = -1, presize1 = ran[pre][1][0]; + if( j > presize1 ) { + idx = ran[pre][0][j-presize1]; + } else { + if( j > 0 ) idx = ran[pre][1][j]; + } + if( idx != -1 && (a[idx]&two(i-1)) != 0 ) { + ++oneCnt; + } + int tBit = bitt[i-1]; + int curOne = curOnes + j - 2*oneCnt; + if( (curOne&1) == bits[i-1] ) { + if( tBit == 0 ) { + f[i][ oneCnt ] += f[i-1][j]; + g[i][ oneCnt ] += g[i-1][j]; + } else { + f[i][ oneCnt ] += f[i-1][j]+g[i-1][j]; + } + } + curOne = curZeros - j + 2*oneCnt; + int nextOne = j + curOnes - oneCnt; + if( (curOne&1) == bits[i-1] ) { + if( tBit == 0 ) { + g[i][ nextOne ] += g[i-1][j] + f[i-1][j]; + } else { + f[i][ nextOne] += f[i-1][j]; + g[i][ nextOne] += g[i-1][j]; + } + } + } + } + ans1 = ans2 = 0; + for( int i = 0 ; i <= n; ++i ) { + ans1 += f[m][i]; + ans2 += g[m][i]; + } + ans2 += ans1; + return ; +} +int main() { + LL t; + int start = clock(); + while( scanf("%d%d%lld%lld",&n,&m,&s,&t) != EOF ) { + if( t > MAXT ) { + cerr< +#include +#include +#include +#include +#include +using namespace std; +__int64 l[1000005],v[1000005],r; +int main() +{ + __int64 n,i,j,k,b; + int t=0; + while(~scanf("%I64d",&n)) + { + t++; + if(t>=40) continue; + memset(l,0,sizeof l); + for(i=1;i<=n;i++) + { + scanf("%I64d",&v[i]); + l[i]=l[i-1]+v[i]+1; + if(l[i-1]<=v[i]) k=i; + } + for(i=k+1,r=0,b=0;i<=n;i++) + { + b+=(v[i]<=b); + r+=max(0ll,v[i]-b); + } + if((r+l[k-1])==v[k]) printf("%I64d\n",k); + else if((r+l[k-1])>v[k]) printf("Unknown\n"); + else printf("Bad Rescue\n"); + } + return 0; +} diff --git a/HDOJ/4568_autoAC.cpp b/HDOJ/4568_autoAC.cpp new file mode 100644 index 0000000..c531a25 --- /dev/null +++ b/HDOJ/4568_autoAC.cpp @@ -0,0 +1,92 @@ +#include +#include +#include +#include +#include +using namespace std; +#define MAXN 222 +#define inf 1<<30 +struct Point{ + int x,y; +}point[MAXN]; +int value[MAXN][MAXN]; +int map[MAXN][MAXN]; +int dist[MAXN][MAXN]; +int dd[MAXN]; +bool mark[MAXN][MAXN]; +int dp[1<<14][14]; +int n,m,k; +int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}}; +void spfa(int num) +{ + memset(mark,false,sizeof(mark)); + for(int i=0;i >que; + que.push(make_pair(point[num].x,point[num].y)); + if(dist[point[num].x][point[num].y]==-1)return; + dist[point[num].x][point[num].y]=0; + while(!que.empty()){ + int x=que.front().first,y=que.front().second; + que.pop(); + mark[x][y]=false; + if(x==0||x==(n-1)||y==0||y==(m-1)){ + dd[num]=min(dd[num],dist[x][y]); + } + for(int i=0;i<4;i++){ + int xx=x+dir[i][0],yy=y+dir[i][1]; + if(xx>=0&&xx=0&&yy +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int a[5], pri, n; +__int64 f(int x,int i) +{ + int j; + __int64 sum=0; + for(j=0;j>cse; + for(int t=1;t<=cse;t++) + { + scanf("%d",&n); + for(int i=0;i<=n;i++) scanf("%d",&a[i]); + scanf("%d",&pri); + printf("Case #%d: ",t); + solve(); + } + return 0; +} diff --git a/HDOJ/4570_autoAC.cpp b/HDOJ/4570_autoAC.cpp new file mode 100644 index 0000000..39ef8da --- /dev/null +++ b/HDOJ/4570_autoAC.cpp @@ -0,0 +1,45 @@ +#include +#include +#include +using namespace std; +int n; +__int64 dp[70][70],a[70],sum[70]; +__int64 pow(__int64 n) +{ + __int64 ans= 1; + int i; + for(i = 1; i<=n; i++) + ans*=2; + return ans; +} +int main() +{ + int t,i,j,k,s; + scanf("%d",&t); + while(t--) + { + scanf("%d",&n); + memset(sum,0,sizeof(sum)); + for(i = 1; i<=n; i++) + { + scanf("%I64d",&a[i]); + sum[i] = sum[i-1]+a[i]; + } + memset(dp,0,sizeof(dp)); + for(s = 0; s<=n; s++) + { + for(i = 1; i<=n && i+s<=n; i++) + { + j = i+s; + if(s<=19) + dp[i][j] =a[i]*pow(j-i)*2; + else + dp[i][j] = (sum[j]-sum[i-1])*2; + for(k = i; k<=j; k++) + dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]); + } + } + printf("%I64d\n",dp[1][n]); + } + return 0; +} diff --git a/HDOJ/4571_autoAC.cpp b/HDOJ/4571_autoAC.cpp new file mode 100644 index 0000000..4841c88 --- /dev/null +++ b/HDOJ/4571_autoAC.cpp @@ -0,0 +1,102 @@ +#include +#include +#include +#include +#include +using namespace std; +const int maxn=110; +const int oo=0x3fffffff; +int S[maxn], C[maxn]; +int mp[maxn], visit[maxn][3*maxn]; +int map[maxn][maxn], cap[maxn][maxn], dis[maxn][3*maxn]; +int n, m, V, T, st, sd, ss, dd; +struct node +{ + int u, t; +}; +void floyd() +{ + ss=n, dd=n+1, S[dd]=0; + for(int k=0; kmap[i][k]+map[k][j]) map[i][j]=map[i][k]+map[k][j]; + for(int i=0; iq; + for(int i=0; i<=n+1; i++) + for(int j=0; j<=V; j++) dis[i][j]=-oo, visit[i][j]=0; + node s, p; + s.u=ss, s.t=0; + q.push(s); + dis[ss][0]=0; + visit[ss][0]=1; + while(!q.empty()) + { + p=q.front(); + q.pop(); + visit[p.u][p.t]=0; + for(int i=0; i<=n+1; i++) + { + if(p.u!=i&&cap[p.u][i]!=oo) + { + int tp=p.t+cap[p.u][i]; + if(tp<=V&&dis[i][tp]> T; + for(int tcase=1; tcase<=T; tcase++) + { + scanf("%d%d%d%d%d",&n,&m,&V,&st,&sd); + for(int i=0; i<=n+1; i++) + for(int j=0; j<=n+1; j++) + { + map[i][j]=oo, cap[i][j]=oo; + if(i==j) map[i][j]=cap[i][j]=0; + } + for(int i=0; i +#include +#include +#include +using namespace std; +int main() +{ + int N,M; + while(scanf("%d%d",&M,&N)!=EOF) + { + printf("%d\n",(M+(M-(N-1)/2)+1)*(N-1)/4+(M+(M-(N+1)/2)+1)*(N+1)/4); + } + return 0; +} diff --git a/HDOJ/4573_autoAC.cpp b/HDOJ/4573_autoAC.cpp new file mode 100644 index 0000000..08b6c2c --- /dev/null +++ b/HDOJ/4573_autoAC.cpp @@ -0,0 +1,121 @@ +#include +#include +#include +using namespace std; +#define db double +#define rt return +#define cs const +#define cp const P& +#define op operator +cs db eps = 1e-9; +inline int sig(db x){rt (x>eps)-(x<-eps);} +cs int N = 10001; +struct P { + db x, y, z; + P(db a = 0, db b = 0, db c = 0):x(a),y(b),z(c){} + void in(){scanf("%lf%lf%lf", &x, &y, &z);} + P op+(cp a)cs{rt P(x+a.x, y+a.y, z+a.z);} + P op-(cp a)cs{rt P(x-a.x, y-a.y, z-a.z);} + P op*(cs db&k)cs{rt P(x*k, y*k, z*k);} + P op^(cp a)cs{rt P(y*a.z-a.y*z, z*a.x-a.z*x, x*a.y-a.x*y);} + db op*(cp a)cs{rt x*a.x + y*a.y + z*a.z;} + P cross(P a, P b){rt a-*this ^ b-*this;} + db dot(P a, P b){rt (a-*this) * (b-*this);} + db L(){rt sqrt(x*x + y*y + z*z);} + db V6(P b, P c){rt (b ^ c) * (*this);} +}p[N]; +int n; +db diff_vol, max_diff; +struct convex { + int cnt, blg[N][N]; + struct face { + int a, b, c, is; + face(int x=0,int y=0,int z=0,int w=0):a(x),b(y),c(z),is(w){} + int visible(P me) { + rt sig(p[a].cross(p[b],p[c]) * (me-p[a])) > 0; + } + }fac[N*10]; + int col(int a, int b, int c){rt p[a].cross(p[b],p[c]).L() < eps;} + int cop(int a, int b, int c, int d){rt !sig(p[a].cross(p[b],p[c])*(p[d]-p[a]));} + void deal(int k, int a, int b) { + int f = blg[a][b]; + if(fac[f].is) { + if(fac[f].visible(p[k])) dfs(k, f); + else { + diff_vol += p[b].V6(p[a], p[k]); + face add = face(b, a, k, 1); + blg[b][a] = blg[a][k] = blg[k][b] = cnt; + fac[cnt++] = add; + } + } + } + void dfs(int k, int cur) { + diff_vol -= p[fac[cur].a].V6(p[fac[cur].b], p[fac[cur].c]); + fac[cur].is = 0; + deal(k, fac[cur].b, fac[cur].a); + deal(k, fac[cur].c, fac[cur].b); + deal(k, fac[cur].a, fac[cur].c); + } + void init() { + cnt = 0; + for(int i = 0; i < 4; i++) { + face add = face((i+1)%4, (i+2)%4, (i+3)%4, 1); + if(add.visible(p[i])) swap(add.b, add.c); + blg[add.a][add.b] = blg[add.b][add.c] = blg[add.c][add.a] = cnt; + fac[cnt++] = add; + } + } + void update(int k) { + for(int i = 0; i < cnt; i++) + if(fac[i].is && fac[i].visible(p[k])) { + dfs(k, i); break; + } + } + db volume() { + db v = 0.; + for(int i = 0; i < cnt; i++) + v += fac[i].is * p[fac[i].a].V6(p[fac[i].b], p[fac[i].c]); + rt v / 6.; + } +}hull; +void solve(int number, int cas) { + max_diff = 0.; + int king = 1, tag = 1; + p[0].in(); + for(int i = 1; i < number; i++) { + p[i].in(); + if(tag == 1) { + tag += sig((p[0]-p[i]).L()); + if(tag > 1) swap(p[1], p[i]); + continue; + } + if(tag == 2) { + tag += sig((p[0].cross(p[1], p[i])).L()); + if(tag > 2) swap(p[2], p[i]); + continue; + } + if(tag == 3) { + tag += sig(p[0].cross(p[1], p[2]) * (p[i]-p[0])) != 0; + if(tag > 3) { + swap(p[3], p[i]); + hull.init(); + for(int j = 4; j <= i; j++) hull.update(j); + king = i + 1, max_diff = hull.volume(); + } + continue; + } + diff_vol = 0.; + hull.update(i); + diff_vol /= 6.; + if(sig(diff_vol - max_diff) > 0) { + max_diff = diff_vol; + king = i + 1; + } + } + printf("Case #%d:\n%d %.2lf\n", cas, king, max_diff); +} +int main() { + int number, cas = 1; + while(scanf("%d", &number) != -1) solve(number, cas++); + rt 0; +} diff --git a/HDOJ/4574_autoAC.cpp b/HDOJ/4574_autoAC.cpp new file mode 100644 index 0000000..2db884d --- /dev/null +++ b/HDOJ/4574_autoAC.cpp @@ -0,0 +1,84 @@ +#include +#include +#include +#include +#include +#include +#define mp(a , b) make_pair(a , b) +using namespace std; +typedef long long LL; +const LL inf = 1000000000LL; +int a , b , l , r , k; +int pow (int a , int b) { + int ret = 1; + for (int i = 0 ; i < b ; i ++) { + ret = ret * a; + if (ret > inf || ret <= 0) + return inf + 1; + } + return ret; +} +int gao (int c , int a , int b , int l , int r , int k) { + if (c == 0) return l <= r; + if (c == 1) { + if (l > r) return 0; + return max (0 , min(r , b) - max (l , a) + 1); + } + int down = max(a , l / pow(b , c - 1)); + int up = min (b , r / pow(a , c - 1)); + int ret = 0; + for (int i = down ; i <= up ; i ++) { + ret += gao (c - 1 , i , b , (l + i - 1) / i , r / i , k - ret); + if (ret > k) return ret; + } + return ret; +} +int ret , ans[50]; +void fuck (int c , int a , int b , int l , int r , int k) { + if (c == 0) return; + if (c == 1) { + int num = k + max(l , a) - 1; + ret = ret * num; + ans[c] = num; + return ; + } + int down = max(a , l / pow(b , c - 1)); + int up = min (b , r / pow(a , c - 1)); + for (int i = down ; i <= up ; i ++) { + int cnt = gao (c - 1 , i , b , (l + i - 1) / i , r / i , k); + if (k > cnt) { + k -= cnt; + continue; + } + ret = ret * i; + ans[c] = i; + fuck (c - 1 , i , b , (l + i - 1) / i , r / i , k); + return ; + } +} +int main () { + int t , cas = 0; + scanf ("%d" , &t); + while (t --) { + bool ok = false; + scanf ("%d %d %d %d %d" , &a , &b , &l , &r , &k); + printf ("Case #%d: " , ++ cas); + for (int i = 1 ; i <= 30 ; i ++) { + int cnt = gao (i , a , b , l , r , k); + if (k > cnt) { + k -= cnt; + continue; + } + ret = 1; + fuck (i , a , b , l , r , k); + printf ("%d\n" , ret); + for (int j = i ; j >= 1 ; j --) { + printf ("%d%c" , ans[j] , j == 1 ? '\n' : ' '); + } + ok = true; + break; + } + if (!ok) puts("-1"); + } + return 0; +} diff --git a/HDOJ/4575_autoAC.cpp b/HDOJ/4575_autoAC.cpp new file mode 100644 index 0000000..7466d77 --- /dev/null +++ b/HDOJ/4575_autoAC.cpp @@ -0,0 +1,196 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define inf 9e99 +#define eps 1e-9 +#define x first +#define y second +#define pb push_back +#define sz(a) int(a.size()) +#define rep(i,a,b) for(int i=a;i<=b;i++) +template inline void gmin(T&a,T b) {if(a>b)a=b;} +template inline T sqr(T a) {return a*a;} +#define N 20020 +vector to[N],len[N]; +int col[N],n; +double sum[N],L; +#define is_leaf(x) sz(to[x])==1 && sum[to[x][0]] path,tmp[N]; +double dp1[N],ans1[N]; +double dp2[N],ans2[N]; +double Y1(int j) {return dp1[j]+sqrt(dp1[j])+sqr(sum[j])+2.0*sum[j]*L;} +double Y2(int j) {return dp2[j]+sqrt(dp2[j])+sqr(sum[j])-2.0*sum[j]*L;} +double slope1(int j,int k) {return (Y1(j)-Y1(k))/(sum[j]-sum[k]);} +double slope2(int j,int k) {return (Y2(j)-Y2(k))/(sum[j]-sum[k]);} +double calc(double Ej,double sum) {return Ej+sqrt(Ej)+sum*sum;} +struct Queue { + map q; + void clear() {q.clear();} + int size() {return q.size();} + int front() {return sz(q)?q.begin()->y:0;} + int front2() {return sz(q)?(++q.begin())->y:0;} + int back() {return sz(q)?q.rbegin()->y:0;} + int back2() {return sz(q)?(++q.rbegin())->y:0;} + void pop_front() {q.erase(q.begin());} + void pop_back() {q.erase(--q.end());} + void insert(int x,int y) {q[x]=y;} + void merge(Queue *b) { + while (b->size()) { + int cur=b->front(); + b->pop_front(); + if (q.find(sum[cur])!=q.end()) { + int j=cur,k=q[sum[cur]]; + if (Y2(j)>=Y2(k)) continue; + } + q[sum[cur]]=cur; + if (sz(q)<=2) continue; + map::iterator i=q.find(sum[cur]),l1,l2,r1,r2; + if (i!=q.begin() && i!=(--q.end())) { + l1=i, l1--; + r1=i, r1++; + if (slope2(l1->y,i->y)>=slope2(i->y,r1->y)) { + q.erase(i); + continue; + } + } + while (i!=q.begin() && i!=(++q.begin())) { + l1=i, l1--; + l2=l1, l2--; + if (slope2(l2->y,l1->y)<=slope2(l1->y,i->y)) break; + q.erase(l1); + } + while (i!=(--q.end()) && i!=(--(--q.end()))) { + r1=i, r1++; + r2=r1, r2++; + if (slope2(i->y,r1->y)<=slope2(r1->y,r2->y)) break; + q.erase(r1); + } + } + } +} q1,*q2[N]; +void first_run(int x) { + rep(i,0,sz(to[x])-1) { + int y=to[x][i]; + if (sum[y]<=sum[x]) continue; + path.pb(y); + tmp[x].clear(); + while (sz(q1)>=2 && slope1(q1.front(),q1.front2())<=2.0*sum[y] ) { + tmp[x].pb(q1.front()); + q1.pop_front(); + } + dp1[y]=calc(dp1[q1.front()],sum[y]-sum[q1.front()]-L); + while (sz(q1)>=2 && slope1(q1.back2(),q1.back())>=slope1(q1.back(),y) ) { + tmp[x].pb(q1.back()); + q1.pop_back(); + } + q1.insert(sum[y],y); + first_run(y); + q1.pop_back(); + rep(i,0,sz(tmp[x])-1) + q1.insert(sum[tmp[x][i]],tmp[x][i]); + path.pop_back(); + } + if (is_leaf(x)) { + gmin(ans1[col[x]],dp1[x]); + } +} +void merge(Queue *&a,Queue *&b) { + if (b->size() < a->size()) { + a->merge(b); + } else { + b->merge(a); + a=b; + } +} +double get_val(Queue *q,int x) { + while (q->size()>=2 && slope2(q->back(),q->back2())>=2.0*sum[x]) q->pop_back(); + dp2[x]=calc(dp2[q->back()],sum[q->back()]-sum[x]-L); + while (q->size()>=2 && slope2(q->front2(),q->front())<=slope2(q->front(),x) ) q->pop_front(); + return dp2[x]; +} +void second_run(int x) { + q2[x]=new Queue; + rep(i,0,sz(to[x])-1){ + int y=to[x][i]; + if (sum[y]<=sum[x]) continue; + second_run(y); + if (x==1) { + gmin(ans2[y],get_val(q2[y],x)); + } else { + merge(q2[x],q2[y]); + } + } + if (x!=1) { + dp2[x]=is_leaf(x)?0:get_val(q2[x],x); + q2[x]->insert(sum[x],x); + } +} +double get_answer() { + vector part; + rep(i,2,n) if (col[i]==i) part.pb(i); + double min1=inf,min2=inf; + int pos1; + rep(i,0,sz(part)-1) { + if (min1>ans2[part[i]]) { + min2=min1; + min1=ans2[part[i]]; + pos1=i; + } else + if (min2>ans2[part[i]]) { + min2=ans2[part[i]]; + } + } + double res=inf; + rep(i,0,sz(part)-1) + gmin(res,ans1[part[i]]+(pos1==i?min2:min1)); + return res; +} +int main() { + while (~scanf("%d%lf",&n,&L)) { + rep(i,1,n) { + to[i].clear(); + len[i].clear(); + } + rep(i,1,n-1) { + int u,v,w; + scanf("%d%d%d",&u,&v,&w); + to[u].pb(v); + to[v].pb(u); + len[u].pb(w); + len[v].pb(w); + } + if (sz(to[1])<2) { + puts("-1"); + continue; + } + fill(sum+2,sum+n+1,-1); + pre_dfs(1); + fill(dp1+2,dp1+n+1,inf); + fill(dp2+1,dp2+n+1,inf); + fill(ans1,ans1+n+1,inf); + fill(ans2,ans2+n+1,inf); + path.clear(); + path.pb(1); + q1.clear(); + q1.insert(0,1); + first_run(1); + second_run(1); + printf("%.2lf\n",get_answer()); + } + return 0; +} diff --git a/HDOJ/4576_autoAC.cpp b/HDOJ/4576_autoAC.cpp new file mode 100644 index 0000000..49f162a --- /dev/null +++ b/HDOJ/4576_autoAC.cpp @@ -0,0 +1,34 @@ +#include +#include +#include +using namespace std; +const int N=220; +int n,m,l,r; +double dp[2][N]; +int main(){ + while(~scanf("%d%d%d%d",&n,&m,&l,&r)){ + if(n==0 && m==0 && l==0 && r==0) + break; + for(int i=0;i<=n;i++) + dp[0][i]=0; + dp[0][0]=1; + int x,cur=0; + while(m--){ + scanf("%d",&x); + for(int i=0;i +#include +#include +#include +using namespace std; +#define lz 2*u,l,mid +#define rz 2*u+1,mid+1,r +typedef long long lld; +const int maxn=100005; +const int mod=10007; +lld add[4*maxn], mul[4*maxn], ch[4*maxn], sum[4*maxn]; +void build(int u, int l, int r) +{ + mul[u]=1; + add[u]=sum[u]=0; + ch[u]=0; + if(l==r) + { + ch[u]=1; + return ; + } + int mid=(l+r)>>1; + build(lz); + build(rz); +} +void push_down(int u, int l, int r) +{ + if(l==r) return ; + int mid=(l+r)>>1; + if(ch[u]) + { + add[2*u]=0, mul[2*u]=1; + add[2*u+1]=0, mul[2*u+1]=1; + ch[2*u]=ch[2*u+1]=1; + sum[2*u]=sum[2*u+1]=sum[u]; + ch[u]=0; + } + else + { + if(add[u]) + { + if(ch[2*u]) sum[2*u]=(sum[2*u]+add[u])%mod; + else + { + push_down(lz); + add[2*u]=(add[2*u]+add[u])%mod; + } + if(ch[2*u+1]) sum[2*u+1]=(sum[2*u+1]+add[u])%mod; + else + { + push_down(rz); + add[2*u+1]=(add[2*u+1]+add[u])%mod; + } + add[u]=0; + } + if(mul[u]>1) + { + if(ch[2*u]) sum[2*u]=(sum[2*u]*mul[u])%mod; + else + { + push_down(lz); + mul[2*u]=(mul[2*u]*mul[u])%mod; + } + if(ch[2*u+1]) sum[2*u+1]=(sum[2*u+1]*mul[u])%mod; + else + { + push_down(rz); + mul[2*u+1]=(mul[2*u+1]*mul[u])%mod; + } + mul[u]=1; + } + } +} +void Update(int u, int l, int r, int tl, int tr, int c, int op) +{ + if(tl<=l&&r<=tr) + { + if(op==3) + { + ch[u]=1; + mul[u]=1, add[u]=0; + sum[u]=c; + } + else + { + if(ch[u]) + { + if(op==1) sum[u]=(sum[u]+c)%mod; + else sum[u]=sum[u]*c%mod; + } + else + { + push_down(u,l,r); + if(op==1) add[u]=(add[u]+c)%mod; + else mul[u]=mul[u]*c%mod; + } + } + return ; + } + push_down(u,l,r); + int mid=(l+r)>>1; + if(tr<=mid) Update(lz,tl,tr,c,op); + else if(tl>mid) Update(rz,tl,tr,c,op); + else + { + Update(lz,tl,mid,c,op); + Update(rz,mid+1,tr,c,op); + } +} +lld Query(int u, int l, int r, int tl, int tr, int p) +{ + if(tl<=l&&r<=tr) + { + if(ch[u]) + { + lld ans=1, tp=sum[u]; + for(int i=1; i<=p; i++) ans=ans*tp%mod; + return (r-l+1)*ans%mod; + } + } + push_down(u,l,r); + int mid=(l+r)>>1; + if(tr<=mid) return Query(lz,tl,tr,p); + else if(tl>mid) return Query(rz,tl,tr,p); + else + { + lld t1=Query(lz,tl,mid,p); + lld t2=Query(rz,mid+1,tr,p); + return (t1+t2)%mod; + } +} +int main() +{ + int n, m; + while(cin >> n >> m, n+m) + { + build(1,1,n); + for(int i=1; i<=m; i++) + { + int l, r, c, op; + scanf("%d%d%d%d",&op,&l,&r,&c); + if(op<=3) Update(1,1,n,l,r,c,op); + else printf("%I64d\n",Query(1,1,n,l,r,c)%mod); + } + } + return 0; +} diff --git a/HDOJ/4579_autoAC.cpp b/HDOJ/4579_autoAC.cpp new file mode 100644 index 0000000..06424f1 --- /dev/null +++ b/HDOJ/4579_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +const int MAXN = 50010; +double c[MAXN][10]; +double p[MAXN][20]; +double a[MAXN][10]; +double b[MAXN]; +double dp[MAXN]; +int main() +{ + int n,m; + while( scanf("%d%d",&n,&m) == 2 ) + { + if(n == 0 && m == 0)break; + for(int i = 1;i <= n;i++) + for(int j = 1;j <= m;j++) + scanf("%lf",&c[i][j]); + for(int i = 1;i < n;i++) + { + double sum = 0; + for(int j = 1;j <= m;j++) + sum += c[i][j]; + double s = 0; + for(int j = 1;j <= m && i-j >= 1;j++) + { + p[i][m-j] = 0.3*c[i][j]/(1+sum); + s += p[i][m-j]; + } + for(int j = 1;j <= m && i+j <= n;j++) + { + p[i][m+j] = 0.7*c[i][j]/(1+sum); + s += p[i][m+j]; + } + p[i][m] = -s; + b[i] = -1; + } + for(int i = 1;i <= m+1 && i <= n;i++) + a[1][i] = p[1][m+i-1]; + for(int i = 2;i < n;i++) + { + int end = min(i+m,n); + int start = max(1,i-m); + for(int j = start;j < i;j++) + if(fabs(p[i][m+j-i]) > 1e-6) + { + double t = p[i][m+j-i]/a[j][1]; + for(int k = 1; k <= m+1 && j+k-1 <= n ;k++) + { + p[i][m+j-i+k-1] -= t*a[j][k]; + } + b[i] -= t*b[j]; + } + for(int j = 1;j <= end-i+1;j++) + a[i][j] = p[i][m+j-1]; + } + dp[n] = 0; + for(int i = n-1;i >= 1;i--) + { + for(int j = 2;j <= m+1 && i+j-1 <= n;j++) + b[i] -= dp[i+j-1] * a[i][j]; + dp[i] = b[i]/a[i][1]; + } + printf("%.2f\n",dp[1]); + } + return 0; +} diff --git a/HDOJ/4582_autoAC.cpp b/HDOJ/4582_autoAC.cpp new file mode 100644 index 0000000..6076861 --- /dev/null +++ b/HDOJ/4582_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +using namespace std; +const int maxn=2013; +int first[maxn],pre[maxn],vv[maxn*20],nxt[maxn*20]; +bitset<2001> to[2001]; +bool vis[maxn]; +int ans; +void dfs(int u,int p) +{ + vis[u]=true; + to[u].reset(); + for(int e=pre[u];e;e=nxt[e]) if(vis[vv[e]]) + to[u].set(vv[e]); + for(int e=first[u];e;e=nxt[e]) if(vv[e]!=p) + dfs(vv[e],u); + if(p==-1) + return; + if(to[u].test(p)) + ans++; + else + to[p]|=to[u]; +} +int main() +{ + int n,m; + while(~scanf("%d%d",&n,&m) && n|m) + { + memset(vis,0,sizeof(vis)); + memset(first,0,sizeof(first)); + memset(pre,0,sizeof(pre)); + int e=2; + for(int i=1;i +#include +#include +#include +using namespace std; +#define LL long long +#define Bool bitset +const int maxn=60; +int a[maxn]; +Bool to[maxn]; +LL num[maxn]; +LL ans; +bool gcd(int a,int b) +{ + return b==0?a!=1:gcd(b,a%b); +} +LL DFS(int n,Bool p) +{ + if(n==-1) + return 1; + LL res=DFS(n-1,p); + if(p.test(n)) + return res; + if((p|to[n])==p) + return res*num[n]; + else + return res+DFS(n-1,(p|to[n]))*(num[n]-1); +} +int main() +{ + int n; + while(~scanf("%d",&n) && n) + { + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +struct Point +{ + int x,y; + Point(int _x = 0,int _y = 0) + { + x = _x; y = _y; + } +}; +int dis(Point a,Point b) +{ + return abs(a.x-b.x)+abs(a.y-b.y); +} +Point p1[2000]; +Point p2[2000]; +char str[50][50]; +int main() +{ + int n,m; + while(scanf("%d%d",&n,&m) == 2) + { + if(n == 0 && m == 0)break; + for(int i = 0;i < n;i++) + scanf("%s",str[i]); + int uN = 0, vN = 0; + for(int i = 0;i < n;i++) + for(int j = 0;j < m;j++) + { + if(str[i][j] == 'H')p1[uN++] = Point(i,j); + else if(str[i][j] == 'C') p2[vN++] = Point(i,j); + } + int ans1 = 0,ans2 = 0; + int Min = 100000000; + for(int i = 0;i < uN;i++) + for(int j = 0;j < vN;j++) + { + if(dis(p1[i],p2[j]) < Min) + { + Min = dis(p1[i],p2[j]); + ans1 = i; + ans2 = j; + } + } + printf("%d %d %d %d\n",p1[ans1].x,p1[ans1].y,p2[ans2].x,p2[ans2].y); + } + return 0; +} diff --git a/HDOJ/4585_autoAC.cpp b/HDOJ/4585_autoAC.cpp new file mode 100644 index 0000000..2dd0374 --- /dev/null +++ b/HDOJ/4585_autoAC.cpp @@ -0,0 +1,28 @@ +#include +#include +#include +#include +using namespace std; +int main() +{ + int n, id, p; + while(cin >> n,n) + { + mapmp; + mp[1000000000]=1; + for(int i=1; i<=n; i++) + { + scanf("%d%d",&id,&p); + map::iterator it=mp.lower_bound(p); + if(it==mp.begin()) cout << id << " " << it->second <::iterator a=it, b=--it; + if((a->first)-p>=p-(b->first))cout << id << " " << b->second <second < +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define LL long long +#define _LL __int64 +#define eps 1e-8 +#define PI acos(-1.0) +using namespace std; +int n,m; +int vis[210]; +int a[210]; +int sum,cnt; +double p,q; +int main() +{ + while(~scanf("%d",&n)) + { + sum = 0; + cnt = 0; + memset(vis,0,sizeof(vis)); + for(int i = 1; i <= n; i++) + { + cin >> a[i]; + sum += a[i]; + } + p = (sum*1.0)/n; + scanf("%d",&m); + int x; + for(int i = 1; i <= m; i++) + { + cin >> x; + if(vis[x]) continue; + cnt++; + vis[x] = 1; + } + q = (cnt*1.0)/n; + if(fabs(p) < eps) + cout << "0.00" << endl; + else if(fabs(q-1) < eps) + cout << "inf" << endl; + else + printf("%.2lf\n",p/(1-q)); + } + return 0; +} diff --git a/HDOJ/4587_autoAC.cpp b/HDOJ/4587_autoAC.cpp new file mode 100644 index 0000000..caabd34 --- /dev/null +++ b/HDOJ/4587_autoAC.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +#include +using namespace std; +#define MAXN 5555 +struct Edge{ + int v,next; +}edge[MAXN*MAXN]; +int n,m,NE; +int head[MAXN]; +void Insert(int u,int v) +{ + edge[NE].v=v; + edge[NE].next=head[u]; + head[u]=NE++; +} +int cnt,rt_son,block; +int low[MAXN],dfn[MAXN]; +int blocks[MAXN]; +bool mark[MAXN]; +void Tarjan(int u,int vv) +{ + low[u]=dfn[u]=++cnt; + mark[u]=true; + for(int i=head[u];i!=-1;i=edge[i].next){ + int v=edge[i].v; + if(v==vv)continue; + if(dfn[v]==0){ + Tarjan(v,vv); + low[u]=min(low[u],low[v]); + if(low[v]>=dfn[u]){ + blocks[u]++; + } + }else if(mark[v]){ + low[u]=min(low[u],dfn[v]); + } + } +} +int main() +{ + int u,v,ans; + while(~scanf("%d%d",&n,&m)){ + NE=0; + memset(head,-1,sizeof(head)); + while(m--){ + scanf("%d%d",&u,&v); + Insert(u,v); + Insert(v,u); + } + ans=0; + for(int u=0;u +#include +#include +using namespace std; +typedef long long ll; +const int N = 40; +ll ti[N], p[N], q[N]; +void cat (ll x, ll* a) { + if (x <= 0) return; + ll ans = 0, s = 0; + for (int i = 0; i <= 32; i++) { + ll t = ti[i+1]; + ll c = x/t, d = x%t; + d -= ti[i]; + a[i] = c * ti[i] + (d <= 0 ? 0 : d); + } +} +ll solve () { + ll ans = 0, s = 0; + for (int i = 0; i <= 32; i++) { + s = s + p[i] - q[i]; + s /= 2; + ans += s; + } + while (s) { + s /= 2; + ans += s; + } + return ans; +} +int main () { + ti[0] = 1; + for (int i = 1; i <= 35; i++) + ti[i] = ti[i-1] * 2; + ll a, b; + while (cin >> a >> b) { + memset(p, 0, sizeof(p)); + memset(q, 0, sizeof(q)); + cat (b+1, p); + cat (a, q); + cout << solve () << endl; + } + return 0; +} diff --git a/HDOJ/4593_autoAC.cpp b/HDOJ/4593_autoAC.cpp new file mode 100644 index 0000000..f840f98 --- /dev/null +++ b/HDOJ/4593_autoAC.cpp @@ -0,0 +1,27 @@ +#include +#include +#include +#include +#include +#include +using namespace std; +const int maxn = 10010; +int cnt[maxn]; +int main() +{ + int n; + while(scanf("%d", &n) == 1) + { + memset(cnt, 0, sizeof(cnt)); + int ans = -1; + for(int i = 0; i < n+1; i++) + { + int tmp; + scanf("%d", &tmp); + cnt[tmp]++; + if(cnt[tmp] >= 2) + ans = tmp; + } + printf("%d\n", ans); + } +} diff --git a/HDOJ/4594_autoAC.cpp b/HDOJ/4594_autoAC.cpp new file mode 100644 index 0000000..3e9daac --- /dev/null +++ b/HDOJ/4594_autoAC.cpp @@ -0,0 +1,210 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long ll; +int T,t,n,m; +map match[4]; +char str[1010],str2[1010],s1[1010],s2[1010]; +int type1,type2,Err,Over; +void init() +{ + int i,j,k; + for(i=0;i<=3;i++) + match[i].clear(); + Err=1; + Over=0; +} +bool Has_Equal() +{ + int i,j,k,len=strlen(str); + bool flag=0,flag2=0; + for(i=0;i +#include +#include +#include +#include +using namespace std; +typedef long long ll; +map match; +char s[100010][20]; +int n,m,point[100010],one[100010],two[100010],sum_one[100010],sum_two[100010]; +bool cmp(char a,char b) +{ + return a=1;i--) + { + len=strlen(s[i]); + sort(s[i],s[i]+len,cmp); + k=match[s[i]]; + if(k==0) + point[i]=n+1; + else + point[i]=k; + match[s[i]]=i; + } + a=n+1;b=n+1; + for(i=n;i>=1;i--) + { + c=point[i]; + if(c=l) + ans+=r*(pos-l+1)-(sum_one[pos]-sum_one[l-1]); + pos=upper_bound(two+1,two+n,r)-two-1; + if(pos>=l) + ans-=r*(pos-l+1)-(sum_two[pos]-sum_two[l-1]); + printf("%I64d\n",ans); + } + } +} diff --git a/HDOJ/4596_autoAC.cpp b/HDOJ/4596_autoAC.cpp new file mode 100644 index 0000000..0b9e836 --- /dev/null +++ b/HDOJ/4596_autoAC.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +using namespace std; +#define maxn 100001 +#define Max(a,b) (a)>(b)?(a):(b) +#define Min(a,b) (a)<(b)?(a):(b) +struct Node +{ + int x,y,z; +}node[1005]; +int gcd(int a,int b) +{ + if(b==0) return a; + else return gcd(b,a%b); +} +int check2(int d,int l,int r) +{ + if(l%d==0 || r%d==0) return 1; + else if(r/d>l/d) return 1; + else return 0; +} +int check(int i,int j) +{ + if(node[i].y>node[j].z || node[j].y>node[i].z) + { + if(node[i].y>node[i].z) swap(i,j); + int d=gcd(node[i].x,node[j].x); + if(check2(d,node[j].y-node[i].z,node[j].z-node[i].y)) + return 1; + else + return 0; + } + return 1; +} +int main(){ + int n,i,j; + while(~scanf("%d",&n)) + { + for(i=1;i<=n;i++) + scanf("%d %d %d",&node[i].x,&node[i].y,&node[i].z); + int flag=0; + for(i=1;i<=n;i++) + { + for(j=i+1;j<=n;j++) + { + if(check(i,j)) {flag=1;break;} + } + if(flag) break; + } + if(!flag)printf("Can Take off\n"); + else printf("Cannot Take off\n"); + } + return 0; +} diff --git a/HDOJ/4597_autoAC.cpp b/HDOJ/4597_autoAC.cpp new file mode 100644 index 0000000..52cd726 --- /dev/null +++ b/HDOJ/4597_autoAC.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int a[30],b[30]; +int sum1[30]; +int sum2[30]; +int dp[30][30][30][30]; +int solve(int l1,int r1,int l2,int r2) +{ + if(dp[l1][r1][l2][r2] != -1)return dp[l1][r1][l2][r2]; + if(l1 > r1 && l2 > r2) + return dp[l1][r1][l2][r2] = 0; + int ans = 0; + int sum = 0; + if(l1 <= r1) + sum += sum1[r1] - sum1[l1-1]; + if(l2 <= r2) + sum += sum2[r2] - sum2[l2-1]; + if(l1 <= r1) + { + ans = max(ans,sum - solve(l1+1,r1,l2,r2)); + ans = max(ans,sum - solve(l1,r1-1,l2,r2)); + } + if(l2 <= r2) + { + ans = max(ans,sum - solve(l1,r1,l2+1,r2)); + ans = max(ans,sum - solve(l1,r1,l2,r2-1)); + } + return dp[l1][r1][l2][r2] = ans; +} +int main() +{ + int n; + int T; + scanf("%d",&T); + while(T--) + { + scanf("%d",&n); + sum1[0] = sum2[0] = 0; + for(int i = 1;i <= n;i++) + { + scanf("%d",&a[i]); + sum1[i] = sum1[i-1] + a[i]; + } + for(int i = 1;i <= n;i++) + { + scanf("%d",&b[i]); + sum2[i] = sum2[i-1] + b[i]; + } + memset(dp,-1,sizeof(dp)); + printf("%d\n",solve(1,n,1,n)); + } + return 0; +} diff --git a/HDOJ/4598_autoAC.cpp b/HDOJ/4598_autoAC.cpp new file mode 100644 index 0000000..66ad341 --- /dev/null +++ b/HDOJ/4598_autoAC.cpp @@ -0,0 +1,129 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define rep(i,n) for(int i=0; i=(m); --i) +#define ll long long +#define arc(a) ((a)*(a)) +#define inf 10000000 +#define exp 0.000001 +#define N 305 +#define T 400 +int cont[N]; +struct node +{ + int y,w,pre; +}; +node a[N*N]; +int pre[N]; +int color[N]; +bool vis[N]; +int dp[N]; +char s[N][N]; +int n,len; +bool dfs(int x) +{ + color[x]=0; + queueq; q.push(x); + while(!q.empty()) + { + int x=q.front(); q.pop(); + rep(i,n) + if(s[x][i]=='1') + if(color[i]==-1) + color[i]=color[x]^1,q.push(i); + else if(color[i]==color[x]) + return false; + } + return true; +} +void init() +{ + memset(color,-1,sizeof(color)); + len=1; + memset(pre,-1,sizeof(pre)); + rep(i,n) dp[i]=inf; + memset(cont,0,sizeof(cont)); + memset(vis,false,sizeof(vis)); +} +void addpage(int s,int t,int w) +{ + a[len].y=t; + a[len].w=w; + a[len].pre=pre[s]; + pre[s]=len++; +} +bool spfa() +{ + queueq; + q.push(0); + vis[0]=true; dp[0]=0; + while(!q.empty()) + { + int x=q.front(); q.pop(); vis[x]=false; + for(int i=pre[x]; i!=-1; i=a[i].pre) + { + int y=a[i].y; + if(dp[x]+a[i].wn) + return false; + } + } + } + } + return true; +} +bool solve() +{ + init(); + rep(i,n) + if(color[i]==-1) + if(!dfs(i)) + return false; + rep(i,n) + repf(j,i+1,n-1) + { + if(s[i][j]=='0') + if(color[i]==0) + addpage(j,i,T-1); + else + addpage(i,j,T-1); + else + if(color[i]==0) + addpage(i,j,-T); + else addpage(j,i,-T); + } + return spfa(); +} +int main() +{ + int test; + scanf("%d",&test); + while(test--) + { + scanf("%d",&n); + rep(i,n) scanf("%s",s[i]); + if(solve()) + printf("Yes\n"); + else + printf("No\n"); + } + return 0; +} diff --git a/HDOJ/4599_autoAC.cpp b/HDOJ/4599_autoAC.cpp new file mode 100644 index 0000000..f708c03 --- /dev/null +++ b/HDOJ/4599_autoAC.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +using namespace std; +LL n; +LL mod =2011; +LL exgcd(LL a,LL b,LL &x,LL &y) +{ + if(b==0) + { + x=1; + y=0; + return a; + } + else + { + LL ans=exgcd(b,a%b,x,y); + LL tmp=x; + x=y; + y=tmp-a/b*y; + return ans; + } +} +LL Pow(LL a,LL b,LL mod) +{ + LL ans=1; + while(b) + { + if(b&1) + { + b--; + ans=(ans*a)%mod; + } + else + { + b/=2; + a=(a*a)%mod; + } + } + return ans; +} +LL solve0(LL n) +{ + LL ans=Pow(6,n%2010,2011); + ans+=24; + ans%=mod; + LL x,y; + exgcd(30,mod,x,y); + LL niyuan=(x%mod+mod)%mod; + ans=(ans*niyuan)%mod; + return ans; +} +LL solve(LL n) +{ + LL ans=Pow(6,n%2010,2011); + ans=(ans+2010)%mod; + LL x,y; + exgcd(5,mod,x,y); + LL niyuan=(x%mod+mod)%mod; + ans=(ans*niyuan)%mod; + return ans; +} +int main() +{ + while(scanf("%I64d",&n)!=EOF) + { + if(n==0) + break; + printf("%I64d %I64d\n",solve0(n),solve(n)); + } + return 0; +}