From 1b4d6396e489413d5c4d5be764738f062815094c Mon Sep 17 00:00:00 2001 From: KiritoTRw <3021577574@qq.com> Date: Wed, 24 Aug 2016 18:23:25 +0800 Subject: [PATCH] Powered By HC TECH : AutoACer Engine 2700-2799 --- HDOJ/2700_autoAC.cpp | 37 +++++ HDOJ/2701_autoAC.cpp | 34 ++++ HDOJ/2702_autoAC.cpp | 171 +++++++++++++++++++ HDOJ/2703_autoAC.cpp | 45 +++++ HDOJ/2704_autoAC.cpp | 92 +++++++++++ HDOJ/2707_autoAC.cpp | 49 ++++++ HDOJ/2708_autoAC.cpp | 73 +++++++++ HDOJ/2709_autoAC.cpp | 24 +++ HDOJ/2710_autoAC.cpp | 56 +++++++ HDOJ/2711_autoAC.cpp | 40 +++++ HDOJ/2712_autoAC.cpp | 41 +++++ HDOJ/2713_autoAC.cpp | 32 ++++ HDOJ/2714_autoAC.cpp | 51 ++++++ HDOJ/2715_autoAC.cpp | 41 +++++ HDOJ/2716_autoAC.cpp | 26 +++ HDOJ/2717_autoAC.cpp | 58 +++++++ HDOJ/2719_autoAC.cpp | 49 ++++++ HDOJ/2721_autoAC.cpp | 49 ++++++ HDOJ/2722_autoAC.cpp | 70 ++++++++ HDOJ/2723_autoAC.cpp | 47 ++++++ HDOJ/2725_autoAC.cpp | 4 + HDOJ/2726_autoAC.cpp | 72 ++++++++ HDOJ/2727_autoAC.cpp | 380 +++++++++++++++++++++++++++++++++++++++++++ HDOJ/2728_autoAC.cpp | 39 +++++ HDOJ/2729_autoAC.cpp | 80 +++++++++ HDOJ/2730_autoAC.cpp | 53 ++++++ HDOJ/2731_autoAC.cpp | 23 +++ HDOJ/2732_autoAC.cpp | 158 ++++++++++++++++++ HDOJ/2733_autoAC.cpp | 144 ++++++++++++++++ HDOJ/2734_autoAC.cpp | 25 +++ HDOJ/2735_autoAC.cpp | 21 +++ HDOJ/2736_autoAC.cpp | 44 +++++ HDOJ/2738_autoAC.cpp | 113 +++++++++++++ HDOJ/2739_autoAC.cpp | 96 +++++++++++ HDOJ/2740_autoAC.cpp | 16 ++ HDOJ/2752_autoAC.cpp | 58 +++++++ HDOJ/2753_autoAC.cpp | 60 +++++++ HDOJ/2754_autoAC.cpp | 72 ++++++++ HDOJ/2755_autoAC.cpp | 135 +++++++++++++++ HDOJ/2756_autoAC.cpp | 31 ++++ HDOJ/2757_autoAC.cpp | 71 ++++++++ HDOJ/2760_autoAC.cpp | 26 +++ HDOJ/2762_autoAC.cpp | 62 +++++++ HDOJ/2763_autoAC.cpp | 121 ++++++++++++++ HDOJ/2765_autoAC.cpp | 49 ++++++ HDOJ/2766_autoAC.cpp | 60 +++++++ HDOJ/2767_autoAC.cpp | 112 +++++++++++++ HDOJ/2768_autoAC.cpp | 69 ++++++++ HDOJ/2769_autoAC.cpp | 64 ++++++++ HDOJ/2770_autoAC.cpp | 66 ++++++++ HDOJ/2771_autoAC.cpp | 116 +++++++++++++ HDOJ/2772_autoAC.cpp | 71 ++++++++ HDOJ/2773_autoAC.cpp | 88 ++++++++++ HDOJ/2775_autoAC.cpp | 165 +++++++++++++++++++ HDOJ/2779_autoAC.cpp | 51 ++++++ HDOJ/2780_autoAC.cpp | 131 +++++++++++++++ HDOJ/2782_autoAC.cpp | 116 +++++++++++++ HDOJ/2783_autoAC.cpp | 125 ++++++++++++++ HDOJ/2785_autoAC.cpp | 128 +++++++++++++++ HDOJ/2788_autoAC.cpp | 57 +++++++ HDOJ/2791_autoAC.cpp | 24 +++ HDOJ/2793_autoAC.cpp | 64 ++++++++ HDOJ/2795_autoAC.cpp | 50 ++++++ HDOJ/2796_autoAC.cpp | 28 ++++ 64 files changed, 4623 insertions(+) create mode 100644 HDOJ/2700_autoAC.cpp create mode 100644 HDOJ/2701_autoAC.cpp create mode 100644 HDOJ/2702_autoAC.cpp create mode 100644 HDOJ/2703_autoAC.cpp create mode 100644 HDOJ/2704_autoAC.cpp create mode 100644 HDOJ/2707_autoAC.cpp create mode 100644 HDOJ/2708_autoAC.cpp create mode 100644 HDOJ/2709_autoAC.cpp create mode 100644 HDOJ/2710_autoAC.cpp create mode 100644 HDOJ/2711_autoAC.cpp create mode 100644 HDOJ/2712_autoAC.cpp create mode 100644 HDOJ/2713_autoAC.cpp create mode 100644 HDOJ/2714_autoAC.cpp create mode 100644 HDOJ/2715_autoAC.cpp create mode 100644 HDOJ/2716_autoAC.cpp create mode 100644 HDOJ/2717_autoAC.cpp create mode 100644 HDOJ/2719_autoAC.cpp create mode 100644 HDOJ/2721_autoAC.cpp create mode 100644 HDOJ/2722_autoAC.cpp create mode 100644 HDOJ/2723_autoAC.cpp create mode 100644 HDOJ/2725_autoAC.cpp create mode 100644 HDOJ/2726_autoAC.cpp create mode 100644 HDOJ/2727_autoAC.cpp create mode 100644 HDOJ/2728_autoAC.cpp create mode 100644 HDOJ/2729_autoAC.cpp create mode 100644 HDOJ/2730_autoAC.cpp create mode 100644 HDOJ/2731_autoAC.cpp create mode 100644 HDOJ/2732_autoAC.cpp create mode 100644 HDOJ/2733_autoAC.cpp create mode 100644 HDOJ/2734_autoAC.cpp create mode 100644 HDOJ/2735_autoAC.cpp create mode 100644 HDOJ/2736_autoAC.cpp create mode 100644 HDOJ/2738_autoAC.cpp create mode 100644 HDOJ/2739_autoAC.cpp create mode 100644 HDOJ/2740_autoAC.cpp create mode 100644 HDOJ/2752_autoAC.cpp create mode 100644 HDOJ/2753_autoAC.cpp create mode 100644 HDOJ/2754_autoAC.cpp create mode 100644 HDOJ/2755_autoAC.cpp create mode 100644 HDOJ/2756_autoAC.cpp create mode 100644 HDOJ/2757_autoAC.cpp create mode 100644 HDOJ/2760_autoAC.cpp create mode 100644 HDOJ/2762_autoAC.cpp create mode 100644 HDOJ/2763_autoAC.cpp create mode 100644 HDOJ/2765_autoAC.cpp create mode 100644 HDOJ/2766_autoAC.cpp create mode 100644 HDOJ/2767_autoAC.cpp create mode 100644 HDOJ/2768_autoAC.cpp create mode 100644 HDOJ/2769_autoAC.cpp create mode 100644 HDOJ/2770_autoAC.cpp create mode 100644 HDOJ/2771_autoAC.cpp create mode 100644 HDOJ/2772_autoAC.cpp create mode 100644 HDOJ/2773_autoAC.cpp create mode 100644 HDOJ/2775_autoAC.cpp create mode 100644 HDOJ/2779_autoAC.cpp create mode 100644 HDOJ/2780_autoAC.cpp create mode 100644 HDOJ/2782_autoAC.cpp create mode 100644 HDOJ/2783_autoAC.cpp create mode 100644 HDOJ/2785_autoAC.cpp create mode 100644 HDOJ/2788_autoAC.cpp create mode 100644 HDOJ/2791_autoAC.cpp create mode 100644 HDOJ/2793_autoAC.cpp create mode 100644 HDOJ/2795_autoAC.cpp create mode 100644 HDOJ/2796_autoAC.cpp diff --git a/HDOJ/2700_autoAC.cpp b/HDOJ/2700_autoAC.cpp new file mode 100644 index 0000000..ccb9179 --- /dev/null +++ b/HDOJ/2700_autoAC.cpp @@ -0,0 +1,37 @@ +#include +#include +int main() +{ + char a[35]; + int i,c,l; + while(gets(a)&&a[0]!='#') + { + c=0; + l=strlen(a); + for(i=0;i<=l-2;i++) + if(a[i]=='1') + c++; + if(a[l-1]=='e') + { + if(c%2!=0) + a[l-1]='1'; + else + a[l-1]='0'; + } + else + { + if(c%2!=0) + a[l-1]='0'; + else + a[l-1]='1'; + } + for(i=0;i +# include +int r, x, y ; +double dist(double ax, double ay, double bx, double by) +{ + return sqrt((ax-bx)*(ax-bx) + (ay-by)*(ay-by)) ; +} +void work(int cas) +{ + double sx = x, sy = y, ex, ey, t ; + int flag = 0 ; + while (1) + { + scanf ("%lf%lf", &ex, &ey) ; + if (ex < 0 && ey < 0) break ; + if (flag) continue ; + if (dist(sx, sy, ex, ey) <= r+1.0) + { + printf ("Firefly %d caught at (%.0lf,%.0lf)\n", cas, ex, ey) ; + flag = 1 ; + } + t = r*1.0 / dist(sx, sy, ex, ey) ; + sx = sx + (ex-sx)*t ; + sy = sy + (ey-sy)*t ; + } + if (!flag) printf ("Firefly %d not caught\n", cas) ; +} +int main () +{ + int nCase = 1 ; + while (scanf ("%d%d%d", &r, &x, &y) && (r||x||y)) + work(nCase++) ; + return 0 ; +} diff --git a/HDOJ/2702_autoAC.cpp b/HDOJ/2702_autoAC.cpp new file mode 100644 index 0000000..3599173 --- /dev/null +++ b/HDOJ/2702_autoAC.cpp @@ -0,0 +1,171 @@ +#include +#include +#include +#include +#include +using namespace std; +int R,C; +char Map[10][10]; +int Move2[6][2] = {{-1,-1},{-1,0},{0,-1},{0,1},{1,-1},{1,0}}; +int Move1[6][2] = {{-1,0},{-1,1},{0,-1},{0,1},{1,0},{1,1}}; +char Path[20]; +bool bVisited[10][10]; +int ileft,iright; +int cnum,pos; +inline bool InBoundary(int x,int y) +{ + if(x >= 0 && x=0 && y s1; + stack s2; + int i = start; + int t = 0; + t = Path[i]-'0'; i++; + if(isdigit(Path[i])) + { + if(t == 0) return false; + } + while(isdigit(Path[i])) + { + t*=10; t+=Path[i]-'0'; + if(t >= 100) + return false; + i++; + } + s1.push(t); + while(1) + { + if(i > n-1) + { + if(!isdigit(Path[n-1])) return false; + break; + } + if(!isdigit(Path[i])) + { + if(!s2.empty()) return false; + else s2.push(Path[i]); + i++; + } + else + { + t = Path[i]-'0'; i++; + if(isdigit(Path[i])) + { + if(t == 0) + return false; + } + while(isdigit(Path[i])) + { + t*=10; t+=Path[i]-'0'; + if(t >= 100) + return false; + i++; + } + char op = s2.top();s2.pop(); + int re = s1.top();s1.pop(); + switch(op) + { + case '+':s1.push(re+t); break; + case '-':s1.push(re-t);break; + case '*':s1.push(re*t);break; + case '/': + if(t == 0 || re%t!=0) + return false; + s1.push(re/t); + break; + } + } + } + value = s1.top(); + return true; +} +bool DFS(int i,int j,int index) +{ + if(index == cnum) + { + Path[index] = 0; + if(Evaluate(pos,index,iright) && iright == ileft) + return true; + else return false; + } + if(Map[i][j] == '=') + { + if(!Evaluate(0,index-1,ileft)) + return false; + pos = index; + } + if(i%2==1) + { + for(int k = 0; k<6; k++) + { + int x = Move2[k][0]+i; int y = Move2[k][1]+j; + if(InBoundary(x,y) && bVisited[x][y] == false) + { + bVisited[x][y] = true; + Path[index] = Map[x][y]; + if(DFS(x,y,index+1)) + return true; + bVisited[x][y] = false; + } + } + } + else + { + for(int k = 0; k <6; k++) + { + int x = Move1[k][0]+i; int y = Move1[k][1]+j; + if(InBoundary(x,y) && bVisited[x][y] == false) + { + bVisited[x][y] = true; + Path[index] = Map[x][y]; + if(DFS(x,y,index+1)) + return true; + bVisited[x][y] = false; + } + } + } + return false; +} +int main() +{ + while(scanf("%d",&R)==1 && R!=0) + { + scanf("%d",&C); + int i,j; + cnum = C*R+R/2; + getchar(); + for(i = 0; i +# include +int n ; +int dp[25][2010] ; +int p[25], sec[25] ; +int min(int a, int b){return ab?a:b;} +int gao() +{ + int ans = 0, t = 0 ; + int i, j ; + for (i = 0 ; i < n ; i++) + { + for (j = 0 ; ; j++) + { + if (j != 0) dp[i][j] += dp[i][j-1] ; + if (j > ans && dp[i][j] == 0) break ; + if (t != 0) t-- ; + else if (dp[i][j] != 0) + { + dp[i+1][j+sec[i]] += min(dp[i][j], p[i]) ; + dp[i][j] -= min(dp[i][j], p[i]) ; + t = sec[i]-1 ; + ans = max(ans, j+sec[i]) ; + } + } + } + return ans ; +} +int main () +{ + int m, i ; + while (1) + { + scanf ("%d%d", &n, &m) ; + if (n == 0 && m == 0) break ; + n = -n ; + for (i = 0 ; i < n ; i++) + scanf ("%d%d", &p[i], &sec[i]) ; + memset (dp, 0, sizeof(dp)) ; + dp[0][0] = m ; + printf ("%d\n", gao()) ; + } + return 0 ; +} diff --git a/HDOJ/2704_autoAC.cpp b/HDOJ/2704_autoAC.cpp new file mode 100644 index 0000000..0e7c2ee --- /dev/null +++ b/HDOJ/2704_autoAC.cpp @@ -0,0 +1,92 @@ +#include +#include +#include +#define MAXN 210 +#define MAXD 40010 +int N, W, H, dep[4 * MAXD], ml[4 * MAXD], cnt[4 * MAXD], len[4 * MAXD]; +struct Seg +{ + int x, y1, y2, c; + bool operator < (const Seg &t) const + { + if(x == t.x) return c < t.c; + return x < t.x; + } + Seg(){} + Seg(int _x, int _y1, int _y2, int _c) : x(_x), y1(_y1), y2(_y2), c(_c){} +}seg[MAXN]; +void build(int cur, int x, int y) +{ + int mid = x + y >> 1, ls = cur << 1, rs = cur << 1 | 1; + cnt[cur] = dep[cur] = len[cur] = 0, ml[cur] = y - x + 1; + if(x == y) return ; + build(ls, x, mid), build(rs, mid + 1, y); +} +void init() +{ + int i, x1, x2, y1, y2; + scanf("%d%d", &W, &H); + for(i = 0; i < N; i ++) + { + scanf("%d%d%d%d", &x1, &y1, &x2, &y2); + seg[i << 1] = Seg(x1, y1, y2, 1), seg[i << 1 | 1] = Seg(x2, y1, y2, -1); + } + std::sort(seg, seg + 2 * N); + build(1, 1, H); +} +void update(int cur, int x, int y) +{ + int ls = cur << 1, rs = cur << 1 | 1; + if(dep[ls] > dep[rs]) dep[cur] = dep[ls], ml[cur] = ml[ls]; + else if(dep[rs] > dep[ls]) dep[cur] = dep[rs], ml[cur] = ml[rs]; + else dep[cur] = dep[ls], ml[cur] = ml[ls] + ml[rs]; + dep[cur] += cnt[cur]; + if(cnt[cur]) len[cur] = y - x + 1; + else len[cur] = len[ls] + len[rs]; +} +void refresh(int cur, int x, int y, int s, int t, int c) +{ + int mid = x + y >> 1, ls = cur << 1, rs = cur << 1 | 1; + if(x >= s && y <= t) + { + cnt[cur] += c; + if(c > 0) ++ dep[cur], len[cur] = y - x + 1; + else + { + -- dep[cur]; + if(cnt[cur]) len[cur] = y - x + 1; + else + { + if(x == y) len[cur] = 0; + else len[cur] = len[ls] + len[rs]; + } + } + return ; + } + if(mid >= s) refresh(ls, x, mid, s, t, c); + if(mid + 1 <= t) refresh(rs, mid + 1, y, s, t, c); + update(cur, x, y); +} +void solve() +{ + int i, md, ans, area; + area = md = ans = 0; + seg[2 * N].x = seg[2 * N - 1].x; + for(i = 0; i < 2 * N; i ++) + { + refresh(1, 1, H, seg[i].y1 + 1, seg[i].y2, seg[i].c); + area += len[1] * (seg[i + 1].x - seg[i].x); + if(dep[1] > md) md = dep[1], ans = ml[1] * (seg[i + 1].x - seg[i].x); + else if(dep[1] == md) ans += ml[1] * (seg[i + 1].x - seg[i].x); + } + printf("%d %d %d\n", W * H - area, md, ans); +} +int main() +{ + while(scanf("%d", &N), N) + { + init(); + solve(); + } + return 0; +} diff --git a/HDOJ/2707_autoAC.cpp b/HDOJ/2707_autoAC.cpp new file mode 100644 index 0000000..2b9b371 --- /dev/null +++ b/HDOJ/2707_autoAC.cpp @@ -0,0 +1,49 @@ +# include +# include +char str[110] ; +char tab[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ',-.?" ; +int cnt, label[1100] ; +void gao() +{ + int i, sp = 0 ; + for (i = 0 ; str[i] ; i++) + { + if (str[i] != ' ' && sp != 0) + label[cnt++] = ((sp&1)?0:1), + sp = 0 ; + else if (str[i] == ' ') sp++ ; + } +} +void Print() +{ + int i, j, buff ; + for (i = 0 ; i < cnt ; i+= 5) + { + buff = 0 ; + for (j = 0 ;j < 5 ; j++) + { + if (i+j>=cnt) label[i+j] = 0 ; + buff = buff * 2 + label[i+j] ; + } + putchar (tab[buff]) ; + } + printf("\n") ; +} +int main () +{ + gets (str) ; + while (1) + { + cnt = 0 ; + if (strcmp(str, "#") == 0) break ; + while (1) + { + if (strcmp(str, "*") == 0) break ; + gao() ; + gets (str) ; + } + Print() ; + gets (str) ; + } + return 0 ; +} diff --git a/HDOJ/2708_autoAC.cpp b/HDOJ/2708_autoAC.cpp new file mode 100644 index 0000000..f2c37a2 --- /dev/null +++ b/HDOJ/2708_autoAC.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +#include +int main() +{ + int i,j,len,flag[28],rear[300]; + int top; + char str[5][74]; + while(gets(str[1])) + { + gets(str[2]); + gets(str[3]); + gets(str[4]); + memset(flag,0,sizeof(flag)); + for(i=1;i<=4;i++) + { + len=strlen(str[i]); + for(j=0;j='A'&&str[i][j]<='Z') + { + flag[str[i][j]-'A']++; + } + } + } + top=0; + for(i=0;i<26;i++) + { + if(top0;i--) + { + for(j=25;j>=0;j--) + { + if(flag[j]>=i) + { + rear[i]=j; + break; + } + } + } + for(i=top;i>0;i--) + { + for(j=0;j<26&&j<=rear[i];j++) + { + if(flag[j]>=i) + { + printf("*"); + } + else + { + printf(" "); + } + if(j<25&&j +#include +#include +#include +using namespace std; +long long dp[1000001]; +int main() +{ + int n,i,j; + while(scanf("%d",&n)!=EOF) + { + memset(dp,0,sizeof(dp)); dp[0]=1; + for(i=1;i<=n;i*=2) + { + for(j=i;j<=n;j++) + { + dp[j]+=dp[j-i]; + dp[j]%=1000000000; + } + } + printf("%lld\n",dp[n]); + } + return 0; +} diff --git a/HDOJ/2710_autoAC.cpp b/HDOJ/2710_autoAC.cpp new file mode 100644 index 0000000..551faac --- /dev/null +++ b/HDOJ/2710_autoAC.cpp @@ -0,0 +1,56 @@ +#include +#include +using namespace std; +#define MAX 2270 +int data[MAX]; +int j; +void Judge(int a) +{ + int i; + int tmp=sqrt(double(a))+1; + for(i=2;i<=tmp;i++) + { + if(a%i==0) + return; + } + data[j]=a; + j++; + return; +} +void Set() +{ + int i; + j=1; + data[0]=1; + data[1]=2; + j++; + for(i=3;i<=20010;i++) + Judge(i); +} +int main() +{ + Set(); + int n,tmp,Max,result,num,i; + while(cin>>n) + { + result=0; + while(n--) + { + cin>>tmp; + for(i=0;i<2263;i++) + { + if(data[i]==tmp||(data[i]tmp) + break; + } + if(result +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int p[9000]; +int ans[9000]; +int main(){ + int n; + while(~scanf("%d",&n)){ + memset(p,0,sizeof(p)); + int i,cas,t=-1; + for(i=2;i<=n;i++){ + scanf("%d",p+i); + } + for(cas=1;cas<=n;cas++){ + t=-1; + for(i=2;i<=n;i++){ + if(p[i]==0){ + t=i; + } + } + if(t==-1) + t=1; + ans[t]=cas; + for(i=t;i<=n;i++) + p[i]--; + } + for(i=1;i<=n;i++) + printf("%d\n",ans[i]); + } + return 0; +} diff --git a/HDOJ/2712_autoAC.cpp b/HDOJ/2712_autoAC.cpp new file mode 100644 index 0000000..b570930 --- /dev/null +++ b/HDOJ/2712_autoAC.cpp @@ -0,0 +1,41 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define LL long long +#define mod 1000000007 +#define inf 0x3f3f3f3f +#define N 10010 +#define clr(a) (memset(a,0,sizeof(a))) +using namespace std; +int n,k,x; +int vis[N]; +int main() +{ + while(scanf("%d%d",&n,&k)>0) + { + memset(vis,0,sizeof(vis)); + int num=0,ans=0; + for(int i=1;i<=n;i++) + { + scanf("%d",&x); + if(!vis[x]) + { + vis[x]=1;num++; + } + if(num==k) + { + memset(vis,0,sizeof(vis)); + num=0;ans++; + } + } + printf("%d\n",ans+1); + } +} diff --git a/HDOJ/2713_autoAC.cpp b/HDOJ/2713_autoAC.cpp new file mode 100644 index 0000000..1e8c1be --- /dev/null +++ b/HDOJ/2713_autoAC.cpp @@ -0,0 +1,32 @@ +#include +#include +using namespace std; +int a[150010]; +int main() +{ + int p,i; + while(scanf("%d",&p)!=EOF) + { + memset(a,0,sizeof(a)); + for (i=1;i<=p;i++) + scanf("%d",&a[i]); + int s=0; + int x=0; + for (i=0;i<=p;i++) + { + if(x==0&&a[i]-a[i+1]<=0&&a[i+1]-a[i+2]>=0) + { + s=s+a[i+1]; + x=1; + } + else + if (x==1&&a[i]-a[i+1]>=0&&a[i+1]-a[i+2]<=0) + { + s-=a[i+1]; + x=0; + } + } + printf("%d\n",s); + } + return 0; +} diff --git a/HDOJ/2714_autoAC.cpp b/HDOJ/2714_autoAC.cpp new file mode 100644 index 0000000..15970a9 --- /dev/null +++ b/HDOJ/2714_autoAC.cpp @@ -0,0 +1,51 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int main () +{ + string str; + while ( cin >> str ) + { + int N = str.size(); + int sum = 0, ask = 0; + for ( int i = 1; i <= N; ++ i ) + { + switch ( str[i-1] ) + { + case 'X': + sum += (10-i+1) * 10; break; + case '?': + ask = 10-i+1; break; + default : + sum += (10-i+1) * (str[i-1] - '0'); break; + } + } + int pos = -1; + for ( int i = 0; i <= 10; ++ i ) + { + if ( ( sum + ask * i ) % 11 == 0 ) + { + pos = i; + break; + } + } + if ( ask != 1 && pos == 10 ) pos = -1; + if ( pos == 10 ) + cout << 'X' << endl; + else + cout << pos << endl; + } + return 0; +} diff --git a/HDOJ/2715_autoAC.cpp b/HDOJ/2715_autoAC.cpp new file mode 100644 index 0000000..164d232 --- /dev/null +++ b/HDOJ/2715_autoAC.cpp @@ -0,0 +1,41 @@ +#include +#include +typedef __int64 ll; +ll m; +ll cal(ll s,ll x) +{ + return (2*s+x-1)*x; +} +ll binary_search(ll x) +{ + ll left,right,mid,tmp; + left=1,right=m/2+1; + while(left<=right) + { + mid=(left+right)>>1; + tmp=cal(mid,x); + if(tmp==2*m) + return mid; + else if(tmp<2*m) + left=mid+1; + else + right=mid-1; + } + return -1; +} +int main() +{ + ll i,tmp,num,cnt=1; + while(scanf("%I64d",&m)!=EOF) + { + num=0; + for(i=2;i*i<=2*m+10;i++) + { + tmp=binary_search(i); + if(tmp!=-1) + num++; + } + printf("%I64d\n",num+1); + } + return 0; +} diff --git a/HDOJ/2716_autoAC.cpp b/HDOJ/2716_autoAC.cpp new file mode 100644 index 0000000..b3d88ef --- /dev/null +++ b/HDOJ/2716_autoAC.cpp @@ -0,0 +1,26 @@ +#include +#include +int main() +{ + char key[28],str[84]; + while(scanf("%s",key)!=EOF) + { + getchar(); + gets(str); + int i,len; + len=strlen(str); + for(i=0;i='A'&&str[i]<='Z') + { + str[i]=key[str[i]-'A']-'a'+'A'; + } + else if(str[i]>='a'&&str[i]<='z') + { + str[i]=key[str[i]-'a']; + } + } + printf("%s\n",str); + } + return 0; +} diff --git a/HDOJ/2717_autoAC.cpp b/HDOJ/2717_autoAC.cpp new file mode 100644 index 0000000..e57416c --- /dev/null +++ b/HDOJ/2717_autoAC.cpp @@ -0,0 +1,58 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int n,m; +int vis[200005]; +struct node +{ + int x; + int step; +}; +int bfs(int n,int m) +{ + int i; + queueq; + node st,ed; + st.x=n; + st.step=0; + vis[st.x]=1; + q.push(st); + while(!q.empty()) + { + st=q.front(); + q.pop(); + if(st.x==m) + return st.step; + for(i=0;i<3;i++) + { + if(i==0) + ed.x=st.x+1; + if(i==1) + ed.x=st.x-1; + if(i==2) + ed.x=st.x*2; + if(vis[ed.x] || ed.x<0 ||ed.x>100000) + continue; + vis[ed.x]=1; + ed.step=st.step+1; + q.push(ed); + } + } +} +int main() +{ + while(cin>>n>>m) + { + memset(vis,0,sizeof(vis)); + int ans=bfs(n,m); + cout< +#include +int main() +{ + int i; + char s[85]; + while(gets(s)&&s[0]!='#') + { + int l=strlen(s); + for(i=0;i +#include +#include +using namespace std; +int aa[100000]; +void convert(int a,int b) +{ + char s[16]; + int i=0; + for(;i<16;i++) + { + int k=a%2; + if(k==1)s[i]='1'; + else if(b%2==1) s[i]='?'; + else s[i]='0'; + a/=2;b/=2; + } + for(i=15;i>=0;i--) + printf("%c",s[i]); + printf("\n"); +} +int main() +{ + int a,b,c,d; + int top=0; + while(true) + { + top=1; + cin>>a; + if(a==0) break; + cin>>b>>c>>d; + aa[0]=d; + for(int i=0;i< 65537;i++) + { + aa[top]=(a%c*d%c+b%c)%c; + d=aa[top++]; + if(d==aa[0])break; + } + int result=aa[0]; + int com=aa[0]; + for(int i=1;i +#include +#include +#include +#include +#include +#include +#define INF 100000000 +#define L 2520 +using namespace std; +int N,M; +int d[4][2]={{0,1},{0,-1},{1,0},{-1,0}}; +int dp[25][25]; +struct Block +{ + int a[4]; +}mp[25][25]; +int main() +{ + int i,j,k,v; + char c; + while(cin>>N>>M,N||M) + { + memset(mp,0,sizeof(mp)); + for(i=0;i<=N;i++) + { + for(j=0;j>v>>c; + if(v) + v=L/v; + if(c=='*') + mp[i][j].a[0]=mp[i][j+1].a[1]=v; + if(c=='>') + mp[i][j].a[0]=v; + if(c=='<') + mp[i][j+1].a[1]=v; + } + if(i!=N) + for(j=0;j<=M;j++) + { + cin>>v>>c; + if(v) + v=L/v; + if(c=='*') + mp[i][j].a[2]=mp[i+1][j].a[3]=v; + if(c=='v') + mp[i][j].a[2]=v; + if(c=='^') + mp[i+1][j].a[3]=v; + } + } + for(i=0;i<=N;i++) + for(j=0;j<=M;j++) + dp[i][j]=INF; + dp[0][0]=0; + for(v=0;v<40;v++) + for(i=0;i<=N;i++) + for(j=0;j<=M;j++) + for(k=0;k<4;k++) + if(mp[i][j].a[k]) + if(dp[i+d[k][0]][j+d[k][1]]>dp[i][j]+mp[i][j].a[k]) + dp[i+d[k][0]][j+d[k][1]]=dp[i][j]+mp[i][j].a[k]; + if(dp[N][M]==INF) + cout<<"Holiday"< +# include +int ACL[30], out[30][2] ; +char str[100] ; +char entity[100], right[100] ; +void gao(char s[]) +{ + char *p = s, op ; + int ent, rit, i, j ; + memset (ACL, 0, sizeof(ACL)) ; + while (*p) + { + sscanf (p, "%[A-Z]%c%[a-z]%*c", entity, &op, right) ; + p += strlen(entity) + strlen(right) + 2 ; + for (i = 0 ; entity[i] ; i++) + { + ent = entity[i]-'A' ; + for (rit = 0, j = 0 ; right[j] ; j++) rit |= (1<<(right[j]-'a')) ; + if (op == '+') ACL[ent] |= rit ; + else if (op == '-') ACL[ent] &= ~rit ; + else //op == '=' + ACL[ent] = rit ; + } + } +} +int main () +{ + int nCase = 1 ; + int i, j, cnt ; + while (~scanf ("%s", str) && strcmp(str, "#")) + { + gao(str) ; + memset (str, 0, sizeof(str)) ; + printf ("%d:", nCase++) ; + for (i = 0, cnt = 0 ; i < 26 ; i++) if (ACL[i]) + out[cnt][0] = i, out[cnt++][1] = ACL[i] ; + for (i = 0 ; i < cnt ; i++) + { + printf ("%c", out[i][0]+'A') ; + if (i==cnt-1 || (i +#include +#include +using namespace std; +class Bookshelf; +class Book{ +public: + Book(int _id,int _width):id(_id),width(_width){} + int id,width; + friend class Bookshelf; +}; +class Bookshelf{ +public: + Bookshelf(int w):width(w){ + occupied_width=0; + } + void add(const Book &book){ + shelf.push_front(book); + occupied_width += book.width; + while(occupied_width>width){ + occupied_width -= (shelf.back()).width; + shelf.pop_back(); + } + } + void remove(const int &id){ + list::iterator i; + for(i=shelf.begin();i!=shelf.end();i++){ + if(i->id == id) break; + } + if(i==shelf.end()) return; + occupied_width -= i->width; + shelf.erase(i); + } + friend ostream& operator<<(ostream &out,Bookshelf &bookshelf); +private: + list shelf; + int width; + int occupied_width; +}; +ostream& operator<<(ostream &out, Bookshelf &bookshelf) +{ + list::iterator i; + for(i=(bookshelf.shelf).begin();i!=(bookshelf.shelf).end();i++) + out<<" "<id; + return out; +} +int main() +{ + int width; + int p=1; + char cmd; + while(cin>>width,width!=-1) + { + Bookshelf bookshelf(width); + int id,w; + while(cin>>cmd) + { + if(cmd=='E') break; + else if(cmd=='R') + { + cin>>id; + bookshelf.remove(id); + }else + { + cin>>id>>w; + bookshelf.add(Book(id,w)); + } + } + cout<<"PROBLEM "< +using namespace std; +const int size=23; +const int num=251; +int n; +int m; +int lastx,lasty; +int map[size][size]; +bool link[num][num]; +int posx[]={0,-1,-2,-2,-1,1,2,2,1}; +int posy[]={0,2,1,-1,-2,-2,-1,1,2}; +typedef class chess +{ + public: + int color; + int r,c; + int connet[8]; + int pc; + chess() + { + color=-1; + pc=0; + } +}PEG; +void LinePeg(PEG* peg,int i); +bool CheckWin(PEG* peg,bool flag); +int main(void) +{ + while(cin>>n>>m) + { + if(!n && !m) + break; + memset(map,0,sizeof(map)); + memset(link,false,sizeof(link)); + PEG* peg=new PEG[m+1]; + for(int i=1;i<=m;i++) + { + int x,y; + cin>>x>>y; + map[x][y]=i; + peg[i].r=x; + peg[i].c=y; + if(i%2) + peg[i].color=1; + else + peg[i].color=0; + if(i==m) + { + lastx=x; + lasty=y; + } + LinePeg(peg,i); + } + if(CheckWin(peg,true) && !CheckWin(peg,false)) + cout<<"yes"<=0 && r<=n && c>=0 && c<=n) + { + if(map[r][c] && peg[ map[r][c] ].color==color) + { + switch(k) + { + case 1: + { + if(link[ map[r][c-2] ][ map[r+1][c] ]) + break; + if(c-3>=0 && link[ map[r][c-3] ][ map[r+1][c-1] ]) + break; + if(c+1<=n && link[ map[r][c-1] ][ map[r+1][c+1] ]) + break; + if(r-1>=0) + { + if(link[ map[r-1][c-2] ][ map[r+1][c-1] ]) + break; + if(link[ map[r-1][c-1] ][ map[r+1][c] ]) + break; + if(link[ map[r-1][c] ][ map[r+1][c-1] ]) + break; + } + if(r+2<=n) + { + if(link[ map[r+2][c-2] ][ map[r][c-1] ]) + break; + if(link[ map[r+2][c-1] ][ map[r][c-2] ]) + break; + if(link[ map[r+2][c] ][ map[r][c-1] ]) + break; + } + int a=map[peg[i].r][peg[i].c]; + int b=map[r][c]; + peg[a].connet[peg[a].pc++]=b; + peg[b].connet[peg[b].pc++]=a; + link[a][b]=link[b][a]=true; + break; + } + case 2: //60搴逛 + { + if(link[ map[r][c-1] ][ map[r+2][c] ]) + break; + if(r-1>=0 && link[ map[r-1][c-1] ][ map[r+1][c] ]) + break; + if(r+3<=n && link[ map[r+1][c-1] ][ map[r+3][c] ]) + break; + if(c-2>=0) + { + if(link[ map[r][c-2] ][ map[r+1][c] ]) + break; + if(link[ map[r+1][c-2] ][ map[r+2][c] ]) + break; + if(link[ map[r+2][c-2] ][ map[r+1][c] ]) + break; + } + if(c+1<=n) + { + if(link[ map[r][c-1] ][ map[r+1][c+1] ]) + break; + if(link[ map[r+1][c-1] ][ map[r][c+1] ]) + break; + if(link[ map[r+1][c-1] ][ map[r+2][c+1] ]) + break; + } + int a=map[peg[i].r][peg[i].c]; + int b=map[r][c]; + peg[a].connet[peg[a].pc++]=b; + peg[b].connet[peg[b].pc++]=a; + link[a][b]=link[b][a]=true; + break; + } + case 3: //120搴逛 + { + if(link[ map[r][c+1] ][ map[r+2][c] ]) + break; + if(r-1>=0 && link[ map[r-1][c+1] ][ map[r+1][c] ]) + break; + if(r+3<=n && link[ map[r+1][c+1] ][ map[r+3][c] ]) + break; + if(c-1>=0) + { + if(link[ map[r][c-1] ][ map[r+1][c+1] ]) + break; + if(link[ map[r+1][c-1] ][ map[r][c+1] ]) + break; + if(link[ map[r+2][c-1] ][ map[r+1][c+1] ]) + break; + } + if(c+2<=n) + { + if(link[ map[r+1][c] ][ map[r][c+2] ]) + break; + if(link[ map[r+2][c] ][ map[r+1][c+2] ]) + break; + if(link[ map[r+1][c] ][ map[r+2][c+2] ]) + break; + } + int a=map[peg[i].r][peg[i].c]; + int b=map[r][c]; + peg[a].connet[peg[a].pc++]=b; + peg[b].connet[peg[b].pc++]=a; + link[a][b]=link[b][a]=true; + break; + } + case 4: //150搴逛 + { + if(link[ map[r][c+2] ][ map[r+1][c] ]) + break; + if(c-1>=0 && link[ map[r+1][c-1] ][ map[r][c+1] ]) + break; + if(c+3<=n && link[ map[r+1][c+1] ][ map[r][c+3] ]) + break; + if(r-1>=0) + { + if(link[ map[r-1][c] ][ map[r+1][c+1] ]) + break; + if(link[ map[r-1][c+1] ][ map[r+1][c] ]) + break; + if(link[ map[r-1][c+2] ][ map[r+1][c+1] ]) + break; + } + if(r+2<=n) + { + if(link[ map[r][c+1] ][ map[r+2][c] ]) + break; + if(link[ map[r][c+1] ][ map[r+2][c+2] ]) + break; + if(link[ map[r][c+2] ][ map[r+2][c+1] ]) + break; + } + int a=map[peg[i].r][peg[i].c]; + int b=map[r][c]; + peg[a].connet[peg[a].pc++]=b; + peg[b].connet[peg[b].pc++]=a; + link[a][b]=link[b][a]=true; + break; + } + case 5: //210搴逛 + { + if(link[ map[r-1][c] ][ map[r][c+2] ]) + break; + if(c-1>=0 && link[ map[r-1][c-1] ][ map[r][c+1] ]) + break; + if(c+3<=n && link[ map[r-1][c+1] ][ map[r][c+3] ]) + break; + if(r-2>=0) + { + if(link[ map[r-2][c] ][ map[r][c+1] ]) + break; + if(link[ map[r-2][c+1] ][ map[r][c+2] ]) + break; + if(link[ map[r-2][c+2] ][ map[r][c+1] ]) + break; + } + if(r+1<=n) + { + if(link[ map[r][c] ][ map[r-1][c+1] ]) + break; + if(link[ map[r+1][c+1] ][ map[r-1][c] ]) + break; + if(link[ map[r+1][c+2] ][ map[r-1][c+1] ]) + break; + } + int a=map[peg[i].r][peg[i].c]; + int b=map[r][c]; + peg[a].connet[peg[a].pc++]=b; + peg[b].connet[peg[b].pc++]=a; + link[a][b]=link[b][a]=true; + break; + } + case 6: //240搴逛 + { + if(link[ map[r-2][c] ][ map[r][c+1] ]) + break; + if(r-3>=0 && link[ map[r-3][c] ][ map[r-1][c+1] ]) + break; + if(r+1<=n && link[ map[r-1][c] ][ map[r+1][c+1] ]) + break; + if(c-1>=0) + { + if(link[ map[r-2][c-1] ][ map[r-1][c+1] ]) + break; + if(link[ map[r-1][c-1] ][ map[r][c+1] ]) + break; + if(link[ map[r][c-1] ][ map[r-1][c+1] ]) + break; + } + if(c+2<=n) + { + if(link[ map[r-1][c] ][ map[r-2][c+2] ]) + break; + if(link[ map[r-2][c] ][ map[r-1][c+2] ]) + break; + if(link[ map[r-1][c] ][ map[r][c+2] ]) + break; + } + int a=map[peg[i].r][peg[i].c]; + int b=map[r][c]; + peg[a].connet[peg[a].pc++]=b; + peg[b].connet[peg[b].pc++]=a; + link[a][b]=link[b][a]=true; + break; + } + case 7: //300搴逛 + { + if(link[ map[r-2][c] ][ map[r][c-1] ]) + break; + if(r-3>=0 && link[ map[r-3][c] ][ map[r-1][c-1] ]) + break; + if(r+1<=n && link[ map[r-1][c] ][ map[r+1][c-1] ]) + break; + if(c-2>=0) + { + if(link[ map[r-2][c-2] ][ map[r-1][c] ]) + break; + if(link[ map[r-1][c-2] ][ map[r-2][c] ]) + break; + if(link[ map[r][c-2] ][ map[r-1][c] ]) + break; + } + if(c+1<=n) + { + if(link[ map[r-1][c-1] ][ map[r-2][c+1] ]) + break; + if(link[ map[r][c-1] ][ map[r-1][c+1] ]) + break; + if(link[ map[r-1][c-1] ][ map[r][c+1] ]) + break; + } + int a=map[peg[i].r][peg[i].c]; + int b=map[r][c]; + peg[a].connet[peg[a].pc++]=b; + peg[b].connet[peg[b].pc++]=a; + link[a][b]=link[b][a]=true; + break; + } + case 8: //330搴逛 + { + if(link[ map[r][c-2] ][ map[r-1][c] ]) + break; + if(c-3>=0 && link[ map[r][c-3] ][ map[r-1][c-1] ]) + break; + if(c+1<=n && link[ map[r][c-1] ][ map[r-1][c+1] ]) + break; + if(r-2>=0) + { + if(link[ map[r-2][c-2] ][ map[r][c-1] ]) + break; + if(link[ map[r-2][c-1] ][ map[r][c-2] ]) + break; + if(link[ map[r-2][c] ][ map[r][c-1] ]) + break; + } + if(r+1<=n) + { + if(link[ map[r-1][c-1] ][ map[r+1][c-2] ]) + break; + if(link[ map[r-1][c-1] ][ map[r+1][c] ]) + break; + if(link[ map[r-1][c] ][ map[r+1][c-1] ]) + break; + } + int a=map[peg[i].r][peg[i].c]; + int b=map[r][c]; + peg[a].connet[peg[a].pc++]=b; + peg[b].connet[peg[b].pc++]=a; + link[a][b]=link[b][a]=true; + break; + } + } + } + } + } + return; +} +bool CheckWin(PEG* peg,bool flag) +{ + int NUM; + if(!flag) + NUM=map[lastx][lasty]; + for(int k=0;k<=n;k++) + { + int p=map[0][k]; + if(p && p!=NUM && peg[p].color==1) + { + int queue[num]; + bool vist[num]={false}; + int head=0; + int tail=0; + queue[tail++]=p; + vist[p]=true; + while(head +double max(double a,double b) +{ + if(a>b) + return a; + else + return b; +} +double min(double a,double b) +{ + if(a>b) + return b; + else + return a; +} +int main() +{ + int a,b,c,d,z; + double x1,x2,x3,x4,y1,y2; + while(scanf("%d%d%d%d",&a,&b,&c,&d)!=EOF&&(a!=0||b!=0||c!=0||d!=0)) + { + if(c>=a&&d>=b) + printf("100%%\n"); + else if(c>=b&&d>=a) + printf("100%%\n"); + else + { + x1=c*1.0/a; + x2=d*1.0/b; + y1=min(x1,x2); + x3=c*1.0/b; + x4=d*1.0/a; + y2=min(x3,x4); + z=max(y1,y2)*100; + printf("%d%%\n",z); + } + } + return 0; +} diff --git a/HDOJ/2729_autoAC.cpp b/HDOJ/2729_autoAC.cpp new file mode 100644 index 0000000..1a55f6a --- /dev/null +++ b/HDOJ/2729_autoAC.cpp @@ -0,0 +1,80 @@ +#include +#include +#define oo 100000 +bool dfs(int, int); +int n,m,mini; +bool finished[14]; +struct CLASS { + char name[8]; + int time,preNum; + int prerequisites[13]; +} subject[15]; +bool permit(int num) { + int i; + for(i=0; i= mini) return false; + if(lev == n) { + if(semester-1 < mini) mini = semester-1; + return true; + } + int i,tn=0,que[15]; + for(i=0; i +#include +#include +#define N 13 +int cmp(const void *p, const void *q) +{ + return *(int *)p > *(int *)q ? -1 : 1; +} +int main() +{ + int i, j; + int n, grey, count, max, colors[N]; + while(scanf("%d", &n) && n) + { + memset(colors, 0, sizeof(colors)); + max = 0; + for(i=0; i max) + max = colors[i]; + } + scanf("%d", &grey); + if(max % 50) + count = max / 50 + 1; + else count = max / 50; + for(i=0; i 0) + { + count++; + for(i=0; i +using namespace std; +int main() +{ + int cases, x = 1; + cin>>cases; + while (cases--) { + int a, b, c, d; + cin>>a>>b>>c>>d; + printf("Problem set %d: %d / %d, base 7 digits %d through %d: ", x++, a, b, c, d); + int i; + a %= b; + for (i = 0; i <= d; ++i) { + a *= 7; + if (i >= c) { + printf("%d", a / b); + } + a %= b; + } + printf("\n"); + } + return 0; +} diff --git a/HDOJ/2732_autoAC.cpp b/HDOJ/2732_autoAC.cpp new file mode 100644 index 0000000..df365dd --- /dev/null +++ b/HDOJ/2732_autoAC.cpp @@ -0,0 +1,158 @@ +#include +#include +#include +#include +#include +#define RE(x) ((x)^1) +#define CP(x) ((x)+500) +#define INF 0x3fffffff +using namespace std; +int N, M, MM, dis[1000], head[1000], idx; +const int source = 980, sink = 981; +char G[25][25], S[25][25]; +struct Edge +{ + int v, cap, next; +}e[20000]; +void init() +{ + idx = -1; + memset(head, 0xff, sizeof (head)); +} +inline int to(int x, int y) +{ + return x*M+y; +} +inline bool out(int x, int y) +{ + int u = x+1, d = N-x, l = y+1, r = M-y; + int dist = min(u, min(d, min(l, r))); + return dist <= MM; +} +inline bool judge(int x, int y) +{ + if (x < 0 || x >= N || y < 0 || y >= M) { + return false; + } + else if (!G[x][y]) { + return false; + } + return true; +} +void insert(int a, int b, int c) +{ + ++idx; + e[idx].v = b, e[idx].cap = c; + e[idx].next = head[a], head[a] = idx; +} +void build(int x, int y) +{ + int xx, yy; + if (G[x][y]) { + insert(to(x, y), CP(to(x,y)), G[x][y]); + insert(CP(to(x, y)), to(x,y), G[x][y]); + if (out(x, y)) { + insert(CP(to(x, y)), sink, INF); + insert(sink, CP(to(x, y)), 0); + } + else { + for (int i = -MM; i <= MM; ++i) { + for (int j = -(MM-abs(i)); j <= (MM-abs(i)); ++j) { + xx = x + i, yy = y + j; + if (judge(xx, yy) && !(x == xx && y == yy)) { + insert(CP(to(x, y)), to(xx, yy), G[x][y]); + insert(to(xx, yy), CP(to(x, y)), 0); + } + } + } + } + } +} +bool spfa(int u) +{ + queueq; + memset(dis, 0xff, sizeof (dis)); + dis[u] = 0; + q.push(u); + while (!q.empty()) { + u = q.front(); + q.pop(); + for (int i = head[u]; i != -1; i = e[i].next) { + if (dis[e[i].v] == -1 && e[i].cap > 0) { + dis[e[i].v] = dis[u] + 1; + q.push(e[i].v); + } + } + } + return dis[sink] != -1; +} +int dfs(int u, int flow) +{ + if (u == sink) { + return flow; + } + int tf = 0, sf; + for (int i = head[u]; i != -1; i = e[i].next) { + if (dis[u]+1 == dis[e[i].v] && e[i].cap > 0 && (sf = dfs(e[i].v, min(flow-tf, e[i].cap)))) { + e[i].cap -= sf, e[RE(i)].cap += sf; + tf += sf; + if (tf == flow) { + return flow; + } + } + } + if (!tf) { + dis[u] = -1; + } + return tf; +} +int dinic() +{ + int ans = 0; + while (spfa(source)) { + ans += dfs(source, INF); + } + return ans; +} +int main() +{ + int T, ca = 0, ans; + scanf("%d", &T); + while (T--) { + init(); + ans = 0; + scanf("%d %d", &N, &MM); + for (int i = 0; i < N; ++i) { + scanf("%s", G[i]); + } + M = strlen(G[0]); + for (int i = 0; i < N; ++i) { + for (int j = 0; j < M; ++j) { + G[i][j] -= '0'; + build(i, j); + } + } + for (int i = 0; i < N; ++i) { + scanf("%s", S[i]); + for (int j = 0; j < M; ++j) { + if (S[i][j] == 'L') { + ++ans; + insert(source, to(i, j), 1); + insert(to(i, j), source, 0); + } + } + } + ans -= dinic(); + printf("Case #%d: ", ++ca); + if (!ans) { + puts("no lizard was left behind."); + } + else if (ans == 1){ + printf("%d lizard was left behind.\n", ans); + } + else { + printf("%d lizards were left behind.\n", ans); + } + } + return 0; +} diff --git a/HDOJ/2733_autoAC.cpp b/HDOJ/2733_autoAC.cpp new file mode 100644 index 0000000..3a3ee1b --- /dev/null +++ b/HDOJ/2733_autoAC.cpp @@ -0,0 +1,144 @@ +#include +#include +char s[81]; +int l; +int Dig(char c) +{ + if (c >= '0' && c <= '9') + { + return 1; + } + return 0; +} +int Upper(char c) +{ + if (c >= 'A' && c <= 'Z') + { + return 1; + } + return 0; +} +int Lower(char c) +{ + if (c >= 'a' && c <= 'z') + { + return 1; + } + return 0; +} +int Char(char c) +{ + if (Upper(c) || Lower(c)) + { + return 1; + } + return 0; +} +int Punc(char c) +{ + if (Dig(c) || Char(c) || c == ' ') + { + return 0; + } + return 1; +} +int Iso(char c) +{ + if (c == 'A' || c == 'a' || c == 'I') + { + return 1; + } + return 0; +} +int check1() +{ + int i; + for (i = 0; i < l - 1; i++) + { + if(Upper(s[i]) && Upper(s[i + 1])) + return 0; + } + return 1; +} +int check2() +{ + int i; + for (i = 0; i < l - 1; i++) + { + if ((Char(s[i]) && Dig(s[i + 1])) || (Char(s[i + 1]) && Dig(s[i]))) + return 0; + } + return 1; +} +int check3() +{ + int i; + if (l == 1) + { + if (Iso(s[0])) + { + return 1; + } + return 0; + } + if (s[1] == ' '&& Iso(s[0]) == 0 && s[0] != ' ') + return 0; + if (s[l - 2] == ' ' && Iso(s[l - 1]) == 0 && s[l - 1] != ' ') + return 0; + for (i = 1; i < l - 1; i++) + { + if(s[i] != ' ' && s[i - 1] == ' ' && s[i + 1] == ' ' && Iso(s[i]) == 0) + return 0; + } + return 1; +} +int check4() +{ + int i; + for (i = 0; i < l - 1; i++) + { + if(Punc(s[i]) && Punc(s[i + 1]) && s[i] != '\"' && s[i + 1] != '\"') + return 0; + } + return 1; +} +int check() +{ + if (check1() == 0) + { + return 0; + } + if (check2() == 0) + { + return 0; + } + if (check3() == 0) + { + return 0; + } + if (check4() == 0) + { + return 0; + } + return 1; +} +int main() +{ + while (1) + { + gets(s); + if (strcmp(s, "#") == 0) + { + break; + } + l = strlen(s); + if (check()) + { + printf("OK\n"); + } + else + { + printf("suspicious\n"); + } + } +} diff --git a/HDOJ/2734_autoAC.cpp b/HDOJ/2734_autoAC.cpp new file mode 100644 index 0000000..b9d5433 --- /dev/null +++ b/HDOJ/2734_autoAC.cpp @@ -0,0 +1,25 @@ +#include +#include +int main() +{ + char a[300]; + int i; + int b[300]; + while(gets(a) &&a[0]!='#') + { + memset(b,0,sizeof(b)); + int l=strlen(a); + for(i=0;i +#include +#include +using namespace std; +int main(){ + char str[100]; + while(scanf("%s", str)&&str[0]!='#'){ + int flag=1, ans=0, len=strlen(str), t=0, i; + for(i=0; i +#include +int main() +{ +int i,j,len,k,z,l,flag; +char ch[100]; +char s[100][2]; +while(gets(ch)) +{ +memset(s,0,sizeof(s)); +flag=0; +if(ch[0]=='*') +break; +len=strlen(ch); +for(i=1;i +#include +#include +#include +#include +using namespace std; +#define maxn 101 +struct Term +{ + int s[maxn]; + char ch[maxn]; +}term[maxn]; +string word[maxn]; +string st; +int n, m, termnum[maxn]; +bool input() +{ + int i = 0; + while (1) + { + getline(cin, word[i]); + if (word[i] == "#") + return false; + if (word[i] == "*") + break; + i++; + } + n = i; + return true; +} +void getterm(string &a, Term &term, int &num) +{ + int i = 0, j = 0; + while (i < a.length()) + { + if (a[i] != '-' && a[i] != '+') + { + term.ch[j] = a[i]; + term.s[j] = 1; + i++; + j++; + continue; + } + if (a[i] == '-') + term.s[j] = 0; + if (a[i] == '+') + term.s[j] = 2; + i++; + term.ch[j] = a[i]; + i++; + j++; + } + num = j; +} +void maketerms() +{ + int temp; + int i = 0; + temp = st.find('|'); + while (temp != string::npos) + { + string sub = st.substr(0, temp); + getterm(sub, term[i], termnum[i]); + st.erase(0, temp + 1); + i++; + temp = st.find('|'); + } + getterm(st, term[i], termnum[i]); + m = i + 1; +} +bool match(string &word, Term &term, int &num) +{ + for (int i = 0; i < num; i++) + if (term.s[i] == 0 && word.find(term.ch[i]) != string::npos) + return false; + for (int i = 0; i < num; i++) + if (term.s[i] == 2 && word.find(term.ch[i]) == string::npos) + return false; + for (int i = 0; i < num; i++) + if (term.s[i] == 1 && word.find(term.ch[i]) != string::npos) + return true; + return false; +} +int main() +{ + while (1) + { + if (!input()) + break; + sort(word, word + n); + while (getline(cin, st) && st != "**") + { + bool found = false; + maketerms(); + for (int i = 0; i < n; i++) + { + for (int j = 0; j < m; j++) + if (match(word[i], term[j], termnum[j])) + { + found = true; + cout << word[i] << endl; + break; + } + if (found) + break; + } + if (!found) + cout << "NONE" << endl; + } + cout << "$" << endl; + } + return 0; +} diff --git a/HDOJ/2739_autoAC.cpp b/HDOJ/2739_autoAC.cpp new file mode 100644 index 0000000..5654e3e --- /dev/null +++ b/HDOJ/2739_autoAC.cpp @@ -0,0 +1,96 @@ +#include +#include "math.h" +int e[2001][2];//杈[0],to.[1]next; +int a[1001][5];//[0],ID,[1]next;2x3y4z +int c[1001]; +int cnum; +int max;int m; +bool sign[1001]; +int n;//圭扮 +int en;//杈圭扮 +void initt(); +void init(); +int DFS(int s); +int eq(int x); +int main() +{ + while(1) + { + scanf("%d",&n); + if(n==0)return 0; + initt(); + init(); + int min=1000; + int i; + for(i=1;i<=n;i++)//n娆DFS + { + max=0; + m=0; + DFS(i); + if(maxc[2])printf("%d %d",c[2],c[1]); + else printf("%d %d",c[1],c[2]); + } + printf("\n"); + } +} +int DFS(int s) +{ + if(sign[s])return 0; + if((!e[a[s][1]][1])&&sign[e[a[s][1]][0]]){ + if(max +#include +int main() +{ +double B,N; +int A; +while(scanf("%lf%lf",&B,&N)&&(B!=0.0||N!=0.0)) +{ +A=pow(B,1/N); +if((B-pow(A,N))<(pow(A+1,N)-B)) + printf("%d\n",A); +else + printf("%d\n",A+1); + } + return 0; +} diff --git a/HDOJ/2752_autoAC.cpp b/HDOJ/2752_autoAC.cpp new file mode 100644 index 0000000..1615cb6 --- /dev/null +++ b/HDOJ/2752_autoAC.cpp @@ -0,0 +1,58 @@ +#include +#include +#include +using namespace std ; +#define M 100000 + 10 +#define eps 1e-4 +int A[M] ; +int n ; +int m ; +int slove(double x) +{ + int sum = 0 ; + double d = A[0] ; + d += 2 * x ; + int i = 0 ; + ++ sum ; + while(d < A[m -1] * 1.0 ) + { + while(A[i] <= d) ++ i ; + d = A[i] + 2 * x ; + sum ++ ; + } + return sum ; +} +double Find(double left , double right) +{ + double mid ; + while(right - left > eps) + { + mid = left + (right - left) / 2 ; + if(slove(mid) <= n) + right = mid ; + else left = mid +eps ; + } + return left ; +} +int main() +{ + int cas ; + double low ; + double high ; + double ans ; + while(scanf("%d",&cas) != EOF) + { + while(cas --) + { + scanf("%d%d",&n,&m) ; + for(int i = 0 ;i < m ; ++ i) + scanf("%d",&A[i]) ; + sort(A , A+ m) ; + low = 0 ; + high = A[m -1] * 1.0 / n ; + ans = Find(low , high) ; + printf("%.1lf\n",ans) ; + } + } + return 0 ; +} diff --git a/HDOJ/2753_autoAC.cpp b/HDOJ/2753_autoAC.cpp new file mode 100644 index 0000000..e65df1d --- /dev/null +++ b/HDOJ/2753_autoAC.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +const int INF = 0x3f3f3f3f; +const double eps = 1e-5; +int n,m; +int sum; +int Dp[110000]; +int a[110]; +int main() +{ + int T; + while(~scanf("%d",&T)) + { + while(T--) + { + scanf("%d %d",&m,&n); + sum=0; + for(int i=1;i<=n;i++) + { + scanf("%d",&a[i]); + sum=max(sum,a[i]); + } + sum+=m; + memset(Dp,INF,sizeof(Dp)); + Dp[0]=0; + for(int i=1;i<=n;i++) + { + for(int j=sum;j>=a[i];j--) + { + if(Dp[j-a[i]]!=INF) + { + Dp[j]=min(Dp[j],Dp[j-a[i]]+1); + } + } + } + for(int i=m;;i++) + { + if(Dp[i]!=INF) + { + printf("%d %d\n",i,Dp[i]); + break; + } + } + } + } + return 0; +} diff --git a/HDOJ/2754_autoAC.cpp b/HDOJ/2754_autoAC.cpp new file mode 100644 index 0000000..899c139 --- /dev/null +++ b/HDOJ/2754_autoAC.cpp @@ -0,0 +1,72 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef long long LL; +typedef unsigned long long ULL; +#define MAX(a,b) ((a) > (b) ? (a) : (b)) +#define MIN(a,b) ((a) < (b) ? (a) : (b)) +#define MEM(a,b) memset((a),(b),sizeof(a)) +const int N = 10000; +vector v[N + 1]; +int flag[N + 1]; +int cnt; +void dfs(int x) +{ + if (flag[x]) return; + flag[x] = 1; + cnt++; + for (int i = 0; i < v[x].size(); i++) + { + dfs(v[x][i]); + } +} +int main() +{ + int ncase; + while (cin >> ncase) + { + while (ncase--) + { + int n, m, l; + cin >> n >> m >> l; + for (int i = 1; i <= n; i++) v[i].clear(); + for (int i = 0; i < m; i++) + { + int x, y; + cin >> x >> y; + v[x].push_back(y); + } + MEM(flag, 0); + cnt = 0; + while (l--) + { + int x; + cin >> x; + dfs(x); + } + cout << cnt << endl; + } + } + return 0; +} diff --git a/HDOJ/2755_autoAC.cpp b/HDOJ/2755_autoAC.cpp new file mode 100644 index 0000000..c96732e --- /dev/null +++ b/HDOJ/2755_autoAC.cpp @@ -0,0 +1,135 @@ +#include +#include +#include +#include +#include +using namespace std; +#define PI 3.14159265358979 +#define EPSILON 1e-6 +typedef struct Point +{ + double x,y; + Point(double a = 0,double b = 0):x(a),y(b) {} + Point(const Point & p):x(p.x),y(p.y) {} + friend Point operator + (const Point &p1, const Point & p2) + { + return Point(p1.x+p2.x,p1.y+p2.y); + } + Point & operator += (const Point & p) + { + x += p.x; + y += p.y; + return *this; + } + friend Point operator * (const Point & p, int u) + { + return Point(p.x*u,p.y*u); + } + Point & operator = (const Point & p) + { + x = p.x; + y = p.y; + return * this; + } + friend bool operator == (const Point & p1, const Point & p2) + { + if(fabs(p1.x-p2.x) +#include +using namespace std; +bool vis[1000000]; +int main(){ + int T, n; + while (scanf("%d",&T)==1){ + while (T--){ + scanf("%d", &n); + int temp, ans = 0; + queue que; + while (n--){ + scanf("%d", &temp); + while (vis[temp]){ + vis[que.front()] = false; + que.pop(); + } + que.push(temp); + vis[temp] = true; + if (que.size() > ans) + ans = que.size(); + } + printf("%d\n", ans); + while (que.size()){ + vis[que.front()] = false; + que.pop(); + } + } + } + return 0; +} diff --git a/HDOJ/2757_autoAC.cpp b/HDOJ/2757_autoAC.cpp new file mode 100644 index 0000000..50caae7 --- /dev/null +++ b/HDOJ/2757_autoAC.cpp @@ -0,0 +1,71 @@ +#include +#include +#include +using namespace std; +int sx,sy,ex,ey; +char a[1002][1002]; +int b[1002][1002]; +int dir[8][2]={0,-1,1,-1,1,0,1,1,0,1,-1,1,-1,0,-1,-1}; +struct fuck{ + int x, y,t; + friend bool operator< (const fuck &a, const fuck &b) + { + return a.t>b.t; + } +}f; +priority_queue q; +int bfs() +{ + int nx,ny,nt,x,y,t,i; + if(sx==ex&&sy==ey) + return 0; + f.x=sx;f.y=sy;f.t=0; + q.push(f); + b[sx][sy]=0; + while(!q.empty()) + { + x=q.top().x; + y=q.top().y; + t=q.top().t; + q.pop(); + for(i=0;i<8;i++) + { + nx=x+dir[i][1]; + ny=y+dir[i][0]; + nt=t+(i!=(a[x][y]-48)); + if(a[nx][ny]!='x'&&nt +#include +#include +using namespace std; +int T; +string str[105]; +int l, n; +void work() +{ + scanf("%d%d\n", &l, &n); + for (int i = 0; i < n; ++i) cin >> str[i]; + str[n] = str[0]; + int ans = n * l; + string cur = str[0]; + for (int i = 1; i < n; ++i) { + int common = 0; + for (int cl = 1; cl <= l; ++cl) if (cur.substr(cur.size() - cl, cl) == str[i].substr(0, cl)) common = cl; + cur += str[i].substr(common); + } + printf("%d\n", cur.size()); +} +int main() +{ + while (scanf("%d", &T) != EOF) + while (T--) work(); +} diff --git a/HDOJ/2762_autoAC.cpp b/HDOJ/2762_autoAC.cpp new file mode 100644 index 0000000..29c4f65 --- /dev/null +++ b/HDOJ/2762_autoAC.cpp @@ -0,0 +1,62 @@ +#include +using namespace std; +const int MAXP = 100; +int dis(int *p1, int *p2) +{ + int d = 0; + for(int i = 0; i < 3; ++i) + { + d += abs(p1[i] - p2[i]); + } + return d; +} +int main() +{ + int N; + cin>>N; + int points[MAXP][3]; + for(int no = 0; no < N; ++no) + { + int P; + cin>>P; + fscanf(stdin, "%d,%d,%d", &points[0][0], &points[0][1], &points[0][2]); + int area = 6; + bool iscorrect = true; + cout< +#include +#include +using namespace std; +const int N = 21; +const int M = 20; +int ans[21][N] = {{1}}; +int BigNumPow(int x[], int n); +int BigNumCopy(int x[], int y[]); +int BigNumMul(int x[], int y[]); +int BigNumAdd(int x[], int y[]); +int main() +{ + int n, t; + int i, j; + int BigNum[N], BigPow[N], BigStep[N], BigCycle[N], tem[N]; + memset(BigNum, 0, sizeof(BigNum)); + memset(BigPow, 0, sizeof(BigPow)); + memset(BigStep, 0, sizeof(BigStep)); + memset(BigCycle, 0, sizeof(BigCycle)); + BigNum[0] = 2; + BigStep[0] = 6; + BigStep[1] = 1; + BigPow[0] = 1; + BigCycle[0] = 4; + for(i = 1; i < 20; ++i) + { + while(BigNum[i] == 0 || BigNum[i] > 2) + { + BigNumMul(BigNum, BigStep); + BigNumAdd(BigPow, BigCycle); + } + BigNumCopy(ans[i], BigPow); + BigNumPow(BigStep, 5); + memset(tem, 0, sizeof(tem)); + for(j = 0; j < M; ++j) + { + tem[j] += BigCycle[j] * 5; + if(tem[j] > 9) + { + tem[j + 1] += tem[j] / 10; + tem[j] = tem[j] % 10; + } + } + BigNumCopy(BigCycle, tem); + } + scanf("%d", &t); + for(j = 1; j <= t; ++j) + { + scanf("%d", &n); + printf("%d %d ", j, n); + --n; + i = M; + while(ans[n][i] == 0) + --i; + while(i >= 0) + printf("%d", ans[n][i--]); + printf("\n"); + } + return 0; +} +int BigNumPow(int x[], int n) +{ + int tmp[N]; + int res[N]; + BigNumCopy(tmp, x); + memset(res, 0, sizeof(res)); + res[0] = 1; + while(n > 0) + { + if(n & 1) + { + BigNumMul(res, tmp); + } + BigNumMul(tmp, tmp); + n = n >> 1; + } + BigNumCopy(x, res); + return 0; +} +int BigNumCopy(int x[], int y[]) +{ + int i; + for(i = 0; i < N; ++i) + x[i] = y[i]; + return 0; +} +int BigNumMul(int x[], int y[]) +{ + int i, j, k; + int tem[N]; + int res[N]; + memset(res, 0, sizeof(res)); + for(i = 0; i < M; ++i) + { + memset(tem, 0, sizeof(tem)); + for(k = i, j = 0; k < M; ++j, ++k) + { + tem[k] += y[i] * x[j]; + tem[k + 1] += tem[k] / 10; + tem[k] = tem[k] % 10; + } + BigNumAdd(res, tem); + } + BigNumCopy(x, res); + return 0; +} +int BigNumAdd(int x[], int y[]) +{ + int i; + for(i = 0; i < M; ++i) + { + x[i] += y[i]; + if(x[i] > 9) + { + x[i] -= 10; + ++x[i + 1]; + } + } + return 0; +} diff --git a/HDOJ/2765_autoAC.cpp b/HDOJ/2765_autoAC.cpp new file mode 100644 index 0000000..f4e5a14 --- /dev/null +++ b/HDOJ/2765_autoAC.cpp @@ -0,0 +1,49 @@ +#include +using namespace std; +const int MAX = 2140000000; +int f[1000001]; +void dfs(int p) +{ + int i,sum = 1,temp; + if(p%2 == 1) + { + for(i=1;i>t; + while(t--) + { + cin>>n; + if(f[n] == MAX) + dfs(n); + cout< +#include +#include +#include +#include +#include +#include +#include +using namespace std; +typedef __int64 ll; +typedef vector vi; +typedef vector vll; +string buf; +vll weight; +int deal(){ + weight.clear(); + cin >> buf; + int depth = 0; + ll tmp; + for (string::iterator ii = buf.begin(); ii != buf.end(); ii++){ + switch (*ii){ + case '[': + { + depth++; + }break; + case ']': + { + depth--; + }break; + case ',':break; + default: + { + tmp = 0; + while ('0' <= *ii && *ii <= '9') tmp = tmp * 10 + *ii - '0', ii++; + ii--; + weight.push_back(tmp << depth); + } + } + } + sort(weight.begin(), weight.end()); + int len = weight.size(); + int best = 0, cur = 1; + weight.push_back(-1); + for (int i = 0; i < len; i++){ + if (weight[i + 1] != weight[i]){ + best = max(best, cur); + cur = 1; + } + else cur++; + } + return len - best; +} +int main(){ + int T; + scanf("%d", &T); + while (T--){ + cout << deal() << endl; + } + return 0; +} diff --git a/HDOJ/2767_autoAC.cpp b/HDOJ/2767_autoAC.cpp new file mode 100644 index 0000000..af097da --- /dev/null +++ b/HDOJ/2767_autoAC.cpp @@ -0,0 +1,112 @@ +#include +#include +#include +#include +#include +#include +#include +using namespace std; +#define MAXN 200010 +#define clr(x,k) memset((x),(k),sizeof(x)) +struct node +{ + int st,to,next; +} +edge[MAXN]; +int n,m,ct,id; +int head[MAXN],low[MAXN],dfn[MAXN],belong[MAXN],in[MAXN],to[MAXN]; +bool instack[MAXN]; +stackq; +void add_e(int i,int u,int v) +{ + edge[i].st=u; + edge[i].to=v; + edge[i].next=head[u]; + head[u]=i; +} +void tarjan(int i) +{ + int j; + dfn[i]=low[i]=++id; + q.push(i); + instack[i]=1; + for(int u=head[i]; ~u; u=edge[u].next) + { + j=edge[u].to; + if(dfn[j]==0) + { + tarjan(j); + if(low[i]>low[j]) + low[i]=low[j]; + } + else if(instack[j]&&low[i]>low[j]) + low[i]=dfn[j]; + } + if(dfn[i]==low[i]) + { + ct++; + do + { + j=q.top(); + q.pop(); + instack[j]=0; + belong[j]=ct; + } + while(i!=j); + } +} +int main() +{ + int t,i,u,v,sum1,sum2; + cin>>t; + while(t--) + { + clr(head,-1); + clr(low,0); + clr(dfn,0); + clr(belong,0); + clr(in,0); + clr(to,0); + while(!q.empty()) + q.pop(); + cin>>n>>m; + for(i=0; i>u>>v; + add_e(i,u,v); + } + id=ct=0; + for(i=1; i<=n; i++) + { + if(!dfn[i]) + tarjan(i); + } + if(ct==1) + { + cout<<0< +#include +int tot,list[20005],mark_dfs[20005],mark_gx[20005],n,m,k; +struct dian +{ + char need[50]; + char no[50]; +}cun1[20005]; +struct ren +{ + int date,next; +}cun[20005]; +void add(int a,int b) +{ + cun[tot].date=b; + cun[tot].next=list[a]; + list[a]=tot++; +} +int dfs(int x) +{ + for(int i=list[x];i;i=cun[i].next) + { + int date=cun[i].date; + if(mark_dfs[date]) continue; + mark_dfs[date]=1; + if(mark_gx[date]==-1||dfs(mark_gx[date])) + { + mark_gx[date]=x; + return 1; + } + } + return 0; +} +void clear() +{ + memset(list,0,sizeof(list)); +} +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + tot=1; + clear(); + scanf("%d%d%d",&n,&m,&k); + for(int i=1;i<=k;i++) + { + scanf("%s%s",cun1[i].need,cun1[i].no); + } + for(int i=1;i +#include +#include +#include +#include +#include +using namespace std; +#define mod 10001 +long long in[10010]; +long long out[10010]; +long long exgcd(long long a,long long b,long long &x,long long &y) +{ + if(!b) + { + x=1; + y=0; + return a; + } + long long tt=exgcd(b,a%b,x,y); + long long t; + t=x; + x=y; + y=(t-a/b*y); + return tt; +} +int main() +{ + int n; + scanf("%d",&n); + for(int i=0;i +#include +#include +#include +using namespace std; +const long long inf=1LL<<62; +const int maxn=110; +const int maxm=maxn*maxn*2; +int n,cnt; +long long h[maxn],s[maxm],dp[maxn][maxm],d; +int q[maxm]; +void Init() +{ + for(int i=0;i<=n;i++) + for(int j=0;j=dp[i-1][now]) + last--; + q[last++]=now++; + } + while(pres[q[pre]]) + pre++; + dp[i][j]=abs(h[i]-s[j])+dp[i-1][q[pre]]; + } + } + ind=lower_bound(s,s+cnt,h[n])-s; + if(dp[n][ind]>=inf) + printf("impossible\n"); + else + printf("%I64d\n",dp[n][ind]); +} +int main() +{ + int T; + scanf("%d",&T); + while(T--) + { + cnt=0; + scanf("%d%I64d",&n,&d); + for(int i=1;i<=n;i++) + scanf("%I64d",&h[i]); + for(int i=1;i<=n;i++) + for(long long j=0;j +#include +#include +#include +using namespace std; +const int maxn = 50 + 5; +const int maxc = 1000 + 1; +int n; +int x0[maxn], y0[maxn], z0[maxn], x1[maxn], y1[maxn], z1[maxn]; +int xs[maxn*2], ys[maxn*2], zs[maxn*2], nx, ny, nz; +int color[maxn*2][maxn*2][maxn*2]; +int dx[] = {0, 0, 0, 0, -1, 1}; +int dy[] = {0, 0, -1, 1, 0, 0}; +int dz[] = {-1, 1, 0, 0, 0, 0}; +struct Cell +{ + int x, y, z; + Cell(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {} + void setVis() const { + color[x][y][z] = 2; + } + int volume() const { + return (xs[x+1]-xs[x])*(ys[y+1]-ys[y])*(zs[z+1]-zs[z]); + } + Cell neighbor(int i) const { + return Cell(x+dx[i], y+dy[i], z+dz[i]); + } + bool valid() const { + return x>=0 && x=0 && y=0 && z Q; Q.push(c); + while (!Q.empty()) + { + Cell now = Q.front(); Q.pop(); + v += now.volume(); + for (int i = 0; i < 6; i++) + { + Cell nxt = now.neighbor(i); + if (!nxt.valid()) continue; + if (nxt.solid()) s += now.area(i); + else if(!nxt.getVis()) + { + nxt.setVis(); + Q.push(nxt); + } + } + } + v = maxc*maxc*maxc - v; +} +int main() +{ + int t; scanf("%d", &t); + while (t--) + { + scanf("%d", &n); + nx = ny = nz = 2; + xs[0] = ys[0] = zs[0] = 0; + xs[1] = ys[1] = zs[1] = maxc; + for (int i = 0; i < n; i++) + { + scanf("%d%d%d", &x0[i], &y0[i], &z0[i]); + scanf("%d%d%d", &x1[i], &y1[i], &z1[i]); + x1[i] += x0[i], y1[i] += y0[i], z1[i] += z0[i]; + xs[nx++] = x0[i], xs[nx++] = x1[i]; + ys[ny++] = y0[i], ys[ny++] = y1[i]; + zs[nz++] = z0[i], zs[nz++] = z1[i]; + } + discretize(xs, nx), discretize(ys, ny), discretize(zs, nz); + memset(color, 0, sizeof(color)); + for (int i = 0; i < n; i++) + { + int X1 = ID(xs, nx, x0[i]), X2 = ID(xs, nx, x1[i]); + int Y1 = ID(ys, ny, y0[i]), Y2 = ID(ys, ny, y1[i]); + int Z1 = ID(zs, nz, z0[i]), Z2 = ID(zs, nz, z1[i]); + for (int X = X1; X < X2; X++) + { + for (int Y = Y1; Y < Y2; Y++) + { + for (int Z = Z1; Z < Z2; Z++) + { + color[X][Y][Z] = 1; + } + } + } + } + int s, v; + floodfill(s, v); + printf("%d %d\n", s, v); + } + return 0; +} diff --git a/HDOJ/2772_autoAC.cpp b/HDOJ/2772_autoAC.cpp new file mode 100644 index 0000000..252740f --- /dev/null +++ b/HDOJ/2772_autoAC.cpp @@ -0,0 +1,71 @@ +#include +int main() +{ + int t,n,min,max_1,max_2,min_1,min_2; + scanf("%d",&t); + while(t--) + { + scanf("%d",&n); + if(n<=1) + return 0; + else if(n==2) + printf("1 1\n"); + else if(n==3) + printf("7 7\n"); + else if(n==4) + printf("4 11\n"); + else if(n==5) + printf("2 71\n"); + else if(n==6) + printf("6 111\n"); + else if(n==7) + printf("8 711\n"); + else if(n==8) + printf("10 1111\n"); + else if(n==9) + printf("18 7111\n"); + else if(n==10) + printf("22 11111\n"); + else if(n==11) + printf("20 71111\n"); + else if(n==12) + printf("28 111111\n"); + else if(n==13) + printf("68 711111\n"); + else if(n==14) + printf("88 1111111\n"); + else + { + max_1=(n-15)/7; + max_2=(n-14)%7; + if(max_2==1) + printf("108"); + else if(max_2==2) + printf("188"); + else if(max_2==3) + printf("200"); + else if(max_2==4) + printf("208"); + else if(max_2==5) + printf("288"); + else if(max_2==6) + printf("688"); + else if(max_2==0) + printf("888"); + if(max_1) + while(max_1--) + printf("8"); + printf(" "); + min_1=n/2-1; + min_2=n%2;; + if(min_2==0) + printf("1"); + else if(min_2==1) + printf("7"); + while(min_1--) + printf("1"); + printf("\n"); + } + } + return 0; +} diff --git a/HDOJ/2773_autoAC.cpp b/HDOJ/2773_autoAC.cpp new file mode 100644 index 0000000..975240b --- /dev/null +++ b/HDOJ/2773_autoAC.cpp @@ -0,0 +1,88 @@ +#include +#include +#include +#include +#include +#define eps 1e-8 +#define N 20010 +using namespace std; +int Sig(double a) +{ + return a<-eps?-1:a>eps; +} +struct Point +{ + double x,y; + void input() + { + scanf("%lf%lf",&x,&y); + } + Point(){} + Point(double x0,double y0):x(x0),y(y0){} +}; +int n1,n2; +Point p1[110]; +Point p2[110]; +double Xmult(Point o,Point a,Point b) +{ + return (a.x-o.x)*(b.y-o.y)-(b.x-o.x)*(a.y-o.y); +} +double Dis(Point a,Point b) +{ + return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)); +} +Point Intersection(Point u1,Point u2,Point v1,Point v2) +{ + Point ret=u1; + double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x))/ + ((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x)); + ret.x+=(u2.x-u1.x)*t; + ret.y+=(u2.y-u1.y)*t; + return ret; +} +void Judge(Point o,Point a,Point b,double &d) +{ + Point tmp=Point(b.y-a.y+o.x,a.x-b.x+o.y); + Point p=Intersection(o,tmp,a,b); + if(Sig(Dis(a,b)-Dis(a,p)-Dis(b,p))) + d=min(Dis(a,o),Dis(b,o)); + else + d=fabs(Xmult(o,a,b))/Dis(a,b); +} +int main() +{ + int t; + scanf("%d",&t); + while(t--) + { + scanf("%d",&n1); + for(int i=0;i +#include +#include +#include +using namespace std; +int v[10],n,a[8][2],rest[20],now[8],occ[23],tot[100]; +long long score[100]; +char s[21]; +int getrank(char ch){ + if(ch=='A')return 1; + if(ch=='T')return 10; + if(ch=='J')return 11; + if(ch=='Q')return 12; + if(ch=='K')return 13; + return ch-'2'+2; +} +int getsuit(char ch){ + if(ch=='c')return 1; + if(ch=='d')return 2; + if(ch=='h')return 3; + if(ch=='s')return 4; +} +bool can(int col,int mask) +{ + for(int i=0;i<5;++i) + for(int j=i+1;j<5;++j) + if(now[i]==now[j]) + return false; + for(int i=0;i<5;++i) + if((mask&(1< +#include +#include +#include +using namespace std; +bool flag[50]; +struct time +{ + int start; + int end; + bool operator <(const time a)const + { + if(a.end==end) + return a.startQ; + int i,n,j=0,t; + while(++j) + { + memset(flag,false,sizeof(flag)); + scanf("%d",&n); + if(!n) + return 0; + for(i=0;i +#include +#include +#include +#include +#include +#include +#include +using namespace std; +int cnt,mark; +char vis[12][12]; +int map[12][12]; +struct Node +{ + int x,y; +}node[102]; +int Judge(int x,int y,int z) +{ + int i,j,n,m; + for(i=0;i<9;i++) + { + if(map[i][y]==z && i!=x) + return 1; + } + for(j=0;j<9;j++) + { + if(map[x][j]==z && j!=y) + return 1; + } + for(n=0,i=x/3*3;n<3;n++,i++) + for(m=0,j=y/3*3;m<3;m++,j++) + { + if(i==x && j==y) + continue; + if(map[i][j]==z) + return 1; + } + return 0; +} +int judge() +{ + int i,j; + for(i=0;i<9;i++) + for(j=0;j<9;j++) + { + if(!map[i][j]) + continue; + if(Judge(i,j,map[i][j])) + return 1; + } + return 0; +} +void dfs(int n) +{ + int i; + if(n==cnt) + { + mark=1; + return; + } + if(mark) + return; + for(i=1;i<=9;i++) + { + if(Judge(node[n].x,node[n].y,i)) + continue; + map[node[n].x][node[n].y]=i; + dfs(n+1); + if(mark) + return; + map[node[n].x][node[n].y]=0; + } +} +void clear() +{ + cnt=0; + memset(map,0,sizeof(map)); + memset(vis,0,sizeof(vis)); + memset(node,0,sizeof(node)); +} +int main() +{ + int k,i,j; + bool f=false; + scanf("%d",&k); + while(k--) + { + if(f) + printf("\n"); + f=true; + clear(); + for(i=0;i<9;i++) + { + scanf("%s",vis[i]); + } + for(i=0;i<9;i++) + { + for(j=0;j<9;j++) + { + map[i][j]=vis[i][j]-'0'; + if(!map[i][j]) + { + node[cnt].x=i; + node[cnt].y=j; + cnt++; + } + } + } + if(judge()) + { + printf("Could not complete this grid.\n"); + continue; + } + mark=0; + dfs(0); + if(mark) + { + for(i=0;i<9;i++) + { + for(j=0;j<9;j++) + printf("%d",map[i][j]); + printf("\n"); + } + } + else + { + printf("Could not complete this grid.\n"); + } + } + return 0; +} diff --git a/HDOJ/2782_autoAC.cpp b/HDOJ/2782_autoAC.cpp new file mode 100644 index 0000000..ac93d48 --- /dev/null +++ b/HDOJ/2782_autoAC.cpp @@ -0,0 +1,116 @@ +#include +#include +using namespace std; +int map[700][700]; +int vis[700][700]; +int ansx,ansy; +int ansd,anssum; +int n,m; +int res=0; +int xx[4]={0,-1,1,0}; +int yy[4]={1,0,0,-1}; +void dfs(int x,int y,int ans,int pre) +{ + if(pre==-1) + { + int i; + for(i=0;i<4;i++) + { + int nx=x+xx[i]; + int ny=y+yy[i]; + if(nx<0||nx>=n||ny<0||ny>=m) + continue; + if(vis[nx][ny]) + continue; + vis[nx][ny]=1; + dfs(nx,ny,ans+1,i); + vis[nx][ny]=0; + if(res>anssum) + { + ansx=x; + ansy=y; + ansd=i; + anssum=res; + } + } + return ; + } + int i; + int flag=1; + int nx=x+xx[pre]; + int ny=y+yy[pre]; + if(nx>=0&&nx=0&&ny=n||ny<0||ny>=m) + continue; + if(vis[nx][ny]) + continue; + vis[nx][ny]=1; + dfs(nx,ny,ans+1,i); + vis[nx][ny]=0; + flag=0; + } + } + if(flag) + { + if(res +#include +#include +#include +#include +#include +using namespace std ; +typedef pair pii ; +#define X first +#define Y second +const int N = 1010 ; +const int inf = 1e9+7 ; +typedef long long LL; +int n , xx[N] , pre[N] , ww[N] , tot ; +vectorg[N]; +struct node { + int a , c , d , id ; + node(){}; + node( int a , int c , int d , int id ):a(a),c(c),d(d),id(id){} + bool operator < ( const node &A ) const { + if( d != A.d ) return d > A.d ; + else if( c != A.c ) return c > A.c ; + else { + stacks1 , s2; int id1 = id , id2 = A.id ; + while( id1 != -1 ) { s1.push( xx[id1] ); id1 = pre[id1] ; } + while( id2 != -1 ) { s2.push( xx[id2] ); id2 = pre[id2] ; } + while( !s1.empty() ) { + int a = s1.top() ; s1.pop() ; + int b = s2.top() ; s2.pop() ; + if( a > b ) return true ; + } + return false ; + } + } +}; +int bestpath[N] , bestcnt , bestcost ; +int tmppath[N] , tmpcnt , tmpcost ; +void Choose_best( int id , int cnt ) { + if( tmpcost > bestcost ) return ; + stacks ; + while( id != -1 ) { s.push( xx[id] ); id = pre[id] ; } + tmpcnt = 0 ; + while( !s.empty() ) { tmppath[tmpcnt++] = s.top() ; s.pop() ; } + if( tmpcost < bestcost ) { + bestcnt = tmpcnt ; + bestcost = tmpcost ; + for( int i = 0 ; i < tmpcnt ; ++i ) bestpath[i] = tmppath[i] ; + return ; + } + if( cnt > bestcnt ) return ; + else if( cnt < bestcnt ) { + bestcnt = tmpcnt ; + for( int i = 0 ; i < tmpcnt ; ++i ) bestpath[i] = tmppath[i] ; + } else { + for( int i = 0 ; i < tmpcnt ; ++i ) { + if( bestpath[i] > tmppath[i] ) { + for( int j = i ; j < bestcnt ; ++j ) { + bestpath[j] = tmppath[j] ; + } + } else if ( bestpath[i] < tmppath[i] ) { + break ; + } + } + } +} +int dis[N] ; +void dij() { + memset( dis , 0x3f , sizeof dis ); + priority_queueque; + tot = 0 ; xx[tot] = 0 , pre[tot] = -1 ; tot++ ; + que.push( node(0,0,0,tot-1) ); + dis[0] = 0 ; + while( !que.empty() ) { + int u = que.top().a , cnt = que.top().c , cost = que.top().d , id = que.top().id ; + que.pop(); + if( cost > dis[u] ) continue ; + if( u == 1 ) { + if( dis[u] ) { + tmpcost = dis[u] ; + Choose_best( id , cnt ); + } + return ; + } + for( int i = 0 ; i < g[u].size() ; ++i ) { + int v = g[u][i].X , w = ww[g[u][i].Y] ; + if( dis[v] > dis[u] + w ) { + dis[v] = dis[u] + w ; + xx[tot] = v ; pre[tot] = id ; tot++; + que.push( node( v , cnt+1 , dis[v] , tot - 1 ) ) ; + } + } + } +} +void Gao() { + dij(); + for( int i = 0 ; i < n ; ++i ) { + int cc = ww[i] ; ww[i] = 0 ; + dij(); + for( int j = i + 1 ; j < n ; ++j ) { + int dd = ww[j] ; ww[j] = 0 ; + dij(); ww[j] = dd ; + } + ww[i] = cc ; + } + for( int i = 0 ; i < bestcnt ; ++i ) cout << bestpath[i] << ' ' ; + cout << bestcost << endl ; +} +int Run() { + while( cin >> n && n ) { + bestcost = bestcnt = inf ; + for( int i = 0 ; i < N ; ++i ) g[i].clear(); + for( int i = 0 ; i < n ; ++i ) { + int u , v , w ; cin >> u >> v >> w ; + ww[i] = w ; + g[u].push_back(pii(v,i)); + g[v].push_back(pii(u,i)); + } + Gao(); + } + return 0 ; +} +int main() { + ios::sync_with_stdio(0); + return Run(); +} diff --git a/HDOJ/2785_autoAC.cpp b/HDOJ/2785_autoAC.cpp new file mode 100644 index 0000000..bbcce16 --- /dev/null +++ b/HDOJ/2785_autoAC.cpp @@ -0,0 +1,128 @@ +#include +#include +#include +#include +using namespace std; +int n; +struct acc{ + int meb; + int bam; + double mo; +}arr[110]; +int judge(int ac, int b){ + int i; + for(i = 0; i < n; i++) + { + if(arr[i].meb == ac && arr[i].bam == b) + { + return i; + } + } + return -1; +} +int main() +{ + int i; + char cao[100]; + while(cin >> n) + { + if(n == 0) + { + cout << "goodbye" << endl; + break; + } + char s; + for(i = 0; i < n; i++) + { + scanf("%d%c%d%lf", &arr[i].meb, &s, &arr[i].bam, &arr[i].mo); + } + while(1){ + scanf("%s", cao); + int l = strlen(cao); + if(strcmp(cao, "end") == 0) + break; + int ac, bank; + double money; + if(cao[0] == 'c') + { + scanf("%d%c%d", &ac, &s, &bank); + if(judge(ac, bank) == -1) + { + arr[n].meb = ac; + arr[n].bam = bank; + arr[n++].mo = 0.0; + cout << "create: ok" << endl; + } + else + { + cout << "create: already exists" << endl; + } + } + else if(cao[0] == 'd') + { + scanf("%d%c%d%lf", &ac, &s, &bank, &money); + int num = judge(ac, bank); + if(num == -1) + { + printf("deposit %.2lf: no such account\n", money); + } + else{ + arr[num].mo += money; + printf("deposit %.2lf: ok\n", money); + } + } + else if(cao[0] == 'w') + { + scanf("%d%c%d%lf", &ac, &s, &bank, &money); + int num = judge(ac, bank); + if(num == -1){ + printf("withdraw %.2lf: no such account\n", money); + } + else{ + if(arr[num].mo < money) + { + printf("withdraw %.2lf: insufficient funds\n", money); + } + else{ + arr[num].mo -= money; + printf("withdraw %.2lf: ok\n", money); + } + } + } + else if(cao[0] == 't') + { + int ac1, bank1; + char s1; + scanf("%d%c%d%d%c%d%lf", &ac, &s, &bank, &ac1, &s1, &bank1, &money); + int num = judge(ac, bank); + int num1 = judge(ac1, bank1); + if(num == -1 || num1 == -1){ + printf("transfer %.2lf: no such account\n", money); + } + else{ + if(arr[num].meb == arr[num1].meb && arr[num].bam == arr[num1].bam) + { + printf("transfer %.2lf: same account\n", money); + } + else if(arr[num].mo < money) + { + printf("transfer %.2lf: insufficient funds\n", money); + } + else{ + arr[num].mo -= money; + arr[num1].mo += money; + if(arr[num].bam == arr[num1].bam) + { + printf("transfer %.2lf: ok\n", money); + } + else{ + printf("transfer %.2lf: interbank\n", money); + } + } + } + } + } + cout << "end" << endl << endl; + } + return 0; +} diff --git a/HDOJ/2788_autoAC.cpp b/HDOJ/2788_autoAC.cpp new file mode 100644 index 0000000..5404ca0 --- /dev/null +++ b/HDOJ/2788_autoAC.cpp @@ -0,0 +1,57 @@ +#include +#include +#include +using namespace std; +const int MAX = 1010; +struct BID{ + char name[25], type[5]; + double price; +}; +BID bid[MAX], buy[MAX], sell[MAX]; +int main(){ + int N, flag; + char issuer[12]; + while(scanf("%d%s", &N, issuer) != EOF && N) + { + int cntb = 0, cnts = 0; + for(int i = 0; i < N; ++i) + { + scanf("%s%s%lf", bid[i].name, bid[i].type, &bid[i].price); + if(strcmp(bid[i].type, "buy") == 0) + buy[cntb++] = bid[i]; + if(strcmp(bid[i].type, "sell") == 0) + sell[cnts++] = bid[i]; + } + printf("%s\n", issuer); + for(int i = 0; i < N; ++i) + { + flag = 0; printf("%s:", bid[i].name); + if(strcmp(bid[i].type, "buy") == 0) + { + for(int j = 0; j < cnts; ++j) + { + if(sell[j].price <= bid[i].price) + { + printf(" %s", sell[j].name); + flag = 1; + } + } + } + if(strcmp(bid[i].type, "sell") == 0) + { + for(int j = 0; j < cntb; ++j) + { + if(buy[j].price >= bid[i].price) + { + printf(" %s", buy[j].name); + flag = 1; + } + } + } + if(!flag) + printf(" NO-ONE"); + printf("\n"); + } + } + return 0; +} diff --git a/HDOJ/2791_autoAC.cpp b/HDOJ/2791_autoAC.cpp new file mode 100644 index 0000000..5177026 --- /dev/null +++ b/HDOJ/2791_autoAC.cpp @@ -0,0 +1,24 @@ +#include +#include +#include +using namespace std; +const int N = 50009; +int a[N]; +int main(){ + int n, i, j, k; + while(~scanf("%d", &n) && n) + { + for(i = 0; i < n; ++i) + scanf("%d", &a[i]); + sort(a, a+n); + printf("%d-A", a[0]); + for(i = n-1; i >= 1; --i){ + if(i&1) + printf(" %d-B", a[i]); + else + printf(" %d-A",a[i]); + } + puts(""); + } + return 0; +} diff --git a/HDOJ/2793_autoAC.cpp b/HDOJ/2793_autoAC.cpp new file mode 100644 index 0000000..a49b4f5 --- /dev/null +++ b/HDOJ/2793_autoAC.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +#include +using namespace std; +const __int64 MAX_N = 5; +const __int64 MOD = 1000000007; +__int64 N; +void multipy( __int64 a[MAX_N][MAX_N], __int64 b[MAX_N][MAX_N], __int64 c[MAX_N][MAX_N] ){ + for( __int64 i = 1; i <= 4; i++ ){ + for( __int64 j = 1; j <= 4; j++ ){ + c[i][j] = 0; + for( __int64 k = 1; k <= 4; k++ ){ + c[i][j] = ( c[i][j] + a[i][k] * b[k][j] % MOD ) % MOD; + } + } + } +} +void get_matrix_pow( __int64 a[MAX_N][MAX_N], __int64 n ){ + __int64 ans[MAX_N][MAX_N] = {0}; + __int64 temp[MAX_N][MAX_N]; + for( __int64 i = 1; i <= 4; i++ ) ans[i][i] = 1; + while( n ){ + if( n % 2 == 1 ){ + multipy( ans, a, temp ); + memcpy( ans, temp, sizeof( __int64 ) * MAX_N * MAX_ ); + } + multipy( a, a, temp ); + memcpy( a, temp, sizeof( __int64 ) * MAX_N * MAX_ ); + n /= 2; + } + memcpy( a, ans, sizeof( __int64 ) * MAX_N * MAX_ ); +} +__int64 solve( __int64 n ){ + __int64 a[MAX_N][MAX_N] = {0}; + if( n < 0 ){ + return 0; + } + if( n == 0 ){ + return 1; + }else if( n == 1 ){ + return 2; + } + a[1][1] = 0;a[1][2] = 1;a[1][3] = 0;a[1][4] = 0; + a[2][1] = 0;a[2][2] = 0;a[2][3] = 1;a[2][4] = 0; + a[3][1] = 1;a[3][2] = 1;a[3][3] = 1;a[3][4] = 0; + a[4][1] = 0;a[4][2] = 0;a[4][3] = 1;a[4][4] = 1; + get_matrix_pow( a, n - 1 ); + __int64 ans = 0; + __int64 b[MAX_N]; + b[1] = b[2] = b[3] = 1; + b[4] = 2; + for( __int64 i = 1; i <= 4; i++ ){ + ans = ( ans + a[4][i] * b[i] % MOD ) % MOD; + } + return ans; +} +int main(){ + __int64 A, B; + while( scanf( "%I64d%I64d", &A, &B ) != EOF ){ + printf( "%I64d\n", ( solve( B ) - solve( A - 1 ) + MOD ) % MOD ); + } + return 0; +} diff --git a/HDOJ/2795_autoAC.cpp b/HDOJ/2795_autoAC.cpp new file mode 100644 index 0000000..8bff5bb --- /dev/null +++ b/HDOJ/2795_autoAC.cpp @@ -0,0 +1,50 @@ +#include +#include +#define MAXN 200050 +#define lchild rt << 1, l, m +#define rchild rt << 1 | 1, m + 1, r +using namespace std; +int h, w, n, m; +class Segment_Tree{ +private: + int node[MAXN << 2]; + void push_up(int rt){ + node[rt] = min(node[rt << 1], node[rt << 1 | 1]); + } +public: + void build(){ + memset(node, 0, sizeof(node)); + } + int update(int val, int rt = 1, int l = 1, int r = n){ + if (l == r){ + if (node[rt] + val <= w){ + node[rt] += val; + return l; + } + else return 0; + } + int m = (l + r) >> 1, ret = 0; + if (node[rt << 1] + val <= w) ret += update(val, lchild); + else ret += update(val, rchild); + push_up(rt); + return ret; + } + int query(){ + return node[1]; + } +}st; +int main(){ + int wi; + while (scanf("%d %d %d", &h, &w, &m) != EOF){ + st.build(); + n = min(h, m); + while (m--){ + scanf("%d", &wi); + if (st.query() + wi <= w){ + printf("%d\n", st.update(wi)); + } + else printf("-1\n"); + } + } + return 0; +} diff --git a/HDOJ/2796_autoAC.cpp b/HDOJ/2796_autoAC.cpp new file mode 100644 index 0000000..1d5d574 --- /dev/null +++ b/HDOJ/2796_autoAC.cpp @@ -0,0 +1,28 @@ +#include +#include +#include +using namespace std; +int a[100],n; +int main(){ +while(scanf("%d",&n)!=EOF){ + memset(a,0,sizeof(a)); + for(int i=1;i<=n;i++){ + scanf("%d",&a[i]); + } + sort(a,a+n+1); + int k=1; + int fro=a[1]; + int site=1; + int left=0; + for(int i=2;i<=n;i++){ + if(a[i]>fro&&i-site+left>=k+1&&a[i]!=a[i-1]){ + fro=a[i]; + left=i-site-k-1+left; + site=i; + k++; + }else continue; + } + printf("%d\n",k); +} +return 0; +}