diff --git a/HDOJ/3303_autoAC.cpp b/HDOJ/3303_autoAC.cpp
new file mode 100644
index 0000000..2823fbf
--- /dev/null
+++ b/HDOJ/3303_autoAC.cpp
@@ -0,0 +1,170 @@
+#include <iostream>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <cctype>
+#include <string>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+#define MAXN 510005
+#define MAXM 164444
+#define INF 100000000
+#define eps 1e-7
+#define L(X) X<<1
+#define R(X) X<<1|1
+using namespace std;
+struct node
+{
+    int left, right;
+    int mi;
+}tree[4 * MAXN];
+int a[MAXN], pos[MAXN];
+void up(int C)
+{
+    tree[C].mi = min(tree[L(C)].mi, tree[R(C)].mi);
+}
+void make_tree(int s, int e, int C)
+{
+    tree[C].left = s;
+    tree[C].right = e;
+    tree[C].mi = INF;
+    if(s == e) return;
+    int mid = (s + e) >> 1;
+    make_tree(s, mid, L(C));
+    make_tree(mid + 1, e, R(C));
+}
+void update(int p, int C)
+{
+    if(tree[C].left == tree[C].right)
+    {
+        tree[C].mi = p;
+        return;
+    }
+    int mid = (tree[C].left + tree[C].right) >> 1;
+    if(mid >= p) update(p, L(C));
+    else update(p, R(C));
+    up(C);
+}
+int ans;
+void query(int s, int e, int C)
+{
+    if(tree[C].left >= s && tree[C].right <= e)
+    {
+        ans = min(ans, tree[C].mi);
+        return;
+    }
+    int mid = (tree[C].left + tree[C].right) >> 1;
+    if(mid >= s) query(s, e, L(C));
+    if(mid < e) query(s, e, R(C));
+}
+int in()
+{
+    int flag = 1;
+    char ch;
+    int a = 0;
+    while((ch = getchar()) == ' ' || ch == '\n');
+    if(ch == '-') flag = -1;
+    else
+    a += ch - '0';
+    while((ch = getchar()) != ' ' && ch != '\n')
+    {
+        a *= 10;
+        a += ch - '0';
+    }
+    return flag * a;
+}
+void out(int a)
+{
+    if(a >= 10)out(a / 10);
+    putchar(a % 10 + '0');
+}
+int main()
+{
+    int t, x, cas = 0;
+    char s;
+    while(scanf("%d", &t) != EOF && t)
+    {
+        if(cas) puts("");
+        int cnt = 0;
+        memset(pos, -1, sizeof(pos));
+        printf("Case %d:\n", ++cas);
+        make_tree(1, MAXN - 1, 1);
+        getchar();
+        while(t--)
+        {
+            s = getchar();
+            x = in();
+            if(s == 'A')
+            {
+                if(x < 5000)
+                {
+                    ans = INF;
+                    int tx = x;
+                    for(int i = cnt - 1; i >= 0; i--)
+                    {
+                        if(a[i] % x < tx)
+                        {
+                            tx = a[i] % x;
+                            ans = a[i];
+                        }
+                        if(tx == 0) break;
+                    }
+                    if(ans == INF) {puts("-1");}
+                    else {out(pos[ans] + 1); putchar('\n');}
+                }
+                else
+                {
+                    int bd = 500055 / x;
+                    int res = INF;
+                    int tx = x;
+                    for(int i = 0; i <= bd; i++)
+                    {
+                        ans = INF;
+                        int low = i * x;
+                        if(low < 1) low = 1;
+                        int high = (i + 1) * x - 1;
+                        if(high > 500054) high = 500054;
+                        query(low, high, 1);
+                        if(ans == INF) continue;
+                        if(ans % x < tx)
+                        {
+                            tx = ans % x;
+                            res = ans;
+                        }
+                        else if(ans % x == tx)
+                        {
+                            if(pos[ans] > pos[res]) res = ans;
+                        }
+                    }
+                    if(res == INF) {puts("-1");}
+                    else {out(pos[res] + 1); putchar('\n');}
+                }
+            }
+            else
+            {
+                if(pos[x] == -1)
+                {
+                    pos[x] = cnt;
+                    a[cnt++] = x;
+                    update(x, 1);
+                }
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3304_autoAC.cpp b/HDOJ/3304_autoAC.cpp
new file mode 100644
index 0000000..0bd9d3a
--- /dev/null
+++ b/HDOJ/3304_autoAC.cpp
@@ -0,0 +1,28 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define LL long long
+const int mod=10000;
+int main()
+{
+    int p,n,tt=0;
+    while(scanf("%d%d",&p,&n)!=EOF)
+    {
+        if(p==0&&n==0)
+            break;
+        int ans=1;
+        while(n)
+        {
+            ans*=(n%p+1);
+            n/=p;
+            if(ans>=mod)
+                ans%=mod;
+        }
+        printf("Case %d: %04d\n",++tt,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3306_autoAC.cpp b/HDOJ/3306_autoAC.cpp
new file mode 100644
index 0000000..3006bd6
--- /dev/null
+++ b/HDOJ/3306_autoAC.cpp
@@ -0,0 +1,90 @@
+#include<stdio.h>
+#include<algorithm>
+#include<string.h>
+using namespace std;
+struct mart
+{
+    __int64 mat[5][5];
+};
+__int64 mod=10007;
+mart kk;
+mart multi(mart a,mart b)
+{
+    mart c;
+    int i,j,k;
+    for(i=1;i<=4;i++)
+        for(j=1;j<=4;j++)
+        {
+            c.mat[i][j]=0;
+            for(k=1;k<=4;k++)
+                c.mat[i][j]=(c.mat[i][j]+a.mat[i][k]*b.mat[k][j])%mod;
+        }
+    return c;
+}
+mart power(int k)
+{
+    mart p,q;
+    int i,j;
+    for(i=1;i<=4;i++)
+        for(j=1;j<=4;j++)
+        {
+            p.mat[i][j]=kk.mat[i][j];
+            if(i==j)
+                q.mat[i][j]=1;
+            else
+                q.mat[i][j]=0;
+        }
+    if(k==0)
+        return q;
+    while(k!=1)
+    {
+        if(k&1)
+        {
+            k--;
+            q=multi(p,q);
+        }
+        else
+        {
+            k=k>>1;
+            p=multi(p,p);
+        }
+    }
+    p=multi(p,q);
+    return p;
+}
+void init(__int64 x,__int64 y)
+{
+    kk.mat[1][1]=1;
+    kk.mat[1][2]=(x%mod)*(x%mod)%mod;
+    kk.mat[1][3]=(y%mod)*(y%mod)%mod;
+    kk.mat[1][4]=(2*x%mod)*(y%mod)%mod;
+    kk.mat[2][1]=0;
+    kk.mat[2][2]=(x%mod)*(x%mod)%mod;
+    kk.mat[2][3]=(y%mod)*(y%mod)%mod;
+    kk.mat[2][4]=(2*x%mod)*(y%mod)%mod;
+    kk.mat[3][1]=0;
+    kk.mat[3][2]=1;
+    kk.mat[3][3]=0;
+    kk.mat[3][4]=0;
+    kk.mat[4][1]=0;
+    kk.mat[4][2]=x%mod;
+    kk.mat[4][3]=0;
+    kk.mat[4][4]=y%mod;
+}
+int main()
+{
+    int n,i;
+    __int64 a[5],x,y;
+    mart xx;
+    while(scanf("%d%I64d%I64d",&n,&x,&y)!=EOF)
+    {
+        a[1]=2,a[2]=1,a[3]=1,a[4]=1;
+        init(x,y);
+        xx=power(n-1);
+        __int64 ans=0;
+        for(i=1;i<=4;i++)
+            ans=(ans+a[i]*xx.mat[1][i])%mod;
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3307_autoAC.cpp b/HDOJ/3307_autoAC.cpp
new file mode 100644
index 0000000..33ca5ba
--- /dev/null
+++ b/HDOJ/3307_autoAC.cpp
@@ -0,0 +1,69 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define LL __int64
+const LL maxn=1001;
+LL e[maxn],t;
+LL gcd(LL a,LL b)
+{
+    return b==0?a:gcd(b,a%b);
+}
+LL euler_phi(LL n)
+{
+    LL m=(LL)sqrt(n+0.5);
+    LL i,ans=n;
+    for(i=2;i<=m;i++)
+        if(n%i==0)
+        {
+            ans=ans/i*(i-1);
+            while(n%i==0)n/=i;
+        }
+    if(n>1)ans=ans/n*(n-1);
+    return ans;
+}
+void find(LL n)
+{
+    LL m=(LL)sqrt(n+0.5);
+    for(LL i=1;i<m;i++)
+        if(n%i==0){e[t++]=i;e[t++]=n/i;}
+    if(m*m==n)e[t++]=m;
+}
+LL pow_mod(LL a,LL b,LL mod)
+{
+    LL s=1;
+    while(b)
+    {
+        if(b&1)
+            s=(s*a)%mod;
+        a=(a*a)%mod;
+        b=b>>1;
+    }
+    return s;
+}
+int main()
+{
+    LL a,x,y;
+    while(cin>>x>>y>>a)
+    {
+        LL m,phi,i;
+        if(y==0){cout<<"1"<<endl;continue;}
+        m=a/gcd(y/(x-1),a);
+        if(gcd(m,x)!=1){cout<<"Impossible!"<<endl;continue;}
+        phi=euler_phi(m);
+        t=0;
+        find(phi);
+        sort(e,e+t);
+        for(i=0;i<t;i++)
+        {
+            if(pow_mod(x,e[i],m)==1)
+            {
+                cout<<e[i]<<endl;
+                break;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3308_autoAC.cpp b/HDOJ/3308_autoAC.cpp
new file mode 100644
index 0000000..50f748b
--- /dev/null
+++ b/HDOJ/3308_autoAC.cpp
@@ -0,0 +1,130 @@
+#include<stdio.h>
+#include<string.h>
+#define MAXD 100010
+int N, M, a[MAXD], mc[4 * MAXD], lc[4 * MAXD], rc[4 * MAXD];
+int getmax(int x, int y)
+{
+    return x > y ? x : y;
+}
+void update(int cur, int x, int y)
+{
+    int mid = (x + y) / 2, ls = 2 * cur, rs = 2 * cur + 1;
+    mc[cur] = getmax(mc[ls], mc[rs]);
+    lc[cur] = lc[ls], rc[cur] = rc[rs];
+    if(a[mid] < a[mid + 1])
+    {
+        mc[cur] = getmax(mc[cur], rc[ls] + lc[rs]);
+        if(lc[ls] == mid - x + 1)
+            lc[cur] += lc[rs];
+        if(rc[rs] == y - mid)
+            rc[cur] += rc[ls];
+    }
+}
+void build(int cur, int x, int y)
+{
+    int mid = (x + y) / 2, ls = 2 * cur, rs = 2 * cur + 1;
+    if(x == y)
+    {
+        mc[cur] = lc[cur] = rc[cur] = 1;
+        return ;
+    }
+    build(ls, x, mid);
+    build(rs, mid + 1, y);
+    update(cur, x, y);
+}
+void init()
+{
+    int i, j, k;
+    for(i = 0; i < N; i ++)
+        scanf("%d", &a[i]);
+    build(1, 0, N - 1);
+}
+void refresh(int cur, int x, int y, int k, int v)
+{
+    int mid = (x + y) / 2, ls = 2 * cur, rs = 2 * cur + 1;
+    if(x == y)
+    {
+        a[x] = v;
+        return ;
+    }
+    if(k <= mid)
+        refresh(ls, x, mid, k, v);
+    else
+        refresh(rs, mid + 1, y, k, v);
+    update(cur, x, y);
+}
+int query(int cur, int x, int y, int s, int t, int p, int &ans)
+{
+    int mid = (x + y) / 2, ls = 2 * cur, rs = 2 * cur + 1;
+    if(x == y)
+        return 1;
+    if(mid >= t)
+        return query(ls, x, mid, s, t, 0, ans);
+    else if(mid + 1 <= s)
+        return query(rs, mid + 1, y, s, t, 1, ans);
+    else
+    {
+        int ln, rn;
+        if(x >= s && y <= t)
+        {
+            ans = getmax(ans, mc[cur]);
+            return p ? rc[cur] : lc[cur];
+        }
+        ln = query(ls, x, mid, s, t, 1, ans), rn = query(rs, mid + 1, y, s, t, 0, ans);
+        if(x >= s && mid <= t)
+        {
+            if(a[mid] < a[mid + 1])
+            {
+                ans = getmax(ans, rc[ls] + rn);
+                if(rc[ls] == mid - x + 1)
+                    return rc[ls] + rn;
+            }
+            return lc[ls];
+        }
+        else if(mid + 1 >= s && y <= t)
+        {
+            if(a[mid] < a[mid + 1])
+            {
+                ans = getmax(ans, ln + lc[rs]);
+                if(lc[rs] == y - mid)
+                    return ln + lc[rs];
+            }
+            return rc[rs];
+        }
+        else
+        {
+            if(a[mid] < a[mid + 1])
+                ans = getmax(ans, ln + rn);
+        }
+    }
+    return 0;
+}
+void solve()
+{
+    int i, j, k, x, y, ans;
+    char b[5];
+    for(i = 0; i < M; i ++)
+    {
+        scanf("%s%d%d", b, &x, &y);
+        if(b[0] == 'Q')
+        {
+            ans = 1;
+            query(1, 0, N - 1, x, y, 0, ans);
+            printf("%d\n", ans);
+        }
+        else
+            refresh(1, 0, N - 1, x, y);
+    }
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    while(t --)
+    {
+        scanf("%d%d", &N, &M);
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3309_autoAC.cpp b/HDOJ/3309_autoAC.cpp
new file mode 100644
index 0000000..825d221
--- /dev/null
+++ b/HDOJ/3309_autoAC.cpp
@@ -0,0 +1,97 @@
+#include <stdio.h>
+#include <string.h>
+#include <queue>
+#include <algorithm>
+using namespace std;
+struct node
+{
+    int x[2],y[2],step;
+    int b[2],h[2];
+};
+char map[25][25];
+bool vis[25][25][25][25];
+int sx[2],sy[2],n,m;
+int to[4][2] = {0,1,1,0,0,-1,-1,0};
+int bfs()
+{
+    queue<node> Q;
+    node a,next;
+    a.x[0] = sx[0],a.y[0]=sy[0];
+    a.x[1] = sx[1],a.y[1]=sy[1];
+    a.step = 0;
+    a.b[0] = a.b[1] = a.h[0] = a.h[1] = 0;
+    Q.push(a);
+    memset(vis,false,sizeof(vis));
+    while(!Q.empty())
+    {
+        a = Q.front();
+        Q.pop();
+        int i,j;
+        for(i = 0; i<4; i++)
+        {
+            next = a;
+            for(j = 0; j<2; j++)
+            {
+                if(next.b[j]) continue;
+                next.x[j]+=to[i][0];
+                next.y[j]+=to[i][1];
+                if(map[next.x[j]][next.y[j]]=='*')
+                {
+                    next.x[j]-=to[i][0];
+                    next.y[j]-=to[i][1];
+                }
+            }
+            if(vis[next.x[0]][next.y[0]][next.x[1]][next.y[1]])
+                continue;
+            if(next.x[0]==next.x[1]&& next.y[0]==next.y[1] && next.b[0]+next.b[1]==0)
+                continue;
+            next.step++;
+            vis[next.x[0]][next.y[0]][next.x[1]][next.y[1]] = true;
+            int flag = 1;
+            for(j = 0; j<2; j++)
+            {
+                int now = map[next.x[j]][next.y[j]];
+                if(now<2 && !next.h[now])
+                {
+                    next.h[now]=1;
+                    next.b[j] = 1;
+                }
+                if(!next.b[j])
+                    flag = 0;
+            }
+            if(flag)
+                return next.step;
+            Q.push(next);
+        }
+    }
+    return -1;
+}
+int main()
+{
+    int t,i,j;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&m);
+        int cnt = 0,len = 0;
+        for(i = 0; i<n; i++)
+        {
+            scanf("%s",map[i]);
+            for(j = 0; j<m; j++)
+            {
+                if(map[i][j]=='H') map[i][j] = cnt++;
+                else if(map[i][j]=='B')
+                {
+                    sx[len] = i,sy[len] = j;
+                    len++;
+                }
+            }
+        }
+        int ans = bfs();
+        if(ans!=-1)
+            printf("%d\n",ans);
+        else
+            printf("Sorry , sir , my poor program fails to get an answer.\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3310_autoAC.cpp b/HDOJ/3310_autoAC.cpp
new file mode 100644
index 0000000..5a52afd
--- /dev/null
+++ b/HDOJ/3310_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<stdio.h>
+#include<math.h>
+double cal(double r1,double r2,double dx)
+{
+    return sqrt(r1*r1-dx*dx)*sqrt(r2*r2-dx*dx);
+}
+double fun(double r1,double r2)
+{
+    int n=1000000;
+    double dx=(r1<r2?r1:r2)/n;
+    double pi=3.141592653;
+    double v=0;
+    for(int i=0;i<n;i++)
+    {
+        v+=cal(r1,r2,(double)dx*i+dx/2);
+    }
+    return v*8*dx;
+}
+int main()
+{
+    int t;
+    double r1,r2;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%lf%lf",&r1,&r2);
+        printf("%.2lf\n",fun(r1,r2));
+    }
+    return 0;
+}
diff --git a/HDOJ/3311_autoAC.cpp b/HDOJ/3311_autoAC.cpp
new file mode 100644
index 0000000..e43f155
--- /dev/null
+++ b/HDOJ/3311_autoAC.cpp
@@ -0,0 +1,104 @@
+#include<stdio.h>
+#include<string.h>
+#define MAXD 1010
+#define MAXM 10010
+#define ST 74
+#define MAXQ 74010
+#define INF 0x3f3f3f3f
+const int Q = 74000;
+int N, M, P, first[MAXD], e, next[MAXM], v[MAXM], w[MAXM];
+int bit[MAXD], q[MAXQ], front, rear, inq[MAXD][ST];
+int f[MAXD][ST], dp[ST];
+void add(int x, int y, int z)
+{
+    v[e] = y, w[e] = z;
+    next[e] = first[x], first[x] = e ++;
+}
+void init()
+{
+    int i, x, y, z;
+    memset(f, 0x3f, sizeof(f));
+    memset(bit, 0, sizeof(bit));
+    for(i = 1; i <= N + M; i ++)
+    {
+        if(i <= N) bit[i] = 1 << i - 1;
+        scanf("%d", &z);
+        if(i <= N) f[i][bit[i]] = 0, f[i][bit[i] | 1 << N] = z;
+        else f[i][1 << N] = z;
+    }
+    memset(first, -1, sizeof(first));
+    e = 0;
+    for(i = 0; i < P; i ++)
+    {
+        scanf("%d%d%d", &x, &y, &z);
+        add(x, y, z), add(y, x, z);
+    }
+}
+int Min(int x, int y)
+{
+    return x < y ? x : y;
+}
+void spfa()
+{
+    int i, x, st, y, nst;
+    while(front != rear)
+    {
+        x = q[front] & 1023, st = q[front] >> 10;
+        inq[x][st] = 0;
+        ++ front > Q ? front = 0 : 0;
+        for(i = first[x]; i != -1; i = next[i])
+        {
+            y = v[i], nst = st | bit[y];
+            if(f[x][st] + w[i] < f[y][nst])
+            {
+                f[y][nst] = f[x][st] + w[i];
+                if(st == nst && !inq[y][nst])
+                {
+                    q[rear ++] = nst << 10 | y, inq[y][nst] = 1;
+                    rear > Q ? rear = 0 : 0;
+                }
+            }
+        }
+    }
+}
+void solve()
+{
+    int i, j, k, nn = 1 << N + 1;
+    front = rear = 0;
+    memset(inq, 0, sizeof(inq));
+    for(i = 0; i < nn; i ++)
+    {
+        for(j = 1; j <= N + M; j ++)
+        {
+            for(k = i - 1 & i; k; k = k - 1 & i)
+                f[j][i] = Min(f[j][i], f[j][k | bit[j]] + f[j][i - k | bit[j]]);
+            if(f[j][i] < INF)
+            {
+                q[rear ++] = i << 10 | j, inq[j][i] = 1;
+                rear > Q ? rear = 0 : 0;
+            }
+        }
+        spfa();
+    }
+    memset(dp, 0x3f, sizeof(dp));
+    for(i = 0; i < nn; i ++)
+        for(j = 1; j <= N + M; j ++)
+            dp[i] = Min(dp[i], f[j][i]);
+    for(i = 0; i < nn; i ++)
+        if(i & 1 << N)
+        {
+            for(j = i - 1 & i; j; j = j - 1 & i)
+                if(j & 1 << N)
+                    dp[i] = Min(dp[i], dp[j] + dp[i - j | 1 << N]);
+        }
+    printf("%d\n", dp[(1 << N + 1) - 1]);
+}
+int main()
+{
+    while(scanf("%d%d%d", &N, &M, &P) == 3)
+    {
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3313_autoAC.cpp b/HDOJ/3313_autoAC.cpp
new file mode 100644
index 0000000..3742808
--- /dev/null
+++ b/HDOJ/3313_autoAC.cpp
@@ -0,0 +1,78 @@
+#include <iostream>
+#include <cstdio>
+#include <queue>
+#include <cstring>
+#include <cstdlib>
+using namespace std;
+#define MAXN 100010
+int pre[MAXN],vis[MAXN],low[MAXN];
+vector <int> e[MAXN];
+int bfs1(int st,int et){
+    queue <int> q;
+    q.push(st);
+    vis[st]=1;pre[st]=-1;
+    while(!q.empty()){
+        int now=q.front();
+        q.pop();
+        for(int i=e[now].size()-1;i>=0;i--){
+            int next=e[now][i];
+            if(vis[next])continue;
+            vis[next]=1;
+            pre[next]=now;
+            if(next==et)return 1;
+            q.push(next);
+        }
+    }
+    return 0;
+}
+int bfs2(int u){
+    queue <int> q;
+    q.push(u);
+    int res=u;
+    vis[u]=1;
+    while(!q.empty()){
+        int now=q.front();
+        q.pop();
+        for(int i=e[now].size()-1;i>=0;i--){
+            int next=e[now][i];
+            if(vis[next])continue;
+            vis[next]=1;
+            if(low[next]==0)q.push(next);
+            else if(low[next]<low[res])res=next;
+        }
+    }
+    return res;
+}
+int main()
+{
+    int n,m,st,et;
+    while(~scanf("%d%d",&n,&m)){
+        for(int i=0;i<=n;i++)
+        e[i].clear();
+        memset(vis,0,sizeof(vis));
+        memset(low,0,sizeof(low));
+        for(int i=0,x,y;i<m;i++){
+            scanf("%d%d",&x,&y);
+            e[x].push_back(y);
+        }
+        scanf("%d%d",&st,&et);
+        if(!bfs1(st,et)){
+            printf("%d\n",n);
+            continue;
+        }
+        int u=et,tot=1;
+        memset(vis,0,sizeof(vis));
+        while(u!=-1){
+            low[u]=tot++;
+            u=pre[u];
+        }
+        int cnt=1;
+        u=st;
+        while(u!=et){
+            u=bfs2(u);
+            ++cnt;
+        }
+        printf("%d\n",cnt);
+    }
+    return 0;
+}
diff --git a/HDOJ/3314_autoAC.cpp b/HDOJ/3314_autoAC.cpp
new file mode 100644
index 0000000..11a2122
--- /dev/null
+++ b/HDOJ/3314_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<iostream>  
+#include<string.h>
+using namespace std;  
+const int maxn=100000+10;  
+int p[maxn],r[maxn],cnt[maxn];  
+void make()  
+{  
+    memset(r,0,sizeof(r));  
+    memset(p,255,sizeof(p));  
+    for(int i=0;i<maxn;i++) cnt[i]=1;  
+}  
+int find(int x)  
+{  
+    int px,t;  
+    for(px=x;p[px]>=0;px=p[px]);  
+    while (x!=px) {  
+        t=p[x];  
+        p[x]=px;  
+        x=t;  
+    }  
+    return px;  
+}  
+int unio(int x,int y)  
+{  
+    x=find(x),y=find(y);  
+    if(x==y)    return -1;  
+    if(r[x]>r[y])  
+    {  
+        p[y]=x;  
+        cnt[y]+=cnt[x];  
+        cnt[x]=cnt[y];  
+        return x;  
+    }  
+    else  
+    {  
+        p[x]=y;  
+        cnt[x]+=cnt[y];  
+        cnt[y]=cnt[x];  
+        if(r[x]==r[y])  r[y]++;  
+        return y;  
+    }  
+}  
+int d[maxn];  
+int main()  
+{  
+    int n;  
+    while (scanf("%d",&n)!=EOF)  
+    {  
+        make();  
+        for(int i=0;i<n;i++){  
+            scanf("%d",&d[i]);  
+            unio(i,d[i]);  
+        }  
+        int tmp_max=-1,k=-1;  
+        bool flag=false;  
+        for(int i=0;i<n;i++)  
+        {  
+            if(i==d[i])  
+            {  
+                if(tmp_max==cnt[find(i)])  
+                {  
+                    flag=false;  
+                }  
+                if(cnt[find(i)]>tmp_max)  
+                {  
+                    flag=true;  
+                    tmp_max=cnt[find(i)];  
+                    k=i;  
+                }  
+            }  
+        }  
+        if(!flag)  
+        {  
+            printf("Trouble\n");  
+        }  
+        else  
+        {  
+            printf("%d\n",k);  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/3315_autoAC.cpp b/HDOJ/3315_autoAC.cpp
new file mode 100644
index 0000000..56dba3c
--- /dev/null
+++ b/HDOJ/3315_autoAC.cpp
@@ -0,0 +1,169 @@
+#include <cstring>
+#include <cstdio>
+#include <queue>
+#include <iostream>
+#define inf 0x3f3f3f3f
+#define MAXN 3000
+#define MAXM 30000
+using namespace std;
+struct node
+{
+    int u,v,f,c;
+};
+node e[MAXM];
+int first[MAXN],ne[MAXM],cc;
+int inq[MAXN],pre[MAXN],preedge[MAXN],d[MAXN];
+inline void add_edge(int u,int v,int f,int c)
+{
+    e[cc].u=u;
+    e[cc].v=v;
+    e[cc].f=f;
+    e[cc].c=c;
+    ne[cc]=first[u];
+    first[u]=cc;
+    cc++;
+    e[cc].v=u;
+    e[cc].u=v;
+    e[cc].f=0;
+    e[cc].c=-c;
+    ne[cc]=first[v];
+    first[v]=cc;
+    cc++;
+}
+int SPFA(int s,int t)
+{
+    memset(inq,0,sizeof(inq));
+    int i;
+    for(i=0;i<=t;i++)
+        d[i]=-inf;
+    memset(pre,-1,sizeof(pre));
+    memset(preedge,-1,sizeof(preedge));
+    d[s]=0;
+    queue<int> q;
+    q.push(s);
+    while(!q.empty())
+    {
+        int u=q.front();
+        q.pop();
+        inq[u]=0;
+        int i;
+        for(i=first[u];i!=-1;i=ne[i])
+        {
+            int v=e[i].v;
+            if(e[i].f)
+            {
+                if(d[v]<d[u]+e[i].c)
+                {
+                    d[v]=d[u]+e[i].c;
+                    pre[v]=u;
+                    preedge[v]=i;
+                    if(!inq[v])
+                    {
+                        inq[v]=1;
+                        q.push(v);
+                    }
+                }
+            }
+        }
+    }
+    if(d[t]==-inf)
+        return 0;
+    else
+        return 1;
+}
+int Min_Cost_Flow(int s,int t)
+{
+    int ans_flow=0,ans_cost=0,mm,tmp;
+    while(SPFA(s,t))
+    {
+        mm=inf;
+        int u=t;
+        while(pre[u]!=-1)
+        {
+            tmp=preedge[u];
+            mm=min(mm,e[tmp].f);
+            u=pre[u];
+        }
+        u=t;
+        while(pre[u]!=-1)
+        {
+            tmp=preedge[u];
+            e[tmp].f-=mm;
+            e[tmp^1].f+=mm;
+            u=pre[u];
+        }
+        ans_flow+=mm;
+        ans_cost+=mm*d[t];
+    }
+    return ans_cost;
+}
+int V[100],H[100],P[100],A[100],B[100];
+int win(int i,int j)
+{
+    int x,y;
+    if(P[j]%A[i]==0)
+        x=P[j]/A[i];
+    else
+        x=P[j]/A[i]+1;
+    if(H[i]%B[j]==0)
+        y=H[i]/B[j];
+    else
+        y=H[i]/B[j]+1;
+    if(x<=y)
+        return 1;
+    else
+        return 0;
+}
+int main()
+{
+    int n;
+    while(scanf("%d",&n),n)
+    {
+        memset(first,-1,sizeof(first));
+        memset(ne,-1,sizeof(ne));
+        cc=0;
+        int i;
+        for(i=1;i<=n;i++)
+            scanf("%d",&V[i]);
+        for(i=1;i<=n;i++)
+            scanf("%d",&H[i]);
+        for(i=1;i<=n;i++)
+            scanf("%d",&P[i]);
+        for(i=1;i<=n;i++)
+            scanf("%d",&A[i]);
+        for(i=1;i<=n;i++)
+            scanf("%d",&B[i]);
+        int s=0,t=2*n+1,j;
+        for(i=1;i<=n;i++)
+        {
+            for(j=1;j<=n;j++)
+            {
+                if(win(i,j))
+                {
+                    if(i==j)
+                        add_edge(i,n+j,1,V[i]*100+1);
+                    else
+                        add_edge(i,n+j,1,V[i]*100);
+                }
+                else
+                {
+                    if(i==j)
+                        add_edge(i,n+j,1,-V[i]*100+1);
+                    else
+                        add_edge(i,n+j,1,-V[i]*100);
+                }
+            }
+        }
+        for(i=1;i<=n;i++)
+        {
+            add_edge(0,i,1,0);
+            add_edge(n+i,t,1,0);
+        }
+        int res=Min_Cost_Flow(s,t);
+        if(res/100<=0)
+            printf("Oh, I lose my dear seaco!\n");
+        else
+            printf("%d %.3f%%\n",res/100,100*1.0*(res%100)/n);
+    }
+    return 0;
+}
diff --git a/HDOJ/3316_autoAC.cpp b/HDOJ/3316_autoAC.cpp
new file mode 100644
index 0000000..477691e
--- /dev/null
+++ b/HDOJ/3316_autoAC.cpp
@@ -0,0 +1,89 @@
+#include<stdio.h>
+#include<string.h>
+#include<queue>
+using namespace std;
+int n;
+int s_x,s_y;
+int map[111][111];
+int flag[111][111];
+int dir[8][2]={1,0, -1,0, 0,1, 0,-1, -1,-1, -1,1, 1,-1, 1,1};
+struct node
+{
+    int x,y;
+};
+int judge(int x,int y)
+{
+    int tot=0;
+    int i;
+    int t_x,t_y;
+    for(i=0;i<8;i++)
+    {
+        t_x=x+dir[i][0];
+        t_y=y+dir[i][1];
+        if(t_x<0 || t_x>=n || t_y<0 || t_y>=n)    continue;
+        if(map[t_x][t_y]==-2)    tot++;
+    }
+    return tot;
+}
+void BFS()
+{
+    queue<node>q;
+    node cur,next;
+    int i;
+    int temp;
+    cur.x=s_x;
+    cur.y=s_y;
+    flag[cur.x][cur.y]=1;
+    q.push(cur);
+    while(!q.empty())
+    {
+        cur=q.front();
+        q.pop();
+        temp=judge(cur.x,cur.y);
+        map[cur.x][cur.y]=temp;
+        if(temp)    continue;
+        for(i=0;i<8;i++)
+        {
+            next.x=cur.x+dir[i][0];
+            next.y=cur.y+dir[i][1];
+            if(next.x<0 || next.x>=n || next.y<0 || next.y>=n)    continue;
+            if(!flag[next.x][next.y])
+            {
+                q.push(next);
+                flag[next.x][next.y]=1;
+            }
+        }
+    }
+}
+int main()
+{
+    int i,l;
+    char str[111];
+    while(scanf("%d",&n)!=-1)
+    {
+        for(i=0;i<n;i++)
+        {
+            scanf("%s",str);
+            for(l=0;l<n;l++)
+            {
+                if(str[l]=='O')        map[i][l]=-1;
+                else if(str[l]=='X')map[i][l]=-2;
+            }
+        }
+        scanf("%d%d",&s_x,&s_y);
+        if(map[s_x][s_y]==-2)    {printf("it is a beiju!\n\n");continue;}
+        memset(flag,0,sizeof(flag));
+        BFS();
+        for(i=0;i<n;i++)
+        {
+            for(l=0;l<n;l++)
+            {
+                if(map[i][l]<0)    printf(".");
+                else            printf("%d",map[i][l]);
+            }
+            printf("\n");
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3317_autoAC.cpp b/HDOJ/3317_autoAC.cpp
new file mode 100644
index 0000000..7b68d1a
--- /dev/null
+++ b/HDOJ/3317_autoAC.cpp
@@ -0,0 +1,31 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<sstream>
+#include<map>
+#include<set>
+#include<cmath>
+#include<iomanip>
+#include<cstdlib>
+#include<cctype>
+#include<assert.h>
+#include<stack>
+#include<queue>
+#include<vector>
+#include<list>
+using namespace std;
+double pi=acos(-1);
+double w,r,sita;
+int main() {
+    while(~scanf("%lf%lf%lf",&r,&w,&sita))
+    {
+        sita/=180.;
+        sita*=pi;
+        double umc=cos(sita/2.)-1.;
+        r-=w/umc;
+        printf("%.3f\n",r);
+    }
+    return 0;
+}
diff --git a/HDOJ/3318_autoAC.cpp b/HDOJ/3318_autoAC.cpp
new file mode 100644
index 0000000..8c36230
--- /dev/null
+++ b/HDOJ/3318_autoAC.cpp
@@ -0,0 +1,79 @@
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+#include <climits>
+#include <vector>
+using namespace std;
+const int N = 100;
+int n, m;
+int boss[N + 2];
+int cur[N + 2];  
+int occupy[N + 2][N + 2];  
+int need[N + 2][N + 2];
+int mark[N + 2];
+bool check(int x)
+{
+ if (mark[x])return false;
+ int i;
+ for (i = 1; i <= n; i++)
+ {
+  if (need[x][i] > cur[i])return false;
+ }
+ return true;
+}
+void callBack(int x)
+{
+ int i;
+ for (i = 1; i <= n; i++)
+ {
+  cur[i] += occupy[x][i];
+  need[x][i] = 0;
+ }
+ mark[x] = 1;
+}
+int main ()
+{
+ int i, j, tmp;
+ while (scanf("%d%d", &n, &m) != EOF)
+ {
+  memset(mark, 0, sizeof(mark));
+  for (i = 1; i <= n; i++)
+  {
+   scanf("%d", &boss[i]);
+   cur[i] = boss[i];
+  }
+  for (i = 1; i <= m; i++)
+   for (j = 1; j <= n; j++)
+   {
+    scanf("%d", &need[i][j]);
+    need[i][j] < 0 ? 0 : need[i][j];
+   }
+  for (i = 1; i <= m; i++)
+   for (j = 1; j <= n; j++)
+   {
+    scanf("%d", &tmp);
+    need[i][j] -= tmp;
+    occupy[i][j] = tmp;
+    cur[j] -= tmp;
+   }
+  int flag;
+  while (1)
+  {
+   flag = 0;
+   for (i = 1; i <= m; i++)
+   {
+    if (check(i)) 
+    {
+     callBack(i);  
+     flag = 1;
+    }
+   }
+   if (!flag)break;
+  }
+  for (i = 1; i <= n; i++)
+   if (cur[i] != boss[i])break;
+  if (i > n)printf("Yes\n");
+  else
+   printf("No\n");
+ }
+}
diff --git a/HDOJ/3320_autoAC.cpp b/HDOJ/3320_autoAC.cpp
new file mode 100644
index 0000000..df07e7a
--- /dev/null
+++ b/HDOJ/3320_autoAC.cpp
@@ -0,0 +1,306 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#define eps 1e-8
+using namespace std;
+const double PI=acos(-1.0);
+const int MAXN=105;
+struct point3{
+    double x,y,z;
+};
+struct order{
+    char c;
+    double x,y,z,ang;
+}ord[MAXN];
+point3 rotate3(point3 q,double x0,double y0,double z0,double ang)
+{
+    double x2=x0*x0;
+    double y2=y0*y0;
+    double z2=z0*z0;
+    double d2=x2+y2+z2;
+    double d=sqrt(d2);
+    double sina=sin(ang);
+    double cosa=cos(ang);
+    point3 ans;
+    ans.x=(x2+(y2+z2)*cosa)/d2*q.x+(x0*y0*(1-cosa)/d2-z0*sina/d)*q.y+(x0*z0*(1-cosa)/d2+y0*sina/d)*q.z;
+    ans.y=(y0*x0*(1-cosa)/d2+z0*sina/d)*q.x+(y2+(x2+z2)*cosa)/d2*q.y+(y0*z0*(1-cosa)/d2-x0*sina/d)*q.z;
+    ans.z=(z0*x0*(1-cosa)/d2-y0*sina/d)*q.x+(z0*y0*(1-cosa)/d2+x0*sina/d)*q.y+(z2+(x2+y2)*cosa)/d2*q.z;
+    return ans;
+}
+int main()
+{
+    int T;
+    char str[500];
+    scanf("%d",&T);
+    while(T--){
+        int i,j;
+        double tmp;
+        double tail,muti;
+        double sig;
+        for(i=0;;i++){
+            scanf("%s",str);
+            if(str[2]=='B') ord[i].c='B';
+            else if(str[2]=='S'){
+                ord[i].c='S';
+                for(j=2;str[j]!='(';j++);
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].x=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].y=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=')';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].z=tmp*sig;
+            }
+            else if(str[2]=='T'){
+                ord[i].c='T';
+                for(j=2;str[j]!='(';j++);
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].x=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].y=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=')';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].z=tmp*sig;
+            }
+            else if(str[2]=='V'){
+                ord[i].c='V';
+                for(j=2;str[j]!='(';j++);
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].x=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].y=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=')';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].z=tmp*sig;
+            }
+            else if(str[2]=='E') break;
+            else{
+                ord[i].c='R';
+                for(j=2;str[j]!='(';j++);
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].ang=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].x=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=',';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].y=tmp*sig;
+                tmp=0.0;
+                sig=1.0;
+                for(j++;str[j]!='.';j++){
+                    if(str[j]=='-'){
+                        sig=-1.0;
+                        continue;
+                    }
+                    tmp=tmp*10+str[j]-'0';
+                }
+                tail=0.0;
+                muti=0.1;
+                for(j++;str[j]!=')';j++){
+                    tail+=(str[j]-'0')*muti;
+                    muti/=10.0;
+                }
+                tmp+=tail;
+                ord[i].z=tmp*sig;
+            }
+        }
+        point3 pnt;
+        i--;
+        pnt.x=ord[i].x;
+        pnt.y=ord[i].y;
+        pnt.z=ord[i].z;
+        for(i--;i>=0;i--){
+            if(ord[i].c=='T'){
+                pnt.x+=ord[i].x;
+                pnt.y+=ord[i].y;
+                pnt.z+=ord[i].z;
+            }
+            else if(ord[i].c=='S'){
+                pnt.x*=ord[i].x;
+                pnt.y*=ord[i].y;
+                pnt.z*=ord[i].z;
+            }
+            else if(ord[i].c=='R'){
+                pnt=rotate3(pnt,ord[i].x,ord[i].y,ord[i].z,ord[i].ang);
+            }
+        }
+        printf("%.1f %.1f %.1f\n",pnt.x,pnt.y,pnt.z);
+    }
+    return 0;
+}
diff --git a/HDOJ/3322_autoAC.cpp b/HDOJ/3322_autoAC.cpp
new file mode 100644
index 0000000..8b7c522
--- /dev/null
+++ b/HDOJ/3322_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <cmath>
+#include <algorithm>
+#include <string.h> 
+using namespace std;
+const int MAXN = 501;
+struct data { double x,y;
+}p[MAXN];
+inline double sqr(double x)
+{
+    return x * x;
+}
+double dis(int a,int b)
+{
+    return sqrt(sqr(p[a].x - p[b].x) + sqr(p[a].y - p[b].y));
+}
+bool cmp(data a,data b)
+{
+    return a.x == b.x ? a.y < b.y : a.x < b.x;
+}
+int main()
+{
+    int n;
+    double dp[MAXN][MAXN];
+    while (scanf("%d",&n) != EOF && n)
+    {
+        for (int i = 1;i <= n;i++)
+            scanf("%lf%lf",&p[i].x,&p[i].y);
+        sort(p,p+n+1,cmp);
+        memset(dp,0,sizeof(dp));
+        for (int i = 0;i <= n;i++)
+            for (int j = 0;j <= n;j++)
+                dp[i][j] = 1e20;
+        dp[0][0] = 0;
+        for (int i = 0;i < n;i++)
+            for (int j = 0;j <= i;j++)
+            {
+                dp[i+1][j] = min(dp[i+1][j],dp[i][j] + dis(i,i+1));
+                dp[i+1][i] = min(dp[i+1][i],dp[i][j] + dis(j,i+1));
+            }
+        double ans = 1e20;
+        for (int i = 0;i <= n;i++)
+        {
+            if (dp[n][i] + dis(i,n) < ans)
+                ans = dp[n][i] + dis(i,n);
+        }
+        printf("%.2lf\n",ans);
+    }
+}
diff --git a/HDOJ/3323_autoAC.cpp b/HDOJ/3323_autoAC.cpp
new file mode 100644
index 0000000..66e9a34
--- /dev/null
+++ b/HDOJ/3323_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<stdio.h>
+#include<string.h>
+#include<string>
+#include<iostream>
+#include<queue>
+#include<vector>
+#define MAX 22222
+using namespace std;
+vector<int>vt[MAX];
+int vis[MAX];
+int a;
+int d[MAX];
+int BFS(int n){
+        queue<int> q;
+        q.push(n);
+        int cnt=0;
+        while(!q.empty()){
+            int now=q.front();
+            for(int i=0;i<vt[now].size();i++){
+                int to=vt[now][i];
+                if(vis[to]==0){
+                    vis[to]=1;
+                    cnt++;
+                    q.push(to);
+                }
+            }
+            q.pop();
+        }
+        return cnt;
+}
+int main(){
+    int T;
+    scanf("%d",&T);
+    while(T--){
+        memset(vis,0,sizeof(vis));  
+        int n,m,c;
+        scanf("%d%d%d",&n,&m,&c);
+        scanf("%d",&a);
+                for(int i=0;i<n;i++)vt[i].clear();
+        for(int i=0;i<c;i++){
+            scanf("%d",&d[i]);
+        }
+        for(int i=0;i<m;i++){
+            int u,v;
+            scanf("%d%d",&u,&v);
+            vt[u].push_back(v);
+                        vt[v].push_back(u);
+        }
+        vis[a]=1;
+        for(int i=0;i<c;i++){
+            vis[d[i]]=1;
+                BFS(d[i]);
+        }
+        printf("%d\n",BFS(a));
+    }
+}
diff --git a/HDOJ/3325_autoAC.cpp b/HDOJ/3325_autoAC.cpp
new file mode 100644
index 0000000..874445a
--- /dev/null
+++ b/HDOJ/3325_autoAC.cpp
@@ -0,0 +1,109 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+#include<string.h>
+#include<map>
+using namespace std;
+int arry[5];
+bool visit[5];
+int result[1000000];
+int ind;
+map<int ,bool> mp;
+int Work(int x,int y,int op)
+{
+ if(op==0)
+  return x+y;
+ else if(op==1)
+  return x-y;
+ else if(op==2)
+  return x*y;
+ else if(op==3 && y && x%y==0)
+  return x/y;
+ else if(op==4 && x && y%x==0)
+  return y/x;
+ else
+  return y-x;
+}
+void DFS(int cnt)
+{
+ int i,j;
+ int x,y,k;
+ if(cnt==4)
+ {
+  for(i=0;i<4;i++)
+   if(!visit[i] && !mp[arry[i]])
+   {
+    result[ind++]=arry[i];
+    mp[arry[i]]=true;
+   }
+  return ;
+ }
+ for(i=0;i<4;i++)
+ {
+  if(visit[i])
+   continue;
+  for(j=i+1;j<4;j++)
+  {
+   if(visit[j])
+    continue;
+   visit[j]=true;
+   x=arry[i];
+   y=arry[j];
+   for(k=0;k<6;k++)
+   {
+    arry[i]=Work(x,y,k);
+    DFS(cnt+1);
+   }
+   arry[i]=x;
+   arry[j]=y;
+   visit[j]=false;
+  }
+ }
+}
+int main()
+{
+ int i,j,k;
+ int t=1;
+ while(scanf("%d%d%d%d",&arry[0],&arry[1],&arry[2],&arry[3])!=EOF)
+ {
+  if(!arry[0] && !arry[1] && !arry[2] && !arry[3])
+   break;
+  mp.clear();
+  ind=0;
+  memset(visit,false,sizeof(visit));
+  DFS(1);
+  sort(result,result+ind);
+  int cnt;
+  int Max=1;
+  int beg,end;
+  beg=end=result[0];
+  i=0;
+  while(i<ind)
+  {
+   j=i;
+   cnt=1;
+   while(i<ind)
+   {
+    if(result[i]+1==result[i+1])
+     cnt++;
+    else
+    {
+     i++;
+     break;
+    }
+    i++;
+   }
+   if(cnt>=Max)
+   {
+    Max=cnt;
+    beg=result[j];
+    if(j<i)
+     end=result[i-1];
+    else
+     end=result[i];
+   }
+  }
+  printf("Case %d: %d to %d\n",t++,beg,end);
+ }
+ return 0;
+}
diff --git a/HDOJ/3326_autoAC.cpp b/HDOJ/3326_autoAC.cpp
new file mode 100644
index 0000000..23a9721
--- /dev/null
+++ b/HDOJ/3326_autoAC.cpp
@@ -0,0 +1,73 @@
+#include<cstdio> 
+#include<iostream>
+#include<cstring>
+using namespace std;
+int n,m[5],l[5],len;
+double p[5],dp[6][3125][32];
+bool f[6][3125][32];
+char ans[100];
+double solve(int g,int r,int mask)
+{
+    if(mask==0) return 1.0;
+    if(f[g][r][mask]) return dp[g][r][mask];
+    int a[5],c=r;
+    double b[2][5],t1,t2;
+    for(int i=n-1;i>=0;--i)
+    {
+        a[i]=c%5;
+        c/=5;
+    }
+    for(int i=0;i<n;++i)
+    {
+        if(l[i]) t1=p[i]/l[i]*(l[i]-a[i]);
+        else t1=0.0;
+        t2=(1-p[i])/(m[i]-l[i])*(m[i]-l[i]-g+a[i]); 
+        if(t1+t2<1e-8) b[0][i]=b[1][i]=0.0;
+        else
+        {
+            b[0][i]=(1-p[i])/(m[i]-l[i])/(t1+t2);
+            b[1][i]=p[i]/l[i]/(t1+t2);
+        }
+    }
+    dp[g][r][mask]=0.0;
+    for(int i=mask;;i=((i-1)&mask))
+    {
+        double tmp=0.0;
+        int choose[5],chs=0;
+        for(int j=0;j<n;++j)
+        {
+            if(i&(1<<j)) choose[j]=1;
+            else choose[j]=0;
+            if((mask&(1<<j))&&choose[j]+a[j]>l[j]) goto fuck;
+            if((mask&(1<<j))&&choose[j]==0&&m[j]-l[j]-g+a[j]<=0) goto fuck;
+            chs=chs*5+choose[j]+a[j];
+        }
+        for(int j=mask;j;j=((j-1)&mask))
+        {
+            double pp=1.0;
+            for(int k=0;k<n;++k)
+                if(j&(1<<k)) pp*=b[choose[k]][k];
+                else if(mask&(1<<k)) pp*=1-b[choose[k]][k];
+            tmp+=pp*solve(g+1,chs,mask-j);
+        }
+        dp[g][r][mask]=max(dp[g][r][mask],tmp);
+        fuck:if(i==0) break;
+    }
+    f[g][r][mask]=1;
+    return dp[g][r][mask];
+}
+int main()
+{
+    while(scanf("%d",&n)&&n)
+    {
+        for(int i=0;i<n;++i) scanf("%d%d%lf",m+i,l+i,p+i);
+        memset(f,0,sizeof(f));
+        memset(ans,0,sizeof(ans));
+        sprintf(ans,"%.3lf",solve(0,0,(1<<n)-1));
+        len=strlen(ans);
+        while(ans[len-1]=='0')
+            ans[--len]='\0';
+        if(ans[len-1]=='.') ans[len-1]='\0';
+        printf("%s\n",ans);
+    }
+}
diff --git a/HDOJ/3327_autoAC.cpp b/HDOJ/3327_autoAC.cpp
new file mode 100644
index 0000000..efe67c3
--- /dev/null
+++ b/HDOJ/3327_autoAC.cpp
@@ -0,0 +1,35 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+char s[10001],lib[100][10001],*arr[20000],ans[20000],*t;
+int cas,n,len[20000],a,b;
+int main()
+{
+    while(scanf("%s",s)&&strcmp(s,"0"))
+    {
+        scanf("%d",&n);
+        for(int i=0;i<n;++i) 
+        {
+            scanf(" %s",lib[i]);
+            arr[i]=lib[i];
+            len[i]=strlen(lib[i]);
+        }
+        t=ans;
+        a=strlen(s);
+        for(int i=0;i<a;)
+        {
+            b=s[i++]-'0';
+            for(int j=10;n>j;j*=10) b=b*10+s[i++]-'0';
+            arr[n]=t;
+            len[n++]=len[b]+1;
+            for(int j=0;j<len[b];++j)
+            {
+                *t=arr[b][j];
+                t++;
+            }
+        }
+        *t='\0';
+        printf("Case %d: %s\n",++cas,ans);
+    }
+}
diff --git a/HDOJ/3328_autoAC.cpp b/HDOJ/3328_autoAC.cpp
new file mode 100644
index 0000000..681cd2a
--- /dev/null
+++ b/HDOJ/3328_autoAC.cpp
@@ -0,0 +1 @@
+Pile <em>t</em>
diff --git a/HDOJ/3329_autoAC.cpp b/HDOJ/3329_autoAC.cpp
new file mode 100644
index 0000000..57c724f
--- /dev/null
+++ b/HDOJ/3329_autoAC.cpp
@@ -0,0 +1 @@
+Case <em>n</em>: Island splits when ocean rises <em>f</em> feet.
diff --git a/HDOJ/3331_autoAC.cpp b/HDOJ/3331_autoAC.cpp
new file mode 100644
index 0000000..77c7242
--- /dev/null
+++ b/HDOJ/3331_autoAC.cpp
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<set>
+#define MAXN 150
+using namespace std;
+int n,m,ids,ide,ans;
+int br[MAXN][MAXN],dist[MAXN];
+struct Node{
+    int g,y,r;
+}node[MAXN];
+struct L{
+    int  x,t;
+    bool operator <(L othr)const{
+        if(x==othr.x)return t<othr.t;
+        else return x<othr.x;
+    }
+}now;
+void SPFA(){
+    set<L>Q;
+    Q.clear();
+    memset(dist,-1,sizeof(dist));
+    Q.insert((L){ids,5});
+    dist[ids]=5;
+    set<L>::iterator  it;
+    while(!Q.empty()){
+        it=Q.begin();
+        now=*it;
+        Q.erase(it); 
+        for(int i=0;i<n;i++){
+            if(br[now.x][i]==-1)continue;
+            int add=0,nowtime,tot,res;
+            nowtime=br[now.x][i]+dist[now.x];
+            tot=node[i].g+node[i].r+node[i].y;
+            res=nowtime%tot;
+            if(res>=node[i].g+node[i].y)add=5+tot-res;       
+            if(i==ide&&(ans==-1||ans>nowtime))ans=nowtime; 
+            if(add+nowtime<dist[i]||dist[i]==-1){
+                dist[i]=nowtime+add;
+                Q.insert((L){i,dist[i]});   
+            }
+        }
+    }
+}
+int main(){
+    while(scanf("%d%d%d%d",&n,&m,&ids,&ide)!=EOF&&(n||m||ids||ide)){
+        if(ids==ide){
+            printf("0:00\n");
+            continue;
+        }
+        for(int i=0;i<n;i++){
+            scanf("%d%d%d",&node[i].g,&node[i].y,&node[i].r);
+        }
+        memset(br,-1,sizeof(br));
+        for(int i=0;i<m;i++){
+            int  xx,yy,zz;
+            scanf("%d%d%d",&xx,&yy,&zz);
+            if(br[xx][yy]==-1||br[xx][yy]>zz)
+            br[xx][yy]=br[yy][xx]=zz;
+        }
+        ans=-1;
+        SPFA();
+        int second=ans;
+        int minute=second/60;
+        second=second%60;
+        printf("%d:%02d\n",minute,second);
+        }
+}
diff --git a/HDOJ/3332_autoAC.cpp b/HDOJ/3332_autoAC.cpp
new file mode 100644
index 0000000..a6c654c
--- /dev/null
+++ b/HDOJ/3332_autoAC.cpp
@@ -0,0 +1,43 @@
+#include<iostream>
+using namespace std;
+int cnt=1;
+struct jsj
+{
+    int x1,y1;
+    int x2,y2;
+}a[101];
+int main()
+{
+    int n;
+    while(scanf("%d",&n)!=EOF)
+    {
+        if(n==0) break;
+        for(int i=0;i<n;i++)
+        {
+            int c,d;
+            scanf("%d%d%d%d",&a[i].x1,&a[i].y1,&c,&d);
+            a[i].x2=a[i].x1+d-1;
+            a[i].y2=a[i].y1+c-1;
+        }
+        int m;
+        scanf("%d",&m);
+        printf("Desktop %d:\n",cnt++);
+        for(int i=0;i<m;i++)
+        {
+            bool f=false;
+            int q1,q2;
+            scanf("%d%d",&q1,&q2);
+            for(int j=n-1;j>=0;j--)
+            {
+                if(q1>=a[j].x1 && q1<=a[j].x2 && q2>=a[j].y1 && q2<=a[j].y2)
+                {
+                    f=true;
+                    printf("window %d\n",j+1);
+                    break;
+                }
+            }
+            if(!f) printf("background\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3333_autoAC.cpp b/HDOJ/3333_autoAC.cpp
new file mode 100644
index 0000000..139f149
--- /dev/null
+++ b/HDOJ/3333_autoAC.cpp
@@ -0,0 +1,93 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<map>
+using namespace std;
+typedef __int64 ll;
+#define N 300010
+#define M 100010
+struct 
+{
+    int l,r;
+    ll num;
+}root[N*4];
+struct Q
+{
+    int s,t,ind;
+}q[M];
+bool cmp(Q i,Q j)
+{
+    return i.t<j.t;
+}
+inline void build(int t,int x,int y)
+{
+    root[t].l=x;
+    root[t].r=y;
+    root[t].num=0;
+    if(x==y) return;
+    int m=(x+y)>>1;
+    build(t*2,x,m);
+    build(t*2+1,m+1,y);
+}
+inline void Modefiy(int t,int x,ll val)
+{
+    int l=root[t].l;
+    int r=root[t].r;
+    if(l==r)
+    {
+        root[t].num+=val;return;
+    }
+    int m=(l+r)>>1;
+    if(x<=m) Modefiy(t*2,x,val);
+    else Modefiy(t*2+1,x,val);
+    root[t].num=root[t*2].num+root[t*2+1].num;
+}
+inline ll query(int t,int x,int y)
+{
+    int l=root[t].l;
+    int r=root[t].r;
+    if(l==x&&r==y)
+    {
+        return root[t].num;
+    }
+    int m=(l+r)>>1;
+    ll ans=0;
+    if(x<=m) ans+=query(t*2,x,min(m,y));
+    if(y>m) ans+=query(t*2+1,max(m+1,x),y);
+    return ans;
+}
+int t,n,qn;
+ll a[N];
+map<ll,int>m;
+ll ans[M];
+int main()
+{
+    scanf("%d",&t);
+    while(t--)
+    {
+        m.clear();
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++) scanf("%I64d",&a[i]);
+        build(1,1,n);
+        scanf("%d",&qn);
+        for(int i=0;i<qn;i++)
+        {
+            scanf("%d%d",&q[i].s,&q[i].t);
+            q[i].ind=i;
+        }
+        sort(q,q+qn,cmp);
+        int k=1;
+        for(int i=0;i<qn;i++)
+        {
+            for(;k<=q[i].t;k++)
+            {
+                if(m[a[k]]!=0) Modefiy(1,m[a[k]],-a[k]);
+                m[a[k]]=k;
+                Modefiy(1,k,a[k]);
+            }
+            ans[q[i].ind]=query(1,q[i].s,q[i].t);
+        }
+        for(int i=0;i<qn;i++) printf("%I64d\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3335_autoAC.cpp b/HDOJ/3335_autoAC.cpp
new file mode 100644
index 0000000..c6b0d15
--- /dev/null
+++ b/HDOJ/3335_autoAC.cpp
@@ -0,0 +1,74 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+typedef __int64 ll;
+struct node{
+    int s,t,nxt ; 
+}e[100005] ;
+int k,m,n,head[505],cnt,match[505],vis[505] ;
+int find(int s)
+{
+    for(int i=head[s] ;i!=-1 ;i=e[i].nxt)
+    {
+        int tt=e[i].t ;
+        if(!vis[tt])
+        {
+            vis[tt]=1 ;
+            if(match[tt]==-1 || find(match[tt]))
+            {
+                match[tt]=s ;
+                return 1 ;
+            }
+        }
+    }
+    return 0 ;
+}
+int max_match()
+{
+    int ans=0 ;
+    memset(match,-1,sizeof(match)) ;
+    for(int i=1 ;i<=n ;i++)
+    {
+        memset(vis,0,sizeof(vis)) ;
+        ans+=find(i);
+    }
+    return ans;
+}
+void add(int s,int t) {e[cnt].s=s ;e[cnt].t=t ;e[cnt].nxt=head[s] ;head[s]=cnt++ ;}
+ll a[1005],b[1005];
+void read_graph()
+{
+    memset(head,-1,sizeof(head)) ;
+    cnt=0 ;
+    for(int i=1;i<=n;i++){
+        for(int j=1;j<=n;j++){
+            if(i==j)continue;
+            if(b[i]%b[j]==0)
+                add(i,j);
+        }
+    }
+}
+int main(){
+    int T;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++){
+            scanf("%I64d",&a[i]);
+        }
+        int st=0;
+        sort(a+1,a+1+n);
+        b[++st]=a[1];
+        for(int i=2;i<=n;i++){
+            if(a[i]!=a[i-1])b[++st]=a[i];
+        }
+        n=st;
+        read_graph();
+        printf("%d\n",n-max_match());
+    }
+    return 0;
+}
diff --git a/HDOJ/3336_autoAC.cpp b/HDOJ/3336_autoAC.cpp
new file mode 100644
index 0000000..1489555
--- /dev/null
+++ b/HDOJ/3336_autoAC.cpp
@@ -0,0 +1,44 @@
+#include <cstdio>
+#include <cstring>
+int const MAX = 200000 + 5;
+int const MOD = 10007;
+int next[MAX];
+char s[MAX];
+void get_next()
+{
+    int i = 0, j = -1;
+    next[0] = -1;
+    while(s[i] != '\0')
+    {
+        if(j == - 1 || s[i] == s[j])
+        {
+            i++;
+            j++;
+            next[i] = j;
+        }
+        else
+            j = next[j];
+    }
+}
+int main()
+{
+    int T, len, ans;
+    scanf("%d", &T);
+    while(T--)
+    {
+        memset(next, 0, sizeof(next));
+        scanf("%d %s", &len, s);
+        get_next();
+        ans = len;
+        for(int i = 1; i <= len; i++)
+        {
+            int tmp = next[i];
+            while(tmp)
+            {
+                ans = (ans + 1) % MOD;
+                tmp = next[tmp];
+            }
+        }
+        printf("%d\n", ans);
+    }
+}
diff --git a/HDOJ/3337_autoAC.cpp b/HDOJ/3337_autoAC.cpp
new file mode 100644
index 0000000..82ef2c7
--- /dev/null
+++ b/HDOJ/3337_autoAC.cpp
@@ -0,0 +1,5 @@
+#include <stdio.h>
+int main()
+{
+printf("72\n");
+}
diff --git a/HDOJ/3338_autoAC.cpp b/HDOJ/3338_autoAC.cpp
new file mode 100644
index 0000000..a7ab88d
--- /dev/null
+++ b/HDOJ/3338_autoAC.cpp
@@ -0,0 +1,172 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <vector>
+#include <queue>
+using namespace std;
+#define Del(a,b) memset(a,b,sizeof(a))
+const int N = 20500;
+const int inf = 0x3f3f3f3f;
+int n,m;
+struct Node
+{
+    int from,to,cap,flow;
+};
+vector<int> v[N];
+vector<Node> e;
+int vis[N];  
+int cur[N];
+void add_Node(int from,int to,int cap)
+{
+    e.push_back((Node){from,to,cap,0});
+    e.push_back((Node){to,from,0,0});
+    int tmp=e.size();
+    v[from].push_back(tmp-2);
+    v[to].push_back(tmp-1);
+}
+bool bfs(int s,int t)
+{
+    Del(vis,-1);
+    queue<int> q;
+    q.push(s);
+    vis[s] = 0;
+    while(!q.empty())
+    {
+        int x=q.front();
+        q.pop();
+        for(int i=0;i<v[x].size();i++)
+        {
+            Node tmp = e[v[x][i]];
+            if(vis[tmp.to]<0 && tmp.cap>tmp.flow)  
+            {
+                vis[tmp.to]=vis[x]+1;
+                q.push(tmp.to);
+            }
+        }
+    }
+    if(vis[t]>0)
+        return true;
+    return false;
+}
+int dfs(int o,int f,int t)
+{
+    if(o==t || f==0)  
+        return f;
+    int a = 0,ans=0;
+    for(int &i=cur[o];i<v[o].size();i++) 
+    {
+        Node &tmp = e[v[o][i]];
+        if(vis[tmp.to]==(vis[o]+1) && (a = dfs(tmp.to,min(f,tmp.cap-tmp.flow),t))>0)
+        {
+            tmp.flow+=a;
+            e[v[o][i]^1].flow-=a; 
+            ans+=a;
+            f-=a;
+            if(f==0)  
+                break;
+        }
+    }
+    return ans;  
+}
+int dinci(int s,int t)
+{
+    int ans=0;
+    while(bfs(s,t))
+    {
+        Del(cur,0);
+        int tm=dfs(s,inf,t);
+        ans+=tm;
+    }
+    return ans;
+}
+int mp[250][250];
+struct Node1
+{
+    int x,y,z;
+};
+Node1 raw[N],col[N];
+int solve(int raw_cnt,int id,int s)
+{
+    int cnt = 0,pos = id+raw_cnt;
+    return e[v[pos][1]].flow+1;
+}
+int main()
+{
+    while(~scanf("%d%d",&n,&m))
+    {
+        memset(mp,-1,sizeof(mp));
+        memset(col,0,sizeof(col));
+        memset(raw,0,sizeof(raw));
+        int cnt=0,raw_cnt=0,col_cnt=0;
+        for(int i=1;i<=n;i++)
+        {
+            for(int j=1;j<=m;j++)
+            {
+                string str;
+                cin>>str;
+                 if(str[0] == '.'){
+                    mp[i][j] = ++cnt;
+                }else{
+                    mp[i][j] = -1;
+                    if(str[0] != 'X'){
+                        int tmp = (str[0]-'0')*100 + (str[1]-'0')*10 + str[2]-'0';
+                        col[++col_cnt].x = i;
+                        col[col_cnt].y = j;
+                        col[col_cnt].z = tmp;
+                    }
+                    if(str[4] != 'X'){
+                        int tmp = (str[4]-'0')*100 + (str[5]-'0')*10 + str[6]-'0';
+                        raw[++raw_cnt].x = i;
+                        raw[raw_cnt].y = j;
+                        raw[raw_cnt].z = tmp;
+                    }
+                }
+            }
+        }
+        int start=0,t=col_cnt+cnt+raw_cnt+2;
+        for(int i = 1;i <= raw_cnt;i++){
+            int x = raw[i].x;
+            int y = raw[i].y;
+            int cnt_len = 0;
+            for(y = y+1;y <= m;y++){
+                if(mp[x][y] != -1){
+                    cnt_len++;
+                    add_Node(i,raw_cnt+mp[x][y],8);
+                }
+                else   break;
+            }
+            add_Node(start,i,raw[i].z-cnt_len);
+        }
+        for(int i = 1;i <= col_cnt;i++){
+            int x = col[i].x;
+            int y = col[i].y;
+            int cnt_len = 0;
+            for(x = x+1;x <= n;x++){
+                if(mp[x][y] != -1){
+                    cnt_len++;
+                    add_Node(raw_cnt+mp[x][y],raw_cnt+cnt+i,8);
+                }
+                else    break;
+            }
+            add_Node(raw_cnt+cnt+i,t,col[i].z-cnt_len);
+        }
+        int ans=dinci(start,t);
+        for(int i=1;i<=n;i++)
+        {
+            for(int j=1;j<=m;j++)
+            {
+                if(mp[i][j]==-1)
+                    printf("_");
+                else
+                    printf("%d",solve(raw_cnt,mp[i][j],cnt));
+                printf("%c",j==m?'\n':' ');
+            }
+        }
+        for(int i=0;i<=t;i++)
+            v[i].clear();
+        e.clear();
+    }
+    return 0;
+}
diff --git a/HDOJ/3339_autoAC.cpp b/HDOJ/3339_autoAC.cpp
new file mode 100644
index 0000000..2261df4
--- /dev/null
+++ b/HDOJ/3339_autoAC.cpp
@@ -0,0 +1,99 @@
+#include<stdio.h>
+#include<string.h>
+#include<iostream>
+#include<algorithm>
+#define INF 100000000
+#define max 101
+using namespace std;
+int dp[10001];
+int N,g[max][max];
+int dis[max];
+int pp[max];
+int v[max];
+void dijk()
+{
+    int i,j,mindis,mark;
+    for(i=0;i<=N;i++)
+    {
+        dis[i] = INF;
+        v[i] = 0;
+    }
+    dis[0] = 0;
+    v[0] = 1;
+    for(i=0;i<=N;i++)
+    {
+        mark = 0;
+        mindis = INF;
+        for(j=0;j<=N;j++)
+        {
+            if(!v[j] && dis[j] < mindis)
+            {
+                mindis = dis[j];
+                mark = j;
+            }
+        }
+        v[mark] = 1;
+        for(j=0;j<=N;j++)
+        {
+            if(!v[j] && dis[j] > dis[mark] + g[mark][j])
+            {
+                dis[j] = dis[mark] + g[mark][j];
+            }
+        }
+    }
+}
+int main()
+{
+    int M,a,b,c,i,j,t,sum,MAX,MIN,sumdis;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&N,&M);
+        for(i=0;i<=N;i++)
+        for(j=0;j<=N;j++)
+        {
+            if(i==j)g[i][j] = 0;
+            else
+            g[i][j] = INF;
+        }
+        while(M--)
+        {
+            scanf("%d%d%d",&a,&b,&c);
+            if(c<g[a][b])
+            {
+                g[a][b] = c;
+                g[b][a] = c;
+            }
+        }
+         for(sum=0,i=1;i<=N;i++)
+        {    
+            scanf("%d",&c);
+            sum+=c;
+            pp[i] = c;
+        }
+        dijk();
+        memset(dp,0,sizeof(dp));
+        for(sumdis=0,i=0;i<=N;i++)
+        {
+            if(dis[i]!=INF)
+            sumdis += dis[i];
+        }
+        for(i=1;i<=N;i++)
+        {
+            for(j=sumdis;j>=dis[i];j--)
+            {
+                if(dp[j]<dp[j-dis[i]]+pp[i])
+                dp[j] = dp[j-dis[i]]+pp[i];
+            }
+        } 
+        for(i=0;i<=sumdis;i++)
+        {
+            if(dp[i] > sum/2)
+            break;
+        }
+        if(i == sumdis+1)
+        printf("impossible\n");
+        else
+        printf("%d\n",i);
+    }
+}
diff --git a/HDOJ/3340_autoAC.cpp b/HDOJ/3340_autoAC.cpp
new file mode 100644
index 0000000..8fcca47
--- /dev/null
+++ b/HDOJ/3340_autoAC.cpp
@@ -0,0 +1,161 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#define MAXD 125010
+double dl[4 * MAXD], dr[4 * MAXD], volume[4 * MAXD];
+int N, tx[MAXD], X, flag[4 * MAXD];
+struct Question
+{
+    char b[5];
+    int n, x[10], y[10];
+}question[MAXD];
+int cmpint(const void *_p, const void *_q)
+{
+    int *p = (int *)_p, *q = (int *)_q;
+    return *p < *q ? -1 : 1;
+}
+void build(int cur, int x, int y)
+{
+    int mid = (x + y) >> 1, ls = cur << 1, rs = (cur << 1) | 1;
+    dl[cur] = dr[cur] = volume[cur] = flag[cur] = 0;
+    if(x == y)
+        return ;
+    build(ls, x, mid);
+    build(rs, mid + 1, y);
+}
+void init()
+{
+    int i, j, k, n;
+    scanf("%d", &N);
+    k = 0;
+    for(i = 0; i < N; i ++)
+    {
+        scanf("%s", question[i].b);
+        if(question[i].b[0] == 'Q')
+        {
+            scanf("%d%d", &question[i].x[0], &question[i].y[0]);
+            tx[k ++] = question[i].x[0], tx[k ++] = question[i].y[0];
+        }
+        else
+        {
+            scanf("%d", &n);
+            question[i].n = n;
+            for(j = 0; j < n; j ++)
+            {
+                scanf("%d%d", &question[i].x[j], &question[i].y[j]);
+                tx[k ++] = question[i].x[j];
+            }
+            question[i].x[n] = question[i].x[0], question[i].y[n] = question[i].y[0];
+        }
+    }
+    qsort(tx, k, sizeof(tx[0]), cmpint);
+    X = -1;
+    for(i = 0; i < k; i ++)
+        if(i == 0 || tx[i] != tx[i - 1])
+            tx[++ X] = tx[i];
+    build(1, 0, X - 1);
+}
+int BS(int x)
+{
+    int mid, min = 0, max = X + 1;
+    for(;;)
+    {
+        mid = (min + max) >> 1;
+        if(mid == min)
+            break;
+        if(tx[mid] <= x)
+            min = mid;
+        else
+            max = mid;
+    }
+    return mid;
+}
+double calculate(double x1, double y1, double x2, double y2, double x)
+{
+    return ((x2 - x) * y1 + (x - x1) * y2) / (x2 - x1);
+}
+void pushdown(int cur, int x, int y)
+{
+    int mid = (x + y) >> 1, ls = cur << 1, rs = (cur << 1) | 1;
+    if(flag[cur])
+    {
+        flag[ls] = flag[rs] = 1;
+        double delta = calculate(tx[x], dl[cur], tx[y + 1], dr[cur], tx[mid + 1]);
+        dl[ls] += dl[cur], dr[ls] += delta, volume[ls] += (dl[cur] + delta) * (tx[mid + 1] - tx[x]) / 2;
+        dl[rs] += delta, dr[rs] += dr[cur], volume[rs] += (delta + dr[cur]) * (tx[y + 1] - tx[mid + 1]) / 2;
+        dl[cur] = dr[cur] = flag[cur] = 0;
+    }
+}
+void update(int cur)
+{
+    volume[cur] = volume[cur << 1] + volume[(cur << 1) | 1];
+}
+double query(int cur, int x, int y, int s, int t)
+{
+    int mid = (x + y) >> 1, ls = cur << 1, rs = (cur << 1) | 1;
+    if(x >= s && y <= t)
+        return volume[cur];
+    pushdown(cur, x, y);
+    if(mid >= t)
+        return query(ls, x, mid, s, t);
+    else if(mid + 1 <= s)
+        return query(rs, mid + 1, y, s, t);
+    else
+        return query(ls, x, mid, s, t) + query(rs, mid + 1, y, s, t);
+}
+void refresh(int cur, int x, int y, int s, int t, double ys, double yt)
+{
+    int mid = (x + y) >> 1, ls = cur << 1, rs = (cur << 1) | 1;
+    if(x >= s && y <= t)
+    {
+        flag[cur] = 1;
+        double dleft, dright;
+        dleft = calculate(tx[s], ys, tx[t + 1], yt, tx[x]);
+        dright = calculate(tx[s], ys, tx[t + 1], yt, tx[y + 1]);
+        dl[cur] += dleft, dr[cur] += dright, volume[cur] += (dleft + dright) * (tx[y + 1] - tx[x]) / 2;
+        return ;
+    }
+    pushdown(cur, x, y);
+    if(mid >= s)
+        refresh(ls, x, mid, s, t, ys, yt);
+    if(mid + 1 <= t)
+        refresh(rs, mid + 1, y, s, t, ys, yt);
+    update(cur);
+}
+void solve()
+{
+    int i, j, k, e, x1, y1, x2, y2;
+    for(i = 0; i < N; i ++)
+    {
+        if(question[i].b[0] == 'Q')
+        {
+            j = BS(question[i].x[0]), k = BS(question[i].y[0]);
+            if(j < k)
+                printf("%.3f\n", query(1, 0, X - 1, j, k - 1));
+            else
+                printf("0.000\n");
+        }
+        else
+        {
+            for(e = 0; e < question[i].n; e ++)
+            {
+                j = BS(question[i].x[e]), k = BS(question[i].x[e + 1]);
+                if(j < k)
+                    refresh(1, 0, X - 1, j, k - 1, -question[i].y[e], -question[i].y[e + 1]);
+                else if(j > k)
+                    refresh(1, 0, X - 1, k, j - 1, question[i].y[e + 1], question[i].y[e]);
+            }
+        }
+    }
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    while(t --)
+    {
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3341_autoAC.cpp b/HDOJ/3341_autoAC.cpp
new file mode 100644
index 0000000..0c830fb
--- /dev/null
+++ b/HDOJ/3341_autoAC.cpp
@@ -0,0 +1,132 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+#include <algorithm>
+#include <queue>
+using namespace std;
+const int INF = 0x3f3f3f3f;
+struct Trie
+{
+    int next[510][4],fail[510];
+    int end[510];
+    int root,L;
+    int newnode()
+    {
+        for(int i = 0;i < 4;i++)
+            next[L][i] = -1;
+        end[L++] = 0;
+        return L-1;
+    }
+    void init()
+    {
+        L = 0;
+        root = newnode();
+    }
+    int getch(char ch)
+    {
+        if(ch == 'A')return 0;
+        else if(ch == 'C')return 1;
+        else if(ch == 'G')return 2;
+        else return 3;
+    }
+    void insert(char buf[])
+    {
+        int len = strlen(buf);
+        int now = root;
+        for(int i = 0;i < len;i++)
+        {
+            if(next[now][getch(buf[i])] == -1)
+                next[now][getch(buf[i])] = newnode();
+            now = next[now][getch(buf[i])];
+        }
+        end[now] ++;
+    }
+    void build()
+    {
+        queue<int>Q;
+        fail[root] = root;
+        for(int i = 0;i < 4;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 = 0;i < 4;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]);
+                }
+        }
+    }
+    int dp[510][11*11*11*11+5];
+    int bit[4];
+    int num[4];
+    int solve(char buf[])
+    {
+        int len = strlen(buf);
+        memset(num,0,sizeof(num));
+        for(int i = 0;i < len;i++)
+            num[getch(buf[i])]++;
+        bit[0] = (num[1]+1)*(num[2]+1)*(num[3]+1);
+        bit[1] = (num[2]+1)*(num[3]+1);
+        bit[2] = (num[3]+1);
+        bit[3] = 1;
+        memset(dp,-1,sizeof(dp));
+        dp[root][0] = 0;
+        for(int A = 0;A <= num[0];A++)
+            for(int B = 0;B <= num[1];B++)
+                for(int C = 0;C <= num[2];C++)
+                    for(int D = 0;D <= num[3];D++)
+                    {
+                        int s = A*bit[0] + B*bit[1] + C*bit[2] + D*bit[3];
+                        for(int i = 0;i < L;i++)
+                            if(dp[i][s] >= 0)
+                            {
+                                for(int k = 0;k < 4;k++)
+                                {
+                                    if(k == 0 && A == num[0])continue;
+                                    if(k == 1 && B == num[1])continue;
+                                    if(k == 2 && C == num[2])continue;
+                                    if(k == 3 && D == num[3])continue;
+                                    dp[next[i][k]][s+bit[k]] = max(dp[next[i][k]][s+bit[k]],dp[i][s]+end[next[i][k]]);
+                                }
+                            }
+                    }
+        int ans = 0;
+        int status = num[0]*bit[0] + num[1]*bit[1] + num[2]*bit[2] + num[3]*bit[3];
+        for(int i = 0;i < L;i++)
+            ans = max(ans,dp[i][status]);
+        return ans;
+    }
+};
+char buf[50];
+Trie ac;
+int main()
+{
+    int n;
+    int iCase = 0;
+    while( scanf("%d",&n) == 1 && n)
+    {
+        iCase++;
+        ac.init();
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%s",buf);
+            ac.insert(buf);
+        }
+        ac.build();
+        scanf("%s",buf);
+        printf("Case %d: %d\n",iCase,ac.solve(buf));
+    }
+    return 0;
+}
diff --git a/HDOJ/3342_autoAC.cpp b/HDOJ/3342_autoAC.cpp
new file mode 100644
index 0000000..9a79233
--- /dev/null
+++ b/HDOJ/3342_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<queue>
+#include<vector>
+using namespace std;
+bool map[111][111];
+vector<int>vet[111];
+int from[111];
+int n,m;
+void floyd()
+{
+   for(int k=0;k<n;k++)
+      for(int i=0;i<n;i++)
+         for(int j=0;j<n;j++)
+            map[i][j]=(map[i][j]||(map[i][k]&&map[k][j]));
+}
+bool Solve()
+{
+   queue<int>Q;
+   int cnt=0;
+   for(int i=0;i<n;i++){
+      if(from[i]==0){ Q.push(i);cnt++; }
+   }
+   while(!Q.empty()){
+      int u=Q.front();
+      Q.pop();
+      for(int i=0;i<vet[u].size();i++){
+         int v=vet[u][i];
+         if(from[v]>0){
+            from[v]--;
+            if(from[v]==0){ Q.push(v);cnt++; }
+         }
+      }
+   }
+   if(cnt==n)return true;
+   return false;
+}
+int main(){
+   int u,v;
+   while(scanf("%d%d",&n,&m),n){
+      memset(map,false,sizeof(map));
+      memset(from,0,sizeof(from));
+      for(int i=0;i<n;i++)vet[i].clear();
+      while(m--){
+         scanf("%d%d",&u,&v);
+         map[u][v]=true;
+      }
+      for(int i=0;i<n;i++)
+         for(int j=0;j<n;j++)if(i!=j){
+            if(map[i][j]){ from[j]++;vet[i].push_back(j); }
+         }
+      bool flag=Solve();
+      flag?puts("YES"):puts("NO");
+   }
+   return 0;
+}
diff --git a/HDOJ/3343_autoAC.cpp b/HDOJ/3343_autoAC.cpp
new file mode 100644
index 0000000..1a0c3a8
--- /dev/null
+++ b/HDOJ/3343_autoAC.cpp
@@ -0,0 +1,14 @@
+#include<stdio.h>
+int main()
+{
+    int T;
+    int l,v,m;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d",&l,&v,&m);
+        if(v>0)    printf("YES\n");
+        else    printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3344_autoAC.cpp b/HDOJ/3344_autoAC.cpp
new file mode 100644
index 0000000..85d6a53
--- /dev/null
+++ b/HDOJ/3344_autoAC.cpp
@@ -0,0 +1,83 @@
+#include<cstdio>
+#include<algorithm>
+#include<iostream>
+#include<cstring>
+#include<cmath>
+using namespace std;
+struct node {
+    int r;
+    int d;
+    bool ok;
+} a[111][111];
+int b[111][111];
+int n,m;
+int num(int x) {
+    if(x==0)return 1;
+    int ans=0;
+    while(x)
+        ans++,x/=10;
+    return 3-ans;
+}
+int main() {
+    int t;
+    cin>>t;
+    while(t--) {
+        char c;
+        scanf("%d%d",&n,&m);
+        memset(a,0,sizeof a);
+        memset(b,0,sizeof b);
+        for(int i=1; i<=n; i++) {
+            for(int j=1; j<=m; j++) {
+                scanf(" %c",&c);
+                if(c=='_') {
+                    a[i][j].ok=1;
+                } else {
+                    b[i][j]=c-'0';
+                }
+            }
+        }
+        for(int i=1; i<=n; i++) {
+            for(int j=1; j<=m; j++) {
+                if(a[i][j].ok) {
+                    for(int k=j+1; k<=m; k++) {
+                        if(a[i][k].ok)break;
+                        a[i][j].r+=b[i][k];
+                    }
+                    for(int k=i+1; k<=n; k++) {
+                        if(a[k][j].ok)break;
+                        a[i][j].d+=b[k][j];
+                    }
+                }
+            }
+        }
+        for(int i=1; i<=n; i++) {
+            for(int j=1; j<=m; j++) {
+                if(a[i][j].ok) {
+                    if(a[i][j].d) {
+                        int h=num(a[i][j].d);
+                        for(int i=0; i<h; i++)
+                            printf("0");
+                        printf("%d",a[i][j].d);
+                    } else
+                        printf("XXX");
+                    if(a[i][j].r==0&&a[i][j].d==0) {
+                        printf("XXXX");
+                    } else if(a[i][j].d&&a[i][j].r==0)
+                        printf("\\XXX");
+                    else{
+                              printf("\\");
+                        int h=num(a[i][j].r);
+                        for(int i=0; i<h; i++)
+                            printf("0");
+                        printf("%d",a[i][j].r);
+                    }
+                } else if(b[i][j])
+                    printf(".......");
+                if(j!=m)printf(" ");
+                else    printf("\n");
+            }
+        }
+          printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3345_autoAC.cpp b/HDOJ/3345_autoAC.cpp
new file mode 100644
index 0000000..123e93f
--- /dev/null
+++ b/HDOJ/3345_autoAC.cpp
@@ -0,0 +1,114 @@
+#include<stdio.h>
+#include<string.h>
+#include<iostream>
+using namespace std;
+char map[105][105];
+int sx,sy,n,m;
+int visit[105][105];
+int dir[4][2]= {1,0,0,1,-1,0,0,-1};
+struct node
+{
+    int x;
+    int y;
+    int cost;
+} a[1000015];
+int mvCost(int tx,int ty,int cost)
+{
+    if(map[tx][ty]=='R')
+    cost-=3;
+    else if(map[tx][ty]=='T')
+    cost-=2;
+    else
+    cost-=1;
+    int flag=0;
+    for(int i=0;i<4;i++)
+    {
+        int ttx=tx+dir[i][0];
+        int tty=ty+dir[i][1];
+        if(ttx>=0 && ttx<n && tty>=0 && tty<m)
+        {
+            if(map[ttx][tty]=='E')
+            {
+                flag=1;
+                break;
+            }
+        }
+    }
+    if(flag==1 && cost>0)
+    cost=0;
+    return cost;
+}
+void bfs(int mv)
+{
+    memset(visit,-1,sizeof(visit));
+    a[0].x=sx;
+    a[0].y=sy;
+    a[0].cost=mv;
+    visit[sx][sy]=mv;
+    int start=0,end=1;
+    node cur,change;
+    while(start<end)
+    {
+        cur=a[start++];
+        if(cur.cost==0)
+            continue;
+        for(int i=0; i<4; i++)
+        {
+            int tx=cur.x+dir[i][0];
+            int ty=cur.y+dir[i][1];
+            if(map[tx][ty]=='#' ||map[tx][ty]=='E' || map[tx][ty]=='Y' )
+                continue;
+            else if(tx>=0 && tx<n && ty>=0 && ty<m  )
+            {
+                int Cost=mvCost(tx,ty,cur.cost);
+                if(Cost<0)
+                continue;
+                else
+                {
+                    if(Cost>visit[tx][ty])
+                    {
+                        change.x=tx;
+                        change.y=ty;
+                        change.cost=Cost;
+                        a[end++]=change;
+                        visit[tx][ty]=Cost;
+                        if(map[tx][ty]!='P')
+                        map[tx][ty]='*';
+                    }
+                }
+            }
+        }
+    }
+}
+int main()
+{
+    int t,mv;
+    cin>>t;
+    while(t--)
+    {
+        cin>>n>>m>>mv;
+        for(int i=0; i<n; i++)
+        {
+            for(int j=0; j<m; j++)
+            {
+                cin>>map[i][j];
+                if(map[i][j]=='Y')
+                {
+                    sx=i;
+                    sy=j;
+                }
+            }
+        }
+        bfs(mv);
+        for(int i=0; i<n; i++)
+        {
+            for(int j=0; j<m; j++)
+            {
+                printf("%c",map[i][j]);
+            }
+            printf("\n");
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3346_autoAC.cpp b/HDOJ/3346_autoAC.cpp
new file mode 100644
index 0000000..46c05f5
--- /dev/null
+++ b/HDOJ/3346_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<iostream>
+#include<cstdlib>
+using namespace std;
+int main()
+{
+    int n,m,sum1,sum2;
+    cin>>n; 
+    while(n--)
+    {
+    cin>>m;
+    sum1=0;
+    sum2=0;
+    if(m%8==0)
+    {cout<<"Lucky number!"<<endl;}
+    else
+    {
+    while(m)
+    {
+    sum1+=m%10;
+    sum2+=(m%10)*(m%10);
+    m=m/10;
+    }
+    if(sum1%8==0||sum2%8==0)
+    cout<<"Lucky number!"<<endl;
+    else
+    cout<<"What a pity!"<<endl;
+    }
+    }
+    return 0;
+}
diff --git a/HDOJ/3347_autoAC.cpp b/HDOJ/3347_autoAC.cpp
new file mode 100644
index 0000000..09cfcc2
--- /dev/null
+++ b/HDOJ/3347_autoAC.cpp
@@ -0,0 +1,59 @@
+#include<iostream>
+#include<map>
+#include<string.h>
+using namespace std;
+const int MAX=1000000;
+string str,var;
+int n;
+int Str2Int(string s)
+{
+    int end=0,a=1;
+    if(s[0]=='-')
+        end=1;
+    int res=0;
+    for(int i=s.size()-1;i>=end; i--)
+    {
+        res += (s[i]-'0')*a;
+        a *= 10;
+    }
+    if(end) return -res;
+    return res;
+}
+int main()
+{
+    map<string,int> m;
+    int T,i,value;
+    char c;
+    cin>>T;
+    while(T--)
+    {
+        cin>>n;
+        for(i=0;i<n-1;i++)
+        {
+            cin>>var>>c>>value;
+            m[var]=value;
+        }
+        int tmp,ans=0;
+        bool plus=true; 
+        while(cin>>str)
+        {
+            if(str=="?") break;
+            else if(str=="+") plus=true;
+            else if(str=="-") plus=false;
+            else if(str=="=") continue;
+            else if(str[0]>='a' && str[0]<='z')
+            {
+                if(plus) ans += m[str];
+                else ans -= m[str];
+            }
+            else
+            {
+                tmp=Str2Int(str);
+                if(plus) ans += tmp;
+                else ans -= tmp;
+            }
+        }
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/3348_autoAC.cpp b/HDOJ/3348_autoAC.cpp
new file mode 100644
index 0000000..a833a08
--- /dev/null
+++ b/HDOJ/3348_autoAC.cpp
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<stdio.h>
+using namespace std;
+int coin[5]={1,5,10,50,100};
+int main()
+{
+    int p,a[5];
+    int total_case,iii;
+    scanf("%d",&total_case);
+    for(iii=0;iii<total_case;iii++)
+    {
+        scanf("%d%d%d%d%d%d",&p,&a[0],&a[1],&a[2],&a[3],&a[4]);
+        int ssum=0,i,n1=0; 
+        for(i=4;i>=0;i--)
+        {
+            if((p-ssum)/coin[i]<a[i])
+            {
+                n1+=(p-ssum)/coin[i];
+                ssum+=((p-ssum)/coin[i])*coin[i];
+            }
+            else
+            {
+                n1+=a[i];
+                ssum+=a[i]*coin[i];
+            }
+        }
+        int sum=0,n2=0;
+        for(i=0;i<5;i++)
+        {
+            int aa=a[i];
+            if((p-sum)/coin[i]<a[i])
+            {
+              n2+=(p-sum)/coin[i];
+              sum+=((p-sum)/coin[i])*coin[i];
+              a[i]=(p-sum)/coin[i];
+            }
+            else
+            {
+               n2+=a[i];
+               sum+=a[i]*coin[i];
+            }
+            if(p-sum<coin[i]&&p-sum!=0&&aa-a[i]>0)
+            {
+               int j;
+               for(j=i-1;j>=0;j--)
+               {  
+                   if((coin[i]-(p-sum))/coin[j]>a[j])
+                   {
+                       n2-=a[j];
+                       sum-=coin[j]*a[j];
+                   }
+                   else
+                   {
+                       n2-=(coin[i]-(p-sum))/coin[j];
+                       sum-=((coin[i]-(p-sum))/coin[j])*coin[j];
+                   }
+               }
+               n2++;
+               sum+=coin[i];
+               break;
+            }
+        }
+        if(sum==p&&ssum==p)
+        printf("%d %d\n",n1,n2);
+        else
+        printf("-1 -1\n");
+    }
+}
diff --git a/HDOJ/3349_autoAC.cpp b/HDOJ/3349_autoAC.cpp
new file mode 100644
index 0000000..ee4e11e
--- /dev/null
+++ b/HDOJ/3349_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<cstdio>
+#include<algorithm>
+#include<iostream>
+#include<cstring>
+#include<cmath>
+using namespace std;
+double a,b,c;
+int main() {
+    int t;
+    cin>>t;
+    while(t--) {
+        scanf("%lf%lf%lf",&a,&b,&c);
+        if(b<c)
+            swap(b,c);
+        double x=b/2;
+        double y=c/2;
+        double r=sqrt(2*a*a);
+        double ans;
+        if(r<y) {
+            ans=a*a;
+        } else {
+            if(y<r/2) {
+                ans=y*y;
+            } else {
+                double z=r-y;
+                ans=a*a-z*z;
+            }
+        }
+        printf("%.4f\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3350_autoAC.cpp b/HDOJ/3350_autoAC.cpp
new file mode 100644
index 0000000..31e4dbd
--- /dev/null
+++ b/HDOJ/3350_autoAC.cpp
@@ -0,0 +1,94 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<stack>
+using namespace std;
+struct state
+{
+    int tot,num;
+}tem,in,out;
+stack <struct state> st;
+stack < char > cst;
+int n,m;
+char s[10005];
+int main()
+{
+    int t;
+    scanf("%d",&t);getchar();
+    while(t--)
+    {
+        gets(s);
+        int len=strlen(s);
+        for(int i=0;i<len;i++)
+        {
+            if(s[i]<='9'&&s[i]>='0')
+            {
+                int tep=0;
+                while(s[i]<='9'&&s[i]>='0')
+                {
+                    tep=tep*10+s[i]-'0';
+                    i++;
+                }
+                if(!cst.empty()&&cst.top()=='+')
+                {
+                    tem=st.top();st.pop();
+                    tem.num+=tep;tem.tot++;
+                    st.push(tem);cst.pop();
+                }
+                else
+                {
+                    tem.num=tep;tem.tot=0;
+                    st.push(tem);
+                }
+                i--;
+            }
+            else if(s[i]=='+'||s[i]=='(')
+                cst.push(s[i]);
+            else if(s[i]==')'||s[i]==',')
+            {
+                while(!cst.empty()&&cst.top()=='+')
+                {
+                    in=st.top();st.pop();
+                    out=st.top();st.pop();
+                    tem.num=in.num+out.num;
+                    tem.tot=in.tot+out.tot+1;
+                    st.push(tem);cst.pop();
+                }
+                if(s[i]==')'&&st.size()>=2)
+                {
+                    in=st.top();st.pop();
+                    out=st.top();st.pop();
+                    if(out.num>in.num)
+                    {
+                        out.tot=out.tot*2+in.tot;
+                        st.push(out);
+                    }
+                    else
+                    {
+                        in.tot=in.tot*2+out.tot;
+                        st.push(in);
+                    }
+                    cst.pop();
+                }
+            }
+        }
+        while(!cst.empty())
+        {
+            while(!cst.empty()&&cst.top()=='+')
+            {
+                in=st.top();st.pop();
+                out=st.top();st.pop();
+                tem.num=in.num+out.num;
+                tem.tot=in.tot+out.tot+1;
+                st.push(tem);
+                cst.pop();
+            }
+        }
+        printf("%d %d\n",st.top().num,st.top().tot);
+        st.pop();
+    }
+    return 0;
+}
diff --git a/HDOJ/3351_autoAC.cpp b/HDOJ/3351_autoAC.cpp
new file mode 100644
index 0000000..f374d46
--- /dev/null
+++ b/HDOJ/3351_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+const int maxn=2005;
+char str[maxn];
+int main(){
+    int cas=1;
+    while(scanf("%s", str)&&str[0]!='-'){
+        int i, ans=0, lef=0;
+        for(i=0; str[i]!='\0'; i++){
+            if(str[i]=='{'){
+                lef++;
+            }
+            else if(lef>0){
+                lef--;
+            }
+            else {
+                ans++;lef++;
+            }
+        }
+        printf("%d. %d\n", cas++, ans+lef/2);
+    }
+    return 0;
+}
diff --git a/HDOJ/3352_autoAC.cpp b/HDOJ/3352_autoAC.cpp
new file mode 100644
index 0000000..9e249d1
--- /dev/null
+++ b/HDOJ/3352_autoAC.cpp
@@ -0,0 +1,21 @@
+#include<stdio.h>
+long long a,b;
+long long up(long long a,long long b)
+{
+    long long t;
+    if(a==0) return b;
+    while(b!=0)
+    {
+    t=b;b=a%b;a=t;
+    }
+return a;
+}
+int main()
+{
+    while(scanf("%lld%lld",&a,&b)!=EOF)
+    {
+    if(a==0&&b==0) break;
+    printf("%lld\n",a*b/up(a,b)/up(a,b));
+}
+return 0;
+}
diff --git a/HDOJ/3353_autoAC.cpp b/HDOJ/3353_autoAC.cpp
new file mode 100644
index 0000000..52d5cc1
--- /dev/null
+++ b/HDOJ/3353_autoAC.cpp
@@ -0,0 +1,103 @@
+#include<stdio.h>
+#include<math.h>
+#include<iostream>
+#include<string.h>
+using namespace std;
+#define MAXN 1000000
+int prime[MAXN],num;
+bool notprime[MAXN];
+int pa[MAXN],ma[MAXN];
+int pb[MAXN],mb[MAXN];
+void PRIME()
+{
+    int i,j;
+    num=0;
+    memset(notprime,false,sizeof(notprime));
+    for(i=2;i<MAXN;i++)
+       if(!notprime[i])
+       {
+           prime[num++]=i;
+           for(j=i+i;j<MAXN;j+=i)
+             notprime[j]=true;
+       }    
+}    
+int main()
+{
+    int a,b;
+    int na,nb;
+    int i,j,t;
+    int iCase=0;
+    PRIME();
+    while(scanf("%d%d",&a,&b))
+    {
+        if(a==0&&b==0) break;
+        iCase++;
+        na=nb=0;
+        for(i=0;i<num&&a>0;i++)
+        {
+            if(a%prime[i]==0)
+            {
+                t=0;
+                while(a%prime[i]==0)
+                {
+                    t++;
+                    a/=prime[i];
+                }   
+                pa[na]=prime[i];
+                ma[na++]=t; 
+            }    
+        }  
+        for(i=0;i<num&&b>0;i++)
+        {
+            if(b%prime[i]==0)
+            {
+                t=0;
+                while(b%prime[i]==0)
+                {
+                    t++;
+                    b/=prime[i];
+                }    
+                pb[nb]=prime[i];
+                mb[nb++]=t;
+            }    
+        }  
+        int X=0,D=0;    
+        i=0;j=0;
+        while(i<na&&j<nb)
+        {
+            if(pa[i]==pb[j])
+            {
+                X++;
+                D+=abs(ma[i]-mb[j]);
+                i++;
+                j++;
+            }
+            else if(pa[i]<pb[j])
+            {
+                X++;
+                D+=ma[i];
+                i++;
+            }       
+            else
+            {
+                X++;
+                D+=mb[j];
+                j++;
+            }     
+        }   
+        while(i==na&&j<nb)
+        {
+            X++;
+            D+=mb[j];
+            j++;
+        }
+        while(i<na&&j==nb)
+        {
+            X++;
+            D+=ma[i];
+            i++;
+        }   
+        printf("%d. %d:%d\n",iCase,X,D);      
+    }    
+    return 0;
+}
diff --git a/HDOJ/3354_autoAC.cpp b/HDOJ/3354_autoAC.cpp
new file mode 100644
index 0000000..6c8e4c2
--- /dev/null
+++ b/HDOJ/3354_autoAC.cpp
@@ -0,0 +1,16 @@
+#include<stdio.h>
+int main()
+{
+    int n0;
+    int iCase=0;
+    while(scanf("%d",&n0),n0)
+    {
+        iCase++;
+        printf("%d. ",iCase);
+        if(n0%2==0)
+          printf("even %d\n",n0/2);
+        else 
+          printf("odd %d\n",(n0-1)/2);
+    }    
+    return 0;
+}
diff --git a/HDOJ/3355_autoAC.cpp b/HDOJ/3355_autoAC.cpp
new file mode 100644
index 0000000..b8369e9
--- /dev/null
+++ b/HDOJ/3355_autoAC.cpp
@@ -0,0 +1,99 @@
+#include<iostream>
+#include<map>
+#include<string>
+#include<queue>
+using namespace std;
+bool is(string s)
+{
+        int i,k=0,flag=0,t=0;
+    int n=s.size();
+    for(i=0;i<n;++i) {
+        if(s[i]=='W'&&flag==1) k++;
+        if(s[i]=='B') {
+            flag=1;
+            if(k!=0) {
+                t=1;
+                break;
+            }
+        }
+    }
+    if(t) return false;
+    else return true;
+}
+int BFS(string s)
+{
+        queue<string> Qu;
+        int len=s.size(),f;
+        string u,v;
+        map<string,int> step;
+        step[s]=0;
+        Qu.push(s);
+        while(!Qu.empty()) {
+                u=Qu.front();
+                Qu.pop();
+                if(step[u]>=10) return -1;
+                f=u.find('F');
+                v=u;
+                if(f+1<len) {
+                        v[f]=v[f+1];
+                        v[f+1]='F';
+                        if(step.find(v)==step.end()) {
+                                step[v]=step[u]+1;
+                                if(is(v)) return step[v];
+                                Qu.push(v);
+                        }
+                }
+                v=u;
+                if(f-1>=0) {
+                        v[f]=v[f-1];
+                        v[f-1]='F';
+                        if(step.find(v)==step.end()) {
+                                step[v]=step[u]+1;
+                                if(is(v)) return step[v];
+                                Qu.push(v);
+                        }
+                }
+                v=u;
+                if(f+2<len) {
+                        if(v[f+2]=='B')
+                                v[f]='W';
+                        if(v[f+2]=='W')
+                                v[f]='B';
+                        v[f+2]='F';
+                        if(step.find(v)==step.end()) {
+                                step[v]=step[u]+1;
+                                if(is(v)) return step[v];
+                                Qu.push(v);
+                        }
+                }
+                v=u;
+                if(f-2>=0) {
+                        if(v[f-2]=='B')
+                                v[f]='W';
+                        if(v[f-2]=='W')
+                                v[f]='B';
+                        v[f-2]='F';
+                        if(step.find(v)==step.end()) {
+                                step[v]=step[u]+1;
+                                if(is(v)) return step[v];
+                                Qu.push(v);
+                        }
+                }
+        }
+        return -1;
+}
+int main()
+{
+        string state;
+        int count=1,r;
+        while(cin>>state)
+        {
+                if(state[0]=='-') break;
+                if(is(state)) cout<<count++<<". 0"<<endl;
+                else {
+                        r=BFS(state);
+                        r==-1?cout<<count++<<". -1"<<endl:cout<<count++<<". "<<r<<endl;
+                }
+        }
+        return 0;
+}
diff --git a/HDOJ/3356_autoAC.cpp b/HDOJ/3356_autoAC.cpp
new file mode 100644
index 0000000..114ac35
--- /dev/null
+++ b/HDOJ/3356_autoAC.cpp
@@ -0,0 +1,73 @@
+#include<stdio.h>
+#include<stdlib.h>
+#define maxn 1000
+#define PI 3.141
+const double inf = 0.00001;
+double d1[maxn], d2[maxn];
+double dis(double x1, double y1, double x2, double y2)
+{
+    return 1.0 * (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
+}
+int main()
+{
+    int n, i, j, ans, sum, k = 0;
+    double r1, r2, r3, r4, r;
+    double x1, y1, x2, y2, x, y;
+    while (scanf("%d", &n), n)
+    {
+        scanf("%lf%lf%lf%lf%lf", &x1, &y1, &x2, &y2, &r);
+        r = 1.0 * r / PI;
+        for (i = 0; i < n; i++)
+        {
+            scanf("%lf%lf", &x, &y);
+            d1[i] = dis(x, y, x1, y1);
+            d2[i] = dis(x, y, x2, y2);
+        }
+        for (i = 0, ans = n; i < n; i++)
+        {
+            r1 = d1[i];
+            if (r1 <= r)//涓句涓瑰朵腑涓涓濉璺绂r1,╀纾娉㈣绂讳负r2
+            {
+                r2 = r - r1;
+                for (j = 0, sum = 0; j < n; j++)
+                {
+                    if (d1[j] <= r1)
+                    {
+                        sum++;
+                    }
+                    else if (d2[j] <= r2)
+                    {
+                        sum++;
+                    }
+                }
+                if (ans > n - sum)
+                {
+                    ans = n - sum;
+                }
+            }
+            r2 = d2[i];
+            if (r2 <= r)
+            {
+                r1 = r - r2;
+                for (j = 0, sum = 0; j < n; j++)
+                {
+                    if (d1[j] <= r1)
+                    {
+                        sum++;
+                    }
+                    else if (d2[j] <= r2)
+                    {
+                        sum++;
+                    }
+                }
+                if (ans > n - sum)
+                {
+                    ans = n - sum;
+                }
+            }
+        }
+        k++;
+        printf("%d. %d\n", k, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3357_autoAC.cpp b/HDOJ/3357_autoAC.cpp
new file mode 100644
index 0000000..fd6a68c
--- /dev/null
+++ b/HDOJ/3357_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <algorithm>
+#include <queue>
+#include <cmath>
+#include <stack>
+#include <set>
+using namespace std;
+int mp[300][300];
+int n;
+void add(int a,int b){
+    mp[a][b]=1;
+    for(int i=1;i<=n;i++)
+        if(mp[i][a]){
+            mp[i][b]=1;
+            for(int j=1;j<=n;j++)
+                if(mp[a][j])
+                    mp[i][j]=1;
+        }
+    for(int i=1;i<=n;i++)
+        if(mp[b][i]){
+            mp[a][i]=1;
+            for(int j=1;j<=n;j++)
+                if(mp[j][b])
+                    mp[j][i]=1;
+        }
+}
+int main(){
+    int t;
+    int cas=1;
+    while(~scanf("%d%d",&n,&t)){
+        if(!n && !t)break;
+        memset(mp,0,sizeof(mp));
+        int ans=0;
+        while(t--){
+            int a,b;
+            scanf("%d%d",&a,&b);    
+            if(mp[b][a])ans++;
+            else if(a==b)ans++;
+            else if(!mp[a][b]) add(a,b);
+        }
+        printf("%d. %d\n",cas++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3358_autoAC.cpp b/HDOJ/3358_autoAC.cpp
new file mode 100644
index 0000000..7ea3c60
--- /dev/null
+++ b/HDOJ/3358_autoAC.cpp
@@ -0,0 +1,81 @@
+#include<cstdio>
+#include<iostream>
+#include<string>
+#include<cmath>
+#include<algorithm>
+#include<vector>
+using namespace std;
+int n, k;
+int x[100005], y[100005];
+vector<int> s1, s2;
+void gao(int *p, vector<int>& V) {
+ sort(p, p+n);
+ V.clear();
+ p[n] = -1;
+ int cnt = 1;
+ for(int i=0; i<n; i++) {
+ if(p[i] != p[i+1]) {
+ V.push_back(cnt);
+ cnt = 1;
+ } else cnt ++;
+ }
+ for(int i=0; i<V.size(); i++) {
+ }
+}
+int ans;
+vector<int> v;
+void dfs(int pi, int ni, int cur) {
+ if(pi == k || ni == v.size()) {
+ cur += (k - pi) * abs(n);
+ if(ans > cur) ans = cur;
+ return ;
+ }
+ int sum = (ni == 0) ? 0 : v[ni-1];
+ if(pi == k-1) {
+ dfs(pi+1, v.size(), cur+abs(v[v.size()-1] - sum - n));
+ return ;
+ }
+ int id = lower_bound(v.begin(), v.end(), n + sum) - v.begin();
+ id --;
+ if(ni <= id && id < v.size()) dfs(pi+1, id+1, cur+abs(v[id] - sum - n));
+ id ++;
+ if(ni <= id && id < v.size()) dfs(pi+1, id+1, cur+abs(v[id] - sum - n));
+}
+int solve(vector<int> V) {
+ ans = 1000000;
+ v = V;
+ for(int i=1; i<v.size(); i++) {
+ v[i] += v[i-1];
+ }
+ for(int i=0; i<v.size(); i++) {
+ v[i] *= k;
+ }
+ dfs(0, 0, 0);
+ return ans;
+}
+int gcd(int x, int y) {
+ while(x%=y^=x^=y^=x);
+ return y;
+}
+int main()
+{
+ int kase = 0;
+ while(scanf("%d%d", &n, &k) == 2 && n && k) {
+ for(int i=0; i<n; i++) {
+ scanf("%d%d", &x[i], &y[i]);
+ }
+ gao(x, s1);
+ gao(y, s2);
+ int ans = solve(s1);
+ ans = min(ans, solve(s2));
+ if(ans == 0) {
+ printf("%d. 0/1\n", ++kase);
+ continue;
+ }
+ k *= k;
+ int g = gcd(ans, k);
+ ans /= g; k/= g;
+ printf("%d. %d/%d\n", ++kase, ans, k);
+ }
+ return 0;
+}
diff --git a/HDOJ/3359_autoAC.cpp b/HDOJ/3359_autoAC.cpp
new file mode 100644
index 0000000..3a4fcae
--- /dev/null
+++ b/HDOJ/3359_autoAC.cpp
@@ -0,0 +1,77 @@
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+#define MAXN 110
+using namespace std;
+double a[MAXN][MAXN], g[MAXN][MAXN], x[MAXN];
+int pos[MAXN][MAXN];
+int n, m, d, cnt;
+int MHT(int x1, int y1, int x2, int y2) {
+    return abs(x1 - x2) + abs(y1 - y2);
+}
+void Gauss() {
+    int i, j, k;
+    double tmp, big;
+    for (i = 0; i < cnt; i++) {
+        for (big = 0, j = i; j < cnt; j++) {
+            if (abs(g[j][i]) > big) {
+                big = abs(g[j][i]);
+                k = j;
+            }
+        }
+        if (k != i) {
+            for (j = 0; j <= cnt; j++)
+                swap(g[i][j], g[k][j]);
+        }
+        for (j = i + 1; j < cnt; j++) {
+            if (g[j][i]) {
+                tmp = -g[j][i] / g[i][i];
+                for (k = i; k <= cnt; k++)
+                    g[j][k] += tmp * g[i][k];
+            }
+        }
+    }
+    for (i = cnt - 1; i >= 0; i--) {
+        tmp = 0;
+        for (j = i + 1; j < cnt; j++)
+            tmp += g[i][j] * x[j];
+        x[i] = (g[i][j] - tmp) / g[i][i];
+    }
+}
+int main() {
+    int i, j, k, l;
+    bool flag = true;
+    while (scanf("%d%d%d", &m, &n, &d), n) {
+        if (flag)
+            flag = false;
+        else
+            putchar('\n');
+        for (i = cnt = 0; i < n; i++) {
+            for (j = 0; j < m; j++) {
+                scanf("%lf", &a[i][j]);
+                pos[i][j] = cnt++;
+            }
+        }
+        memset(g, 0, sizeof(g));
+        for (i = 0; i < n; i++) {
+            for (j = 0; j < m; j++) {
+                for (k = 0; k < n; k++) {
+                    for (l = 0; l < m; l++) {
+                        if (MHT(i, j, k, l) <= d) {
+                            g[pos[i][j]][pos[k][l]] = 1;
+                            g[pos[i][j]][cnt] += a[i][j];
+                        }
+                    }
+                }
+            }
+        }
+        Gauss();
+        for (i = 0; i < n; i++) {
+            for (j = 0; j < m; j++)
+                printf("%8.2lf", x[i * m + j]);
+            putchar('\n');
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3360_autoAC.cpp b/HDOJ/3360_autoAC.cpp
new file mode 100644
index 0000000..42ba803
--- /dev/null
+++ b/HDOJ/3360_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+const int maxn=2505;
+const int maxc=55;
+vector<int>e[maxn];
+int vis[maxn],pre[maxn];
+int map[maxc][maxc];
+int dir[12][2]={{-1,-2},{-2,-1},{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,0},{0,1},{1,0},{0,-1}};
+int find(int u)
+{
+    int i,j,v;
+    for(i=0;i<e[u].size();i++)
+    {
+        v=e[u][i];
+        if(!vis[v])
+        {
+            vis[v]=1;
+            if(pre[v]==-1||find(pre[v]))
+            {
+                pre[v]=u;
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+string a[maxn],b[maxn];
+int main()
+{
+    int n,m,tt=0;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        if(n==0&&m==0)break;
+        int i,j,k;
+        for(i=1;i<=n*m;i++)
+            e[i].clear();
+        for(i=1;i<=n;i++)
+            for(j=1;j<=m;j++)
+            cin>>map[i][j];
+        int x,y,ans=0,t;
+        for(i=1;i<=n;i++)
+        {
+            for(j=1;j<=m;j++)
+            {
+                t=(i+j)%2;
+                if(map[i][j]==-1)continue;
+                for(k=0;k<12;k++)
+                {
+                    if(!(map[i][j]&(1<<k)))continue;
+                    x=i+dir[k][0];
+                    y=j+dir[k][1];
+                    if(x<=0||y<=0||x>n||y>m||map[x][y]==-1)continue;
+                    if(t)e[(i-1)*m+j].push_back((x-1)*m+y);
+                    else e[(x-1)*m+y].push_back((i-1)*m+j);
+                }
+            }
+        }
+        memset(pre,-1,sizeof(pre));
+        for(i=1;i<=n*m;i++)
+        {
+            memset(vis,0,sizeof(vis));
+            ans+=find(i);
+        }
+        printf("%d. %d\n",++tt,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3361_autoAC.cpp b/HDOJ/3361_autoAC.cpp
new file mode 100644
index 0000000..35f7610
--- /dev/null
+++ b/HDOJ/3361_autoAC.cpp
@@ -0,0 +1,10 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+    int n, t, i;
+    scanf("%d", &n);
+    for( i=0; i < n; i++ )
+        scanf("%d", &t), printf("%c", t);
+    return 0;
+}
diff --git a/HDOJ/3362_autoAC.cpp b/HDOJ/3362_autoAC.cpp
new file mode 100644
index 0000000..c0469d1
--- /dev/null
+++ b/HDOJ/3362_autoAC.cpp
@@ -0,0 +1,72 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#define inf 1e9
+using namespace std;
+pair<int, int> point[20];
+bool fix[20];
+double dp[1<<18];
+double Distance(int a, int b) {
+    int x1 = point[a].first, y1 = point[a].second;
+    int x2 = point[b].first, y2 = point[b].second;
+    return sqrt(1.0*(x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+}
+double Fixed(int n, int state, int cur) {
+    double ans = 0;
+    bool mark[20];
+    double dist[20];
+    for (int i = 0; i < n; ++i) {
+        if (((1<<i) & state)) {
+            mark[i] = 1;
+            dist[i] = Distance(i, cur);
+        }
+        else
+            mark[i] = 0;
+    }
+    for (int i = 0; i < 2; ++i) {
+        double Min = inf;
+        int p = 19;
+        for (int j = 0; j < n; ++j) {
+            if (mark[j] && dist[j] < Min) {
+                Min = dist[j];
+                p = j;
+            }
+        }
+        ans += Min;
+        mark[p] = 0;
+    }
+    if (ans >= inf) return -1;
+    return ans;
+}
+int main() {
+    int n;
+    while (cin>>n) {
+        if (!n) break;
+        int begin = 0, target = 0;
+        for (int i = 0; i < n; ++i) {
+            cin>>point[i].first>>point[i].second>>fix[i];
+            if (fix[i])
+                begin += (1<<i);
+            target += (1<<i);
+        }
+        for (int i = 0; i < (1<<n); ++i)
+            dp[i] = inf;
+        dp[begin] = 0;
+        for (int i = begin; i < target; ++i) {
+            if (dp[i] == inf) continue;
+            for (int j = 0; j < n; ++j) {
+                if (i & (1<<j)) continue;
+                double sum = Fixed(n, i, j);
+                if (sum >= 0)
+                    dp[i|(1<<j)] = min(dp[i|(1<<j)], dp[i] + sum);
+            }
+        }
+        if (dp[target] == inf)
+            printf("No Solution\n");
+        else
+            printf("%.6lf\n", dp[target]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3363_autoAC.cpp b/HDOJ/3363_autoAC.cpp
new file mode 100644
index 0000000..ff196c6
--- /dev/null
+++ b/HDOJ/3363_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<iostream>
+#include<algorithm>
+#include<string>
+using namespace std;
+char str[100005];
+int n;
+int main()
+{
+    while(scanf("%d",&n)==1&&n)
+    {
+        scanf("%s",str);
+        int h=0,t=0;
+        for(int i=0;i<n;i++)
+            if(str[i]=='H')
+                h++;
+            else t++;
+        if(h%2==0 && t%2==0)
+        {
+            h/=2;t/=2;
+        }
+        else 
+        {
+            printf("-1\n");
+            continue;
+        }
+        int hh=0,tt=0;
+        for(int i=0;i<n/2;i++)
+            if(str[i]=='H')
+                hh++;
+            else tt++;
+        if(hh==h && tt==t)
+        {
+            printf("1\n%d\n",n/2);
+            continue;
+        }
+        for(int i=n/2,j=0;i<n;i++,j++)
+        {
+            if(str[i]=='H')
+                hh++;
+            else tt++;
+            if(str[j]=='H')
+                hh--;
+            else tt--;
+            if(hh==h && tt==t)
+            {
+                printf("2\n%d %d\n",j+1,i+1);
+                break;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3364_autoAC.cpp b/HDOJ/3364_autoAC.cpp
new file mode 100644
index 0000000..dc6e239
--- /dev/null
+++ b/HDOJ/3364_autoAC.cpp
@@ -0,0 +1,165 @@
+#include <iostream>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <map>
+#include <set>
+using namespace std ;
+const int MAXN=55;
+int a[MAXN][MAXN],b[MAXN][MAXN];
+int x[MAXN];
+bool free_x[MAXN];
+/*
+void Debug(void)
+{
+    int i, j;
+    for (i = 0; i < equ; i++)
+    {
+        for (j = 0; j < var + 1; j++)
+        {
+            cout << a[i][j] << " ";
+        }
+        cout << endl;
+    }
+    cout << endl;
+}
+*/
+inline int gcd(int a,int b)
+{
+    int t;
+    while(b!=0)
+    {
+        t=b;
+        b=a%b;
+        a=t;
+    }
+    return a;
+}
+inline int lcm(int a,int b)
+{
+    return a/gcd(a,b)*b;
+}
+int Gauss(int equ,int var)
+{
+    int i,j,k;
+    int max_r;
+    int col;
+    int ta,tb;
+    int LCM;
+    int temp;
+    int free_x_num;
+    int free_index;
+    for(int i=0;i<=var;i++)
+    {
+        x[i]=0;
+        free_x[i]=true;
+    } 
+    col=0; 
+    for(k = 0;k < equ && col < var;k++,col++)
+    {
+        max_r=k;
+        for(i=k+1;i<equ;i++)
+        {
+            if(abs(a[i][col])>abs(a[max_r][col])) max_r=i;
+        }
+        if(max_r!=k)
+        {
+            for(j=k;j<var+1;j++) swap(a[k][j],a[max_r][j]);
+        }
+        if(a[k][col]==0)
+        {
+            k--;
+            continue;
+        }
+        for(i=k+1;i<equ;i++)
+        {
+            if(a[i][col]!=0)
+            {
+                for(j=col;j<var+1;j++)
+                {
+                    a[i][j] ^= a[k][j];
+                }
+            }
+        }
+    }
+    for (i = k; i < equ; i++)
+    { 
+        if (a[i][col] != 0) return -1;
+    }
+    if (k < var)
+    {
+        for (i = k - 1; i >= 0; i--)
+        {
+            free_x_num = 0; 
+            for (j = 0; j < var; j++)
+            {
+                if (a[i][j] != 0 && free_x[j]) free_x_num++, free_index = j;
+            }
+            if (free_x_num > 1) continue;
+            temp = a[i][var];
+            for (j = 0; j < var; j++)
+            {
+                if (a[i][j] != 0 && j != free_index) temp -= a[i][j] * x[j];
+            }
+            x[free_index] = temp / a[i][free_index]; 
+            free_x[free_index] = 0; 
+        }
+        return var - k; 
+    }    
+    for (i = var - 1; i >= 0; i--)
+    {
+        temp = a[i][var];
+        for (j = i + 1; j < var; j++)
+        {
+            if (a[i][j] != 0) temp -= a[i][j] * x[j];
+        }
+        if (temp % a[i][i] != 0) return -2; 
+        x[i] = temp / a[i][i];
+    }
+    return 0;
+}
+int main(void)
+{
+    int T ;
+    scanf("%d",&T) ; 
+    for(int cas=1 ;cas<=T ;cas++)
+    {
+        int equ,var ;
+        scanf("%d%d",&equ,&var) ;
+        memset(a,0,sizeof(a)) ;
+        memset(b,0,sizeof(b)) ;
+        for(int i=0 ;i<var ;i++)
+        {
+            int k ;
+            scanf("%d",&k) ;
+            for(int j=0 ;j<k ;j++)
+            {
+                int v ;
+                scanf("%d",&v) ;
+                b[v-1][i]=1 ;
+            }
+        }
+        printf("Case %d:\n",cas) ;
+        int q ;
+        scanf("%d",&q) ;
+        while(q--)
+        {
+            memcpy(a,b,sizeof(b)) ;
+            for(int i=0 ;i<equ ;i++)
+            {
+                int v ;
+                scanf("%d",&v) ;
+                a[i][var]=v ;
+            }
+            int x=Gauss(equ,var) ;
+            if(x<0)
+            {
+                puts("0") ;
+                continue ;
+            }
+            printf("%I64d\n",1LL<<x) ;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3365_autoAC.cpp b/HDOJ/3365_autoAC.cpp
new file mode 100644
index 0000000..ddf4469
--- /dev/null
+++ b/HDOJ/3365_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<stdio.h>
+#include<math.h>
+#define N 10010
+#define PI acos(-1)
+#define EPS 1e-8
+struct Point
+{
+    double x,y;
+    void input(){scanf("%lf%lf",&x,&y);}
+    void output(){printf("%.2lf %.2lf\n",x,y);}
+}A[N],B[2],PA,PB;
+double cosa,sina,k;
+double length(Point P)
+{
+    return sqrt(P.x*P.x+P.y*P.y);
+}
+void rotate(Point &P)
+{
+    double t=P.x;
+    P.x=P.x*cosa-P.y*sina;
+    P.y=P.y*cosa+t*sina;
+}
+void expand(Point &P)
+{
+    P.x*=k;
+    P.y*=k;
+}
+int main()
+{
+    int n,i,t,cnt=0;
+    double a;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(i=0;i<n;++i)
+            A[i].input();
+        for(i=0;i<2;++i)
+            B[i].input();
+        PA.x=A[1].x-A[0].x;
+        PA.y=A[1].y-A[0].y;
+        PB.x=B[1].x-B[0].x;
+        PB.y=B[1].y-B[0].y;
+        a=acos((PA.x*PB.x+PA.y*PB.y)/(length(PA)*length(PB)));
+        if(PA.x*PB.y-PA.y*PB.x<EPS)
+            a = 2.0 * PI - a;
+        cosa=cos(a);
+        sina=sin(a);
+        k=length(PB)/length(PA);
+        for(i=2;i<n;++i)
+        {
+            A[i].x-=A[0].x;
+            A[i].y-=A[0].y;
+            rotate(A[i]);
+            expand(A[i]);
+            A[i].x+=B[0].x;
+            A[i].y+=B[0].y;
+        }
+        printf("Case %d:\n",++cnt);
+        B[0].output();
+        B[1].output();
+        for(i=2;i<n;++i)
+            A[i].output();
+    }
+    return 0;
+}
diff --git a/HDOJ/3366_autoAC.cpp b/HDOJ/3366_autoAC.cpp
new file mode 100644
index 0000000..55fb38d
--- /dev/null
+++ b/HDOJ/3366_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+const int maxn=1100;
+struct route{
+    double p,q;
+    friend  bool operator < (route a,route b){
+        return a.p/a.q>b.p/b.q;
+    }
+}r[maxn];
+int n,m;
+double dp[maxn][20];
+void input(){
+    scanf("%d%d",&n,&m);
+    for(int i=0;i<n;i++){
+        scanf("%lf%lf",&r[i].p,&r[i].q);
+    }
+    sort(r,r+n);
+    for(int i=0;i<=n;i++){
+        for(int j=0;j<=m;j++){
+            dp[i][j]=0;
+        }
+    }
+}
+double solve(){
+    double ans=0;
+    dp[0][m]=1;
+    for(int i=0;i<n;i++){
+        for(int j=m;j>=0;j--){
+            ans+=dp[i][j]*r[i].p;
+            if(j-1>=0) dp[i+1][j-1]+=dp[i][j]*r[i].q;
+            dp[i+1][j]+=dp[i][j]*(1.0-r[i].p-r[i].q);
+        }
+    }
+    return ans;
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    for(int i=1;i<=t;i++){
+        input();
+        printf("Case %d: %.5lf\n",i,solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/3367_autoAC.cpp b/HDOJ/3367_autoAC.cpp
new file mode 100644
index 0000000..a30fc6d
--- /dev/null
+++ b/HDOJ/3367_autoAC.cpp
@@ -0,0 +1,70 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+const int N=10010;
+using namespace std;
+int n,m;
+int parent[N];
+int visited[N];
+struct Edge {
+    int u,v,w;
+    bool operator < (const Edge &p) const {
+        return p.w<w;
+    }
+}edge[N*10];
+void UFset(){
+    for(int i=0;i<n;i++)
+        parent[i]=-1;
+}
+int Find(int x){
+    int s;
+    for(s=x;parent[s]>=0;s=parent[s]);
+    while(s!=x){
+        int temp=parent[x];
+        parent[x]=s;
+        x=temp;
+    }
+    return s;
+}
+void Union(int R1,int R2){
+    int r1=Find(R1);
+    int r2=Find(R2);
+    int temp=parent[r1]+parent[r2];
+    if(parent[r1]>parent[r2]){
+        parent[r1]=r2;
+        parent[r2]=temp;
+    }else {
+        parent[r2]=r1;
+        parent[r1]=temp;
+    }
+}
+int main(){
+    while(scanf("%d%d",&n,&m)!=EOF){
+        if(n==0&&m==0)break;
+        memset(visited,0,sizeof(visited));
+        int u,v,ans=0;
+        for(int i=0;i<m;i++){
+            scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
+        }
+        sort(edge,edge+m);
+        UFset();
+        for(int i=0;i<m;i++){
+            u=Find(edge[i].u);
+            v=Find(edge[i].v);
+            if(u!=v){
+                if(visited[u]&&visited[v])continue; 
+                if(visited[u]||visited[v])
+                    visited[u]=visited[v]=1;
+                ans+=edge[i].w;
+                Union(u,v);
+            }else if(!visited[u]||!visited[v]){
+                Union(u,v);
+                visited[u]=visited[v]=1;
+                ans+=edge[i].w;
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3368_autoAC.cpp b/HDOJ/3368_autoAC.cpp
new file mode 100644
index 0000000..fe25054
--- /dev/null
+++ b/HDOJ/3368_autoAC.cpp
@@ -0,0 +1,252 @@
+#include<stdio.h>
+#include<string.h>
+const int maxn = 10;
+char mat[ maxn ][ maxn ];
+const int dx[]={-1,1,-1,1};
+const int dy[]={1,-1,-1,1};
+int max( int a,int b ){
+    return a>b?a:b;
+}
+bool in( int x,int y ){
+    if( x>=1&&x<=8&&y>=1&&y<=8 ) return true;
+    else return false;
+}
+int solve( int x,int y ){
+    int ans = 0;
+    int pos;
+    pos = -1;
+    for( int i=y+1;i<=8;i++ ){
+        if( mat[x][i]=='D' ){
+            pos = i;
+            break;
+        }
+    }
+    if( pos!=-1 ){
+        for( int i=y+1;i<=pos;i++ ){
+            if( mat[x][i]=='*' ){
+                pos = -1;
+                break;
+            }
+        }
+    }
+    if( pos!=-1 ){
+        for( int i=y+1;i<=pos;i++ ){
+            if( mat[x][i]=='L' )
+                ans++;
+        }
+    }
+    pos = -1;
+    for( int i=y-1;i>=1;i-- ){
+        if( mat[x][i]=='D' ){
+            pos = i;
+            break;
+        }
+    }
+    if( pos!=-1 ){
+        for( int i=y-1;i>=pos;i-- ){
+            if( mat[x][i]=='*' ){
+                pos = -1;
+                break;
+            }
+        }
+    }
+    if( pos!=-1 ){
+        for( int i=y-1;i>=pos;i-- ){
+            if( mat[x][i]=='L' )
+                ans++;
+        }
+    }
+    pos = -1;
+    for( int i=x+1;i<=8;i++ ){
+        if( mat[i][y]=='D' ){
+            pos = i;
+            break;
+        }
+    }
+    if( pos!=-1 ){
+        for( int i=x+1;i<=pos;i++ ){
+            if( mat[i][y]=='*' ){
+                pos = -1;
+                break;
+            }
+        }
+    }
+    if( pos!=-1 ){
+        for( int i=x+1;i<=pos;i++ ){
+            if( mat[i][y]=='L' )
+                ans++;
+        }
+    }
+    pos = -1;
+    for( int i=x-1;i>=1;i-- ){
+        if( mat[i][y]=='D' ){
+            pos = i;
+            break;
+        }
+    }
+    if( pos!=-1 ){
+        for( int i=x-1;i>=pos;i-- ){
+            if( mat[i][y]=='*' ){
+                pos = -1;
+                break;
+            }
+        }
+    }
+    if( pos!=-1 ){
+        for( int i=x-1;i>=pos;i-- ){
+            if( mat[i][y]=='L' )
+                ans++;
+        }
+    }
+    int posx,posy;
+    int K;
+    posx = -1;
+    for( int k=1;k<=8;k++ ){
+        int tx = x+k*dx[0];
+        int ty = y+k*dy[0];
+        if( in(tx,ty)==false ) break;
+        if( mat[tx][ty]=='D' ){
+            posx = tx;
+            posy = ty;
+            K = k;
+            break;
+        }
+    }
+    if( posx!=-1 ){
+        for( int k=1;k<=K;k++ ){
+            int tx = x+k*dx[0];
+            int ty = y+k*dy[0];
+            if( in(tx,ty)==false ) break;
+            if( mat[tx][ty]=='*' ){
+                posx = -1;
+                break;
+            }
+        }
+    }
+    if( posx!=-1 ){
+        for( int k=1;k<=K;k++ ){
+            int tx = x+k*dx[0];
+            int ty = y+k*dy[0];
+            if( in(tx,ty)==false ) break;
+            if( mat[tx][ty]=='L' )
+                ans++;
+        }
+    }
+    posx = -1;
+    for( int k=1;k<=8;k++ ){
+        int tx = x+k*dx[1];
+        int ty = y+k*dy[1];
+        if( in(tx,ty)==false ) break;
+        if( mat[tx][ty]=='D' ){
+            posx = tx;
+            posy = ty;
+            K = k;
+            break;
+        }
+    }
+    if( posx!=-1 ){
+        for( int k=1;k<=K;k++ ){
+            int tx = x+k*dx[1];
+            int ty = y+k*dy[1];
+            if( in(tx,ty)==false ) break;
+            if( mat[tx][ty]=='*' ){
+                posx = -1;
+                break;
+            }
+        }
+    }
+    if( posx!=-1 ){
+        for( int k=1;k<=K;k++ ){
+            int tx = x+k*dx[1];
+            int ty = y+k*dy[1];
+            if( in(tx,ty)==false ) break;
+            if( mat[tx][ty]=='L' )
+                ans++;
+        }
+    }
+    posx = -1;
+    for( int k=1;k<=8;k++ ){
+        int tx = x+k*dx[2];
+        int ty = y+k*dy[2];
+        if( in(tx,ty)==false ) break;
+        if( mat[tx][ty]=='D' ){
+            posx = tx;
+            posy = ty;
+            K = k;
+            break;
+        }
+    }
+    if( posx!=-1 ){
+        for( int k=1;k<=K;k++ ){
+            int tx = x+k*dx[2];
+            int ty = y+k*dy[2];
+            if( in(tx,ty)==false ) break;
+            if( mat[tx][ty]=='*' ){
+                posx = -1;
+                break;
+            }
+        }
+    }
+    if( posx!=-1 ){
+        for( int k=1;k<=K;k++ ){
+            int tx = x+k*dx[2];
+            int ty = y+k*dy[2];
+            if( in(tx,ty)==false ) break;
+            if( mat[tx][ty]=='L' )
+                ans++;
+        }
+    }
+    posx = -1;
+    for( int k=1;k<=8;k++ ){
+        int tx = x+k*dx[3];
+        int ty = y+k*dy[3];
+        if( in(tx,ty)==false ) break;
+        if( mat[tx][ty]=='D' ){
+            posx = tx;
+            posy = ty;
+            K = k;
+            break;
+        }
+    }
+    if( posx!=-1 ){
+        for( int k=1;k<=K;k++ ){
+            int tx = x+k*dx[3];
+            int ty = y+k*dy[3];
+            if( in(tx,ty)==false ) break;
+            if( mat[tx][ty]=='*' ){
+                posx = -1;
+                break;
+            }
+        }
+    }
+    if( posx!=-1 ){
+        for( int k=1;k<=K;k++ ){
+            int tx = x+k*dx[3];
+            int ty = y+k*dy[3];
+            if( in(tx,ty)==false ) break;
+            if( mat[tx][ty]=='L' )
+                ans++;
+        }
+    }
+    return ans;
+}
+int main(){
+    int T;
+    scanf("%d",&T);
+    int ca = 1;
+    while( T-- ){
+        for( int i=1;i<=8;i++ ){
+            scanf("%s",mat[i]+1);
+        }
+        int ans = 0;
+        for( int i=1;i<=8;i++ ){
+            for( int j=1;j<=8;j++ ){
+                if( mat[i][j]=='*' ){
+                    ans = max( ans,solve( i,j ) );
+                }
+            }
+        }
+        printf("Case %d: %d\n",ca++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3369_autoAC.cpp b/HDOJ/3369_autoAC.cpp
new file mode 100644
index 0000000..9b78359
--- /dev/null
+++ b/HDOJ/3369_autoAC.cpp
@@ -0,0 +1,180 @@
+#include <utility>
+#include <algorithm>
+#include <string>
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+#include <iomanip>
+#include <set>
+#include <vector>
+#include <cmath>
+#include <queue>
+#include <bitset>
+#include <map>
+#include <iterator>
+using namespace std;
+#define clr(a,v) memset(a,v,sizeof(a))
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1|1
+const int INF = 0x7f7f7f7f;
+const int maxn = 211111;
+const double pi = acos(-1.0);
+const double eps = 1e-10;
+const int mod = 1000000007;
+typedef long long LL;
+typedef pair<int, int> pii;
+typedef vector<LL> VI;
+typedef vector<VI> VVI;
+typedef vector<VVI> VVVI;
+VVI E, I, A;
+int size;
+LL f[20][20];
+LL P[20];
+LL num[20][20];
+LL arr[20];
+int convert(char *s) {
+    if (strcmp(s, "Monday") == 0)
+        return 1;
+    if (strcmp(s, "Tuesday") == 0)
+        return 2;
+    if (strcmp(s, "Wednesday") == 0)
+        return 3;
+    if (strcmp(s, "Thursday") == 0)
+        return 4;
+    if (strcmp(s, "Friday") == 0)
+        return 5;
+    if (strcmp(s, "Saturday") == 0)
+        return 6;
+    if (strcmp(s, "Sunday") == 0)
+        return 7;
+    return -1;
+}
+LL POW(LL a, LL b) {
+    LL res = 1;
+    while (b) {
+        if (b & 1)
+            res = res * a % mod;
+        a = a * a % mod;
+        b >>= 1;
+    }
+    return res;
+}
+VVI multi(const VVI& A, const VVI& B) {
+    VVI res = VVI(size, VI(size, 0));
+    int i, j, k;
+    for (i = 0; i < size; ++i) {
+        for (j = 0; j < size; ++j) {
+            for (k = 0; k < size; ++k) {
+                res[i][j] += A[i][k] * B[k][j];
+                if (res[i][j] >= mod)
+                    res[i][j] %= mod;
+            }
+        }
+    }
+    return res;
+}
+VVI cal(const VVI& A, LL k) {
+    VVI res = E, t = A;
+    while (k) {
+        if (k & 1)
+            res = multi(res, t);
+        t = multi(t, t);
+        k >>= 1;
+    }
+    return res;
+}
+void output(const VVI &arr) {
+    for (int i = 0; i < size; ++i) {
+        cout.width(5);
+        for (int j = 0; j < size; ++j) {
+            cout << arr[i][j] << " ";
+        }
+        cout << endl;
+    }
+}
+LL go(int n, int k, int s) {
+    size = k + 2;
+    int i, j, t;
+    int a = (7 - s % 7) % 7, b = (8 - s % 7) % 7;
+    LL ans = 0;
+    if (n <= 7) {
+        for (i = 1; i <= n; ++i) {
+            t = i % 7;
+            if (t == a || t == b)
+                continue;
+            ans += POW(i, k);
+            ans = ans >= mod ? ans % mod : ans;
+        }
+        return ans;
+    }
+    E = VVI(size, VI(size, 0));
+    for (i = 0; i < size; ++i)
+        E[i][i] = 1;
+    I = VVI(size, VI(size, 0));
+    I[0][0] = 1;
+    for (i = 1; i < size; ++i)
+        I[0][i] = f[k][i - 1] * P[i - 1] % mod;
+    for (i = 1; i < size; ++i) {
+        for (j = i; j < size; ++j) {
+            I[i][j] = f[k + 1 - i][j - i] * P[j - i] % mod;
+        }
+    }
+    LL p = n / 7, tmp;
+    VVI res = E, ta, tb;
+    int r = n % 7;
+    ta = cal(I, p - 1);
+    tb = multi(ta, I);
+    for (i = 1; i <= 7; ++i) {
+        if (i % 7 == a || i % 7 == b)
+            continue;
+        arr[0] = num[i][k];
+        tmp = 0;
+        for (j = 1; j < size; ++j)
+            arr[j] = num[i][k + 1 - j];
+        if (i <= r) {
+            for (j = 0; j < size; ++j) {
+                tmp += tb[0][j] * arr[j];
+                tmp %= mod;
+            }
+        } else {
+            for (j = 0; j < size; ++j) {
+                tmp += ta[0][j] * arr[j];
+                tmp %= mod;
+            }
+        }
+        ans += tmp;
+        ans %= mod;
+    }
+    return ans;
+}
+int main() {
+    ios::sync_with_stdio(false);
+    char s[14];
+    int n, k, i, j;
+    P[0] = 1;
+    for (i = 1; i < 20; ++i)
+        P[i] = P[i - 1] * 7 % mod;
+    for (i = 0; i < 20; ++i)
+        f[i][0] = f[i][i] = 1;
+    for (i = 1; i < 20; ++i) {
+        for (j = 1; j < i; ++j) {
+            f[i][j] = f[i - 1][j - 1] + f[i - 1][j];
+            f[i][j] %= mod;
+        }
+    }
+    for (i = 0; i < 20; ++i)
+        num[i][0] = 1;
+    for (i = 1; i < 20; ++i) {
+        for (j = 1; j < 20; ++j) {
+            num[i][j] = num[i][j - 1] * i % mod;
+        }
+    }
+    int T, cas;
+    scanf("%d", &T);
+    for (cas = 1; cas <= T; ++cas) {
+        scanf("%s", s);
+        scanf("%d%d", &n, &k);
+        printf("Case %d: %I64d\n", cas, go(n, k, convert(s)));
+    }
+    return 0;
+}
diff --git a/HDOJ/3371_autoAC.cpp b/HDOJ/3371_autoAC.cpp
new file mode 100644
index 0000000..0e5f562
--- /dev/null
+++ b/HDOJ/3371_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<stdio.h>
+#include<string.h>
+#define inf 99999999
+int flag[500];
+int D[500];
+int map[505][505];
+int n,i,j;
+int prime()
+{
+    int v,k;
+    int ret=0,mi;
+    for(i=1;i<=n;i++){
+        flag[i]=0;
+        D[i]=inf;
+    }D[1]=0;flag[1]=1;v=1;
+    for(k=1;k<n;k++){
+        for(i=1;i<=n;i++)if(!flag[i]){
+            if(map[v][i]<D[i])
+                D[i]=map[v][i];
+        }
+        mi=inf;
+        for(i=1;i<=n;i++)
+            if(!flag[i]&&D[i]<mi)
+                mi=D[v=i];
+            flag[v]=1;
+            ret+=mi;
+    }
+    return ret;
+}
+int num[505];
+int main()
+{
+    int t,m,k,x,i,j;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int a,b,w;
+        scanf("%d%d%d",&n,&m,&k);
+        for(i=1;i<=n;i++)
+        {
+            map[i][i]=0;
+            for(j=i+1;j<=n;j++)
+                map[i][j]=map[j][i]=inf;
+        }
+        for(i=0;i<m;i++)
+        {
+            scanf("%d%d%d",&a,&b,&w);
+            if(w<map[a][b])
+            map[a][b]=map[b][a]=w;
+        }
+        for(i=0;i<k;i++)
+        {
+            scanf("%d",&m);
+            for(j=0;j<m;j++)
+                scanf("%d",&num[j]);
+            for(j=0;j<m;j++)
+                for(x=j+1;x<m;x++)
+                    map[num[j]][num[x]]=map[num[x]][num[j]]=0;
+        }
+        int ans=prime();
+        if(ans>=inf)
+            printf("-1\n");
+        else printf("%d\n",ans);    
+    }
+    return 0;
+}
diff --git a/HDOJ/3372_autoAC.cpp b/HDOJ/3372_autoAC.cpp
new file mode 100644
index 0000000..8db94ed
--- /dev/null
+++ b/HDOJ/3372_autoAC.cpp
@@ -0,0 +1,164 @@
+#include<iostream>
+#include<cmath>
+#include<complex>
+#include<algorithm>
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+#include<cassert>
+#define MAXN 20
+using namespace std;
+typedef complex<double> point;
+const double eps = 1e-8;
+const double pi = acos( -1.0 );
+double operator^( point p1, point p2 ){ return imag( conj( p1 ) * p2 ); }
+int dblcmp( double x ){ return ( x < -eps ? -1 : x > eps ); }
+bool com( point p1, point p2 )
+{
+    return dblcmp( p1.real( ) - p2.real( ) ) < 0 ||
+        dblcmp( p1.real( ) - p2.real( ) ) == 0 && dblcmp( p1.imag( ) - p2.imag( ) ) < 0;
+}
+point p[MAXN],np[MAXN],out[MAXN];
+int N,Ns;
+int num1[MAXN],num2[MAXN];
+int compute( int n, int q )
+{
+    int j,i=0,k=0;
+    for( j=0; j<n; j++ )
+    {
+        if( q & 1 ) num1[i++] = j;
+        else num2[k++] = j; 
+        q >>= 1;
+    }
+    return i;   //杩烘ュ涓
+}
+void convex_hull( int n )
+{
+    int i,k;
+    if( n<=2 )
+    {
+        for( i=0; i<n; i++ )
+            np[i] = p[i];
+        Ns = n;
+        return ;
+    }
+    sort( p, p+n, com );
+    Ns = 0;
+    for( i=0; i<n; i++ )
+    {
+        while( Ns >= 2 && dblcmp( np[Ns-1] - np[Ns-2] ^ p[i] - np[Ns-1] ) <= 0 )
+           Ns--;            
+        np[Ns++] = p[i];
+    }
+    k = Ns;
+    for( i = n-2; i >= 0; i-- )
+    {
+        while( Ns > k && dblcmp( np[Ns-1] - np[Ns-2] ^ p[i] - np[Ns-2] ) <= 0 )
+            Ns--;
+        np[Ns++] = p[i];
+    }
+    Ns--;
+}
+double disptoseg( point p0, point l1, point l2 )
+{
+    point t = p0;
+    t.real( l1.imag( ) - l2.imag( ) );
+    t.imag( l2.real( ) - l1.real( ) );
+    if( dblcmp( ( l1 - p0 ^ t - p0 ) * ( l2 - p0 ^ t - p0 ) ) > 0 )
+        return abs( p0 - l1 ) < abs( p0 - l2 ) ? abs( p0 - l1 ) : abs( p0 - l2 ); 
+    return fabs( p0 - l1 ^ p0 - l2 ) / abs( l1 - l2 );
+}
+bool point_in_polygon( const point &p0, const double &area2 )
+{
+    int i;
+    double area1 = 0.0;
+    if( Ns == 2 )
+        return dblcmp( real( conj( np[0] - p0 ) * ( p0 - np[1] ) ) ) >= 0 ;
+    for( i = 0; i < Ns; i++ )
+    {
+        area1 += fabs( np[i] - p0 ^ np[i+1] - p0 );
+    }
+    if( area1 - fabs( area2 ) > eps ) return false;
+    return true;
+}
+bool touch( int n, const double &d )
+{
+    int i,j;
+    double len;
+    for( i = 0; i < n; i++ )
+    {
+        for( j = 0; j < Ns; j++ )
+        {
+            len = disptoseg( out[i], np[j], np[j+1] );
+            if( len - d < eps )return true;
+        }
+    }
+    return false;
+}
+int main( )
+{ 
+    point pp[MAXN];
+    double d,r,L,carea,maxarea,area,len,x,y,C;
+    int i,j,max,n,t,k,q;
+   scanf("%d",&t);
+    while( t-- )
+    {
+       scanf("%d%lf%lf",&n,&d,&L);
+        for( i=0; i<n; i++ )
+        {
+           scanf("%lf%lf",&x,&y);
+           pp[i].real( x );
+          pp[i].imag( y );
+            p[i] = pp[i];
+        }
+        r = d / 2.0;
+        C = pi * d;
+       carea = pi * r * r ;
+       convex_hull( n );
+        len = 0.0;
+       np[Ns] = np[0];
+        for( j = 0; j < Ns; j++ )
+            len += abs( np[j] - np[j+1] );
+       if( L - ( len + C ) > -eps )
+       {
+            area = 0.0; 
+            for( j = 0; j < Ns; j++ )
+                area += np[j] ^ np[j+1];
+            area = fabs( area ) / 2.0 + len * r - ( n - 1 ) * carea;
+            if( area > 0 ) maxarea = area;
+        }
+        else 
+        {
+            max = ( 1 << n );
+            maxarea = 0.0;
+            for( i = max-1; i > 0; i-- )
+            {
+                k = compute( n, i );
+                q = n - k;
+                for( j = 0; j < k; j++ )
+                    p[j] = pp[ num1[j] ];
+                for( j = 0; j < q; j++ )  
+                    out[j] = pp[ num2[j] ];
+                convex_hull( k );
+                len = 0.0;
+                np[Ns] = np[0];
+                for( j = 0; j < Ns; j++ )
+                    len += abs( np[j] - np[j+1] );
+                if( L - ( len + C ) > -eps )
+                {
+                    area = 0.0; 
+                    for( j = 0; j < Ns; j++ )
+                        area += np[j] ^ np[j+1];
+                    k = 0;
+                    for( j = 0; j < n; j++ )
+                        if( point_in_polygon( pp[j], area ) )
+                            k++;
+                    area = fabs( area ) / 2.0 + len * r - ( k - 1 ) * carea;
+                    if( area > maxarea && !touch( q, d ) ) maxarea = area;
+                }
+            }
+        }
+        printf("%.3lf\n",maxarea);
+    }
+    return 0;
+}
diff --git a/HDOJ/3373_autoAC.cpp b/HDOJ/3373_autoAC.cpp
new file mode 100644
index 0000000..b1f583c
--- /dev/null
+++ b/HDOJ/3373_autoAC.cpp
@@ -0,0 +1,183 @@
+#include <iostream>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define maxn 200010
+#define eps 1e-6
+#define maxaxis 1000000000
+#define ll __int64
+typedef int Type;
+Type bin[maxn];
+int size, tot;
+int B(Type val) {
+    int l = 0;
+    int r = tot-1;
+    while(l <= r) {
+        int m = (l + r) >> 1;
+        if(bin[m] == val)
+            return m;
+        if(val > bin[m]) {
+            l = m + 1;
+        }else
+            r = m - 1;
+    }
+}
+struct point {
+    int x, y;
+    int _ix, _iy;
+}P[maxn];
+struct Tree {
+    int son[4];
+    Type Sum;
+    void clear() {
+        Sum = 0;
+        for(int i = 0; i < 4; i++)
+            son[i] = -1;
+    }
+}T[maxn*6];
+int root, all;
+void Insert(int& root, int x, int y, int lx, int rx, int ly, int ry) {
+    if(x > rx || x < lx || y > ry || y < ly)
+        return ;
+    if(root == -1) {
+        root = all++;
+        T[root].clear();
+    }
+    if(lx == rx && x == lx && y == ly && ly == ry) {
+        T[root].Sum ++;
+        return ;
+    }
+    int midx0 = (lx + rx) >> 1;
+    int midy0 = (ly + ry) >> 1;
+    int midx1 = (lx==rx) ? midx0 : midx0 + 1;
+    int midy1 = (ly==ry) ? midy0 : midy0 + 1;
+    if(lx == rx) {
+        Insert(T[root].son[0], x, y, lx, midx0, ly, midy0);
+        Insert(T[root].son[1], x, y, lx, midx0, midy1, ry);
+    }else if(ly == ry) {
+        Insert(T[root].son[1], x, y, lx, midx0, midy1, ry);
+        Insert(T[root].son[2], x, y, midx1, rx, ly, midy0);
+    }else {
+        Insert(T[root].son[0], x, y, lx, midx0, ly, midy0);
+        Insert(T[root].son[1], x, y, lx, midx0, midy1, ry);
+        Insert(T[root].son[2], x, y, midx1, rx, ly, midy0);
+        Insert(T[root].son[3], x, y, midx1, rx, midy1, ry);
+    }
+    int i;
+    T[root].Sum = 0;
+    for(i = 0; i < 4; i++) {
+        if(T[root].son[i] != -1) {
+            T[root].Sum += T[ T[root].son[i] ].Sum;
+        }
+    }
+}
+void Query(int root, int x0, int x1, int y0, int y1, 
+                      int lx, int rx, int ly, int ry, Type& Num) {
+    if(x0 > rx || x1 < lx || y0 > ry || y1 < ly || root == -1)
+        return ;
+    if(Num > 1)
+        return ;
+    if(x0 <= lx && rx <= x1 && y0 <= ly && ry <= y1) {
+        Num += T[root].Sum;
+        return ;
+    }
+    int midx0 = (lx + rx) >> 1;
+    int midy0 = (ly + ry) >> 1;
+    int midx1 = (lx==rx) ? midx0 : midx0 + 1;
+    int midy1 = (ly==ry) ? midy0 : midy0 + 1;
+    if(lx == rx) {
+        Query(T[root].son[0], x0, x1, y0, y1, lx, midx0, ly, midy0, Num);
+        Query(T[root].son[1], x0, x1, y0, y1, lx, midx0, midy1, ry, Num);
+    }else if(ly == ry) {
+        Query(T[root].son[1], x0, x1, y0, y1, lx, midx0, midy1, ry, Num);
+        Query(T[root].son[2], x0, x1, y0, y1, midx1, rx, ly, midy0, Num);
+    }else {
+        Query(T[root].son[0], x0, x1, y0, y1, lx, midx0, ly, midy0, Num);
+        Query(T[root].son[1], x0, x1, y0, y1, lx, midx0, midy1, ry, Num);
+        Query(T[root].son[2], x0, x1, y0, y1, midx1, rx, ly, midy0, Num);
+        Query(T[root].son[3], x0, x1, y0, y1, midx1, rx, midy1, ry, Num);
+    }
+}
+int LargeThan(int val, int pre) {
+    int l = 0;
+    int r = pre;
+    int ans = l;
+    while(l <= r) {
+        int m = (l + r) >> 1;
+        if(val <= bin[m]) {
+            r = m - 1;
+            ans = m;
+        }else
+            l = m + 1;
+    }
+    return ans;
+}
+int LessThan(int val, int pre) {
+    int l = pre;
+    int r = tot - 1;
+    int ans = r;
+    while(l <= r) {
+        int m = (l + r) >> 1;
+        if(val >= bin[m]) {
+            l = m + 1;
+            ans = m;
+        }else
+            r = m - 1;
+    }
+    return ans;
+}
+int Process(int idx, int dis) {
+    int xleft  = LargeThan( P[idx].x - dis, P[idx]._ix );
+    int yleft  = LargeThan( P[idx].y - dis, P[idx]._iy );
+    int xright =  LessThan( P[idx].x + dis, P[idx]._ix );
+    int yright =  LessThan( P[idx].y + dis, P[idx]._iy );
+    int Num = 0;
+    Query(root, xleft, xright, yleft, yright, 0, tot-1, 0, tot-1, Num);
+    return Num;
+}
+int n;
+int main() {
+    int i;
+    int Max;
+    while(scanf("%d", &n) != EOF) {
+        size = 0;
+        tot = 0;
+        all = 0;
+        Max = 0;
+        for(i = 0; i < n; i++) {
+            scanf("%d %d", &P[i].x, &P[i].y);
+            bin[ size++ ] = P[i].x;
+            bin[ size++ ] = P[i].y;
+            if(P[i].x > Max) Max = P[i].x;
+            if(P[i].y > Max) Max = P[i].y;
+        }
+        sort(bin, bin + size);
+        for(i = 0; i < size; i++) {
+            if(i == 0 || bin[i] != bin[i-1])
+                bin[tot++] = bin[i];
+        }
+        root = -1;
+        for(i = 0; i < n; i++) {
+            P[i]._ix = B(P[i].x);
+            P[i]._iy = B(P[i].y);
+            Insert(root, P[i]._ix, P[i]._iy, 0, tot-1, 0, tot-1);
+        }
+        ll ans = 0;
+        for(i = 0; i < n; i++) {
+            int l = 0;
+            int r = Max;
+            int dis = 0;
+            while(l <= r) {
+                int m = (l + r) >> 1;
+                if(Process(i, m) > 1) {
+                    r = m - 1;
+                    dis = m;
+                }else
+                    l = m + 1;
+            }
+            ans += dis;
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3374_autoAC.cpp b/HDOJ/3374_autoAC.cpp
new file mode 100644
index 0000000..4c371b1
--- /dev/null
+++ b/HDOJ/3374_autoAC.cpp
@@ -0,0 +1,82 @@
+# include<stdio.h>
+# include<string.h>
+# include<stdlib.h>
+# define N  1000005
+char s1[2*N],s2[2*N],s[N],ch1[N],ch2[N];; 
+int next[N];
+void Gnext(char str[])
+{
+    int i,j,len=strlen(str); 
+    next[0]=0;
+    j=0; 
+    for(i=1;i<len;i++)
+    {
+        while(j>0 && str[j]!=str[i]) j=next[j-1];
+        if(str[i]==str[j]) j++;
+        next[i]=j; 
+    } 
+} 
+int KMP(char *a,char *b)
+{
+    int i,j,lena,lenb,count;
+    j=0;
+    lena=strlen(a);
+    lenb=strlen(b);
+    count=0; 
+    for(i=0;i<lenb;i++)
+    {
+        while(j>0 && a[j]!=b[i]) j=next[j-1];
+        if(a[j]==b[i]) j++;
+        if(j==lena) {j=next[j-1];count++;} 
+    }  
+    return count; 
+} 
+int main()
+{
+    int i,j,len1,len2,len,k,minnum,maxnum,count1,count2;
+    while(scanf("%s",s)!=EOF)
+    {
+        len=strlen(s);
+        strcpy(s1,s);
+        strcat(s1,s);
+        strcpy(s2,s1);
+        i=0;j=1;
+        while(i<=len && j<=len)
+        {
+            for(k=0;k<len;k++)
+            if(s1[i+k]!=s2[j+k]) break;
+            if(k==len) break;
+            if(s1[i+k]>s2[j+k]) i=i+k+1;
+            else j=j+k+1;
+            if(i==j) j++;
+        }
+        if(j<i) i=j; 
+        minnum=i+1;
+        for(j=0;j<len;j++)
+        ch1[j]=s1[i+j];
+        ch1[j]=0;
+        i=0;j=1;
+        while(i<=len && j<=len)
+        {
+            for(k=0;k<len;k++)
+            if(s1[i+k]!=s2[j+k]) break;
+            if(k==len) break;
+            if(s1[i+k]<s2[j+k]) i=i+k+1;
+            else j=j+k+1;
+            if(i==j) j++;
+        }
+        if(j<i) j=i;
+        maxnum=i+1;
+        for(j=0;j<len;j++)
+        ch2[j]=s1[i+j];
+        ch2[j]=0;       
+        Gnext(ch1); 
+        count1=KMP(ch1,s1); 
+        if(minnum==1) count1--; 
+        Gnext(ch2);
+        count2=KMP(ch2,s1);
+        if(maxnum==1) count2--; 
+        printf("%d %d %d %d\n",minnum,count1,maxnum,count2); 
+    }
+    return 0;
+}
diff --git a/HDOJ/3375_autoAC.cpp b/HDOJ/3375_autoAC.cpp
new file mode 100644
index 0000000..fd4aee8
--- /dev/null
+++ b/HDOJ/3375_autoAC.cpp
@@ -0,0 +1,143 @@
+#include<stdio.h>
+#include<string.h>
+#include<queue>
+using namespace std;
+#define max 510
+int mo[4][2]={ {-1,0}, {0,1}, {1,0}, {0,-1} };
+struct node{
+    int ge[4];
+    int vis[4];
+    int fuhao;
+}map[max][max];
+struct data{           
+    int x,y,g;  
+}d[max][max][4]; 
+int m,n,color,white;
+void bfs(int x,int y,int r)      
+{
+    queue <data> q;
+    int i,j,k;
+    if(map[x][y].vis[r])
+        return;
+    data t;
+    t.x=x;t.y=y;t.g=r;
+    q.push(t);
+    map[x][y].vis[r]=1;
+    map[x][y].ge[r]=color;
+    while(!q.empty())
+    {
+        data p;
+        p=q.front();
+        q.pop();
+        i=p.x;
+        j=p.y;
+        k=p.g;
+        if(map[i][j].fuhao=='\\')
+        {
+            if(map[i][j].vis[(5-k)%4]==0)              {
+                q.push(d[i][j][(5-k)%4]);
+                map[i][j].vis[(5-k)%4]=1;
+                map[i][j].ge[(5-k)%4]=color;
+            }
+            if(0<=i+mo[k][0]&&i+mo[k][0]<m && 0<=j+mo[k][1]&&j+mo[k][1]<n)
+            {
+                if(map[i+mo[k][0]][j+mo[k][1]].vis[(k+2)%4]==0)
+                {
+                    map[i+mo[k][0]][j+mo[k][1]].vis[(k+2)%4]=1;
+                    map[i+mo[k][0]][j+mo[k][1]].ge[(k+2)%4]=color;
+                    q.push(d[i+mo[k][0]][j+mo[k][1]][(k+2)%4]);
+                }
+            }
+        }
+        else
+        {
+            if(map[i][j].vis[3-k]==0)  
+            {
+                q.push(d[i][j][3-k]);
+                map[i][j].vis[3-k]=1;
+                map[i][j].ge[3-k]=color;
+            }
+            if(0<=i+mo[k][0]&&i+mo[k][0]<m && 0<=j+mo[k][1]&&j+mo[k][1]<n)
+            {
+                if(map[i+mo[k][0]][j+mo[k][1]].vis[(k+2)%4]==0)
+                {
+                    map[i+mo[k][0]][j+mo[k][1]].vis[(k+2)%4]=1;
+                    map[i+mo[k][0]][j+mo[k][1]].ge[(k+2)%4]=color;
+                    q.push(d[i+mo[k][0]][j+mo[k][1]][(k+2)%4]);
+                }
+            }
+        }
+    }
+}
+void init()
+{
+    int i,j,k;
+    for(i=0;i<m;i++)
+    {
+        for(j=0;j<n;j++)
+            for(k=0;k<4;k++)
+            {
+                map[i][j].vis[k]=0;
+                map[i][j].fuhao=0;
+                map[i][j].ge[k]=0;
+            }
+    }
+}
+int main()
+{
+    int i,j,k;
+    while(scanf("%d %d",&n,&m)!=EOF)
+    {
+        getchar();
+        init();
+        color=0;
+        white=0;
+        for(i=0;i<m;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                scanf("%c",&map[i][j].fuhao);
+                for(k=0;k<4;k++)
+                {
+                    d[i][j][k].x=i;
+                    d[i][j][k].y=j;
+                    d[i][j][k].g=k;
+                }
+            }
+            getchar();
+        }
+        for(i=0;i<m;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                for(k=0;k<4;k++)
+                {
+                    if(map[i][j].vis[k]==0)
+                    {
+                        color++;
+                        bfs(i,j,k);
+                    }
+                }
+            }
+        }
+        for(i=0;i<m;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                int flag=0,t=map[i][j].ge[0];
+                for(k=1;k<4;k++)
+                {
+                    if(t!=map[i][j].ge[k])
+                    {
+                        flag=1;
+                        break;
+                    }
+                }
+                if(!flag)
+                    white++;
+            }
+        }
+        printf("%d\n",white);
+    }
+    return 0;
+}
diff --git a/HDOJ/3376_autoAC.cpp b/HDOJ/3376_autoAC.cpp
new file mode 100644
index 0000000..fe99c94
--- /dev/null
+++ b/HDOJ/3376_autoAC.cpp
@@ -0,0 +1,102 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std ;
+const int INF=0xfffffff ;
+struct node{
+    int s,t,cap,cost,nxt ;
+}e[4000005] ;
+int sumflow ;
+int n,m,cnt,head[1000005],vis[1000005],dis[1000005],pre[1000005] ;
+void add(int s,int t,int cap,int cost)
+{
+    e[cnt].s=s ;e[cnt].t=t ;e[cnt].cap=cap ;e[cnt].cost=cost ;e[cnt].nxt=head[s] ;head[s]=cnt++ ;
+    e[cnt].s=t ;e[cnt].t=s ;e[cnt].cap=0 ;e[cnt].cost=-cost ;e[cnt].nxt=head[t] ;head[t]=cnt++ ;
+}
+int spfa(int s,int t,int N)
+{
+    for(int i=0 ;i<=N ;i++)
+        dis[i]=INF ;
+    dis[s]=0 ;
+    memset(vis,0,sizeof(vis)) ;
+    memset(pre,-1,sizeof(pre)) ;
+    vis[s]=1 ;
+    queue <int> q ;
+    q.push(s) ;
+    while(!q.empty())
+    {
+        int u=q.front() ;
+        q.pop() ;
+        vis[u]=0 ;
+        for(int i=head[u] ;i!=-1 ;i=e[i].nxt)
+        {
+            int tt=e[i].t ;
+            if(e[i].cap && dis[tt]>dis[u]+e[i].cost)
+            {
+                dis[tt]=dis[u]+e[i].cost ;
+                pre[tt]=i ;
+                if(!vis[tt])
+                {
+                    vis[tt]=1 ;
+                    q.push(tt) ;
+                }
+            }
+        }
+    }
+    if(dis[t]==INF)return 0 ;
+    return 1 ;
+}
+int MCMF(int s,int t,int N)
+{
+    int flow,minflow,mincost ;
+    mincost=flow=0 ;
+    while(spfa(s,t,N))                                                
+    {
+        minflow=INF ;
+        for(int i=pre[t] ;i!=-1 ;i=pre[e[i].s])
+            minflow=min(minflow,e[i].cap) ;
+        flow+=minflow ;
+        for(int i=pre[t] ;i!=-1 ;i=pre[e[i].s])
+        {
+            e[i].cap-=minflow ;
+            e[i^1].cap+=minflow ;
+        }
+        mincost+=dis[t]*minflow ;
+    }
+    sumflow=flow ;
+    return mincost ;
+}
+int num[605][605],M[605][605] ;
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        cnt=0 ;
+        memset(head,-1,sizeof(head)) ;
+        int S=0 ;
+        int T=2*n*n+1 ;
+        int ct=1 ;
+        for(int i=1 ;i<=n ;i++)
+            for(int j=1 ;j<=n ;j++)
+            {
+                scanf("%d",&M[i][j]) ;
+                num[i][j]=ct++ ;
+            }
+           add(S,1,2,0) ;
+           add(n*n*2,T,2,0) ;
+          for(int i=1 ;i<=n ;i++)
+          {
+              for(int j=1 ;j<=n ;j++)
+              {
+                  if(num[i][j]==1)add(num[i][j],num[i][j]+n*n,2,-M[i][j]) ;
+                  else if(num[i][j]==n*n)add(num[i][j],num[i][j]+n*n,2,-M[i][j]) ;
+                  else add(num[i][j],num[i][j]+n*n,1,-M[i][j]) ;
+                  if(i<n)add(num[i][j]+n*n,num[i][j]+n,1,0) ;
+                  if(j<n)add(num[i][j]+n*n,num[i][j]+1,1,0) ;
+              }
+          }
+          printf("%d\n",-(MCMF(S,T,T+1)+M[1][1]+M[n][n])) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/3377_autoAC.cpp b/HDOJ/3377_autoAC.cpp
new file mode 100644
index 0000000..0776918
--- /dev/null
+++ b/HDOJ/3377_autoAC.cpp
@@ -0,0 +1,190 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<string.h>
+using namespace std;
+const int MAXD=15;
+const int HASH=10007;
+const int STATE=1000010;
+int N,M;
+int maze[MAXD][MAXD];
+int score[MAXD][MAXD];
+int code[MAXD];
+int ch[MAXD];
+struct HASHMAP
+{
+    int head[HASH],state[STATE],next[STATE],size;
+    int dp[STATE];
+    void init()
+    {
+        size=0;
+        memset(head,-1,sizeof(head));
+    }
+    void push(int st,int ans)
+    {
+        int i,h=st%HASH;
+        for(i=head[h];i!=-1;i=next[i])
+           if(state[i]==st)
+           {
+               if(dp[i]<ans)dp[i]=ans;
+               return;
+           }
+        state[size]=st;
+        dp[size]=ans;
+        next[size]=head[h];
+        head[h]=size++;
+    }
+}hm[2];
+void decode(int *code,int m,int st)
+{
+    for(int i=m;i>=0;i--)
+    {
+        code[i]=st&7;
+        st>>=3;
+    }
+}
+int encode(int *code,int m)
+{
+    int cnt=1;
+    memset(ch,-1,sizeof(ch));
+    ch[0]=0;
+    int st=0;
+    for(int i=0;i<=m;i++)
+    {
+        if(ch[code[i]]==-1)ch[code[i]]=cnt++;
+        code[i]=ch[code[i]];
+        st<<=3;
+        st|=code[i];
+    }
+    return st;
+}
+void shift(int *code,int m)
+{
+    for(int i=m;i>0;i--)code[i]=code[i-1];
+    code[0]=0;
+}
+void dpblank(int i,int j,int cur)
+{
+    int k,left,up;
+    for(k=0;k<hm[cur].size;k++)
+    {
+        decode(code,M,hm[cur].state[k]);
+        left=code[j-1];
+        up=code[j];
+        if((i==1&&j==1)||(i==N&&j==M))
+        {
+            if((left&&(!up))||((!left)&&up))
+            {
+                code[j-1]=code[j]=0;
+                if(j==M)shift(code,M);
+                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+score[i][j]);
+            }
+            else if(left==0&&up==0)
+            {
+                if(maze[i][j+1])
+                {
+                    code[j-1]=0;
+                    code[j]=13;
+                    hm[cur^1].push(encode(code,M),hm[cur].dp[k]+score[i][j]);
+                }
+                if(maze[i][j+1])
+                {
+                    code[j-1]=13;
+                    code[j]=0;
+                    if(j==M)shift(code,M);
+                    hm[cur^1].push(encode(code,M),hm[cur].dp[k]+score[i][j]);
+                }
+            }
+            continue;
+        }
+        if(left&&up)
+        {
+            if(left==up)
+            {
+            }
+            else
+            {
+                code[j-1]=code[j]=0;
+                for(int t=0;t<=M;t++)
+                  if(code[t]==up)
+                    code[t]=left;
+                if(j==M)shift(code,M);
+                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+score[i][j]);
+            }
+        }
+        else if((left&&(!up))||((!left)&&up))
+        {
+            int t;
+            if(left)t=left;
+            else t=up;
+            if(maze[i][j+1])
+            {
+                code[j-1]=0;
+                code[j]=t;
+                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+score[i][j]);
+            }
+            if(maze[i+1][j])
+            {
+                code[j]=0;
+                code[j-1]=t;
+                if(j==M)shift(code,M);
+                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+score[i][j]);
+            }
+        }
+        else
+        {
+            if(maze[i][j+1]&&maze[i+1][j])
+            {
+                code[j]=code[j-1]=13;
+                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+score[i][j]);
+            }
+            code[j-1]=code[j]=0;
+            if(j==M)shift(code,M);
+            hm[cur^1].push(encode(code,M),hm[cur].dp[k]);
+        }
+    }
+}
+void init()
+{
+    memset(maze,0,sizeof(maze));
+    for(int i=1;i<=N;i++)
+      for(int j=1;j<=M;j++)
+      {
+          maze[i][j]=1;
+          scanf("%d",&score[i][j]);
+      }
+}
+void solve()
+{
+    int i,j,cur=0;
+    hm[cur].init();
+    hm[cur].push(0,0);
+    for(int i=1;i<=N;i++)
+      for(int j=1;j<=M;j++)
+      {
+          hm[cur^1].init();
+          dpblank(i,j,cur);
+          cur^=1;
+      }
+    int ans=0;
+    for(int i=0;i<hm[cur].size;i++)
+       ans+=hm[cur].dp[i];
+    printf("%d\n",ans);
+}
+int main()
+{
+    int iCase=0;
+    while(scanf("%d%d",&N,&M)!=EOF)
+    {
+        iCase++;
+        printf("Case %d: ",iCase);
+        init();
+        if(N==1&&M==1)
+        {
+            printf("%d\n",score[1][1]);
+            continue;
+        }
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3378_autoAC.cpp b/HDOJ/3378_autoAC.cpp
new file mode 100644
index 0000000..cca0b1c
--- /dev/null
+++ b/HDOJ/3378_autoAC.cpp
@@ -0,0 +1,100 @@
+#include<stdio.h>
+#include<string.h>
+struct cal{
+    int id;
+    int state;
+    int score;
+    int kill_ZG;
+    int kill_ZC;
+    int kill_FZ;
+    int kill_NJ;
+    int killed_by;
+}player[101];
+int num_ZG,num_ZC,num_FZ,num_NJ;
+int n,m,flag;
+int whether_win();
+void calc_score(int num);
+int main()
+{
+    int t,i,a,b,id;
+    char name[3];
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&m);
+        memset(player,0,sizeof(player[0])*n);
+        num_ZG=num_ZC=num_FZ=num_NJ=0;
+        for(i=0;i<n;i++){
+            scanf("%s",name);
+            switch(name[1]){
+            case 'G':player[i].id=1;num_ZG++;break;
+            case 'C':player[i].id=2;num_ZC++;break;
+            case 'Z':player[i].id=3;num_FZ++;break;
+            case 'J':player[i].id=4;num_NJ++;break;
+            }
+        }
+        flag=whether_win();
+        while(m--){
+            scanf("%d%d",&a,&b);
+            if(flag)
+                continue;
+            player[b].state=1;
+            if(!num_FZ&&!num_ZC&&num_NJ==1&&num_ZG==1)
+                player[b].killed_by=player[a].id;
+            id=player[b].id;
+            switch(id){
+            case 1:num_ZG--;player[a].kill_ZG++;break;
+            case 2:num_ZC--;player[a].kill_ZC++;break;
+            case 3:num_FZ--;player[a].kill_FZ++;break;
+            case 4:num_NJ--;player[a].kill_NJ++;break;
+            }
+            flag=whether_win();
+        }
+        calc_score(flag);
+        printf("%d",player[0].score);
+        for(i=1;i<n;i++)
+            printf(" %d",player[i].score);
+        printf("\n");
+    }
+    return 0;
+}
+int whether_win(void)
+{
+    if(!num_FZ&&!num_NJ)
+        return 1;
+    if(!num_ZG){
+        if(num_NJ==1&&!num_FZ&&!num_ZC)
+            return 2;
+        else
+            return 3;
+    }
+    return 0;
+}
+void calc_score(int num)
+{
+    int i;
+    switch(num){
+    case 1:
+        for(i=0;i<n;i++)
+            switch(player[i].id){
+            case 1:player[i].score=4+num_ZC*2+player[i].kill_FZ+player[i].kill_NJ;break;
+            case 2:player[i].score=5+num_ZC+player[i].kill_FZ+player[i].kill_NJ;break;
+            case 4:if(player[i].killed_by==1) player[i].score=n;break;
+        }
+        break;
+    case 2:
+        for(i=0;i<n;i++)
+            switch(player[i].id){
+            case 1:player[i].score=1;break;
+            case 4:if(!player[i].state) player[i].score=4+n*2;break;
+        }
+        break;
+    case 3:
+        for(i=0;i<n;i++)
+            switch(player[i].id){
+            case 3:player[i].score=num_FZ*3+player[i].kill_ZC+player[i].kill_NJ+player[i].kill_ZG*2;break;
+            case 4:if(!player[i].state) player[i].score=1;
+        }
+        break;
+    }
+    return;
+}
diff --git a/HDOJ/3379_autoAC.cpp b/HDOJ/3379_autoAC.cpp
new file mode 100644
index 0000000..952571c
--- /dev/null
+++ b/HDOJ/3379_autoAC.cpp
@@ -0,0 +1,87 @@
+#include<iostream>
+#include<string.h>
+using namespace std;
+const int maxn=1005;
+int map[maxn][maxn],n,cnt[maxn][maxn];
+char name[maxn][100];
+int match_name(char str[])
+{
+   for(int i=1;i<n;i++)
+       if(strcmp(str,name[i])==0)
+           return i;
+    strcpy(name[n],str);
+    return n++;
+}
+void str_convert(char str[])
+{
+    int i,j,first_node,k;
+    bool flag=0;
+    char str1[100];
+    for(i=0;i<strlen(str);)
+    {
+        for(j=0;str[i]!=' '&&str[i]!='\0';i++,j++)
+            str1[j]=str[i];
+        str1[j]='\0';
+        i++;
+        k=match_name(str1);
+        if(flag==0)
+        {
+            first_node=k;
+            flag=1;
+        }
+        else if(map[first_node][k]==0)
+            {
+              map[first_node][k]=map[k][first_node]=1;
+              cnt[first_node][k]=cnt[k][first_node]=1;
+            }
+    }
+}
+void floyd() 
+{
+    int i,j,k;
+    for(k=1;k<n;k++)
+        for(i=1;i<n;i++)
+            for(j=1;j<n;j++)
+              if(map[i][k] && map[k][j])
+                if(map[i][j]==0)
+                {
+                      map[i][j]=map[i][k]+map[k][j];
+                      cnt[i][j]=cnt[i][k]*cnt[k][j];
+                }
+                else if(map[i][k]+map[k][j]<map[i][j])
+                {
+                    map[i][j]=map[i][k]+map[k][j];
+                    cnt[i][j]=cnt[i][k]*cnt[k][j];
+                }
+                else if(map[i][k]+map[k][j]==map[i][j])
+                    cnt[i][j] += cnt[i][k]*cnt[k][j];
+}
+int main()
+{
+    int i,j;
+    char str[100],str1[100],str2[100];
+    gets(str);
+    while(gets(str))
+    {
+      n=1;
+      memset(map,0,sizeof(map));
+      memset(cnt,0,sizeof(cnt));
+      str_convert(str);
+      while(gets(str))
+      {
+        if(strcmp(str,"GRAPH END")==0) break;
+        str_convert(str);
+      }
+      for(i=1;i<n;i++)
+         map[i][i]=1;
+      floyd();
+       while(cin>>str1>>str2)
+       {
+        if(strcmp(str1,"GRAPH")==0 && strcmp(str2,"BEGIN")==0) break;
+        i=match_name(str1);
+        j=match_name(str2);
+        cout<<str1<<" "<<str2<<" "<<cnt[i][j]<<endl;
+       }
+    }
+    return 0;
+}
diff --git a/HDOJ/3387_autoAC.cpp b/HDOJ/3387_autoAC.cpp
new file mode 100644
index 0000000..c0da485
--- /dev/null
+++ b/HDOJ/3387_autoAC.cpp
@@ -0,0 +1,177 @@
+#include <stdio.h>
+#include <string.h>
+#define OPER 1
+#define NUM 2
+#define INF 0x3fffffff
+#define null x
+#define END -1
+#define MUTI 3
+int n,T;
+char oper_now,oper_last;
+char in[1000];
+__int64 ans,temp,num_equal;
+int num,l;
+int isnum(char a)
+{
+    if(a>='0'&& a<='9')
+        return 1;
+    else return 0;
+}
+int findp()
+{
+    if(num==l)return END;
+    int i,j;
+    int t=num;
+    if(in[t]=='='&& in[t+1]=='=')
+    {
+        num_equal  =0;
+        while(in[num]=='=')
+        {
+            num_equal++;
+            num++;
+        }
+        return MUTI;
+    }
+    if(!isnum(in[num]))
+    {
+        num++;
+        return OPER;
+    }
+    __int64 tt=0;
+    int jj=10;
+    int ttp;
+    while(isnum(in[num]))
+    {
+        if((tt*jj+ (in[num]-'0'))>99999999|| (tt*jj+ (in[num]-'0'))<-99999999)
+        {
+            num++;
+            continue;
+        }
+        tt= tt*jj+ (in[num]-'0');
+        num++;
+    }
+    temp= tt;
+    return NUM;
+}
+__int64 cal_op()
+{
+    __int64 aaa;
+    switch(oper_now)
+    {
+        case'-':return ans-temp;
+        case'+':return temp+ans;
+        case'*':aaa= (__int64)ans*temp;if(aaa>99999999|| aaa<-99999999)return INF;else return ans*temp;
+        case'/':if(temp!=0)return ans/temp;else return INF;
+    }
+}
+void cal()
+{
+    if(in[num-1]!='=')
+    {
+        if(temp!=INF&& oper_now!=NULL)
+        {
+            ans= cal_op();
+            temp= INF;
+        }
+        else if(oper_now==NULL&& temp!=INF)
+        {
+             ans= temp;
+             temp= INF;
+        }
+        oper_last= oper_now;
+        oper_now= in[num-1];
+    }
+    else
+    {
+        if(oper_now!=NULL)
+        if(temp!=INF)
+        {
+            ans= cal_op();
+            temp= INF;
+        }
+        else
+        {
+            temp= ans;
+            ans= cal_op();
+            temp= INF;
+        }
+        oper_now= NULL;
+    }
+}
+int main()
+{
+    int i,j,t;
+    int op,pp;
+    scanf("%d",&T);
+    getchar();
+    for(pp=0; pp<T; pp++)
+    {
+        num=0;
+        ans=0;
+        temp= INF;
+        oper_now= NULL;
+        oper_last= NULL;
+        gets(in);
+        l= strlen(in);
+        int ttt;
+        int error=0;
+        while(op= findp(),op!=END&& !error)
+        {
+            if(ans>99999999|| ans<-99999999)
+            {
+                error=1;
+                goto end;
+            }
+            if(op==OPER)
+            {
+                cal();
+            }
+            else if(op==MUTI)
+            {
+                    if(oper_now!=NULL)
+                    {
+                          if(temp!=INF)
+                          {
+                              for(i=0;i<num_equal;i++)
+                              {
+                                   ans= cal_op();
+                                   if(ans>99999999|| ans<-99999999)
+                                   {
+                                       error=1;
+                                       goto end;
+                                   }
+                              }
+                              temp= INF;
+                          }
+                          else
+                          {
+                              ttt= ans;
+                              for(i=0;i<num_equal;i++)
+                              {
+                                   temp= ttt;
+                                   ans= cal_op();
+                                   if(ans>99999999|| ans<-99999999)
+                                   {
+                                       error=1;
+                                       goto end;
+                                   }
+                              }
+                              temp= INF;
+                          }
+                    }
+                    oper_now= NULL;
+            }
+            if(ans>99999999|| ans<-99999999)
+            {
+                error=1;
+                goto end;
+            }
+        }
+end:;
+        printf("Case %d: ",pp+1);
+        if(!error)
+        printf("%I64d\n",temp==INF?ans:temp);
+        else printf("ERROR\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3388_autoAC.cpp b/HDOJ/3388_autoAC.cpp
new file mode 100644
index 0000000..36fd815
--- /dev/null
+++ b/HDOJ/3388_autoAC.cpp
@@ -0,0 +1,112 @@
+#include <iostream>
+#include <string.h>
+#include <algorithm>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+const int N=1000005;
+const LL INF=(LL)1<<62;
+bool prime[N];
+LL p[N];
+LL fac[N];
+LL k,cnt,num,ans,n,m,K;
+void isprime()
+{
+    k=0;
+    int i,j;
+    memset(prime,true,sizeof(prime));
+    for(i=2; i<N; i++)
+    {
+        if(prime[i])
+        {
+            p[k++]=i;
+            for(j=i+i; j<N; j+=i)
+            {
+                prime[j]=false;
+            }
+        }
+    }
+}
+void Solve(LL m,LL n)
+{
+    cnt=0;
+    LL i;
+    for(i=0; p[i]*p[i]<=n; i++)
+    {
+        if(n%p[i]==0)
+        {
+            fac[cnt++]=p[i];
+            while(n%p[i]==0) n/=p[i];
+        }
+    }
+    if(n>1)
+        fac[cnt++]=n;
+    for(i=0; p[i]*p[i]<=m; i++)
+    {
+        if(m%p[i]==0)
+        {
+            fac[cnt++]=p[i];
+            while(m%p[i]==0) m/=p[i];
+        }
+    }
+    if(m>1)
+        fac[cnt++]=m;
+}
+void dfs(LL k,LL t,LL s,LL n)
+{
+    if(k==num)
+    {
+        if(t&1) ans-=n/s;
+        else    ans+=n/s;
+        return;
+    }
+    dfs(k+1,t,s,n);
+    dfs(k+1,t+1,s*fac[k],n);
+}
+LL Binary()
+{
+    LL l=1,r=INF,mid,ret;
+    while(l<=r)
+    {
+        mid=(l+r)/2;
+        ans=0;
+        dfs(0,0,1,mid);
+        if(ans>=K)
+        {
+            ret=mid;
+            r=mid-1;
+        }
+        else
+            l=mid+1;
+    }
+    return ret;
+}
+int main()
+{
+    isprime();
+    LL t,ct,tt=1;
+    scanf("%I64d",&t);
+    while(t--)
+    {
+        scanf("%I64d%I64d%I64d",&m,&n,&K);
+        printf("Case %d: ",tt++);
+        if(n==1&&m==1)
+        {
+            printf("%I64d\n",k);
+            continue;
+        }
+        Solve(m,n);
+        sort(fac,fac+cnt);
+        num=1;
+        for(LL i=1; i<cnt; i++)
+        {
+            if(fac[i]!=fac[i-1])
+            {
+                fac[num++]=fac[i];
+            }
+        }
+        ct=num;
+        printf("%I64d\n",Binary());
+    }
+    return 0;
+}
diff --git a/HDOJ/3389_autoAC.cpp b/HDOJ/3389_autoAC.cpp
new file mode 100644
index 0000000..4eb2bf6
--- /dev/null
+++ b/HDOJ/3389_autoAC.cpp
@@ -0,0 +1,26 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+int main()
+{
+    int T,tt=1;
+    int n;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        int ans = 0;
+        for(int i=1;i<=n;i++)
+        {
+            int x;
+            scanf("%d",&x);
+            if(i%6==0 || i%6==2 || i%6==5)
+                ans ^= x;
+        }
+        printf("Case %d: ",tt++);
+        if(ans) puts("Alice");
+        else puts("Bob");
+    }
+    return 0;
+}
diff --git a/HDOJ/3390_autoAC.cpp b/HDOJ/3390_autoAC.cpp
new file mode 100644
index 0000000..7f9bbdd
--- /dev/null
+++ b/HDOJ/3390_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+#define mod 100003
+typedef long long LL;
+LL a[106][3],b[106][3],c[106][3];
+int main()
+{
+    memset(a,0,sizeof(a));
+    memset(b,0,sizeof(b));
+    memset(c,0,sizeof(c));
+    c[0][0]=1;
+    for (int i=1;i<=100;i++)
+    {
+        a[i][0]=(a[i-1][0]*90%mod+c[i-1][0]*44%mod+a[i-1][1]*80%mod+c[i-1][1]*41%mod)%mod;
+        a[i][1]=(a[i-1][0]*10%mod+c[i-1][0]+a[i-1][1]*10%mod+c[i-1][1])%mod;
+        a[i][2]=(a[i-1][1]*10%mod+c[i-1][1]*3%mod+a[i-1][2]*100%mod+c[i-1][2]*45%mod)%mod;
+        b[i][0]=(b[i-1][0]*900%mod+a[i-1][0]*880+c[i-1][0]*284+b[i-1][1]*800%mod+
+            a[i-1][1]*820%mod+c[i-1][1]*275%mod)%mod;
+        b[i][1]=(b[i-1][0]*100%mod+a[i-1][0]*20%mod+c[i-1][0]+b[i-1][1]*100%mod
+            +a[i-1][1]*20%mod+c[i-1][1])%mod;
+        b[i][2]=(b[i-1][1]*100%mod+a[i-1][1]*60%mod+c[i-1][1]*9%mod+
+            b[i-1][2]*1000%mod+a[i-1][2]*900%mod+c[i-1][2]*285%mod)%mod;
+        c[i][0]=(c[i-1][0]*9%mod+c[i-1][1]*8%mod)%mod;
+        c[i][1]=(c[i-1][0]+c[i-1][1])%mod;
+        c[i][2]=(c[i-1][1]+c[i-1][2]*10%mod)%mod;
+    }
+    int test;
+    scanf("%d",&test);
+    for (int ii=1;ii<=test;ii++)
+    {
+        int n;
+        scanf("%d",&n);
+        printf("Case %d: %I64d\n",ii,b[n][2]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3392_autoAC.cpp b/HDOJ/3392_autoAC.cpp
new file mode 100644
index 0000000..1ff7492
--- /dev/null
+++ b/HDOJ/3392_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <cstdio>
+#include <algorithm>
+#include <cmath>
+const int maxn=11000;
+using namespace std;
+double a[maxn],b[maxn];
+double dp[2][maxn];
+int main()
+{
+ int n,m;
+ while(cin>>n>>m)
+ {
+        if(n==0&&m==0)break;
+        for(int i=1;i<=n;i++)scanf("%lf",&a[i]);
+        for(int i=1;i<=m;i++)scanf("%lf",&b[i]);
+        double *A=a,*B=b;
+        if(n>m){swap(n,m);swap(A,B);}
+        sort(A+1,A+1+n);
+        sort(B+1,B+1+m);
+        memset(dp,0,sizeof(dp));
+        for(int i=1;i<=n;i++)
+         for(int j=i;j<=i+m-n;j++)
+         {
+          if(i==j)
+          {
+              dp[i&1][j]=dp[(i-1)&1][j-1]+fabs(A[i]-B[j]);
+          }
+          else
+          {
+              dp[i&1][j]=min(dp[(i-1)&1][j-1]+fabs(A[i]-B[j]),dp[i&1][j-1]);
+          }
+         }
+       printf("%.6lf\n",dp[n&1][m]);
+ }
+ return 0;
+}
diff --git a/HDOJ/3394_autoAC.cpp b/HDOJ/3394_autoAC.cpp
new file mode 100644
index 0000000..dbffe55
--- /dev/null
+++ b/HDOJ/3394_autoAC.cpp
@@ -0,0 +1,84 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <stack>
+using namespace std;
+const int N=10006;
+struct Edge
+{
+    int st, en;
+    Edge() {}
+    Edge(int a, int b)
+    {
+        st=a, en=b;
+    }
+};
+stack <Edge> palm;
+vector <int> arc[N];
+vector <Edge> block[N];
+int dfn[N], low[N];
+bool vs[N];
+int n, m, ind, T, sum1, sum2;
+void tarjan(int u, int pre)
+{
+    dfn[u]=low[u]=T++;
+    int len=(int)arc[u].size();
+    for(int i=0; i<len; i++)
+    {
+        int v=arc[u][i];
+        if(dfn[v]==-1)
+        {
+            palm.push(Edge(u, v));
+            tarjan(v, u);
+            if(low[u]>low[v]) low[u]=low[v];
+            if(dfn[u]<=low[v])
+            {
+                for(Edge temp; !palm.empty(); )
+                {
+                    temp=palm.top();
+                    if(dfn[temp.st]<dfn[v]) break;
+                    block[ind].push_back(temp), palm.pop();
+                }
+                block[ind++].push_back(Edge(u, v));
+                palm.pop();
+                if(dfn[u]<low[v]) sum1++;
+            }
+        }
+        else if(v!=pre && dfn[v]<dfn[u])
+        {
+            palm.push(Edge(u, v));
+            if(low[u]>dfn[v]) low[u]=dfn[v];
+        }
+    }
+}
+int main()
+{
+    while(scanf("%d%d", &n, &m), n!=0 || m!=0)
+    {
+        for(int i=0; i<n; i++) arc[i].clear();
+        for(int i=0, a, b; i<m; i++)
+        {
+            scanf("%d%d", &a, &b);
+            arc[a].push_back(b);
+            arc[b].push_back(a);
+        }
+        for(int i=0; i<n; i++) dfn[i]=-1, block[i].clear();
+        while(!palm.empty()) palm.pop();
+        ind=T=sum1=sum2=0;
+        for(int i=0; i<n; i++) if(dfn[i]==-1) tarjan(i, -1);
+        for(int i=0; i<ind; i++)
+        {
+            for(int j=0; j<n; j++) vs[j]=0;
+            int len=(int)block[i].size(), tot=0;
+            for(int j=0; j<len; j++)
+            {
+                if(!vs[block[i][j].st]) vs[block[i][j].st]=1, tot++;
+                if(!vs[block[i][j].en]) vs[block[i][j].en]=1, tot++;
+            }
+            if(len>tot) sum2+=len;
+        }
+        printf("%d %d\n", sum1, sum2);
+    }
+    return 0;
+}
diff --git a/HDOJ/3395_autoAC.cpp b/HDOJ/3395_autoAC.cpp
new file mode 100644
index 0000000..31b10e9
--- /dev/null
+++ b/HDOJ/3395_autoAC.cpp
@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+#define clr(x) memset(x, 0, sizeof(x))
+#define M 210
+const int INF = 0x1f1f1f1f;
+int v;
+int link[M], lx[M], ly[M];
+int visx[M], visy[M], G[M][M];
+int slack;
+int DFS(int x)
+{
+    visx[x] = 1;
+    for (int y = 1; y <= v; ++y)
+    {
+        if (visy[y])
+            continue;
+        int t = lx[x] + ly[y] - G[x][y];
+        if (t == 0)
+        {
+            visy[y] = 1;
+            if (link[y] == -1||DFS(link[y]))
+            {
+                link[y] = x;
+                return 1;
+            }
+        }
+        else if (slack > t)
+            slack = t;
+    }
+    return 0;
+}
+int KM()
+{
+    int i,j;
+    memset (link,-1,sizeof(link));
+    memset (ly,0,sizeof(ly));
+    for (i = 1;i <= v; ++i)
+        for (j = 1,lx[i] = -INF;j <= v; ++j)
+            if (G[i][j] > lx[i])
+                lx[i] = G[i][j];
+    for (int x = 1;x <= v; ++x)
+    {
+        memset(visx,0,sizeof(visx));
+        memset(visy,0,sizeof(visy));
+        while (1)
+        {
+            slack=INF;
+            if (DFS(x))
+                break;
+            for(i = 1; i <= v; i++)
+            {
+                if(visx[i]) {  lx[i]-=slack;  visx[i]=0;  }
+                if(visy[i]) {  ly[i]+=slack;  visy[i]=0;  }
+            }
+        }
+    }
+    int res = 0;
+    for (i = 1;i <= v; ++i)
+            res += G[link[i]][i];
+    return res;
+}
+int main()
+{
+    int i, j, k;
+    int n, val[110];
+    char w[110];
+    while(scanf("%d", &n) != EOF)
+    {
+        if(n == 0) break;
+        clr(G);
+        v = n;
+        for(i = 1; i <= n; ++i)
+        scanf("%d", &val[i]);
+        for(i = 1; i <= n; ++i) {
+            scanf("%s", w+1);
+            for(j = 1; j <= n; ++j)
+                if(w[j]-'0') G[i][j] = val[i]^val[j];
+        }
+        int ans = KM();
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3397_autoAC.cpp b/HDOJ/3397_autoAC.cpp
new file mode 100644
index 0000000..4a67249
--- /dev/null
+++ b/HDOJ/3397_autoAC.cpp
@@ -0,0 +1,132 @@
+#include<iostream>
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+#define lson u<<1
+#define rson u<<1|1
+#define MAXN 100010
+int dat[MAXN];
+struct Node {
+    int lef,rig;
+    int lsum,rsum,msum;
+    int lz,rz,mz;
+    int sum;
+    int COVER,XOR;
+}T[MAXN<<2];
+void makeXOR(int u){
+    swap(T[u].lsum,T[u].lz);
+    swap(T[u].rsum,T[u].rz);
+    swap(T[u].msum,T[u].mz);
+    T[u].sum=T[u].rig-T[u].lef+1-T[u].sum;
+}
+void PushUp(int u){
+    if(T[u].lef==T[u].rig)return;
+    int len=T[u].rig-T[u].lef+1;
+    T[u].lsum=T[lson].lsum;
+    T[u].rsum=T[rson].rsum;
+    if(T[u].lsum==(len+1)>>1)T[u].lsum+=T[rson].lsum;
+    if(T[u].rsum==len>>1)T[u].rsum+=T[lson].rsum;
+    T[u].msum=max(T[lson].msum,T[rson].msum);
+    T[u].msum=max(T[u].msum,T[lson].rsum+T[rson].lsum);
+    T[u].lz=T[lson].lz;
+    T[u].rz=T[rson].rz;
+    if(T[u].lz==(len+1)>>1)T[u].lz+=T[rson].lz;
+    if(T[u].rz==len>>1)T[u].rz+=T[lson].rz;
+    T[u].mz=max(T[lson].mz,T[rson].mz);
+    T[u].mz=max(T[u].mz,T[lson].rz+T[rson].lz);
+    T[u].sum=T[lson].sum+T[rson].sum;
+}
+void PushDown(int u){
+    if(T[u].lef==T[u].rig)return;
+    if(T[u].COVER!=-1){
+        int len=T[u].rig-T[u].lef+1;
+        T[lson].COVER=T[rson].COVER=T[u].COVER;
+        T[lson].XOR=T[rson].XOR=0;
+        T[lson].lsum=T[lson].rsum=T[lson].msum=T[u].COVER?(len+1)>>1:0;
+        T[lson].lz=T[lson].rz=T[lson].mz=T[u].COVER?0:(len+1)>>1;
+        T[lson].sum=T[u].COVER?(len+1)>>1:0;
+        T[rson].lsum=T[rson].rsum=T[rson].msum=T[u].COVER?len>>1:0;
+        T[rson].lz=T[rson].rz=T[rson].mz=T[u].COVER?0:len>>1;
+        T[rson].sum=T[u].COVER?len>>1:0;
+        T[u].COVER=-1;
+    }
+    if(T[u].XOR){
+        T[u].XOR=0;
+        T[lson].XOR^=1;
+        T[rson].XOR^=1;
+        makeXOR(lson);
+        makeXOR(rson);
+    }
+}
+void Build(int u,int l,int r){
+    T[u].lef=l;
+    T[u].rig=r;
+    T[u].COVER=-1;
+    T[u].XOR=0;
+    if(l==r){
+        T[u].lsum=T[u].rsum=T[u].msum=(dat[l]==1);
+        T[u].lz=T[u].rz=T[u].mz=(dat[l]==0);
+        T[u].sum=dat[l];
+        T[u].COVER=dat[l];
+        return;
+    }
+    int mid=(l+r)>>1;
+    Build(lson,l,mid);
+    Build(rson,mid+1,r);
+    PushUp(u);
+}
+void Update(int u,int l,int r,int op){
+    PushDown(u);
+    if(l<=T[u].lef&&T[u].rig<=r){
+        if(op<2){
+            int len=T[u].rig-T[u].lef+1;
+            T[u].COVER=op;
+            T[u].lsum=T[u].rsum=T[u].msum=op?len:0;
+            T[u].lz=T[u].rz=T[u].mz=op?0:len;
+            T[u].sum=op?len:0;
+        }
+        else {
+            T[u].XOR=1;
+            makeXOR(u);
+        }
+    }
+    else {
+        if(l<=T[lson].rig)Update(lson,l,r,op);
+        if(r>=T[rson].lef)Update(rson,l,r,op);
+        PushUp(u);
+    }
+}
+int Query(int u,int l,int r,int op){
+    PushDown(u);
+    if(l<=T[u].lef&&T[u].rig<=r){
+        if(op==3)return T[u].sum;
+        else return T[u].msum;
+    }
+    else {
+        if(r<=T[lson].rig)return Query(lson,l,r,op);
+        if(l>=T[rson].lef)return Query(rson,l,r,op);
+        if(op==3) return Query(lson,l,T[lson].rig,op)+Query(rson,T[rson].lef,r,op);
+        int ret=min(T[lson].rsum,T[lson].rig-l+1)+min(T[rson].lsum,r-T[rson].lef+1);
+        int ans=max(Query(lson,l,T[lson].rig,op),Query(rson,T[rson].lef,r,op));
+        return max(ans,ret);
+    }
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        int n,m;
+        int cmd,a,b;
+        scanf("%d%d",&n,&m);
+        for(int i=1;i<=n;i++)scanf("%d",dat+i);
+        Build(1,1,n);
+        while(m--){
+            scanf("%d%d%d",&cmd,&a,&b);
+            a++,b++;
+            if(cmd<3)Update(1,a,b,cmd);
+            else printf("%d\n",Query(1,a,b,cmd));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3398_autoAC.cpp b/HDOJ/3398_autoAC.cpp
new file mode 100644
index 0000000..3eb0e4a
--- /dev/null
+++ b/HDOJ/3398_autoAC.cpp
@@ -0,0 +1,111 @@
+#include <stdio.h>
+#define MOD 20100501
+typedef struct
+{
+    __int64 val,num;
+}Pri;
+__int64 prime[2000005];
+Pri a[200000];
+__int64 up;
+void Isprime()
+{
+    __int64 k,i,j;
+    up=0;
+    for (i=0;i<2000003;i++)
+    {
+        prime[i]=true;
+    }
+    for (i=2;i<2000003;i++)
+    {
+        if (prime[i]==false) continue;
+        k=i;
+        while(i*k<=2000000)
+        {
+            prime[i*k]=false;
+            k++;
+        }
+        a[up++].val=i;
+    }
+}
+void Cplus(__int64 t)
+{
+    __int64 i,s;
+    __int64 k;
+    for (i=0;i<up;i++)
+    {
+        s=0;
+        k=a[i].val;
+        while(t>=k)
+        {
+            s=s+t/k;
+            k=k*a[i].val;
+        }
+        a[i].num=a[i].num+s;
+    } 
+}
+void Cminus(__int64 t)
+{
+    __int64 i,s;
+    __int64 k;
+    for (i=0;i<up;i++)
+    {
+        s=0;
+        k=a[i].val;
+        while(t>=k)
+        {
+            s=s+t/k;
+            k=k*a[i].val;
+        }
+        a[i].num=a[i].num-s;
+    }    
+}
+__int64 Count(__int64 n,__int64 p)
+{
+    __int64 i,j,s;
+    s=1;
+    while(n!=0)
+    {
+        if (n%2==1)
+        {
+            s=s*p%MOD;
+        }
+        p=p*p%MOD;
+        n=n/2;
+    }
+    return s;
+}
+int main()
+{
+    __int64 i,t,j,n,T,m;
+    __int64 ans;
+    scanf("%I64d",&T);
+    Isprime();
+    while(T--)
+    {
+        scanf("%I64d%I64d",&n,&m);
+        for (i=0;i<up;i++)
+        {
+            a[i].num=0;
+        }
+        Cplus(m+n);
+        Cminus(m);
+        Cminus(n+1);
+        t=n+1-m;
+        for (i=0;i<up;i++)
+        {
+            while(t%a[i].val==0)
+            {
+                a[i].num++;
+                t=t/a[i].val;
+            }
+            if (t==1) break;
+        }
+        ans=1;
+        for (i=0;i<up;i++)
+        {
+            ans=ans*Count(a[i].num,a[i].val)%MOD;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3399_autoAC.cpp b/HDOJ/3399_autoAC.cpp
new file mode 100644
index 0000000..a0b3ad0
--- /dev/null
+++ b/HDOJ/3399_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <iostream>
+#include <string.h> 
+using namespace std;
+const int maxn=1100000,maxm=4*maxn;
+struct Edge
+{
+int y;
+int ne;
+} e[maxm];
+int st[maxn],ee;
+void addedge(int x,int y)
+{
+e[ee].y=y;e[ee].ne=st[x];st[x]=ee++;
+e[ee].y=x;e[ee].ne=st[y];st[y]=ee++;
+}
+int c[maxn];
+int numn[maxn],numm[maxn],lost[maxn];
+int s[maxn],head,tail;
+void bfs(int k,int col)
+{
+int i;
+head=0;tail=1;s[0]=k;
+c[k]=col;
+while (head<tail)
+{
+   k=s[head++];
+   for (i=st[k];i!=-1;i=e[i].ne) 
+   {
+    numm[col]++;
+    if (c[e[i].y]==0)
+    {
+     c[e[i].y]=col;
+     s[tail++]=e[i].y;
+    }
+   }
+}
+numn[col]=tail;
+}
+int main()
+{
+int cass;
+for (scanf("%d",&cass);cass--;)
+{
+   int n;
+   scanf("%d",&n);
+   int i,x,y,z1,z2;
+   memset(st,-1,sizeof(st));
+   ee=0;
+   for (i=0;i<n;i++) 
+   {
+    scanf("%d.%d %d.%d",&z1,&x,&z2,&y);
+    x=z1*1000000+x-1500000;
+    y=z2*1000000+y-1500000;
+    addedge(x,y);
+   }
+   memset(c,0,sizeof(c));
+   memset(numn,0,sizeof(numn));
+   memset(numm,0,sizeof(numm));
+   memset(lost,-1,sizeof(lost));
+   int col=0;
+   for (i=0;i<maxn;i++) if (c[i]==0)
+   {
+    col++;
+    bfs(i,col);
+   }
+   for (i=1;i<=col;i++) numm[i]/=2;
+   for (i=0;i<maxn;i++) if (numn[c[i]]>numm[c[i]]) if (lost[c[i]]<i) lost[c[i]]=i;
+   for (i=0;i<maxn;i++) 
+    if (lost[c[i]]==i) break;
+   printf("%d\n",i);
+}
+return 0;
+}