diff --git a/HDOJ/3802_autoAC.cpp b/HDOJ/3802_autoAC.cpp
new file mode 100644
index 0000000..be9018a
--- /dev/null
+++ b/HDOJ/3802_autoAC.cpp
@@ -0,0 +1,128 @@
+#include <cstdio>  
+#include <iostream>  
+#include <cmath>  
+#include <algorithm>  
+#include <cstring>  
+using namespace std;  
+typedef __int64 LL;  
+LL mod;  
+struct Matrix  
+{  
+    LL m[3][3];  
+}E,D;  
+LL a,b,n;  
+void init()  
+{  
+    for(int i=1;i<=2;i++)  
+        for(int j=1;j<=2;j++)  
+            E.m[i][j]=(i==j);  
+    D.m[1][1]=1;  
+    D.m[1][2]=1;  
+    D.m[2][1]=1;  
+    D.m[2][2]=0;  
+}  
+Matrix Multi(Matrix A,Matrix B)  
+{  
+    Matrix ans;  
+    for(int i=1;i<=2;i++)  
+        for(int j=1;j<=2;j++)  
+        {  
+            ans.m[i][j]=0;  
+            for(int k=1;k<=2;k++)  
+                ans.m[i][j]=(ans.m[i][j]+A.m[i][k]*B.m[k][j])%mod;  
+        }  
+    return ans;  
+}  
+Matrix Pow(Matrix A,LL k)  
+{  
+    Matrix ans=E;  
+    while(k)  
+    {  
+        if(k&1)  
+        {  
+            k--;  
+            ans=Multi(ans,A);  
+        }  
+        else  
+        {  
+            k/=2;  
+            A=Multi(A,A);  
+        }  
+    }  
+    return ans;  
+}  
+LL Fib(LL n)  
+{  
+    if(n==0)  
+        return 1;  
+    Matrix ans=Pow(D,n);  
+    return ans.m[1][1]%mod;  
+}  
+void Print(Matrix A)  
+{  
+    for(int i=1;i<=2;i++)  
+    {  
+        for(int j=1;j<=2;j++)  
+            cout<<A.m[i][j]<<" ";  
+        cout<<endl;  
+    }  
+}  
+LL get(Matrix A,Matrix B,LL fib)  
+{  
+    Matrix ans=Pow(A,fib-1);  
+    ans=Multi(ans,B);  
+    return ans.m[1][1];  
+}  
+LL Pow(LL a,LL b)  
+{  
+    LL ans=1;  
+    while(b)  
+    {  
+        if(b&1)  
+        {  
+            b--;  
+            ans=(ans*a)%mod;  
+        }  
+        else  
+        {  
+            b/=2;  
+            a=(a*a)%mod;  
+        }  
+    }  
+    return ans;  
+}  
+int main()  
+{  
+    init();  
+    int t;  
+    cin>>t;  
+    init();  
+    while(t--)  
+    {  
+        cin>>a>>b>>n>>mod;  
+        LL aa=(1+Pow(a,(mod-1)/2))%mod;  
+        LL bb=(1+Pow(b,(mod-1)/2))%mod;  
+        if(aa==0||bb==0)  
+        {  
+            cout<<0<<endl;  
+            continue;  
+        }  
+        Matrix T,cnt;  
+        T.m[1][1]=2*(a+b)%mod;  
+        T.m[1][2]=-(a-b)*(a-b)%mod;  
+        T.m[2][1]=1;  
+        T.m[2][2]=0;  
+        cnt.m[1][1]=2*(a+b)%mod;  
+        cnt.m[2][1]=2;  
+        LL tmp;  
+        mod--;  
+        tmp=Fib(n);  
+        mod++;  
+        LL ans=get(T,cnt,tmp);  
+        ans=4*ans%mod;  
+        if(ans<0)  
+            ans+=mod;  
+        cout<<ans<<endl;  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/3803_autoAC.cpp b/HDOJ/3803_autoAC.cpp
new file mode 100644
index 0000000..ce5e70f
--- /dev/null
+++ b/HDOJ/3803_autoAC.cpp
@@ -0,0 +1,211 @@
+#include<stdio.h>
+#include<iostream>
+ using namespace std;
+#define sign(a) ((a)>0?1:(((a)<0?-1:0)))
+struct point{__int64 x,y;};
+__int64 pp1,pp2,qq1,qq2;
+__int64 xmult(point p1,point p2,point p0){
+    return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
+}
+__int64 xmult(__int64 x1,__int64 y1,__int64 x2,__int64 y2,__int64 x0,__int64 y0){
+    return (x1-x0)*(y2-y0)-(x2-x0)*(y1-y0);
+}
+__int64 dmult(point p1,point p2,point p0){
+    return (p1.x-p0.x)*(p2.x-p0.x)+(p1.y-p0.y)*(p2.y-p0.y);
+}
+__int64 dmult(__int64 x1,__int64 y1,__int64 x2,__int64 y2,__int64 x0,__int64 y0){
+    return (x1-x0)*(x2-x0)+(y1-y0)*(y2-y0);
+}
+__int64 dots_inline(point p1,point p2,point p3){
+    return !xmult(p1,p2,p3);
+}
+__int64 dots_inline(__int64 x1,__int64 y1,__int64 x2,__int64 y2,__int64 x3,__int64 y3){
+    return !xmult(x1,y1,x2,y2,x3,y3);
+}
+__int64 dot_online_in(point p,point l1,point l2){
+    return !xmult(p,l1,l2)&&(l1.x-p.x)*(l2.x-p.x)<=0&&(l1.y-p.y)*(l2.y-p.y)<=0;
+}
+__int64 dot_online_in(__int64 x,__int64 y,__int64 x1,__int64 y1,__int64 x2,__int64 y2){
+    return !xmult(x,y,x1,y1,x2,y2)&&(x1-x)*(x2-x)<=0&&(y1-y)*(y2-y)<=0;
+}
+__int64 dot_online_ex(point p,point l1,point l2){
+    return dot_online_in(p,l1,l2)&&(p.x!=l1.x||p.y!=l1.y)&&(p.x!=l2.x||p.y!=l2.y);
+}
+__int64 dot_online_ex(__int64 x,__int64 y,__int64 x1,__int64 y1,__int64 x2,__int64 y2){
+    return dot_online_in(x,y,x1,y1,x2,y2)&&(x!=x1||y!=y1)&&(x!=x2||y!=y2);
+}
+__int64 same_side(point p1,point p2,point l1,point l2){
+    return sign(xmult(l1,p1,l2))*xmult(l1,p2,l2)>0;
+}
+__int64 opposite_side(point p1,point p2,point l1,point l2){
+    return sign(xmult(l1,p1,l2))*xmult(l1,p2,l2)<0;
+}
+__int64 parallel(point u1,point u2,point v1,point v2){
+    return (u1.x-u2.x)*(v1.y-v2.y)==(v1.x-v2.x)*(u1.y-u2.y);
+}
+__int64 __int64ersect_in(point u1,point u2,point v1,point v2){
+    if (!dots_inline(u1,u2,v1)||!dots_inline(u1,u2,v2))
+        return !same_side(u1,u2,v1,v2)&&!same_side(v1,v2,u1,u2);
+    return dot_online_in(u1,v1,v2)||dot_online_in(u2,v1,v2)||dot_online_in(v1,u1,u2)||dot_online_in(v2,u1,u2);
+}
+__int64 __int64ersect_ex(point u1,point u2,point v1,point v2){
+    return opposite_side(u1,u2,v1,v2)&&opposite_side(v1,v2,u1,u2);
+}
+void __int64ersection(point u1,point u2,point v1,point v2){
+    point ret=u1;
+    pp2=qq2=(__int64)(u1.x-u2.x)*(__int64)(v1.y-v2.y)-(__int64)(u1.y-u2.y)*(__int64)(v1.x-v2.x);
+    pp1=u1.x;
+    qq1=u1.y;
+    pp1*=pp2;
+    qq1*=qq2;
+    pp1+=((__int64)(u1.x-v1.x)*(__int64)(v1.y-v2.y)-(__int64)(u1.y-v1.y)*(__int64)(v1.x-v2.x))*(__int64)(u2.x-u1.x);
+    qq1+=((__int64)(u1.x-v1.x)*(__int64)(v1.y-v2.y)-(__int64)(u1.y-v1.y)*(__int64)(v1.x-v2.x))*(__int64)(u2.y-u1.y);
+}
+point m1,m2,n1,n2;
+__int64 ansx[2],ansy[2];
+__int64 fab(__int64 k)
+{
+    return k>0?k:-k;
+}
+__int64 gcd(__int64 m,__int64 n) 
+{
+    while (1)
+    {
+    m=m%n;
+    if (m==0) return n;
+    n=n%m;
+    if (n==0) return m;
+    }
+}
+void dod(__int64 kk1,__int64 kk2,__int64 kk)
+{
+    __int64 t1,t2,t3,t4;
+    __int64 sign1=1;
+    if(kk2==0) while(1);
+    if(kk1==0) 
+    {
+        ansx[kk]=kk1;
+        ansy[kk]=1;
+        return ;
+    }
+    if(kk2==1 || kk1==1 )
+    {
+        ansx[kk]=kk1;
+        ansy[kk]=kk2;
+        return ;
+    }
+    if((kk1<0 && kk2>0) || (kk1>0 && kk2<0))
+    {
+        sign1=-1;
+    }
+    t1=fab(kk1);
+    t2=fab(kk2);
+    if(t1>t2)
+    {
+        t3=gcd(t1,t2);
+        t1/=t3;
+        t2/=t3;
+        ansx[kk]=sign1*t1;ansy[kk]=t2;
+    }
+    else if(t1<t2)
+    {
+        t3=gcd(t2,t1);
+        t1/=t3;
+        t2/=t3;
+        ansx[kk]=sign1*t1;ansy[kk]=t2;
+    }
+    else {ansx[kk]=sign1*1;ansy[kk]=1;}
+}
+__int64 check(point aa,point bb)
+{
+    if(aa.x==bb.x && aa.y==bb.y) return 1;
+    return 0;
+}
+int main()
+{
+    int t;
+    int ans=0;
+    point res;
+    scanf("%d",&t);
+    while(t--)
+    {
+        ans=0;
+        cin>>m1.x>>m1.y>>m2.x>>m2.y>>n1.x>>n1.y>>n2.x>>n2.y;
+        if(__int64ersect_in(m1,m2,n1,n2)) 
+        {
+            if(__int64ersect_ex(m1,m2,n1,n2)) 
+            {
+                ans=1;
+                __int64ersection(m1,m2,n1,n2);
+                dod(pp1,pp2,0);
+                dod(qq1,qq2,1);
+            }
+            else if(parallel(m1,m2,n1,n2)) 
+            {
+                if( check(m1,m2) && check(n1,n2))  
+                {
+                    res=m1;
+                    cout<<'1'<<endl<<res.x<<' '<<res.y<<endl;
+                    continue;
+                }
+                else if( check(m1,m2) || check(n1,n2))
+                {
+                    if(check(m1,m2)) {ans=1; res=m1;}    
+                    else {ans=1; res=n1;}    
+                    if(ans==1) {cout<<'1'<<endl<<res.x<<' '<<res.y<<endl;continue;}
+                }
+                else if( 1== check(m1,n1) + check(m1,n2) + check(m2,n1) + check(m2,n2))
+                {
+                    ans=-1;
+                    if(check(m1,n1)) 
+                    {
+                        if(dmult(m2,n2,m1)<0) {ans=1;res=m1;}
+                    }
+                    else if(check(m1,n2))
+                    {
+                        if(dmult(m2,n1,m1)<0) {ans=1;res=m1;}
+                    }
+                    else if(check(m2,n1))
+                    {
+                        if(dmult(m1,n2,m2)<0) {ans=1;res=m2;}
+                    }
+                    else if(check(m2,n2))
+                    {
+                        if(dmult(m1,n1,m2)<0) {ans=1;res=m2;}
+                    }
+                    if(ans==1) {cout<<'1'<<endl<<res.x<<' '<<res.y<<endl;continue;}
+                }
+                else ans=-1; 
+            }
+            else
+            {
+                if(check(m1,n1) || check(m1,n2))  
+                {
+                    res=m1;ans=1;
+                }
+                if(check(m2,n1) || check(m2,n2))
+                {
+                    res=m2;ans=1;
+                }
+                if(ans==1) {cout<<'1'<<endl<<res.x<<' '<<res.y<<endl;continue;}
+                ans=1;
+                __int64ersection(m1,m2,n1,n2);
+                dod(pp1,pp2,0);
+                dod(qq1,qq2,1);
+            }
+        }
+        if(ans==-1) puts("INF");
+        else
+        {
+            printf("%d\n",ans);
+            if(ans==1)
+            {
+                if(ansy[0]==1) cout<<ansx[0]<<" ";
+                else cout<<ansx[0]<<'/'<<ansy[0]<<" ";
+                if(ansy[1]==1) cout<<ansx[1]<<endl;
+                else cout<<ansx[1]<<'/'<<ansy[1]<<endl;
+            }
+        }    
+    }
+    return 0;
+}
diff --git a/HDOJ/3804_autoAC.cpp b/HDOJ/3804_autoAC.cpp
new file mode 100644
index 0000000..14a06ca
--- /dev/null
+++ b/HDOJ/3804_autoAC.cpp
@@ -0,0 +1,115 @@
+#include <cstdlib>
+#include <iostream>
+#include <stdio.h>
+#include <memory.h>
+#include <set>
+#include <vector>
+#include <stack>
+#include <iterator>
+using namespace std;
+#define N 100005
+struct res
+{
+    int i,x;
+};
+struct pt
+{
+    int p,v;
+};
+struct que
+{
+    int x,y,ans;
+};
+vector<pt> a[N];
+vector<que> query;
+vector<int> hasq[N];
+stack<res> stk;
+multiset<int> v;
+multiset<int>::iterator it;
+bool instack[N];
+int iv[N];
+int main(int argc, char** argv)
+{
+    int tcase,i,j,n,q,x,y,w;
+    scanf("%d",&tcase);
+    while(tcase--)
+    {
+        scanf("%d",&n);
+        for(i=1;i<=n;i++)
+            a[i].clear();
+        iv[1]=-1;
+        for(i=1;i<=n-1;i++)
+        {
+            scanf("%d%d%d",&x,&y,&w);
+            iv[y]=w;
+            pt temp;
+            temp.p=y;
+            temp.v=w;
+            a[x].push_back(temp);
+            temp.p=x;
+            temp.v=w;
+            a[y].push_back(temp);
+        }
+        scanf("%d",&q);
+        for(i=1;i<=n;i++)
+            hasq[i].clear();
+        for(i=1;i<=q;i++)
+            query.clear();
+        for(i=1;i<=q;i++)
+        {
+            scanf("%d%d",&x,&y);
+            que temp;
+            temp.x=x;
+            temp.y=y;
+            temp.ans=-1;
+            query.push_back(temp);
+            hasq[x].push_back(query.size()-1);
+        }
+        v.clear();
+        v.insert(-1);
+        v.insert(-1);
+        v.insert(-1);
+        while(!stk.empty()) stk.pop();
+        memset(instack,0,sizeof(instack));
+        res temp;
+        temp.x=1;
+        temp.i=0;
+        instack[1]=1;
+        stk.push(temp);
+        while(!stk.empty())
+        {
+            res now=stk.top();
+            stk.pop();
+            if (now.i==0)
+            {
+                if (hasq[now.x].size()>0)
+                    for(int i=0;i<hasq[now.x].size();i++)
+                    {
+                        int qi=hasq[now.x][i];
+                        int qx=query[qi].x;
+                        int qy=query[qi].y;
+                        int ans;
+                        it=v.upper_bound(qy);
+                        it--;
+                        ans=(*it);
+                        query[qi].ans=ans;
+                    }
+            }
+            if (now.i==a[now.x].size()) {v.erase(v.find(iv[now.x]));continue;}   
+            now.i++;
+            stk.push(now);
+            res next;
+            next.i=0;
+            next.x=a[now.x][now.i-1].p;
+            if (!instack[next.x])
+            {
+              v.insert(a[now.x][now.i-1].v);
+              stk.push(next);
+              instack[next.x]=1;
+            }
+        }
+        for(i=0;i<query.size();i++)
+            printf("%d\n",query[i].ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3805_autoAC.cpp b/HDOJ/3805_autoAC.cpp
new file mode 100644
index 0000000..874e8ee
--- /dev/null
+++ b/HDOJ/3805_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<stdio.h>
+int a[1000],b[1000],c[1000];
+int main(){
+    int t,n,i,j,k,a0,b0,c0;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        if(n<5){
+            if(n==3) printf("6\n1 2\n5 3 4\n");
+            else printf("9\n5 4\n1 3\n8 2 6 7\n");
+            continue;
+        }
+        if(n&1){
+            i=3*(n-2);
+            a0=b0=c0=0;
+            while(i>0){
+                c[c0++]=i--;
+                b[b0++]=i--;
+                a[a0++]=i--;
+                if(i<=0) break;
+                a[a0++]=i--;
+                b[b0++]=i--;
+                c[c0++]=i--;
+            }
+        }
+        else{
+            i=3*(n-2);
+            c[0]=2;c[1]=6;
+            b[0]=3;b[1]=4;
+            a[0]=1;a[1]=5;
+            a0=b0=c0=2;
+            while(i>6){
+                c[c0++]=i--;
+                b[b0++]=i--;
+                a[a0++]=i--;
+                a[a0++]=i--;
+                b[b0++]=i--;
+                c[c0++]=i--;
+            }
+        }
+        printf("%d\n",3*(n-1));
+        for(i=0;i<a0;i++) printf("%d %d\n",a[i],b[i]);
+        printf("%d",3*(n-1)-1);
+        for(i=0;i<c0;++i) printf(" %d",c[i]);
+        printf(" %d\n",3*(n-1)-2);
+    }
+    return 0;
+}
diff --git a/HDOJ/3807_autoAC.cpp b/HDOJ/3807_autoAC.cpp
new file mode 100644
index 0000000..d0f22c3
--- /dev/null
+++ b/HDOJ/3807_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <vector>
+#include <string>
+#include <algorithm>
+#define INF 0x7f7f7f7f
+using namespace std;
+int num[1010];
+vector<int> ans;
+int main()
+{
+    int t, n, x, A, B;
+    scanf("%d", &t);
+    while(t--)
+    {
+        memset(num, 0, sizeof(num));
+        ans.clear();
+        scanf("%d", &n);
+        for(int i = 0; i < n; ++ i)
+        {
+            scanf("%d",&x);
+            num[x]++;
+        }
+        scanf("%d%d", &A, &B);
+        for(int i = 1; i <= n; ++ i)
+        {
+            for(int j = 0; j <= A; ++ j)
+            {
+                int lie = n-num[i];
+                if(i-j >= 0 && lie-j >= 0 && (n-(i-j+lie) >= 0 && n-(i-j+lie) <= B))
+                {
+                    ans.push_back(i);
+                    break;
+                }
+            }
+        }
+        if((int)ans.size() == 0)
+            printf("impossible\n");
+        else
+        {
+            int len = ans.size();
+            for(int i = 0; i < len-1; ++ i)
+                printf("%d ", ans[i]);
+            printf("%d\n", ans[len-1]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3808_autoAC.cpp b/HDOJ/3808_autoAC.cpp
new file mode 100644
index 0000000..e3138c5
--- /dev/null
+++ b/HDOJ/3808_autoAC.cpp
@@ -0,0 +1,25 @@
+#include <iostream>
+using namespace std;
+char a[11][100]={"Yu Jian","Tin O O","I Missed","Stefanie","The Same","About","Honey Honey","Unfinished","Hey Jude","When Winter Fades"};
+void fun(int i)
+{
+ if(i>0 && i<6)
+  cout<<a[i-1]<<endl;
+ else if(i>7 && i<13)
+  cout<<a[i-3]<<endl; 
+}
+int main()
+{
+ int t,n;
+ cout<<"Best wishes to Stefanie\n\n";
+ cin>>t;
+ while(t--)
+ {
+  cin>>n;
+        if(n<14)
+   fun(n);
+  else 
+   fun(n%14);
+ }
+ return 0;
+}
diff --git a/HDOJ/3809_autoAC.cpp b/HDOJ/3809_autoAC.cpp
new file mode 100644
index 0000000..bb0677c
--- /dev/null
+++ b/HDOJ/3809_autoAC.cpp
@@ -0,0 +1,20 @@
+#include<iostream>
+#include<stdio.h>
+#include<cmath>
+using namespace std;
+int main(){
+    int t,tt;
+    double x,y,x1,y1;
+    scanf("%d",&t);
+    tt=t;
+    while (t--){
+          scanf("%lf%lf",&x1,&y1);
+          x=x1,y=y1; 
+          for (int i=0;i<30;i++){
+              x=x1+sqrt(y);
+              y=y1+sqrt(x);
+              }
+          printf("Case %d: %.6lf %.6lf\n",tt-t,x,y);
+          }
+    return 0;
+}
diff --git a/HDOJ/3810_autoAC.cpp b/HDOJ/3810_autoAC.cpp
new file mode 100644
index 0000000..9d43338
--- /dev/null
+++ b/HDOJ/3810_autoAC.cpp
@@ -0,0 +1,117 @@
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+#include <algorithm>
+#include <queue>
+#include <vector>
+#define LL long long
+using namespace std;
+const int INF = 1000000000;
+const int N = 51;
+struct node
+{
+    int t,g;
+    bool operator<(const node& tt) const
+    {
+        if(g == tt.g) return t > tt.t;
+        return g < tt.g;
+    }
+}s[N],now,ne;
+int n,m,tot,min1;
+int t[N],g[N],vst[N],num[N];
+int adj[N][N];
+int d[N][N];
+priority_queue<node> q1,q2;
+void dfs(int i)
+{
+    for(int j = 1; j <= n; j++)
+    {
+        if(vst[j]) continue;
+        if(adj[i][j])
+        {
+            vst[j] = 1;
+            d[tot][num[tot]++] = j;
+            dfs(j);
+        }
+    }
+}
+void init()
+{
+    tot = 0;
+    for(int i = 1; i <= n; i++)
+    {
+        if(!vst[i])
+        {
+            vst[i] = 1;
+            d[tot][num[tot]++] = i;
+            dfs(i);
+            tot++;
+        }
+    }
+}
+void solve()
+{
+    int i,j,k;
+    min1 = INF;
+    for(i = 0; i < tot; i++)
+    {
+        while(!q1.empty()) q1.pop();
+        while(!q2.empty()) q2.pop();
+        now.t = now.g = 0;
+        q1.push(now);
+        for(j = 0; j < num[i]; j++)
+        {
+            while(!q1.empty())
+            {
+                now = q1.top();
+                q1.pop();
+                q2.push(now);
+                ne.t = now.t+s[d[i][j]].t;
+                ne.g = now.g+s[d[i][j]].g;
+                if(ne.g >= m) {min1 = min(min1, ne.t); continue;}
+                if(ne.t < min1) q2.push(ne);
+            }
+            int tem = INF;
+            while(!q2.empty())
+            {
+                now = q2.top();
+                q2.pop();
+                if(tem >= now.t)
+                {
+                    q1.push(now);
+                    tem = now.t;
+                }
+            }
+        }
+    }
+}
+int main()
+{
+    int T;
+    int i,j,k;
+    scanf("%d", &T);
+    for(int cc = 1; cc <= T; cc++)
+    {
+        scanf("%d%d", &n, &m);
+        memset(adj, 0, sizeof(adj));
+        memset(num, 0, sizeof(num));
+        memset(vst, 0, sizeof(vst));
+        for(i = 1; i <= n; i++)
+        {
+            scanf("%d%d%d", &s[i].t, &s[i].g, &k);
+            for(j = 0; j < k; j++)
+            {
+                int aa;
+                scanf("%d", &aa);
+                adj[i][aa] = adj[aa][i] = 1;
+            }
+        }
+        printf("Case %d: ", cc);
+        init();
+        solve();
+        if(min1 == INF) puts("Poor Magina, you can't save the world all the time!");
+        else printf("%d\n", min1);
+    }
+    return 0;
+}
diff --git a/HDOJ/3811_autoAC.cpp b/HDOJ/3811_autoAC.cpp
new file mode 100644
index 0000000..f518ee1
--- /dev/null
+++ b/HDOJ/3811_autoAC.cpp
@@ -0,0 +1,55 @@
+#include"stdio.h"
+#include"string.h"
+#include"stdlib.h"
+int n,m;
+__int64 fac[18];
+int ban[18][18];
+__int64 dp[1<<17];
+void ini()
+{
+    int i;
+    fac[0]=1;
+    for(i=1;i<=17;i++)    fac[i]=fac[i-1]*i;
+}
+void getban()
+{
+    int a,b;
+    memset(ban,0,sizeof(ban));
+    while(m--)
+    {
+        scanf("%d%d",&a,&b);
+        a--;b--;
+        ban[a][b]=1;
+    }
+}
+void getdp()
+{
+    int i,j,k;
+    memset(dp,0,sizeof(dp));
+    dp[0]=1;
+    for(i=0;i<n;i++)                
+    for(j=(1<<n)-1;j>=0;j--)       
+    {
+        if(!dp[j])    continue;
+        for(k=0;k<n;k++)           
+        {
+            if(j&(1<<k))    continue;   
+            if(ban[i][k])    continue;
+            dp[j|(1<<k)]+=dp[j];
+        }
+    }
+}
+int main()
+{
+    int T,Case;
+    ini();
+    scanf("%d",&T);
+    for(Case=1;Case<=T;Case++)
+    {
+        scanf("%d%d",&n,&m);
+        getban();
+        getdp();
+        printf("Case %d: %I64d\n",Case,fac[n]-dp[(1<<n)-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3812_autoAC.cpp b/HDOJ/3812_autoAC.cpp
new file mode 100644
index 0000000..1cd0ad2
--- /dev/null
+++ b/HDOJ/3812_autoAC.cpp
@@ -0,0 +1,133 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<string>
+#include<map>
+#include<algorithm>
+using namespace std;
+char real[105][30];
+int n,w=0,mm[105][105],st,et;
+char temp1[208][30];
+int record[105],vis[105],vis1[105];
+int yes[105],root[105];
+int Find(int r)
+{
+    if(r==root[r]) return r;
+    else return root[r]=Find(root[r]);
+}
+int add(char *a)
+{
+    int i;
+    for(i=0;i<w;i++){
+        if(strcmp(a,real[i])==0)
+         return i;
+    }
+    strcpy(real[w++],a);
+}
+void init()
+{
+    int i,num=0,j;
+    char s1[30],s2[30];
+    for(i=0;i<n;i++){
+        scanf("%s %s",s1,s2);
+        add(s1);
+        add(s2);
+        strcpy(temp1[num++],s1);
+        strcpy(temp1[num++],s2);
+    }
+    for(i=0;i<w-1;i++)
+        for(j=i+1;j<w;j++){
+            if(strcmp(real[i],real[j])>0){
+                char temp[30];
+                strcpy(temp,real[j]);
+                strcpy(real[j],real[i]);
+                strcpy(real[i],temp);
+            }
+        }
+        for(i=0;i<w;i++) root[i]=i;
+    for(i=0;i<num;i+=2){
+        int nowx=add(temp1[i]),nowy=add(temp1[i+1]);
+        mm[nowx][nowy]=mm[nowy][nowx]=1;
+        int ra=Find(nowx),rb=Find(nowy);
+        if(ra!=rb) root[rb]=ra;
+    }
+}
+int ansl=0;
+int dfs(int now,int tt)
+{
+    if(tt>=w) return 0;
+    int i;
+    vis[now]=1;
+    record[tt]=now;
+    if(now==et){
+        if(ansl<tt) {
+            ansl=tt;
+            for(i=0;i<=ansl;i++) yes[i]=record[i];
+        }
+            if(tt==w-1) return 1;
+    }
+    for(i=0;i<w;i++){
+        if(vis[i]==0&&mm[now][i]==1){
+            vis[i]=1;
+            if(dfs(i,tt+1)) return 1;
+            vis[i]=0;
+        }
+    }
+    return 0;
+}
+int dfs1(int ttt,int ending)
+{
+    int i;
+    if(ttt==ending) return 1;
+    for(i=0;i<w;i++){
+        if(!vis1[i]&&mm[ttt][i]&&(!vis[i])){
+            vis1[i]=1;
+            if(dfs1(i,ending)) return 1;
+            //vis1[i]=0;
+        }
+    }
+    return 0;
+}
+int main()
+{
+    int i,cc,Case=0;
+    scanf("%d",&cc);
+    while(cc--){
+        Case++;
+        scanf("%d",&n);
+        memset(vis,0,sizeof(vis));
+        memset(mm,0,sizeof(mm));
+        w=0;
+        init();
+        st=-1;et=-1;
+        for(i=0;i<w;i++){
+            if(strcmp(real[i],"sea")==0) st=i;
+            if(strcmp(real[i],"sky")==0) et=i;
+        }
+        printf("Case %d:",Case);
+        if(st==-1||et==-1){
+            printf(" what a pity\n");
+            continue;
+        }
+        if(Find(st)!=Find(et)) {
+            printf(" what a pity\n");
+            continue;
+        }
+        for(i=0;i<w;i++){
+            memset(vis1,0,sizeof(vis1));
+            vis1[st]=1;
+            if(!dfs1(i,et)) vis[i]=1;
+        }
+        for(i=0;i<w;i++){
+            memset(vis1,0,sizeof(vis1));
+            vis1[et]=1;
+            if(!dfs1(i,st)) vis[i]=1;
+        }
+        ansl=0;
+        dfs(st,0);
+        for(i=0;i<=ansl;i++){
+            printf(" %s",real[yes[i]]);
+        }
+        printf("\n");
+    }
+}
diff --git a/HDOJ/3814_autoAC.cpp b/HDOJ/3814_autoAC.cpp
new file mode 100644
index 0000000..c01128b
--- /dev/null
+++ b/HDOJ/3814_autoAC.cpp
@@ -0,0 +1,188 @@
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#define eps 1e-9
+using namespace std;
+double f_abs(double x){
+    return x<0?-x:x;
+}
+struct Point{
+    double x,y;
+    bool up,dn;
+    void disp(){
+        printf("%lf %lf\n",x,y);
+    }
+    void get(){
+        scanf("%lf%lf",&x,&y);
+    }
+    bool friend operator<(Point a,Point b){
+        if(f_abs(a.x-b.x)<eps)return a.y<b.y;
+        return a.x<b.x;
+    }
+    bool friend operator>(Point a,Point b){
+        return b<a;
+    }
+    bool friend operator==(Point a,Point b){
+        return f_abs(a.x-b.x)<eps&&f_abs(a.y-b.y)<eps;
+    }
+};
+struct Line{
+    Point s,e;
+    bool friend operator<(Line a,Line b){
+        return a.s<b.s;
+    }
+    void st(){
+        Point t;
+        if(s>e){
+            t=s;s=e;e=t;
+        }
+    }
+    void get(){
+        s.get();e.get();
+        st();
+    }
+};
+Line line[200000],myl[2];
+Point ep[200000];
+int en;
+double get_cross(Point a,Line b){
+    double ax,ay,bx,by;
+    ax=b.s.x-a.x;
+    ay=b.s.y-a.y;
+    bx=b.e.x-a.x;
+    by=b.e.y-a.y;
+    return ax*by-ay*bx;
+}
+int inter(Line a,Line b,Point &rp=Point()){
+    double cj[2];
+    cj[0]=get_cross(b.s,a);cj[1]=get_cross(b.e,a);
+    if(cj[0]*cj[1]>eps)return 0;
+    cj[0]=get_cross(a.s,b);cj[1]=get_cross(a.e,b);
+    if(cj[0]*cj[1]>eps)return 0;
+    if(f_abs(cj[0])<eps&&f_abs(cj[1])<eps){
+        return 4;
+    }
+    if(f_abs(cj[0])<eps){
+        rp=a.s;
+        if(cj[1]>eps)return 2;
+        else return 3;
+    }else if(f_abs(cj[1])<eps){
+        rp=a.e;
+        if(cj[0]>eps)return 2;
+        else return 3;
+    }else{
+        double key1=(a.e.x-a.s.x)*(b.e.y-b.s.y);  
+        double key2=(b.e.x-b.s.x)*(a.e.y-a.s.y);  
+        double key=key1-key2;  
+        rp.x=(a.s.y-b.s.y)*(a.e.x-a.s.x)*(b.e.x-b.s.x);  
+        rp.x-=key2*a.s.x-key1*b.s.x;  
+        rp.x/=key;  
+        if(f_abs(b.e.x-b.s.x)<eps)rp.y=(a.e.y-a.s.y)/(a.e.x-a.s.x)*(rp.x-a.s.x)+a.s.y;  
+        else rp.y=(b.e.y-b.s.y)/(b.e.x-b.s.x)*(rp.x-b.s.x)+b.s.y;  
+        return 1;
+    }
+}
+int ln;
+void get_myl2(){
+    double dy=myl[0].e.y-myl[0].s.y,dx=myl[0].e.x-myl[0].s.x;
+    double t=sqrt(dy*dy+dx*dx);
+    dy/=t;dx/=t;
+    myl[1].e=myl[0].s;
+    myl[1].s.x=myl[1].e.x-300000*dx;
+    myl[1].s.y=myl[1].e.y-300000*dy;
+}
+void get_data(){
+    myl[0].get();
+    int t,n,i;
+    int pcnt=0;
+    Point p[2],ini;
+    ln=0;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        ini.get();
+        if(n==1)continue;
+        p[0]=ini;
+        bool f=0;
+        for(i=1;i<n;i++){
+            f^=1;
+            p[f].get();
+            line[ln].s=p[f^1];
+            line[ln].e=p[f];
+            line[ln++].st();
+        }
+        line[ln].s=p[f];
+        line[ln].e=ini;
+        line[ln++].st();
+    }
+    get_myl2();
+}
+double get_len(Point a,Point b){
+    return sqrt((b.x-a.x)*(b.x-a.x)+(b.y-a.y)*(b.y-a.y));
+}
+void get_ep(Line l){
+    en=0;
+    int t,i;
+    for(i=0;i<ln;i++){
+        t=inter(line[i],l,ep[en]);
+        if(!t||t==4)continue;
+        if(t==1){
+            ep[en].up=1;
+            ep[en++].dn=1;
+        }else if(t==2){
+            ep[en].up=1;
+            ep[en++].dn=0;
+        }else{
+            ep[en].up=0;
+            ep[en++].dn=1;
+        }
+    }
+    sort(ep,ep+en);
+    int ten=0;
+    for(i=0;i<en;i++){
+        if(ten&&ep[i]==ep[ten-1]){
+            ep[ten-1].up^=ep[i].up;
+            ep[ten-1].dn^=ep[i].dn;
+        }else ep[ten++]=ep[i];
+    }
+    en=ten;
+}
+void run(){
+    if(myl[0].s==myl[0].e){
+        printf("0.00%%\n");
+        return;
+    }
+    int i;
+    bool in=0,left=0,right=0;
+    get_ep(myl[1]);
+    for(i=0;i<en;i++){
+        left^=ep[i].up;
+        right^=ep[i].dn;
+    }
+    if(left||right)in=1;
+    else in=0;
+    get_ep(myl[0]);
+    double len=get_len(myl[0].s,myl[0].e),res=0;
+    Point lp=myl[0].s;
+    ep[en++]=myl[0].e;
+    for(i=0;i<en;i++){
+        if(ep[i]==myl[0].s)continue;
+        if(in)res+=get_len(ep[i],lp);
+        left^=ep[i].up;
+        right^=ep[i].dn;
+        if(left||right)in=1;
+        else in=0;
+        lp=ep[i];
+    }
+    printf("%.2lf%%\n",res*100/len);
+}
+int main(){
+    int i,t;
+    scanf("%d",&t);
+    for(i=1;i<=t;i++){
+        get_data();
+        printf("Case %d: ",i);
+        run();
+    }
+    return 0;
+}
diff --git a/HDOJ/3816_autoAC.cpp b/HDOJ/3816_autoAC.cpp
new file mode 100644
index 0000000..d7d1aff
--- /dev/null
+++ b/HDOJ/3816_autoAC.cpp
@@ -0,0 +1,21 @@
+#include<stdio.h>
+int main()
+{
+                printf("2 3 6\n");
+                printf("2 4 6 12\n");
+                printf("2 5 6 12 20\n");
+                printf("2 5 7 12 20 42\n");
+                printf("3 5 6 7 12 20 42\n");
+                printf("3 5 6 8 12 20 42 56\n");
+                printf("3 5 6 8 16 20 42 48 56\n");
+                printf("3 5 6 12 16 20 24 42 48 56\n");
+                printf("3 5 6 16 20 21 24 28 42 48 56\n");
+                printf("3 5 6 16 21 24 28 36 42 45 48 56\n");
+                printf("3 5 6 16 24 28 30 36 42 45 48 56 70\n");
+                printf("3 5 6 16 28 30 33 36 42 45 48 56 70 88\n");
+                printf("3 5 6 16 28 33 36 39 42 45 48 56 70 88 130\n");
+                printf("3 5 6 16 33 36 39 42 44 45 48 56 70 77 88 130\n");
+                printf("3 5 6 20 33 36 39 42 44 45 48 56 70 77 80 88 130\n");
+                printf("3 5 6 24 33 36 39 42 44 45 48 56 70 77 80 88 120 130\n");
+                return 0;
+}
diff --git a/HDOJ/3817_autoAC.cpp b/HDOJ/3817_autoAC.cpp
new file mode 100644
index 0000000..739f4dc
--- /dev/null
+++ b/HDOJ/3817_autoAC.cpp
@@ -0,0 +1,28 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+    int s,a,b,c,t,d=1;
+    cin>>s;
+    while(s--)
+    {
+        cin>>a>>b>>c;
+        if(a<b)
+        {
+            t=a;
+            a=b;
+            b=t;
+        }
+        if(a<c)
+        {
+            t=a;
+            a=c;
+            c=t;
+        }
+        cout<<"Case "<<d++<<": ";
+        if(b*b+c*c==a*a) cout<<"Right triangle"<<endl;
+        else if(b*b+c*c<a*a) cout<<"Obtuse triangle"<<endl;
+        else cout<<"Acute triangle"<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/3818_autoAC.cpp b/HDOJ/3818_autoAC.cpp
new file mode 100644
index 0000000..79bc4e4
--- /dev/null
+++ b/HDOJ/3818_autoAC.cpp
@@ -0,0 +1,61 @@
+#include<stdio.h>
+#include<string.h>
+#define MAX 1000000
+int a[1000010];
+int b[1000];
+int main()
+{
+     int x,n,i,j,num,max=0,sum,ji=0;
+     scanf("%d",&x);
+     while(x--)    
+     {
+            ji++;
+            memset( a, 0, sizeof(a) );  
+            for( i=1; i<=2; i++ )         
+               {
+                  scanf("%d",&n);
+                  for( j=1; j<=n;j++ )          
+                     {
+                       scanf("%d",&num);
+                       if( num>max )max=num;
+                       a[num]++;
+                     }  
+               }
+            for( i=max; i>=2; i--)  
+               {
+                  if(a[i]>=2){
+                              a[i]-=2;        
+                              a[i+1]+=1; 
+                              a[i-2]+=1;
+                             }
+               } 
+               if(a[1]!=0)a[2]+=a[1];     
+            for( i=max+1; i>=3; i-- )     
+               {
+                   if(a[i]==1&&a[i-1]==1)
+                       {
+                           a[i]=a[i-1]=0;
+                           a[i+1]+=1;  ;
+                       }             
+               }
+            for( i=max+2; i>=3; i-- )
+               {
+                   if(a[i]==1&&a[i-1]==1)
+                       {
+                           a[i]=a[i-1]=0;
+                           a[i+1]+=1;  ;
+                       }             
+               }
+            j=0;
+            sum=0;
+            for(i=2; i<=max+5; i++)   
+            {
+              if(a[i]!=0){b[j++]=i;sum++;}         
+            }
+            printf("Case %d:\n",ji);
+            printf("%d",sum);
+            for( i=0; i<j; i++)
+               printf(" %d",b[i]);
+               printf("\n");               
+     } 
+}
diff --git a/HDOJ/3819_autoAC.cpp b/HDOJ/3819_autoAC.cpp
new file mode 100644
index 0000000..2695959
--- /dev/null
+++ b/HDOJ/3819_autoAC.cpp
@@ -0,0 +1,38 @@
+#include<iostream>
+#include<cmath>   
+#include<string>
+using namespace std;
+char s[110000];
+int ct[110000];
+int main()
+{
+    int t,i,sum,len,j,max,move;
+    scanf("%d",&t);
+    for(i=1;i<=t;i++)
+    {
+      scanf("%s",&s);
+      len=strlen(s);
+      memset(ct,0,sizeof(ct));
+      sum=0;
+      for(j=0;j<len;j++)
+      {
+        if(s[j]=='A'){sum++;}
+        ct[j]=sum;
+      }
+       max=ct[sum-1];
+       for(j=0;j+sum<=len;j++)
+        {
+            move=ct[j+sum-1]-ct[j-1];
+            if (move>max)
+                max=move;
+        }
+        for(;j<len;j++)
+        {
+            move=ct[(j+sum)%len-1]+ct[len-1]-ct[j-1];
+            if (move>max)
+                max=move;
+        }
+        printf("Case %d: %d\n",i,sum-max);
+    }
+     return 0;
+}
diff --git a/HDOJ/3820_autoAC.cpp b/HDOJ/3820_autoAC.cpp
new file mode 100644
index 0000000..3d6da9b
--- /dev/null
+++ b/HDOJ/3820_autoAC.cpp
@@ -0,0 +1,120 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<queue>
+using namespace std;
+const int VM=101000;
+const int EM=500100;
+const int INF=0x3f3f3f3f;
+struct Edge{
+    int to,nxt;
+    int cap;
+}edge[EM<<1];
+int n,m,G,S,cnt,head[VM],src,des,map1[110][110],map2[110][110];
+int dep[VM],gap[VM],cur[VM],aug[VM],pre[VM];
+void addedge(int cu,int cv,int cw){
+    edge[cnt].to=cv;  edge[cnt].cap=cw;  edge[cnt].nxt=head[cu];
+    head[cu]=cnt++;
+    edge[cnt].to=cu;  edge[cnt].cap=0;   edge[cnt].nxt=head[cv];
+    head[cv]=cnt++;
+}
+int SAP(int n){
+    int max_flow=0,u=src,v;
+    int id,mindep;
+    aug[src]=INF;
+    pre[src]=-1;
+    memset(dep,0,sizeof(dep));
+    memset(gap,0,sizeof(gap));
+    gap[0]=n;
+    for(int i=0;i<=n;i++)
+        cur[i]=head[i]; 
+    while(dep[src]<n){
+        int flag=0;
+        if(u==des){
+            max_flow+=aug[des];
+            for(v=pre[des];v!=-1;v=pre[v]){     
+                id=cur[v];
+                edge[id].cap-=aug[des];
+                edge[id^1].cap+=aug[des];
+                aug[v]-=aug[des];  
+                if(edge[id].cap==0) 
+                    u=v;
+            }
+        }
+        for(int i=cur[u];i!=-1;i=edge[i].nxt){
+            v=edge[i].to;    
+            if(edge[i].cap>0 && dep[u]==dep[v]+1){  
+                flag=1;
+                pre[v]=u;
+                cur[u]=i;
+                aug[v]=min(aug[u],edge[i].cap);
+                u=v;
+                break;
+            }
+        }
+        if(!flag){
+            if(--gap[dep[u]]==0)   
+                break;
+            mindep=n;
+            cur[u]=head[u];
+            for(int i=head[u];i!=-1;i=edge[i].nxt){
+                v=edge[i].to;
+                if(edge[i].cap>0 && dep[v]<mindep){
+                    mindep=dep[v];
+                    cur[u]=i;   
+                }
+            }
+            dep[u]=mindep+1;
+            gap[dep[u]]++;
+            if(u!=src)
+                u=pre[u];
+        }
+    }
+    return max_flow;
+}
+int main(){
+    int t,cases=0;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d%d%d",&n,&m,&G,&S);
+        cnt=0;
+        memset(head,-1,sizeof(head));
+        src=0; des=n*m*2+1;
+        int sum=0;
+        for(int i=1;i<=n;i++)
+            for(int j=1;j<=m;j++){
+                scanf("%d",&map1[i][j]);
+                sum+=map1[i][j];
+            }
+        for(int i=1;i<=n;i++)
+            for(int j=1;j<=m;j++){
+                scanf("%d",&map2[i][j]);
+                sum+=map2[i][j];
+            }
+        int tmp;
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=m;j++){
+                tmp=(i-1)*m+j;
+                if((i+j)%2==0){
+                    addedge(src,tmp,map1[i][j]);
+                    addedge(tmp,tmp+n*m,INF);
+                    addedge(tmp+n*m,des,map2[i][j]);
+                    if(i>1) addedge(tmp,tmp-m+n*m,G);
+                    if(i<n) addedge(tmp,tmp+m+n*m,G);
+                    if(j>1) addedge(tmp,tmp-1+n*m,G);
+                    if(j<m) addedge(tmp,tmp+1+n*m,G);
+                }else{
+                    addedge(src,tmp,map2[i][j]);
+                    addedge(tmp,tmp+n*m,INF);
+                    addedge(tmp+n*m,des,map1[i][j]);
+                    if(i>1) addedge(tmp,tmp-m+n*m,S);
+                    if(i<n) addedge(tmp,tmp+m+n*m,S);
+                    if(j>1) addedge(tmp,tmp-1+n*m,S);
+                    if(j<m) addedge(tmp,tmp+1+n*m,S);
+                }
+            }
+        }
+        printf("Case %d: %d\n",++cases,sum-SAP(des+1));
+    }
+    return 0;
+}
diff --git a/HDOJ/3821_autoAC.cpp b/HDOJ/3821_autoAC.cpp
new file mode 100644
index 0000000..19219b6
--- /dev/null
+++ b/HDOJ/3821_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <cstdio>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+#define maxn 1005
+int x[maxn],y[maxn];
+int map[maxn];
+int main()
+{
+    int i,j,T,C=1,n,m;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        for(i=0; i<n; i++)
+        {
+            for(j=0; j<n; j++)
+            {
+                int t;
+                scanf("%d",&t);
+                if(t==1)
+                {
+                    x[i]=j;
+                    map[j]=i;
+                }
+            }
+        }
+        for(i=0; i<n; i++)
+        {
+            y[i]=x[i];
+        }
+        vector<int>v;
+        for(i=1; i<n; i++)
+        {
+            for(j=i; j>=1; j--)
+            {
+                if(y[j]<y[j-1])
+                {
+                    swap(y[j],y[j-1]);
+                    v.push_back(j-1);
+                }
+            }
+        }
+        printf("Case %d: %d\n",C++,v.size());
+        int len=v.size();
+        for(i=0;i<len-1;i++)
+        {
+            printf("%d ",v[i]);
+        }
+        if(len!=0)
+        {
+            printf("%d",v[len-1]);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3823_autoAC.cpp b/HDOJ/3823_autoAC.cpp
new file mode 100644
index 0000000..e67bd5e
--- /dev/null
+++ b/HDOJ/3823_autoAC.cpp
@@ -0,0 +1,53 @@
+#include <iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define maxn 21000000
+bool isprime[maxn];
+long long prime[maxn],nprime;
+void getprime()
+{
+    memset(isprime,1,sizeof(isprime));
+    nprime=0;
+    long long i,j;
+    for(i=2; i<maxn; i++)
+        if(isprime[i])
+        {
+            prime[nprime++]=i;
+            for(j=i*i; j<maxn; j+=i)
+                isprime[j]=0;
+        }
+}
+bool isd[150];
+int main()
+{
+    getprime();
+    int t,ca=0;
+    long long a,b;
+    for(int i=1; i<nprime; i++)
+        if(prime[i]-prime[i-1]<150)
+            isd[prime[i]-prime[i-1]]=1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%I64d%I64d",&a,&b);
+        if(a>b)
+            swap(a,b);
+        long long ans=-1,d=b-a;
+        printf("Case %d: ",++ca);
+        if(!isd[d]||a==b)
+        {
+            puts("-1");
+            continue;
+        }
+        for(int i=1; i<nprime; i++)
+            if(prime[i]-prime[i-1]==d&&a<=prime[i-1])
+            {
+                ans=prime[i-1]-a;
+                break;
+            }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3824_autoAC.cpp b/HDOJ/3824_autoAC.cpp
new file mode 100644
index 0000000..ac518c5
--- /dev/null
+++ b/HDOJ/3824_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <cstdio>
+#include <cstring>
+using namespace std;
+#define maxn 1000
+#define max (1<<29)
+typedef __int64 ll;
+const ll inf = (1ll)<<50;
+int t, n, m, s, a, i, j, u, v, w, now, tmp1, tmp2;
+int dis[maxn][maxn];
+ll best[maxn];
+ll cost, k21, k22;
+bool vis[maxn];
+int head, tail;
+int q[maxn*maxn];
+bool flag;
+int main() {
+ scanf("%d", &t);
+ for (int cases = 1; cases <= t; cases++) {
+ scanf("%d %d %d %d", &n, &m, &s, &a);
+ for (i = 0; i < n; i++)
+ for (j = 0; j < n; j++)
+ dis[i][j] = -1;
+ for (i = 0; i < m; i++) {
+ scanf("%d %d %d", &u, &v, &w);
+ dis[u][v] = dis[v][u] = w;
+ }
+ head = 1; tail = 1; q[1] = a;
+ for (i = 0; i < n; i++) best[i] = inf;
+ for (i = 0; i < n; i++) vis[i] = false;
+ best[a] = 0;vis[a] = true;
+ while (head <= tail) {
+ now = q[head];
+ for (i = 0; i < n; i++)
+ if ((dis[now][i] != -1) && (dis[now][i]*3 <= s)) {
+ if ( best[now]+3*dis[now][i] <= s) {
+ cost = best[now]+2*dis[now][i]; 
+ flag = true;
+ } else {
+ tmp1 = s-3*dis[now][i]; 
+ tmp2 = s-5*dis[now][i]; 
+ if(tmp2 > 0){ 
+ k21 = (best[now]-tmp1)/tmp2; 
+ k22 = (best[now]-tmp1)%tmp2;
+ cost = 1ll*(s-dis[now][i])*(1+k21)+1ll*(k22!=0)*(k22+4*dis[now][i]);
+ flag = true;
+ } else flag = false; 
+ }
+ if (flag && cost < best[i]){
+ best[i] = cost;
+ if (!vis[i]) {
+ vis[i] = true;
+ q[++tail] = i;
+ }
+ }
+ }
+ head++; vis[now] = false;
+ }
+ if (best[0] == inf) { printf("Case %d: Poor princess, we will miss you!\n", cases); } else {
+ printf("Case %d: %I64d\n", cases, best[0]);
+ }
+ }
+}
diff --git a/HDOJ/3825_autoAC.cpp b/HDOJ/3825_autoAC.cpp
new file mode 100644
index 0000000..6565f20
--- /dev/null
+++ b/HDOJ/3825_autoAC.cpp
@@ -0,0 +1,85 @@
+#include<stdio.h>
+#include<math.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+struct node
+{
+ double x , y; int time;
+} a[1000];
+int n , v;
+int f[1000] ; double d[1000] , dis[200][200];
+int cmp(node p , node q)
+{
+ if (p.time < q.time) return 1;
+ return 0;
+}
+double dist(int p , int q)
+{
+ return sqrt( (a[p].x - a[q].x) * (a[p].x - a[q].x) + (a[p].y - a[q].y) * (a[p].y - a[q].y));
+}
+void pre_deal()
+{
+ int i , j;
+ for (i=1;i<=n;i++)
+ for (j=i+1;j<=n;j++)
+ dis[i][j] = dist(i , j);
+}
+void deal()
+{
+ int i , j , k , ans1; double ans2 , t;
+ pre_deal();
+ ans1 = 0;
+ for(i=1;i<=n;i++)
+ {
+ memset(f , 0 , sizeof(f));
+ f[i] = 1; d[i] = 0;
+ for (j=i+1;j<=n;j++) d[j]=1e10;
+ for (j=i+1;j<=n;j++)
+ if (dis[i][j]/v-1e-8 <= a[j].time - a[i].time)
+ {
+ if (f[j] < f[i] + 1 || f[j] == f[i] + 1 && d[j] > d[i] + dis[i][j])
+ {
+ f[j] = f[i] + 1;
+ d[j] = d[i] + dis[i][j];
+ }
+ for (k=j+1;k<=n;k++)
+ if (f[k] < f[j] + 1 || f[k] == f[j] + 1 && d[k] > d[j] + dis[j][k])
+ if (dis[j][k] / v - 1e-8 <= a[k].time - a[j].time)
+ {
+ f[k] = f[j] + 1;
+ d[k] = d[j] + dis[j][k];
+ }
+ }
+ for (j=i;j<=n;j++)
+ {
+ t = dis[i][j];
+ if (f[j] > ans1 || f[j] == ans1 && d[j] + t < ans2)
+ {
+ ans1 = f[j]; ans2 = d[j] + t;
+ }
+ }
+ }
+ printf("%d %.3lf\n", ans1 , ans2);
+}
+void init()
+{
+ int i;
+ scanf("%d%d", &n , &v);
+ for(i=1;i<=n;i++)
+ {
+ scanf("%lf%lf%d",&a[i].x,&a[i].y, &a[i].time);
+ }
+ sort(a+1 , a+n+1 ,cmp);
+}
+int main()
+{
+ int tot;
+ scanf("%d", &tot);
+ for (int i=1;i<=tot;i++)
+ {
+ printf("Case %d: " , i); 
+ init();
+ deal();
+ }
+}
diff --git a/HDOJ/3826_autoAC.cpp b/HDOJ/3826_autoAC.cpp
new file mode 100644
index 0000000..5e9190e
--- /dev/null
+++ b/HDOJ/3826_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<math.h>
+int hash[500024]={0};
+int prime( int num[] )
+{
+    for( int i=3;i<=1000;i+=2 )
+    {
+         if( hash[i/2] )
+           continue;
+         int x=i<<1;
+         for( int j=i*i; j<=1000000; j+=x ) 
+            hash[j/2]=1;    
+    }
+    int count=0;
+    num[++count]=2;
+    for( int i=1;i<=500000;i++ )
+    {
+         if( hash[i]==0 )
+         num[++count]=( i<<1 )+1;     
+    }    
+    return count;
+}
+bool  judge( int num[], int count , long long  number )
+{
+    long long t=( long long )sqrt( number ) ;
+    for( int i=1;i<=count; i++ )
+    {
+         if( number==1 ) break;
+         if( 0==(number%num[i]) )
+         {
+             number/=num[i];
+             if( number%num[i]==0 )  return true;     
+         }      
+    }
+    if( number!=1 )
+    {
+         t=( long long  )sqrt( number ) ;
+             if( (t*t)==number )  
+                return true;      
+    }
+    return false;     
+}
+int main( )
+{
+    int T,num[78550];
+    int count = prime( num );
+    scanf( "%d",&T );
+    for( int i=1;i<=T; i++ )
+    {
+        long long number;
+        scanf( "%I64d",&number );
+        printf( "Case %d: ",i );
+        bool t=judge( num,count,number );
+        printf( t?"No\n":"Yes\n" );
+    }
+    return 0;    
+}
diff --git a/HDOJ/3827_autoAC.cpp b/HDOJ/3827_autoAC.cpp
new file mode 100644
index 0000000..d0354d9
--- /dev/null
+++ b/HDOJ/3827_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<string.h>
+#include<stdio.h>
+char ch[201];
+int xue[3] , sta[201] , n , flag = 1; 
+void init()
+{
+ int i; char t;
+ scanf("%d\n", &n);
+ for (i=1;i<=n;i++)
+ {
+ scanf("%c ", &ch[i]);
+ sta[i] = 0;
+ } 
+ for (i=1;i<=4;i++) sta[i] = 1;
+ for (i=5;i<=8;i++) sta[i] = 2;
+ xue[1] = 3; xue[2] = 3;
+}
+int find_need(char now , int x)
+{
+ int i;
+ for (i=1;i<=n;i++)
+ if (ch[i] == now && sta[i] == x) return i;
+ return 0;
+}
+int find(int x)
+{
+ int i;
+ for (i=1;i<=n;i++)
+ if (sta[i] == x) return i;
+ return 0; 
+}
+void deal()
+{
+ int i , j , t , x , tail , m , now = 0;
+ flag = 1; tail = 8; m = n;
+ while (1)
+ {
+ now++;
+ if (now > m+1) break;
+ if (tail + 1 <= m) sta[tail+1] = flag;
+ if (tail + 2 <= m) sta[tail+2] = flag;
+ if (tail+2 <= m) tail = tail + 2; else tail = m;
+ for (j=1;j<=n;j++)
+ if (ch[j] == 'S' && sta[j] == flag)
+ {
+ sta[j] = 3;
+ t = find_need('D' , 3-flag);
+ if (t == 0) 
+ {
+ x = find(3-flag); 
+ if (x == 0) continue;
+ sta[x] = 3;
+ n++; 
+ sta[n] = flag;
+ ch[n] = ch[x];
+ }
+ else sta[t] = 3;
+ }
+ for (j=1;j<=n;j++)
+ if (ch[j] == 'K' && sta[j] == flag)
+ {
+ sta[j] = 3;
+ t = find_need('E' , 3-flag);
+ if (t == 0)
+ {
+ xue[3-flag] --;
+ if (xue[3-flag] < 1) 
+ {
+ if (flag == 1) printf("The winner is the first.\n"); 
+ else printf("The winner is the second.\n"); 
+ return;
+ }
+ }
+ else sta[t] = 3; 
+ break; 
+ }
+ flag = 3-flag;
+ }
+ printf("Just a tie.\n");
+}
+int main()
+{
+ int i , tot;
+ scanf("%d", &tot);
+ for (i = 1; i<= tot;i++)
+ {
+ printf("Case %d: " , i); 
+ init();
+ deal(); 
+ }
+}
diff --git a/HDOJ/3828_autoAC.cpp b/HDOJ/3828_autoAC.cpp
new file mode 100644
index 0000000..a88252d
--- /dev/null
+++ b/HDOJ/3828_autoAC.cpp
@@ -0,0 +1,153 @@
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <stdlib.h>
+#include <vector>
+#include <math.h>
+#include <algorithm>
+#include <iostream>
+#define N 16
+#define M 1<<16
+#define MS 1000000009
+#define LL long long
+using namespace std;
+int n,goal;
+string str[N];
+LL da[N];
+int gra[N][N],mark[N];
+int slen[N];
+int dp[M][N];
+LL ans;
+void ini(void)
+{
+    goal=(1<<n)-1;
+    for(int i=0;i<n;i++)
+        str[i].clear();
+    for(int i=0;i<n;i++)
+    {
+        LL k=da[i];
+        while(k)
+        {
+            str[i].push_back((k&1)+'0');
+            k=k>>1;
+        }
+        int j=str[i].size();
+        string tempstr;
+        while(j--)
+            tempstr.push_back(str[i][j]);
+        str[i]=tempstr;
+    }
+    sort(str,str+n);
+    for(int i=0;i<n;i++)
+        slen[i]=str[i].size();
+    memset(mark,0,sizeof(mark));
+    for(int i=0;i<n;i++)
+        for(int j=0;j<n;j++)
+            if(i!=j&&slen[i]>slen[j])
+                for(int k1=0;k1<slen[i]-slen[j]+1;k1++)
+                {
+                    int flag=0;
+                    for(int k2=0;k2<slen[j];k2++)
+                        if(str[i][k1+k2]!=str[j][k2])
+                        {
+                            flag=1;
+                            break;
+                        }
+                    if(flag==0)
+                    {
+                        if(!mark[j])
+                        {
+                            mark[j]=1;
+                            goal-=(1<<j);
+                        }
+                        break;
+                    }
+                }
+    for(int i=0;i<n-1;i++)
+        for(int j=i+1;j<n;j++)
+            if(!mark[i]&&!mark[j]&&str[i]==str[j])
+                mark[j]=1,goal-=(1<<j);
+    memset(gra,0,sizeof(gra));
+    for(int i=0;i<n;i++)
+        for(int j=0;j<n;j++)
+            if(!mark[i]&&!mark[j]&&i!=j)
+                for(int k=0;k<slen[i];k++)
+                {
+                    int flag=0;
+                    for(int u=0;u+k<slen[i];u++)
+                        if(str[i][k+u]!=str[j][u])
+                        {
+                            flag=1;
+                            break;
+                        }
+                    if(!flag)
+                    {
+                        gra[i][j]=slen[i]-k;
+                        break;
+                    }
+                }
+}
+void dfs(int s,int p)
+{
+    if(~dp[s][p])return ;
+    if(s==(1<<p))
+    {
+        dp[s][p]=slen[p];
+        return ;
+    }
+    int minn=0x3f3f3f3f;
+    int t=s-(1<<p);
+    for(int i=0;i<n;i++)
+        if(!mark[i]&&i!=p&&(s&(1<<i)))
+        {
+            dfs(t,i);
+            minn=min(minn,dp[t][i]-gra[p][i]);
+        }
+    dp[s][p]=minn+slen[p];
+}
+void rans(int s,int p,int e)
+{
+    for(int i=e;i<slen[p];i++)
+        ans=(ans*2+str[p][i]-'0')%MS;
+    if(s==(1<<p))return ;
+    int t=s-(1<<p);
+    int k=-1;
+    string a;
+    for(int i=0;i<n;i++)
+        if(!mark[i]&&(s&(1<<i))&&dp[t][i]-gra[p][i]+slen[p]==dp[s][p])
+        {
+            string b(str[i],gra[p][i],slen[p]-gra[p][i]);
+            if(k==-1||a>b)
+                a=b,k=i;
+        }
+    rans(t,k,gra[p][k]);
+}
+void re(void)
+{
+    for(int i=0;i<n;i++)
+        scanf("%lld",&da[i]);
+}
+void run(void)
+{
+    ini();
+    memset(dp,-1,sizeof(dp));
+    for(int i=0;i<n;i++)
+        if(!mark[i])
+            dfs(goal,i);
+    int p,minn=0x3f3f3f3f;
+    for(int i=0;i<n;i++)
+        if(!mark[i]&&dp[goal][i]<minn)
+            p=i,minn=dp[goal][i];
+    ans=0;
+    rans(goal,p,0);
+    printf("%lld\n",ans);
+}
+int main()
+{
+    while(scanf("%d",&n)!=EOF)
+    {
+        re();
+        run();
+    }
+    return 0;
+}
diff --git a/HDOJ/3829_autoAC.cpp b/HDOJ/3829_autoAC.cpp
new file mode 100644
index 0000000..ef58a52
--- /dev/null
+++ b/HDOJ/3829_autoAC.cpp
@@ -0,0 +1,72 @@
+#include<iostream>
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define M 510
+#define N 250010
+int Head[M], Next[N], Key[N];
+int match[M];
+string like[M], dislike[M]; 
+bool use[M];
+int num;
+int child;
+void add(int u, int v) 
+{
+    Key[num] = v;
+    Next[num] = Head[u];
+    Head[u] = num++;
+}
+bool find(int u) 
+{
+    int temp;
+    for(int i = Head[u]; i != -1; i = Next[i])
+    {
+        temp = Key[i];
+        if(!use[temp])
+        {
+            use[temp] = true;
+            if(match[temp] == -1 || find(match[temp]))
+            {
+                match[temp] = u;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int hungary() 
+{
+    int sum = 0;
+    for(int i = 0; i < child; ++i)
+    {
+        memset(use, false, sizeof(use));
+        if(find(i))
+            sum++;
+    }
+    return sum;
+}
+int main()
+{
+    int cat, dog;
+    string likeit, dislikeit;
+    while(scanf("%d%d%d", &cat, &dog, &child) != EOF)
+    {
+        num = 0;
+        memset(Head, -1, sizeof(Head));
+        memset(match, -1, sizeof(match));
+        for(int i = 0; i < child; ++i)
+        {
+            cin>>likeit>>dislikeit; 
+            like[i] = likeit; 
+            dislike[i] = dislikeit;
+        }
+        for(int i = 0; i < child; ++i) 
+            for(int j = 0; j < child; ++j)
+                if(like[i].compare(dislike[j]) == 0 || dislike[i].compare(like[j]) == 0) 
+                    add(i, j);
+        printf("%d\n", child - hungary() / 2); 
+    }
+    return 0;
+}
diff --git a/HDOJ/3830_autoAC.cpp b/HDOJ/3830_autoAC.cpp
new file mode 100644
index 0000000..aa18358
--- /dev/null
+++ b/HDOJ/3830_autoAC.cpp
@@ -0,0 +1,129 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <algorithm>
+using namespace std;
+#define ll __int64
+struct State
+{
+    ll x,y,z;
+    ll dep;
+};
+State S,T;
+inline bool cmp_state(State a , State b)
+{
+    if(a.x == b.x && a.y == b.y && a.z == b.z) 
+        return true;
+    return false;
+}
+inline ll Abs(ll x)
+{
+    return x > 0LL ? x : -x;
+}
+inline void SORT(State &a)
+{
+    if(a.y < a.x) swap(a.x , a.y);
+    if(a.z < a.x) swap(a.x , a.z);
+    if(a.y > a.z) swap(a.y , a.z);
+}
+State Root(State &a)
+{
+    State tmp = a;
+    tmp.dep = 0;
+    ll dep = 0;
+    while(Abs(tmp.x - tmp.y) != Abs(tmp.y - tmp.z))
+    {
+        ll len = Abs(tmp.x - tmp.y);
+        ll __len = Abs(tmp.y- tmp.z);
+        if(__len > len)
+        {
+            ll c = (__len - 1)/ len; 
+            dep += c;
+            tmp.y += c * len;
+            tmp.x += c * len;
+        }
+        else
+        {
+            ll c = (len - 1) / __len;
+            dep += c;
+            tmp.y -= c * __len;
+            tmp.z -= c * __len;
+        }
+//        printf("%d  %d  %d\n",tmp.x , tmp.y , tmp.z);
+    }
+    a.dep = dep;
+    return tmp;
+}
+void updata(State &a ,ll delta)
+{
+    ll count = 0;
+    while(count < delta)
+    {
+        ll len = Abs(a.x - a.y);
+        ll __len = Abs(a.y - a.z);
+        ll k = Abs(count - delta); 
+        if(len < __len)
+        {
+            ll c = (__len - 1) / len; 
+            ll Min = min(k , c);
+            a.x += Min * len;
+            a.y += Min * len;
+            count += Min;
+            if(Min == k) break;
+        }
+        else
+        {
+            ll c = (len - 1) / __len;
+            ll Min = min(k , c);
+            a.y -= Min * __len;
+            a.z -= Min * __len;
+            count += Min;
+            if(Min == k) break;
+        }
+    }
+    a.dep -= delta;
+}
+ll solve()
+{
+    State tS,tT;
+    ll low = 0 , high = S.dep;
+    while(low <= high)
+    {
+        ll mid = (low + high) >> 1;
+        ll delta = S.dep - mid;
+        tS = S; tT = T;
+        updata(tS , delta); //SORT(tS);
+        updata(tT , delta); //SORT(tT);
+        if(!cmp_state(tS , tT))
+            high = mid - 1;
+        else
+            low = mid + 1;
+    }
+    return 2 * (S.dep - high);
+}
+int main()
+{ 
+    while( scanf("%I64d%I64d%I64d",&S.x,&S.y,&S.z) != EOF)
+    {
+        scanf("%I64d%I64d%I64d",&T.x,&T.y,&T.z);
+        S.dep = T.dep = 0;
+        SORT(S); SORT(T);
+        State RS = Root(S);
+        State RT = Root(T);
+        if(!cmp_state(RS,RT)) 
+        {
+            printf("NO\n");
+            continue;
+        }
+        ll tmpr = Abs(S.dep - T.dep); 
+        if(S.dep > T.dep)
+            updata(S , S.dep - T.dep);
+        else
+            updata(T , T.dep - S.dep);
+        ll res = solve();
+        printf("YES\n");
+        printf("%I64d\n",res + tmpr);
+    }
+    return 0;
+}
diff --git a/HDOJ/3831_autoAC.cpp b/HDOJ/3831_autoAC.cpp
new file mode 100644
index 0000000..59b03e2
--- /dev/null
+++ b/HDOJ/3831_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<stack>
+#include<set>
+#include<cmath>
+#include<vector>
+using namespace std;
+#define mod 1000000007
+#define inf 0x7f7f7f7f
+#define N 505
+int dp[N][N][55];
+char s[N],p[N];
+int  a[N],b[N];
+int la, lb;
+int main()
+{
+    int i, j, k, u, v;
+    while(scanf("%s",s+1),s[1]!='#'){
+        scanf("%s",p+1);
+        for(i=1;s[i];i++)if(islower(s[i]))a[i] = s[i]-'a';else a[i] = s[i]-'A'+26;
+        for(i=1;p[i];i++)if(islower(p[i]))b[i] = p[i]-'a';else b[i] = p[i]-'A'+26;
+        memset(dp, inf, sizeof dp);
+        la = strlen(s+1), lb = strlen(p+1);
+        dp[0][0][52] = 0;
+        for(i = 1; i <= la; i++)dp[0][i][52]=dp[i][0][52] = i;
+        for(i = 1; i <= la; i++)
+        {
+            for(j = 1; j <= lb; j++)
+            {
+                for(k = 0; k < 52; k++)
+                {
+                    u = inf;
+                    if(b[j]==k)
+                        u = dp[i-1][j-1][k];
+                    else 
+                    {
+                    u = min(u, dp[i-1][j][k]+1);
+                    u = min(u, dp[i][j-1][k]+1);
+                    u = min(u, dp[i-1][j-1][k] +1);
+                    dp[i][j][b[j]] = min(dp[i][j][b[j]],dp[i-1][j-1][k]+1);
+                    }
+                    dp[i][j][k] = min(u, dp[i][j][k]);
+                }
+                u = inf;
+                if(a[i]==b[j])
+                    u = dp[i-1][j-1][52];
+                else {
+                    u = min(u, dp[i-1][j][52]+1);
+                    u = min(u, dp[i][j-1][52]+1);
+                    u = min(u, dp[i-1][j-1][52] +1);
+                    dp[i][j][b[j]] = min(dp[i][j][b[j]], dp[i-1][j-1][52]+1);
+                }
+                dp[i][j][52] = min(dp[i][j][52], u);
+            }
+        }
+        int ans = 1000000000;
+        for(i = 0; i <= 52; i++)ans = min(ans, dp[la][lb][i]);
+        printf("%d\n",ans);    
+    }
+    return 0;
+}
diff --git a/HDOJ/3832_autoAC.cpp b/HDOJ/3832_autoAC.cpp
new file mode 100644
index 0000000..8c3e64a
--- /dev/null
+++ b/HDOJ/3832_autoAC.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <queue>
+#include <cstdlib>
+#define inf 99999999
+using namespace std;
+int map[205][205];
+struct node
+{
+    int x,y,r;
+};
+node a[205];
+int d1[205];
+int d2[205];
+int d3[205];
+int n;
+void bfs(int u,int *d)
+{
+    int i;
+    for(i=1;i<=n;i++)
+        d[i]=inf;
+    int vis[205];
+    memset(vis,0,sizeof(vis));
+    queue<int> q;
+    q.push(u);
+    vis[u]=1;
+    d[u]=0;
+    while(!q.empty())
+    {
+        u=q.front();
+        q.pop();
+        int i;
+        for(i=1;i<=n;i++)
+        {
+            if(!vis[i]&&map[u][i])
+            {
+                vis[i]=1;
+                d[i]=d[u]+1;
+                q.push(i);
+            }
+        }
+    }
+}
+inline int dis(node a,node b)
+{
+    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
+}
+inline int isarc(node a,node b)
+{
+    if(dis(a,b)<=(a.r+b.r)*(a.r+b.r))
+        return 1;
+    else
+        return 0;
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    int cas;
+    for(cas=0;cas<t;cas++)
+    {
+        memset(a,0,sizeof(a));
+        memset(map,0,sizeof(map));
+        scanf("%d",&n);
+        int i;
+        for(i=1;i<=n;i++)
+            scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].r);
+        int j;
+        for(i=1;i<=n;i++)
+        {
+            for(j=i+1;j<=n;j++)
+            {
+                if(isarc(a[i],a[j]))
+                    map[i][j]=map[j][i]=1;
+            }
+        }
+        bfs(1,d1);
+        bfs(2,d2);
+        bfs(3,d3);
+        int res=inf;
+        for(i=1;i<=n;i++)
+        {
+            if(d1[i]!=inf&&d2[i]!=inf&&d3[i]!=inf&&d1[i]+d2[i]+d3[i]<res)   
+                res=d1[i]+d2[i]+d3[i];
+        }
+        if(res==inf)
+            printf("-1\n");
+        else
+            printf("%d\n",n-res-1);
+    }
+    return 0;
+}
diff --git a/HDOJ/3833_autoAC.cpp b/HDOJ/3833_autoAC.cpp
new file mode 100644
index 0000000..6326409
--- /dev/null
+++ b/HDOJ/3833_autoAC.cpp
@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int a[10005];
+int has[10005];
+int main()
+{
+    int t,n,i,j;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(i = 0; i<n; i++)
+        {
+            scanf("%d",&a[i]);
+            has[a[i]] = i;
+        }
+        int flag = 0;
+        for(i = 0; i<n; i++)
+        {
+            for(j = i+1; j<n; j++)
+            {
+                int s = a[i]+a[j];
+                if(s%2)
+                continue;
+                if(has[s/2]>i && has[s/2]<j)
+                {
+                    flag = 1;
+                    break;
+                }
+            }
+            if(flag)
+                break;
+        }
+        printf("%s\n",flag?"Y":"N");
+    }
+    return 0;
+}
diff --git a/HDOJ/3834_autoAC.cpp b/HDOJ/3834_autoAC.cpp
new file mode 100644
index 0000000..300a0d9
--- /dev/null
+++ b/HDOJ/3834_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+const double eps=1e-12;
+const double pi=acos(-1.0);
+using namespace std;
+typedef long long ll;
+inline double sqr(double x)
+{
+    return x*x;
+}
+struct point
+{
+    double x, y, r;
+    point(){}
+    point(double _x, double _y, double _r){x=_x;y=_y;r=_r;}
+    void read(){scanf("%lf%lf%lf", &x, &y, &r);}
+    point operator -(const point &tp)const
+    {
+        return point(x-tp.x, y-tp.y, r-tp.r);
+    }
+    point operator +(const point &tp)const
+    {
+        return point(x+tp.x, y+tp.y, r+tp.r);
+    }
+    point operator *(const double &k)const
+    {
+        return point(x*k, y*k, r*k);
+    }
+}table, ball;
+double dx, dy, tot;
+int cross(point op, point sp, point ep)
+{
+    double ans=(sp.y-op.y)*(ep.x-op.x)-(ep.y-op.y)*(sp.x-op.x);
+    if(ans>eps)return 1;
+    return -1;
+}
+double angle(point a, point b)
+{
+    double area=a.x*b.x+a.y*b.y;
+    double ablen=sqrt((a.x*a.x+a.y*a.y)*(b.x*b.x+b.y*b.y));
+    return acos(area/ablen);
+}
+int main()
+{
+    int ca;
+    scanf("%d", &ca);
+    while(ca-->0)
+    {
+        table.read();
+        ball.read();
+        scanf("%lf%lf%lf", &dx, &dy, &tot);
+        ball.x-=table.x;
+        ball.y-=table.y;
+        table.r-=ball.r;
+        double a=sqr(dx)+sqr(dy);
+        double b=2.0*(ball.x*dx*1.0+ball.y*dy*1.0);
+        double c=sqr(ball.x)+sqr(ball.y)-sqr(table.r);
+        double sti=(sqrt(sqr(b)-4.0*a*c)-b)/(2.0*a);
+        if(sti-tot>eps)
+        {
+            printf("%.1lf %.1lf\n", (ball.x+tot*dx+table.x), (ball.y+tot*dy+table.y));
+            continue;
+        }
+        point zero=point(0, 0, 0);
+        point first=point(sti*dx+ball.x, sti*dy+ball.y, 0);
+        int dir=cross(zero, first, ball);
+        double ref=angle(ball-first, zero-first);
+        double dis=cos(ref)*table.r*2;
+        double v=sqrt(dx*dx+dy*dy);
+        tot-=sti;
+        double len=tot*v;
+        double dti=len/dis;
+        ll lti=(ll)(dti+eps);
+        double perti=dis/v;
+        double left=tot-perti*lti;
+        double pang=(pi-2*ref)*lti;
+        double stang=atan2(first.y, first.x);
+        stang=stang+pang*dir;
+        point now=point(cos(stang)*table.r, sin(stang)*table.r, 0);
+        double vang=stang+(pi-2*ref)*dir;
+        point next=point(cos(vang)*table.r, sin(vang)*table.r, 0);
+        double rate=left/perti;
+        point vec=next-now;
+        now=now+(vec*rate);
+        printf("%.1lf %.1lf\n", now.x+table.x, now.y+table.y);
+    }
+    return 0;
+}
diff --git a/HDOJ/3835_autoAC.cpp b/HDOJ/3835_autoAC.cpp
new file mode 100644
index 0000000..dfec130
--- /dev/null
+++ b/HDOJ/3835_autoAC.cpp
@@ -0,0 +1,29 @@
+#include<stdio.h>
+#include<math.h>
+int main()
+{
+    int k,i,j,n,ans;
+    while(~scanf("%d",&n))
+    {
+        if(!n)
+        {
+            printf("1\n");
+            continue;
+        }
+        ans=0;
+        k=(int)sqrt(n/2.0);
+        for(i=0;i<=k;++i)
+        {
+            j=(int)sqrt(n-i*i);
+            if(i*i+j*j==n)
+            {
+                if(i==j||i==0||j==0)  
+                    ans+=4;
+                else
+                    ans+=8;   
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3836_autoAC.cpp b/HDOJ/3836_autoAC.cpp
new file mode 100644
index 0000000..9c2516e
--- /dev/null
+++ b/HDOJ/3836_autoAC.cpp
@@ -0,0 +1,97 @@
+#include"stdio.h"
+#include"string.h"
+#include"stdlib.h"
+#include"stack"
+#define N 30000
+using namespace std;
+int n,m;
+int index_s;
+int instack[N],DFN[N],LOW[N];
+int belong[N],indegree[N],outdegree[N];
+struct Eage
+{
+    int from,to,next;
+}eage[2*N];
+int tot,head[N];
+void add(int a,int b)
+{
+    eage[tot].from=a;
+    eage[tot].to=b;
+    eage[tot].next=head[a];
+    head[a]=tot++;
+}
+void getmap()
+{
+    int i,l;
+    int a,b;
+    tot=0;
+    memset(head,-1,sizeof(head));
+    while(m--)  {scanf("%d%d",&a,&b);add(a,b);}
+}
+stack<int>st;
+void Tarjan(int k)
+{
+    int j,v;
+    st.push(k);
+    instack[k]=1;
+    DFN[k]=LOW[k]=++index_s;
+    for(j=head[k];j!=-1;j=eage[j].next)
+    {
+        v=eage[j].to;
+        if(instack[v])  LOW[k]=LOW[k]>DFN[v]?DFN[v]:LOW[k];
+        else if(DFN[v]==-1)
+        {
+            Tarjan(v);
+            LOW[k]=LOW[k]>LOW[v]?LOW[v]:LOW[k];
+        }
+    }
+    if(DFN[k]==LOW[k])
+    {
+        do
+        {
+            j=st.top();
+            st.pop();
+            instack[j]=0;
+            belong[j]=k;
+        }while(j!=k);
+    }
+}
+void getdegree()
+{
+    int i,l;
+    memset(indegree,0,sizeof(indegree));
+    memset(outdegree,0,sizeof(outdegree));
+    for(i=0;i<tot;i++)
+    {
+        if(belong[eage[i].from]==belong[eage[i].to])    continue;
+        indegree[belong[eage[i].to]]++;
+        outdegree[belong[eage[i].from]]++;
+    }
+}
+int main()
+{
+    int i;
+    int temp,t1,t2,ans;
+    while(scanf("%d%d",&n,&m)!=-1)
+    {
+        getmap();
+        index_s=0;
+        memset(DFN,-1,sizeof(DFN));
+        memset(LOW,-1,sizeof(LOW));
+        memset(instack,0,sizeof(instack));
+        for(i=1;i<=n;i++)   if(DFN[i]==-1) Tarjan(i);
+        getdegree();
+        temp=t1=t2=0;
+        for(i=1;i<=n;i++)
+        {
+            if(belong[i]!=i)    continue;
+            temp++;
+            if(indegree[i]==0)  t1++;
+            if(outdegree[i]==0) t2++;
+        }
+        ans=t1>t2?t1:t2;
+        if(n<1 || temp==1) ans=0;
+        printf("%d\n",ans);
+   }
+    return 0;
+}
diff --git a/HDOJ/3838_autoAC.cpp b/HDOJ/3838_autoAC.cpp
new file mode 100644
index 0000000..16e50a5
--- /dev/null
+++ b/HDOJ/3838_autoAC.cpp
@@ -0,0 +1,160 @@
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#include <cstring>
+#define PI pair
+#define MP make_pair
+#define FI first
+#define SE second
+const double eps = 1e-8;
+const double pi = acos(-1.);
+using namespace std;
+struct point
+{
+    int x, y;
+    bool operator<( const point r )    const
+    {
+        if( x == r.x )    return y < r.y;
+        return x < r.x;
+    }
+    point( int _x = 0, int _y = 0 ) : x(_x), y(_y){}
+} A[10], B[10], C[10];
+struct T
+{
+    point rot, tra;
+} ans[40000];
+int snap( double x )
+{
+    if( x < 0 )    return -snap(-x);
+    return (int)(x+0.5);
+}
+void rot( double rx, double ry )
+{
+    double d, ang = atan2(ry, rx);
+    for( int i = 0; i < 3; ++i )
+    {
+        d = atan2(A[i].y+0., A[i].x+0.);
+        double L = sqrt(A[i].x*A[i].x + A[i].y*A[i].y + 0.);
+        C[i].x = snap(L*cos(d+ang));
+        C[i].y = snap(L*sin(d+ang));
+    }
+}
+int e;
+bool line;
+void solve( int rx, int ry )
+{
+    rot(rx, ry);
+    int i, j, k;
+    int kx, cx, ky, cy;
+    bool st;
+    sort(C, C+3);
+    do
+    {
+        st = 0;
+        if( C[1].x - C[2].x )
+        {
+            if( B[1].x-B[2].x == 0 )    continue;
+            if( (B[1].x-B[2].x)%(C[1].x-C[2].x) == 0 )
+            {
+                kx = (B[1].x-B[2].x)/(C[1].x-C[2].x);
+                cx = B[1].x-C[1].x*kx;
+            }
+            else    continue;
+        }
+        else if( C[0].x - C[1].x )
+        {
+            if( B[0].x-B[1].x == 0 )    continue;
+            if( (B[0].x-B[1].x)%(C[0].x-C[1].x) == 0 )
+            {
+                kx = (B[0].x-B[1].x)/(C[0].x-C[1].x);
+                cx = B[0].x-C[0].x*kx;
+            }
+            else    continue;
+        }
+        else
+        {
+            if( B[0].x == B[1].x && B[0].x == B[2].x )
+            {
+                kx = 1, cx = B[0].x-C[0].x*kx;
+                st = 1;
+            }
+            else    continue;
+        }
+        if( C[1].y - C[2].y )
+        {
+            if( B[1].y-B[2].y == 0 )    continue;
+            if( (B[1].y-B[2].y)%(C[1].y-C[2].y) == 0 )
+            {
+                ky = (B[1].y-B[2].y)/(C[1].y-C[2].y);
+                cy = B[1].y-C[1].y*ky;
+            }
+            else    continue;
+        }
+        else if( C[0].y - C[1].y )
+        {
+            if( B[0].y-B[1].y == 0 )    continue;
+            if( (B[0].y-B[1].y)%(C[0].y-C[1].y) == 0 )
+            {
+                ky = (B[0].y-B[1].y)/(C[0].y-C[1].y);
+                cy = B[0].y-C[0].y*ky;
+            }
+            else    continue;
+        }
+        else
+        {
+            if( B[0].y == B[1].y && B[0].y == B[2].y )
+            {
+                ky = 1, cy = B[0].y-C[0].y*ky;
+                st = 1;
+            }
+            else    continue;
+        }
+        for( i = 0; i < 3; ++i )
+        {
+            if( B[i].x != C[i].x*kx + cx )    break;
+            if( B[i].y != C[i].y*ky + cy )    break;
+        }
+        if( i != 3 )    continue;
+        ans[e].rot = point(rx, ry);
+        ans[e].tra = point(kx, ky);
+        e++;
+        if( st )    line = 1;
+    } while( next_permutation(C, C+3) );
+}
+int main()
+{
+    int cases = 1;
+    int i, j, k;
+    double d;
+    while( 1 )
+    {
+        for( i = 0; i < 3; ++i )
+            scanf("%d %d", &A[i].x, &A[i].y);
+        if( !A[0].x && !A[0].y && !A[1].x && !A[1].y && !A[2].x && !A[2].y )
+            break;
+        for( i = 0; i < 3; ++i )
+            scanf("%d %d", &B[i].x, &B[i].y);
+        e = 0;
+        line = 0;
+        for( i = -10; i <= 10; ++i )
+        {
+            solve(i, 10);    solve(i, -10);
+            solve(10, i);    solve(-10, i);
+        }
+        for( i = 1; i < e; ++i )
+        {
+            if( ans[i].rot.x == ans[i-1].rot.x && ans[i].rot.y == ans[i-1].rot.y &&
+                ans[i].tra.x == ans[i-1].tra.x && ans[i].tra.y == ans[i-1].tra.y )
+                continue;
+            if( ans[i].rot.x == -ans[i-1].rot.x && ans[i].rot.y == -ans[i-1].rot.y &&
+                ans[i].tra.x == -ans[i-1].tra.x && ans[i].tra.y == -ans[i-1].tra.y )
+                continue;
+            break;
+        }
+        printf("Case %d: ", cases++);
+        if( e == 0 )    puts("no solution");
+        else if( line || i < e )    puts("inconsistent solutions");
+        else    puts("equivalent solutions");
+    }
+    return 0;
+}
diff --git a/HDOJ/3839_autoAC.cpp b/HDOJ/3839_autoAC.cpp
new file mode 100644
index 0000000..c371a46
--- /dev/null
+++ b/HDOJ/3839_autoAC.cpp
@@ -0,0 +1,101 @@
+#include <cstdio>
+#include <iostream>
+#include <cstring>
+#include <cstdlib>
+#include <vector>
+#include <map>
+using namespace std;
+int H,W;
+char Map[220][440];
+int vis[220][440];
+int chr[220][440];
+int wblc_cnt,bblc_cnt;
+char hie[6]={'W','A','K','J','S','D'};
+int dx[4]={0,0,1,-1};
+int dy[4]={1,-1,0,0};
+map<int,bool> Hsh[80010];
+int bccnt[80010];
+char ans[80010];
+int comp(const void *_a,const void *_b)
+{
+    char a=*(char *)_a;
+    char b=*(char *)_b;
+    return a-b;
+}
+void dfs1(int x,int y)
+{
+    vis[x][y]=wblc_cnt;
+    int nx,ny;
+    for(int i=0;i<4;i++){
+        nx=dx[i]+x;
+        ny=dy[i]+y;
+        if(nx>=0&&nx<H&&ny>=0&&ny<W && !vis[nx][ny]  && Map[nx][ny]=='0')dfs1(nx,ny);
+    }
+}
+void dfs2(int x,int y)
+{
+    chr[x][y]=bblc_cnt;
+    int nx,ny;
+    for(int i=0;i<4;i++){
+        nx=dx[i]+x;
+        ny=dy[i]+y;
+        if(nx>=0&&nx<H&&ny>=0&&ny<W&&!chr[nx][ny]){
+            if(Map[nx][ny]=='0'){
+                if(Hsh[bblc_cnt].find(vis[nx][ny]) != Hsh[bblc_cnt].end())continue;
+                Hsh[bblc_cnt].insert(pair<int,bool>(vis[nx][ny],true));
+            }else dfs2(nx,ny);
+        }
+    }
+}
+int main()
+{
+    char str[60];
+    int kase=1;
+    while(~scanf("%d%d",&H,&W)&&(H+W)){
+        printf("Case %d: ",kase++);
+        getchar();
+        memset(Map,0,sizeof(Map));
+        memset(vis,0,sizeof(vis));
+        memset(chr,0,sizeof(chr));
+        for(int i=0;i<=4*W+8;i++)Map[0][i]=Map[H+1][i]='0';
+        for(int i=1;i<=H;i++){
+            gets(str);
+            for(int j=0;j<4;j++)
+                Map[i][j]=Map[i][4+W*4+j]='0';
+            for(int j=0;j<W;j++){
+                int x;
+                if('0'<=str[j] && str[j]<='9')
+                    x=str[j]-'0';
+                else
+                    x=10+str[j]-'a';
+                for(int k=0;k<4;k++){
+                    if(x & 1<<(3-k)) Map[i][4+j*4+k]='1';
+                    else Map[i][4+j*4+k]='0';
+                }
+            }
+        }
+        W+=2;W*=4;
+        H+=2;
+        wblc_cnt=0;
+        for(int i=0;i<H;i++)for(int j=0;j<W;j++)
+            if(vis[i][j]==0 && Map[i][j]=='0'){
+                wblc_cnt++;
+                dfs1(i,j);
+            }
+        bblc_cnt=0;
+        for(int i=0;i<H*W;i++) Hsh[i].clear();
+        for(int i=0;i<H;i++)for(int j=0;j<W;j++)
+            if(chr[i][j]==0 && Map[i][j]=='1'){
+                bblc_cnt++;
+                dfs2(i,j);
+            }
+        for(int i=1;i<=bblc_cnt;i++)
+            bccnt[i]=Hsh[i].size();
+        for(int i=1;i<=bblc_cnt;i++)
+            ans[i]=hie[bccnt[i]-1];
+        qsort(ans+1,bblc_cnt,sizeof(char),comp);
+        ans[bblc_cnt+1]='\0';
+        puts(ans+1);
+    }
+    return 0;
+}
diff --git a/HDOJ/3841_autoAC.cpp b/HDOJ/3841_autoAC.cpp
new file mode 100644
index 0000000..464cc67
--- /dev/null
+++ b/HDOJ/3841_autoAC.cpp
@@ -0,0 +1,63 @@
+#include <cstdio>
+#include <algorithm>
+#include <vector>
+using namespace std;
+const int maxn=1010;
+int s[maxn*2][maxn*2];
+int get(int x1,int y1,int x2,int y2)
+{
+    return s[x2][y2]+s[x1-1][y1-1]-s[x1-1][y2]-s[x2][y1-1];
+}
+int N;
+inline void gao(int &n)
+{
+        if(n<1)
+            n=1;
+        if(n>N)
+            n=N;
+}
+int main()
+{
+    int dx,dy,n,q,i,j,k;
+    int u,v;
+    int ii=0;
+    while(scanf("%d%d%d%d",&dx,&dy,&n,&q),dx+dy)
+    {
+        N=dx+dy;
+        for(i=1;i<=dx+dy;i++)
+            for(j=1;j<=dx+dy;j++)
+                s[i][j]=0;
+        while(n--)
+        {
+            scanf("%d%d",&u,&v);
+            s[u+v][v-u+dx]=1;
+        }
+        for(i=1;i<=dx+dy;i++)
+            for(j=1;j<=dx+dy;j++)
+                s[i][j]+=s[i][j-1];
+        for(i=1;i<=dx+dy;i++)
+            for(j=1;j<=dx+dy;j++)
+                s[i][j]+=s[i-1][j];
+printf("Case %d:\n",++ii);
+        while(q--)
+        {
+            int m;
+            scanf("%d",&m);
+            int ans=0,x,y;
+            int ansx=1,ansy=1;
+            for(j=1;j<=dy;j++)
+                for(i=1;i<=dx;i++)
+                {
+                    u=i,v=j-m;
+                    x=(u+v),y=(v-u+dx);
+                    u=x+m*2,v=y+m*2;
+                    gao(x),gao(y);
+                    gao(u),gao(v);
+                    u=get(x,y,u,v);
+                    if(u>ans)
+                        ans=u,ansx=i,ansy=j;
+                }
+            printf("%d (%d,%d)\n",ans,ansx,ansy);
+        }
+    }
+}
diff --git a/HDOJ/3842_autoAC.cpp b/HDOJ/3842_autoAC.cpp
new file mode 100644
index 0000000..433f1e1
--- /dev/null
+++ b/HDOJ/3842_autoAC.cpp
@@ -0,0 +1,79 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <cstdlib>
+#include <ctime>
+#include <set>
+#include <vector>
+#include <map>
+#define MAXN 11111
+#define MAXM 55555
+#define INF 1000000007
+using namespace std;
+long long f[111111];
+struct node {
+    int d, p, g, r;
+}p[111111];
+bool cmp(node x, node y) {
+    return x.d < y.d;
+}
+int n, d;
+typedef pair<int, long long> PA;
+PA A[111111], C[111111];
+long long h(int j) {
+    return f[j] + (long long)p[j].r - (long long)p[j].p - (long long)p[j].g * (long long)(p[j].d + 1);
+}
+int slopecomp(PA a, PA b, PA c) {
+    long long xa = b.first - a.first;
+    long long xb = c.first - a.first;
+    long long ya = b.second - a.second;
+    long long yb = c.second - a.second;
+    double tmp = (double)xa * yb - (double)xb * ya;
+    return tmp < 0;
+}
+void cdq(int l, int r) {
+    if(l + 1 <= r) {
+        int m = (l + r) >> 1;
+        cdq(l, m);
+        int na = 0, nb = 0, nc = 0;
+        for(int j = l; j <= m; j++) {
+            if(f[j] >= p[j].p) A[na++] = PA(p[j].g, h(j));
+        }
+        sort(A, A + na);
+        for(int i = 0; i < na; i++) {
+            while(nc > 1 && !slopecomp(C[nc - 1], C[nc], A[i])) nc--;
+            C[++nc] = A[i];
+        }
+        int j = 0;
+        for(int i = m + 1; i <= r; i++) {
+            long long a1, a2, b1, b2, x;
+            x = p[i].d;
+            while(j < nc) {
+                a1 = C[j].first;
+                a2 = C[j + 1].first;
+                b1 = C[j].second;
+                b2 = C[j + 1].second;
+                if(a1 * x + b1 >= a2 * x + b2) break;
+                j++;
+            }
+            f[i] = max(f[i], (long long)C[j].first * x + C[j].second);
+        }
+        cdq(m + 1, r);
+    }
+}
+int main() {
+    int cas = 0;
+    while(scanf("%d%I64d%d", &n, &f[0], &d) != EOF) {
+        if(n == 0 && f[0] == 0 && d == 0) break;
+        for(int i = 1; i <= n; i++) scanf("%d%d%d%d", &p[i].d, &p[i].p, &p[i].r, &p[i].g);
+        sort(p + 1, p + n + 1, cmp);
+        ++n;
+        p[n].d = d + 1;
+        p[n].g = p[n].p = 0;
+        for(int i = 1; i <= n; i++) f[i] = f[0];
+        cdq(0, n);
+        printf("Case %d: %I64d\n", ++cas, f[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3843_autoAC.cpp b/HDOJ/3843_autoAC.cpp
new file mode 100644
index 0000000..4ca37a1
--- /dev/null
+++ b/HDOJ/3843_autoAC.cpp
@@ -0,0 +1,91 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+const double pi = acos(-1.);
+const double eps = 1e-8;
+using namespace std;
+int N;
+int a[1000];
+double ang[1000];
+int dcmp( double x )
+{
+    if( x < eps )    return -1;
+    if( x > eps )    return 1;
+    return 0;
+}
+bool chk( int s, int e, double R )
+{
+    double t = 2*R*R;
+    double sA = 0, mA = -1e30;
+    int id;
+    for( int i = s; i < e; ++i )
+    {
+        ang[i] = acos((t-a[i]*a[i])/t);
+        sA += ang[i];
+        if( mA < ang[i] )
+            mA = ang[i], id = i;
+    }
+    if( dcmp(sA-mA-pi) >= 0 )
+        return dcmp(sA-2*pi) <= 0;
+    else
+    {
+        ang[id] *= -1;
+        return dcmp(sA-mA+2*pi-mA - 2*pi) >= 0;
+    }
+}
+int cal( int s, int e, double& S )
+{
+    double ll = 0, rr = 1000000, R;
+    for( int i = s; i < e; ++i )
+        ll = max(ll, a[i]*0.5);
+    for( int T = 0; T < 80; ++T )
+    {
+        R = (ll+rr)/2;
+        if( chk(s, e, R) )
+            rr = R;
+        else
+            ll = R;
+    }
+    R = (ll+rr)/2;
+    S = 0;
+    for( int i = s; i < e; ++i )
+        S += R*R*sin(ang[i]);
+    S *= 0.5;
+    for( int i = s; i < e; ++i )    if( ang[i] < 0 )
+        return i;
+    return -1;
+}
+double f( int s, int e )
+{
+    if( e-s < 3 )    return 0;
+    int sum = 0, mv = a[s];
+    int i, j, k, id = s;
+    for( i = s; i < e; ++i )
+    {
+        sum += a[i];
+        if( a[i] > mv )
+            mv = a[i], id = i;
+    }
+    if( sum <= mv*2 )
+        return f(s, id)+f(id+1, e);
+    else
+    {
+        double S;
+        k = cal(s, e, S);
+        if( k < 0 )
+            return S;
+        return max(S, f(s, k)+f(k+1, e));
+    }
+}
+int main()
+{
+    int i, cases = 1;
+    while( scanf("%d", &N), N )
+    {
+        for( i = 0; i < N; ++i )
+            scanf("%d", &a[i]);
+        printf("Case %d: %.8lf\n", cases++, f(0, N));
+    }
+    return 0;
+}
diff --git a/HDOJ/3844_autoAC.cpp b/HDOJ/3844_autoAC.cpp
new file mode 100644
index 0000000..cbd28f9
--- /dev/null
+++ b/HDOJ/3844_autoAC.cpp
@@ -0,0 +1,129 @@
+#pragma comment(linker, "/STACK:102400000,102400000")  
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+#include<iostream>
+#include<vector>
+#include<stack>
+const int maxn=1e5+1000;
+const int maxm=maxn*2;
+using namespace std;
+struct Edge
+{
+    int u;
+    int v;
+    Edge(){}
+    Edge(int su,int sv)
+    {
+        u=su;
+        v=sv;
+    }
+};
+int e,n,m,nxt[maxm],head[maxn],pnt[maxm],dfn[maxn],low[maxn],iscut[maxn],bccno[maxn],dfs_clock,bcc_cnt;
+vector<int> bcc[maxn];
+stack<Edge> s;
+int dfs(int u,int fa)
+{
+    low[u]=dfn[u]=++dfs_clock;
+    int child=0;
+    for(int i=head[u];i!=-1;i=nxt[i])
+    {
+        if(!dfn[pnt[i]])
+        {
+            s.push(Edge(u,pnt[i]));
+            child++;
+            low[u]=min(low[u],dfs(pnt[i],u));
+            if(dfn[u]<=low[pnt[i]])
+            {
+                iscut[u]=true;
+                bcc_cnt++;
+                bcc[bcc_cnt].clear();
+                for(;;)
+                {
+                    Edge x=s.top();
+                    s.pop();
+                    if(bccno[x.u]!=bcc_cnt)
+                    {
+                        bcc[bcc_cnt].push_back(x.u);
+                        bccno[x.u]=bcc_cnt;
+                    }
+                    if(bccno[x.v]!=bcc_cnt)
+                    {
+                        bcc[bcc_cnt].push_back(x.v);
+                        bccno[x.v]=bcc_cnt;
+                    }
+                    if(x.u==u&&x.v==pnt[i])
+                        break;
+                }
+            }
+        }
+        else if(dfn[pnt[i]]<dfn[u]&&pnt[i]!=fa)
+        {
+            s.push(Edge(u,pnt[i]));
+            low[u]=min(low[u],dfn[pnt[i]]);
+        }
+    }
+    if(fa<0&&child==1)
+        iscut[u]=0;
+    return low[u];
+}
+void AddEdge(int u,int v)
+{
+    pnt[e]=v;nxt[e]=head[u];head[u]=e++;
+    pnt[e]=u;nxt[e]=head[v];head[v]=e++;
+}
+void find_bcc(int n)
+{
+    memset(dfn,0,sizeof(dfn));
+    memset(iscut,0,sizeof(iscut));
+    memset(bccno,0,sizeof(bccno));
+    dfs_clock=bcc_cnt=0;
+    for(int i=1;i<=n;i++)
+        if(!dfn[i])
+            dfs(i,-1);
+}
+void solve()
+{
+    find_bcc(n);
+    long long ans1=0,ans2=1;
+    for(int i=1;i<=bcc_cnt;i++)
+    {
+        int cut_cnt=0;
+        for(int j=0;j<bcc[i].size();j++)
+            if(iscut[bcc[i][j]])
+                cut_cnt++;
+        if(cut_cnt==1)
+        {
+            ans1++;
+            ans2*=(long long)(bcc[i].size()-cut_cnt);
+        }
+    }
+    if(bcc_cnt==1)
+    {
+        ans1=2;
+        ans2=bcc[1].size()*(bcc[1].size()-1)/2;
+    }
+    printf("%I64d %I64d\n",ans1,ans2);
+}
+int main()
+{
+    int cas=1;
+    while(scanf("%d",&m)&&m)
+    {
+        e=n=0;
+        memset(head,-1,sizeof(head));
+        while(!s.empty())
+            s.pop();
+        for(int i=0;i<m;i++)
+        {
+            int u,v;
+            scanf("%d%d",&u,&v);
+            n=max(n,u);
+            n=max(n,v);
+            AddEdge(u,v);
+        }
+        printf("Case %d: ",cas++);
+        solve();
+    } 
+    return 0;
+}
diff --git a/HDOJ/3845_autoAC.cpp b/HDOJ/3845_autoAC.cpp
new file mode 100644
index 0000000..338a40b
--- /dev/null
+++ b/HDOJ/3845_autoAC.cpp
@@ -0,0 +1,93 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#define PI pair<int, int>
+#define MP make_pair
+#define x first
+#define y second
+const int maxn = 100100;
+using namespace std;
+int N, m;
+inline bool in( int x, int y )
+{
+    return x >= -m && x <= m && y >= -m && y <= m;
+}
+PI p[maxn];
+PI a[maxn], b[maxn], c[maxn], d[maxn];
+int ea, eb, ec, ed;
+bool chk()
+{
+    int i, j, k;
+    ea = eb = ec = ed = -1;
+    for( i = 0; i < N; ++i )
+    {
+        if( in(p[i].x+m, p[i].y-m) )
+        {
+            while( ea >= 0 && a[ea].y >= p[i].y-m )    ea--;
+            if( ea >= 0 && a[ea].x==p[i].x+m )    continue;
+            a[++ea] = MP(p[i].x+m, p[i].y-m);
+        }
+        if( in(p[i].x+m, p[i].y+m) )
+        {
+            while( eb >= 0 && b[eb].y <= p[i].y+m )    eb--;
+            if( eb >= 0 && b[eb].x==p[i].x+m )    continue;
+            b[++eb] = MP(p[i].x+m, p[i].y+m);
+        }
+    }
+    for( i = N-1; i >= 0; --i )
+    {
+        if( in(p[i].x-m, p[i].y-m) )
+        {
+            while( ec >= 0 && c[ec].y >= p[i].y-m )    ec--;
+            if( ec >= 0 && c[ec].x==p[i].x-m )    continue;
+            c[++ec] = MP(p[i].x-m, p[i].y-m);
+        }
+        if( in(p[i].x-m, p[i].y+m) )
+        {
+            while( ed >= 0 && d[ed].y <= p[i].y+m )    ed--;
+            if( ed >= 0 && d[ed].x==p[i].x-m )    continue;
+            d[++ed] = MP(p[i].x-m, p[i].y+m);
+        }
+    }
+    int na = 0, nb = 0, nc = ec+1, nd = ed+1;
+    int v1, v2;
+    for( i = -m; i <= m; ++i )
+    {
+        if( nc > 0 && c[nc-1].x == i )    nc--;
+        if( nd > 0 && d[nd-1].x == i )    nd--;
+        v1 = m+1, v2 = -m-1;
+        if( na <= ea )    v1 = min(v1, a[na].y);
+        if( nb <= eb )    v2 = max(v2, b[nb].y);
+        if( nc <= ec )    v1 = min(v1, c[nc].y);
+        if( nd <= ed )    v2 = max(v2, d[nd].y);
+        if( v1-1 > v2 )    return 0;
+        if( na <= ea && a[na].x == i )    na++;
+        if( nb <= eb && b[nb].x == i )    nb++;
+    }
+    return 1;
+}
+int main()
+{
+    int i, j, k, cases = 1;
+    int ll, rr;
+    while( scanf("%d", &N), N+1 )
+    {
+        for( i = 0; i < N; ++i )
+            scanf("%d %d", &p[i].x, &p[i].y);
+        sort(p, p+N);
+        ll = -1, rr = 1000000;
+        while( rr-ll > 1 )
+        {
+            m = (ll+rr)/2;
+            if( chk() )
+                rr = m;
+            else
+                ll = m;
+        }
+        m = rr;
+        printf("Case %d: ", cases++);
+        if( chk() )    printf("%d\n", rr);
+        else    puts("never");
+    }
+    return 0;
+}
diff --git a/HDOJ/3846_autoAC.cpp b/HDOJ/3846_autoAC.cpp
new file mode 100644
index 0000000..b29871f
--- /dev/null
+++ b/HDOJ/3846_autoAC.cpp
@@ -0,0 +1,90 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+struct pnt
+{
+    int n,h,f;
+}p[1000];
+const int maxn=1000000;
+int cmp(pnt a,pnt b)
+{
+    if(a.n==b.n) return a.f<b.f;
+    return a.n<b.n;
+}
+int c;
+void init()
+{
+    long long i,x;
+    for(i=2;;i++)
+    {
+        x=i*(i+1)*(2*i+1)/6;
+        if(x>maxn) break;
+        p[c].n=x,p[c].h=i,p[c++].f=1;
+    }
+    x=1;
+    for(i=3;;i+=2)
+    {
+        x+=i*i;
+        if(x>maxn) break;
+        p[c].n=x,p[c].h=i,p[c++].f=0;
+    }
+    x=4;
+    for(i=4;;i+=2)
+    {
+        x+=i*i;
+        if(x>maxn) break;
+        p[c].n=x,p[c].h=i,p[c++].f=0;
+    }
+    sort(p,p+c,cmp);
+}
+int dp[maxn+5][12],pre[maxn+5][7];
+int sta[1000],top;
+int main()
+{
+    init();
+    int tot,i,j,tc=1;
+    for(i=0;i<=maxn;i++)
+        for(j=0;j<=8;j++)
+        dp[i][j]=21000;
+    dp[0][0]=-1;
+    int k;
+    for(i=0;i<=maxn;i++)
+    {
+        for(j=0;j<=6;j++)if(dp[i][j]<=10000)
+        for(k=dp[i][j]+1;k<c&&p[k].n+i<=maxn;k++)if(dp[i+p[k].n][j+1]>k)
+            dp[i+p[k].n][j+1]=k;
+    }
+    int ii=0;
+    while(scanf("%d",&tot),tot)
+    {
+        int ans=-1;
+        for(i=1;i<=6;i++)if(dp[tot][i]<=2100)
+        {
+        ans=i;
+        break;
+        }
+        printf("Case %d:",++ii);
+        if(ans<0)
+        {
+        puts(" impossible");
+        continue;
+        }
+        i=c;
+        while(ans--)
+        {
+        for(i--;i>=0;i--)if(tot>=p[i].n&&dp[tot-p[i].n][ans]<i)
+        {
+            printf(" %d",p[i].h);
+            if(p[i].f)
+            printf("H");
+            else
+            printf("L");
+            break;
+        }
+        tot-=p[i].n;
+        }
+        puts("");
+    }
+}
diff --git a/HDOJ/3847_autoAC.cpp b/HDOJ/3847_autoAC.cpp
new file mode 100644
index 0000000..f78e6ec
--- /dev/null
+++ b/HDOJ/3847_autoAC.cpp
@@ -0,0 +1,98 @@
+#include<stdio.h>
+#include<math.h>
+#include<string.h>
+#include<stdlib.h>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-8;
+const double pi = acos(-1.0);
+int n;
+struct point {
+    double x, y;
+    point operator - (const point& t) const {
+        point tmp;
+        tmp.x = x - t.x;
+        tmp.y = y - t.y;
+        return tmp;
+    }
+    point operator + (const point& t) const {
+        point tmp;
+        tmp.x = x + t.x;
+        tmp.y = y + t.y;
+        return tmp;
+    }
+    bool operator == (const point& t) const {
+        return fabs(x-t.x) < eps && fabs(y-t.y) < eps;
+    }
+}p[220]; 
+bool cmpxy(point a,point b)
+{
+    if(a.y!=b.y) return a.y<b.y;
+    return a.x<b.x;
+}
+double xmult(point p1,point p2,point p0){
+    return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
+}
+inline double cross(point a, point b, point c) {                  
+    return (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y); 
+}
+inline double dis(point a, point b) {                               
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+void Grahamxy(point *p, int &n) {                                    
+    if ( n < 3 ) 
+        return;
+    int i, m=0, top=1;
+    sort(p, p+n, cmpxy);    
+    for (i=n; i < 2*n-1; i++)
+        p[i] = p[2*n-2-i];
+    for (i=2; i < 2*n-1; i++) {
+        while ( top > m && cross(p[top], p[i], p[top-1]) < eps ) 
+            top--;
+        p[++top] = p[i];
+        if ( i == n-1 )    m = top;
+    }
+    n = top;
+}
+inline double PLdis(point p,point l1,point l2){                       
+    return fabs(cross(p,l1,l2))/dis(l1,l2);
+}
+void judge(point a,point b,double &len)
+{
+    double max=0;
+    for(int i=0;i<n;i++)
+    {
+        double tmp=PLdis(p[i],a,b);
+        if(tmp>max)
+            max=tmp;
+    }
+    len=max;
+}
+double solve()
+{
+     int i,j;
+     double tmp;
+     double ans=((__int64)1<<62);
+     for(i=0;i<n;i++)
+     {
+         judge(p[i],p[i+1],tmp);
+         if(tmp<ans)
+             ans=tmp;
+     }
+     return ans;
+}
+int main()
+{
+    int i,j;
+    int cases=1;
+    while(scanf("%d",&n),n)
+    {
+        for(i=0;i<n;i++)
+            scanf("%lf%lf",&p[i].x,&p[i].y);
+        Grahamxy(p,n);
+        p[n]=p[0];
+        double ans=solve();
+        printf("Case %d: %.2lf\n",cases++,ans+0.005);
+    }
+    return 0;
+}
diff --git a/HDOJ/3848_autoAC.cpp b/HDOJ/3848_autoAC.cpp
new file mode 100644
index 0000000..6bb3f49
--- /dev/null
+++ b/HDOJ/3848_autoAC.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <cstdio>
+using namespace std;
+const int inf=30000000;
+const int maxx=10003;
+struct Tree{
+    int v,we,next;
+};
+Tree tree[maxx*2];
+int head[maxx*2],pt;
+int dp_f[maxx],dp_s[maxx];
+void adde(int x,int y,int we){
+    tree[pt].v=y;
+    tree[pt].we=we;
+    tree[pt].next=head[x];
+    head[x]=pt++;
+}
+int min(int a,int b){
+    return a<b?a:b;
+}
+void dfs(int root,int pre){
+    bool mark=false;
+    for(int i=head[root];i;i=tree[i].next){
+        int v=tree[i].v;
+        if(pre==v)continue;
+        mark=true;
+        dfs(v,root);
+        if(dp_f[root]>(dp_f[v]+tree[i].we)){
+            dp_s[root]=dp_f[root];
+            dp_f[root]=dp_f[v]+tree[i].we;
+        }else if(dp_f[root]==dp_f[v]+tree[i].we){
+            dp_s[root]=dp_f[root];
+        }else{
+            dp_s[root]=min(dp_s[root],dp_f[v]+tree[i].we);
+        }
+    }
+    if(!mark)dp_f[root]=dp_s[root]=0;
+}
+int main(){
+    int n;
+    while(scanf("%d",&n)&&n){
+        pt=1;
+        int i,x,y,we,cnt;
+        cnt=0;
+        for(i=1;i<=n;i++){
+            dp_f[i]=dp_s[i]=inf;
+        }
+        memset(head,0,sizeof(head));
+        memset(tree,0,sizeof(tree));
+        for(i=2;i<=n;i++){
+            scanf("%d%d%d",&x,&y,&we);
+            adde(x,y,we);
+            adde(y,x,we);
+            if(x==1 || y==1)cnt++;
+        }
+        dfs(1,0);
+        int ans=1<<30;
+        for(i=1;i<=n;i++){
+            if(dp_f[i]==0 || dp_s[i]==0 ||dp_f[i]>20000000 ||dp_s[i]>20000000)continue;
+            ans=min(ans,dp_f[i]+dp_s[i]);
+        }
+        if(cnt==1)ans=min(ans,dp_f[1]);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3849_autoAC.cpp b/HDOJ/3849_autoAC.cpp
new file mode 100644
index 0000000..719f9f4
--- /dev/null
+++ b/HDOJ/3849_autoAC.cpp
@@ -0,0 +1,135 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <map>
+#include <string>
+#include <algorithm>
+#define INF 0x3f3f3f3f
+using namespace std;
+const int MAXN=300000;
+const int MAXM=600000;
+struct node
+{
+    int u,v;
+};
+node edge[MAXM];
+int first[MAXN],ne[MAXM],cc;
+int dfn[MAXN],low[MAXN],belong[MAXN];
+int ti,id,top;
+int stack[MAXN];
+int arc[MAXM]; 
+int arcid;       
+inline void add_edge(int u,int v)
+{
+    edge[cc].u=u;
+    edge[cc].v=v;
+    ne[cc]=first[u];
+    first[u]=cc;
+    cc++;
+}
+void tardfs(int u,int p)
+{
+    dfn[u]=low[u]=ti++;
+    stack[top++]=u;
+    int i;
+    int ff=1;
+    for(i=first[u];i!=-1;i=ne[i])
+    {
+        int v=edge[i].v;
+        if(v==p&&ff)       
+        {
+            ff=0;
+            continue;
+        }
+        if(dfn[v]==-1)
+        {
+            tardfs(v,u);
+            if(low[u]>low[v])
+                low[u]=low[v];
+            else if(low[v]>dfn[u])
+            {
+                arc[arcid]=i;   
+                arcid++;
+                id++;
+                for(stack[top]=-1;stack[top]!=v;)
+                {
+                    top--;
+                    belong[stack[top]]=id;
+                }
+            }
+        }
+        else if(low[u]>dfn[v])
+            low[u]=dfn[v];
+    }
+}
+int tarjan(int n)
+{
+    ti=1;               
+    id=0;               
+    top=0;         
+    arcid=0;            
+    memset(dfn,-1,sizeof(dfn));
+    memset(low,0,sizeof(low));
+    memset(belong,0,sizeof(belong));
+    tardfs(1,-1);
+    return id;
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        memset(first,-1,sizeof(first));
+        memset(ne,-1,sizeof(ne));
+        cc=0;
+        int n,m;
+        scanf("%d%d",&n,&m);
+        map<string,int> mp1;
+        map<int,string> mp2;
+        int cnt=1;
+        int i;
+        char str1[150],str2[150];
+        for(i=0;i<m;i++)
+        {
+            scanf("%s%s",str1,str2);
+            if(mp1[str1]==0)
+            {
+                mp1[str1]=cnt;
+                mp2[cnt]=str1;
+                cnt++;
+            }
+            if(mp1[str2]==0)
+            {
+                mp1[str2]=cnt;
+                mp2[cnt]=str2;
+                cnt++;
+            }
+            int u=mp1[str1];
+            int v=mp1[str2];
+            add_edge(u,v);
+            add_edge(v,u);
+        }
+        tarjan(n);
+        int flag=0;
+        for(i=1;i<=n;i++)
+        {
+            if(dfn[i]==-1)
+                flag=1;
+        }
+        if(flag)
+        {
+            printf("0\n");
+            continue;
+        }
+        sort(arc,arc+arcid);
+        printf("%d\n",arcid);
+        for(i=0;i<arcid;i++)
+        {
+            int x=arc[i];
+            x=min(x,x^1);
+            printf("%s %s\n",mp2[edge[x].u].c_str(),mp2[edge[x].v].c_str());
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3850_autoAC.cpp b/HDOJ/3850_autoAC.cpp
new file mode 100644
index 0000000..652d690
--- /dev/null
+++ b/HDOJ/3850_autoAC.cpp
@@ -0,0 +1,167 @@
+#include <stdio.h>
+#include <string.h>
+#define maxn 150
+#define mod 1000000007
+struct matrix{
+    int v[70][70];
+    void clear(){
+        memset(v,0,sizeof(v));
+    }
+} a,b;
+int st_num[maxn],stn;
+int n,m;
+int ans;
+int f[10][10][maxn];
+int q[2][maxn],qn[2];
+void dfs(int p,int mask,int st){
+    if (p==n){
+        if ((mask&(1<<n))==0){
+            a.v[st_num[st]][st_num[mask]]++;
+        }
+        return;
+    }
+    int c1=((mask>>p)&1),c2=((mask>>p+1)&1);
+    if (c1 && c2){
+        dfs(p+1,mask^(1<<p)^(1<<p+1),st);
+    }else
+    if (c1 || c2){
+        dfs(p+1,mask,st);
+        dfs(p+1,mask^(1<<p)^(1<<p+1),st);
+    }else{
+        dfs(p+1,mask^(1<<p)^(1<<p+1),st);
+    }
+}
+matrix mat_mul(matrix a,matrix b){
+    matrix c;
+    for (int i=0;i<stn;i++)
+        for (int j=0;j<stn;j++){
+            c.v[i][j]=0;
+            for (int k=0;k<stn;k++)
+                c.v[i][j]=(c.v[i][j]+(long long)a.v[i][k]*b.v[k][j])%mod;
+        }
+    return c;
+}
+matrix Mul(int p){
+    matrix ret,ta=a;
+    ret.clear();
+    for (int i=0;i<stn;i++) ret.v[i][i]=1;
+    while (p){
+        if ((p&1)>0) ret=mat_mul(ret,ta);
+        ta=mat_mul(ta,ta);
+        p>>=1;
+    }
+    return ret;
+}
+inline int getBit(int mask,int p){
+    return (mask>>p)&1;
+}
+inline void Add(int &x,int v){
+    x=(x+v)%mod;
+}
+int cal(int st1,int st2,int c1,int c2){
+    int ret=0;
+    int now=0,next;
+    qn[0]=1;
+    q[0][0]=st1;
+    memset(f,0,sizeof(f));
+    for (int i=0;i<n;i++){
+        next=now^1;
+        qn[next]=0;
+        for (int p=0;p<qn[now];p++){
+            int st=q[now][p];
+            if (i==0 || getBit(st,n)==getBit(st2,i-1)){
+                if (i==0){
+                    f[0][0][st<<1]=1;
+                    q[next][qn[next]++]=st<<1;
+                }else{
+                    int nst=st;
+                    if (getBit(st2,i-1)) nst-=(1<<n);
+                    Add(f[i][0][nst<<1],f[i-1][n][st]);
+                    q[next][qn[next]++]=nst<<1;
+                }
+            }
+        }
+        now=next;        
+        for (int j=0;j<n;j++){
+            next=now^1;
+            qn[next]=0;
+            for (int p=0;p<qn[now];p++){
+                int st=q[now][p],nst;
+                int c1=getBit(st,j),c2=getBit(st,j+1);
+                if (c1 && c2){
+                    nst=st^(1<<j)^(1<<j+1);
+                    if (f[i][j+1][nst]==0){
+                        q[next][qn[next]++]=nst;
+                    }
+                    Add(f[i][j+1][nst],f[i][j][st]);
+                }else
+                if (c1 || c2){
+                    nst=st;
+                    if (f[i][j+1][nst]==0){
+                        q[next][qn[next]++]=nst;
+                    }
+                    Add(f[i][j+1][nst],f[i][j][st]);
+                    nst=st^(1<<j)^(1<<j+1);
+                    if (f[i][j+1][nst]==0){
+                        q[next][qn[next]++]=nst;
+                    }
+                    Add(f[i][j+1][nst],f[i][j][st]);
+                }else{
+                    nst=st^(1<<j)^(1<<j+1);
+                    if (f[i][j+1][nst]==0){
+                        q[next][qn[next]++]=nst;
+                    }
+                    Add(f[i][j+1][nst],f[i][j][st]);
+                }
+            }
+            now=next;
+        }
+    }
+    for (int i=0;i<qn[now];i++){
+        int st=q[now][i];
+        if (getBit(st,n)==getBit(st2,n-1)){
+            int nst=st;
+            if (getBit(st,n)) nst-=(1<<n);
+            if (nst==0) Add(ret,f[n-1][n][st]);
+        }
+    }
+    long long tmp=ret;
+    tmp*=c1;
+    tmp%=mod;
+    tmp*=c2;
+    tmp%=mod;
+    ret=tmp;
+    return ret;
+}
+int main(){
+    int cp=0;
+    while (scanf("%d%d",&n,&m)!=EOF){
+        printf("Case %d: ",++cp);
+        if (n%2){
+            puts("0");
+            continue;
+        }
+        stn=0;
+        memset(st_num,-1,sizeof(st_num));
+        for (int i=0;i<(1<<n);i++){
+            int k=0;
+            for (int j=0;j<n;j++)
+                if ((i&(1<<j))>0) k++;
+            if (k%2==0){
+                st_num[i]=stn++;
+            }
+        }
+        a.clear();
+        for (int i=0;i<(1<<n);i++)
+            if (st_num[i]>-1) dfs(0,i<<1,i);
+        b=Mul(m-n);
+        ans=0;
+        for (int i=0;i<(1<<n);i++)
+            for (int j=0;j<(1<<n);j++){
+                int si=st_num[i],sj=st_num[j];
+                if (b.v[0][si] && b.v[0][sj]) ans=(ans+cal(i,j,b.v[0][si],b.v[0][sj]))%mod;
+            }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3851_autoAC.cpp b/HDOJ/3851_autoAC.cpp
new file mode 100644
index 0000000..bc7db75
--- /dev/null
+++ b/HDOJ/3851_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<iostream>
+#include<cstdio>
+using namespace std;
+const int maxn=700000;
+int Q,N,T;
+__int64 PD,PN;
+__int64 must;
+int n;
+__int64 d[maxn];
+__int64 f[maxn];
+void solve(__int64 t,__int64 P)
+{
+    __int64 k;
+    if (t>T*2) k=(t-T*2)/T;
+    else k=0;
+    must+=k*P;
+    for (int i=0;i<t-k*T;i++)
+        d[++n]=P;
+}
+__int64 ff(int i)
+{
+    if (i<=0) return 0;
+    else return f[i];
+}
+__int64 max(__int64 a,__int64 b)
+{
+    if (a>b) return a;
+    else return b;
+}
+void Dp()
+{
+    memset(f,0,sizeof(f));
+    for (int i=1;i<=n;i++)
+        f[i]=max(ff(i-1),ff(i-T)+d[i]);
+}
+int main()
+{
+    scanf("%d",&Q);
+    for (int ci=1;ci<=Q;ci++)
+    {
+        scanf("%d%d%I64d%I64d",&N,&T,&PD,&PN);
+        must=n=0;
+        for (int i=0;i<N;i++)
+        {
+            __int64 t1,t2;
+            scanf("%I64d%I64d",&t1,&t2);
+            solve(t1,PD);
+            solve(t2,PN);
+        }
+        Dp();
+        printf("Case %d: %I64d\n",ci,must+f[n]);
+    }
+}
diff --git a/HDOJ/3853_autoAC.cpp b/HDOJ/3853_autoAC.cpp
new file mode 100644
index 0000000..58a8577
--- /dev/null
+++ b/HDOJ/3853_autoAC.cpp
@@ -0,0 +1,35 @@
+#include <cstdio>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+using namespace std;
+double p[3][1005][1005];
+double f[1005][1005];
+bool vs[1005][1005];
+int R, C;
+double DP(int x, int y)
+{
+    if(x==R && y==C) return 0;
+    if(x>R || y>C) return 0;
+    if(vs[x][y]) return f[x][y];
+    if(abs(p[0][x][y]-1)<1e-6)
+    {
+        vs[x][y]=1;
+        return f[x][y]=0;
+    }
+    vs[x][y]=1;
+    return f[x][y]=(2+p[1][x][y]*DP(x, y+1)+p[2][x][y]*DP(x+1, y))/(1-p[0][x][y]);
+}
+int main()
+{
+    while(scanf("%d%d", &R, &C)!=EOF)
+    {
+        for(int i=1; i<=R; i++)
+            for(int j=1; j<=C; j++)
+                scanf("%lf%lf%lf", &p[0][i][j], &p[1][i][j], &p[2][i][j]);
+        memset(f, 0, sizeof(f));
+        memset(vs, 0, sizeof(vs));
+        printf("%.3lf\n", DP(1, 1));
+    }
+    return 0;
+}
diff --git a/HDOJ/3854_autoAC.cpp b/HDOJ/3854_autoAC.cpp
new file mode 100644
index 0000000..4fd3d91
--- /dev/null
+++ b/HDOJ/3854_autoAC.cpp
@@ -0,0 +1,80 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+#define typev int 
+#define N 200000
+typev ar[N]; 
+int lowb(int t) { return t & (-t) ; }
+void add(int i, typev v)
+{for ( ; i < N; ar[i] += v, i += lowb(i));}
+typev sum(int i)
+{
+    typev s = 0;
+    for ( ; i > 0; s += ar[i], i -= lowb(i));
+    return s;
+}
+int n, m, k;
+long long nowans;
+int x[N], L[N], R[N], sta[N];
+void init()
+{
+    memset(L, -1, sizeof(L)); memset(R, -1, sizeof(R));
+    memset(ar, 0, sizeof(ar));
+    for(int i = 1; i <= n; i++) if (x[i] < k)
+        for(int j = i + 1; j <= n && x[j] >= k; j++)
+            L[j] = i;
+    for(int i = n; i >= 1; i--) if (x[i] < k)
+        for(int j = i - 1; j >= 1 && x[j] >= k; j--)
+            R[j] = i;
+}
+int Get(int l, int r, int now)
+{
+    if (l > r) return 0;
+    if (l == -1 || r == -1) return 0;
+    if (now == 0) return r - l + 1 - (sum(r) - sum(l - 1));
+    return sum(r) - sum(l - 1);
+}
+int main()
+{
+    int t;scanf("%d", &t);
+    while(t--)
+    {
+        scanf("%d%d%d", &n, &m, &k);
+        for(int i = 1; i <= n; i++) scanf("%d", &x[i]);
+        init();
+        for(int i = 1; i <= n; i++)
+        {
+            scanf("%d", &sta[i]);
+            if (sta[i]) add(i, 1);
+        }
+        nowans = 0;
+        for(int i = 1; i <= n; i++)
+            if (x[i] < k) nowans += Get(i + 1, n, !sta[i]);
+            else nowans += Get(R[i], n, !sta[i]);
+        while(m--)
+        {
+            int tmp;scanf("%d", &tmp);
+            if (tmp == 1) cout << nowans << endl;
+            else
+            {
+                scanf("%d", &tmp);
+                int before = 0, after = 0;
+                int i = tmp;
+                if (x[tmp] < k)
+                {
+                    before += Get(1, i - 1, !sta[i]) + Get(i + 1, n, !sta[i]);
+                    after += Get(1, i - 1, sta[i]) + Get(i + 1, n, sta[i]);
+                }else
+                {
+                    before += Get(1, L[i], !sta[i]) + Get(R[i], n, !sta[i]);
+                    after += Get(1, L[i], sta[i]) + Get(R[i], n, sta[i]);
+                }
+                if (sta[i] == 0) add(i, 1), sta[i] = 1;
+                else add(i, -1), sta[i] = 0;
+                nowans += (after - before);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3857_autoAC.cpp b/HDOJ/3857_autoAC.cpp
new file mode 100644
index 0000000..1c91907
--- /dev/null
+++ b/HDOJ/3857_autoAC.cpp
@@ -0,0 +1,25 @@
+#include<iostream>
+#include<cstdio>
+using namespace std;
+int main()
+{
+    int n,i,a;
+    int out;
+    while (scanf("%d",&n)!=EOF)
+    {
+        out=0;
+        for (i=1;i<=n;i++)
+        {
+            scanf("%d",&a);
+            if (a==i)
+            {
+                if (out==0) printf("%d",a);
+                else printf(" %d",a);
+                out=1;
+            }
+        }
+        if (out==1) printf("\n");
+        else printf("No Mistake\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3859_autoAC.cpp b/HDOJ/3859_autoAC.cpp
new file mode 100644
index 0000000..81659e9
--- /dev/null
+++ b/HDOJ/3859_autoAC.cpp
@@ -0,0 +1,21 @@
+#include <stdio.h> 
+__int64 Solve(__int64 n,__int64 m)
+{
+    if (n%m==0) return n/m;
+    if (n%2==1 && m%2==0) return -1;
+    if (n>=3*m) return (n/m-2)+Solve(n%m+2*m,m);
+    if ((n%2)==(m%2)) return 3;
+    if (n>=2*m) return 4;
+    return Solve(n,n-m);
+}
+int main()
+{
+    __int64 n,m,ret,q,r;
+    while(scanf("%I64d%I64d",&n,&m)!=EOF)
+    {
+        ret=Solve(n,m);
+        if (ret<0) printf("No Solution!\n");
+        else printf("%I64d\n",ret);
+    }
+    return 0;
+}
diff --git a/HDOJ/3860_autoAC.cpp b/HDOJ/3860_autoAC.cpp
new file mode 100644
index 0000000..07568be
--- /dev/null
+++ b/HDOJ/3860_autoAC.cpp
@@ -0,0 +1,215 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<algorithm>
+#include<cmath>
+using namespace std;
+#define SIZE 250
+#define Max 0x7fffffff
+struct edge{int to, next, val;}e[10000000];
+int t, n, m, P, O, g[SIZE * SIZE][4];
+pair<int, int> o[SIZE], p[SIZE];
+int mo[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1};
+int v[SIZE * SIZE], cnt, len[SIZE * SIZE], dis[SIZE * SIZE];
+int que[10000000], vst[SIZE * SIZE], n2, m2, pst, ost;
+int GetMove(int a, int b, int c, int d)
+{
+    if (c < a) return 0;
+    if (c > a) return 1;
+    if (d < b) return 2;
+    return 3;
+}
+bool judge(int a, int b){return a >= 0 && a < n && b >= 0 && b < m;}
+void insert(int from, int to, int val)
+{
+    e[cnt].val = val; e[cnt].to = to; e[cnt].next = v[from];
+    v[from] = cnt++;
+    e[cnt].val = val; e[cnt].to = from; e[cnt].next = v[to];
+    v[to] = cnt++;
+}
+int spfa(int s, int t)
+{
+    memset(dis, -1, sizeof(dis));
+    memset(vst, 0, sizeof(vst));
+    int head = 0, tail = 0;
+    dis[s] = 0;
+    que[tail++] = s; vst[s] = 0;
+    while(head < tail)
+    {
+        int id = que[head++];
+        vst[id] = 0;
+        for(int i = v[id]; i != -1; i = e[i].next)
+        {
+            if (dis[e[i].to] == -1 || dis[id] + e[i].val < dis[e[i].to])
+            {
+                dis[e[i].to] = dis[id] + e[i].val;
+                if (!vst[e[i].to])
+                {
+                    vst[e[i].to] = 1;
+                    que[tail++] = e[i].to;
+                }
+            }
+        }
+    }
+    return dis[t];
+}
+void build_graph(int mid, int s, int t)
+{
+    memset(v, -1, sizeof(v)); cnt = 0;
+    for(int i = 0; i < P - 1; i++)
+    {
+        int pre, next;
+        if (i == 0) pre = s; else pre = pst + i - 1;
+        if (i == P - 2) next = t; else next = pst + i + 1;
+        insert(pre, pst + i, p[i].second);
+        insert(pst + i, next, p[i + 1].second);
+        int from = p[i].first, to = p[i + 1].first;
+        for(int j = from; j < to; j++)
+        {
+            int tmp = j * m2;
+            int val = g[j * m][1];
+            if (val == -1) val = 0;
+            val = min(val, len[mid]);
+            insert(pst + i, tmp, val);
+        }
+    }
+    for(int i = 0; i < O - 1; i++)
+    {
+        int pre, next;
+        if (i == 0) pre = s; else pre = ost + i - 1;
+        if (i == O - 2) next = t; else next = ost + i + 1;
+        insert(pre, ost + i, o[i].second);
+        insert(ost + i, next, o[i + 1].second);
+        int from = o[i].first, to = o[i + 1].first;
+        for(int j = from; j < to; j++)
+        {
+            int tmp = j * m2 + m2 - 1;
+            int val = g[j * m + m - 1][1];
+            if (val == -1) val = 0;
+            val = min(val, len[mid]);
+            insert(ost + i, tmp, val);
+        }
+    }
+    for(int i = 0; i < m2; i++)
+    {
+        int val = g[i][3];
+        if (val == -1) val = 0;
+        val = min(val, len[mid]);
+        insert(s, i, val);
+        val = g[(n - 1) * m + i][3];
+        if (val == -1) val = 0;
+        val = min(val, len[mid]);
+        insert(t, (n2 - 1) * m2 + i, val);
+    }
+    for(int i = 0; i < p[0].first; i++)
+    {
+        int val = g[i * m][1];
+        if (val == -1) val = 0;
+        val = min(val, len[mid]);
+        insert(s, i * m2, val);
+    }
+    for(int i = 0; i < o[0].first; i++)
+    {
+        int val = g[i * m + m - 1][1];
+        if (val == -1) val = 0;
+        val = min(val, len[mid]);
+        insert(s, i * m2 + m2 - 1, val);
+    }
+    for(int i = p[P - 1].first; i < n2; i++)
+    {
+        int val = g[i * m][1];
+        if (val == -1) val = 0;
+        val = min(val, len[mid]);
+        insert(t, i * m2, val);
+    }
+    for(int i = o[O - 1].first; i < n2; i++)
+    {
+        int val = g[i * m + m - 1][1];
+        if (val == -1) val = 0;
+        val = min(val, len[mid]);
+        insert(t, i * m2 + m2 - 1, val);
+    }
+    if (P == 1) insert(s, t, p[0].second);
+    if (O == 1) insert(s, t, o[0].second);
+    for(int i = 0; i < n2; i++)
+        for(int j = 0; j < m2; j++)
+        {
+            int val[4];
+            val[0] = g[i * m + j][3];
+            val[2] = g[i * m + j][1];
+            val[1] = g[(i + 1) * m + j + 1][2];
+            val[3] = g[(i + 1) * m + j + 1][0];
+            for(int k = 0; k < 4; k++)
+            {
+                if (val[k] == -1) val[k] = 0;
+                val[k] = min(val[k], len[mid]);
+                int tmpa = i + mo[k][0], tmpb = j + mo[k][1];
+                if (tmpa >= 0 && tmpa < n2 && tmpb >= 0 && tmpb < m2)
+                    insert(i * m2 + j, tmpa * m2 + tmpb, val[k]);
+            }
+        }
+}
+int main()
+{
+    scanf("%d", &t);
+    while(t--)
+    {
+        int sum = 0;
+        scanf("%d%d", &n, &m);
+        scanf("%d", &P);for(int i = 0; i < P; i++)
+            scanf("%d%d", &p[i].first, &p[i].second), p[i].first--;
+        scanf("%d", &O);for(int i = 0; i < O; i++)
+            scanf("%d%d", &o[i].first, &o[i].second), o[i].first--, sum += o[i].second;
+        sort(p, p + P); sort(o, o + O);
+        for(int i = 0; i < n; i++) for(int j = 0; j < m; j++)
+            for(int k = 0; k < 4; k++)
+            {
+                int tmpa = i + mo[k][0], tmpb = j + mo[k][1];
+                g[i * m + j][k] = -1;
+                if (judge(tmpa, tmpb)) g[i * m + j][k] = Max;
+            }
+        int tmp;scanf("%d", &tmp);while(tmp--)
+        {
+            int x1, y1, x2, y2, val;
+            scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &val);
+            x1--; y1--; x2--; y2--;
+            g[x1 * m + y1][GetMove(x1, y1, x2, y2)] = val;
+            g[x2 * m + y2][GetMove(x2, y2, x1, y1)] = val;
+        }
+        scanf("%d", &tmp); while(tmp--)
+        {
+            int a, b;scanf("%d%d", &a, &b); a--; b--;
+            for(int i = 0; i < 4; i++)
+            {
+                int tmpa = a + mo[i][0], tmpb = b + mo[i][1];
+                if (judge(tmpa, tmpb))
+                    g[a * m + b][GetMove(a, b, tmpa, tmpb)] = -1;
+            }
+        }
+        scanf("%d", &tmp);
+        for(int i = 0; i < tmp; i++) scanf("%d", &len[i]);
+        sort(len, len + tmp);
+        n2 = n - 1, m2 = m - 1;
+        int l = 0, r = tmp - 1, ans = -1;
+        int s = n2 * m2;
+        int t = s + 1;
+        pst = t + 1, ost = t + P;
+        while(l <= r)
+        {
+            int mid = (l + r) >> 1;
+            build_graph(mid, s, t);
+            int tmp = spfa(s, t);
+            if (tmp < sum)
+                l = mid + 1;
+            else
+            {
+                if (ans == -1 || mid < ans) ans = mid;
+                r = mid - 1;
+            }
+        }
+        if (ans == -1) printf("-1\n");
+        else
+            printf("%d\n", len[ans]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3861_autoAC.cpp b/HDOJ/3861_autoAC.cpp
new file mode 100644
index 0000000..ac369f2
--- /dev/null
+++ b/HDOJ/3861_autoAC.cpp
@@ -0,0 +1,106 @@
+#include <iostream>
+#include <cstdio>
+#include <vector>
+#include <algorithm>
+#include <cstring>
+using namespace std;
+const int maxn=55555;
+int  dfn[maxn], low[maxn], stack[maxn], belong[maxn], visit[maxn], match[maxn];
+bool instack[maxn];
+int top, scnt, Index, n, m, T;
+vector<int>vt[maxn];
+struct Node
+{
+    int u, v;
+}f[2*maxn];
+void Init_tarjan()
+{
+    top=scnt=Index=0;
+    for(int i=1; i<=n; i++) dfn[i]=low[i]=instack[i]=0;
+}
+void tarjan(int u)
+{
+    stack[++top]=u;
+    dfn[u]=low[u]=++Index;
+    instack[u]=1;
+    for(int i=0; i<vt[u].size(); i++)
+    {
+        int v=vt[u][i];
+        if(!dfn[v])
+        {
+            tarjan(v);
+            low[u]=min(low[u],low[v]);
+        }
+        else if(instack[v])
+        {
+            low[u]=min(low[u],dfn[v]);
+        }
+    }
+    if(low[u]==dfn[u])
+    {
+        int v;
+        scnt++;
+        do
+        {
+            v=stack[top--];
+            instack[v]=0;
+            belong[v]=scnt;
+        }
+        while(u!=v);
+    }
+}
+bool find(int u)
+{
+    for(int i=0; i<vt[u].size(); i++)
+    {
+        int v=vt[u][i];
+        if(!visit[v])
+        {
+            visit[v]=1;
+            if(match[v]==-1||find(match[v]))
+            {
+                match[v]=u;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int hungary()
+{
+    int cnt=0;
+    memset(match,-1,sizeof(match));
+    for(int i=1; i<=scnt; i++)
+    {
+        for(int j=1; j<=scnt; j++) visit[j]=0;
+        if(find(i)) cnt++;
+    }
+    return cnt;
+}
+int main()
+{
+    cin >> T;
+    while(T--)
+    {
+        cin >> n >> m;
+        for(int i=0; i<=n; i++) vt[i].clear();
+        for(int i=0; i<m; i++)
+        {
+            scanf("%d%d",&f[i].u,&f[i].v);
+            vt[f[i].u].push_back(f[i].v);
+        }
+        Init_tarjan();
+        for(int i=1; i<=n; i++)
+            if(!dfn[i]) tarjan(i);
+        for(int i=0; i<=n; i++) vt[i].clear();
+        for(int i=0; i<m; i++)
+        {
+            int u=belong[f[i].u], v=belong[f[i].v];
+            if(u==v) continue;
+            vt[u].push_back(v);
+        }
+        int ans=hungary();
+        cout << scnt-ans <<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/3862_autoAC.cpp b/HDOJ/3862_autoAC.cpp
new file mode 100644
index 0000000..b7ebbd8
--- /dev/null
+++ b/HDOJ/3862_autoAC.cpp
@@ -0,0 +1,63 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cmath>
+#include<algorithm>
+#include<cstring>
+const double eps=1e-9;
+const double pi=acos(-1.0);
+using namespace std;
+double l, r, ang;
+bool mark, ok;
+int an, bn, n;
+void check(double a)
+{
+    if((!mark)&&(fabs(a-180.0)>eps)&&(fabs(a)>eps))mark=true;
+    if(fabs(a-180.0)<eps)an++;
+    else if(fabs(a)<eps)bn++;
+    if(a<180.0&&a>l)l=a;
+    else if(a>180.0&&360.0-a>r)r=360.0-a;
+    if(l+r>180.0)ok=false;
+}
+int main()
+{
+    int i, t;
+    double tmp;
+    scanf("%d", &t);
+    while(t-->0)
+    {
+        ang=0;
+        l=r=0;
+        mark=false;
+        an=0;bn=1;
+        ok=true;
+        scanf("%d", &n);
+        for(i=0; i<n; i++)
+        {
+            scanf("%lf", &tmp);
+            if(ok)
+            {
+                if(tmp<0)tmp=-tmp;
+                else tmp=360.0-tmp;
+                ang+=tmp;
+                if(ang>=360.0)ang-=360.0;
+                check(ang);
+            }
+        }
+        if(ok)
+        {
+            if(!mark)
+            {
+                if(an>0)ok=false;
+            }
+            else
+            {
+                if(an>0&&fabs(l)<eps)l=180.0;
+                else if(an>0&&fabs(r)<eps)r=180.0;
+                if(l+r-180.00>eps)ok=false;
+            }
+        }
+        if(ok)printf("No\n");
+        else printf("Yes\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3863_autoAC.cpp b/HDOJ/3863_autoAC.cpp
new file mode 100644
index 0000000..d6c72cf
--- /dev/null
+++ b/HDOJ/3863_autoAC.cpp
@@ -0,0 +1,8 @@
+#include <stdio.h>
+int main()
+{
+    int n;
+    while(scanf("%d",&n),n+1)
+    puts("I bet on Oregon Maple~");
+    return 0;
+}
diff --git a/HDOJ/3864_autoAC.cpp b/HDOJ/3864_autoAC.cpp
new file mode 100644
index 0000000..7f3fce0
--- /dev/null
+++ b/HDOJ/3864_autoAC.cpp
@@ -0,0 +1,128 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+typedef __int64 LL;
+const LL NUM=10;
+LL t,f[100];
+LL mul_mod(LL a,LL b,LL n)
+{
+    a=a%n;
+    b=b%n;
+    LL s=0;
+    while(b)
+    {
+        if(b&1)
+            s=(s+a)%n;
+        a=(a<<1)%n;
+        b=b>>1;
+    }
+    return s;
+}
+LL pow_mod(LL a,LL b,LL n)
+{
+    a=a%n;
+    LL s=1;
+    while(b)
+    {
+        if(b&1)
+            s=mul_mod(s,a,n);
+        a=mul_mod(a,a,n);
+        b=b>>1;
+    }
+    return s;
+}
+bool check(LL a,LL n,LL r,LL s)
+{
+    LL ans,p,i;
+    ans=pow_mod(a,r,n);
+    p=ans;
+    for(i=1;i<=s;i++)
+    {
+        ans=mul_mod(ans,ans,n);
+        if(ans==1&&p!=1&&p!=n-1)return true;
+        p=ans;
+    }
+    if(ans!=1)return true;
+    return false;
+}
+bool Miller_Rabin(LL n)
+{
+    if(n<2)return false;
+    if(n==2)return true;
+    if(!(n&1))return false;
+    LL i,r,s,a;
+    r=n-1;s=0;
+    while(!(r&1)){r=r>>1;s++;}
+    for(i=0;i<NUM;i++)
+    {
+        a=rand()%(n-1)+1;
+        if(check(a,n,r,s))
+            return false;
+    }
+    return true;
+}
+LL gcd(LL a,LL b)
+{
+    return b==0?a:gcd(b,a%b);
+}
+LL Pollard_rho(LL n,LL c)
+{
+    LL i=1,j,k=2,x,y,d,p;
+    x=rand()%n;
+    y=x;
+    while(true)
+    {
+        i++;
+        x=(mul_mod(x,x,n)+c)%n;
+        if(y==x)return n;
+        if(y>x)p=y-x;
+        else p=x-y;
+        d=gcd(p,n);
+        if(d!=1&&d!=n)return d;
+        if(i==k)
+        {
+            y=x;
+            k+=k;
+        }
+    }
+}
+void find(LL n)
+{
+    if(Miller_Rabin(n))
+    {
+        f[t++]=n;
+        return;
+    }
+    LL p=n;
+    while(p>=n)p=Pollard_rho(p,rand()%(n-1)+1);
+    find(p);
+    find(n/p);
+}
+int main()
+{
+    srand(time(NULL));
+    LL n;
+    while(cin>>n)
+    {
+        if(n==1){cout<<"is not a D_num"<<endl;continue;}
+        t=0;
+        find(n);
+        if(t!=2&&t!=3){cout<<"is not a D_num"<<endl;continue;}
+        sort(f,f+t);
+        if(t==2)
+        {
+            if(f[0]!=f[1])cout<<f[0]<<" "<<f[1]<<" "<<n<<endl;
+            else cout<<"is not a D_num"<<endl;
+        }
+        else
+        {
+            if(f[0]==f[1]&&f[1]==f[2])cout<<f[0]<<" "<<f[0]*f[0]<<" "<<n<<endl;
+            else cout<<"is not a D_num"<<endl;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3865_autoAC.cpp b/HDOJ/3865_autoAC.cpp
new file mode 100644
index 0000000..f4d1c6c
--- /dev/null
+++ b/HDOJ/3865_autoAC.cpp
@@ -0,0 +1,115 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#include<cstdio>
+using namespace std;
+int x[20][20][15][15], n, m, p, q, need[20][20][2], small[20][20];
+int dp[20][20][2], match[20], g[20][20];
+bool vst[20], equ[20][20];
+int find(int u, int m)
+{
+    for(int i = 0; i < m; i++)
+        if (!vst[i] && g[u][i])
+        {
+            vst[i] = 1;
+            if (match[i] == -1 || find(match[i], m) == 1)
+            {
+                match[i] = u;
+                return 1;
+            }
+        }
+    return 0;
+}
+int solve(int n)
+{
+    memset(match, -1, sizeof(match));
+    int ans = 0;
+    for(int i = 0; i < n; i++)
+    {
+        memset(vst, 0, sizeof(vst));
+        ans += find(i, n);
+    }
+    return ans;
+}
+int main()
+{
+    while(scanf("%d%d%d%d", &n, &m, &p, &q) != EOF)
+    {
+        for(int i = 0; i < n; i++)
+            for(int j = 0; j < n; j++)
+                for(int i2 = 0; i2 < m; i2++)
+                    for(int j2 = 0; j2 < m; j2++)
+                        scanf("%d", &x[i][j][i2][j2]);
+        for(int i = 0; i < n; i++)
+            for(int j = 0; j < n; j++)
+            {
+                for(int i2 = 0; i2 < m; i2++)
+                    for(int j2 = 0; j2 < m; j2++)
+                    {
+                        if (x[i][j][i2][j2]) g[i2][j2] = 1;
+                        else g[i2][j2] = 0;
+                    }
+                small[i][j] = solve(m) * p;
+            }
+        for(int i = 0; i < n; i++)
+            for(int j = 0; j < n; j++)
+            {
+                need[i][j][0] = need[i][j][1] = 0;
+                dp[i][j][0] = dp[i][j][1] = 0x7fffffff;
+                for(int i2 = 0; i2 < m; i2++)
+                {
+                    bool flag = false;
+                    for(int j2 = 0; j2 < m; j2++)
+                        if (x[i][j][i2][j2])
+                        {flag = true; break;}
+                    need[i][j][0] += flag;
+                }
+                need[i][j][0] *= p;
+                for(int j2 = 0; j2 < m; j2++)
+                {
+                    bool flag = false;
+                    for(int i2 = 0; i2 < m; i2++)
+                        if (x[i][j][i2][j2])
+                        {flag = true; break;}
+                    need[i][j][1] += flag;
+                }
+                need[i][j][1] *= p;
+                if (small[i][j] < need[i][j][0] && small[i][j] < need[i][j][1])
+                    equ[i][j] = true;
+                else equ[i][j] = false;
+            }
+        dp[0][0][0] = min(need[0][0][0], need[0][0][1] + q);
+        if (equ[0][0]) dp[0][0][0] = min(dp[0][0][0], small[0][0] + q);
+        dp[0][0][1] = min(need[0][0][1], need[0][0][0] + q);
+        if (equ[0][0]) dp[0][0][1] = min(dp[0][0][1], small[0][0] + q);
+        for(int i = 0; i < n; i++)
+            for(int j = 0; j < n; j++)
+            {
+                int tmpa, tmpb;
+                tmpa = i - 1; tmpb = j;
+                if (tmpa >= 0 && tmpa < n && tmpb >= 0 && tmpb < n)
+                {
+                    int val = dp[tmpa][tmpb][0];
+                    int val1 = min(need[i][j][0], need[i][j][1] + q + q);
+                    if (equ[i][j]) val1 = min(val1, small[i][j] + q + q);
+                    int val2 = min(need[i][j][0] + q, need[i][j][1] + q);
+                    if (equ[i][j]) val2 = min(val2, small[i][j] + q);
+                    dp[i][j][0] = min(dp[i][j][0], val + val1);
+                    dp[i][j][1] = min(dp[i][j][1], val + val2);
+                }
+                tmpa = i; tmpb = j - 1;
+                if (tmpa >= 0 && tmpa < n && tmpb >= 0 && tmpb < n)
+                {
+                    int val = dp[tmpa][tmpb][1];
+                    int val1 = min(need[i][j][1], need[i][j][0] + q + q);
+                    if (equ[i][j]) val1 = min(val1, small[i][j] + q + q);
+                    int val2 = min(need[i][j][1] + q, need[i][j][0] + q);
+                    if (equ[i][j]) val2 = min(val2, small[i][j] + q);
+                    dp[i][j][1] = min(dp[i][j][1], val + val1);
+                    dp[i][j][0] = min(dp[i][j][0], val + val2);
+                }
+            }
+        printf("%d\n", min(dp[n - 1][n - 1][0], dp[n - 1][n - 1][1]));
+    }
+    return 0;
+}
diff --git a/HDOJ/3866_autoAC.cpp b/HDOJ/3866_autoAC.cpp
new file mode 100644
index 0000000..7a5fa4f
--- /dev/null
+++ b/HDOJ/3866_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<iostream>
+#include<algorithm>
+#include<stdlib.h>
+using namespace std;
+struct Node
+{
+    int value1,value,sub;
+}node[10005],ex;
+int T,P,N;
+int i,sum;
+bool cmp1(struct Node p,struct Node q)  
+{ 
+    if(p.value!=q.value)
+        return p.value>q.value;
+    else return p.sub<q.sub;
+}
+int cmp2(const void *p,const void *q)  
+{  
+    int c = (*(struct Node*)p).sub - (*(struct Node*)q).sub;  
+    if(c>0) return 1;  
+    else return -1;  
+}
+int main()
+{
+    cin>>T;
+    while(T--)
+    {
+        cin>>P>>N;
+        sum=0;
+        for(i=0;i<N;i++)
+        {
+            scanf("%d",&node[i].value);
+            node[i].sub=i;
+            node[i].value1=node[i].value;
+            sum+=node[i].value;
+        }
+        if(sum<P)
+        {
+            printf("IMPOSSIBLE\n");
+            continue;
+        }
+        sort(node,node+N,cmp1);
+        int ln=N,lp=P,x;
+        while(lp>0)
+        {
+            x=node[ln-1].value;
+            if(lp/ln<x) x=lp/ln;
+            if(x>0)
+            {
+                int pre_ln=ln;
+                for(i=0;i<pre_ln;i++)
+                {
+                    node[i].value-=x;
+                    if(!node[i].value) ln--;
+                }
+                lp-=x*pre_ln;
+            }
+            else
+            {
+                for(i=0;i<lp;i++)
+                    node[i].value--;
+                lp=0;
+            }
+        }
+        qsort(node,N,sizeof(struct Node),cmp2);
+        for(i=0;i<N-1;i++)
+            printf("%d ",node[i].value1-node[i].value);
+        printf("%d\n",node[N-1].value1-node[N-1].value);
+    }
+    return 0;
+}
diff --git a/HDOJ/3867_autoAC.cpp b/HDOJ/3867_autoAC.cpp
new file mode 100644
index 0000000..6004720
--- /dev/null
+++ b/HDOJ/3867_autoAC.cpp
@@ -0,0 +1,105 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <set>
+#include <algorithm>
+using namespace std;
+#define EPS 1e-8
+#define LS0(a) (a << 1)
+#define LS1(a) ((a << 1) | 1)
+const int MAXN = 20010;
+struct Point { 
+    double x, y;
+    Point(double _x = 0.0, double _y = 0.0): x(_x), y(_y) {}
+    Point operator + (const Point &b) const {
+        return Point(x + b.x, y + b.y);
+    }
+    Point operator - (const Point &b) const {
+        return Point(x - b.x, y - b.y);
+    }
+    double operator ^ (const Point &b) const {
+        return x * b.y - y * b.x;
+    }
+    bool operator < (const Point &b) const {  
+        return x * b.y < y * b.x;
+    }
+    void input() {
+        scanf("%lf%lf", &x, &y);
+    }
+    double diso() {
+        return sqrt(x * x + y * y);
+    }
+}cur,ps[MAXN];
+Point lnlncross_pt(Point aa, Point ad, Point ba, Point bd) { 
+    ad = ad - aa;
+    bd = bd - ba;
+    double tmp = bd ^ ad;
+    return Point(
+        (ad.x * bd.x * (ba.y - aa.y) + aa.x * bd.x * ad.y - ba.x * ad.x * bd.y) / tmp,
+        (ad.y * bd.y * (aa.x - ba.x) + ba.y * ad.y * bd.x - aa.y * bd.y * ad.x) / tmp);
+}
+struct Item {
+    Point *u, *v;
+    int type; 
+    int sgid; 
+    Item(Point *_u = NULL, Point *_v = NULL, int _ty = 0, int _id = 0)
+        : u(_u), v(_v), type(_ty), sgid(_id) {}
+    bool operator < (const Item &b) const {
+        if(u == b.u && v == b.v)
+            return false;
+        Point au = lnlncross_pt(Point(0.0, 0.0), cur, *u, *v);
+        Point bu = lnlncross_pt(Point(0.0, 0.0), cur, *b.u, *b.v);
+        return au.diso() < bu.diso();
+    }
+}item[MAXN];
+bool flag[MAXN];
+set<Item> Scan;
+bool cmp(const Item &a, const Item &b) { 
+        return atan2(a.u->y, a.u->x) < atan2(b.u->y, b.u->x);
+}
+void inputps(int n) {
+    Point src, a, b;
+    src.input();
+    for(int i = 0; i < n; ++i) {
+        a.input(); a = a - src;
+        b.input(); b = b - src;
+        if(b < a) swap(a, b);
+        ps[LS0(i)] = a;
+        ps[LS1(i)] = b;
+        item[LS0(i)] = Item(&ps[LS0(i)], &ps[LS1(i)], 0, i);
+        item[LS1(i)] = Item(&ps[LS1(i)], &ps[LS0(i)], 1, i);
+    }
+    sort(item, item + 2 * n, cmp);
+}
+bool sgcross_with_ax(Item &a) {   
+    Point tmp(-1.0, 0.0);
+    return (*a.u ^ *a.v) * (*a.u ^ tmp) > 0.0
+        && (*a.u ^ tmp) * (tmp ^ *a.v) > 0.0;
+}
+int main() {
+    int n;
+    while(scanf("%d", &n) != EOF) {
+        inputps(n);
+        memset(flag,0,sizeof(flag));
+        Scan.clear();
+        for(int i = 0; i < 2 * n; ++i) {
+        cur = *item[i].u;
+            if(item[i].type == 1 && sgcross_with_ax(item[i]))
+                Scan.insert(item[i]);
+        }
+        for(int i = 0; i < 2 * n; ++i) {
+        cur = *item[i].u;
+            if(item[i].type == 1)
+                Scan.insert(item[i]);
+            else
+                Scan.erase(Item(item[i].v, item[i].u, 1, item[i].sgid));
+            if(!Scan.empty())
+                flag[Scan.begin()->sgid] = true;
+        }
+        int ans = 0;
+        for(int i = 0; i < n; ++i)
+            if(flag[i])ans ++;
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3868_autoAC.cpp b/HDOJ/3868_autoAC.cpp
new file mode 100644
index 0000000..02b411c
--- /dev/null
+++ b/HDOJ/3868_autoAC.cpp
@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <algorithm>
+#include <math.h>
+using namespace std;
+#define eps 1e-6
+typedef struct
+{
+    double x,y;
+}point;
+point a[20005];
+double ret;
+point tag[20005];
+double Dist(point p,point q)
+{
+    return sqrt((p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y));
+}
+bool cmpx(point p,point q)
+{
+    if (p.x!=q.x) return p.x<q.x;
+    return p.y<q.y;
+}
+bool cmpy(point p,point q)
+{
+    if (p.y!=q.y) return p.y<q.y;
+    return p.x<q.x;
+}
+void Merge(int l,int r)
+{
+    int mid,x,y,i,j,k;
+    double m;
+    if (r-l+1<=6)
+    {
+        for (i=l;i<=r;i++)
+        {
+            for (j=i+1;j<=r;j++)
+            {
+                m=Dist(a[i],a[j]);
+                if (m>ret/2) continue;
+                for (k=j+1;k<=r;k++)
+                {
+                    ret=min(ret,m+Dist(a[j],a[k])+Dist(a[i],a[k]));
+                }
+            }
+        }
+        return;
+    }
+    mid=(l+r)/2;
+    Merge(l,mid);
+    Merge(mid+1,r);
+    int up=0;
+    for (i=l;i<=r;i++)
+    {
+        if (fabs(a[mid].x-a[i].x)<ret/2) tag[up++]=a[i];
+    }
+    sort(tag,tag+up,cmpy);
+    for (i=0;i<up;i++)
+    {
+        for (j=i+1;j<up && j<=i+7;j++)
+        {
+            m=Dist(tag[i],tag[j]);
+            if (m>ret/2) continue;
+            for (k=j+1;k<up && k<=j+7;k++)
+            {
+                ret=min(ret,m+Dist(tag[j],tag[k])+Dist(tag[i],tag[k]));
+            }
+        }
+    }
+}
+int main()
+{
+    int i,j,n,T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        for (i=0;i<n;i++)
+        {
+            scanf("%lf%lf",&a[i].x,&a[i].y);
+        }
+        sort(a,a+n,cmpx);
+        ret=999999999;
+        Merge(0,n-1);
+        printf("%.3lf\n",ret);
+    }
+    return 0;
+}
diff --git a/HDOJ/3869_autoAC.cpp b/HDOJ/3869_autoAC.cpp
new file mode 100644
index 0000000..3181ef3
--- /dev/null
+++ b/HDOJ/3869_autoAC.cpp
@@ -0,0 +1,109 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <vector>
+#include <cstring>
+#include <algorithm>
+#include <string>
+#include <set>
+#include <functional>
+#include <numeric>
+#include <sstream>
+#include <stack>
+#include <map>
+#include <queue>
+#define CL(arr, val)    memset(arr, val, sizeof(arr))
+#define REP(i, n)       for((i) = 0; (i) < (n); ++(i))
+#define FOR(i, l, h)    for((i) = (l); (i) <= (h); ++(i))
+#define FORD(i, h, l)   for((i) = (h); (i) >= (l); --(i))
+#define L(x)    (x) << 1
+#define R(x)    (x) << 1 | 1
+#define MID(l, r)   (l + r) >> 1
+#define Min(x, y)   (x) < (y) ? (x) : (y)
+#define Max(x, y)   (x) < (y) ? (y) : (x)
+#define E(x)        (1 << (x))
+#define iabs(x)     (x) < 0 ? -(x) : (x)
+#define OUT(x)  printf("%lld\n", x)
+typedef long long LL;
+const double eps = 1e-6;
+const double PI = acos(-1.0);
+const int inf = 0x1F1F1F1F;
+using namespace std;
+const int N = 100010;
+const int MOD = 1000000007;
+int n;
+int pre[N];
+bool vis[2][N];
+int v[N], e[N];
+int vv[N<<1], ee[N<<1];
+void get_next(int P[]) {
+    int i, j = -1;
+    pre[0] = -1;
+    for(i = 1; i < n; ++i) {
+        while(j > -1 && P[j+1] != P[i]) j = pre[j];
+        if(P[j + 1] == P[i])    ++j;
+        pre[i] = j;
+    }
+}
+void kmp(int T[], int P[], int f) {
+    get_next(P);
+    int i, k;
+    for(k = -1, i = 0; i < (n<<1); ++i) {
+        while(k > -1 && P[k+1] != T[i]) k = pre[k];
+        if(P[k+1] == T[i])  ++k;
+        if(k == n - 1)  {
+            vis[f][i - n + 1] = true;
+            k = pre[k];
+        }
+    }
+}
+LL Pow(LL a, int b) {
+    LL res = 1;
+    while(b) {
+        if(b&1) res = (res*a)%MOD;
+        a = (a*a)%MOD;
+        b >>= 1;
+    }
+    return res;
+}
+int exp_gcd(int a, int b, int& x, int& y) {
+    if(b == 0) {
+        x = 1; y = 0;
+        return a;
+    }
+    int d = exp_gcd(b, a%b, y, x);  
+    y -= a/b*x;                 
+    return d;
+}
+int Inv(int c) {
+    int x, y;
+    exp_gcd(c, MOD, x, y);
+    return x < 0 ? x + MOD : x;
+}
+int gcd(int a, int b) {
+    return b == 0 ? a : gcd(b, a%b);
+}
+int main() {
+    int T, c, cnt, i;
+    LL ans;
+    scanf("%d", &T);
+    while(T--) {
+        scanf("%d%d", &n, &c);
+        for(i = 0; i < n; ++i)  {scanf("%d", &v[i]); vv[i] = vv[i+n] = v[i];}
+        for(i = 0; i < n; ++i)  {scanf("%d", &e[i]); ee[i] = ee[i+n] = e[i];}
+        CL(vis, false);
+        kmp(vv, v, 0);
+        kmp(ee, e, 1);
+        ans = cnt = 0;
+        for(i = 1; i <= n; ++i) {
+            if(vis[0][i] && vis[1][i]) {
+                ans += Pow(c, gcd(i, n));
+                ans %= MOD;
+                cnt++;
+            }
+        }
+        ans = ans*Inv(cnt)%MOD;
+        cout << ans << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/3870_autoAC.cpp b/HDOJ/3870_autoAC.cpp
new file mode 100644
index 0000000..2ef0e43
--- /dev/null
+++ b/HDOJ/3870_autoAC.cpp
@@ -0,0 +1,87 @@
+#include<cstdio>
+#include<vector>
+#include<queue>
+#include<string.h>
+#include<algorithm>
+#define N 400*400
+using namespace std;
+int t,n,a[405][405];
+int v,e,low[N],p[N],q[N],adj[N];
+bool f[N];
+struct Edge
+{
+    int v,w,next;
+}edge[4*N];
+void insert(int u,int v,int w)
+{
+    edge[e].v=v;edge[e].w=w;
+    edge[e].next=adj[u];
+    adj[u]=e++;
+}
+int spfa(int s)
+{
+    memset(f,0,sizeof(f));
+    memset(low,0x7f,sizeof(low));
+    int i,j,k,x,h=0,t=1;
+    v=n*n+1;
+    q[t]=s;
+    low[s]=0;
+    while(h!=t)
+    {
+        h=(h+1)%(v+1);
+        x=q[h];
+        f[x]=0;
+        for(k=adj[x];k!=-1;k=edge[k].next)
+        {
+            i=edge[k].v;
+            j=edge[k].w;
+            if(j+low[x]<low[i])
+            {
+                low[i]=low[x]+j;
+                if(!f[i])
+                {
+                    f[i]=1;
+                    t=(t+1)%(v+1);
+                    q[t]=i;
+                }
+            }
+        }
+    }
+    return low[n*n+1];
+}
+int main()
+{
+    scanf("%d",&t);
+    while(t--)
+    {
+        memset(adj,-1,sizeof(adj));
+        int i,j;
+        e=0;
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+            for(j=0;j<n;j++)
+                scanf("%d",&a[i][j]);
+        n--;
+        for(i=0;i<n;i++)
+        {
+            insert(0,i*n+1,a[i][0]);
+            insert(0,(n-1)*n+i+1,a[n][i]);
+            insert(i+1,n*n+1,a[0][i]);
+            insert(i*n+n,n*n+1,a[i][n]);
+            for(j=0;j<n;j++)
+            {
+                if(j+1<n)
+                {
+                    insert(i*n+j+1,i*n+j+2,a[i][j+1]);
+                    insert(i*n+j+2,i*n+j+1,a[i][j+1]);
+                }
+                if(i+1<n)
+                {
+                    insert(i*n+j+1,(i+1)*n+j+1,a[i+1][j]);
+                    insert((i+1)*n+j+1,i*n+j+1,a[i+1][j]);
+                }
+            }
+        }
+        printf("%d\n",spfa(0));
+    }
+}
diff --git a/HDOJ/3871_autoAC.cpp b/HDOJ/3871_autoAC.cpp
new file mode 100644
index 0000000..5464253
--- /dev/null
+++ b/HDOJ/3871_autoAC.cpp
@@ -0,0 +1,191 @@
+#include <iostream>
+#include <cstdio>
+#include <queue>
+#include <cstring>
+using namespace std;
+#define maxn 31
+bool mat[maxn][maxn][maxn];
+struct point
+{
+    short x,y,z,rot,dir,step;
+    point(){}
+    point(int a,int b,int c,int d,int e):x(a),y(b),z(c),rot(d),dir(e){}
+    bool operator ==(const point q)
+    {
+        return x == q.x && y == q.y && z == q.z && rot == q.rot && dir == q.dir;
+    }
+}ST,EN;
+int n;
+char opt[10] = {0,'F','L','R','U','D','B'};
+point pre[maxn][maxn][maxn][7][7];
+short step[maxn][maxn][maxn][7][7];
+int dis[maxn][maxn][maxn][7][7];
+int LEFT[7][7] = 
+{
+    0,0,0,0,0,0,0,
+    0,0,3,5,0,6,2,
+    0,6,0,1,3,0,4,
+    0,2,4,0,5,1,0,
+    0,0,6,2,0,3,5,
+    0,3,0,4,6,0,1,
+    0,5,1,0,2,4,0
+};
+int RIGHT[7][7] = 
+{
+    0,0,0,0,0,0,0,
+    0,0,6,2,0,3,5,
+    0,3,0,4,6,0,1,
+    0,5,1,0,2,4,0,
+    0,0,3,5,0,6,2,
+    0,6,0,1,3,0,4,
+    0,2,4,0,5,1,0
+};
+int dx[7] = {0,1,0,0,-1,0,0};
+int dy[7] = {0,0,1,0,0,-1,0};
+int dz[7] = {0,0,0,1,0,0,-1};
+int back[7] = { 0,4,5,6,1,2,3 };
+char record[maxn * maxn * maxn * 10 * 10];
+bool check(point p)
+{
+    int x = p.x,y = p.y,z = p.z;
+    return (1 <= x && x <= n) && (1 <= y && y <= n) && (1 <= z && z <= n) && !mat[x][y][z];
+}
+queue <point> Q;
+void bfs()
+{
+    while(!Q.empty())
+        Q.pop();
+    int x = ST.x,y = ST.y,z = ST.z,rot = ST.rot,dir = ST.dir;
+    if(!check(ST))
+        return ;
+    dis[x][y][z][rot][dir] = 0;
+    if(ST == EN)
+        return ;
+    pre[x][y][z][rot][dir] = ST;
+    ST.step = 0;
+    Q.push(ST);
+    while(!Q.empty())
+    {
+        point now = Q.front();
+        Q.pop();
+        for(int i = 1;i <= 6;i++)
+        {
+            if(i == 1)
+            {
+                rot = now.rot;
+                dir = now.dir;
+                x = now.x + dx[now.dir];
+                y = now.y + dy[now.dir];
+                z = now.z + dz[now.dir];
+            }
+            else
+            {
+                if(i == 2)
+                {
+                    rot = now.rot;
+                    dir = LEFT[now.rot][now.dir];
+                }
+                else if(i == 3)
+                {
+                    rot = now.rot;
+                    dir = RIGHT[now.rot][now.dir];
+                }
+                else if(i == 4)
+                {
+                    rot = back[now.dir];
+                    dir = now.rot;
+                }
+                else if(i == 5)
+                {
+                    rot = now.dir;
+                    dir = back[now.rot];
+                }
+                else
+                {
+                    rot = now.rot;
+                    dir = back[now.dir];
+                }
+                x = now.x;
+                y = now.y;
+                z = now.z;
+            }
+            if(check(point(x,y,z,rot,dir)) && dis[x][y][z][rot][dir] > now.step + 1)
+            {
+                dis[x][y][z][rot][dir] = now.step + 1;
+                pre[x][y][z][rot][dir] = now;
+                step[x][y][z][rot][dir] = i;
+                point haha(x,y,z,rot,dir);
+                haha.step = now.step + 1;
+                Q.push(haha);
+            }
+        }
+    }
+}
+void come(int temp)
+{
+    record[temp + 1] = 0;
+    point rc = EN;
+    while(!(rc == ST))
+    {
+        int x = rc.x,y = rc.y,z = rc.z,rot = rc.rot,dir = rc.dir;
+        record[temp--] = opt[step[x][y][z][rot][dir]];
+        rc = pre[x][y][z][rot][dir];
+    }
+}
+void solve()
+{
+    scanf("%d",&n);
+    int a,b,c,d,e;
+    memset(mat,0,sizeof(mat));
+    for(int i = 0;i < 2;i++)
+    {
+        scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);
+        if(i == 0)
+            ST = point(a,b,c,e,d);
+        else
+            EN = point(a,b,c,e,d);
+    }
+    for(int i = 1;i <= n;i++)
+    {
+        for(int j = 1;j <= n;j++)
+        {
+            char str[15];
+            str[0] = 'x';
+            scanf(" %s",&str[1]);
+            int l = strlen(str);
+            bool code[35];
+            memset(code,0,sizeof(code));
+            for(int q = l - 1;q >= 1;q--)
+            {
+                int fuck = str[q] - '0';
+                for(int k = 1;k <= 3;k++)
+                {
+                    if(fuck & 1)
+                        code[(l - q - 1) * 3 + k] = 1;
+                    fuck >>= 1;
+                }
+            }
+            for(int k = n;k >= 1;k --)
+                mat[j][k][i] = code[k];
+        }
+    }
+    memset(dis,0x7f,sizeof(dis));
+    memset(pre,0,sizeof(pre));
+    memset(step,0,sizeof(step));
+    bfs();
+    if(dis[EN.x][EN.y][EN.z][EN.rot][EN.dir] == 0x7f7f7f7f)
+        puts("Sorry, I can't get there.");
+    else
+    {
+        int ans = dis[EN.x][EN.y][EN.z][EN.rot][EN.dir];
+        come(ans);
+        printf("%d\n",ans);
+        puts(&record[1]);
+    }
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    for(int i = 0;i < t;i++)solve();
+}
diff --git a/HDOJ/3872_autoAC.cpp b/HDOJ/3872_autoAC.cpp
new file mode 100644
index 0000000..7bd7f5a
--- /dev/null
+++ b/HDOJ/3872_autoAC.cpp
@@ -0,0 +1,123 @@
+#include <functional>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <iomanip>
+#include <numeric>
+#include <cstring>
+#include <cassert>
+#include <cstdio>
+#include <string>
+#include <vector>
+#include <bitset>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <ctime>
+#include <list>
+#include <set>
+#include <map>
+using namespace std;
+#define pii pair<int,int>
+#define mem(a,b) memset(a,b,sizeof(a))
+#define lson l,mid,rt<<1
+#define rson mid+1,r,rt<<1|1
+#define PI acos(-1.0)
+typedef __int64 LL;
+typedef unsigned __int64 ULL;
+const int N=100010;
+const int INF=0x3f3f3f3f;
+const int MOD=95041567,STA=8000010;
+const LL LNF=1LL<<60;
+const double EPS=1e-8;
+const double OO=1e15;
+const int dx[4]={-1,0,1,0};
+const int dy[4]={0,1,0,-1};
+const int day[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
+inline int sign(double x){return (x>EPS)-(x<-EPS);}
+template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
+template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
+template<class T> inline T lcm(T a,T b,T d){return a/d*b;}
+template<class T> inline T Min(T a,T b){return a<b?a:b;}
+template<class T> inline T Max(T a,T b){return a>b?a:b;}
+template<class T> inline T Min(T a,T b,T c){return min(min(a, b),c);}
+template<class T> inline T Max(T a,T b,T c){return max(max(a, b),c);}
+template<class T> inline T Min(T a,T b,T c,T d){return min(min(a, b),min(c,d));}
+template<class T> inline T Max(T a,T b,T c,T d){return max(max(a, b),max(c,d));}
+LL low[N<<2][2],f[N];
+int l[N],la[N],q[N][2],type[N],eng[N];
+int T,n;
+void update(int l,int r,int rt,int w,LL val,int flag)
+{
+    if(l==r){
+        low[rt][flag]=val;
+        return;
+    }
+    int mid=(l+r)>>1;
+    if(w<=mid)update(lson,w,val,flag);
+    else update(rson,w,val,flag);
+    low[rt][flag]=Min(low[rt<<1][flag],low[rt<<1|1][flag]);
+}
+LL query(int l,int r,int rt,int L,int R,int flag)
+{
+    if(L<=l && r<=R){
+        return low[rt][flag];
+    }
+    int mid=(l+r)>>1;
+    LL ret=LNF;
+    if(L<=mid)ret=Min(ret,query(lson,L,R,flag));
+    if(R>mid)ret=Min(ret,query(rson,L,R,flag));
+    return ret;
+}
+int binary(int l,int r,int tar)
+{
+    int mid;
+    while(l<r){
+        mid=(l+r)>>1;
+        if(q[mid][0]<tar)l=mid+1;
+        else r=mid;
+    }
+    return l;
+}
+int main()
+{
+    int i,j,t,L,R,top;
+    LL lowf;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        mem(la,0);
+        for(i=1;i<=n;i++){
+            scanf("%d",&type[i]);
+            l[i]=la[type[i]];
+            la[type[i]]=i;
+        }
+        for(i=1;i<=n;i++){
+            scanf("%d",&eng[i]);
+        }
+        mem(low,INF);mem(f,INF);f[0]=0;
+        update(0,n+1,1,0,0,1);
+        q[top=0][0]=0;q[top][1]=INF;
+        for(i=1;i<=n;i++){
+            while(q[top][1]<=eng[i]){
+                update(0,n+1,1,q[top-1][0],LNF,0);
+                top--;
+            }
+            q[++top][0]=i;q[top][1]=eng[i];
+            t=q[top-1][0];
+            lowf=query(0,n+1,1,t,i-1,1);
+            update(0,n+1,1,t,lowf+eng[i],0);
+            L=binary(0,top+1,l[i]);
+            f[i]=query(0,n+1,1,q[L][0],i,0);
+            if(l[i]<q[L][0]){
+                lowf=query(0,n+1,1,l[i],q[L][0]-1,1);
+                f[i]=Min(f[i],lowf+q[L][1]);
+            }
+            update(0,n+1,1,i,f[i],1);
+        }
+        printf("%I64d\n",f[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3873_autoAC.cpp b/HDOJ/3873_autoAC.cpp
new file mode 100644
index 0000000..19afd0d
--- /dev/null
+++ b/HDOJ/3873_autoAC.cpp
@@ -0,0 +1,78 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<queue>
+#include<vector>
+#include<algorithm>
+using namespace std;
+typedef long long LL;
+typedef pair<LL,int>Pair;
+#define inf (1ll)<<55
+#define MAXN 3333
+struct Node {
+    int v,w;
+};
+int In[MAXN];
+LL dist[MAXN],pro[MAXN];
+bool mark[MAXN];
+vector<Node>Map[MAXN];
+vector<int>vet[MAXN];
+int n,m;
+void Dijkstra(){
+   for(int i=1;i<=n;i++){ dist[i]=inf;pro[i]=0; }
+   dist[1]=0;
+   memset(mark,false,sizeof(mark));
+   priority_queue<Pair,vector<Pair>,greater<Pair> >Q;
+   Q.push(make_pair(dist[1],1));
+   while(!Q.empty()){
+      Pair pp=Q.top();
+      Q.pop();
+      int u=pp.second;
+      if(mark[u])continue;
+      mark[u]=true;
+      for(int i=0;i<vet[u].size();i++){
+         int v=vet[u][i];
+         In[v]--;
+         pro[v]=max(pro[v],dist[u]);
+         if(dist[v]!=inf&&In[v]==0){
+            dist[v]=max(dist[v],pro[v]);
+            Q.push(make_pair(dist[v],v));
+         }
+      }
+      for(int i=0;i<Map[u].size();i++){
+         int v=Map[u][i].v;
+         int w=Map[u][i].w;
+         if(dist[v]>dist[u]+w){
+            dist[v]=max(dist[u]+w,pro[v]);
+            if(In[v]==0){ Q.push(make_pair(dist[v],v)); }
+         }
+      }
+   }
+}
+int main() {
+    int _case,u,v,w,x;
+    scanf("%d",&_case);
+    while(_case--) {
+        scanf("%d%d",&n,&m);
+        for(int i=1; i<=n; i++) {
+            Map[i].clear();
+            vet[i].clear();
+        }
+        while(m--) {
+            scanf("%d%d%d",&u,&v,&w);
+            Node p;
+            p.v=v,p.w=w;
+            Map[u].push_back(p);
+        }
+        for(int i=1; i<=n; i++) {
+            scanf("%d",&In[i]);
+            for(int j=1; j<=In[i]; j++) {
+                scanf("%d",&x);
+                vet[x].push_back(i);
+            }
+        }
+        Dijkstra();
+        printf("%I64d\n",dist[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3874_autoAC.cpp b/HDOJ/3874_autoAC.cpp
new file mode 100644
index 0000000..feca365
--- /dev/null
+++ b/HDOJ/3874_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#define mem(a) memset(a,0,sizeof(a))
+#define MAX(a , b) ((a) > (b) ? (a) : (b))
+using namespace std;
+struct QUERY
+{
+    int a,b;
+    int index;
+}query[200005];
+__int64 c[50005],  ans[200005];
+int last[1000005], value[50005], N, M, T;
+int cmp(QUERY x, QUERY y)
+{
+    return x.b < y.b;
+}
+int lowbit(int x)
+{
+    return x & (-x);
+}
+__int64 getSum(int k)
+{
+    __int64 sum = 0;
+    while(k>=1)
+    {
+        sum += c[k];
+        k -= lowbit(k);
+    }
+    return sum;
+}
+void edit(int k, int val)
+{
+    while(k<=N)
+    {
+        c[k] += val;
+        k += lowbit(k);
+    }
+}
+int main()
+{
+    while(~scanf("%d", &T))while(T--)
+    {
+        mem(query);  mem(c);
+        mem(last);   mem(ans);
+        mem(value);
+        scanf("%d", &N);
+        for(int i=1;i<=N;i++)
+        {
+            scanf("%d", &value[i]);
+            edit(i, value[i]);
+            if(!last[value[i]]) last[value[i]] = i;
+        }
+        scanf("%d", &M);
+        for(int i=1;i<=M;i++)
+        {
+            scanf("%d%d", &query[i].a, &query[i].b);
+            query[i].index = i;
+        }
+        sort(query+1, query+M+1, cmp);
+        int lastRight = 1;
+        for(int i = 1; i <= M; i ++)
+        {
+            for(int j = lastRight; j <= query[i].b; j ++)
+            {
+                if(last[value[j]] != j)
+                {
+                    edit(last[value[j]], -value[j]);
+                    last[value[j]] = j;
+                }
+            }
+            lastRight = query[i].b;
+            ans[query[i].index] = getSum(query[i].b) - getSum(query[i].a-1);
+        }
+        for(int i=1;i<=M;i++)
+        {
+            printf("%I64d\n", ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3875_autoAC.cpp b/HDOJ/3875_autoAC.cpp
new file mode 100644
index 0000000..f553806
--- /dev/null
+++ b/HDOJ/3875_autoAC.cpp
@@ -0,0 +1,169 @@
+#include<iostream>
+#include<cstring>
+#include<cstdlib>
+#include<cstdio>
+using namespace std;
+typedef unsigned __int64 u64;
+const int MAX=100;
+u64 f0[100],f1[100],ff,n,tmp,ret,ret1,p,pp;
+u64 myrandom()
+{
+    u64 a;
+    a=rand();
+    a*=rand();
+    a*=rand();
+    a*=rand();
+    return a;
+}
+u64 mulmod(u64 a,u64 b,u64 c)
+{
+    u64 ret=0;
+    while(b)
+    {
+        if(b&1)
+        {
+            ret+=a;
+            if(ret>c)
+                ret-=c;
+        }
+        a<<=1;
+        if(a>c)
+            a-=c;
+        b>>=1;
+    }
+    return ret;
+}
+u64 powmod(u64 a,u64 b,u64 c)
+{
+    u64 ret=1;
+    while(b)
+    {
+        if(b&1)
+            ret=mulmod(ret,a,c);
+        a=mulmod(a,a,c);
+        b>>=1;
+    }
+    return ret;
+}
+int miller(u64 base,u64 n)
+{
+    u64 m=n-1,k=0;
+    while(m%2==0)
+    {
+        m>>=1;
+        k++;
+    }
+    if(powmod(base,m,n)==1)
+        return 1;
+    for(int i=0;i<k;i++)
+    {
+        if(powmod(base,m<<i,n)==n-1)
+            return 1;
+    }
+    return 0;
+}
+int Miller_Rabin(u64 n)
+{
+    for(int i=2;i<100;++i)
+        if(n%i==0)
+            if(n==i)
+                return 1;
+            else return 0;
+    for( int i=0;i<MAX;++i)
+    {
+        u64 base=myrandom()%(n-1)+1;
+        if(!miller(base,n))
+            return 0;
+    }
+    return 1;
+}
+u64 gcd(u64 a, u64 b)
+{
+    if(b==0) return a;
+    return gcd(b,a%b);
+}
+u64 f(u64 a,u64 b)
+{
+    return (mulmod(a,a,b)+1)%b;
+}
+u64 Pollard_Rho(u64 n)
+{
+    if(n<=2) return 0;
+    for(u64 i=2;i<100;++i)
+        if(n%i==0)
+            return i;
+    u64 p,x,xx;
+    for( int i=1;i<MAX;i ++)
+    {
+        x=myrandom()%n;
+        xx=f(x,n);
+        p=gcd((xx+n-x)%n,n);
+        while(p==1)
+        {
+            x=f(x,n);
+            xx=f(f(xx,n),n);
+            p=gcd((xx+n-x)%n,n)%n;
+        }
+        if(p) return p;
+    }
+    return 0;
+}
+u64 Prime(u64 a)
+{
+    if(Miller_Rabin(a)) return 0;
+    u64 t=Pollard_Rho(a);
+    u64 p=Prime(t);
+    if(p) return p;
+    return t;
+}
+int main()
+{
+    int tt;
+    scanf("%d",&tt);
+    while(tt--)
+    {
+        scanf("%I64d %I64d",&n,&p);
+        pp=p*2;
+        u64 old=n%pp;
+        ret=1,ret1=1,ff=0;
+        while(n>1)
+        {
+            if(Miller_Rabin(n)) 
+                break;
+            tmp=Prime(n);
+            f0[ff]=tmp;
+            f1[ff]=1;
+            n/=tmp;
+            while(n%tmp==0)
+            {
+                n/=tmp;
+                f1[ff]++;
+            }
+            ff++;
+        }
+        if(n>0)
+        {
+            f0[ff]=n;
+            f1[ff++]=1;
+        }
+        for(int i=0;i<ff;++i)
+        {
+            u64 tmp=1;
+            for(int j=0;j<f1[i];++j)
+                tmp=tmp*f0[i];
+            ret1=ret1*(f1[i]*(tmp-tmp/f0[i])+tmp);
+            ret1=ret1%p;
+            tmp=1;
+            for(int j=0;j<2*f1[i]+1;++j)
+                tmp=tmp*f0[i];
+            ret=ret*((tmp+1)/(1+f0[i]));
+            ret=ret%pp;
+        }
+        ret=((old*(ret+1))%pp)/2;
+        if(ret==ret1)
+            printf("yes\n");
+        else 
+            printf("no\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3876_autoAC.cpp b/HDOJ/3876_autoAC.cpp
new file mode 100644
index 0000000..811efbc
--- /dev/null
+++ b/HDOJ/3876_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<stdio.h>
+#include<math.h>
+int main()
+{
+ int t;
+ int a,b,c;
+ double x1,x2,x,temp;
+ scanf("%d",&t);
+ while(t--)
+ {
+  scanf("%d%d%d",&a,&b,&c);
+  x=b*b-4*a*c;
+  if(x<0)
+   printf("NO\n");
+  else if(x==0)
+  {
+   x1=-1.0*b/(2*a);
+   printf("%.2f\n",x1);
+  }
+  else if(x>0)
+  {
+   x1=(-1.0*b-sqrt(x))/(2*a);
+   x2=(-1.0*b+sqrt(x))/(2*a);
+   if(x1>x2)
+   {
+    temp=x1;x1=x2;x2=temp;
+   }
+   printf("%.2f %.2f\n",x1,x2);
+  }
+ }
+ return 0;
+}
diff --git a/HDOJ/3877_autoAC.cpp b/HDOJ/3877_autoAC.cpp
new file mode 100644
index 0000000..2194da3
--- /dev/null
+++ b/HDOJ/3877_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+using namespace std;
+struct node{
+       __int64 a;
+       __int64 b;
+       __int64 c;
+       int temp;
+       }m[10002];
+__int64 cmp(node x,node y)
+{  
+    if((x.c==y.c)&&((x.a-x.b)*(y.a-y.b)<=0))
+    return x.a>y.a;
+    if(x.c==y.c)
+    return x.temp<y.temp;
+    return x.c>y.c;
+}
+int main()
+{    
+ int t,n,i,j;
+ scanf("%d",&t);
+ while(t--)
+ {
+  scanf("%d",&n);
+  for(i=0;i<n;i++)
+  {
+  scanf("%I64d%I64d",&m[i].a,&m[i].b);
+  m[i].c=m[i].a+m[i].b;
+  m[i].temp=i;
+     }
+  sort(m,m+n,cmp);
+  for(i=0;i<n;i++)
+  {
+  if(m[i].a>m[i].b)
+  printf("%I64d+%I64d=[>%I64d]\n",m[i].a,m[i].b,m[i].c);
+  else if(m[i].a==m[i].b)
+  printf("%I64d+%I64d=[=%I64d]\n",m[i].a,m[i].b,m[i].c);
+  else 
+  printf("%I64d+%I64d=[<%I64d]\n",m[i].a,m[i].b,m[i].c);
+     }
+     printf("\n");
+ }
+ return 0;
+}
diff --git a/HDOJ/3879_autoAC.cpp b/HDOJ/3879_autoAC.cpp
new file mode 100644
index 0000000..2b756cc
--- /dev/null
+++ b/HDOJ/3879_autoAC.cpp
@@ -0,0 +1,110 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#define MAXN 60000              
+#define INF 1e8
+#define min(a,b) (a<b?a:b)
+#define max(a,b) (a>b?a:b)
+using namespace std;
+struct edge
+{
+    int u,v,w,next;
+}E[400050];                     
+int head[MAXN],ecnt;
+int gap[MAXN],cur[MAXN],pre[MAXN],dis[MAXN];
+int l,r,mid;
+int N,M,scr,sink,vn,num;
+void Insert(int u,int v,int w)
+{
+    E[ecnt].u=u;
+    E[ecnt].v=v;
+    E[ecnt].w=w;
+    E[ecnt].next=head[u];
+    head[u]=ecnt++;
+    E[ecnt].u=v;
+    E[ecnt].v=u;
+    E[ecnt].w=0;
+    E[ecnt].next=head[v];
+    head[v]=ecnt++;
+}
+int Sap(int s,int t,int n)
+{
+    int ans=0,aug=INF;
+    int i,v,u=pre[s]=s;
+    for(i=0;i<=n;i++)
+    {
+        cur[i]=head[i];
+        dis[i]=gap[i]=0;
+    }
+    gap[s]=n;
+    bool flag;
+    while(dis[s]<n)
+    {
+        flag=false;
+        for(int &j=cur[u];j!=-1;j=E[j].next)
+        {
+            v=E[j].v;
+            if(E[j].w>0&&dis[u]==dis[v]+1)
+            {
+                flag=true;
+                aug=min(aug,E[j].w);
+                pre[v]=u;
+                u=v;
+                if(u==t)
+                {
+                    ans+=aug;
+                    while(u!=s)
+                    {
+                        u=pre[u];
+                        E[cur[u]].w-=aug;
+                        E[cur[u]^1].w+=aug;
+                    }
+                    aug=INF;
+                }
+                break;
+            }
+        }
+        if(flag) continue;
+        int mindis=n;
+        for(i=head[u];i!=-1;i=E[i].next)
+        {
+            v=E[i].v;
+            if(E[i].w>0&&dis[v]<mindis)
+            {
+                mindis=dis[v];
+                cur[u]=i;
+            }
+        }
+        if((--gap[dis[u]])==0) break;
+        gap[dis[u]=mindis+1]++;
+        u=pre[u];
+    }
+    return ans;
+}
+int n,m;
+int main()
+{
+   while(scanf("%d%d",&n,&m)!=EOF)
+   {
+       memset(head,-1,sizeof(head));ecnt=0;
+       scr=0;sink=n+m+1;vn=sink+1;
+       for(int i=1;i<=n;i++)
+       {
+           int v;
+           scanf("%d",&v);
+           Insert(i,sink,v);
+       }
+       int sum=0;
+       for(int i=1;i<=m;i++)
+       {
+           int a,b,v;
+           scanf("%d%d%d",&a,&b,&v);
+           Insert(scr,i+n,v);
+           Insert(i+n,a,INF);
+           Insert(i+n,b,INF);
+           sum+=v;
+       }
+        printf("%d\n",sum-Sap(scr,sink,vn));
+   }
+   return 0;
+}
diff --git a/HDOJ/3880_autoAC.cpp b/HDOJ/3880_autoAC.cpp
new file mode 100644
index 0000000..3b60e14
--- /dev/null
+++ b/HDOJ/3880_autoAC.cpp
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main(){
+    __int64 i, j, k;
+    __int64 a, b, M;
+    while(scanf("%I64d%I64d%I64d", &a, &b, &M) != EOF){
+        if (a > b){
+            k = a;
+            a = b;
+            b = k;
+        }
+        if (b == 1){
+            k = M;
+        }else{
+            k = 0;
+            j = 1;
+            for (i = b; M / i > 0; i = i * b){
+                k += j * M / i;
+                j = -j;
+            }
+        }
+        printf("%I64d\n", k);
+    }
+    return 0;
+}
diff --git a/HDOJ/3881_autoAC.cpp b/HDOJ/3881_autoAC.cpp
new file mode 100644
index 0000000..7a6d87f
--- /dev/null
+++ b/HDOJ/3881_autoAC.cpp
@@ -0,0 +1,163 @@
+#include <cstdio>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+typedef double typev;
+typedef pair<int, int> pii;
+const int N = 100005;
+const double eps = 1e-8;
+const double DINF = 1e40;
+const double pi = acos(-1.0);
+template<typename T>
+void getSNum(T& ans){
+    char ch;
+    int s;
+    while(true){
+        ch = getchar();
+        if((ch >= '0' && ch <= '9') || ch == '-') break;
+    }
+    if(ch == '-'){
+        s = -1;
+        ans = 0;
+    }else{
+        s = 1;
+        ans = ch -'0';
+    }
+    while(true){
+        ch = getchar();
+        if(!(ch >= '0' && ch <= '9')) break;
+        ans = ans*10+ch-'0';
+    }
+    ans *= s;
+}
+int sign(double a){
+    return a < -eps ? -1 : (a > eps);
+}
+struct point{
+    typev x, y;
+    int id;
+    void read(){
+        scanf("%lf%lf", &x, &y);
+    }
+    void print(){
+        printf("(%lf, %lf)\n", x, y);
+    }
+    point(typev _x=0, typev _y=0):x(_x), y(_y) {}
+}ps[N], que[N];
+int n;
+point k;
+typev xmul(point st, point ed1, point ed2){
+    return (ed1.x-st.x)*(ed2.y-st.y) - (ed1.y-st.y)*(ed2.x-st.x) ;
+}
+bool isLess(pii a, pii b){
+    return a.first < b.first || (a.first == b.first && a.second < b.second);
+}
+double maxSlope(point *ps, int n, pii& ans){
+    int l, r, i, k;
+    double s, tmp;
+    pii ti;
+    l = r = 0;
+    que[r++] = ps[0];
+    s = -DINF;
+    for(i = 1; i < n; i++){
+        while(r-l >= 2){
+            k = sign(xmul(que[l], que[l+1], ps[i]));
+            if(k < 0 || (k == 0 && que[l].id < que[l+1].id)) break;
+            l++;
+        }
+        tmp = (ps[i].y-que[l].y)/(ps[i].x-que[l].x);
+        ti.first = que[l].id; ti.second = ps[i].id;
+        if(sign(s-tmp) < 0 || (sign(s-tmp) == 0 && isLess(ti, ans))){
+            s = tmp;
+            ans = ti;
+        }
+        while(r-l >= 2){
+            k = sign(xmul(que[r-2], que[r-1], ps[i]));
+            if(k > 0 || (k == 0 && que[r-1].id < ps[i].id)) break;
+            r--;
+        }
+        que[r++] = ps[i];
+    }
+    return s;
+}
+bool cmpp(point a, point b){
+    return (a.x < b.x) || (sign(a.x-b.x) == 0 && a.y < b.y);
+}
+double maxSlopeAbs(point* ps, int n, pii& ans){
+    //棣ゆ圭x肩哥
+    sort(ps, ps+n, cmpp);
+    double s = -DINF;
+    int i, j, mi;
+    pii ti;
+    for(i = 0; i < n; i++){
+        for(j = i; j < n && sign(ps[j].x-ps[i].x) == 0; j++) ;
+        if(j-i > 1){
+            for(mi=ps[i].id, i++; i < j; i++){
+                ti.first = mi;
+                ti.second = ps[i].id;
+                if(s < 0 || (s > 0 && isLess(ti, ans))){
+                    s = DINF;
+                    ans = ti;
+                }
+                if(mi > ps[i].id){
+                    mi = ps[i].id;
+                }
+            }
+        }
+        i = j-1;
+    }
+    if(s > 0){
+        return s;
+    }
+    s = maxSlope(ps, n, ans);
+    double tmp;
+    int l, r;
+    for(i = 0; i < n; i++){
+        ps[i].x = 0 - ps[i].x;
+    }
+    l = 0; r = n-1;
+    while(l < r){
+        swap(ps[l++], ps[r--]);
+    }
+    tmp = maxSlope(ps, n, ti);
+    if(sign(tmp-s) > 0 || (sign(tmp-s) == 0 && isLess(ti, ans))){
+        s = tmp;
+        ans = ti;
+    }
+    return s;
+}
+point rotate(point st, double Cos, double Sin){
+    return point(st.x*Sin- st.y*Cos, st.x*Cos+st.y*Sin);
+}
+bool input(){
+    if(scanf("%d", &n) == EOF) return false;
+    k.read();
+    int i, g;
+    double Cos, Sin, len;
+    len = sqrt(k.x*k.x+k.y*k.y);
+    Cos = k.x / len;
+    Sin = k.y / len;
+    for(i = 0; i < n; i++){
+        getSNum(g);
+        ps[i].x = g;
+        getSNum(g);
+        ps[i].y = g;
+        ps[i] = rotate(ps[i], Cos, Sin);
+        ps[i].id = i+1;
+    }
+    return true;
+}
+void solve(){
+    pii ans;
+    if(k.x == 0 && k.y == 0){
+        ans.first = 1;
+        ans.second = 2;
+    }else{
+        maxSlopeAbs(ps, n, ans);
+    }
+    printf("%d %d\n", ans.first, ans.second);
+}
+int main(){
+    while(input()) solve();
+    return 0;
+}
diff --git a/HDOJ/3882_autoAC.cpp b/HDOJ/3882_autoAC.cpp
new file mode 100644
index 0000000..5efd067
--- /dev/null
+++ b/HDOJ/3882_autoAC.cpp
@@ -0,0 +1,100 @@
+#include<stdio.h>
+#include<math.h>
+#include<algorithm>
+#include<string.h>
+#include<iostream>
+using namespace std;
+const double eps=1e-9;
+int dcmp(double x){if(x<-eps) return -1;return x>eps;}
+struct point3
+{
+    double x,y,z;
+    point3(double x=0,double y=0,double z=0):x(x),y(y),z(z){}
+    void read(){int xt,yt,zt;scanf("%d %d %d",&xt,&yt,&zt);x=xt;y=yt;z=zt;}
+};
+point3 operator -(point3 a,point3 b){return point3(a.x-b.x,a.y-b.y,a.z-b.z);}
+point3 operator *(point3 a,double b){return point3(a.x*b,a.y*b,a.z*b);}
+bool operator <(point3 a,point3 b){return a.x<b.x||(dcmp(a.x-b.x)==0&&a.y<b.y)||(dcmp(a.x-b.x)==0&&dcmp(a.y-b.y)==0&&a.z<b.z);}
+bool operator ==(point3 a,point3 b){return !(a<b||b<a);}
+double dot(point3 a,point3 b){return a.x*b.x+a.y*b.y+a.z*b.z;}
+double cross(point3 a,point3 b){return a.x*b.y-a.y*b.x;}
+double length(point3 a){return sqrt(dot(a,a));}
+int convexhull(point3 *p,int n,point3 *ch)  
+{  
+    sort(p,p+n);
+    int nt=0;
+    for(int i=0;i<n;i++)
+    {
+        if(!nt||!(p[nt-1]==p[i])) p[nt++]=p[i];
+    }
+    n=nt;
+    int m=0;  
+    for(int i=0;i<n;i++)  
+    {  
+        while(m>1&&dcmp(cross(ch[m-1]-ch[m-2],p[i]-ch[m-2]))<=0) --m;  
+        ch[m++]=p[i];  
+    } 
+    int k=m;  
+    for(int i=n-2;i>=0;i--)  
+    {  
+        while(m>k&&dcmp(cross(ch[m-1]-ch[m-2],p[i]-ch[m-2]))<=0) --m;  
+        ch[m++]=p[i];  
+    }  
+    if(n>1) --m;  
+    return m;  
+}  
+int n,m;
+double a,b,c,d;
+point3 p[105],p0,q[105],ch[105];
+int main()
+{
+    int i,j;
+    int at,bt,ct,dt;
+    while(scanf("%d %d %d %d",&at,&bt,&ct,&dt)!=EOF&&(at||bt||ct||dt))
+    {
+        a=at,b=bt,c=ct,d=dt;
+        scanf("%d",&n);
+        for(i=0;i<n;i++) p[i].read();
+        p0.read();
+        for(i=0;i<n;i++) p[i]=p[i]-p0;
+        d=d-dot(point3(a,b,c),p0);
+        scanf("%d",&m);
+        for(i=0;i<m;i++) q[i].read(),q[i]=q[i]-p0;
+        int nt=0;
+        for(i=0;i<n;i++)
+        {
+            double te=dot(point3(a,b,c),p[i]);
+            if(dcmp(te)==0) continue;
+            if(dcmp(d/te)>0) p[i]=p[i]*(d/te),++nt;
+        }
+        if(nt==0) printf("ZERO\n");
+        else if(nt<n) printf("INF\n");
+        else
+        {
+            for(i=0;i<n;i++)
+            {
+                if(ct) p[i].z=0;
+                else if(bt) swap(p[i].y,p[i].z),p[i].z=0;
+                else swap(p[i].x,p[i].z),p[i].z=0;
+            }
+            nt=convexhull(p,n,ch);
+            int rt=0;
+            for(i=0;i<m;i++)
+            {
+                double te=dot(point3(a,b,c),q[i]);
+                if(dcmp(te)==0||dcmp(d/te)<0) continue;
+                q[i]=q[i]*(d/te);
+                if(ct) q[i].z=0;
+                else if(bt) swap(q[i].y,q[i].z),q[i].z=0;
+                else swap(q[i].x,q[i].z),q[i].z=0;
+                for(j=0;j<nt;j++)
+                {
+                    if(dcmp(cross(q[i]-ch[j],ch[(j+1)%nt]-ch[j]))>=0) break;
+                }
+                if(j>=nt) {++rt;/*cout<<q[i].x<<" 1 "<<q[i].y<<endl;*/}
+            }
+            printf("%.2lf%%\n",100.0*rt/m);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3883_autoAC.cpp b/HDOJ/3883_autoAC.cpp
new file mode 100644
index 0000000..0c66950
--- /dev/null
+++ b/HDOJ/3883_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int n, m;
+int map[101][101];
+int hash[2][101][101][2];
+bool vis[101];
+int f[2];
+int abs(int a){
+    if (a < 0) return -a;
+    return a;
+}
+int main(){
+    int i, j, k, t, ii, ans;
+    int *p;
+    while(scanf("%d%d", &n, &m) != EOF){
+        for (i = 1; i <= n; i++)
+            for (j = 1; j <= m; j++)
+                scanf("%d", &map[i][j]);
+        memset(vis, 0, sizeof(vis));
+        ans = 0x80000000;
+        ii = 0;
+        for (i = 1; i <= n; i++){            
+            ii = 1 - ii;
+            for (j = 1; j <= m; j++){
+                f[0] = f[1] = 0x80000000;
+                for (k = 100; k >= 0; k--){
+                    for (t = 0; t <= 1; t++){
+                        p = & hash[ii][j][k][t];
+                        *p = 0x80000000;
+                        if (!vis[k]) continue;
+                        if (i > 1 && *p < hash[1 - ii][j][k][t])
+                            *p = hash[1 - ii][j][k][t];
+                        if (j > 1 && *p < hash[ii][j - 1][k][t])
+                            *p = hash[ii][j - 1][k][t];
+                        if (k <= abs(map[i][j])) continue;
+                        if (f[1 - t] < *p) f[1 - t] = *p;
+                    }
+                }
+                if (f[0] == 0x80000000) f[0] = 0;
+                if (f[1] == 0x80000000) f[1] = 0;
+                f[0] = map[i][j] - f[0];
+                f[1] = map[i][j] - f[1];
+                if (ans < f[0]) ans = f[0];
+                k = abs(map[i][j]);
+                if (!vis[k] || hash[ii][j][k][0] < f[0]){
+                    vis[k] = 1;
+                    hash[ii][j][k][0] = f[0];
+                }
+                if (!vis[k] || hash[ii][j][k][1] < f[1]){
+                    vis[k] = 1;
+                    hash[ii][j][k][1] = f[1];
+                }
+            }
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3884_autoAC.cpp b/HDOJ/3884_autoAC.cpp
new file mode 100644
index 0000000..d32b563
--- /dev/null
+++ b/HDOJ/3884_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <memory.h>
+#define MAXN 10006
+#define INF 1e9
+using namespace std;
+struct Node
+{
+    int x,p;
+}node[MAXN];
+int N,ans;
+__int64 K;
+int cmp(const void *p1,const void *p2)
+{
+    return ((struct Node *)p1)->x-((struct Node *)p2)->x;
+}
+void Init()
+{
+    int i;
+    for(i=1;i<=N;i++)
+        scanf("%d%d",&node[i].x,&node[i].p);
+    qsort(node+1,N,sizeof(node[0]),cmp);
+}
+void Solve()
+{
+    int i,j,k;
+    __int64 M,d1,d2;
+    int now;
+    ans=0;
+    for(i=1;i<=N;i++)
+    {
+        k=i-1;j=i+1;
+        M=K;now=node[i].p;
+        while(true)
+        {
+            if(k==0&&j!=N+1) 
+            {
+                d1=INF;
+                d2=node[j].x-node[i].x;
+            }
+            else if(k!=0&&j==N+1)
+            {
+                d1=node[i].x-node[k].x;
+                d2=INF;
+            }
+            else if(k!=0&&j!=N+1)
+            {
+                d1=node[i].x-node[k].x;
+                d2=node[j].x-node[i].x;
+            }
+            else break;
+            if(d1<d2)
+            {
+                if(d1*node[k].p<=M)
+                {
+                    now+=node[k].p;
+                    M-=d1*node[k].p;
+                    k--; 
+                }
+                else
+                {
+                    now+=M/d1;
+                    break;
+                }
+            }
+            else
+            {
+                if(d2*node[j].p<=M)
+                {
+                    now+=node[j].p;
+                    M-=d2*node[j].p;
+                    j++;
+                }
+                else
+                {
+                    now+=M/d2;
+                    break;
+                }
+            }
+        }
+        if(now>ans) ans=now;
+    }
+    printf("%d\n",ans);
+}
+int main()
+{
+    while(scanf("%d%I64d",&N,&K)!=EOF)
+    {
+        Init();
+        Solve();
+    }
+return 0;
+}
diff --git a/HDOJ/3885_autoAC.cpp b/HDOJ/3885_autoAC.cpp
new file mode 100644
index 0000000..de9ac51
--- /dev/null
+++ b/HDOJ/3885_autoAC.cpp
@@ -0,0 +1,154 @@
+#include <iostream>
+#include <cstdio>
+#include <memory.h>
+#include <algorithm>
+#include <queue>
+#define MAXN 55
+#define min(a,b) (a<b?a:b)
+#define max(a,b) (a>b?a:b)
+using namespace std;
+struct Rect
+{
+    int x1,y1,x2,y2;
+}rect[55*55];
+struct Point
+{
+    int x,y;
+    Point(int x1,int y1)
+    {x=x1;y=y1;}
+    Point(){}
+};
+int dir[8][2]={{-1,-1},{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1}};
+int map1[MAXN][MAXN],map2[MAXN][MAXN];
+bool vis[MAXN][MAXN];
+bool flag[55*55];
+int cnt;
+int N,M,cas;
+queue<Point>Q;
+int cmp(const void *p1,const void *p2)
+{
+    if(((struct Rect *)p1)->x1!=((struct Rect *)p2)->x1)
+        return ((struct Rect *)p1)->x1-((struct Rect *)p2)->x1;
+    if(((struct Rect *)p1)->y1!=((struct Rect *)p2)->y1)
+        return ((struct Rect *)p1)->y1-((struct Rect *)p2)->y1;
+    if(((struct Rect *)p1)->x2!=((struct Rect *)p2)->x2)
+        return ((struct Rect *)p2)->x2-((struct Rect *)p1)->x2;
+    return ((struct Rect *)p2)->y2-((struct Rect *)p1)->y2;
+}
+void Init()
+{
+    int i,j;
+    char s[300];
+    for(i=1;i<=N;i++)
+    {
+        for(j=1;j<=M;j++)
+            scanf("%d",&map1[i][j]);
+    }
+    for(i=1;i<=N;i++)
+    {
+        for(j=1;j<=M;j++)
+            scanf("%d",&map2[i][j]);
+    }
+}
+bool Judge(int x,int y)
+{
+    if(x>=1&&x<=N&&y>=1&&y<=M)
+        return true;
+    return false;
+}
+void Run(int dx,int dy,Rect &now)
+{
+    int i;
+    Q.push(Point(dx,dy));
+    if(dx<now.x1||dx>now.x2)
+    {
+        for(i=now.y1;i<=now.y2;i++)
+            Q.push(Point(dx,i));
+    }
+    if(dy<now.y1||dy>now.y2)
+    {
+        for(i=now.x1;i<=now.x2;i++)
+            Q.push(Point(i,dy));
+    }
+    now.x1=min(now.x1,dx);
+    now.y1=min(now.y1,dy);
+    now.x2=max(now.x2,dx);
+    now.y2=max(now.y2,dy);
+}
+void BFS(int sx,int sy)
+{
+    int i,x,y;
+    while(!Q.empty()) Q.pop();
+    memset(vis,false,sizeof(vis));
+    vis[sx][sy]=true;
+    rect[cnt].x1=rect[cnt].x2=sx;
+    rect[cnt].y1=rect[cnt].y2=sy;
+    Q.push(Point(sx,sy));
+    while(!Q.empty())
+    {
+        x=Q.front().x;
+        y=Q.front().y;
+        Q.pop();
+        for(i=0;i<8;i++)
+        {
+            int dx=x+dir[i][0];
+            int dy=y+dir[i][1];
+            if(Judge(dx,dy)&&!vis[dx][dy])
+            {
+                vis[dx][dy]=true;
+                if(map1[dx][dy]!=map2[dx][dy])
+                {
+                    Run(dx,dy,rect[cnt]);
+                }
+            }
+        }
+    }
+    cnt++;
+}
+void Solve()
+{
+    int i,j;
+    cnt=0;
+    for(i=1;i<=N;i++)
+    {
+        for(j=1;j<=N;j++)
+        {
+            if(map1[i][j]!=map2[i][j])
+            {
+                BFS(i,j);
+            }
+        }
+    }
+    qsort(rect,cnt,sizeof(rect[0]),cmp);
+    memset(flag,true,sizeof(flag));
+    int num=0;
+    for(i=0;i<cnt;i++)
+    {
+        if(!flag[i]) continue;
+        for(j=i+1;j<cnt;j++)
+        {
+            if(!flag[j]) continue;
+            if(rect[i].x1<=rect[j].x1&&rect[i].y1<=rect[j].y1&&rect[i].x2>=rect[j].x2&&rect[i].y2>=rect[j].y2)
+            {
+                flag[j]=false;
+            }
+        }
+    }
+    for(i=0;i<cnt;i++)
+        num+=flag[i];
+    printf("%d\n",num);
+    for(i=0;i<cnt;i++)
+    {
+        if(flag[i])
+            printf("%d %d %d %d\n",rect[i].x1,rect[i].y1,rect[i].x2,rect[i].y2);
+    }
+}
+int main()
+{
+    while(scanf("%d%d",&N,&M)!=EOF)
+    {
+        Init();
+        Solve();
+    }
+return 0;
+}
diff --git a/HDOJ/3886_autoAC.cpp b/HDOJ/3886_autoAC.cpp
new file mode 100644
index 0000000..93cec13
--- /dev/null
+++ b/HDOJ/3886_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+#include<algorithm>
+#include<cstring>
+#define ll long long
+#define M 100000000
+using namespace std;
+char str[101],a[101],b[101];
+int len,bit[101],dp[101][101][10];
+bool ok(int i,int u,int v)
+{
+    if(str[i]=='/') return u<v;
+    if(str[i]=='-') return u==v;
+    if(str[i]=='\\') return u>v;
+}
+int dfs(int pos,int j,int pre,bool h,bool f)
+{
+    if(pos==-1) return j==len;
+    if(!f&&dp[pos][j][pre]!=-1) return dp[pos][j][pre];
+    int ans=0;
+    int e=f?bit[pos]:9;
+    for(int i=0;i<=e;i++){
+        if(h) ans+=dfs(pos-1,j,i,h&&i==0,f&&i==e);
+        else if(j<len&&ok(j,pre,i)) ans+=dfs(pos-1,j+1,i,h,f&&i==e);
+        else if(j>0&&ok(j-1,pre,i)) ans+=dfs(pos-1,j,i,h,f&&i==e);
+        ans%=M;
+    }
+    if(!f) dp[pos][j][pre]=ans;
+    return ans;
+}
+int solve(char an[],bool f)
+{
+    int m=0,i,j=0,le=strlen(an);
+    while(an[j]=='0') j++;
+    for(i=le-1;i>=j;i--) bit[m++]=an[i]-'0';
+    if(f&&m>0){
+        for(i=0;i<m;i++){
+            if(bit[i]){
+                bit[i]--;
+                break;
+            }
+            else bit[i]=9;
+        }
+    }
+    return dfs(m-1,0,0,1,1);
+}
+int main()
+{
+    int i,j,k,m,n;
+    while(scanf("%s",str)!=EOF){
+        len=strlen(str);
+        scanf("%s%s",a,b);
+        memset(dp,-1,sizeof(dp));
+        printf("%08d\n",(solve(b,0)-solve(a,1)+M)%M);
+    }
+    return 0;
+}
diff --git a/HDOJ/3887_autoAC.cpp b/HDOJ/3887_autoAC.cpp
new file mode 100644
index 0000000..d84f477
--- /dev/null
+++ b/HDOJ/3887_autoAC.cpp
@@ -0,0 +1,85 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <vector>
+#include <cstring>
+using namespace std;
+const int maxn=100005;
+vector<int>vt[maxn];
+int bit[2*maxn];
+int que[2*maxn];
+int st[maxn];
+int sd[maxn];
+int f[maxn];
+int n, rt, num;
+void dfs(int u, int fa)
+{
+    que[++num]=u;
+    for(int i=0; i<vt[u].size(); i++)
+    {
+        int v=vt[u][i];
+        if(v==fa) continue;
+        dfs(v,u);
+    }
+    que[++num]=u;
+}
+int lowbit(int x)
+{
+    return x&(-x);
+}
+void cal(int x, int val)
+{
+    while(x<=num)
+    {
+        bit[x]+=val;
+        x+=lowbit(x);
+    }
+}
+int getsum(int x)
+{
+    int ans=0;
+    while(x>0)
+    {
+        ans+=bit[x];
+        x-=lowbit(x);
+    }
+    return ans;
+}
+int main()
+{
+    while(~scanf("%d%d",&n,&rt),n+rt)
+    {
+        for(int i=0; i<=n; i++)
+            vt[i].clear();
+        for(int i=1; i<n; i++)
+        {
+            int x, y;
+            scanf("%d%d",&x,&y);
+            vt[x].push_back(y);
+            vt[y].push_back(x);
+        }
+        fill(st+1,st+1+n,0);
+        num=0;
+        dfs(rt,-1);
+        for(int i=1; i<=num; i++)
+        {
+            if(!st[que[i]]) st[que[i]]=i;
+            else sd[que[i]]=i;
+        }
+        memset(bit,0,sizeof(bit));
+        for(int i=1; i<=num; i++)
+            cal(i,1);
+        for(int i=n; i>=1; i--)
+        {
+            f[i]=(getsum(sd[i]-1)-getsum(st[i]))/2;
+            cal(st[i],-1);
+            cal(sd[i],-1);
+        }
+        printf("%d",f[1]);
+        for(int i=2; i<=n; i++)
+            printf(" %d",f[i]);
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/3889_autoAC.cpp b/HDOJ/3889_autoAC.cpp
new file mode 100644
index 0000000..a41f817
--- /dev/null
+++ b/HDOJ/3889_autoAC.cpp
@@ -0,0 +1,83 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+int main()
+{
+ int p,n,i,k=0;
+ double Mx,My,SDx,SDy,SE,rxy,a[10002],b[10002];
+ while(scanf("%d%d",&p,&n)!=EOF)
+ {
+  double sum=0,sx=0,sy=0,Sx=0,Sy=0,s=0,t,SD=0,ka,kb;
+  if(p==1)
+  {
+   for(i = 0 ; i < n ; i ++ )
+   {
+    scanf("%lf",&a[i]);
+    sum+=a[i];
+   }
+   Mx = sum/n;
+   for( i = 0 ; i < n ; i ++ )
+   s += ((a[i]-Mx)*(a[i]-Mx));
+   SDx = sqrt(s/n);
+   printf("%.2lf",(a[0]-Mx)/SDx);
+   for(i=1;i<n;i++)
+   printf(" %.2lf",(a[i]-Mx)/SDx);
+   printf("\n");
+  }
+  else if(p==2)
+  {
+   for( i = 0 ; i <= n ; i ++ )
+   {
+    scanf("%lf",&a[i]);
+    if(i!=0)
+    sum+=a[i];
+   }
+   Mx=sum/n;
+   for( i = 1 ; i <= n ; i ++ )
+   s+=((a[i]-Mx)*(a[i]-Mx));
+   SDx=sqrt(s/(n-1));
+   SE=SDx/sqrt(n);
+   t=(Mx-a[0])/SE;
+   printf("%.2lf\n",t);
+  }
+  else
+  {
+   for( i = 0 ; i < n ; i ++ )
+   {
+    scanf("%lf",&a[i]);
+    sx += a[i];
+   }
+   for( i = 0 ; i < n ; i ++ )
+   {
+    scanf("%lf",&b[i]);
+    sy += b[i];
+   }
+   Mx = sx/n;
+   for( i = 0 ; i < n ; i ++ )
+   Sx += ((a[i]-Mx)*(a[i]-Mx));
+   SDx = sqrt(Sx/n);
+   My = sy/n;
+   for( i = 0 ; i < n ; i ++ )
+   Sy += ((b[i]-My)*(b[i]-My));
+   SDy = sqrt(Sy/n);
+   for( i = 0 ; i < n ; i ++)
+   {
+    SD += ((a[i]-Mx)*(b[i]-My));
+   }
+   rxy = SD/(n*SDx*SDy);
+   kb = rxy*SDy/SDx;
+   ka = My-kb*Mx;
+   if(p==3)
+   {
+      printf("%.2lf\n",rxy);
+   }
+   else
+   {
+       printf("%.2lf %.2lf\n",ka,kb);
+   }
+  }
+ }
+ return 0;
+}
diff --git a/HDOJ/3890_autoAC.cpp b/HDOJ/3890_autoAC.cpp
new file mode 100644
index 0000000..823ca69
--- /dev/null
+++ b/HDOJ/3890_autoAC.cpp
@@ -0,0 +1,122 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+struct point
+{
+    int x,y,flag,tag;
+    double c;
+}p[141000];
+struct tree
+{
+    double c;
+    int num;
+}T1[141000],T2[21000];
+int x[141000],y[141000],xnum,ynum;
+bool cmp(point a,point b)
+{
+    if(a.x!=b.x) return a.x<b.x;
+    if(a.y!=b.y) return a.y<b.y;
+    return a.flag<b.flag;
+}
+void Add(int index,int x,int y,int flag,int tag)
+{
+    p[index].x=x,p[index].y=y;
+    p[index].flag=flag,p[index].tag=tag;
+}
+int Lowbit(int t)
+{
+    return t^(t&(t-1));
+}
+void AddNum(int index,double c)
+{
+    int i;
+    for(i=index;i<=ynum;i+=Lowbit(i))
+    {
+        T1[i].num++;
+        T1[i].c+=c;
+    }
+}
+void Query(int index,int now)
+{
+    int i;
+    for(i=index;i>0;i-=Lowbit(i))
+    {
+        T2[p[now].flag].c=T2[p[now].flag].c+T1[i].c*p[now].tag;
+        T2[p[now].flag].num=T2[p[now].flag].num+T1[i].num*p[now].tag;
+    }
+}
+int BiSearch(int now)
+{
+    int l=0,r=ynum-1,mid;
+    while(l<=r)
+    {
+        mid=(l+r)/2;
+        if(y[mid]>now) r=mid-1;
+        else l=mid+1;
+    }
+    return l;
+}
+int main()
+{
+    int n,m,i,j,x1,y1,x2,y2;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        for(xnum=0,ynum=0,i=0;i<n;i++)
+        {
+            scanf("%d%d%lf",&p[i].x,&p[i].y,&p[i].c);
+            p[i].flag=0;
+            x[xnum++]=p[i].x;
+            y[ynum++]=p[i].y;
+        }
+        for(i=0;i<m;i++)
+        {
+            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
+            x[xnum++]=x2,x[xnum++]=x1-1;
+            y[ynum++]=y2,y[ynum++]=y1-1;
+            Add(n+4*i,x1-1,y1-1,i+1,1);
+            Add(n+4*i+1,x1-1,y2,i+1,-1);
+            Add(n+4*i+2,x2,y1-1,i+1,-1);
+            Add(n+4*i+3,x2,y2,i+1,1);
+            T2[i+1].num=0;
+            T2[i+1].c=0;
+        }
+        sort(x,x+xnum);
+        sort(y,y+ynum);
+        for(j=1,i=1;i<xnum;i++)
+            if(x[i]!=x[i-1])
+                x[j++]=x[i];
+        xnum=j;
+        for(j=1,i=1;i<ynum;i++)
+            if(y[i]!=y[i-1])
+                y[j++]=y[i];
+        ynum=j;
+        for(i=0;i<=ynum+1;i++)
+        {
+            T1[i].c=0;
+            T1[i].num=0;
+        }
+        sort(p,p+n+4*m,cmp);
+        for(y1=0,i=0;i<n+4*m;i++)
+        {
+            if(!p[i].flag)
+            {
+                y1=BiSearch(p[i].y);
+                AddNum(y1,p[i].c);
+            }
+            else
+            {
+                y1=BiSearch(p[i].y);
+                Query(y1,i);
+            }
+        }
+        for(i=1;i<=m;i++)
+        {
+            if(!T2[i].num)
+                printf("0.00/0\n");
+            else
+                printf("%.2lf/%d\n",T2[i].c,T2[i].num);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3891_autoAC.cpp b/HDOJ/3891_autoAC.cpp
new file mode 100644
index 0000000..8b9f93b
--- /dev/null
+++ b/HDOJ/3891_autoAC.cpp
@@ -0,0 +1,73 @@
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+#include<iostream>
+using namespace std;
+const long long P=112233;
+typedef long long ll;
+int n;
+long long c[P*10],pro,p[20],s[20],a[P*10],inv[P*10];
+void exgcd(ll a,ll b,ll &d,ll &x,ll &y){
+ if ( b==0 ){
+ d=a; x=1; y=0;
+ }
+ else{
+ exgcd(b,a%b,d,x,y);
+ ll t=x; x=y; y=t-(a/b)*y;
+ }
+}
+void cnt(){
+ long long d,x,y;
+ for (int i=1;i<=1000001;i++){
+ long long a=i;
+ exgcd(a,P,d,x,y);
+ inv[a]=x;
+ }
+}
+void work(long long a,long long b,int k){
+ for (int i=1;i<=4;i++){
+ while ( a%p[i]==0 ){
+ s[i]++;
+ a/=p[i];
+ }
+ while ( b%p[i]==0 ){
+ s[i]--;
+ b/=p[i];
+ }
+ }
+ pro=(pro*inv[b]*a)%P;
+ c[k]=pro;
+ for (int i=1;i<=4;i++)
+ for (int j=1;j<=s[i];j++)
+ c[k]=c[k]*p[i]%P;
+}
+int main(){
+ cnt();
+while ( scanf("%d",&n)!=EOF ){
+ for (int i=1;i<=n;i++) scanf("%I64d",&a[i]);
+ p[1]=3; p[2]=11; p[3]=19; p[4]=179;
+ pro=1;
+ memset(s,0,sizeof(s));
+ c[0]=1;
+ int e=1;
+ for (int i=1;i<=n;i++)
+ work(n-i+1,i,i);
+ a[0]=0;
+ for (int i=1;i<=n;i++){
+ a[0]=(a[0]+c[i]*a[i]*e)%P;
+ e=-e;
+ }
+ memset(s,0,sizeof(s));
+ pro=1;
+ e=1;
+ for (int i=1;i<=n+1;i++)
+ work(n-i+2,i,i);
+ long long ans=0;
+ for (int i=n;i>=0;i--){
+ ans=(ans+c[i]*a[i]*e)%P;
+ e=-e;
+ }
+ ans=(ans+P)%P;
+ cout<<ans<<endl;
+}
+}
diff --git a/HDOJ/3892_autoAC.cpp b/HDOJ/3892_autoAC.cpp
new file mode 100644
index 0000000..0244567
--- /dev/null
+++ b/HDOJ/3892_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <iostream>
+#include <string.h>
+#include <algorithm>
+#include <stdio.h>
+#include <vector>
+using namespace std;
+typedef long long LL;
+const LL MOD = 999983;
+vector<LL> p[505];
+int T;
+LL quick_mod(LL a,LL b,LL m)
+{
+    LL ans = 1;
+    a %= m;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans = ans*a%m;
+            b--;
+        }
+        b>>=1;
+        a=a*a%m;
+    }
+    return ans;
+}
+vector<LL> poly_gcd(vector<LL> a,vector<LL> b)
+{
+    if(b.size() == 0) return a;
+    int t = a.size() - b.size();
+    vector<LL> c;
+    for(LL i=0; i<=t; i++)
+    {
+        LL tmp = a[i] * quick_mod(b[0],MOD-2,MOD) % MOD;
+        for(LL j=0; j<b.size(); j++)
+            a[i+j] = (a[i+j] - tmp * b[j] % MOD + MOD) % MOD;
+    }
+    LL p = -1;
+    for(LL i=0; i<a.size(); i++)
+    {
+        if(a[i] != 0)
+        {
+            p=i;
+            break;
+        }
+    }
+    if(p >= 0)
+        for(LL i=p; i<a.size(); i++)
+            c.push_back(a[i]);
+    return poly_gcd(b,c);
+}
+bool Import()
+{
+    LL n,t;
+    if(scanf("%d",&T) == 1)
+    {
+        for(LL i=0;i<T;i++)
+        {
+            p[i].clear();
+            scanf("%I64d",&n);
+            for(LL j=0;j<=n;j++)
+            {
+                scanf("%I64d",&t);
+                p[i].push_back(t);
+            }
+        }
+        return true;
+    }
+    return false;
+}
+void Work()
+{
+    if(T==1)
+    {
+        if(p[0].size() > 1) puts("YES");
+        else puts("NO");
+        return;
+    }
+    vector<LL> v = poly_gcd(p[0],p[1]);
+    LL i = 2;
+    while(i < T && v.size() > 1)
+    {
+        v = poly_gcd(v,p[i]);
+        i++;
+    }
+    if(v.size() > 1) puts("YES");
+    else puts("NO");
+}
+int main()
+{
+    while(Import())
+        Work();
+    return 0;
+}
diff --git a/HDOJ/3893_autoAC.cpp b/HDOJ/3893_autoAC.cpp
new file mode 100644
index 0000000..1f538e6
--- /dev/null
+++ b/HDOJ/3893_autoAC.cpp
@@ -0,0 +1,82 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define LL __int64
+const LL mod=112233;
+LL a[14][14]={
+                { 0, 1, 1, 1, 1, 1,1,0,0,0,0,0,0,0},
+                { 1, 0, 1, 1, 1, 1,0,0,0,0,0,0,0,0},
+                { 1, 1, 0, 1, 1, 1,0,0,0,0,0,0,0,0},
+                { 1, 1, 1, 0, 1, 1,0,0,0,0,0,0,0,0},
+                { 1, 1, 1, 1, 0, 1,0,0,0,0,0,0,0,0},
+                { 1, 1, 1, 1, 1, 0,0,0,0,0,1,0,0,0},
+                { 0, 0, 0, 0, 0, 0,0,1,0,0,0,0,0,0},
+                { 0, 0, 0, 0, 0, 0,0,0,1,0,0,0,0,0},
+                { 0, 0, 0, 0, 0, 0,0,0,0,1,0,0,0,0},
+                { 0, 0, 0, 0, 0,-1,0,0,0,0,0,0,0,0},
+                { 0, 0, 0, 0, 0, 0,0,0,0,0,0,1,0,0},
+                { 0, 0, 0, 0, 0, 0,0,0,0,0,0,0,1,0},
+                { 0, 0, 0, 0, 0, 0,0,0,0,0,0,0,0,1},
+                {-1, 0, 0, 0, 0, 0,0,0,0,0,0,0,0,0}
+};
+struct matrix{
+    LL f[14][14];
+};
+matrix mul(matrix a,matrix b)
+{
+    matrix c;
+    LL i,j,k;
+    memset(c.f,0,sizeof(c.f));
+    for(k=0;k<14;k++)
+    {
+        for(i=0;i<14;i++)
+        {
+            if(!a.f[i][k])continue;
+            for(j=0;j<14;j++)
+            {
+                if(!b.f[k][j])continue;
+                c.f[i][j]=(c.f[i][j]+a.f[i][k]*b.f[k][j])%mod;
+            }
+        }
+    }
+    return c;
+}
+matrix pow_mod(matrix a,LL b)
+{
+    matrix s;
+    memset(s.f,0,sizeof(s.f));
+    for(LL i=0;i<14;i++)
+        s.f[i][i]=1;
+    while(b)
+    {
+        if(b&1)
+            s=mul(s,a);
+        a=mul(a,a);
+        b=b>>1;
+    }
+    return s;
+}
+int main()
+{
+    LL n;
+    while(cin>>n)
+    {
+        if(n%2==0)
+        {
+            cout<<0<<endl;
+            continue;
+        }
+        matrix e;
+        LL i,j,ans=0;
+        memcpy(e.f,a,sizeof(a));
+        e=pow_mod(e,n/2);
+        for(i=0;i<6;i++)
+            for(j=0;j<6;j++)
+            ans=(ans+e.f[i][j])%mod;
+        cout<<(ans+mod)%mod<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/3894_autoAC.cpp b/HDOJ/3894_autoAC.cpp
new file mode 100644
index 0000000..9a18f19
--- /dev/null
+++ b/HDOJ/3894_autoAC.cpp
@@ -0,0 +1,142 @@
+#include <iostream>
+#include <stdio.h>
+using namespace std;
+const int N = 1000005;
+struct e{
+    int v;
+    e* nxt;
+}es[N<<1], *fir[N], stk[N];
+int n, m, en, p;
+int E, W;
+bool hasFood[N];
+int eastNum[N], westNum[N], par[N];
+int minp[N], t[N], que[N], dep[N];
+inline void add_e(int u, int v){
+    es[en].v = v;
+    es[en].nxt = fir[u];
+    fir[u] = &es[en++];
+}
+template <typename T>
+void getNum(T& a){
+    a = 0;
+    char ch;
+    while(true){
+        ch = getchar();
+        if(ch >= '0' && ch <= '9') break;
+    }
+    a = ch - '0';
+    while(true){
+        ch = getchar();
+        if(ch < '0' || ch > '9') break;
+        a = a * 10 + ch - '0';
+    }
+}
+bool input(){
+    if(scanf("%d%d%d%d", &n, &m, &E, &W)== EOF) return false;
+    int i, u, v;
+    en = 0;
+    for(i = 1; i <= n; i++){
+        fir[i] = NULL;
+        hasFood[i] = false;
+    }
+    for(i = 1; i < n; i++){
+        getNum<int>(u);
+        getNum<int>(v);
+        add_e(u, v);
+        add_e(v, u);
+    }
+    scanf("%d", &p);
+    for(i = 1; i <= p; i++){
+        getNum(u);
+        hasFood[i] = true;
+    }
+    return true;
+}
+inline bool isEast(int u){ return u  <= E; }
+inline bool has(int u) { return hasFood[u]; }
+inline bool isWest(int u){ return u >= n - W + 1; }
+inline void push(int v, int p, int& top){
+    eastNum[v] = westNum[v] = 0;
+    if(isEast(v)){
+        eastNum[v]++;
+    }else if(isWest(v)){
+        westNum[v]++;
+    }
+    ++top;
+    stk[top].v = v;
+    stk[top].nxt = fir[v];
+    par[v] = p;
+}
+typedef bool (*fun)(int u);
+void bfs(int st, int* ar, fun check){
+    int l, r, u, v, num;
+    e* cur;
+    l = r = num = 0;
+    que[r++] = st; dep[st] = 0;
+    if(check(st)){
+        ar[num++] = 0;
+    }
+    while(l != r && num < p){
+        u = que[l++];
+        for(cur = fir[u]; cur; cur = cur->nxt){
+            if((v = cur->v) != par[u]){
+                que[r++] = v; par[v] = u; dep[v] = dep[u] + 1;
+                if(check(v)){
+                    ar[num++] = dep[v];
+                    if(num >= p) break;
+                }
+            }
+        }
+    }
+}
+void solve(){
+    int top = -1, u, v, est, wst, ans;
+    int i, maxt;
+    push(1, -1, top);
+    while(top >= 0){
+        u = stk[top].v;
+        if(stk[top].nxt == NULL){
+            if(eastNum[u] == 0 && westNum[u] == W){
+                wst = u;
+                est = par[u];
+                break;
+            }
+            if(eastNum[u] == E && westNum[u] == 0){
+                wst = par[u];
+                est = u;
+                break;
+            }
+            if(par[u] >= 1){
+                eastNum[par[u]] += eastNum[u];
+                westNum[par[u]] += westNum[u];
+            }
+            top--;
+            continue;
+        }else{
+            v = stk[top].nxt->v;
+            stk[top].nxt = stk[top].nxt->nxt;
+            if(v != par[u]){
+                push(v, u, top);
+            }
+        }
+    }
+    par[est] = wst;
+    par[wst] = est;
+    bfs(wst, minp, isWest);
+    bfs(est, t, has);
+    ans = 0;
+    maxt = -1;
+    for(i = 0; i < p; i++){
+        if(t[i] < maxt + 1) t[i] = maxt + 1;
+        maxt = t[i];
+        if(ans < t[i] + minp[p - i - 1]){
+            ans = t[i] + minp[p - i - 1];
+        }
+    }
+    ans++;
+    cout<<ans<<endl;
+}
+int main() {
+    while(input()) solve();
+    return 0;
+}
diff --git a/HDOJ/3895_autoAC.cpp b/HDOJ/3895_autoAC.cpp
new file mode 100644
index 0000000..18542fa
--- /dev/null
+++ b/HDOJ/3895_autoAC.cpp
@@ -0,0 +1,76 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cmath>
+const double eps=1e-4;
+using namespace std;
+inline double sqr(double a)
+{
+    return a*a;
+}
+double ax, x2, x3, ay, y2, y3, r1, r2, r3;
+int m1, m2, m3;
+bool check(double x, double y, double r)
+{
+    if(fabs(sqr(x-ax)+sqr(y-ay)-sqr(r+m1*r1))>eps)return false;
+    if(fabs(sqr(x-x2)+sqr(y-y2)-sqr(r+m2*r2))>eps)return false;
+    if(fabs(sqr(x-x3)+sqr(y-y3)-sqr(r+m3*r3))>eps)return false;
+    return true;
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    while(t-->0)
+    {
+        scanf("%lf%lf%lf%d%lf%lf%lf%d%lf%lf%lf%d", &ax, &ay, &r1, &m1, &x2, &y2, &r2, &m2, &x3, &y3, &r3, &m3);
+        if(m1==0)m1=-1;
+        if(m2==0)m2=-1;
+        if(m3==0)m3=-1;
+        double a, b, c, d, aa, bb, cc, dd;
+        a=2*(ax-x2);
+        b=2*(ay-y2);
+        c=2*(r2*m2-r1*m1);
+        d=m2*m2*r2*r2-m1*m1*r1*r1-x2*x2+ax*ax-y2*y2+ay*ay;
+        aa=2*(ax-x3);
+        bb=2*(ay-y3);
+        cc=2*(r3*m3-r1*m1);
+        dd=m3*m3*r3*r3-m1*m1*r1*r1-x3*x3+ax*ax-y3*y3+ay*ay;
+        double a1, b1, a2, b2;
+        if(fabs(bb*a-aa*b)<eps){printf("NO SOLUTION!\n");continue;}
+        a1=(a*cc-c*aa)/(bb*a-aa*b);
+        b1=(dd*a-d*aa)/(bb*a-aa*b);
+        if(fabs(b*aa-bb*a)<eps){printf("NO SOLUTION!\n");continue;}
+        a2=(cc*b-c*bb)/(b*aa-bb*a);
+        b2=(b*dd-bb*d)/(b*aa-bb*a);
+        double A, B, C;
+        A=a2*a2+a1*a1-1;
+        B=2*a2*b2-2*ax*a2+2*a1*b1-2*ay*a1-2*m1*r1;
+        C=b2*b2-2*ax*b2+ax*ax+b1*b1-2*ay*b1+ay*ay-r1*r1;
+        double rr;
+        if(B*B-4*A*C<0){printf("NO SOLUTION!\n");continue;}
+        if(fabs(A)<eps){printf("NO SOLUTION!\n");continue;}
+        rr=(sqrt(B*B-4*A*C)-B)/2/A;
+        double rx=a2*rr+b2;
+        double ry=a1*rr+b1;
+        if(rr>=-eps&&check(rx, ry, rr))
+        {
+            printf("%.4lf %.4lf", rx, ry);
+            if(fabs(rr)>=eps)printf(" %.4lf", rr);
+            printf("\n");
+            continue;
+        }
+        rr=(-B-sqrt(B*B-4*A*C))/2/A;
+        rx=a2*rr+b2;
+        ry=a1*rr+b1;
+        if(rr>=-eps&&check(rx, ry, rr))
+        {
+            printf("%.4lf %.4lf", rx, ry);
+            if(fabs(rr)>=eps)printf(" %.4lf", rr);
+            printf("\n");
+            continue;
+        }
+        printf("NO SOLUTION!\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3896_autoAC.cpp b/HDOJ/3896_autoAC.cpp
new file mode 100644
index 0000000..faf72f8
--- /dev/null
+++ b/HDOJ/3896_autoAC.cpp
@@ -0,0 +1,152 @@
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#define len1 100001
+#define len2 1000001
+#define min(x1,x2) ((x1)<(x2)?(x1):(x2))
+#define swap(x1,x2) {int _t = x1 ; x1 = x2 ; x2 = _t;}
+int dfn[len1] , low[len1] , final[len1] , hash[len1] , sm = 0 , timel = 0 , deep[len1] ;
+int n , m , lim = 0 ;
+int fa[20][len1] , ed[20] ;
+struct edge
+{
+    int tot  ;
+    int now[len1] , next[len2] , g[len2] ;
+    void add( int st, int ed )
+    {
+        ++tot;
+        g[tot] = ed ;
+        next[tot] = now[st];
+        now[st] = tot ;
+    }
+}e;
+void dfs( int x , int ff , int dep )
+{
+    ++timel ;
+    dfn[x] = low[x] = timel ;
+    hash[x] = sm ;
+    deep[x] = dep ;
+    for ( int i = e.now[x] ; i ; i = e.next[i] )
+    if ( e.g[i] != ff )
+    {
+        if ( hash[ e.g[i] ] != sm )
+        {
+            dfs( e.g[i] , x , dep+1 );
+            low[x] = min( low[x] , low[ e.g[i] ] );
+            fa[1][ e.g[i] ] = x ;
+        }
+        else
+            low[x] = min( low[x] , dfn[ e.g[i] ] );
+    }
+    final[x] = ++timel ;
+}
+bool ini( int a , int b )
+{
+    if ( dfn[a] >= dfn[b] && final[a] <= final[b] )
+        return true ;
+    return false;
+}
+bool judge( int sc , int sv , int g1 , int g2 ) 
+{
+    int fl = 0 ;
+    if ( deep[g1] < deep[g2] )
+        swap(g1,g2);
+    if ( ini( sc , g1 ) && ini( sv , g1 ) )
+        fl = 1 ;
+    else if ( !ini( sc , g1 ) && !ini( sv , g1 ) )
+        fl = 1 ;
+    else if ( low[g1] <= dfn[g2] )
+        fl = 1 ;
+    return fl ;
+}
+int move( int x , int step )
+{
+    int t = x , p = 1;
+    if ( step < 0 )
+        return -1 ;
+    while ( step )
+    {
+        if ( step & 1 )
+            t = fa[p][t];
+        step >>= 1 ;
+        ++p;
+    }
+    return t ;
+}
+int main()
+{
+    FILE *in , *out;
+    int sc , sv , g1 , g2 , q , t , t1 , t2 ;
+    int fl = 1 ;
+    scanf("%d%d",&n,&m);
+    ed[1] = 1 ;
+    for ( int i = 2 ; ; ++i )
+    {
+        ed[i] = (ed[i-1]<<1);
+        lim = i ;
+        if ( ed[i] >= n )
+            break;
+    }
+    for ( int i = 1 ; i <= m ; ++i )
+    {
+        scanf("%d%d",&sc,&sv);
+        e.add( sc , sv );
+        e.add( sv , sc );
+    }
+    ++sm  ;
+    dfs( 1 , 1 , 1 );
+    for ( int i = 2 ; i <= lim ; ++i )
+        for ( int j = 1 ; j <= n ; ++j )
+            fa[i][j] = fa[i-1][ fa[i-1][j] ];
+    scanf("%d",&q);
+    for ( int i = 1 ; i <= q ; ++i )
+    {
+        if ( i == 27 )
+            i = 27 ;
+        scanf("%d",&t);
+        fl = 0 ;
+        if ( t == 1 )
+        {
+            scanf("%d%d%d%d",&sc,&sv,&g1,&g2);
+            fl = judge( sc , sv , g1 , g2 );
+        }
+        else
+        {
+            scanf("%d%d%d",&sc,&sv,&g1);
+            if ( !ini( sc , g1 ) && !ini( sv , g1 ) )
+                fl = 1 ;
+            else if ( ini( sc , g1 )^ini( sv , g1 ) )
+            {
+                if ( ini( sc , g1 ) )
+                {
+                    t = move( sc , deep[sc] - deep[g1] - 1 );
+                    if ( low[t] < dfn[g1] )
+                        fl = 1 ;
+                }
+                else
+                {
+                    t = move( sv , deep[sv] - deep[g1] - 1 );
+                    if ( low[t] < dfn[g1] )
+                        fl = 1 ;
+                }
+            }
+            else
+            {
+                t1 = move( sc , deep[sc] - deep[g1] - 1 );
+                t2 = move( sv , deep[sv] - deep[g1] - 1 );
+                if ( t1 == t2 )
+                    fl = 1 ;
+                else
+                {
+                    if ( low[t1] < dfn[g1] && low[t2] < dfn[g1] )
+                        fl = 1;
+                }
+            }
+        }
+        if ( fl )
+            printf("yes\n");
+        else
+            printf("no\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3899_autoAC.cpp b/HDOJ/3899_autoAC.cpp
new file mode 100644
index 0000000..e832e67
--- /dev/null
+++ b/HDOJ/3899_autoAC.cpp
@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <memory.h>
+const int maxn = 100005;
+struct Graph {
+    int hed[maxn], nxt[maxn*2], pnt[maxn*2], val[maxn*2];
+    int idx;
+    void init(int n) {
+        memset(hed + 1, -1, n * 4);
+        idx = 0;
+    }
+    void addedge(int x, int y, int v) {
+        pnt[idx] = y; val[idx] = v; nxt[idx] = hed[x]; hed[x] = idx++;
+        pnt[idx] = x; val[idx] = v; nxt[idx] = hed[y]; hed[y] = idx++;
+    }
+} gra;
+struct Node {
+    int r, x, p;
+} sta[maxn];
+int teams[maxn], total;
+__int64 cunt[maxn], cost[maxn];
+void dfs_1() {
+    int x, y, r, p, top = 0;
+    sta[0].x = 1; sta[0].r = 0; sta[0].p = gra.hed[1];
+    cunt[1] = teams[1];
+    cost[1] = 0;
+    while (true) {
+        p = sta[top].p;
+        if (p == -1) {
+            top--;
+            if (top >= 0) {
+                p = sta[top].p;
+                x = sta[top].x;
+                y = gra.pnt[p];
+                cunt[x] += cunt[y];
+                cost[x] += cunt[y] * gra.val[p] + cost[y];
+                sta[top].p = gra.nxt[p];
+            } else {
+                break;
+            }
+        } else {
+            x = sta[top].x;
+            r = sta[top].r;
+            y = gra.pnt[p];
+            if (y != r) {
+                ++top;
+                cunt[y] = teams[y];
+                cost[y] = 0;
+                sta[top].r = x;
+                sta[top].x = y;
+                sta[top].p = gra.hed[y];
+            } else {
+                sta[top].p = gra.nxt[p];
+            }
+        }
+    }
+}
+void dfs_2() {
+    int x, y, r, p, top = 0;
+    sta[0].x = 1; sta[0].r = 0; sta[0].p = gra.hed[1];
+    while (true) {
+        p = sta[top].p;
+        if (p == -1) {
+            top--;
+            if (top >= 0) {
+                p = sta[top].p;
+                sta[top].p = gra.nxt[p];
+            } else {
+                break;
+            }
+        } else {
+            x = sta[top].x;
+            r = sta[top].r;
+            y = gra.pnt[p];
+            if (y != r) {
+                ++top;
+                cost[y] = cost[x] + (total - 2 * cunt[y]) * gra.val[p];
+                sta[top].r = x;
+                sta[top].x = y;
+                sta[top].p = gra.hed[y];
+            } else {
+                sta[top].p = gra.nxt[p];
+            }
+        }
+    }
+}
+int main() {
+    int n, x, y, v;
+    while (scanf("%d", &n) != EOF) {     
+        total = 0;
+        for (int i = 1; i <= n; i++) {
+            scanf("%d", teams + i);
+            total += teams[i];
+        }
+        gra.init(n);
+        for (int i = 1; i < n; i++) {
+            scanf("%d %d %d", &x, &y, &v);
+            gra.addedge(x, y, v);
+        }
+        dfs_1();
+        dfs_2();
+        __int64 ans = cost[1];
+        for (int i = 2; i <= n; i++) {
+            if (cost[i] < ans)
+                ans = cost[i];
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3900_autoAC.cpp b/HDOJ/3900_autoAC.cpp
new file mode 100644
index 0000000..0938134
--- /dev/null
+++ b/HDOJ/3900_autoAC.cpp
@@ -0,0 +1,115 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std;
+#define ll long long
+struct data
+{
+    int t,l,c;  
+}B[3545];       
+int n,r;   
+#include<map>
+#include<queue>
+#include<set>
+map<ll,bool > vis;
+ll s;
+inline bool check(ll s,int x) 
+{
+    int tx=(s&(7ll<<(x*3)))>>(x*3);
+    for(int i=0;i<n;i++)
+    {
+        if(i==x) continue;
+        int ti=(s&(7ll<<(i*3)))>>(i*3);
+        if(B[x].t==B[i].t) {
+            if(B[x].c!=B[i].c) continue;
+            if(tx+B[x].l<=ti||ti+B[i].l<=tx) continue;
+            return 0;
+        } else {
+            if(tx+B[x].l>B[i].c&&B[i].c>=tx&&
+               ti<=B[x].c&&B[x].c<B[i].l+ti) {
+                return 0;
+            }
+        }
+    }
+    return 1;
+}
+inline bool done(ll s)
+{
+    for(int i=0;i<n;i++) {
+        if(B[i].t==1) continue;
+        int tt= ((s&(7ll<<(3*r)))>>(r*3));
+        if(B[i].c<tt+B[r].l) continue;
+        int l=((s&(7ll<<(3*i)))>>(i*3)) , r=l+B[i].l;
+        if(r<=2||l>2) continue;
+        return 0;
+    }
+    return 1;
+}
+inline void cover(ll& s,int x,int p)
+{
+    s&=~(7ll<<(x*3));
+    s|=(ll)p<<(x*3);
+}
+#define pii  pair<ll,int>
+#define  mp  make_pair
+int bfs(ll s)
+{
+    if(done(s)) return 1;
+    queue< pii  > q;
+    q.push(mp(s,0));
+    vis.clear();
+    vis[s]=1;
+    while(!q.empty()) {
+        pii tt=q.front(); q.pop();
+        ll u=tt.first;
+        int d=tt.second+1;
+        for(int i=0;i<n;i++) {
+            int p=(u&(7ll<<(i*3)))>>(i*3);
+            for(int j=1;j<=p;j++) {
+                ll v=u;
+                cover(v,i,p-j);
+                if(!check(v,i)) break;
+                if(done(v)) return d+1;
+                if(vis[v]) continue;
+                vis[v]=1;
+                q.push(mp(v,d));
+            }
+            for(int j=1;p+j+B[i].l<=6;j++) {
+                ll v=u;
+                cover(v,i,p+j);
+                if(!check(v,i)) break;
+                if(done(v)) return d+1;
+                if(vis[v]) continue;
+                vis[v]=1;
+                q.push(mp(v,d));
+            }
+        }
+    }
+    return -1;
+}
+int main()
+{
+    while(cin>>n&&n)
+    {
+       ll s=0;
+        for(int i=0;i<n;i++)
+        {
+            int t,lx,ly,rx,ry;
+            cin>>t>>lx>>ly>>rx>>ry;
+            if(lx==rx) {
+                B[i].t=0;
+                B[i].l=ry-ly+1;
+                B[i].c=lx;
+                s|=((ll)ly<<(3*i));
+            }
+            else {
+                B[i].t=1;
+                B[i].l=rx-lx+1;
+                B[i].c=ly;
+                s|=((ll)lx<<(3*i));
+            }
+        }
+        cin>>r;
+        cout<<bfs(s)<<endl;
+    }
+}
diff --git a/HDOJ/3901_autoAC.cpp b/HDOJ/3901_autoAC.cpp
new file mode 100644
index 0000000..2bd17ed
--- /dev/null
+++ b/HDOJ/3901_autoAC.cpp
@@ -0,0 +1,133 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <utility>
+#include <queue>
+#include <vector>
+#include <algorithm>
+using namespace std;
+#define pb push_back
+typedef pair <int, int> pt;
+const int BUF_SIZE = 100000, SON = 26;
+char s[BUF_SIZE + 1], t[BUF_SIZE + 1];
+int lens, lent;
+vector <pt> vec;
+bool fir, las;
+struct node_t {
+    node_t *son[SON], *fail;
+    vector <int> lis;
+} node_pool[BUF_SIZE + 1], *node_idx, *root;
+node_t *node_alloc() {
+    node_t *ret = node_idx ++;
+    memset(ret -> son, 0, sizeof(ret -> son));
+    ret -> fail = NULL;
+    ret -> lis.clear();
+    return ret;
+}
+void init() {
+    node_idx = node_pool;
+    root = node_alloc();
+}
+void ins(char *st, char *ed, int p) {
+    node_t *pos = root;
+    while (st != ed) {
+        int t = *(st ++) - 'a';
+        if (!pos -> son[t]) pos -> son[t] = node_alloc();
+        pos = pos -> son[t];
+    }
+    pos -> lis.pb(p);
+}
+void build() {
+    static queue <node_t *> q;
+    for (int i = 0; i < SON; i ++)
+        if (root -> son[i]) {
+            root -> son[i] -> fail = root;
+            q.push(root -> son[i]);
+        }
+        else root -> son[i] = root;
+    while (q.size()) {
+        node_t *u = q.front();
+        q.pop();
+        for (int i = 0; i < SON; i ++)
+            if (u -> son[i]) {
+                u -> son[i] -> fail = u -> fail -> son[i];
+                for (vector <int>::iterator it = u -> fail -> son[i] -> lis.begin(); it != u -> fail -> son[i] -> lis.end(); it ++)
+                    u -> son[i] -> lis.pb(*it);
+                q.push(u -> son[i]);
+            }
+            else u -> son[i] = u -> fail -> son[i];
+    }
+}
+bool solve(int lb, int rb, bool st, bool ed) { 
+    init();
+    int pat = 0;
+    static int cnt[BUF_SIZE];
+    memset(cnt, 0, sizeof(cnt));
+    for (int i = lb; i < rb; )
+        if (t[i] == '?') i ++;
+        else {
+            int j = i;
+            while (j < rb && t[j] != '?') j ++;
+            ins(t + i, t + j, j - 1 - lb);
+            i = j;
+            pat ++;
+        }
+    build();
+    node_t *pos = root;
+    for (int i = 0; i < lens; i ++) {
+        int p = s[i] - 'a';
+        pos = pos -> son[p];
+        node_t *tmp = pos;
+        for (vector <int>::iterator it = tmp -> lis.begin(); it != tmp -> lis.end(); it ++) {
+            int q = *it;
+            if (i - q >= 0)
+                cnt[i - q] ++;
+        }
+    }
+    for (int i = 0; i < lens; i ++)
+        if (cnt[i] == pat) {
+            if (vec.empty()) {
+                if (!fir && st && i != 0) continue;
+                if (!las && ed && i + rb - lb != lens) continue;
+                vec.pb(make_pair(i, i + rb - lb));
+                return 1;
+            }
+            else {
+                vector <pair <int, int> >::reverse_iterator it = vec.rbegin();
+                if (i >= it -> second) {
+                    if (ed && !las && i + rb - lb != lens) continue;
+                    vec.pb(make_pair(i, i + rb - lb));
+                    return 1;
+                }
+            }
+        }
+    return 0;
+}
+int main() {
+    while (scanf("%s%s", s, t) != EOF) {
+        lens = strlen(s), lent = strlen(t);
+        fir = (t[0] == '*'), las = (t[lent - 1] == '*');
+        vec.clear();
+        bool fail = 0;
+        int split = 0;
+        int real_end = lent;
+        while (real_end && t[real_end - 1] == '*') real_end --;
+        for (int i = 0; i < lent; )
+            if (t[i] == '*') i ++;
+            else {
+                int j = i;
+                while (j < lent && t[j] != '*') j ++;
+                if (!solve(i, j, split == 0, j == real_end)) {
+                    fail = 1;
+                    split ++;
+                    break;
+                }
+                i = j;
+                split ++;
+            }
+        if (split == 0) printf("YES\n");
+        else if (fail) printf("NO\n");
+        else printf("YES\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3902_autoAC.cpp b/HDOJ/3902_autoAC.cpp
new file mode 100644
index 0000000..0b7a02b
--- /dev/null
+++ b/HDOJ/3902_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<iostream>
+using namespace std;
+#define N 40005
+struct node{
+    double x,y;
+}p[N];
+int n;
+double cal_dis(int x,int y){
+    double x1=p[x].x,y1=p[x].y;
+    double x2=p[y].x,y2=p[y].y;
+    return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
+}
+int main(void){
+    while(~scanf("%d",&n)){
+        int k=1;
+        for(int i=1;i<=n;i++){
+            scanf("%lf%lf",&p[k].x,&p[k].y);
+            if(k!=1&&k%2){
+                p[k-1].x=(p[k-2].x+p[k].x)/2.0;
+                p[k-1].y=(p[k-2].y+p[k].y)/2.0;
+            }
+            k+=2;
+        }
+        p[k-1].x=(p[1].x+p[k-2].x)/2.0;
+        p[k-1].y=(p[1].y+p[k-2].y)/2.0;
+        bool flag=0;
+        for(int i=1;i<=n;i++){
+            double x1=p[i].x-p[i+n].x;
+            double y1=p[i].y-p[i+n].y;
+            int j,k;
+            k=i-1;
+            j=i+1;
+            for(;j<=i+n;j++,k--){
+                if(k<=0) k=2*n;
+                double x2=p[j].x-p[k].x;
+                double y2=p[j].y-p[k].y;
+                if(x1*x2+y1*y2!=0)
+                    break;
+                if(cal_dis(i,j)!=cal_dis(i,k))
+                    break;
+            }
+            if(j>i+n){
+                flag=1;
+                break;
+            }
+        }
+        if(flag)
+            printf("YES\n");
+        else
+            printf("NO\n");
+    }
+}
diff --git a/HDOJ/3903_autoAC.cpp b/HDOJ/3903_autoAC.cpp
new file mode 100644
index 0000000..521e49c
--- /dev/null
+++ b/HDOJ/3903_autoAC.cpp
@@ -0,0 +1,18 @@
+#include<stdio.h>
+#include<math.h>
+int main()
+{
+    __int64 t, a, b, c, n, m, k;
+    scanf("%I64d",&t);
+    while(t--)
+    {
+        scanf("%I64d%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&n,&m,&k);
+        __int64 s = 4 * a * a * b * b - (a * a + b * b - c * c) * (a * a + b * b - c * c);
+        __int64 tmp = sqrt(s);
+        if(tmp * tmp == s)
+            printf("YES\n");
+        else
+            printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3905_autoAC.cpp b/HDOJ/3905_autoAC.cpp
new file mode 100644
index 0000000..e88ebd8
--- /dev/null
+++ b/HDOJ/3905_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<iostream>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+int dp[1005][1005],sum[1005],a[1005],s[1005][1005];
+int main()
+{
+    int n,m,r;
+    while(scanf("%d%d%d",&n,&m,&r)!=EOF)
+    {
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&a[i]);
+            sum[i]=sum[i-1]+a[i];
+        }
+        memset(dp,-1,sizeof(dp));
+        memset(s,-0x1f1f1f1f,sizeof(s));
+        dp[0][0]=0;s[0][0]=-sum[1];
+        for(int i=1;i<=n;i++)
+        {
+            if(i>=r)
+            {
+                dp[0][i]=sum[i];         
+            }
+            dp[i][i]=0;
+            s[0][i]=max(s[0][i-1],dp[0][i]-sum[i+1]);
+        }
+        for(int i=1;i<=m;i++)
+        {
+            for(int j=i;j<=n;j++)
+            {
+                if(dp[i-1][j-1]!=-1)
+                    dp[i][j]=max(dp[i-1][j-1],dp[i][j]);
+                if(j-r>=i&&s[i-1][j-r-1]!=-0x1f1f1f1f)
+                    dp[i][j]=max(dp[i][j],sum[j]+s[i-1][j-r-1]);
+                if(dp[i][j]!=-1)
+                    s[i][j]=max(s[i][j-1],dp[i][j]-sum[j+1]);
+                else
+                    s[i][j]=s[i][j-1];
+            }
+        }
+        printf("%d\n",dp[m][n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3907_autoAC.cpp b/HDOJ/3907_autoAC.cpp
new file mode 100644
index 0000000..bb415ec
--- /dev/null
+++ b/HDOJ/3907_autoAC.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <string.h>
+using namespace std;
+struct e{
+    int data;
+    int weight;
+    e *next;
+};
+e edge[1001];
+int n;
+void add(int s,int t,int weight){
+    e *p=new e;
+    p->data=t;
+    p->next=edge[s].next;
+    p->weight=weight;
+    edge[s].next=p;
+}
+int s[1001],q[1001];
+int f[1001][1001];
+int solve(int s1,int t1,int w){
+    int ans1=0;
+    int ans2=0;
+    int i,j,k;
+    if(f[s1][t1]!=-1) return f[s1][t1];
+    e *p=edge[s1].next;
+    e *q1=p;
+    if(w>q[s1])
+    {
+        while(p)
+        {
+            solve(p->data,s1,p->weight);
+            ans1+=f[p->data][s1];
+            p=p->next;
+        }
+        f[s1][t1]=ans1+s[s1];
+    }
+    else
+    {
+        while(p)
+        {
+            solve(p->data,s1,p->weight);
+            ans1+=f[p->data][s1];
+            p=p->next;
+        }
+        while(q1)
+        {
+            solve(q1->data,t1,w+q1->weight);
+            ans2+=f[q1->data][t1];
+            q1=q1->next;
+        }
+        f[s1][t1]=min(ans2,ans1+s[s1]);
+    }
+    return f[s1][t1];
+}
+void read(){
+    int i,j,k,s1,t,root;
+    int cas;
+    cin>>cas;
+    while(cas--)
+    {
+        cin>>n;
+        memset(edge,0,sizeof(edge));
+        memset(f,-1,sizeof(f));
+        for(i=1;i<=n;i++)
+        {
+            cin>>j>>k>>s1>>t;
+            if(j!=0) add(j,i,t);
+            else root=i;
+            q[i]=k;
+            s[i]=s1;
+        }
+        e *p=edge[root].next;
+        int ans=0;
+        while(p)
+        {
+            ans+=solve(p->data,root,p->weight);
+            p=p->next;
+        }
+        cout<<ans<<endl;
+    }
+}
+int main(){
+    read();
+    return 0;
+}
diff --git a/HDOJ/3908_autoAC.cpp b/HDOJ/3908_autoAC.cpp
new file mode 100644
index 0000000..ea79ef3
--- /dev/null
+++ b/HDOJ/3908_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#define N 1000
+int co_prime[N];    
+int unco_prime[N];    
+int s[N];
+int Gcd(int a, int b)
+{
+    return a%b?Gcd(b,a%b):b;
+}
+int main()
+{
+    int t,n,i,j,sum;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(i=1;i<=n;i++)
+            scanf("%d",&s[i]);
+        for(i=1;i<=n;i++){
+            for(j=1;j<=n;j++){
+                if(i == j)continue;
+                if(Gcd(s[i],s[j]) == 1)co_prime[i] ++;
+                else unco_prime[i] ++;
+            }
+        }
+        sum = 0;
+        for(i=1;i<=n;i++)sum += co_prime[i] * unco_prime[i];
+        printf("%d\n",n*(n-1)*(n-2)/6- sum/2);
+        for(i=0;i<=n;i++)co_prime[i] = unco_prime[i] = 0;
+    }
+    return 0;
+}
diff --git a/HDOJ/3910_autoAC.cpp b/HDOJ/3910_autoAC.cpp
new file mode 100644
index 0000000..dd412f0
--- /dev/null
+++ b/HDOJ/3910_autoAC.cpp
@@ -0,0 +1,11 @@
+#include<stdio.h>
+int main()
+{
+    int A,B,C;
+    while(scanf("%d%d%d",&A,&B,&C)!=EOF)
+    {
+        double x=(double)(B+C)/(A+B+C*2);
+        printf("%.6lf\n",(1-x)*B-x*C);
+    }    
+    return 0;
+}
diff --git a/HDOJ/3911_autoAC.cpp b/HDOJ/3911_autoAC.cpp
new file mode 100644
index 0000000..74613f3
--- /dev/null
+++ b/HDOJ/3911_autoAC.cpp
@@ -0,0 +1,147 @@
+#include<iostream>
+using namespace std;
+struct node{
+   int lone,lzero;
+   int rone,rzero;
+   int tmax0,tmax1;
+   int flag;
+   int l,r;
+   int mlen;
+}p[100001*4];
+int a[100001];
+int max(int x,int y)
+{
+    return x>y?x:y;
+}
+int min(int x,int y)
+{
+    return x<y?x:y;
+}
+void update_info(int n)
+{
+    p[n].lone=p[n*2].lone;
+    if(p[n*2].lone==p[n*2].mlen)
+        p[n].lone+=p[n*2+1].lone;
+    p[n].lzero=p[n*2].lzero;
+    if(p[n*2].lzero==p[n*2].mlen)
+        p[n].lzero+=p[n*2+1].lzero;
+    p[n].rone=p[n*2+1].rone;
+    if(p[n*2+1].rone==p[n*2+1].mlen)
+        p[n].rone+=p[n*2].rone;
+    p[n].rzero=p[n*2+1].rzero;
+    if(p[n*2+1].rzero==p[n*2+1].mlen)
+        p[n].rzero+=p[n*2].rzero;
+    p[n].tmax0=max(p[n*2].tmax0,p[n*2+1].tmax0);
+    p[n].tmax0=max(p[n].tmax0,p[n*2].rzero+p[n*2+1].lzero);
+    p[n].tmax1=max(p[n*2].tmax1,p[n*2+1].tmax1);
+    p[n].tmax1=max(p[n].tmax1,p[n*2].rone+p[n*2+1].lone);
+}
+void build(int l,int r,int n)
+{
+    p[n].l=l;
+    p[n].r=r;
+    p[n].flag=0;
+    p[n].mlen=(r-l+1);
+    if(l==r)
+    {
+        if(a[l]==1)
+        {
+            p[n].lone=1;
+            p[n].lzero=0;
+            p[n].rone=1;
+            p[n].rzero=0;
+            p[n].tmax0=0;
+            p[n].tmax1=1;
+        }
+        else
+        {
+            p[n].lone=0;
+            p[n].lzero=1;
+            p[n].rone=0;
+            p[n].rzero=1;
+            p[n].tmax0=1;
+            p[n].tmax1=0;
+        }
+        return ;
+    }
+    int mid=(l+r)/2;
+    build(l,mid,n*2);
+    build(mid+1,r,n*2+1);
+    update_info(n);
+}
+void pushdown(int n)
+{
+   p[n*2].flag=p[n*2].flag^1;
+   p[n*2+1].flag=p[n*2+1].flag^1;
+   swap(p[n*2].lone,p[n*2].lzero);
+   swap(p[n*2].rone,p[n*2].rzero);
+   swap(p[n*2].tmax1,p[n*2].tmax0);
+   swap(p[n*2+1].lone,p[n*2+1].lzero);
+   swap(p[n*2+1].rone,p[n*2+1].rzero);
+   swap(p[n*2+1].tmax1,p[n*2+1].tmax0);
+   p[n].flag=0;
+}
+void insert(int x,int y,int n)
+{
+    if(x==p[n].l&&y==p[n].r)
+    {
+        swap(p[n].lone,p[n].lzero);
+        swap(p[n].rzero,p[n].rone);
+        swap(p[n].tmax1,p[n].tmax0);
+        p[n].flag=p[n].flag^1;
+        return ;
+    }
+    if(p[n].flag==1)
+        pushdown(n);
+    int mid=(p[n].l+p[n].r)/2;
+    if(y<=mid)
+        insert(x,y,n*2);
+    else if(x>mid)
+        insert(x,y,n*2+1);
+    else
+    {
+        insert(x,mid,n*2);
+        insert(mid+1,y,n*2+1);
+    }
+    update_info(n);
+}
+int sum(int x,int y,int n)
+{
+    if(x==p[n].l&&y==p[n].r)
+       return p[n].tmax1;
+    int mid=(p[n].l+p[n].r)/2;
+    if(p[n].flag==1)
+        pushdown(n);
+    if(y<=mid)
+        return sum(x,y,n*2);
+    else if(x>mid)
+        return sum(x,y,n*2+1);
+    else
+    {
+        int left=0,right=0,midden=0;
+        midden=min(mid-x+1,p[n*2].rone)+min(y-mid,p[n*2+1].lone);
+        left=sum(x,mid,n*2);
+        right=sum(mid+1,y,n*2+1);
+        return max(midden,max(left,right));
+    }
+}
+int main()
+{
+    int n,m,i,nima,x,y;
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        build(1,n,1);
+        scanf("%d",&m);
+        while(m--)
+        {
+            scanf("%d%d%d",&nima,&x,&y);
+            if(nima==1)
+                insert(x,y,1);
+            else
+                printf("%d\n",sum(x,y,1));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3912_autoAC.cpp b/HDOJ/3912_autoAC.cpp
new file mode 100644
index 0000000..971e8e1
--- /dev/null
+++ b/HDOJ/3912_autoAC.cpp
@@ -0,0 +1,167 @@
+#include <iostream>
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+#include<cmath>
+#include<algorithm>
+#include<ctime>
+using namespace std;
+#define N 50009
+int R,C,ER,EC,num;
+int map1[505][505];
+int map2[505][505];
+int vis[505][505];
+struct Point
+{
+    int x,y,f;
+    Point(int _x,int _y,int _f){x=_x;y=_y;f=_f;}
+};
+void init()
+{
+    scanf("%d%d%d%d",&R,&C,&ER,&EC);
+    memset(vis,0,sizeof(vis));
+    num=0;
+    for(int i=0;i<2*R-1;i++)
+    {
+        if(i&1)
+        {
+        for(int j=0;j<C;j++)
+        scanf("%d",&map1[i/2][j]);
+        }
+        else 
+        {
+        for(int j=0;j<C-1;j++)
+        scanf("%d",&map2[i/2][j]);
+        }
+    }
+}
+void dfs(Point s,Point ss)
+{
+    int ff=s.f;
+    for(;;)
+    {
+    if(!vis[s.x][s.y])num++;
+    vis[s.x][s.y]=1;
+    if(s.x==ss.x&&s.y==ss.y)
+    {
+        if((s.f==3&&ff==0)||(s.f==1&&ff==2))
+        break;
+        if(s.f==ff&&ff==0&&(s.y==0||map2[s.x][s.y-1]==1))
+        break;
+        if(s.f==ff&&ff==2&&(s.y==C-1||map2[s.x][s.y]==1))
+        break;
+    }
+    if(s.f==0)
+    {
+        if(s.y>0&&map2[s.x][s.y-1]==0)
+        {
+            s.y--;
+            s.f=1;
+        }
+        else if(s.x+1<R&&map1[s.x][s.y]==0)
+        {
+            s.x++;
+            s.f=0;
+        }
+        else if(s.y+1<C&&map2[s.x][s.y]==0)
+        {
+            s.y++;
+            s.f=3;
+        }
+        else if(s.x>0&&map1[s.x-1][s.y]==0)
+        {
+            s.x--;
+            s.f=2;
+        }
+    }
+    else if(s.f==1)
+    {
+         if(s.x>0&&map1[s.x-1][s.y]==0)
+        {
+            s.x--;
+            s.f=2;
+        }
+        else if(s.y>0&&map2[s.x][s.y-1]==0)
+        {
+            s.y--;
+            s.f=1;
+        }
+        else if(s.x+1<R&&map1[s.x][s.y]==0)
+        {
+            s.x++;
+            s.f=0;
+        }
+        else if(s.y+1<C&&map2[s.x][s.y]==0)
+        {
+            s.y++;
+            s.f=3;
+        }
+    }
+    else if(s.f==2)
+    {
+         if(s.y+1<C&&map2[s.x][s.y]==0)
+        {
+            s.y++;
+            s.f=3;
+        }
+        else  if(s.x>0&&map1[s.x-1][s.y]==0)
+        {
+            s.x--;
+            s.f=2;
+        }
+        else if(s.y>0&&map2[s.x][s.y-1]==0)
+        {
+            s.y--;
+            s.f=1;
+        }
+        else if(s.x+1<R&&map1[s.x][s.y]==0)
+        {
+            s.x++;
+            s.f=0;
+        }
+    }
+    else if(s.f==3)
+    {
+         if(s.x+1<R&&map1[s.x][s.y]==0)
+        {
+            s.x++;
+            s.f=0;
+        }
+         else if(s.y+1<C&&map2[s.x][s.y]==0)
+        {
+            s.y++;
+            s.f=3;
+        }
+        else  if(s.x>0&&map1[s.x-1][s.y]==0)
+        {
+            s.x--;
+            s.f=2;
+        }
+        else if(s.y>0&&map2[s.x][s.y-1]==0)
+        {
+            s.y--;
+            s.f=1;
+        }
+    }
+    }
+}
+void solve()
+{
+    Point s=Point(0,ER,0);    
+    Point ss=Point(R-1,EC,2);
+    dfs(s,ss);
+    dfs(ss,s);
+    if(num==R*C) puts("YES");
+    else puts("NO");
+}
+int main()
+{
+    int Case;
+    scanf("%d",&Case);
+    while(Case--)
+    {
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3913_autoAC.cpp b/HDOJ/3913_autoAC.cpp
new file mode 100644
index 0000000..56ffeac
--- /dev/null
+++ b/HDOJ/3913_autoAC.cpp
@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define MAXV 500
+#define MAXE 1000
+#define INF 0x7fffffff
+int list[MAXV];
+char s[MAXV];
+int f[MAXV + 1][26];
+bool equal[MAXV];
+int n;
+struct Edge {
+    int ed, next;
+} edge[MAXE];
+int head[MAXV], nEdge;
+void init() {
+    memset(head, 0xff, sizeof(head));
+    nEdge = 0;
+}
+void addEdge(const int a, const int b) {
+    edge[nEdge].ed = b;
+    edge[nEdge].next = head[a];
+    head[a] = nEdge++;
+}
+bool find(int cur, int tar){
+    int i, p;
+    if (cur >= n) return false;
+    if (tar >= n) return true;
+    for (i = head[cur]; ~i; i = edge[cur].next){
+        p = edge[i].ed;
+        if (p == tar) return true;
+        return find(p, tar);
+    }
+    return false;
+}
+int imin(int a, int b){
+    return a < b ? a : b;
+}
+void calc(){
+    int i, j, k;
+    for (i = 0; i < n - 1; i++){
+        equal[i] = find(list[i + 1] + 1, list[i] + 1);
+    }
+    equal[i] = true;
+    for (i = n - 1; i >= 0; i--){
+        for (j = 0; j < 26; j++){
+            f[i][j] = n + 1;
+            for (k = j + 1 - equal[i]; k < 26; k++){
+                f[i][j] = imin(f[i + 1][k], f[i][j]);
+            }
+            if (s[list[i]] != j + 'a') f[i][j]++;
+        }
+    }
+    j = n + 1;
+    for (i = 0; i < 26; i++)
+        j = imin(j, f[0][i]);
+    if (j > n) j = -1;
+    printf("%d\n", j);
+}
+int main(){
+    int i;
+    while(scanf("%d", &n) != EOF){
+        scanf("%s", s);
+        init();
+        memset(f, 0, sizeof(f));
+        memset(equal, 0, sizeof(equal));
+        for (i = 0; i < n; i++) scanf("%d", &list[i]);
+        for (i = 0; i < n - 1; i++){
+            addEdge(list[i + 1], list[i]);
+        }
+        calc();
+    }
+    return 0;
+}
diff --git a/HDOJ/3915_autoAC.cpp b/HDOJ/3915_autoAC.cpp
new file mode 100644
index 0000000..2422c1a
--- /dev/null
+++ b/HDOJ/3915_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<cstdio>
+#include<algorithm>
+#define MAXN 110
+#define MOD 1000007
+using namespace std;
+int a[MAXN], g[MAXN][MAXN];
+int Gauss(int n) {
+    int i, j, r, c, cnt;
+    for (c = cnt = 0; c < n; c++) {
+        for (r = cnt; r < 31; r++) {
+            if (g[r][c])
+                break;
+        }
+        if (r < 31) {
+            if (r != cnt) {
+                for (i = 0; i < n; i++)
+                    swap(g[r][i], g[cnt][i]);
+            }
+            for (i = cnt + 1; i < 31; i++) {
+                if (g[i][c]) {
+                    for (j = 0; j < n; j++)
+                        g[i][j] ^= g[cnt][j];
+                }
+            }
+            cnt++;
+        }
+    }
+    return n - cnt;
+}
+int main() {
+    int c;
+    int n, i, j;
+    int ans, vary;
+    scanf("%d", &c);
+    while (c--) {
+        scanf("%d", &n);
+        for (i = 0; i < n; i++)
+            scanf("%d", &a[i]);
+        for (i = 0; i < 31; i++) {
+            for (j = 0; j < n; j++)
+                g[i][j] = (a[j] >> i) & 1;
+        }
+        vary = Gauss(n);
+        for (ans = 1; vary--;) {
+            ans <<= 1;
+            ans %= MOD;
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3916_autoAC.cpp b/HDOJ/3916_autoAC.cpp
new file mode 100644
index 0000000..0c7c8f6
--- /dev/null
+++ b/HDOJ/3916_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<stdio.h>
+#include<string.h>
+#define MAXN 10010
+#define INF 0x3fffffff
+int v[MAXN],cur[MAXN];     
+int min(int x,int y)
+{
+    return x<y?x:y;
+}
+int main()
+{
+    int n,t,ans;
+    int i,j,s,sub;                
+    for(scanf("%d",&t);t;t--)
+    {
+        scanf("%d",&n);
+        if(!n)
+        {
+            puts("0");
+            continue;
+        }
+        for(i=1;i<=n;i++)
+            scanf("%d",v+i);
+        memset(cur,0,sizeof(cur));
+        v[n+1]=-INF;
+        for(i=1;v[i]==0;i++);         
+        j=i;
+        s=0;
+        ans=INF;
+        while(i<=n)
+        {
+            if(i>j)
+            {
+                s=0;
+                j=i;
+            }
+            while(j<=n && v[j]-cur[j]<=v[j+1])    
+                j++;
+            if(ans>j-i+1)
+                ans=j-i+1;                       
+            sub=v[j]-cur[j]-v[j+1];
+            cur[j]+=min(sub,v[i]-s);        
+            s+=min(sub,v[i]-s);
+            while(!(v[i]-s))            
+            {
+                s-=cur[i];               
+                i++;
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3917_autoAC.cpp b/HDOJ/3917_autoAC.cpp
new file mode 100644
index 0000000..0d4a6f4
--- /dev/null
+++ b/HDOJ/3917_autoAC.cpp
@@ -0,0 +1,116 @@
+#include<iostream>
+#include<algorithm>
+#include<cstdio>
+#include<cstring>
+#include<memory.h>
+using namespace std;
+const int M=10002;
+const int INF=(1e9)-1;
+int t,n,m,tot;
+int gap[M],dis[M],pre[M],head[M],cur[M],s[M];
+int NE,NV,sink,a[M],b[M],c[M],d[M];
+struct Node
+{
+    int c,pos,next;
+} E[M*4];
+#define FF(i,NV) for(int i=0;i<NV;i++)
+int sap(int s,int t)
+{
+    memset(dis,0,sizeof(int)*(NV+1));
+    memset(gap,0,sizeof(int)*(NV+1));
+    FF(i,NV) cur[i] = head[i];
+    int u = pre[s] = s,maxflow = 0,aug =INF;
+    gap[0] = NV;
+    while(dis[s] < NV)
+    {
+loop:
+        for(int &i = cur[u]; i != -1; i = E[i].next)
+        {
+            int v = E[i].pos;
+            if(E[i].c && dis[u] == dis[v] + 1)
+            {
+                aug=min(aug,E[i].c);
+                pre[v] = u;
+                u = v;
+                if(v == t)
+                {
+                    maxflow += aug;
+                    for(u = pre[u]; v != s; v = u,u = pre[u])
+                    {
+                        E[cur[u]].c -= aug;
+                        E[cur[u]^1].c += aug;
+                    }
+                    aug =INF;
+                }
+                goto loop;
+            }
+        }
+        if( (--gap[dis[u]]) == 0)   break;
+        int mindis = NV;
+        for(int i = head[u]; i != -1 ; i = E[i].next)
+        {
+            int v = E[i].pos;
+            if(E[i].c && mindis > dis[v])
+            {
+                cur[u] = i;
+                mindis = dis[v];
+            }
+        }
+        gap[ dis[u] = mindis+1 ] ++;
+        u = pre[u];
+    }
+    return maxflow;
+}
+void addEdge(int u,int v,int c )
+{
+    E[NE].c = c;
+    E[NE].pos = v;
+    E[NE].next = head[u];
+    head[u] = NE++;
+    E[NE].c = 0;
+    E[NE].pos = u;
+    E[NE].next = head[v];
+    head[v] = NE++;
+}
+int main()
+{
+    int n, m,sum, source, sink, vn,k;
+    while(scanf("%d %d", &n, &m),(n||m))
+    {
+        NE=0,tot=0;
+        sum = 0;
+        source = 0;
+        sink=m+1;
+        NV=sink+1;
+        memset(head, -1, sizeof(head));
+        memset(s,0,sizeof(s));
+        for(int i=1;i<=m;i++)
+        {
+            scanf("%d",&vn);
+            addEdge(source,i,vn);
+            sum+=vn;
+        }
+        scanf("%d",&k);
+        for(int i=1;i<=k;i++)
+        {
+            scanf("%d%d%d%d",&a[i],&b[i],&d[i],&c[i]);
+            s[d[i]]+=c[i];
+        }
+        for(int i=1;i<=k;i++)
+        {
+            for(int j=1;j<=k;j++)
+            {
+                if(i!=j&&b[i]==a[j]&&d[i]!=d[j])
+                {
+                    addEdge(d[i],d[j],INF);
+                }
+            }
+        }
+        for(int i=1;i<=m;i++)
+        {
+            addEdge(i,sink,s[i]);
+        }
+        printf("%d\n",sum-sap(source,sink));
+    }
+    return 0;
+}
diff --git a/HDOJ/3918_autoAC.cpp b/HDOJ/3918_autoAC.cpp
new file mode 100644
index 0000000..2fd44f5
--- /dev/null
+++ b/HDOJ/3918_autoAC.cpp
@@ -0,0 +1,215 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <memory.h>
+#include <cmath>
+#define MAXN 300
+#define eps 1e-5
+#define max(a,b) (a>b?a:b)
+#define min(a,b) (a<b?a:b)
+using namespace std;
+struct point {double x,y;};  
+struct point pnt[MAXN],ll[MAXN],rr[MAXN],center;   
+int N,M,l_pos,r_pos;  
+double ans,H;
+bool ne;  
+point bcenter(point pnt[], int n)
+{   
+    point p, s;   
+    if(n==1) 
+        return pnt[0];
+    if(n==2)
+    {
+        s.x=(pnt[0].x+pnt[1].x)/2;
+        s.y=(pnt[0].y+pnt[1].y)/2;
+        return s;
+    }
+    double tp, area = 0, tpx = 0, tpy = 0;   
+    p.x = pnt[0].x; p.y = pnt[0].y;   
+    for (int i = 1; i <= n; ++i) 
+    {   // point: 0 ~ n-1   
+        s.x = pnt[(i == n) ? 0 : i].x;   
+        s.y = pnt[(i == n) ? 0 : i].y;   
+        tp = (p.x * s.y - s.x * p.y); area += tp / 2;   
+        tpx += (p.x + s.x) * tp; tpy += (p.y + s.y) * tp;   
+        p.x = s.x; p.y = s.y;   
+    }   
+    s.x = tpx / (6 * area); s.y = tpy / (6 * area);   
+    return s;   
+}  
+void Print()
+{
+    int i;
+    printf("-------------------------------------\n");
+    for(i=0;i<M;i++)
+        printf("%.2lf %.2lf\n",ll[i].x,ll[i].y);
+    for(i=0;i<N;i++)
+        printf("%.2lf %.2lf\n",rr[i].x,rr[i].y);
+    printf("-------------------------------------\n");
+}
+point get_point(point c,point a,point b)
+{
+    point res;
+    double dx,dy;
+    dx=fabs(a.x-b.x);
+    dy=b.y-a.y;
+    res.y=c.y;
+    if(fabs(a.x-b.x)<=eps)
+        res.x=a.x;
+    else
+    {
+        if(a.x<b.x)
+            res.x=dx*(c.y-a.y)*1.0/dy+a.x;
+        else
+            res.x=a.x-dx*(c.y-a.y)*1.0/dy;
+    }
+    return res;
+}
+void ini()
+{
+    M=N=0;
+    l_pos=r_pos=0;
+    ans=H=0;
+    memset(pnt,0,sizeof(pnt));
+    memset(ll,0,sizeof(ll));
+    memset(rr,0,sizeof(rr));
+}
+void Init()
+{
+    int i;
+    ini();
+    scanf("%d%d",&M,&N);
+    for(i=0;i<M;i++)
+        scanf("%lf%lf",&ll[i].x,&ll[i].y);
+    for(i=0;i<N;i++)
+        scanf("%lf%lf",&rr[i].x,&rr[i].y);
+}
+bool Judge(point o)
+{
+    if((o.x-ll[0].x>=eps)&&(rr[0].x-o.x>=eps))
+        return true;
+    return false;
+}
+bool fuck(double mid,int l_pos,int r_pos)
+{
+    int i;
+    point temp,now1,now2;
+    temp.x=1;temp.y=mid;
+    int cnt=0;
+    if(fabs(ll[l_pos].y-rr[r_pos].y)<=eps)
+    {
+        for(i=l_pos;i>=0;i--)
+            pnt[cnt++]=ll[i];
+        for(i=0;i<=r_pos;i++)
+            pnt[cnt++]=rr[i];
+    }
+    else if(ll[l_pos].y<rr[r_pos].y)
+    {
+        now1=get_point(temp,ll[l_pos],ll[l_pos+1]);
+        now2=get_point(temp,rr[r_pos-1],rr[r_pos]);
+        pnt[cnt++]=now1;
+        for(i=l_pos;i>=0;i--)
+            pnt[cnt++]=ll[i];
+        for(i=0;i<r_pos;i++)
+            pnt[cnt++]=rr[i];
+        pnt[cnt++]=now2;
+    }
+    else
+    {
+        now1=get_point(temp,ll[l_pos-1],ll[l_pos]);
+        now2=get_point(temp,rr[r_pos],rr[r_pos+1]);
+        pnt[cnt++]=now1;
+        for(i=l_pos-1;i>=0;i--)
+            pnt[cnt++]=ll[i];
+        for(i=0;i<=r_pos;i++)
+            pnt[cnt++]=rr[i];
+        pnt[cnt++]=now2;
+    }
+    center=bcenter(pnt,cnt);
+    return Judge(center);
+}
+void Solve()
+{
+    ans=ll[0].y;;
+    double l,r,mid;
+    int i,cnt;
+    point now;
+    l_pos=r_pos=1;
+    while(true)
+    {
+        cnt=0;
+        if(l_pos==M||r_pos==N) break;
+        if(ll[l_pos].y<=rr[r_pos].y)
+        {
+            for(i=l_pos;i>=0;i--)
+                pnt[cnt++]=ll[i];
+            for(i=0;i<r_pos;i++)
+                pnt[cnt++]=rr[i];
+            now=get_point(ll[l_pos],rr[r_pos-1],rr[r_pos]);
+            pnt[cnt++]=now;
+            center=bcenter(pnt,cnt);
+            ne=Judge(center);
+            if(!ne)
+            {
+                l=max(rr[r_pos-1].y,ll[l_pos-1].y);r=ll[l_pos].y;
+                while(fabs(l-r)>eps)
+                {
+                    mid=(l+r)/2.0;
+                    if(fuck(mid,l_pos,r_pos-1))
+                        l=mid;
+                    else
+                        r=mid;
+                }
+                ans=max(ans,l);
+                break;
+            }
+            else
+            {
+                ans=max(ans,ll[l_pos].y);
+                l_pos++;
+            }
+        }
+        else
+        {
+            now=get_point(rr[r_pos],ll[l_pos-1],ll[l_pos]);
+            pnt[cnt++]=now;
+            for(i=l_pos-1;i>=0;i--)
+                pnt[cnt++]=ll[i];
+            for(i=0;i<=r_pos;i++)
+                pnt[cnt++]=rr[i];
+            center=bcenter(pnt,cnt);
+            ne=Judge(center);
+            if(!ne)
+            {
+                l=max(ll[l_pos-1].y,rr[r_pos-1].y);r=rr[r_pos].y;
+                while(fabs(l-r)>eps)
+                {
+                    mid=(l+r)/2.0;
+                    if(fuck(mid,l_pos-1,r_pos))
+                        l=mid;
+                    else
+                        r=mid;
+                }
+                ans=max(ans,l);
+                break;
+            }
+            else
+            {
+                ans=max(ans,rr[r_pos].y);
+                r_pos++;
+            }
+        }
+    }
+    printf("%.3lf\n",ans);
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        Init();
+        Solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3920_autoAC.cpp b/HDOJ/3920_autoAC.cpp
new file mode 100644
index 0000000..293e5be
--- /dev/null
+++ b/HDOJ/3920_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<cmath>
+#include<iostream>
+using namespace std;
+double dis[21][21],dp[1<<21];
+int n,fx,fy,mac;
+struct node
+{
+    int x,y;
+}nd[21];
+double DIS(double x,double y,double xx,double yy)
+{
+    return sqrt((x-xx)*(x-xx)+(y-yy)*(y-yy));
+}
+bool cmp(node a,node b)
+{
+    return DIS(a.x,a.y,fx,fy)<DIS(b.x,b.y,fx,fy);
+}
+double DP(int sta)
+{
+    if(dp[sta]!=0x7fffffff)
+        return dp[sta];
+    if(sta==0) {dp[0]=0.0;}
+    else
+    {
+        int tem=sta,i=0;
+        for(i=0;i<20;i++)
+        {
+            if((1<<i)&sta)break;
+        }
+        for(int j=i+1;j<2*n;j++)
+        {
+            if((sta&(1<<j))==0)continue;
+            dp[sta]=min(DP(sta-(1<<j)-(1<<i))+dis[i][j],dp[sta]);
+        }
+    }
+    return dp[sta];
+}
+int main()
+{
+    int c,ca=0;
+    scanf("%d",&c);
+    while(c--)
+    {
+        ca++;
+        scanf("%d%d",&fx,&fy);
+        scanf("%d",&n);
+        for(int i=0;i<2*n;i++)
+        {
+            scanf("%d%d",&nd[i].x,&nd[i].y);
+        }
+        sort(nd,nd+2*n,cmp);
+        for(int i=0;i<2*n;i++)
+            for(int j=i+1;j<2*n;j++)
+            {
+                dis[i][j]=DIS(nd[i].x,nd[i].y,fx,fy)+DIS(nd[i].x*1.0,nd[i].y*1.0,nd[j].x*1.0,nd[j].y*1.0);
+            }
+            printf("Case #%d: ",ca);
+            for(int i=0;i<(1<<2*n);i++)
+                dp[i]=0x7fffffff;
+            printf("%.2f\n",DP((1<<(2*n))-1));
+    }
+}
diff --git a/HDOJ/3921_autoAC.cpp b/HDOJ/3921_autoAC.cpp
new file mode 100644
index 0000000..21769a2
--- /dev/null
+++ b/HDOJ/3921_autoAC.cpp
@@ -0,0 +1,155 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <algorithm>
+using namespace std;
+struct Point
+{
+    double x, y;
+} node[201];
+struct T_T
+{
+    int id;
+    double dis;
+} que[201];
+double sx, sy;
+double ans;
+double dis[201];
+double map[201][201];
+int q[201][201], q2[201][201];
+int n;
+int m;
+bool vis[201];
+int ra, rb, rc, rd;
+double rmin;
+double rdis;
+double dist(int i, int j)
+{
+    return sqrt((node[i].x - node[j].x) * (node[i].x - node[j].x)
+                + (node[i].y - node[j].y) * (node[i].y - node[j].y));
+}
+bool cmp(T_ a, T_ b)
+{
+    return a.dis < b.dis;
+}
+void init()
+{
+    for(int i = 0; i < m; i++)  dis[i] = dist(i, m);
+    for(int i = 0; i < m; i++)
+        for(int j = i + 1; j < m; j++)
+            map[i][j] = map[j][i] = dist(i, j);
+    for(int i = 0; i < m; i++)
+    {
+        int temp = 0;
+        for(int j = 0; j < m; j++)
+            if(i != j)
+            {
+                que[temp].id = j;
+                que[temp].dis = dis[j] + map[j][i];
+                temp++;
+            }
+        sort(que, que + temp, cmp);
+        for(int j = 0; j < temp; j++)
+            q[i][j] = que[j].id;
+    }
+    for(int i = 0; i < m; i++)
+    {
+        int temp = 0;
+        for(int j = 0; j < m; j++)
+            if(i != j)
+            {
+                que[temp].id = j;
+                que[temp].dis = map[i][j];
+                temp++;
+            }
+        sort(que, que + temp, cmp);
+        for(int j = 0; j < temp; j++)
+            q2[i][j] = que[j].id;
+    }
+}
+void solve()
+{
+    rmin = -1;
+    int a, b, c, d;
+    for(b = 0; b < m; b++)
+        if(!vis[b])
+        {
+            for(c = 0; c < m; c++)
+                if(!vis[c] && b != c)
+                {
+                    int t = 0;
+                    a = q[b][t];
+                    while(vis[a] || a == c)
+                    {
+                        t++;
+                        a = q[b][t];
+                    }
+                    t = 0;
+                    d = q2[c][t];
+                    while(vis[d] || d == a || d == b)
+                    {
+                        t++;
+                        d = q2[c][t];
+                    }
+                    double cou = dis[a] + map[a][b] + map[b][c] + map[c][d];
+                    double cdis = (dis[a] + dis[b] + dis[c] + dis[d]) / 4.0;
+                    if(rmin < 0 || cou < rmin || (rmin == cou && cdis < rdis))
+                    {
+                        rmin = cou;
+                        rdis = cdis;
+                        ra = a, rb = b, rc = c, rd = d;
+                    }
+                    t = 0;
+                    d = q2[c][t];
+                    while(vis[d] || d == b)
+                    {
+                        t++;
+                        d = q2[c][t];
+                    }
+                    t = 0;
+                    a = q[b][t];
+                    while(vis[a] || a == c || a == d)
+                    {
+                        t++;
+                        a = q[b][t];
+                    }
+                    cou = dis[a] + map[a][b] + map[b][c] + map[c][d];
+                    cdis = (dis[a] + dis[b] + dis[c] + dis[d]) / 4.0;
+                    if(rmin < 0 || cou < rmin || (rmin == cou && cdis < rdis))
+                    {
+                        rmin = cou;
+                        rdis = cdis;
+                        ra = a, rb = b, rc = c, rd = d;
+                    }
+                }
+        }
+    vis[ra] = 1;
+    vis[rb] = 1;
+    vis[rc] = 1;
+    vis[rd] = 1;
+    ans += rmin;
+}
+int main()
+{
+    int T;
+    int cas = 1;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%lf%lf", &sx, &sy);
+        scanf("%d", &n);
+        m = 4 * n;
+        for(int i = 0; i < m; i++)  scanf("%lf%lf", &node[i].x, &node[i].y);
+        node[m].x = sx;
+        node[m].y = sy;
+        init();
+        ans = 0;
+        memset(vis, 0, sizeof(vis));
+        for(int i = 0; i < n; i++)
+        {
+        solve();
+        }
+        printf("Case #%d: %0.2lf\n", cas++, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3923_autoAC.cpp b/HDOJ/3923_autoAC.cpp
new file mode 100644
index 0000000..bd309b1
--- /dev/null
+++ b/HDOJ/3923_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <iostream>
+#include <cstdio>
+#include <string.h>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+using namespace std;
+const int mod=1000000007;
+__int64 n,c;
+__int64 fun(__int64 a,__int64 b)
+{
+    __int64 t=1,y=a;
+    for(int i=1;i<=b;i*=2)
+    {
+        if(b&i)
+          t=t*y%mod;
+        y=y*y%mod;
+    }
+    return t;
+}
+__int64 euler(__int64 a)
+{
+    __int64 ans=a;
+    for(int i=2;i<=a;i++)
+    {
+        if(a%i==0)
+            ans-=ans/i;
+        while(a%i==0)
+            a/=i;
+    }
+    if(a>1)
+        ans-=ans/a;
+    return ans;
+}
+__int64 Extend_euclid(__int64 a,__int64 b,__int64 &x,__int64 &y)
+{
+    __int64 d=0,t=0;
+    if(b==0)
+    {
+        x=1;
+        y=0;
+        return a;
+    }
+    else
+    {
+        d=Extend_euclid(b,a%b,x,y);
+        t=x;
+        x=y;
+        y=t-a/b*y;
+    }
+    return d;
+}
+__int64 Bignum_Div(__int64 a,__int64 b)
+{
+    __int64 x=0,y=0;
+    Extend_euclid(b,mod,x,y);
+    __int64 ans= a*x%mod;
+    while(ans<0)
+        ans+=mod;
+    return ans;
+}
+int main()
+{
+    __int64 ans=0,t=1,T=0;
+    scanf("%I64d",&T);
+    while(T--)
+    {
+        scanf("%I64d %I64d",&c,&n);
+        ans=0;
+        for(int i=1;i<=n;i++)
+        {
+            if(n%i==0)
+            {
+                ans+=fun(c,i)*euler(n/i);
+                ans%=mod;
+            }
+        }
+        if(n&1)
+        {
+            ans+=n*fun(c,n/2+1);
+            ans%=mod;
+        }
+        else
+        {
+            ans+=n/2*( fun(c,n/2)+fun(c,n/2+1));
+            ans%=mod;
+        }
+        ans=Bignum_Div(ans,2*n);
+        printf("Case #%I64d: %I64d\n",t++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3924_autoAC.cpp b/HDOJ/3924_autoAC.cpp
new file mode 100644
index 0000000..ebf4b53
--- /dev/null
+++ b/HDOJ/3924_autoAC.cpp
@@ -0,0 +1,100 @@
+#include<iostream>
+#include<algorithm>
+#include<cstring>
+#include<cstdio>
+using namespace std;
+typedef __int64 LL;
+const int MAX=30;
+const int LIM=21;
+LL num[MAX],rig[MAX],total[MAX];
+int b[4];
+LL gs(int L)
+{
+    LL res=0;
+    for(int i=0;i<=L;i++)
+    {
+        for(int j=i;j<=L;j++)
+        {
+            int k=L-i-j;
+            if(j>k) continue;
+            b[0]=i;
+            b[1]=j;
+            b[2]=k;
+            do
+            {
+                res+=num[b[0]]*num[b[1]]*num[b[2]];
+            }while(next_permutation(b,b+3));
+        }
+    }
+    return res;
+}
+LL getR(int L)
+{
+    LL res=0;
+    for(int i=0;i<=L;i++)
+    {
+        res+=num[i]*num[L-i];
+    }
+    return res;
+}
+void init()
+{
+    num[0]=num[1]=1;
+    for(int i=2;i<=LIM;i++) num[i]=gs(i-1);
+    total[0]=0;
+    for(int i=1;i<=LIM;i++) total[i]=total[i-1]+num[i];
+    rig[0]=1;
+    for(int i=1;i<=LIM;i++) rig[i]=getR(i);
+}
+int getNN(LL N)
+{
+    for(int i=1;i<=LIM;i++) if(total[i]>=N) return i;
+}
+void dfs(int L,LL N)
+{
+    if(L==1) {printf("X");return ;}
+    int x=L-1;
+    int ll,mm,rr;
+    for(ll=0;N>num[ll]*rig[x-ll];ll++) N-=num[ll]*rig[x-ll];
+    if(ll)
+    {
+        printf("(");
+        dfs(ll,(N-1)/rig[x-ll]+1);
+        printf(")");
+    }
+    N%=rig[x-ll];
+    if(N==0) N=rig[x-ll];
+    x-=ll;
+    for(mm=0;N>num[mm]*num[x-mm];mm++) N-=num[mm]*num[x-mm];
+    if(mm)
+    {
+        printf("(");
+        dfs(mm,(N-1)/num[x-mm]+1);
+        printf(")");
+    }
+    N%=num[x-mm];
+    if(N==0) N=num[x-mm];
+    x-=mm;
+    if(x)
+    {
+        printf("(");
+        dfs(x,N);
+        printf(")");
+    }
+    printf("X");
+}
+int main()
+{
+    init();
+    int T;scanf("%d",&T);
+    int CN=0;
+    while(T--)
+    {
+        LL N;scanf("%I64d",&N);
+        int nn=getNN(N);
+        printf("Case #%d: ",++CN);
+        dfs(nn,N-total[nn-1]);
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/3925_autoAC.cpp b/HDOJ/3925_autoAC.cpp
new file mode 100644
index 0000000..96e49e6
--- /dev/null
+++ b/HDOJ/3925_autoAC.cpp
@@ -0,0 +1,103 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int maxn = 100 + 10;
+bool cmp(char *s, int high, int low, char *sub)
+{
+ int j = 0;
+ for(int i = high; i <= low; i++) if(s[i] != sub[j++]) return 0;
+ return 1;
+}
+int cmpp(char *a, char *b) 
+{
+ int len_a = strlen(a), len_b = strlen(b), len = min(len_a, len_b), i;
+ if(len_a != len_b) 
+ {
+ if(len_a > len_b) return 1;
+ else return -1;
+ }
+ else 
+ {
+ for(i = 0; i < len; i++)
+ {
+ if(a[i] > b[i]) return 1; 
+ if(a[i] < b[i]) return -1; 
+ }
+ return 0; 
+ }
+}
+int to_int(char *s, int high, int low) 
+{
+ int ret = 0;
+ for(int i = high; i <= low; i++) ret = ret*10 + s[i]-'0';
+ return ret;
+}
+int main()
+{
+ int i, j, k, u, v, cnt = 1, T;
+ char a[maxn], b[maxn], B[maxn], c[maxn], minn[maxn];
+ scanf("%d", &T);
+ while(T--)
+ {
+ scanf("%s%s", a, b);
+ int len_a = strlen(a), len_b = strlen(b);
+ for(i = 0; i < maxn; i++) minn[i] = '9'; 
+ for(i = len_b; i < maxn; i++) b[i] = '0'; b[maxn-1] = 0; 
+ int bb = to_int(b, 0, len_b-1); 
+ if(len_a < len_b) 
+ {
+ int aa = to_int(a, 0, len_a-1);
+ printf("Case #%d: %d\n", cnt++, bb-aa);
+ continue;
+ }
+ bool ok = 0; 
+ for(i = len_a-len_b; i >= 0; i--) 
+ {
+ int aa = to_int(a, i, i+len_b-1);
+ if(aa == bb) 
+ {
+ ok = 1;
+ break;
+ }
+ else 
+ {
+ for(u = 0; u < maxn; u++) B[u] = b[u]; 
+ for(j = len_a-1, k = len_a-1-i; j >= i; j--, k--)
+ {
+ if(B[k] >= a[j]) c[k] = B[k] - a[j] + '0';
+ else 
+ {
+ if(k-1 >= 0) B[k-1]--;
+ c[k] = B[k] + 10 - a[j] + '0';
+ }
+ }
+ c[len_a-i] = 0; 
+ for(v = 0; v < len_a-i; v++) if(c[v] != '0') break; 
+ if(v != 0) for(u = 0; v <= len_a-i; u++,v++) c[u] = c[v];
+ if(cmpp(c, minn) < 0) for(u = 0; u <= len_a-i; u++) minn[u] = c[u]; 
+ }
+ }
+ if(ok) printf("Case #%d: %d\n", cnt++, 0);
+ else 
+ {
+ for(u = 0; u < maxn; u++) B[u] = b[u]; 
+ for(j = len_a-1, k = len_a; j >= 0; j--, k--)
+ {
+ if(B[k] >= a[j]) c[k] = B[k] - a[j] + '0';
+ else 
+ {
+ B[k-1]--;
+ c[k] = B[k] + 10 - a[j] + '0';
+ }
+ }
+ c[0] = B[0]; 
+ c[len_a+1] = 0; 
+ for(v = 0; v < len_a+1; v++) if(c[v] != '0') break; 
+ if(v != 0) for(u = 0; v <= len_a+1; u++,v++) c[u] = c[v];
+ if(cmpp(c, minn) == -1) for(u = 0; u <= len_a+1; u++) minn[u] = c[u]; 
+ printf("Case #%d: %s\n", cnt++, minn);
+ }
+ }
+ return 0;
+}
diff --git a/HDOJ/3926_autoAC.cpp b/HDOJ/3926_autoAC.cpp
new file mode 100644
index 0000000..1d31479
--- /dev/null
+++ b/HDOJ/3926_autoAC.cpp
@@ -0,0 +1,109 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<climits>
+#include<algorithm>
+using namespace std;
+#define MAXN 10010
+int pre1[MAXN], pre2[MAXN]; 
+int num1, num2;
+struct graph 
+{
+    int son;
+    bool ring;
+};
+graph g1[MAXN], g2[MAXN];
+bool cmb(const graph &g1, const graph &g2) 
+{
+    if(g1.son < g2.son)
+        return true;
+    else if(g1.son == g2.son && g1.ring < g2.ring)
+        return true;
+    else
+        return false;
+}
+int find(int x, int pre[]) 
+{
+    return x == pre[x] ? x : find(pre[x], pre);
+}
+void join(int x, int y, int pre[],graph g1[]) 
+{
+    int root1, root2;
+    root1 = find(x, pre);
+    root2 = find(y, pre);
+    if(root1 == root2)
+        g1[root1].ring = true; 
+    else
+    {
+        if(g1[root1].son >= g1[root2].son)
+        {
+            pre[root2] = root1;
+            g1[root1].son += g1[root2].son;
+        }
+        else
+        {
+            pre[root1] = root2;
+            g1[root2].son += g1[root1].son;
+        }
+    }
+}
+bool cmp(int num, graph g1[], graph g2[]) 
+{
+    sort(g1 + 1, g1 + num + 1, cmb); 
+    sort(g2 + 1, g2 + num + 1, cmb);
+    for(int i = 1; i <= num; ++i)
+        if(g1[i].son != g2[i].son || (g1[i].son == g2[i].son && g1[i].ring != g2[i].ring))
+            return false;
+    return true;
+}
+int main()
+{
+    int ncase, T = 0;
+    int link1, link2;
+    int hand1, hand2;
+    int ans1, ans2;
+    bool flag;
+    scanf("%d", &ncase);
+    while(ncase--)
+    {
+        flag = true;
+        scanf("%d%d", &num1, &link1);
+        for(int i = 1; i < MAXN; ++i)
+        {
+            pre1[i] = i;
+            pre2[i] = i;
+            g1[i].son = 1;
+            g2[i].son = 1;
+            g1[i].ring = false;
+            g2[i].ring = false;
+        }
+        for(int i = 1; i <= link1; ++i)
+        {
+            scanf("%d%d", &hand1, &hand2);
+            join(hand1, hand2, pre1, g1);
+        }
+        scanf("%d%d", &num2, &link2);
+        if(link2 != link1) 
+            flag = false;
+        for(int i = 1; i <= link2; ++i)
+        {
+            scanf("%d%d", &hand1, &hand2);
+            if(flag == false)
+                continue;
+            else
+                join(hand1, hand2, pre2, g2);
+        }
+        flag = cmp(num2, g1, g2);
+        if(flag == false)
+            printf("Case #%d: NO\n", ++T);
+        else
+        {
+            if(flag)
+                printf("Case #%d: YES\n", ++T);
+            else
+                printf("Case #%d: NO\n", ++T);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3927_autoAC.cpp b/HDOJ/3927_autoAC.cpp
new file mode 100644
index 0000000..d6cb2b3
--- /dev/null
+++ b/HDOJ/3927_autoAC.cpp
@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <memory.h>
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+#include <queue>
+#include <algorithm>
+#include <iostream>
+#define ll long long
+using namespace std;
+const int N = 200;
+int mtx[N][N], n;
+int row[N], col[N], dia[2];
+map<int, int> M;
+int cunt;
+void Change(int r1, int c1, int r2, int c2) {
+    int d = mtx[r1][c1] - mtx[r2][c2];
+    if (d == 0) return;
+    int res = 0;
+    if ((M[row[r1]]--) == 1) res--;
+    if ((M[col[c1]]--) == 1) res--;
+    if ((M[row[r2]]--) == 1) res--;
+    if ((M[col[c2]]--) == 1) res--;
+    if (r1 == c1 && (M[dia[0]]--) == 1) res--;
+    if (r1 == n - c1 - 1 && (M[dia[1]]--) == 1) res--;
+    if (r2 == c2 && (M[dia[0]]--) == 1) res--;
+    if (r2 == n - c2 - 1 && (M[dia[1]]--) == 1) res--;
+    swap(mtx[r1][c1], mtx[r2][c2]);
+    row[r1] -= d; col[c1] -= d; row[r2] += d; col[c2] += d;
+    if (r1 == c1) dia[0] -= d;
+    if (r1 == n - c1 - 1) dia[1] -= d;
+    if (r2 == c2) dia[0] += d;
+    if (r2 == n - c2 - 1) dia[1] += d;
+    if ((M[row[r1]]++) == 0) res++;
+    if ((M[col[c1]]++) == 0) res++;
+    if ((M[row[r2]]++) == 0) res++;
+    if ((M[col[c2]]++) == 0) res++;
+    if (r1 == c1 && (M[dia[0]]++) == 0) res++;
+    if (r1 == n - c1 - 1 && (M[dia[1]]++) == 0) res++;
+    if (r2 == c2 && (M[dia[0]]++) == 0) res++;
+    if (r2 == n - c2 - 1 && (M[dia[1]]++) == 0) res++;
+    if (res >= 0) {
+        cunt += res;
+        return;
+    }
+    M[row[r1]]--; M[col[c1]]--; M[row[r2]]--; M[col[c2]]--;
+    if (r1 == c1) M[dia[0]]--;
+    if (r1 == n - c1 - 1) M[dia[1]]--;
+    if (r2 == c2) M[dia[0]]--;
+    if (r2 == n - c2 - 1) M[dia[1]]--;
+    swap(mtx[r1][c1], mtx[r2][c2]);
+    row[r1] += d; col[c1] += d; row[r2] -= d; col[c2] -= d;
+    if (r1 == c1) dia[0] += d;
+    if (r1 == n - c1 - 1) dia[1] += d;
+    if (r2 == c2) dia[0] -= d;
+    if (r2 == n - c2 - 1) dia[1] -= d;
+    M[row[r1]]++; M[col[c1]]++; M[row[r2]]++; M[col[c2]]++;
+    if (r1 == c1)  M[dia[0]]++;
+    if (r1 == n - c1 - 1) M[dia[1]]++;
+    if (r2 == c2) M[dia[0]]++;
+    if (r2 == n - c2 - 1) M[dia[1]]++;
+}
+int main() {
+    int T, C, m, idx, s1, s2;
+    int r1, c1, r2, c2;
+    scanf("%d", &T);
+    for (C = 1; C <= T; C++) {
+        scanf("%d", &n);
+        idx = 0;
+        for (int i = 0; i < n; i++)
+            for (int j = 0; j < n; j++)
+                mtx[i][j] = ++idx;
+        M.clear();
+        cunt = 0;
+        for (int i = 0; i < n; i++) {
+            s1 = 0, s2 = 0;
+            for (int j = 0; j < n; j++) {
+                s1 += mtx[i][j];
+                s2 += mtx[j][i];
+            }
+            row[i] = s1; col[i] = s2;
+            if ((M[s1]++) == 0) cunt++;
+            if ((M[s2]++) == 0) cunt++;
+        }
+        s1 = s2 = 0;
+        for (int i = 0; i < n; i++) {
+            s1 += mtx[i][i];
+            s2 += mtx[i][n-i-1];
+        }
+        dia[0] = s1; dia[1] = s2;
+        if ((M[s1]++) == 0) cunt++;
+        if ((M[s2]++) == 0) cunt++;
+        m = 2 * n + 2;
+        while (cunt < m) {
+            r1 = rand() % n;
+            r2 = rand() % n;
+            c1 = rand() % n;
+            c2 = rand() % n;
+            Change(r1, c1, r2, c2);
+        }
+        printf("Case #%d:\n", C);
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (j) printf(" ");
+                printf("%d", mtx[i][j]);
+            }
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3928_autoAC.cpp b/HDOJ/3928_autoAC.cpp
new file mode 100644
index 0000000..59aa198
--- /dev/null
+++ b/HDOJ/3928_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <functional>
+#define Maxn 100
+#define inf 1<<30
+using namespace std;
+int T, n, f[Maxn][Maxn], out[Maxn][Maxn];
+int le[Maxn], ri[Maxn];
+int dfs(int x, int y)
+{
+     if (f[x][y] != -1) return f[x][y];
+     if (out[x][y] == 1) return f[x][y] = 0;
+     int t1, t2, t3, tmp = inf;
+     for (int i=1; i<=n; i++)
+     {
+         t1 = t2 = t3 = -inf;
+         int x1 = x, yy1 = min(le[i]-1, y);  
+         if (yy1 == y) continue;
+         if (x1 <= yy1 && out[x1][yy1]) t1 = dfs(x1, yy1);
+         int x2 = max(le[i]+1, x), y2 = min(ri[i]-1, y);  
+         if (x2 == x && y2 == y) continue;     
+         if (x2 <= y2 && out[x2][y2]) t2 = dfs(x2, y2);
+         int x3 = max(ri[i], x), y3 = y;     
+         if (x3 == x) continue;         
+         if (x3 <= y3 && out[x3][y3]) t3 = dfs(x3, y3); 
+         tmp = min(tmp, max(t1,max(t2, t3)));         
+     }
+     return f[x][y] = tmp + 1;
+     }
+int main()
+{
+    int k;
+    scanf("%d", &T);
+    for (int t=1; t<=T; t++)
+    {
+        memset(le, -1, sizeof(le));
+        memset(f, -1, sizeof(f));
+        memset(out, 0, sizeof(out));
+        scanf("%d", &n);
+        for (int i=1; i<=2*n; i++)
+        {
+            scanf("%d", &k);  
+            if (le[k] == -1) le[k] = i;
+            else ri[k] = i; 
+        }
+        for (int i=1; i<=2*n; i++)
+          for (int j=i; j<=2*n; j++)
+            for (int p=1; p<=n; p++)
+            if (ri[p] <= j && ri[p] >= i) out[i][j]++;
+        printf("Case #%d: %d\n", t, dfs(2, 2*n));
+    }
+    return 0;
+    }
diff --git a/HDOJ/3929_autoAC.cpp b/HDOJ/3929_autoAC.cpp
new file mode 100644
index 0000000..3f933de
--- /dev/null
+++ b/HDOJ/3929_autoAC.cpp
@@ -0,0 +1,34 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+const int N=20;
+LL w[N];
+LL ans,n;
+LL get(LL x)
+{
+    return x==0? 0:get(x-(x&-x))+1;
+}
+void dfs(LL beg,LL num,LL sym)
+{
+    ans+=((LL)1<<get(num))*sym;
+    for(LL i=beg+1;i<=n;i++)
+        dfs(i,num&w[i],-2*sym);
+}
+int main()
+{
+    LL k=1,t,i;
+    cin>>t;
+    while(t--)
+    {
+        cin>>n;
+        for(i=1;i<=n;i++)
+           cin>>w[i];
+        ans=0;
+        for(i=1;i<=n;i++)
+           dfs(i,w[i],1);
+        cout<<"Case #"<<k++<<": "<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/3930_autoAC.cpp b/HDOJ/3930_autoAC.cpp
new file mode 100644
index 0000000..1d796ef
--- /dev/null
+++ b/HDOJ/3930_autoAC.cpp
@@ -0,0 +1,179 @@
+#include <iostream>
+#include <string.h>
+#include <algorithm>
+#include <stdio.h>
+#include <math.h>
+#include <map>
+using namespace std;
+typedef long long LL;
+const int N=1000005;
+int p[N];
+bool prime[N];
+int num,cnt;
+LL k,m,newx,g;
+LL a[65],b[65];
+void isprime()
+{
+    num=0;
+    int i,j;
+    memset(prime,true,sizeof(prime));
+    for(i=2;i<N;i++)
+    {
+        if(prime[i])
+        {
+            p[num++]=i;
+            for(j=i+i;j<N;j+=i)
+            {
+                prime[j]=false;
+            }
+        }
+    }
+}
+LL multi(LL a,LL b,LL m)
+{
+    LL ans=0;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans=(ans+a)%m;
+            b--;
+        }
+        b>>=1;
+        a=(a+a)%m;
+    }
+    return ans;
+}
+LL quick_mod(LL a,LL b,LL m)
+{
+    LL ans=1;
+    a%=m;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans=multi(ans,a,m);
+            b--;
+        }
+        b>>=1;
+        a=multi(a,a,m);
+    }
+    return ans;
+}
+void factor(LL n)
+{
+    cnt=0;
+    for(int i=0;(LL)p[i]*p[i]<=n;i++)
+    {
+        if(n%p[i]==0)
+        {
+            a[cnt]=p[i];
+            int c=0;
+            while(n%p[i]==0)
+            {
+                c++;
+                n/=p[i];
+            }
+            b[cnt++]=c;
+        }
+    }
+    if(n>1)
+    {
+        a[cnt]=n;
+        b[cnt++]=1;
+    }
+}
+LL extend_Euclid(LL a,LL b,LL &x,LL &y)
+{
+    if(b==0)
+    {
+        x=1;
+        y=0;
+        return a;
+    }
+    LL gd=extend_Euclid(b,a%b,x,y);
+    LL temp=x;
+    x=y;
+    y=temp-(a/b)*y;
+    return gd;
+}
+LL Inv(LL n,LL p)
+{
+    return quick_mod(n,p-2,p);
+}
+bool dfs(int dept,LL t)
+{
+    if(dept==cnt)
+    {
+        LL ans=quick_mod(g,t,m);
+        if(ans==1&&t!=m-1) return false;
+        return true;
+    }
+    LL tmp=1;
+    for(int i=0;i<=b[dept];i++)
+    {
+        if(!dfs(dept+1,t*tmp)) return false;
+        tmp*=a[dept];
+    }
+    return true;
+}
+void find()
+{
+    factor(m-1);
+    for(g=2;;g++)
+        if(dfs(0,1)) break;
+}
+LL log_x(LL a,LL b,LL p)
+{
+    map<LL,int>x;
+    LL z=(LL)ceil(sqrt(p*1.0));
+    LL v=Inv(quick_mod(a,z,p),p);
+    LL e=1;
+    x[1]=0;
+    for(int i=1;i<z;i++)
+    {
+        e=multi(e,a,p);
+        if(!x.count(e))
+            x[e]=i;
+    }
+    for(int i=0;i<z;i++)
+    {
+        if(x.count(b))
+            return i*z+x[b];
+        b=multi(b,v,p);
+    }
+    return -1;
+}
+LL sol[1005];
+void Solve(LL a,LL b,LL n)
+{
+    LL d,x,y;
+    d=extend_Euclid(a,n,x,y);
+    if(b%d) puts("-1");
+    else
+    {
+        n/=d;b/=d;
+        sol[0]=(x*b%n+n)%n;
+        for(int i=1;i<d;i++)
+            sol[i]=sol[i-1]+n;
+        for(int i=0;i<d;i++)
+            sol[i]=quick_mod(g,sol[i],m);
+        sort(sol,sol+d);
+        for(int i=0;i<d;i++)
+            cout<<sol[i]<<endl;
+    }
+}
+int main()
+{
+    int t=1;
+    isprime();
+    while(cin>>k>>m>>newx)
+    {
+        find();
+        LL t1=log_x(g,newx,m);
+        LL t2=m-1;
+        cout<<"case"<<t++<<":"<<endl;
+        Solve(k,t1,t2);
+    }
+    return 0;
+}
diff --git a/HDOJ/3931_autoAC.cpp b/HDOJ/3931_autoAC.cpp
new file mode 100644
index 0000000..099c1ce
--- /dev/null
+++ b/HDOJ/3931_autoAC.cpp
@@ -0,0 +1,115 @@
+#include <cstdio>
+#include <cstring>
+const int maxN=255;
+const int maxn=550;
+const int inf=1<<25;
+const int s=0;
+int L , W , N , P;
+struct edge{
+       int v,next,w;
+}edge[maxn*maxn];
+int head[maxn],cnt;//for sap 
+void addedge(int u, int v, int w)
+{
+     edge[cnt].v=v;
+     edge[cnt].w=w;
+     edge[cnt].next=head[u];
+     head[u]=cnt++;
+     edge[cnt].v=u;
+     edge[cnt].w=0;
+     edge[cnt].next=head[v];
+     head[v]=cnt++;
+}
+int sap(int t)
+{
+    int pre[maxn],cur[maxn],dis[maxn],gap[maxn];
+    int flow=0 , aug=inf ,u;
+    bool flag;
+    for (int i=0 ; i<=t ; ++i)
+    {
+        cur[i]=head[i];
+        gap[i]=dis[i]=0;
+    }
+    gap[s]=t+1;
+    u=pre[s]=s;
+    while (dis[s]<=t)
+    {
+          flag=0 ; 
+          for (int &j=cur[u] ; ~j ; j=edge[j].next)
+          {
+              int v=edge[j].v;
+              if (edge[j].w>0 && dis[u]==dis[v]+1)
+              {
+                   flag=1;
+                   if(edge[j].w<aug)aug=edge[j].w;
+                   pre[v]=u;
+                   u=v;
+                   if (u==t)
+                   {
+                       flow+=aug;
+                       while (u!=s)
+                       {
+                             u=pre[u];
+                             edge[cur[u]].w-=aug;
+                             edge[cur[u]^1].w+=aug;
+                       }
+                       aug=inf;    
+                   }  
+                   break;        
+              }
+          }
+          if (flag)continue ;
+          int mindis=t+1;
+          for (int j=head[u]; ~j ; j=edge[j].next)
+          {
+              int v=edge[j].v;
+              if (edge[j].w>0 && dis[v]<mindis)
+              {
+                 mindis=dis[v];
+                 cur[u]=j;
+              }
+          }
+          if(--gap[dis[u]]==0)break;
+          gap[dis[u]=mindis+1]++;
+          u=pre[u];
+    }
+    return flow;
+}
+int x[maxN],y[maxN],r[maxN],p[maxN];//for build graph
+bool intersect (int a,int b)
+{
+     int dis=(x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]);
+     if(dis<=((r[a]+r[b])*(r[a]+r[b])))return true ;
+     else return false ;
+}
+void build_graph()
+{
+     int n=2*N;
+     for (int i=1 ; i<=N ; ++i)
+     {
+         addedge (i,i+N,p[i]);
+         if(y[i]<=r[i])addedge(0,i,inf);
+         if(y[i]+r[i]>=W)addedge(i+N,n+1,inf);
+         for (int j=i+1 ; j<=N ; ++j)//
+         if(intersect(i,j))addedge(i+N,j,inf),addedge(j+N,i,inf);
+     }
+}
+void init ()
+{
+     memset (head , -1 , sizeof(head));
+     cnt=0;
+}
+int main ()
+{
+    while (~scanf("%d%d%d%d",&L,&W,&N,&P))
+    {
+          init();
+          for (int i=1 ; i<=N ; ++i)
+           scanf("%d %d %d %d",x+i,y+i,r+i,p+i);
+          build_graph();
+          int ans=P-sap(2*N+1);
+          if(ans<0)printf("Our hero has been killed\n");
+          else printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3932_autoAC.cpp b/HDOJ/3932_autoAC.cpp
new file mode 100644
index 0000000..2bc0647
--- /dev/null
+++ b/HDOJ/3932_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <cstdio>
+#include <cmath>
+#include <time.h>
+#include <cstdlib>
+using namespace std;
+const double pi=acos(-1.0);
+const int maxn=1005;
+double x[maxn], y[maxn];
+int n;
+double dis2 (double x1,double y1 ,double x2,double y2)
+{
+       double tmp1=x1-x2,tmp2=y1-y2;
+       tmp1*=tmp1;
+       tmp2*=tmp2;
+       return tmp1+tmp2;
+}
+double test(double xx, double yy) 
+{
+       double max = 0,tmp;
+       for (int i=0;i<n;i++)
+           if(max<(tmp=dis2(xx,yy,x[i],y[i])))max=tmp;
+       return max;
+}
+int main()
+{
+    double xx,yy;
+    double delta,theta;
+    double X,Y;
+    double retx,rety,ans;
+    while (~scanf("%lf%lf%d",&X,&Y,&n))
+    {
+        for (int i=0 ; i<n ; i++)
+            scanf("%lf%lf",x+i,y+i);
+        double ans=1000000000.0;
+        for (int i=0 ; i<10 ; ++i)
+        {
+            xx=((double)(rand()%1001)/1000.0)*X;
+            yy=((double)(rand()%1001)/1000.0)*Y;
+            double dis=test(xx,yy);
+            for (delta=X ; delta>0.001 ; delta*=0.9) 
+            {
+                for (theta=0 ; theta<=2*pi ; theta+=(pi/25.0))
+                {
+                    double tx=xx+delta*cos(theta);
+                    double ty=yy+delta*sin(theta);
+                    double tdis=test(tx,ty);
+                    if(tdis<dis)
+                    {
+                        xx=tx;
+                        yy=ty;
+                        dis=tdis;
+                    }
+                }
+            }
+            if(dis<ans)
+            {
+                retx=xx;
+                rety=yy;
+                ans=dis;
+            }
+        }
+        printf("(%.1lf,%.1lf).\n%.1lf\n",retx,rety,sqrt(ans));
+    }
+    return 0;
+}
diff --git a/HDOJ/3933_autoAC.cpp b/HDOJ/3933_autoAC.cpp
new file mode 100644
index 0000000..77a0991
--- /dev/null
+++ b/HDOJ/3933_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <cctype>
+using namespace std;
+const int maxn=1001;
+const int maxs=101;
+int dp[maxs][maxn];
+int data[maxn];
+int min(int a,int b){
+    return a<b?a:b;
+}
+int main(){
+    int n,s,la,lb;
+    while(scanf("%d",&n)&&n){
+        scanf("%d%d%d",&lb,&la,&s);
+        memset(dp,0,sizeof(dp));
+        int i,j,k;
+        for(i=1;i<=n;i++){
+            scanf("%d",&data[i]);
+            dp[0][i]=data[i];
+            dp[0][i]+=dp[0][i-1];
+        }
+        for(i=1;i<=s;i++){
+            for(j=1;j<=n;j++){
+                dp[i][j]=dp[i][j-1]+data[j];
+                for(k=la;k<=lb && k<=j;k++){
+                    dp[i][j]=min(dp[i][j],dp[i-1][j-k]);
+                }
+            }
+        }
+        int ans=1<<30;
+        for(i=0;i<=s;i++){
+            ans=min(dp[s][n],ans);
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3934_autoAC.cpp b/HDOJ/3934_autoAC.cpp
new file mode 100644
index 0000000..8fba729
--- /dev/null
+++ b/HDOJ/3934_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<math.h>
+using namespace std;
+#define PR 1e-8
+#define N 50015
+struct TPoint
+{
+    double x,y;
+    TPoint(){}
+    TPoint(double _x,double _y):x(_x),y(_y){}
+    TPoint operator-(const TPoint p) {return TPoint(x-p.x,y-p.y);}
+}ply[N];
+int n;
+double MAX(double a,double b) {return a>b?a:b;}
+double dist(TPoint a,TPoint b)
+{
+    TPoint c(b-a);
+    return sqrt(c.x*c.x+c.y*c.y);
+}
+double cross(TPoint a,TPoint b,TPoint c)
+{
+    TPoint s(b-a),t(c-a);
+    return s.x*t.y-s.y*t.x;
+}
+int dblcmp(double a)
+{
+    if(fabs(a)<PR) return 0;
+    return a>0?1:-1;
+}
+bool cmpx(TPoint a,TPoint b) 
+{
+    if(fabs(a.x-b.x)<PR) return a.y<b.y;
+    return a.x<b.x;
+}
+bool cmp(TPoint a,TPoint b)
+{
+    int d1=dblcmp(cross(ply[0],a,b));
+    return d1>0||(d1==0&&dist(ply[0],a)<dist(ply[0],b));
+}
+double diss(TPoint a,TPoint b)
+{
+    return dist(a,b)*dist(a,b);
+}
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        int i,top=2,j,p,q,r;
+        for(i=0;i<n;i++)
+            scanf("%lf%lf",&ply[i].x,&ply[i].y);
+        sort(ply,ply+n,cmpx);
+        sort(ply+1,ply+n,cmp);
+        for(i=2;i<n;i++)
+        {
+            while(top>1&&(dblcmp(cross(ply[top-2],ply[i],ply[top-1])))>=0) top--;
+            ply[top++]=ply[i];
+        }
+        double max1=-1e20,tmp;
+        n=top; ply[n]=ply[0]; ply[n+1]=ply[1]; ply[n+2]=ply[2];
+        p=0; q=1; r=2;
+        while(1)
+        {
+            int pp=p,qq=q,rr=r;
+            while(cross(ply[p],ply[q],ply[r+1])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
+                r=(r+1)%n;
+            max1=MAX(max1,fabs(tmp)*0.5);
+            while(cross(ply[p],ply[q+1],ply[r])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
+                q=(q+1)%n;
+            max1=MAX(max1,fabs(tmp)*0.5);
+            while(cross(ply[p+1],ply[q],ply[r])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
+                p=(p+1)%n;
+            max1=MAX(max1,fabs(tmp)*0.5);
+            if(pp==p&&qq==q&&rr==r) r=(r+1)%n;
+            if(r==0) break;
+        }
+        if(n<3) max1=0;
+        printf("%.2lf\n",max1);
+    }
+    return 0;
+}
diff --git a/HDOJ/3935_autoAC.cpp b/HDOJ/3935_autoAC.cpp
new file mode 100644
index 0000000..0024c91
--- /dev/null
+++ b/HDOJ/3935_autoAC.cpp
@@ -0,0 +1,64 @@
+#include <cstdio>
+#include <iostream>
+#include <math.h>
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+using namespace std;
+#define maxn 105
+int g[maxn];
+int x[maxn];
+int n,m;
+int inf=100*100;
+int all;
+int Get(int n)
+{
+     n=(n&0x55555555)+((n>>1)&0x55555555);  
+     n=(n&0x33333333)+((n>>2)&0x33333333);  
+     n=(n&0x0f0f0f0f)+((n>>4)&0x0f0f0f0f);  
+     n=(n&0x00ff00ff)+((n>>8)&0x00ff00ff);  
+     n=(n&0x0000ffff)+((n>>16)&0x0000ffff);  
+     return n;
+}
+void heng(int &x,int i)
+{
+    x^=i;x^=i<<1;x^=i>>1;  
+    x=x&all;
+}
+int main()
+{
+    int i, j,k;
+    while(scanf("%d%d", &n,&m) != EOF)
+    {
+        memset(g,0,sizeof(g));
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<m;j++)
+            {
+                int tmp;
+                scanf("%d",&tmp);
+                g[i]=g[i]<<1|tmp;
+            }
+        }
+        all=(1<<m)-1;
+        int ans=inf;
+        for(i=0;i<(1<<m);i++)
+        {    
+            for(k=0;k<n;k++)x[k]=g[k];
+            int t=Get(i);
+            heng(x[0],i);
+            x[1]^=i;
+            for(j=1;j<n;j++)
+            {
+                int k=x[j-1]^all;
+                heng(x[j],k);
+                x[j+1]^=k;
+                t+=Get(k);
+            }
+            if(t<ans&&x[n-1]==all)ans=t;
+        }
+        if(ans==inf)printf("no solution\n");
+        else printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3936_autoAC.cpp b/HDOJ/3936_autoAC.cpp
new file mode 100644
index 0000000..e2241b4
--- /dev/null
+++ b/HDOJ/3936_autoAC.cpp
@@ -0,0 +1,58 @@
+#include <cstdio>
+#include <cstring>
+typedef long long ll;
+const ll mod=1000000007;
+ll mtrx[60][2][2];
+void pre_pro()
+{
+    memset (mtrx , 0 , sizeof(mtrx));
+    mtrx[0][0][0]=1;mtrx[0][0][1]=1;
+    mtrx[0][1][0]=1;mtrx[0][1][1]=0;
+    for (int t=0 ; t<60 ; ++t)
+       for (int i=0 ; i<2 ; ++i)
+         for (int j=0 ; j<2 ; ++j)
+         {
+             for (int k=0 ; k<2 ; ++k)
+              mtrx[t+1][i][j]+=mtrx[t][i][k]*mtrx[t][k][j];
+            mtrx[t+1][i][j]%=mod;
+         }
+}
+ll fib (ll a)
+{
+    a--;
+    ll mat[2][2]={1,0,0,1};
+    ll tmp[2][2];
+    for (int p=0 ; a ; a>>=1 , ++p)
+    {
+        if(!(a&1))continue;
+        tmp[0][0]=mat[0][0];tmp[0][1]=mat[0][1];
+        tmp[1][0]=mat[1][0];tmp[1][1]=mat[1][1];
+        memset (mat, 0 , sizeof(mat));
+        for (int i=0 ; i<2 ; ++i)
+         for (int j=0 ; j<2 ; ++j)
+         {
+             for (int k=0 ; k<2 ; ++k)
+                 mat[i][j]+=mtrx[p][i][k]*tmp[k][j];
+             mat[i][j]%=mod;
+         }
+    }
+    return mat[0][0];
+}
+ll sum(ll a)
+{
+    if(a==0)return 0;
+    else return fib(2*a)*fib(2*a+1)%mod;
+}
+int main ()
+{
+    pre_pro();
+    int cas;
+    scanf("%d",&cas);
+    while (cas--)
+    {
+        ll l,r;
+        scanf("%I64d%I64d",&l,&r);
+        printf("%d\n",(sum(r)-sum(l-1)+mod)%mod);
+    }
+    return 0;
+}
diff --git a/HDOJ/3937_autoAC.cpp b/HDOJ/3937_autoAC.cpp
new file mode 100644
index 0000000..933f7e2
--- /dev/null
+++ b/HDOJ/3937_autoAC.cpp
@@ -0,0 +1,107 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<cmath>
+#define N 64
+struct trie{
+ int next[N];
+ int tag;
+}data[3000000];
+int inp;
+int init(int a){
+ memset(data[a].next,0,sizeof(data[a].next));
+ data[a].tag=0;
+ return a;
+}
+int tran(char a){
+ if(a>='A'&&a<='Z') return a-'A';
+ if(a>='a'&&a<='z') return a-'a'+26;
+ return a-'0'+52;
+}
+void insert(char *a){
+ int p=0;
+ for(;*a;a++){
+ int d=tran(*a);
+ if(data[p].next[d]==0)data[p].next[d]=init(++inp);
+ p=data[p].next[d];
+ data[p].tag++;
+ }
+}
+int query(char *a){
+ int p=data[0].next[tran(*a)];
+ for(a++;*a&&p;a++){
+ int d=tran(*a);
+ p=data[p].next[d];
+ }
+ return data[p].tag;
+}
+bool isok(double x,double y){
+ return (fabs(x-y)/x)<0.11;
+}
+int getint(char *a){
+ int ret=0;
+ for(int i=0;i<8;i++)
+ ret=ret*2+a[i];
+ return ret;
+}
+char be[]="begin";
+char en[]="end";
+bool cmp(char *a,char *b,int len){
+ for(int i=0;i<len;i++)
+ if(a[i]!=b[i])
+ return false;
+ return true;
+}
+int T,n,m,tf;
+double a,b;
+char str[100],ss[10];
+int main(void){
+ while(scanf("%d%d",&T,&m)+1){
+ inp=0;init(0);
+ tf=0;
+ for(int i=0;i<T;i++){
+ scanf("%s",str);
+ insert(str);
+ }
+ for(;m;m--){
+ tf=0;
+ double temp;
+ scanf("%d",&n);
+ scanf("%lf%lf",&a,&b);
+ if(!(a<b&&isok(2*a,b))){
+ tf=1;
+ }
+ ss[0]=0,ss[1]=1;
+ for(int i=2;i<8;i++){
+ scanf("%lf",&temp);
+ if(isok(temp,a))
+ ss[i]=0;
+ else
+ ss[i]=1;
+ }
+ str[0]=getint(ss);
+ for(int i=1;i<n;i++){
+ for(int j=0;j<8;j++){
+ scanf("%lf",&temp);
+ if(isok(temp,a)){
+ ss[j]=0;
+ }
+ else{
+ ss[j]=1;
+ }
+ }
+ str[i]=getint(ss);
+ }
+ str[n]='\0';
+ if(!cmp(be,str,5)||!cmp(en,str+n-3,3))
+ tf=1;
+ if(tf){
+ printf("wrong barcode!\n");
+ }
+ else{
+ str[n-3]='\0';
+ printf("%d\n",query(str+5));
+ }
+ }
+ }
+}
diff --git a/HDOJ/3938_autoAC.cpp b/HDOJ/3938_autoAC.cpp
new file mode 100644
index 0000000..284c79f
--- /dev/null
+++ b/HDOJ/3938_autoAC.cpp
@@ -0,0 +1,103 @@
+#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 INF 2000000000
+#define MAXN 10005
+#define L(x) x<<1
+#define R(x) x<<1|1
+using namespace std;
+int n, m, q;
+int father[MAXN],  num[MAXN];
+long long out[MAXN];
+struct node
+{
+    int u, v, w;
+    bool operator <(const node &a)const
+    {
+        return w < a.w;
+    }
+}edge[MAXN * 10];
+struct wen
+{
+    int l, id;
+    bool operator <(const wen &a)const
+    {
+        return l < a.l;
+    }
+}p[MAXN];
+void init()
+{
+    for(int i = 1; i <= n; i++)
+    {
+        father[i] = i;
+        num[i] = 1;
+    }
+}
+int find(int x)
+{
+    if(father[x] == x) return x;
+    int t = find(father[x]);
+    father[x] = t;
+    return t;
+}
+int join(int x, int y)
+{
+    int fx = find(x);
+    int fy = find(y);
+    if(fx == fy) return 0;
+    int t = num[fx] * num[fy];
+    num[fx] += num[fy];
+    num[fy] = 0;
+    father[fy] = fx;
+    return t;
+}
+int main()
+{
+    while(scanf("%d%d%d", &n, &m, &q) != EOF)
+    {
+        init();
+        for(int i = 1; i <= m; i++)
+            scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
+        sort(edge + 1, edge + m + 1);
+        for(int i = 1; i <= q; i++)
+        {
+            scanf("%d", &p[i].l);
+            p[i].id = i;
+        }
+        sort(p + 1, p + q + 1);
+        int pos = 1;
+        long long ans = 0;
+        for(int i = 1; i <= q; i++)
+        {
+            while(pos <= m && edge[pos].w <= p[i].l)
+            {
+                ans += join(edge[pos].u, edge[pos].v);
+                pos ++;
+            }
+            out[p[i].id] = ans;
+        }
+        for(int i = 1; i <= q; i++)
+        printf("%I64d\n", out[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3939_autoAC.cpp b/HDOJ/3939_autoAC.cpp
new file mode 100644
index 0000000..ad6a44c
--- /dev/null
+++ b/HDOJ/3939_autoAC.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+#define maxn 1000010
+int phi[maxn]; 
+int prime[maxn],cnt; 
+bool flag[maxn]; 
+int p[100],num; 
+LL ans,l; 
+void init()
+{   
+    cnt=0;
+    memset(flag,0,sizeof(flag));
+    for(int i=2;i<maxn;i++)
+      if(!flag[i])
+      {
+          prime[cnt++]=i;
+          for(int j=i+i;j<maxn;j+=i)
+              flag[j]=1;
+      }
+    for(int i=0;i<maxn;i++) phi[i]=i;
+    for(int i=2;i<maxn;i+=2) phi[i]>>=1;
+    for(int i=3;i<maxn;i+=2)
+      if(phi[i]==i)
+        for(int j=i;j<maxn;j+=i)
+          phi[j]=phi[j]-phi[j]/i;
+}
+void divide(int x)
+{
+    num=0;
+    for(int i=0;i<cnt&&prime[i]*prime[i]<=x;i++)
+      if(x%prime[i]==0)
+      {
+          p[num++]=prime[i];
+          while(x%prime[i]==0) x/=prime[i];
+      }
+    if(x>1) p[num++]=x;
+}
+void dfs(int id,int mul,int tot,int x)
+{
+    if(id==num)
+    {
+        if(tot&1) ans=ans-x/mul;
+        else ans=ans+x/mul;
+        return ;
+    }
+    dfs(id+1,mul*p[id],tot+1,x);
+    dfs(id+1,mul,tot,x);
+}
+int main()
+{
+    init();
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        scanf("%lld",&l);
+        int temp=sqrt(l+0.0);
+        ans=0;
+        for(int i=1;i<=temp;i++) 
+        {
+            int lim=sqrt(l-(LL)i*i+0.0);  
+            if(i&1) 
+            {
+                divide(i);
+                if(i<=lim) dfs(0,1,0,i>>1);
+                else dfs(0,1,0,lim>>1);
+            }
+            else 
+            {
+                if(i<=lim) ans+=phi[i];
+                else
+                {
+                    divide(i);
+                    dfs(0,1,0,lim);
+                }
+            }
+        }
+        printf("%lld\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3940_autoAC.cpp b/HDOJ/3940_autoAC.cpp
new file mode 100644
index 0000000..75cd829
--- /dev/null
+++ b/HDOJ/3940_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <cstring>
+#include <cmath>
+using namespace std;
+double fly_pos(double vx,double vy,double h)
+{
+    return vx*(vy+sqrt(vy*vy+19.6*h))/9.8;
+}
+double fly_h(double vy,double h,double t)
+{
+    return h+vy*t-4.9*t*t;
+}
+int main()
+{
+    double h,vx,vy,t,h0,l,v1,v2,v3;
+    char bird[10];
+    while(~scanf("%lf%s",&h,bird))
+    {
+        if(!strcmp("Red",bird))
+        {
+            scanf("%lf%lf",&vx,&vy);
+            printf("%.3lf\n",fly_pos(vx,vy,h));
+        }
+        else if(!strcmp("Blue",bird))
+        {
+            scanf("%lf%lf%lf%lf%lf%lf",&vx,&vy,&t,&v1,&v2,&v3);
+            if(fly_pos(vx,vy,h)<t*vx)
+            {
+                printf("%.3lf\n",fly_pos(vx,vy,h));
+                continue;
+            }
+            h0=fly_h(vy,h,t);
+            l=vx*t;
+            vy=vy-9.8*t;
+            printf("%.3lf %.3lf %.3lf\n",l+fly_pos(v1,vy,h0),l+fly_pos(v2,vy,h0),l+fly_pos(v3,vy,h0));
+        }
+        else
+        {
+            scanf("%lf%lf%lf",&vx,&vy,&t);
+            if(fly_pos(vx,vy,h)<t*vx)
+            {
+                printf("%.3lf\n",fly_pos(vx,vy,h));
+                continue;
+            }
+            h0=fly_h(vy,h,t);
+            l=vx*t;
+            vy=vy-9.8*t;
+            printf("%.3lf\n",l+fly_pos(2*vx,2*vy,h0));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3941_autoAC.cpp b/HDOJ/3941_autoAC.cpp
new file mode 100644
index 0000000..00ae8d3
--- /dev/null
+++ b/HDOJ/3941_autoAC.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <sstream>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <cmath>
+#include <iomanip>
+#include <cstring>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+using namespace std;
+const int MOD=1000000007;
+const int MaxN=103;
+const int MaxM=203;
+int N,K,f[2][MaxN][MaxM],s[MaxN][MaxM];
+int solve()
+{
+ int MaxK=2*K+1;
+ for (int i=0; i<=K; ++i)
+     for (int j=0; j<=MaxK; ++j) f[0][i][j]=s[i][j]=0;
+ f[0][0][0]=1;
+ s[0][0]=1;
+ int cur=0,last;
+ for (int i=1; i<=N; ++i)
+ {
+ last=cur;
+ cur=1-cur;
+ for (int j=0; j<=K; ++j)
+     for (int k=0; k<=MaxK; ++k) f[cur][j][k]=0;
+ f[cur][0][0]=1;
+ for (int j=1; j<=K; ++j)
+ {
+     for (int k=j; k<MaxK-1; ++k)
+     {
+         f[cur][j][k]=f[cur][j-1][k-1]+f[last][j][k-j];
+         f[cur][j][k]%=MOD;
+     }
+     for (int p=0; p<=j; ++p)
+     {
+      int cnt=MaxK-1-j;
+      f[cur][j][MaxK-1]+=s[p][cnt];
+      f[cur][j][MaxK-1]%=MOD;
+      cnt=MaxK-j;
+      f[cur][j][MaxK]+=s[p][cnt];
+      f[cur][j][MaxK]%=MOD;
+     }
+ }
+ for (int j=0; j<=K; ++j)
+     for (int k=MaxK; k>=0; --k) s[j][k]=f[cur][j][k];
+ for (int j=0; j<=K; ++j)
+     for (int k=MaxK-2; k>=0; --k)
+     {
+         s[j][k]+=s[j][k+2];
+         s[j][k]%=MOD;
+            } 
+ }
+ int ans=0;
+ for (int i=0; i<=K; ++i)
+     for (int j=i+i; j<MaxK; j+=2) 
+     {
+      ans+=f[cur][i][j];
+      ans%=MOD;
+     }
+ return ans;
+}
+int main()
+{
+ int Testnum;
+ scanf("%d",&Testnum);
+ for (int Test=1; Test<=Testnum; ++Test)
+ {
+ scanf("%d %d",&N,&K);
+ printf("Case #%d: %d\n",Test,solve());
+    }
+}
diff --git a/HDOJ/3943_autoAC.cpp b/HDOJ/3943_autoAC.cpp
new file mode 100644
index 0000000..a16a29c
--- /dev/null
+++ b/HDOJ/3943_autoAC.cpp
@@ -0,0 +1,76 @@
+#include"cstdlib"
+#include"cstdio"
+#include"cstring"
+#include"cmath"
+#include"queue"
+#include"algorithm"
+#include"iostream"
+using namespace std;
+__int64 dp[22][22][22];  
+int num[22];
+__int64 dfs(int site,int a,int b,int f,int x,int y)
+{
+    if(site==0)
+    {
+        if(a==x&&b==y) return 1;
+        return 0;
+    }
+    if(!f&&dp[site][a][b]!=-1) return dp[site][a][b];
+    int len=f?num[site]:9;
+    __int64 ans=0;
+    for(int i=0;i<=len;i++)
+    {
+        if(i==4) ans+=dfs(site-1,a+1,b,f&&i==len,x,y);
+        else if(i==7) ans+=dfs(site-1,a,b+1,f&&i==len,x,y);
+        else ans+=dfs(site-1,a,b,f&&i==len,x,y);
+    }
+    if(!f) dp[site][a][b]=ans;
+    return ans;
+}
+__int64 solve(__int64 a,int x,int y)
+{
+    int cnt=0;
+    while(a)
+    {
+        num[++cnt]=a%10;
+        a/=10;
+    }
+    return dfs(cnt,0,0,1,x,y);
+}
+int main()
+{
+    int t,cas=1;
+    cin>>t;
+    while(t--)
+    {
+        __int64 p,q;
+        int x,y;
+        scanf("%I64d%I64d%d%d",&p,&q,&x,&y);
+        memset(dp,-1,sizeof(dp));
+        int n;
+        scanf("%d",&n);
+        printf("Case #%d:\n",cas++);
+        while(n--)
+        {
+            __int64 k,s;
+            __int64 ans=-1;
+            s=solve(p,x,y);
+            scanf("%I64d",&k);
+            s+=k;
+            __int64 l=p+1,r=q;
+            while(l<=r)          
+            {
+                __int64 mid=(l+r)/2;
+                if(solve(mid,x,y)>=s)
+                {
+                    ans=mid;
+                    r=mid-1;
+                }
+                else l=mid+1;
+            }
+            if(ans!=-1) printf("%I64d\n",ans);
+            else puts("Nya!");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3944_autoAC.cpp b/HDOJ/3944_autoAC.cpp
new file mode 100644
index 0000000..7bab613
--- /dev/null
+++ b/HDOJ/3944_autoAC.cpp
@@ -0,0 +1,69 @@
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#define maxn 10000
+using namespace std;
+int flag[maxn],pim[maxn],tol;
+int p[1229][9973];
+int ni[1229][9973];
+int mp[10000];
+void init()
+{
+    tol=0;
+    for(int i=2; i<maxn; i++) 
+    {
+        if(!flag[i])  pim[tol++]=i;
+        for(int j=0; j<tol&&i*pim[j]<maxn; j++)
+        {
+            flag[i*pim[j]]=1;
+            if(i%pim[j]==0) break;
+        }
+    }
+    for(int i=0; i<tol; i++)
+    {
+        int k=pim[i];
+        mp[k]=i;
+        p[i][0]=1, p[i][1]=1;
+        ni[i][0]=1,ni[i][1]=1;
+        for(int j=2; j<k; j++) 
+        {
+            p[i][j]=j*p[i][j-1]%pim[i];
+            ni[i][j]=-k/j*ni[i][k%j]%k;
+            if(ni[i][j]<0) ni[i][j]+=k;
+        }
+    }
+    for(int i=0; i<tol; i++) 
+    {
+        int k=pim[i];
+        for(int j=1; j<k; j++)
+        {
+            ni[i][j]=ni[i][j]*ni[i][j-1]%k;
+        }
+    }
+}
+int cal(int n,int m,int v)
+{
+    if(n<m) return 0;
+    int x=mp[v];
+    return p[x][n] * ni[x][m]%v * ni[x][n-m]%v;
+}
+int main()
+{
+    int n,k,p,ca=0;
+    init();
+    while(scanf("%d %d %d",&n,&k,&p)==3)
+    {
+        if(k>n/2) k=n-k;
+        int res=1,u_u=n-k;
+        n++;
+        while(n&&k)
+        {
+            res=res*cal(n%p,k%p,p)%p;
+            if(res==0) break;
+            n/=p;
+            k/=p;
+        }
+        printf("Case #%d: %d\n",++ca,(res+u_u)%p);
+    }
+    return 0;
+}
diff --git a/HDOJ/3945_autoAC.cpp b/HDOJ/3945_autoAC.cpp
new file mode 100644
index 0000000..f1be25a
--- /dev/null
+++ b/HDOJ/3945_autoAC.cpp
@@ -0,0 +1,129 @@
+#include <cstdio>
+#include <iostream>
+#include <cstring>
+#include <vector>
+using namespace std;
+#define rep(i,n) for(int i=0;i<n;i++)
+#define mod 1000000009
+#define pb push_back
+vector <int> p[15];
+int st[15];
+int f[1<<16][20];
+int to[15][20][20];
+long long dp[15][25][25];
+int num[1<<16];
+int dx[]= {0,0,-1,1,1,1,-1,-1};
+int dy[]= {-1,1,0,0,1,-1,1,-1};
+int check(int x,int y)
+{
+    if(x>=0 && x<4 && y>=0 && y<4)return 1;
+    return 0;
+}
+int nxt(int t)
+{
+    int ret=0;
+    rep(i,17)
+    {
+        int x=i/4;
+        int y=i%4;
+        int cnt=0;
+        for(int j=0; j<8; j++)
+        {
+            int nx = x+dx[j];
+            int ny = y+dy[j];
+            if(check(nx,ny))
+            {
+                int pos = nx*4+ny;
+                if((1<<pos)&t)
+                    cnt++;
+            }
+        }
+        if((1<<i)&t)
+        {
+            if(cnt==2||cnt==3)
+                ret^=(1<<i);
+        }
+        else
+        {
+            if(cnt==3)
+                ret^=(1<<i);
+        }
+    }
+    return ret;
+}
+void init()
+{
+    int n = 1<<16;
+    memset(num,0,sizeof(num));
+    rep(i,n)rep(j,17)
+    if(i&(1<<j))
+        num[i]++;
+    rep(i,n)f[i][0]=nxt(i);
+    for(int i=1; i<=18; i++)
+        for(int j=0; j<n; j++)
+            f[j][i]=f[f[j][i-1]][i-1];
+}
+int getnxt(int s,int t)
+{
+    for(int i=18; i>=0; i--)
+        if((1<<i)<=t)
+        {
+            t-=(1<<i);
+            s=f[s][i];
+        }
+    return s;
+}
+int main()
+{
+    int L,K,M,T,N,t;
+    init();
+    scanf("%d",&L);
+    rep(cas,L)
+    {
+        scanf("%d%d%d%d",&K,&M,&T,&N);
+        rep(i,K)p[i].clear();
+        memset(st,0,sizeof(st));
+        rep(k,K)rep(i,4)rep(j,4)
+        {
+            scanf("%d",&t);
+            if(t)st[k]^=(1<<(i*4+j));
+        }
+        int n=1<<16;
+        memset(to,0,sizeof(to));
+        rep(k,K) // 10*2^16
+            rep(i,n)
+            if((st[k]&i) == st[k])
+            {
+                int j=i^st[k];
+                int cnt1=num[j];
+                int _nxt=getnxt(i,T);
+                int cnt2=num[_nxt];
+                to[k][cnt1][cnt2]++;
+            }
+        memset(dp,0,sizeof(dp));
+        dp[0][0][0]=1;
+        for(int k=0; k<K; k++)
+        {
+            for(int i=0; i<=M; i++)
+            {
+                for(int j=0; j<=N; j++)
+                {
+                    if(dp[k][i][j]==0)continue;
+                    for(int p=0; p<=16; p++)
+                    {
+                        for(int q=0; q<=16; q++)
+                        {
+                            if(to[k][p][q]==0)continue;
+                            if(i+p<=M && j+q<=N)
+                                dp[k+1][i+p][j+q]=(dp[k+1][i+p][j+q]+dp[k][i][j]*to[k][p][q])%mod;
+                        }
+                    }
+                }
+            }
+        }
+        long long ret=0;
+        for(int i=0; i<=M; i++)
+            ret=(ret+dp[K][i][N])%mod;
+        printf("Case #%d: %I64d\n",cas+1,ret);
+    }
+}
diff --git a/HDOJ/3946_autoAC.cpp b/HDOJ/3946_autoAC.cpp
new file mode 100644
index 0000000..31c7a57
--- /dev/null
+++ b/HDOJ/3946_autoAC.cpp
@@ -0,0 +1,43 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<algorithm>
+#include<cmath>
+using namespace std;
+int a[10005], b[10005];
+int res, pre, as[10005];
+bool cmp(int x, int y)
+{
+    return x>y;
+}
+int main()
+{
+    int n, m, an, bn, t=1, ca, i, end, lef, tmp;
+    scanf("%d", &ca);
+    while(ca-->0)
+    {
+        scanf("%d%d%d%d", &n, &m, &an, &bn);
+        for(i=0; i<an; i++)
+            scanf("%d", &a[i]);
+        for(i=0; i<bn; i++)
+            scanf("%d", &b[i]);
+        sort(a, a+an, cmp);
+        sort(b, b+bn, cmp);
+        memset(as, 0, sizeof(as));
+        for(i=1; i<=an; i++)as[i]=as[i-1]+a[i-1];
+        end=n*m/3;
+        if(((n==2)&&(m%3==2))||((m==2)&&(n%3==2)))end--;
+        end=min(end, bn);
+        res=as[min(n*m/2, an)];
+        pre=0;
+        for(i=1; i<=end; i++)
+        {
+            pre+=b[i-1];
+            lef=min((n*m-3*i)/2, an);
+            tmp=pre+as[lef];
+            if(tmp>res)res=tmp;
+        }
+        printf("Case #%d: %d\n", t++, res);
+    }
+    return 0;
+}
diff --git a/HDOJ/3947_autoAC.cpp b/HDOJ/3947_autoAC.cpp
new file mode 100644
index 0000000..b127b23
--- /dev/null
+++ b/HDOJ/3947_autoAC.cpp
@@ -0,0 +1,129 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<queue>
+using namespace std;
+#define sz 200
+#define inf 0x7fffffff
+int g[sz][sz];
+int s[sz],t[sz],v[sz];
+struct node{
+    int s, t, v, len, nxt;
+} e[sz * 40 + 20];
+int hd[sz], cnt, pre[sz] , pos[sz], dis[sz], vis[sz];
+int sum ;
+void insert(int s, int t, int v, int len){
+    e[cnt].s = s;e[cnt].t = t;e[cnt].v = v;e[cnt].len = len;
+    e[cnt].nxt = hd[s];hd[s] = cnt++;
+    e[cnt].s = t;e[cnt].t = s;e[cnt].v = 0;e[cnt].len = -len;
+    e[cnt].nxt = hd[t];hd[t] = cnt++;
+}
+bool spfa(int s, int t, int n){
+    for(int i = 0; i < n; i++){
+        dis[i]=inf;
+        vis[i]=0;
+        pre[i]=-1;
+    }
+    queue<int>q;
+    while(!q.empty())q.pop();
+    q.push(s);
+    pre[s] = s;
+    dis[s] = 0;
+    while( !q.empty() ){
+        int u = q.front();
+        q.pop();
+        vis[u] = 0;
+        for(int i = hd[u]; i!=-1; i=e[i].nxt){
+            int v = e[i].t;
+            if (e[i].v > 0 && dis[u] + e[i].len < dis[v]){
+                dis[v] = dis[u] + e[i].len;
+                pre[v] = u;
+                pos[v] = i;
+                if (!vis[v]){
+                    vis[v] = 1;
+                    q.push(v);
+                }
+            }
+        }
+    }
+    return pre[t] != -1 && dis[t] < inf;
+}
+int mcf(int s, int t, int n){
+    int fw = 0, ct = 0;
+    while(spfa(s,t,n)){
+        int v = inf;
+        for(int i = t; i != s; i = pre[i])
+            v = min(v, e[pos[i]].v);
+        fw += v;
+        ct += dis[t] * v;
+        for(int i = t; i != s; i = pre[i]){
+            e[pos[i]].v -= v;
+            e[pos[i] ^ 1].v += v;
+        }
+    }
+    if(fw != sum)return -1;
+    return ct; 
+}
+struct node1{
+    int s,t,v,nxt;
+}ne[sz*10];
+int nhd[sz],ncnt;
+void insert1(int s ,int t,int v){
+    ne[ncnt].s=s;
+    ne[ncnt].t=t;
+    ne[ncnt].v=v;
+    ne[ncnt].nxt = nhd[s];
+    nhd[s]=ncnt++;
+}
+int main(){
+    int TT;
+    scanf("%d",&TT);
+    for(int cas=1;cas<=TT;cas++){
+        int n;
+        scanf("%d",&n);
+        memset(pre,-1,sizeof(pre));
+        int S=0,T=n+1;
+        memset(hd,-1,sizeof(hd));
+        cnt = 0;
+        memset(g,-1,sizeof(g));
+        memset(pre,-1,sizeof(pre));
+        memset(nhd,-1,sizeof(nhd));
+        ncnt=0;
+        for(int i=1;i<n;i++){
+             scanf("%d%d%d",&s[i],&t[i],&v[i]);
+             g[s[i]][t[i]]=i;
+             pre[s[i]] = t[i];
+             insert1(t[i],s[i],v[i]);
+        }
+        s[n]=1;
+        t[n]=n+1;
+        v[n]=0;
+        insert1(n+1,1,0);
+        g[1][1+n]=n+1;
+        pre[1]=n+1;
+        sum=0;
+        for(int i=1;i<=n;i++){
+            int vv = v[i];
+            for(int j=nhd[s[i]];j!=-1;j=ne[j].nxt){
+                vv -= ne[j].v;
+                insert(i,g[ne[j].t][s[i]],inf,0);
+            }
+            if(vv>0){
+                sum+=vv;
+                insert(S,i,vv,0);
+            }
+            if(vv<0){
+                insert(i,T,-vv,0);
+            }
+        }
+        int m;
+        cin>>m;
+        int ss,tt,li,ci;
+        for(int i=0;i<m;i++){
+            scanf("%d%d%d%d",&ss,&tt,&li,&ci);
+            insert(g[ss][pre[ss]],g[tt][pre[tt]],li,ci);
+        }
+        printf("Case #%d: ",cas);
+        cout<<mcf(S,T,T+1)<<endl;
+    }
+}
diff --git a/HDOJ/3948_autoAC.cpp b/HDOJ/3948_autoAC.cpp
new file mode 100644
index 0000000..4995173
--- /dev/null
+++ b/HDOJ/3948_autoAC.cpp
@@ -0,0 +1,122 @@
+#include<cstdio>  
+#include<cmath>  
+#include<cstring>  
+#include<algorithm>  
+using namespace std;  
+#define MAXN 200100  
+int dp[MAXN][20];  
+char r[MAXN];  
+int sa[MAXN];  
+int wa[MAXN],wb[MAXN],wv[MAXN],ws[MAXN];  
+int height[MAXN],rk[MAXN];  
+int mm[MAXN];  
+int cas;  
+inline bool cmp(int *r,int a,int b,int len){  
+    return r[a]==r[b]&&r[a+len]==r[b+len];  
+}  
+void SA(int n,int m){  
+    int i,j,p,*x=wa,*y=wb,*t;  
+    for(i=0;i<m;i++)  
+        ws[i]=0;  
+    for(i=0;i<n;i++)  
+        ws[x[i]=r[i]]++;  
+    for(i=1;i<m;i++)  
+        ws[i]+=ws[i-1];  
+    for(i=n-1;i>=0;i--)  
+        sa[--ws[x[i]]]=i;  
+    for(j=p=1;p<n;j<<=1,m=p){  
+        for(p=0,i=n-j;i<n;i++)  
+            y[p++]=i;  
+        for(i=0;i<n;i++){  
+            if(sa[i]>=j)  
+                y[p++]=sa[i]-j;  
+        }  
+        for(i=0;i<m;i++)  
+            ws[i]=0;  
+        for(i=0;i<n;i++)  
+            ws[wv[i]=x[y[i]]]++;  
+        for(i=1;i<m;i++)  
+            ws[i]+=ws[i-1];  
+        for(i=n-1;i>=0;i--)  
+            sa[--ws[wv[i]]]=y[i];  
+        for(t=x,x=y,y=t,x[sa[0]]=0,p=i=1;i<n;i++)  
+            x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;  
+    }  
+}  
+void Height(int n){  
+    int i,j,k=0;  
+    for(i=0;i<=n;i++)    
+        rk[sa[i]]=i;  
+    for(i=0;i<n;height[rk[i++]]=k)  
+        for(k?k--:0,j=sa[rk[i]-1];r[i+k]==r[j+k];k++);  
+}  
+int init(){  
+    int i,j,len;  
+    memset(height,0,sizeof(height));  
+    len=strlen(r);  
+    r[len]='$';  
+    for(j=0;j<len;j++)  
+        r[j+len+1]=r[len-1-j];  
+    r[j+len+1]='\0';  
+    return len*2+1;  
+}  
+void st(int n){  
+    int i,j,p,q;  
+    for(i=1;i<=n;i++)  
+        dp[i][0]=i;  
+    for(j=1;j<=mm[n];j++)  
+        for(i=1;i+(1<<j)-1<=n;i++){  
+            p=height[dp[i][j-1]];  
+            q=height[dp[i+(1<<(j-1))][j-1]];  
+            if(p>q)  
+                dp[i][j]=dp[i+(1<<(j-1))][j-1];  
+            else  
+                dp[i][j]=dp[i][j-1];  
+        }  
+}  
+int RMQ_MIN(int i,int j){  
+    int tem;  
+    if(i>j){  
+        tem=i;  
+        i=j;  
+        j=tem;  
+    }  
+    i++;           
+    int k=mm[(j-i+1)];  
+    return min(height[dp[i][k]],height[dp[j-(1<<k)+1][k]]);  
+}  
+void solve(int n){  
+    int i,j,ans=0,pre1=0,pre2=0;  
+    st(n);  
+    for(i=2;i<=n;i++){  
+        pre1=min(pre1,height[i]);  
+        j=RMQ_MIN(i,rk[n-1-sa[i]]);  
+        if(j>pre1){  
+            ans+=j-pre1;  
+            pre1=j;  
+        }  
+        pre2=min(pre2,height[i]);  
+        j=RMQ_MIN(i,rk[n-sa[i]]);  
+        if(j>pre2){  
+            ans+=j-pre2;  
+            pre2=j;  
+        }  
+    }  
+    printf("Case #%d: %d\n",cas,ans);  
+}  
+int main(){  
+    int i,j,n,t,T;  
+    mm[0]=-1;  
+    for(i=1;i<MAXN;i++)  
+        mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];           
+    scanf("%d",&T);  
+    cas=0;  
+    for(t=1;t<=T;t++){  
+        scanf("%s",r);  
+        n=init();  
+        SA(n+1,130);  
+        Height(n);  
+        cas++;  
+        solve(n);  
+    }  
+}
diff --git a/HDOJ/3949_autoAC.cpp b/HDOJ/3949_autoAC.cpp
new file mode 100644
index 0000000..be07a4f
--- /dev/null
+++ b/HDOJ/3949_autoAC.cpp
@@ -0,0 +1,64 @@
+#include<cstdio>
+#include<algorithm>
+#define MAXN 10010
+typedef long long LL;
+using namespace std;
+int n;
+LL a[MAXN];
+void Gauss() {
+    int i, j, k, t;
+    k = 0;
+    for (i = 60; i >= 0; i--) {
+        for (j = k; j < n; j++) {
+            if ((a[j] >> i) & 1)
+                break;
+        }
+        if (j < n) {
+            swap(a[j], a[k]);
+            for (t = 0; t < n; t++) {
+                if (t != k && ((a[t] >> i) & 1))
+                    a[t] ^= a[k];
+            }
+            k++;
+        }
+    }
+    sort(a, a + n);
+    n = unique(a, a + n) - a;
+}
+LL Cal(int k) {
+    LL ans;
+    int i;
+    ans = i = 0;
+    if (a[0] == 0) {
+        if (k == 1)
+            return 0;
+        k--;
+        i++;
+    }
+    for (; i < n && k; k >>= 1, i++) {
+        if (k & 1)
+            ans ^= a[i];
+    }
+    if (i == n && k)
+        return -1;
+    return ans;
+}
+int main() {
+    int c, ca = 1;
+    int i, q;
+    LL k;
+    scanf("%d", &c);
+    while (c--) {
+        scanf("%d", &n);
+        for (i = 0; i < n; i++)
+            scanf("%I64d", &a[i]);
+        Gauss();
+        scanf("%d", &q);
+        printf("Case #%d:\n", ca++);
+        while (q--) {
+            scanf("%I64d", &k);
+            printf("%I64d\n", Cal(k));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3950_autoAC.cpp b/HDOJ/3950_autoAC.cpp
new file mode 100644
index 0000000..0a0223d
--- /dev/null
+++ b/HDOJ/3950_autoAC.cpp
@@ -0,0 +1,195 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <set>
+using namespace std;
+#define LL(x) (x<<1)
+#define RR(x) (x<<1|1)
+#define MID(a,b) (a+((b-a)>>1))
+#define INF (1<<30)
+const int N=50005;
+int n,q,ed[N];
+int st_len,ed_len;
+struct Segtree
+{
+    set<int> T[N];
+    int st[N*4],len[N*4];
+    void PushUp(int ind)
+    {
+        if(st[LL(ind)]<st[RR(ind)])
+        {
+            st[ind]=st[LL(ind)];
+            len[ind]=len[LL(ind)];
+        }
+        else
+        {
+            st[ind]=st[RR(ind)];
+            len[ind]=len[RR(ind)];
+        }
+    }
+    void build(int lft,int rht,int ind)
+    {
+        st[ind]=INF;
+        if(lft==rht) T[lft].clear();
+        else
+        {
+            int mid=MID(lft,rht);
+            build(lft,mid,LL(ind));
+            build(mid+1,rht,RR(ind));
+        }
+    }
+    void updata(int pos,int ist,bool add,int ind,int lft,int rht)
+    {
+        if(lft==rht)
+        {
+            if(add) T[lft].insert(ist);
+            else T[lft].erase(ist);
+            if(T[lft].size()==0) st[ind]=INF;
+            else
+            {
+                len[ind]=lft;    st[ind]=*(T[lft].begin());
+            }
+        }
+        else
+        {
+            int mid=MID(lft,rht);
+            if(pos<=mid) updata(pos,ist,add,LL(ind),lft,mid);
+            else updata(pos,ist,add,RR(ind),mid+1,rht);
+            PushUp(ind);
+        }
+    }
+    pair<int,int> query(int ist,int ied,int ind,int lft,int rht)
+    {
+        if(ist<=lft&&rht<=ied) return make_pair(st[ind],len[ind]);
+        else
+        {
+            int mid=MID(lft,rht);
+            pair<int,int> tmp1,tmp2; tmp1.first=INF,tmp2.first=INF;
+            if(ist<=mid) tmp1=query(ist,ied,LL(ind),lft,mid);
+            if(ied> mid) tmp2=query(ist,ied,RR(ind),mid+1,rht);
+            if(tmp1.first<tmp2.first) return tmp1;
+            else return tmp2;
+        }
+    }
+}seg;
+struct BIT
+{
+    int T[N],sum;
+    void init(){memset(T,0,sizeof(T));sum=0;}
+    int lowbit(int x){return x&-x;}
+    void insert(int x,int add)
+    {
+        sum+=add;
+        while(x<N)
+        {
+            T[x]+=add; x+=lowbit(x);
+        }
+    }
+    int query(int k)
+    {
+        int ind=0;
+        for(int i=20;i>=0;i--)
+        {
+            ind^=(1<<i);
+            if(ind<N&&k>T[ind]) k-=T[ind];
+            else ind^=(1<<i);
+        }
+        return ind+1;
+    }
+    int getsum()
+    {
+        return sum;
+    }
+}bit;
+int calu(int st,int len,int m,int a,int b)    
+{
+    int ed=st+len-1;
+    return max(ed-m-b+1,st);
+}
+bool judge(int st1,int st2,int &ilen,int &ist) 
+{
+    ist=st1;
+    if(st1>st2) return false;
+    ilen=st2-st1+1;
+    return true;
+}
+int main()
+{
+    int t,t_cnt=0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&q);
+        seg.build(1,n,1);   bit.init();
+        st_len=n,ed_len=n;
+        printf("Case #%d:\n",++t_cnt);
+        while(q--)
+        {
+            char cmd[5];     scanf("%s",cmd);
+            if(cmd[0]=='A')
+            {
+                int m,a,b;     scanf("%d%d%d",&m,&a,&b);
+                if(st_len>=m)     
+                {
+                    if(st_len==n)  
+                    {
+                        ed[1]=m; bit.insert(1,1); st_len=0; ed_len-=m;
+                        printf("%d\n",1);
+                    }
+                    else            
+                    {
+                        int tmp=calu(1,st_len,m,a,b);     
+                        ed[tmp]=tmp+m-1; bit.insert(tmp,1); 
+                        printf("%d\n",tmp);
+                        int len,st;
+                        if(judge(ed[tmp]+1,st_len,len,st)) seg.updata(len,st,1,1,1,n);    
+                        st_len=tmp-1;                     
+                    }
+                }
+                else
+                {
+                    pair<int,int> res=seg.query(m,m+a+b,1,1,n);
+                    if(res.first!=INF)
+                    {
+                        seg.updata(res.second,res.first,0,1,1,n); 
+                        int tmp=calu(res.first,res.second,m,a,b);  
+                        ed[tmp]=tmp+m-1;  bit.insert(tmp,1);        
+                        printf("%d\n",tmp);
+                        int len,st;
+                        if(judge(res.first,tmp-1,len,st))     seg.updata(len,st,1,1,1,n);        
+                        if(judge(ed[tmp]+1,res.first+res.second-1,len,st))     seg.updata(len,st,1,1,1,n);
+                    }
+                    else
+                    {
+                        if(ed_len<m) puts("-1");
+                        else
+                        {
+                            int tmp=n-ed_len+1;
+                            ed[tmp]=tmp+m-1; ed_len=n-ed[tmp];    bit.insert(tmp,1);
+                            printf("%d\n",tmp);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                int k; scanf("%d",&k);
+                if(k>bit.getsum()||k<=0) continue;  
+                int st=bit.query(k);                 
+                int st1=1;
+                if(k>1) st1=ed[bit.query(k-1)]+1;    
+                int len1=st-st1;                    
+                if(len1>0&&st1!=1) seg.updata(len1,st1,0,1,1,n);    
+                int st2=bit.query(k+1)-1,len2;        
+                if(st2>n) len2=0,st2=n;
+                else len2=st2-ed[st];
+                if(len2>0&&!(st2==n)) seg.updata(len2,ed[st]+1,0,1,1,n);
+                if(st1!=1&&st2!=n) seg.updata(st2-st1+1,st1,1,1,1,n);
+                if(st1==1) st_len=st2-st1+1;
+                if(st2==n) ed_len=st2-st1+1;            
+                bit.insert(st,-1);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3951_autoAC.cpp b/HDOJ/3951_autoAC.cpp
new file mode 100644
index 0000000..16d2f43
--- /dev/null
+++ b/HDOJ/3951_autoAC.cpp
@@ -0,0 +1,18 @@
+#include<iostream>
+#include<cstdlib>
+#include<stdio.h>
+using namespace std;
+int main()
+{
+    int t,n,k;
+    int count=1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&k);
+        printf("Case %d: ",count++);
+        if(k==1&&(n%2==1)) puts("first");
+        else if(n<=k) puts("first");
+        else puts("second");
+    }
+}
diff --git a/HDOJ/3952_autoAC.cpp b/HDOJ/3952_autoAC.cpp
new file mode 100644
index 0000000..3610136
--- /dev/null
+++ b/HDOJ/3952_autoAC.cpp
@@ -0,0 +1,104 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-8;
+const double pi = acos(-1.0);
+struct Point {
+    double x, y;
+    Point operator - (const Point& t) const {
+        Point tmp;
+        tmp.x = x - t.x;
+        tmp.y = y - t.y;
+        return tmp;
+    }
+    Point operator + (const Point& t) const {
+        Point tmp;
+        tmp.x = x + t.x;
+        tmp.y = y + t.y;
+        return tmp;
+    }
+    bool operator == (const Point& t) const {
+        return fabs(x-t.x) < eps && fabs(y-t.y) < eps;
+    }
+}; 
+struct pol{
+    Point node[11];
+    int num;
+}P[11];
+inline double Cross(Point a, Point b, Point c) {                   
+    return (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y); 
+}
+bool dotOnSeg(Point p, Point s, Point e) {                            
+    if ( p == s || p == e )        // 蜂电规娉
+        return true;
+    return Cross(p,s,e) < eps && 
+        (p.x-s.x)*(p.x-e.x)<eps && (p.y-s.y)*(p.y-e.y)<eps;
+}
+struct Line {
+    double a, b, c;
+};
+Line Turn(Point s, Point e) {                                       
+    Line ln;
+    ln.a = s.y - e.y;
+    ln.b = e.x - s.x;
+    ln.c = s.x*e.y - e.x*s.y;
+    return ln;
+}
+bool Line_Inst(Line l1, Line l2, Point &p) {                        
+    double d = l1.a*l2.b - l2.a*l1.b;
+    if ( fabs(d) < eps )    return false;
+    p.x = (-l1.c*l2.b + l2.c*l1.b) / d;
+    p.y = (-l1.a*l2.c + l2.a*l1.c) / d;
+    return true; 
+}
+int main()
+{
+    int t,i,j,k,cases=1;
+    scanf("%d",&t);
+    int x,y,m,n,ans;
+    while(t--)
+    {
+         scanf("%d",&n);
+         for(i=1;i<=n;i++)
+         {
+             scanf("%d",&P[i].num);
+             for(j=1;j<=P[i].num;j++)
+                  scanf("%lf%lf",&P[i].node[j].x,&P[i].node[j].y);
+         }
+     if(n<=2){ printf("Case %d: %d\n",cases++,n);continue;}
+     Point p;
+     int max=0;
+         for(i=1;i<=n;i++)
+         {
+             for(j=i+1;j<=n;j++)
+             {
+                 for(k=1;k<=P[i].num;k++)
+                 {
+                     for(m=1;m<=P[j].num;m++)
+                     {   
+                         ans=2;                   
+                         Line a=Turn(P[i].node[k],P[j].node[m]) ;
+                         for(x=1;x<=n;x++)
+                         {
+                             if(x==i||x==j) continue;
+                             for(y=1;y<P[x].num;y++)
+                             {
+                                 Line b=Turn(P[x].node[y],P[x].node[y+1]);
+                                 if(Line_Inst(a,b,p)&&dotOnSeg(p,P[x].node[y],P[x].node[y+1]))    
+                                 {
+                                     ans++;
+                                     break;
+                                 }
+                             }
+                         }
+                         if(ans>max) max=ans;
+                     }
+                 }
+             }
+         }
+         printf("Case %d: %d\n",cases++,max);
+    }
+    return 0;
+}
diff --git a/HDOJ/3954_autoAC.cpp b/HDOJ/3954_autoAC.cpp
new file mode 100644
index 0000000..a3e6fde
--- /dev/null
+++ b/HDOJ/3954_autoAC.cpp
@@ -0,0 +1,139 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+#define LL(x) (x<<1)
+#define RR(x) (x<<1|1)
+#define MID(a,b) (a+((b-a)>>1))
+#define INF (1<<30)
+const int N=10000+5;
+typedef long long LL;
+struct node
+{
+    int lft,rht;
+    LL level,mx,flag,need;
+    int mid(){return MID(lft,rht);}
+    void init(){level=1;mx=0;flag=0;}
+    void fun(LL valu)
+    {
+        mx+=level*valu;
+        need-=valu;
+        flag+=valu;
+    }
+};
+int n,m,k;
+LL ned[12];
+struct Segtree
+{
+    node tree[N*4];
+    void down(int ind)
+    {
+        if(tree[ind].flag)
+        {
+            tree[LL(ind)].fun(tree[ind].flag);
+            tree[RR(ind)].fun(tree[ind].flag);
+            tree[ind].flag=0;
+        }
+    }
+    void up(int ind)
+    {
+        tree[ind].mx=max(tree[LL(ind)].mx,tree[RR(ind)].mx);
+        tree[ind].level=max(tree[LL(ind)].level,tree[RR(ind)].level);
+        tree[ind].need=min(tree[LL(ind)].need,tree[RR(ind)].need);
+    }
+    void build(int lft,int rht,int ind)
+    {
+        tree[ind].lft=lft;    tree[ind].rht=rht;
+        tree[ind].init();     tree[ind].need=ned[2];
+        if(lft!=rht)
+        {
+            int mid=tree[ind].mid();
+            build(lft,mid,LL(ind));
+            build(mid+1,rht,RR(ind));
+        }
+    }
+    void updata(int st,int ed,int ind,int valu)
+    {
+        int lft=tree[ind].lft,rht=tree[ind].rht;
+        if(st<=lft&&rht<=ed)
+        {
+            if(valu>=tree[ind].need)
+            {
+                if(lft==rht)
+                {
+                    LL &now=tree[ind].level;
+                    tree[ind].mx+=now*valu;
+                    while(tree[ind].mx>=ned[now+1]) now++;
+                    LL tmp=ned[now+1]-tree[ind].mx;
+                    tree[ind].need=tmp/now+(tmp%now!=0);
+                }
+                else 
+                {
+                    down(ind);
+                    int mid=tree[ind].mid();
+                    if(st<=mid) updata(st,ed,LL(ind),valu);
+                    if(ed> mid) updata(st,ed,RR(ind),valu);
+                    up(ind);
+                }
+            }
+            else 
+            {
+                tree[ind].fun(valu);
+            }
+        }
+        else 
+        {
+            down(ind);
+            int mid=tree[ind].mid();
+            if(st<=mid) updata(st,ed,LL(ind),valu);
+            if(ed> mid) updata(st,ed,RR(ind),valu);
+            up(ind);
+        }
+    }
+    LL query(int st,int ed,int ind)
+    {
+        int lft=tree[ind].lft,rht=tree[ind].rht;
+        if(st<=lft&&rht<=ed) return tree[ind].mx;
+        else 
+        {
+            down(ind);
+            int mid=tree[ind].mid();
+            LL mx1=0,mx2=0;
+            if(st<=mid) mx1=query(st,ed,LL(ind));
+            if(ed> mid) mx2=query(st,ed,RR(ind));
+            up(ind);
+            return max(mx1,mx2);
+        }
+    }
+}seg;
+int main()
+{
+    int t,t_cnt=0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d%d",&n,&k,&m);
+        ned[1]=0; ned[k+1]=((LL)1<<60);
+        for(int i=2;i<=k;i++) scanf("%I64d",&ned[i]);
+        printf("Case %d:\n",++t_cnt);
+        seg.build(1,n,1);
+        while(m--)
+        {
+            char cmd[5];
+            int a,b,c;
+            scanf("%s",cmd);
+            if(cmd[0]=='W')
+            {
+                scanf("%d%d%d",&a,&b,&c);
+                seg.updata(a,b,1,c);
+            }
+            else 
+            {
+                scanf("%d%d",&a,&b);
+                printf("%I64d\n",seg.query(a,b,1));
+            }
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/3955_autoAC.cpp b/HDOJ/3955_autoAC.cpp
new file mode 100644
index 0000000..e1d4ba7
--- /dev/null
+++ b/HDOJ/3955_autoAC.cpp
@@ -0,0 +1,145 @@
+# include<stdio.h>
+# include<string.h>
+# include<stdlib.h>
+# include<queue>
+# define N 105 
+using namespace std; 
+int n,m,MP; 
+bool map[N][N][10]; 
+bool visit[N][N]; 
+int x0,y0,endx,endy; 
+int dir1[6][2]={-1,1, 0,1, 1,1, 1,0, 0,-1, -1,0};
+int dir2[6][2]={-1,0, 0,1, 1,0, 1,-1, 0,-1, -1,-1};
+struct node{
+    int x,y;
+    int sum;
+    bool operator<(const node &b) const
+    {
+        return b.sum <  sum; 
+    } 
+};
+int MIN(int a,int b)
+{
+    return a<b?a:b;
+}
+bool is(int xx,int yy)
+{
+    if(xx<0 || xx>=n || yy<0 || yy>=m) return 0;
+    return 1; 
+} 
+bool is1(int xx,int yy)
+{
+    int i,x1,y1; 
+    if(xx%2==1)
+    {
+        for(i=0;i<6;i++)
+        {
+            x1=xx+dir1[i][0];
+            y1=yy+dir1[i][1];
+            if(is(x1,y1) && map[x1][y1][3]) return 1; 
+        } 
+        return 0; 
+    } 
+    else
+    {
+        for(i=0;i<6;i++)
+        {
+            x1=xx+dir2[i][0];
+            y1=yy+dir2[i][1];
+            if(is(x1,y1) && map[x1][y1][3]) return 1; 
+        } 
+        return 0;
+    } 
+} 
+int bfs()
+{
+    priority_queue<node>q;
+    node cur,next;
+    int i,cost,remain;
+    cur.x=x0;
+    cur.y=y0;
+    cur.sum=0;
+    while(!q.empty()) q.pop(); 
+    q.push(cur); 
+    while(!q.empty())
+    {
+        cur=q.top();
+        q.pop();
+        remain=MP-cur.sum%MP;
+        if(cur.x==endx && cur.y==endy) 
+        {
+            if(remain==MP) return cur.sum/MP;
+            else return cur.sum/MP+1; 
+        } 
+        if(visit[cur.x][cur.y]) continue;
+        visit[cur.x][cur.y]=1; 
+        for(i=0;i<6;i++)
+        {
+            if(cur.x%2==1)
+            {
+                next.x=cur.x+dir1[i][0];
+                next.y=cur.y+dir1[i][1]; 
+            } 
+            else
+            {
+                next.x=cur.x+dir2[i][0];
+                next.y=cur.y+dir2[i][1]; 
+            } 
+            if(!(is(next.x,next.y)) || map[next.x][next.y][3]) continue;
+            if(is1(cur.x,cur.y) && is1(next.x,next.y)) 
+            {
+                next.sum=cur.sum+remain;
+                q.push(next);
+            }
+            else if(map[cur.x][cur.y][2] && map[next.x][next.y][2])
+            {
+                next.sum=cur.sum+1;
+                q.push(next);
+            }
+            else if(map[cur.x][cur.y][i+4])
+            {
+                next.sum=cur.sum+remain;
+                q.push(next);
+            }
+            else 
+            {
+                if(map[next.x][next.y][0]) cost=1;
+                else cost=2;
+                cost *=4;
+                next.sum=cur.sum+MIN(cost,remain);
+                q.push(next);
+            }
+        } 
+    } 
+    return -1;
+} 
+int main()
+{
+    int i,j,ncase,t,k;
+    int a[10],ans;
+    a[0]=1;
+    for(i=1;i<10;i++)
+    a[i]=a[i-1]*2; 
+    scanf("%d",&ncase);
+    for(t=1;t<=ncase;t++)
+    {
+        scanf("%d%d%d",&n,&m,&MP);
+        MP*=4;
+        memset(map,0,sizeof(map)); 
+        for(i=0;i<n;i++)
+        for(j=0;j<m;j++)
+        { 
+            scanf("%d",&ans); 
+            for(k=9;k>=0;k--)
+            if(ans>=a[k])
+            {
+                map[i][j][k]=1;
+                ans-=a[k]; 
+            }  
+        } 
+        scanf("%d%d%d%d",&x0,&y0,&endx,&endy); 
+        memset(visit,0,sizeof(visit)); 
+        printf("Case %d: %d\n",t,bfs()); 
+    } 
+    return 0; 
+}
diff --git a/HDOJ/3957_autoAC.cpp b/HDOJ/3957_autoAC.cpp
new file mode 100644
index 0000000..2574ba4
--- /dev/null
+++ b/HDOJ/3957_autoAC.cpp
@@ -0,0 +1,151 @@
+# include<stdio.h>
+# include<string.h>
+# define cc 100
+# define rr 60
+# define V 6000
+int U[V],D[V];
+int L[V],R[V];
+int C[V],ROW[V];
+int H[rr],S[cc];
+int mark[rr],visit[27],size,ak;
+struct node{
+    int m;
+    int num1,num2;
+    int a[11][2],b[11][2];
+}s[27];
+void Link(int r,int c)
+{
+    S[c]++;
+    C[size]=c;
+    ROW[size]=r;
+    U[size]=U[c];D[U[c]]=size;
+    D[size]=c;U[c]=size;
+    if(H[r]==-1) H[r]=L[size]=R[size]=size;
+    else
+    {
+        L[size]=L[H[r]];R[L[H[r]]]=size;
+        R[size]=H[r];L[H[r]]=size;
+    }
+    size++;
+}
+void remove(int c)
+{
+    int i;
+    for(i=D[c];i!=c;i=D[i])
+    {
+        L[R[i]]=L[i];
+        R[L[i]]=R[i];
+    }
+}
+void resume(int c)
+{
+    int i;
+    for(i=U[c];i!=c;i=U[i])
+        L[R[i]]=R[L[i]]=i;
+}
+int h()
+{
+    int i,j,k,count=0;
+    bool hash[cc];
+    memset(hash,0,sizeof(hash));
+    for(i=R[0];i;i=R[i])
+    {
+        if(hash[i]) continue;
+        hash[i]=1;
+        count++;
+        for(j=D[i];j!=i;j=D[j])
+            for(k=R[j];k!=j;k=R[k])
+                hash[C[k]]=1;
+    }
+    return count;
+}
+void Dance(int k)
+{
+    int j,i,c,Min;
+    if(k+h()>=ak) return;
+    if(!R[0]) 
+    {
+        if(k<ak) ak=k;
+        return;
+    }
+    for(Min=rr,i=R[0];i;i=R[i])
+        if(Min>S[i]) Min=S[i],c=i;
+    for(i=D[c];i!=c;i=D[i])
+    {
+        if(visit[mark[ROW[i]]]) continue;
+        visit[mark[ROW[i]]]=1;
+        remove(i);
+        for(j=R[i];j!=i;j=R[j])
+            remove(j);
+        Dance(k+1);
+        for(j=L[i];j!=i;j=L[j])
+            resume(j);
+        resume(i);
+        visit[mark[ROW[i]]]=0;
+    }
+}
+int main()
+{
+    int i,j,ncase,t,n,sum[26],number,mob,k,c,r;
+    scanf("%d",&ncase);
+    for(t=1;t<=ncase;t++)
+    {
+        scanf("%d",&n);
+        sum[0]=1;
+        for(i=0;i<n;i++)
+        {
+            scanf("%d",&s[i].m);
+            scanf("%d",&s[i].num1);
+            for(k=0;k<s[i].num1;k++)
+                scanf("%d%d",&s[i].a[k][0],&s[i].a[k][1]);
+            if(s[i].m==2)
+            {
+                scanf("%d",&s[i].num2);
+                for(k=0;k<s[i].num2;k++)
+                    scanf("%d%d",&s[i].b[k][0],&s[i].b[k][1]);
+            }
+            sum[i+1]=sum[i]+s[i].m;
+        }
+        c=sum[n]-1;
+        for(i=0;i<=c;i++)
+        {
+            S[i]=0;
+            U[i]=D[i]=i;
+            L[i+1]=i;R[i]=i+1;
+        }R[c]=0;
+        size=c+1;
+        r=0;
+        memset(H,-1,sizeof(H));
+        for(i=0;i<n;i++)
+        {
+            r++;
+            mark[r]=i;
+            for(j=0;j<s[i].num1;j++)
+            {
+                number=s[i].a[j][0];
+                mob=s[i].a[j][1];
+                Link(r,sum[number]+mob);
+            }
+            for(j=0;j<s[i].m;j++)
+                Link(r,sum[i]+j);
+            if(s[i].m==2)
+            {
+                r++;
+                mark[r]=i;
+                for(j=0;j<s[i].num2;j++)
+                {
+                    number=s[i].b[j][0];
+                    mob=s[i].b[j][1];
+                    Link(r,sum[number]+mob);
+                }
+                for(j=0;j<s[i].m;j++)
+                    Link(r,sum[i]+j);
+            }
+        }
+        memset(visit,0,sizeof(visit));
+        ak=n;
+        Dance(0);
+        printf("Case %d: %d\n",t,ak);
+    }
+    return 0;
+}
diff --git a/HDOJ/3958_autoAC.cpp b/HDOJ/3958_autoAC.cpp
new file mode 100644
index 0000000..4fcea04
--- /dev/null
+++ b/HDOJ/3958_autoAC.cpp
@@ -0,0 +1,315 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <queue>
+#include <algorithm>
+#include <vector>
+#include <cstring>
+#include <stack>
+#include <cctype>
+#include <utility>   
+#include <map>
+#include <string>  
+#include <climits> 
+#include <set>
+#include <string>    
+#include <sstream>
+#include <utility>   
+#include <ctime>
+using std::priority_queue;
+using std::vector;
+using std::swap;
+using std::stack;
+using std::sort;
+using std::max;
+using std::min;
+using std::pair;
+using std::map;
+using std::string;
+using std::cin;
+using std::cout;
+using std::set;
+using std::queue;
+using std::string;
+using std::stringstream;
+using std::make_pair;
+using std::getline;
+using std::greater;
+using std::endl;
+using std::multimap;
+using std::deque;
+using std::random_shuffle;
+typedef long long LL;
+typedef unsigned long long ULL;
+typedef pair<int, int> PAIR;
+typedef multimap<int, int> MMAP;
+typedef LL TY;
+const int MAXN(10010);
+const int MAXM(5010);
+const int MAXE(10010);
+const int MAXK(6);
+const int HSIZE(13131);
+const int SIGMA_SIZE(26);
+const int MAXH(19);
+const int INFI((INT_MAX-1) >> 1);
+const ULL BASE(31);
+const LL LIM(10000000);
+const int INV(-10000);
+const int MOD(65521);
+template<typename T> void checkmax(T &a, T b){if(b > a) a = b;}
+template<typename T> void checkmin(T &a, T b){if(b < a) a = b;}
+template<typename T> T ABS(const T &a){return a < 0? -a: a;}
+int pre[21][10][MAXN], opt[21][10][MAXN];
+int MM;
+struct HASH_MAP
+{
+    int first[HSIZE], value[MAXN], next[MAXN];
+    LL state[MAXN];
+    int size;
+    void init()
+    {
+        memset(first, -1, sizeof(first));
+        size = 0;
+    }
+    void insert(LL ts, int tv, int x, int y, int pid, int op)
+    {
+        int h = ts%HSIZE;
+        for(int i = first[h]; ~i; i = next[i])
+            if(state[i] == ts)
+            {
+                if(tv > value[i])
+                {
+                    pre[x][y][i] = pid;
+                    opt[x][y][i] = op;
+                    value[i] = tv;
+                }
+                return ;
+            }
+        checkmax(MM, size);
+        pre[x][y][size] = pid;
+        opt[x][y][size] = op;
+        state[size] = ts;
+        value[size] = tv;
+        next[size] = first[h];
+        first[h] = size++;
+    }
+} hm[2];
+HASH_MAP *cur, *last;
+int N, M;
+int code[11], path[11];  
+int Num[8];
+char mp[21][15];
+void decode(LL ts)
+{
+    for(int i = 0; i <= M; ++i)
+    {
+        code[i] = ts&7;
+        path[i] = ts&8;
+        ts >>= 4;
+    }
+}
+LL encode()
+{
+    LL ret = 0;
+    memset(Num, -1, sizeof(Num));
+    int cnt = 0;
+    for(int i = M; i >= 0; --i)
+        if(code[i] == 0)
+            ret = (ret << 4)|path[i];
+        else
+        {
+            if(Num[code[i]] == -1) Num[code[i]] = ++cnt;
+            ret = (ret << 4)|Num[code[i]]|path[i];
+        }
+    return ret;
+}
+void updata(int x, int y, int tv, int pid)
+{
+    int lc = (y == 0)? 0: code[y];
+    int uc = (x == 0)? 0: code[y+1];
+    int lp = (y == 0)? 0: path[y-1];
+    int up = (x == 0)? 0: path[y+1];
+    if(mp[x][y] == 'S' || mp[x][y] == 'T')
+    {
+        if(lc == 0 && uc == 0)
+        {
+            if(lp || up) return;
+            if(x < N-1)
+            {
+                path[y] = 8;
+                code[y] = 7;
+                code[y+1] = 0;
+                cur->insert(encode(), tv+1, x, y, pid, 1);
+            }
+            if(y < M-1)
+            {
+                path[y] = 8;
+                code[y] = 0;
+                code[y+1] = 7;
+                cur->insert(encode(), tv+1, x, y, pid, 1);
+            }
+        }
+        else
+            if(lc == 0 || uc == 0)
+            {
+                if(lc)
+                {
+                    if(up) return;
+                    path[y] = 8;
+                    code[y] = code[y+1] = 0;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+                else
+                {
+                    if(lp) return;
+                    path[y] = 8;
+                    code[y] = code[y+1] = 0;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+            }
+        return;
+    }
+    if(mp[x][y] == 'B')
+    {
+        if(lc == 0 && uc == 0)
+        {
+            path[y] = 0;
+            code[y] = code[y+1] = 0;
+            cur->insert(encode(), tv, x, y, pid, 0);
+        }
+        return;
+    }
+    if(lc == 0 && uc == 0)
+    {
+        path[y] = 0;
+        code[y] = code[y+1] = 0;
+        cur->insert(encode(), tv, x, y, pid, 0);
+        if(x == N-1 || y == M-1) return;
+        if(lp || up) return;
+        path[y] = 8;
+        code[y] = code[y+1] = 7;
+        cur->insert(encode(), tv+1, x, y, pid, 1);
+    }
+    else
+        if(lc == 0 || uc == 0)
+        {
+            if(lc)
+            {
+                if(up) return;
+                if(x < N-1)
+                {
+                    path[y] = 8;
+                    code[y] = lc;
+                    code[y+1] = 0;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+                if(y < M-1)
+                {
+                    path[y] = 8;
+                    code[y] = 0;
+                    code[y+1] = lc;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+            }
+            else
+            {
+                if(lp) return;
+                if(x < N-1)
+                {
+                    path[y] = 8;
+                    code[y] = uc;
+                    code[y+1] = 0;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+                if(y < M-1)
+                {
+                    path[y] = 8;
+                    code[y] = 0;
+                    code[y+1] = uc;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+            }
+        }
+        else
+            if(lc != uc)
+            {
+                path[y] = 8;
+                for(int i = 0; i <= M; ++i)
+                    if(code[i] == uc) code[i] = lc;
+                code[y] = code[y+1] = 0;
+                cur->insert(encode(), tv+1, x, y, pid, 1);
+            }
+}
+void solve()
+{
+    cur = hm;
+    last = hm+1;
+    last->init();
+    last->insert(0, 0, 0, 0, 0, 0);
+    for(int i = 0; i < N; ++i)
+    {
+        int sz = last->size;
+        for(int j = 0; j < sz; ++j)
+            last->state[j] <<= 4;
+        for(int j = 0; j < M; ++j)
+        {
+            cur->init();
+            sz = last->size;
+            for(int k = 0; k < sz; ++k)
+            {
+                decode(last->state[k]);
+                updata(i, j, last->value[k], k);
+            }
+            swap(cur, last);
+        }
+    }
+    int ans = 0, id;
+    for(int i = 0; i < last->size; ++i)
+    {
+        decode(last->state[i]);
+        bool flag(true);
+        for(int j = 0; j <= M; ++j)
+            if(code[j])
+            {
+                flag = false;
+                break;
+            }
+        if(flag)
+        {
+            if(last->value[i] > ans)
+            {
+                ans = last->value[i];
+                id = i;
+            }
+        }
+    }
+    for(int i = 0; i < N; ++i)
+        for(int j = 0; j < M; ++j)
+            if(mp[i][j] == '.')
+                mp[i][j] = 'W';
+    for(int i = N-1; i >= 0; --i)
+        for(int j = M-1; j >= 0; --j)
+        {
+            if(mp[i][j] == 'W' && opt[i][j][id]) mp[i][j] = '.';
+            id = pre[i][j][id];
+        }
+    printf("%d\n", ans);
+    for(int i = 0; i < N; ++i)
+        printf("%s\n", mp[i]);
+    printf("\n");
+}
+int main()
+{
+    int TC, n_case(0);
+    scanf("%d", &TC);
+    while(TC--)
+    {
+        scanf("%d%d", &N, &M);
+        for(int i = 0; i < N; ++i)
+            scanf("%s", mp[i]);
+        printf("Case %d: ", ++n_case);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3959_autoAC.cpp b/HDOJ/3959_autoAC.cpp
new file mode 100644
index 0000000..74354fc
--- /dev/null
+++ b/HDOJ/3959_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<stdio.h>
+long long gcd(long long a,long long b)
+{
+    if(b==0) return a;
+    return gcd(b,a%b);
+}
+int main()
+{
+    int s,m,n,i,j,count=1;
+    long long sum,t;
+    scanf("%d",&s);
+    while(s--)
+    {
+        sum=1;
+        scanf("%d %d",&n,&m);
+        for(i=1;i<=110;i++)
+        {
+            sum=sum*m;
+            if(sum>=n) break;
+        }
+        sum=sum*i;
+        t=gcd(sum,n);
+        sum=sum/t;n=n/t;
+        printf("Case %d: %lld/%d\n",count++,sum,n);
+    }
+    return 0;
+}
diff --git a/HDOJ/3961_autoAC.cpp b/HDOJ/3961_autoAC.cpp
new file mode 100644
index 0000000..1db4a6e
--- /dev/null
+++ b/HDOJ/3961_autoAC.cpp
@@ -0,0 +1,125 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+#define sqr(x) ((x)*(x))
+using namespace std;
+typedef long long ll;
+const double eps=1e-9;
+const double pi=acos(-1.0);
+struct point
+{
+    double x, y;
+    point() {}
+    point(double xx, double yy):x(xx), y(yy) {}
+    point operator + (const point &a) const
+    {
+        return point(x+a.x, y+a.y);
+    }
+    point operator - (const point &a) const
+    {
+        return point(x-a.x, y-a.y);
+    }
+} po[105], cen, s, e, tp[105];
+double r;
+int t1, t2, t;
+int n, pn;
+point cg()
+{
+    point p, s, re;
+    re.x=0.0;
+    re.y=0.0;
+    double area=0.0, ar;
+    p=po[0];
+    po[n]=po[0];
+    for(int i=1; i<=n; i++)
+    {
+        s=po[i];
+        ar=p.x*s.y-s.x*p.y;
+        area+=(ar/2);
+        re.x+=(p.x+s.x)*ar;
+        re.y+=(p.y+s.y)*ar;
+        p=s;
+    }
+    re.x/=(6*area);
+    re.y/=(6*area);
+    return re;
+}
+point pointrotate(point o, double ang, point p)
+{
+    point tp;
+    p.x-=o.x;
+    p.y-=o.y;
+    tp.x=p.x*cos(ang)-p.y*sin(ang)+o.x;
+    tp.y=p.y*cos(ang)+p.x*sin(ang)+o.y;
+    return tp;
+}
+double dis(point a, point b)
+{
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+double dot(point sp, point ep, point op)
+{
+    return (sp.x-op.x)*(ep.x-op.x)+(sp.y-op.y)*(ep.y-op.y);
+}
+double cross(point sp, point ep, point op)
+{
+    return (sp.x-op.x)*(ep.y-op.y)-(sp.y-op.y)*(ep.x-op.x);
+}
+double coverdeg(double ang, double d, double r)
+{
+    double neg=1;
+    if(ang<0)
+    {
+        ang=-ang;
+        neg=-1;
+    }
+    double sina=d*sin(ang)/r;
+    if(sina>1)sina=1;
+    return neg*(asin(sina)-ang);
+}
+int main ()
+{
+    int i;
+    while(~scanf("%lf%lf%lf%lf%lf%d%d%d%d", &s.x, &s.y, &e.x, &e.y, &r, &n, &t1, &t2, &t))
+    {
+        for(i=0; i<n; i++)scanf("%lf%lf", &po[i].x, &po[i].y);
+        cen=cg();
+        double a2=(double)(t%t2)/t2*2*pi;
+        for(i=0; i<n; i++)po[i]=pointrotate(cen, a2, po[i]);
+        double a1=(double)(t%t1)/t1*2*pi;
+        point newcen=pointrotate(e, a1, cen);
+        point mov=newcen-cen;
+        for(i=0; i<n; i++)po[i]=po[i]+mov;
+        double se=dis(s, e);
+        double maxang=acos(r/se);
+        double maxarc=2*maxang*r;
+        if(dot(s, newcen, e)<0)
+        {
+            printf("%.2lf\n", maxarc);
+            continue;
+        }
+        double supang=pi*0.5-maxang;
+        point up=po[0], lp=po[0];
+        for(int i=1; i<n; i++)
+        {
+            if(cross(up, po[i], s)>eps)up=po[i];
+            if(cross(lp, po[i], s)<-eps)lp=po[i];
+        }
+        double ua=acos(dot(up, e, s)/(se*dis(s, up)));
+        double la=acos(dot(lp, e, s)/(se*dis(s, lp)));
+        if(cross(e, up, s)<0)ua=-ua;
+        if(cross(e, lp, s)<0)la=-la;
+        double cvua=min(supang, ua), cvla=max(-supang, la);
+        if(cvua<cvla)
+        {
+            printf("%.2lf\n", maxarc);
+            continue;
+        }
+        double coverarc=r*(coverdeg(cvua, se, r)-coverdeg(cvla, se, r));
+        printf("%.2lf\n", maxarc-coverarc);
+    }
+    return 0;
+}
diff --git a/HDOJ/3962_autoAC.cpp b/HDOJ/3962_autoAC.cpp
new file mode 100644
index 0000000..541873e
--- /dev/null
+++ b/HDOJ/3962_autoAC.cpp
@@ -0,0 +1,135 @@
+#include <stdio.h>
+#include <string.h>
+#define MAX 40
+#define MOD 10007
+char dir[MAX];
+int hash[256],n,m,total;
+struct node {
+    int flag,in;
+    node *fail,*next[4];
+}*qu[MAX*MAX],arr[MAX*MAX],*root;
+node *CreateNode() {
+    node *p = &arr[total];
+    p->in = total++;
+    p->flag = 0;
+    p->fail = NULL;
+    for (int i = 0; i < 4; ++i)
+        p->next[i] = NULL;
+    return p;
+}
+void Insert(char *str) {
+    int i = 0,k;
+    node *p = root;
+    while (str[i]) {
+        k = hash[str[i++]];
+        if (p->next[k] == NULL)
+            p->next[k] = CreateNode();
+        p = p->next[k];
+    }
+    p->flag = 1;
+}
+void Build_AC() {
+    int head,tail,i;
+    head = tail = 0;
+    root->fail = root;
+    qu[++head] = root;
+    while (tail < head) {
+        node *p = qu[++tail];
+        for (i = 0; i < 4; ++i) {
+            if (p->next[i] != NULL) {
+                if (p == root) p->next[i]->fail = root;
+                else p->next[i]->fail = p->fail->next[i];
+                qu[++head] = p->next[i];
+                p->next[i]->flag |= p->fail->next[i]->flag;
+            }
+            else {
+                if (p == root) p->next[i] = root;
+                else p->next[i] = p->fail->next[i];
+            }//else
+        }//for
+    }//while
+}//void
+struct Mat{
+    int mat[MAX*2][MAX*2],size;
+    Mat(int n) {size = n,memset(mat,0,sizeof(mat));}
+    Mat(int arr[][MAX*2],int n) { size = n,memcpy(mat,arr,sizeof(arr));}
+    friend Mat operator *(Mat a,Mat b);
+    friend Mat operator +(Mat a,Mat b);
+    friend Mat operator ^(Mat a,int k);
+    friend Mat Sum(Mat a,int k);
+}A(MAX*2),E(MAX*2);
+Mat operator *(Mat a,Mat b) {
+    Mat c(total*2);
+    for (int i = 0; i < c.size; ++i)
+        for (int j = 0; j < c.size; ++j)
+            for (int k = 0; k < c.size; ++k)
+                if (a.mat[i][k] && b.mat[k][j]) {
+                    c.mat[i][j] += a.mat[i][k] * b.mat[k][j];
+                    c.mat[i][j] %= MOD;
+                }
+    return c;
+}
+Mat operator +(Mat a,Mat b) {
+    Mat c(total*2);
+    for (int i = 0; i < c.size; ++i)
+        for (int j = 0; j < c.size; ++j)
+            c.mat[i][j] = (a.mat[i][j] + b.mat[i][j]) % MOD;
+    return c;
+}
+Mat operator ^(Mat a,int k) {
+    Mat c = E;
+    while (k) {
+        if (k & 1) c = c * a;
+        a = a * a,k >>= 1;
+    }
+    return c;
+}
+Mat Sum(Mat A,int k) {
+    if (k == 1) return A;
+    else if (k & 1) return (A^k) * Sum(A,k-1);
+    else return Sum(A,k/2) * ((A^(k/2)) + E);
+}
+void GetMat() {
+    int i,j,k;
+    Mat c(total*2);
+    for (i = 0; i < total; ++i) {
+        for (k = 0; k < 4; ++k) {
+            j = arr[i].next[k]->in;    
+            if (arr[i].next[k]->flag)
+                c.mat[i][j+total]++;
+            else c.mat[i][j]++,c.mat[i+total][j+total]++;
+        }
+    }
+    E = A = c;
+    memset(E.mat,0,sizeof(E.mat));
+    for (i = 0; i < E.size; ++i)
+        E.mat[i][i] = 1;
+}
+int Solve_1A() {
+    int i,j,k,ans,sum;
+    ans = 1,k = n,sum = 4;
+    while (k) {
+        if (k & 1) ans = (ans * sum) % MOD;
+        sum = (sum * sum) % MOD,k >>= 1;
+    }
+    A = A^n;
+    for (i = 0; i < 2 * total; ++i)
+        ans = (ans - A.mat[0][i] + MOD) % MOD;
+    return ans;
+}
+int main()
+{
+    int i,j,k,ans;
+    hash['A'] = 0,hash['T'] = 1;
+    hash['C'] = 2,hash['G'] = 3;
+    while (scanf("%d%d",&m,&n) != EOF) {
+        total = 0;
+        root = CreateNode();
+        for (i = 0; i < m; ++i)
+            scanf("%s",dir),Insert(dir);
+        Build_AC();
+        GetMat();
+        ans = Solve_1A();
+        printf("%d\n",ans % MOD);
+    }
+}
diff --git a/HDOJ/3964_autoAC.cpp b/HDOJ/3964_autoAC.cpp
new file mode 100644
index 0000000..66d3dc4
--- /dev/null
+++ b/HDOJ/3964_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<iostream>
+using namespace std;
+bool map[15][15];
+bool mark[15];
+int val[15];
+int n;
+void dfs(int index,int num,int j)
+{
+    int i;
+    if(num>1&&map[index][j])
+    {
+        for(int k=0;k<num;k++)
+            printf("%d",val[k]);
+        printf("\n");
+    }
+    for(i=j+1;i<n;i++)
+    {
+        if(mark[i]==0&&map[index][i])
+        {
+            mark[i]=1;
+            val[num]=i;
+            dfs(i,num+1,j);
+            mark[i]=0;
+        }
+    }
+}
+int main()
+{
+    int i,j,a;
+    //freopen("a.txt","r",stdin);
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                scanf("%d",&a);
+                if(a==0)map[i][j]=0;
+                else map[i][j]=1;
+            }
+        }
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<n;j++)
+                mark[j]=0;
+            mark[i]=1;
+            val[0]=i;
+            dfs(i,1,i);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3966_autoAC.cpp b/HDOJ/3966_autoAC.cpp
new file mode 100644
index 0000000..05044b4
--- /dev/null
+++ b/HDOJ/3966_autoAC.cpp
@@ -0,0 +1,161 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int MAXN = 50010;
+struct Edge
+{
+    int to,next;
+}edge[MAXN*2];
+int head[MAXN],tot;
+int top[MAXN];
+int fa[MAXN];
+int deep[MAXN];
+int num[MAXN];
+int p[MAXN];
+int fp[MAXN];
+int son[MAXN];
+int pos;
+void init()
+{
+    tot = 0;
+    memset(head,-1,sizeof(head));
+    pos = 1;
+    memset(son,-1,sizeof(son));
+}
+void addedge(int u,int v)
+{
+    edge[tot].to = v; edge[tot].next = head[u]; head[u] = tot++;
+}
+void dfs1(int u,int pre,int d)
+{
+    deep[u] = d;
+    fa[u] = pre;
+    num[u] = 1;
+    for(int i = head[u];i != -1; i = edge[i].next)
+    {
+        int v = edge[i].to;
+        if(v != pre)
+        {
+            dfs1(v,u,d+1);
+            num[u] += num[v];
+            if(son[u] == -1 || num[v] > num[son[u]])
+                son[u] = v;
+        }
+    }
+}
+void getpos(int u,int sp)
+{
+    top[u] = sp;
+    p[u] = pos++;
+    fp[p[u]] = u;
+    if(son[u] == -1) return;
+    getpos(son[u],sp);
+    for(int i = head[u];i != -1;i = edge[i].next)
+    {
+        int v = edge[i].to;
+        if( v != son[u] && v != fa[u])
+            getpos(v,v);
+    }
+}
+int lowbit(int x)
+{
+    return x&(-x);
+}
+int c[MAXN];
+int n;
+int sum(int i)
+{
+    int s = 0;
+    while(i > 0)
+    {
+        s += c[i];
+        i -= lowbit(i);
+    }
+    return s;
+}
+void add(int i,int val)
+{
+    while(i <= n)
+    {
+        c[i] += val;
+        i += lowbit(i);
+    }
+}
+void Change(int u,int v,int val)
+{
+    int f1 = top[u], f2 = top[v];
+    int tmp = 0;
+    while(f1 != f2)
+    {
+        if(deep[f1] < deep[f2])
+        {
+            swap(f1,f2);
+            swap(u,v);
+        }
+        add(p[f1],val);
+        add(p[u]+1,-val);
+        u = fa[f1];
+        f1 = top[u];
+    }
+    if(deep[u] > deep[v]) swap(u,v);
+    add(p[u],val);
+    add(p[v]+1,-val);
+}
+int a[MAXN];
+int main()
+{
+     int M,P;
+    while(scanf("%d%d%d",&n,&M,&P) == 3)
+    {
+        int u,v;
+        int C1,C2,K;
+        char op[10];
+        init();
+        for(int i = 1;i <= n;i++)
+        {
+            scanf("%d",&a[i]);
+        }
+        while(M--)
+        {
+            scanf("%d%d",&u,&v);
+            addedge(u,v);
+            addedge(v,u);
+        }
+        dfs1(1,0,0);
+        getpos(1,1);
+        memset(c,0,sizeof(c));
+        for(int i = 1;i <= n;i++)
+        {
+            add(p[i],a[i]);
+            add(p[i]+1,-a[i]);
+        }
+        while(P--)
+        {
+            scanf("%s",op);
+            if(op[0] == 'Q')
+            {
+                scanf("%d",&u);
+                printf("%d\n",sum(p[u]));
+            }
+            else
+            {
+                scanf("%d%d%d",&C1,&C2,&K);
+                if(op[0] == 'D')
+                    K = -K;
+                Change(C1,C2,K);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3967_autoAC.cpp b/HDOJ/3967_autoAC.cpp
new file mode 100644
index 0000000..56754f6
--- /dev/null
+++ b/HDOJ/3967_autoAC.cpp
@@ -0,0 +1,73 @@
+#include<stdio.h>
+#include<math.h>
+#include<iostream>
+using namespace std;
+__int64 a,b,k,num,dp[20][25],d[20][25],C[20],r[20][25],A[20];
+__int64 dfs(__int64 now,__int64 left)
+{
+    if(now<0) return 0;
+    __int64 sum=0,i,j,ii;
+    for(i=0;i<A[now];i++)
+        r[now][(left*10+i)%k]++;
+    for(j=0;j<k;j++)
+    {
+        for(i=0;i<10;i++)
+            r[now][(j*10+i)%k]+=r[now+1][j];
+        ii=r[now+1][j];
+        if(!j&&ii>0) ii--;
+        sum+=ii*dp[now][((k-j)%k+k)%k];
+    }
+    if(now!=num)
+        sum+=d[now][((k-left)%k+k)%k];
+    sum+=dfs(now-1,(left*10+A[now])%k);
+    return sum;
+}
+void dfs2()
+{
+    __int64 i,j,now;
+    memset(C,0,sizeof(C));
+    C[0]=1%k;
+    for(i=1;i<18;i++)
+        C[i]=(C[i-1]*10)%k;
+    for(i=0;i<=A[0];i++)
+        d[0][i%k]++;
+    for(now=1;now<=num;now++)
+    {
+        for(j=0;j<k;j++)
+        {
+            d[now][(A[now]*C[now]+j)%k]+=d[now-1][j];
+            for(i=0;i<A[now];i++)
+                d[now][(i*C[now]+j)%k]+=dp[now-1][j];
+        }
+    }
+}
+__int64 Cal(__int64 a)
+{
+    __int64 i=0;
+    while(a)
+    {
+        A[i++]=a%10;
+        a/=10;
+    }
+    num=i-1;
+    memset(d,0,sizeof(d));
+    memset(r,0,sizeof(r));
+    dfs2();
+    return dfs(num,0);
+}
+int main()
+{
+    __int64 i,j,ii;
+    while(scanf("%I64d%I64d%I64d",&a,&b,&k)!=EOF)
+    {
+        memset(dp,0,sizeof(dp));
+        for(i=0;i<10;i++)
+            dp[0][i%k]++;
+        for(i=1;i<18;i++)
+            for(ii=0;ii<k;ii++)
+                for(j=0;j<=9;j++)
+                    dp[i][(ii*10+j)%k]+=dp[i-1][ii];
+        printf("%I64d\n",Cal(b)-Cal(a-1));
+    }
+    return 0;
+}
diff --git a/HDOJ/3968_autoAC.cpp b/HDOJ/3968_autoAC.cpp
new file mode 100644
index 0000000..7dd0feb
--- /dev/null
+++ b/HDOJ/3968_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <string>
+#include <cstring>
+#include <set>
+#include <map>
+#include <cstdio>
+#include <queue>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define forn(i, n) for(int i = 0; i < (int)(n); i++)
+#define clr(a, b) memset(a, b, sizeof(a))
+#define SZ(a) ((int)a.size())
+#define PB push_back
+#define MP make_pair
+#define inf 0x3f3f3f3f
+typedef vector<int> vi;
+typedef pair<int, int> pii;
+typedef long long ll;
+#ifdef ecust
+#define R "%lld"
+#else
+#define R "%I64d"
+#endif
+namespace acm {
+double x0, y0, x1, y1;
+double vx, vy;
+double t;
+double fun(double x){
+    return 1.0/9.8*(x/2*sqrt(x*x+vx*vx)+vx*vx/2*log(x+sqrt(x*x+vx*vx)));
+}
+void solve(){
+    scanf("%lf%lf%lf%lf%lf", &x0, &y0, &x1, &y1, &t);
+    if(fabs(t) <= 1e-8) {puts("Impossible."); return;}
+    vx = ((x1 - x0))/t;
+    vy = ((y1 - y0) + 0.5*9.8*t*t)/t;
+    printf("%.3lf\n", fun(vy)-fun(vy-9.8*t));
+}
+void icpc(){
+    int cas; scanf("%d", &cas);
+    while(cas--){
+        solve();
+    }
+}
+}
+int main() {
+    acm::icpc();
+    return 0;
+}
diff --git a/HDOJ/3969_autoAC.cpp b/HDOJ/3969_autoAC.cpp
new file mode 100644
index 0000000..d654912
--- /dev/null
+++ b/HDOJ/3969_autoAC.cpp
@@ -0,0 +1,277 @@
+#include <iostream>
+#include <map>
+#include <algorithm>
+#include <cstdio>
+#include <string>
+#include <cstring>
+using namespace std;
+int main()
+{
+    int i, j, t, n, k;
+    char team1[55], team2[55], tmp[122], tmp1[55][55], tmp2[55][55], fk[9];
+    bool chuchang[3][13];
+    int score[5], pts[5][55], off[5][55], def[5][55], reb[5][55], ast[5][55], pf[5][55], free[5][55][5], three[5][55][5], faqiu[55][55][5], stl[5][55], block[5][55];
+    scanf("%d", &t);
+    while(t--)
+    {
+        memset(chuchang, 0, sizeof(chuchang));
+        memset(score, 0, sizeof(score));
+        memset(pts, 0, sizeof(pts));
+        memset(off, 0, sizeof(off));
+        memset(def, 0, sizeof(def));
+        memset(reb, 0, sizeof(reb));
+        memset(ast, 0, sizeof(ast));
+        memset(pf, 0, sizeof(pf));
+        memset(free, 0, sizeof(free));
+        memset(three, 0, sizeof(three));
+        memset(faqiu, 0, sizeof(faqiu));
+        memset(stl, 0, sizeof(stl));
+        memset(block, 0, sizeof(block));
+        map<string, int>teamnum;
+        map<string, int>num;
+        scanf("%s %s %s", team1, tmp, team2);
+        for(i = 1; i <= 12; i++)
+        {
+            scanf("%s", tmp1[i]);
+            string tmpname = tmp1[i];
+            teamnum[tmpname] = 1;
+            num[tmpname] = i;
+        }
+        for(i = 1; i <= 12; i++)
+        {
+            scanf("%s", tmp2[i]);
+            string tmpname = tmp2[i];
+            teamnum[tmpname] = 2;
+            num[tmpname] = i;
+        }
+        scanf("%d", &n);
+        string pre = "", now = "";
+        bool ispass = 0,  twoout = 0, threeout = 0, fa = 0, fangui = 0;
+        getchar();
+        for(k = 0; k < n; k++)
+        {
+            gets(tmp);
+            if(k == 0 || k == n - 1) continue;
+            string str = tmp;
+            if(str.find("Hold Ball") != -1)
+            {
+                int len = str.length() - 10;
+                string tt = str.substr(0, len);
+                now = tt;
+                fangui = false;
+            }
+            else if(str.find("Pass to") != -1)
+            {
+                string tt = "";
+                int len = str.length();
+                for(i = 0; i < len; i++)
+                {
+                    if(str[i] == ' ') break;
+                    else tt += str[i];
+                }
+                pre = tt;
+                ispass = true;
+                now = str.substr(pre.length() + 9);
+            }
+            else if(str.find("Layup") != -1 || str.find("Slam Dunk") != -1 || str.find("Hook Shot") != -1  || str.find("Jump Shot") != -1 )
+            twoout = true;
+            else if(str.find("3pt Shot") != -1)
+            threeout = true;
+            else if(str.find("Missed") != -1)
+            {
+                if(fa == true)
+                {
+                    faqiu[teamnum[now]][num[now]][2]++;
+                    fa = false;
+                }
+                else if(twoout == true)
+                {
+                    if(!fangui) free[teamnum[now]][num[now]][2]++;
+                    else fangui = false;
+                    twoout = false;
+                }
+                else if(threeout == true)
+                {
+                    if(!fangui)
+                    {
+                        free[teamnum[now]][num[now]][2]++;
+                        three[teamnum[now]][num[now]][2]++;
+                    }
+                    else fangui = false;
+                    threeout = false;
+                }
+                ispass = false;
+            }
+            else if(str.find("Made") != -1)
+            {
+                if(fa == true)
+                {
+                    pts[teamnum[now]][num[now]]++;
+                    score[teamnum[now]]++;
+                    faqiu[teamnum[now]][num[now]][2]++;
+                    faqiu[teamnum[now]][num[now]][1]++;
+                    fa = false;
+                }
+                else if(twoout)
+                {
+                    pts[teamnum[now]][num[now]] += 2;
+                    score[teamnum[now]] += 2;
+                    free[teamnum[now]][num[now]][1]++;
+                    free[teamnum[now]][num[now]][2]++;
+                    if(ispass)
+                    {
+                        ast[teamnum[now]][num[pre]]++;
+                        ispass = false;
+                    }
+                    twoout = false;
+                }
+                else if(threeout)
+                {
+                    pts[teamnum[now]][num[now]] += 3;
+                    score[teamnum[now]] += 3;
+                    free[teamnum[now]][num[now]][1]++;
+                    free[teamnum[now]][num[now]][2]++;
+                    three[teamnum[now]][num[now]][2]++;
+                    three[teamnum[now]][num[now]][1]++;
+                    if(ispass)
+                    {
+                        ast[teamnum[now]][num[pre]]++;
+                        ispass = false;
+                    }
+                    threeout = false;
+                }
+                ispass = false;
+            }
+            else if(str.find("Rebound") != -1)
+            {
+                string tt = "";
+                int len = str.length();
+                for(i = 0; i < len; i++)
+                {
+                    if(str[i] == ' ') break;
+                    else tt += str[i];
+                }
+                if(teamnum[tt] != teamnum[now])
+                {
+                    def[teamnum[tt]][num[tt]]++;
+                    reb[teamnum[tt]][num[tt]]++;
+                }
+                else if(teamnum[tt] == teamnum[now])
+                {
+                    off[teamnum[tt]][num[tt]]++;
+                    reb[teamnum[tt]][num[tt]]++;
+                }
+                now = tt;
+                ispass = false;
+                twoout = false;
+                threeout = false;
+            }
+            else if(str.find("Blocked") != -1)
+            {
+                if(threeout)
+                {
+                    free[teamnum[now]][num[now]][2]++;
+                    three[teamnum[now]][num[now]][2]++;
+                    threeout = false;
+                }
+                else if(twoout)
+                {
+                    free[teamnum[now]][num[now]][2]++;
+                    twoout = false;
+                }
+                string tt = str.substr(11);
+                block[teamnum[tt]][num[tt]]++;
+                ispass = false;
+                twoout = false;
+                threeout = false;
+            }
+            else if(str.find("Foul") != -1)
+            {
+                string tt = "";
+                int len = str.length();
+                for(i = 0; i < len; i++)
+                {
+                    if(str[i] == ' ') break;
+                    else tt += str[i];
+                }
+                pf[teamnum[tt]][num[tt]]++;
+                if(twoout || threeout)
+                    fangui = true;
+            }
+            else if(str.find("Free Throw") != -1)
+            {
+                fa = true;
+                ispass = false;
+            }
+            else if(str.find("Substitution") != -1)
+            {
+                int len = str.find("Substitution") + 25;
+                string tt = str.substr(len);
+                chuchang[teamnum[tt]][num[tt]] = 1;
+                ispass = false;
+                twoout = false;
+                threeout = false;
+            }
+            else if(str.find("Timeout") != -1)
+            ispass = false;
+            else if(str.find("Jump Ball") != -1)
+            ispass = false;
+            else if(str.find("Steal") != -1)
+            {
+                string tt = "";
+                int len = str.length();
+                for(i = 0; i < len; i++)
+                {
+                    if(str[i] == ' ') break;
+                    else tt += str[i];
+                }
+                stl[teamnum[tt]][num[tt]]++;
+                now = tt;
+                ispass = false;
+            }
+        }
+        printf("%s %d-%d %s\n", team1, score[1], score[2], team2);
+        printf("%s\n", team1);
+        puts("              PLAYER PTS OFF DEF REB AST STL BLK PF FGM-A 3PM-A FTM-A");
+        for(i = 1; i <= 12; i++)
+        {
+            if(i <= 5 || chuchang[1][i] == 1)
+            {
+                printf("%20s%4d%4d%4d%4d%4d%4d%4d%3d", tmp1[i], pts[1][i], off[1][i], def[1][i], reb[1][i], ast[1][i], stl[1][i], block[1][i], pf[1][i]);
+                sprintf(fk, "%d-%d", free[1][i][1], free[1][i][2]);
+                printf("%6s", fk);
+                sprintf(fk, "%d-%d", three[1][i][1], three[1][i][2]);
+                printf("%6s", fk);
+                sprintf(fk, "%d-%d", faqiu[1][i][1], faqiu[1][i][2]);
+                printf("%6s\n", fk);
+            }
+            else
+            {
+                printf("%20s", tmp1[i]);
+                puts("          DNP - Coach's Decision");
+            }
+        }
+        printf("%s\n", team2);
+        puts("              PLAYER PTS OFF DEF REB AST STL BLK PF FGM-A 3PM-A FTM-A");
+        for(i = 1; i <= 12; i++)
+        {
+            if(i <= 5 || chuchang[2][i] == 1)
+            {
+                printf("%20s%4d%4d%4d%4d%4d%4d%4d%3d", tmp2[i], pts[2][i], off[2][i], def[2][i], reb[2][i], ast[2][i], stl[2][i], block[2][i], pf[2][i]);
+                sprintf(fk, "%d-%d", free[2][i][1], free[2][i][2]);
+                printf("%6s", fk);
+                sprintf(fk, "%d-%d", three[2][i][1], three[2][i][2]);
+                printf("%6s", fk);
+                sprintf(fk, "%d-%d", faqiu[2][i][1], faqiu[2][i][2]);
+                printf("%6s\n", fk);
+            }
+            else
+            {
+                printf("%20s", tmp2[i]);
+                puts("          DNP - Coach's Decision");
+            }
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/3971_autoAC.cpp b/HDOJ/3971_autoAC.cpp
new file mode 100644
index 0000000..9ecb202
--- /dev/null
+++ b/HDOJ/3971_autoAC.cpp
@@ -0,0 +1,110 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+namespace ST
+{
+    typedef long long LL;
+    const int maxn = 300010;
+    LL a[maxn];
+    LL Min[maxn<<2], Max[maxn<<2], add[maxn<<2];
+    inline void pushUp(int rt)
+    {
+        Max[rt] = max(Max[rt<<1], Max[rt<<1|1]);
+        Min[rt] = min(Min[rt<<1], Min[rt<<1|1]); 
+    }
+    inline void modify(int rt, LL c)
+    {
+        add[rt] += c;
+        Max[rt] += c;
+        Min[rt] += c;
+    }
+    inline void pushDown(int rt)
+    {
+        modify(rt << 1, add[rt]);
+        modify((rt << 1) | 1, add[rt]);
+        add[rt] = 0;
+    }
+    void build(int l, int r, int rt)
+    {
+        add[rt] = 0;
+        if (l == r) {
+            Max[rt] = Min[rt] = a[l];
+            return ;
+        }
+        int m = (l + r) >> 1;
+        build(l, m, rt << 1);
+        build(m + 1, r, (rt << 1) | 1);
+        pushUp(rt);
+    }
+    void update(int l, int r, int rt, LL L, LL R, LL D)
+    {
+        if (L > Max[rt] || R < Min[rt]) return ;
+        if (L <= Min[rt] && R >= Max[rt]) {
+            modify(rt, D);
+            return ;
+        }
+        if (l == r) return ;
+        int m = (l + r) >> 1;
+        pushDown(rt);
+        update(l, m, rt << 1, L, R, D); 
+        update(m + 1, r, (rt << 1) | 1, L, R, D); 
+        pushUp(rt);
+    }
+    int query(int l, int r, int rt, LL L, LL R)
+    {
+        if (L > Max[rt] || R < Min[rt]) {
+            return 0;
+        }
+        if (L <= Min[rt] && R >= Max[rt]) {
+            return r - l + 1;
+        }
+        if (l == r) return 0;
+        int m = (l + r) >> 1;
+        pushDown(rt);
+        return query(l, m, rt << 1, L, R) + query(m + 1, r, (rt << 1) | 1, L, R);
+    }
+    void getNewArr(int l, int r, int rt)
+    {
+        if (l == r) {
+            a[l] = Max[rt];
+            return ;
+        }
+        int m = (l + r) >> 1;
+        pushDown(rt);
+        getNewArr(l, m, rt << 1);
+        getNewArr(m + 1, r, (rt << 1) | 1);
+    }
+} 
+int main()
+{
+    using namespace ST;
+    int n, m;
+    char op[2];
+    long long L, R, D;
+    while (scanf("%d%d", &n, &m) != EOF) {
+        for (int i = 1; i <= n; ++i) {
+            scanf("%lld", &a[i]);
+        }
+        sort(a + 1, a + n + 1);
+        build(1, n, 1);
+        while (m--) {
+            scanf("%s", op);
+            if (op[0] == 'C') {
+                scanf("%lld%lld%lld", &L, &R, &D);
+                update(1, n, 1, L, R, D);
+            } else {
+                scanf("%lld%lld", &L, &R);
+                printf("%d\n", query(1, n, 1, L, R));
+            }
+            if (m % 4500 == 0) {
+                getNewArr(1, n, 1);
+                sort(a + 1, a + n + 1);
+                build(1, n, 1);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3973_autoAC.cpp b/HDOJ/3973_autoAC.cpp
new file mode 100644
index 0000000..941c438
--- /dev/null
+++ b/HDOJ/3973_autoAC.cpp
@@ -0,0 +1,88 @@
+#include<cstdio>  
+#include<cstring>  
+#include<map>  
+#define maxn 100010  
+#define p 33  
+using namespace std;  
+typedef unsigned long long ll;  
+struct Tree{  
+    int l,r;  
+    ll hashes;  
+}tree[300000];  
+char str[2000100];  
+ll hh[maxn];  
+void init(){  
+    int i;  
+    hh[0]=1;  
+    for(i=1;i<=maxn;i++)  
+        hh[i]=hh[i-1]*p;  
+}  
+ll calhash(){  
+    int i,len=strlen(str);  
+    ll sum=0;  
+    for(i=0;i<len;i++)  
+        sum=sum*p+str[i]-'a'+1;  
+    return sum;  
+}  
+void build(int s,int t,int id){  
+    tree[id].l=s;tree[id].r=t;  
+    if(s==t){  
+        tree[id].hashes=str[s]-'a'+1;  
+        return;  
+    }  
+    int mid=(s+t)>>1;  
+    build(s,mid,id<<1);  
+    build(mid+1,t,id<<1|1);  
+    tree[id].hashes=tree[id<<1].hashes*hh[t-mid]+tree[id<<1|1].hashes;  
+}  
+void update(int l,int id){  
+    if(tree[id].l==tree[id].r){  
+        tree[id].hashes=str[l]-'a'+1;  
+        return ;  
+    }  
+    int mid=(tree[id].l+tree[id].r)>>1;  
+    if(l<=mid) update(l,id<<1);  
+    else update(l,id<<1|1);  
+    tree[id].hashes=tree[id<<1].hashes*hh[tree[id].r-mid]+tree[id<<1|1].hashes;  
+}  
+ll query(int s,int t,int id){  
+    if(tree[id].l==s && tree[id].r==t)  
+        return tree[id].hashes;  
+    int mid=(tree[id].l+tree[id].r)>>1;  
+    if(t<=mid) return query(s,t,id<<1);  
+    else if(s>mid) return query(s,t,id<<1|1);  
+    return query(s,mid,id<<1)*hh[t-mid]+query(mid+1,t,id<<1|1);  
+}  
+int main(){  
+    int t,T,pos,l,r,i,q,n;  
+    char s1[10],s2[10];  
+    map<ll,int>mp;  
+    init();  
+    scanf("%d",&T);  
+    for(t=1;t<=T;t++){  
+        printf("Case #%d:\n",t);  
+        scanf("%d",&n);  
+        mp.clear();  
+        for(i=1;i<=n;i++){  
+            scanf("%s",str);  
+            mp.insert(make_pair(calhash(),1));  
+        }  
+        scanf("%s",str);  
+        int len=strlen(str);  
+        build(0,len-1,1);  
+        scanf("%d",&q);  
+        for(i=1;i<=q;i++){  
+            scanf("%s",s1);  
+            if(s1[0]=='C'){  
+                scanf("%d%s",&pos,s2);  
+                str[pos]=s2[0];  
+                update(pos,1);  
+            }  
+            else{  
+                scanf("%d %d",&l,&r);  
+                if(mp.find(query(l,r,1))!=mp.end()) printf("Yes\n");  
+                else printf("No\n");  
+            }  
+        }  
+    }  
+}
diff --git a/HDOJ/3974_autoAC.cpp b/HDOJ/3974_autoAC.cpp
new file mode 100644
index 0000000..19d0fb2
--- /dev/null
+++ b/HDOJ/3974_autoAC.cpp
@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <iostream>
+using namespace std;
+const int MAX = 50010;
+struct NODE
+{
+    int task,count;
+};
+NODE p[MAX];
+int parent[MAX];
+void init()
+{
+    memset(parent,-1,sizeof(parent));
+}
+int main()
+{
+    int ncases,n,u,v,m,x,task;
+    char s[5];    
+    scanf("%d",&ncases);    
+    int ind=1;
+    while(ncases--)
+    {
+        scanf("%d",&n);
+        init();
+        int i;
+        for(i=0;i<n-1;i++)
+        {
+            scanf("%d%d",&u,&v);
+            parent[u]=v;
+        }
+        for(i=1;i<=n;i++)
+        {
+            p[i].task=-1;
+            p[i].count=-1;
+        }        
+        scanf("%d",&m);        
+        printf("Case #%d:\n",ind++);
+        int count=0;
+        while(m--)
+        {
+            scanf("%s",s);
+            if(s[0]=='T')
+            {
+                scanf("%d%d",&x,&task);
+                p[x].task=task;
+                p[x].count=++count;
+            }
+            else
+            {
+                scanf("%d",&x);
+                task=p[x].task;
+                int count=p[x].count;
+                while(x!=-1)
+                {
+                    if(p[x].count>count)
+                    {
+                        task=p[x].task;
+                        count=p[x].count;
+                    }
+                    x=parent[x];
+                }
+                printf("%d\n",task);
+            }
+        }
+    }
+return 0;
+}
diff --git a/HDOJ/3975_autoAC.cpp b/HDOJ/3975_autoAC.cpp
new file mode 100644
index 0000000..174924c
--- /dev/null
+++ b/HDOJ/3975_autoAC.cpp
@@ -0,0 +1,40 @@
+#include<stdio.h>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+#define EPS 1e-8
+int main(){
+    int t,i,ca=1;
+    scanf("%d",&t);
+    double ti,g=10;
+    double x0[3],vx[3],vy[3],d[3],v[3];
+    double a,b,t1,c;
+    while(t--){
+        for(i=0;i<3;i++)scanf("%lf",x0+i);
+        for(i=0;i<3;i++)scanf("%lf",v+i);
+        for(i=0;i<3;i++)scanf("%lf",d+i);
+        for(i=0;i<3;i++){
+            vx[i]=v[i]*cos(d[i]);
+            vy[i]=v[i]*sin(d[i]);
+            if(i==0 || ti>2*vy[i]/g)
+                ti=2*vy[i]/g;
+        }
+        a=(vx[0]-vx[1])*(vy[1]-vy[2])-((vx[1]-vx[2])*(vy[0]-vy[1]));
+        b=(x0[0]-x0[1])*(vy[1]-vy[2])-(x0[1]-x0[2])*(vy[0]-vy[1]);
+        printf("Case #%d: ",ca++);
+        if(ti<EPS)
+            printf("-1\n");
+        else if(fabs(a)<EPS && fabs(b)<EPS)
+            printf("Multiply answer\n");
+        else if(fabs(a)<EPS)
+            printf("-1\n");
+        else{
+            t1=-b/a;
+            if(t1>EPS && ti-t1>-EPS )
+                printf("%.4lf\n",t1+EPS);
+            else
+                printf("-1\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3976_autoAC.cpp b/HDOJ/3976_autoAC.cpp
new file mode 100644
index 0000000..ca54707
--- /dev/null
+++ b/HDOJ/3976_autoAC.cpp
@@ -0,0 +1,79 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const double eps = 1e-9;
+const int MAXN = 100;
+double a[MAXN][MAXN],x[MAXN];
+int equ,var;
+int Gauss()
+{
+    int i,j,k,col,max_r;
+    for(k = 0,col = 0;k < equ && col < var;k++,col++)
+    {
+        max_r = k;
+        for(i = k+1;i < equ;i++)
+            if(fabs(a[i][col]) > fabs(a[max_r][col]))
+                max_r = i;
+        if(fabs(a[max_r][col]) < eps)return 0;
+        if(k != max_r)
+        {
+            for(j = col;j < var;j++)
+                swap(a[k][j],a[max_r][j]);
+            swap(x[k],x[max_r]);
+        }
+        x[k]/=a[k][col];
+        for(j = col+1;j < var;j++)a[k][j]/=a[k][col];
+        a[k][col] = 1;
+        for(int i = 0;i < equ;i++)
+            if(i != k)
+            {
+                x[i] -=  x[k]*a[i][k];
+                for(j = col+1;j < var;j++)a[i][j] -= a[k][j]*a[i][col];
+                a[i][col] = 0;
+            }
+    }
+    return 1;
+}
+int main()
+{
+    int n,m;
+    int T;
+    int iCase = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d",&n,&m);
+        equ = var = n;
+        memset(a,0,sizeof(a));
+        int u,v,w;
+        for(int i = 0;i < m;i++)
+        {
+            scanf("%d%d%d",&u,&v,&w);
+            a[u-1][v-1] += 1.0/w;
+            a[u-1][u-1] += -1.0/w;
+            a[v-1][u-1] += 1.0/w;
+            a[v-1][v-1] += -1.0/w;
+        }
+        for(int i = 0;i < n-1;i++)
+            x[i] = 0;
+        x[0] = 1;
+        for(int i = 0;i < n;i++)
+            a[n-1][i] = 0;
+        x[n-1] = 0;
+        a[n-1][0] = 1;
+        Gauss();
+        printf("Case #%d: %.2lf\n",iCase,x[n-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3977_autoAC.cpp b/HDOJ/3977_autoAC.cpp
new file mode 100644
index 0000000..7d8d4a8
--- /dev/null
+++ b/HDOJ/3977_autoAC.cpp
@@ -0,0 +1,207 @@
+#include <stdio.h>
+#include <algorithm>
+#include <math.h>
+#include <string.h>
+#include <vector>
+using namespace std;
+#define MAXN 1000005
+int prime[MAXN];
+int p[MAXN];
+int s[MAXN];
+vector <int> pmo[MAXN];
+int up;
+int tag[MAXN];
+int ttt[MAXN];
+int answer[MAXN];
+typedef struct
+{
+    long long m[2][2];
+}Matrix;
+void Prime()
+{
+    long long i,k;
+    up=0;
+    memset(prime,0,sizeof(prime));
+    for (i=2;i<=MAXN-3;i++)
+    {
+        if (prime[i]==1) continue;
+        k=i;
+        while(k*i<MAXN-2)
+        {
+            prime[i*k]=1;
+            k++;
+        }
+        p[up++]=i;
+        prime[i]=up-1;
+    }
+}
+Matrix Mul(Matrix a,Matrix b,int mod)
+{
+    Matrix c;
+    int i,j,k;
+    for (i=0;i<2;i++)
+    {
+        for (j=0;j<2;j++)
+        {
+            c.m[i][j]=0;
+            for (k=0;k<2;k++)
+            {
+                c.m[i][j]=(c.m[i][j]+a.m[i][k]*b.m[k][j])%mod;
+            }
+        }
+    }
+    return c;
+}
+long long CountFib(int t,int mod)
+{
+    Matrix a,b;
+    int k=t;
+    a.m[0][0]=a.m[0][1]=a.m[1][0]=b.m[0][0]=1;
+    a.m[1][1]=b.m[1][0]=b.m[0][1]=b.m[1][1]=0;
+    while(t)
+    {
+        if (t&1)
+        {
+            b=Mul(a,b,mod);
+        }
+        a=Mul(a,a,mod);
+        t>>=1;
+    }
+    return b.m[0][0];
+}
+int num[100][2];
+int ret;
+int now=0;
+int Multi(int t,int n)
+{
+    int ans=1;
+    while(n)
+    {
+        if (n&1) ans=ans*t;
+        t=t*t;
+        n>>=1;
+    }
+    return ans;
+}
+void DFS(int t,int mod,int mul)
+{
+    int j;
+    if (mul>=ret) return;
+    if (t==now)
+    {
+        if (CountFib(mul,mod)==1 && CountFib(mul+1,mod)==1) ret=mul;
+        return;
+    }
+    for (j=0;j<=num[t][1];j++)
+    {
+        if (num[t][0]==2 && j==0) continue;
+        int k=mul*Multi(num[t][0],j);
+        DFS(t+1,mod,k);
+    }
+}
+int DT(int t,int mod)
+{
+    int i;
+    ret=t;
+    now=0;
+    for (i=0;i<up;i++)
+    {
+        if (t%p[i]!=0) continue;
+        num[now][0]=p[i];
+        num[now][1]=0;
+        while(t%p[i]==0)
+        {
+            num[now][1]++;
+            t/=p[i];
+        }
+        now++;
+        if (t==1) break;
+    }
+    if (t!=1)
+    {
+        num[now][0]=t;
+        num[now++][1]=1;
+    }
+    DFS(0,mod,1);
+    return ret;
+}
+int Count(int t)
+{
+    int i,k,j;
+    if (t==2)
+    {
+        return 3;
+    }
+    else if (t==5)
+    {
+        return 20;
+    }
+    if (t%10==1 || t%10==9) k=t-1;
+    if (t%10==3 || t%10==7) k=t*2+2;
+    return DT(k,t);
+}
+int fj[50][2];
+int main()
+{
+    int i,j,m,T,cnt;
+    long long n;
+    Prime();
+    scanf("%d",&T);
+    cnt=1;
+    while(T--)
+    {
+        scanf("%I64d",&n);
+        m=0;
+        for (i=0;i<up;i++)
+        {
+            if (n%p[i]==0)
+            {
+                fj[m][0]=p[i];
+                fj[m][1]=0;
+                while(n%p[i]==0)
+                {
+                    fj[m][1]++;
+                    n/=p[i];
+                }
+                m++;
+            }
+            if (n==1) break;
+        }
+        memset(answer,0,sizeof(answer));
+        int mm=0;
+        for (i=0;i<m;i++)
+        {
+            memset(tag,0,sizeof(tag));
+            if (fj[i][1]>0)
+            {
+                mm=max(prime[fj[i][0]],mm);
+                tag[prime[fj[i][0]]]+=fj[i][1]-1;
+            }
+            int tt=Count(fj[i][0]);
+            for (j=0;j<up;j++)
+            {
+                while(tt%p[j]==0)
+                {
+                    tt/=p[j];
+                    tag[j]++;
+                    mm=max(mm,j);
+                }
+                if (tt==1) break;
+            }
+            for (j=0;j<=mm;j++)
+            {
+                answer[j]=max(tag[j],answer[j]);
+            }
+        }
+        long long pr=1;
+        for (i=0;i<=mm;i++)
+        {
+            for (j=0;j<answer[i];j++)
+            {
+                pr*=p[i];
+            }
+        }
+        printf("Case #%d: %I64d\n",cnt++,pr);
+    }
+    return 0;
+}
diff --git a/HDOJ/3978_autoAC.cpp b/HDOJ/3978_autoAC.cpp
new file mode 100644
index 0000000..5786c3a
--- /dev/null
+++ b/HDOJ/3978_autoAC.cpp
@@ -0,0 +1,197 @@
+#include <cstdio>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+#include <map>
+using namespace std;
+#define maxn 10010
+typedef long long LL;
+int prime[maxn];
+map<LL,LL>pika;
+void Prime(){
+    memset(prime,0,sizeof(prime));
+    for(int i=2;i<maxn;i++){
+        if(!prime[i]) prime[++prime[0]]=i;
+        for(int j=1;j<=prime[0]&&prime[j]<maxn/i;j++){
+            prime[prime[j]*i]=1;
+            if(i%prime[j]==0){
+                break;
+            }
+        }
+    }
+}
+LL factor[100][2];
+int fatcnt;
+int get_factors(LL n){
+    fatcnt=0;
+    LL tmp=n;
+    for(int i=1;prime[i]<=tmp/prime[i];i++){
+        factor[fatcnt][1]=0;
+        if(tmp%prime[i]==0){
+            factor[fatcnt][0]=prime[i];
+            while(tmp%prime[i]==0){
+                tmp/=prime[i];
+                factor[fatcnt][1]++;
+            }
+            fatcnt++;
+        }
+    }
+    if(tmp!=1){
+        factor[fatcnt][0]=tmp;
+        factor[fatcnt][1]=1;
+        fatcnt++;
+    }
+    return fatcnt;
+}
+LL gcd(LL a,LL b){
+    if(b==0){
+        return a;
+    }
+    else{
+        return gcd(b,a%b);
+    }
+}
+LL lcm(LL a,LL b){
+    return a/gcd(a,b)*b;
+}
+struct Matrix{
+    LL m[2][2];
+}E,D;
+Matrix Multi(Matrix A,Matrix B,LL mod){
+    Matrix ans;
+    for(int i=0;i<2;i++){
+        for(int j=0;j<2;j++){
+            ans.m[i][j]=0;
+            for(int k=0;k<2;k++){
+                ans.m[i][j]+=(A.m[i][k]*B.m[k][j])%mod;
+                if(ans.m[i][j]>=mod){
+                    ans.m[i][j]-=mod;
+                }
+            }
+        }
+    }
+    return ans;
+}
+void init(){
+    memset(E.m,0,sizeof(E.m));
+    memset(D.m,0,sizeof(D.m));
+    D.m[0][0]=D.m[0][1]=D.m[1][0]=1;
+    for(int i=0;i<2;i++){
+        E.m[i][i]=1;
+    }
+    Prime();
+}
+Matrix Pow(Matrix A,LL e,LL mod){
+    Matrix ans=E;
+    while(e){
+        if(e&1){
+            ans=Multi(ans,A,mod);
+        }
+        A=Multi(A,A,mod);
+        e>>=1;
+    }
+    return ans;
+}
+LL Pow(LL a,LL b,LL mod){
+    LL ans=1;
+    while(b){
+        if(b&1){
+            ans=(ans*a)%mod;
+        }
+        a=(a*a)%mod;
+        b>>=1;
+    }
+    return ans;
+}
+int legendre(LL a,LL p){
+    if(Pow(a,(p-1)>>1,p)==1){
+        return 1;
+    }
+    else{
+        return -1;
+    }
+}
+int f0=1,f1=1;
+LL get_fib(LL n,LL mod)
+{
+    if(mod==1) return 0;
+    return Pow(D,n,mod).m[0][0]%mod;
+}
+LL fac[maxn],GG[maxn];
+LL G(LL p)
+{
+    if(p<maxn && GG[p]!=-1) return GG[p];
+    LL num;
+    if(legendre(5,p)==1){
+        num=p-1;
+    }
+    else{
+        num=2*(p+1);
+    }
+    int cnt=0;
+    for(LL i=1;i*i<=num;i++){
+        if(num%i==0){
+            fac[cnt++]=i;
+            if(i*i!=num){
+                fac[cnt++]=num/i;
+            }
+        }
+    }
+    sort(fac,fac+cnt);
+    LL ans;
+    for(int i=0;i<cnt;i++){
+        if(get_fib(fac[i],p)==f0&&get_fib(fac[i]+1,p)==f1){
+            ans=fac[i];
+            break;
+        }
+    }
+    if(p<maxn) GG[p]=ans;
+    return ans;
+}
+LL find_loop(LL n)
+{
+    if(pika.count(n)){
+        return pika[n];
+    }
+    get_factors(n);
+    LL ans=1;
+    for(int i=0;i<fatcnt;i++)
+    {
+        LL record=1;
+        if(factor[i][0]==2) record=3;
+        else if(factor[i][0]==3) record=8;
+        else if(factor[i][0]==5) record=20;
+        else  record=G(factor[i][0]);
+        for(int j=1;j<factor[i][1];j++)
+            record*=factor[i][0];
+        ans=lcm(ans,record);
+    }
+    return pika[n]=ans;
+}
+LL loop[10010];
+void solve(LL p,LL k){
+    loop[0]=p;
+    for(int i=1;i<=k;i++){
+        loop[i]=find_loop(loop[i-1]);
+    }
+}
+int main()
+{
+    pika.clear();
+    init();
+    memset(GG,-1,sizeof(GG));
+    int T,cas=0;
+    scanf("%d",&T);
+    LL n,p,k;
+    while(T--)
+    {
+        scanf("%I64d%I64d%I64d",&n,&k,&p);
+        solve(p,k);
+        for(int i=k;i>=0;i--){
+            n=get_fib(n,loop[i]);
+        }
+        printf("Case #%d: %I64d\n",++cas,n);
+    }
+    return 0;
+}
diff --git a/HDOJ/3979_autoAC.cpp b/HDOJ/3979_autoAC.cpp
new file mode 100644
index 0000000..80c2de1
--- /dev/null
+++ b/HDOJ/3979_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+struct Node
+{
+    int h,g;
+}node[10010];
+int n,m;
+bool cmp(Node a,Node b)
+{
+    return a.h*b.g < b.h*a.g;
+}
+int main()
+{
+    int T;
+    int iCase = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase ++;
+        scanf("%d%d",&n,&m);
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d%d",&node[i].h,&node[i].g);
+            node[i].h = (node[i].h + m - 1)/m;
+        }
+        sort(node,node+n,cmp);
+        long long ans = 0;
+        int cnt = 0;
+        for(int i = 0;i < n;i++)
+        {
+            cnt += node[i].h;
+            ans += (long long)cnt*node[i].g;
+        }
+        printf("Case #%d: %I64d\n",iCase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3980_autoAC.cpp b/HDOJ/3980_autoAC.cpp
new file mode 100644
index 0000000..31ce616
--- /dev/null
+++ b/HDOJ/3980_autoAC.cpp
@@ -0,0 +1,31 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <iostream>
+using namespace std;
+int t, n, m;
+int f[1005];
+bool emerge[1000];
+int get_sg(int len)
+{
+    if(len<m) return f[len]=0;
+    if(f[len]!=-1) return f[len];
+    bool vs[1001]={0};
+    for(int i=0; len-i-m>=0; i++)
+        vs[get_sg(i)^get_sg(len-i-m)]=1;
+    for(int i=0; i<1001; i++)
+        if(!vs[i]) return f[len]=i;
+}
+int main()
+{
+    scanf("%d", &t);
+    for(int ca=1; ca<=t; ca++)
+    {
+        scanf("%d%d", &n, &m);
+        memset(f, -1, sizeof(f));
+        printf("Case #%d: ", ca);
+        if(n<m || get_sg(n-m)) printf("abcdxyzk\n");
+        else printf("aekdycoin\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3981_autoAC.cpp b/HDOJ/3981_autoAC.cpp
new file mode 100644
index 0000000..9a744a4
--- /dev/null
+++ b/HDOJ/3981_autoAC.cpp
@@ -0,0 +1,101 @@
+#include <iostream>
+#include <string>
+#include <cstring>
+#include <cstdio>
+#include <set>
+#include <map>
+#include <queue>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define forn(i, n) for(int i = 0; i < (int)(n); i++)
+#define clr(a, b) memset(a, b, sizeof(a))
+#define SZ(a) ((int)a.size())
+#define PB push_back
+#define MP make_pair
+#define inf 0x3f3f3f3f
+typedef vector<int> vi;
+typedef pair<int, int> pii;
+typedef long long ll;
+#ifdef ecust
+#define RR "%lld"
+#else
+#define RR "%I64d"
+#endif
+namespace acm {
+int dp[2][220][10][220];
+int T, HS, A, R, U, D, FI, P;
+int des[300];
+void update(int &a, int b) {
+    a = max(a, b);
+}
+void solve() {
+    scanf("%d%d%d%d", &T, &HS, &A, &R);
+    scanf("%d%d%d%d", &U, &D, &FI, &P);
+    forn(i, T)
+        scanf("%d", des + i + 1);
+    clr(dp, 0x3f);
+    forn(i, 2)
+        forn(j, 220)
+            forn(k, 10)
+                forn(l, 220)
+                    dp[i][j][k][l] = -inf;
+    int now = 0;
+    dp[0][HS][0][0] = 0;
+    for (int tt = 1; tt <= T; ++tt) {
+        int fang = des[tt];
+        for (int i = 1; i <= HS; ++i) {
+            for (int j = 0; j <= 6; ++j) {
+                for (int k = 0; k <= T; ++k) {
+                    if (dp[now][i][j][k] == -inf)
+                        continue;
+                    if (i > D) {
+                        int add = A + (HS - i) / R * U;
+                        if (add < fang)
+                            add = 0;
+                        else
+                            add -= fang;
+                        update(dp[now ^ 1][i - D][6][k + 1], dp[now][i][j][k]
+                                + add + FI * k);
+                    }
+                    int add = A + (HS - i) / R * U;
+                    if (add < fang)
+                        add = 0;
+                    else
+                        add -= fang;
+                    if (j - 1 == 0)
+                        update(dp[now ^ 1][i][j - 1][0], dp[now][i][j][k] + add
+                                + FI * k);
+                    else if (j)
+                        update(dp[now ^ 1][i][j - 1][k], dp[now][i][j][k] + add
+                                + FI * k);
+                    else if (j == 0)
+                        update(dp[now ^ 1][i][j][k], dp[now][i][j][k] + add);
+                }
+            }
+        }
+        now = now ^ 1;
+    }
+    int ans = -inf, ans2 = -inf;
+    forn(j, 220)
+        forn(k, 10)
+            forn(l, 220) {
+                if (dp[now ][j][k][l] != inf) {
+                    update(ans, dp[now ][j][k][l] - (HS - j) * P);
+                }
+            }
+    printf("%d\n", ans);
+}
+void icpc() {
+    int nc, nn = 1;
+    scanf("%d", &nc);
+    while (nc--) {
+        printf("Case #%d: ", nn++);
+        solve();
+    }
+}
+}
+int main() {
+    acm::icpc();
+    return 0;
+}
diff --git a/HDOJ/3982_autoAC.cpp b/HDOJ/3982_autoAC.cpp
new file mode 100644
index 0000000..d63a456
--- /dev/null
+++ b/HDOJ/3982_autoAC.cpp
@@ -0,0 +1,267 @@
+#include <set>
+#include <map>
+#include <queue>
+#include <stack>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <limits.h>
+#include <string.h>
+#include <string>
+#include <algorithm>
+#define MID(x,y) ( ( x + y ) >> 1 )
+#define L(x) ( x << 1 )
+#define R(x) ( x << 1 | 1 )
+#define FOR(i,s,t) for(int i=s; i<t; i++)
+#define BUG puts("here!!!")
+using namespace std;
+const int MAX = 2010;
+struct point { 
+    double x,y;
+    void P(double xx, double yy){ x = xx; y = yy;}
+    void get(){ scanf("%lf%lf",&x, &y);}
+};
+struct line { point a,b; double ang;};  
+point s[MAX*2], ch, p[MAX*2];  
+line l[MAX*2],deq[MAX*2];  
+const double eps = 1e-6;  
+const double pi = acos(-1.0);
+bool dy(double x,double y)  {   return x > y + eps;} 
+bool xy(double x,double y)  {   return x < y - eps;}  
+bool dyd(double x,double y) {   return x > y - eps;}   
+bool xyd(double x,double y) {   return x < y + eps;}     
+bool dd(double x,double y)  {   return fabs( x - y ) < eps;}   
+double crossProduct(point a,point b,point c)  
+{  
+    return (c.x - a.x)*(b.y - a.y) - (b.x - a.x)*(c.y - a.y);  
+}  
+double disp2p(point a,point b) 
+{
+    return sqrt( ( a.x - b.x ) * ( a.x - b.x ) + ( a.y - b.y ) * ( a.y - b.y ) );
+}
+bool parallel(line u,line v)  
+{  
+    return dd( (u.a.x - u.b.x)*(v.a.y - v.b.y) - (v.a.x - v.b.x)*(u.a.y - u.b.y) , 0.0 );  
+}  
+point l2l_inst_p(line l1,line l2)  
+{  
+    point ans = l1.a;  
+    double t = ((l1.a.x - l2.a.x)*(l2.a.y - l2.b.y) - (l1.a.y - l2.a.y)*(l2.a.x - l2.b.x))/  
+               ((l1.a.x - l1.b.x)*(l2.a.y - l2.b.y) - (l1.a.y - l1.b.y)*(l2.a.x - l2.b.x));  
+    ans.x += (l1.b.x - l1.a.x)*t;  
+    ans.y += (l1.b.y - l1.a.y)*t;  
+    return ans;  
+}  
+bool equal_ang(line a,line b)  
+{  
+    return dd(a.ang,b.ang);  
+}  
+bool cmphp(line a,line b)  
+{  
+    if( dd(a.ang,b.ang) ) return xy(crossProduct(b.a,b.b,a.a),0.0);  
+    return xy(a.ang,b.ang);  
+}  
+bool equal_p(point a,point b)
+{  
+    return dd(a.x,b.x) && dd(a.y,b.y);  
+}
+void makeline_hp(double x1,double y1,double x2,double y2,line &l)
+{
+    l.a.x = x1; l.a.y = y1; l.b.x = x2; l.b.y = y2;
+    l.ang = atan2(y2 - y1,x2 - x1);
+}
+void inst_hp_nlogn(line *ln,int n,point *s,int &len)  
+{  
+    len = 0;  
+    sort(ln,ln+n,cmphp);  
+    n = unique(ln,ln+n,equal_ang) - ln;  
+    int bot = 0,top = 1;  
+    deq[0] = ln[0]; deq[1] = ln[1];  
+    for(int i=2; i<n; i++)  
+    {  
+        if( parallel(deq[top],deq[top-1]) || parallel(deq[bot],deq[bot+1]) )  
+            return ;  
+        while( bot < top && dy(crossProduct(ln[i].a,ln[i].b,  
+            l2l_inst_p(deq[top],deq[top-1])),0.0) )  
+            top--;  
+        while( bot < top && dy(crossProduct(ln[i].a,ln[i].b,  
+            l2l_inst_p(deq[bot],deq[bot+1])),0.0) )  
+            bot++;  
+        deq[++top] = ln[i];  
+    }  
+    while( bot < top && dy(crossProduct(deq[bot].a,deq[bot].b,  
+        l2l_inst_p(deq[top],deq[top-1])),0.0) ) top--;  
+    while( bot < top && dy(crossProduct(deq[top].a,deq[top].b,  
+        l2l_inst_p(deq[bot],deq[bot+1])),0.0) ) bot++;  
+    if( top <= bot + 1 ) return ;  
+    for(int i=bot; i<top; i++)  
+        s[len++] = l2l_inst_p(deq[i],deq[i+1]);  
+    if( bot < top + 1 ) s[len++] = l2l_inst_p(deq[bot],deq[top]);  
+    len = unique(s,s+len,equal_p) - s;  
+}
+point l2l_inst_p(point u1,point u2,point v1,point v2)
+{
+    point ans = u1;
+    double t = ((u1.x - v1.x)*(v1.y - v2.y) - (u1.y - v1.y)*(v1.x - v2.x))/
+                ((u1.x - u2.x)*(v1.y - v2.y) - (u1.y - u2.y)*(v1.x - v2.x));
+    ans.x += (u2.x - u1.x)*t;
+    ans.y += (u2.y - u1.y)*t;
+    return ans;
+}
+void l2c_inst_p(point c,double r,point l1,point l2,point &p1,point &p2)
+{
+    point p = c;
+    double t;
+    p.x += l1.y - l2.y;
+    p.y += l2.x - l1.x;
+    p = l2l_inst_p(p,c,l1,l2);
+    t = sqrt(r*r - disp2p(p,c)*disp2p(p,c))/disp2p(l1,l2);
+    p1.x = p.x + (l2.x - l1.x)*t;
+    p1.y = p.y + (l2.y - l1.y)*t;
+    p2.x = p.x - (l2.x - l1.x)*t;
+    p2.y = p.y - (l2.y - l1.y)*t;
+}
+double disp2l(point a,point l1,point l2)
+{
+    return fabs( crossProduct(a,l1,l2) )/disp2p(l1,l2);
+}
+bool onSegment(point a, point b, point c)
+{
+    if( dd(crossProduct(a,b,c),0.0) && dyd(c.x,min(a.x,b.x)) && 
+        xyd(c.x,max(a.x,b.x)) && dyd(c.y,min(a.y,b.y)) && xyd(c.y,max(a.y,b.y)) )
+        return true;
+    return false;
+}
+bool cmp(point a,point b)
+{
+    double t1 = atan2(a.y - ch.y, a.x - ch.x);
+    double t2 = atan2(b.y - ch.y, b.x - ch.x);
+    return xy(t1, t2);
+}
+double area_triangle(point a,point b,point c)
+{
+    return fabs( crossProduct(a,b,c) )/2.0;
+}
+double gong_area(point c,point a,point b,double r)
+{
+    if( dd(crossProduct(c,a,b), 0.0) )
+        return r*r*pi/2;
+    double area = area_triangle(a, b, c);
+    double ang = acos(1-disp2p(a,b)*disp2p(a,b)/(r*r*2));
+    return ang*r*r/2 - area;
+}
+bool incircle(point a,point c, double r)
+{
+    return xy(disp2p(a, c), r);
+}
+bool pin_convexh(point *p,int n,point a)
+{
+    p[n] = p[0]; p[n+1] = p[1];
+    for(int i=0; i<n; i++)
+        if( xy(crossProduct(p[i],p[i+1],a)*
+            crossProduct(p[i+1],p[i+2],a),0.0) )
+            return false;
+    return true;
+}
+point foot_line(point a,point l1,point l2)
+{                                        
+    point c;
+    c.x = a.x - l2.y + l1.y;
+    c.y = a.y + l2.x - l1.x;
+    return c;    
+}
+double solve(point *s, int len, double r)
+{
+    point c; c.x = c.y = 0;
+    point a, b;
+    int cnt = 0;
+    s[len] = s[0];
+    FOR(i, 0, len)    
+    {    
+        if( xy(disp2l(c, s[i], s[i+1]), r) )
+        {
+            l2c_inst_p(c, r, s[i], s[i+1], a, b);
+            if( onSegment(s[i], s[i+1], a) )
+                p[cnt++] = a;
+            if( onSegment(s[i], s[i+1], b) )
+                p[cnt++] = b;
+        }
+        if( incircle(s[i], c, r) )
+            p[cnt++] = s[i];
+        if( incircle(s[i+1], c, r) )
+            p[cnt++] = s[i+1];
+    }
+    sort(p, p+cnt, cmp);
+    cnt = unique(p, p+cnt, equal_p) - p;
+    p[cnt] = p[0];
+    double area = 0.0;
+    if( cnt == 2 )     
+    {
+        if( xy(crossProduct(p[0],p[1],ch), 0.0) )
+            swap(p[0], p[1]);
+        cnt--;
+    }
+    FOR(i, 0, cnt)
+    {
+        area += area_triangle(p[0], p[i], p[i+1]);
+        if( !dd(disp2p(p[i], c), r) || !dd(disp2p(p[i+1], c), r) )
+            continue; 
+        point mid;
+        mid.P((p[i].x + p[i+1].x)/2, (p[i].y + p[i+1].y)/2);
+        point a, b, k;
+        k = foot_line(c, p[i], p[i+1]);
+        l2c_inst_p(c, r, k, c, a, b);
+        bool flag = false;
+        if( dyd(crossProduct(p[i], p[i+1], a), 0.0) && pin_convexh(s, len, a) )
+            flag = true; 
+        if( dyd(crossProduct(p[i], p[i+1], b), 0.0) && pin_convexh(s, len, b) )
+            flag = true; 
+        if( !flag ) continue;
+        double area_gong = gong_area(c, p[i], p[i+1], r);
+        if( dy(crossProduct(p[i], p[i+1], c), 0.0) )
+            area_gong = pi*r*r - area_gong;
+        area += area_gong;
+    }
+    return area/(pi*r*r);
+}
+int main()
+{
+    int ncases, ind = 1, n;
+    double r;
+    scanf("%d", &ncases);
+    while( ncases-- )
+    {
+        scanf("%lf%d",&r, &n);
+        FOR(i, 0, n)
+        {
+            l[i].a.get();
+            l[i].b.get();
+        }
+        ch.get();
+        bool f = false;
+        point c; c.P(0,0);
+        FOR(i, 0, n)
+        {
+            if( dy(crossProduct(l[i].a, l[i].b, ch), 0.0) )
+                swap(l[i].a, l[i].b);
+            l[i].ang = atan2(l[i].b.y - l[i].a.y, l[i].b.x - l[i].a.x);
+            if( xy(disp2l(c,l[i].a, l[i].b), r) )
+                f = true;         
+        }
+        if( !f )        
+        {
+            printf("Case %d: %.5lf%%\n",ind++, 100.0);
+            continue;
+        }
+        makeline_hp(-2*r, -2*r, 2*r, -2*r, l[n++]); 
+        makeline_hp(2*r, -2*r, 2*r, 2*r, l[n++]);
+        makeline_hp(2*r, 2*r, -2*r, 2*r, l[n++]);
+        makeline_hp(-2*r, 2*r, -2*r, -2*r, l[n++]);
+        int len;
+        inst_hp_nlogn(l, n, s, len); 
+        double ans = solve(s, len, r);
+        printf("Case %d: %.5lf%%\n",ind++, ans*100);
+    }
+return 0;
+}
diff --git a/HDOJ/3986_autoAC.cpp b/HDOJ/3986_autoAC.cpp
new file mode 100644
index 0000000..72fa383
--- /dev/null
+++ b/HDOJ/3986_autoAC.cpp
@@ -0,0 +1,88 @@
+#include<iostream>
+#include<cstdio>
+#include<queue>
+#include<vector>
+using namespace std;
+const int MAXN=1000+10;
+const int inf=1<<30;
+struct Node{
+    int v,w,id;
+};
+vector<Node>vet[MAXN];
+int path[MAXN];
+int dist[MAXN];
+bool visited[MAXN];
+bool mark[MAXN*50];
+int id[MAXN];
+int n,m;
+bool tag;
+void SPFA(int u){
+    for(int i=1;i<=n;i++)dist[i]=inf;
+    dist[u]=0;
+    memset(visited,false,sizeof(visited));
+    queue<int>Q;
+    Q.push(u);
+    while(!Q.empty()){
+        int u=Q.front();
+        Q.pop();
+        visited[u]=false;
+        for(int i=0;i<vet[u].size();i++){
+            int v=vet[u][i].v;
+            int w=vet[u][i].w;
+            int ID=vet[u][i].id;
+            if(mark[vet[u][i].id])continue;
+            if(dist[u]+w<dist[v]){
+                dist[v]=dist[u]+w;
+                if(tag)path[v]=u,id[v]=ID;
+                if(!visited[v]){
+                    Q.push(v);
+                    visited[v]=true;
+                }
+            }
+        }
+    }
+}
+int main(){
+    int _case;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        for(int i=1;i<=n;i++)vet[i].clear();
+        memset(path,-1,sizeof(path));
+        memset(mark,false,sizeof(mark));
+        for(int i=1;i<=m;i++){
+            int u,v,w;
+            scanf("%d%d%d",&u,&v,&w);
+            Node p1,p2;
+            p1.v=u,p2.v=v;
+            p1.w=p2.w=w;
+            p1.id=p2.id=i; 
+            vet[u].push_back(p2);
+            vet[v].push_back(p1);
+        }
+        tag=true;
+        SPFA(1);
+        tag=false;
+        if(dist[n]==inf){
+            printf("-1\n");
+            continue;
+        }
+        int ans=0;
+        bool flag=true;
+        for(int u=n;u!=-1;u=path[u]){
+            mark[id[u]]=true;
+            SPFA(1);
+            mark[id[u]]=false;
+            if(dist[n]==inf){
+                printf("-1\n");
+                flag=false;
+                break;
+            }
+            ans=max(ans,dist[n]);
+        }
+        if(flag){
+            printf("%d\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3987_autoAC.cpp b/HDOJ/3987_autoAC.cpp
new file mode 100644
index 0000000..8fc344f
--- /dev/null
+++ b/HDOJ/3987_autoAC.cpp
@@ -0,0 +1,83 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+using namespace std;
+typedef long long ll;
+#define MAXN 2222
+#define MAXM 2222222
+struct Edge{
+    int v,next;
+    ll cap;
+}edge[MAXM];
+int head[MAXN];
+int pre[MAXN];
+int cur[MAXN];
+int level[MAXN];
+int gap[MAXN];
+int NV,NE,n,m,vs,vt;
+void Insert(int u,int v,ll cap,ll cc=0){
+    edge[NE].v=v;edge[NE].cap=cap;
+    edge[NE].next=head[u];head[u]=NE++;
+    edge[NE].v=u;edge[NE].cap=cc;
+    edge[NE].next=head[v];head[v]=NE++;
+}
+ll SAP(int vs,int vt){
+    memset(pre,-1,sizeof(pre));
+    memset(level,0,sizeof(level));
+    memset(gap,0,sizeof(gap));
+    for(int i=0;i<=NV;i++)cur[i]=head[i];
+    int u=pre[vs]=vs;
+    ll aug=-1,maxflow=0;
+    gap[0]=NV;
+    while(level[vs]<NV){
+loop:
+        for(int &i=cur[u];i!=-1;i=edge[i].next){
+            int v=edge[i].v;
+            if(edge[i].cap&&level[u]==level[v]+1){
+                aug==-1?aug=edge[i].cap:aug=min(aug,edge[i].cap);
+                pre[v]=u;
+                u=v;
+                if(v==vt){
+                    maxflow+=aug;
+                    for(u=pre[u];v!=vs;v=u,u=pre[u]){
+                        edge[cur[u]].cap-=aug;
+                        edge[cur[u]^1].cap+=aug;
+                    }
+                    aug=-1;
+                }
+                goto loop;
+            }
+        }
+        int minlevel=NV;
+        for(int i=head[u];i!=-1;i=edge[i].next){
+            int v=edge[i].v;
+            if(edge[i].cap&&minlevel>level[v]){
+                cur[u]=i;
+                minlevel=level[v];
+            }
+        }
+        if(--gap[level[u]]==0)break;
+        level[u]=minlevel+1;
+        gap[level[u]]++;
+        u=pre[u];
+    }
+    return maxflow;
+}
+int main(){
+    int _case,u,v,w,flag,t=1;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        vs=0,vt=n-1,NV=n,NE=0;
+        memset(head,-1,sizeof(head));
+        for(int i=1;i<=m;i++){
+            scanf("%d%d%d%d",&u,&v,&w,&flag);
+            Insert(u,v,(ll)w*MAXM+1);
+            if(flag)Insert(v,u,(ll)w*MAXM+1);
+        }
+        ll ans=SAP(vs,vt);
+        printf("Case %d: %d\n",t++,ans%MAXM);
+    }
+    return 0;
+}
diff --git a/HDOJ/3988_autoAC.cpp b/HDOJ/3988_autoAC.cpp
new file mode 100644
index 0000000..66c575d
--- /dev/null
+++ b/HDOJ/3988_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<iostream>
+#include<cstring>
+#include<queue>
+#include<cstdio>
+#include<cmath>
+#include<algorithm>
+#define N 100005
+#define MOD 9973
+#define LL unsigned long long
+#define eps 1e-7
+#define zero(a) fabs(a)<eps
+#define equal(a,b) zero(a-b)
+using namespace std;
+bool flag[10000005];
+int cnt=0,prime[10000005];
+void Init(){
+    for(int i=2;i<=sqrt(10000000.0)+1;i++){
+        if(flag[i])
+            continue;
+        for(int j=2;j*i<=10000000;j++)
+            flag[i*j]=true;
+    }
+    for(int i=2;i<=10000000;i++)
+        if(!flag[i])
+            prime[cnt++]=i;
+}
+LL get_sum(LL n,LL p){
+    LL ret=0;
+    while(n){
+        n/=p;
+        ret+=n;
+    }
+    return ret;
+}
+int main(){
+    int t,cas=0;
+    scanf("%d",&t);
+    Init();
+    while(t--){
+        LL n,k;
+        scanf("%I64u%I64u",&n,&k);
+        if(k==1){
+            printf("Case %d: inf\n",++cas);
+            continue;
+        }
+        LL mmax=-1;
+        for(int i=0;i<cnt&&prime[i]<=k;i++){
+            if(k%prime[i]==0){
+                int c=0;
+                while(k%prime[i]==0){
+                    c++;
+                    k/=prime[i];
+                }
+                LL tmp=get_sum(n,prime[i])/c;
+                if(mmax==-1)
+                    mmax=tmp;
+                else
+                    mmax=min(mmax,tmp);
+            }
+        }
+        if(k>1){
+            LL tmp=get_sum(n,k);
+            if(mmax==-1)
+                mmax=tmp;
+            else
+                mmax=min(mmax,tmp);
+        }
+        printf("Case %d: %I64u\n",++cas,mmax);
+    }
+    return 0;
+}
diff --git a/HDOJ/3991_autoAC.cpp b/HDOJ/3991_autoAC.cpp
new file mode 100644
index 0000000..f545102
--- /dev/null
+++ b/HDOJ/3991_autoAC.cpp
@@ -0,0 +1,110 @@
+#include <cstdio>
+#include <cstring>
+struct EDGE
+{
+    int v, next;
+}edge[2010010];
+struct NODE
+{
+    int p;
+    long long t;
+}node[1010];
+const long long inf = 1ll<<60;
+long long map[105][105];
+bool usedif[1005];
+int link[1005];
+int head[1010];
+int cnt, gx, gy;
+bool cmp(NODE a, NODE b)
+{
+    return a.t < b.t;
+}
+void addedge(int u, int v)
+{
+    edge[cnt].v = v;
+    edge[cnt].next = head[u];
+    head[u] = cnt++;
+}
+bool can(int t)
+{
+    for(int p = head[t]; p != -1; p = edge[p].next)
+    {
+        int i = edge[p].v;
+        if(usedif[i]==0)
+        {
+            usedif[i]=1;
+            if(link[i]==-1||can(link[i]))
+            {
+                link[i]=t;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int MaxMatch()
+{
+    int num=0;
+    memset(link,-1,sizeof(link));
+    for(int i=0; i< gx; i++)
+    {
+        memset(usedif,0,sizeof(usedif));
+        if(can(i))  num++;
+    }
+    return num;
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    int cas = 1;
+    while(T--)
+    {
+        int n, m, q;
+        scanf("%d%d%d", &n, &m, &q);
+        int d = 1<< 30;
+        for(int i = 0; i < n; i++)
+          for(int j = 0; j < n; j++)
+          if(i != j)  map[i][j] = inf;
+         else map[i][j] = 0;
+        while(m--)
+        {
+            int a, b;
+            long long c;
+            scanf("%d%d%I64d", &a, &b, &c);
+            if(map[a][b] > c)
+            {
+                map[a][b] = map[b][a] = c;
+            }
+        }
+        for(int k = 0; k < n; k++)
+          for(int i = 0; i < n; i++)
+          {
+            if(i == k) continue;
+            if(map[i][k] == inf)  continue;
+            for(int j = 0; j < n; j++)
+            if(map[k][j] != inf && map[i][k] + map[k][j] < map[i][j])
+            {
+                map[i][j] = map[i][k] + map[k][j];
+            }
+          }
+        for(int i = 0; i < q; i++)
+        {
+            scanf("%d%d", &node[i].p, &node[i].t);
+        }
+        gx = q;
+        cnt = 0;
+        memset(head, -1, sizeof(head));
+        for(int i = 0; i < q; i++)
+        {
+            for(int j = 0; j < q; j++)
+            if(i != j && node[j].t - node[i].t >= map[node[i].p][node[j].p])
+            {
+                addedge(i, j);
+            }
+        }
+        int ans = gx - MaxMatch();
+        printf("Case %d: %d\n", cas++, ans - 1);
+    }
+    return 0;
+}
diff --git a/HDOJ/3992_autoAC.cpp b/HDOJ/3992_autoAC.cpp
new file mode 100644
index 0000000..016fd49
--- /dev/null
+++ b/HDOJ/3992_autoAC.cpp
@@ -0,0 +1,190 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+const int maxn=100000;
+struct Node
+{
+    int flag;
+    int id;
+    Node* next[26];
+    Node* fail;
+};
+Node* root;
+Node temp[maxn];
+int tp;
+void reset(Node* p)
+{
+    p->flag=0;p->id=tp-1;
+    for(int i=0;i<26;i++) p->next[i]=NULL;
+    p->fail=root;
+    if(p==root) p->fail=NULL;
+}
+void init()
+{
+    tp=0;
+    root=&temp[tp++];
+    reset(root);
+}
+void insert(char* str)
+{
+    Node* p=root;
+    for(int i=0;str[i];i++)
+    {
+        int x=str[i]-'a';
+        if(p->next[x]==NULL)
+        {
+            p->next[x]=&temp[tp++];
+            reset(p->next[x]);
+        }
+        p=p->next[x];
+    }
+    p->flag=1;
+}
+Node* que[maxn];
+int front,rear;
+void DFA()
+{
+    front=rear=0;
+    que[rear++]=root;
+    while(front<rear)
+    {
+        Node* t=que[front++];
+        for(int i=0;i<26;i++)
+        {
+            Node* cnt=t->next[i];
+            if(cnt!=NULL)
+            {
+                Node* fath=t->fail;
+                while(fath!=NULL&&fath->next[i]==NULL)
+                {
+                    fath=fath->fail;
+                }
+                if(fath==NULL)
+                {
+                    cnt->fail=root;
+                }
+                else cnt->fail=fath->next[i];
+                cnt->flag|=cnt->fail->flag;
+                que[rear++]=cnt;
+            }
+        }
+    }
+}
+double pet[26];
+int n;
+char str[maxn];
+double a[1000][1000];
+int equ,var;//浠0寮濮
+void toMatrix()
+{
+    var=rear;
+    equ=0;
+    memset(a,0,sizeof(a));
+    for(int i=0;i<rear;i++)
+    {
+        Node* p=&temp[i];
+        if(p->flag)
+        {
+            a[equ][p->id]=1;
+            a[equ++][var]=0;
+            continue;
+        }
+        a[equ][p->id]=-1;
+        a[equ][var]=-1;
+        for(int j=0;j<26;j++)
+        {
+            Node* cnt=p->next[j];
+            int k;
+            if(cnt!=NULL)
+            {
+                k=cnt->id;
+                a[equ][k]+=pet[j];
+            }
+            else
+            {
+                Node* fath=p->fail;
+                while(fath!=NULL&&fath->next[j]==NULL)
+                {
+                    fath=fath->fail;
+                }
+                if(fath!=NULL)
+                {
+                    k=fath->next[j]->id;
+                    a[equ][k]+=pet[j];
+                }
+                else
+                {
+                    k=0;
+                    a[equ][0]+=pet[j];
+                }
+            }
+        }
+        equ++;
+    }
+}
+const double eps=1e-10;
+double x[1000];
+void Gauss()
+{
+    for(int i=0;i<equ;i++)
+    {
+        int j;
+        for(j=i;j<equ;j++)
+        {
+            if(fabs(a[j][i])>eps) break;
+        }
+        for(int k=i;k<=var;k++) swap(a[i][k],a[j][k]);
+        for(j=i+1;j<equ;j++)
+        {
+            double p=-a[j][i]/a[i][i];
+            for(int k=i;k<=var;k++) a[j][k]+=a[i][k]*p;
+        }
+    }
+    for(int i=equ-1;i>=0;i--)
+    {
+        x[i]=a[i][var]/a[i][i];
+        a[i][var]/=a[i][i];a[i][i]=1;
+        for(int j=i-1;j>=0;j--)
+        {
+            a[j][var]+=-a[j][i]*a[i][var];
+            a[j][i]=0;
+        }
+    }
+}
+int main()
+{
+    while(scanf("%d",&n)==1)
+    {
+        init();
+        for(int i=0;i<26;i++) scanf("%lf",&pet[i]);
+        int flag=0;
+        for(int i=0;i<n;i++)
+        {
+            scanf("%s",str);
+            insert(str);
+            int f=1;
+            for(int j=0;str[j];j++)
+            {
+                int x=str[j]-'a';
+                if(fabs(pet[x])<eps)
+                {
+                    f=0;break;
+                }
+            }
+            if(f) flag=1;
+        }
+        if(!flag)
+        {
+            printf("Infinity\n");
+            continue;
+        }
+        DFA();
+        toMatrix();
+        Gauss();
+        printf("%.6lf\n",x[0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3993_autoAC.cpp b/HDOJ/3993_autoAC.cpp
new file mode 100644
index 0000000..eb220e4
--- /dev/null
+++ b/HDOJ/3993_autoAC.cpp
@@ -0,0 +1,24 @@
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+int a[20];
+int b[20];
+int main(){
+ int test,n;
+ scanf("%d",&test);
+ while (test--){
+ scanf("%d",&n);
+ for (int i=0;i<n;i++)
+ scanf("%d",&a[i]);
+ for (int j=0;j<n;j++)
+ scanf("%d",&b[j]);
+ int ans=0;
+ for (int i=0;i<n;i++)
+ for (int j=0;j<n;j++)
+ if (b[i]>a[j]) ans+=3;
+ printf("%.6lf\n",ans*1.0/n);
+ }
+ return 0;
+}
diff --git a/HDOJ/3994_autoAC.cpp b/HDOJ/3994_autoAC.cpp
new file mode 100644
index 0000000..bfbf144
--- /dev/null
+++ b/HDOJ/3994_autoAC.cpp
@@ -0,0 +1,97 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+#define MaxN 200
+#define eps 1e-8
+double dp[MaxN+5][MaxN+5];
+double tmp[MaxN+5][MaxN+5];
+int n;
+int c;
+int m;
+int lst[MaxN+5];
+void floyd(bool flag){
+    int i,j,k;
+    if (flag){
+        for (k=0;k<n;k++){
+            for (i=0;i<n;i++){
+                for (j=0;j<n;j++){
+                    if ((i==j) || (j==k) || (i==k)) continue;
+                    if (dp[i][j]<dp[i][k]*dp[k][j]){
+                        dp[i][j]=dp[i][k]*dp[k][j];
+                    }
+                }
+            }
+        }
+        return;
+    }
+    for (k=0;k<n;k++){
+        for (i=0;i<n;i++){
+            for (j=0;j<n;j++){
+                if ((i==j) || (j==k) || (i==k)) continue;
+                if (dp[i][k]>=0 && dp[k][j]>=0 && (dp[i][j]<0 || dp[i][j]>dp[i][k]+dp[k][j])){
+                    dp[i][j]=dp[i][k]+dp[k][j];
+                }
+            }
+        }
+    }
+}
+bool iszero(double a)
+{
+        return a<eps;
+}
+void init(){
+    int i,j;
+    scanf("%d",&n);    
+    for (i=0;i<n;i++){
+        for (j=0;j<n;j++){
+            scanf("%lf",&dp[i][j]);
+            dp[i][j]=dp[i][j]/100.0;
+        }
+    }
+    floyd(1);
+    scanf("%d",&m);
+    for (i=0;i<m;i++){
+        scanf("%d",&lst[i]);
+    }
+    for (i=0;i<m;i++){
+        if (lst[i]==1) break;
+    }
+    if (i==m) lst[m++]=1;
+    for (i=0;i<m;i++){
+        if (lst[i]==2) break;
+    }
+    if (i==m) lst[m++]=2;
+    sort(lst,lst+m);
+    for (i=0;i<m;i++){
+        for (j=i+1;j<m;j++){
+            tmp[i][j]=dp[lst[i]-1][lst[j]-1];
+            tmp[j][i]=dp[lst[j]-1][lst[i]-1];
+        }
+    }
+    for (i=0;i<m;i++){
+        for (j=0;j<m;j++){
+            if (iszero(tmp[i][j]))dp[i][j]=-1;
+            else dp[i][j]=1.0/tmp[i][j];
+            if (iszero(tmp[j][i]))dp[j][i]=-1;
+            else dp[j][i]=1.0/tmp[j][i];
+        }
+    }
+    n=m;
+    scanf("%d",&c);
+    floyd(0);
+}
+void solve(){
+    printf("%.6lf\n",dp[0][1]*c);
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while (t--){
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3995_autoAC.cpp b/HDOJ/3995_autoAC.cpp
new file mode 100644
index 0000000..b3a24f0
--- /dev/null
+++ b/HDOJ/3995_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+#define sqr(a) ((a)*(a))
+#define trarea(p) fabs ((vdet(p[0],p[1],p[2])/2.0))
+double const EPS = 1e-12;
+int const maxn = 20011;
+struct point{double x,y;int flag;};
+struct circle{
+        point c;
+        double r;
+};
+inline double vdet(point op,point p1,point p2){
+        return (p1.x-op.x)*(p2.y-op.y)-(p2.x-op.x)*(p1.y-op.y);
+}
+inline double dis(point a,point b){
+        return sqr(a.x-b.x)+sqr(a.y-b.y);
+}
+inline point get_out_circle(point p[]){  
+        double c1,c2,xa,xb,xc,ya,yb,yc;
+        point o;
+        xa=p[0].x,xb=p[1].x,xc=p[2].x;
+        ya = p[0].y,yb = p[1].y,yc = p[2].y;
+        c1 = (sqr(xa) + sqr(ya) - sqr(xb) - sqr(yb))/2.0;
+        c2 = (sqr(xa) + sqr(ya) - sqr(xc) - sqr(yc))/2.0;
+        o.x = (c1*(ya-yc)-c2*(ya-yb))/((xa-xb)*(ya-yc)-(xa-xc)*(ya-yb));
+        o.y = (c1*(xa-xc)-c2*(xa-xb))/((ya-yb)*(xa-xc)-(ya-yc)*(xa-xb));
+        return o;
+}
+inline double get_out_r(point p[]){  
+        double a = dis(p[0],p[1]),b = dis(p[1],p[2]),c = dis(p[2],p[0]),s = trarea(p);
+        return a*b*c/sqr(4*s);
+}
+point must_on[3],p[maxn];
+circle mc;
+inline void get_circle(int tm){  
+        switch(tm){
+                case 0:mc.r = -1;
+                       break;
+                case 1:mc.r = 0,mc.c = must_on[0];
+                       break;
+                case 2:{
+                               mc.r = dis(must_on[0],must_on[1])/4.0;
+                               mc.c.x = (must_on[0].x+must_on[1].x)/2.0;
+                               mc.c.y = (must_on[0].y + must_on[1].y)/2.0;
+                       }break;
+                case 3:{
+                               mc.r = get_out_r(must_on);
+                               mc.c = get_out_circle(must_on);
+                       }break;
+        }
+}
+inline void min_circle(int t,int ton){
+        get_circle(ton);
+        if(ton >= 3)return;
+        for(int i = 0; i < t; ++i){
+                if(p[i].flag == 1){
+                    if(dis(mc.c,p[i]) > mc.r + EPS){ 
+                        must_on[ton] = p[i];
+                        min_circle(i,ton+1);
+                    }
+                }
+                else {
+                    if(dis(mc.c,p[i]) + EPS < mc.r){ 
+                        must_on[ton] = p[i];
+                        min_circle(i,ton+1);
+                    }
+                }
+        }
+}
+int main(){
+        int n,m;
+        while (scanf("%d%d",&n,&m) != EOF){
+                for(int i = 0; i < n; ++i){
+                        scanf("%lf%lf",&p[i].x,&p[i].y);
+                        p[i].flag = 1;
+                }
+                for(int i = n; i < m + n; ++i){
+                        scanf("%lf%lf",&p[i].x,&p[i].y);
+                        p[i].flag = 2;
+                }
+                n = n + m;
+                random_shuffle(p,p+n); 
+                min_circle(n,0);
+                printf("%.3lf %.3lf\n%.3lf\n",mc.c.x,mc.c.y,sqrt(mc.r));
+        }
+        return 0;
+}
diff --git a/HDOJ/3996_autoAC.cpp b/HDOJ/3996_autoAC.cpp
new file mode 100644
index 0000000..cba63a3
--- /dev/null
+++ b/HDOJ/3996_autoAC.cpp
@@ -0,0 +1,111 @@
+#include<iostream>
+#include<algorithm>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int N=62002;
+const int M=62002;
+const __int64 INF=1LL<<60;
+int t,n,m,tot,cas=1;
+int gap[M],dis[M],pre[M],head[N],cur[N],vis[N];
+int NE,NV,sink,source;
+struct Node
+{
+    __int64 c;
+    int pos,next;
+} E[9999999];
+#define FF(i,NV) for(int i=0;i<NV;i++)
+__int64 sap(int s,int t)
+{
+    memset(dis,0,sizeof(int)*(NV+1));
+    memset(gap,0,sizeof(int)*(NV+1));
+    FF(i,NV) cur[i] = head[i];
+    int u = pre[s] = s;
+    __int64 maxflow = 0,aug =INF;
+    gap[0] = NV;
+    while(dis[s] < NV)
+    {
+loop:
+        for(int &i = cur[u]; i != -1; i = E[i].next)
+        {
+            int v = E[i].pos;
+            if(E[i].c && dis[u] == dis[v] + 1)
+            {
+                if(aug>E[i].c) aug=E[i].c;
+                pre[v] = u;
+                u = v;
+                if(v == t)
+                {
+                    maxflow += aug;
+                    for(u = pre[u]; v != s; v = u,u = pre[u])
+                    {
+                        E[cur[u]].c -= aug;
+                        E[cur[u]^1].c += aug;
+                    }
+                    aug =INF;
+                }
+                goto loop;
+            }
+        }
+        if( (--gap[dis[u]]) == 0)   break;
+        int mindis = NV;
+        for(int i = head[u]; i != -1 ; i = E[i].next)
+        {
+            int v = E[i].pos;
+            if(E[i].c >0&& mindis > dis[v])
+            {
+                cur[u] = i;
+                mindis = dis[v];
+            }
+        }
+        gap[ dis[u] = mindis+1 ] ++;
+        u = pre[u];
+    }
+    return maxflow;
+}
+void addEdge(int u,int v,__int64 c )
+{
+    E[NE].c = c;
+    E[NE].pos = v;
+    E[NE].next = head[u];
+    head[u] = NE++;
+    E[NE].c = 0;
+    E[NE].pos = u;
+    E[NE].next = head[v];
+    head[v] = NE++;
+}
+int main()
+{
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        int i,j,a,b,w,cost,val;
+        __int64 sum=0;
+        source=0,sink=3000,NE=0,NV=sink+1;
+        memset(head,-1,sizeof(int)*(NV));
+        for(int i=1; i<=n; i++)
+        {
+            scanf("%d",&m);
+            for(int j=1; j<=m; j++)
+            {
+                scanf("%d%d%d",&cost,&val,&w);
+                val-=cost;
+                if(val>0)
+                {
+                    addEdge(source,i*26+j,val);
+                    sum+=val;
+                }
+                else    addEdge(i*26+j,sink,-val);
+                while(w--)
+                {
+                    scanf("%d%d",&a,&b);
+                    addEdge(i*26+j,a*26+b,INF);
+                }
+            }
+        }
+        __int64 ans=sap(source,sink);
+        printf("Case #%d: %I64d\n",cas++,sum-ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3998_autoAC.cpp b/HDOJ/3998_autoAC.cpp
new file mode 100644
index 0000000..420748a
--- /dev/null
+++ b/HDOJ/3998_autoAC.cpp
@@ -0,0 +1,100 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring> 
+using namespace std ; 
+const int INF=0xfffffff ;
+struct node
+{
+    int s,t,cap,nxt ;
+}e[400005] ;
+int m,n,cnt,head[100005],level[100005],q[100005] ;
+void add(int s,int t,int cap)
+{
+    e[cnt].s=s ;e[cnt].t=t ;e[cnt].cap=cap ;e[cnt].nxt=head[s] ;head[s]=cnt++ ;
+    e[cnt].s=t ;e[cnt].t=s ;e[cnt].cap=0 ;e[cnt].nxt=head[t] ;head[t]=cnt++ ;
+}
+bool build(int s,int t)
+{
+    int front=0,rear=0 ;
+    memset(level,-1,sizeof(level)) ;
+    q[rear++]=s ;
+    level[s]=1 ;
+    while(front<rear)
+    {
+        int u=q[front++] ;
+        for(int i=head[u] ;i!=-1 ;i=e[i].nxt)
+        {
+            int tt=e[i].t ;
+            if(level[tt]==-1 && e[i].cap>0)
+            {
+                level[tt]=level[u]+1 ;
+                if(tt==t)return true ;
+                q[rear++]=tt ;
+            }
+        }
+    }
+    return false ;
+}
+int find(int s,int t,int flow)
+{
+    if(s==t)return flow ;
+    int ret=0,a ;
+    for(int i=head[s] ;i!=-1 ;i=e[i].nxt)
+    {
+        int tt=e[i].t ;
+        if(level[tt]==level[s]+1 && e[i].cap>0)
+        {
+            a=find(tt,t,min(e[i].cap,flow-ret)) ;
+            e[i].cap-=a ;
+            e[i^1].cap+=a ;
+            ret+=a ;
+            if(ret==flow)
+                return ret ;
+        }
+    }
+    if(!ret)level[s]=-1 ;
+    return ret ;
+}
+int dinic(int s,int t)
+{
+    int flow,ret=0 ;
+    while(build(s,t))
+        while(flow=find(s,t,INF))
+            ret+=flow ;
+    return ret ;
+}
+int a[1005],dp[1005] ;
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        for(int i=1 ;i<=n ;i++)
+            scanf("%d",&a[i]) ;
+        int ans=0 ;
+        for(int i=1 ;i<=n ;i++)
+        {
+            dp[i]=1 ;
+            for(int j=1 ;j<i ;j++)
+                if(a[j]<a[i] && dp[j]+1>dp[i])
+                    dp[i]=dp[j]+1 ;
+            ans=max(ans,dp[i]) ;
+        }
+        int S,T ;
+        S=0 ;T=2*n+1 ;
+        cnt=0 ;
+        memset(head,-1,sizeof(head)) ;
+        for(int i=1 ;i<=n ;i++)
+        {
+            add(i,i+n,1) ;
+            if(dp[i]==1)add(S,i,1) ;
+            if(dp[i]==ans)add(i+n,T,1) ;
+            for(int j=i+1 ;j<=n ;j++)
+            {
+                if(dp[j]==dp[i]+1)
+                    add(i+n,j,1) ;
+            }
+        }
+        printf("%d\n%d\n",ans,dinic(S,T)) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/3999_autoAC.cpp b/HDOJ/3999_autoAC.cpp
new file mode 100644
index 0000000..09346f4
--- /dev/null
+++ b/HDOJ/3999_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+struct node{
+    int num;
+    struct node *left;
+    struct node *right;
+}*tree;
+int tot=0;
+node *build(node *root,int num)
+{
+    if(root==NULL)
+    {
+        root=new node;
+        root->left=NULL;
+        root->right=NULL;
+        root->num=num;
+        return root;
+    }
+    else 
+    {
+        int t=root->num-num;;
+        if(t>0)
+            root->left=build(root->left,num);
+        else 
+            root->right=build(root->right,num);
+        return root;
+    }
+}
+bool first;
+void visit(node *root)
+{
+    if(root!=NULL&&!first)
+         printf(" %d",root->num);
+    else 
+    {
+        first=false;
+        printf("%d",root->num);
+    }
+}
+void preorder(node *root)
+{
+    if(root!=NULL)
+    {  
+        visit(root);
+        preorder(root->left);
+        preorder(root->right);
+    }
+}
+int main()
+{
+    int n,num;
+    while(scanf("%d",&n)!=EOF)
+    {
+        first=true;
+        int num;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&num);
+            tree=build(tree,num);
+        }
+        preorder(tree);
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/4000_autoAC.cpp b/HDOJ/4000_autoAC.cpp
new file mode 100644
index 0000000..45600c0
--- /dev/null
+++ b/HDOJ/4000_autoAC.cpp
@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <iostream>
+using namespace std;
+const int N=100001;
+int a, n, f[N];
+__int64 ans, tmp, tmp1;
+void insert(int i)
+{
+    for(; i<=n; i+=i&(-i))
+        f[i] += 1;
+}
+int query(int i)
+{
+    int tmp=0;
+    for(; i>0; i-=i&(-i))
+        tmp += f[i];
+    return tmp;
+}
+int main()
+{
+    int i, cas, cas1=1;
+    scanf("%d", &cas);
+    while(cas--)
+    {
+        scanf("%d", &n);
+        ans = 0;
+        for(i=1; i<=n; i++)
+            f[i] = 0;
+        for(i=1; i<=n; i++)
+        {
+            scanf("%d", &a);
+            insert(a);
+            tmp = query(a-1);
+            tmp1 = (n-a)-(i-1-tmp);
+            ans -= tmp*tmp1;
+            if(tmp1>=2)
+                ans += tmp1*(tmp1-1)/2;
+        }
+        printf("Case #%d: %I64d\n", cas1++, ans%100000007);
+    }
+    return 0;
+}
diff --git a/HDOJ/4001_autoAC.cpp b/HDOJ/4001_autoAC.cpp
new file mode 100644
index 0000000..784ae68
--- /dev/null
+++ b/HDOJ/4001_autoAC.cpp
@@ -0,0 +1,76 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+using namespace std;
+struct block
+{
+    int x,y,z,d;
+}b[1005];
+long long dp[1005];
+int n;
+bool cmp(block a,block b)
+{
+    if(a.x!=b.x)return a.x<b.x;
+    if(a.y!=b.y)return a.y<b.y;
+    return a.d>b.d;
+}
+void DP()
+{
+    long long ans=b[0].z;
+    for(int i=0;i<n;i++)
+    {
+        dp[i]=b[i].z;
+        ans=max(ans,dp[i]);
+    }
+    for(int i=1;i<n;i++)
+    {
+        if(b[i].d==0)
+        {
+            for(int j=0;j<i;j++)
+            {
+                if(b[j].x<=b[i].x&&b[j].y<=b[i].y)
+                    dp[i]=max(dp[i],dp[j]+b[i].z);
+            }
+        }
+        if(b[i].d==1)
+        {
+            for(int j=0;j<i;j++)
+            {
+                if(b[j].x<=b[i].x&&b[i].y>=b[j].y&&(b[i].y*b[j].y||b[i].x>b[j].x))
+                    dp[i]=max(dp[i],dp[j]+b[i].z);
+            }
+        }
+        if(b[i].d==2)
+        {
+            for(int j=0;j<i;j++)
+            {
+                if(b[i].x>b[j].x&&b[i].y>b[j].y)
+                {
+                    dp[i]=max(dp[i],dp[j]+b[i].z);
+                }
+            }
+        }
+        ans=max(ans,dp[i]);  
+    }
+    cout<<ans<<'\n';
+}
+int main()
+{
+    while(1)
+    {
+        scanf("%d",&n);
+        if(n==0)break;
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d%d%d%d",&b[i].x,&b[i].y,&b[i].z,&b[i].d);
+            if(b[i].x<b[i].y)
+                swap(b[i].x,b[i].y);
+        }
+        sort(b,b+n,cmp);
+        DP();
+    }
+    return 0;
+}
diff --git a/HDOJ/4002_autoAC.cpp b/HDOJ/4002_autoAC.cpp
new file mode 100644
index 0000000..32fae7d
--- /dev/null
+++ b/HDOJ/4002_autoAC.cpp
@@ -0,0 +1,82 @@
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <vector>
+#include <map>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+char tb[][150] = {
+"2",
+"6",
+"30",
+"210",
+"2310",
+"30030",
+"510510",
+"9699690",
+"223092870",
+"6469693230",
+"200560490130",
+"7420738134810",
+"304250263527210",
+"13082761331670030",
+"614889782588491410",
+"32589158477190044730",
+"1922760350154212639070",
+"117288381359406970983270",
+"7858321551080267055879090",
+"557940830126698960967415390",
+"40729680599249024150621323470",
+"3217644767340672907899084554130",
+"267064515689275851355624017992790",
+"23768741896345550770650537601358310",
+"2305567963945518424753102147331756070",
+"232862364358497360900063316880507363070",
+"23984823528925228172706521638692258396210",
+"2566376117594999414479597815340071648394470",
+"279734996817854936178276161872067809674997230",
+"31610054640417607788145206291543662493274686990",
+"4014476939333036189094441199026045136645885247730",
+"525896479052627740771371797072411912900610967452630",
+"72047817630210000485677936198920432067383702541010310",
+"10014646650599190067509233131649940057366334653200433090",
+"1492182350939279320058875736615841068547583863326864530410",
+"225319534991831177328890236228992001350685163362356544091910",
+"35375166993717494840635767087951744212057570647889977422429870",
+"5766152219975951659023630035336134306565384015606066319856068810",
+"962947420735983927056946215901134429196419130606213075415963491270",
+"166589903787325219380851695350896256250980509594874862046961683989710",
+"29819592777931214269172453467810429868925511217482600306406141434158090",
+"5397346292805549782720214077673687806275517530364350655459511599582614290",
+"1030893141925860008499560888835674370998623848299590975192766715520279329390",
+"198962376391690981640415251545285153602734402721821058212203976095413910572270",
+"39195588149163123383161804554421175259738677336198748467804183290796540382737190",
+"7799922041683461553249199106329813876687996789903550945093032474868511536164700810",
+"1645783550795210387735581011435590727981167322669649249414629852197255934130751870910",
+"367009731827331916465034565550136732339800312955331782619462457039988073311157667212930",
+"83311209124804345037562846379881038241134671040860314654617977748077292641632790457335110",
+"19078266889580195013601891820992757757219839668357012055907516904309700014933909014729740190",
+"4445236185272185438169240794291312557432222642727183809026451438704160103479600800432029464270",
+"1062411448280052319722448549835623701226301211611796930357321893850294264731624591303255041960530",
+"256041159035492609053110100510385311995538591998443060216114576417920917800321526504084465112487730",
+"64266330917908644872330635228106713310880186591609208114244758680898150367880703152525200743234420230"
+};
+int main()
+{
+    char str[150];
+    int t;
+    cin>>t;
+    while(t--){
+        scanf("%s",str);
+        int i = 0;
+        for(;;i++){
+            if(strlen(str)>strlen(tb[i])) continue;
+            if(strlen(str)<strlen(tb[i])) break;
+            if(strcmp(str,tb[i])<0) break;
+        }
+        cout<<tb[i-1]<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4003_autoAC.cpp b/HDOJ/4003_autoAC.cpp
new file mode 100644
index 0000000..120c9aa
--- /dev/null
+++ b/HDOJ/4003_autoAC.cpp
@@ -0,0 +1,65 @@
+#include<stdio.h>
+#include<algorithm>
+#include<string.h>
+#include<iostream>
+using namespace std;
+const int MAXN=10010;
+struct Node
+{
+    int to;
+    int next;
+    int cost;
+}edge[MAXN*2];
+int head[MAXN];
+int tol;
+int dp[MAXN][11];
+void init()
+{
+    memset(head,-1,sizeof(head));
+    tol=0;
+    memset(dp,0,sizeof(dp));
+}
+void add(int a,int b,int val)
+{
+    edge[tol].to=b;
+    edge[tol].cost=val;
+    edge[tol].next=head[a];
+    head[a]=tol++;
+    edge[tol].to=a;
+    edge[tol].cost=val;
+    edge[tol].next=head[b];
+    head[b]=tol++;
+}
+int N,K;
+void dfs(int u,int pre)
+{
+    for(int i=head[u];i!=-1;i=edge[i].next)
+    {
+        int v=edge[i].to;
+        if(v==pre)continue;
+        dfs(v,u);
+        for(int k=K;k>=0;k--)
+        {
+            dp[u][k]+=dp[v][0]+2*edge[i].cost;
+            for(int j=1;j<=k;j++)
+              dp[u][k]=min(dp[u][k],dp[u][k-j]+dp[v][j]+j*edge[i].cost);
+        }
+    }
+}
+int main()
+{
+    int S;
+    int a,b,val;
+    while(scanf("%d%d%d",&N,&S,&K)!=EOF)
+    {
+        init();
+        for(int i=1;i<N;i++)
+        {
+            scanf("%d%d%d",&a,&b,&val);
+            add(a,b,val);
+        }
+        dfs(S,-1);
+        printf("%d\n",dp[S][K]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4004_autoAC.cpp b/HDOJ/4004_autoAC.cpp
new file mode 100644
index 0000000..c73a371
--- /dev/null
+++ b/HDOJ/4004_autoAC.cpp
@@ -0,0 +1,45 @@
+#include<iostream>
+#include<algorithm>
+using namespace std;
+int a[500005];
+int l,n,m;
+int solve(int step){
+    int s=0,count=0,i=0;
+    while(s<l){
+        s+=step;
+        while(a[i]<=s)
+            i++;
+        s=a[i-1];
+        count++;
+    }
+    return count;
+}
+int binary_search(int low,int high){
+    int left=low,right=high,mid;
+    while(left<right){
+        mid=(left+right)/2;
+        if(solve(mid)<=m){
+            right=mid;
+        }
+        else{
+            left=mid+1;
+        }
+    }
+    return left;
+}
+int main(){
+    while(cin>>l>>n>>m){
+        int ans,i;
+        for(i=0;i<n;i++)
+            scanf("%d",&a[i]);
+        sort(a,a+n);
+        a[n]=l; a[n+1]=l*2;
+        ans=a[0];
+        for(i=1;i<=n;i++)
+            if(a[i]-a[i-1]>ans)
+                ans=a[i]-a[i-1];
+        ans=binary_search(ans,l);
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4005_autoAC.cpp b/HDOJ/4005_autoAC.cpp
new file mode 100644
index 0000000..0ad1831
--- /dev/null
+++ b/HDOJ/4005_autoAC.cpp
@@ -0,0 +1,115 @@
+#include<stdio.h>
+#include<string.h>
+#include<vector>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+const int maxn = 10010;
+int tot,n,m,ans;
+const int inf = 999999999;
+struct Edge
+{
+    int t,w;
+    int next;
+    int vis;
+}edge[1000005];
+int head[maxn],E;
+void add(int s,int t,int w)
+{
+    edge[E].t=t;
+    edge[E].w=w;
+    edge[E].vis=0;
+    edge[E].next=head[s];
+    head[s]=E++;
+}
+int Btype,Time,N,M;
+int dfn[maxn],low[maxn],belong[maxn];
+int  st[maxn],Top;
+int tt[100010][3],cnt;
+inline int min(int a,int b){return a<b?a:b;}
+void dfs(int s)
+{
+    int i,t;
+    st[++Top]=s;
+    dfn[s]=low[s]=++Time;
+    for (i=head[s];i!=-1;i=edge[i].next)
+    {    
+        if(edge[i].vis)continue;    
+        edge[i].vis=edge[i^1].vis=1;
+        t=edge[i].t;
+        if (!dfn[t])
+        {
+            dfs(t);
+            low[s]=min(low[s],low[t]);
+            if(dfn[s]<low[t])  
+            {
+                tt[++cnt][0]=s,tt[cnt][1]=t,tt[cnt][2]=edge[i].w;
+            }
+        }
+        else low[s]=min(low[s],dfn[t]);
+    }
+    if(dfn[s]==low[s])
+    {
+        Btype++;
+        do{
+            t=st[Top--];
+            belong[t]=Btype;
+        }while(t!=s);
+    }
+}
+void SCC(int n)
+{
+    int i;
+    Time=0;Btype=0;Top=0;
+    memset(dfn,0,sizeof(int)*(n+1));
+    for(i=1;i<=n;i++)if(!dfn[i])
+        dfs(i);
+}
+int find(int s,int t)
+{
+    int i;
+    int Min=inf,vice_Min=inf,rr=inf;
+    for(i=head[s];i!=-1;i=edge[i].next)
+    {
+        int v=edge[i].t;
+        if(v==t) continue;
+        int w=find(v,s);
+        if(w<vice_Min) vice_Min=w; 
+        if(edge[i].w<vice_Min) vice_Min=edge[i].w;
+        if(Min>vice_Min) swap(vice_Min,Min);
+        if(Min<rr) rr=Min;
+    }
+    if(ans>vice_Min) ans=vice_Min;
+    return rr;
+}
+int a1,a2,flag;
+int main()
+{
+    int i,a,b,w;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        memset(head,-1,sizeof(head));E=0;
+        for(i=0;i<m;i++)
+        {
+            scanf("%d%d%d",&a,&b,&w);
+            add(a,b,w);
+            add(b,a,w);
+        }
+        cnt=0;     
+        SCC(n);
+        memset(head,-1,sizeof(head));E=0;
+        int C=inf;
+        for(i=1;i<=cnt;i++)
+        {
+            add(belong[tt[i][0]],belong[tt[i][1]],tt[i][2]);
+            add(belong[tt[i][1]],belong[tt[i][0]],tt[i][2]);
+            if(tt[i][2]<C){C=tt[i][2]; a=belong[tt[i][0]],b=belong[tt[i][1]];}
+        }
+        ans=inf;
+        find(a,b);
+        find(b,a);
+        if(ans==inf) printf("-1\n");
+        else printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4006_autoAC.cpp b/HDOJ/4006_autoAC.cpp
new file mode 100644
index 0000000..f85c094
--- /dev/null
+++ b/HDOJ/4006_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<queue>
+#include<iostream>
+#include<vector>
+using namespace std;
+struct mycmp
+{
+    bool operator()(const int &a,const int &b)
+    {
+        return a>b;
+    }
+};
+int main()
+{
+    int n,k,val;
+    char str[5];
+    int count;
+    while(scanf("%d%d",&n,&k)!=EOF)
+    {
+        priority_queue<int,vector<int>,mycmp> pq;
+        while(n--)
+        {
+            scanf("%s",str);
+            if(str[0]=='I')
+            {
+                scanf("%d",&val);
+                pq.push(val);
+                while(pq.size()>k)
+                    pq.pop();
+            }
+            else 
+            {
+                printf("%d\n",pq.top());
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4007_autoAC.cpp b/HDOJ/4007_autoAC.cpp
new file mode 100644
index 0000000..0116165
--- /dev/null
+++ b/HDOJ/4007_autoAC.cpp
@@ -0,0 +1,60 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<queue>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+const int INF=1000100000;
+struct node
+{
+    int x,y;
+}n[1010];
+bool cmp(node a,node b)
+{
+    return a.x<b.x;
+}
+int main()
+{
+    int p,r,xmax,xmin,ymax,ymin,y[1010];
+    while(scanf("%d%d",&p,&r)!=EOF)
+    {
+        ymax=xmax=-INF;ymin=xmin=INF;
+        for(int i=0;i<p;i++)
+        {
+            scanf("%d%d",&n[i].x,&n[i].y);
+            if(ymax<n[i].y)ymax=n[i].y;
+            if(ymin>n[i].y)ymin=n[i].y;
+            if(xmax<n[i].x)xmax=n[i].x;
+            if(xmin>n[i].x)xmin=n[i].x;
+        }
+        if((ymax-ymin<=r)&&(xmax-xmin<=r))
+        {
+            printf("%d\n",p);
+            continue;
+        }
+        else
+        {
+            sort(n,n+p,cmp);
+            int ans=0;
+            for(int i=0;i<p;i++)
+            {
+                int k=0;
+                for(int j=i;n[j].x<=n[i].x+r&&j<p;j++)
+                {
+                    y[k++]=n[j].y;
+                }
+                sort(y,y+k);
+                int count=0,tem=0;
+                for(int j=0;j<k&&tem<k;j++)
+                {
+                    while(y[tem]-y[j]<=r&&tem<k)tem++;
+                    if(count<tem-j)count=tem-j;
+                }
+                if(ans<count)ans=count;
+            }
+            printf("%d\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4008_autoAC.cpp b/HDOJ/4008_autoAC.cpp
new file mode 100644
index 0000000..b8bfefa
--- /dev/null
+++ b/HDOJ/4008_autoAC.cpp
@@ -0,0 +1,131 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int MAXN = 100000 + 1234;
+struct EDGE
+{
+    int u, v;
+} edge[MAXN * 2];
+int cnt;
+int minchild[MAXN][2];
+int mindown[MAXN];
+int fa[MAXN][20];
+int head[MAXN];
+int n;
+int depth[MAXN], maxdepth, topk;
+bool cmp(EDGE a, EDGE b)
+{
+    if(a. u != b.u)  return a.u < b.u;
+    return a.v < b.v;
+}
+void insert(int *s, int x)
+{
+    if(x < s[0])
+    {
+        s[1] = s[0];
+        s[0] = x;
+    }
+    else if(x < s[1])  s[1] = x;
+}
+void dfs(int root)
+{
+    minchild[root][0] = minchild[root][1] = mindown[root] = n + 1;
+    for(int p = head[root]; p < cnt && edge[p].u == root; p++)
+    {
+        int v = edge[p].v;
+        if(v == fa[root][0])  continue;
+        fa[v][0] = root;
+        insert(minchild[root], v);
+        depth[v] = depth[root] + 1;
+        dfs(v);
+        mindown[root] = min(mindown[root], mindown[v]);
+    }
+    maxdepth = max(maxdepth, depth[root]);
+    mindown[root] = min(mindown[root], minchild[root][0]);
+}
+int findfather(int x, int step)
+{
+    int k = topk - 1;
+    while(step > 0)
+    {
+        while((1 << k) > step) k--;
+        x = fa[x][k];
+        step -= (1 << k);
+    }
+    return x;
+}
+int main()
+{
+    int T;
+    int q, x, y;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%d%d", &n, &q);
+        cnt = n - 1;
+        for(int i = 0; i < cnt; i++)
+        {
+            scanf("%d%d", &edge[i].u, &edge[i].v);
+            edge[i + cnt].u = edge[i].v;
+            edge[i + cnt].v = edge[i].u;
+        }
+        cnt = cnt + cnt;
+        sort(edge, edge + cnt, cmp);
+        head[1] = 0;
+        for(int i = 1; i < cnt; i++)
+            if(edge[i].u != edge[i-1].u)  head[edge[i].u] = i;
+        fa[1][0] = 0;
+        depth[1] = maxdepth = 0;
+        dfs(1);
+        topk = 0;
+        while((1 << topk) <= maxdepth)  topk++;
+        for(int k = 1; k < topk; k++)
+            for(int i = 1; i <= n; i++)
+                if(fa[i][k - 1] != 0)  fa[i][k] = fa[fa[i][k-1]][k-1];
+        int mindown1[2];
+        mindown1[0] = mindown1[1] = n + 1;
+        for(int p = head[1]; p < cnt && edge[p].u == 1; p++)
+        {
+            int v = edge[p].v;
+            int rv = min(mindown[v], v);
+            insert(mindown1, rv);
+        }
+        while(q--)
+        {
+            scanf("%d%d", &x, &y);
+            int ans1 = n + 1, ans2 =n + 1;
+            if(y == 1)
+            {
+                int z = findfather(x, depth[x] - depth[y] - 1);
+                int rz = min(z, mindown[z]);
+                ans1 = (z == minchild[1][0] ? minchild[1][1] : minchild[1][0]);
+                ans2 = (rz == mindown1[0] ? mindown1[1] : mindown1[0]);
+            }
+            else
+            {
+                bool flag = false;
+                int z;
+                if(depth[y] < depth[x])
+                {
+                    z = findfather(x, depth[x] - depth[y] - 1);
+                    if(fa[z][0] == y)  flag = true;
+                }
+                if(flag)
+                {
+                    ans1 = (z == minchild[y][0] ? min(minchild[y][1], fa[y][0]) : min(minchild[y][0], fa[y][0]));
+                    ans2 = 1;
+                }
+                else
+                {
+                    ans1 = minchild[y][0];
+                    ans2 = mindown[y];
+                }
+            }
+            if (ans1 > n) printf("no answers!\n");
+            else printf("%d %d\n", ans1, ans2);
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/4009_autoAC.cpp b/HDOJ/4009_autoAC.cpp
new file mode 100644
index 0000000..5129a3e
--- /dev/null
+++ b/HDOJ/4009_autoAC.cpp
@@ -0,0 +1,122 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+using namespace std;
+#define INF 0x3FFFFFF
+#define MAXN 2222
+struct edge
+{
+    int  u,v,w;
+}e[99999999];
+int  a,b,c; 
+int n,en;
+int pre[MAXN],in[MAXN],id[MAXN],vis[MAXN];
+int x[MAXN],y[MAXN],z[MAXN]; 
+int getdis(int i,int j)
+{
+    return abs(x[i]-x[j])+abs(y[i]-y[j])+abs(z[i]-z[j]);
+}
+void add(int u,int v,int w)
+{
+    e[en].u=u;
+    e[en].v=v;
+    e[en++].w=w;
+}
+int zl(int root ,int vn)
+{
+    int ans=0;
+    int cnt;
+    while(1)  
+    {
+        for(int i=0;i<vn;i++)
+            in[i]=INF,id[i]=-1,vis[i]=-1;
+        for(int i=0;i<en;i++)
+        {
+            if(in[e[i].v]>e[i].w && e[i].u!=e[i].v)
+            {
+                pre[e[i].v]=e[i].u;
+                in[e[i].v]=e[i].w;
+            } 
+        }
+        in[root]=0;
+        pre[root]=root;
+        for(int i=0;i<vn;i++)
+        {
+            ans+=in[i];
+            if(in[i]==INF)
+                 return -1; 
+        }
+        cnt=0; 
+        for(int i=0;i<vn;i++)
+        {
+            if(vis[i]==-1)
+            {
+                int t=i;
+                while(vis[t]==-1)
+                {
+                    vis[t]=i;
+                    t=pre[t];
+                }
+                if(vis[t]!=i || t==root) continue;
+                for(int j=pre[t];j!=t;j=pre[j])
+                    id[j]=cnt;
+                id[t]=cnt++;
+            }
+        }
+        if(cnt==0) break;
+        for(int i=0;i<vn;i++)
+            if(id[i]==-1)  
+                id[i]=cnt++;
+        for(int i=0;i<en;i++)
+        {
+            int u,v;
+            u=e[i].u;
+            v=e[i].v;
+            e[i].u=id[u];
+            e[i].v=id[v];
+            e[i].w-=in[v];
+        }
+        vn=cnt;
+        root=id[root];
+    }
+    return ans;
+}
+void solve()
+{
+    int cnt,j;
+    en=0;
+    for(int i=1;i<=n;i++)
+    {
+        scanf("%d%d%d",&x[i],&y[i],&z[i]);
+        add(0,i,z[i]*a);
+    }
+    for(int i=1;i<=n;i++)
+    {
+        scanf("%d",&cnt);
+        for(int k=1;k<=cnt;k++)
+        {
+            scanf("%d",&j);
+            if(i==j)
+                continue;
+            if(z[i]>=z[j])
+                add(i,j,getdis(i,j)*b);
+            else
+                add(i,j,getdis(i,j)*b+c);
+        }
+    }
+    int ans=zl(0,n+1);
+    if(ans==-1)
+    {
+        printf("poor XiaoA\n");
+        return;
+    }
+    printf("%d\n",ans);    
+}
+int main()
+{
+    while(scanf("%d%d%d%d",&n,&a,&b,&c)!=EOF && n+a+b+c)
+        solve();
+    return 0;
+}
diff --git a/HDOJ/4010_autoAC.cpp b/HDOJ/4010_autoAC.cpp
new file mode 100644
index 0000000..54b32b6
--- /dev/null
+++ b/HDOJ/4010_autoAC.cpp
@@ -0,0 +1,252 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int MAXN = 300010;
+int ch[MAXN][2],pre[MAXN],key[MAXN];
+int add[MAXN],rev[MAXN],Max[MAXN];
+bool rt[MAXN];
+void Update_Add(int r,int d)
+{
+    if(!r)return;
+    key[r] += d;
+    add[r] += d;
+    Max[r] += d;
+}
+void Update_Rev(int r)
+{
+    if(!r)return;
+    swap(ch[r][0],ch[r][1]);
+    rev[r] ^= 1;
+}
+void push_down(int r)
+{
+    if(add[r])
+    {
+        Update_Add(ch[r][0],add[r]);
+        Update_Add(ch[r][1],add[r]);
+        add[r] = 0;
+    }
+    if(rev[r])
+    {
+        Update_Rev(ch[r][0]);
+        Update_Rev(ch[r][1]);
+        rev[r] = 0;
+    }
+}
+void push_up(int r)
+{
+    Max[r] = max(max(Max[ch[r][0]],Max[ch[r][1]]),key[r]);
+}
+void Rotate(int x)
+{
+    int y = pre[x], kind = ch[y][1]==x;
+    ch[y][kind] = ch[x][!kind];
+    pre[ch[y][kind]] = y;
+    pre[x] = pre[y];
+    pre[y] = x;
+    ch[x][!kind] = y;
+    if(rt[y])
+        rt[y] = false, rt[x] = true;
+    else
+        ch[pre[x]][ch[pre[x]][1]==y] = x;
+    push_up(y);
+}
+void P(int r)
+{
+    if(!rt[r])P(pre[r]);
+    push_down(r);
+}
+void Splay(int r)
+{
+    P(r);
+    while( !rt[r] )
+    {
+        int f = pre[r], ff = pre[f];
+        if(rt[f])
+            Rotate(r);
+        else if( (ch[ff][1]==f)==(ch[f][1]==r) )
+            Rotate(f), Rotate(r);
+        else
+            Rotate(r), Rotate(r);
+    }
+    push_up(r);
+}
+int Access(int x)
+{
+    int y = 0;
+    for( ; x ; x = pre[y=x])
+    {
+        Splay(x);
+        rt[ch[x][1]] = true, rt[ch[x][1]=y] = false;
+        push_up(x);
+    }
+    return y;
+}
+bool judge(int u,int v)
+{
+    while(pre[u]) u = pre[u];
+    while(pre[v]) v = pre[v];
+    return u == v;
+}
+void mroot(int r)
+{
+    Access(r);
+    Splay(r);
+    Update_Rev(r);
+}
+void lca(int &u,int &v)
+{
+    Access(v), v = 0;
+    while(u)
+    {
+        Splay(u);
+        if(!pre[u])return;
+        rt[ch[u][1]] = true;
+        rt[ch[u][1]=v] = false;
+        push_up(u);
+        u = pre[v = u];
+    }
+}
+void link(int u,int v)
+{
+    if(judge(u,v))
+    {
+        puts("-1");
+        return;
+    }
+    mroot(u);
+    pre[u] = v;
+}
+void cut(int u,int v)
+{
+    if(u == v || !judge(u,v))
+    {
+        puts("-1");
+        return;
+    }
+    mroot(u);
+    Splay(v);
+    pre[ch[v][0]] = pre[v];
+    pre[v] = 0;
+    rt[ch[v][0]] = true;
+    ch[v][0] = 0;
+    push_up(v);
+}
+void ADD(int u,int v,int w)
+{
+    if(!judge(u,v))
+    {
+        puts("-1");
+        return;
+    }
+    lca(u,v);
+    Update_Add(ch[u][1],w);
+    Update_Add(v,w);
+    key[u] += w;
+    push_up(u);
+}
+void query(int u,int v)
+{
+    if(!judge(u,v))
+    {
+        puts("-1");
+        return;
+    }
+    lca(u,v);
+    printf("%d\n",max(max(Max[v],Max[ch[u][1]]),key[u]));
+}
+struct Edge
+{
+    int to,next;
+}edge[MAXN*2];
+int head[MAXN],tot;
+void addedge(int u,int v)
+{
+    edge[tot].to = v;
+    edge[tot].next = head[u];
+    head[u] = tot++;
+}
+void dfs(int u)
+{
+    for(int i = head[u];i != -1; i = edge[i].next)
+    {
+        int v = edge[i].to;
+        if(pre[v] != 0)continue;
+        pre[v] = u;
+        dfs(v);
+    }
+}
+int main()
+{
+    int n,q,u,v;
+    while(scanf("%d",&n) == 1)
+    {
+        tot = 0;
+        for(int i = 0;i <= n;i++)
+        {
+            head[i] = -1;
+            pre[i] = 0;
+            ch[i][0] = ch[i][1] = 0;
+            rev[i] = 0;
+            add[i] = 0;
+            rt[i] = true;
+        }
+        Max[0] = -2000000000;
+        for(int i = 1;i < n;i++)
+        {
+            scanf("%d%d",&u,&v);
+            addedge(u,v);
+            addedge(v,u);
+        }
+        for(int i = 1;i <= n;i++)
+        {
+            scanf("%d",&key[i]);
+            Max[i] = key[i];
+        }
+        scanf("%d",&q);
+        pre[1] = -1;
+        dfs(1);
+        pre[1] = 0;
+        int op;
+        while(q--)
+        {
+            scanf("%d",&op);
+            if(op == 1)
+            {
+                int x,y;
+                scanf("%d%d",&x,&y);
+                link(x,y);
+            }
+            else if(op == 2)
+            {
+                int x,y;
+                scanf("%d%d",&x,&y);
+                cut(x,y);
+            }
+            else if(op == 3)
+            {
+                int w,x,y;
+                scanf("%d%d%d",&w,&x,&y);
+                ADD(x,y,w);
+            }
+            else
+            {
+                int x,y;
+                scanf("%d%d",&x,&y);
+                query(x,y);
+            }
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4011_autoAC.cpp b/HDOJ/4011_autoAC.cpp
new file mode 100644
index 0000000..b96dff6
--- /dev/null
+++ b/HDOJ/4011_autoAC.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <stdio.h>
+using namespace std;
+#define min(a,b) ((a)<(b)?(a):(b))
+const long  N=100010;
+__int64 a[N],aa,minx;
+int main()
+{
+    int n,t,b;
+    int i,j,k;
+      while (cin>>t)
+      {
+          minx=k=0;
+          while (t--)
+          {
+              scanf("%d%I64d%d",&n,&aa,&b);
+              minx=n*b+2*aa;
+              scanf("%I64d",&a[0]);
+              for (i=1;i<n;i++)
+              {
+                  scanf("%I64d",&a[i]);
+                  if(a[i]-1==a[i-1]) continue;
+                  minx+=min((a[i]-a[i-1]-1)*b,2*aa);
+              }
+              printf("Case #%d: %I64d\n",++k,minx);
+          }
+      }
+return 0;
+}
diff --git a/HDOJ/4012_autoAC.cpp b/HDOJ/4012_autoAC.cpp
new file mode 100644
index 0000000..f37c81c
--- /dev/null
+++ b/HDOJ/4012_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<cstdio>
+#include<cstring>
+#include<queue>
+using namespace std;
+int n;
+char maze[20];
+bool vis[1<<16];
+int bfs(){
+    queue<pair<int,int> > que;
+    que.push(make_pair(0,0));
+    memset(vis,false,sizeof(vis));
+    vis[0]=true;
+    while(!que.empty()){
+        int u=que.front().first;
+        int d=que.front().second;
+        que.pop();
+        for(int i=0;i<(n<<1);i++){
+            if(u&(1<<i)) continue;
+            int v=0;
+            for(int j=i;j<(i/n+1)*n;j++){
+                if(u&(1<<j)) break;
+                if(maze[j]==maze[i]) v|=(1<<j);
+            }
+            for(int j=i-1;j>=(i/n)*n;j--){
+                if(u&(1<<j)) break;
+                if(maze[j]==maze[i]) v|=(1<<j);
+            }
+            if((u|v)==(1<<(n<<1))-1) return d+1;
+            for(int j=v;j;j=v&(j-1)){
+                if(vis[j|u]) continue;
+                vis[j|u]=true;
+                que.push(make_pair(j|u,d+1));
+            }
+            if(i/n) continue;
+            if(u&(1<<(i+n))) continue;
+            v=0;
+            for(int j=i;j<n;j++){
+                if((u&(1<<j))|(u&(1<<(j+n)))) break;
+                if(maze[j]==maze[i]) v|=1<<j;
+                if(maze[j+n]==maze[i]) v|=1<<(j+n);
+            }
+            for(int j=i-1;j>=0;j--){
+                if((u&(1<<j))|(u&(1<<(j+n)))) break;
+                if(maze[j]==maze[i]) v|=1<<j;
+                if(maze[j+n]==maze[i]) v|=1<<(j+n);
+            }
+            if((u|v)==(1<<(n<<1))-1) return d+1;
+            for(int j=v;j;j=v&(j-1)){
+                if(vis[j|u]) continue;
+                vis[j|u]=true;
+                que.push(make_pair(j|u,d+1));
+            }
+        }
+    }
+}
+int main(){
+    int t,cas=0;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        scanf("%s",maze);
+        scanf("%s",maze+n);
+        int ans=bfs();
+        printf("Case #%d: %d\n",++cas,ans);
+    }
+}
diff --git a/HDOJ/4013_autoAC.cpp b/HDOJ/4013_autoAC.cpp
new file mode 100644
index 0000000..63332e4
--- /dev/null
+++ b/HDOJ/4013_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <vector>
+#define N 20
+using namespace std;
+struct trie
+{
+       bool cover;
+       int son[2];
+       void init()
+       {
+            cover = false;
+            memset (son,0,sizeof (son));
+       }
+}tt[70000];
+vector <int> w[N];
+bool vis[N];
+int index;
+bool insert (string s)
+{
+     int len = s.size (),p = 0;
+     for (int i = 0;i < len;i ++)
+     {
+         if (tt[p].son[s[i] - '0'] == 0)
+         {
+            tt[index].init();
+            tt[p].son[s[i] - '0'] = index ++;
+         }
+         p = tt[p].son[s[i] - '0'];
+     }
+     if (tt[p].cover) return false;
+     tt[p].cover = true;
+     return true;
+}
+string dfs (int u,int fa)
+{
+       string s = "0";
+       vector<string> q;
+       q.clear ();
+       int len = w[u].size ();
+       for (int i = 0;i < len;i ++)
+       {
+           int v = w[u][i];
+           if (vis[v] && v != fa) q.push_back ( dfs(v,u) );
+       }
+       sort (q.begin(),q.end());
+       for (int i = 0;i < q.size ();i ++) s += q[i];
+       s += "1";
+       return s;
+}
+int main ()
+{
+    int cas,c = 0,n,x,y,ans;
+    scanf ("%d",&cas);
+    while (cas --)
+    {
+          index = 1;
+          ans = 0;
+          tt[0].init();
+          scanf ("%d",&n);
+          int len = 1 << n;
+          for (int i = 0;i < n;i ++) w[i].clear ();
+          for (int i = 1;i < n;i ++)
+          {
+              scanf ("%d%d",&x,&y);
+              w[x - 1].push_back(y - 1);
+              w[y - 1].push_back(x - 1);
+          }
+          int i,j;
+          for (i = 1;i < len;i ++)
+          {
+              memset (vis,false,sizeof (vis));
+              for (j = 0;j < n;j ++)
+                  if (i & (1 << j)) vis[j] = true;
+              int k = 0;
+              for (j = 0;j < n;j ++)
+              {
+                  if (vis[j])
+                  {
+                     string s = dfs (j,j);
+                     if (insert(s)) k = 1;
+                     if (k == 0) break;
+                  }
+              }
+              if (j == n) ans ++;
+          }
+          printf ("Case #%d: %d\n",++c,ans);
+    }
+return 0;
+}
diff --git a/HDOJ/4014_autoAC.cpp b/HDOJ/4014_autoAC.cpp
new file mode 100644
index 0000000..5137fd6
--- /dev/null
+++ b/HDOJ/4014_autoAC.cpp
@@ -0,0 +1,135 @@
+#include<iostream>
+#include<stdio.h>
+#include<vector>
+#include<string.h>
+#include<algorithm>
+using namespace std ;
+const int N = 100010;
+const int M = 500010;
+const long long K = 100000;
+int n , m ;
+struct node {
+    int u , v ;
+    long long cnt ;
+    bool operator < ( const node &a ) const {
+        if( u != a.u ) return u < a.u ;
+        else return v < a.v ;
+    }
+} e[M] ;
+int tot ;
+int in[N] ;
+const int HASH = 300007;
+struct HASHMAP {
+    long long key[N] , f[N] ;
+    int head[HASH] , next[N] , size ;
+    void init() {
+        memset( head , -1 , sizeof head ) ;
+        size = 0 ;
+    }
+    void insert( int u , int v , long long ans ) {
+        long long KEY = K * u + v ;
+        int c = KEY % HASH ;
+        f[size] = ans ;
+        key[size] = KEY ;
+        next[size] = head[c] ;
+        head[c] = size++;
+    }
+    long long find( int u , int v ) {
+        long long KEY = K * u + v ;
+        int c = KEY % HASH ;
+        for( int i = head[c] ; ~i ; i = next[i] ) {
+            if( key[i] == KEY ) return f[i] ;
+        }
+        return -1 ;
+    }
+} mp ;
+long long find( int u , int v ) {
+    int l = 0 , r = m - 1 ;
+    if( l > r ) return -1 ;
+    if( u > e[r].u || ( u == e[r].u && v > e[r].v ) ) return -1 ;
+    if( v < e[l].v || ( v == e[l].v && u < e[l].u ) ) return -1 ;
+    while( l <= r ) {
+        int mid = (l+r)>>1;
+        if( u < e[mid].u ) {
+            r = mid - 1 ;
+        }
+        else if( u == e[mid].u ) {
+            if( v < e[mid].v ) r = mid - 1 ;
+            else if( v > e[mid].v ) l = mid + 1 ;
+            else return e[mid].cnt ;
+        }
+        else {
+            l = mid + 1 ;
+        }
+    }
+    return -1 ;
+}
+vector< pair<int,long long> >g[N];
+void Work() {
+    mp.init();
+    int q ; cin >> q ;
+    while( q-- ) {
+        int u , v ; cin >> u >> v ;
+        u-- , v-- ;
+        if( u > v ) swap( u , v ) ;
+        else if( u == v ) { cout << "0 1"<< endl ; continue ; }
+        long long ans = find( u , v ) ;
+        if( ans != -1 ) {
+            cout << "1 " << ans << endl ;
+        } else {
+            ans = mp.find( u , v ) ;
+            if( ans == -1 ) {
+                ans = 0 ;
+                if( in[u] > in[v] ) swap( u , v ) ;
+                for( int i = 0 ; i < g[u].size() ; ++i ) {
+                    int mid = g[u][i].first ;
+                    long long cnt1 = g[u][i].second , cnt2 = find( min(mid,v) , max(mid,v) );
+                    if( cnt2 != -1 ) ans += cnt1 * cnt2 ;
+                }
+                if( u > v ) swap( u , v ) ;
+                mp.insert( u , v , ans ) ;
+            }
+            if( ans ) cout << "2 " << ans << endl ;
+            else cout << "The pair of cities are not connected or too far away." << endl ;
+        }
+    }
+}
+void Gao() {
+    memset( in , 0 , sizeof in );
+    for( int i = 0 ; i < n ; ++i ) g[i].clear();
+    cin >> n >> m ;
+    if( !m ) return  ;
+    for( int i = 0 ; i < m ; ++i ) {
+        int x , y ; cin >> x >> y ;
+        x-- , y-- ;
+        if( x > y ) swap( x , y ) ;
+        e[i].u = x , e[i].v = y , e[i].cnt = 1 ;
+        in[x]++ , in[y]++ ;
+    }
+    sort( e , e + m ) ;
+    tot = 1 ;
+    for( int i = 1 ; i < m ; ++i ) {
+        if( e[tot-1].u == e[i].u && e[tot-1].v == e[i].v ) {
+            e[tot-1].cnt++ ;
+        } else {
+            e[tot++] = e[i] ;
+        }
+    }
+    m = tot ;
+    for( int i = 0 ; i < m ; ++i ) {
+        g[e[i].u].push_back( make_pair( e[i].v,e[i].cnt) ) ;
+        g[e[i].v].push_back( make_pair( e[i].u,e[i].cnt) ) ;
+    }
+}
+int Run() {
+    int _ , cas = 1 ; cin >> _ ;
+    while( _-- ) {
+        cout << "Case #" << cas++ << ":" << endl ;
+        Gao(); Work();
+    }
+    return 0 ;
+}
+int main() {
+    ios::sync_with_stdio(0);
+    return Run();
+}
diff --git a/HDOJ/4015_autoAC.cpp b/HDOJ/4015_autoAC.cpp
new file mode 100644
index 0000000..30dfe11
--- /dev/null
+++ b/HDOJ/4015_autoAC.cpp
@@ -0,0 +1,15 @@
+#include<stdio.h>
+int main()
+{
+    int T;
+    int m,k;
+    int iCase=0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d",&m,&k);
+        printf("Case #%d: %.8lf\n",iCase,(double)1/(k+m*k+1));
+    }    
+    return 0;
+}
diff --git a/HDOJ/4016_autoAC.cpp b/HDOJ/4016_autoAC.cpp
new file mode 100644
index 0000000..3dffa3f
--- /dev/null
+++ b/HDOJ/4016_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<iostream>
+#include<algorithm>
+#define N 45
+using namespace std;
+__int64 MAX=0x7fffffffffffffff;
+__int64 a[N],sum[N],ans;
+int k,n;
+void dfs(int t,int d,__int64 num)
+{
+    if(ans>num) ans=num;
+    if(t==n+1||d==k) return;
+       __int64 s=num;
+   s &= sum[t];
+   if(s>=ans)return;
+   dfs(t+1,d+1,num&a[t]);
+   dfs(t+1,d,num);
+}
+int main()
+{
+    int cas,T=0;
+    cin>>cas;
+    while(cas--)
+    {
+        scanf("%d %d",&n,&k);
+        for(int i=1;i<=n;i++)
+            scanf("%I64d",&a[i]);
+        sort(a+1,a+n+1);
+        sum[n]=a[n];
+        for(int i=n-1;i>=1;i--)
+            sum[i]=a[i]&sum[i+1];
+        ans=MAX;
+        dfs(1,0,MAX);
+        printf("Case #%d: ",++T);
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4018_autoAC.cpp b/HDOJ/4018_autoAC.cpp
new file mode 100644
index 0000000..fb03f6c
--- /dev/null
+++ b/HDOJ/4018_autoAC.cpp
@@ -0,0 +1,20 @@
+#include <iostream>
+#include <cstring>
+#include <string>
+#include <cstdio>
+using namespace std;
+int main()
+{
+    char str[2000];
+    char buf[2000];
+    int t;
+    scanf("%d",&t);
+    for (int i=1;i<=t;i++)
+    {
+        printf("Case #%d: ",i);
+        cin>>str;
+        sscanf(str,"%*[^/]//%[^/:]",buf);
+        cout<<buf<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4020_autoAC.cpp b/HDOJ/4020_autoAC.cpp
new file mode 100644
index 0000000..8835ff0
--- /dev/null
+++ b/HDOJ/4020_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+int N,M,Q,U,C,L;
+int name[500110],r[500110],q;
+double click[500010],len[500110];
+double ans[500110],res[500110];
+int hash[100110];
+int cmp(const void *_p,const void *_q)
+{
+    int *a=(int *)_p;
+    int *b=(int *)_q;
+    return click[*a]>click[*b]?-1:1;
+}
+int main()
+{
+    int i,j,k,n,t,tt,cur;
+    scanf("%d",&t);
+    for(tt=0;tt<t;tt++)
+    {
+        scanf("%d%d%d",&N,&M,&Q);
+        for(i=0;i<M;i++)
+        {
+            scanf("%d%lf%lf",&name[i],&click[i],&len[i]);
+            r[i]=i;
+        }    
+        qsort(r,M,sizeof(r[0]),cmp);    
+        for(i=1;i<=N;i++)
+            hash[i]=0;
+        for(i=1;i<=M;i++)
+            ans[i]=0.0;
+        for(i=0;i<M;i++)
+        {
+            hash[name[r[i]]]++;
+            ans[hash[name[r[i]]]]+=len[r[i]];
+        }
+        res[0]=0;
+        for(i=1;i<=M;i++)
+        {
+            res[i]=ans[i]+res[i-1];
+        }
+        printf("Case #%d:\n",tt+1);
+        for(i=0;i<Q;i++)
+        {
+            scanf("%d",&q);
+            if(q>M)
+                printf("%.0f\n",res[M]);
+            else
+                printf("%.0f\n",res[q]);
+        }
+    }
+    return 0;    
+}
diff --git a/HDOJ/4021_autoAC.cpp b/HDOJ/4021_autoAC.cpp
new file mode 100644
index 0000000..66ac44c
--- /dev/null
+++ b/HDOJ/4021_autoAC.cpp
@@ -0,0 +1,99 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+int a[24];
+int b[24];
+int c[24];
+int d[24];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        for(int i=0;i<24;i++)
+           scanf("%d",&a[i]);
+        for(int i=0;i<24;i++)
+           scanf("%d",&b[i]);
+        if(a[0]==0)swap(a[0],a[3]);
+        if(a[1]==0)swap(a[1],a[6]);
+        if(a[2]==0)swap(a[2],a[3]);
+        if(a[7]==0)swap(a[7],a[6]);
+        if(a[16]==0)swap(a[16],a[17]);
+        if(a[21]==0)swap(a[20],a[21]);
+        if(a[22]==0)swap(a[17],a[22]);
+        if(a[23]==0)swap(a[20],a[23]);
+        if(b[0]==0)swap(b[0],b[3]);
+        if(b[1]==0)swap(b[1],b[6]);
+        if(b[2]==0)swap(b[2],b[3]);
+        if(b[7]==0)swap(b[7],b[6]);
+        if(b[16]==0)swap(b[16],b[17]);
+        if(b[21]==0)swap(b[20],b[21]);
+        if(b[22]==0)swap(b[17],b[22]);
+        if(b[23]==0)swap(b[20],b[23]);
+        bool flag=true;
+        if(a[0]!=b[0])flag=false;
+        if(a[1]!=b[1])flag=false;
+        if(a[2]!=b[2])flag=false;
+        if(a[7]!=b[7])flag=false;
+        if(a[16]!=b[16])flag=false;
+        if(a[21]!=b[21])flag=false;
+        if(a[22]!=b[22])flag=false;
+        if(a[23]!=b[23])flag=false;
+        if(flag==false)
+        {
+            printf("Y\n");
+            continue;
+        }
+        for(int i=0;i<4;i++)
+        {
+            c[i]=a[i+3];
+            d[i]=b[i+3];
+        }
+        for(int i=4;i<12;i++)
+        {
+            c[i]=a[i+4];
+            d[i]=b[i+4];
+        }
+        for(int i=12;i<16;i++)
+        {
+            c[i]=a[i+5];
+            d[i]=b[i+5];
+        }
+        int cnt1=0;
+        int cnt2=0;
+        int m1=0,m2=0;
+        for(int i=1;i<16;i++)
+        {
+            if(c[i]==0)
+            {
+                m1=i;
+                continue;
+            }
+            for(int j=0;j<i;j++)
+            {
+                if(c[i]<c[j])cnt1++;
+            }
+        }
+        for(int i=1;i<16;i++)
+        {
+            if(d[i]==0)
+            {
+                m2=i;
+                continue;
+            }
+            for(int j=0;j<i;j++)
+            {
+                if(d[i]<d[j])cnt2++;
+            }
+        }
+        m1/=4;
+        m2/=4;
+        int m=abs(m1-m2);
+        if(((cnt1+m)%2)!=(cnt2%2))flag=false;
+        if(flag)printf("N\n");
+        else printf("Y\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4022_autoAC.cpp b/HDOJ/4022_autoAC.cpp
new file mode 100644
index 0000000..6dc329c
--- /dev/null
+++ b/HDOJ/4022_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<map>
+#include<set>
+#include<iterator>
+using namespace std;
+typedef map<int,multiset<int> > def;
+void pop(def &a,def &b,int k)
+{
+    printf("%d\n",a[k].size());
+    for(multiset<int>::iterator i=a[k].begin();i!=a[k].end();i++)
+        b[*i].erase(k);
+    a[k].clear();
+}
+int main()
+{
+    int n,m,x,y;
+    while(1)
+    {
+        scanf("%d%d",&n,&m);
+        if(n==0&&m==0)return 0;
+        def h;def l;
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d%d",&x,&y);
+            h[x].insert(y);
+            l[y].insert(x);
+        }
+        for(int j=0;j<m;j++)
+        {
+            scanf("%d%d",&x,&y);
+           if(x==0)
+                pop(h,l,y);
+            else
+                pop(l,h,y);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4023_autoAC.cpp b/HDOJ/4023_autoAC.cpp
new file mode 100644
index 0000000..c1a024a
--- /dev/null
+++ b/HDOJ/4023_autoAC.cpp
@@ -0,0 +1,167 @@
+#include<stdio.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+int a[16];
+int main()
+{
+    int T;
+    int iCase=0;
+    int now;
+    int Alice,Bob;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        printf("Case #%d: ",iCase);
+        for(int i=1;i<=15;i++)
+          scanf("%d",&a[i]);
+        Alice=Bob=0;
+        now=1;
+        if(a[15]%2==0)
+        {
+            Alice+=a[15]/2;
+            Bob+=a[15]/2;
+        }
+        else
+        {
+            Alice+=a[15]/2+1;
+            Bob+=a[15]/2;
+            now=2;
+        }
+        int tempa=a[5]+a[6];
+        int tempb=a[3]+a[4];
+        if(tempa==tempb)
+        {
+            Alice+=tempa;
+            Bob+=tempb;
+        }
+        else if(tempa<tempb)
+        {
+            Alice+=tempa;
+            Bob+=tempa;
+            tempb-=tempa;
+            if(tempb%2==0)
+            {
+                Bob+=tempb/2;
+            }
+            else
+            {
+                if(now==1)
+                {
+                    now=2;
+                    Bob+=tempb/2;
+                }
+                else
+                {
+                    now=1;
+                    Bob+=tempb/2+1;
+                }
+            }
+        }
+        else
+        {
+            Alice+=tempb;
+            Bob+=tempb;
+            tempa-=tempb;
+            if(tempa%2==0)
+            {
+                Alice+=tempa/2;
+            }
+            else
+            {
+                if(now==1)
+                {
+                    now=2;
+                    Alice+=tempa/2+1;
+                }
+                else
+                {
+                    now=1;
+                    Alice+=tempa/2;
+                }
+            }
+        }
+        int temp=a[11]+a[12]+a[13]+a[14];
+        if(temp%2==0)
+        {
+            Alice+=0;
+            Bob+=0;
+        }
+        else
+        {
+            if(now==1)
+            {
+                now=2;
+            }
+            else
+            {
+                now=1;
+            }
+        }
+        tempa=a[7]+a[8];
+        tempb=a[9]+a[10];
+        if(tempa==tempb)
+        {
+            Alice+=0;
+            Bob+=0;
+        }
+        else if(tempa<tempb)
+        {
+            Alice+=0;
+            Bob+=0;
+            tempb-=tempa;
+            if(tempb%2==0)
+            {
+                Bob+=tempb/2;
+            }
+            else
+            {
+                if(now==1)
+                {
+                    now=2;
+                    Bob+=tempb/2+1;
+                }
+                else
+                {
+                    now=1;
+                    Bob+=tempb/2;
+                }
+            }
+        }
+        else
+        {
+            tempa-=tempb;
+            if(tempa%2==0)
+            {
+                Alice+=tempa/2;
+            }
+            else
+            {
+                if(now==1)
+                {
+                    now=2;
+                    Alice+=tempa/2;
+                }
+                else
+                {
+                    now=1;
+                    Alice+=tempa/2+1;
+                }
+            }
+        }
+        Alice+=2*a[1];
+        Bob+=2*a[2];
+        if(now==1)
+        {
+            if(Bob>=Alice)printf("Bob\n");
+            else printf("Alice\n");
+        }
+        else
+        {
+            if(Alice>=Bob)printf("Alice\n");
+            else printf("Bob\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4024_autoAC.cpp b/HDOJ/4024_autoAC.cpp
new file mode 100644
index 0000000..6f6cab5
--- /dev/null
+++ b/HDOJ/4024_autoAC.cpp
@@ -0,0 +1,28 @@
+#include<stdio.h>
+#include<iostream>
+#include<math.h>
+#include<string.h>
+using namespace std;
+int main()
+{
+    double x1,y1,x2,y2,Lx,Ly,vD,vB,L;
+    while(scanf("%lf%lf%lf%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&Lx,&Ly,&vD,&vB,&L))
+    {
+        if(x1==0&&y1==0&&x2==0&&y2==0&&Lx==0&&Ly==0&&vD==0&&vB==0&&L==0)break;
+        double a=vD*vD-Lx*Lx-Ly*Ly;
+        double b=2*L*vD-2*Lx*(x1-x2+L*Lx/vB)-2*Ly*(y1-y2+L*Ly/vB);
+        double c=L*L-(x1-x2+L*Lx/vB)*(x1-x2+L*Lx/vB)-(y1-y2+L*Ly/vB)*(y1-y2+L*Ly/vB);
+        double s1=(-b-sqrt(b*b-4*a*c))/(2*a);
+        double s2=(-b+sqrt(b*b-4*a*c))/(2*a);
+        b=-2*L*vD-2*Lx*(x1-x2+L*Lx/vB)-2*Ly*(y1-y2+L*Ly/vB);
+        double s3=(-b-sqrt(b*b-4*a*c))/(2*a);
+        double s4=(-b+sqrt(b*b-4*a*c))/(2*a);
+        printf("%.3lf ",L);
+        if(s1<0)s1=10000000000.0;
+        if(s2<0)s2=10000000000.0;
+        if(s3<0)s3=10000000000.0;
+        if(s4<0)s4=10000000000.0;
+        printf("%.3lf\n",min(s1,min(s2,min(s3,s4)))+L/vB);
+    }
+    return 0;
+}
diff --git a/HDOJ/4025_autoAC.cpp b/HDOJ/4025_autoAC.cpp
new file mode 100644
index 0000000..050cd70
--- /dev/null
+++ b/HDOJ/4025_autoAC.cpp
@@ -0,0 +1,104 @@
+#include <stdio.h>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+struct Set{
+    int k, num[5];
+};
+int ans_count, a1, a2, n, m;
+int a[31][23];
+Set s[23];
+__int64 ans[(1<<22) + 2];
+__int64 sum[(1<<22)+2];
+__int64 final_ans;
+int find(__int64 v)
+{
+    int left = 0, right = ans_count-1, mid;
+    if (ans_count == 0) return -1;
+    while (left < right-1) {
+        mid = left + (right - left) / 2;
+        if (v <= ans[mid]) right = mid;
+        else  left = mid;
+    }
+    if (v == ans[left]) return left;
+    if (v == ans[right]) return right;
+    return -1;
+}
+void dfs_x1(int p, __int64 now)
+{
+    int i, j, x;
+    __int64 tmp;
+    if (p >= a2+1) {
+        ans[ans_count++] = now;
+        return;
+    }
+    for (i = 0; i < s[p].k; i++) {
+        x = s[p].num[i];
+        tmp = now;
+        for (j = 1; j <= n; j++)   tmp ^= ((__int64)(a[j][p] * x)) << (2*(j-1));
+        dfs_x1(p+1, tmp);
+    }
+}
+void dfs_x2(int p, __int64 now)
+{
+    int i, j, x, ret;
+    __int64 tmp;
+    if (p >= a2+1) {
+        ret = find(now);
+        if (ret != -1) {
+            final_ans += sum[ret];
+        }
+        return;
+    }
+    for (i = 0; i < s[p].k; i++) {
+        x = s[p].num[i];
+        tmp = now;
+        for (j = 1; j <= n; j++)   tmp ^= ((__int64)(a[j][p] * x)) << (2*(j-1));
+        dfs_x2(p+1, tmp);
+    }
+}
+int main()
+{
+    int cs, tt, i, j, ss, n_count;
+    scanf("%d", &tt);
+    for (cs = 1; cs <= tt; cs++) {
+        scanf("%d %d", &n, &m);
+        for (i = 1; i <= n; i++) {
+            for (j = 1; j <= m; j++) {
+                scanf("%d", &a[i][j]);
+            }
+        }
+        for (i = 1; i <= m; i++) {
+            scanf("%d", &s[i].k);
+            n_count = 0;
+            ss = 0;
+            for (j = 0; j < s[i].k; j++) {
+                scanf("%d", &s[i].num[n_count]);
+                if (ss & (1<<s[i].num[n_count])) continue;
+                n_count++;
+            }
+            s[i].k = n_count;
+        }
+        ans_count = 0;
+        a1 = 1;
+        a2 = (m/2);
+        dfs_x1(a1, 0LL);
+        sort(ans, ans+ans_count);
+        j = 0;
+        sum[j] = 1;
+        for (i = 1; i < ans_count; i++) {
+            if (ans[j] == ans[i]) sum[j]++;
+            else {
+                ans[++j] = ans[i];
+                sum[j] = 1;
+            }
+        }
+        ans_count = j+1;
+        final_ans = 0LL;
+        a1 = a2 + 1;
+        a2 = m;
+        dfs_x2(a1, 0LL);
+        printf("%I64d\n", final_ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4026_autoAC.cpp b/HDOJ/4026_autoAC.cpp
new file mode 100644
index 0000000..ef6aaaa
--- /dev/null
+++ b/HDOJ/4026_autoAC.cpp
@@ -0,0 +1,93 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<iostream>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+struct node
+{
+    int x,y;
+}nd[16];
+long long dp[1<<16][16];
+int n,m,gp[6][6],pos,gd[6][6],mp[6][6];
+int gcd(int x,int y)
+{
+     if (y == 0)
+        return x;
+    return gcd(y, x % y);
+}
+bool ok(int x,int y,int sta)
+{
+    int x1=nd[x].x,x2=nd[y].x,y1=nd[x].y,y2=nd[y].y;
+    int dx=x2-x1;
+    int dy=y2-y1;
+    int c=gd[abs(dx)][abs(dy)];
+    dx=dx/c;dy=dy/c;
+    for(int i=0;i<=5;i++)
+    {
+        x1+=dx;y1+=dy;
+        if(gp[x1][y1]==1)
+            return false;
+        else if(x1==x2&&y1==y2)
+            return true;
+        else if(gp[x1][y1]==0&&(sta&(1<<(mp[x1][y1])))==0)
+            return false;
+    }
+    return false;
+}
+long long DP(int st,int k)
+{
+    if(dp[st][k]!=-1)return dp[st][k];
+    if(st==(1<<k)) dp[st][k]=1;
+    else
+    {
+        dp[st][k]=0;
+        for(int j=0;j<pos;j++)
+        {
+            if(((1<<j)&st)==0||j==k)continue;
+            if(ok(j,k,st)==0)continue;
+            dp[st][k]+=DP(st-(1<<k),j);    
+        }
+    }
+        return dp[st][k];
+}
+void work()
+{
+    long long ans=0;
+    memset(dp,-1,sizeof(dp));
+    for(int i=0;i<pos;i++)
+          DP((1<<pos)-1,i);
+    for(int i=0;i<pos;i++)
+    {
+            ans+=dp[(1<<pos)-1][i];
+    }
+    cout<<ans<<'\n';
+}
+void init()
+{
+    for(int i=0;i<6;i++)
+        for(int j=0;j<6;j++)
+            gd[i][j]=gcd(i,j);
+}
+int main()
+{
+    init();
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {    
+        pos=0;
+        for(int i=0;i<n;i++)
+            for(int j=0;j<m;j++)
+            {
+                scanf("%d",&gp[i][j]);
+                if(gp[i][j]==0)
+                {
+                    nd[pos].x=i;
+                    nd[pos++].y=j;
+                    mp[i][j]=pos-1;
+                }
+            }
+            work();
+    }
+    return 0;
+}
diff --git a/HDOJ/4027_autoAC.cpp b/HDOJ/4027_autoAC.cpp
new file mode 100644
index 0000000..8d6af4d
--- /dev/null
+++ b/HDOJ/4027_autoAC.cpp
@@ -0,0 +1,120 @@
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cstdio>
+#include <stdlib.h>
+#include <iostream>
+#include <limits.h>
+#include <string>
+#include <cstring>
+#include <algorithm>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <algorithm>
+#define LL __int64
+using namespace std;
+const int N=100010;
+struct Node
+{
+    int L,R;
+    LL len;
+    LL sum;
+} t[N*4];
+LL data[N];
+int n,q;
+void up(int fa){
+    t[fa].sum=t[fa<<1].sum+t[fa<<1|1].sum;
+}
+void down(int l,int r,int fa)
+{
+    if(t[fa].L==t[fa].R)
+    {
+        t[fa].sum=(LL)(sqrt(t[fa].sum));
+        return;
+    }
+    int ls=fa<<1;
+    int rs=fa<<1|1;
+    int mid=(t[fa].L+t[fa].R)/2;
+    down(l,mid,ls);
+    down(mid+1,r,rs);
+    up(fa);
+}
+void built(int l,int r,int fa)
+{
+    t[fa].L=l;
+    t[fa].R=r;
+    t[fa].len=r-l+1;
+    t[fa].sum=0LL;
+    if(l==r)
+    {
+        t[fa].sum=data[l];
+        return;
+    }
+    int mid=(l+r)/2;
+    built(l,mid,fa<<1);
+    built(mid+1,r,fa<<1|1);
+    up(fa);
+}
+void update(int l,int r,int fa)
+{
+    int ls=fa<<1;
+    int rs=fa<<1|1;
+    int mid=(t[fa].L+t[fa].R)/2;
+    if(t[fa].L==l&&t[fa].R==r)
+    {
+        if(t[fa].sum==t[fa].len)
+            return ;
+        down(l,r,fa);
+            return ;
+    }
+    if(r<=mid)
+        update(l,r,ls);
+    else if(l>mid)
+        update(l,r,rs);
+    else
+    {
+        update(l,mid,ls);
+        update(mid+1,r,rs);
+    }
+    up(fa);
+}
+LL query(int l,int r,int fa)
+{
+    int ls=fa<<1;
+    int rs=fa<<1|1;
+    int mid=(t[fa].L+t[fa].R)/2;
+    if(t[fa].L>=l&&t[fa].R<=r)
+        return t[fa].sum;
+    if(r<=mid)
+        return query(l,r,ls);
+    else if(l>mid)
+        return query(l,r,rs);
+    else
+        return query(l,mid,ls)+query(mid+1,r,rs);
+}
+int main()
+{
+    int t=1;
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(int i=1; i<=n; i++)
+        scanf("%I64d",&data[i]);
+        built(1,n,1);
+        int a,b,c;
+        printf("Case #%d:\n",t++);
+        cin>>q;
+        while(q--)
+        {
+            scanf("%d%d%d",&a,&b,&c);
+            if(b>c)swap(b,c);
+            if(a)
+                cout<<query(b,c,1)<<endl;
+            else
+                update(b,c,1);
+        }
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4028_autoAC.cpp b/HDOJ/4028_autoAC.cpp
new file mode 100644
index 0000000..9ce3dff
--- /dev/null
+++ b/HDOJ/4028_autoAC.cpp
@@ -0,0 +1,54 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<map>
+#define LL long long
+using namespace std;
+LL m;int n;
+typedef map <LL,LL> mp;
+mp dp[45];
+LL gcd(LL a,LL b)
+{
+    return b==0?a:gcd(b,a%b);
+}
+LL lcm(LL a,LL b)
+{
+    return a*b/gcd(a,b);
+}
+void DP()
+{
+        dp[1][1]=1;
+    for(int i=2;i<=40;i++)
+    {
+        dp[i]=dp[i-1];
+        dp[i][i]+=1;
+        for(mp::iterator j=dp[i-1].begin();j!=dp[i-1].end();j++)
+        {
+            LL lc=lcm(i,j->first);
+            dp[i][lc]+=j->second;
+        }
+    }
+}
+void ANS()
+{
+    LL ans=0;
+    for(mp::iterator i=dp[n].begin();i!=dp[n].end();i++)
+        if(i->first>=m)ans+=i->second;
+    cout<<ans<<'\n';
+}
+int main()
+{
+    int T,t;
+    DP();
+    scanf("%d",&T);
+    for(t=1;t<=T;t++)
+    {
+        cin>>n>>m;
+        printf("Case #%d: ",t);
+        ANS();
+    }
+    return 0;
+}
diff --git a/HDOJ/4029_autoAC.cpp b/HDOJ/4029_autoAC.cpp
new file mode 100644
index 0000000..c68f036
--- /dev/null
+++ b/HDOJ/4029_autoAC.cpp
@@ -0,0 +1,98 @@
+#include<iostream>
+#include<cstdio>
+#include<map>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<queue>
+#include<algorithm>
+#include<set>
+#define inf (1ull<<63)-1
+#define N 130
+#define maxn 100005
+#define Min(a,b) ((a)<(b)?(a):(b))
+#define Max(a,b) ((a)>(b)?(a):(b))
+#define pb(a) push_back(a)
+#define mem(a,b) memset(a,b,sizeof(a))
+#define eps 1e-9
+#define zero(a) fabs(a)<eps
+#define ULL unsigned long long
+#define lson (step<<1)
+#define rson (step<<1|1)
+#define MOD 1000000007
+#define mp(a,b) make_pair(a,b)
+using namespace std;
+const ULL hash1=26;
+struct HASH{
+    ULL h1;
+    HASH(){}
+    HASH(ULL _h1):h1(_h1){}
+}h[N][N]; 
+int wa[maxn],wb[maxn],wv[maxn],Ws[maxn];  
+int cmp(int *r,int a,int b,int l)  
+{return r[a]==r[b]&&r[a+l]==r[b+l];}  
+void da(const int *r,int *sa,int n,int m){  
+    int i,j,p,*x=wa,*y=wb,*t;   
+    for(i=0;i<m;i++) Ws[i]=0;   
+    for(i=0;i<n;i++) Ws[x[i]=r[i]]++;   
+    for(i=1;i<m;i++) Ws[i]+=Ws[i-1];   
+    for(i=n-1;i>=0;i--) sa[--Ws[x[i]]]=i;   
+    for(j=1,p=1;p<n;j*=2,m=p){   
+        for(p=0,i=n-j;i<n;i++) y[p++]=i;   
+        for(i=0;i<n;i++) if(sa[i]>=j) y[p++]=sa[i]-j;   
+        for(i=0;i<n;i++) wv[i]=x[y[i]];   
+        for(i=0;i<m;i++) Ws[i]=0;   
+        for(i=0;i<n;i++) Ws[wv[i]]++;   
+        for(i=1;i<m;i++) Ws[i]+=Ws[i-1];   
+        for(i=n-1;i>=0;i--) sa[--Ws[wv[i]]]=y[i];   
+        for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;i<n;i++)   
+            x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;   
+    }   
+    return;   
+}  
+int sa[maxn],Rank[maxn],height[maxn];   
+void calheight(const int *r,int *sa,int n){  
+    int i,j,k=0;  
+    for(i=1;i<=n;i++) Rank[sa[i]]=i; 
+    for(i=0;i<n;height[Rank[i++]]=k)  
+        for(k?k--:0,j=sa[Rank[i]-1];r[i+k]==r[j+k];k++);  
+    return;  
+}    
+int tot,r[maxn],cnt;
+char str[N][N];
+int main(){
+    int t,cas=0,n,m;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&m);
+        for(int i=0;i<n;i++) scanf("%s",str[i]);
+        mem(h,0);
+        ULL ans=0;
+        for(int w=1;w<=m;w++){
+            tot=1;cnt=0;
+            map<ULL,int> map;
+            map.clear();
+            for(int i=0;i<n;i++){
+                for(int j=0;j+w-1<m;j++){
+                    h[i][j].h1=h[i][j].h1*hash1+str[i][j+w-1]-'A';
+                    if(map.find(h[i][j].h1)==map.end())
+                        map.insert(mp(h[i][j].h1,tot++));
+                }
+            }        
+            for(int j=0;j+w-1<m;j++){    
+                for(int i=0;i<n;i++){            
+                    r[cnt++]=map[h[i][j].h1];
+                }
+                r[cnt++]=tot++;
+            }
+            r[cnt]=0;
+            da(r,sa,cnt+1,tot);
+            calheight(r,sa,cnt);
+            ULL tmp=(n*(n+1)/2)*(m-w+1);
+            for(int i=1;i<=cnt;i++){tmp-=height[i];}
+            ans+=tmp;    
+        }
+        printf("Case #%d: %I64u\n",++cas,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4030_autoAC.cpp b/HDOJ/4030_autoAC.cpp
new file mode 100644
index 0000000..0994796
--- /dev/null
+++ b/HDOJ/4030_autoAC.cpp
@@ -0,0 +1,139 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cmath>
+#include<map>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const int maxn = 105;
+const int forever = -1;
+const int never = -2;
+struct point
+{
+    ll x, y;
+} p[maxn], v[maxn];
+map <ll, ll> Map;
+ll cti[maxn][maxn];
+void initial(int n)
+{
+    int i, j, t;
+    for(i=0; i<n; i++)
+        for(j=i+1; j<n; j++)
+        {
+            if(p[i].x==p[j].x && p[i].y==p[j].y && v[i].x==v[j].x && v[i].y==v[j].y)
+                cti[i][j]=cti[j][i]=forever;
+            else
+            {
+                cti[i][j]=cti[j][i]=never;
+                if(v[i].x != v[j].x)
+                {
+                    if((p[i].x-p[j].x)%(v[j].x-v[i].x) != 0)continue;
+                    t=(p[i].x-p[j].x)/(v[j].x-v[i].x);
+                    if(t<0 || (p[i].y+v[i].y*t != p[j].y+v[j].y*t))continue;
+                }
+                else if(v[i].y != v[j].y)
+                {
+                    if((p[i].y-p[j].y)%(v[j].y-v[i].y) != 0)continue;
+                    t=(p[i].y-p[j].y)/(v[j].y-v[i].y);
+                    if(t<0 || (p[i].x+v[i].x*t != p[j].x+v[j].x*t))continue;
+                }
+                else continue;
+                cti[i][j]=cti[j][i]=t;
+            }
+        }
+}
+int main()
+{
+    int i, j, k, n, tmp, cnt, res, ans;
+    ll a, b, c, t;
+    while(~scanf("%d", &n) && n)
+    {
+        for(i = 0; i < n; i++)scanf("%I64d%I64d%I64d%I64d", &p[i].x, &p[i].y, &v[i].x, &v[i].y);
+        if(n == 1 || n == 2)
+        {
+            printf("%d\n", n);
+            continue;
+        }
+        initial(n);
+        ans = 0;
+        for(i = 0; i < n; i++)
+            for(j = i+1; j < n; j++)
+            {
+                Map.clear();
+                cnt = 0;
+                res = 0;
+                for(k = 0; k < n; k++)
+                {
+                    if(k==i || k==j)continue;
+                    a = (v[i].x-v[j].x)*(v[i].y-v[k].y) - (v[i].x-v[k].x)*(v[i].y-v[j].y);
+                    b = (p[i].x-p[j].x)*(v[i].y-v[k].y) + (v[i].x-v[j].x)*(p[i].y-p[k].y)
+                        - (p[i].y-p[j].y)*(v[i].x-v[k].x) - (v[i].y-v[j].y)*(p[i].x-p[k].x);
+                    c = (p[i].x-p[j].x)*(p[i].y-p[k].y) - (p[i].y-p[j].y)*(p[i].x-p[k].x);
+                    if(a==0 && b==0 && c==0)cnt++;
+                    else if(a==0)
+                    {
+                        if(c==0 || b==0)continue;
+                        else if(c%b==0)
+                        {
+                            t=-c/b;
+                            if(t>0 && t!=cti[i][j])
+                            {
+                                tmp = ++Map[t];
+                                res = max(tmp, res);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        ll d = b*b-4*a*c;
+                        ll t1, t2;
+                        if(d<0) continue;
+                        else
+                        {
+                            ll sqd = sqrt(d+0.0);
+                            if(sqd*sqd == d)
+                            {
+                                t1= -b+sqd;
+                                if(t1%(2*a)==0)
+                                {
+                                    t1/=(2*a);
+                                    if(t1>0 && t1!=cti[i][j])
+                                    {
+                                        tmp = ++Map[t1];
+                                        res = max(tmp, res);
+                                    }
+                                }
+                                if(sqd!=0)
+                                {
+                                    t2= -b-sqd;
+                                    if(t2%(2*a)==0)
+                                    {
+                                        t2/=(2*a);
+                                        if(t2>0 && t2!=cti[i][j])
+                                        {
+                                            tmp = ++Map[t2];
+                                            res = max(tmp, res);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                ans = max(res+2+cnt, ans);
+                if(cti[i][j]!=never && cti[i][j]!=0)
+                {
+                    res=0;
+                    for(k=0; k<n; k++)
+                    {
+                        if(k==i || k==j)continue;
+                        if(cti[i][j] == cti[i][k])res++;
+                    }
+                    ans=max(res+2, ans);
+                }
+            }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4031_autoAC.cpp b/HDOJ/4031_autoAC.cpp
new file mode 100644
index 0000000..7c3b8da
--- /dev/null
+++ b/HDOJ/4031_autoAC.cpp
@@ -0,0 +1,82 @@
+#include <iostream>
+#include <string.h>
+using namespace std;
+const int MAX = 20000 + 100;
+int C[MAX];
+int N;
+struct Node
+{
+    int l;
+    int r;
+};
+int LowBit(int x)
+{
+    return x & (-x);
+}
+void Update(int num,int key)
+{
+    while(num <= N)
+    {
+        C[num] += key;
+        num += LowBit(num);
+    }
+}
+int CalSum(int num)
+{
+    int sum = 0;
+    while(num > 0)
+    {
+        sum += C[num];
+        num -= LowBit(num);
+    }
+    return sum;
+}
+int main()
+{
+    int T;
+    cin>>T;
+    int Case = 0;
+    while(T--)
+    {
+        int Q;
+        int CD;
+        int time = 0;
+        int used_time[MAX] = {0};
+        int porected[MAX] = {0};
+        Node attack[MAX] = {0};
+        memset(C,0,sizeof(C));
+        Case++;
+        cout<<"Case "<<Case<<":"<<endl;
+        scanf("%d%d%d",&N,&Q,&CD);
+        int i;
+        for(i=0;i<Q;i++)
+        {
+            char str[20];
+            scanf("%s",str);
+            if(str[0] == 'A')
+            {
+                scanf("%d%d",&attack[time].l,&attack[time].r);
+                Update(attack[time].l,1);
+                Update(attack[time].r+1,-1);
+                time++;
+            }
+            else
+            {
+                int num;
+                scanf("%d",&num);
+                int i;
+                for(i = used_time[num] ; i< time ;i++)
+                {
+                    if(attack[i].l <=num    && num <= attack[i].r )
+                    {
+                        porected[num]++;
+                        used_time[num] = i + CD;
+                        i = i + CD - 1;
+                    }
+                }
+                printf("%d\n",CalSum(num)-porected[num]);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4032_autoAC.cpp b/HDOJ/4032_autoAC.cpp
new file mode 100644
index 0000000..792389c
--- /dev/null
+++ b/HDOJ/4032_autoAC.cpp
@@ -0,0 +1,166 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+char translate[16] = "3456789TJQKA2BR";
+char tot[16] =       "444444444444411";
+int a[3][16];
+int b[15];
+int limit[5] = {0, 5, 3, 0, 0};
+int big[5][16];
+bool rocket;
+int attach[16][3];
+int get(char c){
+    for (int i = 0; i < 15; ++i)
+        if (translate[i] == c) return i;
+}
+void init(int i, string s){
+    memset(a[i], 0, sizeof(a[i]));
+    for (int j = 0; j < s.size(); ++j)
+        ++a[i][get(s[j])];
+}
+void init(int index){
+    if (!index){
+        memset(big, 255, sizeof(big));
+        memset(attach, 255, sizeof(attach));
+        rocket = false;
+        return;
+    }
+    if (a[index][14]&&a[index][13]) rocket = true;
+    int b[3] = {0, 0, 0};
+    for (int i = 0; i < 15; ++i)
+        for (int k = 1; k < 3; ++k)
+            if (a[index][i] >= k) ++b[k];
+    for (int i = 0; i < 15; ++i)
+        for (int cardnumber = 1; cardnumber < 5; ++cardnumber)
+            for (int len = 1; i + len <= 15; ++len){
+                if ((len > 1)&&(i + len > 12)) break;
+                int ok = true;
+                if (a[index][i + len - 1] >= cardnumber){
+                    big[cardnumber][len] = max(big[cardnumber][len], i);
+                    if ((cardnumber == 3)&&(b[1] >= 2 * len))
+                        attach[len][1] = max(attach[len][1], i);
+                    if ((cardnumber == 3)&&(b[2] >= 2 * len))
+                        attach[len][2] = max(attach[len][2], i);
+                }
+                else break;
+                }
+}
+bool dfs(int remain, int level, bool fail);
+bool dfs(int cardnumber, int remain, int i, int len, int index, int begin, int fail){
+    if (index == len){
+        if ((len >= 2)&&(b[len - 1] + b[len - 2] == 27)) return false;
+        return dfs(remain - (3 + cardnumber) * len, 4000 + i + len, fail);
+    }
+    for (int j = begin; j < 15; ++j){
+        if (j == i) j = i + len;
+        if (a[0][j] >= cardnumber){
+            a[0][j] -= cardnumber;
+            b[index] = j;
+            if (dfs(cardnumber, remain, i, len, index + 1, j + 1,fail)) return true;
+            a[0][j] += cardnumber;
+        }
+    }
+    return false;
+}
+bool dfs(int remain, int level, bool fail){
+    if (remain == 0) return true;
+    if (level == 0){
+        if (a[0][14]&&a[0][13]){
+            --a[0][14];
+            --a[0][13];
+            if (dfs(remain - 2, 1000, fail)) return true;
+            ++a[0][14];
+            ++a[0][13];
+        }
+        return dfs(remain, 1000, fail);
+    }
+    if (level / 1000 == 1){ 
+        for (int i = level % 1000; i < 15; ++i)
+            if (a[0][i] == 4){
+                if (fail&&(i < big[4][1])) continue;
+                a[0][i] -= 4;
+                if (dfs(remain - 4, 1000 + i + 1, fail||(i < big[4][1]))) return true;
+                a[0][i] += 4;
+            }
+        return dfs(remain, 2000, fail);
+    }
+    if ((big[4][1] > -1)&&(fail)) return false;
+    if (level / 1000 == 2){
+        for (int i = level % 1000; i < 15; ++i)
+            if (a[0][i] == 4){
+                a[0][i] -= 4;
+                for (int p = 1; p <= 2; ++p)
+                for (int j = 0; j < 13; ++j)
+                if (a[0][j] >= p)
+                for (int k = j + 1; k < 15; ++k)
+                if (a[0][k] >= p){
+                    a[0][j] -= p;
+                    a[0][k] -= p;
+                    if (dfs(remain - 2 * p - 4, 2000 + i + 1, fail|(big[4][1] >= 0))) return true;
+                    a[0][k] += p;
+                    a[0][j] += p;
+                }
+                a[0][i] += 4;
+            }
+        return dfs(remain, 3000, fail);
+    }
+    if (level / 1000 == 3){
+        for (int i = level % 100; i < 15; ++i)
+        for (int cardnumber = 1; cardnumber < 4; ++cardnumber)
+        for (int len = 1; len + i <= 16; ++len){
+            if ((!((len > 1)&&(i + len > 12)))&&(a[0][i + len - 1] >= cardnumber)){
+                a[0][i + len - 1] -= cardnumber;
+                if (((!(big[cardnumber][len] > i))||(!fail))&&((len >= limit[cardnumber])||(len == 1)))
+                    if (dfs(remain - cardnumber * len, 3000 + i, fail||(big[cardnumber][len] > i)))
+                        return true;
+            }else{
+                for (int j = 0; j < len - 1; ++j)
+                    a[0][i + j] += cardnumber;
+                break;
+            }
+        }
+        return dfs(remain, 4000, fail);
+    }
+    for (int i = level % 1000; i < 15; ++i)
+    for (int cardnumber = 1; cardnumber < 3; ++cardnumber)
+    for (int len = 1; len + i <= 16; ++len){
+        if ((!((len > 1)&&(i + len > 12)))&&(a[0][i + len - 1] >= 3)){
+            a[0][i + len - 1] -= 3;
+            if ((!(attach[len][cardnumber] > i))||(!fail)){
+                if (dfs(cardnumber, remain, i, len, 0, 0, (attach[len][cardnumber] > i)||fail)) return true;
+            }
+        }else{
+            for (int j = 0; j < len - 1; ++j)
+                a[0][i + j] += 3;
+            break;
+        }
+    }
+    return false;
+}
+int main(){
+    int t, _t;
+    for (scanf("%d ", &_t), t = 0; t < _t; ++t){
+        for (int i = 0; i < 3; ++i){
+            string s;
+            cin>>s;
+            init(i, s);
+        }
+        for (int i = 0; i < 3; ++i)
+            init(i);
+        for (int i = 0; i < 15; ++i){
+            if (a[0][i] + a[1][i] + a[2][i] != tot[i] - '0') a[0][i] = a[0][i] / (a[0][i] - a[0][i]);
+        }
+        if (rocket) big[4][1] = 100;
+        if (big[4][1] >= 0){
+            for( int i = 1; i <= 3; ++i)
+                for (int j = 1; j < 16; ++j)
+                    big[i][j]  = 100;
+            for (int i = 1; i <= 2; ++i)
+            for (int j = 0; j < 16; ++j)
+                attach[j][i] = 100;
+            }
+        if (dfs(20, 0, 0)){
+            printf("Case %d: Yes\n", t + 1);
+        }else printf("Case %d: No\n", t + 1);
+    }
+}
diff --git a/HDOJ/4033_autoAC.cpp b/HDOJ/4033_autoAC.cpp
new file mode 100644
index 0000000..0811007
--- /dev/null
+++ b/HDOJ/4033_autoAC.cpp
@@ -0,0 +1,80 @@
+#include <cstdio>
+#include <iostream>
+#include <cstring>
+#include <cmath>
+using namespace std;
+double ch[200];
+const double PI = 4 * atan( double( 1 ) );
+//const double PI = 3.1415926;
+int num;
+double is_triangle( double a, double b, double c )
+{
+    if( c > a + b )
+        return 100;
+    else if( c < fabs( a - b ) )    
+        return -100;
+    else
+        return acos( ( a * a + b * b - c * c ) / ( 2 * a * b ) );
+}
+double Acos( double a, double b, double c )
+{
+    return is_triangle( a, b, c );
+}
+double total_angle( double mid )
+{
+    double ans = 0;
+    for( int i = 2; i <= num; ++i )
+    {
+        double t = Acos( ch[i], ch[i-1], mid );
+        if( fabs( t ) == 100 )            
+            return t;        
+        else
+            ans += Acos( ch[i], ch[i-1], mid );
+    }
+    return ans;
+}
+double Bsearch( double ss, double ee )
+{
+    double left = ss, right = ee, mid, sum_angle;
+    while( right - left >= 1e-9 )
+    { 
+        mid = ( left + right ) / 2.0;
+        double t = total_angle( mid );
+        if( fabs( t ) == 100 )
+        {
+            if( t > 0 )
+                right = mid;
+            else
+                left = mid; 
+        }
+        else
+        {
+            sum_angle = t + Acos( ch[1] , ch[num], mid ); 
+            if( sum_angle - 2 * PI > 1e-9 )
+                right = mid;
+            else if( sum_angle - 2 * PI < -1e-9 )
+                left = mid;
+            else 
+                return mid;
+        }
+    }
+    return 0;
+}
+int main(  )
+{
+    int i,j,k,T;
+    cin>>T;
+    for(i = 1; i <= T; ++i )
+    {
+        cin>>num;
+        for(j = 1; j <= num; ++j )
+            cin>>ch[j]; 
+        double ans = Bsearch( fabs( ch[num] - ch[1] ), ch[1] + ch[num] );
+        printf( "Case %d: ", i );
+        if( ans == 0 )
+            puts( "impossible" );
+        else
+            printf( "%.3lf\n", ans );
+    }
+    return 0;
+}
diff --git a/HDOJ/4034_autoAC.cpp b/HDOJ/4034_autoAC.cpp
new file mode 100644
index 0000000..0cf8706
--- /dev/null
+++ b/HDOJ/4034_autoAC.cpp
@@ -0,0 +1,59 @@
+#include<iostream>
+#include<cstdlib>
+#include<stdio.h>
+#include<memory.h>
+using namespace std;
+int map[110][110];
+int visit[110][110];
+int n;
+int dist[110][110];
+void floyd() {
+        int i,j,k;
+            for(i=1;i<=n;i++)
+            for(j=1;j<=n;j++)
+            for(k=1;k<=n;k++)
+            {
+                if(j!=i&&i!=k&&dist[j][k]>=dist[j][i]+dist[i][k])
+                {
+                    visit[j][k]=1;
+                    dist[j][k]=dist[j][i]+dist[i][k];
+                 }
+            }
+}
+int main()
+{
+    int t;
+    int count=1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        memset(map,0,sizeof(map));
+        memset(dist,0,sizeof(dist));
+        for(int i=1;i<=n;i++)
+        for(int j=1;j<=n;j++)
+        {scanf("%d",&dist[i][j]);
+         map[i][j]=dist[i][j];}
+         memset(visit,0,sizeof(visit));
+         floyd();
+         int ans=0;
+         bool flag=true;
+         for(int i=1;i<=n;i++)
+         for(int j=1;j<=n;j++)
+         {
+            if(visit[i][j]==1&&dist[i][j]==map[i][j])
+            {
+                ans++;
+            }
+            if(dist[i][j]<map[i][j])
+            {
+                flag=false;
+            }
+         }
+         int m=n*(n-1)-ans;
+         if(!flag||m<n-1)
+         printf("Case %d: impossible\n",count++);
+         else
+        printf("Case %d: %d\n",count++,m);
+    }
+}
diff --git a/HDOJ/4035_autoAC.cpp b/HDOJ/4035_autoAC.cpp
new file mode 100644
index 0000000..85f558b
--- /dev/null
+++ b/HDOJ/4035_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<iostream>
+#include<math.h>
+#include<vector>
+using namespace std;
+const int MAXN=10010;
+const double eps=1e-9;
+double k[MAXN],e[MAXN];
+double A[MAXN],B[MAXN],C[MAXN];
+vector<int>vec[MAXN];
+bool dfs(int t,int pre)
+{
+    int m=vec[t].size();
+    A[t]=k[t];
+    B[t]=(1-k[t]-e[t])/m;
+    C[t]=1-k[t]-e[t];
+    double tmp=0;
+    for(int i=0;i<m;i++)
+    {
+        int v=vec[t][i];
+        if(v==pre)continue;
+        if(!dfs(v,t))return false;
+        A[t]+=(1-k[t]-e[t])/m*A[v];
+        C[t]+=(1-k[t]-e[t])/m*C[v];
+        tmp+=(1-k[t]-e[t])/m*B[v];
+    }
+    if(fabs(tmp-1)<eps)return false;
+    A[t]/=(1-tmp);
+    B[t]/=(1-tmp);
+    C[t]/=(1-tmp);
+    return true;
+}
+int main()
+{
+    int T;
+    int n;
+    int u,v;
+    int iCase=0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++)vec[i].clear();
+        for(int i=1;i<n;i++)
+        {
+            scanf("%d%d",&u,&v);
+            vec[u].push_back(v);
+            vec[v].push_back(u);
+        }
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%lf%lf",&k[i],&e[i]);
+            k[i]/=100;
+            e[i]/=100;
+        }
+        printf("Case %d: ",iCase);
+        if(dfs(1,-1)&&fabs(1-A[1])>eps)
+        {
+            printf("%.6lf\n",C[1]/(1-A[1]));
+        }
+        else printf("impossible\n");
+    }
+}
diff --git a/HDOJ/4036_autoAC.cpp b/HDOJ/4036_autoAC.cpp
new file mode 100644
index 0000000..ee027c6
--- /dev/null
+++ b/HDOJ/4036_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+typedef struct _point
+{
+    double x,y,v;
+    double HP;
+}point;
+point Poin[ 1005 ];
+point Tudo[ 1005 ];
+int search( double X, int H )
+{
+    int m,l = 1,h = H;
+    while ( l < h ) {
+        m = (l+h+1)>>1;
+        if ( Poin[ m ].x > X )
+            h = m-1;
+        else l = m;
+    }
+    return h;
+}
+int main()
+{
+    int T,N,M,W;
+    scanf("%d",&T);
+    for ( int t = 1 ; t <= T ; ++ t ) {
+        scanf("%d%d%d",&N,&M,&W);
+        for ( int i = 1 ; i <= N ; ++ i )
+            scanf("%lf%lf",&Poin[ i ].x,&Poin[ i ].y);
+        for ( int i = 1 ; i <= M ; ++ i )
+            scanf("%lf%lf%d",&Tudo[ i ].x,&Tudo[ i ].v,&W);
+        for ( int i = 1 ; i <= M ; ++ i ) {
+            int s = search( Tudo[ i ].x, N );
+            if ( Tudo[ i ].x == Poin[ s ].x )
+                Tudo[ i ].y = Poin[ s ].y;
+            else
+                Tudo[ i ].y = Poin[ s ].y + (Poin[ s+1 ].y-Poin[ s ].y)/(Poin[ s+1 ].x-Poin[ s ].x)*(Tudo[ i ].x-Poin[ s ].x);
+            Tudo[ i ].HP = 40.0*(Tudo[ i ].y-Poin[ 1 ].y) + Tudo[ i ].v*Tudo[ i ].v;
+        }
+        double Max = 0;
+        for ( int i = 1 ; i <= M ; ++ i )
+            if ( Max < Tudo[ i ].HP ) 
+                Max = Tudo[ i ].HP;
+        for ( int i = 2 ; i <= N ; ++ i ) {
+            double HP = 40.0*(Poin[ i ].y-Poin[ 1 ].y);
+            if ( Max < HP ) Max = HP;
+        }
+        printf("Case %d: %.2lf\n",t,sqrt(Max));
+    }
+    return 0;
+}
diff --git a/HDOJ/4037_autoAC.cpp b/HDOJ/4037_autoAC.cpp
new file mode 100644
index 0000000..29c67eb
--- /dev/null
+++ b/HDOJ/4037_autoAC.cpp
@@ -0,0 +1,136 @@
+#include<algorithm>
+#include<iostream>
+#include<string.h>
+#include<stdio.h>
+using namespace std;
+const int INF=0x3f3f3f3f;
+const int maxn=100010;
+typedef long long ll;
+const ll mod=20110911*2;
+#define lson L,mid,ls
+#define rson mid+1,R,rs
+ll sm[maxn],ss[maxn],sc[maxn<<2],sd[maxn<<2],siid[maxn<<2];
+ll sic[maxn<<2],sid[maxn<<2],ac[maxn<<2],ad[maxn<<2];
+ll asc,aic,asd,aid,aiid;
+void addc(int L,int R,int rt,ll d)
+{
+    ac[rt]=(ac[rt]+d)%mod;
+    sc[rt]=(sc[rt]+(R-L+1)*d)%mod;
+    sic[rt]=(sic[rt]+(sm[R]-sm[L-1])*d)%mod;
+}
+void addd(int L,int R,int rt,ll d)
+{
+    ad[rt]=(ad[rt]+d)%mod;
+    sd[rt]=(sd[rt]+(R-L+1)*d)%mod;
+    sid[rt]=(sid[rt]+(sm[R]-sm[L-1])*d)%mod;
+    siid[rt]=(siid[rt]+(ss[R]-ss[L-1])*d)%mod;
+}
+void PushDown(int L,int R,int rt)
+{
+    int ls=rt<<1,rs=ls|1,mid=(L+R)>>1;
+    if(ad[rt])
+        addd(lson,ad[rt]),addd(rson,ad[rt]),ad[rt]=0;
+    if(ac[rt])
+        addc(lson,ac[rt]),addc(rson,ac[rt]),ac[rt]=0;
+}
+void PushUp(int rt)
+{
+    int ls=rt<<1,rs=ls|1;
+    sc[rt]=(sc[ls]+sc[rs])%mod;
+    sic[rt]=(sic[ls]+sic[rs])%mod;
+    sd[rt]=(sd[ls]+sd[rs])%mod;
+    sid[rt]=(sid[ls]+sid[rs])%mod;
+    siid[rt]=(siid[ls]+siid[rs])%mod;
+}
+void build(int L,int R,int rt)
+{
+    ac[rt]=ad[rt]=0;
+    if(L==R)
+    {
+        scanf("%I64d%I64d",&sc[rt],&sd[rt]);
+        sic[rt]=(L*sc[rt])%mod;
+        sid[rt]=(L*sd[rt])%mod;
+        siid[rt]=(sid[rt]*L)%mod;
+        return;
+    }
+    int ls=rt<<1,rs=ls|1,mid=(L+R)>>1;
+    build(lson);
+    build(rson);
+    PushUp(rt);
+}
+void update(int L,int R,int rt,int l,int r,ll d,int op)
+{
+    if(l<=L&&R<=r)
+    {
+        if(op)
+            addd(L,R,rt,d);
+        else
+            addc(L,R,rt,d);
+        return;
+    }
+    int ls=rt<<1,rs=ls|1,mid=(L+R)>>1;
+    PushDown(L,R,rt);
+    if(l<=mid)
+        update(lson,l,r,d,op);
+    if(r>mid)
+        update(rson,l,r,d,op);
+    PushUp(rt);
+}
+void qu(int L,int R,int rt,int l,int r)
+{
+    if(l<=L&&R<=r)
+    {
+        asc=(asc+sc[rt])%mod;
+        aic=(aic+sic[rt])%mod;
+        asd=(asd+sd[rt])%mod;
+        aid=(aid+sid[rt])%mod;
+        aiid=(aiid+siid[rt])%mod;
+        return;
+    }
+    int ls=rt<<1,rs=ls|1,mid=(L+R)>>1;
+    PushDown(L,R,rt);
+    if(l<=mid)
+        qu(lson,l,r);
+    if(r>mid)
+        qu(rson,l,r);
+    PushUp(rt);
+}
+int main()
+{
+    int i,t,n,q,x,y,z,cas=1;
+    char cmd[20];
+    for(i=1;i<maxn;i++)
+    {
+        sm[i]=(sm[i-1]+i)%mod;
+        ss[i]=(ss[i-1]+(ll)i*i)%mod;
+    }
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        build(1,n,1);
+        scanf("%d",&q);
+        printf("Case %d:\n",cas++);
+        while(q--)
+        {
+            asc=aic=asd=aid=aiid=0;
+            scanf("%s%d%d",cmd,&x,&y);
+            if(cmd[0]!='Q')
+                scanf("%d",&z);
+            if(cmd[2]=='s')
+                update(1,n,1,x,y,z,0);
+            else if(cmd[2]=='l')
+                update(1,n,1,x,y,z,1);
+            else
+            {
+                qu(1,n,1,x,y);
+                ll ans=((ll)y*(y+1)*asd-(2*y+1)*aid+aiid)%mod;
+                ans-=2*((y+1)*asc-aic);
+                ans%=mod;
+                ans=(ans+mod)%mod;
+                printf("%I64d\n",ans/2);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4038_autoAC.cpp b/HDOJ/4038_autoAC.cpp
new file mode 100644
index 0000000..99785bb
--- /dev/null
+++ b/HDOJ/4038_autoAC.cpp
@@ -0,0 +1,80 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#define mod 1000000007
+using namespace std;
+int t,n,a[100010],odd_num,m,indx,Minpos,Min;
+__int64 ans;
+void init(){
+    odd_num = 0;    ans = 1;
+    Min = mod;  indx = 1;
+}
+long long pow_mod(int a,int n,int p)
+{
+    long long ret=1;
+    long long A=a;
+    while(n)
+    {
+        if (n & 1)
+            ret=(ret*A)%p;
+        A=(A*A)%p;
+        n>>=1;
+    }
+    return ret;
+}
+int main()
+{
+    scanf("%d",&t);
+    for(int ca = 1; ca <= t; ca ++){
+        scanf("%d%d",&n,&m); init();
+        for(int i = 1; i <= n;i ++){
+            scanf("%d",a + i);
+            if(a[i] < 0) odd_num++;
+        }
+        sort(a + 1, a + 1 + n);
+        if(odd_num & 1){
+            int j = 1;
+            while(a[j] < 0) j ++;   indx = -- j;
+            if(a[j] + m > 0) m += a[j], a[j] = 0;
+            else a[j] += m,m = 0;
+        }
+        if(m > 0){
+            for(int j = indx; j <= n && m > 0; j ++)
+                if(a[j] == 0) a[j] ++, m --;
+            for(int j = indx; j <= n && m > 0; j ++)
+                if(a[j] == 1) a[j] ++, m --;
+            for(int j = indx; j <= n && m > 0; j ++)
+                if(a[j] == 2) a[j] ++, m --;
+            for(int j = 1; j <= n; j ++)
+                ans = (ans * a[j]) % mod;
+            if(m <= 0){
+                printf("Case %d: %I64d\n",ca,ans);
+            }else{
+                if(m == 1){
+                    for(int j = 1; j <= n; j ++)
+                        if(Min > a[j]) Min = a[j], Minpos = j;
+                    ans /= a[Minpos];
+                    ans = (ans * (a[Minpos] + 1)) % mod;
+                    printf("Case %d: %I64d\n",ca,ans);
+                }else if(m % 3 == 0){
+                    ans = (ans * pow_mod(3,m/3,mod)) % mod;
+                    printf("Case %d: %I64d\n",ca,ans);
+                }else if((m - 1) % 3 == 0){
+                    ans = (ans * pow_mod(3,(m - 1)/3 - 1,mod)) % mod;
+                    ans = (ans * 4) % mod;
+                    printf("Case %d: %I64d\n",ca,ans);
+                }else if((m - 2) % 3 == 0){
+                    ans = (ans * pow_mod(3,(m - 2)/3,mod)) % mod;
+                    ans = (ans * 2) % mod;
+                    printf("Case %d: %I64d\n",ca,ans);
+                }
+            }
+        }
+        else{
+            for(int j = 1; j <= n; j ++)
+                ans = (ans * a[j]) % mod;
+            printf("Case %d: %I64d\n",ca,ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4039_autoAC.cpp b/HDOJ/4039_autoAC.cpp
new file mode 100644
index 0000000..ceb80b5
--- /dev/null
+++ b/HDOJ/4039_autoAC.cpp
@@ -0,0 +1,106 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<map>
+#include<queue>
+using namespace std;
+map<string,int> mp;
+map<int,string> sp;
+int head[2500];
+int n,m,pos,cn;
+struct edge
+{
+    int v,next;
+}eg[2500*2500];
+struct visit
+{
+    int v,cnt;
+}vd[2500];
+bool cmp(visit a,visit b)
+{
+    if(a.cnt==b.cnt)return sp[a.v]<sp[b.v];
+    return a.cnt>b.cnt;
+}
+void find(int s)
+{
+    int vs[2500];int num=0;
+    memset(vs,-1,sizeof(vs));
+    bool vid[2500]={0};
+    for(int i=0;i<2500;i++)vd[i].cnt=0;
+    for(int i=head[s];i!=-1;i=eg[i].next)
+        vid[eg[i].v]=1;
+    for(int i=head[s];i!=-1;i=eg[i].next)
+    {
+        for(int j=head[eg[i].v];j!=-1;j=eg[j].next)
+        {
+            if(eg[j].v==s||vid[eg[j].v]==1)continue;
+            if(vs[eg[j].v]==-1)
+            {
+                vd[num].v=eg[j].v;
+                vd[num].cnt++;
+                vs[eg[j].v]=num++;
+            }
+            else
+                vd[vs[eg[j].v]].cnt++;
+        }
+    }
+    sort(vd,vd+num,cmp);
+    if(vd[0].cnt==0)printf("-");
+    else
+    {
+        cout<<sp[vd[0].v];
+        for(int i=1;i<num;i++)
+        {
+            if(vd[i].cnt==vd[0].cnt)
+            {
+                cout<<' '<<sp[vd[i].v];
+            }
+        }
+    }
+    printf("\n");
+}
+int main()
+{
+    int T,t,x,y;
+    char s1[100],s2[100];
+    scanf("%d",&T);
+    for(int t=1;t<=T;t++)
+    {
+        pos=1,cn=0;
+        memset(head,-1,sizeof(head));
+        mp.clear();sp.clear();
+        scanf("%d%d",&n,&m);
+        getchar();
+        for(int i=0;i<n;i++)
+        {
+            scanf("%s",s1);
+            scanf("%s",s2);
+            getchar();
+            if(mp[s1]==0)
+            {
+             mp[s1]=pos;
+             sp[pos++]=s1;
+            }
+            if(mp[s2]==0)
+            {
+             mp[s2]=pos;
+             sp[pos++]=s2;
+            }
+            x=mp[s1];y=mp[s2];
+            eg[cn].v=y;eg[cn].next=head[x];head[x]=cn++;
+            eg[cn].v=x;eg[cn].next=head[y];head[y]=cn++;
+        }
+        printf("Case %d:\n",t);
+        for(int i=0;i<m;i++)
+        {
+            scanf("%s",s1);
+            getchar();
+            int tem=mp[s1];
+            find(tem);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4041_autoAC.cpp b/HDOJ/4041_autoAC.cpp
new file mode 100644
index 0000000..a0fc6cd
--- /dev/null
+++ b/HDOJ/4041_autoAC.cpp
@@ -0,0 +1,79 @@
+#include<iostream>
+#include<string>
+#include<stack>
+#include<queue>
+using namespace std;
+stack<int> fstack;
+queue<int> Q;
+char s[1000010];
+struct name
+{
+    char str[11];
+}na[50001];
+int main()
+{
+    int cas,n,num;
+    char str1[11];
+    scanf("%d",&cas);
+    while(cas--)
+    {
+        while(!fstack.empty())
+            fstack.pop();
+        while(!Q.empty())
+            Q.pop();
+        scanf("%s",s);
+        int len=strlen(s);
+        num=0;
+        int j=0;
+        for(int i=0;i<len;i++)
+        {
+            if(s[i]>='a'&&s[i]<='z')
+                str1[j++]=s[i];
+            else
+            {
+                if(j!=0)
+                {
+                    str1[j]='\0';
+                    j=0;
+                    strcpy(na[++num].str,str1);
+                }
+                if(s[i]=='(')
+                {
+                    fstack.push(num);
+                        Q.push(num);
+                }
+                else if(s[i]==',')
+                {
+                    if(s[i-1]!=')')
+                        Q.push(num);
+                    Q.push(fstack.top());
+                }
+                else {
+                    if(s[i-1]!=')')
+                        Q.push(num);
+                    Q.push(fstack.top());
+                    fstack.pop();
+                }
+            }
+        }
+        if(num==0)
+        {
+            str1[j]='\0';
+            printf("1\n%s\n\n",str1);
+            continue;
+        }
+        printf("%d\n",num);
+        for(int i=1;i<=num;i++)
+            printf("%s\n",na[i].str);
+        while(!Q.empty())
+        {
+            if(Q.front()==1&&Q.size()==1)
+                break;
+            printf("%d ",Q.front());
+            Q.pop();
+            printf("%d\n",Q.front());
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/4042_autoAC.cpp b/HDOJ/4042_autoAC.cpp
new file mode 100644
index 0000000..a0057e7
--- /dev/null
+++ b/HDOJ/4042_autoAC.cpp
@@ -0,0 +1,130 @@
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define db double
+#define rt return
+#define cs const
+cs db eps = 1e-8 , PI = acos(-1.);
+inline int sig(db x){rt (x>eps)-(x<-eps);}
+#define cp const P&
+#define op operator
+cs int N = 511;
+struct P {
+    db x , y , z;
+    P(db a = 0 , db b = 0 , db c = 0):x(a),y(b),z(c){}
+    void in(){scanf("%lf%lf%lf" , &x , &y , &z);}
+    P op+(cp a)cs{rt P(x+a.x , y+a.y , z+a.z);}
+    P op-(cp a)cs{rt P(x-a.x , y-a.y , z-a.z);}
+    P op*(cs db&k)cs{rt P(x*k , y*k , z*k);}
+    P op^(cp a)cs{rt P(y*a.z-a.y*z , z*a.x-a.z*x , x*a.y-a.x*y);}
+    db op*(cp a)cs{rt x*a.x + y*a.y + z*a.z;}
+    db L(){rt sqrt(x*x + y*y + z*z);}
+    db rela(P v){rt sig(*this * v) * L();}
+    P cross(P a , P b){rt a-*this ^ b-*this;}
+    db dot(P a , P b){rt (a-*this) * (b-*this);}
+    int on_seg(P a , P b){rt cross(a,b).L() < eps && dot(a , b) < eps;}
+};
+P vp1[N] , vp2[N];
+int cnt1 , cnt2;
+struct face {
+    P a , b , c , v;
+    void init(){v = a.cross(b , c);}
+    int side(P p){rt sig(v*(p-a));}
+    int inter_line(P p , P vec , P &x) {
+        if(!sig(v*vec)) rt 0;
+        x = p + vec * (v*(a-p) / (v*vec));
+        rt 1;
+    }
+};
+inline db get_angle(P o , P a , P b , P v) {
+    rt atan2(o.cross(a , b).rela(v) , o.dot(a , b));
+}
+int read() {
+    scanf("%d%d" , &cnt1 , &cnt2);
+    for(int i = 0 ; i < cnt1 ; i++) vp1[i].in();
+    for(int i = 0 ; i < cnt2 ; i++) vp2[i].in();
+    vp1[cnt1] = vp1[0] , vp2[cnt2] = vp2[0];
+    rt cnt1 + cnt2;
+}
+inline int in_poly(P p , P vp[] , int n) {
+    for(int i = 0 ;i < n ; i++)
+        if(p.on_seg(vp[i] , vp[i+1])) rt 1;
+    P v;
+    for(int i = 2 ; i < n ; i++)
+        if(sig(vp[0].cross(vp[1] , vp[i]).L())) {
+            v = vp[0].cross(vp[1] , vp[i]);
+            break;
+        }
+    db agl = 0.;
+    for(int i = 0 ; i < n ; i++)
+        agl += get_angle(p , vp[i] , vp[i+1] , v);
+    rt !sig(agl-2.*PI) || !sig(agl+2.*PI);
+}
+inline int seg_seg(P a , P b , P c , P d) {
+    if(sig(a.cross(b , c) * (d-a))) rt 0;
+    P v = b - a ^ d - c;
+    db t = v.L();
+    if(sig(t) == 0)
+        rt a.on_seg(c , d) || b.on_seg(c , d) || c.on_seg(a , b) || d.on_seg(a , b);
+    db u1 = c.cross(d , a).rela(v) / t , u2 = a.cross(c , b).rela(v) / t;
+    rt sig(u1*(u1-1.)) <= 0 && sig(u2*(u2-1.)) <= 0;
+}
+inline int seg_face(P a , P b , P vp[] , int n) {
+    face f;
+    for(int i = 2 ; i < n ; i++)
+        if(sig(vp[0].cross(vp[1] , vp[i]).L())) {
+            f.a = vp[0] , f.b = vp[1] , f.c = vp[i] , f.init();
+            break;
+        }
+    int l = f.side(a) , r = f.side(b);
+    if(l * r > 0) rt 0;
+    if(l || r) {
+        P xp;
+        f.inter_line(a , b - a , xp);
+        rt in_poly(xp , vp , n);
+    }
+    for(int i = 0 ; i < n ; i++)
+        if(seg_seg(a , b , vp[i] , vp[i+1])) rt 1;
+    rt in_poly(a , vp , n) || in_poly(b , vp , n);
+}
+inline int face_face(P vp1[] , int cn1 , P vp2[] , int cnt2) {
+    for(int i = 0 ; i < cnt1 ; i++) {
+        if(seg_face(vp1[i] , vp1[i+1] , vp2 , cnt2)) rt 1;
+    }
+    rt 0;
+}
+inline int test_data(P vp[] , int n) {
+    int line = 1;
+    for(int i = 2 ; line && i < n ; i++)
+        if(sig(vp[0].cross(vp[1] , vp[i]).L())) line = 0;
+    rt !line;
+}
+void solve() {
+    int pic1 = test_data(vp1 , cnt1) , pic2 = test_data(vp2 , cnt2);
+    int inter = 0;
+    if(pic1 == 0 && pic2 == 0) {
+        for(int i = 0 ; inter == 0 && i < cnt1 ; i++)
+            for(int j = 0 ; inter == 0 && j < cnt2 ; j++)
+                inter = seg_seg(vp1[i] , vp1[i+1] , vp2[j] , vp2[j+1]);
+    }
+    if(pic1 == 0 && pic2 == 1) {
+        for(int i = 0 ; inter == 0 && i < cnt1 ; i++)
+            inter = seg_face(vp1[i] , vp1[i+1] , vp2 , cnt2);
+    }
+    if(pic1 == 1 && pic2 == 0) {
+        for(int i = 0 ; inter == 0 && i < cnt2 ; i++)
+            inter = seg_face(vp2[i] , vp2[i+1] , vp1 , cnt1);
+    }
+    if(pic1 == 1 && pic2 == 1) {
+        inter = face_face(vp1 , cnt1 , vp2 , cnt2) ||
+                    face_face(vp2 , cnt2 , vp1 , cnt1);
+    }
+    puts(inter ? "YES" : "NO");
+}
+int main() {
+    while(read()) {
+        solve();
+    }
+    rt 0;
+}
diff --git a/HDOJ/4043_autoAC.cpp b/HDOJ/4043_autoAC.cpp
new file mode 100644
index 0000000..28a6da0
--- /dev/null
+++ b/HDOJ/4043_autoAC.cpp
@@ -0,0 +1,77 @@
+#include<stdio.h>
+#include<string.h>
+#define N 2010
+#define K 510
+char mol[K][N],den[K][N];
+char virt[N];
+int gcd(int a,int b)
+{
+    return b?gcd(b,a%b):a;
+}
+int divide(char *str,int n,char *s)
+{
+    int i,k,len;
+    len=strlen(str);
+    s[len]=0;
+    for(k=0,i=len-1;i>=0;i--)
+    {
+        k=k*10+str[i]-'0';
+        s[i]=k/n+'0';
+        k%=n;
+    }
+    for(i=len-1;i>0;i--)
+    {
+        if(s[i]!='0')
+            break;
+        s[i]=0;
+    }
+    return k;
+}
+void mult(char *str,int n,char *x)
+{
+    int i,s[N];
+    for(i=0;i<N;i++)
+        s[i]=0;
+    for(i=0;str[i];i++)
+        s[i]=(str[i]-'0')*n;
+    for(i=0;i<N-1;i++)
+    {
+        s[i+1]+=s[i]/10;
+        s[i]%=10;
+    }
+    for(i=N-1;i>0 && s[i]==0;i--);
+    x[i+1]=0;
+    for(;i>=0;i--)x[i]=s[i]+'0';
+}
+void init()
+{
+    int i,j,k;
+    strcpy(mol[1],"1");
+    strcpy(den[1],"2");
+    for(i=2;i<K;i++)
+    {
+        j=2*i;
+        k=gcd(j,divide(mol[i-1],j,virt));
+        divide(mol[i-1],k,mol[i]);
+        mult(den[i-1],j/k,den[i]);
+        j--;
+        k=gcd(j,divide(den[i],j,virt));
+        if(k>1)
+            divide(den[i],k,den[i]);
+        mult(mol[i],j/k,mol[i]);
+        strrev(mol[i-1]);
+        strrev(den[i-1]);
+    }
+}
+int main()
+{
+    int n,T;
+    init();
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        printf("%s/%s\n",mol[n],den[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4044_autoAC.cpp b/HDOJ/4044_autoAC.cpp
new file mode 100644
index 0000000..a487202
--- /dev/null
+++ b/HDOJ/4044_autoAC.cpp
@@ -0,0 +1,100 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+const int MAXN=1010;
+const int INF=0x3fffffff;
+struct Node
+{
+    int to;
+    int next;
+}edge[MAXN*2];
+int tol;
+int head[MAXN];
+int dp[MAXN][220];
+int price[MAXN][60];
+int power[MAXN][60];
+void init()
+{
+    memset(head,-1,sizeof(head));
+    tol=0;
+}
+void add(int a,int b)
+{
+    edge[tol].to=b;
+    edge[tol].next=head[a];
+    head[a]=tol++;
+    edge[tol].to=a;
+    edge[tol].next=head[b];
+    head[b]=tol++;
+}
+int n,m;
+int tmp[MAXN];
+void dfs(int u,int pre)
+{
+    if(head[u]==-1||(edge[head[u]].to==pre&&edge[head[u]].next==-1))
+    {
+        for(int i=0;i<=m;i++)dp[u][i]=0;
+        for(int i=0;i<=m;i++)tmp[i]=dp[u][i];
+        for(int i=m;i>=0;i--)
+        {
+            for(int j=1;j<=price[u][0];j++)
+               if(price[u][j]<=i)
+                 dp[u][i]=max(dp[u][i],tmp[i-price[u][j]]+power[u][j]);
+            tmp[i]=dp[u][i];
+        }
+        return;
+    }
+    for(int i=0;i<=m;i++) dp[u][i]=INF;
+    for(int i=head[u];i!=-1;i=edge[i].next)
+    {
+        int v=edge[i].to;
+        if(v==pre)continue;
+        dfs(v,u);
+        for(int j=m;j>=0;j--)
+        {
+            int t=0;
+            for(int k=0;k<=j;k++)
+              t=max(t,min(dp[u][j-k],dp[v][k]));
+            dp[u][j]=t;
+        }
+    }
+    for(int i=0;i<=m;i++)tmp[i]=dp[u][i];
+    for(int i=m;i>=0;i--)
+    {
+        for(int j=1;j<=price[u][0];j++)
+          if(price[u][j]<=i)
+             dp[u][i]=max(dp[u][i],tmp[i-price[u][j]]+power[u][j]);
+        tmp[i]=dp[u][i];
+    }
+}
+int main()
+{
+    int u,v;
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        init();
+        scanf("%d",&n);
+        for(int i=1;i<n;i++)
+        {
+            scanf("%d%d",&u,&v);
+            add(u,v);
+        }
+        scanf("%d",&m);
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&price[i][0]);
+            power[i][0]=price[i][0];
+            for(int j=1;j<=price[i][0];j++)
+            {
+                scanf("%d%d",&price[i][j],&power[i][j]);
+            }
+        }
+        dfs(1,0);
+        printf("%d\n",dp[1][m]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4045_autoAC.cpp b/HDOJ/4045_autoAC.cpp
new file mode 100644
index 0000000..7a8311c
--- /dev/null
+++ b/HDOJ/4045_autoAC.cpp
@@ -0,0 +1,35 @@
+#include<iostream>
+#include<cmath>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#define LL long long
+#define eps 1e-7
+#define MOD 1000000007
+using namespace std;
+int c[2001][2001]={1},stir2[1005][1005]={1};
+int main(){
+    for(int i=1;i<=2000;i++){
+        c[i][0]=c[i][i]=1;
+        for(int j=1;j<i;j++)
+            c[i][j]=(c[i-1][j-1]+c[i-1][j])%MOD;
+    }
+    for(int i=1;i<=1000;i++){
+        stir2[i][0]=0;
+        stir2[i][i]=1;
+        for(int j=1;j<i;j++)
+            stir2[i][j]=((LL)j*stir2[i-1][j]+stir2[i-1][j-1])%MOD;
+    }
+    int n,r,k,m;
+    while(cin>>n>>r>>k>>m){
+        int sum=0;
+        if(n-((r-1)*k+1)<0){
+            cout<<0<<endl;
+            continue;
+        }
+        for(int i=1;i<=min(r,m);i++)
+            sum=(sum+stir2[r][i])%MOD;
+        cout<<((LL)c[n-((r-1)*k+1)+r+1-1][r]*sum)%MOD<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4046_autoAC.cpp b/HDOJ/4046_autoAC.cpp
new file mode 100644
index 0000000..247da11
--- /dev/null
+++ b/HDOJ/4046_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <cstdio>
+#include <iostream>
+using namespace std;
+int n, m;
+int c[60000];
+char str[60000];
+int lowbit ( int x )  
+{  
+    return x & ( -x );  
+}  
+void update ( int x, int v )  
+{  
+    for ( int i = x; i <= n; i += lowbit(i) )  
+        c[i] += v;   
+} 
+int getSum ( int x )  
+{  
+    int sum = 0;  
+    for ( int i = x; i > 0; i -= lowbit(i) )  
+        sum += c[i];  
+    return sum;  
+}  
+bool check ( char x, char y, char z )
+{
+    if ( x == 'w' && y == 'b' && z == 'w' )
+        return true;
+    return false;
+}
+void init ()
+{
+    for ( int i = 3; i <= n; i++ )
+        if ( check(str[i-2],str[i-1],str[i]) )
+            update ( i, 1 );
+}
+int main()
+{
+    char change;
+    int t, l, r, pos, oper;
+    int cnt = 0;
+    scanf("%d",&t);
+    while ( t-- )
+    {
+        scanf("%d%d",&n,&m);
+        scanf("%s",str+1);
+        memset(c,0,sizeof(c));
+        init();
+        printf("Case %d:\n",++cnt);
+        while ( m-- )
+        {
+            scanf("%d",&oper);
+            if ( oper == 0 )
+            {
+                scanf("%d%d",&l,&r);
+                l++; r++;
+                if ( l > r )  swap ( l, r );
+                if ( r - l < 2 )  printf("0\n");
+                else printf ("%d\n", getSum(r) - getSum(l+1) ); 
+            }
+            else
+            {
+                int i;
+                scanf("%d %c",&pos, &change);
+                pos++;
+                if ( str[pos] == change ) continue;
+                i = pos;
+                if ( 3 <= i && i <= n )
+                {
+                    if ( check(str[i-2],str[i-1],str[i]) && !check(str[i-2],str[i-1],change) )
+                        update(i,-1);
+                    if ( !check(str[i-2],str[i-1],str[i]) && check(str[i-2],str[i-1],change) )
+                        update(i,1);
+                }
+                i = pos + 1;
+                if ( 3 <= i && i <= n )
+                {
+                    if ( check(str[i-2],str[i-1],str[i]) && !check(str[i-2],change,str[i]) )
+                        update(i,-1);
+                    if ( !check(str[i-2],str[i-1],str[i]) && check(str[i-2],change,str[i]) )
+                        update(i,1);
+                }
+                i = pos + 2;
+                if ( 3 <= i && i <= n )
+                {
+                    if ( check(str[i-2],str[i-1],str[i]) && !check(change,str[i-1],str[i]) )
+                        update(i,-1);
+                    if ( !check(str[i-2],str[i-1],str[i]) && check(change,str[i-1],str[i]) )
+                        update(i,1);
+                }
+                str[pos] = change;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4048_autoAC.cpp b/HDOJ/4048_autoAC.cpp
new file mode 100644
index 0000000..2e7cdb2
--- /dev/null
+++ b/HDOJ/4048_autoAC.cpp
@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#define MAXN 20010
+int MOD;
+using namespace std;
+typedef long long LL;
+int cas, n, m, tx;
+int pri[MAXN], notp[MAXN], flag[MAXN], prs;
+int tot[MAXN], maxm;
+int fac[MAXN][305], facs[MAXN], phi[MAXN * 10];
+void init(){
+    for (int i = 2; i < MAXN; i++) if (!notp[i]) {
+        flag[i] = 1;
+        for (int j = i*2; j < MAXN; j += i) {
+            if (!notp[j]) notp[j] = flag[j] = 1;
+            else if (flag[j]) flag[j]++;
+            if (j%(i*i) == 0) flag[j] = 0;
+        }
+    }
+    for (int i = 2; i < MAXN; i++)
+        if (!notp[i]) pri[prs++] = i;
+    for (int i = 1; i < MAXN; i++)
+        for (int j = 1; j * j <= i; j++) if (i % j == 0) {
+            fac[i][facs[i]++] = j;
+            if (j * j != i)fac[i][facs[i]++] = i/j;
+        }
+    const int maxn = 100000;
+    for (int i = 1; i <= maxn; i ++) phi[i] = i;
+    for (int i = 2; i <= maxn; i ++) if(phi[i] == i) {
+        for(int j = i; j <= maxn; j += i)
+            phi[j] = phi[j] / i * (i - 1);
+    }
+}
+int powmod(int x, int d){
+    int ans = 1, tmp = x;
+    for (; d; d >>= 1, tmp = (LL)tmp * tmp % MOD)
+        if (d&1) ans = (LL)ans * tmp % MOD;
+    return ans;
+}
+int cal(int l){
+    int ans = powmod(tot[1], l);
+    for (int i = 2; i <= maxm; i++) {
+        if (flag[i] == 0) continue;
+        if (flag[i] & 1) ans = (ans - powmod(tot[i], l)) % MOD;
+        else ans = (ans + powmod(tot[i], l)) % MOD;
+    }
+    return (ans % MOD + MOD) % MOD;
+}
+void solve(){
+    int ans = 0;
+    for(int i = 1; i * i <= n; i ++) if(n % i == 0) {
+        ans = (ans + (LL)cal(i) * phi[n / i]) % MOD;
+        if(i * i != n)
+            ans = (ans + (LL)cal(n / i) * phi[i]) % MOD;
+    }
+    printf("%d\n", (ans + MOD) % MOD / n);
+}
+int main(){
+    init();
+    scanf("%d", &cas);
+    while (cas--) {
+        scanf("%d%d", &m, &n);
+        MOD = 10007 * n;
+        memset(tot, 0, sizeof tot);
+        maxm = 0;
+        for (int i = 1; i <= m; i++) {
+            scanf("%d", &tx);
+            maxm = max(tx, maxm);
+            for (int j = 0; j < facs[tx]; j++)
+                tot[fac[tx][j]]++;
+        }
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4049_autoAC.cpp b/HDOJ/4049_autoAC.cpp
new file mode 100644
index 0000000..0199ee4
--- /dev/null
+++ b/HDOJ/4049_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+using namespace std;
+int Maps[ 11 ][ 11 ];
+int Cost[ 11 ];
+int Inst[ 11 ][ 11 ];
+int F[ 11 ][ 1025 ];
+int Stat[ 11 ];
+int Q[ 11 ][ 1025 ];
+int main()
+{
+    int N,M;
+    while ( cin >> N >> M && N ) {
+        for ( int i = 1 ; i <= M ; ++ i )
+            cin >> Cost[ i ];
+        for ( int i = 1 ; i <= N ; ++ i )
+        for ( int j = 1 ; j <= M ; ++ j )
+            cin >> Inst[ i ][ j ];
+        for ( int i = 1 ; i <= N ; ++ i )
+        for ( int j = 1 ; j <= N ; ++ j )
+            cin >> Maps[ i ][ j ];
+        int V = (1<<N)-1;
+        for ( int i = 0 ; i <= N ; ++ i )
+        for ( int j = 0 ; j <= V ; ++ j )
+            F[ i ][ j ] = -10000001;
+        for ( int j = 0 ; j <= V ; ++ j )
+            F[ 0 ][ j ] = 0;
+        for ( int i = 1 ; i <= M ; ++ i ) 
+        for ( int j = 0 ; j <= V ; ++ j ) {
+            int temp = j;
+            for ( int k = 1 ; k <= N ; ++ k ) {
+                Stat[ k ] = temp%2;
+                temp /= 2;
+            }
+            int Save = 0;
+            for ( int k = 1 ; k <= N ; ++ k )
+                if ( Stat[ k ] )
+                    Save += Inst[ k ][ i ] - Cost[ i ];
+            for ( int p = 1 ; p <= N ; ++ p )
+            for ( int q = p+1 ; q <= N ; ++ q )
+                if ( Stat[ p ] && Stat[ q ] )
+                    Save += Maps[ p ][ q ];
+            int count = 0;
+            Q[ 0 ][ 0 ] = j;
+            for ( int k = 1 ; k <= N ; ++ k )
+                if ( !Stat[ k ] ) {
+                    for ( int p = 0 ; p < (1<<count) ; ++ p ) {
+                        int New = Q[ count ][ p ];
+                        Q[ count+1 ][ p*2+0 ] = New;
+                        Q[ count+1 ][ p*2+1 ] = New|(1<<(k-1));
+                    }
+                    ++ count;
+                }
+            int Min = -10000001;
+            for ( int k = 0 ; k < (1<<count) ; ++ k ) {
+                if ( Min < F[ i-1 ][ Q[ count ][ k ] ] )
+                    Min = F[ i-1 ][ Q[ count ][ k ] ];
+            }
+            F[ i ][ j ] = Min+Save;
+        }
+        int Max = -10000001;
+        for ( int i = 1 ; i <= M ; ++ i ) 
+        for ( int j = 0 ; j <= V ; ++ j )
+            if ( Max < F[ i ][ j ] )
+                Max = F[ i ][ j ];
+        if ( Max > 0 )
+            cout << Max << endl;
+        else
+            cout << "STAY HOME" << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4050_autoAC.cpp b/HDOJ/4050_autoAC.cpp
new file mode 100644
index 0000000..69a2f35
--- /dev/null
+++ b/HDOJ/4050_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<queue>
+#include<cmath>
+#include<string>
+#include<vector>
+#include<algorithm>
+#include<map>
+#include<set>
+#include<ctime>
+#define maxn 200005
+#define eps 1e-8
+#define inf 2000000000
+#define LL long long
+#define zero(a) fabs(a)<eps
+#define MOD 19901014
+#define N 1000005
+#define pi acos(-1.0)
+using namespace std;
+double dp[4004][4];
+double p[4004][4];
+int main(){
+    int t,a,b,n;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d%d",&n,&a,&b);
+        for(int i=1;i<=n;i++)
+            for(int j=0;j<4;j++)
+                scanf("%lf",&p[i][j]);
+        for(int i=n+1;i<=n+a;i++)
+            for(int j=0;j<4;j++)
+                p[i][j]=(j==3);
+        memset(dp,0,sizeof(dp));
+        dp[0][3]=1;
+        for(int i=0;i<=n;i++){
+            double p1=1,p2=1,p3=1;
+            for(int j=a;j<=b;j++){
+                dp[i+j][2]+=dp[i][1]*p1*p[i+j][2];
+                dp[i+j][3]+=dp[i][1]*p1*p[i+j][3];
+                p1*=(p[i+j][0]+p[i+j][1]);
+                dp[i+j][1]+=dp[i][2]*p2*p[i+j][1];
+                dp[i+j][3]+=dp[i][2]*p2*p[i+j][3];
+                p2*=(p[i+j][0]+p[i+j][2]);
+                dp[i+j][1]+=dp[i][3]*p3*p[i+j][1];
+                dp[i+j][2]+=dp[i][3]*p3*p[i+j][2];
+                dp[i+j][3]+=dp[i][3]*p3*p[i+j][3];
+                p3*=p[i+j][0];
+            }
+        }
+        double ans=0;
+        for(int i=1;i<=n+a;i++)
+            for(int j=1;j<4;j++)
+                ans+=dp[i][j];
+        printf("%.8f\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4051_autoAC.cpp b/HDOJ/4051_autoAC.cpp
new file mode 100644
index 0000000..ecd6e13
--- /dev/null
+++ b/HDOJ/4051_autoAC.cpp
@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include <string.h>
+#include <map>
+#include <algorithm>
+using namespace std;
+char ss[4][10], str[600];
+int l[5], c[4], n, mul[10], len, cn;
+int maxl[5];
+char stmp[10];
+bool pd(int x);
+int a[30], stri;
+bool check(int ssx){
+    int i, x;
+    for (i = 0; ss[ssx][i]; i++){
+        if (ss[ssx][i] < 10){
+            if (!check(ss[ssx][i])){
+                return false;
+            }
+        }else{
+            x = ss[ssx][i];
+            if (a[x] == -1){
+                a[x] = str[stri];
+            }
+            if (a[x] != str[stri]) return false;
+            stri++;
+        }
+    }
+    return true;
+}
+bool wk(int x, int p){
+    int i;
+    if (l[x] > len) return false;
+    if (p == c[x]){
+        maxl[x] = max(maxl[x + 1], l[x]);
+        return pd(x - 1);
+    }
+    for (i = x + 1; i < n; i++){
+        l[x] += l[i];
+        ss[x][p] = i;
+        if (wk(x, p + 1)) return true;
+        l[x] -= l[i];
+    }
+    ss[x][p] = cn++;
+    l[x]++;
+    if (wk(x, p + 1)) return true;
+    cn--;
+    l[x]--;
+    ss[x][p] = 0;
+    if (wk(x, c[x])) return true;
+    return false;
+}
+bool pd(int x){
+    if (mul[x] * maxl[x + 1] < len){
+        return false;
+    }
+    if (x < 0){
+        if (l[0] != len) return false;
+        memset(a, -1, sizeof(a));
+        stri = 0;
+        return check(0);
+    }
+    l[x] = 0;
+    if (wk(x, 0)) return true;
+    return false;
+}
+map<char, int> mp;
+int main(){
+    int i, s, ss;
+    while (scanf("%d", &n) != EOF){
+        s = 1;
+        for (i = 0; i < n; i++){
+            scanf("%d", &c[i]);
+            s += c[i] - 1;
+        }
+        ss = 0;
+        mul[0] = c[0];
+        for (i = 1; i < n; i++){
+            mul[i] = mul[i - 1] * c[i];
+        }
+        l[n] = 1;
+        maxl[n] = 1;
+        scanf("%s", str);
+        mp.clear();
+        for (i = 0; str[i]; i++){
+            if (mp.count(str[i]) == 0){
+                mp[str[i]] = 1;
+                ss++;
+            }
+        }
+        if (ss > s){
+            printf("No\n");
+            continue;
+        }
+        len = strlen(str);
+        if (len <= s){
+            printf("Yes\n");
+            continue;
+        }
+        cn = 10;
+        if (pd(n - 1)){
+            printf("Yes\n");
+        }else{
+            printf("No\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4052_autoAC.cpp b/HDOJ/4052_autoAC.cpp
new file mode 100644
index 0000000..b3f0ab2
--- /dev/null
+++ b/HDOJ/4052_autoAC.cpp
@@ -0,0 +1,113 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+#define lson l, m, rt << 1
+#define rson m + 1, r, rt << 1 | 1
+#define LL long long
+const int maxn = 100110;
+int sum[maxn << 2], cover[maxn << 2];
+int V[maxn], p[maxn][4];
+int n, w, h, cnt, tot;
+struct ST{
+    int l, r, h, c;
+    ST(){}
+    ST(int L, int R, int H, int C):l(L), r(R), h(H), c(C){};
+    bool operator < (const ST &cmp) const{
+        return h < cmp.h;
+    }
+}ss[maxn];
+void PushUp(int rt, int l, int r)
+{
+    if(cover[rt]) sum[rt] = V[r + 1] - V[l];
+    else if(l == r) sum[rt] = 0;
+    else sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
+}
+void update(int L, int R, int c, int l, int r, int rt)
+{
+    if(L <= l && r <= R){
+        cover[rt] += c;
+        PushUp(rt, l, r);
+        return ;
+    }
+    int m = (l + r) >> 1;
+    if(L <= m) update(L, R, c, lson);
+    if(m < R) update(L, R, c, rson);
+    PushUp(rt, l, r);
+}
+int Bin(int x)
+{
+    int l = 0, r = tot - 1;
+    while(l <= r){
+        int mid = (l + r) >> 1;
+        if(x == V[mid]) return mid;
+        else if(x > V[mid]) l = mid + 1;
+        else r = mid - 1;
+    }
+    return l;
+}
+LL gao()
+{
+    LL res = 0;
+    tot = 1;
+    sort(V, V + cnt);
+    sort(ss, ss + cnt);
+    for(int i = 1; i < cnt; i++){
+        if(V[i] != V[i - 1])
+            V[tot++] = V[i];
+    }
+    memset(sum, 0, sizeof(sum));
+    memset(cover, 0, sizeof(cover));
+    for(int i = 0; i < cnt - 1; i++){
+        int l = Bin(ss[i].l), r= Bin(ss[i].r) - 1;
+        if(l <= r){
+            update(l, r, ss[i].c, 0, tot, 1);
+            res += (LL)sum[1] * (ss[i + 1].h - ss[i].h);
+        }
+    }
+    return res;
+}
+LL sloveX(int n1, int m)
+{
+    cnt = 0;
+    for(int i = 0; i < n1; i++){
+        V[cnt] = max(0, p[i][0] - m);
+        ss[cnt++] = ST(max(0, p[i][0] - m), p[i][2], p[i][1] - 1, 1);
+        V[cnt] = p[i][2];
+        ss[cnt++] = ST(max(0, p[i][0] - m), p[i][2], p[i][3], -1);
+    }
+    V[cnt] = w - m + 1;
+    ss[cnt++] = ST(w - m + 1, w, 0, 1);
+    V[cnt] = w;
+    ss[cnt++] = ST(w - m + 1, w, h, -1);
+    return gao();
+}
+LL sloveY(int n1, int m)
+{
+    cnt = 0;
+    for(int i = 0; i < n1; i++){
+        V[cnt] = p[i][0] - 1;
+        ss[cnt++] = ST(p[i][0] - 1, p[i][2], max(0, p[i][1] - m), 1);
+        V[cnt] = p[i][2];
+        ss[cnt++] = ST(p[i][0] - 1, p[i][2], p[i][3], -1);
+    }
+    V[cnt] = 0;
+    ss[cnt++] = ST(0, w, h - m + 1, 1);
+    V[cnt] = w;
+    ss[cnt++] = ST(0, w, h, -1);
+    return gao();
+}
+int main()
+{
+    int n1, m;
+    while(scanf("%d %d %d %d", &w, &h, &n1, &m) == 4){
+        for(int i = 0; i < n1; i++)
+            scanf("%d %d %d %d", &p[i][0], &p[i][1], &p[i][2], &p[i][3]);
+        LL ans = 0;
+        if(w >= m)ans = (LL)w * h - sloveX(n1, m);
+        if(m != 1 && h >= m) ans += (LL)w * h - sloveY(n1, m);
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4054_autoAC.cpp b/HDOJ/4054_autoAC.cpp
new file mode 100644
index 0000000..d48eac1
--- /dev/null
+++ b/HDOJ/4054_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<iostream>
+#include<cctype>
+#include<cstring>
+#include<cstdio>
+using namespace std;
+int main()
+{
+    char s[4100];
+    while(gets(s))
+    {
+        int len=strlen(s);
+        int line;
+        if(len%16==0)line=len/16;
+        else line=len/16+1;
+        for(int i=0;i<line;i++)
+        {
+            int count=0;
+            printf("%.4x: ",i<<4);
+            for(int j=i*16;s[j]&&j<i*16+16;j++)
+            {
+                printf("%.2x",s[j]);
+                count+=2;
+                if(j&1){putchar(' ');count++;}
+            }
+            while(count++<40)putchar(' ');
+            for(int j=i*16;s[j]&&j<i*16+16;j++)
+            {
+                if(islower(s[j]))
+                putchar(toupper(s[j]));
+                else
+                putchar(tolower(s[j]));
+            }
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4055_autoAC.cpp b/HDOJ/4055_autoAC.cpp
new file mode 100644
index 0000000..932db1e
--- /dev/null
+++ b/HDOJ/4055_autoAC.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+using namespace std;
+const int N=1005;
+const int mod=1000000007;
+char str[N];
+int dp[N][N],sum[N][N];
+int main()
+{
+    while(scanf("%s",str+2)!=EOF)
+    {
+        memset(dp,0,sizeof(dp));
+        memset(sum,0,sizeof(sum));
+        int n=(int)strlen(str+2);
+        dp[1][1]=sum[1][1]=1;
+        for(int i=2;i<=n+1;i++)
+        {
+            for(int j=1;j<=i;j++)
+            {
+                if(str[i]=='I'||str[i]=='?') dp[i][j]=(dp[i][j]+sum[i-1][j-1])%mod;
+                if(str[i]=='D'||str[i]=='?') 
+                {
+                    int tmp=((sum[i-1][i-1]-sum[i-1][j-1])%mod+mod)%mod;
+                    dp[i][j]=(dp[i][j]+tmp)%mod;
+                }
+                sum[i][j]=(dp[i][j]+sum[i][j-1])%mod;
+            }
+        }
+        printf("%d\n",sum[n+1][n+1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4056_autoAC.cpp b/HDOJ/4056_autoAC.cpp
new file mode 100644
index 0000000..00ded90
--- /dev/null
+++ b/HDOJ/4056_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+#include <string>
+#include <cstdio>
+#include <cmath>
+#include <queue>
+#include <map>
+#include <set>
+#include <cstdlib>
+#include <ctime>
+#define eps 1e-5
+#define MAXN 111111
+#define MAXM 1111111
+#define INF 1000000008
+using namespace std;
+int fa[55555];
+int ans[15];
+struct P
+{
+    int a, b, c, x, y;
+    char op[15];
+}p[55555];
+int vis[55555];
+int find(int x)
+{
+    if(fa[x] == -1) return x;
+    int t = find(fa[x]);
+    fa[x] = t;
+    return t;
+}
+int main()
+{
+    int n, m, q;
+    while(scanf("%d%d%d", &n, &m, &q) != EOF)
+    {
+        memset(ans, 0, sizeof(ans));
+        for(int i = 0; i < q; i++)
+        {
+            scanf("%s%d%d%d%d", p[i].op, &p[i].x, &p[i].y, &p[i].a, &p[i].b);
+            if(p[i].op[0] == 'R') scanf("%d", &p[i].c);
+        }
+        for(int k = 0; k < n; k++)
+        {
+            for(int i = 0; i <= m; i++) fa[i] = -1, vis[i] = 0;
+            for(int i = q - 1; i >= 0; i--)
+            {
+                int co = p[i].b, a, b;
+                if(p[i].op[0] == 'R')
+                {
+                    co = p[i].c;
+                    if(k < p[i].x || k >= p[i].x + p[i].a) continue;
+                    a = p[i].y;
+                    b = p[i].y + p[i].b - 1;
+                }
+                else if(p[i].op[0] == 'C')
+                {
+                    if(abs(k - p[i].x) > p[i].a) continue;
+                    int tmp = p[i].a * p[i].a - (k - p[i].x) * (k - p[i].x);
+                    int tp = (int)(sqrt(tmp));
+                    a = p[i].y - tp;
+                    b = p[i].y + tp;
+                }
+                else if(p[i].op[0] == 'D')
+                {
+                    if(abs(k - p[i].x) > p[i].a) continue;
+                    int tmp = p[i].a - abs(k - p[i].x);
+                    a = p[i].y - tmp;
+                    b = p[i].y + tmp;
+                }
+                else if(p[i].op[0] == 'T')
+                {
+                    if(k - p[i].x >= (p[i].a + 1) / 2 || k < p[i].x) continue;
+                    int tmp = (p[i].a - 1) / 2 - (k - p[i].x);
+                    a = p[i].y - tmp;
+                    b = p[i].y + tmp;
+                }
+                a = max(a, 0);
+                b = min(m - 1, b);
+                int fx = find(a), fy;
+                for(int j = b; j >= a; j = fy - 1)
+                {
+                    fy = find(j);
+                    if(!vis[fy]) ans[co]++;
+                    vis[fy] = 1;
+                    if(fx != fy) fa[fy] = fx;
+                }
+            }
+        }
+        for(int i = 1; i < 9; i++) printf("%d ", ans[i]);
+        printf("%d\n", ans[9]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4057_autoAC.cpp b/HDOJ/4057_autoAC.cpp
new file mode 100644
index 0000000..a770f33
--- /dev/null
+++ b/HDOJ/4057_autoAC.cpp
@@ -0,0 +1,101 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+#include<cmath>
+#define eps 1e-10
+#define N 100005
+#define inf 1<<20
+#define zero(a) (fabs(a)<eps)
+#define lson (step<<1)
+#define rson (step<<1|1)
+using namespace std;
+struct Trie{
+    int next[4],fail;
+    int end;
+    void Init(){next[0]=next[1]=next[2]=next[3]=0;fail=end=0;}
+}tree[N];
+int dp[2][1005][1<<10];
+char str[105];
+int val[105],tot;
+int id(char ch){
+    if(ch=='A') return 0;
+    if(ch=='T') return 1;
+    if(ch=='G') return 2;
+    return 3;
+}
+void Insert(char *s,int len,int k){
+    int p=0;
+    for(int i=0;i<len;i++){
+        int q=id(s[i]);
+        if(tree[p].next[q]==0){
+            tree[++tot].Init();
+            tree[p].next[q]=tot;
+        }
+        p=tree[p].next[q];
+    }
+    tree[p].end|=(1<<k);
+}
+void Bulid_Fail(){
+    int que[N];
+    int head=0,tail=0;
+    que[tail++]=0;
+    while(head<tail){
+        int p=que[head++];
+        for(int i=0;i<4;i++){
+            if(tree[p].next[i]==0)
+                tree[p].next[i]=tree[tree[p].fail].next[i];
+            else{
+                int q=tree[p].next[i];
+                if(p)
+                    tree[q].fail=tree[tree[p].fail].next[i];
+                tree[q].end|=tree[tree[q].fail].end;
+                que[tail++]=q;
+            }
+        }
+    }
+}
+int n,m;
+int get(int state){
+    int ans=0;
+    for(int i=0;i<n;i++)
+        if(state&(1<<i))
+           ans+=val[i];
+    return ans;
+}
+void DP(){
+    memset(dp,0,sizeof(dp));
+    dp[0][0][0]=1;
+    for(int i=1;i<=m;i++){
+        memset(dp[i&1],0,sizeof(dp[i&1]));
+        for(int j=0;j<=tot;j++){
+            for(int k=0;k<4;k++){
+                for(int r=0;r<(1<<n);r++){
+                    if(dp[(i+1)&1][j][r])
+                        dp[i&1][tree[j].next[k]][r|tree[tree[j].next[k]].end]=1;
+                }
+            }
+        }
+    }
+    int ans=-inf;
+    for(int j=0;j<(1<<n);j++)
+        for(int i=0;i<=tot;i++)
+           if(dp[m&1][i][j]){
+              ans=max(ans,get(j));
+              break;
+           }
+    if(ans<0) puts("No Rabbit after 2012!");
+    else printf("%d\n",ans);
+}
+int main(){
+    while(scanf("%d%d",&n,&m)!=EOF){
+        tree[0].Init();tot=0;
+        for(int i=0;i<n;i++){
+            scanf("%s%d",str,&val[i]);
+            Insert(str,strlen(str),i);
+        }
+        Bulid_Fail();
+        DP();
+    }
+    return 0;
+}
diff --git a/HDOJ/4059_autoAC.cpp b/HDOJ/4059_autoAC.cpp
new file mode 100644
index 0000000..c406509
--- /dev/null
+++ b/HDOJ/4059_autoAC.cpp
@@ -0,0 +1,162 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<iostream>
+#include<math.h>
+#include<vector>
+using namespace std;
+#define LL __int64
+#define MOD 1000000007
+#define maxn 2000007
+LL yu[maxn];
+struct matrix
+{
+    LL mat[7][7];
+    matrix()
+    {
+        memset(mat,0,sizeof(mat));
+    }
+    friend matrix operator *(matrix A,matrix B)
+    {
+        int i,j,k;
+        matrix C;
+        for(i=1; i<=6; i++)
+        {
+            for(j=1; j<=6; j++)
+            {
+                for(k=1; k<=6; k++)
+                {
+                    C.mat[i][j]=(C.mat[i][j]+(A.mat[i][k]*B.mat[k][j])%MOD)%MOD;
+                }
+                C.mat[i][j]=C.mat[i][j]%MOD;
+            }
+        }
+        return C;
+    }
+} ONE,AA[30];
+matrix powmul(matrix A,LL k)
+{
+    matrix B;
+    for(int i=1; i<=6; i++)B.mat[i][i]=1;
+    int l=1;
+    while(k)
+    {
+        if(k&1)B=B*AA[l];
+        l++;
+        k>>=1;
+    }
+    return B;
+}
+vector<int>vec;
+void init()
+{
+    int i,j;
+    ONE.mat[1][1]=1;ONE.mat[1][2]=1;ONE.mat[1][3]=4;
+    ONE.mat[1][4]=6;ONE.mat[1][5]=4;ONE.mat[1][6]=1;
+    ONE.mat[2][1]=0;ONE.mat[2][2]=1;ONE.mat[2][3]=4;
+    ONE.mat[2][4]=6;ONE.mat[2][5]=4;ONE.mat[2][6]=1;
+    ONE.mat[3][1]=0;ONE.mat[3][2]=0;ONE.mat[3][3]=1;
+    ONE.mat[3][4]=3;ONE.mat[3][5]=3;ONE.mat[3][6]=1;
+    ONE.mat[4][4]=1;ONE.mat[4][5]=2;ONE.mat[4][6]=1;
+    ONE.mat[5][4]=0;ONE.mat[5][5]=1;ONE.mat[5][6]=1;
+    ONE.mat[6][6]=1;
+    yu[0]=0;
+    yu[1]=1;
+    LL x;
+    for(i=2;i<maxn;i++)
+    {
+        x=i%MOD;
+        x=x*i;
+        x=x%MOD;
+        x=x*i;
+        x=x%MOD;
+        x=x*i;
+        x=x%MOD;
+        yu[i]=yu[i-1]+x;
+        yu[i]=yu[i]%MOD;
+    }
+    AA[1]=ONE;
+    for(i=2;i<30;i++)AA[i]=AA[i-1]*AA[i-1];
+}
+matrix A;
+LL kan(LL x)
+{
+    if(x<maxn)return yu[x];
+    matrix OP;
+    for(int i=1;i<=6;i++)OP.mat[i][1]=1;
+    A=powmul(ONE,x-1);
+    OP=A*OP;
+    return OP.mat[1][1];
+}
+LL pan(LL n,LL x)
+{
+    if(x>=n)return 0;
+    LL p=1;
+    LL ns=4;
+    while(ns--)
+    {
+        p=p*x;
+        p=p%MOD;
+    }
+    ns=(n-1)/x;
+    p=p*kan(ns);
+    p=p%MOD;
+    return p;
+}
+void dos(LL n)
+{
+    LL p=1;
+    LL ans=0;
+    int i,j,leap;
+    LL m=n;
+    vec.clear();
+    for(i=2;i*i<=n;i++)
+    {
+        if(n%i==0)
+        {
+            vec.push_back(i);
+        }
+        while(n%i==0)n=n/i;
+    }
+    if(n!=1)vec.push_back(n);
+    n=m;
+    int t=1<<(vec.size());
+    for(i=1;i<t;i++)
+    {
+        leap=0;
+        p=1;
+        for(j=0;j<vec.size();j++)
+        {
+            if(i&(1<<j))
+            {
+                leap++;
+                p=p*vec[j];
+            }
+        }
+        leap=leap%2;
+        if(leap)ans+=pan(n,p);
+        else ans-=pan(n,p);
+        ans=(ans+MOD)%MOD;
+    }
+    ans=kan(n-1)-ans;
+    ans=(ans+MOD)%MOD;
+    printf("%I64d\n",ans);
+}
+int main()
+{
+    int T;
+    LL n;
+    init();
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%I64d",&n);
+        if(n==1)
+        {
+            cout<<"0"<<endl;
+            continue;
+        }
+        dos(n);
+    }
+    return 0;
+}
diff --git a/HDOJ/4060_autoAC.cpp b/HDOJ/4060_autoAC.cpp
new file mode 100644
index 0000000..c18210c
--- /dev/null
+++ b/HDOJ/4060_autoAC.cpp
@@ -0,0 +1,123 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+#define MAXN 210
+int nx, ny, g[MAXN][MAXN], sy[MAXN], cx[MAXN], cy[MAXN];
+int path(int u) {
+    for (int v = 1; v <= ny; v++)if (g[u][v] && !sy[v]) {
+            sy[v] = 1;
+            if (!cy[v] || path(cy[v])) {
+                cx[u] = v;
+                cy[v] = u;
+                return 1;
+            }
+        }
+    return 0;
+}
+int MaximumMatch() {
+    int i, ret = 0;
+    memset(cx, 0, sizeof (cx));
+    memset(cy, 0, sizeof (cy));
+    for (i = 1; i <= nx; i++)if (!cx[i]) {
+            memset(sy, 0, sizeof (sy));
+            ret += path(i);
+        }
+    return ret;
+}
+char c[2010];
+int s[2010][2010], w, h, n, m;
+int sum(int x0, int y0, int x1, int y1){
+    x0--, y0--;
+    return s[x1][y1] - s[x0][y1] - s[x1][y0] + s[x0][y0];
+}
+int sumx[2010], sumy[2010];
+int pd(int a, int b){
+    int i, j, ans = 0, t;
+    for (i = 0; i < n; i++){
+        for (j = 0; j < m; j++){
+            if (sum((a + b) * i + b + 1, (a + b) * j + b + 1, (a + b) * i + b + a, (a + b) * j + b + a) != a * a){
+                ans++;
+            }
+        }
+    }
+    for (i = 0; i <= n; i++){
+        sumx[i] = sum((a + b) * i + 1, 1, (a + b) * i + b, w);
+    }
+    for (j = 0; j <= m; j++){
+        sumy[j] = sum(1, (a + b) * j + 1, h, (a + b) * j + b);
+    }
+    for (i = 0; i <= n; i++){
+        for (j = 0; j <= m; j++){
+            g[i + 1][j + 1] = 0;
+            t = sum((a + b) * i + 1, (a + b) * j + 1, (a + b) * i + b, (a + b) * j + b);
+            sumx[i] -= t;
+            sumy[j] -= t;
+        }
+    }
+    for (i = 0; i <= n; i++){
+        if (sumx[i]) ans++;
+    }
+    for (j = 0; j <= m; j++){
+        if (sumy[j]) ans++;
+    }
+    for (i = 0; i <= n; i++){
+        if (sumx[i]) continue;
+        for (j = 0; j <= m; j++){
+            if (sumy[j]) continue;
+            t = sum((a + b) * i + 1, (a + b) * j + 1, (a + b) * i + b, (a + b) * j + b);
+            if (t) g[i + 1][j + 1] = 1;
+        }
+    }
+    nx = n + 1;
+    ny = m + 1;
+    return ans + MaximumMatch();
+}
+int main(){
+    int t, i, j, x, y, ans;
+    while (scanf("%d%d%d%d%d", &h, &w, &n, &m, &t) != EOF){
+        for (i = 1; i <= h; i++){
+            scanf("%s", c);
+            for (j = 0; c[j]; j++){
+                s[i][j + 1] = s[i][j];
+                if (c[j] == '1'){
+                    s[i][j + 1]++;
+                }
+            }
+        }
+        for (i = 1; i <= h; i++){
+            for (j = 1; j <= w; j++){
+                s[i][j] += s[i - 1][j];
+            }
+        }
+        if (n != m){
+            y = (h * m - w * n) / (m - n);
+            x = (h * (m + 1) - w * (n + 1)) / (n - m);
+            if (x <= 0 || y <= 0 || y > x || n * x + y * (n + 1) != h || m * x + y * (m + 1) != w){
+                printf("-1\n");
+                continue;
+            }
+            printf("%d\n", pd(x, y) * t);
+        }else{
+            if (h != w){
+                printf("-1\n");
+                continue;
+            }
+            ans = 1<<30;
+            for (x = 1; n * x < h; x++){
+                if ((h - n * x) % (n + 1) == 0){
+                    y = (h - n * x) / (n + 1);
+                    if (x >= y){
+                        ans = min(ans, pd(x, y));
+                    }
+                }
+            }
+            if (ans == (1<<30)){
+                printf("-1\n");
+            }else{
+                printf("%d\n", ans * t);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4061_autoAC.cpp b/HDOJ/4061_autoAC.cpp
new file mode 100644
index 0000000..cb79dd9
--- /dev/null
+++ b/HDOJ/4061_autoAC.cpp
@@ -0,0 +1,20 @@
+#include<stdio.h>
+#include<cstring>
+#include<algorithm>
+#define I(x) scanf("%d",&x)
+using namespace std;
+int main(){
+    int n,a,sum,t,b,ca=0;
+    I(t);
+    while(t--){
+        I(n);
+        sum=0;
+        for(int i=0;i<n;i++){
+            I(a);
+            sum+=a;
+            if(i==0) b=a;
+        }
+        printf("Case %d: %.6lf\n",++ca,1.0*b/sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4062_autoAC.cpp b/HDOJ/4062_autoAC.cpp
new file mode 100644
index 0000000..c0e5091
--- /dev/null
+++ b/HDOJ/4062_autoAC.cpp
@@ -0,0 +1,250 @@
+#include<cstdio>
+#include<cstring>
+#include<set>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+struct point{
+    int h,l;
+    friend bool operator <(point p1,point p2){return p1.h<p2.h||(p1.h==p2.h&&p1.l<p2.l);}
+};
+int h[]={1,1,1,1,1,2,3,4,5,6,7,8,9,9,9,9,9,8,7,6,5,4,3,2};
+int l[]={5,7,9,11,13,14,15,16,17,16,15,14,13,11,9,7,5,4,3,2,1,2,3,4};
+int hMove[]={0,-1,-1,0,1,1},lMove[]={-2,-1,1,2,1,-1};
+int cas,bnum,wnum;char map[19][19];set<point> s,whs;bool hasmove;
+int judge(char ch1,char ch2){
+    int i,j,cnt1,cnt2;
+    for(i=0;i<24;i++){
+        if(map[h[i]][l[i]]==ch1){
+            for(j=0;j<6;j++){
+                cnt1=1;cnt2=0;
+                if(map[h[i]+hMove[j]][l[i]+lMove[j]]==0||map[h[i]+hMove[j]][l[i]+lMove[j]]=='.')    
+                    continue;
+                while(map[h[i]+cnt1*hMove[j]][l[i]+cnt1*lMove[j]]==ch1)    
+                    cnt1++;
+                if(cnt1>=3)    continue;
+                while(map[h[i]+(cnt1+cnt2)*hMove[j]][l[i]+(cnt1+cnt2)*lMove[j]]==ch2)    
+                    cnt2++;
+                if(cnt2>cnt1){
+                    if(map[h[i]-hMove[j]][l[i]-lMove[j]]==0){
+                        if(ch1=='B'&&bnum-cnt1<9)   return 2;
+                        if(ch1=='W'&&wnum-cnt1<9)   return 0;
+                    }
+                }
+            }
+        }
+    }
+    return 1;
+}
+int wmove1(int h,int l){
+    int j,flag;bool idx;
+    for(j=0;j<6;j++){
+        idx=false;
+        if(map[h+hMove[j]][l+lMove[j]]=='.'){
+            swap(map[h][l],map[h+hMove[j]][l+lMove[j]]);
+            idx=true;hasmove=true;
+        }
+        if(idx){
+            flag=judge('W','B');
+            swap(map[h][l],map[h+hMove[j]][l+lMove[j]]);
+            if(flag==1)    return flag;
+        }
+    }
+    return 0;
+}
+int wmove2(int h1,int l1,int h2,int l2){
+    int j,flag;int idx;
+    for(j=0;j<6;j++){
+        idx=0;
+        if(map[h1+hMove[j]][l1+lMove[j]]=='.'&&map[h2+hMove[j]][l2+lMove[j]]=='.'){
+            swap(map[h1][l1],map[h1+hMove[j]][l1+lMove[j]]);
+            swap(map[h2][l2],map[h2+hMove[j]][l2+lMove[j]]);
+            idx=1;
+        }
+        if(h2-h1==hMove[j]&&l2-l1==lMove[j]){
+            if(map[h2+hMove[j]][l2+lMove[j]]=='.'){
+                swap(map[h1][l1],map[h2+hMove[j]][l2+lMove[j]]);
+                idx=2;
+            }
+            if(map[h2+hMove[j]][l2+lMove[j]]=='B'&&map[h2+2*hMove[j]][l2+2*lMove[j]]=='.'){
+                swap(map[h2+hMove[j]][l2+lMove[j]],map[h2+2*hMove[j]][l2+2*lMove[j]]);
+                swap(map[h1][l1],map[h2+hMove[j]][l2+lMove[j]]);
+                idx=3;
+            }
+            if(map[h2+hMove[j]][l2+lMove[j]]=='B'&&map[h2+2*hMove[j]][l2+2*lMove[j]]==0){
+                map[h2+hMove[j]][l2+lMove[j]]='W';
+                map[h1][l1]='.';
+                idx=4;            
+            }
+        }
+        if(idx) hasmove=true;
+        if(idx==1){
+            flag=judge('W','B');
+            swap(map[h1][l1],map[h1+hMove[j]][l1+lMove[j]]);
+            swap(map[h2][l2],map[h2+hMove[j]][l2+lMove[j]]);
+            if(flag==1)    return flag;
+        }
+        if(idx==2){
+            flag=judge('W','B');
+            swap(map[h1][l1],map[h2+hMove[j]][l2+lMove[j]]);
+            if(flag==1)    return flag;
+        }
+        if(idx==3){
+            flag=judge('W','B');
+            swap(map[h1][l1],map[h2+hMove[j]][l2+lMove[j]]);
+            swap(map[h2+hMove[j]][l2+lMove[j]],map[h2+2*hMove[j]][l2+2*lMove[j]]);
+            if(flag==1)    return flag;
+        }
+        if(idx==4){
+            flag=judge('W','B');
+            map[h2+hMove[j]][l2+lMove[j]]='B';
+            map[h1][l1]='W';
+            if(flag==1)    return flag;
+        }    
+    }
+    return 0;
+}
+int wmove3(int h1,int l1,int h2,int l2,int h3,int l3)
+{
+    int j,flag;int idx;
+    for(j=0;j<6;j++){
+        idx=0;
+        if(map[h1+hMove[j]][l1+lMove[j]]=='.'&&map[h2+hMove[j]][l2+lMove[j]]=='.'
+            &&map[h3+hMove[j]][l3+lMove[j]]=='.'){
+            swap(map[h1][l1],map[h1+hMove[j]][l1+lMove[j]]);
+            swap(map[h2][l2],map[h2+hMove[j]][l2+lMove[j]]);
+            swap(map[h3][l3],map[h3+hMove[j]][l3+lMove[j]]);
+            idx=1;
+        }
+        if(h2-h1==hMove[j]&&l2-l1==lMove[j]){
+            if(map[h3+hMove[j]][l3+lMove[j]]=='.'){
+                swap(map[h1][l1],map[h3+hMove[j]][l3+lMove[j]]);
+                idx=2;
+            }
+            if(map[h3+hMove[j]][l3+lMove[j]]=='B'&&map[h3+2*hMove[j]][l3+2*lMove[j]]=='.'){
+                swap(map[h3+hMove[j]][l3+lMove[j]],map[h3+2*hMove[j]][l3+2*lMove[j]]);
+                swap(map[h1][l1],map[h3+hMove[j]][l3+lMove[j]]);
+                idx=3;
+            }
+            if(map[h3+hMove[j]][l3+lMove[j]]=='B'&&map[h3+2*hMove[j]][l3+2*lMove[j]]==0){
+                map[h1][l1]='.';
+                map[h3+hMove[j]][l3+lMove[j]]='W';
+                idx=4;
+            }
+            if(map[h3+hMove[j]][l3+lMove[j]]=='B'&&map[h3+2*hMove[j]][l3+2*lMove[j]]=='B'
+                &&map[h3+3*hMove[j]][l3+3*lMove[j]]=='.'){
+                    swap(map[h3+hMove[j]][l3+lMove[j]],map[h3+3*hMove[j]][l3+3*lMove[j]]);
+                    swap(map[h1][l1],map[h3+hMove[j]][l3+lMove[j]]);
+                    idx=5;
+            }
+            if(map[h3+hMove[j]][l3+lMove[j]]=='B'&&map[h3+2*hMove[j]][l3+2*lMove[j]]=='B'
+                &&map[h3+3*hMove[j]][l3+3*lMove[j]]==0){
+                    map[h1][l1]='.';
+                    map[h2][l2]='.';
+                    map[h3+hMove[j]][l3+lMove[j]]='W';
+                    map[h3+2*hMove[j]][l3+2*lMove[j]]='W';
+                    idx=6;
+            }
+        }
+        if(idx) hasmove=true;
+        if(idx==1){
+            flag=judge('W','B');
+            swap(map[h1][l1],map[h1+hMove[j]][l1+lMove[j]]);
+            swap(map[h2][l2],map[h2+hMove[j]][l2+lMove[j]]);
+            swap(map[h3][l3],map[h3+hMove[j]][l3+lMove[j]]);
+            if(flag==1)    return flag;
+        }
+        if(idx==2){
+            flag=judge('W','B');
+            swap(map[h1][l1],map[h3+hMove[j]][l3+lMove[j]]);
+            if(flag==1)    return flag;
+        }
+        if(idx==3){
+            flag=judge('W','B');
+            swap(map[h1][l1],map[h3+hMove[j]][l3+lMove[j]]);
+            swap(map[h3+hMove[j]][l3+lMove[j]],map[h3+2*hMove[j]][l3+2*lMove[j]]);
+            if(flag==1)    return flag;
+        }
+        if(idx==4){
+            flag=judge('W','B');
+            map[h3+hMove[j]][l3+lMove[j]]='B';
+            map[h1][l1]='W';
+            if(flag==1)    return flag;
+        }
+        if(idx==5){
+            flag=judge('W','B');
+            swap(map[h1][l1],map[h3+hMove[j]][l3+lMove[j]]);
+            swap(map[h3+hMove[j]][l3+lMove[j]],map[h3+3*hMove[j]][l3+3*lMove[j]]);
+            if(flag==1)    return flag;
+        }
+        if(idx==6){
+            flag=judge('W','B');
+            map[h1][l1]='W';
+            map[h2][l2]='W';
+            map[h3+hMove[j]][l3+lMove[j]]='B';
+            map[h3+2*hMove[j]][l3+2*lMove[j]]='B';
+            if(flag==1)    return flag;
+        }
+    }
+    return 0;
+}
+void mycin(){
+    int i;
+    for(i=5;i<=13;i+=2) cin>>map[1][i];
+    for(i=4;i<=14;i+=2) cin>>map[2][i];
+    for(i=3;i<=15;i+=2) cin>>map[3][i];
+    for(i=2;i<=16;i+=2) cin>>map[4][i];
+    for(i=1;i<=17;i+=2) cin>>map[5][i];
+    for(i=2;i<=16;i+=2) cin>>map[6][i];
+    for(i=3;i<=15;i+=2) cin>>map[7][i];
+    for(i=4;i<=14;i+=2) cin>>map[8][i];
+    for(i=5;i<=13;i+=2) cin>>map[9][i];
+}
+int main()
+{
+    int i,j,k=1,flag;point p;
+    set<point>::iterator iter;
+    scanf("%d",&cas);
+    while(cas--){
+        s.clear();whs.clear();hasmove=false;
+        memset(map,0,sizeof(map));
+        mycin();
+        for(i=1,wnum=bnum=0;i<=9;i++){
+            for(j=1;j<=17;j++){
+                if(map[i][j]=='W'){wnum++;p.h=i;p.l=j;whs.insert(p);}
+                if(map[i][j]=='B')    bnum++;
+            }
+        }
+        flag=judge('B','W');
+        for(iter=whs.begin();iter!=whs.end()&&flag!=2;iter++){
+            int h1=iter->h,l1=iter->l;
+            flag=wmove1(h1,l1);
+            if(flag==1)    break;
+        }
+        for(iter=whs.begin();iter!=whs.end()&&flag!=1&&flag!=2;iter++){
+            for(j=0;j<6&&flag!=1;j++){
+                if(map[iter->h+hMove[j]][iter->l+lMove[j]]=='W'){
+                    int h1=iter->h,l1=iter->l,h2=h1+hMove[j],l2=l1+lMove[j];
+                    flag=wmove2(h1,l1,h2,l2);
+                    if(flag==1)    break;
+                }
+            }
+        }
+        for(iter=whs.begin();iter!=whs.end()&&flag!=1&&flag!=2;iter++){
+            for(j=0;j<6&&flag!=1;j++){
+                if(map[iter->h+hMove[j]][iter->l+lMove[j]]=='W'&&map[iter->h+2*hMove[j]][iter->l+2*lMove[j]]=='W'){
+                    int h1=iter->h,l1=iter->l,h2=h1+hMove[j],l2=l1+lMove[j],h3=h1+2*hMove[j],l3=l1+2*lMove[j];
+                    flag=wmove3(h1,l1,h2,l2,h3,l3);
+                    if(flag==1)    break;
+                }
+            }
+        }
+        if(hasmove==false&&flag!=2)
+            flag=judge('W','B');
+        printf("Case %d: ",k++);
+        if(flag==0)    printf("Black\n");
+        if(flag==1) printf("Draw\n");
+        if(flag==2)    printf("White\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4063_autoAC.cpp b/HDOJ/4063_autoAC.cpp
new file mode 100644
index 0000000..808fd9c
--- /dev/null
+++ b/HDOJ/4063_autoAC.cpp
@@ -0,0 +1,290 @@
+#include <set>
+#include <queue>
+#include <stack>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <limits.h>
+#include <string.h>
+#include <string>
+#include <algorithm>
+#define MID(x,y) ( ( x + y ) >> 1 )
+#define L(x) ( x << 1 )
+#define R(x) ( x << 1 | 1 )
+#define FOR(i,s,t) for(int i=(s); i<(t); i++)
+#define BUG puts("here!!!")
+#define STOP system("pause")
+#define file_r(x) freopen(x, "r", stdin)
+#define file_w(x) freopen(x, "w", stdout)
+using namespace std;
+const int MAX = 1000;
+const double eps = 1e-6;
+const double inf = 1e50;
+struct point{
+    double x, y;
+    void get()
+    {
+        scanf("%lf%lf", &x, &y);
+    }
+};
+bool dy(double x,double y)    {    return x > y + eps;}    
+bool xy(double x,double y)    {    return x < y - eps;}    
+bool dyd(double x,double y)    {     return x > y - eps;}    
+bool xyd(double x,double y)    {    return x < y + eps;}     
+bool dd(double x,double y)     {    return fabs( x - y ) < eps;}  
+double disp2p(point a,point b) 
+{
+    return sqrt( ( a.x - b.x ) * ( a.x - b.x ) + ( a.y - b.y ) * ( a.y - b.y ) );
+}
+bool operator==(point a, point b)
+{
+    return dd(a.x, b.x) && dd(a.y, b.y);
+}
+typedef struct NODE{
+    int to;
+    double len;
+    NODE *next;
+}NODE;
+NODE *p[MAX],node[MAX*MAX];
+struct circle{
+    point c;
+    double r;
+};
+circle c[MAX];
+int cou;
+void init()
+{
+    cou = 0;
+    memset(p, 0, sizeof(p));
+}
+void Add(int from,int to,double len)
+{
+    node[cou].next = p[from];
+    node[cou].to = to;
+    node[cou].len = len;
+    p[from] = &node[cou++];
+}
+queue<int> q;
+double SPFA_List(int from,int to,int n)
+{
+    while( !q.empty() ) q.pop();
+    double dis[MAX];
+    bool inq[MAX];
+    for(int i=0; i<n; i++)
+        dis[i] = inf;
+    memset(inq,false,sizeof(inq));
+    dis[from] = 0;
+    q.push(from);
+    inq[from] = 1;
+    while( !q.empty() )
+    {
+        int now = q.front();
+        q.pop();
+        inq[now] = false;
+        NODE *head = p[now];
+        while( head != NULL )
+        {
+            int v = head->to;
+            double len = head->len;
+            if( dy(dis[v], dis[now] + len) )
+            {
+                dis[v] = dis[now] + len;
+                if( !inq[v] )
+                {
+                    inq[v] = true;
+                    q.push(v);
+                }
+            }
+            head = head->next;
+        }
+    }
+    if( dd(dis[to], inf) ) return -1;
+    return dis[to];
+}
+point l2l_inst_p(point u1,point u2,point v1,point v2)
+{
+    point ans = u1;
+    double t = ((u1.x - v1.x)*(v1.y - v2.y) - (u1.y - v1.y)*(v1.x - v2.x))/
+                ((u1.x - u2.x)*(v1.y - v2.y) - (u1.y - u2.y)*(v1.x - v2.x));
+    ans.x += (u2.x - u1.x)*t;
+    ans.y += (u2.y - u1.y)*t;
+    return ans;
+}
+void l2c_inst_p(point c,double r,point l1,point l2,point &p1,point &p2)
+{
+    point p = c;
+    double t;
+    p.x += l1.y - l2.y;
+    p.y += l2.x - l1.x;
+    p = l2l_inst_p(p,c,l1,l2);
+    t = sqrt(r*r - disp2p(p,c)*disp2p(p,c))/disp2p(l1,l2);
+    p1.x = p.x + (l2.x - l1.x)*t;
+    p1.y = p.y + (l2.y - l1.y)*t;
+    p2.x = p.x - (l2.x - l1.x)*t;
+    p2.y = p.y - (l2.y - l1.y)*t;
+}
+void c2c_inst_p(point c1,double r1,point c2,double r2,point &p1,point &p2)
+{
+    point u,v;
+    double t;
+    t = (1 + (r1*r1 - r2*r2)/disp2p(c1,c2)/disp2p(c1,c2))/2;
+    u.x = c1.x + (c2.x - c1.x)*t;
+    u.y = c1.y + (c2.y - c1.y)*t;
+    v.x = u.x + c1.y - c2.y;
+    v.y = u.y - c1.x + c2.x;
+    l2c_inst_p(c1,r1,u,v,p1,p2);
+}
+bool c2c_tangent(point a,double r1,point b,double r2)
+{
+    if( dd(disp2p(a,b),r1+r2) || dd(disp2p(a,b),fabs(r1-r2)) )
+        return true;
+    return false;
+}
+point c2c_tangent_p(point a,double r1,point b,double r2)
+{
+    point t;
+    if( dd(disp2p(a,b),r1 + r2)  )
+    {
+        t.x = (r1*b.x + r2*a.x)/(r1 + r2);
+        t.y = (r1*b.y + r2*a.y)/(r1 + r2);
+        return t;
+    }
+    t.x = (r1*b.x - r2*a.x)/(r1 - r2);
+    t.y = (r1*b.y - r2*a.y)/(r1 - r2);
+    return t;
+}
+point g[MAX];
+bool f[MAX][MAX];
+double crossProduct(point a,point b,point c)
+{
+    return (c.x - a.x)*(b.y - a.y) - (b.x - a.x)*(c.y - a.y);
+}
+double disp2l(point a,point l1,point l2)
+{
+    return fabs( crossProduct(a,l1,l2) )/disp2p(l1,l2);
+}
+bool onSegment(point a, point b, point c)
+{
+    if( dd(crossProduct(a,b,c),0.0) && dyd(c.x,min(a.x,b.x)) && 
+        xyd(c.x,max(a.x,b.x)) && dyd(c.y,min(a.y,b.y)) && xyd(c.y,max(a.y,b.y)) )
+        return true;
+    return false;
+}
+bool cmp(point a, point b)
+{
+    if( dd(a.x, b.x) )    return xy(a.y, b.y);
+    return xy(a.x, b.x);
+}
+point tp[MAX];
+bool check(int cnt, int n)
+{
+    FOR(i, 1, cnt)
+    {
+        point tt;
+        tt.x = (tp[i].x + tp[i-1].x)/2;
+        tt.y = (tp[i].y + tp[i-1].y)/2;
+        bool f = false;
+        FOR(k, 0, n)
+            if( xyd(disp2p(c[k].c, tt), c[k].r) )
+            {
+                f = true;
+                break;
+            }
+        if( !f )
+            return false;
+    }
+    return true;
+}
+double solve(int n)
+{
+    int l = 0;
+    int s = 0, t = n-1;
+    FOR(i, 0, n)
+        g[l++] = c[i].c;
+    FOR(i, 0, n)
+    {
+        FOR(k, i+1, n)
+        {
+            if( dy(disp2p(c[i].c, c[k].c), c[i].r + c[k].r) 
+                    || c[i].c == c[k].c )
+                continue;
+            if( c2c_tangent(c[i].c, c[i].r, c[k].c, c[k].r) )
+            {
+                point tt = c2c_tangent_p(c[i].c, c[i].r, c[k].c, c[k].r);
+                g[l++] = tt;
+                continue;
+            }
+            point t1, t2;
+            c2c_inst_p(c[i].c, c[i].r, c[k].c, c[k].r, t1, t2);
+            g[l++] = t1;
+            g[l++] = t2;
+        }
+    }
+    memset(f, false, sizeof(f));
+    int tmp[MAX];
+    FOR(i, 0, n)
+    {
+        int cnt = 0;
+        FOR(k, 0, l)
+            if( xyd(disp2p(c[i].c, g[k]), c[i].r) )
+                tmp[cnt++] = k;
+        FOR(k, 0, cnt)
+            FOR(j, k+1, cnt)
+            {
+                int x = tmp[k], y = tmp[j];
+                if( f[x][y] ) continue;
+                double dis = disp2p(g[x], g[y]);
+                Add(x, y, dis);
+                Add(y, x, dis);
+                f[x][y] = f[y][x] = true;
+            }        
+    }
+    FOR(i, 0, l)
+        FOR(k, i+1, l)
+        {
+            if( f[i][k] ) continue;
+            int cnt = 0;
+            tp[cnt++] = g[i];
+            tp[cnt++] = g[k];
+            FOR(j, 0, n)
+                if( xyd(disp2l(c[j].c, g[i], g[k]),c[j].r) )
+                {
+                    point t1, t2;
+                    l2c_inst_p(c[j].c, c[j].r, g[i], g[k], t1, t2);
+                    if( onSegment(g[i], g[k], t1) )
+                        tp[cnt++] = t1;
+                    if( onSegment(g[i], g[k], t2) )
+                        tp[cnt++] = t2;        
+                }
+            sort(tp, tp+cnt, cmp);
+            if( check(cnt, n) )
+            {
+                Add(i, k, disp2p(g[i], g[k]));
+                Add(k, i, disp2p(g[k], g[i]));
+            }
+        }
+    return SPFA_List(s, t, l);
+}
+int main()
+{
+    int ncases, n, ind = 1;
+    scanf("%d", &ncases);
+    while( ncases-- )
+    {
+        scanf("%d", &n);
+        init();
+        FOR(i, 0, n)
+        {
+            c[i].c.get();
+            scanf("%lf", &c[i].r);
+        }
+        double ans = solve(n);
+        printf("Case %d: ",ind++);
+        if( ans < -eps )
+            puts("No such path.");
+        else
+            printf("%.4lf\n", ans);
+    }
+return 0;
+}
diff --git a/HDOJ/4064_autoAC.cpp b/HDOJ/4064_autoAC.cpp
new file mode 100644
index 0000000..70bf788
--- /dev/null
+++ b/HDOJ/4064_autoAC.cpp
@@ -0,0 +1,76 @@
+# include<stdio.h>
+# include<string.h>
+# define N 600000
+# define mod 1000000007
+int n,m;
+__int64 dp[2][N],sum;
+char map[15][15][5];
+int a[200],tag,flag;
+int s[15];
+void DFS(int r,int up,int down,int num,int right)
+{
+    int xx,rr,yy,ll,i;
+    if(num==m)
+    {
+        if(r==0) dp[flag][down]+=tag;
+        else
+        {
+            dp[flag][down]+=dp[(flag+1)%2][up]*tag;
+            dp[flag][down]%=mod;
+        }
+        return;
+    }
+    for(i=1;i<4;i++)
+        if(map[r][num][i]!=map[r][num][0]) break;
+    if(i==4)
+    {
+        tag*=4;
+        xx=a[map[r][num][0]];
+        if(xx==right || right==-1) DFS(r,up*3+xx,down*3+xx,num+1,xx);
+        tag/=4;
+        return;
+    }
+    for(i=0;i<4;i++)
+    {
+        xx=a[map[r][num][i]];
+        rr=a[map[r][num][(i+1)%4]];
+        yy=a[map[r][num][(i+2)%4]];
+        ll=a[map[r][num][(i+3)%4]];
+        if(right==-1 || ll==right) DFS(r,up*3+xx,down*3+yy,num+1,rr);
+    }
+}
+int main()
+{
+    int i,j,ncase,t;
+    scanf("%d",&ncase);
+    a['F']=0;
+    a['C']=1;
+    a['R']=2;
+    s[0]=1;
+    for(i=1;i<=12;i++)
+        s[i]=s[i-1]*3;
+    for(t=1;t<=ncase;t++)
+    {
+        scanf("%d%d",&n,&m);
+        for(i=0;i<n;i++)
+            for(j=0;j<m;j++)
+                scanf("%s",map[i][j]);
+        flag=0;
+        memset(dp,0,sizeof(dp));
+        for(i=0;i<n;i++)
+        {
+            tag=1;
+            flag=(flag+1)%2;
+            DFS(i,0,0,0,-1);
+            for(j=0;j<s[m];j++) dp[(flag+1)%2][j]=0;
+        }
+        sum=0;
+        for(i=0;i<s[m];i++)
+        {
+            sum+=dp[flag][i];
+            sum%=mod;
+        }
+        printf("Case %d: %I64d\n",t,sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4066_autoAC.cpp b/HDOJ/4066_autoAC.cpp
new file mode 100644
index 0000000..d1df168
--- /dev/null
+++ b/HDOJ/4066_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+const int maxn=1510;
+double a[maxn], d[maxn];
+void getd()
+{
+    d[1]=0.5;
+    for(int i=2; i<maxn; i++)
+        d[i]=d[i-1]*(2*i-1)/(2*i);
+}
+void geta()
+{
+    a[0]=1.0;
+    for(int i=1; i<maxn; i++)
+        a[i]=a[i-1]+2*d[i];
+}
+int main()
+{
+    getd();
+    geta();
+    int t, ca=1, n;
+    scanf("%d", &t);
+    while(t-->0)
+    {
+        scanf("%d", &n);
+        printf("Case %d: ", ca++);
+        if(n&1)
+            printf("%.6lf\n", a[n/2]);
+        else
+            printf("%.6lf\n", (a[(n-1)/2]+a[(n+1)/2])*0.5);
+    }
+    return 0;
+}
diff --git a/HDOJ/4067_autoAC.cpp b/HDOJ/4067_autoAC.cpp
new file mode 100644
index 0000000..852285a
--- /dev/null
+++ b/HDOJ/4067_autoAC.cpp
@@ -0,0 +1,118 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<queue>
+using namespace std;
+#define MAXN 222
+#define MAXM 2222222
+#define inf 1<<30
+struct Edge{
+    int v,cap,cost,next;
+}edge[MAXM];
+int n,m,vs,vt,NE;
+int head[MAXN];
+void Insert(int u,int v,int cap,int cost)
+{
+    edge[NE].v=v;
+    edge[NE].cap=cap;
+    edge[NE].cost=cost;
+    edge[NE].next=head[u];
+    head[u]=NE++;
+    edge[NE].v=u;
+    edge[NE].cap=0;
+    edge[NE].cost=-cost;
+    edge[NE].next=head[v];
+    head[v]=NE++;
+}
+int dist[MAXN],pre[MAXN],cur[MAXN];
+bool mark[MAXN];
+bool spfa(int vs,int vt)
+{
+    memset(mark,false,sizeof(mark));
+    fill(dist,dist+MAXN-1,inf);
+    dist[vs]=0;
+    queue<int>que;
+    que.push(vs);
+    while(!que.empty()){
+        int u=que.front();
+        que.pop();
+        mark[u]=false;
+        for(int i=head[u];i!=-1;i=edge[i].next){
+            int v=edge[i].v,cost=edge[i].cost;
+            if(edge[i].cap>0&&dist[u]+cost<dist[v]){
+                dist[v]=cost+dist[u];
+                pre[v]=u;
+                cur[v]=i;
+                if(!mark[v]){
+                    mark[v]=true;
+                    que.push(v);
+                }
+            }
+        }
+    }
+    return dist[vt]<inf;
+}
+int MinCostFlow(int vs,int vt)
+{
+    int flow=0,cost=0;
+    while(spfa(vs,vt)){
+        int aug=inf;
+        for(int u=vt;u!=vs;u=pre[u]){
+            aug=min(aug,edge[cur[u]].cap);
+        }
+        flow+=aug;cost+=dist[vt]*aug;
+        for(int u=vt;u!=vs;u=pre[u]){
+            edge[cur[u]].cap-=aug;
+            edge[cur[u]^1].cap+=aug;
+        }
+    }
+    return cost;
+}
+int In[MAXN],Out[MAXN];
+bool Judge()
+{
+    for(int i=head[vs];i!=-1;i=edge[i].next){
+        int cap=edge[i].cap;
+        if(cap>0)return false;
+    }
+    return true;
+}
+int main()
+{
+    int s,t,u,v,a,b,sum,cost,T=1,_case;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d%d%d",&n,&m,&s,&t);
+        NE=0;
+        memset(head,-1,sizeof(head));
+        memset(In,0,sizeof(In));
+        memset(Out,0,sizeof(Out));
+        sum=0;
+        while(m--){
+            scanf("%d%d%d%d",&u,&v,&a,&b);
+            if(a<=b){
+                Insert(v,u,1,b-a);
+                In[v]++,Out[u]++;
+                sum+=a;
+            }else {
+                Insert(u,v,1,a-b);
+                sum+=b;
+            }
+        }
+        In[s]++;
+        Out[t]++;
+        vs=0,vt=n+1;
+        for(int i=1;i<=n;i++){
+            if(In[i]>Out[i])Insert(vs,i,(In[i]-Out[i]),0);
+            else if(In[i]<Out[i])Insert(i,vt,(Out[i]-In[i]),0);
+        }
+        cost=MinCostFlow(vs,vt);
+        printf("Case %d: ",T++);
+        if(Judge()){
+            printf("%d\n",sum+cost);
+        }else 
+            puts("impossible");
+    }
+    return 0;
+}
diff --git a/HDOJ/4068_autoAC.cpp b/HDOJ/4068_autoAC.cpp
new file mode 100644
index 0000000..771ad3d
--- /dev/null
+++ b/HDOJ/4068_autoAC.cpp
@@ -0,0 +1,118 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#define LEN 25
+#define N 10
+using namespace std;
+bool g[N][N];
+char name[N][LEN];
+int n;
+int p1[N],p2[N];
+void change(int *ans)
+{
+    int x,y,OK=0;
+    for(int i=0; i<n; i++)
+    {
+        x=ans[i];
+        y=p1[i];
+        if(strcmp(name[x],name[y]) < 0) 
+            break;
+        else if(strcmp(name[y],name[x]) < 0)
+        {
+            OK=1;
+            break;
+        }
+    }
+    if(OK)
+        for(int i=0; i<n; i++)
+            ans[i]=p1[i];
+}
+bool fight()
+{
+    int i=0,j=0,x,y;
+    while(i<n && j<n)
+    {
+        x=p1[i];
+        y=p2[j];
+        if(g[y][x]) i++;
+        else        j++;
+    }
+    return i<n;
+}
+void solve(int Case)
+{
+    for(int i=0; i<n; i++) p1[i]=p2[i]=i;
+    int ans[N],FIND,OK;
+    FIND=0;
+    do
+    {
+        sort(p2,p2+n);
+        OK=1;
+        do
+        {
+            if(!fight())
+            {
+                OK=0;
+                break;
+            }
+        }
+        while(next_permutation(p2,p2+n)); 
+        if(OK)
+        {
+            if(!FIND)
+            {
+                FIND=1;
+                for(int i=0; i<n; i++) 
+                    ans[i]=p1[i];
+            }
+            else 
+                change(ans);
+        }
+    }
+    while(next_permutation(p1,p1+n)); 
+    if(!FIND)
+        printf("Case %d: No\n",Case);
+    else
+    {
+        printf("Case %d: Yes\n",Case);
+        for(int i=0; i<n; i++)
+        {
+            if(i) printf(" ");
+            printf("%s",name[ans[i]]);
+        }
+        printf("\n");
+    }
+}
+void input()
+{
+    scanf("%d",&n);
+    for(int i=0; i<n; i++) 
+        scanf("%s",name[i]);
+    memset(g,0,sizeof(g));
+    for(int i=0; i<n; i++)
+    {
+        int m;
+        char tmp[LEN];
+        scanf("%d",&m);
+        for(int j=0; j<m; j++)
+        {
+            scanf("%s",tmp);
+            for(int k=0; k<n; k++) if(!strcmp(name[k],tmp))
+            {
+                g[i][k]=1;
+                break;
+            }
+        }
+    }
+}
+int main()
+{
+    int T,t;
+    scanf("%d",&T);
+    for(t=1; t<=T; t++)
+    {
+        input();
+        solve(t);
+    }
+    return 0;
+}
diff --git a/HDOJ/4069_autoAC.cpp b/HDOJ/4069_autoAC.cpp
new file mode 100644
index 0000000..43d9521
--- /dev/null
+++ b/HDOJ/4069_autoAC.cpp
@@ -0,0 +1,193 @@
+#include<stdio.h>
+#include<memory.h>
+#include <climits>
+#include<string.h>
+#include<stdlib.h>
+#define N 1024
+#define M 1024*110
+int l[M], r[M], d[M], u[M], col[M], row[M], o[N], res[N], s[N],head[M];
+int node=0,count;
+int map[10][10],visit[10][10],a[10][10];
+int cmp(const void *a,const void *b)
+{
+ return *(int*)a-*(int*)b;
+}
+inline void addnode(int &x)
+{
+ ++x;
+    r[x] = l[x] = u[x] = d[x] = x;
+}
+inline void insert_row(int rowx, int x)
+{
+    r[l[rowx]] = x;
+    l[x] = l[rowx];
+    r[x] = rowx;
+    l[rowx] = x;
+}
+inline void insert_col(int colx, int x)
+{
+    d[u[colx]] = x;
+    u[x] = u[colx];
+    d[x] = colx;
+    u[colx] = x;
+}
+void dlx_init(int col)
+{
+ memset(head,-1,sizeof(head));
+ memset(res,0,sizeof(res));
+ memset(o,0,sizeof(o));
+ memset(s,0,sizeof(s));
+ int i;
+ node=-1;
+ addnode(node);
+ for(i=1;i<=col;i++)
+ {
+        addnode(node);
+        insert_row(0, node);  
+ }
+}
+inline void insert_node(int x,int y)
+{
+ s[y]++;
+ addnode(node);
+ row[node]=x;
+ col[node]=y;
+ insert_col(y,node);
+ if(head[x]==-1) head[x]=node;
+ else
+  insert_row(head[x],node);
+}
+inline void remove(int c)
+{
+    l[r[c]] = l[c];
+    r[l[c]] = r[c];
+ int i,j;
+    for (i = d[c]; i != c; i = d[i])
+        for (j = r[i]; j != i; j = r[j])
+        {
+            u[d[j]] = u[j];
+            d[u[j]] = d[j];
+            s[col[j]]--;
+        }
+}
+inline void resume(int c)
+{
+    for (int i = u[c]; i != c; i = u[i])
+        for (int j = l[i]; j != i; j = l[j])
+        {
+            u[d[j]] = j;
+            d[u[j]] = j;
+            s[col[j]]++;
+        }
+    l[r[c]] = c;
+    r[l[c]] = c;
+}
+void print()
+{
+ int i,k=0,j,ans[82]={0};
+ for(i=0;i<81;i++)
+  ans[i]=res[i];
+ qsort(ans,81,sizeof(int),cmp);
+ for(i=0;i<9;i++)
+  for(j=0;j<9;j++)
+   map[i][j]=ans[k++]-(i*9+j)*9;
+}
+bool DLX(int deep)
+{
+    if (r[0] == 0)
+    {
+  count++;
+  if(count==1)
+   print();
+  else
+   return true;
+  return false;
+ }
+    int min = INT_MAX, tempc,i,j;
+    for (i = r[0]; i != 0; i = r[i])
+        if (s[i] < min)
+        {
+            min = s[i];
+            tempc = i;
+        }
+    remove(tempc);
+    for (i = d[tempc]; i != tempc; i = d[i])
+    {
+        res[deep] = row[i];
+        for (j = r[i]; j != i; j = r[j]) remove(col[j]);
+        if (DLX(deep + 1)) return true;
+        for (j = l[i]; j != i; j = l[j]) resume(col[j]);
+    }
+    resume(tempc);
+    return false;
+}
+inline void dad(int i,int j,int ii)
+{
+ int x=(i*9+j)*9+ii;
+ insert_node(x,i*9+j+1);
+ insert_node(x,81+i*9+ii);
+ insert_node(x,81*2+j*9+ii);
+ insert_node(x,81*3+9*(visit[i][j]-1)+ii);
+}
+void dfs(int i,int j,int n)
+{
+ if(i<0||i>9||j<0||j>9)
+  return;
+ visit[i][j]=n;
+ if(!(a[i][j]&16)&&!visit[i-1][j])
+  dfs(i-1,j,n);
+ if(!(a[i][j]&32)&&!visit[i][j+1])
+  dfs(i,j+1,n);
+ if(!(a[i][j]&64)&&!visit[i+1][j])
+  dfs(i+1,j,n);
+ if(!(a[i][j]&128)&&!visit[i][j-1])
+  dfs(i,j-1,n);
+}
+int main()
+{
+ int n,cases=0;
+ scanf("%d",&n);
+ while(cases++<n)
+ {
+  count=0;
+  memset(visit,0,sizeof(visit));
+  memset(a,0,sizeof(a));
+  dlx_init(81*4);
+  int k=0,i=0,j=0,s=1;
+  for(i=0;i<9;i++)
+   for(j=0;j<9;j++)
+   {
+    scanf("%d",&map[i][j]);
+    a[i][j]=map[i][j]&(~15);
+    map[i][j]=map[i][j]&15;
+   }
+  for(i=0;i<9;i++)
+   for(j=0;j<9;j++)
+    if(!visit[i][j])
+     dfs(i,j,s++);
+  for(i=0;i<9;i++)
+   for(j=0;j<9;j++)
+    if(map[i][j]==0)
+    {
+     int ii;
+     for(ii=1;ii<=9;ii++)
+      dad(i,j,ii);
+    }
+    else
+     dad(i,j,map[i][j]);
+  DLX(0);
+  printf("Case %d:\n",cases);
+  if(!count)
+   printf("No solution\n");
+  else if(count==1)
+   for(i=0;i<9;i++)
+   {
+    for(j=0;j<9;j++)
+     printf("%d",map[i][j]);
+    printf("\n");
+   }
+  else
+   printf("Multiple Solutions\n");
+ }
+ return 0;
+}
diff --git a/HDOJ/4070_autoAC.cpp b/HDOJ/4070_autoAC.cpp
new file mode 100644
index 0000000..425f6f6
--- /dev/null
+++ b/HDOJ/4070_autoAC.cpp
@@ -0,0 +1,36 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+#define N 100004
+struct node
+{
+    int s,t;
+}ans[N];
+bool cmp(node a,node b)
+{
+    if(a.t!=b.t)return a.t>b.t;
+    else a.s>b.s;
+}
+int main()
+{
+    int t,c=0,n;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d%d",&ans[i].s,&ans[i].t);
+        }
+        sort(ans,ans+n,cmp);
+        int ans1=0,time=0;
+        for(int i =0;i<n;i++)
+        {
+            time+=ans[i].s;
+            ans1=max(time+ans[i].t,ans1);
+        }
+        printf("Case %d: %d\n",++c,ans1);
+    }
+    return 0;
+}
diff --git a/HDOJ/4071_autoAC.cpp b/HDOJ/4071_autoAC.cpp
new file mode 100644
index 0000000..c23565e
--- /dev/null
+++ b/HDOJ/4071_autoAC.cpp
@@ -0,0 +1,64 @@
+#include <iostream>
+#include <cmath>
+using namespace std;
+#define max(a,b) ((a)>=(b)?(a):(b))
+const int maxn = 50000;
+struct node
+{
+    double x, y;
+}pt[maxn+5];
+bool set(double &tl, double &tr, double cl, double cr)
+{
+    if (cl>tr || tl>cr) return false;
+    if (tr>cr) tr = cr;
+    if (tl<cl) tl = cl;
+    return true;
+}
+bool ok(double r, int n, double &p)
+{
+    int i;
+    double r2 = r*r;
+    double td, tl, tr;
+    td = sqrt(r2-pt[0].y*pt[0].y);
+    tl = pt[0].x - td;
+    tr = pt[0].x + td;
+    for (i=1; i<n; i++)
+    {
+        td = sqrt(r2-pt[i].y*pt[i].y);
+        if (!set(tl, tr, pt[i].x-td, pt[i].x+td))
+            return false;
+    }
+    p = (tl+tr)/2;
+    return true;
+}
+void solve(int n, double &p, double &d)
+{
+    double low = 0, high = 3e5;
+    int i;
+    for (i=0; i<n; i++) low = max(low, fabs(pt[i].y));
+    double mid;
+    while(fabs(high-low)>1e-9)
+    {
+        mid = (low+high)/2;
+        if (ok(mid, n, p))
+        {
+            d = mid;
+            high = mid;
+        }
+        else low = mid;
+    }
+}
+int main()
+{
+    int n;
+    int i;
+    double p, d;
+    while(scanf("%d", &n)!=EOF)
+    {
+        if (n==0) break;
+        for (i=0; i<n; i++) scanf("%lf %lf", &pt[i].x, &pt[i].y);
+        solve(n, p, d);
+        printf("%.9lf %.9lf\n", p, d);
+    }
+    return 0;
+}
diff --git a/HDOJ/4072_autoAC.cpp b/HDOJ/4072_autoAC.cpp
new file mode 100644
index 0000000..eb3c459
--- /dev/null
+++ b/HDOJ/4072_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <cstdio>
+#include <iostream>
+#include <cstring>
+#include <cmath>
+#include <string>
+#include <algorithm>
+#include <queue>
+#include <stack>
+using namespace std;
+const double PI = acos(-1.0);
+const double e = 2.718281828459;
+const double eps = 1e-8;
+char s[10];
+int main()
+{
+    int n;
+    int flag = 0;
+    while(cin>>n && n)
+    {
+        if(!flag)
+            flag = 1;
+        else
+            printf("\n");
+        int sum1, sum2, m;
+        sum1 = sum2 = 0;
+        while(n--)
+        {
+            cin>>s>>m;
+            if(s[0] == 'D')
+            {  
+                printf("DROP 2 %d\n", m);
+                sum2 += m;
+            }
+            else
+            {
+                if(sum1 >= m)
+                {   
+                    printf("TAKE 1 %d\n", m);
+                    sum1 -= m;
+                }
+                else
+                {   
+                    if(sum1 > 0)
+                    {   
+                        printf("TAKE 1 %d\n", sum1);
+                        m -= sum1;
+                        sum1 = 0;
+                    }   
+                    printf("MOVE 2->1 %d\n", sum2);
+                    sum1 = sum2;
+                    sum2 = 0;  
+                    if(m > 0)
+                    {
+                        printf("TAKE 1 %d\n", m);
+                        sum1 -= m;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4073_autoAC.cpp b/HDOJ/4073_autoAC.cpp
new file mode 100644
index 0000000..8662331
--- /dev/null
+++ b/HDOJ/4073_autoAC.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <cmath>
+#include <algorithm>
+#include <vector>
+#include <cstdlib>
+#include <sstream>
+#include <fstream>
+#include <list>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <map>
+#include <set>
+#include <bitset>
+#include <cctype>
+#include <ctime>
+#include <utility>
+#define M0(x) memset(x, 0, sizeof(x))
+#define clr(x,y) memset(x, y, sizeof(x))
+#define P 10567201
+#define N 1010
+using namespace std;
+long long c[1010][1010], two[1010];
+int n, m, v;
+long long f[N+5], inv[N+5];  
+using namespace std;
+void get_inv(){
+    inv[1] = 1;
+    for (int i = 2; i < N; ++i)
+        inv[i] = (P - P / i) * inv[P % i] % P;
+}
+void pre_do(){
+     get_inv();
+     two[0] = 1;
+     for (int i = 1; i < N; ++i){
+         two[i] = (two[i-1] << 1);
+         if (two[i] >= P) two[i] -= P;
+    }
+    for (int i = 1; i < N; ++i){
+         c[i][0] = 1;
+         for (int j = 1; j < N; ++j)
+             c[i][j] = c[i][j-1] * (two[i]-j+1) % P * inv[j] % P;    
+    }
+}
+void solve(){
+     if (v == 0) f[0] = 1;
+     else f[0] = 0;
+     f[1] = 1;
+     for (int i = 2; i <= m; ++i){
+        long long same = f[i-2] * (two[n]-i+2) % P;
+        f[i] = (c[n][i-1] - same) * inv[i] % P;
+     }
+     f[m] += (f[m] < 0 ? P : 0); 
+     printf("%I64d\n", f[m]);
+}
+int main(){
+    pre_do();
+    while (scanf("%d%d%d", &n, &m, &v) != EOF){
+         if (!(n+m+v)) break;
+         solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4074_autoAC.cpp b/HDOJ/4074_autoAC.cpp
new file mode 100644
index 0000000..49c1240
--- /dev/null
+++ b/HDOJ/4074_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cmath>
+#include<cstring>
+#include<vector>
+#define M 502
+using namespace std;
+double p[M][M][2];
+int d[]={5,20,1,18,4,13,6,10,15,2,17,3,19,7,16,8,11,14,9,12,5,20};
+int cal(int a,int b){ return a>=b?a-b:a;}
+int main()
+{
+    int n,m;
+    for(n=0;n<M;n++){
+        p[0][n][0]=1;
+        p[n][0][1]=1;
+    }
+    for(n=1;n<M;n++)
+    for(m=1;m<M;m++){
+        if(n<=20) p[n][m][0]=n/20.0;
+        if(m<=20) p[n][m][1]=m/3.0;
+        for(int k=0;k<90;k++){
+            double a=0;
+            for(int i=1;i<=20;i++)
+                a+=p[cal(n,d[i])][m][1];
+            p[n][m][0]=1-a/20.0;
+            double b=1e300;
+            for(int i=1;i<=20;i++){
+                double c=0;
+                for(int j=-1;j<=1;j++)
+                    c+=p[n][cal(m,d[i+j])][0];
+                c/=3.0;
+                if(b>c) b=c;
+            }
+            p[n][m][1]=1-b;
+            if(n>20) break;
+        }
+    }
+    while(scanf("%d",&n)&&n){
+        printf("%.12lf %.12lf\n",p[n][n][0],p[n][n][1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4076_autoAC.cpp b/HDOJ/4076_autoAC.cpp
new file mode 100644
index 0000000..b2c01de
--- /dev/null
+++ b/HDOJ/4076_autoAC.cpp
@@ -0,0 +1,101 @@
+# include<stdio.h>
+# include<string.h>
+# include<queue>
+using namespace std;
+# define N 35
+# define INF 0xfffffff
+int dir[4][2]={0,1,0,-1,1,0,-1,0};
+struct node{
+    int x,y;
+};
+int map[N][N],visit[N][N];
+int count1[N][N],mark[N][N];
+int xx[N][N],yy[N][N],tt[N][N];
+int n,m,flag;
+void bfs()
+{
+    int i,ans;
+    queue<node>q;
+    node cur,next;
+    cur.x=0;
+    cur.y=0;
+    q.push(cur);
+    visit[0][0]=0;
+    mark[0][0]=1;
+    count1[0][0]++;
+    while(!q.empty())
+    {
+        cur=q.front();
+        mark[cur.x][cur.y]=0;
+        q.pop();
+        if(count1[cur.x][cur.y]>n*m) {flag=1;return;}
+        if(cur.x==n-1 && cur.y==m-1) continue;
+        if(xx[cur.x][cur.y]!=-1)
+        {
+            next.x=xx[cur.x][cur.y];
+            next.y=yy[cur.x][cur.y];
+            ans=visit[cur.x][cur.y]+tt[cur.x][cur.y];
+            if(visit[next.x][next.y]>ans)
+            {
+                visit[next.x][next.y]=ans;
+                if(mark[next.x][next.y]==0)
+                {
+                    mark[next.x][next.y]=1;
+                    count1[next.x][next.y]++;
+                    q.push(next);
+                }
+            }
+            continue;
+        }
+        for(i=0;i<4;i++)
+        {
+            next.x=cur.x+dir[i][0];
+            next.y=cur.y+dir[i][1];
+            ans=visit[cur.x][cur.y]+1;
+            if(next.x<0 || next.y<0 || next.x>=n || next.y>=m || map[next.x][next.y]==1) continue;
+            if(visit[next.x][next.y]>ans)
+            {
+                visit[next.x][next.y]=ans;
+                if(mark[next.x][next.y]==0)
+                {
+                    mark[next.x][next.y]=1;
+                    count1[next.x][next.y]++;
+                    q.push(next);
+                }
+            }
+        }
+    }
+}
+int main()
+{
+    int i,j,num,a,b;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        if(n==0 && m==0) break;
+        scanf("%d",&num);
+        memset(map,0,sizeof(map));
+        while(num--)
+        {
+            scanf("%d%d",&a,&b);
+            map[a][b]=1;
+        }
+        scanf("%d",&num);
+        memset(xx,-1,sizeof(xx));
+        while(num--)
+        {
+            scanf("%d%d",&a,&b);
+            scanf("%d%d%d",&xx[a][b],&yy[a][b],&tt[a][b]);
+        }
+        memset(mark,0,sizeof(mark));
+        memset(count1,0,sizeof(count1));
+        for(i=0;i<=n;i++)
+            for(j=0;j<=m;j++)
+                visit[i][j]=INF;
+        flag=0;
+        bfs();
+        if(flag==1) {printf("Never\n");continue;}
+        if(visit[n-1][m-1]==INF) printf("Impossible\n");
+        else printf("%d\n",visit[n-1][m-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4077_autoAC.cpp b/HDOJ/4077_autoAC.cpp
new file mode 100644
index 0000000..0eacdfd
--- /dev/null
+++ b/HDOJ/4077_autoAC.cpp
@@ -0,0 +1,112 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <functional>
+#include <vector>
+#include <map>
+#include <cstring>
+#include <string>
+#include <list>
+#include <set>
+#include <bitset>
+#include <cctype>
+#include <cmath>
+#include <ctime>
+#include <numeric>
+#include <utility>
+#include <stack>
+#include <queue>
+#include <deque>
+#include <iomanip>
+#include <cassert>
+#define pb push_back
+#define mp make_pair
+#define Maxn 1100
+#define fi first
+#define se second
+using namespace std;
+typedef pair<double, double> pii;
+const double eps=1e-8;
+const double inf=1e300;
+int n;
+double dp[Maxn][2];
+pii seg[Maxn][2];
+inline double getdis(pii a, pii b)
+{
+    return sqrt((a.fi-b.fi)*(a.fi-b.fi)+(a.se-b.se)*(a.se-b.se));
+}
+inline int sign(double x)
+{
+    return x<-eps?-1:x>eps;
+}
+pii intersert(pii A, pii B, double y)
+{
+    double dx = A.fi - B.fi;
+    double dy = A.se - B.se;
+    return mp(A.fi + (y-A.se)*dx/dy, y);
+}
+bool leftturn(pii p, pii a, pii b)
+{
+    double x1 = (a.fi-p.fi), y1 = (a.se-p.se);
+    double x2 = (b.fi - p.fi), y2 = (b.se-p.se);
+    return sign(x1*y2-x2*y1)>0;
+}
+bool noRightTurn(pii p, pii a, pii b)
+{
+    double x1 = (a.fi-p.fi), y1 = (a.se-p.se);
+    double x2 = (b.fi - p.fi), y2 = (b.se-p.se);
+    return sign(x1*y2 - x2*y1)>=0;
+}
+int main()
+{
+    double a, b, c;
+    while (~scanf("%d", &n), n)
+    {
+        scanf("%lf%lf", &a, &b);
+        seg[0][0] = mp(a, b);
+        for (int i=1; i<=n; i++)
+        {
+            scanf("%lf%lf%lf", &c, &a, &b);
+            seg[i][0] = mp(a, c);
+            seg[i][1] = mp(b, c);
+        }
+        dp[n][0] = dp[n][1] = 0;
+        int j;
+        for (int i=n-1; i>=0; i--)
+        {
+            for (int side=0; side<2; side++)
+            {
+                dp[i][side] = inf;
+                pair<pii,pii> next = mp(seg[i+1][0], seg[i+1][1]);
+                pii pt = seg[i][side];
+                for (j=i+1; j<=n; j++)
+                {
+                    if (leftturn(pt, seg[j][1], next.fi) || leftturn(pt, next.se, seg[j][0])) break;
+                    if (noRightTurn(pt, next.fi, seg[j][0]))
+                    {
+                        next.fi = seg[j][0];
+                        dp[i][side] = min(dp[i][side], getdis(pt, next.fi)+dp[j][0]);
+                    }
+                    if (noRightTurn(pt, seg[j][1], next.se))
+                    {
+                        next.se = seg[j][1];
+                        dp[i][side] = min(dp[i][side], getdis(pt, next.se)+dp[j][1]);
+                    }
+                }
+                if (j > n)
+                {
+                    double y = seg[n][0].se;
+                    next.fi = intersert(pt, next.fi,y);
+                    next.se = intersert(pt, next.se, y);
+                    if (pt.fi < next.fi.fi) dp[i][side] = min(dp[i][side], getdis(pt, next.fi));
+                    else if (pt.fi > next.se.fi) dp[i][side] = min(dp[i][side], getdis(pt, next.se));
+                    else dp[i][side] = min(dp[i][side], pt.se - y);
+                }
+                if (i == 0) break;
+            }
+        }
+        printf("%.10f\n", dp[0][0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4079_autoAC.cpp b/HDOJ/4079_autoAC.cpp
new file mode 100644
index 0000000..427ab91
--- /dev/null
+++ b/HDOJ/4079_autoAC.cpp
@@ -0,0 +1,35 @@
+#include"stdio.h"
+#include"string.h"
+#define N 10002
+struct node
+{
+    int x,y;
+}A[N];
+int main()
+{
+    int i,j,k;
+    int n,m;
+    int s,d,x,y;
+    while(scanf("%d%d",&n,&m),n||m)
+    {
+        for(i=0;i<n;i++)
+        {
+            scanf("%d%d",&s,&d); 
+            scanf("%d%d",&x,&y);
+            A[i].x=x;
+            A[i].y=x+y;
+        }
+        for(i=0;i<m;i++)
+         {
+            scanf("%d%d",&x,&y);
+            y=x+y;
+            for(k=0,j=0;j<n;j++)
+              {
+                  if(A[j].y>x&&A[j].x<y)
+                       k++;
+              }
+            printf("%d\n",k);
+         }
+    }
+    return 0;
+}
diff --git a/HDOJ/4080_autoAC.cpp b/HDOJ/4080_autoAC.cpp
new file mode 100644
index 0000000..fb9e63d
--- /dev/null
+++ b/HDOJ/4080_autoAC.cpp
@@ -0,0 +1,94 @@
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+const int MAXN=40000+5;
+const int SIGMA_SIZE=26;
+const int INF=~0U>>1;
+struct State{
+    State* go[SIGMA_SIZE],*suf;
+    int val,cnt,right;
+    State():suf(0) {val=cnt=0;memset(go,0,sizeof go);}
+}*root,*last;
+State mem[MAXN<<1],*cur;
+int ans1,ans2;
+int m;
+inline void init()
+{
+    ans1=-1;
+    cur=mem;
+    mem[0]=State();
+    last=root=cur++;
+}
+inline void extend(int w)
+{
+    State* p=last,*np=cur++;
+    *np=State();
+    np->right=np->val=p->val+1;
+    while(p && !p->go[w]) p->go[w]=np,p=p->suf;
+    if(!p) np->suf=root;
+    else
+    {
+        State* q=p->go[w];
+        if(q->val==p->val+1) np->suf=q;
+        else
+        {
+            State* nq=cur++;
+            *nq=State();
+            memcpy(nq->go,q->go,sizeof q->go);
+            nq->right=nq->val=p->val+1;
+            nq->suf=q->suf;
+            q->suf=np->suf=nq;
+            while(p && p->go[w]==q) p->go[w]=nq,p=p->suf;
+        }
+    }
+    last=np;
+}
+inline int idx(char c)
+{
+    return c-'a';
+}
+char s[MAXN];
+int n;
+State* pt[MAXN<<1];
+void work()
+{
+    static int ws[MAXN<<1];
+    State* t;
+    for(int i=0;i<=n;++i) ws[i]=0;
+    for(t=mem+1;t!=cur;++t) ++ws[t->val];
+    for(int i=1;i<=n;++i) ws[i]+=ws[i-1];
+    for(t=cur-1;t!=mem;--t) pt[--ws[t->val]]=t;
+    t=root;
+    for(int i=0;i<n;++i) t=t->go[idx(s[i])],t->cnt++;
+    for(int i=cur-mem-2;i>=0;--i)
+    {
+        State* u=pt[i];
+        if(u->cnt>=m)
+        {
+            if(u->val>ans1) ans1=u->val,ans2=u->right-u->val;
+            else if(u->val==ans1) ans2=std::max(ans2,u->right-u->val);
+        }
+        if(u->suf)
+            u->suf->cnt+=u->cnt,u->suf->right=std::max(u->suf->right,u->right);
+    }
+}
+int main()
+{
+    while(scanf("%d",&m)!=EOF && m)
+    {
+        init();
+        scanf("%s",s);
+        n=strlen(s);
+        if(m==1)
+        {
+            printf("%d 0\n",n);
+            continue;
+        }
+        for(int i=0;i<n;++i)
+            extend(idx(s[i]));
+        work();
+        if(ans1==-1) puts("none");
+        else printf("%d %d\n",ans1,ans2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4081_autoAC.cpp b/HDOJ/4081_autoAC.cpp
new file mode 100644
index 0000000..f9fc04d
--- /dev/null
+++ b/HDOJ/4081_autoAC.cpp
@@ -0,0 +1,81 @@
+#include<iostream>
+#include<cstring>
+#include<cmath>
+const int N=1010;
+const double inf=1e14;
+using namespace std;
+struct Point{
+    int x,y,z;
+}point[N];
+int n;
+double edge[N][N];
+int nearvex[N];
+double  lowcost[N]; 
+double sum;
+int used[N][N];
+int visited[N];
+double  Max[N][N];
+void prim(int v0){
+    sum=0;
+    memset(used,0,sizeof(used));
+    memset(visited,0,sizeof(visited));
+    memset(Max,0,sizeof(Max));
+    for(int i=1;i<=n;i++){
+        lowcost[i]=edge[v0][i];
+        nearvex[i]=v0;
+    }
+    visited[v0]=1;
+    for(int i=1;i<n;i++){
+        double min=inf;
+        int v=-1;
+        for(int j=1;j<=n;j++){
+            if(!visited[j]&&lowcost[j]<min){
+                v=j,min=lowcost[j];
+            }
+        }
+        if(v!=-1){
+            sum+=lowcost[v];
+            used[v][nearvex[v]]=used[nearvex[v]][v]=1;
+            visited[v]=1;
+            for(int k=1;k<=n;k++){
+                if(visited[k]&&k!=v){
+                          Max[v][k]=Max[k][v]=(Max[k][nearvex[v]]>lowcost[v]?Max[k][nearvex[v]]:lowcost[v]);
+                }
+                if(!visited[k]&&edge[v][k]<lowcost[k]){
+                    lowcost[k]=edge[v][k];
+                    nearvex[k]=v;
+                }
+            }
+        }
+    }
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++){
+            scanf("%d%d%d",&point[i].x,&point[i].y,&point[i].z);
+        }
+        for(int i=1;i<=n;i++){
+            edge[i][i]=0;
+            for(int j=i+1;j<=n;j++){
+                double dis=sqrt(pow((point[i].x-point[j].x)*1.0,2)+pow((point[i].y-point[j].y)*1.0,2));
+                edge[i][j]=edge[j][i]=dis;
+            }
+        }
+        prim(1);
+        double r=-1;
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=n;j++)if(i!=j){
+                if(used[i][j]){
+                    r=(r>(point[i].z+point[j].z)*1.0/(sum-edge[i][j])?r:(point[i].z+point[j].z)*1.0/(sum-edge[i][j]));
+                }else if(!used[i][j]){
+                    r=(r>(point[i].z+point[j].z)*1.0/(sum-Max[i][j])?r:(point[i].z+point[j].z)*1.0/(sum-Max[i][j]));
+                }
+            }
+        }
+        printf("%.2lf\n",r);
+    }
+    return 0;
+}
diff --git a/HDOJ/4082_autoAC.cpp b/HDOJ/4082_autoAC.cpp
new file mode 100644
index 0000000..b0568a9
--- /dev/null
+++ b/HDOJ/4082_autoAC.cpp
@@ -0,0 +1,107 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<algorithm>
+using namespace std;
+const int MAXN = 20;
+const int MAXM = 820;
+int ans, n, d[MAXN][MAXN], m, ns;
+int used[210][210];
+struct point
+{
+    int x, y;
+}p[MAXN];
+struct triangle
+{
+    int a, b, c;
+}t[MAXM];
+int dist(point p1, point p2)
+{
+    int x, y;
+    x = p1.x - p2.x;
+    y = p1.y - p2.y;
+    return x * x + y * y;
+}
+bool ponls(point p0, point p1, point p2)
+{
+    int x1, x2, y1, y2;
+    x1 = p0.x - p2.x;
+    y1 = p0.y - p2.y;
+    x2 = p1.x - p2.x;
+    y2 = p1.y - p2.y;
+    if(x1 * y2 == x2 * y1)
+        return true;
+    return false;
+}
+bool similar(triangle t1, triangle t2) 
+{
+    int a1, a2, b1, b2, c1, c2;
+    a1 = t1.a, b1 = t1.b, c1 = t1.c;
+    a2 = t2.a, b2 = t2.b, c2 = t2.c;
+    if(a1 * b2 == b1 * a2 && a1 * c2 == c1 * a2 && b1 * c2 == c1 * b2)
+        return true;
+    return false;
+}
+void ReadGraph()
+{
+    int i, j, k, s, v;
+    n = 0;
+    memset(used, 0, sizeof used);
+    for(i = 1; i <= ns; i ++)
+    {
+        scanf("%d%d", &s, &v);
+        s += 100, v += 100; 
+        if(used[s][v]) continue;
+        used[s][v] = 1;
+        p[++ n].x = s;
+        p[n]. y = v;
+    }
+    for(i = 1; i <= n; i ++)
+        for(j = 1; j <= n; j ++)
+            d[i][j] = d[j][i] = dist(p[i], p[j]);
+}
+void MakeTriangle()
+{
+    int i, j, k, temp[3];
+    m = 0;
+    for(i = 1; i <= n; i ++)
+        for(j = i + 1; j <= n; j ++)
+            for(k = j + 1; k <= n; k ++)
+            {
+                if(ponls(p[i], p[j], p[k]))
+                    continue;
+                temp[0] = d[i][j];
+                temp[1] = d[j][k];
+                temp[2] = d[i][k];
+                sort(temp, temp + 3);
+                t[++ m].a = temp[0];
+                t[m].b = temp[1];
+                t[m].c = temp[2];
+            }
+}
+void cal()
+{
+    int cnt, i, j;
+    ans = 0;
+    for(i = 1; i <= m; i ++)
+    {
+        cnt = 1;
+        for(j = i + 1; j <= m; j ++)
+        {
+            if( similar(t[i], t[j]))
+                ++ cnt;
+        }
+        ans = max(ans, cnt);
+    }
+}
+int main()
+{
+    while(scanf("%d", &ns), ns)
+    {
+        ReadGraph();
+        MakeTriangle();
+        cal();
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4083_autoAC.cpp b/HDOJ/4083_autoAC.cpp
new file mode 100644
index 0000000..b29bb0b
--- /dev/null
+++ b/HDOJ/4083_autoAC.cpp
@@ -0,0 +1,176 @@
+#include<cstdio>
+ #include<cstring>
+ #include<algorithm>
+ #include<cstdlib>
+ using namespace std;
+ int ratk[12][2]={
+         {-1,0},{0,-1},{0,1},{1,0},
+         {-1,-1},{-1,1},{1,-1},{1,1},
+         {-2,0},{0,-2},{0,2},{2,0}
+ };
+ int natk[3]={8,12,4};
+ double fatk[3][3]={{1,2,0.5},{0.5,1,2},{2,0.5,1}};
+ int dir[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
+ struct Soldier{
+     int flag, type;
+     Soldier(){}
+     Soldier(int f, int t):flag(f), type(t){}
+ }sld[8];
+ struct Next{
+     int id, mx, my, aid, sc;
+     Next(){}
+     Next(int _id, int _mx, int _my, int _aid, int _sc):
+         id(_id), mx(_mx), my(_my), aid(_aid), sc(_sc){}
+     friend bool operator< (const Next& a, const Next& b){
+         return a.sc > b.sc;
+     }
+ }nexts[12][150];
+ int nsz[12];
+ struct State{
+     int x, y, sc; 
+     State(){}
+     State(int _x, int _y, int _sc):
+         x(_x), y(_y), sc(_sc){} 
+ }sta[12][8]; 
+ short smaze[12][8][8]; 
+ int lx, ly, lk;
+ int n, s[3];
+ short maze[8][8];
+ int skm, szy;
+ inline bool myturn(int k, int id){ 
+     if(sld[id].flag!=(k&1)) return false;
+     if(sta[k][id].sc==0) return false;
+     return true;
+ }
+ inline bool moveillegal(int k, int id, int x, int y){  
+     if(x<0||x>=lx) return true;
+     if(y<0||y>=ly) return true;
+     if(maze[x][y]==2) return true;
+     if(sld[id].type==2&&maze[x][y]==1) return true; 
+     if(smaze[k][x][y]!=-1&&sld[smaze[k][x][y]].flag!=sld[id].flag) return true;
+     return false; 
+ } 
+ inline bool attackillegal(int k, int id, int x, int y){  
+     if(x<0||x>=lx) return true;
+     if(y<0||y>=ly) return true;
+     if(smaze[k][x][y]==-1) return true;
+     if(sld[smaze[k][x][y]].flag==sld[id].flag) return true;
+     if(sta[k][smaze[k][x][y]].sc==0) return true;
+     return false;
+ }
+ inline void donext(int k, Next& p){ 
+     if(p.id==-1) return; 
+     swap(smaze[k][sta[k][p.id].x][sta[k][p.id].y],smaze[k][p.mx][p.my]); 
+     sta[k][p.id].x = p.mx;
+     sta[k][p.id].y = p.my;
+     if(p.aid==-1) return;
+     sta[k][p.aid].sc-=p.sc; 
+     sld[p.aid].flag?szy-=p.sc:skm-=p.sc;
+     if(sta[k][p.aid].sc==0){
+         smaze[k][sta[k][p.aid].x][sta[k][p.aid].y]=-1;
+     } 
+ } 
+ inline void undonext(int k, Next& p){ 
+     if(p.id==-1) return; 
+     sta[k][p.id].x = sta[k-1][p.id].x; 
+     sta[k][p.id].y = sta[k-1][p.id].y;
+     swap(smaze[k][sta[k][p.id].x][sta[k][p.id].y],smaze[k][p.mx][p.my]);
+     if(p.aid==-1) return;
+     sta[k][p.aid].sc+=p.sc; 
+     sld[p.aid].flag?szy+=p.sc:skm+=p.sc;
+     smaze[k][sta[k][p.aid].x][sta[k][p.aid].y]=p.aid; 
+ } 
+ inline int attack(int k, int sid, int tid){ 
+     return min(sta[k][tid].sc,
+             int(sta[k][sid].sc*fatk[sld[sid].type][sld[tid].type]));
+ }
+ inline void getattack(int k, int id, int x, int y){ 
+     for(int d=0;d<natk[sld[id].type];d++){
+         int tx = x + ratk[d][0];
+         int ty = y + ratk[d][1];
+         if(!attackillegal(k, id, tx, ty)){
+             int atkid = smaze[k][tx][ty]; 
+             int atksc = attack(k, id, atkid); 
+             nexts[k][nsz[k]++] = Next(id, x, y, atkid, atksc); 
+         }
+     } 
+ } 
+ bool reach[8][8];
+ inline void stepbystep(int dep, int k, int id, int x, int y){ 
+     reach[x][y] = true;
+     if(dep==0) return;
+     for(int d=0;d<4;d++){
+         int tx = x+dir[d][0];
+         int ty = y+dir[d][1];
+         if(!moveillegal(k, id, tx, ty)){
+             stepbystep(dep-1, k, id, tx, ty);
+         }
+     }
+ }
+ inline void getmove(int k, int id){ 
+     memset(reach, false, sizeof(reach));
+     stepbystep(s[sld[id].type], k, id, sta[k][id].x, sta[k][id].y);
+     for(int i=0;i<lx;i++){
+         for(int j=0;j<ly;j++){
+             if(reach[i][j]&&smaze[k][i][j]==-1){
+                 getattack(k, id, i, j);  
+                 nexts[k][nsz[k]++] = Next(id, i, j, -1, 0); 
+             }
+         }
+     }
+     getattack(k, id, sta[k][id].x, sta[k][id].y); 
+ }
+ inline void getnext(int k){ 
+     nsz[k]=0;
+     for(int i=0;i<n;i++){
+         if(myturn(k,i)) getmove(k, i); 
+     }
+     nexts[k][nsz[k]++] = Next(-1, -1, -1, -1, 0); 
+     sort(nexts[k], nexts[k]+nsz[k]); 
+ }
+ int dfs(int k, int sc, int maxcut, int mincut){ 
+     if(k==lk) return sc; 
+     if(szy==0||skm==0) return sc; 
+     getnext(k); 
+     memcpy(sta[k+1],sta[k],sizeof(sta[k]));
+     memcpy(smaze[k+1],smaze[k],sizeof(smaze[k])); 
+     int maxval = sc-szy, minval = sc+skm;
+     for(int i=0;i<nsz[k];i++){
+         Next &u = nexts[k][i];
+         donext(k+1, u);  
+         int val = dfs(k+1,(k&1)?(sc-u.sc):(sc+u.sc), maxval, minval);
+         undonext(k+1, u); 
+         if(maxval<val) maxval = val;
+         if(minval>val) minval = val;
+         if(((k&1)==0)&&val>=mincut) return val; 
+         if(((k&1)==0)&&(val-sc>=szy)) return val; 
+         if(((k&1)==1)&&val<=maxcut) return val; 
+         if(((k&1)==1)&&(val-sc<=-skm)) return val; 
+     }
+     return (k&1)?minval:maxval; 
+ }
+ int main(){
+     while(scanf("%d%d%d", &lx, &ly, &lk),lx||ly){
+         memset(maze, 0, sizeof(maze));
+         memset(smaze, -1, sizeof(smaze));
+         for(int i=0;i<lx;i++){
+             for(int j=0;j<ly;j++){
+                 scanf("%d", &maze[i][j]);
+             }
+         }
+         scanf("%d%d%d%d", &n, &s[0], &s[2], &s[1]);
+         szy=skm=0;
+         for(int i=0;i<n;i++){
+             int x, y, a, b, c; 
+             scanf("%d%d%d%d%d", &x, &y, &a, &b, &c);
+             if(c==1) c=2; else if(c==2) c=1; 
+             x--; y--;
+             sld[i] = Soldier(a, c);
+             smaze[0][x][y] = i;
+             sta[0][i] = State(x, y, b);
+             a?szy+=b:skm+=b;
+         }
+         int ans = dfs(0, skm-szy, -szy, skm);
+         printf("%d\n", ans);
+     }
+ }
diff --git a/HDOJ/4085_autoAC.cpp b/HDOJ/4085_autoAC.cpp
new file mode 100644
index 0000000..0877409
--- /dev/null
+++ b/HDOJ/4085_autoAC.cpp
@@ -0,0 +1,104 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std;
+#define INF 2000000
+const int N=60;
+struct Edge
+{
+    int v,w;
+    Edge *nxt;
+}memo[N*N],*cur,*adj[N];
+int n,m,K,mask;
+int st[N],vis[N][1<<11];
+int d[N][1<<11],dp[1<<11];
+queue<int>que;
+void addEdge(int u,int v,int w)
+{
+    cur->v=v;    cur->w=w;
+    cur->nxt=adj[u]; 
+    adj[u]=cur++;
+}
+bool check(int s)
+{
+    int res=0;
+    for(int i=0;s;i++,s>>=1)
+        res+=(s&1)*(i<K?1:-1);
+    return (res==0?true:false);
+}
+void spfa()
+{
+    while(que.size())
+    {
+        int top=que.front(); que.pop();
+        int u=top/10000,s=top%10000;
+        vis[u][s]=0;
+        for(Edge* it=adj[u];it;it=it->nxt)
+        {
+            int v=it->v,w=it->w;
+            if(d[v][s|st[v]]>d[u][s]+w)
+            {
+                d[v][s|st[v]]=d[u][s]+w;
+                if((s|st[v])==s&&!vis[v][s]) 
+                    que.push(v*10000+s),vis[v][s]=1;
+            }
+        }
+    }
+}
+void init()
+{
+    cur=memo; mask=(1<<(2*K))-1;
+    memset(st,0,sizeof(st));
+    memset(vis,0,sizeof(vis));
+    memset(adj,0,sizeof(adj));
+    for(int i=1;i<=n;i++)
+        for(int j=0;j<=mask;j++) d[i][j]=INF;
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int u,v,w;
+        scanf("%d%d%d",&n,&m,&K);
+        init();
+        for(int i=0;i<m;i++)
+        {
+            scanf("%d%d%d",&u,&v,&w);
+            addEdge(u,v,w);
+            addEdge(v,u,w);
+        }
+        for(int i=1;i<=K;i++)
+        {
+            st[i]=1<<(i-1);    
+            d[i][st[i]]=0;
+            st[n-i+1]=(1<<(K+(i-1)));    
+            d[n-i+1][st[n-i+1]]=0;
+        }
+        for(int s=0;s<=mask;s++)
+        {
+            for(int i=1;i<=n;i++)
+            {
+                for(int p=(s-1)&s;p;p=(p-1)&s)
+                d[i][s]=min(d[i][s],d[i][p|st[i]]+d[i][(s-p)|st[i]]);
+                if(d[i][s]<INF&&!vis[i][s]) 
+                    que.push(i*10000+s),vis[i][s]=1;
+            }
+            spfa();
+        }
+        for(int s=0;s<=mask;s++)
+        {
+            dp[s]=INF;
+            for(int i=1;i<=n;i++) dp[s]=min(dp[s],d[i][s]);
+        }
+        for(int s=1;s<=mask;s++)
+            if(check(s))
+                for(int p=(s-1)&s;p;p=(p-1)&s)
+                    if(check(p)) dp[s]=min(dp[s],dp[p]+dp[s-p]);
+        if(dp[mask]>=INF) puts("No solution");
+        else printf("%d\n",dp[mask]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4087_autoAC.cpp b/HDOJ/4087_autoAC.cpp
new file mode 100644
index 0000000..425418e
--- /dev/null
+++ b/HDOJ/4087_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#define forn(i,n) for(int i=0; i<(int)(n); i++)
+using namespace std;
+const int N = 4;
+const double eps = 1e-6;
+const double pi = acos(-1.0);
+struct matrix {
+    int n;
+    double a[N][N];
+    void clear() {forn(i,n)forn(j,n)a[i][j]=0;}
+    matrix(){}
+    matrix(int z):n(z){clear();}
+    matrix operator * (const matrix& u){
+        matrix ans(n);
+        forn(i,n) forn(k,n) forn(j,n)
+            ans.a[i][j] += a[i][k] * u.a[k][j];
+        return ans;
+    }
+    matrix pow(int k){
+        matrix r(n), t=*this;
+        forn(i,n) r.a[i][i]=1.0;
+        while (k){
+            if (k&1) r = t*r;
+            t = t*t;
+            k >>= 1;
+        } return r;
+    }
+};
+char op[20];
+matrix dfs(int tim){
+    matrix res(4);
+    forn(i,4)res.a[i][i]=1;
+    double r[5];
+    while (~scanf("%s", op)){
+        if (op[0] == 'e') break;        
+        matrix tmp(4);
+        forn(i,4)tmp.a[i][i]=1;
+        if (op[0] == 't'){                  
+            forn(i,3) scanf("%lf", &r[i]);
+            forn(i,3) tmp.a[i][3]=r[i];
+        }
+        else if (op[0] == 's'){              
+            forn(i,3) scanf("%lf", &r[i]);
+            forn(i,3) tmp.a[i][i]=r[i];
+        }
+        else if (op[0] == 'r' && op[1] == 'o'){     
+            double t=0.0, c, s;
+            forn(i,4) scanf("%lf", &r[i]);
+            forn(i,3) t += r[i]*r[i];
+            t = sqrt(t);
+            forn(i,3) r[i] /= t;
+            r[3] = r[3]/180*pi;
+            c = cos(r[3]), s = sin(r[3]);
+            forn(i,3){
+                forn(j,3){
+                    bool f = (i+1)%3==j;
+                    if (i == j) tmp.a[i][j]=(1-c)*r[i]*r[j]+c;
+                    else tmp.a[i][j]=(1-c)*r[i]*r[j]+s*(f?-r[3^i^j]:r[3^i^j]);
+                }
+            }
+        }
+        else {             
+            int tim2;
+            scanf("%d", &tim2);
+            tmp = dfs(tim2);
+        }
+        res = tmp*res;
+    }
+    return res.pow(tim);
+}
+double p[5], q[5];
+int main()
+{
+    int n;
+    while (~scanf("%d", &n) && n){
+        matrix tmp(4);
+        forn(i,4)tmp.a[i][i]=1;
+        tmp = dfs(1)*tmp;
+        forn(i,n){
+            forn(j,3) scanf("%lf",&p[j]);
+            p[3] = 1.0;
+            forn(j,3){
+                q[j] = 0.0;
+                forn(k,4) q[j]+=tmp.a[j][k]*p[k];
+            }
+            forn(j,3) printf("%.2f%c",q[j]+eps,j==2?'\n':' ');
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/4089_autoAC.cpp b/HDOJ/4089_autoAC.cpp
new file mode 100644
index 0000000..86805b8
--- /dev/null
+++ b/HDOJ/4089_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+#include<cmath>
+#define eps 1e-10
+#define N (1<<7)+5
+#define inf 1<<20
+#define zero(a) (fabs(a)<eps)
+#define lson (step<<1)
+#define rson (step<<1|1)
+using namespace std;
+double p1,p2,p3,p4,p21,p31,p41;
+double dp[2005][2005],c[2005];
+int n,m,k;
+int main(){
+    while(scanf("%d%d%d%lf%lf%lf%lf",&n,&m,&k,&p1,&p2,&p3,&p4)!=EOF){
+        if(zero(p4)) {puts("0.00000");continue;}
+        p21=p2/(1-p1);
+        p31=p3/(1-p1);
+        p41=p4/(1-p1);
+        dp[1][1]=p4/(1-p1-p2);
+        for(int i=2;i<=n;i++){
+            for(int j=2;j<=(i<k?i:k);j++)
+               c[j]=dp[i-1][j-1]*p31+p41;
+            for(int j=k+1;j<=i;j++)
+               c[j]=dp[i-1][j-1]*p31;
+            double p=1,tmp=0;
+            for(int j=i;j>1;j--){
+                tmp+=p*c[j];
+                p*=p21;
+            }
+            dp[i][i]=(tmp+p*p41)/(1-p*p21);
+            dp[i][1]=p21*dp[i][i]+p41;
+            for(int j=2;j<i;j++)
+               dp[i][j]=p21*dp[i][j-1]+c[j];
+        }
+        printf("%.5f\n",dp[n][m]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4091_autoAC.cpp b/HDOJ/4091_autoAC.cpp
new file mode 100644
index 0000000..c745e7c
--- /dev/null
+++ b/HDOJ/4091_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+typedef __int64 LL;
+LL gcd(LL a,LL b)
+{
+    return b==0?a:gcd(b,a%b);
+}
+LL lcm(LL a,LL b)
+{
+    return a/gcd(a,b)*b;
+}
+int main()
+{
+    LL n,s1,v1,s2,v2;
+    LL T,tt=0;
+    cin>>T;
+    while(T--)
+    {
+        LL i,j,k,ans,p,q,m,num;
+        cin>>n>>s1>>v1>>s2>>v2;
+        m=lcm(s1,s2);
+        num=n/m;
+        if(num){num--;}
+        if(v1*s2>=v2*s1)
+        {
+            num=m/s1*num;
+            p=(n-num*s1)/s2;
+            ans=num*v1+p*v2;
+            if(s1>=s2)
+            {
+                for(i=num;i*s1<=n;i++)
+                {
+                    q=i*v1+(n-i*s1)/s2*v2;
+                    if(q>ans)ans=q;
+                }
+            }
+            else
+            {
+                for(i=p;i>=0;i--)
+                {
+                    q=i*v2+(n-i*s2)/s1*v1;
+                    if(q>ans)ans=q;
+                }
+            }
+        }
+        else
+        {
+            num=m/s2*num;
+            p=(n-num*s2)/s1;
+            ans=num*v2+p*v1;
+            if(s2>=s1)
+            {
+                for(i=num;i*s2<=n;i++)
+                {
+                    q=i*v2+(n-i*s2)/s1*v1;
+                    if(q>ans)ans=q;
+                }
+            }
+            else
+            {
+                for(i=p;i>=0;i--)
+                {
+                    q=i*v1+(n-i*s1)/s2*v2;
+                    if(q>ans)ans=q;
+                }
+            }
+        }
+        cout<<"Case #"<<++tt<<": "<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4092_autoAC.cpp b/HDOJ/4092_autoAC.cpp
new file mode 100644
index 0000000..cc9d7b1
--- /dev/null
+++ b/HDOJ/4092_autoAC.cpp
@@ -0,0 +1,156 @@
+#include <cstdio>
+#include <cstring>
+#include <set>
+#include <algorithm>
+using namespace std;
+const int maxn = 16;
+struct Trian {
+    int x, y, z;
+    Trian () {};
+    Trian (int x, int y, int z) {
+        this->x = x;
+        this->y = y;
+        this->z = z;
+    }
+    Trian add (int type) {
+        int mv = (x+y+z == 0 ? 1 : -1);
+        if (type == 0)
+            return Trian(x, y+mv, z+mv);
+        else if (type == 1)
+            return Trian(x+mv, y, z+mv);
+        else
+            return Trian(x+mv, y+mv, z);
+    }
+    void rotate () {
+        int tmp = x;
+        x = y;
+        y = z;
+        z = tmp;
+    }
+    void overturn () {
+        x = 1 - x;
+        y = 1 - y;
+        z = -z;
+    }
+    void move (int x, int y, int z) {
+        this->x += x;
+        this->y += y;
+        this->z += z;
+    }
+};
+bool operator == (const Trian& a, const Trian& b) {
+    return a.x == b.x && a.y == b.y && a.z == b.z;
+}
+bool operator < (const Trian& a, const Trian& b) {
+    if (a.x != b.x)
+        return a.x < b.x;
+    else if (a.y != b.y)
+        return a.y < b.y;
+    else
+        return a.z < b.z;
+}
+struct Hash {
+    int cnt, key[maxn+5];
+};
+bool operator < (const Hash& a, const Hash& b) {
+    if (a.cnt != b.cnt)
+        return a.cnt < b.cnt;
+    for (int i = 0; i < a.cnt; i++)
+        if (a.key[i] != b.key[i])
+            return a.key[i] < b.key[i];
+    return false;
+}
+struct Pizz {
+    int cnt;
+    Trian arr[maxn+5];
+    Pizz () { cnt = 0; }
+    bool add (const Trian& u) {
+        for (int i = 0; i < cnt; i++)
+            if (arr[i] == u)
+                return false;
+        arr[cnt++] = u;
+        return true;
+    }
+    void remove () { cnt--; }
+    Hash getKey () {
+        Hash u;
+        u.cnt = cnt;
+        for (int i = 0; i < cnt; i++) {
+            u.key[i] = arr[i].x + 8;
+            u.key[i] <<= 4;
+            u.key[i] += arr[i].y + 8;
+            u.key[i] <<= 4;
+            u.key[i] += arr[i].z + 8;
+        }
+        return u;
+    }
+};
+set<Hash> vis;
+int ans[maxn+5] = {0};
+bool find (Pizz v) {
+    for (int i = 0; i < 3; i++) {
+        sort(v.arr, v.arr+v.cnt);
+        if (vis.find(v.getKey()) != vis.end())
+            return true;
+        for (int j = 0; j < v.cnt; j++)
+            v.arr[j].rotate();
+    }
+    return false;
+}
+bool search (Pizz u) {
+    for (int i = 0; i < u.cnt; i++) {
+        int x = u.arr[i].x;
+        int y = u.arr[i].y;
+        int z = u.arr[i].z;
+        Pizz v = u;
+        if (x + y + z == 0) {
+            for (int j = 0; j < v.cnt; j++)
+                v.arr[j].move(-x, -y, -z);
+            if (find(v))
+                return true;
+        } else {
+            for (int j = 0; j < v.cnt; j++) {
+                v.arr[j].overturn();
+                v.arr[j].move(x-1, y-1, z);
+            }
+            if (find(v))
+                return true;
+        }
+    }
+    return false;
+}
+void insert (Pizz u) {
+    for (int i = 0; i < 3; i++) {
+        sort(u.arr, u.arr+u.cnt);    
+        vis.insert(u.getKey());
+        for (int j = 0; j < u.cnt; j++)
+            u.arr[j].rotate();
+    }
+}
+void dfs (Pizz u) {
+    if (u.cnt == maxn+1)
+        return;
+    if (search(u))
+        return;
+    insert(u);
+    ans[u.cnt]++;
+    for (int i = 0; i < u.cnt; i++) {
+        for (int j = 0; j < 3; j++) {
+            Trian v = u.arr[i].add(j);
+            if (u.add(v)) {
+                dfs(u);
+                u.remove();
+            }
+        }
+    }
+}
+int rec[maxn+5] = {0, 1, 1, 1, 4, 6, 19, 43, 120, 307, 866, 2336, 6588, 18373, 52119, 147700, 422016};
+int main () {
+    int cas, n;
+    scanf("%d", &cas);
+    for (int i = 1; i <= cas; i++) {
+        scanf("%d", &n);
+        printf("Case #%d: %d\n", i, rec[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4093_autoAC.cpp b/HDOJ/4093_autoAC.cpp
new file mode 100644
index 0000000..7880fe7
--- /dev/null
+++ b/HDOJ/4093_autoAC.cpp
@@ -0,0 +1,192 @@
+#include<iostream>
+#include<sstream>
+#include<fstream>
+#include<vector>
+#include<list>
+#include<deque>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<bitset>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cctype>
+#include<cmath>
+#include<ctime>
+#include<iomanip>
+using namespace std;
+const double eps(1e-8);
+typedef long long lint;
+const long double PI = acos(-1.0);
+struct Complex
+{
+    long double real, image;
+    Complex(long double _real, long double _image)
+    {
+        real = _real;
+        image = _image;
+    }
+    Complex(){}
+};
+Complex operator + (const Complex &c1, const Complex &c2)
+{
+    return Complex(c1.real + c2.real, c1.image + c2.image);
+}
+Complex operator - (const Complex &c1, const Complex &c2)
+{
+    return Complex(c1.real - c2.real, c1.image - c2.image);
+}
+Complex operator * (const Complex &c1, const Complex &c2)
+{
+    return Complex(c1.real*c2.real - c1.image*c2.image, c1.real*c2.image + c1.image*c2.real);
+}
+int rev(int id, int len)
+{
+    int ret = 0;
+    for(int i = 0; (1 << i) < len; i++)
+    {
+        ret <<= 1;
+        if(id & (1 << i)) ret |= 1;
+    }
+    return ret;
+}
+Complex A[1 << 16];
+void FFT(Complex *a, int len, int DFT)
+{
+    for(int i = 0; i < len; i++) A[rev(i, len)] = a[i];
+    for(int s = 1; (1 << s) <= len; s++)
+    {
+        int m = (1 << s);
+        Complex wm = Complex(cos(DFT*2*PI/m), sin(DFT*2*PI/m));
+        for(int k = 0; k < len; k += m)
+        {
+            Complex w = Complex(1, 0);
+            for(int j = 0; j < (m >> 1); j++)
+            {
+                Complex t = w*A[k + j + (m >> 1)];
+                Complex u = A[k + j];
+                A[k + j] = u + t;
+                A[k + j + (m >> 1)] = u - t;
+                w = w*wm;
+            }
+        }
+    }
+    if(DFT == -1) for(int i = 0; i < len; i++) A[i].real /= len, A[i].image /= len;
+    for(int i = 0; i < len; i++) a[i] = A[i];
+}
+int polynomialLength;
+void multiply(Complex *p1, Complex *p2)
+{
+    for(int i = 0; i < polynomialLength; i++)
+        p1[i] = p1[i]*p2[i];
+    return;
+}
+void Copy(Complex *p1, Complex *p2)
+{
+    for(int i = 0; i < polynomialLength; i++)
+        p1[i] = p2[i];
+    return;
+}
+int a[13010];
+int p, m;
+Complex f[6][1 << 16];
+Complex g[7][1 << 16];
+const int par[6][10] = 
+{
+    {0},
+    {1},
+    {1, -1},
+    {1, -3, 2},
+    {1, -6, 3, 8, -6},
+    {1, -10, 15, 20, -20, -30, 24}
+};
+void solve()
+{
+    int maxL = 0;
+    for(int i = 1; i <= m; i++)
+        maxL = max(maxL, a[i]);
+    polynomialLength = 1;
+    while(polynomialLength <= maxL*p) polynomialLength <<= 1;
+    for(int i = 1; i <= p; i++)
+    {
+        for(int j = 0; j < polynomialLength; j++)
+            f[i][j] = Complex(0, 0);
+        for(int j = 1; j <= m; j++)
+            f[i][i*a[j]].real += 1;
+        FFT(f[i], polynomialLength, 1);
+    }
+    int inclusiveLength = -1;
+    switch(p)
+    {
+        case 1: Copy(g[0], f[1]);
+                inclusiveLength = 1;
+                break;
+        case 2: Copy(g[0], f[1]);
+                multiply(g[0], f[1]);
+                Copy(g[1], f[2]);
+                inclusiveLength = 2;
+                break;
+        case 3: Copy(g[0], f[1]);
+                multiply(g[0], f[1]); multiply(g[0], f[1]);
+                Copy(g[1], f[2]);
+                multiply(g[1], f[1]);
+                Copy(g[2], f[3]);
+                inclusiveLength = 3;
+                break;
+        case 4: Copy(g[0], f[1]);
+                multiply(g[0], f[1]); multiply(g[0], f[1]); multiply(g[0], f[1]);
+                Copy(g[1], f[2]);
+                multiply(g[1], f[1]); multiply(g[1], f[1]);
+                Copy(g[2], f[2]);
+                multiply(g[2], f[2]);
+                Copy(g[3], f[3]);
+                multiply(g[3], f[1]);
+                Copy(g[4], f[4]);
+                inclusiveLength = 5;
+                break;
+        case 5: Copy(g[0], f[1]);
+                multiply(g[0], f[1]); multiply(g[0], f[1]); multiply(g[0], f[1]); multiply(g[0], f[1]);
+                Copy(g[1], f[2]);
+                multiply(g[1], f[1]); multiply(g[1], f[1]); multiply(g[1], f[1]);
+                Copy(g[2], f[2]);
+                multiply(g[2], f[2]); multiply(g[2], f[1]);
+                Copy(g[3], f[3]);
+                multiply(g[3], f[1]); multiply(g[3], f[1]);
+                Copy(g[4], f[3]);
+                multiply(g[4], f[2]);
+                Copy(g[5], f[4]);
+                multiply(g[5], f[1]);
+                Copy(g[6], f[5]);
+                inclusiveLength = 7;
+                break;
+    }
+    for(int i = 0; i < inclusiveLength; i++)
+        FFT(g[i], polynomialLength, -1);
+    for(int i = 0; i < polynomialLength; i++)
+    {
+        double res = 0;
+        for(int j = 0; j < inclusiveLength; j++)
+            res += g[j][i].real*par[p][j];
+        for(int j = 1; j <= p; j++) res /= j;
+        if(res > 0.5) printf("%d: %.0f\n", i, res);
+    }
+    return;
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    for(int cas = 1; cas <= T; cas++)
+    {
+        scanf("%d %d", &m, &p);
+        for(int i = 1; i <= m; i++)
+            scanf("%d", &a[i]);
+        printf("Case #%d:\n", cas);
+        solve();
+        putchar('\n');
+    }
+    return 0;
+}
diff --git a/HDOJ/4095_autoAC.cpp b/HDOJ/4095_autoAC.cpp
new file mode 100644
index 0000000..bb1afdc
--- /dev/null
+++ b/HDOJ/4095_autoAC.cpp
@@ -0,0 +1,178 @@
+#include <iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<cctype>
+using namespace std;
+const int N = 100005;
+typedef __int64 ll;
+struct node
+{
+    int l,r,f,key,value;
+    friend bool operator <(const struct node a,const struct node b)
+    {
+        return a.key < b.key;
+    }
+}lcm[N];
+int n,m,root,num,maxdp;
+int stack[N];
+int dep[N];
+int head[N];
+struct nd
+{
+    int to,next;
+}g[N];
+void add(int s,int e)
+{
+    g[num].to = e;
+    g[num].next = head[s];
+    head[s] = num ++;
+}
+int build()
+{
+    int top = -1;
+    int i,j;
+    top = -1;
+    for(i = 1;i <= n;i ++)
+    {
+        j = top;
+        while(j >= 0 && lcm[stack[j]].value > lcm[i].value)
+            j --;
+        if(j != -1)
+        {
+            lcm[i].f = stack[j];
+            lcm[stack[j]].r = i;
+        }
+        if(j < top)
+        {
+            lcm[stack[j + 1]].f = i;
+            lcm[i].l = stack[j + 1];
+        }
+        stack[++ j] = i;
+        top = j;
+    }
+    lcm[stack[0]].f = -1;
+    return stack[0];
+}
+void bfs(int root,int dp)
+{
+    int front,rear;
+    front = rear = 0;
+    dep[root] = dp;
+    add(dp,root);
+    stack[rear ++] = root;
+    while(front != rear)
+    {
+        int cur = stack[front ++];
+        if(lcm[cur].l > 0)
+        {
+            dep[lcm[cur].l] = dep[cur] + 1;
+            add(dep[cur] + 1,lcm[cur].l);
+            stack[rear ++] = lcm[cur].l;
+            if(maxdp < dep[cur] + 1)
+                maxdp = dep[cur] + 1;
+        }
+        if(lcm[cur].r > 0)
+        {
+            dep[lcm[cur].r] = dep[cur] + 1;
+            add(dep[cur] + 1,lcm[cur].r);
+            stack[rear ++] = lcm[cur].r;
+            if(maxdp < dep[cur] + 1)
+                maxdp = dep[cur] + 1;
+        }
+    }
+}
+char ans[205][N + 205];
+void print(ll l,ll r,ll u,ll d)
+{
+    ll i,j,k;
+    for(i = u;i <= d;i ++)
+    {
+        memset(ans[i - u],0,sizeof(ans[i - u]));
+        if(i & 1)
+        {
+            for(j = head[(i + 1)>>1];~j;j = g[j].next)
+            {
+                ans[i - u][g[j].to] = 'o';
+                if(lcm[g[j].to].l != -1)
+                {
+                    ans[i - u][lcm[g[j].to].l] = '+';
+                    for(k = lcm[g[j].to].l + 1;k < g[j].to;k ++)
+                        ans[i - u][k] = '-';
+                }
+                if(lcm[g[j].to].r != -1)
+                {
+                    ans[i - u][lcm[g[j].to].r] = '+';
+                    for(k = lcm[g[j].to].r - 1;k > g[j].to;k --)
+                        ans[i - u][k] = '-';
+                }
+            }
+        }
+        else
+        {
+            for(j = head[i>>1];~j;j = g[j].next)
+            {
+                if(lcm[g[j].to].l != -1)
+                    ans[i - u][lcm[g[j].to].l] = '|';
+                if(lcm[g[j].to].r != -1)
+                    ans[i - u][lcm[g[j].to].r] = '|';
+            }
+        }
+    }
+    for(i = 0;i <= d - u;i ++)
+    {
+        bool fuck = false;
+        for(j = l;j <= r;j ++)
+            if(ans[i][j])
+            {
+                fuck = true;
+                break;
+            }
+        if(fuck == false)
+            continue;
+        for(j = l;j <= r;j ++)
+            if(ans[i][j])
+                putchar(ans[i][j]);
+            else
+                putchar(' ');
+        putchar(10);
+    }
+}
+void rush()
+{
+    ll l,r,u,d;
+    scanf("%d",&m);
+    while(m --)
+    {
+        scanf("%I64d%I64d%I64d%I64d",&u,&l,&d,&r);
+        d = u + d - 1;
+        r = l + r - 1;
+        if(d > maxdp + maxdp-1)
+            d = maxdp + maxdp-1;
+        print(l,r,u,d);
+        printf("\n");
+    }
+}
+int main()
+{
+    int i,t,cas = 0;
+    scanf("%d",&t);
+    while(t --)
+    {
+        scanf("%d",&n);
+        for(i = num = 1;i <= n;i ++)
+        {
+            lcm[i].l = lcm[i].r = lcm[i].f = -1;
+            head[i] = -1;
+            scanf("%d",&lcm[i].key);
+            lcm[i].value = i;
+        }
+        sort(lcm + 1,lcm + 1 + n);
+        root = build();
+        maxdp = 1;
+        bfs(root,1);
+        printf("Case #%d:\n",++cas);
+        rush();
+    }
+    return 0;
+}
diff --git a/HDOJ/4096_autoAC.cpp b/HDOJ/4096_autoAC.cpp
new file mode 100644
index 0000000..75fadb9
--- /dev/null
+++ b/HDOJ/4096_autoAC.cpp
@@ -0,0 +1,171 @@
+#include <iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<map>
+#include<string>
+using namespace std;
+const int N = 3005;
+const int M = 1000005;
+int head[N];
+struct node
+{
+    int to,next;
+}e[M];
+bool vis[N];
+int num,id;
+char s1[10005],s[9][100];
+map<string,int>non,verb;
+bool flag;
+void build(int s,int ed)
+{
+    e[num].to = ed;
+    e[num].next = head[s];
+    head[s] = num ++;
+}
+void gofind(int cur,int tag)
+{
+    vis[cur] = true;
+    if(flag)
+        return;
+    if(cur == tag)
+    {
+        flag = true;
+        return;
+    }
+    int i;
+    for(i = head[cur];~i;i = e[i].next)
+        if(vis[e[i].to] == false)
+            gofind(e[i].to,tag);
+}
+int main()
+{
+    int t,cas = 0;
+    scanf("%d",&t);
+    gets(s1);
+    while(t --)
+    {
+        non.clear();verb.clear();
+        memset(head,-1,sizeof(head));
+        num = id = 1;
+        printf("Case #%d:\n",++cas);
+        while(gets(s1))
+        {
+            int len = strlen(s1);
+            if(s1[len - 1] == '!')
+                break;
+            else if(s1[len - 1] == '.')
+                {
+                    s1[len - 1] = '\0';
+                    if(sscanf(s1,"%s%s%s%s%s%s",s[0],s[1],s[2],s[3],s[4],s[5]) != 6)
+                    {
+                        sscanf(s1,"%s%s%s",s[2],s[3],s[4]);
+                        string a,b;
+                        a = s[2];b = s[4];
+                        if(non.find(a) == non.end())
+                            non[a] = id ++;
+                        if(s[3][0] == 'a')
+                        {
+                            if(non.find(b) == non.end())
+                                non[b] = id ++;
+                            build(non[a],non[b]);
+                        }
+                        else
+                        {
+                            if(verb.find(b) == verb.end())
+                                verb[b] = id ++;
+                            build(non[a],verb[b]);
+                        }
+                    }
+                    else
+                    {
+                        sscanf(s1,"%s%s%s%s%s%s",s[2],s[2],s[2],s[2],s[3],s[4]);
+                        string a,b;
+                        a = s[2];b = s[4];
+                        if(verb.find(a) == verb.end())
+                            verb[a] = id ++;
+                        if(s[3][0] == 'a')
+                        {
+                            if(non.find(b) == non.end())
+                                non[b] = id ++;
+                            build(verb[a],non[b]);
+                        }
+                        else
+                        {
+                            if(verb.find(b) == verb.end())
+                                verb[b] = id ++;
+                            build(verb[a],verb[b]);
+                        }
+                    }
+                }
+                else if(s1[len -1] == '?')
+                {
+                    memset(vis,false,sizeof(vis));
+                    s1[len - 1] = '\0';
+                    if(sscanf(s1,"%s%s%s%s%s%s",s[0],s[1],s[2],s[3],s[4],s[5]) != 6)
+                    {
+                        sscanf(s1,"%s%s%s",s[3],s[2],s[4]);
+                        string a,b;
+                        a = s[2];b = s[4];
+                        if(non.find(a) == non.end())
+                            non[a] = id ++;
+                        if(s[3][0] == 'a')
+                        {
+                            if(non.find(b) == non.end())
+                                non[b] = id ++;
+                            flag = false;
+                            gofind(non[a],non[b]);
+                            if(flag)
+                                putchar('Y');
+                            else
+                                putchar('M');
+                        }
+                        else
+                        {
+                            if(verb.find(b) == verb.end())
+                                verb[b] = id ++;
+                            flag = false;
+                            gofind(non[a],verb[b]);
+                            if(flag)
+                                putchar('Y');
+                            else
+                                putchar('M');
+                        }
+                    }
+                    else
+                    {
+                        sscanf(s1,"%s%s%s%s%s%s",s[3],s[3],s[3],s[3],s[2],s[4]);
+                        string a,b;
+                        a = s[2];b = s[4];
+                        if(verb.find(a) == verb.end())
+                            verb[a] = id ++;
+                        sscanf(s1,"%s",s[3]);
+                        if(s[3][0] == 'a')
+                        {
+                            if(non.find(b) == non.end())
+                                non[b] = id ++;
+                            flag = false;
+                            gofind(verb[a],non[b]);
+                            if(flag)
+                                putchar('Y');
+                            else
+                                putchar('M');
+                        }
+                        else
+                        {
+                            if(verb.find(b) == verb.end())
+                                verb[b] = id ++;
+                            flag = false;
+                            gofind(verb[a],verb[b]);
+                            if(flag)
+                                putchar('Y');
+                            else
+                                putchar('M');
+                        }
+                    }
+                }
+        }
+        putchar(10);
+    }
+    return 0;
+}
diff --git a/HDOJ/4097_autoAC.cpp b/HDOJ/4097_autoAC.cpp
new file mode 100644
index 0000000..d450665
--- /dev/null
+++ b/HDOJ/4097_autoAC.cpp
@@ -0,0 +1,170 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <vector>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-8;
+const double pi = acos(-1.0);
+int dcmp(double x) {
+    if(fabs(x) < eps)
+        return 0;
+    return x > eps ? 1 : -1;
+}
+struct point {
+    double x, y;
+    point(double x = 0, double y = 0) :
+            x(x), y(y) {
+    }
+    point operator-(const point &t) const {
+        return point(x - t.x, y - t.y);
+    }
+    point operator*(const double &t) const {
+        return point(x * t, y * t);
+    }
+    void in() {
+        scanf("%lf%lf", &x, &y);
+    }
+} p[4];
+double dis(point a, point b) {
+    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
+}
+double angle(double a, double b, double c) {
+    return acos((b * b + c * c - a * a) / (2 * b * c));
+}
+struct tri {
+    point p[3];
+    double d[3], jiao[3];
+    void in() {
+        int i;
+        for(i = 0; i < 3; i++)
+            p[i].in();
+        for(i = 0; i < 3; i++)
+            d[i] = dis(p[i], p[(i + 1) % 3]);
+        sort(d, d + 3);
+        for(i = 0; i < 3; i++)
+            jiao[i] = angle(d[i], d[(i + 1) % 3], d[(i + 2) % 3]);
+    }
+} t1, t2;
+double cross(point a, point b) {
+    return a.x * b.y - a.y * b.x;
+}
+bool judge(int x, int y, int a, int b) {
+    int f1 = dcmp(cross(p[y] - p[x], p[a] - p[x]));
+    int f2 = dcmp(cross(p[y] - p[x], p[b] - p[x]));
+    if(!f1 || !f2)
+        return 0;
+    if(f1 != f2)
+        return 1;
+    return 0;
+}
+bool equal(point a, point b, point c, tri t) {
+    point p[3];
+    double d[3];
+    p[0] = a;
+    p[1] = b;
+    p[2] = c;
+    int i;
+    for(i = 0; i < 3; i++)
+        d[i] = dis(p[i], p[(i + 1) % 3]);
+    sort(d, d + 3);
+    for(i = 0; i < 3; i++)
+        if(d[i] != t.d[i])
+            return 0;
+    return 1;
+}
+bool Cao(double a, double b, double c, double *dd) {
+    double d[4];
+    d[0] = a;
+    d[1] = b;
+    d[2] = c;
+    sort(d, d + 3);
+    for(int i = 0; i < 3; i++)
+        if(dcmp(d[i] - dd[i]))
+            return 0;
+    return 1;
+}
+typedef pair <double, double> pii;
+int main() {
+    int i, j, cas, ca = 1;
+    scanf("%d", &cas);
+    while(cas--) {
+        t1.in();
+        t2.in();
+        for(i = 0; i < 4; i++)
+            p[i].in();
+        printf("Case #%d: ", ca++);
+        bool ok = 0;
+        if(judge(0, 2, 1, 3)) {
+            if(!ok && equal(p[0], p[1], p[2], t1)
+                    && equal(p[0], p[3], p[2], t2))
+                ok = 1;
+            if(!ok && equal(p[0], p[1], p[2], t2)
+                    && equal(p[0], p[3], p[2], t1))
+                ok = 1;
+        }
+        if(judge(1, 3, 0, 2)) {
+            if(!ok && equal(p[1], p[0], p[3], t1)
+                    && equal(p[1], p[2], p[3], t2))
+                ok = 1;
+            if(!ok && equal(p[1], p[0], p[3], t2)
+                    && equal(p[1], p[2], p[3], t1))
+                ok = 1;
+        }
+        if(!ok) {
+            int i, j, k;
+            point q[4];
+            int pos = -1;
+            for(i = 0; i < 4; i++)
+                if(!dcmp(
+                        cross(p[i] - p[(i + 2) % 4],
+                                p[(i + 1) % 4] - p[(i + 2) % 4]))) {
+                    pos = (i + 1) % 4; 
+                    break;
+                }
+            loop: int tot = 0;
+            if(pos != -1) {
+                for(i = 0; i < 4; i++)
+                    if(i != pos) {
+                        q[tot++] = p[i];
+                    }
+                for(i = 0; i < 3; i++)
+                    p[i] = q[i];
+                double area1 = fabs(cross(t1.p[0] - t1.p[1], t1.p[0] - t1.p[2]))
+                        + fabs(cross(t2.p[0] - t2.p[1], t2.p[0] - t2.p[2]));
+                double area2 = fabs(cross(p[0] - p[1], p[2] - p[1]));
+                if(!dcmp(area1 - area2)) {
+                    double dd[4]; 
+                    for(i = 0; i < 3; i++)
+                        dd[i] = dis(p[i], p[(i + 1) % 3]);
+                    sort(dd, dd + 3);
+                    for(i = 0; i < 3; i++)
+                        for(j = 0; j < 3; j++)
+                            if(!dcmp(t1.d[i] - t2.d[j])) {    
+                                int x, y;
+                                vector <pii> la, lb;
+                                for(x = 0; x < 3; x++)
+                                    if(x != i)
+                                        la.push_back(
+                                                make_pair(t1.d[x], t1.jiao[x]));
+                                for(x = 0; x < 3; x++)
+                                    if(x != j)
+                                        lb.push_back(
+                                                make_pair(t2.d[x], t2.jiao[x]));
+                                for(x = 0; x < 2; x++)     
+                                    for(y = 0; y < 2; y++) {
+                                        if(!dcmp(la[x].second + lb[y].second- pi)
+                                                && Cao(la[x].first, lb[y].first, la[x ^ 1].first + lb[y ^ 1].first, dd))
+                                            ok = 1;
+                                    }
+                            }
+                }
+            }
+        }
+        if(ok)
+            puts("Yes");
+        else
+            puts("No");
+    }
+    return 0;
+}
diff --git a/HDOJ/4099_autoAC.cpp b/HDOJ/4099_autoAC.cpp
new file mode 100644
index 0000000..42eede7
--- /dev/null
+++ b/HDOJ/4099_autoAC.cpp
@@ -0,0 +1,107 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+const int N=10;
+int f1[65],f2[65],f3[65];
+class Trie
+{
+    public:
+       int v;
+       int flag;
+       Trie *next[N];
+       Trie()
+       {
+           v=-1;
+           memset(next,NULL,sizeof(next));
+       }
+};
+Trie *root;
+void Insert(char *S,int ans)
+{
+    int len=strlen(S);
+    Trie *p=root;
+    for(int i=0;i<len;i++)
+    {
+        int id=S[i]-'0';
+        if(p->next[id]==NULL)
+            p->next[id]=new Trie();
+        p=p->next[id];
+        if(p->v<0) p->v=ans;
+    }
+}
+int Find(char *S)
+{
+    Trie *p=root;
+    int count;
+    int len=strlen(S);
+    for(int i=0;i<len;i++)
+    {
+        int id=S[i]-'0';
+        p=p->next[id];
+        if(p==NULL) return -1;
+        else  count=p->v;
+    }
+    return count;
+}
+void Init()
+{
+    int h;
+    char str[65]="1";
+    memset(f1,0,sizeof(f1));
+    memset(f2,0,sizeof(f2));
+    memset(f3,0,sizeof(f3));
+    f1[0]=1;f2[0]=1;
+    Insert(str,0);
+    for(int i=2;i<100000;i++)
+    {
+        memset(str,0,sizeof(str));
+        int r=0;
+        for(int j=0;j<60;j++)
+        {
+            f3[j]=f1[j]+f2[j]+r;
+            r=f3[j]/10;
+            f3[j]%=10;
+        }
+        for(int j=59;j>=0;j--)
+        if(f3[j])
+        {
+            h=j;
+            break;
+        }
+        int k=0;
+        for(int j=h;j>=0;j--)
+        {
+            str[k++]=f3[j]+'0';
+            if(k>=40) break;
+        }
+        Insert(str,i);
+        if(h>55)
+        {
+            for(int j=1;j<59;j++)
+                f3[j-1]=f3[j];
+            for(int j=1;j<59;j++)
+                f2[j-1]=f2[j];
+        }
+        for(int j=0;j<60;j++)
+            f1[j]=f2[j];
+        for(int j=0;j<60;j++)
+            f2[j]=f3[j];
+    }
+}
+int main()
+{
+    root=new Trie();
+    Init();
+    char str[105];
+    int t,i,j,k=1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%s",str);
+        printf("Case #%d: ",k++);
+        int tmp=Find(str);
+        printf("%d\n",tmp);
+    }
+    return 0;
+}
diff --git a/HDOJ/4102_autoAC.cpp b/HDOJ/4102_autoAC.cpp
new file mode 100644
index 0000000..c578bab
--- /dev/null
+++ b/HDOJ/4102_autoAC.cpp
@@ -0,0 +1,177 @@
+#include <stdio.h>
+#include<algorithm>
+#include<math.h>
+#include<iostream>
+using namespace std;
+#define N 8005
+#define EPS 1e-8
+struct TPoint {
+    int x, y;
+    TPoint() {
+    }
+    TPoint(const int &_x, const int &_y) :
+        x(_x), y(_y) {
+    }
+    bool operator ==(const TPoint &b) const {
+        return (x == b.x && y == b.y);
+    }
+    TPoint operator-(const TPoint &b) const {
+        return TPoint(x - b.x, y - b.y);
+    }
+};
+TPoint p[N], hull[N],r;
+int tn;
+double cross(const TPoint & a, const TPoint & b, const TPoint & c) {
+    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}
+double len(const TPoint &a) {
+    return sqrt((double) (a.x * a.x + a.y * a.y));
+}
+double dis(const TPoint &a, const TPoint &b) {
+    return len(b - a);
+}
+bool graham_cmp(const TPoint &b, const TPoint &c) {
+    double tmp = cross(b, c, p[0]);
+    if (tmp > EPS)
+        return true;
+    if (fabs(tmp) < EPS && (dis(b, p[0]) < dis(c, p[0])))
+        return true;
+    return false;
+}
+int graham_scan(int n) {
+    int top, i, k = 0;
+    for (i = 1; i < n; ++i) {
+        if ((p[k].y - p[i].y < EPS) || (fabs((double)p[i].y - p[k].y) < EPS && p[k].x
+                - p[i].x > EPS))
+            k = i;
+    }
+    swap(p[0], p[k]);
+    sort(p + 1, p + n, graham_cmp);
+    hull[0] = p[0], hull[1] = p[1], hull[2] = p[2];
+    if (n < 3)
+        return n;
+    else
+        top = 3;
+    for (i = 3; i < n; ++i) {
+        while (top >= 2 && cross(hull[top - 2], hull[top - 1], p[i]) < EPS)
+            --top;
+        hull[top++] = p[i];
+    }
+    return top;
+}
+inline double dis_p2_line(TPoint & a,TPoint & b,TPoint & p)
+{ return fabs(cross(a,p,b))/dis(a,b); }
+struct node {
+    int x1, x2, y1, y2;
+    int level;
+    bool flag;
+} a[2005];
+int Max(int a, int b) {
+    return a > b ? a : b;
+}
+int Min(int a, int b) {
+    return a < b ? a : b;
+}
+int main() {
+    int i, j, n;
+    int level, t, x, y;
+    while (scanf("%d", &n) != EOF) {
+        for (i = 0; i < n; ++i) {
+            scanf("%d%d%d%d", &a[i].x1, &a[i].y1, &a[i].x2, &a[i].y2);
+            a[i].flag = false;
+            a[i].x1 *= 2;
+            a[i].y1 *= 2;
+            a[i].x2 *= 2;
+            a[i].y2 *= 2;
+            if (a[i].x1 > a[i].x2) {
+                t = a[i].x1;
+                a[i].x1 = a[i].x2;
+                a[i].x2 = t;
+            }
+            if (a[i].y1 > a[i].y2) {
+                t = a[i].y1;
+                a[i].y1 = a[i].y2;
+                a[i].y2 = t;
+            }
+        }
+        a[0].level = 1;
+        a[0].flag = true;
+        for (i = 1; i < n; ++i) {
+            level = 1;
+            for (j = i-1; j >= 0; --j) {
+                if (level >= a[j].level + 1)
+                    continue;
+                if (a[i].x2 <= a[j].x1)
+                    continue;
+                if (a[j].x2 <= a[i].x1)
+                    continue;
+                if (a[i].y2 <= a[j].y1)
+                    continue;
+                if (a[j].y2 <= a[i].y1)
+                    continue;
+                level = a[j].level + 1;
+            }
+            a[i].level = level;
+            tn = 0;
+            for (j = 0; j < i; ++j) {
+                if (level != a[j].level + 1)
+                    continue;
+                if (a[i].x2 <= a[j].x1)
+                    continue;
+                if (a[j].x2 <= a[i].x1)
+                    continue;
+                if (a[i].y2 <= a[j].y1)
+                    continue;
+                if (a[j].y2 <= a[i].y1)
+                    continue;
+                int x1,x2,y1,y2;
+                x1 = Max(a[i].x1,a[j].x1);
+                x2 = Min(a[i].x2,a[j].x2);
+                y1 = Max(a[i].y1,a[j].y1);
+                y2 = Min(a[i].y2,a[j].y2);
+                p[tn].x = x1;
+                p[tn++].y = y1;
+                p[tn].x = x1;
+                p[tn++].y = y2;
+                p[tn].x = x2;
+                p[tn++].y = y1;
+                p[tn].x = x2;
+                p[tn++].y = y2;
+            }
+            if(tn==0)
+            {
+                a[i].flag=true;
+                continue;
+            }
+            p[tn].x=((a[i].x1+a[i].x2)>>1);
+            p[tn++].y=((a[i].y1+a[i].y2)>>1);
+            tn=graham_scan(tn);
+            a[i].flag=true;
+            for(j=0;j<tn;++j)
+            {
+                if(hull[j]==TPoint(((a[i].x1+a[i].x2)>>1),((a[i].y1+a[i].y2)>>1)))
+                {
+                    a[i].flag=false;
+                    a[i].level=-1;
+                    break;
+                }
+                r=TPoint(((a[i].x1+a[i].x2)>>1),((a[i].y1+a[i].y2)>>1));
+                double s=fabs(dis_p2_line(hull[j],hull[(j+1)%tn],r));
+                if(s<EPS)
+                {
+                    a[i].flag=false;
+                    a[i].level=-1;
+                    break;
+                }
+            }
+        }
+        int ans=0;
+        for(i=0;i<n;++i)
+        {
+            if(a[i].flag)
+                ans++;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4103_autoAC.cpp b/HDOJ/4103_autoAC.cpp
new file mode 100644
index 0000000..7f1df9a
--- /dev/null
+++ b/HDOJ/4103_autoAC.cpp
@@ -0,0 +1,20 @@
+#include<stdio.h>
+#include<iostream>
+#include<string>
+#include<stdlib.h>
+#include<math.h>
+#include<algorithm>
+#include<queue>
+using namespace std;
+int a,b;
+double c,d,t,pi;
+bool flag;
+int main()
+{
+    pi = 3.1416926536;
+    while(scanf("%d%d%lf",&a,&b,&c)!=EOF && (a!=0 || b !=0 || fabs(c)>0.0000001))
+    {
+        printf("%d\n",a - 1);
+    }
+    return 0;
+}
diff --git a/HDOJ/4104_autoAC.cpp b/HDOJ/4104_autoAC.cpp
new file mode 100644
index 0000000..4958f7d
--- /dev/null
+++ b/HDOJ/4104_autoAC.cpp
@@ -0,0 +1,25 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+int a[1005],sum[1005];
+int main()
+{
+    int n,i;
+    while(scanf("%d",&n)!=EOF)
+    {
+        memset(sum,0,sizeof(sum));
+        for(i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        sort(a+1,a+1+n);
+        for(i=1;i<=n;i++)
+            sum[i]=sum[i-1]+a[i];
+        for(i=1;i<=n;i++)
+        {
+            if(a[i]>sum[i-1]+1)
+                break;
+        }
+        printf("%d\n",sum[i-1]+1);
+    }
+    return 0;
+}
diff --git a/HDOJ/4105_autoAC.cpp b/HDOJ/4105_autoAC.cpp
new file mode 100644
index 0000000..cf0cdad
--- /dev/null
+++ b/HDOJ/4105_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std;
+char a[5000];
+int main()
+{
+    int i,j,k,n,m,b,c;
+    while (1)
+    {
+          if (scanf("%d",&n)==EOF) break;
+          scanf("%s",a);
+          for (i=0;i<n;i++) a[i]-='0';
+          bool f=false;
+          int ans=0;
+          b=0;
+          c=10;
+          for (i=0;i<n;i++)
+          {
+              if (f==false)
+              {
+                 if (c>a[i]) b=a[i];
+                 else
+                 {
+                     i++;
+                     b=a[i];
+                 }
+              }
+              else
+              {
+                  if (a[i]>b) c=a[i];
+                  else
+                  {
+                      if (a[i]==0)
+                      {
+                         while (a[i]==0) i++;
+                         b=0;
+                         c=a[i];
+                      }
+                      else
+                      {
+                          i++;
+                          c=a[i-1]*10+a[i];
+                      }
+                  }
+              }
+              if (i>=n) break;
+              ans++;f=!f;
+          }
+          cout<<ans-1<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4106_autoAC.cpp b/HDOJ/4106_autoAC.cpp
new file mode 100644
index 0000000..83134f8
--- /dev/null
+++ b/HDOJ/4106_autoAC.cpp
@@ -0,0 +1,101 @@
+#include<cstdio>  
+#include<stdlib.h>  
+#include<cstring>  
+using namespace std;  
+const int inf=99999999;  
+struct{  
+    int v, cap, cost, next, re;  
+}edge[10005];  
+int n,ans;  
+int k,edgeHead[1050];  
+int que[10050],pre[1050],dis[1050];  
+bool vis[1050];  
+int wei[1050];  
+int min(int a,int b){  
+    return a>b?b:a;  
+}  
+int max(int a,int b){  
+    return a>b?a:b;  
+}  
+void addEdge(int u,int v,int ca,int co){  
+    edge[k].v=v;  
+    edge[k].cap=ca;  
+    edge[k].cost=co;  
+    edge[k].next=edgeHead[u];  
+    edge[k].re=k + 1;          
+    edgeHead[u]=k ++;  
+    edge[k].v=u;  
+    edge[k].cap=0;  
+    edge[k].cost=-co;               
+    edge[k].next=edgeHead[v];  
+    edge[k].re=k - 1;  
+    edgeHead[v]=k ++;  
+}  
+bool spfa(){                 
+    int i, head = 0, tail = 1;    
+    for(i = 0; i <= n; i ++){  
+        dis[i] = inf;
+        vis[i] = false;  
+    }  
+    dis[0] = 0;  
+    que[0] = 0;  
+    vis[0] = true;  
+    while(head != tail){  
+        int u = que[head];  
+        for(i = edgeHead[u]; i != 0; i = edge[i].next){  
+            int v = edge[i].v;  
+            if(edge[i].cap && dis[v] >dis[u] + edge[i].cost){ 
+                dis[v] = dis[u] + edge[i].cost;  
+                pre[v] = i;                       
+                if(!vis[v]){  
+                    vis[v] = true;  
+                    que[tail ++] = v;  
+                    if(tail == 10000) tail = 0;             
+                }  
+            }  
+        }  
+        vis[u] = false;  
+        head++;  
+        if(head ==10000) head = 0;  
+    }  
+    if(dis[n] ==inf) return false;
+    return true;  
+}  
+void end(){  
+    int u, p;  
+    for(u = n; u != 0; u = edge[edge[p].re].v){  
+        p = pre[u];  
+        edge[p].cap -= 1;  
+        edge[edge[p].re].cap += 1;  
+        ans += edge[p].cost;  
+    }  
+}  
+int main(){  
+    int i,j,v,lim,m,sum;  
+    while(scanf("%d %d %d",&v,&m,&lim)!=EOF){  
+        k=1;  
+        sum=0;  
+        memset(edgeHead,0,sizeof(edgeHead));  
+        for(i=1;i<=v;i++){  
+            scanf("%d",&wei[i]);  
+            sum+=wei[i];  
+        }  
+        if(m<=lim){  
+            printf("%d\n",sum);  
+            continue;  
+        }                            
+        n=v-m+2;  
+        for(i=0;i<=n;i++){  
+            addEdge(i,i+1,lim,0);  
+        }  
+        for(i=1;i<=v;i++){  
+            addEdge(max(1,i-m+1),min(n-1,i)+1,1,-wei[i]);  
+        }  
+        ans=0;  
+        n++;  
+        while(spfa())  
+            end();  
+        printf("%d\n",-ans);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4107_autoAC.cpp b/HDOJ/4107_autoAC.cpp
new file mode 100644
index 0000000..e872dda
--- /dev/null
+++ b/HDOJ/4107_autoAC.cpp
@@ -0,0 +1,113 @@
+#include<iostream>
+#include<cstring>
+#include<cstdlib>
+#include<cstdio>
+#define N  200005
+struct cam
+{
+    int x;
+    int y;
+    int min;
+    int max;
+    int v;
+}list[N*4];
+int n,m,p;
+int Min(int x,int y)
+{
+    return x<y?x:y;
+}
+int Max(int x,int y)
+{
+    return x>y?x:y;
+}
+void build(int k,int x,int y)
+{
+    list[k].x=x;
+    list[k].y=y;
+    list[k].min=list[k].max=list[k].v=0;
+    if(x==y)
+    return;
+    int mid=(x+y)/2;
+    build(k<<1,x,mid);
+    build(k<<1|1,mid+1,y);
+}
+void lazy(int k)
+{
+    int v=list[k].v;
+    if(v>0)
+    {
+        list[k<<1].v+=v;
+        list[k<<1].min+=v;
+        list[k<<1].max+=v;
+        list[k<<1|1].v+=v;
+        list[k<<1|1].min+=v;
+        list[k<<1|1].max+=v;
+        list[k].v=0;
+    }
+}
+void update(int k,int a,int b,int c)
+{
+    if(list[k].x==a&&list[k].y==b&&(list[k].min>=p||list[k].max<p))
+    {
+        if(list[k].max<p)
+        {
+            list[k].v+=c;
+            list[k].max+=c;
+            list[k].min+=c;
+        }
+        else
+        {
+            list[k].v+=c*2;
+            list[k].max+=c*2;
+            list[k].min+=c*2;
+        }
+        return;
+    }
+    if(list[k].v>0)
+    lazy(k);
+    int mid=(list[k].x+list[k].y)/2;
+    if(a>mid)
+    update(k<<1|1,a,b,c);
+    else if(b<=mid)
+    update(k<<1,a,b,c);
+    else
+    {
+        update(k<<1,a,mid,c);
+        update(k<<1|1,mid+1,b,c);
+    }
+    list[k].max=Max(list[k<<1].max,list[k<<1|1].max);
+    list[k].min=Min(list[k<<1].min,list[k<<1|1].min);
+}
+int query(int k,int id)
+{
+    if(list[k].x==id&&list[k].y==id) 
+    return list[k].v;
+    if(list[k].v>0)
+    lazy(k);
+    int mid=(list[k].x+list[k].y)/2;
+    if(id<=mid)
+    return query(k<<1,id);
+    else
+    return query(k<<1|1,id);
+}
+int main()
+{
+    int i,a,b,c;
+    while(scanf("%d%d%d",&n,&m,&p)!=EOF)
+    {
+        build(1,1,n);
+        while(m--)
+        {
+            scanf("%d%d%d",&a,&b,&c);
+            update(1,a,b,c);
+        }
+        for(i=1;i<=n;i++)
+        {
+            if(i==n)
+            printf("%d\n",query(1,i));
+            else
+            printf("%d ",query(1,i));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4109_autoAC.cpp b/HDOJ/4109_autoAC.cpp
new file mode 100644
index 0000000..4fdcc2b
--- /dev/null
+++ b/HDOJ/4109_autoAC.cpp
@@ -0,0 +1,59 @@
+#include<cstdio>
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<cstring>
+using namespace std;
+struct node
+{
+    int y,t;
+}edge[10009];
+int T[1009];
+vector<node> v[1009]; int n,m;
+int in[1009];
+void solve()
+{
+    queue<int> q;
+    for(int i=0;i<n;i++)
+    if(in[i]==0)
+    {
+        q.push(i);
+        T[i]=1;
+    }
+    while(!q.empty())
+    {
+        int x=q.front();q.pop();
+        for(int i=0;i<v[x].size();i++)
+        {
+            int y=v[x][i].y;
+            T[y]=max(T[y],T[x]+v[x][i].t);
+            in[y]--;
+            if(in[y]==0)
+            {
+                q.push(y);
+            }
+        }
+    }
+    int ans=0;
+    for(int i=0;i<n;i++)
+    ans=max(ans,T[i]);
+    cout<<ans<<endl;
+}
+int main()
+{
+   int a,b,t;
+   while(scanf("%d%d",&n,&m)!=EOF)
+   {
+       memset(in,0,sizeof(in));
+       memset(T,0,sizeof(T));
+       for(int i=0;i<n;i++)
+       v[i].clear();
+       for(int i=0;i<m;i++)
+       {
+           scanf("%d%d%d",&a,&edge[i].y,&edge[i].t);
+           v[a].push_back(edge[i]);
+           in[edge[i].y]++;
+       }
+       solve();
+   }
+}
diff --git a/HDOJ/4111_autoAC.cpp b/HDOJ/4111_autoAC.cpp
new file mode 100644
index 0000000..cb134cd
--- /dev/null
+++ b/HDOJ/4111_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<stdio.h>
+#include<string.h>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+int dp[55][55000];
+int a[55];
+int DP(int a,int b)
+{
+    if(dp[a][b]!=-1) return dp[a][b];
+    if(b==1) return dp[a][b]=DP(a+1,0);
+    dp[a][b]=0;
+    if(a>=1&&!DP(a-1,b))
+        dp[a][b]=1;
+    if(a>=1&&b&&!DP(a-1,b+1))
+        dp[a][b]=1;
+    if(a>=2&&((b&&!DP(a-2,b+3))||(b==0&&!DP(a-2,2))))
+        dp[a][b]=1;
+    if(b>=2&&!DP(a,b-1))
+        dp[a][b]=1;
+    return dp[a][b];
+}
+int main()
+{
+    memset(dp,-1,sizeof(dp));
+    int t,test=1,n,i,j,k;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(j=0,k=0,i=0;i<n;i++)
+        {
+            scanf("%d",&a[i]);
+            if(a[i]==1) j++;
+            else k+=a[i]+1;
+        }
+        if(k) k--;
+        DP(j,k);
+        printf("Case #%d: ",test++);
+        if(dp[j][k]) printf("Alice\n");
+        else printf("Bob\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4112_autoAC.cpp b/HDOJ/4112_autoAC.cpp
new file mode 100644
index 0000000..7441795
--- /dev/null
+++ b/HDOJ/4112_autoAC.cpp
@@ -0,0 +1,28 @@
+#include<stdio.h>
+#include<math.h>
+int main()
+{
+    int T;
+    int iCase=0;
+    int n,m,k;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d%d",&n,&m,&k);
+        int t1=n,t2,t3=n;
+        if(m<t1)t1=m;
+        if(k<t1)t1=k;
+        if(m>t3)t3=m;
+        if(k>t3)t3=k;
+        t2=n+m+k-t1-t3;
+        n=t1;m=t2;k=t3;
+        int res=0;
+        if(n>1)res+=(int)(log(1.0*n)/log(2.0)+0.999);
+        if(m>1)res+=(int)(log(1.0*m)/log(2.0)+0.999);
+        if(k>1)res+=(int)(log(1.0*k)/log(2.0)+0.999);
+        long long res1=(long long)n*m*k-1;
+        printf("Case #%d: %I64d %d\n",iCase,res1,res);
+    }    
+    return 0;
+}
diff --git a/HDOJ/4114_autoAC.cpp b/HDOJ/4114_autoAC.cpp
new file mode 100644
index 0000000..d109bc9
--- /dev/null
+++ b/HDOJ/4114_autoAC.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std;
+#define INF 0x3f3f3f3f
+typedef long long LL;
+const int N=55;
+int adj[N][N];
+int pos[N],T[N],FT[N],pass[N];
+int dis[N][1<<8][1<<8];
+int n,m,K;
+void floyed()
+{
+    for(int k=1;k<=n;k++)
+    {
+        for(int i=1;i<=n;i++) if(i!=k)
+        {
+            for(int j=1;j<=n;j++) if(j!=i&&j!=k)
+            {
+                adj[i][j]=min(adj[i][j],adj[i][k]+adj[k][j]);
+            }
+        }
+    }
+}
+int fun()
+{
+    int ans=INF;
+    dis[1][0][0]=0;
+    for(int s1=0;s1<(1<<K);s1++)
+    {
+        for(int s2=0;s2<(1<<K);s2++)
+        {
+            for(int i=1;i<=n;i++)
+            {
+                int now=dis[i][s1][s2];
+                if(now==INF) continue;
+                if(s2==((1<<K)-1)) ans=min(ans,now+adj[i][1]);
+                for(int j=0;j<K;j++) if((s2&(1<<j))==0)
+                {
+                    int &nxt=dis[pos[j]][ s1|pass[ pos[j] ] ][s2^(1<<j)];
+                    int add=adj[i][pos[j]];
+                    if(s1&(1<<j)) add+=FT[j];
+                    else add+=T[j];
+                    nxt=min(nxt,now+add);
+                }
+                for(int j=1;j<=n;j++)
+                {
+                    int &nxt=dis[j][s1|pass[j]][s2];
+                    int add=adj[i][j];
+                    nxt=min(nxt,now+add);
+                }
+            }
+        }
+    }
+    return ans;
+}
+int main()
+{
+    int t,t_cnt=0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        memset(dis,0x3f,sizeof(dis));
+        memset(adj,0x3f,sizeof(adj));
+        memset(pass,0,sizeof(pass));
+        for(int i=0;i<N;i++) adj[i][i]=0;
+        scanf("%d%d%d",&n,&m,&K);
+        for(int i=0;i<m;i++)
+        {
+            int a,b,c; scanf("%d%d%d",&a,&b,&c);
+            adj[a][b]=adj[b][a]=c;
+        }
+        floyed();
+        for(int i=0;i<K;i++)
+        {
+            scanf("%d%d%d",&pos[i],&T[i],&FT[i]);
+            int num; scanf("%d",&num);
+            for(int j=0;j<num;j++)
+            {
+                int tmp; scanf("%d",&tmp);
+                pass[tmp]|=(1<<i);
+            }
+        }
+        printf("Case #%d: %d\n",++t_cnt,fun());
+    }
+    return 0;
+}
diff --git a/HDOJ/4115_autoAC.cpp b/HDOJ/4115_autoAC.cpp
new file mode 100644
index 0000000..4dc0c42
--- /dev/null
+++ b/HDOJ/4115_autoAC.cpp
@@ -0,0 +1,152 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<vector>
+#include<queue>
+#include<string.h>
+using namespace std;
+const int MAXN=22000;
+bool visit[MAXN];
+queue<int>q1,q2;
+vector<vector<int> >adj; 
+vector<vector<int> >radj;
+vector<vector<int> >dag;
+int n,m,cnt;
+int id[MAXN],order[MAXN],ind[MAXN];
+void dfs(int u)
+{
+    visit[u]=true;
+    int i,len=adj[u].size();
+    for(i=0;i<len;i++)
+      if(!visit[adj[u][i]])
+        dfs(adj[u][i]);
+    order[cnt++]=u;
+}
+void rdfs(int u)
+{
+    visit[u]=true;
+    id[u]=cnt;
+    int i,len=radj[u].size();
+    for(i=0;i<len;i++)
+      if(!visit[radj[u][i]])
+        rdfs(radj[u][i]);
+}
+void korasaju()
+{
+    int i;
+    memset(visit,false,sizeof(visit));
+    for(cnt=0,i=0;i<2*n;i++)
+      if(!visit[i])
+        dfs(i);
+    memset(id,0,sizeof(id));
+    memset(visit,false,sizeof(visit));
+    for(cnt=0,i=2*n-1;i>=0;i--)
+      if(!visit[order[i]])
+      {
+          cnt++;
+          rdfs(order[i]);
+      }
+}
+bool solvable()
+{
+    for(int i=0;i<n;i++)
+      if(id[2*i]==id[2*i+1])
+        return false;
+   return true;
+}
+void add(int x,int y)
+{
+    adj[x].push_back(y);
+    radj[y].push_back(x);
+}
+int a[MAXN],b[MAXN];
+int main()
+{
+    int T;
+    int x,y,z;
+    scanf("%d",&T);
+    int iCase=0;
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d",&n,&m);
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d",&a[i]);
+            if(a[i]==1)b[i]=2;
+            else if(a[i]==2)b[i]=3;
+            else b[i]=1;
+            if(a[i]>b[i])swap(a[i],b[i]);
+        }
+        adj.assign(2*n,vector<int>());
+        radj.assign(2*n,vector<int>());
+        bool flag=true;
+        while(m--)
+        {
+            scanf("%d%d%d",&x,&y,&z);
+            x--;
+            y--;
+            if(!flag)continue;
+            if(x==y)
+            {
+                if(z==1)flag=false;
+                continue;
+            }
+            if(z==0)
+            {
+                if(a[x]!=a[y])
+                {
+                    add(2*x,2*y+1);
+                    add(2*y,2*x+1);
+                }
+                if(a[x]!=b[y])
+                {
+                    add(2*x,2*y);
+                    add(2*y+1,2*x+1);
+                }
+                if(b[x]!=a[y])
+                {
+                    add(2*x+1,2*y+1);
+                    add(2*y,2*x);
+                }
+                if(b[x]!=b[y])
+                {
+                    add(2*x+1,2*y);
+                    add(2*y+1,2*x);
+                }
+            }
+            else if(z==1)
+            {
+                if(a[x]==a[y])
+                {
+                    add(2*x,2*y+1);
+                    add(2*y,2*x+1);
+                }
+                if(a[x]==b[y])
+                {
+                    add(2*x,2*y);
+                    add(2*y+1,2*x+1);
+                }
+                if(b[x]==a[y])
+                {
+                    add(2*x+1,2*y+1);
+                    add(2*y,2*x);
+                }
+                if(b[x]==b[y])
+                {
+                    add(2*x+1,2*y);
+                    add(2*y+1,2*x);
+                }
+            }
+        }
+        if(!flag)
+        {
+            printf("Case #%d: no\n",iCase);
+            continue;
+        }
+        korasaju();
+        if(solvable())printf("Case #%d: yes\n",iCase);
+        else printf("Case #%d: no\n",iCase);
+    }
+    return 0;
+}
diff --git a/HDOJ/4117_autoAC.cpp b/HDOJ/4117_autoAC.cpp
new file mode 100644
index 0000000..fe09fb7
--- /dev/null
+++ b/HDOJ/4117_autoAC.cpp
@@ -0,0 +1,244 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <cstdio>
+#include <queue>
+#include <cstring>
+using namespace std;
+#define D(x)
+const int MAX_CHILD_NUM = 26;
+const int MAX_NODE_NUM = 3 * (int)1e5 + 10;
+const int MAX_LEN = 3 * (int)1e5 + 10;
+const int MAX_N = 2 * (int)1e4 + 10;
+#define MAX_EDGE_NUM MAX_NODE_NUM * 2
+struct Edge
+{
+    int v, next;
+    Edge()
+    {}
+    Edge(int v, int next):v(v), next(next)
+    {}
+} edge[MAX_EDGE_NUM];
+int head[MAX_NODE_NUM];
+int edge_cnt;
+void init_edge()
+{
+    memset(head, -1, sizeof(head));
+    edge_cnt = 0;
+}
+void add_edge(int u, int v)
+{
+    edge[edge_cnt] = Edge(v, head[u]);
+    head[u] = edge_cnt++;
+}
+struct Trie
+{
+    int next[MAX_NODE_NUM][MAX_CHILD_NUM];
+    int fail[MAX_NODE_NUM];
+    int count[MAX_NODE_NUM];
+    int node_cnt;
+    int root;
+    bool vis[MAX_NODE_NUM]; //set it to false
+    void init()
+    {
+        node_cnt = 0;
+        root = newnode();
+    }
+    int newnode()
+    {
+        for (int i = 0; i < MAX_CHILD_NUM; i++)
+            next[node_cnt][i] = -1;
+        count[node_cnt++] = 0;
+        return node_cnt - 1;
+    }
+    int get_id(char a)
+    {
+        return a - 'a';
+    }
+    void insert(char buf[], int index)
+    {
+        int now = root;
+        for (int i = 0; buf[i]; i++)
+        {
+            int id = get_id(buf[i]);
+            if (next[now][id] == -1)
+                next[now][id] = newnode();
+            now = next[now][id];
+        }
+        count[now] = index;
+    }
+    void build()
+    {
+        queue<int>Q;
+        fail[root] = root;
+        for (int i = 0; i < MAX_CHILD_NUM; 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();
+            for (int i = 0; i < MAX_CHILD_NUM; i++)
+                if (next[now][i] == -1)
+                    next[now][i] = next[fail[now]][i];
+                else
+                {
+                    fail[next[now][i]]=next[fail[now]][i];
+                    Q.push(next[now][i]);
+                }
+        }
+    }
+    void build_fail_tree()
+    {
+        init_edge();
+        for (int i = 1; i < node_cnt; i++)
+        {
+            add_edge(i, fail[i]);
+            add_edge(fail[i], i);
+        }
+    }
+}ac;
+const int MAX_INTERVAL = MAX_LEN;
+struct SegmentTree
+{
+    struct Node
+    {
+        int l, r;
+        Node *pleft, *pright;
+        int value;
+    }tree[MAX_INTERVAL *4];
+    int node_cnt;
+    void init()
+    {
+        node_cnt = 0;
+    }
+    Node* new_node()
+    {
+        node_cnt++;
+        return tree + node_cnt;
+    }
+    void build_tree(Node *proot, int s, int e)
+    {
+        proot->l = s;
+        proot->r = e;
+        proot->value = 0;
+        if (s == e)
+        {
+            proot->pleft = proot->pright = NULL;
+            return;
+        }
+        int mid = (s + e) / 2;
+        build_tree(proot->pleft = new_node(), s, mid);
+        build_tree(proot->pright = new_node(), mid + 1, e);
+    }
+    void pull_up(Node *proot)
+    {
+    }
+    void push_down(Node *proot)
+    {
+    }
+    void update(Node *proot, int start, int end, int value)
+    {
+        if (start > proot->r || end < proot->l)
+            return;
+        start = max(start, proot->l);
+        end = min(end, proot->r);
+        if (start == proot->l && end == proot->r)
+        {
+            proot->value = max(proot->value, value);
+            return;
+        }
+        push_down(proot);
+        update(proot->pleft, start, end, value);
+        update(proot->pright, start, end, value);
+        pull_up(proot);
+    }
+    int query(Node *proot, int start, int end)
+    {
+        int ret = proot->value;
+        if (start > proot->r || end < proot->l)
+            return 0;
+        start = max(start, proot->l);
+        end = min(end, proot->r);
+        if (start == proot->l && end == proot->r)
+        {
+            return ret;
+        }
+        push_down(proot);
+        ret = max(ret, query(proot->pleft, start, end));
+        ret = max(ret, query(proot->pright, start, end));
+        pull_up(proot);
+        return ret;
+    }
+}tree;
+char st[MAX_LEN];
+int pos[MAX_N];
+int dfn[MAX_LEN][2];
+int dfn_cnt;
+int n;
+int weight[MAX_N];
+void dfs(int u, int parent)
+{
+    dfn[u][0] = ++dfn_cnt;
+    for (int i = head[u]; i != -1; i = edge[i].next)
+    {
+        int v = edge[i].v;
+        if (v != parent)
+        {
+            dfs(v, u);
+        }
+    }
+    dfn[u][1] = dfn_cnt;
+}
+int work()
+{
+    int ret = 0;
+    tree.init();
+    tree.build_tree(tree.tree, 0, dfn_cnt);
+    for (int i = 0; i < n; i++)
+    {
+        int u = ac.root;
+        int temp = 0;
+        for (int j = pos[i]; j < pos[i + 1]; j++)
+        {
+            u = ac.next[u][ac.get_id(st[j])];
+            temp = max(temp, tree.query(tree.tree, dfn[u][0], dfn[u][0]) + weight[i]);
+        }
+        tree.update(tree.tree, dfn[u][0], dfn[u][1], temp);
+        ret = max(ret, temp);
+    }
+    return ret;
+}
+void input()
+{
+    scanf("%d", &n);
+    int temp = 0;
+    for (int i = 0; i < n; i++)
+    {
+        scanf("%s%d", st + temp, &weight[i]);
+        pos[i] = temp;
+        ac.insert(st + temp, i);
+        int len = strlen(st + temp);
+        temp += len;
+    }
+    pos[n] = temp;
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    for (int i = 1; i <= t; i++)
+    {
+        ac.init();
+        input();
+        ac.build();
+        ac.build_fail_tree();
+        dfn_cnt = 0;
+        dfs(0, -1);
+        printf("Case #%d: %d\n", i, work());
+    }
+    return 0;
+}
diff --git a/HDOJ/4118_autoAC.cpp b/HDOJ/4118_autoAC.cpp
new file mode 100644
index 0000000..812fc9b
--- /dev/null
+++ b/HDOJ/4118_autoAC.cpp
@@ -0,0 +1,68 @@
+#pragma comment(linker, "/STACK:10240000000000,10240000000000")
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#define MAXN 101005
+#define MAXM 400005
+#define INF 1000000000
+using namespace std;
+struct EDGE
+{
+    int v, next;
+    long long w;
+}edge[MAXM];
+int head[MAXN], e;
+int n;
+int num[MAXN];
+long long ans;
+void init()
+{
+    ans = 0;
+    memset(head, -1, sizeof(head));
+    e = 0;
+    memset(num, 0, sizeof(num));
+}
+void add(int u, int v, long long w)
+{
+    edge[e].v = v;
+    edge[e].w = w;
+    edge[e].next = head[u];
+    head[u] = e++;
+}
+void dfs(int u, int fa)
+{
+    num[u] = 1;
+    for(int i = head[u]; i != -1; i = edge[i].next)
+    {
+        int v = edge[i].v;
+        if(v != fa)
+        {
+            dfs(v, u);
+            num[u] += num[v];
+            long long tmp = min(num[v], n - num[v]);
+            ans += tmp * edge[i].w * 2LL;
+        }
+    }
+}
+int main()
+{
+    int T, cas = 0, x, y, z;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%d", &n);
+        init();
+        for(int i = 1; i < n; i++)
+        {
+            scanf("%d%d%d", &x, &y, &z);
+            add(x, y, z);
+            add(y, x, z);
+        }
+        dfs(1, 0);
+        printf("Case #%d: %I64d\n", ++cas, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4119_autoAC.cpp b/HDOJ/4119_autoAC.cpp
new file mode 100644
index 0000000..8f87fb0
--- /dev/null
+++ b/HDOJ/4119_autoAC.cpp
@@ -0,0 +1,111 @@
+#include <set>
+#include <string>
+#include <stdio.h>
+#include <algorithm>
+using namespace std;
+struct Point
+{
+    int x,y;
+    Point(){}
+    Point(int x,int y):x(x),y(y){}
+    bool operator <(const Point& S)const
+    {
+        return x<S.x || x==S.x && y<S.y;
+    }
+}P[4][666];
+struct TT
+{
+    string s;
+    bool ok;
+    bool operator <(const TT& S)const
+    {
+        return s < S.s;
+    }
+}Ans[4];
+int n,m;
+Point Rotary(Point A)
+{
+    return Point(A.y,n+1-A.x);
+}
+int main()
+{
+    int z,ncase=0;
+    char tmp[25],map[55][55];
+    set<string> Dic;
+    scanf("%d",&z);
+    while(z--)
+    {
+        Dic.clear();
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++)
+            scanf("%s",map[i]+1);
+        int top = 0;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%s",map[0]+1);
+            for(int j=1;j<=n;j++)
+                if(map[0][j] == '*')
+                    P[0][top++] = Point(i,j);
+        }
+        for(int i=1;i<=3;i++)
+            for(int j=0;j<top;j++)
+                P[i][j] = Rotary(P[i-1][j]);
+        for(int i=0;i<=3;i++)
+            sort(P[i],P[i]+top);
+        for(int k=0;k<=3;k++)
+            Ans[k].ok = true;
+        scanf("%d",&m);
+        for(int i=0;i<m;i++)
+        {
+            scanf("%s",tmp);
+            Dic.insert(tmp);
+        }
+        for(int k=0;k<=3;k++)
+        {
+            int loc = -1;
+            string& str = Ans[k].s;
+            str = "";
+            for(int i=k;i<k+4;i++)
+                for(int j=0;j<top;j++)
+                {
+                    char ttmp = map[ P[i%4][j].x ][ P[i%4][j].y ];
+                    str += ttmp=='.' ? ' ' : ttmp;
+                }
+            while(!str.empty() && str[0]==' ')
+                str.erase(str.begin());
+            for(int i=1;i<str.length();i++)
+                if(str[i]==' ' && str[i-1]==' ')
+                    str.erase(str.begin()+(i--));
+            if(!str.empty() && str[ str.length()-1 ]==' ')
+                str.erase(str.end()-1);
+            if(str.empty())
+            {
+                Ans[k].ok = false;
+                continue;
+            }
+            while(++loc < str.length())
+            {
+                string word;
+                while(loc<str.length() && str[loc]!=' ')
+                    word += str[loc++];
+                if(Dic.find(word) == Dic.end())
+                {
+                    Ans[k].ok = false;
+                    break;
+                }
+            }
+        }
+        sort(Ans,Ans+4);
+        printf("Case #%d: ",++ncase);
+        int i;
+        for(i=0;i<4;i++)
+            if(Ans[i].ok)
+            {
+                puts(Ans[i].s.c_str());
+                break;
+            }
+        if(i == 4)
+            puts("FAIL TO DECRYPT");
+    }
+    return 0;
+}
diff --git a/HDOJ/4120_autoAC.cpp b/HDOJ/4120_autoAC.cpp
new file mode 100644
index 0000000..b0a6103
--- /dev/null
+++ b/HDOJ/4120_autoAC.cpp
@@ -0,0 +1,126 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<algorithm>
+#define LL __int64
+const int N = 10005;
+using namespace std;
+int a[N], n, k, s, t;
+int Ans()
+{
+    int i;
+    for( i = 1; i <= k; i ++ )
+        if( a[i] < 0 )
+            return 0;
+    for( i = 1; i < k; i ++ )
+    {
+        a[i] -= a[i+1];
+        if( a[i] )
+        {
+            n --;
+            t -= a[i] * i;
+        }
+    }
+    s = a[k];
+    a[k] = 0;
+    for( i = 1; i < k; i ++ )
+        if( a[i] < 0 )
+            return 0;
+    if( n < 0 || s < n)
+        return 0;
+    if( n == 0 )
+    {
+        if( t == 0 && s == 0 )
+            return 1;
+        else
+            return 0;
+    }
+    if( n == 1 )
+    {
+        if( t%s == 0 && t/s >= k )
+        {
+            a[t/s] = s;
+            return 1;
+        }
+        else
+            return 0;
+    }
+    int ans(0), j, tt, mm = ( n*n-n ) / 2;
+    for( i = k; i*s <= t-mm; i ++ )
+    {
+        tt = t-mm - i*s;
+        if( tt == 0 )
+        {
+            for( j = 1; j < n; j ++ )
+                a[k+j] = 1;
+            a[k] = s-n+1;
+            ans ++;
+        }
+        else if( tt > 1 && n > 2 )
+            return 2;
+        else if( tt > 1 && n == 2 )
+        {
+            tt += mm;
+            for( j = 1; j < s; j ++ )
+            {
+                if( j > tt )
+                    break;
+                else if( ans > 1 )
+                    return 2;
+                if( tt%j == 0 )
+                {
+                    a[ tt/j + i ] = j;
+                    a[i] = s-j;
+                    ans ++;
+                }
+            }
+        }
+        else if( s > n )
+            return 2;
+        else
+        {
+            for( j = 1; j < n-1; j ++ )
+                a[k+j] = 1;
+            a[k+n] = 1;
+            a[k] = s-n+1;
+            ans ++;
+        }
+        if( ans > 1 )
+            return 2;
+    }
+    return ans;
+}
+int main()
+{
+    int ca, cs, i, pre, now;
+    scanf( "%d", &ca );
+    for( cs = 1; cs <= ca; cs ++ )
+    {
+        memset( a, 0, sizeof(a) );
+        scanf( "%d%d", &n, &k );
+        scanf( "%d", &t );
+        pre = t;
+        for( i = 1; i <= k; i ++ )
+        {
+            scanf( "%d", &now );
+            a[i] = pre - now;
+            pre = now;
+        }
+        printf( "Case #%d:\n", cs );
+        now = Ans();
+        if( now < 1 )
+            printf( "No Solution\n" );
+        else if( now > 1 )
+            printf( "Multiple Solutions\n" );
+        else
+        {
+            printf( "Unique Solution\n" );
+            for( i = 1; i < N; i ++ )
+                if( a[i] )
+                    printf( "%d %d\n", i, a[i] );
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4121_autoAC.cpp b/HDOJ/4121_autoAC.cpp
new file mode 100644
index 0000000..ba1dbf5
--- /dev/null
+++ b/HDOJ/4121_autoAC.cpp
@@ -0,0 +1,160 @@
+#include <iostream>
+#include <algorithm>
+using namespace std ;
+int abs(int x)
+{
+    return x>0?x:-x ;
+}
+char map[11][11] ;
+int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}} ;
+int RGX,RGY ;
+int xx,yy ;
+int ok(int x,int y)
+{
+    if(y!=RGY)
+        return 1 ;
+    for(int i=x+1 ;i<RGX ;i++)
+        if(map[i][y]!='0')
+            return 1 ;
+    return 0 ;
+}
+int cha(int x,int y)
+{
+    if(x!=xx && y!=yy)
+        return 0 ;
+    if(x==xx)
+    {
+        int minn=min(y,yy) ;
+        int maxn=max(y,yy) ;
+        for(int i=minn+1 ;i<maxn ;i++)
+            if(map[x][i]!='0')
+                return 0 ;
+    }
+    if(y==yy)
+    {
+        int minn=min(x,xx) ;
+        int maxn=max(x,xx) ;
+        for(int i=minn+1 ;i<maxn ;i++)
+            if(map[i][y]!='0')
+                return 0 ;
+    }
+    return 1 ;
+}
+int hor(int x,int y)
+{
+    if((abs(x-xx)==1 && abs(y-yy)==2) || (abs(x-xx)==2 &&abs(y-yy)==1))
+    {
+        if(xx-x==-2)
+        {
+            if(map[x-1][y]!='0')
+                return 0 ;
+        }
+        if(xx-x==2)
+        {
+            if(map[x+1][y]!='0')
+                return 0 ;
+        }
+        if(yy-y==-2)
+        {
+            if(map[x][y-1]!='0')
+                return 0 ;
+        }
+        if(yy-y==2)
+        {
+            if(map[x][y+1]!='0')
+                return 0 ;
+        }
+        return 1 ;
+    }
+    return 0 ;
+}
+int can(int x,int y)
+{
+    if(x!=xx && y!=yy)
+        return 0 ;
+    int flag=0 ;
+    if(x==xx)
+    {
+        int minn=min(y,yy) ;
+        int maxn=max(y,yy) ;
+        for(int i=minn+1 ;i<maxn ;i++)
+            if(map[x][i]!='0')
+                flag++ ;
+    }
+    if(y==yy)
+    {
+        int minn=min(x,xx) ;
+        int maxn=max(x,xx) ;
+        for(int i=minn+1 ;i<maxn ;i++)
+            if(map[i][y]!='0')
+                flag++ ;
+    }
+    if(flag==1)
+        return 1 ;
+    return 0 ;
+}
+int main()
+{
+    int n ;
+    int x,y ;
+    while(~scanf("%d%d%d%*c",&n,&x,&y))
+    {
+        if(n==0 && x==0 && y==0)
+            break ;
+        for(int i=0 ;i<11 ;i++)
+            for(int j=0 ;j<11 ;j++)
+                map[i][j]='0' ;
+        for(int i=0 ;i<n ;i++)
+        {
+            char chr ;
+            int a,b ;
+            cin >> chr >> a >> b ;
+            map[a][b]=chr ;
+            if(chr=='G')
+            {
+                RGX=a ;RGY=b ;
+            }
+        }
+        int flag ;
+        for(int i=0 ;i<4 ;i++)
+        {
+            flag=0 ;
+            xx=x+dir[i][0] ;
+            yy=y+dir[i][1] ;
+            if(xx<1 || xx>3){flag=1 ;continue ;}
+            if(yy<4 || yy>6){flag=1 ;continue ;}
+            if(!ok(xx,yy)){flag=1 ;continue ;}
+            char t=map[xx][yy] ;
+            map[xx][yy]='0' ;
+            for(int j=1 ;j<=10 ;j++)
+            {
+                for(int k=1 ;k<=9 ;k++)
+                {
+                    if(map[j][k]=='R')
+                    {
+                        if(cha(j,k))
+                            flag=1 ;    
+                    }
+                    if(map[j][k]=='H')
+                    {
+                        if(hor(j,k))
+                            flag=1 ;
+                    }
+                    if(map[j][k]=='C')
+                    {
+                        if(can(j,k))
+                            flag=1 ;
+                    }
+                }
+            }
+            if(!flag)
+                break ;
+            map[xx][yy]=t ;
+         }
+        if(flag)
+            puts("YES") ;
+        else
+            puts("NO") ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/4122_autoAC.cpp b/HDOJ/4122_autoAC.cpp
new file mode 100644
index 0000000..43d01b8
--- /dev/null
+++ b/HDOJ/4122_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<iostream>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<string>
+#include<queue>
+#include<algorithm>
+#include<map>
+#include<iomanip>
+#define INF 99999999
+using namespace std;
+const int MAX=2500+10;
+char mon[5];
+int M[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
+struct Node{
+    int num,t;
+}order[MAX],q[MAX*4];
+int MON(char *m){
+    if(strcmp(m,"Jan") == 0)return 1;
+    if(strcmp(m,"Feb") == 0)return 2;
+    if(strcmp(m,"Mar") == 0)return 3;
+    if(strcmp(m,"Apr") == 0)return 4;
+    if(strcmp(m,"May") == 0)return 5;
+    if(strcmp(m,"Jun") == 0)return 6;
+    if(strcmp(m,"Jul") == 0)return 7;
+    if(strcmp(m,"Aug") == 0)return 8;
+    if(strcmp(m,"Sep") == 0)return 9;
+    if(strcmp(m,"Oct") == 0)return 10;
+    if(strcmp(m,"Nov") == 0)return 11;
+    return 12;
+}
+bool LeapYear(int &year){
+    return year%4 == 0 && year%100 || year%400 == 0;
+}
+int Time(int &year,int Mon,int &d,int &h){
+    int t=0;
+    for(int i=2000;i<year;++i){
+        if(LeapYear(i))t+=366;
+        else t+=365;
+    }
+    bool flag=LeapYear(year);
+    for(int i=1;i<Mon;++i){
+        if(flag && i == 2)t+=29;
+        else t+=M[i];
+    }
+    t+=d-1;
+    return t*24+h;
+}
+int main(){
+    int n,m,t,s,r,h,d,year,a;
+    while(~scanf("%d%d",&n,&m),n+m){
+        for(int i=0;i<n;++i){
+            scanf("%s%d%d%d%d",mon,&d,&year,&h,&r);
+            order[i].num=r,order[i].t=Time(year,MON(mon),d,h); 
+        }
+        int top=0,tail=0,p=0;
+        __int64 sum=0;
+        scanf("%d%d",&t,&s);
+        for(int i=0;i<m;++i){
+            scanf("%d",&a);
+            while(top<tail && q[tail-1].num+(i-q[tail-1].t)*s>=a)--tail;
+            q[tail].num=a,q[tail++].t=i;
+            while(p<n && i == order[p].t){
+                while(q[top].t+t<i)++top;
+                sum+=(q[top].num+(i-q[top].t)*s)*order[p++].num;
+            }
+        }
+        printf("%I64d\n",sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4123_autoAC.cpp b/HDOJ/4123_autoAC.cpp
new file mode 100644
index 0000000..fb614f3
--- /dev/null
+++ b/HDOJ/4123_autoAC.cpp
@@ -0,0 +1,133 @@
+#include<cstdio>
+#include<iostream>
+#include<vector>
+using namespace std;
+#include<algorithm>
+#include<string>
+#define N 50010
+#define M 510
+#define inf 200000000 
+int w[N],edge,id[N],an[M];
+__int64 dp[N][2],dis[N];
+struct qq{
+    int id;
+    __int64 l;
+}q[M];
+bool cmp(const qq &a,const qq &b){
+    return a.l<b.l;
+}
+struct node{
+    int v,next;
+    __int64 l;
+}e[N*2];
+void add(int u,int v,__int64 l){
+    e[edge].v=v;
+    e[edge].l=l;
+    e[edge].next=w[u];
+    w[u]=edge++;
+}
+void dfs1(int u,int no){
+    for(int i=w[u];i!=-1;i=e[i].next){
+        int v=e[i].v;
+        if(v!=no){
+            dfs1(v,u);
+            if(dp[v][0]+e[i].l>dp[u][0]){
+                dp[u][1]=dp[u][0];
+                id[u]=v,dp[u][0]=dp[v][0]+e[i].l;
+            }
+            else if(dp[v][0]+e[i].l>dp[u][1]) dp[u][1]=dp[v][0]+e[i].l;
+        }
+    }
+}
+void dfs2(int u,int no,__int64 l){
+    dis[u]=max(l,dp[u][0]);
+    for(int i=w[u];i!=-1;i=e[i].next){
+        int v=e[i].v;
+        if(v!=no){
+            if(v==id[u]) dfs2(v,u,max(l,dp[u][1])+e[i].l);
+            else dfs2(v,u,dis[u]+e[i].l);
+        }
+    }
+}
+int dp_max[N][20],dp_min[N][20];
+__int64 p[20];
+int max_id(int x,int y){
+    return dis[x]>dis[y]?x:y;
+}
+int min_id(int x,int y){
+    return dis[x]>dis[y]?y:x;
+}
+int log(int x){
+    int i=0;
+    while(p[i]<=x) i++; 
+    return i-1;
+}
+int get_max_id(int x,int y){
+    int t=log(y-x+1);
+    return max_id(dp_max[x][t],dp_max[y-p[t]+1][t]);
+}
+int get_min_id(int x,int y){
+    int t=log(y-x+1);
+    return min_id(dp_min[x][t],dp_min[y-p[t]+1][t]);
+}
+__int64 get_min(int x,int y){
+    return dis[get_min_id(x,y)];
+}
+__int64 get_max(int x,int y){
+    return dis[get_max_id(x,y)];
+}
+void RMQ(int n){
+    int i,j,l=n,t=0;
+    p[0]=1;
+    for(i=1;i<18;i++) 
+        p[i]=p[i-1]<<1;
+    t=log(n);
+    for(i=1;i<=n;i++) 
+        dp_max[i][0]=dp_min[i][0]=i;
+    for(i=1;i<=t;i++){
+        l=n-p[i]+1;
+        for(j=1;j<=l;j++){
+            dp_max[j][i]=max_id(dp_max[j][i-1],dp_max[j+p[i-1]][i-1]);
+            dp_min[j][i]=min_id(dp_min[j][i-1],dp_min[j+p[i-1]][i-1]);
+        }
+    }
+}
+int main(){
+    int n,m,a,b;
+    __int64 c;
+    while(scanf("%d%d",&n,&m)){
+        if(!n&&!m) break;
+        edge=0;
+        memset(w,-1,sizeof(int)*(n+1));
+        for(int i=1;i<n;++i){
+            scanf("%d%d%I64d",&a,&b,&c);
+            add(a,b,c);
+            add(b,a,c);
+        }
+        memset(dis,0,sizeof(__int64)*(n+1));
+        memset(dp,0,sizeof(dp));
+        dfs1(1,1);
+        dfs2(1,1,0);
+        RMQ(n);
+        for(int i=0;i<m;++i){
+            scanf("%I64d",&q[i].l);
+            q[i].id=i;
+        }
+        sort(q,q+m,cmp);
+        for(int i=0;i<m;++i){
+            int ans,start=1;
+            if(!i) ans=1;
+            else ans=an[q[i-1].id];
+            while(1){
+                int j=start+ans-1;
+                for(;j<=n&&get_max(start,j)-get_min(start,j)<=q[i].l;++j);
+                if(ans<j-start) ans=j-start;
+                if(j==n+1) break;
+                ++start;
+            }
+            an[q[i].id]=ans;
+        }
+        for(int i=0;i<m;++i) printf("%d\n",an[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4125_autoAC.cpp b/HDOJ/4125_autoAC.cpp
new file mode 100644
index 0000000..b1729fa
--- /dev/null
+++ b/HDOJ/4125_autoAC.cpp
@@ -0,0 +1,175 @@
+#include<stdio.h>
+#include<string.h>
+char s[2000000],ss[10000];
+int sta[700000],top,root,ch[700000][2],cnt;
+int zhu[700000],C[700000];
+inline void f()
+{
+    zhu[root]=0;cnt=0;
+    sta[0]=root,top=1;
+    if(!ch[root][0]&&!ch[root][1])
+    {
+        s[0]=root%2+'0';
+        return;
+    }
+    int t=root;
+    while(t-root||((zhu[t]==1&&ch[t][1])||zhu[t]==0))
+    {
+        s[cnt++]=t%2+'0';
+        if(top<0)
+            return;
+        if(zhu[t]==0)
+        {
+            if(ch[t][0])
+            {
+                zhu[t]=1;
+                t=ch[t][0];
+                zhu[t]=0;
+                sta[top++]=t;
+            }
+            else if(ch[t][1])
+            {
+                zhu[t]=2;
+                t=ch[t][1];
+                zhu[t]=0;
+                sta[top++]=t;
+            }
+            else if(t==root)
+                return ;
+            else
+                zhu[t]=2,t=sta[--top-1];
+        }
+        else if(zhu[t]==1)
+        {
+            if(ch[t][1])
+            {
+                zhu[t]=2;
+                t=ch[t][1];
+                zhu[t]=0;
+                sta[top++]=t;
+            }
+            else if(t==root)
+                return ;
+            else
+                t=sta[--top-1];
+        }
+        else if(t==root)
+            return ;
+        else
+            t=sta[--top-1];
+    }
+    s[cnt++]=root%2+'0';
+}
+int P[10000];
+inline void scan(int &u)
+{
+    char c;
+    while(c=getchar(),c<'0'||c>'9');
+    u=c-'0';
+    while(c=getchar(),c<='9'&&c>='0')
+        u=u*10+c-'0';
+}
+int ff(int l)
+{
+    int i,j,ans=0;
+    P[0]=-1;
+    for(i=1,j=-1;i<l;i++)
+    {
+        while(j+1&&ss[j+1]-ss[i])
+            j=P[j];
+        if(ss[j+1]==ss[i])
+            j++;
+        P[i]=j;
+    }
+    for(i=0,j=-1;i<cnt;i++)
+    {
+        while(j+1&&ss[j+1]-s[i])
+            j=P[j];
+        if(ss[j+1]==s[i])
+            j++;
+        if(j==l-1)
+            ans++;
+    }
+    return ans;
+}
+int N,Min,Max;
+int cal(int n)
+{
+    int ans=0;
+    while(n>=1)
+        ans+=C[n],n-=n&(-n);
+    return ans;
+}
+void update(int n)
+{
+    while(n<=N)
+        C[n]++,n+=n&(-n);
+}
+void insert(int n)
+{
+    update(n);
+    int t=cal(n);
+    if(!root)
+    {
+        root=n;
+        Min=Max=n;
+        return;
+    }
+    if(n>Max)
+    {
+        ch[Max][1]=n;
+        Max=n;
+        return;
+    }
+    if(n<Min)
+    {
+        ch[Min][0]=n;
+        Min=n;
+        return;
+    }
+    int l=1,r=n-1,mid;
+    Min=Min<n?Min:n;
+    Max=Max>n?Max:n;
+    while(l<r)
+    {
+        mid=(l+r)>>1;
+        if(cal(mid)==t-1)
+            r=mid;
+        else
+            l=mid+1;
+    }
+    l=r;
+    if(!ch[l][1])
+    {
+        ch[l][1]=n;
+        return;
+    }
+    l=n+1,r=N;
+    while(l<r)
+    {
+        mid=(l+r)>>1;
+        if(cal(mid)-t)
+            r=mid;
+        else
+            l=mid+1;
+    }
+    ch[r][0]=n;
+}
+int main()
+{
+    int t,n,i,j;
+    scanf("%d",&t);
+    for(int ii=1;ii<=t;ii++)
+    {
+        memset(ch,0,sizeof(ch));
+        memset(C,0,sizeof(C));
+        Min=1000000,Max=0;
+        root=0;
+        scanf("%d",&n);N=n;
+        for(i=1;i<=n;i++)
+            scanf("%d",&j),insert(j);
+        f();
+        scanf("%s",ss);
+        printf("Case #%d: %d\n",ii,ff(strlen(ss)));
+    }
+}
diff --git a/HDOJ/4126_autoAC.cpp b/HDOJ/4126_autoAC.cpp
new file mode 100644
index 0000000..c262499
--- /dev/null
+++ b/HDOJ/4126_autoAC.cpp
@@ -0,0 +1,117 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<vector>
+using namespace std;
+const int maxn = 3003;
+const int maxm = maxn * maxn;
+const int inf = 1000000000;
+int n, m;
+__int64 mst;
+int map[maxn][maxn];
+int dp[maxn][maxn];
+int dis[maxn], pre[maxn];
+bool vis[maxn];
+vector<int> edge[maxn];
+int minz(int a, int b)
+{
+    return a < b ? a : b;
+}
+void init()
+{
+    int i, j;
+    for(i = 0; i < n; i++)
+    {
+        for(j = 0; j < n; j++)
+            map[i][j] = dp[i][j] = inf;
+        edge[i].clear();
+        vis[i] = 0;
+        pre[i] = -1;
+        dis[i] = inf;
+    }
+}
+void input()
+{
+    int x, y, z;
+    while(m--)
+    {
+        scanf("%d%d%d", &x, &y, &z);
+        map[x][y] = map[y][x] = z;
+    }
+}
+void prim()
+{
+    int i, j, k;
+    for(i = 1; i < n; i++)
+    {
+        dis[i] = map[0][i];
+        pre[i] = 0;
+    }
+    dis[0] = inf;
+    vis[0] = 1;
+    pre[0] = -1;
+    mst = 0;
+    for(i = 0; i < n-1; i++)
+    {
+        k = 0;
+        for(j = 1; j < n; j++)
+            if(!vis[j] && dis[k] > dis[j])
+                k = j;
+        vis[k] = 1;
+        mst += dis[k];
+        if(pre[k] != -1)
+            edge[k].push_back(pre[k]),
+            edge[pre[k]].push_back(k);
+        for(j = 1; j < n; j++)
+            if(!vis[j] && dis[j] > map[k][j] )
+                dis[j] = map[k][j], pre[j] = k;
+    }
+}
+int dfs(int pos, int u, int fa) 
+{
+    int i, ans = inf;
+    for(i = 0; i < edge[u].size(); i++)
+    {
+        int v = edge[u][i];
+        if(v == fa) continue;
+        int tmp = dfs(pos, v, u);
+        ans = minz(ans, tmp);
+        dp[u][v] = dp[v][u] = minz(dp[u][v], tmp); 
+    }
+    if(pos != fa) 
+        ans = minz(ans, map[pos][u]);
+    return ans;
+}
+void solve()
+{
+    int i;
+    for(i = 0; i < n; i++)
+        dfs(i, i, -1);
+}
+void query()
+{
+    int x, y, z;
+    double sum = 0;
+    scanf("%d", &m);
+    for(int ii = 1; ii <= m; ii++)
+    {
+        scanf("%d%d%d", &x, &y, &z);
+        if(pre[x] != y && pre[y] != x)
+            sum += mst * 1.0;
+        else
+            sum += mst * 1.0 - map[x][y] + minz(dp[x][y], z);
+    }
+    printf("%.4f\n", sum/m);
+}
+int main()
+{
+    while( ~scanf("%d%d", &n, &m) && n + m)
+    {
+        init();
+        input();
+        prim();
+        solve();
+        query();
+    }
+    return 0;
+}
diff --git a/HDOJ/4127_autoAC.cpp b/HDOJ/4127_autoAC.cpp
new file mode 100644
index 0000000..57f959e
--- /dev/null
+++ b/HDOJ/4127_autoAC.cpp
@@ -0,0 +1,118 @@
+#include<iostream>
+#include<cstdio>
+#include<map>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<algorithm>
+#include<set>
+#include<string>
+#include<queue>
+#define inf 1<<30
+#define M 60005
+#define N 10005
+#define maxn 300005
+#define eps 1e-10
+#define zero(a) fabs(a)<eps
+#define Min(a,b) ((a)<(b)?(a):(b))
+#define Max(a,b) ((a)>(b)?(a):(b))
+#define pb(a) push_back(a)
+#define mem(a,b) memset(a,b,sizeof(a))
+#define LL long long
+#define lson step<<1
+#define rson step<<1|1
+#define MOD 1000000009
+using namespace std;
+int maze[10][10];
+int n;
+int way[4][2]={0,1,0,-1,1,0,-1,0};
+int vis[10][10];
+bool check(int x,int y)
+{
+    if(x<0||y<0||x>=n||y>=n) return false;
+    return true;
+}
+void floodfill(int x,int y,int c)
+{
+    vis[x][y]=1;
+    for(int i=0;i<4;i++)
+    {
+        int tx=x+way[i][0];
+        int ty=y+way[i][1];
+        if(!check(tx,ty)) continue;
+        if(vis[tx][ty]==1) continue;
+        if(maze[tx][ty]==c) floodfill(tx,ty,c);
+        else vis[tx][ty]=2;
+    }
+}
+int get_cnt(int col)
+{
+    int cnt=0;
+    for(int i=0;i<n;i++)
+    {
+        for(int j=0;j<n;j++)
+        {
+            if(maze[i][j]==col&&vis[i][j]==2)
+            {
+                cnt++;
+                floodfill(i,j,maze[i][j]);
+            }
+        }
+    }
+    return cnt;
+}
+int get_h()
+{
+    bool flag[6];mem(flag,false);
+    int cnt=0;
+    for(int i=0;i<n;i++)
+    {
+        for(int j=0;j<n;j++)
+        {
+            if(vis[i][j]!=1&&!flag[maze[i][j]])
+            {
+                cnt++;
+                flag[maze[i][j]]=true;
+            }
+        }
+    }
+    return cnt;
+}
+int depth;
+bool IDAstar(int dep)
+{
+    if(depth==dep) return get_h()==0;
+    if(dep+get_h()>depth) return false;
+    for(int i=0;i<6;i++)
+    {
+        int tmp[10][10];
+        memcpy(tmp,vis,sizeof(vis));
+        if(get_cnt(i)==0) continue;
+        if(IDAstar(dep+1)) return true;
+        memcpy(vis,tmp,sizeof(vis));
+    }
+    return false;
+}
+int main()
+{
+    while(scanf("%d",&n)!=EOF&&n)
+    {
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<n;j++)
+            {
+                scanf("%d",&maze[i][j]);
+            }
+        }
+        mem(vis,0);
+        floodfill(0,0,maze[0][0]);
+        depth=get_h();
+        while(true)
+        {
+            if(IDAstar(0)) break;
+            depth++;
+        }
+        printf("%d\n",depth);
+    }
+    return 0;
+}
diff --git a/HDOJ/4128_autoAC.cpp b/HDOJ/4128_autoAC.cpp
new file mode 100644
index 0000000..ccac513
--- /dev/null
+++ b/HDOJ/4128_autoAC.cpp
@@ -0,0 +1,99 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+struct Node
+{
+    long long s,t;
+}node[11000];
+int cmp(const void *a,const void *b)
+{
+    return ((Node *)b)->s-((Node *)a)->s;
+}
+long long S[11000],T[11000],N;
+int ff(int s,int t)
+{
+    if(N==1)
+        return 1;
+    if(N==2)
+    {
+        if((T[1]-t)*(S[2]-s)<(S[1]-s)*(T[2]-t))
+            return 1;
+        return 2;
+    }
+    int l=2,r=N-1,mid;
+    while(l<r)
+    {
+        mid=(l+r)>>1;
+        if((T[mid]-t)*(S[mid-1]-s)<=(T[mid-1]-t)*(S[mid]-s)&&(T[mid]-t)*(S[mid+1]-s)<=(T[mid+1]-t)*(S[mid]-s))
+            l=r=mid;
+        else if((T[mid]-t)*(S[mid-1]-s)<(T[mid-1]-t)*(S[mid]-s)&&(T[mid]-t)*(S[mid+1]-s)>=(T[mid+1]-t)*(S[mid]-s))
+            l=mid+1;
+        else
+            r=mid-1;
+    }
+    if((T[1]-t)*(S[r]-s)<(T[r]-t)*(S[1]-s))
+        r=1;
+    if((T[N]-t)*(S[r]-s)<(T[r]-t)*(S[N]-s))
+        r=N;
+    return r;
+}
+int q[11000],f,r,qq[11000];
+int main()
+{
+    long long n,s,w,d,L,j;
+    int i,t;
+    double ans;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%I64d%I64d%I64d%I64d",&n,&d,&L,&w);
+        for(i=1,s=0;i<=n;i++)
+            scanf("%I64d%I64d",&node[i].s,&node[i].t),s+=d*node[i].t,w-=node[i].s*d;
+        L-=d*n;
+        if(L<0||w<0)
+        {
+            printf("No solution\n");
+            continue;
+        }
+        qsort(node+1,n,sizeof(Node),cmp);
+        for(i=1,f=1,r=0;i<=n;i++)
+        {
+            while(f<=r&&node[i].t<node[q[r]].t)
+                r--;
+            q[++r]=i;
+        }
+        n=r;
+        for(i=1;i<=n&&L*node[q[i]].s>w;i++);
+        if(i>n)
+        {
+            printf("No solution\n");
+            continue;
+        }
+        else if(L*(node[q[1]].s)<=w)
+        {
+            printf("%.2f\n",s+L*node[q[1]].t+0.0);
+            continue;
+        }
+        r=i;
+        S[1]=node[q[1]].s,T[1]=node[q[1]].t;
+        for(i=2,N=1,qq[1]=q[1];i<r;i++)
+        {
+            while(N>1&&((node[qq[N-1]].t-node[qq[N]].t)*(node[qq[N]].s-node[q[i]].s)<=(node[qq[N]].t-node[q[i]].t)*(node[qq[N-1]].s-node[qq[N]].s)))
+                N--;
+            qq[++N]=q[i];
+        }
+        for(i=1;i<=N;i++)
+            S[i]=node[qq[i]].s,T[i]=node[qq[i]].t;
+        for(ans=4000000000,i=r;i<=n;i++)
+        {
+            j=ff(node[q[i]].s,node[q[i]].t);
+            j=qq[j];
+            double tt=L*node[q[i]].t+(w-L*node[q[i]].s)*((node[q[i]].t-node[j].t+0.0)/(node[q[i]].s-node[j].s+0.0));
+            if(tt<ans)
+                ans=tt;
+        }
+        printf("%.2f\n",ans+s);
+    }
+}
diff --git a/HDOJ/4132_autoAC.cpp b/HDOJ/4132_autoAC.cpp
new file mode 100644
index 0000000..33c91fb
--- /dev/null
+++ b/HDOJ/4132_autoAC.cpp
@@ -0,0 +1,130 @@
+#include <iostream>
+#include <string.h>
+#include <cmath>
+#include <vector>
+#include <set>
+#include <map>
+#include <algorithm>
+using namespace std;
+const int maxn = 50000;
+struct node
+{
+    int s;
+    int e;
+    int v;
+}seg[maxn+5];
+struct hashnode
+{
+    int rv;
+    int id;
+}index[maxn*2+5];
+bool cmp(const hashnode &a, const hashnode &b)
+{
+    return a.rv<b.rv;
+}
+int f[maxn*2+5];
+inline int lowbit(int x)
+{
+    return x & (-x);
+}
+inline void _update(int x, int d)
+{
+    int i;
+    for (i=x; i>0; i-=lowbit(i))
+    {
+        f[i] += d;
+    }
+}
+inline void update(int l, int r, int d)
+{
+    _update(l-1, -d);
+    _update(r, d);
+}
+inline int getpt(int x, int n)
+{
+    int i, s = 0;
+    for (i=x; i<=n; i+=lowbit(i))
+    {
+        s += f[i];
+    }
+    return s;
+}
+int bs(int v, int s, int t)
+{
+    int l=s-1, r=t+1, m, ans;
+    while(l<=r)
+    {
+        m = (l+r)>>1;
+        if (v<=index[m].rv)
+        {
+            ans = m;
+            r = m-1;
+        }
+        else l = m+1;
+    }
+    return index[ans].id;
+}
+int main()
+{
+    int t;
+    int len;
+    double amt;
+    int n;
+    int i, j;
+    int a, b;
+    int end;
+    double ans;
+    scanf("%d", &t);
+    while(t--)
+    {
+        scanf("%d %lf", &len, &amt);
+        scanf("%d", &n);
+        index[1].rv = 0;
+        index[2].rv = len;
+        for (i=0,j=3; i<n; i++,j+=2)
+        {
+            scanf("%d %d %d", &seg[i].s, &seg[i].e, &seg[i].v);
+            index[j].rv = seg[i].s;
+            index[j+1].rv = seg[i].e;
+        }
+        end = j-1;
+        sort(index+1, index+end+1, cmp);
+        index[1].id = 1;
+        for (i=2,j=2; i<=end; i++)
+        {
+            if (index[i].rv!=index[j-1].rv)
+            {
+                index[j].rv = index[i].rv;
+                index[j].id = j;
+                j++;
+            }
+        }
+        end = j-1;
+        memset(f, 0, sizeof(f));
+        update(1, end-1, 1);
+        for (i=0; i<n; i++)
+        {
+            a = bs(seg[i].s, 1, end);
+            b = bs(seg[i].e, 1, end);
+            update(a, b-1, seg[i].v);
+        }
+        ans = 0;
+        for (i=1; i<end && fabs(amt)>1e-6; i++)
+        {
+            a = index[i+1].rv-index[i].rv;
+            b = getpt(i, end);
+            if (a*1.0>amt/b)
+            {
+                ans += amt/b;
+                amt = 0;
+            }
+            else
+            {
+                ans += a;
+                amt -= a*b;
+            }
+        }
+        printf("%.2lf\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4133_autoAC.cpp b/HDOJ/4133_autoAC.cpp
new file mode 100644
index 0000000..a8d3724
--- /dev/null
+++ b/HDOJ/4133_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<stdio.h>
+__int64 prime[16]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};
+__int64 n,cnter,ans;
+void dfs(__int64 cur,__int64 cnt,__int64 power,__int64 sub)
+{
+    __int64 i;
+    if(cur>n)
+        return;
+    if(cnt==cnter&&cur<ans)
+        ans=cur;
+    if(cnt>cnter)
+    {
+        ans=cur;
+        cnter=cnt;
+    }
+    __int64 p=prime[sub];
+    for(i=1;i<=power;i++)
+    {
+        if(cur*p>n)
+            break;
+        dfs(cur*p,cnt*(i+1),i,sub+1);
+        p=p*prime[sub];
+    }
+}
+int main()
+{
+    int t,T;
+    scanf("%d",&T);
+    for(t=1;t<=T;t++)
+    {
+        scanf("%I64d",&n);
+        cnter=0,ans=0;
+        dfs(1,1,50,0);
+        printf("Case #%d: %I64d\n",t,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4134_autoAC.cpp b/HDOJ/4134_autoAC.cpp
new file mode 100644
index 0000000..57458c7
--- /dev/null
+++ b/HDOJ/4134_autoAC.cpp
@@ -0,0 +1,31 @@
+#include<stdio.h> 
+int a[110];
+int main(){
+    int t;
+    scanf("%d",&t);
+    int ca = 1;
+    while(t--){
+        int n;
+        scanf("%d",&n);
+        int i,j;
+        for(i=1;i<=n;i++)scanf("%d",&a[i]);
+        int win = 0;
+        i = 1,j = n;
+        while(1){
+            if(j-i+1==2){
+                if(a[1]>a[2])win = 1;
+                else win = 2;
+                break;
+            }
+            int ii = i,jj = j;
+            while(ii<=jj){
+                a[ii++] += a[jj--];
+            }
+            i = 1,j = (j+1)/2;
+        }
+        printf("Case #%d: ",ca++);
+        if(win==1)puts("Alice");
+        else if(win==2)puts("Bob");
+    }
+    return 0;
+}
diff --git a/HDOJ/4135_autoAC.cpp b/HDOJ/4135_autoAC.cpp
new file mode 100644
index 0000000..ebca124
--- /dev/null
+++ b/HDOJ/4135_autoAC.cpp
@@ -0,0 +1,43 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<vector>
+using namespace std;
+long long a,b,n;
+vector<long long> vt;
+long long solve(long long x,long long n){
+    vt.clear();
+    long long i,j;
+    for(i=2;i*i<=n;i++)     
+        if(n%i==0){
+            vt.push_back(i);
+            while(n%i==0)
+                n/=i;
+        }
+    if(n>1)
+        vt.push_back(n);
+    long long sum=0,val,cnt;
+    for(i=1;i<(1<<vt.size());i++){  
+        val=1;
+        cnt=0;
+        for(j=0;j<vt.size();j++)
+            if(i&(1<<j)){       
+                val*=vt[j];
+                cnt++;
+            }
+        if(cnt&1)     
+            sum+=x/val;
+        else
+            sum-=x/val;
+    }
+    return x-sum;
+}
+int main(){
+    int t,cases=0;
+    scanf("%d",&t);
+    while(t--){
+        cin>>a>>b>>n;
+        cout<<"Case #"<<++cases<<": "<<solve(b,n)-solve(a-1,n)<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4136_autoAC.cpp b/HDOJ/4136_autoAC.cpp
new file mode 100644
index 0000000..bb265e4
--- /dev/null
+++ b/HDOJ/4136_autoAC.cpp
@@ -0,0 +1,59 @@
+#include<algorithm>
+#include<stdlib.h>
+#include<iostream>
+#include<string.h>
+#include<stdio.h>
+using namespace std;
+#define eps 1e-10
+#define N 100015
+#define db double
+db ans,p1,p2,win1,win2,win_num[2][2][2],dp[2][2][2];
+int sign(db x){
+    return (x > eps) - (x < -eps);
+}
+void dfs(int pl1,db p,int pl2,int v,int s){
+    if((pl1 == 6&&pl2 <= 4)||pl1 == 7){
+        win_num[s][0][v] += p*(pl1+pl2)*5.;
+        dp[s][0][v] += p;
+        return ;
+    }
+    if((pl2 == 6&&pl1 <= 4)||pl2 == 7){
+        win_num[s][1][v] += p*(pl1+pl2)*5.;
+        dp[s][1][v] += p;
+        return ;
+    }
+    if(v) dfs(pl1,p*p2,pl2+1,v^1,s),dfs(pl1+1,p*(1.-p2),pl2,v^1,s);
+    else dfs(pl1+1,p*p1,pl2,v^1,s),dfs(pl1,p*(1.-p1),pl2+1,v^1,s);
+}
+void dfs2(int l1,int l2,db pl1,db p,db pl2,int v){
+    if(l1 == 3||l2 == 3){
+        ans += p*(pl1+pl2);
+        return ;
+    }
+    dfs2(l1+1,l2,pl1+win_num[v][0][0],dp[v][0][0]*p,pl2,0);
+    dfs2(l1+1,l2,pl1+win_num[v][0][1],dp[v][0][1]*p,pl2,1);
+    dfs2(l1,l2+1,pl1,dp[v][1][0]*p,pl2+win_num[v][1][0],0);
+    dfs2(l1,l2+1,pl1,dp[v][1][1]*p,pl2+win_num[v][1][1],1);
+}
+char s[256];
+int main()
+{
+    int T,cas = 1;
+    int i,j,k;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%s%s%lf",&s,&s,&p1);
+        scanf("%s%s%lf",&s,&s,&p2);
+        p1 /= 100.;
+        p2 /= 100.;
+        ans = 0.;
+        for(i = 0; i < 2; i ++) for(j = 0; j < 2; j ++) for(k = 0; k < 2; k ++) win_num[i][j][k] = dp[i][j][k] = 0.;
+        dfs(0,1.,0,0,0);
+        dfs(0,1.,0,1,1);
+        for(i = 0; i < 2; i ++) for(j = 0; j < 2; j ++) for(k = 0; k < 2; k ++) if(sign(dp[i][j][k])) win_num[i][j][k] /= dp[i][j][k];
+        dfs2(0,0,0.,1.,0.,0);
+        printf("Case #%d: %.6lf\n",cas++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4137_autoAC.cpp b/HDOJ/4137_autoAC.cpp
new file mode 100644
index 0000000..cacf64a
--- /dev/null
+++ b/HDOJ/4137_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<stdio.h> 
+#include<math.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+struct node{
+    int id;
+    int v;
+}p[33];
+bool cmp(node a,node b){
+    return a.v<b.v;
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    int ca=1;
+    while(t--){
+        int n;
+        scanf("%d",&n);
+        int i;
+        int ans = 0;
+        for(i=1;i<=n;i++){
+            scanf("%d",&p[i].v);
+            p[i].id = i;
+        }
+        sort(p+1,p+1+n,cmp);
+        for(i=1;i<=n;i++){
+            ans += abs(p[i].id-i);
+        }
+        printf("Case #%d: %d\n",ca++,ans/2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4138_autoAC.cpp b/HDOJ/4138_autoAC.cpp
new file mode 100644
index 0000000..c6d57e1
--- /dev/null
+++ b/HDOJ/4138_autoAC.cpp
@@ -0,0 +1,74 @@
+#include<cstdio>
+#include<cstring>
+using namespace std;
+__int64 dp[100][30][30];
+int ans[100];
+int main(){
+    memset(dp,0,sizeof(dp));
+    dp[0][1][0]=1;
+    for(int i=2;i<=75;i++){
+        for(int j=1;j<=27;j++){
+            for(int k=0;k<=20;k++){
+                __int64 val=0;
+                if(j==1){
+                    if(k==0) continue;
+                    for(int jj=2;jj<=27;jj++){
+                        if(i>=j) val+=dp[i-j][jj][k-1];
+                    }
+                }else{
+                    for(int jj=1;jj<=27;jj++){
+                        if(i>=j) val+=dp[i-j][jj][k];
+                    }
+                }
+                dp[i][j][k]=val;
+            }
+        }
+    }
+    int t,cas=0;
+    scanf("%d",&t);
+    while(t--){
+        int V,W;
+        __int64 I;
+        scanf("%d%d%I64d",&V,&W,&I);
+        printf("Case #%d: ",++cas);
+        W-=1;
+        I-=1;
+        ans[0]=-1;
+        for(int i=2;i<=27;i++){
+            if(I>=dp[V][i][W]){
+                I-=dp[V][i][W];
+            }else{
+                V-=i;
+                ans[0]=i;
+                break;
+            }
+        }
+        if(ans[0]==-1){
+            puts("Corrupted!");
+            continue;
+        }
+        int cnt=1;
+        bool flag=false;
+        while(true){
+            for(int i=1;i<=27;i++){
+                if(flag&&(i==1)) continue;
+                if((W==0)&&(i==1)) continue;
+                flag=false;
+                if(I>=dp[V][i][W]){
+                    I-=dp[V][i][W];
+                }else{
+                    V-=i;
+                    if(i==1){W-=1;flag=true;}
+                    ans[cnt++]=i;
+                    break;
+                }
+            }
+            if(V==0) break;
+        }
+        for(int i=0;i<cnt;i++){
+            if(ans[i]==1) putchar(' ');
+            else putchar(ans[i]-2+'a');
+        }
+        puts("");
+    }
+}
diff --git a/HDOJ/4139_autoAC.cpp b/HDOJ/4139_autoAC.cpp
new file mode 100644
index 0000000..c5f9d77
--- /dev/null
+++ b/HDOJ/4139_autoAC.cpp
@@ -0,0 +1,60 @@
+#include<stdio.h> 
+#include<math.h>
+#include<string.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+#define N 1000005
+#define LL long long
+int max(int a,int b){return a>b?a:b;}
+LL cnt[N];
+void gao(int n,int p){
+    int i;
+    int a=1;
+    for(i=2;i*i<=n;i+=a,a=2){
+        if(n%i==0){
+            while(n%i==0){
+                cnt[i] += p;
+                n/=i;
+            }
+        }
+    }
+    if(n>1)cnt[n] += p;
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    int ca=1;
+    while(t--){
+        int n,m;
+        scanf("%d%d",&n,&m);
+        int i,j;
+        int a,b;
+        memset(cnt,0,sizeof(cnt));
+        int maxm = 0;
+        for(i=0;i<n;i++){
+            scanf("%d",&a);
+            maxm = max(a,maxm);
+            gao(a,1);
+        }
+        for(j=0;j<m;j++){
+            scanf("%d",&b);
+            maxm = max(b,maxm);
+            gao(b,-1);
+        }
+        int x = 1,y = 1;
+        for(i=2;i<=maxm;i++){
+            if(cnt[i] > 0){
+                while(cnt[i]--){
+                    x *= i;
+                }
+            } else if(cnt[i]<0){
+                while(cnt[i]++){
+                    y *= i;
+                }
+            }
+        }
+        printf("Case #%d: %d / %d\n",ca++,x,y);
+    }
+    return 0;
+}
diff --git a/HDOJ/4140_autoAC.cpp b/HDOJ/4140_autoAC.cpp
new file mode 100644
index 0000000..00cd96e
--- /dev/null
+++ b/HDOJ/4140_autoAC.cpp
@@ -0,0 +1,80 @@
+#include <stdio.h>
+#include <string.h>
+#define N 1000000
+char str[N];
+int x;
+int pow(int a,int b)
+{
+    int res =  1;
+    while(b--)
+        res *= a;
+    return res;
+}
+int solve()
+{
+    int res = 0,add = 0,flag = 1,c,e;
+    int i = 0,j = 0;
+    int len = strlen(str);
+    for(--len; str[len]!='+' && str[len] != '-' && len >= 0; --len);
+    if(str[0] == '-')
+    {
+        flag = -1;
+        i = 1;
+    }
+    for(;i < len; ++i)
+    {
+        c = 0;
+        for(j = i; str[j] != 'X'; ++j)
+            c = c*10 + str[j] - '0';
+        if(i == j)
+            c = 1;
+        ++j;
+        if(str[j] == '^')
+        {
+            e = 0;
+            for(++j;str[j] != '+' && str[j] !='-';++j)
+                e = e * 10 + str[j] - '0';
+        }
+        else
+            e = 1;
+        res += c* flag*pow(x,e);
+        if(str[j] == '+')
+            flag = 1;
+        else
+            flag = -1;
+        i = j;
+    }
+    c = 0;
+    for(j = i;str[j] && str[j] != 'X'; ++j)
+        c = c * 10 + str[j] - '0';
+    if(!str[j])
+        res += c * flag;
+    else
+    {
+        if(i == j)
+            c = 1;
+        ++j;
+        if(!str[j])
+            res += c * x * flag;
+        else
+        {
+            ++ j;
+            e = 0;
+            for(;str[j];++j)
+                e = e * 10 + str[j] - '0';
+            res += c * flag * pow(x,e);
+        }
+    }
+    return res;
+}
+int main()
+{
+    int t,sp = 0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%s",&x,str);
+        printf("Case #%d: %d\n",++sp, solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/4141_autoAC.cpp b/HDOJ/4141_autoAC.cpp
new file mode 100644
index 0000000..a49cd8e
--- /dev/null
+++ b/HDOJ/4141_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+using namespace std; 
+#define N 1010
+int vis[N][N],height[N][N];
+int m,n,cnt;
+int mo[][2] = {0,1, 0,-1, 1,0, -1,0};
+bool ok(int x,int y,int c)
+{
+     return x > 0 && x <= m && y > 0 && y <= n && height[x][y] >= c;
+}
+bool boundary(int x,int y)
+{
+     return x == 1 || y == 1 || x == m || y == n;
+}
+void dfs(int x,int y,int c)
+{
+     height[x][y] = 0;
+     if(boundary(x,y))
+         ++cnt;
+     int s,t;
+     for(int i = 0; i < 4; ++i)
+     {
+             s = x + mo[i][0];
+             t = y + mo[i][1];
+             if(ok(s,t,c))
+                 dfs(s,t,height[s][t]);
+     }
+}
+int main()
+{
+    int t,a;
+    int x,y;
+    int sp = 0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int i,j;
+        scanf("%d%d%d%d",&m,&n,&x,&y);
+        for( i = 1 ; i <= m; ++i)
+             for( j = 1 ; j <= n; ++j)
+                  scanf("%d",&height[i][j]);
+        cnt = 0;
+        dfs(x,y,height[x][y]);
+        printf("Case #%d: %d\n",++sp,cnt);
+    }
+    return 0;
+}
diff --git a/HDOJ/4142_autoAC.cpp b/HDOJ/4142_autoAC.cpp
new file mode 100644
index 0000000..75abe55
--- /dev/null
+++ b/HDOJ/4142_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<iostream>
+#include<string>
+#include<string.h>
+using namespace std;
+int main()
+{    
+    int n, p=1;
+    scanf("%d", &n);
+    while(n--)
+    {
+        int a, b, c;
+        scanf("%d%d%d", &a, &b, &c);
+        if(a > b)
+            swap(a, b);
+        if(b > c)
+            swap(b, c);
+        if(a > b)
+            swap(a, b);
+        printf("Case #%d: ", p++);
+        if(a+b <= c)
+            printf("invalid!\n");
+        else if(a==b && b==c)
+            printf("equilateral\n");
+        else if(a==b || b==c)
+            printf("isosceles\n");
+        else
+            printf("scalene\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4143_autoAC.cpp b/HDOJ/4143_autoAC.cpp
new file mode 100644
index 0000000..6a8ace0
--- /dev/null
+++ b/HDOJ/4143_autoAC.cpp
@@ -0,0 +1,27 @@
+#include"stdio.h"
+#include"math.h"
+int main()
+{
+    int i;
+    int t;
+    int n;
+    int x;
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        x=-1;
+        t=(int)sqrt(n);
+        for(i=t;i>0;i--)
+        {
+            if(n%i==0&&(n/i-i)%2==0&&(n/i-i)/2>0)
+            {
+                x=(n/i-i)/2;
+                break;
+            }
+        }
+        printf("%d\n",x);
+    }
+    return 0;
+}
diff --git a/HDOJ/4144_autoAC.cpp b/HDOJ/4144_autoAC.cpp
new file mode 100644
index 0000000..13fb148
--- /dev/null
+++ b/HDOJ/4144_autoAC.cpp
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <string.h>
+int num(char c)
+{
+    if(c>='A' && c<='Z')
+    return 0;
+    else return 1;
+}
+int main()
+{
+    int n,i,k;
+    char a[10005];
+    while(~scanf("%d%s",&n,a))
+    {
+        for(i = 0;i<n;i+=5)
+        {
+            k = 0;
+            if(num(a[i]))
+            k+=16;
+            if(num(a[i+1]))
+            k+=8;
+            if(num(a[i+2]))
+            k+=4;
+            if(num(a[i+3]))
+            k+=2;
+            if(num(a[i+4]))
+            k++;
+            printf("%c",k+'A');
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4145_autoAC.cpp b/HDOJ/4145_autoAC.cpp
new file mode 100644
index 0000000..7219090
--- /dev/null
+++ b/HDOJ/4145_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define N 100010
+struct enemy
+{
+    int x, y, da, db;
+}p[N], c1, c2;
+bool cmp(enemy a, enemy b)
+{
+    return a.da < b.da;
+}
+int dist(enemy a, enemy b)
+{
+    return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
+}
+int main()
+{
+    int ncase;
+    int num;
+    int ans, res, onlyb;
+    scanf("%d", &ncase);
+    while(ncase--)
+    {
+        scanf("%d%d%d%d", &c1.x, &c1.y, &c2.x, &c2.y);
+        scanf("%d", &num);
+        for(int i = 0; i < num; ++i)
+        {
+            scanf("%d%d", &p[i].x, &p[i].y);
+            p[i].da = dist(c1, p[i]);
+            p[i].db = dist(c2, p[i]);
+        }
+        sort(p, p + num, cmp);
+        res = p[num - 1].da; 
+        ans = 0;
+        for(int i = num - 2; i >= 0; --i)
+        {
+            ans = max(ans, p[i + 1].db);
+            res = min(res, ans + p[i].da);
+        }
+        ans = max(ans, p[0].db);
+        res = min(res, ans); 
+        printf("%d\n", res);
+    }
+    return 0;
+}
diff --git a/HDOJ/4146_autoAC.cpp b/HDOJ/4146_autoAC.cpp
new file mode 100644
index 0000000..317c8f3
--- /dev/null
+++ b/HDOJ/4146_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    int s,n,m,x,y,i,j,count,sum=1;
+    char str[1001][1001];
+    int a[1001],b[1001];
+    scanf("%d",&s);
+    while(s--)
+    {
+        memset(a,0,sizeof(a));
+        memset(b,0,sizeof(b));
+        count=0;
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+        {
+            scanf("%s",str[i]);
+        }
+        scanf("%d",&m);
+        for(i=0;i<m;i++)
+        {
+            scanf("%d %d",&x,&y);
+            x--,y--;
+            a[x]=1-a[x];
+            b[y]=1-b[y];
+        }
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                if(a[i]+b[j]==1)
+                {
+                    if(str[i][j]=='b') count++;
+                }
+                else
+                {
+                    if(str[i][j]=='w') count++;
+                }
+            }
+        }
+        printf("Case #%d: %d\n",sum++,count);
+    }
+    return 0;
+}
diff --git a/HDOJ/4147_autoAC.cpp b/HDOJ/4147_autoAC.cpp
new file mode 100644
index 0000000..6307e25
--- /dev/null
+++ b/HDOJ/4147_autoAC.cpp
@@ -0,0 +1,35 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    char str[10001];
+    int s,b,d,f,F,i,j,len,sum,min;
+    while(scanf("%d %d %d %d %d",&s,&b,&d,&f,&F)!=EOF)
+    {
+        min=99999;
+        for(j=1;j<=s;j++)
+        {
+            sum=0;
+            scanf("%s",str);
+            len=strlen(str);
+            for(i=0;i<=len-1;i++)
+            {
+                if(str[i]=='A')
+                {
+                    sum=sum+b+d+f;
+                }
+                if(str[i]=='B')
+                {
+                    sum=sum+2*b+2*d+F;
+                }
+                if(str[i]=='C')
+                {
+                    sum=sum+3*b+3*d+2*F;
+                }
+            }
+            if(min>sum) {min=sum;}
+        }
+        printf("%d\n",min);
+    }
+    return 0;
+}
diff --git a/HDOJ/4148_autoAC.cpp b/HDOJ/4148_autoAC.cpp
new file mode 100644
index 0000000..5f56c04
--- /dev/null
+++ b/HDOJ/4148_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+using namespace std;
+char s[31][10000];
+int main()
+{
+    int n,i,j,len;
+    s[1][0]='1';
+    s[1][2]='\0';
+    for(i=2;i<31;i++)
+    {
+        len=strlen(s[i-1]);
+        int sum=1,k=0;
+        for(j=0;j<len;j++)
+           if(s[i-1][j+1]==s[i-1][j]) sum++;
+           else
+           {
+               s[i][k]=sum+'0';
+               k++;
+               s[i][k]=s[i-1][j];
+               k++;
+               sum=1;
+           }
+           s[i][k]='\0';
+    }
+    while(cin>>n&&n)
+    {
+        len=strlen(s[n]);
+        cout<<len<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4149_autoAC.cpp b/HDOJ/4149_autoAC.cpp
new file mode 100644
index 0000000..30bdc9a
--- /dev/null
+++ b/HDOJ/4149_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <iostream>
+using namespace std;
+int x[10];
+int main()
+{
+    int m, p;
+    int i;
+    int t;
+    scanf("%d", &t);
+    while(t--)
+    {
+        for (i=1; i<=9; i++) scanf("%d", &x[i]);
+        m = 0;
+        p = 0;
+        int k=0;
+        while(1)
+        {
+            for (i=1; i<=8; i++)
+            {
+                if (x[i]!=0) break;
+            }
+            p >>= 1;
+            if (i>8 && p==0 && x[9]==0) break;
+            int ct = 0;
+            for (i=1; i<=8; i++)
+            {
+                if (x[i]&1) ct++;
+            }
+            int y = (ct&1);
+            int z = ((x[9]&1)+(p&1))&1;
+            int tm = y^z;
+            if (tm)
+            {
+                p += (8-ct);
+            }
+            else
+            {
+                p += ct;
+            }
+            m += (tm<<k);
+            k++;
+            for (i=1; i<=9; i++) x[i]>>=1;
+        }
+        printf("%d\n", m);
+    }
+    return 0;
+}
diff --git a/HDOJ/4150_autoAC.cpp b/HDOJ/4150_autoAC.cpp
new file mode 100644
index 0000000..6a4daed
--- /dev/null
+++ b/HDOJ/4150_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    char a[1000001],b[100001];
+    int s,i,j,p,count,len1,len2;
+    scanf("%d",&s);
+    while(s--)
+    {
+        count=0;
+        scanf("%s %s",a,b);
+        len1=strlen(a);
+        len2=strlen(b);
+        for(i=0;i<=len1-1;i++)
+        {
+            p=i;
+            for(j=0;j<=len2-1;j++)
+            {
+                if(a[p]==b[j]) {p++;}
+                else
+                    break;
+            }
+            if(j==len2)
+            {
+                count++;
+                i=i+len2-1;
+            }
+        }
+        printf("%d\n",count);
+    }
+    return 0;
+}
diff --git a/HDOJ/4151_autoAC.cpp b/HDOJ/4151_autoAC.cpp
new file mode 100644
index 0000000..827206f
--- /dev/null
+++ b/HDOJ/4151_autoAC.cpp
@@ -0,0 +1,53 @@
+#include"stdio.h"
+int main()
+{
+    int n;
+    int t1[10];
+    int ans;
+    int i,j;
+    int a,b,t;
+    int num[10],k;
+    int hash[10];
+    int fac[10];
+    fac[0]=1;
+    for(i=1;i<10;i++)    fac[i]=fac[i-1]*i;
+    t1[0]=1;
+    for(i=1;i<10;i++)    t1[i]=9*fac[9]/fac[9-(i-1)];
+    while(scanf("%d",&n)!=-1)
+    {
+        if(n<=0)    {printf("0\n");continue;}
+        if(n<10)    {printf("%d\n",n-1);continue;}
+        k=0;
+        while(n)
+        {
+            num[k++]=n%10;
+            n/=10;
+        }
+        a=0;
+        b=k-1;
+        while(a<b)
+        {
+            t=num[a];
+            num[a]=num[b];
+            num[b]=t;
+            a++;
+            b--;
+        }
+        ans=0;
+        for(i=0;i<10;i++)    hash[i]=1;
+        for(i=1;i<k;i++)    ans+=t1[i];
+        ans+=(num[0]-1)*fac[9]/fac[10-k];
+        hash[num[0]]=0;
+        for(i=1;i<k;i++)
+        {
+            for(j=0;j<num[i];j++)
+            {
+                if(hash[j])    ans+=fac[9-i]/fac[10-k];
+            }
+            if(hash[num[i]]==0)    break;
+            hash[num[i]]=0;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4152_autoAC.cpp b/HDOJ/4152_autoAC.cpp
new file mode 100644
index 0000000..489bc39
--- /dev/null
+++ b/HDOJ/4152_autoAC.cpp
@@ -0,0 +1,53 @@
+# include <cstdio>
+# include <cstring>
+int d[20]= {1},a[22][22],c[22],fn[22],n,m;
+int yes()
+{
+    for (int i(1); i<=n; i++)
+    {
+        if (c[i]<fn[i]) return 0;
+    }
+    return 1;
+}
+int main()
+{
+    for (int i(1); i<=18; i++) d[i]=d[i-1]*2;
+    while (scanf("%d",&n)!=EOF)
+    {
+        for (int i(1); i<=n; i++) scanf("%d",&fn[i]);
+        scanf("%d",&m);
+        for (int i(1); i<=m; i++)
+        {
+            for (int j(1); j<=n; j++)
+            {
+                scanf("%d",&a[i][j]);
+            }
+        }
+        int ans=0,ansi=0;
+        for (int i(d[m+1]-1); i>=0; i--)
+        {
+            memset(c,0,sizeof(c));
+            int num = 0;
+            for (int j(1); j<=m; j++)
+            {
+                if (i&d[j-1])
+                {
+                    num++;
+                    for (int k(1); k<=n; k++) c[k] += a[j][k];
+                }
+            }
+            if (yes() && num >= ans)
+            {
+                ans = num;
+                ansi = i;
+            }
+        }
+        printf("%d",ans);
+        for (int i(0); i<m; i++)
+        {
+            if (ansi & d[i]) printf(" %d",i+1);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4153_autoAC.cpp b/HDOJ/4153_autoAC.cpp
new file mode 100644
index 0000000..fe756fd
--- /dev/null
+++ b/HDOJ/4153_autoAC.cpp
@@ -0,0 +1,38 @@
+#include"stdio.h"
+#include"string.h"
+int main()
+{
+    int n,m;
+    int i;
+    int a[101];
+    int mark[101];
+    int s1,s2;
+    int max;
+    while(scanf("%d%d",&n,&m)!=-1,n||m)
+    {
+        memset(mark,0,sizeof(mark));
+        max=0;
+        for(i=0;i<n;i++)
+        {
+            scanf("%d",&a[i]);
+            mark[a[i]/m]++;
+            if(max<a[i])max=a[i];
+        }
+        s2=max/m;
+        max=0;
+        for(i=0;i<=s2;i++)
+        {
+            if(mark[i]>max)
+                max=mark[i];
+        }
+        s1=max;
+        double ans;
+        ans=0.01;
+        for(i=0;i<=s2;i++)
+        {
+            ans+=(i*1.0/s2)*(mark[s2-i]*1.0/s1);
+        }
+        printf("%.6f\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4154_autoAC.cpp b/HDOJ/4154_autoAC.cpp
new file mode 100644
index 0000000..32ab355
--- /dev/null
+++ b/HDOJ/4154_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<stdio.h>
+#include<stdlib.h>
+int f[1450]={0};
+int main()
+{
+    int cmp(const void *a,const void *b);
+    int t,i,max,p;
+    while(scanf("%d",&t),t!=0)
+    {
+        max=0;
+        p=0;
+        for(i=0;i<t;i++)
+        {
+            scanf("%d",&f[i]);
+        }
+        qsort(f,t,sizeof(int),cmp);
+        f[i]=1422;
+        if((f[i]-f[i-1])>100)
+        {
+            printf("IMPOSSIBLE\n");
+            p=1;
+        }
+        else
+        {
+            for(i=1;i<t;i++)
+            {
+                if((f[i]-f[i-1])>max)
+                {
+                    max=f[i]-f[i-1];
+                    if(max>200)
+                    {
+                        p=1;
+                        break;
+                    }
+                }
+            }
+            if(p==0)
+            {
+                printf("POSSIBLE\n");
+            }
+            else
+            {
+                printf("IMPOSSIBLE\n");
+            }
+        }
+    }
+    return 0;
+}
+int cmp(const void *a,const void *b)
+{
+    return *(int *)a-* (int*)b;
+}
diff --git a/HDOJ/4155_autoAC.cpp b/HDOJ/4155_autoAC.cpp
new file mode 100644
index 0000000..1e4088e
--- /dev/null
+++ b/HDOJ/4155_autoAC.cpp
@@ -0,0 +1,50 @@
+#include<stdio.h>
+#include<string.h>
+#define MAXD 16000
+int sg[MAXD], h[7];
+char b[30];
+int dfs(int st)
+{
+    if(sg[st] != -1)
+        return sg[st];
+    int i, j, k, s[10], sum = 0;
+    memset(s, 0, sizeof(s));
+    for(i = 1; i <= 6; i ++)
+        sum += h[i] * i;
+    for(i = 1; i <= 6; i ++)
+        if(h[i] < 4 && i + sum <= 31)
+        {
+            ++ h[i];
+            for(j = 1, k = 0; j <= 6; j ++)
+                k = k * 5 + h[j];
+            s[dfs(k)] = 1;
+            -- h[i];
+        }
+    for(i = 0; s[i]; i ++);
+    return sg[st] = i;
+}
+void solve()
+{
+    int i, j, k, turn;
+    memset(h, 0, sizeof(h));
+    for(i = 0; b[i]; i ++)
+        ++ h[b[i] - '0'];
+    turn = i % 2;
+    for(i = 1, j = 0; i <= 6; i ++)
+        j = j * 5 + h[i];
+    k = dfs(j);
+    printf("%s ", b);
+    if(turn == 0)
+        printf("%s\n", k == 0 ? "B" : "A");
+    else
+        printf("%s\n", k == 0 ? "A" : "B");
+}
+int main()
+{
+    memset(sg, -1, sizeof(sg));
+    while(scanf("%s", b) == 1)
+    {
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4156_autoAC.cpp b/HDOJ/4156_autoAC.cpp
new file mode 100644
index 0000000..5400fc8
--- /dev/null
+++ b/HDOJ/4156_autoAC.cpp
@@ -0,0 +1,8 @@
+#include <cstdio>
+int main(){
+    for(int a,b,c,t;scanf("%d%d%d",&a,&b,&c)&&(a||b||c);){
+        if(a<b)t=a,a=b,b=t;
+        if(a<c)t=a,a=c,c=t;
+        printf("%s\n",(a+b>c)&&(a+c>b)&&(b+c>a)&&a*a==b*b+c*c?"right":"wrong");
+    }
+}
diff --git a/HDOJ/4158_autoAC.cpp b/HDOJ/4158_autoAC.cpp
new file mode 100644
index 0000000..36c7b43
--- /dev/null
+++ b/HDOJ/4158_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <cstring>
+#include <queue>
+#include <iostream>
+using namespace std;
+int map[21][21];
+bool vis[21][21];
+int dx[4]= {1,-1,0,0};
+int dy[4]= {0,0,-1,1};
+int cb,cw,n;
+struct point
+{
+    int x,y;
+}p,t;
+void bfs(int x,int y)
+{
+    p.x=x,p.y=y;
+    queue <point> q;
+    q.push(p);
+    int num=0;
+    vis[p.x][p.y]=true;
+    int r2=-1,r3=-1;
+    while(!q.empty())
+    {
+        t=q.front();
+        num++;
+        q.pop();
+        for(int i=0; i<4; i++)
+        {
+            p.x=t.x+dx[i];
+            p.y=t.y+dy[i];
+            if(vis[p.x][p.y]) continue;
+            if(p.x<1||p.x>n||p.y<1||p.y>n) continue;
+            if(map[p.x][p.y]==1) r2=1;
+            else if(map[p.x][p.y]==2) r3=1;
+            else q.push(p),vis[p.x][p.y]=true;
+        }
+    }
+    if(r2==1&&r3==1) return ;
+    if(r3==-1) cb+=num;
+    else if(r2==-1) cw+=num;
+    return ;
+}
+int main()
+{
+    int b,w,x,y;
+    while(scanf("%d",&n)==1&&n)
+    {
+        memset(map,0,sizeof(map));
+        memset(vis,false,sizeof(vis));
+        cb=cw=0;
+        scanf("%d%d",&b,&w);
+        for(int i=0; i<b; i++)
+            scanf("%d%d",&x,&y),map[x][y]=1;
+        for(int i=0; i<w; i++)
+            scanf("%d%d",&x,&y),map[x][y]=2;
+        for(int i=1; i<=n; i++)
+            for(int j=1; j<=n; j++)
+                if(!map[i][j]&&!vis[i][j]) bfs(i,j);
+        if(cb==cw) printf("Draw\n");
+        else if(cb>cw) printf("Black wins by %d\n",cb-cw);
+        else printf("White wins by %d\n",cw-cb);
+    }
+    return 0;
+}
diff --git a/HDOJ/4159_autoAC.cpp b/HDOJ/4159_autoAC.cpp
new file mode 100644
index 0000000..f4ee566
--- /dev/null
+++ b/HDOJ/4159_autoAC.cpp
@@ -0,0 +1,40 @@
+#include"stdio.h"
+#include"math.h"
+double jie(int n)
+{
+    double y=1;
+    int i;
+    for(i=2;i<=n;i++)
+        y*=i;
+    return y;
+}
+double c(int n,int x)
+{
+    double z;
+    z=jie(n)/jie(x)/jie(n-x);
+    return z;
+}
+int main()
+{
+    double ans;
+    int n;
+    int s;
+    double x,y;
+    int i;
+    while(scanf("%d%d",&n,&s)!=-1)
+    {
+        if(s>n)
+        {
+            printf("100.00000\n");
+            continue;
+        }
+        x=y=0;
+        for(i=0;i<s;i++)
+            x+=c(n,i)*pow(2,n-i);
+        for(i=0;i<=s;i++)
+            y+=c(n,i)*pow(2,n-i);
+        ans=x/y;
+        printf("%0.5lf\n",ans*100);
+    }
+    return 0;
+}
diff --git a/HDOJ/4160_autoAC.cpp b/HDOJ/4160_autoAC.cpp
new file mode 100644
index 0000000..d239e9e
--- /dev/null
+++ b/HDOJ/4160_autoAC.cpp
@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define max 510
+    struct  d
+    {
+        int w,l,h;
+    }doll[max];
+int match[max][max];
+int link[max];
+bool used[max];
+ int n;
+bool  dfs(int u)
+{
+    for(int v=1;v<=n;v++)
+        if(match[u][v]==1&&!used[v])
+        {
+            used[v]=true;
+            if(link[v]==-1||dfs(link[v]))
+            {
+                link[v]=u;
+                return true;
+            }
+        }
+    return false;
+}
+int Xiong()
+{
+    int res=0;
+    memset(link,-1,sizeof(link));
+    for(int i=1;i<=n;i++)
+    {
+        memset(used,false,sizeof(used));
+            if(dfs(i))
+                res++;
+    }
+    return res;
+}
+int main()
+{
+    int i,j;
+    while(scanf("%d",&n)==1&&n)
+    {
+        for(i=1;i<=n;i++)
+            scanf("%d%d%d",&doll[i].w,&doll[i].l,&doll[i].h);
+        memset(match,0,sizeof(match));                     
+         for(i=1;i<=n;i++) 
+             for(j=1;j<=n;j++)
+                 if(doll[i].w>doll[j].w&&doll[i].l>doll[j].l&&doll[i].h>doll[j].h)
+                     match[i][j]=1;
+         printf("%d\n",n-Xiong());        
+    }
+    return 0;
+}
diff --git a/HDOJ/4161_autoAC.cpp b/HDOJ/4161_autoAC.cpp
new file mode 100644
index 0000000..d4639e5
--- /dev/null
+++ b/HDOJ/4161_autoAC.cpp
@@ -0,0 +1,43 @@
+#include <stdio.h>
+int sum=-1;
+int dif(int a[],int n)
+{
+    int i,s=0;
+    bool zero=true;
+    sum++;
+    for(i=0;i<n-1;i++)
+    {    if(a[i]<0)
+            a[i]=0-a[i];
+        if(a[i+1]<0)
+            a[i+1]=0-a[i+1];
+        a[i]=a[i+1]-a[i];
+        if(a[i]!=0)
+            zero=false;
+        s+=a[i];
+    }
+    a[n-1]=s;
+    if(s==0 && zero)
+        return sum;
+    if(sum>1000)
+        return -1;
+    dif(a,n);
+}
+int main()
+{
+    int a[21];
+    int n,temp=1;
+    while(scanf("%d",&n)!=EOF && n)
+    {
+        sum=-1;
+        for(int i=0;i<n;i++)
+            scanf("%d",&a[i]);
+        int num=dif(a,n);
+        printf("Case %d: ",temp);
+        if(num==-1)
+            printf("not attained\n");
+        else
+            printf("%d iterations\n",num);
+        temp++;
+    }
+    return 0;
+}
diff --git a/HDOJ/4162_autoAC.cpp b/HDOJ/4162_autoAC.cpp
new file mode 100644
index 0000000..4c21eba
--- /dev/null
+++ b/HDOJ/4162_autoAC.cpp
@@ -0,0 +1,37 @@
+#include <cstdio>
+#include <cstring>
+using namespace std;
+int b[300100],len;
+char c[300100];
+inline int ca(int x)
+{return x<len?x:x-len;}
+int minp()
+{
+    int i=0,j=1,k=0;
+    while(i<len && j<len && k<len)
+    {
+        int det=b[ca(i+k)]-b[ca(j+k)];
+        if(det==0) k++;
+        else 
+        {
+            if(det>0) i+=k+1; else j+=k+1;
+            if(i==j) j++;
+            k=0;
+        }
+    }
+    return i>j?j:i;
+}
+int main()
+{
+    while(scanf("%s",c)==1)
+    {
+        len=strlen(c);c[len]=c[0];c[len+1]='\0';
+        for(int i=0;i<len;i++)
+        {
+            b[i]=c[i+1]-c[i];
+            if(c[i]>c[i+1]) b[i]+=8;
+        }
+        int k=minp();
+        for(int l=0;l<len;l++) printf("%d",b[ca(k+l)]); puts("");
+    }
+}
diff --git a/HDOJ/4163_autoAC.cpp b/HDOJ/4163_autoAC.cpp
new file mode 100644
index 0000000..f5adc3d
--- /dev/null
+++ b/HDOJ/4163_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+typedef struct
+{
+    int p,d;
+}Data;
+Data dt[1000003];
+bool cmp1(Data d1,Data d2)
+{
+    if(d1.p==d2.p) return d1.d<d2.d;
+    return d1.p<d2.p;
+}
+bool cmp2(Data d1,Data d2)
+{
+    if(d1.p==d2.p) return d1.d>d2.d;
+    return d1.p>d2.p;
+}
+bool cmp3(Data d1,Data d2)
+{
+     return d1.d<d2.d;
+}
+bool cmp4(Data d1,Data d2)
+{
+     return d1.d>d2.d;
+}
+void print()
+{
+    static int cnt=0;
+    printf("Case %d\n",++cnt);
+}
+int main()
+{
+    int n,k1,k2;
+    while(scanf("%d %d %d",&n,&k1,&k2),n&&k1&&k2)
+    {
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d",&dt[i].p);
+            dt[i].d=i+1;
+        }
+        sort(dt,dt+n,cmp1);
+        print();
+        sort(dt,dt+k1,cmp3);
+        printf("%d",dt[0].d);
+        for(int i=1;i<k1;i++)
+        printf(" %d",dt[i].d);
+        printf("\n");
+        sort(dt,dt+n,cmp2);
+        sort(dt,dt+k2,cmp4);
+        printf("%d",dt[0].d);
+        for(int i=1;i<k2;i++)
+        printf(" %d",dt[i].d);
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4164_autoAC.cpp b/HDOJ/4164_autoAC.cpp
new file mode 100644
index 0000000..3e49c48
--- /dev/null
+++ b/HDOJ/4164_autoAC.cpp
@@ -0,0 +1,117 @@
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<set>
+#include<vector>
+#include<queue>
+#include<cstdlib>
+#include<ctime>
+#include<cmath>
+#include<bitset>
+using namespace std;
+#define N 210
+#define inf 50000000
+int dir[8][2] = { { 0, 1 }, { 1, 1 }, { 1, 0 }, { 1, -1 }, { 0, -1 },
+        { -1, -1 }, { -1, 0 }, { -1, 1 } };
+int T = 1, n, m, idx, tot;
+int maz[N][N], done[N * N], ans[N * N];
+char Map[N][N];
+struct position {
+    int x, y;
+} u, v, qu[N * N];
+void bfs(int x, int y) {
+    maz[x][y] = idx;
+    Map[x][y] = '0';
+    u.x = x;
+    u.y = y;
+    int l = 0, r = 1;
+    qu[0] = u;
+    while (l < r) {
+        u = qu[l++];
+        for (int i = 0; i < 8; i++) {
+            v.x = u.x + dir[i][0];
+            v.y = u.y + dir[i][1];
+            if (v.x >= 1 && v.x <= n && v.y >= 1 && v.y <= m
+                    && Map[v.x][v.y] == '1') {
+                maz[v.x][v.y] = idx;
+                Map[v.x][v.y] = '0';
+                qu[r++] = v;
+            }
+        }
+    }
+    if (r < 5)
+        done[idx] = 1;
+}
+void solve(int x, int y) {
+    u.x = x;
+    u.y = y;
+    int i = 1, to = 6;
+    qu[0] = u;
+    for (;;) {
+        int flag = 0;
+        for (int j = to; j != to || !flag; j = (j + 1) % 8) {
+            if (j == to)
+                flag = 1;
+            v.x = u.x + dir[j][0];
+            v.y = u.y + dir[j][1];
+            if (v.x >= 1 && v.x <= n && v.y >= 1 && v.y <= m
+                    && maz[v.x][v.y] == maz[x][y]) {
+                u.x = u.x + dir[(j + 7) % 8][0];
+                u.y = u.y + dir[(j + 7) % 8][1];
+                for (j = 0; j < 8; j++) {
+                    if (v.x + dir[j][0] == u.x && v.y + dir[j][1] == u.y) {
+                        to = j;
+                        break;
+                    }
+                }
+                qu[i++] = v;
+                u = v;
+                if (i >= 4 && qu[0].x == qu[i - 2].x && qu[0].y == qu[i - 2].y
+                        && qu[1].x == qu[i - 1].x && qu[1].y == qu[i - 1].y) {
+                    ans[tot++] = i - 2;
+                    return;
+                }
+                break;
+            }
+        }
+    }
+}
+int main() {
+    while (~scanf("%d%d", &n, &m)) {
+        if (!n && !m)
+            break;
+        for (int i = 1; i <= n; i++)
+            scanf("%s", Map[i] + 1);
+        idx = 0;
+        memset(maz, 0, sizeof(maz));
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (Map[i][j] == '1') {
+                    idx++;
+                    done[idx] = 0;
+                    bfs(i, j);
+                }
+            }
+        }
+        tot = 0;
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (maz[i][j] && !done[maz[i][j]]) {
+                    done[maz[i][j]] = 1;
+                    solve(i, j);
+                }
+            }
+        }
+        printf("Case %d\n", T++);
+        if (tot) {
+            sort(ans, ans + tot);
+            for (int i = 0; i < tot; i++)
+                printf("%d%s", ans[i], (i == tot - 1) ? "\n" : " ");
+        } else
+            printf("no objects found\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4165_autoAC.cpp b/HDOJ/4165_autoAC.cpp
new file mode 100644
index 0000000..397e9c0
--- /dev/null
+++ b/HDOJ/4165_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<cstdio>
+#include<cmath>
+#include<stack>
+#include<cstring>
+#include<string>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+#define clr(x) memset(x,0,sizeof(x))
+long long dp[31][31];
+bool inti(){
+    clr(dp);
+    for(int i=0;i<=30;i++){
+        dp[i][0]=1;
+    }
+    for(int i=1;i<=30;i++){
+        for(int j=1;j<=i;j++){
+            dp[i][j]=dp[i-1][j]+dp[i][j-1];
+        }
+    }
+    return true;
+}
+int main(){
+    inti();
+    int i,j,k,m,n;
+    while(cin>>n&&n){
+        cout<<dp[n][n]<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4166_autoAC.cpp b/HDOJ/4166_autoAC.cpp
new file mode 100644
index 0000000..8ffbf92
--- /dev/null
+++ b/HDOJ/4166_autoAC.cpp
@@ -0,0 +1,95 @@
+#include<stdio.h>
+#include<string.h>
+#include<iostream>
+#include<queue>
+using namespace std;
+const int maxn = 1005;
+const int inf = 1<<29;
+struct nd{
+    int x,y,d,t,id;
+};
+int has[maxn][maxn][4];
+int ans[maxn][maxn][4];
+int vis[maxn][maxn][4];
+int dx[] = {0,-1,0,1};
+int dy[] = {1,0,-1,0};
+char as[maxn][maxn],E[10],dd[128];
+int N,M,m,mn,cnt;
+int si,sj,di,dj;
+bool nok(int x,int y){
+    if(x<0||y<0||x==N||y==M||as[x][y]=='*')return true;
+    return false;
+}
+void bfs(int x,int y,int d)
+{
+    nd k,t;
+    int a,b,c,i;
+    cnt = 0;
+    for(a = 0; a < N; ++ a)
+        for(b = 0; b < M; ++ b)
+            for(c = 0; c < 4; ++ c)
+                has[a][b][c]=inf,ans[a][b][c]=0;
+    has[x][y][d]=0; ans[x][y][d]=1;
+    if(x==di&&y==dj)return;
+    queue<nd>que;
+    t.x=x;t.y=y;t.d=d;t.t=0; t.id = cnt; vis[x][y][d]=cnt++;
+    que.push(t);
+    while(!que.empty()){
+        t = que.front(); que.pop();
+        if(t.id ^ vis[t.x][t.y][t.d])continue;
+        for(i = 0; i < 4; ++ i){
+            k = t; k.t++; k.d = i;
+            k.x += dx[i]; k.y += dy[i];
+            if(nok(k.x,k.y))continue;
+            if(i^t.d)k.t++;
+            if((i+2)%4==t.d)k.t++;
+            if(k.t>has[k.x][k.y][k.d]||k.t>mn)continue;
+            if(k.t==has[k.x][k.y][k.d]){
+                ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
+                if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
+                if((i+2)%4==t.d){
+                    ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
+                    if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
+                }
+            }else{
+                ans[k.x][k.y][k.d]=ans[t.x][t.y][t.d];
+                if((i+2)%4==t.d)ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
+                if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
+            }
+            has[k.x][k.y][k.d] = k.t;
+            if(k.x==di && k.y==dj){
+                if(has[k.x][k.y][k.d]<mn)mn=has[k.x][k.y][k.d];
+                continue;
+            }
+            k.id = cnt; vis[k.x][k.y][k.d] = cnt++;
+            que.push(k);
+        }
+        ans[t.x][t.y][t.d]=0;
+    }
+}
+int main()
+{
+    int cas=0,i,k;
+    dd['E']=0;dd['N']=1;dd['W']=2;dd['S']=3;
+    while(scanf("%d %d %d",&N,&M,&m)!=EOF){
+        if(!m)break;
+        for(i = 0; i < N; ++ i)
+            scanf("%s",as[i]);
+        scanf("%d %d %d %d %s",&si,&sj,&di,&dj,E);
+        mn = inf;
+        bfs(si,sj,dd[E[0]]);
+        k = 0;
+        for(i = 0; i < 4; ++ i){
+            if(has[di][dj][i]<mn){
+                mn = has[di][dj][i];
+                k = ans[di][dj][i];
+            }else if(has[di][dj][i]==mn){
+                k += ans[di][dj][i];
+                if(k >= m)k -= m;
+            }
+        }
+        if(mn==inf)printf("Case %d: %d -1\n",++cas,m);
+        else printf("Case %d: %d %d\n",++cas,m,k);
+    }
+    return 0;
+}
diff --git a/HDOJ/4167_autoAC.cpp b/HDOJ/4167_autoAC.cpp
new file mode 100644
index 0000000..f8568f0
--- /dev/null
+++ b/HDOJ/4167_autoAC.cpp
@@ -0,0 +1,40 @@
+#include<iostream>  
+#include<sstream>  
+#include<algorithm>  
+#include<set>  
+using namespace std;  
+int main()  
+{  
+    cin.sync_with_stdio(false);  
+    int n,maxlen,cas=1;  
+    while(cin>>n>>maxlen)  
+    {  
+        if(n==0&&maxlen==0) break;  
+        cout<<"Case "<<cas++<<endl;  
+        string s,a,b,ss;  
+        set<string>myset;  
+        getline(cin,s);  
+        for(int i=0;i<n;i++)  
+        {  
+            getline(cin,ss);  
+            for(int j=0;j<ss.length();j++)  
+                while(ss[j]==39||ss[j]==45) ss.erase(j,1);  
+            istringstream oss(ss);  
+            oss>>a;while(oss>>b);  
+            s=a[0]+b;  
+            for(int i=0;i<s.length();i++) s[i]=tolower(s[i]);             
+            string add;int id=1;  
+            if(s.length()>maxlen) s.erase(maxlen);  
+            while(myset.find(s+add)!=myset.end())  
+            {  
+                add.clear();  
+                if(id>9) add+=48+id/10;add+=48+id%10;  
+                if(add.length()+s.length()>maxlen)   
+                    s.erase(maxlen-add.length());  
+                id++;  
+            }  
+            myset.insert(s+add);cout<<s+add<<endl;  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4169_autoAC.cpp b/HDOJ/4169_autoAC.cpp
new file mode 100644
index 0000000..f5f8215
--- /dev/null
+++ b/HDOJ/4169_autoAC.cpp
@@ -0,0 +1,63 @@
+#include<algorithm>
+#include<vector>
+#include<iostream>
+using namespace std;
+const int N = 150010;
+vector<int> g[N];
+int n,dp[310],K,w[N];
+void init()
+{
+    for(int i=0;i<=n;i++)
+        g[i].clear();
+}
+int dfs(int u)
+{
+    int size=g[u].size();
+    int t=0;
+    int cur[310];
+    for(int i=1;i<=K;i++)
+        dp[i]=cur[i]=-INT_MAX;
+    cur[0]=dp[0]=0;
+    for(int i=0;i<size;i++)
+    {
+        int v=g[u][i];
+        int now=dfs(v);
+        for(int j=t;j>=0;j--)
+        {
+            for(int k=1;k<=now;k++)
+            {
+                if(k+j>K)
+                    break;
+                cur[k+j]=max(cur[k+j],dp[k]+cur[j]);
+            }
+        }
+            t+=now;
+    }
+    if(size==0) 
+        t++;
+    cur[1]=max(cur[1],w[u]);
+    for(int i=0;i<=K;i++)
+        dp[i]=cur[i];
+    return t;
+}
+int main()
+{
+    int x,root;
+    while(scanf("%d %d",&n,&K)==2)
+    {
+        init();
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d %d",&x,&w[i]);
+            if(x==0)
+                root=i;
+            else 
+                g[x].push_back(i);
+        }
+        dfs(root);
+        if(dp[K]==-INT_MAX)
+            printf("impossible\n");
+        else printf("%d\n",dp[K]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4170_autoAC.cpp b/HDOJ/4170_autoAC.cpp
new file mode 100644
index 0000000..460fca8
--- /dev/null
+++ b/HDOJ/4170_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<stdio.h>
+#include<math.h>
+#include<algorithm>
+#define eps 1e-6
+using namespace std;
+struct point
+{
+    int x,y;
+}a[10],v[10],s;
+double t,ans;
+int N,sv,i,p[10],T[3],js=1;
+double crosstime(double x0,double y0,double v0,double x1,double y1,double vx,double vy)
+{ 
+    double a,b,c,t;
+    a=vx*vx+vy*vy-v0*v0;
+    b=2*(vx*(x1-x0)+vy*(y1-y0));
+    c=(x1-x0)*(x1-x0)+(y1-y0)*(y1-y0);
+    if(a<eps&&a>-eps) return -c/b;
+    if(a<eps) {a=-a;b=-b;c=-c;}
+    return (-b+sqrt(b*b-4*a*c))/(2*a);
+}
+double back(double x0,double y0,double x1,double y1,double sv)
+{
+    return sqrt((x1-x0)*(x1-x0)+(y1-y0)*(y1-y0))/sv;
+}
+void trs(double ans,int T[3])
+{
+    T[0]=(int)ans;
+    ans-=T[0];
+    T[1]=(int)(ans*=60.0);ans-=T[1];
+    T[2]=(int)(ans*60.0+0.9999999);
+    if(T[2]==60) {T[2]=0;T[1]++;}
+    if(T[1]==60) {T[1]=0;T[0]++;}
+}
+int main()
+{
+    while(scanf("%d",&N),N)
+    {
+        for(i=0;i<N;i++) scanf("%d%d%d%d",&a[i].x,&a[i].y,&v[i].x,&v[i].y);
+        scanf("%d%d%d",&s.x,&s.y,&sv);
+        for(i=0;i<=N;i++) p[i]=i;
+        ans=1e9;
+        do
+        {
+            t=crosstime(s.x*1.0,s.y*1.0,sv*1.0,a[p[0]].x,a[p[0]].y,v[p[0]].x,v[p[0]].y)+1.0;
+            for(i=1;i<N;i++)
+                t+=1.0+crosstime(a[p[i-1]].x*1.0+t*v[p[i-1]].x,a[p[i-1]].y*1.0+t*v[p[i-1]].y,sv*1.0,a[p[i]].x*1.0+t*v[p[i]].x,a[p[i]].y*1.0+t*v[p[i]].y,v[p[i]].x*1.0,v[p[i]].y*1.0);
+            t+=back(a[p[N-1]].x*1.0+t*v[p[N-1]].x,a[p[N-1]].y*1.0+t*v[p[N-1]].y,s.x,s.y,sv);
+            if(t<ans) ans=t;
+        }
+        while(next_permutation(p,p+N));
+        trs(ans,T);
+        printf("Case %d: %d hour(s) %d minute(s) %d second(s)\n",js++,T[0],T[1],T[2]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4171_autoAC.cpp b/HDOJ/4171_autoAC.cpp
new file mode 100644
index 0000000..24b5d02
--- /dev/null
+++ b/HDOJ/4171_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <string.h>
+#include <cstdio>
+#include <vector>
+#include <queue>
+using namespace std;
+const int N = 100010;
+__int64 num[N],dis[N],num1 = 0,head[N];
+struct edge
+{
+    int rp,value,next;
+}ee[N];
+void init()
+{
+    num1 = 0;
+    memset(num,0,sizeof(num));
+    memset(dis,0,sizeof(dis));
+    memset(head,-1,sizeof(head));
+}
+void addedge(int x,int y,int v)
+{
+    ee[num1].rp = y;
+    ee[num1].value = v;
+    ee[num1].next = head[x];
+    head[x] = num1++;
+}
+void bfs(int x)
+{
+    queue<int> qq;
+    qq.push(x);
+    while(!qq.empty())
+    {
+        int y = qq.front();
+        qq.pop();
+        for(int i = head[y];i != -1;i = ee[i].next)
+        {
+            int k = ee[i].rp;
+            dis[k] = dis[y] + ee[i].value;
+            qq.push(k);
+        }
+    }
+}
+int main()
+{
+    int n;
+    while(~scanf("%d",&n))
+    {
+        init();
+        for(int i = 0;i <= n;++i)
+        {
+            scanf("%I64d",&num[i]);
+        }
+        int x,y,value;
+        __int64 sum = 0;
+        for(int i = 1;i <= n;++i)
+        {
+            scanf("%d%d%d",&x,&y,&value);
+            addedge(x,y,value);
+            sum += value;
+        }
+        bfs(0);
+        __int64 mmin = 2000000000;
+        __int64 ss = 0;
+        for(int i = 0;i <= n;++i)
+        {
+            ss = (sum - dis[i]) * 2 + num[i] + dis[i];
+             if(ss < mmin)
+            {
+                mmin = ss;
+            }
+        }
+        printf("%I64d\n",mmin);
+    }
+    return 0;
+}
diff --git a/HDOJ/4173_autoAC.cpp b/HDOJ/4173_autoAC.cpp
new file mode 100644
index 0000000..8d3d07e
--- /dev/null
+++ b/HDOJ/4173_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<iostream>
+#include<sstream>
+#include<fstream>
+#include<vector>
+#include<list>
+#include<deque>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<bitset>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cctype>
+#include<cmath>
+#include<ctime>
+#include<iomanip>
+using namespace std;
+const double eps(1e-8);
+typedef long long lint;
+const int maxn = 200 +5;
+pair<double,double>con[maxn];
+int main(){
+    int n;
+    while(cin >> n){
+        for(int i = 1 ; i <= n ; i++) scanf("%lf%lf",&con[i].first,&con[i].second);
+        int ans = 0;
+        for(int i = 1 ; i <= n ; i++){
+            for(int j = 1 ; j <= n ; j++){
+                pair<double,double> t;
+                t.first = (con[i].first + con[j].first) / 2.0;
+                t.second = (con[i].second + con[j].second) / 2.0;
+                int cnt = 0;
+                for(int k = 1 ; k <= n ; k++){
+                    double dis = pow(t.first - con[k].first,2) + pow(t.second - con[k].second,2);
+                    if(dis <= 6.25 + eps) cnt++;
+                }
+                ans = max(ans , cnt);
+            }
+        }
+        cout << ans << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4174_autoAC.cpp b/HDOJ/4174_autoAC.cpp
new file mode 100644
index 0000000..18192e5
--- /dev/null
+++ b/HDOJ/4174_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    int n,len,num[111],flag,k,b,i;
+    char a[111];
+      scanf("%d",&n);
+        while(n--)
+        {
+            flag=0;
+            scanf("%s",a);
+            len=strlen(a);
+            for(i=0;i<len;i++)
+            {
+                if(a[i]=='a'||a[i]=='b'||a[i]=='c'||a[i]=='A'||a[i]=='B'||a[i]=='C')
+                    num[i]=2;
+                else if(a[i]=='d'||a[i]=='e'||a[i]=='f'||a[i]=='D'||a[i]=='E'||a[i]=='F')
+                    num[i]=3;
+                else if(a[i]=='g'||a[i]=='h'||a[i]=='i'||a[i]=='G'||a[i]=='H'||a[i]=='I')
+                    num[i]=4;
+                else if(a[i]=='j'||a[i]=='k'||a[i]=='l'||a[i]=='J'||a[i]=='K'||a[i]=='L')
+                    num[i]=5;
+                else if(a[i]=='m'||a[i]=='n'||a[i]=='o'||a[i]=='M'||a[i]=='N'||a[i]=='O')
+                    num[i]=6;
+                else if(a[i]=='p'||a[i]=='q'||a[i]=='r'||a[i]=='s'||a[i]=='P'||a[i]=='Q'||a[i]=='R'||a[i]=='S')
+                    num[i]=7;
+                else if(a[i]=='t'||a[i]=='u'||a[i]=='v'||a[i]=='T'||a[i]=='U'||a[i]=='V')
+                    num[i]=8;
+                else if(a[i]=='w'||a[i]=='x'||a[i]=='y'||a[i]=='z'||a[i]=='W'||a[i]=='X'||a[i]=='Y'||a[i]=='Z')
+                    num[i]=9;
+            }
+            k=0;
+            b=len-1;
+            while(k<b)
+            {
+                if(num[k]!=num[b])
+                {
+                    flag=1;
+                    break;
+                }
+                else
+                {
+                    k++;
+                    b--;
+                }
+            }
+            if(flag==1)
+            {
+                printf("NO\n");
+            }
+            else
+                printf("YES\n");
+        }
+    return 0;
+}
diff --git a/HDOJ/4175_autoAC.cpp b/HDOJ/4175_autoAC.cpp
new file mode 100644
index 0000000..f907d69
--- /dev/null
+++ b/HDOJ/4175_autoAC.cpp
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <string.h>
+#include <cstdio>
+#include <math.h>
+using namespace std;
+struct point
+{
+    int pos,value;
+}pp[27][1010];
+int dp[27][1010];
+int main()
+{
+    int numcase;
+    scanf("%d",&numcase);
+    for(int k = 1;k <= numcase;++k)
+    {
+        int numl,numc,len,i,j,p;
+        memset(dp,0,sizeof(dp));
+        scanf("%d%d%d",&numl,&numc,&len);
+        for(i = 1;i <= numl;++i)
+        {
+            for(j = 1;j <= numc;++j)
+            {
+                scanf("%d%d",&pp[i][j].pos,&pp[i][j].value);
+            }
+        }
+       int mmin = 200000000;
+       for(i = 1;i <= numl;++i)
+       {
+           for(j = 1;j <= numc;++j)
+           {
+               mmin = 200000000;
+               for(p = 1;p <= numc;++p)
+               {
+                   dp[i][j] = dp[i-1][p] + abs(pp[i][j].pos - pp[i-1][p].pos) + pp[i][j].value;
+                   if(dp[i][j] < mmin)
+                   {
+                       mmin = dp[i][j];
+                   }
+               }
+               dp[i][j] = mmin;
+             }
+       }
+       mmin = 200000000;
+       for( i = 1;i <= numc;++i)
+       {
+           dp[numl][i] = dp[numl][i] + abs(len - pp[numl][i].pos);
+           if(dp[numl][i] < mmin)
+           {
+               mmin = dp[numl][i];
+           }
+       }
+       printf("%d\n",mmin);
+    }
+    return 0;
+}
diff --git a/HDOJ/4176_autoAC.cpp b/HDOJ/4176_autoAC.cpp
new file mode 100644
index 0000000..618ae47
--- /dev/null
+++ b/HDOJ/4176_autoAC.cpp
@@ -0,0 +1,31 @@
+#include <cstdlib>   
+#include <cstdio>  
+#include <cmath>  
+#include <algorithm>  
+#include <string.h>  
+#include <iostream>  
+using namespace std;  
+int main()  
+{  
+    int k;  
+    int n;  
+    cin>>k;  
+    int a[55];  
+    int cas=1;  
+    while(k--)  
+    {  
+        cin>>n;  
+        for(int i=0;i<n;i++)  
+            scanf("%d",&a[i]);  
+        int b,c,d=-1;  
+        sort(a,a+n);  
+        printf("Class %d\n",cas++);  
+        b=a[0],c=a[n-1];  
+        for(int i=1;i<n;i++)  
+        {  
+            d=max(d,a[i]-a[i-1]);  
+        }  
+        printf("Max %d, Min %d, Largest gap %d\n",c,b,d);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4177_autoAC.cpp b/HDOJ/4177_autoAC.cpp
new file mode 100644
index 0000000..804f5a2
--- /dev/null
+++ b/HDOJ/4177_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <stdio.h>
+inline int ab(int x) { return x >= 0 ? x : -x ;}
+int cal(int x,int y,int z,int &k)
+{
+    if(ab(x-y)==ab(y-z)) {
+        k = y; return ab(x-y);
+    }
+    else if(ab(x-z)==ab(y-z)) {
+        k = z; return ab(x-z);
+    }
+    else if(ab(x-y)==ab(z-x)) {
+        k = x; return ab(x-y);
+    }
+    else { k = -1 ; return -1;}
+}
+int tx[8] , ti[8];
+int h[4] , m[4] , re[4];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int re[4] , dis;
+        for(int i=1;i<=3;i++){
+            scanf("%d:%d",&h[i],&m[i]);
+        }
+        for(int i=1;i<=3;i++)
+        {
+            re[i] = h[i]*60+m[i];
+        }
+        int ok = 0;
+        tx[1] = cal(re[1],re[2],re[3],ti[1]);
+        tx[2] = cal(re[1]+720,re[2],re[3],ti[2]);
+        tx[3] = cal(re[1],re[2]+720,re[3],ti[3]);
+        tx[4] = cal(re[1],re[2],re[3]+720,ti[4]);
+        tx[5] = cal(re[1]-720,re[2],re[3],ti[5]);
+        tx[6] = cal(re[1],re[2]-720,re[3],ti[6]);
+        tx[7] = cal(re[1],re[2],re[3]-720,ti[7]);
+        for(int i=1;i<=7;i++)
+        {
+            if(tx[i] > 0) 
+            {
+                ok = 1;
+                if(tx[i] == 4*60) {
+                    printf("Look at the sun\n");
+                    break;
+                }
+                else {
+                    printf("The correct time is %d:%02d\n",
+                        ti[i]/60,ti[i]%60);
+                    break;
+                }
+            }
+        }
+        if(!ok) printf("Look at the sun\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4178_autoAC.cpp b/HDOJ/4178_autoAC.cpp
new file mode 100644
index 0000000..a1699e0
--- /dev/null
+++ b/HDOJ/4178_autoAC.cpp
@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <string.h>
+int main()
+{
+    char inf[50],ans[5];
+    int t,n,cnt,cas = 0,f,i,j,y[5];
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        memset(y,0,sizeof(y));
+        gets(inf);
+        for(j = 0; j < n; ++j)
+        {
+            cnt = f = 0;
+            gets(inf);
+            for(i = 0; inf[i] != ' ' && inf[i]; ++i);
+            for(; inf[i]; ++i){
+                if(inf[i-1] == ' ' && inf[i] == 'y'){
+                    if(cnt == 0)
+                        ++y[1];
+                    else
+                        ++y[2];
+                    ++cnt;
+                    f = 1;
+                }
+                else if(inf[i-1] ==' ' && inf[i] =='n'){
+                    ++cnt;
+                }
+            }
+            if(cnt == 0)
+                ++y[4];
+            else if(!f)
+                ++y[3];
+        }
+        printf("Roll-call: %d\n",++cas);
+        printf("Present: %d out of %d\n",y[1],n);
+        printf("Needs to study at home: %d out of %d\n",y[2],n);
+        printf("Needs remedial work after school: %d out of %d\n",y[3],n);
+        printf("Absent: %d out of %d\n",y[4],n);
+    }
+    return 0;
+}
diff --git a/HDOJ/4179_autoAC.cpp b/HDOJ/4179_autoAC.cpp
new file mode 100644
index 0000000..0176901
--- /dev/null
+++ b/HDOJ/4179_autoAC.cpp
@@ -0,0 +1,88 @@
+#include <cstdio>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+using namespace std;
+const int N = 11111;
+const int M = 55555;
+int eh[2][N], ec[2];
+struct Edge {
+    int id, nx, df;
+    double l;
+    Edge() {}
+    Edge(int id, int nx, int df, double l) : id(id), nx(nx), df(df), l(l) {}
+} edge[2][M << 1];
+inline void init() {
+    memset(eh, -1, sizeof(eh));
+    memset(ec, 0, sizeof(ec));
+}
+inline void addedge(int u, int v, int df, double l, int id) {
+    edge[id][ec[id]] = Edge(v, eh[id][u], df, l);
+    eh[id][u] = ec[id]++;
+}
+int x[N], y[N], z[N];
+template<class T> inline T sqr(T a) { return a * a;}
+int st[M << 1], ed[M << 1];
+inline int getdf(int a, int b) {
+    if (z[a] >= z[b]) return 0;
+    double len = sqrt(sqr((double) x[a] - x[b]) + sqr((double) y[a] - y[b]));
+    return (int) floor(100.0 * (z[b] - z[a]) / len);
+}
+inline double getdis(int a , int b) { return sqrt(sqr((double) x[a] - x[b]) + sqr((double) y[a] - y[b]) + sqr((double) z[a] - z[b]));}
+const double FINF = 1e50;
+double dis[2][N];
+int q[M << 1];
+bool vis[N];
+void spfa(int s, int id) {
+    for (int i = 0; i < N; i++) dis[id][i] = FINF;
+    int qh, qt;
+    qh = qt = 0;
+    dis[id][s] = 0;
+    q[qt++] = s;
+    vis[s] = true;
+    while (qh < qt) {
+        int cur = q[qh++];
+        vis[cur] = false;
+        for (int i = eh[id][cur]; ~i; i = edge[id][i].nx) {
+            if (dis[id][edge[id][i].id] > dis[id][cur] + edge[id][i].l) {
+                dis[id][edge[id][i].id] = dis[id][cur] + edge[id][i].l;
+                if (!vis[edge[id][i].id]) q[qt++] = edge[id][i].id, vis[edge[id][i].id] = true;
+            }
+        }
+    }
+}
+int main() {
+    int n, m;
+    while (~scanf("%d%d", &n, &m) && (n || m)) {
+        for (int i = 1; i <= n; i++) scanf("%d%d%d", &x[i], &y[i], &z[i]);
+        for (int i = 0; i < m; i++) scanf("%d%d", &st[i], &ed[i]);
+        int A, B, D;
+        scanf("%d%d%d", &A, &B, &D);
+        init();
+        for (int i = 0; i < m; i++) {
+            double tmp = getdis(st[i], ed[i]);
+            int df = getdf(st[i], ed[i]);
+            if (df <= D) {
+                addedge(st[i], ed[i], df, tmp, 0);
+                addedge(ed[i], st[i], df, tmp, 1);
+            }
+            df = getdf(ed[i], st[i]);
+            if (df <= D) {
+                addedge(ed[i], st[i], df, tmp, 0);
+                addedge(st[i], ed[i], df, tmp, 1);
+            }
+        }
+        spfa(A, 0);
+        spfa(B, 1);
+        double ans = FINF;
+        for (int i = 1; i <= n; i++) {
+            for (int t = eh[0][i]; ~t; t = edge[0][t].nx) {
+                if (edge[0][t].df == D) ans = min(ans, dis[0][i] + edge[0][t].l + dis[1][edge[0][t].id]);
+            }
+        }
+        if (ans < FINF) printf("%.1f\n", ans);
+        else puts("None");
+    }
+    return 0;
+}
diff --git a/HDOJ/4180_autoAC.cpp b/HDOJ/4180_autoAC.cpp
new file mode 100644
index 0000000..efd5121
--- /dev/null
+++ b/HDOJ/4180_autoAC.cpp
@@ -0,0 +1,50 @@
+#include <stdio.h>
+#define EPS 1e-20
+__int64 exgcd(__int64 a,__int64 b,__int64 &x,__int64 &y)
+{
+    if(b == 0LL)
+    {
+        x = 1LL;
+        y = 0LL;
+        return a;
+    }
+    __int64 d = exgcd(b,a%b,x,y);
+    __int64 t = x;
+    x = y;
+    y = t - a / b * y;
+    return d;
+}
+int main()
+{
+    __int64 t,a,b,x,y,c1,d1,c2,d2,d;
+    scanf("%I64d",&t);
+    while(t--)
+    {
+        scanf("%I64d/%I64d",&a,&b);
+        x = y = 0;
+        d = exgcd(a,b,x,y);
+        if(d != 1)
+        {
+            printf("%I64d/%I64d\n",a/d,b/d);
+            continue;
+        }
+        if(a == 1)
+        {
+            printf("1/%I64d\n",b-1);
+            continue;
+        }
+        while(x < 0)
+            x += b;
+        d1 = x;
+        c1 = (a * d1 - 1LL) / b;
+        while(y < 0)
+            y += a;
+        c2 = y;
+        d2 = (b * c2 - 1LL) / a;
+        if(d1 > d2)
+            printf("%I64d/%I64d\n",c1,d1);
+        else
+            printf("%I64d/%I64d\n",c2,d2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4182_autoAC.cpp b/HDOJ/4182_autoAC.cpp
new file mode 100644
index 0000000..f9e393b
--- /dev/null
+++ b/HDOJ/4182_autoAC.cpp
@@ -0,0 +1,61 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<queue>
+using namespace std ;
+#define maxn 201
+#define INF 10000000
+struct node
+{
+    int e , d ;
+}qe[maxn] ;
+int dp[maxn][maxn] , k ;
+int cmp( node a , node b )
+{
+    return a.d > b.d ;
+}
+bool check( int n , int m )
+{
+    int i , j ;
+    for( i = 0 ; i <= n ;i++ )
+        for( j = 0 ; j <= m ;j++ )
+          dp[i][j] = INF ;
+    dp[0][0] = 0 ;
+    for( i = 1 ; i <= n ;i++ )
+    {
+        dp[i][0] = dp[i-1][0]+qe[i].e ;
+        for( j = 1 ; j <= m && j <= i;j++ )
+        {
+           dp[i][j] = dp[i-1][j]+qe[i].e ;
+           dp[i][j] = min( dp[i][j],dp[i-1][j-1]+j*qe[i].d) ;
+        }
+    }
+    return dp[n][m] <= k ;
+}
+int main()
+{
+    int i , j , n , m ,ans ,case1 = 0 , tot ;
+    while( scanf("%d%d",&n , &k ) != EOF)
+    {
+        if( n == k && k == 0 ) break ;
+        tot = 0 ;
+        for( i = 1 ; i <= n ;i++ ) {
+            scanf("%d%d" , &qe[i].e,&qe[i].d) ;
+            tot += qe[i].e ;
+        }
+        sort(qe+1,qe+1+n,cmp) ;
+        ans = -1 ;
+        if( tot <= k ) ans = 0 ;
+        for( i = n ; i >= 0 ;i-- )
+        {
+            if(check(n,i))
+            {
+                ans = i ;
+                break ;
+            }
+        }
+        if( ans == -1 )printf("%d: Mission Impossible\n",++case1) ;
+        else printf("%d: %d\n",++case1,ans) ;
+    }
+}
diff --git a/HDOJ/4183_autoAC.cpp b/HDOJ/4183_autoAC.cpp
new file mode 100644
index 0000000..838e4e5
--- /dev/null
+++ b/HDOJ/4183_autoAC.cpp
@@ -0,0 +1,152 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <algorithm>
+using namespace std;
+int head[10000], s, t, nv, maxint=99999999, cnt;
+int cur[400], num[400], d[400], q[100000], pre[400];
+struct Node
+{
+    double q;
+    int x, y, r;
+}dian[1000];
+int cmp(Node x, Node y)
+{
+    return x.q<y.q;
+}
+struct node
+{
+    int u, v, cap, next;
+}edge[100000];
+void add(int u, int v, int cap)
+{
+    edge[cnt].v=v;
+    edge[cnt].cap=cap;
+    edge[cnt].next=head[u];
+    head[u]=cnt++;
+    edge[cnt].v=u;
+    edge[cnt].cap=0;
+    edge[cnt].next=head[v];
+    head[v]=cnt++;
+}
+void bfs()
+{
+    memset(num,0,sizeof(num));
+    memset(d,-1,sizeof(d));
+    int f1=0, f2=0, i;
+    q[f1++]=t;
+    d[t]=0;
+    num[0]=1;
+    while(f1>=f2)
+    {
+        int u=q[f2++];
+        for(i=head[u];i!=-1;i=edge[i].next)
+        {
+            int v=edge[i].v;
+            if(d[v]==-1)
+            {
+                d[v]=d[u]+1;
+                num[d[v]]++;
+                q[f1++]=v;
+            }
+        }
+    }
+}
+void isap()
+{
+    memcpy(cur,head,sizeof(cur));
+    bfs();
+    int flow=0, u=pre[s]=s, i;
+    while(d[s]<nv)
+    {
+        if(u==t)
+        {
+            int f=maxint, pos;
+            for(i=s;i!=t;i=edge[cur[i]].v)
+            {
+                if(f>edge[cur[i]].cap)
+                {
+                    f=edge[cur[i]].cap;
+                    pos=i;
+                }
+            }
+            for(i=s;i!=t;i=edge[cur[i]].v)
+            {
+                edge[cur[i]].cap-=f;
+                edge[cur[i]^1].cap+=f;
+            }
+            flow+=f;
+            u=pos;
+        }
+        for(i=cur[u];i!=-1;i=edge[i].next)
+        {
+            if(d[edge[i].v]+1==d[u]&&edge[i].cap)
+            {
+                break;
+            }
+        }
+        if(i!=-1)
+        {
+            cur[u]=i;
+            pre[edge[i].v]=u;
+            u=edge[i].v;
+        }
+        else
+        {
+            if(--num[d[u]]==0) break;
+            int mind=nv;
+            for(i=head[u];i!=-1;i=edge[i].next)
+            {
+                if(mind>d[edge[i].v]&&edge[i].cap)
+                {
+                    cur[u]=i;
+                    mind=d[edge[i].v];
+                }
+            }
+            d[u]=mind+1;
+            num[d[u]]++;
+            u=pre[u];
+        }
+    }
+    if(flow>=2)
+        printf("Game is VALID\n");
+    else
+        printf("Game is NOT VALID\n");
+}
+int main()
+{
+    int i, j, n, x, y, r, T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        memset(head,-1,sizeof(head));
+        cnt=0;
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+        {
+            scanf("%lf%d%d%d",&dian[i].q,&dian[i].x,&dian[i].y,&dian[i].r);
+        }
+        sort(dian,dian+n,cmp);
+        if(dian[0].r+dian[n-1].r*1.0>sqrt((dian[0].x-dian[n-1].x)*(dian[0].x-dian[n-1].x)*1.0+(dian[0].y-dian[n-1].y)*(dian[0].y-dian[n-1].y)*1.0))
+        {
+            printf("Game is VALID\n");
+            continue ;
+        }
+        for(i=0;i<n;i++)
+        {
+            for(j=i+1;j<n;j++)
+            {
+                if(dian[i].r*1.0+dian[j].r>sqrt((dian[i].x-dian[j].x)*(dian[i].x-dian[j].x)+(dian[i].y-dian[j].y)*(dian[i].y-dian[j].y)))
+                {
+                    add(i,j,1);
+                }
+            }
+        }
+        s=0;
+        t=n-1;
+        nv=t+1;
+        isap();
+    }
+    return 0;
+}
diff --git a/HDOJ/4185_autoAC.cpp b/HDOJ/4185_autoAC.cpp
new file mode 100644
index 0000000..df46655
--- /dev/null
+++ b/HDOJ/4185_autoAC.cpp
@@ -0,0 +1,75 @@
+#include<stdio.h>
+#include<vector>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+int map[700][700],p[700][700],vis[700],x[700],y[700],t,n,num,k;
+char s[700][700];
+bool search(int i)
+{
+    int j;
+    for(j=0;j<num;j++)
+    {
+        if(map[i][j]&&!vis[j])
+        {
+            vis[j]=1;
+            if(!y[j]||search(y[j]))
+            {
+                y[j]=i;
+                x[i]=j;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int match()
+{
+    memset(x,0,sizeof(x));
+    memset(y,0,sizeof(y));
+    int ans=0;
+    for(int i=0;i<num;i++)
+    {
+        memset(vis,0,sizeof(vis));
+        if(search(i)) ans++;
+    }
+    return ans/2;
+}
+int main()
+{
+    scanf("%d",&t);
+    k=1;
+    while(t--)
+    {
+        int i,j;
+        num=0;
+        memset(map,0,sizeof(map));
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+        scanf("%s",s[i]);
+        for(i=0;i<n;i++)
+        for(j=0;j<n;j++)
+        if(s[i][j]=='#')
+        p[i][j]=num++;
+        for(i=0;i<n;i++)
+        for(j=0;j<n;j++)
+        {
+            if(s[i][j]=='#')
+            {
+                if(j<n-1&&s[i][j+1]=='#')
+                {
+                    map[p[i][j]][p[i][j+1]]=1;
+                    map[p[i][j+1]][p[i][j]]=1;
+                }
+                if(i<n-1&&s[i+1][j]=='#')
+                {
+                    map[p[i][j]][p[i+1][j]]=1;
+                    map[p[i+1][j]][p[i][j]]=1;
+                }
+            }
+        }
+        int p=match();
+        printf("Case %d: %d\n",k++,p);
+    }
+    return 0;
+}
diff --git a/HDOJ/4187_autoAC.cpp b/HDOJ/4187_autoAC.cpp
new file mode 100644
index 0000000..b44fe81
--- /dev/null
+++ b/HDOJ/4187_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <algorithm>
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <vector>
+#define MOD 100000007
+#define PRIME_SIZE 500005
+#define _int64 long long
+using namespace std;
+int prime[PRIME_SIZE], phi[PRIME_SIZE];
+bool primes[PRIME_SIZE];
+void Euler_primes_phi_mu()
+{
+    phi[1]=1;
+    for (int i=2; i<PRIME_SIZE; i++)
+    {
+        if (primes[i]==0)
+            phi[i]=i-1, prime[++prime[0]]=i;
+        for (int j=1; j<=prime[0] && prime[j]*i<PRIME_SIZE; j++)
+        {
+            primes[prime[j]*i]=true;
+            if (i%prime[j]==0) { phi[i*prime[j]] = phi[i]*prime[j]; break; }
+            phi[i*prime[j]] = phi[i]*(prime[j]-1);
+        }
+    }
+}
+_int64 GCD(_int64 a, _int64 b) { for (_int64 t; a%b; t=a%b, a=b, b=t) ; return b; }
+_int64 pow_mod(_int64 a, _int64 n)
+{
+    _int64 ans=1;
+    for (; n; n>>=1, a=(a*a)%MOD) if (n&1) ans=(ans*a)%MOD;
+    return ans;
+}
+_int64 polay(int n, int base)
+{
+    _int64 ans=0;
+    for (int i=1; i*i<=n; i++)
+        if (n%i==0)
+        {
+            ans=(ans+pow_mod(base, i)*phi[n/i])%MOD;
+            if (i*i!=n)
+                ans=(ans+pow_mod(base, n/i)*phi[i])%MOD;
+        }
+    ans=(ans*pow_mod(n, MOD-2))%MOD;
+    return ans;
+}
+int ne[PRIME_SIZE], N[PRIME_SIZE], d[PRIME_SIZE];
+void Pre_next(int *s, int len)
+{
+    int i, j=0;
+    for (ne[0]=-1, i=2; i<=len; i++)
+    {
+        while (j>-1 && s[i-1]!=s[j]) j=ne[j];
+        ne[i]=++j;
+    }
+}
+int main()
+{
+    Euler_primes_phi_mu();
+    int n, m, i;
+    while (scanf("%d %d", &m, &n), ~m)
+    {
+        for (i=1; i<=n; i++) scanf("%d", &N[i]);
+        sort(N+1, N+n+1); N[n+1]=N[1]+360000;
+        for (i=1; i<=n; i++) d[i-1]=N[i+1]-N[i];
+        Pre_next(d, n);
+        int dif=n-ne[n];
+        _int64 gcd;
+        if (n%dif==0) gcd=GCD(n, dif);
+        else gcd=n;
+        _int64 ans=polay(n/gcd, pow_mod(m, gcd));
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4189_autoAC.cpp b/HDOJ/4189_autoAC.cpp
new file mode 100644
index 0000000..2127a66
--- /dev/null
+++ b/HDOJ/4189_autoAC.cpp
@@ -0,0 +1,139 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define N 100010
+#define M 260010
+typedef long long LL;
+struct node{
+    LL x,y;
+    int id;
+}w[150010];
+LL ty[150010],ans[100010];
+int ny;
+struct Tree{
+    int l,r;
+    LL val;
+}tree[1050010];
+bool cmp1(const node &a,const node &b){
+    if(a.x!=b.x) return a.x<b.x;
+    if(a.y!=b.y) return a.y<b.y;
+    return a.id<b.id;
+}
+bool cmp2(const node &a,const node &b){
+    if(a.x!=b.x) return a.x<b.x;
+    if(a.y!=b.y) return a.y>b.y;
+    return a.id<b.id;
+}
+bool cmp3(const node &a,const node &b){
+    if(a.x!=b.x) return a.x>b.x;
+    if(a.y!=b.y) return a.y<b.y;
+    return a.id<b.id;
+}
+bool cmp4(const node &a,const node &b){
+    if(a.x!=b.x) return a.x>b.x;
+    if(a.y!=b.y) return a.y>b.y;
+    return a.id<b.id;
+}
+int findy(LL y){
+    int l=0,r=ny-1;
+    while(l<=r){
+        int mid=(l+r)>>1;
+        if(ty[mid]<y) l=mid+1;
+        else if(ty[mid]>y) r=mid-1;
+        else return mid+1;
+    }
+}
+void build(int L,int R,int x){
+    tree[x].l=L;
+    tree[x].r=R;
+    tree[x].val=1000000000000;
+    if(L==R) return ;
+    int mid=(L+R)>>1;
+    build(L,mid,x<<1);
+    build(mid+1,R,x<<1|1);
+}
+LL find(int L,int R,int x){
+    if(tree[x].l>=L&&tree[x].r<=R)
+        return tree[x].val;
+    int mid=(tree[x].l+tree[x].r)>>1;
+    if(R<=mid) return find(L,R,x<<1);
+    if(L>mid) return find(L,R,x<<1|1);
+    return min(find(L,mid,x<<1),find(mid+1,R,x<<1|1));
+}
+void update(int id,int x,LL val){
+    if(tree[x].l==tree[x].r){
+        tree[x].val=min(tree[x].val,val);
+        return ;
+    }
+    int mid=(tree[x].l+tree[x].r)>>1;
+    if(id<=mid) update(id,x<<1,val);
+    else update(id,x<<1|1,val);
+    tree[x].val=min(tree[x<<1].val,tree[x<<1|1].val);
+}
+int main(){
+    int n,q,cs=0;
+    while(scanf("%d",&n)&&n!=-1){
+        if(cs) printf("\n");
+        else cs=1;
+        for(int i=0;i<n;++i){
+            scanf("%lld%lld",&w[i].x,&w[i].y);
+            w[i].id=-1;
+            ty[i]=w[i].y;
+        }
+        scanf("%d",&q);
+        for(int i=0;i<q;++i){
+            ans[i]=1000000000000;
+            scanf("%lld%lld",&w[i+n].x,&w[i+n].y);
+            w[i+n].id=i;
+            ty[i+n]=w[i+n].y;
+        }
+        sort(ty,ty+n+q);
+        ny=0;
+        for(int i=1;i<n+q;++i)
+            if(ty[i]!=ty[ny]) ty[++ny]=ty[i];
+        ny++;
+        LL my=ty[ny-1],iy=ty[0];
+        build(1,ny,1);
+        sort(w,w+n+q,cmp1);
+        LL mx=w[n+q-1].x,ix=w[0].x;
+        for(int i=0;i<n+q;++i){
+            if(w[i].id!=-1){
+                int j=findy(w[i].y);
+                ans[w[i].id]=min(ans[w[i].id],find(1,j,1)-(my-w[i].y)-(mx-w[i].x));
+            }
+            else update(findy(w[i].y),1,(my-w[i].y)+(mx-w[i].x));
+        }
+        build(1,ny,1);
+        sort(w,w+n+q,cmp2);
+        for(int i=0;i<n+q;++i){
+            if(w[i].id!=-1){
+                int j=findy(w[i].y);
+                ans[w[i].id]=min(ans[w[i].id],find(j,ny,1)-(w[i].y-iy)-(mx-w[i].x));
+            }
+            else update(findy(w[i].y),1,(w[i].y-iy)+(mx-w[i].x));
+        }
+        build(1,ny,1);
+        sort(w,w+n+q,cmp3);
+        for(int i=0;i<n+q;++i){
+            if(w[i].id!=-1){
+                int j=findy(w[i].y);
+                ans[w[i].id]=min(ans[w[i].id],find(1,j,1)-(my-w[i].y)-(w[i].x-ix));
+            }
+            else update(findy(w[i].y),1,(my-w[i].y)+(w[i].x-ix));
+        }
+        build(1,ny,1);
+        sort(w,w+n+q,cmp4);
+        for(int i=0;i<n+q;++i){
+            if(w[i].id!=-1){
+                int j=findy(w[i].y);
+                ans[w[i].id]=min(ans[w[i].id],find(j,ny,1)-(w[i].y-iy)-(w[i].x-ix));
+            }
+            else update(findy(w[i].y),1,(w[i].y-iy)+(w[i].x-ix));
+        }
+        for(int i=0;i<q;++i) printf("%lld\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4190_autoAC.cpp b/HDOJ/4190_autoAC.cpp
new file mode 100644
index 0000000..fab3e77
--- /dev/null
+++ b/HDOJ/4190_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<algorithm>
+#include<math.h>
+#define size 500010
+using namespace std;
+int n,m;
+int a[size];
+int ok(int x)
+{
+    int i = 0 , t = 0;
+    while ( i < n) 
+    {
+          t += ceil(a[i]*1.0 / x );
+          i++;
+    }    
+    if(t > m)  return 0;   
+    else return 1;
+}
+int find_ans(int low , int heigh)
+{
+    int mid , ans;
+    while (low < heigh)
+    {
+          mid = (low + heigh) /2; 
+          int temp = ok(mid); 
+          if( ok(mid) == 0 ) {  low = mid + 1; }
+          else {   heigh = mid ;}
+    }
+    return heigh;
+}
+int main()
+{
+    int max;
+    while ( scanf("%d%d",&n,&m) != EOF && n!=-1 && m!=-1)
+    {
+          int avg = m/n;
+          max = 0;
+          for(int i=0;i<n;i++)  
+          {
+               scanf("%d",&a[i]);
+               if(a[i] > max) max = a[i];
+          }
+          if( n == m ) printf("%d\n",max);
+          else
+               printf("%d\n",find_ans(1, max));
+    }
+    return 0;
+}
diff --git a/HDOJ/4191_autoAC.cpp b/HDOJ/4191_autoAC.cpp
new file mode 100644
index 0000000..6cb83c1
--- /dev/null
+++ b/HDOJ/4191_autoAC.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#define DB double
+using namespace std;
+const int MAXN = 20;
+DB dp[MAXN][MAXN];
+void init(){
+    for(int i = 0;i <= 10; i++)
+        for(int j = 0; j <= 10; j++)
+            dp[i][j] = 0.0;
+}
+int main()
+{
+    DB p;
+    while(scanf("%lf",&p) != EOF){
+        if(p == -1.0) break;
+        init();
+        for(int i = 0; i < 3; i++) dp[4][i] = 1.0;
+        dp[3][3] = p * p / (1 - p * (1 - p) * 2);
+        for(int i = 3; i >= 0; i--)
+            for(int j = 3; j >= 0;j--){
+                if(i == 3 && j == 3) continue;
+                dp[i][j] = p * dp[i+1][j] + (1 - p) * dp[i][j + 1];
+            }
+        DB gp = dp[0][0];
+        init();
+        for(int i = 0; i < 6; i++) dp[7][i] = 1.0;
+        dp[6][6] = p * p / (1 - p * (1 - p) * 2);
+        for(int i = 6; i >= 0; i--)
+            for(int j = 6; j >= 0;j--){
+                if(i == 6 && j == 6) continue;
+                dp[i][j] = p * dp[i+1][j] + (1 - p) * dp[i][j + 1];
+            }
+        DB p7 = dp[0][0];
+        init();
+        dp[6][6] = p7;
+        dp[6][5] = gp + (1.0 - gp) * dp[6][6];
+        dp[5][6] = gp * dp[6][6];
+        for(int i = 0; i <= 4;i++) dp[6][i] = 1.0;
+        for(int i = 5; i >= 0; i--)
+            for(int j = 5;j >= 0;j--){
+                dp[i][j] = gp * dp[i+1][j] + (1.0 - gp) * dp[i][j+1];
+            }
+        DB sp = dp[0][0];
+        init();
+        for(int i = 0; i < 2; i++) dp[2][i] = 1.0;
+        for(int i = 1; i >= 0; i--)
+            for(int j = 1; j >= 0; j--){
+                dp[i][j] = dp[i+1][j] * sp + dp[i][j+1] * (1.0 - sp);
+            }
+        DB mp = dp[0][0];
+        printf("%.11f %.11f %.11f\n",gp,sp,mp);
+    }
+    return 0;
+}
diff --git a/HDOJ/4192_autoAC.cpp b/HDOJ/4192_autoAC.cpp
new file mode 100644
index 0000000..c2980cc
--- /dev/null
+++ b/HDOJ/4192_autoAC.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+#define N 10005
+char str[N];
+int num[N];
+char op[N];
+int v[11];
+int id[11];
+char cmp(char a,char b){
+    if(a=='+'){
+        if(b=='+' || b=='-' || b==')')return '>';
+        else return '<';
+    }
+    if(a=='-'){
+        if(b=='+' || b=='-' || b==')')return '>';
+        else return '<';
+    }
+    if(a=='*'){
+        if(b=='(')return '<';
+        else return '>';
+    }
+    if(a=='('){
+       if(b==')')return '=';
+       else return '<';
+    }
+    if(a==')'){
+        return '>';
+    }
+}
+int cal(int a,int b,char c){
+    if(c=='+')return a+b;
+    if(c=='-')return a-b;
+    if(c=='*')return a*b;
+}
+int gao(){
+    int i,j;
+    int topnum = 0,topop = 1;
+    int k = 1;
+    op[1] = '(';
+    for(i=1;str[i];i++){
+        if(islower(str[i])){
+            topnum++;
+            num[topnum] = v[id[k++]];
+        } else {
+            char c = cmp(op[topop],str[i]);
+            char tag;
+            if(c=='<'){
+                topop++;
+                op[topop] = str[i];
+            } else if(c=='='){
+                topop--;
+            } else if(c=='>'){
+                int b = num[topnum--];
+                int a = num[topnum--];
+                tag = op[topop--];
+                int res = cal(a,b,tag);
+                topnum++;
+                num[topnum] = res;
+                i--;
+            }
+        }
+    }
+    return num[topnum];
+}
+int main(){
+    int n;
+    while(scanf("%d",&n) && n){
+        int i,j;
+        for(i=1;i<=n;i++){
+            scanf("%d",&v[i]);
+            id[i] = i;
+        }
+        int ans;
+        scanf("%d",&ans);
+        scanf("%s",str+1);
+        int len = strlen(str+1);
+        str[0] = '(',str[len+1] = ')',str[len+2] = '\0';
+        bool ok =0;
+        do{
+            int tmp = gao();
+            if(tmp==ans){
+                ok = 1;
+                break;
+            }
+        }while(next_permutation(id+1,id+1+n));
+        if(ok)puts("YES");
+        else puts("NO");
+    }
+    return 0;
+}
diff --git a/HDOJ/4193_autoAC.cpp b/HDOJ/4193_autoAC.cpp
new file mode 100644
index 0000000..8e33537
--- /dev/null
+++ b/HDOJ/4193_autoAC.cpp
@@ -0,0 +1,34 @@
+#include"iostream"
+#include"cstdio"
+#include"cstring"
+using namespace std;
+const int N=1000006;
+int n,num[N],ans;
+int main()
+{
+    int i,l;
+    int p,acc,sum,cnt;
+    while(scanf("%d",&n),n)
+    {
+        sum=0;
+        for(i=0;i<n;i++){scanf("%d",&num[i]);sum+=num[i];}
+        if(sum<0)    {printf("0\n");continue;}
+        p=n-1;
+        ans=cnt=sum=0;
+        while(cnt<=p)
+        {
+            sum+=num[cnt++];
+            while(sum<0)    sum+=num[p--];
+        }
+        acc=0;
+        while(p>=0)
+        {
+            if(acc>=0)        ans++;
+            if(acc<0)        acc+=num[p];
+            else if(num[p]<0)    acc=num[p];
+            p--;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4194_autoAC.cpp b/HDOJ/4194_autoAC.cpp
new file mode 100644
index 0000000..0853a1d
--- /dev/null
+++ b/HDOJ/4194_autoAC.cpp
@@ -0,0 +1,68 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cmath>
+#include <algorithm>
+#include <queue>
+#include <stack>
+#include <vector>
+#include <set>
+#include <map>
+#define MP(a, b) make_pair(a, b)
+#define PB(a) push_back(a)
+using namespace std;
+typedef long long ll;
+typedef pair<int, int> pii;
+typedef pair<unsigned int,unsigned int> puu;
+typedef pair<int, double> pid;
+typedef pair<ll, int> pli;
+typedef pair<int, ll> pil;
+const int INF = 0x3f3f3f3f;
+const double eps = 1E-6;
+const int LEN = 1001;
+map<string, int> mp;
+int n, k, top;
+int num[LEN];
+vector<int> tab[LEN];
+int ch(string s){
+    if(!mp.count(s)) mp[s] = top++;
+    return mp[s];
+}
+int main()
+{
+    char str[1010];
+    int tmp;
+    while(scanf("%d%d", &k, &n) != EOF){
+        if(!k && !n) break;
+        for(int i=0; i<LEN; i++) tab[i].clear();
+        top = 0; mp.clear();
+        for(int i=0; i<n; i++){
+            scanf("%s", &str);
+            num[i] = ch(str);
+            for(int j=0; j<k; j++){
+                scanf("%d", &tmp);
+                tmp --;
+                tab[tmp].PB(i);
+            }
+        }
+        int ans = 0;
+        for(int i=0; i<n; i++){
+            if(tab[i].size() != k) ans ++;
+            else{
+                map<int, int> st;
+                int cc = 0;
+                for(int j=0; j<tab[i].size(); j++){
+                    int x = tab[i][j], y = num[i];
+                    if(num[x] == y || st.count(x)){
+                        ans ++;break;
+                    }else st[x] = 1;
+                }
+            }
+        }
+        if(ans == 0) puts("NO PROBLEMS FOUND");
+        else if(ans == 1) puts("1 PROBLEM FOUND");
+        else printf("%d PROBLEMS FOUND\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4195_autoAC.cpp b/HDOJ/4195_autoAC.cpp
new file mode 100644
index 0000000..84ba13e
--- /dev/null
+++ b/HDOJ/4195_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<cmath>
+#define eps 1e-6
+#define pi acos(-1)
+using namespace std;
+struct node
+{
+    double x,y;
+};
+node p[4];
+double getdis(node p1,node p2)
+{
+    return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
+}
+double getang(double a,double b,double c)
+{
+    double ang= (a*a+b*b-c*c)/(2*a*b);
+    return acos(ang);
+}
+int main()
+{
+    char str[1000];
+    while(gets(str)&&strcmp(str,"END")!=0)
+    {
+        sscanf(str,"%lf%lf",&p[0].x,&p[0].y);
+        scanf("%lf%lf%lf%lf",&p[1].x,&p[1].y,&p[2].x,&p[2].y);
+        getchar();
+        double dis1=getdis(p[0],p[1]);
+        double dis2=getdis(p[1],p[2]);
+        double dis3=getdis(p[0],p[2]);
+        double ang1=getang(dis1,dis2,dis3);
+        double ang2=getang(dis2,dis3,dis1);
+        double ang3=getang(dis1,dis3,dis2);
+        for(int i=3; i<=1000; i++)
+        {
+            if(ang1*i/pi-(int)(ang1*i/pi+eps)<eps && ang2*i/pi-(int)(ang2*i/pi+eps)<eps && ang3*i/pi-(int)(ang3*i/pi+eps)<eps)
+            {
+                printf("%d\n",i);
+                break;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4196_autoAC.cpp b/HDOJ/4196_autoAC.cpp
new file mode 100644
index 0000000..e46606e
--- /dev/null
+++ b/HDOJ/4196_autoAC.cpp
@@ -0,0 +1,57 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+#define N 10000000
+#define MOD 1000000007
+#define LL long long
+using namespace std;
+bool flag[N+5]={0};
+int prime[1000000],cnt=0;
+void Prime(){
+    for(int i=2;i<sqrt(N+1.0);i++){
+        if(flag[i])
+            continue;
+        for(int j=2;j*i<=N;j++)
+            flag[i*j]=true;
+    }
+    for(int i=2;i<=N;i++)
+        if(!flag[i])
+            prime[cnt++]=i;
+}
+int getsum(int n,int p){
+    int sum=0;
+    while(n){
+        sum+=n/p;
+        n/=p;
+    }
+    return sum;
+}
+LL PowMod(LL a, LL b){
+    LL ans=1;
+    while(b){
+        if(b&1)
+            ans=(ans*a)%MOD;
+        a=(a*a)%MOD;
+        b>>=1;
+    }
+    return ans;
+}
+LL fac[N+5];
+int a;
+int main(){
+    int n;
+    fac[1]=1;
+    for(int i=2;i<=N;i++)
+        fac[i]=(fac[i-1]*i)%MOD;
+    Prime();
+    while(scanf("%d",&n)!=EOF&&n){
+        LL ret=1;
+        for(int i=0;i<cnt&&prime[i]<=n;i++){
+            a=getsum(n,prime[i]);
+            if(a&1)
+                ret=(ret*prime[i])%MOD;
+        }
+        printf("%I64d\n",(fac[n]*PowMod(ret,MOD-2))%MOD);
+    }
+    return 0;
+}
diff --git a/HDOJ/4197_autoAC.cpp b/HDOJ/4197_autoAC.cpp
new file mode 100644
index 0000000..9fb4600
--- /dev/null
+++ b/HDOJ/4197_autoAC.cpp
@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <math.h>
+#include <algorithm>
+using namespace std;
+const int N = 1001;
+const double PI = acos(-1),
+             EPS = 1e-8;
+struct Angle
+{
+    double l,r;
+};
+bool cmp(const Angle &a,const Angle &b)
+{
+    return a.l  < b.l;
+}
+int n;
+Angle A[N];
+int ok(double l,double r,double x)
+{
+    if(l - r < EPS)
+        return l - x < EPS && x - r < EPS;
+    return l - x < EPS || x - r < EPS ;
+}
+int main()
+{
+    int i,t;
+    double a,b,r;
+    double x,y;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(i = 0; i  < n; ++i)
+        {
+            scanf("%lf%lf%lf",&a,&b,&r);
+            double dis = sqrt(a * a + b * b);
+            double si = asin(r/dis);
+            double ta = atan2(b,a);
+            A[i].l = ta - si;
+            if(A[i].l < -PI)
+                A[i].l += 2 * PI;
+            A[i].r = ta + si;
+            if(A[i].r > PI)
+                A[i].r -= 2 * PI;
+        }
+        sort(A, A + n, cmp);
+        int res = n,tem;
+        for(i = 0; i < n;++i)
+        {
+            tem = 1;
+            double L = A[i].l,R = A[i].r;
+            for(int j = 1;j < n; ++j)
+            {
+                int k = (i + j) % n;
+                if(!ok(L,R,A[k].l))
+                {
+                    L = A[k].l;
+                    R = A[k].r;
+                    ++ tem ;
+                }
+                else if(ok(L,R,A[k].r))
+                {
+                    R = A[k].r;
+                }
+            }
+            if(tem < res)
+                res = tem;
+        }
+        printf("%d\n",res);
+    }
+    return 0;
+}
diff --git a/HDOJ/4198_autoAC.cpp b/HDOJ/4198_autoAC.cpp
new file mode 100644
index 0000000..b9ef025
--- /dev/null
+++ b/HDOJ/4198_autoAC.cpp
@@ -0,0 +1,81 @@
+#include<iostream>
+#include<queue>
+#include<string.h>
+using namespace std;
+int n,m,d;
+int t[4][2]={0,1,0,-1,1,0,-1,0},vist[510][510];
+int mx,my;
+char s[510][510];
+struct ss
+{
+    friend bool operator<(const ss a,const ss b)
+    {
+        return a.sum>b.sum;
+    }
+    int x,y,sum;
+};
+priority_queue<ss>Q;
+void bfs()
+{
+    memset(vist,0,sizeof(vist));
+    ss node1,node2;
+    node1.x=mx;
+    node1.y=my;
+    node1.sum=0;
+    while(!Q.empty())
+        Q.pop();
+    Q.push(node1);
+    vist[mx][my]=1;
+    while(!Q.empty())
+    {
+        node1=Q.top();
+        Q.pop();
+        if(node1.x==0||node1.y==0||node1.x==n-1||node1.y==m-1)
+        {
+            printf("%d\n",node1.sum+1);
+            return ;
+        }
+        for(int i=0;i<4;i++)
+        {
+            int xx=node1.x+t[i][0];
+            int yy=node1.y+t[i][1];
+            if(xx>=0&&xx<n&&yy>=0&&yy<m&&s[xx][yy]!='#'&&!vist[xx][yy])
+            {
+                vist[xx][yy]=1;
+                node2.x=xx;
+                node2.y=yy;
+                if(s[xx][yy]=='.')
+                    node2.sum=node1.sum+1;
+                else
+                    node2.sum=node1.sum+d+1;
+                Q.push(node2);
+            }
+        }
+    }
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d%d",&n,&m,&d);
+        int i,j;
+        for(i=0;i<n;i++)
+        {
+            getchar();
+            for(j=0;j<m;j++)
+            {
+                scanf("%c",&s[i][j]);
+                if(s[i][j]=='S')
+                {
+                    mx=i;
+                    my=j;
+                    s[i][j]='.';
+                }
+            }
+        }
+        bfs();
+    }
+    return 0;
+}
diff --git a/HDOJ/4200_autoAC.cpp b/HDOJ/4200_autoAC.cpp
new file mode 100644
index 0000000..3890841
--- /dev/null
+++ b/HDOJ/4200_autoAC.cpp
@@ -0,0 +1,123 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+using namespace std;
+#define INF 1000000000
+#define N 110
+#define M 210
+int n, d;
+bool mat[N][N], val[N];
+void print(bool a[N][N], int n)
+{
+    for(int i = 1; i <= n; i++)
+    {
+        for(int j = 1; j <= n+1; j++)
+        {
+            printf("%d ", a[i][j]);
+        }
+        printf("\n");
+    }
+    printf("\n");
+}
+int dfs(int col, int cnt)
+{
+    if(col == n+1)
+    {
+        int res = cnt;
+        for(int i = 1; i <= n; i++)
+        {
+            if(val[i] ^ mat[i][n+1]) res++;
+        }
+        return res;
+    }
+    int res = 0;
+    for(int i = 1; i <= n; i++)
+        val[i] ^= mat[i][col];
+    res = dfs(col+1, cnt+1);
+    for(int i = 1; i <= n; i++)
+        val[i] ^= mat[i][col];
+    res = min(dfs(col+1, cnt), res);
+    return res;
+}
+int gauss()
+{
+    int row = 1;
+    int r = n;
+    for(int i = 1; i <= r; i++, row++)
+    {
+        int p = -1;
+        for(int j = row; j <= n; j++)
+        {
+            if(mat[j][i] == 1)
+            {
+                p = j;
+                break;
+            }
+        }
+        if(p == -1)
+        {
+            for(int j = 1; j <= n; j++)
+            {
+                swap(mat[j][i], mat[j][r]);
+            }
+            //print(mat, n);
+            r--;
+            i--;
+            row--;
+            continue;
+        }
+        if(p != row)
+        {
+            for(int j = i; j <= n+1; j++)
+            {
+                swap(mat[row][j], mat[p][j]);
+            }
+        }
+        for(int j = 1; j <= n; j++)
+        {
+            if(mat[j][i] == 1 && j != row)
+            for(int k = i; k <= n+1; k++)
+            {
+                mat[j][k] ^= mat[row][k];
+            }
+        }
+    }
+    for(int i = row; i <= n; i++)
+    {
+        if(mat[i][n+1] == 1)
+        {
+            return -1;
+        }
+    }
+    memset(val, 0, sizeof(val));
+    int ans = dfs(row, 0);
+    return ans;
+}
+int main()
+{
+    int t; scanf("%d", &t);
+    while(t--)
+    {
+        scanf("%d%d", &n, &d);
+        memset(mat, 0, sizeof(mat));
+        for(int i = 1; i <= n; i++)
+        {
+            scanf("%d", &mat[i][n+1]);
+        }
+        for(int i = 1; i <= n; i++)
+        {
+            int st = max(1, i-d), ed = min(n, i+d);
+            for(int j = st; j <= ed; j++)
+            {
+                mat[i][j] = 1;
+            }
+        }
+        int ans = gauss();
+        if(ans != -1)
+            printf("%d\n", ans);
+        else printf("impossible\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4203_autoAC.cpp b/HDOJ/4203_autoAC.cpp
new file mode 100644
index 0000000..c71ce6b
--- /dev/null
+++ b/HDOJ/4203_autoAC.cpp
@@ -0,0 +1,24 @@
+#include<cstdio>  
+#include<stdlib.h>  
+#include<cstring>  
+#include<queue>  
+using namespace std;  
+int main(){  
+    int i,t,T,k,s;  
+    scanf("%d",&T);  
+    for(t=1;t<=T;t++){  
+        scanf("%d %d",&s,&k);  
+        if(k&1){  
+            if(s&1)printf("1\n");  
+            else printf("0\n");  
+        }  
+        else{  
+            int tem=s%(k+1);  
+            if(tem==k)printf("%d\n",k);  
+            else{  
+                if(tem&1)printf("1\n");  
+                else printf("0\n");  
+            }  
+        }  
+    }  
+}
diff --git a/HDOJ/4205_autoAC.cpp b/HDOJ/4205_autoAC.cpp
new file mode 100644
index 0000000..7652a3e
--- /dev/null
+++ b/HDOJ/4205_autoAC.cpp
@@ -0,0 +1,64 @@
+#include <iostream> 
+#include <stdio.h> 
+#include <string.h> 
+#include <algorithm> 
+#include <stdlib.h> 
+using namespace std;
+#define N 1010
+#define inf 2000000010
+struct node{
+    int x,li,id;
+}w[N];
+bool cmp(const node &a,const node &b){
+    if(a.x!=b.x) return a.x<b.x;
+    return a.li>b.li;
+}
+int dp[N][N];
+int main(){
+    int T,n,id;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d",&n);
+        int Min=-inf;
+        for(int i=0;i<n;++i){
+            scanf("%d%d",&w[i].x,&w[i].li);
+            w[i].id=i;
+        }
+        sort(w,w+n,cmp);
+        for(int i=0;i<n;++i){
+            if(!w[i].id) id=i;
+            for(int j=0;j<=n;++j)
+                dp[i][j]=inf;
+        }
+        if(id){
+            dp[0][0]=Min;
+            dp[0][1]=w[0].x;
+        }
+        else dp[0][1]=w[0].x+(w[0].li+1>>1); 
+        for(int i=1;i<n;++i){
+            if(i==id){
+                int l=w[i].x-(w[i].li+1>>1);
+                int r=w[i].x+(w[i].li+1>>1);
+                for(int j=0;j<=i;++j)
+                    if(dp[i-1][j]<=l)
+                        dp[i][j+1]=r;
+                continue;
+            }
+            for(int j=0;j<=i;++j){
+                dp[i][j]=min(dp[i][j],dp[i-1][j]);
+                if(dp[i-1][j]!=inf){
+                    if(dp[i-1][j]<=w[i].x){
+                        int temp=max(dp[i-1][j]+w[i].li,w[i].x);
+                        dp[i][j+1]=min(dp[i][j+1],temp);
+                    }
+                }
+            }
+        }
+        for(int i=n;i;--i)
+            if(dp[n-1][i]!=inf){
+                printf("%d\n",i);
+                break;
+            }
+    }
+    return 0;
+}
diff --git a/HDOJ/4206_autoAC.cpp b/HDOJ/4206_autoAC.cpp
new file mode 100644
index 0000000..771bf8d
--- /dev/null
+++ b/HDOJ/4206_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <cmath>
+using namespace std;
+int main(void)
+{
+    int cas;
+    scanf("%d", &cas);
+    while(cas--)
+    {
+        int n, a, b, z, y;
+        scanf("%d", &n);
+        int tempn = (int)sqrt((double)n);
+        int ansY, ansZ;
+        ansY = ansZ = INT_MAX;
+        for(int i = 1; i <= tempn; i++)
+        {
+            if(n % i == 0)
+            {
+                a = n / i;
+                b = i;
+                if((a + b) % 2 == 0)
+                {
+                    z = (a + b) / 2;
+                    y = z - min(a, b);
+                    if(z < ansZ || y < ansY)
+                    {
+                        ansY = y, ansZ = z;
+                    }
+                }
+            }
+        }
+        if(ansZ == INT_MAX)
+        {
+            printf("IMPOSSIBLE\n");
+        }
+        else
+            printf("%d %d\n", ansY, ansZ);
+    }
+    return 0;
+}
diff --git a/HDOJ/4207_autoAC.cpp b/HDOJ/4207_autoAC.cpp
new file mode 100644
index 0000000..4827f7b
--- /dev/null
+++ b/HDOJ/4207_autoAC.cpp
@@ -0,0 +1,9 @@
+    432
+   5678
+-------
+   3456
+  3024
+ 2592
+2160
+-------
+2452896
diff --git a/HDOJ/4209_autoAC.cpp b/HDOJ/4209_autoAC.cpp
new file mode 100644
index 0000000..bc3e76a
--- /dev/null
+++ b/HDOJ/4209_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<iostream>
+using namespace std;
+struct node
+{
+   int d;
+   int p;
+};
+typedef int Case;
+node nod[10];
+const double PI=3.1415926;
+int main()
+{
+    int n;
+    Case cas=1;
+    while(cin>>n,n)
+    {
+        double min=1000000,area,sq;
+        int rem;
+        for(int i=0;i<n;i++)
+        {
+            cin>>nod[i].d>>nod[i].p;
+            area=PI*(nod[i].d/2.0)*(nod[i].d/2.0);
+            sq=nod[i].p/area;
+            if(min>sq)
+            {
+                min=sq;
+                rem=nod[i].d;
+            } 
+        }
+        cout<<"Menu "<<cas++<<": "<<rem<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4210_autoAC.cpp b/HDOJ/4210_autoAC.cpp
new file mode 100644
index 0000000..070afd3
--- /dev/null
+++ b/HDOJ/4210_autoAC.cpp
@@ -0,0 +1,156 @@
+#include<iostream>
+#include<algorithm>
+#include<string>
+using namespace std;
+const int N = 10;
+struct Domino
+{
+    int x,y;
+}d[40];
+struct Uncover
+{
+    int x,y;
+}u[N*N];
+int map[N][N],st[3][9],t,num;
+int dir[2][2]={{0,1},{1,0}};
+bool vis[N][N],flag;
+void init()
+{
+    for(int i=1;i<=8;i++)
+        for(int j=i+1;j<=9;j++)
+        {
+            d[t].x=i,d[t].y=j;
+            t++;
+        }
+}
+bool isfinish()
+{
+    for(int i=0;i<3;i++)
+        for(int j=0;j<9;j++)
+            if(st[i][j]!=((1<<9)-1))
+                return false;
+    return true;
+}
+bool check(int x,int y,int xx,int yy,int first,int second)
+{
+    int ss1=(x/3)*3+y/3,ss2=(xx/3)*3+yy/3;
+    first--,second--;
+    if((st[0][x]&(1<<first))||(st[0][xx]&(1<<second)))
+        return false;
+    if((st[1][y]&(1<<first))||(st[1][yy]&(1<<second)))
+        return false;
+    if((st[2][ss1]&(1<<first))||(st[2][ss2]&(1<<second)))
+        return false;
+    st[0][x]|=(1<<first),st[0][xx]|=(1<<second);
+    st[1][y]|=(1<<first),st[1][yy]|=(1<<second);
+    st[2][ss1]|=(1<<first),st[2][ss2]|=(1<<second);
+    return true;
+}
+void restore(int x,int y,int xx,int yy,int first,int second)
+{
+    int ss1=(x/3)*3+y/3,ss2=(xx/3)*3+yy/3;
+    first--,second--;
+    st[0][x]&=~(1<<first),st[0][xx]&=~(1<<second);
+    st[1][y]&=~(1<<first),st[1][yy]&=~(1<<second);
+    st[2][ss1]&=~(1<<first),st[2][ss2]&=~(1<<second);
+}
+void set(int x,int y,int a)
+{
+    int ss=(x/3)*3+y/3;
+    a--;
+    st[0][x]|=(1<<a);
+    st[1][y]|=(1<<a);
+    st[2][ss]|=(1<<a);
+}
+void dfs(int n)
+{
+    int x=u[n].x,y=u[n].y;
+    if(isfinish())
+    {
+        flag=true;
+        return ;
+    }
+    for(int i=0;i<t;i++)
+    {    
+        if(vis[d[i].x][d[i].y])
+            continue;
+        vis[d[i].x][d[i].y]=true;
+        for(int f=0;f<2;f++)
+        {
+            int first=d[i].x,second=d[i].y;
+            if(f&1) swap(first,second);
+            for(int k=0;k<2;k++)
+            {    
+                int temp=n;
+                int xx=x+dir[k][0];
+                int yy=y+dir[k][1];
+                if(xx<0 || xx>=9 || yy<0 || yy>=9 || map[xx][yy]!=0)
+                    continue;
+                if(!check(x,y,xx,yy,first,second))
+                    continue;
+                map[x][y]=first,map[xx][yy]=second;
+                if(map[u[temp+1].x][u[temp+1].y]==0)
+                    dfs(temp+1);
+                else {
+                    while(temp<num && map[u[temp+1].x][u[temp+1].y]!=0)
+                        temp++;
+                    dfs(temp+1);
+                }
+                if(flag) return;
+                restore(x,y,xx,yy,first,second);
+                map[x][y]=0,map[xx][yy]=0;
+            }
+        }
+        vis[d[i].x][d[i].y]=false;
+    }            
+}
+int main()
+{
+    t=0;
+    init();
+    int m,cas=0;
+    char s1[5],s2[5];
+    int a,b,c,d;
+    while(scanf("%d",&m)==1 && m)
+    {
+        memset(vis,false,sizeof(vis));
+        memset(map,0,sizeof(map));
+        memset(st,0,sizeof(st));
+        for(int i=0;i<m;i++)
+        {
+            scanf("%d %s %d %s",&a,s1,&b,s2);
+            int x=s1[0]-'A',y=s1[1]-'0'-1;
+            map[x][y]=a;
+            set(x,y,a);
+            x=s2[0]-'A',y=s2[1]-'0'-1;
+            map[x][y]=b;
+            set(x,y,b);
+            vis[a][b]=vis[b][a]=true;
+        }
+        for(int i=1;i<=9;i++)
+        {
+            scanf("%s",s1);
+            int x=s1[0]-'A',y=s1[1]-'0'-1;
+            set(x,y,i);
+            map[x][y]=i;
+        }
+        num=0;
+        for(int i=0;i<9;i++)
+            for(int j=0;j<9;j++)
+                if(map[i][j]==0)
+                {
+                    u[num].x=i,u[num].y=j;
+                    num++;
+                }
+        flag=false;
+        dfs(0);
+        printf("Puzzle %d\n",++cas);
+        for(int i=0;i<9;i++)
+        {
+            for(int j=0;j<9;j++)
+                printf("%d",map[i][j]);
+            puts("");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4211_autoAC.cpp b/HDOJ/4211_autoAC.cpp
new file mode 100644
index 0000000..e31d88d
--- /dev/null
+++ b/HDOJ/4211_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<iostream>
+#include<string.h>
+#include<string>
+using namespace std;
+int main()
+{
+    char str[100];
+    int a[200];
+    while(gets(str) != NULL)
+    {
+        if(strcmp(str, "END") == 0)
+            break;
+        int l=strlen(str);
+        int i;
+        memset(a, 0, sizeof(a));
+        for( i=0; i < l; i++ )
+        {
+            if(str[i] >= 'A' && str[i] <= 'Z')
+                a[str[i]]++;
+        }
+        for( i='A'; i <= 'Z'; i++ )
+        {
+            if(a[i] > 1)
+                break;
+        }
+        if(i > 'Z')
+            puts(str);
+    }
+    return 0;
+}
diff --git a/HDOJ/4212_autoAC.cpp b/HDOJ/4212_autoAC.cpp
new file mode 100644
index 0000000..a34c3ca
--- /dev/null
+++ b/HDOJ/4212_autoAC.cpp
@@ -0,0 +1,91 @@
+#include <iostream>
+#include <vector>
+#include <set>
+#include<cstdio>
+using namespace std;
+vector<int> a[23];
+int ans,nn;
+int b[22];
+int tp=1<<22;
+void init()
+{
+    for(int i=1;i<tp;i++)
+    {
+        int tmp=i;
+        int k=0;
+        int sum=0;
+        while(tmp)
+        {
+            ++k;
+            if(tmp&1)
+            {
+                sum+=k;
+                if(sum>22) break;
+            }
+            tmp>>=1;
+        }
+        if(!tmp) a[sum].push_back(i);
+    }
+}
+inline int total_one(int p)
+{
+    int c=0;
+    while(p)
+    {
+        p&=p-1;
+        c++;
+    }
+    return c;
+}
+int main()
+{
+    int T=0;
+    int n,m;
+    init();
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        if(n+m==0) break;
+        nn=1<<n;
+        ++T;
+        for(int i=0;i<m;i++)
+        {
+            scanf("%d",&b[i]);
+        }
+        ans=0;
+        set<int> now;
+        now.insert(0);
+        for(int i=0;i<m;i++)
+        {
+            set<int> next;
+            for(set<int>::iterator it=now.begin();it!=now.end();it++)
+            {
+                int temp=a[b[i]].size();
+                int sign=0;
+                int tmp=*it;
+                for(int j=0;j<temp;j++)
+                {
+                    if(a[b[i]][j]>=nn) continue;
+                    if((tmp & a[b[i]][j]) ==0)
+                    {
+                        sign=1;
+                        next.insert(tmp | a[b[i]][j]);
+                    }
+                }
+                if(!sign) 
+                {
+                    int _tmp=total_one(tmp);
+                    ans=ans>_tmp?ans:_tmp;
+                }
+            }
+            now=next;
+            if(now.size()==0) break;
+        }            
+        for(set<int>::iterator it=now.begin();it!=now.end();it++)
+        {
+            int _tmp=total_one(*it);
+            ans=ans>_tmp?ans:_tmp;
+        }
+        printf("Game %d: %d\n",T,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4213_autoAC.cpp b/HDOJ/4213_autoAC.cpp
new file mode 100644
index 0000000..a458c20
--- /dev/null
+++ b/HDOJ/4213_autoAC.cpp
@@ -0,0 +1,103 @@
+#include<cstdio>
+#include<cstring>
+#define maxn 20
+char map[maxn][maxn];
+bool aim[maxn][maxn];
+bool complete;
+int dirx[4]={-1,1,0,0},diry[4]={0,0,-1,1};
+int startx,starty;
+int n,m;
+void run(char *s)
+{
+    for(;*s;s++)
+    {
+        int dir;
+        if(*s=='U') dir=0;
+        else if(*s=='D') dir=1;
+        else if(*s=='L') dir=2;
+        else dir=3;
+        int tx=startx+dirx[dir],ty=starty+diry[dir];
+        if(map[tx][ty]!='#')
+        {
+            int nextx=tx+dirx[dir],nexty=ty+diry[dir];
+            bool flag=false;
+            if(map[tx][ty]=='b'&&map[nextx][nexty]!='b'&&map[nextx][nexty]!='#')
+            {
+                map[tx][ty]='w';
+                map[nextx][nexty]='b';
+                map[startx][starty]='.';
+                startx=tx,starty=ty;
+                flag=true;
+            }
+            else if(map[tx][ty]=='.'||map[tx][ty]=='+')
+            {
+                map[tx][ty]='w';
+                map[startx][starty]='.';
+                startx=tx,starty=ty;
+            }
+            if(flag)
+            {
+                int t1=0,t2=0;
+                for(int i=0;i<n;i++)
+                    for(int j=0;j<m;j++)
+                    {
+                        if(aim[i][j])
+                        {
+                            t1++;
+                            if(map[i][j]=='b')
+                                t2++;
+                        }
+                    }
+                if(t1==t2)
+                {
+                    complete=true;
+                    return;
+                }
+            }
+        }
+    }
+}
+int main()
+{
+    int cas=1;
+    while(scanf("%d %d",&n,&m),n||m)
+    {
+        int i,k;
+        complete=false;
+        for(i=0;i<n;i++)
+            for(k=0;k<m;k++)
+            {
+                scanf(" %c",&map[i][k]);
+                aim[i][k]=false;
+                if(map[i][k]=='+'||map[i][k]=='B'||map[i][k]=='W')
+                {
+                    aim[i][k]=true;
+                    if(map[i][k]!='+')
+                        map[i][k]+=32;
+                }
+                if(map[i][k]=='w')
+                    startx=i,starty=k;
+            }
+        char str[100];
+        scanf("%s",str);
+        run(str);
+        printf("Game %d: ",cas++);
+        puts(complete?"complete":"incomplete");
+        for(i=0;i<n;i++)
+        {
+            for(k=0;k<m;k++)
+            {
+                if(aim[i][k])
+                {
+                    if(map[i][k]=='b'||map[i][k]=='w')
+                        map[i][k]-=32;
+                    else
+                        map[i][k]='+';
+                }
+                printf("%c",map[i][k]);
+            }
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4215_autoAC.cpp b/HDOJ/4215_autoAC.cpp
new file mode 100644
index 0000000..164d47b
--- /dev/null
+++ b/HDOJ/4215_autoAC.cpp
@@ -0,0 +1,18 @@
+#include<iostream>
+#include<cstdio>
+using namespace std;
+int main()
+{
+    int answer[31]={0,1,1,2,2,4,5,5,6,6,7,7,7,7,7,7,7,7,8,8,8,8,8,8,9,9,9,9,9,9,10};
+    int n,c;
+    scanf("%d",&c);
+    for(int t=1;t<=c;t++)
+    {
+        scanf("%d",&n);
+        if(n<30)
+            printf("Case %d: %d\n",t,answer[n]);
+        else
+            printf("Case %d: 10\n",t);
+    }
+    return 0;
+}
diff --git a/HDOJ/4216_autoAC.cpp b/HDOJ/4216_autoAC.cpp
new file mode 100644
index 0000000..ba19b07
--- /dev/null
+++ b/HDOJ/4216_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+using namespace std;
+#define D 10000
+#define max(a,b) ((a)>(b)?(a):(b))
+#define min(a,b) ((a)<(b)?(a):(b))
+int num[105][2];
+int dp[2][20005][2];
+int T,n,x,y;
+double dis(int a,int b)
+{
+    double c=(double)a,d=(double)b;
+    return sqrt((c-x)*(c-x)+(d-y)*(d-y));
+}
+int main()
+{
+    scanf("%d",&T);
+    for(int cas=1; cas<=T; ++cas)
+    {
+        scanf("%d%d%d",&n,&x,&y);
+        x+=D;
+        y+=D;
+        for(int i=1; i<=n; ++i)
+        {
+            scanf("%d%d",&num[i][0],&num[i][1]);
+        }
+        memset(dp,-1,sizeof(dp));
+        dp[0][D][0]=dp[0][D][1]=D;
+        for(int i=1; i<=n; ++i)
+        {
+            for(int j=0; j<=20000; ++j)
+                for(int k=0; k<2; ++k)
+                {
+                    if(dp[(i-1)&1][j][k]!=-1)
+                    {
+                        if(dp[i&1][j+num[i][1]][0]==-1||dp[i&1][j+num[i][1]][0]>dp[(i-1)&1][j][k]+num[i][0])
+                            dp[i&1][j+num[i][1]][0]=dp[(i-1)&1][j][k]+num[i][0];
+                        if(dp[i&1][j-num[i][1]][0]==-1||dp[i&1][j-num[i][1]][0]>dp[(i-1)&1][j][k]-num[i][0])
+                            dp[i&1][j-num[i][1]][0]=dp[(i-1)&1][j][k]-num[i][0];
+                        if(dp[i&1][j+num[i][1]][1]==-1||dp[i&1][j+num[i][1]][1]<dp[(i-1)&1][j][k]+num[i][0])
+                            dp[i&1][j+num[i][1]][1]=dp[(i-1)&1][j][k]+num[i][0];
+                        if(dp[i&1][j-num[i][1]][1]==-1||dp[i&1][j-num[i][1]][1]<dp[(i-1)&1][j][k]-num[i][0])
+                            dp[i&1][j-num[i][1]][1]=dp[(i-1)&1][j][k]-num[i][0];
+                    }
+                }
+        }
+        double dist=0.0;
+        for(int i=0; i<=20000; ++i)
+            for(int j=0; j<2; ++j)
+                if(dp[n&1][i][j]!=-1)
+                    dist=max(dist,dis(dp[n&1][i][j],i));
+        printf("Case %d: %.3f\n",cas,dist);
+    }
+    return 0;
+}
diff --git a/HDOJ/4217_autoAC.cpp b/HDOJ/4217_autoAC.cpp
new file mode 100644
index 0000000..ee1532a
--- /dev/null
+++ b/HDOJ/4217_autoAC.cpp
@@ -0,0 +1,48 @@
+#include"stdio.h"
+#include"string.h"
+#include"stdlib.h"
+struct Seg
+{
+    int l,r,mid;
+    int sum;
+}T[1111111];
+void build(int l,int r,int k)
+{
+    T[k].l=l;
+    T[k].r=r;
+    T[k].mid=(l+r)>>1;
+    if(l==r)    {T[k].sum=1;return ;}
+    build(l,T[k].mid,2*k);
+    build(T[k].mid+1,r,2*k+1);
+    T[k].sum=T[2*k].sum+T[2*k+1].sum;
+}
+int find(int tot,int k)
+{
+    int ans;
+    if(T[k].l==T[k].r)  {T[k].sum=0;return T[k].l;}
+    if(tot<=T[2*k].sum) ans=find(tot,2*k);
+    else                ans=find(tot-T[2*k].sum,2*k+1);
+    T[k].sum=T[2*k].sum+T[2*k+1].sum;
+    return ans;
+}
+int main()
+{
+    int T,Case;
+    int n,m;
+    int t,temp;
+    __int64 ans;
+    scanf("%d",&T);
+    for(Case=1;Case<=T;Case++)
+    {
+        scanf("%d%d",&n,&m);
+        build(1,n,1);
+        ans=0;
+        while(m--)
+        {
+            scanf("%d",&t);
+            ans+=find(t,1);
+        }
+        printf("Case %d: %I64d\n",Case,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4218_autoAC.cpp b/HDOJ/4218_autoAC.cpp
new file mode 100644
index 0000000..436cd89
--- /dev/null
+++ b/HDOJ/4218_autoAC.cpp
@@ -0,0 +1,27 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+using namespace std;
+int main()
+{
+    int n,r;
+    scanf("%d",&n);
+    for(int i=1; i<=n; i++)
+    {
+        scanf("%d",&r);
+        printf("Case %d:\n",i);
+        for(int j=0; j <2 * r+1; j++)
+        {
+            for(int k=0; k<2 * r + 1; k++)
+            {
+                if( abs((j-r)*(j-r)+(k-r)*(k-r)-r*r+0.0)<=3 )
+                    putchar('*');
+                else
+                    putchar(' ');
+            }
+            puts("");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4219_autoAC.cpp b/HDOJ/4219_autoAC.cpp
new file mode 100644
index 0000000..4ce23cf
--- /dev/null
+++ b/HDOJ/4219_autoAC.cpp
@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <string.h>
+#include <vector>
+#include <algorithm>
+#define N 70
+#define S 600
+using namespace std;
+int n,l,s,vis[N],fa[N];
+vector<int>gra[N];
+double dp[N][S];
+void dfs(int d,int p)
+{
+    vis[d]=1;fa[d]=p;
+    int len=gra[d].size();
+    if(p!=-1&&len==1)
+    {
+        dp[d][0]=1;
+        for(int i=1;i<=s;i++)dp[d][i]=0;
+        return ;
+    }
+    for(int i=0;i<len;i++)
+        if(!vis[gra[d][i]])dfs(gra[d][i],d);
+    double sum[S]={0};
+    for(int i=0;i<=s;i++)
+    {
+        if(i*2<=s)
+        {
+            dp[d][i]=1;
+            for(int j=0;j<len;j++)
+            {
+                int e=gra[d][j];
+                if(fa[e]!=d)continue;
+                double tmp=0;
+                for(int k=0;k<=min(l,i);k++)
+                    for(int h=0;h<=i-k;h++)
+                        tmp+=dp[e][h];
+                tmp/=(l+1);
+                dp[d][i]*=tmp;
+            }
+            if(i>0)dp[d][i]-=sum[i-1],sum[i]=dp[d][i]+sum[i-1];
+            else sum[i]=dp[d][i];
+        }
+        else
+        {
+            int op=s-i;
+            dp[d][i]=0;
+            for(int j=0;j<len;j++)
+            {
+                int e=gra[d][j];
+                if(fa[e]!=d)continue;
+                double tmp1=0;
+                for(int k=0;k<=min(l,op);k++)
+                    for(int h=0;h<=op-k;h++)
+                        tmp1+=dp[e][h];
+                tmp1/=(l+1);
+                double tmp2=0;
+                for(int k=0;k<=min(l,i);k++)
+                    tmp2+=dp[e][i-k];
+                tmp2/=(l+1);
+                dp[d][i]+=sum[op]*tmp2/tmp1;
+            }
+        }
+    }
+}
+int main()
+{
+    int ncase;
+    scanf("%d",&ncase);
+    for(int u=1;u<=ncase;u++)
+    {
+        scanf("%d%d%d",&n,&l,&s);
+        for(int i=1;i<=n;i++)gra[i].clear();
+        for(int i=1;i<n;i++)
+        {
+            int a,b;
+            scanf("%d%d",&a,&b);
+            gra[a].push_back(b);
+            gra[b].push_back(a);
+        }
+        memset(vis,0,sizeof(vis));
+        dfs(1,-1);
+        double ans=0;
+        for(int i=0;i<=s;i++)ans+=dp[1][i];
+        printf("Case %d: %.6lf\n",u,ans);
+    }
+}
diff --git a/HDOJ/4221_autoAC.cpp b/HDOJ/4221_autoAC.cpp
new file mode 100644
index 0000000..c478c3f
--- /dev/null
+++ b/HDOJ/4221_autoAC.cpp
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <algorithm>
+using namespace std;
+struct TT
+{
+    int c,d;
+    bool operator < (const TT& s)const
+    {
+        return d < s.d;
+    }
+}A[100002];
+int main()
+{
+    int z,n;
+    __int64 t,ans;
+    scanf("%d",&z);
+    for(int k=1;k<=z;k++)
+    {
+        scanf("%d",&n);
+        for(int i=0;i<n;i++)
+            scanf("%d%d",&A[i].c,&A[i].d);
+        sort(A,A+n);
+        t = ans = 0;
+        for(int i=0;i<n;i++)
+        {
+            t += A[i].c;
+            if(ans < t - A[i].d)
+                ans = t - A[i].d;
+        }
+        printf("Case %d: %I64d\n",k,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4223_autoAC.cpp b/HDOJ/4223_autoAC.cpp
new file mode 100644
index 0000000..34e1761
--- /dev/null
+++ b/HDOJ/4223_autoAC.cpp
@@ -0,0 +1,31 @@
+#include <stdio.h>
+int abs(int s)
+{
+    if(s<0)
+        return -s;
+    return s;
+}
+int main()
+{
+    int t,n,i,j,a[1010],sum,min,k=1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        min=abs(a[1]);
+        for(i=2;i<=n;i++)
+        {
+            sum=0;
+            for(j=i;j>=1;j--)
+            {
+                sum+=a[j];
+                if(min>abs(sum))
+                    min=abs(sum);
+            }
+        }
+        printf("Case %d: %d\n",k++,min);
+    }
+    return 0;
+}
diff --git a/HDOJ/4224_autoAC.cpp b/HDOJ/4224_autoAC.cpp
new file mode 100644
index 0000000..604f7c9
--- /dev/null
+++ b/HDOJ/4224_autoAC.cpp
@@ -0,0 +1,31 @@
+#include<iostream>
+#include<cstdio>
+using namespace std;
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    for(int k=1;k<=t;k++)
+    {
+        int u1,d1,u2,d2,u3,d3;
+        scanf("%d %d %d %d %d %d",&u1,&d1,&u2,&d2,&u3,&d3);
+        int a=0,b=0,c=0;
+        if(u1<d1)
+            a=-1;
+        else  if(u1>d1)
+            a=1;
+        if(u2<d2)
+            b=-1;
+        else  if(u2>d2)
+            b=1;
+        if(u3<d3)
+            c=-1;
+        else  if(u3>d3)
+            c=1;
+        if( ((a+b+c)==3)||((a+b+c)==-3)||((a*b*c==0)&&((a+b+c==1)||(a+b+c==-1)))||(a+b+c==2)||(a+b+c)==-2)
+            printf("Case %d: No\n",k);
+        else
+            printf("Case %d: Yes\n",k);
+    }
+    return 0;
+}
diff --git a/HDOJ/4225_autoAC.cpp b/HDOJ/4225_autoAC.cpp
new file mode 100644
index 0000000..69de799
--- /dev/null
+++ b/HDOJ/4225_autoAC.cpp
@@ -0,0 +1,226 @@
+#include <stdio.h>
+#include <iostream>
+#include <memory.h>
+#include <algorithm>
+#include <vector>
+using namespace std;
+typedef vector<int> Vx;
+char str[100000],len = 0;
+int idx = 0;
+Vx getexp(int &f);
+Vx getval(int &f);
+bool Isnumber(char x){
+    return x >= '0' && x <= '9';
+}
+int getnum(){
+    int num = 0;
+    int tt = 0;
+    if(str[idx] == '-'){
+        idx++;
+        Vx tmp = getval(tt);
+        return -tmp[0];
+    }
+    if(str[idx] == '+'){
+        idx++;
+        Vx tmp = getval(tt);
+        return tmp[0];
+    }
+    while(Isnumber(str[idx])){
+        num = num * 10 + str[idx] - '0';
+        idx++;
+    }
+    return num;
+}
+int op(int a,int b,char opt){
+    int Ret = 0;
+    if(opt == '+') Ret = a + b;
+    if(opt == '-') Ret = a - b;
+    if(opt == '*') Ret = a * b;
+    return Ret;
+}
+void display(Vx x){
+}
+Vx cal(Vx a,Vx b,char opt){
+    Vx Ret;
+    int i;
+    if(a.size() == 1 && b.size() == 1){
+        Ret.push_back(op(a[0],b[0],opt));
+        return Ret;
+    }
+    if(a.size() == 1) {
+        for(i = 0;i < b.size();i++){
+            Ret.push_back(op(a[0],b[i],opt));
+        }
+        return Ret;
+    }
+    if(b.size() == 1) {
+        for(i = 0;i < a.size();i++) {
+            Ret.push_back(op(a[i],b[0],opt));
+        }
+        return Ret;
+    }
+    for(i = 0;i < a.size();i++) {
+        Ret.push_back(op(a[i],b[i],opt));
+    }
+    return Ret;
+}
+Vx vary(int val){
+    int i;
+    Vx Ret;
+    Ret.clear();
+    if(val == 0) return Ret;
+    if(val >  0) {
+        for(i = 1;i <= val;i++) Ret.push_back(i);
+    }else{
+        for(i = -val;i >= 1;i--) Ret.push_back(i);
+    }
+    return Ret;
+}
+Vx getval(int &f){
+    Vx Ret;
+    int i;
+    if(Isnumber(str[idx]) || str[idx] == '-'){
+        Ret.push_back(getnum());
+        f = 0;
+        return Ret;
+    }
+    if(str[idx] == 'v'){
+        idx = idx + 5;
+        int tt = 0;
+        Vx tmp = getexp(tt);
+        idx++;
+        Ret = vary(tmp[0]);
+        f = 1;
+        return Ret;
+    }
+    if(str[idx] == 'b'){
+        idx = idx + 6;
+        while(str[idx] != ')'){
+            int tt = 0;
+            Vx tmp = getexp(tt);
+            Ret.push_back(tmp[0]);
+            if(str[idx] == ')') break;
+            idx++;
+        }
+        f = 1;
+        idx++;
+        return Ret;
+    }
+    if(str[idx] == 'd' && str[idx+1] == 'a'){
+        idx = idx + 6;
+        int tt = 0;
+        Vx tmp = getexp(tt);
+        idx++;
+        if(tt == 1){
+            int ans = tmp[tmp.size() - 1],p;
+            if(tmp.size() % 2 == 0) p = -1;
+            else p = 1;
+            for(i = tmp.size() - 2;i >= 0;i--){
+                if(p == 1) ans = tmp[i] + ans;
+                else ans = tmp[i] - ans;
+                p = -p;
+            }
+            f = 0;
+            Ret.push_back(ans);
+        }else{
+            int p = 1,num = tmp[0];
+            if(num > 0) {
+                for(i = num;i >= 1;i--) {
+                    Ret.push_back(i * p);
+                    p = -p;
+                }
+            }else if(num < 0){
+                for(i = num;i <= -1;i++){
+                    Ret.push_back(i * p);
+                    p = -p;
+                }
+            }
+            f = 1;
+        }
+        return Ret;
+    }
+    if(str[idx] == 'd' && str[idx+1] == 'u'){
+        idx = idx + 5;
+        int tt = 0;
+        Vx tmp = getexp(tt);
+        idx++;
+        int ans = tmp[tmp.size() - 1];
+        for(i = tmp.size() - 2;i >= 0;i--){
+            ans = tmp[i] - ans;
+        }
+        Ret.push_back(ans);
+        f = 0;
+        return Ret;
+    }
+    if(str[idx] == 's'){
+        //sum()
+        idx = idx + 4;
+        int tt = 0;
+        Vx tmp = getexp(tt);
+        idx++;
+        int ans = 0;
+        for(i = 0;i < tmp.size();i++) {
+            ans += tmp[i];
+        }
+        Ret.push_back(ans);
+        f = 0;
+        return Ret;
+    }
+    return Ret;
+}
+bool isop(char x){
+    if(x == '+' || x == '-' || x == '*') return true;
+    else return false;
+}
+Vx getexp(int &f){
+    int i;
+    int tmp = 0;
+    Vx beg = getval(tmp);
+    f = tmp;
+    vector<pair<Vx,char> >E;E.clear();
+    while(idx < len && str[idx] == ' '){
+        if(isop(str[idx+1]) == false || str[idx+2] != ' ') break;
+        while(str[idx] == ' ')idx++;
+        char op = str[idx];
+        idx++;
+        while(str[idx] == ' ')idx++;
+         int t = 0;
+        Vx tmp = getval(t);
+        f = (f|t);
+        E.push_back(make_pair(tmp,op));
+    }
+    if(E.size() == 0) return beg;
+    Vx Ret = E[E.size() - 1].first;
+    for(i = E.size() - 1;i >= 0;i--){
+        if(i > 0){
+            Ret = cal(E[i-1].first,Ret,E[i].second);
+        }else Ret = cal(beg,Ret,E[i].second);
+    }
+    return Ret;
+}
+int main(){
+    int i,j,k,cas = 0;
+    int t;
+    scanf("%d",&t);
+    getchar();
+    while(t--){
+        gets(str);
+        idx = 0;
+        int f = 0;
+        len = strlen(str);
+        Vx ans = getexp(f);
+        if(f == 0) {
+            printf("Case %d: %d\n",++cas,ans[0]);
+        }else{
+            printf("Case %d: ",++cas);
+            printf("{");
+            for(i = 0;i < ans.size();i++){
+                printf("%d",ans[i]);
+                if(i != ans.size() - 1) 
+                    printf(", ");
+            }
+            printf("}\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4226_autoAC.cpp b/HDOJ/4226_autoAC.cpp
new file mode 100644
index 0000000..4ab5a08
--- /dev/null
+++ b/HDOJ/4226_autoAC.cpp
@@ -0,0 +1,70 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const int maxn = 1111;
+const double PI = 3.14159265358979323846;
+const double oo = (1 << 30) * 1.0;
+char kind[maxn];
+double len[maxn];
+double dp[maxn][12];
+int n, m;
+double calc(int a, int b, int c)
+{
+    if (kind[a] == 'R' || kind[a] == 'L')
+    {
+        if (b == c)
+        {
+            double r;
+            if (kind[a] == 'R') 
+                r = (b - 1) * 10.0 + 5 + len[a];
+            else r = (m - b) * 10.0 + 5 + len[a];
+            return (PI / 2.0 * r);
+        }
+        else return oo; 
+    }
+    else
+    {
+        if (len[a] < abs((c - b)) * 100.0) 
+            return oo;
+        else
+            return (sqrt(len[a] * len[a] + (b - c) * 10 * (b - c) * 10));
+    }
+}
+double DP()
+{
+    for (int i = 0; i <= m; ++i)
+        dp[0][i] = 0.0;
+    for (int i = 1; i <= n; ++i)
+    {
+        for (int j = 1; j <= m; ++j)
+        {
+            dp[i][j] = oo;
+            for (int k = 1; k <= m; ++k)
+            {
+                dp[i][j] = min(dp[i][j], dp[i-1][k] + calc(i, k, j));
+            }
+        }
+    }
+    double ans = oo;
+    for (int i = 1; i <= m; ++i)
+        ans = min(ans, dp[n][i]);
+    return ans;
+}
+int main()
+{
+    while (scanf("%d %d", &n, &m))
+    {
+        if (n == 0 && m == 0)
+            break;
+        char ch;
+        for (int i = 1; i <= n; ++i)
+        {
+            scanf("\n%c %lf", &kind[i], &len[i]);
+        }
+        printf("%.2lf\n", DP());
+    }
+    return 0;
+}
diff --git a/HDOJ/4227_autoAC.cpp b/HDOJ/4227_autoAC.cpp
new file mode 100644
index 0000000..211cede
--- /dev/null
+++ b/HDOJ/4227_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <iostream>
+#include<stdio.h>
+#include<algorithm>
+using namespace std;
+int a[13], p[13];
+int sum, i, ans;
+bool use[13];
+void dfs(int k) {
+    int i;
+    if (k == 12) {
+        ans++;
+        return;
+    }
+    for (i = 0; i < 12; i++) {
+        if (i > 0 && !use[i - 1] && p[k - 1] == a[i])
+            continue;
+        if (!use[i]) {
+            p[k] = a[i];
+            if (k == 3) {
+                if (p[0] + p[1] + p[2] + p[3] != sum) {
+                    continue;
+                }
+            }
+            if (k == 6) {
+                if (p[3] + p[4] + p[5] + p[6] != sum) {
+                    continue;
+                }
+            }
+            if (k == 8) {
+                if (p[0] + p[8] + p[7] + p[6] != sum) {
+                    continue;
+                }
+            }
+            if (k == 10) {
+                if (p[10] + p[1] + p[8] + p[9] != sum) {
+                    continue;
+                }
+            }
+            if (k == 11) {
+                if (p[10] + p[2] + p[4] + p[11] != sum) {
+                    continue;
+                }
+                if (p[9] + p[7] + p[5] + p[11] != sum) {
+                    continue;
+                }
+            }
+            use[i] = 1;
+            dfs(k + 1);
+            use[i] = 0;
+        }
+    }
+}
+int main() {
+    while (1) {
+        sum = 0;
+        for (i = 0; i < 12; i++) {
+            scanf("%d", &a[i]);
+            sum += a[i];
+        }
+        sort(a, a + 12);
+        if (!sum)
+            break;
+        if (sum % 3) {
+            printf("0\n");
+            continue;
+        }
+        ans = 0;
+        sum /= 3;
+        dfs(0);
+        printf("%d\n", ans / 12);
+    }
+    return 0;
+}
diff --git a/HDOJ/4228_autoAC.cpp b/HDOJ/4228_autoAC.cpp
new file mode 100644
index 0000000..12fc2cf
--- /dev/null
+++ b/HDOJ/4228_autoAC.cpp
@@ -0,0 +1,49 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<set>
+#include<cmath>
+#include<bitset>
+#define mem(a,b) memset(a,b,sizeof(a))
+#define lson i<<1,l,mid
+#define rson i<<1|1,mid+1,r
+#define INF 510010
+#define maxn 400010
+using namespace std;
+typedef long long ll;
+typedef unsigned long long ull;
+ll p[1010];
+ll prime[30]= {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53};
+void getartprime(ll cur,int cnt,int limit,int k)
+{
+    if(cur>(1LL<<60) || cnt>150) return ;
+    if(p[cnt]!=0 && p[cnt]>cur)
+        p[cnt]=cur;
+    if(p[cnt]==0)
+        p[cnt]=cur;
+    ll temp=cur;
+    for(int i=1; i<=limit; i++) 
+    {
+        temp=temp*prime[k];
+        if(temp>(1LL<<60)) return;
+        getartprime(temp,cnt*(i+1),i,k+1);
+    }
+}
+int main()
+{
+    int n;
+    getartprime(1,1,75,0);
+    for(int i=1; i<=75; i++)
+    {
+        if(p[i*2-1]!=0 && p[i*2]!=0)
+            p[i]=min(p[i*2-1],p[i*2]);
+        else if(p[i*2]!=0) p[i]=p[i*2];
+        else p[i]=p[i*2-1];
+    }
+    while(scanf("%d",&n),n)
+        printf("%I64d\n",p[n]);
+    return 0;
+}
diff --git a/HDOJ/4229_autoAC.cpp b/HDOJ/4229_autoAC.cpp
new file mode 100644
index 0000000..c03cd80
--- /dev/null
+++ b/HDOJ/4229_autoAC.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+#include <cmath>
+using namespace std;
+int main()
+{
+ int a,b,c,d,i,j,k,h,t;
+ while(cin>>a>>b>>c>>d)
+ {
+  if(a==0&& b==0&& c==0&& d==0)
+   break;
+  else
+  {
+   if(a==b&& b==c&& c==d)
+    t=0;
+   else
+   {
+    t=0;
+    while(a|| b || c|| d)
+    {
+     i=abs(a-b);
+     j=abs(b-c);
+     k=abs(c-d);
+     h=abs(d-a);
+     a=i,b=j,c=k,d=h;
+     t++;
+    }
+    t-=1;
+   }
+   cout<<t<<endl;
+  }
+ }
+ return 0;
+}
diff --git a/HDOJ/4230_autoAC.cpp b/HDOJ/4230_autoAC.cpp
new file mode 100644
index 0000000..73a4604
--- /dev/null
+++ b/HDOJ/4230_autoAC.cpp
@@ -0,0 +1,115 @@
+#include"iostream"
+#include"cstdio"
+#include"queue"
+#include"cstring"
+using namespace std;
+const int N=106;
+const int mod=1000000;
+const int inf=123456789;
+int n,m,s_x,s_y,s_face,e_x,e_y;
+int step[N][N][4],cnt[N][N][4],flag[N][N][4];
+char map[N][N];
+int dir[4][2]={-1,0, 0,-1, 1,0, 0,1};
+struct node{
+    int x,y,step,face;
+};
+void bfs()
+{
+    int i;
+    node now,next;
+    queue<node>q;
+    now.x=s_x;
+    now.y=s_y;
+    now.step=0;
+    now.face=s_face;
+    step[now.x][now.y][now.face]=0;
+    cnt[now.x][now.y][now.face]=1;
+    memset(flag,0,sizeof(flag));
+    q.push(now);
+    while(!q.empty())
+    {
+        now=q.front();
+        q.pop();
+        if(flag[now.x][now.y][now.face])    continue;
+        flag[now.x][now.y][now.face]=1;
+        for(i=0;i<4;i++)    if(step[now.x][now.y][now.step]<=step[e_x][e_y][i])    break;
+        if(i>=4)    return ;
+        next.x=now.x+dir[now.face][0];
+        next.y=now.y+dir[now.face][1];
+        next.step=now.step+1;
+        next.face=now.face;
+        while(0<=next.x && next.x<n && 0<=next.y && next.y<m && map[next.x][next.y]!='*')
+        {
+            if(next.step<step[next.x][next.y][next.face])
+            {
+                step[next.x][next.y][next.face]=next.step;
+                cnt[next.x][next.y][next.face]=cnt[now.x][now.y][now.face]%mod;
+                q.push(next);
+            }
+            else if(next.step==step[next.x][next.y][next.face])
+            {
+                cnt[next.x][next.y][next.face]=(cnt[next.x][next.y][next.face]+cnt[now.x][now.y][now.face])%mod;
+                q.push(next);
+            }
+            next.x+=dir[now.face][0];
+            next.y+=dir[now.face][1];
+        }
+        next.x=now.x;
+        next.y=now.y;
+        next.step=now.step+1;
+        next.face=(now.face+1)%4;
+        if(next.step<step[next.x][next.y][next.face])
+        {
+            step[next.x][next.y][next.face]=next.step;
+            cnt[next.x][next.y][next.face]=cnt[now.x][now.y][now.face];
+            q.push(next);
+        }
+        else if(next.step==step[next.x][next.y][next.face])
+        {
+            cnt[next.x][next.y][next.face]=(cnt[next.x][next.y][next.face]+cnt[now.x][now.y][now.face])%mod;
+            q.push(next);
+        }
+        next.step=now.step+1;
+        next.face=(now.face+3)%4;
+        if(next.step<step[next.x][next.y][next.face])
+        {
+            step[next.x][next.y][next.face]=next.step;
+            cnt[next.x][next.y][next.face]=cnt[now.x][now.y][now.face];
+            q.push(next);
+        }
+        else if(next.step==step[next.x][next.y][next.face])
+        {
+            cnt[next.x][next.y][next.face]=(cnt[next.x][next.y][next.face]+cnt[now.x][now.y][now.face])%mod;
+            q.push(next);
+        }
+    }
+}
+int main()
+{
+    int i,l,j;
+    while(scanf("%d%d",&n,&m),n||m)
+    {
+        for(i=0;i<n;i++)
+        {
+            scanf("%s",map[i]);
+            for(l=0;l<m;l++)
+            {
+                if(map[i][l]=='X')    {e_x=i;e_y=l;}
+                if(map[i][l]=='N')    {s_x=i;s_y=l;s_face=0;}
+                else if(map[i][l]=='W')    {s_x=i;s_y=l;s_face=1;}
+                else if(map[i][l]=='S')    {s_x=i;s_y=l;s_face=2;}
+                else if(map[i][l]=='E')    {s_x=i;s_y=l;s_face=3;}
+                for(j=0;j<4;j++)    step[i][l][j]=inf;
+            }
+        }
+        map[s_x][s_y]='.';
+        memset(cnt,0,sizeof(cnt));
+        bfs();
+        int ans=0,minstep=inf;
+        for(i=0;i<4;i++)    if(step[e_x][e_y][i]<minstep)    minstep=step[e_x][e_y][i];
+        for(i=0;i<4;i++)    if(step[e_x][e_y][i]==minstep)    ans=(ans+cnt[e_x][e_y][i])%mod;
+        if(minstep==inf)    printf("0 0\n");
+        else    printf("%d %d\n",minstep,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4231_autoAC.cpp b/HDOJ/4231_autoAC.cpp
new file mode 100644
index 0000000..fb80924
--- /dev/null
+++ b/HDOJ/4231_autoAC.cpp
@@ -0,0 +1,189 @@
+#include <stdio.h>
+#include <iostream>
+#include <string.h>
+#include <stdlib.h>
+using namespace std;
+#define M 105
+struct info
+{
+    char side;
+    int sou;
+    int v;
+};
+info fold[30];
+int w,h,n;
+int we,he;
+int x,y;
+void getdata(void);
+int cal(int ws,int hs,int px,int py,int step);
+int main()
+{
+    while (scanf("%d%d%d",&w,&h,&n),w+h+n)
+    {
+        getdata();
+        printf("%d\n",cal(we,he,x,y,n));
+    }
+    return 0;
+}
+void getdata(void)
+{
+    int i;
+    we=w;
+    he=h;
+    for (i=1;i<=n;i++)
+    {
+        scanf(" %c%d",&fold[i].side,&fold[i].v);
+        switch(fold[i].side)
+        {
+        case 'T':
+        case 'B':
+            fold[i].sou=he;
+            if (he-fold[i].v>=fold[i].v)
+                he-=fold[i].v;
+            else
+            {
+                he=fold[i].v;
+                /*fold[i].v=he-fold[i].v;
+                fold[i].side=fold[i].side=='B'?'T':'B';
+                he-=fold[i].v;*/
+            }
+            break;
+        case 'L':
+        case 'R':
+            fold[i].sou=we;
+            if (we-fold[i].v>=fold[i].v)
+                we-=fold[i].v;
+            else
+            {
+                we=fold[i].v;
+                /*fold[i].v=we-fold[i].v;
+                fold[i].side=fold[i].side=='R'?'L':'R';
+                we-=fold[i].v;*/
+            }
+            break;
+        }
+    }
+    scanf("%d%d",&x,&y);
+}
+int cal(int ws,int hs,int px,int py,int step)
+{
+    int ans=0;
+    int line;
+    if (step<1)
+        return 1;
+    else
+    {
+        switch (fold[step].side)
+        {
+        case 'T':
+            if (hs>fold[step].v)
+            {
+                if (py<hs-fold[step].v)
+                {
+                    ans+=cal(ws,hs+fold[step].v,px,py,step-1);
+                }
+                else
+                {
+                    ans+=cal(ws,hs+fold[step].v,px,py,step-1);
+                    ans+=cal(ws,hs+fold[step].v,px,hs+(hs-py),step-1);
+                }
+            }
+            else
+            {
+                line=2*fold[step].v-fold[step].sou;
+                if (py>line)
+                {
+                    ans+=cal(ws,fold[step].sou,px,hs+(hs-py)-line,step-1);
+                    ans+=cal(ws,fold[step].sou,px,py-line,step-1);
+                }
+                else
+                {
+                    ans+=cal(ws,fold[step].sou,px,hs+(hs-py)-line,step-1);
+                }
+            }
+            break;
+        case 'B':
+            if (hs>fold[step].v)
+            {
+                if (py>fold[step].v)
+                {
+                    ans+=cal(ws,hs+fold[step].v,px,py+fold[step].v,step-1);
+                }
+                else
+                {
+                    ans+=cal(ws,hs+fold[step].v,px,py+fold[step].v,step-1);
+                    ans+=cal(ws,hs+fold[step].v,px,fold[step].v-py,step-1);
+                }
+            }
+            else
+            {
+                line=2*fold[step].v-fold[step].sou;
+                if (py<hs-line)
+                {
+                    ans+=cal(ws,fold[step].sou,px,py+fold[step].v,step-1);
+                    ans+=cal(ws,fold[step].sou,px,fold[step].v-py,step-1);
+                }
+                else
+                {
+                    ans+=cal(ws,fold[step].sou,px,fold[step].v-py,step-1);
+                }
+            }
+            break;
+        case 'L':
+            if (ws>fold[step].v)
+            {
+                if (px>fold[step].v)
+                {
+                    ans+=cal(ws+fold[step].v,hs,px+fold[step].v,py,step-1);
+                }
+                else
+                {
+                    ans+=cal(ws+fold[step].v,hs,px+fold[step].v,py,step-1);
+                    ans+=cal(ws+fold[step].v,hs,fold[step].v-px,py,step-1);
+                }
+            }
+            else
+            {
+                line=2*fold[step].v-fold[step].sou;
+                if (px<ws-line)
+                {
+                    ans+=cal(fold[step].sou,hs,px+fold[step].v,py,step-1);
+                    ans+=cal(fold[step].sou,hs,fold[step].v-px,py,step-1);
+                }
+                else
+                {
+                    ans+=cal(fold[step].sou,hs,fold[step].v-px,py,step-1);
+                }
+            }
+            break;
+        case 'R':
+            if (ws>fold[step].v)
+            {
+                if (px<ws-fold[step].v)
+                {
+                    ans+=cal(fold[step].sou,hs,px,py,step-1);
+                }
+                else
+                {
+                    ans+=cal(fold[step].sou,hs,px,py,step-1);
+                    ans+=cal(fold[step].sou,hs,ws+(ws-px),py,step-1);
+                }
+            }
+            else
+            {
+                line=2*fold[step].v-fold[step].sou;
+                if (px>line)
+                {
+                    ans+=cal(fold[step].sou,hs,px-line,py,step-1);
+                    ans+=cal(fold[step].sou,hs,ws+(ws-px)-line,py,step-1);
+                }
+                else
+                {
+                    ans+=cal(fold[step].sou,hs,ws+(ws-px)-line,py,step-1);
+                }
+            }
+            break;
+        }
+    }
+    return ans;
+}
diff --git a/HDOJ/4233_autoAC.cpp b/HDOJ/4233_autoAC.cpp
new file mode 100644
index 0000000..7ba5075
--- /dev/null
+++ b/HDOJ/4233_autoAC.cpp
@@ -0,0 +1,93 @@
+#include<iostream>
+#include<sstream>
+#include<fstream>
+#include<vector>
+#include<list>
+#include<deque>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<bitset>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cctype>
+#include<cmath>
+#include<ctime>
+#include<iomanip>
+using namespace std;
+const double eps(1e-8);
+typedef long long lint;
+#define maxn 100010
+int N, K, root;
+int w[maxn];
+bool select[maxn];
+vector<int> G[maxn];
+int f[maxn];
+void dfs(int now)
+{
+    int nex;
+    int mx = -1e9;
+    for(int i = 0, sz = G[now].size(); i < sz; i++)
+    {
+        nex = G[now][i];
+        dfs(G[now][i]);
+        f[now] = max(f[now], max(f[nex], w[nex] + mx));
+        w[now] = max(w[now], w[nex]);
+        mx = max(mx, w[nex]);
+    }
+    return;
+}
+void solve()
+{
+    memset(select, 0, sizeof(select));
+    priority_queue<pair<int, int> > Q;
+    Q.push(make_pair(w[root], root));
+    int ret = 0;
+    while(K)
+    {
+        if(Q.empty())
+        {
+            puts("0");
+            return;
+        }
+        int u = Q.top().second;
+        Q.pop();
+        if(select[u])
+        {
+            K++;
+            select[u] = 0;
+            ret -= w[u];
+            for(int i = 0, sz = G[u].size(); i < sz; i++) Q.push(make_pair(w[G[u][i]], G[u][i]));
+        }
+        else
+        {
+            K--;
+            select[u] = 1;
+            ret += w[u];
+            Q.push(make_pair(f[u] - w[u], u));
+        }
+    }
+    printf("%d\n", ret);
+    return;
+}
+int main()
+{
+    while(scanf("%d %d", &N, &K), N || K)
+    {
+        for(int i = 1; i <= N; i++) G[i].clear();
+        int p;
+        for(int i = 1; i <= N; i++)
+        {
+            f[i] = -1e9;
+            scanf("%d %d", &p, w + i);
+            if(p == 0) root = i;
+            else G[p].push_back(i);
+        }
+        dfs(root);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4234_autoAC.cpp b/HDOJ/4234_autoAC.cpp
new file mode 100644
index 0000000..0a2da91
--- /dev/null
+++ b/HDOJ/4234_autoAC.cpp
@@ -0,0 +1,80 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <math.h>
+using namespace std;
+#define for if(0); else for
+const double PI=acos(-1.0);
+struct Point{
+    double x,y,vx,vy,t;
+    Point(){}
+    Point(double x,double y){
+        this->x=x;
+        this->y=y;
+    }
+    Point(double x,double y,double d,double v){
+        this->x=x;
+        this->y=y;
+        this->vx=v*cos(d*PI/180.0);
+        this->vy=v*sin(d*PI/180.0);
+        this->t=0;
+    }
+    Point go(double t) const{
+        Point ret=*this;
+        ret.x+=vx*t;
+        ret.y+=vy*t;
+        return ret;
+    }
+};
+int n;
+Point p[16];
+double spd;
+double dp[16][1<<15];
+bool vis[16][1<<15];
+double dis(const Point &a,const Point &b){
+    double dx=a.x-b.x;
+    double dy=a.y-b.y;
+    return sqrt(dx*dx+dy*dy);
+}
+double cost(const Point &a,const Point &b){
+    Point ta=Point(b.x-a.x,b.y-a.y);
+    Point v=Point(b.vx,b.vy);
+    double V=dis(v,Point(0,0));
+    double D=dis(ta,Point(0,0));
+    double A=V*V-spd*spd;
+    double C=D*D;
+    double B=-2.0*(ta.x*v.x+ta.y*v.y);
+    return (B-sqrt(B*B-4*A*C))/2.0/A;
+}
+int main() {
+    setbuf(stdout,NULL);
+    while(scanf("%d%lf",&n,&spd) &&(n!=0&&spd!=0)){
+        p[0]=Point(0,0,0,0);
+        for(int i=1;i<=n;i++){
+            double x,y,d,v;
+            scanf("%lf%lf%lf%lf",&x,&y,&d,&v);
+            p[i]=Point(x,y,d,v);
+        }
+        memset(vis,0,sizeof(vis));
+        vis[0][0]=1;
+        for(int stat=1;stat<1<<n;stat++){
+            for(int i=1;i<=n;i++){
+                int prev=stat;
+                prev &= ~ ( 1<< (i-1) );
+                if(prev==stat) continue;
+                for(int j=0;j<=n;j++) if(j!=i){
+                    if(vis[j][prev]){
+                        double val=dp[j][prev]+cost(p[j].go(dp[j][prev]),p[i].go(dp[j][prev]));
+                        if(!vis[i][stat]) vis[i][stat]=1,dp[i][stat]=val;
+                        else dp[i][stat]=min(dp[i][stat],val);
+                    }
+                }
+            }
+        }
+        double ans=dp[1][(1<<n)-1];
+        for(int i=1;i<=n;i++) ans=min(ans,dp[i][(1<<n)-1]);
+        printf("%.2lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4235_autoAC.cpp b/HDOJ/4235_autoAC.cpp
new file mode 100644
index 0000000..7b41cf6
--- /dev/null
+++ b/HDOJ/4235_autoAC.cpp
@@ -0,0 +1,16 @@
+#include <stdio.h>
+int a[591]={126,153,688,1206,1255,1260,1395,1435,1503,1530,1827,2187,3159,3784,6880,10251,10255,10426,10521,10525,10575,11259,11844,11848,12006,12060,12384,12505,12546,12550,12595,12600,12762,12843,12955,12964,13243,13545,13950,14035,14350,15003,15030,15246,15300,15435,15624,15795,16272,17325,17428,17437,17482,18225,18265,18270,19026,19215,21375,21586,21753,21870,25105,25375,25474,25510,28476,29632,31509,31590,33655,33696,36855,37840,37845,39784,41665,42898,44676,45684,45760,45864,47538,48672,49855,51759,52168,53865,56295,56875,62968,63895,67149,67392,67950,68800,71199,78975,100255,100525,101299,102051,102505,102510,102541,102550,102595,102942,102955,103968,104026,104260,104368,105021,105025,105075,105210,105250,105264,105295,105723,105750,107163,107329,108126,108135,108216,108612,108864,109525,110758,112468,112509,112590,114268,115672,115699,116478,116496,116725,116928,117067,118408,118440,118480,118575,118926,119848,120006,120060,120384,120600,120762,120843,121086,121576,121815,122746,122764,123084,123354,123538,123840,123894,124483,124488,124542,124978,125005,125050,125095,125248,125433,125460,125500,125950,125995,126000,126027,126108,126846,127417,127620,128403,128430,128943,129438,129505,129514,129550,129564,129595,129640,129775,129955,131242,132430,132565,132615,132655,133245,134275,134725,135045,135450,135828,135837,136525,136854,136948,138784,139500,139824,140035,140350,141345,142978,143500,143739,143793,145273,145314,145345,145683,146137,146520,146952,149364,149782,150003,150030,150246,150300,150435,150624,150826,152271,152406,152460,152608,152685,152946,153000,153436,154350,155277,156024,156240,156289,156325,156915,157950,158193,162072,162526,162720,162976,163255,163795,163854,163944,164583,165208,168520,171598,172246,172386,172822,173250,173925,174028,174082,174208,174280,174298,174370,174793,174802,174820,174982,175329,176215,178294,178942,179325,179428,179482,180225,180297,180621,182065,182250,182650,182700,182974,184126,186624,187029,189702,189742,190260,190827,191205,192150,192375,192685,192717,193257,193945,194229,197428,197482,197725,201852,205785,207391,208624,210375,210681,210753,211896,212868,213075,213466,213750,213759,214506,215086,215424,215455,215860,216733,217503,217530,217638,217854,218488,218700,223524,226498,226872,226876,227448,229648,231579,231673,233896,236754,236758,236925,238968,241506,241564,243175,245182,245448,246150,246928,250105,250510,251005,251050,251095,251896,253750,254740,255010,255100,256315,256410,256414,258795,259510,260338,261378,261783,262984,263074,263155,263736,267034,268398,279328,281736,283198,283648,284598,284760,285376,286416,286974,287356,289674,291375,291753,293625,295105,295510,296320,297463,297832,304717,307183,312475,312565,312655,312975,314199,314743,315009,315090,315490,315594,315625,315900,316255,319059,319536,325615,326155,326452,328419,328864,329346,329656,336195,336550,336960,338296,341284,341653,342688,346288,346725,346968,347913,352966,355995,361989,362992,365638,368104,368550,368784,369189,371893,373864,375156,375615,376992,378400,378418,378450,381429,384912,384925,386415,390847,392566,393246,393417,394875,397840,399784,404932,404968,414895,415575,416065,416259,416650,416988,419287,428980,429664,435784,439582,442975,446760,446976,447916,449676,449955,450688,451768,456840,457168,457600,458640,462672,465088,465984,468535,475380,475893,476892,486720,488592,489159,489955,490176,491688,493857,495328,497682,498550,515907,516879,517509,517590,519745,520168,520816,521608,521680,526792,529672,530379,531297,535968,536539,538650,549765,559188,562950,564912,567648,568750,571648,573768,588676,611793,611878,612598,614965,617728,618759,623758,629680,632875,638950,649638,661288,665919,667876,671409,671490,671944,673920,678892,679500,687919,688000,692712,697248,702189,702918,710496,711099,711909,711990,715959,719199,729688,736695,738468,741928,769792,773896,778936,782896,785295,789250,789525,789750,791289,792585,794088,798682,809919,809937,809964,815958,829696,841995,859968,899019,936985,939658,960988,1000255};
+int main()
+{
+    int x;
+    while (scanf("%d", &x)){
+        if (x == 0) break;
+        for (int i = 0; i < 591; ++i){
+            if (a[i] >= x){
+                printf("%d\n", a[i]);
+                break;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4236_autoAC.cpp b/HDOJ/4236_autoAC.cpp
new file mode 100644
index 0000000..7693c18
--- /dev/null
+++ b/HDOJ/4236_autoAC.cpp
@@ -0,0 +1,22 @@
+#include<iostream>
+#include<string>
+using namespace std;
+char ch[25];
+int main()
+{
+    int n, i, j;
+    scanf("%d", &n);
+    while(n--)
+    {
+        int a, b;
+        scanf("%d%d%*c%s", &a, &b, ch);
+        printf("%d ", a);
+        for(i = 0; ch[i] != '\0'; i++)
+        {
+            for(j = 0; j < b; j++)
+                printf("%c", ch[i]);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4237_autoAC.cpp b/HDOJ/4237_autoAC.cpp
new file mode 100644
index 0000000..0a02736
--- /dev/null
+++ b/HDOJ/4237_autoAC.cpp
@@ -0,0 +1,13 @@
+#include<iostream>
+#include<cstdio>
+using namespace std;
+int main(){
+    int t,r;
+    long long n,m,k;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%lld%lld",&r,&k,&m);    
+        printf("%d %lld\n",r,1+(k-m)*m);
+    }
+    return 0;
+}
diff --git a/HDOJ/4238_autoAC.cpp b/HDOJ/4238_autoAC.cpp
new file mode 100644
index 0000000..4ac3bbd
--- /dev/null
+++ b/HDOJ/4238_autoAC.cpp
@@ -0,0 +1,80 @@
+#include<iostream>
+#include<stdio.h>
+#include<string.h>
+#include<queue>
+#include<stack>
+#include<algorithm>
+#include<cmath>
+#include<set>
+#include<map>
+#define ll long long
+#define oo 1<<29
+#define pi acos(-1.0)
+#define esp 1e-30
+using namespace std;
+char s[45]={"PQWERTYUIOJ#SZK*?F@D!HNM&LXGABCV"},c,Q[30];
+int A[30],C[30];
+int main()
+{
+       int cases,id,t,x,i,len; 
+       scanf("%d",&cases);
+       while (cases--)
+       {
+               scanf("%d%s",&id,Q),len=strlen(Q);
+               if (Q[0]=='-') x=Q[1]-'0';
+                        else  x=Q[0]-'0';
+               if (x)
+               {
+                     if (x>1) { printf("%d INVALID VALUE\n",id); continue; }
+                     for (i=3;i<=19;i++)
+                        if (Q[i]>='1' && Q[i]<='9') break;
+                     if (i<=19) { printf("%d INVALID VALUE\n",id); continue; }
+               }
+               if (Q[0]=='-') 
+               {
+                     A[1]=1;
+                     C[x=1]=1;
+                     for (i=2;i<len;i++)
+                       if (Q[i]>='0' && Q[i]<='9') 
+                          C[++x]=0-(Q[i]-'0');
+                     len=x;
+                     for (i=len;i>=1;i--)
+                        if (C[i]<0) C[i-1]--,C[i]+=10;
+                     C[1]=0;
+               }
+               else 
+               {
+                     A[1]=0;
+                     x=0;
+                     for (i=0;i<len;i++)
+                       if (Q[i]>='0' && Q[i]<='9') 
+                          C[++x]=Q[i]-'0';
+                     len=x;
+               }
+               for (i=2;i<=17;i++)
+               {
+                       for (x=2;x<=len;x++) C[x]*=2;
+                       for (x=1;x<=len;x++) C[x-1]+=C[x]/10,C[x]%=10;
+                       if (C[1]) A[i]=1;
+                            else A[i]=0;
+                       C[1]=0;
+                       while (len && !C[len]) len--;
+               }
+              if (len && A[1]) A[17]++;
+               for (x=20;x>=1;x--) A[x-1]+=A[x]/2,A[x]%=2;  
+               x=0;
+               for (i=1;i<=5;i++)
+                 if (A[i]) x+=1<<(5-i);
+               printf("%d %c",id,s[x]);
+               x=0,t=10;
+               for (i=6;i<=16;i++)
+               {
+                     if (A[i]) x+=1<<t;
+                     t--;
+               }
+               printf(" %d",x);
+               if (!A[17]) printf(" F\n");
+                     else  printf(" D\n");
+       }
+       return 0;
+}
diff --git a/HDOJ/4239_autoAC.cpp b/HDOJ/4239_autoAC.cpp
new file mode 100644
index 0000000..09d2679
--- /dev/null
+++ b/HDOJ/4239_autoAC.cpp
@@ -0,0 +1,83 @@
+#include<stdio.h>
+#include<string.h>
+char map[33] = {'P' , 'Q' , 'W' , 'E' , 'R' , 'T' , 'Y' , 'U' , 'I' , 'O' , 'J' , '#' , 'S' , 'Z' , 'K' , '*' , '?' , 'F' , '@' , 'D' , '!' , 'H' , 'N' , 'M' , '&' , 'L' , 'X' , 'G' , 'A','B','C','V'};
+char a[3] , b[3];
+int n , num;
+double ans;
+char tans[10000];
+char str[30];
+void f(char t){
+    int d = 4;
+    for(int i = 0 ; i < 32 ; i ++){
+        if(t == map[i]){
+            while(i != 0){
+                str[d --] = i % 2 + '0';
+                i /= 2;
+            }
+            break;
+        }
+    }
+    while(d >= 0){
+        str[d --] = '0';
+    }
+    return ;
+}
+void ff(int t){
+    int d = 15;
+    while(t != 0){
+        str[d --] = t % 2 + '0';
+        t /= 2;
+    }
+    while(d >= 5){
+        str[d --] = '0';
+    }
+    return ;
+}
+void fff(char t){
+    if(t == 'F') str[16] = '0';
+    if(t == 'D') str[16] = '1';
+}
+int main(){
+    scanf("%d" , &n);
+        for(int i = 1 ; i <= n ; i ++){
+            ans = 0;
+            double c = 0.5;
+            scanf("%*d%s%d%s" , a , &num , b);
+            f(a[0]);
+            ff(num);
+            fff(b[0]);
+            str[17] = '\0';
+            printf("%d " , i);
+            if(str[0] == '0'){
+                for(int i = 1 ; i < 17 ; i ++){
+                    ans += (str[i] - '0') * c;
+                    c /= 2;
+                }
+                sprintf(tans , "%.16lf" , ans);
+            }
+            else{
+                for(int i = 1 ; i < 17 ; i ++){
+                    ans += (str[i] - '0') * c;
+                    c /= 2;
+                }
+                ans += -1.0;
+                sprintf(tans , "%.16lf" , ans);
+            }
+            if(ans == 0.0){
+                printf("0.0\n");
+            }
+            else if(ans == -1.0){
+                printf("-1.0\n");
+            }
+            else{
+                int di;
+                for(di = strlen(tans) - 1 ; di >= 0 ; di --){
+                    if(tans[di] != '0') break;
+                }
+                tans[di + 1] = '\0';
+                printf("%s" , tans);
+                printf("\n");
+            }
+        }
+    return 0;
+}
diff --git a/HDOJ/4240_autoAC.cpp b/HDOJ/4240_autoAC.cpp
new file mode 100644
index 0000000..9f599c4
--- /dev/null
+++ b/HDOJ/4240_autoAC.cpp
@@ -0,0 +1,112 @@
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std;
+const int maxn = 1010;
+const int INF = 0x3f3f3f3f;
+struct Edge
+{
+    int from, to, cap, flow;
+    Edge(int from, int to, int cap, int flow): from(from), to(to), cap(cap), flow(flow) {}
+};
+int high, low;
+struct EK
+{
+    int n, m, s, t;
+    vector<Edge> edges;
+    vector<int> G[maxn];
+    int p[maxn];
+    int a[maxn];
+    void init(int n)
+    {
+        this->n = n;
+        edges.clear();
+        for(int i = 0; i <= n; i++) G[i].clear();
+    }
+    void AddEdge(int from, int to, int cap)
+    {
+        edges.push_back(Edge (from, to, cap, 0));
+        edges.push_back(Edge (to, from, 0, 0));
+        m = edges.size();
+        G[from].push_back(m-2);
+        G[to].push_back(m-1);
+    }
+    bool BFS(int s, int t, int &flow)
+    {
+        memset(a, 0, sizeof(a));
+        queue<int> Q;
+        Q.push(s);
+        a[s] = INF;
+        while(!Q.empty())
+        {            
+            int u = Q.front(); Q.pop();
+            for(int i = 0; i < G[u].size(); i++)
+            {
+                Edge &e = edges[G[u][i]];
+                if(!a[e.to] && e.cap > e.flow)
+                {
+                    p[e.to] = G[u][i];
+                    Q.push(e.to);
+                    a[e.to] = min(a[u], e.cap-e.flow);
+                }
+            }
+        }
+        if(a[t] == 0) return 0;
+        flow += a[t];
+        low = INF;
+        int u = t;
+        while(u != s)
+        {
+            edges[p[u]].flow += a[t];
+            edges[p[u]^1].flow -= a[t];
+            low = min(low, edges[p[u]].cap); 
+            u = edges[p[u]].from;
+        }
+        high = max(high, low); 
+        return 1;
+    }
+    int Maxflow(int s, int t)
+    {
+        this->s = s; this->t = t;
+        int flow = 0;
+        while(BFS(s, t, flow)) ;
+        return flow;
+    }
+};
+void readint(int &x)
+{
+    char c;
+    while(!isdigit(c)) c = getchar();
+    x = 0;
+    while(isdigit(c)) { x = x*10 + c-'0'; c = getchar(); }
+}
+void writeint(int x)
+{
+    if(x > 9) writeint(x/10);
+    putchar(x%10+'0');
+}
+EK solver;
+int n, m, s, t;
+int kase;
+void solve()
+{
+    scanf("%d%d%d%d%d", &kase, &n, &m, &s, &t);
+    solver.init(n+3);
+    high = -INF;
+    while(m--)
+    {
+        int x, y, z;
+        readint(x), readint(y), readint(z);
+        solver.AddEdge(x, y, z);
+    }
+    int ans = solver.Maxflow(s, t);
+    printf("%d %.3lf\n", kase, ans*1.0/high);
+}
+int main()
+{
+    int T;
+    for(readint(T); T > 0; T--) solve();
+    return 0;
+}
diff --git a/HDOJ/4242_autoAC.cpp b/HDOJ/4242_autoAC.cpp
new file mode 100644
index 0000000..fbdb628
--- /dev/null
+++ b/HDOJ/4242_autoAC.cpp
@@ -0,0 +1,54 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+using namespace std;
+char a[20];
+double funx(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4){
+    return (y4-y2+(y1-y2)*x2/(x1-x2)-(y3-y4)*x4/(x3-x4))/((y1-y2)/(x1-x2)-(y3-y4)/(x3-x4));
+}
+double funy(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4){
+    return y2+(y1-y2)*(funx(x1,y1,x2,y2,x3,y3,x4,y4)-x2)/(x1-x2);
+}
+double area(double x0,double y0,double x1,double y1,double x2,double y2){
+    return fabs(x0*y1+x2*y0+x1*y2-x2*y1-x0*y2-x1*y0);
+}
+double dis(double x1,double y1,double x2,double y2){
+    return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
+}
+int main(){
+    double ax=0.0,ay=0.0,bx,by=0.0,cx,cy,dx,dy;
+    double aax,aay,bbx,bby,ccx,ccy,ddx,ddy;
+    int t,n;
+    while(~scanf("%d",&t)){
+        while(t--){
+            scanf("%d%lf%lf%lf%lf%lf",&n,&bx,&cx,&cy,&dx,&dy);
+            aax=(bx+cx)/2;
+            aay=(by+cy)/2;
+            bbx=(cx+dx)/2;
+            bby=(cy+dy)/2;
+            ccx=(ax+dx)/2;
+            ccy=(ay+dy)/2;
+            ddx=(ax+bx)/2;
+            ddy=(ay+by)/2;
+            double x1=funx(ax,ay,aax,aay,bx,by,bbx,bby);
+            double y1=funy(ax,ay,aax,aay,bx,by,bbx,bby);
+            double x2=funx(bx,by,bbx,bby,cx,cy,ccx,ccy);
+            double y2=funy(bx,by,bbx,bby,cx,cy,ccx,ccy);
+            double x3=funx(cx,cy,ccx,ccy,dx,dy,ddx,ddy);
+            double y3=funy(cx,cy,ccx,ccy,dx,dy,ddx,ddy);
+            double x4=funx(ax,ay,aax,aay,dx,dy,ddx,ddy);
+            double y4=funy(ax,ay,aax,aay,dx,dy,ddx,ddy);
+            double al,bob,chas,dave,emily;
+            al  =area(ax,ay,bx,by,x1,y1)/2/160;
+            bob =area(bx,by,cx,cy,x2,y2)/2/160;
+            chas=area(cx,cy,dx,dy,x3,y3)/2/160;
+            dave=area(dx,dy,ax,ay,x4,y4)/2/160;
+            double all=(area(ax,ay,bx,by,cx,cy)+area(ax,ay,cx,cy,dx,dy))/2/160;
+            emily=all-al-bob-chas-dave;
+            int d=(int)ceil((dis(x1,y1,x2,y2)+dis(x2,y2,x3,y3)+dis(x3,y3,x4,y4)+dis(x4,y4,x1,y1))*16.5);
+            printf("%d %.3f %.3f %.3f %.3f %.3f %d\n",n,al,bob,chas,dave,emily,d);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4243_autoAC.cpp b/HDOJ/4243_autoAC.cpp
new file mode 100644
index 0000000..d5d46bd
--- /dev/null
+++ b/HDOJ/4243_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<algorithm>
+#include<string.h>
+#include<stack>
+#include<queue>
+#include<math.h>
+#include<cstdio>
+#define mem(a,b) memset(a,b,sizeof(a))
+using namespace std;
+const int maxn=500;
+const int inf=0x7fffff;
+double A(double x)
+{
+    double r=1;    
+    for(double i=1;i<=x;i++)
+        r*=i;
+    return r;
+}
+double C(double m,double n)
+{
+    double r=1;
+    for(double i=n-m+1;i<=n;i++)
+        r*=i;
+    for(double i=m;i>=1;i--)
+        r/=i;
+    return r;    
+}
+int main()
+{
+    int t,a;
+    double n,m;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%lf%lf",&a,&n,&m);
+        double ans=0;
+        if(m==1) ans+=A(n-1);
+        else 
+            for(double i=1;i<m;i++)
+            {
+                if(i==1)    
+                    ans+=A(n-2);
+                else ans+=A(n-1-i)*A(i)*C(i-1,m-2);
+            }
+        printf("%d %0.lf\n",a,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4244_autoAC.cpp b/HDOJ/4244_autoAC.cpp
new file mode 100644
index 0000000..dabae31
--- /dev/null
+++ b/HDOJ/4244_autoAC.cpp
@@ -0,0 +1,295 @@
+#include <climits>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <string>
+#include <vector>
+#include <list>
+#include <set>
+#include <map>
+#include <stack>
+#include <queue>
+#include <algorithm>
+#include <iterator>
+#include <utility>
+using namespace std;
+template< class T > T _abs(T n) { return (n < 0 ? -n : n); }
+template< class T > T _max(T a, T b) { return (!(a < b) ? a : b); }
+template< class T > T _min(T a, T b) { return (a < b ? a : b); }
+template< class T > T sq(T x) { return x * x; }
+#define ALL(p) p.begin(),p.end()
+#define MP(x, y) make_pair(x, y)
+#define SET(p) memset(p, -1, sizeof(p))
+#define CLR(p) memset(p, 0, sizeof(p))
+#define MEM(p, v) memset(p, v, sizeof(p))
+#define CPY(d, s) memcpy(d, s, sizeof(s))
+#define SZ(c) (int)c.size()
+#define PB(x) push_back(x)
+#define ff first
+#define ss second
+#define ld long double
+#define pii pair< int, int >
+#define psi pair< string, int >
+const double EPS = 1e-9;
+const int INF = 0x7f7f7f7f;
+struct point {
+    double x,y,z;
+};
+bool eql(point &a,point &b) {
+    return fabs(a.x-b.x)<EPS && fabs(a.y-b.y)<EPS && fabs(a.z-b.z)<EPS;
+}
+double dist(point a,point b) {
+    b.x-=a.x;
+    b.y-=a.y;
+    b.z-=a.z;
+    return sqrt(sq(b.x)+sq(b.y)+sq(b.z));
+}
+double ar(point a,point b,point c) {
+    double x=dist(a,b);
+    double y=dist(b,c);
+    double z=dist(c,a);
+    double s=0.5*(x+y+z);
+    return sqrt(s*(s-x)*(s-y)*(s-z));
+}
+int main() {
+    int i,j,k,l,T,I,cn;
+    double a,b,c,d,x,y,z;
+    point tt[200];
+    double g[3][2]={0};
+    cin>>T;
+    while(T--) {
+        cin>>I>>g[0][1]>>g[1][1]>>g[2][1]>>a>>b>>c>>d;
+        vector < pair < point , point > > r,tr;
+        for(i=0;i<2;i++) {
+            cn=0;
+            x=g[0][i];
+            for(j=0;j<2;j++) {
+                y=g[1][j];
+                z=(d-b*y-a*x)/c;
+                if(z>=0 && z<=g[2][1]) {
+                    tt[cn].x=x;
+                    tt[cn].y=y;
+                    tt[cn].z=z;
+                    cn++;
+                }
+            }
+            if(cn==2) {
+                r.PB(make_pair(tt[0],tt[1]));
+                continue;
+            }
+            for(j=0;j<2;j++) {
+                z=g[2][j];
+                y=(d-c*z-a*x)/b;
+                if(y>=0 && y<=g[1][1]) {
+                    tt[cn].x=x;
+                    tt[cn].y=y;
+                    tt[cn].z=z;
+                    cn++;
+                }
+            }
+            if(cn==2) r.PB(make_pair(tt[0],tt[1]));
+            else if(cn==3) {
+                bool f=1;
+                for(j=0;j<3 && f;j++) for(l=0;l<j && f;l++) if(!eql(tt[j],tt[l])) {
+                    r.PB(make_pair(tt[j],tt[l]));
+                    f=0;
+                }
+            }
+        }
+        for(i=0;i<2;i++) {
+            cn=0;
+            y=g[1][i];
+            for(j=0;j<2;j++) {
+                x=g[0][j];
+                z=(d-b*y-a*x)/c;
+                if(z>=0 && z<=g[2][1]) {
+                    tt[cn].x=x;
+                    tt[cn].y=y;
+                    tt[cn].z=z;
+                    cn++;
+                }
+            }
+            if(cn==2) {
+                r.PB(make_pair(tt[0],tt[1]));
+                continue;
+            }
+            for(j=0;j<2;j++) {
+                z=g[2][j];
+                x=(d-c*z-b*y)/a;
+                if(x>=0 && x<=g[0][1]) {
+                    tt[cn].x=x;
+                    tt[cn].y=y;
+                    tt[cn].z=z;
+                    cn++;
+                }
+            }
+            if(cn==2) r.PB(make_pair(tt[0],tt[1]));
+            else if(cn==3) {
+                bool f=1;
+                for(j=0;j<3 && f;j++) for(l=0;l<j && f;l++) if(!eql(tt[j],tt[l])) {
+                    r.PB(make_pair(tt[j],tt[l]));
+                    f=0;
+                }
+            }
+        }
+        for(i=0;i<2;i++) {
+            cn=0;
+            z=g[2][i];
+            for(j=0;j<2;j++) {
+                y=g[1][j];
+                x=(d-b*y-c*z)/a;
+                if(x>=0 && x<=g[0][1]) {
+                    tt[cn].x=x;
+                    tt[cn].y=y;
+                    tt[cn].z=z;
+                    cn++;
+                }
+            }
+            if(cn==2) {
+                r.PB(make_pair(tt[0],tt[1]));
+                continue;
+            }
+            for(j=0;j<2;j++) {
+                x=g[0][j];
+                y=(d-c*z-a*x)/b;
+                if(y>=0 && y<=g[1][1]) {
+                    tt[cn].x=x;
+                    tt[cn].y=y;
+                    tt[cn].z=z;
+                    cn++;
+                }
+            }
+            if(cn==2) r.PB(make_pair(tt[0],tt[1]));
+            else if(cn==3) {
+                bool f=1;
+                for(j=0;j<3 && f;j++) for(l=0;l<j && f;l++) if(!eql(tt[j],tt[l])) {
+                    r.PB(make_pair(tt[j],tt[l]));
+                    f=0;
+                }
+            }
+        }
+        for(i=0;i<r.size();i++) if(!eql(r[i].first,r[i].second)) tr.PB(r[i]);
+        r=tr;
+        vector < point > ls;
+        j=0;
+        ls.push_back(r[0].first);
+        j=0;
+        for(i=0;i<r.size();i++) {
+            for(k=0;k<r.size();k++) if(k!=j) {
+                if(eql(ls.back(),r[k].first)) {
+                    ls.PB(r[k].second);
+                    break;
+                }
+                if(eql(ls.back(),r[k].second)) {
+                    ls.PB(r[k].first);
+                    break;
+                }
+            }
+            j=k;
+        }
+        double res=0;
+        for(i=0;i<ls.size();i++) 
+        for(i=2;i<ls.size()-1;i++) res+=ar(ls[0],ls[i-1],ls[i]);
+        z=g[2][1];
+        if(fabs(r.back().first.z-z)<=EPS && fabs(r.back().second.z-z)<=EPS) {
+            r.clear();
+            r.PB(tr.back());
+            for(i=0;i<2;i++) {
+                x=g[0][i];
+                if(a*x+b*g[1][0]+c*z<=d && a*x+b*g[1][1]+c*z<=d) {
+                    y=(d-c*z-a*x)/b;
+                    tt[0].x=x;
+                    tt[0].y=g[1][0];
+                    tt[0].z=z;
+                    tt[1].x=x;
+                    tt[1].y=g[1][1];
+                    tt[1].z=z;
+                    r.PB(make_pair(tt[0],tt[1]));
+                }
+                else if(a*x+b*g[1][0]+c*z<=d) {
+                    y=(d-c*z-a*x)/b;
+                    tt[0].x=x;
+                    tt[0].y=g[1][0];
+                    tt[0].z=z;
+                    tt[1].x=x;
+                    tt[1].y=y;
+                    tt[1].z=z;
+                    r.PB(make_pair(tt[0],tt[1]));
+                }
+                else if(a*x+b*g[1][1]+c*z<=d) {
+                    y=(d-c*z-a*x)/b;
+                    tt[0].x=x;
+                    tt[0].y=y;
+                    tt[0].z=z;
+                    tt[1].x=x;
+                    tt[1].y=g[1][1];
+                    tt[1].z=z;
+                    r.PB(make_pair(tt[0],tt[1]));
+                }
+            }
+            for(i=0;i<2;i++) {
+                y=g[1][i];
+                if(a*g[0][0]+b*y+c*z<=d && a*g[0][1]+b*y+c*z<=d) {
+                    x=(d-c*z-b*y)/a;
+                    tt[0].x=g[0][0];
+                    tt[0].y=y;
+                    tt[0].z=z;
+                    tt[1].x=g[0][1];
+                    tt[1].y=y;
+                    tt[1].z=z;
+                    r.PB(make_pair(tt[0],tt[1]));
+                }
+                else if(a*g[0][0]+b*y+c*z<=d) {
+                    x=(d-c*z-b*y)/a;
+                    tt[0].x=g[0][0];
+                    tt[0].y=y;
+                    tt[0].z=z;
+                    tt[1].x=x;
+                    tt[1].y=y;
+                    tt[1].z=z;
+                    r.PB(make_pair(tt[0],tt[1]));
+                }
+                else if(a*g[0][1]+b*y+c*z<=d) {
+                    x=(d-c*z-b*y)/a;
+                    tt[0].x=x;
+                    tt[0].y=y;
+                    tt[0].z=z;
+                    tt[1].x=g[0][1];
+                    tt[1].y=y;
+                    tt[1].z=z;
+                    r.PB(make_pair(tt[0],tt[1]));
+                }
+            }
+            tr.clear();
+            for(i=0;i<r.size();i++) if(!eql(r[i].first,r[i].second)) tr.PB(r[i]);
+            r=tr;
+            for(i=0;i<r.size();i++) {
+            }
+            vector < point > ls;
+            j=0;
+            ls.push_back(r[0].first);
+            j=0;
+            for(i=0;i<r.size();i++) {
+                for(k=0;k<r.size();k++) if(k!=j) {
+                    if(eql(ls.back(),r[k].first)) {
+                        ls.PB(r[k].second);
+                        break;
+                    }
+                    if(eql(ls.back(),r[k].second)) {
+                        ls.PB(r[k].first);
+                        break;
+                    }
+                }
+                j=k;
+            }
+            for(i=0;i<ls.size();i++) 
+            for(i=2;i<ls.size()-1;i++) res+=ar(ls[0],ls[i-1],ls[i]);
+        }
+        cout<<I<<' '<<ceil(res-EPS)<<'\n';
+    }
+    return 0;
+}
diff --git a/HDOJ/4245_autoAC.cpp b/HDOJ/4245_autoAC.cpp
new file mode 100644
index 0000000..99ffd3e
--- /dev/null
+++ b/HDOJ/4245_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+char str[100];
+int cas = 1;
+int main()
+{
+    while(gets(str))
+    {
+        printf("Case %d: ",cas++);
+        int i,j,len;
+        len = strlen(str);
+        if(str[1] == ' ')
+            printf("UNIQUE\n");
+        else
+        {
+            if(str[1] == '#')
+            {
+                if(str[0] == 'G')
+                    printf("Ab");
+                else
+                    printf("%cb",str[0]+1);
+            }
+            else if(str[1] == 'b')
+            {
+                if(str[0] == 'A')
+                printf("G#");
+                else
+                printf("%c#",str[0]-1);
+            }
+            for(i = 2;i<len;i++)
+            printf("%c",str[i]);
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4246_autoAC.cpp b/HDOJ/4246_autoAC.cpp
new file mode 100644
index 0000000..99ffd3e
--- /dev/null
+++ b/HDOJ/4246_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+char str[100];
+int cas = 1;
+int main()
+{
+    while(gets(str))
+    {
+        printf("Case %d: ",cas++);
+        int i,j,len;
+        len = strlen(str);
+        if(str[1] == ' ')
+            printf("UNIQUE\n");
+        else
+        {
+            if(str[1] == '#')
+            {
+                if(str[0] == 'G')
+                    printf("Ab");
+                else
+                    printf("%cb",str[0]+1);
+            }
+            else if(str[1] == 'b')
+            {
+                if(str[0] == 'A')
+                printf("G#");
+                else
+                printf("%c#",str[0]-1);
+            }
+            for(i = 2;i<len;i++)
+            printf("%c",str[i]);
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4247_autoAC.cpp b/HDOJ/4247_autoAC.cpp
new file mode 100644
index 0000000..5e61574
--- /dev/null
+++ b/HDOJ/4247_autoAC.cpp
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int main()
+{
+    int a[4],cas = 1;
+    int x,y,ans;
+    while(~scanf("%d%d%d%d",&a[0],&a[1],&a[2],&a[3]))
+    {
+        sort(a,a+4);
+        printf("Case %d: %d\n",cas++,a[2]+a[3]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4248_autoAC.cpp b/HDOJ/4248_autoAC.cpp
new file mode 100644
index 0000000..d1da434
--- /dev/null
+++ b/HDOJ/4248_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <cstdio>
+#include <cstring>
+typedef long long Long;
+const int MOD = 1000000007;
+int C[11111][111];
+void init() {
+    C[0][0] = C[1][0] = C[1][1] = 1;
+    for (int i = 2; i <= 10101; i++) {
+        for (int j = 0; j <= i && j <= 100; j++) {
+            if (j == 0) C[i][j] = 1;
+            else C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
+        }
+    }
+}
+int dp[111][11111];
+int a[111];
+int main() {
+    init();
+    for (int ii = 1;;ii++) {
+        int n; if (scanf("%d",&n) == -1) break;
+        memset(dp,0,sizeof(dp));
+        memset(a,0,sizeof(a));
+        for (int i = 0; i < n; i++) {
+            scanf("%d",a + i);
+        }
+        for (int i = 0; i <= a[0]; i++) dp[0][i] = 1;
+        int maxlen = a[0];
+        for (int now = 0; now < n - 1; now ++) {
+            int next = now + 1;
+            for (int len = 0; len <= maxlen; len++) {
+                if (dp[now][len] == 0) continue;
+                dp[next][len] += dp[now][len];
+                if (dp[next][len] >= MOD) dp[next][len] -= MOD;
+                Long tmp = dp[now][len];
+                for (int put = 1; put <= a[next]; put++) {
+                    Long tt = tmp * C[len + put][put] % MOD;
+                    dp[next][len + put] += tt;
+                    if (dp[next][len + put] >= MOD) dp[next][len + put] -= MOD;
+                }
+            }
+            maxlen += a[next];
+        }
+        int ans = 0;
+        for (int i = 1; i <= maxlen; i++) ans = (ans + dp[n - 1][i]) % MOD;
+        printf("Case %d: %d\n",ii,ans);
+    }    
+    return 0;
+}
diff --git a/HDOJ/4249_autoAC.cpp b/HDOJ/4249_autoAC.cpp
new file mode 100644
index 0000000..7699edf
--- /dev/null
+++ b/HDOJ/4249_autoAC.cpp
@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+char str[105];
+int a[15];
+int b[15];
+int c[15];
+long long dp[10][2];
+int main()
+{
+    int i,j,n,tag,t,aup,bup,cup,cnt=1,x,y,z,p,q,r;
+    while(scanf("%s",str)!=EOF)
+    {
+        memset(dp,0,sizeof(dp));
+        n=strlen(str);
+        tag=0;
+        aup=bup=cup=0;
+        for (i=n-1;i>=0;i--)
+        {
+            if (str[i]=='=' || str[i]=='+') tag++;
+            else
+            {
+                t=str[i]=='?'?-1:(str[i]-'0');
+                if (tag==0) c[cup++]=t;
+                if (tag==1) b[bup++]=t;
+                if (tag==2) a[aup++]=t;
+            }
+        }
+        if (cup<max(aup,bup))
+        {
+            printf("Case %d: 0\n",cnt++);
+            continue;
+        }
+        for (i=aup;i<=cup;i++)
+        {
+            a[i]=0;
+        }
+        for (i=bup;i<=cup;i++)
+        {
+            b[i]=0;
+        }
+        for (i=0;i<cup;i++)
+        {
+            for (x=0;x<=9;x++)
+            {
+                if (i==aup-1 && aup!=1 && x==0 && a[i]==-1) continue;
+                if (a[i]!=-1 && x>=1) continue;
+                for (y=0;y<=9;y++)
+                {
+                    if (i==bup-1 && bup!=1 && y==0 && b[i]==-1) continue;
+                    if (b[i]!=-1 && y>=1) continue;
+                    for (z=0;z<=9;z++)
+                    {
+                        if (i==cup-1 && cup!=1 && z==0 && c[i]==-1) continue;
+                        if (c[i]!=-1 && z>=1) continue;
+                        p=a[i]==-1?x:a[i];
+                        q=b[i]==-1?y:b[i];
+                        r=c[i]==-1?z:c[i];
+                        if (p+q==r)
+                        {
+                            if (i==0) dp[i][0]++;
+                            else dp[i][0]+=dp[i-1][0];
+                        }
+                        if (p+q==10+r)
+                        {
+                            if (i==0) dp[i][1]++;
+                            else dp[i][1]+=dp[i-1][0];
+                        }
+                        if (p+q+1==r && i!=0)
+                        {
+                            dp[i][0]+=dp[i-1][1];
+                        }
+                        if (p+q+1==r+10 && i!=0)
+                        {
+                            dp[i][1]+=dp[i-1][1];
+                        }
+                    }
+                }
+            }
+         }
+        printf("Case %d: %I64d\n",cnt++,dp[cup-1][0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4251_autoAC.cpp b/HDOJ/4251_autoAC.cpp
new file mode 100644
index 0000000..635dccf
--- /dev/null
+++ b/HDOJ/4251_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<iostream>
+#include<algorithm>
+using namespace std;
+const int N=100010;
+int srted[N];
+struct node
+{
+    int num[N];
+    int val[N];
+}t[40];
+int n,m;
+void build(int l,int r,int d)
+{
+    if(l==r) return;
+    int mid=(l+r)>>1;
+    int midd=srted[mid];
+    int same=mid-l+1,samed=0,zn=l-1,yn=mid,i;
+    for(i=l;i<=r;++i)
+        if(t[d].val[i]<midd) --same;
+    for(i=l;i<=r;++i)
+    {
+        if(i==l) t[d].num[i]=0;
+        else t[d].num[i]=t[d].num[i-1];
+        if(t[d].val[i]<midd)
+        {
+            ++t[d].num[i];
+            t[d+1].val[++zn]=t[d].val[i];
+        }else if(t[d].val[i]>midd)
+        {
+            t[d+1].val[++yn]=t[d].val[i];
+        }else
+        {
+            if(samed<same)
+            {
+                ++samed;
+                ++t[d].num[i];
+                t[d+1].val[++zn]=t[d].val[i];
+            }else
+                t[d+1].val[++yn]=t[d].val[i];
+        }
+    }
+    build(l,mid,d+1);
+    build(mid+1,r,d+1);
+}
+int query(int a,int b,int k,int l,int r,int d)
+{
+    if(a==b) return t[d].val[a];
+    int mid=(l+r)>>1;
+    int sx=t[d].num[a-1],sy=t[d].num[b];
+    if(a-1<l) sx=0;
+    if(sy-sx>=k)
+        return query(l+sx,l+sy-1,k,l,mid,d+1);
+    else
+    {
+        int s1=(a==1?0:a-l-sx);
+        int s2=(b-a+1)-(sy-sx);
+        int nk=k-(sy-sx);
+        return query(mid+1+s1,mid+s1+s2,nk,mid+1,r,d+1);
+    }
+}
+int main()
+{
+    int cas=1;
+    int i,a,b;
+    while(cin>>n)
+    {
+        cout<<"Case "<<cas++<<":"<<endl;
+        for(i=1;i<=n;++i)
+        {
+            cin>>srted[i];
+            t[0].val[i]=srted[i];
+        }
+        sort(srted+1,srted+1+n);
+        build(1,n,0);
+        cin>>m;
+        for(i=1;i<=m;++i)
+        {
+            cin>>a>>b;
+            cout<<query(a,b,(a+b)/2-a+1,1,n,0)<<endl;
+        }
+    }
+}
diff --git a/HDOJ/4252_autoAC.cpp b/HDOJ/4252_autoAC.cpp
new file mode 100644
index 0000000..21ec3be
--- /dev/null
+++ b/HDOJ/4252_autoAC.cpp
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int a[1000005],x,len;
+int main()
+{
+    int n,i,cas = 1,ans,j;
+    while(~scanf("%d",&n))
+    {
+        ans = 0;
+        for(i = 0; i<n; i++)
+            scanf("%d",&a[i]);
+        if(a[0]==0)
+            ans++;
+        for(i = 1; i<n; i++)
+        {
+            if(a[i]==0)
+                ans++;
+            else
+            {
+                for(j = i-1; j>=0; j--)
+                {
+                    if(a[i]>a[j])
+                        break;
+                    else if(a[i]==a[j])
+                    {
+                        ans++;
+                        break;
+                    }
+                }
+            }
+        }
+        printf("Case %d: %d\n",cas++,n-ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4253_autoAC.cpp b/HDOJ/4253_autoAC.cpp
new file mode 100644
index 0000000..1ef8c83
--- /dev/null
+++ b/HDOJ/4253_autoAC.cpp
@@ -0,0 +1,114 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+struct node
+{
+    int v1,v2;
+    int w;
+} s[100005],t[100005];
+int n,m,k,cnts,cntt;
+int father[100005],sum;
+int cmp(const node a,const node b)
+{
+    if(a.w<b.w)
+        return 1;
+    else
+        return 0;
+}
+int find(int x)
+{
+    int i=x,root;
+    while(x!=father[x])
+        x=father[x];
+    root=x;
+    x=i;
+    while(x!=father[x])
+    {
+        i=father[x];
+        father[x]=root;
+        x=i;
+    }
+    return root;
+}
+int deal(int x)
+{
+    for(int i=0; i<=n; i++)
+        father[i]=i;
+    int lens=0,lent=0,pp=0;
+    sum=0;
+    while(lens<cnts||lent<cntt)
+    {
+        if(s[lens].w+x<=t[lent].w)
+        {
+            int s1=find(s[lens].v1);
+            int s2=find(s[lens].v2);
+            if(s1!=s2)
+            {
+                father[s1]=s2;
+                sum+=s[lens].w+x;
+                pp++;
+            }
+            lens++;
+        }
+        else
+        {
+            int s1=find(t[lent].v1);
+            int s2=find(t[lent].v2);
+            if(s1!=s2)
+            {
+                father[s1]=s2;
+                sum+=t[lent].w;
+            }
+            lent++;
+        }
+    }
+    if(pp>=k)   return 1;
+    else    return 0;
+}
+int main()
+{
+    int text=0;
+    while(scanf("%d%d%d",&n,&m,&k)>0)
+    {
+        cnts=0,cntt=0;
+        for(int i=0; i<m; i++)
+        {
+            int v1,v2,w,tmp;
+            scanf("%d%d%d%d",&v1,&v2,&w,&tmp);
+            if(tmp==0)
+            {
+                s[cnts].v1=v1;
+                s[cnts].v2=v2;
+                s[cnts].w=w;
+                cnts++;
+            }
+            if(tmp==1)
+            {
+                t[cntt].v1=v1;
+                t[cntt].v2=v2;
+                t[cntt].w=w;
+                cntt++;
+            }
+        }
+        sort(s,s+cnts,cmp);
+        sort(t,t+cntt,cmp);
+        t[cntt].w=s[cnts].w=(1<<29);
+        printf("Case %d: ",++text);
+        int l=-1000,r=1000;
+        int ans=0;
+        while(l<=r)
+        {
+            int mid=(l+r)/2;
+            if(deal(mid))
+            {
+                l=mid+1;
+                ans=sum-mid*k;
+            }
+            else r=mid-1;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4254_autoAC.cpp b/HDOJ/4254_autoAC.cpp
new file mode 100644
index 0000000..392542e
--- /dev/null
+++ b/HDOJ/4254_autoAC.cpp
@@ -0,0 +1,24 @@
+#include<stdio.h>
+#include<math.h>
+int N, P, Q;
+double f[200005];
+double logC(int n, int m) {
+    return f[n]-f[m]-f[n-m];
+}
+int main() {
+    int test = 0;
+    for(int i=1; i<=200000; i++)
+     f[i] = f[i-1] + log(0.0+i);
+    while(scanf("%d%d%d", &N, &P, &Q) != EOF) {
+        double a = 0, b = 0;
+        for(int red=Q; red<=N-(P-Q); red++) {
+            int blue = N - red;
+            double p = exp(logC(red, Q) + logC(N-red, P - Q) - logC(N, P));
+            double q = (red - Q + 0.0) / (N - P);
+            a += p * q;
+            b += p;
+        }
+        printf("Case %d: %.4lf\n", ++test, a/b);
+    }
+    return 0;
+}
diff --git a/HDOJ/4255_autoAC.cpp b/HDOJ/4255_autoAC.cpp
new file mode 100644
index 0000000..2a4af7e
--- /dev/null
+++ b/HDOJ/4255_autoAC.cpp
@@ -0,0 +1,110 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<queue>
+#define N 40400
+#define MAX 210
+#define CNT 4000
+using namespace std;
+bool isprime[N];
+int prime[CNT],cnt;
+int map[MAX][MAX];
+bool visited[MAX][MAX];
+struct point{int x,y,step;};
+void find_prime()
+{
+    int i,j;
+    cnt=0;
+    memset(isprime,true,sizeof(isprime));
+    isprime[1]=false;
+    for(i=2;i<N;i++)
+    {
+        if(isprime[i])
+        {
+            prime[cnt++]=i;
+            for(j=2*i;j<N;j=j+i) isprime[j]=false;
+        }
+    }
+}
+void build_map(int p,int q,int s,int c)
+{
+    if(s==0) return ;
+    int i;
+    for(i=q;i<q+c;i++)   map[p][i]=s--;
+    for(i=p+1;i<p+c;i++) map[i][q+c-1]=s--;
+    for(i=q+c-2;i>q;i--) map[p+c-1][i]=s--;
+    for(i=p+c-1;i>p;i--) map[i][q]=s--;
+    build_map(p+1,q+1,s,c-2);
+}
+int t_i,t_j;
+void find(int u)
+{
+    int i,j;
+    for(i=1;i<=200;i++)
+    {
+        for(j=1;j<=200;j++)
+        {
+            if(u==map[i][j])
+            {
+                t_i=i;t_j=j;
+                return ;
+            }
+        }
+    }
+}
+int BFS(int u,int v)
+{
+    find(u);
+    point t,tt;
+    t.x=t_i;t.y=t_j;t.step=0;
+    queue<point>Q;
+    while(!Q.empty()) Q.pop();
+    Q.push(t);
+    visited[t.x][t.y]=true;
+    while(!Q.empty())
+    {
+        t=Q.front();Q.pop();
+        if(map[t.x][t.y]==v) return t.step;
+        if(t.x-1>=1&&!visited[t.x-1][t.y]&&!isprime[map[t.x-1][t.y]])
+        {
+            tt.x=t.x-1;tt.y=t.y;tt.step=t.step+1;
+            Q.push(tt);
+            visited[tt.x][tt.y]=true;
+        }
+        if(t.x+1<=200&&!visited[t.x+1][t.y]&&!isprime[map[t.x+1][t.y]])
+        {
+            tt.x=t.x+1;tt.y=t.y;tt.step=t.step+1;
+            Q.push(tt);
+            visited[tt.x][tt.y]=true;
+        }
+        if(t.y-1>=1&&!visited[t.x][t.y-1]&&!isprime[map[t.x][t.y-1]])
+        {
+            tt.x=t.x;tt.y=t.y-1;tt.step=t.step+1;
+            Q.push(tt);
+            visited[tt.x][tt.y]=true;
+        }
+        if(t.y+1<=200&&!visited[t.x][t.y+1]&&!isprime[map[t.x][t.y+1]])
+        {
+            tt.x=t.x;tt.y=t.y+1;tt.step=t.step+1;
+            Q.push(tt);
+            visited[tt.x][tt.y]=true;
+        }
+    }
+    return 0;
+}
+int main()
+{
+    int u,v,k=1;
+    memset(map,0,sizeof(map));
+    find_prime();
+    build_map(1,1,40000,200);
+    while(scanf("%d%d",&u,&v)!=EOF)
+    {
+        memset(visited,false,sizeof(visited));
+        int ans;
+        ans=BFS(u,v);
+        if(ans) printf("Case %d: %d\n",k++,ans);
+        else printf("Case %d: impossible\n",k++);
+    }
+    return 0;
+}
diff --git a/HDOJ/4256_autoAC.cpp b/HDOJ/4256_autoAC.cpp
new file mode 100644
index 0000000..90a6249
--- /dev/null
+++ b/HDOJ/4256_autoAC.cpp
@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int main()
+{
+    char str[20][10] = {"#","I","II","III","IV","V","VI","VII","VIII","IX","X","XI","XII"};
+    char s[10];
+    int i,cas = 1;
+    while(~scanf("%s",s))
+    {
+        for(i = 1;i<=12;i++)
+        {
+            if(strcmp(s,str[i])==0)
+            {
+                printf("Case %d: %d\n",cas++,i);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4258_autoAC.cpp b/HDOJ/4258_autoAC.cpp
new file mode 100644
index 0000000..87cd7b0
--- /dev/null
+++ b/HDOJ/4258_autoAC.cpp
@@ -0,0 +1,51 @@
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+#include <cstring>
+using namespace std;
+int N,C;
+long long a[1000010];
+long long f[1000010];
+struct point
+{
+    int id;
+    long long  x,y;
+    point(int a,long long b,long long c)
+    {
+        id = a;x = b;y = c;
+    }
+    point(){};
+};
+long long  solve()
+{
+    static point s[1000010];
+    int head = 1,tail = 0;
+    long long temp;
+    for (int i = 1;i <= N;i++)
+    {
+        point p(i-1,a[i],f[i-1]+ a[i]*a[i]);
+        while(tail-1 >= head && (s[tail].x - s[tail-1].x)*(p.y - s[tail].y) - (s[tail].y - s[tail-1].y) *(p.x - s[tail].x) <0)
+            tail --;
+        s[++tail] = p;
+        while (head <= tail && (temp = s[head].y - 2*a[i]*s[head].x+a[i]*a[i] + C,temp < f[i]||f[i] == -1))
+        {
+            f[i] = temp;
+            head++;
+        }
+        head--;
+    }
+    return f[N];
+}
+int main()
+{
+    while(scanf("%d%d",&N,&C),N+C)
+    {
+        a[0] = 0;
+        for(int i = 1;i <= N;i++)
+            scanf("%d",&a[i]);
+        memset(f,-1,sizeof(f));
+        f[0] = 0;
+        printf("%I64d\n",solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/4259_autoAC.cpp b/HDOJ/4259_autoAC.cpp
new file mode 100644
index 0000000..a27a01f
--- /dev/null
+++ b/HDOJ/4259_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <cmath>
+#include <stack>
+using namespace std;
+const int MAXN = 1805;
+int a[2][MAXN], vst[MAXN], cnt;
+int myS[MAXN][MAXN], top[MAXN];
+void init()
+{
+    memset(vst, 0, sizeof(vst));
+}
+void dfs(int x)
+{
+    cnt++;
+    vst[x] = 1;
+    int nx = a[1][x];
+    if(!vst[nx])
+    {
+        dfs(nx);
+    }
+}
+__int64 gcd1(__int64 a, __int64 b)
+{
+    __int64 r = b, t;
+    while(r)
+    {
+        t = r;
+        r = a % r;
+        a = t;
+    }
+    return a;
+}
+__int64 gcd2(__int64 a, __int64 b)
+{
+    return b == 0 ?  a : gcd2(b, a % b);
+}
+int main(void)
+{
+    int n, k;
+    while(scanf("%d %d", &n, &k), n || k)
+    {
+        init();
+        for(int i = 0; i < n; i++)
+        {
+            int in = i % k;
+            myS[in][top[in]++] = i;
+        }
+        int s = 0;
+        for(int i = 0; i < n; i++)
+            a[0][i] = i;
+        for(int in = 0; in < k; in++)
+        {
+            while(top[in])
+            {
+                a[1][s++] = myS[in][--top[in]];
+            }
+        }
+        int c = 0;
+        __int64 res[MAXN];
+        for(int i = 0; i < n; i++)
+        {
+            if(!vst[i])
+            {
+                cnt = 0;
+                dfs(i);
+                res[c++] = cnt;
+            }
+        }
+        __int64 tmp;
+        if(c >= 2)
+        {
+            tmp = res[0] / gcd2(res[0], res[1]) * res[1];
+            for(int i = 2; i < c; i++)
+                tmp = tmp / gcd2(tmp, res[i]) * res[i];
+        }
+        else if(c == 1)
+            tmp = res[0];
+        printf("%I64d\n", tmp);
+    }
+    return 0;
+}
diff --git a/HDOJ/4260_autoAC.cpp b/HDOJ/4260_autoAC.cpp
new file mode 100644
index 0000000..790d64c
--- /dev/null
+++ b/HDOJ/4260_autoAC.cpp
@@ -0,0 +1,19 @@
+#include<iostream>
+#include<string>
+using namespace std;
+string s;
+long long cal(long long x,char goal)
+{
+    for(long long i=x;i>=0;i--)
+    if(s[i]!=goal) return cal(i-1,'A'^'B'^'C'^goal^s[i])+(1LL<<i);
+    return 0;
+}
+int main()
+{
+    while(cin>>s,s!="X")
+    {
+        long long ans=cal(s.length()-1,'B');
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4261_autoAC.cpp b/HDOJ/4261_autoAC.cpp
new file mode 100644
index 0000000..db22998
--- /dev/null
+++ b/HDOJ/4261_autoAC.cpp
@@ -0,0 +1,82 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <map>
+#include <stack>
+#include <vector>
+#include <set>
+#include <queue>
+#pragma comment (linker,"/STACK:102400000,102400000")
+#define maxn 70
+#define MAXN 31290
+#define OO (1<<31)-1
+#define mod 100000000
+#define INF 0x3f3f3f3f
+#define pi acos(-1.0)
+#define eps 1e-6
+typedef long long ll;
+using namespace std;
+int n,m,ans,cnt,tot,flag;
+int a[2005],dp[30][2005],w[2005][2005];
+int main()
+{
+    int i,j,k,t,num1,num2,sum;
+    while(scanf("%d%d",&n,&m),n|m)
+    {
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d",&a[i]);
+        }
+        for(i=1;i<=n;i++)
+        {
+            priority_queue<int>lower;
+            priority_queue<int,vector<int>,greater<int> >upper;
+            sum=0;
+            for(j=i;j<=n;j++)
+            {
+                if(upper.empty()||a[j]>=upper.top())
+                {
+                    upper.push(a[j]);
+                    sum+=a[j];
+                }
+                else
+                {
+                    lower.push(a[j]);
+                    sum-=a[j];
+                }
+                num1=(j-i+1)/2; num2=j-i+1-num1;  
+                if(lower.size()>num1)
+                {
+                    upper.push(lower.top());
+                    sum+=2*lower.top();
+                    lower.pop();
+                }
+                else if(upper.size()>num2)
+                {
+                    lower.push(upper.top());
+                    sum-=2*upper.top();
+                    upper.pop();
+                }
+                if(num2>num1) w[i][j]=sum-upper.top();
+                else w[i][j]=sum;
+            }
+        }
+        for(i=0;i<=m;i++) for(j=0;j<=n;j++) dp[i][j]=INF;
+        dp[0][0]=0;
+        for(i=1;i<=m;i++)
+        {
+            for(j=i;j<=n;j++)
+            {
+                for(k=0;k<j;k++)
+                {
+                    dp[i][j]=min(dp[i][j],dp[i-1][k]+w[k+1][j]);
+                }
+            }
+        }
+        printf("%d\n",dp[m][n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4262_autoAC.cpp b/HDOJ/4262_autoAC.cpp
new file mode 100644
index 0000000..6fc1793
--- /dev/null
+++ b/HDOJ/4262_autoAC.cpp
@@ -0,0 +1,60 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define lson u<<1
+#define rson u<<1|1
+#define MAXN 100005
+int map[MAXN];
+struct Node{
+    int lef,rig;
+    int sum;
+}T[MAXN<<2];
+void PushUp(int u){
+    T[u].sum=T[lson].sum+T[rson].sum;
+}
+void Build(int u,int l,int r){
+    T[u].lef=l;
+    T[u].rig=r;
+    if(l==r){T[u].sum=1;return;}
+    int mid=(l+r)>>1;
+    Build(lson,l,mid);
+    Build(rson,mid+1,r);
+    PushUp(u);
+}
+void Update(int u,int pos,int val){
+    if(T[u].lef==T[u].rig){T[u].sum=val;return;}
+    if(pos<=T[lson].rig)Update(lson,pos,val);
+    else Update(rson,pos,val);
+    PushUp(u);
+}
+int Query(int u,int l,int r){
+        if(l<=T[u].lef&&T[u].rig<=r)return T[u].sum;
+        if(r<=T[lson].rig)return Query(lson,l,r);
+        if(l>=T[rson].lef)return Query(rson,l,r);
+        return Query(lson,l,T[lson].rig)+Query(rson,T[rson].lef,r);
+}
+int main(){
+    int n;
+    while(scanf("%d",&n)&&n){
+        int tmp;
+        for(int i=1;i<=n;i++){
+            scanf("%d",&tmp);
+            map[tmp]=i;
+        }
+        Build(1,1,n);
+        int cur=1;
+        __int64 ans=n;
+        for(int i=1;i<n;i++){
+            if(i==1)tmp=Query(1,cur,map[i])-1;
+            else if(map[i]>cur)tmp=Query(1,cur+1,map[i])-1;
+            else tmp=Query(1,map[i],cur-1);
+            ans+=min(tmp,n-i+1-tmp);
+            Update(1,map[i],0);
+            cur=map[i];
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4263_autoAC.cpp b/HDOJ/4263_autoAC.cpp
new file mode 100644
index 0000000..a141783
--- /dev/null
+++ b/HDOJ/4263_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+const int maxx = 1010;
+int Find(int x,int father[])
+{
+    while(x!=father[x]) x = father[x];
+    return x;
+}
+void Union(int r1, int r2, int& counter,int father[])
+{
+    int a = Find(r1,father);
+    int b = Find(r2,father);
+    if(a!=b)
+    {
+        counter++;
+        father[a] = b;
+    }
+}
+void ini(int n,int father[])
+{
+    for(int i=1; i<=n; i++)
+        father[i] = i;
+}
+int main()
+{
+    int n,m,k;
+    int father_r[maxx];
+    int father_b[maxx];
+    while(scanf("%d %d %d",&n,&m,&k),n||m||k)
+    {
+        ini(n,father_r);
+        ini(n,father_b);
+        int counter_r,counter_b;
+        counter_r = counter_b = 0;
+        for(int i=1; i<=m; i++)
+        {
+            char ch=0;
+            while(ch!='B'&&ch!='R')
+                ch=getchar();
+            int u,v;
+            scanf("%d%d",&u,&v);
+            if(ch=='B')
+                Union(u,v,counter_b,father_b);
+            else
+                Union(u,v,counter_r,father_r);
+        }
+        if(k<=counter_b && k>=n-counter_r-1)
+            printf("1\n");
+        else
+            printf("0\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4264_autoAC.cpp b/HDOJ/4264_autoAC.cpp
new file mode 100644
index 0000000..6f96a40
--- /dev/null
+++ b/HDOJ/4264_autoAC.cpp
@@ -0,0 +1,163 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<cmath>
+#include<vector>
+#define eps 1e-8
+#define N 200
+using namespace std;
+const double PI=acos(-1.0);
+int dlcmp(double x)
+{
+    return x<-eps?-1:x>eps;
+}
+struct Point
+{
+    double x,y;
+    Point(){}
+    Point(double a,double b):x(a),y(b){}
+    Point operator + (const Point a) const {return Point(x+a.x,y+a.y);}
+    Point operator - (const Point a) const {return Point(x-a.x,y-a.y);}
+    Point operator * (const double a) const {return Point(x*a,y*a);}
+    Point operator / (const double a) const {return Point(x/a,y/a);}
+    bool operator == (const Point a)
+    {
+        return !dlcmp(x-a.x)&&!dlcmp(y-a.y);
+    }
+    Point trunc(double d) const
+    {
+        double dis(Point,Point);
+        double len=dis(*this,Point(0,0));
+        return Point(x*d/len,y*d/len);
+    }
+    Point rotate(double a)
+    {
+        return Point(x*cos(a)-y*sin(a),y*cos(a)+x*sin(a));
+    }
+};
+struct Circle
+{
+    Point o;
+    double r;
+    Circle(){}
+    Circle(Point a,double l):o(a),r(l){}
+};
+struct node
+{
+    double s,e;
+    node(){}
+    node(double a,double b):s(a),e(b){}
+};
+Circle c[N],red,purple;
+vector<node>arc;
+double sqr(double x)
+{
+    return x*x;
+}
+double fix(double x)
+{
+    if (dlcmp(x-1)>=0)
+        return 1;
+    if (dlcmp(x+1)<=0)
+        return -1;
+    return x;
+}
+double dis(Point a,Point b)
+{
+    return sqrt(sqr(a.x-b.x)+sqr(a.y-b.y));
+}
+void get_InCommonTangent(Circle c1,Circle c2,Point &s1,Point &e1,Point &s2,Point &e2)
+{
+    double l=dis(c1.o,c2.o);
+    double d=l*c1.r/(c1.r+c2.r);
+    double tmp=c1.r/d;
+    tmp=fix(tmp);
+    double theta=acos(tmp);
+    Point vec=c2.o-c1.o;
+    vec=vec.trunc(c1.r);
+    s1=c1.o+vec.rotate(theta);
+    s2=c1.o+vec.rotate(-theta);
+    vec=c1.o-c2.o;
+    vec=vec.trunc(c2.r);
+    e1=c2.o+vec.rotate(theta);
+    e2=c2.o+vec.rotate(-theta);
+}
+void inter_circle_ray(Circle c,Point s,Point e,Point &p)
+{
+    Point vec=e-s;
+    double A=sqr(vec.x)+sqr(vec.y);
+    double B=2*(vec.x*(s.x-c.o.x)+vec.y*(s.y-c.o.y));
+    double C=sqr(s.x-c.o.x)+sqr(s.y-c.o.y)-sqr(c.r);
+    double delta=sqr(B)-4*A*C;
+    delta=fabs(delta);
+    double k=(-B+sqrt(delta))/(2*A);
+    p=s+vec*k;
+}
+double get_angle(Point a)
+{
+    return atan2(a.y,a.x);
+}
+double cmp(node a,node b)
+{
+    if (dlcmp(a.s-b.s)==0)
+        return dlcmp(a.e-b.e)<0;
+    else
+        return dlcmp(a.s-b.s)<0;
+}
+int main()
+{
+    int n,p,x,y,r,i,j;
+    double ans,sum,cur;
+    node u,v;
+    Point s1,e1,s2,e2,vec,p1,p2;
+    while (scanf("%d%d%d%d%d",&n,&p,&x,&y,&r),n||p||x||y||r)
+    {
+        purple.o=Point(0,0);
+        purple.r=(double)p;
+        red.o.x=(double)x;
+        red.o.y=(double)y;
+        red.r=(double)r;
+        arc.clear();
+        for (i=0;i<n;i++)
+            scanf("%lf%lf%lf",&c[i].o.x,&c[i].o.y,&c[i].r);
+        for (i=0;i<n;i++)
+        {
+            get_InCommonTangent(red,c[i],s1,e1,s2,e2);
+            if (s1==e1)
+            {
+                vec=c[i].o-red.o;
+                e1=s1+vec.rotate(PI/2);
+                e2=s2+vec.rotate(-PI/2);
+            }
+            inter_circle_ray(purple,s1,e1,p1);
+            inter_circle_ray(purple,s2,e2,p2);
+            u.s=get_angle(p1);
+            u.e=get_angle(p2);
+            if (u.s>u.e)
+            {
+                arc.push_back(node(u.s,PI));
+                arc.push_back(node(-PI,u.e));
+            }
+            else
+                arc.push_back(u);
+        }
+        sort(arc.begin(),arc.end(),cmp);
+        sum=arc[0].e-arc[0].s;
+        cur=arc[0].e;
+        for (i=1;i<arc.size();i++)
+        {
+            if (dlcmp(arc[i].e-cur)<=0)
+                continue;
+            if (dlcmp(arc[i].s-cur)>0)
+                sum+=arc[i].e-arc[i].s;
+            else
+                sum+=arc[i].e-cur;
+            cur=arc[i].e;
+        }
+        ans=(2*PI-sum)/(2*PI);
+        if (ans<0)
+            ans=0;
+        printf("%.4f\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4265_autoAC.cpp b/HDOJ/4265_autoAC.cpp
new file mode 100644
index 0000000..5364a46
--- /dev/null
+++ b/HDOJ/4265_autoAC.cpp
@@ -0,0 +1,185 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <set>
+#include <vector>
+#include <map>
+#include <queue>
+#include <set>
+#include <algorithm>
+#include <limits>
+using namespace std;
+typedef long long LL;
+const int MAXN=1e+3;
+const int MAXM=1e+5;
+const int INF = numeric_limits<int>::max();
+const LL LL_INF= numeric_limits<LL>::max();
+struct Edge
+{
+    int from,to;
+    LL ci;int next;
+    Edge(){}
+    Edge(int _from,int _to,LL _ci,int _next):from(_from),to(_to),ci(_ci),next(_next){}
+}e[MAXM],e1[MAXM];
+int head[MAXN],tot;
+int dis[MAXN];
+int top,sta[MAXN],cur[MAXN],tmp[MAXN];
+int vis1[100],vis2[MAXM];
+int n;
+inline void init(){
+    memset(head,-1,sizeof(head));
+    tot=0;
+}
+inline void AddEdge(int u,int v,LL ci0,LL ci1=0){
+    e[tot]=Edge(u,v,ci0,head[u]);
+    head[u]=tot++;
+    e[tot]=Edge(v,u,ci1,head[v]);
+    head[v]=tot++;
+}
+inline bool bfs(int st,int et){
+    memset(dis,0,sizeof(dis));
+    dis[st]=1;
+    queue <int> q;
+    q.push(st);
+    while(!q.empty()){
+        int now=q.front();
+        q.pop();
+        for(int i=head[now];i!=-1;i=e[i].next){
+            int next=e[i].to;
+            if(vis2[i])continue;
+            if(e[i].ci&&!dis[next]){
+                dis[next]=dis[now]+1;
+                if(next==et)return true;
+                q.push(next);
+            }
+        }
+    }
+    return false;
+}
+LL Dinic(int st,int et){
+    LL ans=0;
+    while(bfs(st,et)){
+        top=0;
+        memcpy(cur,head,sizeof(head));
+        int u=st,i;
+        while(1){
+            if(u==et){
+                int pos;
+                LL minn=LL_INF;
+                for(i=0;i<top;i++)
+                {
+                    if(minn>e[sta[i]].ci){
+                        minn=e[sta[i]].ci;
+                        pos=i;
+                    }
+                }
+                for(i=0;i<top;i++){
+                    e[sta[i]].ci-=minn;
+                    e[sta[i]^1].ci+=minn;
+                }
+                top=pos;
+                u=e[sta[top]].from;
+                ans+=minn;
+            }
+            for(i=cur[u];i!=-1;cur[u]=i=e[i].next)
+                if(vis2[i]);
+                else if(e[i].ci&&dis[u]+1==dis[e[i].to])break;
+            if(cur[u]!=-1){
+                sta[top++]=cur[u];
+                u=e[cur[u]].to;
+            }
+            else {
+                if(top==0)break;
+                dis[u]=0;
+                u=e[sta[--top]].from;
+            }
+        }
+    }
+    return ans;
+}
+int main()
+{
+    char ch;
+    while(~scanf("%d",&n)&&n){
+        init();
+        memset(vis2,0,sizeof(vis2));
+        for(int i=1;i<=n;i++){
+        for(int j=1;j<=n;j++){
+            scanf(" %c",&ch);
+            if(ch=='Y'){
+                AddEdge(i,j+n,1);
+            }
+        }
+        }
+        memcpy(e1,e,sizeof(e));
+        memcpy(tmp,head,sizeof(head));
+        int st=500,et=501;
+        int ttot=tot;
+        int l=0,r=100,ans=0,mid;
+        while(l<=r){
+            mid=(l+r)>>1;
+            for(int i=1;i<=n;i++){
+                AddEdge(st,i,mid);
+                AddEdge(i+n,et,mid);
+            }
+            if(Dinic(st,et)==(LL)n*mid){
+                ans=mid;
+                //if(ans<mid)ans=mid;
+                l=mid+1;
+            }
+            else r=mid-1;
+            memcpy(e,e1,sizeof(e));
+            memcpy(head,tmp,sizeof(head));
+            tot=ttot;
+        }
+        printf("%d\n",ans);
+        for(int i=1;i<=n;i++){
+            AddEdge(st,i,ans);
+            AddEdge(i+n,et,ans);
+        }
+        Dinic(st,et);
+        for(int i=1;i<=n;i++){
+            for(int j=head[i];~j;j=e[j].next){
+                if(e[j].ci&&e[j].to!=st){
+                    vis2[j^1]=vis2[j]=1;
+                }
+            }
+        }
+        memcpy(e,e1,sizeof(e));
+        memcpy(head,tmp,sizeof(head));
+        tot=ttot;
+        for(int j=1;j<=n;j++){
+            AddEdge(st,j,1);
+            AddEdge(j+n,et,1);
+        }
+        for(int i=0;i<ans;i++){
+            memset(vis1,0,sizeof(vis1));
+            tot=ttot;
+            Dinic(st,et);
+            for(int j=1;j<=n;j++){
+                for(int k=head[j];~k;k=e[k].next){
+                    if(vis2[k])continue;
+                    if(e[k].ci==0&&e[k].to!=st){
+                        vis1[e[k].to-n]=j;
+                        vis2[k^1]=vis2[k]=1;
+                        break;
+                    }
+                }
+            }
+            for(int j=1;j<n;j++){
+            printf("%d ",vis1[j]);
+            if(!vis1[j])while(1);
+            }
+            printf("%d\n",vis1[n]);
+            if(!vis1[n])while(1);
+            for(int j=head[st];~j;j=e[j].next){
+                e[j].ci=1;e[j^1].ci=0;
+            }
+            for(int j=head[et];~j;j=e[j].next){
+                e[j^1].ci=1;e[j].ci=0;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4266_autoAC.cpp b/HDOJ/4266_autoAC.cpp
new file mode 100644
index 0000000..62bcc62
--- /dev/null
+++ b/HDOJ/4266_autoAC.cpp
@@ -0,0 +1,179 @@
+#include<stdio.h>
+#include<string.h>
+#include<math.h>
+#include<algorithm>
+#include <iostream>
+using namespace std;
+#define PR 1e-9
+#define N 1100
+struct TPoint
+{
+    double x,y,z;
+    TPoint(){}
+    TPoint(double _x,double _y,double _z):x(_x),y(_y),z(_z){}
+    TPoint operator-(const TPoint p) {return TPoint(x-p.x,y-p.y,z-p.z);}
+    TPoint operator*(const TPoint p) {return TPoint(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);}
+    double operator^(const TPoint p) {return x*p.x+y*p.y+z*p.z;}
+};
+TPoint dd;
+struct fac
+{
+    int a,b,c;
+    bool ok;
+};
+TPoint xmult(TPoint u,TPoint v)
+{
+    return TPoint(u.y*v.z-v.y*u.z,u.z*v.x-u.x*v.z,u.x*v.y-u.y*v.x);
+}
+double dmult(TPoint u,TPoint v)
+{
+    return u.x*v.x+u.y*v.y+u.z*v.z;
+}
+TPoint subt(TPoint u,TPoint v)
+{
+    return TPoint(u.x-v.x,u.y-v.y,u.z-v.z);
+}
+double vlen(TPoint u)
+{
+    return sqrt(u.x*u.x+u.y*u.y+u.z*u.z);
+}
+TPoint pvec(TPoint a,TPoint b,TPoint c)
+{
+    return xmult(subt(a,b),subt(b,c));
+}
+double Dis(TPoint a,TPoint b,TPoint c,TPoint d)
+{
+    return fabs(dmult(pvec(a,b,c),subt(d,a)))/vlen(pvec(a,b,c));
+}
+struct T3dhull
+{
+    int n;
+    TPoint ply[N];
+    int trianglecnt;
+    fac tri[N];
+    int vis[N][N];
+    double dist(TPoint a){return sqrt(a.x*a.x+a.y*a.y+a.z*a.z);}
+    double area(TPoint a,TPoint b,TPoint c){return dist((b-a)*(c-a));}
+    double volume(TPoint a,TPoint b,TPoint c,TPoint d){return (b-a)*(c-a)^(d-a);}
+    double ptoplane(TPoint &p,fac &f)
+    {
+         TPoint m=ply[f.b]-ply[f.a],n=ply[f.c]-ply[f.a],t=p-ply[f.a];
+         return (m*n)^t;
+    }
+    void deal(int p,int a,int b)
+    {
+        int f=vis[a][b];
+        fac add;
+        if(tri[f].ok)
+        {
+            if((ptoplane(ply[p],tri[f]))>PR) dfs(p,f);
+            else
+            {
+                 add.a=b,add.b=a,add.c=p,add.ok=1;
+                 vis[p][b]=vis[a][p]=vis[b][a]=trianglecnt;
+                 tri[trianglecnt++]=add;
+            }
+        }
+    }
+    void dfs(int p,int cnt)
+    {
+        tri[cnt].ok=0;
+        deal(p,tri[cnt].b,tri[cnt].a);
+        deal(p,tri[cnt].c,tri[cnt].b);
+        deal(p,tri[cnt].a,tri[cnt].c);
+    }
+    bool same(int s,int e)
+    {
+        TPoint a=ply[tri[s].a],b=ply[tri[s].b],c=ply[tri[s].c];
+        return fabs(volume(a,b,c,ply[tri[e].a]))<PR
+            &&fabs(volume(a,b,c,ply[tri[e].b]))<PR
+            &&fabs(volume(a,b,c,ply[tri[e].c]))<PR;
+    }
+    void construct()
+    {
+        int i,j;
+        trianglecnt=0;
+        if(n<4) return ;
+        bool tmp=true;
+        for(i=1;i<n;i++)
+        {
+            if((dist(ply[0]-ply[i]))>PR)
+            {
+                swap(ply[1],ply[i]); tmp=false; break;
+            }
+        }
+        if(tmp) return;
+        tmp=true;
+        for(i=2;i<n;i++)
+        {
+            if((dist((ply[0]-ply[1])*(ply[1]-ply[i])))>PR)
+            {
+                swap(ply[2],ply[i]); tmp=false; break;
+            }
+        }
+        if(tmp) return ;
+        tmp=true;
+        for(i=3;i<n;i++)
+        {
+            if(fabs((ply[0]-ply[1])*(ply[1]-ply[2])^(ply[0]-ply[i]))>PR)
+            {
+                swap(ply[3],ply[i]); tmp=false; break;
+            }
+        }
+        if(tmp) return ;
+        fac add;
+        for(i=0;i<4;i++)
+        {
+            add.a=(i+1)%4,add.b=(i+2)%4,add.c=(i+3)%4,add.ok=1;
+            if((ptoplane(ply[i],add))>0) swap(add.b,add.c);
+            vis[add.a][add.b]=vis[add.b][add.c]=vis[add.c][add.a]=trianglecnt;
+            tri[trianglecnt++]=add;
+        }
+        for(i=4;i<n;i++)
+        {
+            for(j=0;j<trianglecnt;j++)
+            {
+                if(tri[j].ok&&(ptoplane(ply[i],tri[j]))>PR)
+                {
+                    dfs(i,j); break;
+                }
+            }
+        }
+        int cnt=trianglecnt;
+        trianglecnt=0;
+        for(i=0;i<cnt;i++)
+        {
+            if(tri[i].ok)
+                tri[trianglecnt++]=tri[i];
+        }
+    }
+    double res()
+    {
+        double _min=1e300;
+        for(int i=0;i<trianglecnt;i++)
+        {
+            double now=Dis(ply[tri[i].a],ply[tri[i].b],ply[tri[i].c],dd);
+            if(_min>now) _min=now;
+        }
+        return _min;
+    }
+}hull;
+int main()
+{
+    double now,_min;
+    while(scanf("%d",&hull.n)!=EOF)
+    {
+        if(hull.n==0) break;
+        int i,j,q;
+        for(i=0;i<hull.n;i++)
+            scanf("%lf%lf%lf",&hull.ply[i].x,&hull.ply[i].y,&hull.ply[i].z);
+        hull.construct();
+        scanf("%d",&q);
+        for(j=0;j<q;j++)
+        {
+            scanf("%lf%lf%lf",&dd.x,&dd.y,&dd.z);
+            printf("%.4lf\n",hull.res());
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4267_autoAC.cpp b/HDOJ/4267_autoAC.cpp
new file mode 100644
index 0000000..76ae801
--- /dev/null
+++ b/HDOJ/4267_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <cstdio>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+const int N = 50010;
+int cnt[N][11][11];
+int num[N];
+int inline lowbit(int x){
+    return x & (-x);
+}
+void inline update(int x,int k,int mod,int add){
+    while(x > 0){
+      cnt[x][k][mod] += add;
+      x -= lowbit(x);
+    }
+}
+int inline sum(int x,int a){
+    int s = 0;
+    while(x < N){
+        for(int i = 1; i <= 10; ++i){
+           s += cnt[x][i][a%i];
+        }
+        x += lowbit(x);
+    }
+    return s;
+}
+int main(){
+    int n;
+    while(scanf("%d",&n) != EOF){
+       for(int i = 1; i <= n; ++i)
+           scanf("%d",&num[i]);
+       memset(cnt,0,sizeof(cnt));
+       int m;
+       scanf("%d",&m);
+       while(m--){
+          int op,a,b,k,add;
+          scanf("%d",&op);
+          if(op == 1){
+             scanf("%d%d%d%d",&a,&b,&k,&add);
+             update(b,k,a%k,add);
+             update(a-1,k,a%k,-add);
+          }
+          else{
+            scanf("%d",&a);
+            int ans = sum(a,a);
+            printf("%d\n",ans + num[a]);
+          }
+       }
+    }
+    return 0;
+}
diff --git a/HDOJ/4268_autoAC.cpp b/HDOJ/4268_autoAC.cpp
new file mode 100644
index 0000000..8c5cf43
--- /dev/null
+++ b/HDOJ/4268_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<iostream>
+#include<set>
+#include<algorithm>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+multiset<int> myset;
+multiset<int>::iterator it;
+const int maxn=200000;
+struct node
+{
+    int x,y;
+    bool operator<(const node& b)const
+    {
+        return x<b.x;
+    }
+}a[maxn],b[maxn];
+int main()
+{
+    int sec,n;
+    scanf("%d",&sec);
+    for(int z=1;z<=sec;z++)
+    {
+        myset.clear();
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++)
+        scanf("%d%d",&a[i].x,&a[i].y);
+        for(int i=1;i<=n;i++)
+        scanf("%d%d",&b[i].x,&b[i].y);
+        sort(a+1,a+1+n);
+        sort(b+1,b+1+n);
+        int j=1;int ans=0;
+        for(int i=1;i<=n;i++)
+        {
+            while(j<=n&&b[j].x<=a[i].x)
+            {
+                myset.insert(b[j].y);
+                j++;
+            }
+            it=myset.upper_bound(a[i].y);
+            if(myset.size()>0&&it!=myset.begin())it--;
+            if(myset.size()>0&&(*it)<=a[i].y)
+            {
+                ans++;
+                myset.erase(it);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4269_autoAC.cpp b/HDOJ/4269_autoAC.cpp
new file mode 100644
index 0000000..fa4a100
--- /dev/null
+++ b/HDOJ/4269_autoAC.cpp
@@ -0,0 +1,163 @@
+#include <iostream>  
+#include <cstdio>  
+#include <cstring>  
+#include <cstdlib>  
+#include <algorithm>  
+#include <sstream>  
+#include <map>  
+#include <cctype>  
+using namespace std;  
+struct Item {  
+    int prz, typ, num;  
+    int tn;  
+    int us[65][2];  
+}a[110];  
+struct Name {  
+    char name[20];  
+    bool operator < (const Name &b) const {  
+        return strcmp(name, b.name) == -1;  
+    }  
+}b;  
+map <Name, int> mmap;  
+map <Name, int>::iterator it;  
+int id, fg;  
+int n;  
+char s[10000], ch, bf[1000];  
+int cnt, gold, p;  
+int main(void) {  
+    int cas = 0;  
+    while (~scanf("%d", &n)) {  
+        mmap.clear();  
+        cnt = gold = 0;  
+        fg = 0;  
+        cas++;  
+        while (n--) {  
+            scanf("%s", b.name);  
+            it = mmap.find(b);  
+            if (it == mmap.end()) {  
+                mmap.insert(pair<Name, int>(b, fg++));  
+                id = fg - 1;  
+            } else  
+                id = it->second;  
+            scanf("%d", &a[id].prz);  
+            a[id].typ = 0;  
+            a[id].num = a[id].tn = 0;  
+        }  
+        scanf("%d", &n);  
+        while (n--) {  
+            scanf("%s", b.name);  
+            it = mmap.find(b);  
+            if (it == mmap.end()) {  
+                mmap.insert(pair<Name, int>(b, fg++));  
+                id = fg - 1;  
+            } else  
+                id = it->second;  
+            scanf("%d", &a[id].prz);  
+            a[id].typ = 1;  
+            a[id].num = a[id].tn = 0;  
+            getchar();  
+            cin.getline(s, 10000);  
+            stringstream ss(s);  
+            while (ss >> b.name) {  
+                it = mmap.find(b);  
+                if (it == mmap.end()) {  
+                    mmap.insert(pair<Name, int>(b, fg++));  
+                    it = mmap.find(b);  
+                }  
+                a[id].us[a[id].tn][0] = it->second;  
+                ss >> a[id].us[a[id].tn][1] >> bf;  
+                a[id].tn++;  
+            }  
+        }  
+        scanf("%d", &n);  
+        while (n--) {  
+            scanf("%s", b.name);  
+            it = mmap.find(b);  
+            if (it == mmap.end()) {  
+                mmap.insert(pair<Name, int>(b, fg++));  
+                id = fg - 1;  
+            } else  
+                id = it->second;  
+            scanf("%d", &a[id].prz);  
+            a[id].typ = 2;  
+            a[id].num = a[id].tn = 0;  
+        }  
+        scanf("%d", &n);  
+        while (n--) {  
+            //cout << "Gold = " << gold << endl;  
+            scanf("%s", s);  
+            if (isdigit(s[1])) {  
+                p = 0;  
+                for (int i = 1; s[i] != 0; i++)  
+                    p = p*10 + s[i] - 48;  
+                if (s[0] == '+')  
+                    gold += p;  
+                else if (gold >= p)  
+                    gold -= p;  
+            } else {  
+                sscanf(s+1, "%s", b.name);  
+                it = mmap.find(b);  
+                if (it == mmap.end())  
+                    continue;  
+                id = it->second;  
+                if (s[0] == '+') {  
+                    if (a[id].typ == 0 && cnt < 6 && gold >= a[id].prz) {  
+                        a[id].num++;  
+                        cnt++;  
+                        gold -= a[id].prz;  
+                    } else if (a[id].typ == 2 && cnt < 6 && gold >= a[id].prz) {  
+                        if (a[id].num == 0) cnt++;  
+                        a[id].num++;  
+                        gold -= a[id].prz;  
+                    } else if (a[id].typ == 1 && gold >= a[id].prz) {  
+                        bool flag = 1;  
+                        int grid = 1;  
+                        for (int i = 0; i < a[id].tn && flag; i++) {  
+                            if (a[a[id].us[i][0]].num < a[id].us[i][1])  
+                                flag = 0;  
+                            else  
+                                grid -= a[id].us[i][1];  
+                        }  
+                        if (flag && cnt + grid <= 6) {  
+                            gold -= a[id].prz;  
+                            cnt += grid;  
+                            a[id].num++;  
+                            for (int i = 0; i < a[id].tn; i++)  
+                                a[a[id].us[i][0]].num -= a[id].us[i][1];  
+                        }  
+                    }  
+                } else if (a[id].num != 0) {  
+                    if (a[id].typ == 0) {  
+                        cnt--;  
+                        a[id].num--;  
+                        gold += a[id].prz;  
+                    } else if (a[id].typ == 1) {  
+                        cnt--;  
+                        a[id].num--;  
+                        int cost = a[id].prz;  
+                        for (int i = 0; i < a[id].tn; i++)  
+                            cost += a[id].us[i][1] * a[a[id].us[i][0]].prz;  
+                        gold += cost;  
+                    } else {  
+                        cnt--;  
+                        gold += a[id].prz * a[id].num;  
+                        a[id].num = 0;  
+                    }  
+                }  
+            }  
+        }  
+        printf("Case %d:\n%d\n%d\n", cas, gold, cnt);  
+        for (it = mmap.begin(); it != mmap.end(); it++) {  
+            for (int i = 0; i < a[it->second].num; i++) {  
+                if (a[it->second].typ != 2)  
+                    printf("%s: 1\n", (it->first).name);  
+                else {  
+                    printf("%s: %d\n", (it->first).name, a[it->second].num);  
+                    break;  
+                }  
+            }  
+        }  
+        printf("\n");  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4270_autoAC.cpp b/HDOJ/4270_autoAC.cpp
new file mode 100644
index 0000000..c090976
--- /dev/null
+++ b/HDOJ/4270_autoAC.cpp
@@ -0,0 +1,97 @@
+#include <cstdio>
+#include <cstring>
+const int MAXN = 200005;
+struct SAMNode {
+    SAMNode *f, *ch[26];
+    int len;
+    bool *d;
+    int pos; 
+    int v;
+};
+SAMNode *root, *last;
+int p_cnt, d_cnt, seq_len, v_id;
+SAMNode pool[MAXN*2];
+bool is_d[MAXN*2];
+char str[MAXN];
+SAMNode *seq[MAXN];
+bool is_del(SAMNode *x) {
+    return x == NULL || *x->d;
+}
+void append(char ch) {
+    int c = ch - 'a';
+    SAMNode *p = last, *np = pool + p_cnt++;
+    memset(np, 0, sizeof(*np));
+    np->pos = np->len = p->len + 1;
+    np->d = is_d + d_cnt++;
+    *np->d = false;
+    seq[seq_len = np->len] = np;
+    last = np;
+    for (; NULL != p && is_del(p->ch[c]); p = p->f) p->ch[c] = np;
+    if (NULL == p) {
+        np->f = root;
+    } else {
+        if (p->ch[c]->len == p->len + 1) {
+            np->f = p->ch[c];
+        } else {
+            SAMNode *q = p->ch[c], *nq = pool + p_cnt++;
+            *nq = *q;
+            nq->len = p->len + 1;
+            q->f = np->f = nq;
+            for (; NULL != p && p->ch[c] == q; p = p->f) p->ch[c] = nq;
+        }
+    }
+}
+void del(int len) {
+    while (len--) *seq[seq_len--]->d = true;
+    last = seq[seq_len];
+}
+int dfs_len;
+int dfs(SAMNode *x, int l) {
+    if (l == dfs_len) return x->pos - l  + 1;
+    if (x->v == v_id) return seq_len - l + 1;
+    for (int i = 0; i < 26; ++i) {
+        if (!is_del(x->ch[i])) {
+            return dfs(x->ch[i], l+1);
+        }
+    }
+    return x->len - l + 1;
+}
+int query(int len) {
+    ++v_id;
+    for (SAMNode *p = last; p != root; p = p->f) p->v = v_id;
+    dfs_len = len;
+    int ret = dfs(root, 0);
+    return ret;
+}
+int main() {
+    while (EOF != scanf("%s", str)) {
+        root = last = pool;
+        memset(root, 0, sizeof(*root));
+        root->d = is_d;
+        is_d[0] = false;
+        p_cnt = 1;
+        d_cnt = 1;
+        v_id = 0;
+        seq[0] = root;
+        for (char *c = str; *c; ++c) append(*c);
+        int m, q, len;
+        scanf("%d", &m);
+        while (m--) {
+            scanf("%d", &q);
+            if (1 == q) {
+                scanf("%s", str);
+                for (char *c = str; *c; ++c) append(*c);
+            } else if (2 == q) {
+                scanf("%d", &len);
+                printf("%d\n", query(len));
+            } else if (3 == q) {
+                scanf("%d", &len);
+                del(len);
+            } else {
+                for(;;);
+                fprintf(stderr, "error cmd %d\n", q);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4271_autoAC.cpp b/HDOJ/4271_autoAC.cpp
new file mode 100644
index 0000000..798e560
--- /dev/null
+++ b/HDOJ/4271_autoAC.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+#include <cstdio>
+#include <string.h>
+#define MIN(a , b) ((a) < (b) ? (a) : (b))
+using namespace std;
+const int inf = 1 << 29;
+const int maxn = 100002;
+const int maxm = 12;
+char str[maxn],dtr[maxn + maxm],dic[maxm][maxm],huan[maxm];
+int dp[maxn + maxm][maxm];
+int m,len,llen;
+int CompareString(char *s1,char *s2,int l1,int l2) 
+{
+    memset(dp,0,sizeof(dp));
+    for(int i=0;i<=l2;i++)
+    {
+        dp[0][i] = i;
+    }
+    for(int i=1;i<=l1;i++)
+    {
+        for(int j=1;j<=l2;j++)
+        {
+            int cost = (s1[i-1] == s2[j-1]) ? 0 : 1;
+            dp[i][j] = MIN(dp[i-1][j-1] + cost , MIN(dp[i-1][j] + 1 , dp[i][j-1] + 1));
+        }
+    }
+    int res = inf;
+    for(int i=0;i<=l1;i++)
+    {
+        res = MIN(res , dp[i][l2]);
+    }
+    return res;
+}
+void solve()
+{
+    len = strlen(str);
+    strcpy(dtr , str);
+    for(int i=0;i<maxm;i++)
+    {
+        dtr[i+len] = str[i];
+    }
+    llen = len + maxm;
+    dtr[llen] = '\0';
+    scanf("%d",&m);
+    getchar();
+    int pos = -1,ans = inf;
+    for(int i=0;i<m;i++)
+    {
+        scanf("%s",dic[i]);
+        int l = strlen(dic[i]);
+        if((l << 1) < len)
+        {
+            int tmp = CompareString(dtr , dic[i] , llen , l);
+            if(tmp < ans || (tmp == ans && strcmp(dic[pos] , dic[i]) > 0))
+            {
+                ans = tmp;
+                pos = i;
+            }
+        }
+        else
+        {
+            for(int s=0;s<len;s++)
+            {
+                for(int j=0;j<len;j++)
+                {
+                    huan[j] = str[(s+j) % len];
+                }
+                huan[len] = '\0';
+                int tmp = CompareString(huan , dic[i] , len , l);
+                if(tmp < ans || (tmp == ans && strcmp(dic[pos] , dic[i]) > 0))
+                {
+                    ans = tmp;
+                    pos = i;
+                }
+            }
+        }
+    }
+    printf("%s %d\n",dic[pos],ans);
+    return;
+}
+int main()
+{
+    while(~scanf("%s",str))
+    {
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4272_autoAC.cpp b/HDOJ/4272_autoAC.cpp
new file mode 100644
index 0000000..1c66a3c
--- /dev/null
+++ b/HDOJ/4272_autoAC.cpp
@@ -0,0 +1,95 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <memory.h>
+#define MIN(a , b) ((a) < (b) ? (a) : (b))
+#define MAX(a , b) ((a) > (b) ? (a) : (b))
+using namespace std;
+const int maxn = 1300;
+int x[maxn],stack[maxn],cnt[maxn];
+bool dp[maxn][maxn],vis[maxn][maxn];
+int n;
+void read()
+{
+    memset(cnt,0,sizeof(cnt));
+    memset(vis,false,sizeof(vis));
+    for(int i=0;i<n;i++)
+    {
+        scanf("%d",&stack[i]);
+        x[i] = stack[i];
+    }
+    return;
+}
+bool check()
+{
+    if(n & 1) return false;
+    sort(x , x + n);
+    int m = x - unique(x , x + n);
+    for(int i=0;i<n;i++)
+    {
+        int idx = lower_bound(x , x + m , stack[i]) - x;
+        cnt[idx]++;
+    }
+    for(int i=0;i<m;i++)
+    {
+        if(cnt[i] & 1) return false;
+    }
+    return true;
+}
+bool dfs(int dep , int to , int st)
+{
+    if(vis[dep][st]) return dp[dep][st];
+    bool flag = false;
+    int use = 0;
+    for(int i=dep-1;i>=0 && use < 5;i--)
+    {
+        if(st & (1 << (dep - i)))
+        {
+            use++;
+            if(stack[dep] == stack[i])
+            {
+                int cur = st;
+                cur ^= 1;
+                cur ^= (1 << (dep - i));
+                if(cur == 0)
+                {
+                    flag = true;
+                    break;
+                }
+                int pos = dep;
+                while((cur & 1) == 0)
+                {
+                    cur >>= 1;
+                    pos--;
+                }
+                int end = to-1;
+                while(end >= 0 && pos - end < 10)
+                {
+                    cur |= (1 << (pos - end));
+                    end--;
+                }
+                if(dfs(pos , end+1 , cur))
+                {
+                    flag = true;
+                    break;
+                }
+            }
+        }
+    }
+    vis[dep][st] = true;
+    return dp[dep][st] = flag;
+}
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        read();
+        if(check() == false)
+        {
+            puts("0");
+            continue;
+        }
+        puts(dfs(n-1 , MAX(n-10 , 0) , (1 << MIN(10 , n)) - 1) ? "1" : "0");
+    }
+    return 0;
+}
diff --git a/HDOJ/4273_autoAC.cpp b/HDOJ/4273_autoAC.cpp
new file mode 100644
index 0000000..36ecc58
--- /dev/null
+++ b/HDOJ/4273_autoAC.cpp
@@ -0,0 +1,255 @@
+#include<stdio.h>
+#include<algorithm>
+#include<string.h>
+#include<math.h>
+#include<stdlib.h>
+using namespace std;
+const int MAXN=550;
+const double eps=1e-8;
+struct Point
+{
+    double x,y,z;
+    Point(){}
+    Point(double xx,double yy,double zz):x(xx),y(yy),z(zz){}
+    Point operator -(const Point p1)
+    {
+        return Point(x-p1.x,y-p1.y,z-p1.z);
+    }
+    Point operator +(const Point p1)
+    {
+        return Point(x+p1.x,y+p1.y,z+p1.z);
+    }
+    Point operator *(const Point p)
+    {
+        return Point(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);
+    }
+    Point operator *(double d)
+    {
+        return Point(x*d,y*d,z*d);
+    }
+    Point operator / (double d)
+    {
+        return Point(x/d,y/d,z/d);
+    }
+    double  operator ^(Point p)
+    {
+        return (x*p.x+y*p.y+z*p.z);
+    }
+};
+struct CH3D
+{
+    struct face
+    {
+        int a,b,c;
+        bool ok;
+    };
+    int n;
+    Point P[MAXN];
+    int num;
+    face F[8*MAXN];
+    int g[MAXN][MAXN];
+    double vlen(Point a)
+    {
+        return sqrt(a.x*a.x+a.y*a.y+a.z*a.z);
+    }
+    Point cross(const Point &a,const Point &b,const Point &c)
+    {
+        return Point((b.y-a.y)*(c.z-a.z)-(b.z-a.z)*(c.y-a.y),
+                     (b.z-a.z)*(c.x-a.x)-(b.x-a.x)*(c.z-a.z),
+                     (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x)
+                     );
+    }
+    double area(Point a,Point b,Point c)
+    {
+        return vlen((b-a)*(c-a));
+    }
+    double volume(Point a,Point b,Point c,Point d)
+    {
+        return (b-a)*(c-a)^(d-a);
+    }
+    double dblcmp(Point &p,face &f)
+    {
+        Point m=P[f.b]-P[f.a];
+        Point n=P[f.c]-P[f.a];
+        Point t=p-P[f.a];
+        return (m*n)^t;
+    }
+    void deal(int p,int a,int b)
+    {
+        int f=g[a][b];
+        face add;
+        if(F[f].ok)
+        {
+            if(dblcmp(P[p],F[f])>eps)
+              dfs(p,f);
+            else
+            {
+                add.a=b;
+                add.b=a;
+                add.c=p;
+                add.ok=true;
+                g[p][b]=g[a][p]=g[b][a]=num;
+                F[num++]=add;
+            }
+        }
+    }
+    void dfs(int p,int now)
+    {
+         F[now].ok=0;
+         deal(p,F[now].b,F[now].a);
+         deal(p,F[now].c,F[now].b);
+         deal(p,F[now].a,F[now].c);
+    }
+    bool same(int s,int t)
+    {
+        Point &a=P[F[s].a];
+        Point &b=P[F[s].b];
+        Point &c=P[F[s].c];
+        return fabs(volume(a,b,c,P[F[t].a]))<eps &&
+               fabs(volume(a,b,c,P[F[t].b]))<eps &&
+               fabs(volume(a,b,c,P[F[t].c]))<eps;
+    }
+    void create()
+    {
+        int i,j,tmp;
+        face add;
+        num=0;
+        if(n<4)return;
+        bool flag=true;
+        for(i=1;i<n;i++)
+        {
+            if(vlen(P[0]-P[i])>eps)
+            {
+                swap(P[1],P[i]);
+                flag=false;
+                break;
+            }
+        }
+        if(flag)return;
+        flag=true;
+        for(i=2;i<n;i++)
+        {
+            if(vlen((P[0]-P[1])*(P[1]-P[i]))>eps)
+            {
+                swap(P[2],P[i]);
+                flag=false;
+                break;
+            }
+        }
+        if(flag)return;
+        flag=true;
+        for(int i=3;i<n;i++)
+        {
+            if(fabs((P[0]-P[1])*(P[1]-P[2])^(P[0]-P[i]))>eps)
+            {
+                swap(P[3],P[i]);
+                flag=false;
+                break;
+            }
+        }
+        if(flag)return;
+        for(i=0;i<4;i++)
+        {
+            add.a=(i+1)%4;
+            add.b=(i+2)%4;
+            add.c=(i+3)%4;
+            add.ok=true;
+            if(dblcmp(P[i],add)>0)swap(add.b,add.c);
+            g[add.a][add.b]=g[add.b][add.c]=g[add.c][add.a]=num;
+            F[num++]=add;
+        }
+        for(i=4;i<n;i++)
+        {
+            for(j=0;j<num;j++)
+            {
+                if(F[j].ok&&dblcmp(P[i],F[j])>eps)
+                {
+                    dfs(i,j);
+                    break;
+                }
+            }
+        }
+        tmp=num;
+        for(i=num=0;i<tmp;i++)
+          if(F[i].ok)
+            F[num++]=F[i];
+    }
+    double area()
+    {
+        double res=0;
+        if(n==3)
+        {
+            Point p=cross(P[0],P[1],P[2]);
+            res=vlen(p)/2.0;
+            return res;
+        }
+        for(int i=0;i<num;i++)
+          res+=area(P[F[i].a],P[F[i].b],P[F[i].c]);
+        return res/2.0;
+    }
+    double volume()
+    {
+        double res=0;
+        Point tmp(0,0,0);
+        for(int i=0;i<num;i++)
+           res+=volume(tmp,P[F[i].a],P[F[i].b],P[F[i].c]);
+        return fabs(res/6.0);
+    }
+    int triangle()
+    {
+        return num;
+    }
+    int polygon()
+    {
+        int i,j,res,flag;
+        for(i=res=0;i<num;i++)
+        {
+            flag=1;
+            for(j=0;j<i;j++)
+              if(same(i,j))
+              {
+                  flag=0;
+                  break;
+              }
+            res+=flag;
+        }
+        return res;
+    }
+    Point barycenter()
+    {
+        Point ans(0,0,0),o(0,0,0);
+        double all=0;
+        for(int i=0;i<num;i++)
+        {
+            double vol=volume(o,P[F[i].a],P[F[i].b],P[F[i].c]);
+            ans=ans+(o+P[F[i].a]+P[F[i].b]+P[F[i].c])/4.0*vol;
+            all+=vol;
+        }
+        ans=ans/all;
+        return ans;
+    }
+    double ptoface(Point p,int i)
+    {
+        return fabs(volume(P[F[i].a],P[F[i].b],P[F[i].c],p)/vlen((P[F[i].b]-P[F[i].a])*(P[F[i].c]-P[F[i].a])));
+    }
+};
+CH3D hull;
+int main()
+{
+    while(scanf("%d",&hull.n)==1)
+    {
+        for(int i=0;i<hull.n;i++)
+        {
+            scanf("%lf%lf%lf",&hull.P[i].x,&hull.P[i].y,&hull.P[i].z);
+        }
+        hull.create();
+        Point p=hull.barycenter();
+        double minn=1e20;
+        for(int i=0;i<hull.num;i++)
+        {
+            minn=min(minn,hull.ptoface(p,i));
+        }
+        printf("%.3lf\n",minn);
+    }
+    return 0;
+}
diff --git a/HDOJ/4274_autoAC.cpp b/HDOJ/4274_autoAC.cpp
new file mode 100644
index 0000000..7a2e296
--- /dev/null
+++ b/HDOJ/4274_autoAC.cpp
@@ -0,0 +1,74 @@
+#include<iostream>
+#include<cstdio>
+#include<map>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<algorithm>
+#include<set>
+#define inf 110000000
+#define M 10005
+#define N 10005
+#define Min(a,b) ((a)<(b)?(a):(b))
+#define Max(a,b) ((a)>(b)?(a):(b))
+#define pb(a) push_back(a)
+#define mem(a,b) memset(a,b,sizeof(a))
+#define LL long long
+#define MOD 1000000007
+using namespace std;
+struct Node{
+    int v,next;
+}edge[N*2];
+int n,start[N],tot;
+int up[N],low[N];
+void addedge(int u,int v){
+    edge[tot].v=v;
+    edge[tot].next=start[u];
+    start[u]=tot++;
+}
+void _addedge(int u,int v){
+    addedge(u,v);
+    addedge(v,u);
+}
+bool ans;
+void dfs(int u,int pre){
+    if(ans) return;
+    if(up[u]!=-1&&low[u]>up[u]){ans=true;return;}
+    int tmp=0;
+    int leaf=1;
+    for(int i=start[u];i!=-1;i=edge[i].next){
+        int v=edge[i].v;
+        if(v==pre) continue;
+        dfs(v,u);
+        leaf=0;
+        tmp+=low[v];
+    }
+    if(leaf) return;
+    low[u]=max(tmp+1,low[u]);
+    if(up[u]!=-1&&low[u]>up[u]) ans=true;
+}
+int main(){
+    while(scanf("%d",&n)!=EOF){
+        tot=0;mem(start,-1);
+        for(int i=2;i<=n;i++){
+            int u;
+            scanf("%d",&u);
+            _addedge(u,i);
+        }
+        int m;
+        for(int i=1;i<=n;i++){low[i]=1;up[i]=-1;}
+        scanf("%d",&m);
+        for(int i=0;i<m;i++){
+            int u,w;
+            char str[5];
+            scanf("%d%s%d",&u,str,&w);
+            if(str[0]=='<') up[u]=w-1;
+            else if(str[0]=='>') low[u]=w+1;
+            else low[u]=up[u]=w;
+        }
+        ans=false;
+        dfs(1,0);
+        puts(ans?"Lie":"True");
+    }
+    return 0;
+}
diff --git a/HDOJ/4275_autoAC.cpp b/HDOJ/4275_autoAC.cpp
new file mode 100644
index 0000000..46153e0
--- /dev/null
+++ b/HDOJ/4275_autoAC.cpp
@@ -0,0 +1,187 @@
+#pragma comment(linker, "/STACK:16777216")
+#include<iostream>
+#include<sstream>
+#include<fstream>
+#include<vector>
+#include<list>
+#include<deque>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<bitset>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cctype>
+#include<cmath>
+#include<ctime>
+#include<iomanip>
+using namespace std;
+const double eps(1e-8);
+typedef long long lint;
+#define hash hhhhhhh
+#define end eeeeend
+#define maxn 50010
+const lint mod = 1e9 + 7;
+const lint A = 233, P = 23333, Q = 1e9 + 1027, B = 50009;
+int n, m;
+int dis[maxn];
+bool flag;
+vector<int> dia;
+int start, end;
+lint hash[maxn], cnt[maxn];
+int idx[maxn];
+lint fac[maxn];
+vector<int> G[maxn];
+int center;
+void dfs(int now, int fa)
+{
+    int nex;
+    for(int i = 0, sz = G[now].size(); i < sz; i++) if((nex = G[now][i]) != fa)
+    {
+        dis[nex] = dis[now] + 1;
+        dfs(nex, now);
+    }
+    return;
+}
+bool getDiameter(int now, int fa)
+{
+    int nex;
+    for(int i = 0, sz = G[now].size(); i < sz; i++) if((nex = G[now][i]) != fa)
+        if(getDiameter(nex, now))
+        {
+            dia.push_back(now);
+            return true;
+        }
+    if(now == end)
+    {
+        dia.push_back(now);
+        return true;
+    }
+    return false;
+}
+void diameter()
+{
+    dis[1] = 0;
+    dfs(1, -1);
+    start = 1;
+    for(int i = 1; i <= n; i++)
+        if(dis[start] < dis[i]) start = i;
+    dis[start] = 0;
+    dfs(start, -1);
+    end = start;
+    for(int i = 1; i <= n; i++)
+        if(dis[end] < dis[i]) end = i;
+    dia.clear();
+    getDiameter(start, -1);
+    if(dis[end] & 1)
+    {
+        flag = true;
+        int centerLeft = dia[(dia.size() >> 1) - 1];
+        int centerRight = dia[dia.size() >> 1];
+        center = n + 1;
+        G[center].push_back(centerLeft);
+        G[center].push_back(centerRight);
+        for(int i = 0, sz = G[centerLeft].size(); i < sz; i++)
+            if(G[centerLeft][i] == centerRight)
+            {
+                G[centerLeft][i] = center;
+                break;
+            }
+        for(int i = 0, sz = G[centerRight].size(); i < sz; i++)
+            if(G[centerRight][i] == centerLeft)
+            {
+                G[centerRight][i] = center;
+                break;
+            }
+    }
+    else
+        center = dia[dia.size() >> 1];
+    return;
+}
+lint quick(lint base, lint pow)
+{
+    lint ret = 1;
+    while(pow)
+    {
+        if(pow & 1) ret = ret*base % mod;
+        base = base*base % mod;
+        pow >>= 1;
+    }
+    return ret;
+}
+lint C(int x, int y)
+{
+    lint ret = 1;
+    for(int i = 1; i + x - y <= x; i++)
+        ret = ret*(x - y + i) % mod;
+    ret = ret*quick(fac[y], mod - 2) % mod;
+    return ret;
+}
+bool cmp(int x, int y)
+{
+    return hash[x] < hash[y];
+}
+void calc(int now, int fa)
+{
+    int nex;
+    for(int i = 0, sz = G[now].size(); i < sz; i++) if((nex = G[now][i]) != fa)
+        calc(nex, now);
+    if(G[now].size() == 1)
+    {
+        hash[now] = A*B % Q;//hash间负A*B % Q
+        cnt[now] = m;
+        return;
+    }
+    hash[now] = A*B % Q;
+    cnt[now] = m;
+    int num = 0;
+    for(int i = 0, sz = G[now].size(); i < sz; i++) if((nex = G[now][i]) != fa)
+        idx[num++] = nex;
+    sort(idx, idx + num, cmp);
+    for(int i = 0; i < num; i++)
+    {
+        nex = idx[i];
+        hash[now] *= P;
+        hash[now] ^= hash[nex];
+        hash[now] %= Q;
+    }
+    hash[now] = hash[now] * B % Q;
+    int st = 0;
+    while(st < num)
+    {
+        lint val = hash[idx[st]];
+        lint kinds = cnt[idx[st]];
+        lint count = 1;
+        st++;
+        while(st < num && val == hash[idx[st]])
+            count++, st++;
+        cnt[now] = cnt[now] * C(kinds + count - 1, count) % mod;
+    }
+    return;
+}
+int main()
+{
+    fac[0] = 1;
+    for(int i = 1; i < maxn; i++) fac[i] = fac[i - 1] * i % mod;
+    while(~scanf("%d %d", &n, &m))
+    {
+        for(int i = 1; i <= n + 1; i++) G[i].clear();
+        for(int i = 1; i < n; i++)
+        {
+            int u, v;
+            scanf("%d %d", &u, &v);
+            G[u].push_back(v);
+            G[v].push_back(u);
+        }
+        flag = false;
+        diameter();
+        calc(center, -1);
+        if(flag)
+            printf("%I64d\n", cnt[center] * quick(m, mod - 2) % mod);
+        else printf("%I64d\n", cnt[center]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4276_autoAC.cpp b/HDOJ/4276_autoAC.cpp
new file mode 100644
index 0000000..96244ef
--- /dev/null
+++ b/HDOJ/4276_autoAC.cpp
@@ -0,0 +1,99 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std;
+const int N=105;
+int head[N],tot;
+int dp[N][N*5];
+struct Edge
+{
+    int from,to,cost,pre;
+    Edge(){}
+    Edge(int a,int b,int c,int d){from=a;to=b;cost=c;pre=d;}
+}edge[N*3];
+void addEdge(int u,int v,int cost)
+{
+    edge[tot]=Edge(u,v,cost,head[u]);
+    head[u]=tot++;
+}
+int spfa(int st,int ed)
+{
+    queue<int> que;
+    int vis[N],dis[N],pre[N];
+    memset(vis,0,sizeof(vis));
+    memset(dis,0x7f,sizeof(dis));
+    memset(pre,-1,sizeof(pre));
+    que.push(st);
+    vis[st]=1;  dis[st]=0;
+    while(!que.empty())
+    {
+        int u=que.front();
+        que.pop();  vis[u]=0;
+        for(int i=head[u];i!=-1;i=edge[i].pre)
+        {
+            int v=edge[i].to,cost=edge[i].cost;
+            if(dis[v]>dis[u]+cost)
+            {
+                dis[v]=dis[u]+cost;
+                pre[v]=i;
+                if(!vis[v])
+                {
+                    vis[v]=1;
+                    que.push(v);
+                }
+            }
+        }
+    }
+    for(int i=ed;i!=st;i=edge[pre[i]].from)
+    {
+        edge[pre[i]].cost=0;
+        edge[pre[i]^1].cost=0;
+    }
+    return dis[ed];
+}
+void dfs(int u,int fa,int coin)
+{
+    for(int e=head[u];e!=-1;e=edge[e].pre)
+    {
+        int v=edge[e].to,cost=edge[e].cost*2;
+        if(v==fa||coin<cost) continue;
+        dfs(v,u,coin-cost);
+        for(int i=coin;i>=cost;i--)
+        {
+            for(int j=0;j+cost<=i;j++)
+            {
+                if(dp[u][i-j-cost]!=-1&&dp[v][j]!=-1)
+                    dp[u][i]=max(dp[u][i],dp[u][i-j-cost]+dp[v][j]);
+            }
+        }
+    }
+}
+int main()
+{
+    int n,t;
+    while(scanf("%d%d",&n,&t)!=EOF)
+    {
+        tot=0;
+        memset(dp,-1,sizeof(dp));
+        memset(head,-1,sizeof(head));
+        for(int i=0;i<n-1;i++)
+        {
+            int a,b,c;
+            scanf("%d%d%d",&a,&b,&c);
+            addEdge(a,b,c);
+            addEdge(b,a,c);
+        }
+        for(int i=1;i<=n;i++) scanf("%d",&dp[i][0]);
+        t-=spfa(1,n);
+        if(t<0) puts("Human beings die in pursuit of wealth, and birds die in pursuit of food!");
+        else
+        {
+            dfs(1,0,t);
+            int res=0;
+            for(int i=0;i<=t;i++) res=max(res,dp[1][i]);
+            printf("%d\n",res);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4277_autoAC.cpp b/HDOJ/4277_autoAC.cpp
new file mode 100644
index 0000000..2ad53a8
--- /dev/null
+++ b/HDOJ/4277_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+#include<set>
+#include<vector>
+#include<string>
+#define LL long long
+#define N 25
+using namespace std;
+int num[N];
+int n,summ,xj,xk;
+int Case;
+struct node
+{
+    int x,y,z;
+    bool operator < (const struct node &a) const
+    {
+        return (x!=a.x)?(x<a.x):(y!=a.y?(y<a.y):(z<a.z));
+    }
+}temp,ans;
+set<struct node> hashx;
+void dfs(int);
+int main()
+{
+    scanf("%d",&Case);
+    for(int c=0;c<Case;c++)
+    {
+        summ=0;hashx.clear();
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&num[i]);
+            summ+=num[i];
+        }
+        temp.x=num[1];temp.y=0;
+        if(n<3)
+        {
+            printf("%d\n",0);
+            continue;
+        }
+        dfs(2);
+        printf("%d\n",hashx.size());
+    }
+    return 0;
+}
+void dfs(int x)
+{
+    if(x>n)
+    {
+                xj=temp.x;
+                xk=temp.y;
+                if(((xj+xk)>(summ-xj-xk))&&(summ-xk>xk)&&(summ-xj>xj))
+                {
+                    ans.x=max(xj,max(summ-xj-xk,xk));
+                    ans.z=min(xj,min(summ-xj-xk,xk));
+                    if(xj!=ans.x&&xj!=ans.z) ans.y=xj;
+                    else if(xk!=ans.x&&xk!=ans.z) ans.y=xk;
+                    else ans.y=summ-ans.x-ans.z;
+                    hashx.insert(ans);
+                }
+                return;
+    }
+    dfs(x+1);
+    temp.x+=num[x];
+    dfs(x+1);
+    temp.x-=num[x];
+    temp.y+=num[x];
+    dfs(x+1);
+    temp.y-=num[x];
+}
diff --git a/HDOJ/4278_autoAC.cpp b/HDOJ/4278_autoAC.cpp
new file mode 100644
index 0000000..b93d8a1
--- /dev/null
+++ b/HDOJ/4278_autoAC.cpp
@@ -0,0 +1,28 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+using namespace std;
+int main()
+{
+    int n;
+    char num[15];
+    while(scanf("%s",num))
+    {
+        if(num[0]=='0')
+            break;
+        int l=strlen(num);
+        int i;
+        int sum=0;
+        for(i=0;i<l;i++)
+        {
+            if(num[i]<'3')
+                sum+=(int)(num[i]-'0')*pow(8.0,l*1.0-i-1);
+            else if(num[i]<'8')
+                sum+=(int)(num[i]-'0'-1)*pow(8.0,l*1.0-i-1);
+            else
+                sum+=(int)(num[i]-'0'-2)*pow(8.0,l*1.0-i-1);
+        }
+        printf("%s: %d\n",num,sum);
+    }
+}
diff --git a/HDOJ/4279_autoAC.cpp b/HDOJ/4279_autoAC.cpp
new file mode 100644
index 0000000..7613da7
--- /dev/null
+++ b/HDOJ/4279_autoAC.cpp
@@ -0,0 +1,50 @@
+#include"iostream"
+#include"cstdio"
+#include"cstring"
+using namespace std;
+const unsigned __int64 limit=3037000498;
+unsigned __int64 solve(unsigned __int64 x)
+{
+    unsigned __int64 ans,low,mid,up,temp;
+    low=1;up=limit;
+    while(low<=up)
+    {
+        mid=(low+up)>>1;
+        temp=mid*mid+4*mid;
+        if(temp<=x)    low=mid+1;
+        else        up=mid-1;
+    }
+    low--;
+    ans=low*(low+1)/2 + (low/2 + low%2)*3;
+    temp=x-(low*low+4*low);
+    if(!temp)    return ans;
+    if(temp<=(low+1)*2)
+    {
+        if((low+1)%2)    ans+=temp/2 + temp%2;
+        else            ans+=(temp-1)/2 + (temp-1)%2;
+    }
+    else
+    {
+        ans+=low+1;
+        if((low+1)%2)    ans+=temp-(low+1)*2;
+    }
+    return ans;
+}
+int main()
+{
+    int T;
+    unsigned __int64 a,b,ans[2];
+    cin>>T;
+    while(T--)
+    {
+        scanf("%I64u%I64u",&a,&b);
+        if(b<=5)    {printf("0\n");continue;}
+        if(a<=6)a=0;
+        else    a-=6;
+        b-=5;
+        ans[0]=solve(a);
+        ans[1]=solve(b);
+        printf("%I64u\n",ans[1]-ans[0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4280_autoAC.cpp b/HDOJ/4280_autoAC.cpp
new file mode 100644
index 0000000..3b89bcf
--- /dev/null
+++ b/HDOJ/4280_autoAC.cpp
@@ -0,0 +1,105 @@
+#include"stdio.h"
+#include"string.h"
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#define inf 99999999
+int min(int a,int b)
+{
+    return a<b?a:b;
+}
+int e,head[100005];
+int level[100005];
+int q[100005];
+struct node
+{
+    int to,val;
+    int next;
+}edge[200005];
+void add_edge(int x,int y,int w)
+{
+    edge[e].to=y;
+    edge[e].val=w;
+    edge[e].next=head[x];
+    head[x]=e++;
+    edge[e].to=x;
+    edge[e].val=w;
+    edge[e].next=head[y];
+    head[y]=e++;
+}
+bool bfs(int s,int t)
+{
+    int front=0,rear=0;
+    int top,k;
+    q[rear++]=s;
+    memset(level,0,sizeof(level));
+    level[s]=1;
+    while(front<rear)
+    {
+        top=q[front++];
+        if(top==t)
+            return true;
+        for(k=head[top];k!=-1;k=edge[k].next)
+        {
+            if(!level[edge[k].to]&&edge[k].val>0)
+            {
+                level[edge[k].to]=level[top]+1;
+                q[rear++]=edge[k].to;
+            }
+        }
+    }
+    return false;
+}
+int dfs(int now,int maxf,int t)
+{
+    int ret=0,f,k;
+    if(now==t)
+        return maxf;
+    for(k=head[now];k!=-1;k=edge[k].next)
+    {
+        if(level[edge[k].to]==level[now]+1&&edge[k].val>0)
+        {
+            f=dfs(edge[k].to,min(maxf-ret,edge[k].val),t);
+            edge[k].val-=f;
+            edge[k^1].val+=f;
+            ret+=f;
+            if(ret==maxf)
+                return ret;
+        }
+    }
+    if(ret==0)
+        level[now]=0;
+    return ret;
+}
+int dinic(int s,int t)
+{
+    int ans=0;
+    while(bfs(s,t))
+        ans+=dfs(s,inf,t);
+    return ans;
+}
+int main( )
+{
+    int T,i,n,m,s,t;
+    int x,y,w,ps,pt;
+    scanf("%d",&T);
+    while(T--)
+    {
+        e=0;s=inf;t=0;
+        memset(head,-1,sizeof(head));
+        scanf("%d%d",&n,&m);
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d%d",&x,&y);
+            if(s>x)
+            {s=x;ps=i;}
+            if(t<x)
+            {t=x;pt=i;}
+        }            
+        for(i=1;i<=m;i++)
+        {
+            scanf("%d%d%d",&x,&y,&w);
+            add_edge(x,y,w);
+        }
+        printf("%d\n",dinic(ps,pt));
+    }
+    return 0;
+}
diff --git a/HDOJ/4281_autoAC.cpp b/HDOJ/4281_autoAC.cpp
new file mode 100644
index 0000000..e12dad5
--- /dev/null
+++ b/HDOJ/4281_autoAC.cpp
@@ -0,0 +1,86 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<cmath>
+using namespace std;
+#define inf 1<<30
+struct Point{
+    int x,y;
+}point[17];
+int n,m,ans,val[17],dp1[1<<17];
+int dp[1<<17][17],best[1<<17];
+int Ok[1<<17];
+int dist[17][17];
+int Get_Dist(int i,int j)
+{
+    return ceil(sqrt(double(point[i].x-point[j].x)*(point[i].x-point[j].x)+double(point[i].y-point[j].y)*(point[i].y-point[j].y)));
+}
+int Judge(int state)
+{
+    int sum=0;
+    for(int i=0;i<n;i++){
+        if(state&(1<<i))sum+=val[i];
+    }
+    return sum<=m;
+}
+int Solve()
+{
+    fill(dp1,dp1+(1<<n),inf);
+    dp1[0]=0;
+    for(int state=0;state<(1<<n);state++){
+        if(Ok[state]){
+            for(int i=0;i<(1<<n);i++){
+                if((state&i)==0&&dp1[i]!=inf){
+                    dp1[state|i]=min(dp1[state|i],dp1[i]+1);
+                }
+            }
+        }
+    }
+    return dp1[(1<<n)-1];
+}
+int TSP()
+{
+    fill(best,best+(1<<n),inf);
+    for(int i=0;i<(1<<n);i++)
+        for(int j=0;j<n;j++)dp[i][j]=inf;
+    dp[1][0]=0;
+    for(int state=0;state<(1<<n);state++){
+        if(Ok[state]){
+            for(int i=0;i<n;i++)if(state&(1<<i)){
+                if(dp[state][i]==inf)continue;
+                best[state]=min(best[state],dp[state][i]+dist[i][0]);
+                for(int j=0;j<n;j++)if(!(state&(1<<j))){
+                    dp[state|(1<<j)][j]=min(dp[state|(1<<j)][j],dp[state][i]+dist[i][j]);
+                }
+            }
+        }
+    }
+    for(int state=0;state<(1<<n);state++){
+        if(state&1){
+            for(int substate=state&(state-1);substate;substate=state&(substate-1)){
+                best[state]=min(best[state],best[substate]+best[(state^substate)|1]);
+            }
+        }
+    }
+    return best[(1<<n)-1];
+}
+int main()
+{
+    while(~scanf("%d%d",&n,&m)){
+        for(int i=0;i<n;i++)scanf("%d%d",&point[i].x,&point[i].y);
+        for(int i=0;i<n;i++)scanf("%d",&val[i]);
+        for(int i=0;i<n;i++)
+            for(int j=0;j<n;j++)dist[i][j]=Get_Dist(i,j);
+        for(int s=0;s<(1<<n);s++){
+            Ok[s]=Judge(s);
+        }
+        ans=Solve();
+        if(ans==inf){
+            puts("-1 -1");
+            continue;
+        }
+        printf("%d %d\n",ans,TSP());
+    }
+    return 0;
+}
diff --git a/HDOJ/4282_autoAC.cpp b/HDOJ/4282_autoAC.cpp
new file mode 100644
index 0000000..1330e46
--- /dev/null
+++ b/HDOJ/4282_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <queue>
+#include <map>
+#include <set>
+using namespace std;
+long long quickpow(long long a,long long b)
+{
+    long long n=1;
+    while(b>0)
+    {
+        if(b&1)
+        {
+            n*=a;
+        }
+        b>>=1;
+        a*=a;
+    }
+    return n;
+}
+int main()
+{
+    long long n;
+    while(scanf("%I64d",&n),n)
+    {
+        long long sign=0;
+        long long num=0;
+        for(int i=1;i<=sqrt(n);i++)
+        {
+            if(i*i==n)
+            {
+                num=i;
+                break;
+            }
+        }
+        if(num)
+        {
+            if(num%2==0)
+            sign+=(num/2-1);
+            else
+            sign+=(num/2);
+        }
+        for(long long k=3;k<=31;k++)
+        {
+            for(long long i=1;i<=1500;i++)
+            {
+                for(long long j=i+1;j<=1500;j++)
+                {
+                    long long powsum=quickpow(j,k)+quickpow(i,k)+j*i*k;
+                    if(powsum==n)
+                    sign++;
+                    if(powsum>n||powsum<0)
+                    break;
+                }
+                if(quickpow(i,k)>n)
+                break;
+            }
+        }
+        printf("%I64d\n",sign);
+    }
+}
diff --git a/HDOJ/4283_autoAC.cpp b/HDOJ/4283_autoAC.cpp
new file mode 100644
index 0000000..6dc97f2
--- /dev/null
+++ b/HDOJ/4283_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+const int inf = 10000000;
+int n,a[105],sum[105],dp[105][105];
+int main()
+{
+    int t,i,j,k,l,cas = 1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        memset(sum,0,sizeof(sum));
+        for(i = 1; i<=n; i++)
+        {
+            scanf("%d",&a[i]);
+            sum[i] = sum[i-1]+a[i];
+        }
+        memset(dp,0,sizeof(dp));
+        for(i = 1; i<=n; i++)
+        {
+            for(j = i+1; j<=n; j++)
+                dp[i][j] = inf;
+        }
+        for(l = 1; l<n; l++)
+        {
+            for(i = 1; i<=n-l; i++)
+            {
+                j = i+l;
+                for(k = 1; k<=j-i+1; k++)
+                    dp[i][j] = min(dp[i][j],dp[i+1][i+k-1]+dp[i+k][j]+k*(sum[j]-sum[i+k-1])+a[i]*(k-1));
+            }
+        }
+        printf("Case #%d: %d\n",cas++,dp[1][n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4284_autoAC.cpp b/HDOJ/4284_autoAC.cpp
new file mode 100644
index 0000000..afd6aa0
--- /dev/null
+++ b/HDOJ/4284_autoAC.cpp
@@ -0,0 +1,78 @@
+#include<stdio.h>
+#include<string.h>
+#define max(a,b)(a)>(b)?(a):(b)
+#define INF 0x3f3f3f3f
+int g[155][155];
+int dp[1<<16][16];
+int num[22];
+int earn[22];
+int cost[22];
+int main()
+{
+    int t,i,j,k,mon,n,m;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d%d",&n,&m,&mon);
+        memset(g,INF,sizeof(g));
+        for(i=1;i<=n;i++)
+            g[i][i]=0;
+        int a,b,c;
+        while(m--)
+        {
+            scanf("%d%d%d",&a,&b,&c);
+            if(c<g[a][b])
+                g[a][b]=g[b][a]=c;
+        }
+        for(k=1;k<=n;k++)
+            for(i=1;i<=n;i++)
+                if(g[i][k]!=INF)
+                  for(j=1;j<=n;j++)
+                         if(g[k][j]!=INF&&g[i][k]+g[k][j]<g[i][j])
+                            g[i][j]=g[i][k]+g[k][j];
+        memset(dp,-1,sizeof(dp));
+        int h,tmp;
+        scanf("%d",&h);
+        for(i=0;i<h;i++)
+            scanf("%d%d%d",&num[i],&earn[i],&cost[i]);
+        for(i=0;i<h;i++)
+        {
+            tmp=mon-g[1][num[i]]-cost[i];
+            if(tmp>=0)
+                dp[1<<i][i]=tmp+earn[i];
+        }
+        int st=(1<<h)-1;
+        for(i=1;i<=st;i++)
+            for(j=0;j<h;j++)
+            {
+                if(dp[i][j]<0)
+                    continue;
+                for(k=0;k<h;k++)
+                {
+                    if(i&(1<<k))
+                        continue;
+                    tmp=dp[i][j]-g[num[j]][num[k]]-cost[k];
+                    if(tmp>=0)
+                    {
+                        tmp+=earn[k];
+                        int stat=i+(1<<k);
+                        dp[stat][k]=max(dp[stat][k],tmp);
+                    }
+                }
+            }
+        int flag=0;
+        for(i=0;i<h;i++)
+        {
+            tmp=dp[st][i]-g[num[i]][1];
+            if(tmp>=0)
+            {
+                flag=1;
+                break;
+            }
+        }
+        if(flag)
+            printf("YES\n");
+        else printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4285_autoAC.cpp b/HDOJ/4285_autoAC.cpp
new file mode 100644
index 0000000..9f1572b
--- /dev/null
+++ b/HDOJ/4285_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 STATE=1000010;
+const int HASH=300007;
+const int MOD=1000000007;
+int N,M,K;
+int maze[MAXD][MAXD];
+int code[MAXD];
+int ch[MAXD];
+int num;
+struct HASHMAP
+{
+    int head[HASH],next[STATE],size;
+    long long state[STATE];
+    int f[STATE];
+    void init()
+    {
+        size=0;
+        memset(head,-1,sizeof(head));
+    }
+    void push(long long st,int ans)
+    {
+        int i;
+        int h=st%HASH;
+        for(i=head[h];i!=-1;i=next[i])
+          if(state[i]==st)
+          {
+              f[i]+=ans;
+              f[i]%=MOD;
+              return;
+          }
+        state[size]=st;
+        f[size]=ans;
+        next[size]=head[h];
+        head[h]=size++;
+    }
+}hm[2];
+void decode(int *code,int m,long long  st)
+{
+    num=st&63;
+    st>>=6;
+    for(int i=m;i>=0;i--)
+    {
+        code[i]=st&7;
+        st>>=3;
+    }
+}
+long long encode(int *code,int m)
+{
+    int cnt=1;
+    memset(ch,-1,sizeof(ch));
+    ch[0]=0;
+    long long 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];
+    }
+    st<<=6;
+    st|=num;
+    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(left&&up)
+        {
+            if(left==up)
+            {
+                if(num>=K)continue;
+                int t=0;
+                for(int p=0;p<j-1;p++)
+                  if(code[p])t++;
+                if(t&1)continue;
+                if(num<K)
+                {
+                    num++;
+                    code[j-1]=code[j]=0;
+                    hm[cur^1].push(encode(code,j==M?M-1:M),hm[cur].f[k]);
+                }
+            }
+            else
+            {
+                code[j-1]=code[j]=0;
+                for(int t=0;t<=M;t++)
+                  if(code[t]==up)
+                    code[t]=left;
+                hm[cur^1].push(encode(code,j==M?M-1:M),hm[cur].f[k]);
+            }
+        }
+        else if(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].f[k]);
+            }
+            if(maze[i+1][j])
+            {
+                code[j]=0;
+                code[j-1]=t;
+                hm[cur^1].push(encode(code,j==M?M-1:M),hm[cur].f[k]);
+            }
+        }
+        else
+        {
+            if(maze[i][j+1]&&maze[i+1][j])
+            {
+                code[j-1]=code[j]=13;
+                hm[cur^1].push(encode(code,j==M?M-1:M),hm[cur].f[k]);
+            }
+        }
+    }
+}
+void dpblock(int i,int j,int cur)
+{
+    int k;
+    for(k=0;k<hm[cur].size;k++)
+    {
+        decode(code,M,hm[cur].state[k]);
+        code[j-1]=code[j]=0;
+        hm[cur^1].push(encode(code,j==M?M-1:M),hm[cur].f[k]);
+    }
+}
+char str[20];
+void init()
+{
+    scanf("%d%d%d",&N,&M,&K);
+    memset(maze,0,sizeof(maze));
+    for(int i=1;i<=N;i++)
+    {
+        scanf("%s",&str);
+        for(int j=1;j<=M;j++)
+          if(str[j-1]=='.')
+            maze[i][j]=1;
+    }
+}
+void solve()
+{
+    int i,j,cur=0;
+    hm[cur].init();
+    hm[cur].push(0,1);
+    for(i=1;i<=N;i++)
+      for(j=1;j<=M;j++)
+      {
+          hm[cur^1].init();
+          if(maze[i][j])dpblank(i,j,cur);
+          else dpblock(i,j,cur);
+          cur^=1;
+      }
+    int ans=0;
+    for(i=0;i<hm[cur].size;i++)
+      if(hm[cur].state[i]==K)
+      {
+          ans+=hm[cur].f[i];
+          ans%=MOD;
+      }
+    printf("%d\n",ans);
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4286_autoAC.cpp b/HDOJ/4286_autoAC.cpp
new file mode 100644
index 0000000..0cf247b
--- /dev/null
+++ b/HDOJ/4286_autoAC.cpp
@@ -0,0 +1,218 @@
+#include<iostream>
+#include<cstring>
+#include<queue>
+#include<cstdio>
+#include<algorithm>
+#define N 1000005
+#define inf 1<<29
+#define MOD 100000007
+#define LL long long
+#define Key_value ch[ch[root][1]][0]
+#define _match(a,b) ((a)==(b))
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+using namespace std;
+int n,q,a[N],pl,pr;
+int size[N],pre[N],rev[N],sum[5],val[N];
+int ch[N][2],tot1,root,s[N],tot2;
+inline void NewNode(int &r,int k,int father){
+    if(tot2)
+        r=s[tot2--];
+    else
+        r=++tot1;
+    ch[r][0]=ch[r][1]=0;
+    pre[r]=father;
+    size[r]=1;
+    rev[r]=0;
+    val[r]=k;
+}
+inline void Push_Up(int x){
+    int l=ch[x][0],r=ch[x][1];
+    size[x]=size[l]+size[r]+1;
+}
+inline void Push_Down(int r){
+    if(rev[r]){
+        rev[ch[r][0]]^= 1;  
+        rev[ch[r][1]]^= 1;  
+        swap(ch[r][0],ch[r][1]);  
+        rev[r]=0;  
+    }
+}
+inline void Bulid(int &r,int L,int R,int father){
+    if(L>R)
+        return ;
+    int mid=(L+R)/2;
+    NewNode(r,a[mid],father);
+    Bulid(ch[r][0],L,mid-1,r);
+    Bulid(ch[r][1],mid+1,R,r);
+    Push_Up(r);
+}
+void Init(){
+    tot1=tot2=root=0;
+    ch[root][0]=ch[root][1]=pre[root]=rev[root]=size[root]=0;
+    NewNode(root,-100,0);
+    NewNode(ch[root][1],-1,root);
+    Push_Up(root);
+    Bulid(Key_value,1,n,ch[root][1]);
+    Push_Up(ch[root][1]);
+    Push_Up(root);
+}
+inline void Rotate(int x,int kind){
+    int y=pre[x];
+    Push_Down(y);
+    Push_Down(x);
+    ch[y][!kind]=ch[x][kind];
+    pre[ch[x][kind]]=y;
+    if(pre[y])
+        ch[pre[y]][ch[pre[y]][1]==y]=x;
+    pre[x]=pre[y];
+    ch[x][kind]=y;
+    pre[y]=x;
+    Push_Up(y);
+}
+inline void Splay(int r,int goal){
+    Push_Down(r);
+    while(pre[r]!=goal){
+        if(pre[pre[r]]==goal)
+            Rotate(r,ch[pre[r]][0]==r);
+        else{
+            int y=pre[r];
+            int kind=(ch[pre[y]][0]==y);
+            if(ch[y][kind]==r){
+                Rotate(r,!kind);
+                Rotate(r,kind);
+            }
+            else{
+                Rotate(y,kind);
+                Rotate(r,kind);
+            }
+        }
+    }
+    Push_Up(r);
+    if(goal==0) root=r;
+}
+inline void RotateTo(int k, int goal) {  
+    int x=root;  
+    Push_Down(x);  
+    while(k!=size[ch[x][0]]+1){  
+        if (k<=size[ch[x][0]]){  
+            x=ch[x][0];  
+        }else{  
+            k-=(size[ch[x][0]]+1);  
+            x=ch[x][1];  
+        }  
+        Push_Down(x);  
+    }  
+    Splay(x,goal);  
+}  
+void Print();
+inline void Reversal(int pos,int k){
+    RotateTo(pos,0);
+    RotateTo(pos+k+1,root);
+    rev[Key_value]^=1;
+}
+inline void Insert(int pos,int k,int num){
+    RotateTo(pos,0);
+    RotateTo(pos+1,root);
+    NewNode(Key_value,num,ch[root][1]);
+    Push_Up(ch[root][1]);
+    Push_Up(root);
+}
+inline void Delete(int pos,int k){
+    RotateTo(pos,0);
+    RotateTo(pos+k+1,root);
+    Key_value=0;
+    Push_Up(ch[root][1]);
+}
+int cnt,ans[N];
+inline void scanf_(int &num){
+    char in;
+    bool neg=false;
+    while(((in=getchar()) > '9' || in<'0') && in!='-') ;
+    if(in=='-'){
+        neg=true;
+        while((in=getchar()) >'9' || in<'0');
+    }
+    num=in-'0';
+    while(in=getchar(),in>='0'&&in<='9')
+        num*=10,num+=in-'0';
+    if(neg)
+        num=0-num;
+}
+inline void printf_(int num){
+    bool flag=false;
+    if(num<0){
+        putchar('-');
+        num=-num;
+    }
+    int ans[10],top=0;
+    while(num!=0){
+        ans[top++]=num%10;
+        num/=10;
+    }
+    if(top==0)
+        putchar('0');
+    for(int i=top-1;i>=0;i--){
+        char ch=ans[i]+'0';
+        putchar(ch);
+    }
+}
+void InOrder(int r){
+    if(r==0)
+        return;
+    Push_Down(r);
+    InOrder(ch[r][0]);
+    if(cnt) putchar(' ');
+    printf_(val[r]);
+    cnt++;
+    InOrder(ch[r][1]);
+}
+void Print(){
+    RotateTo(1,0);
+    RotateTo(n+2,root);
+    cnt=0;
+    InOrder(Key_value);
+    putchar('\n');
+}
+int main(){
+    int t;
+    scanf_(t);
+    while(t--){
+        scanf_(n);
+        for(int i=1;i<=n;i++)
+            scanf_(a[i]);
+        Init();
+        char str[20];
+        int k=1,pl,r1;
+        scanf_(pl);scanf_(pr);scanf_(q);
+        while(q--){
+            scanf("%s",str);
+            if(str[0]=='M'&&str[4]=='R'){
+                scanf("%s",str);
+                if(str[0]=='L') pl++;
+                else pr++;
+            }
+            else if(str[0]=='M'&&str[4]=='L'){
+                scanf("%s",str);
+                if(str[0]=='L') pl--;
+                else pr--;
+            }
+            else if(str[0]=='I'){
+                scanf("%s",str);
+                scanf_(a[1]);
+                if(str[0]=='L') {Insert(pl,k,a[1]);}
+                else {Insert(pr+1,k,a[1]);}
+                n++;pr++;
+            }
+            else if(str[0]=='D'){
+                scanf("%s",&str);
+                if(str[0]=='L') {Delete(pl,k);}
+                else {Delete(pr,k);}
+                n--;pr--;
+            }
+            else if(str[0]=='R')
+                Reversal(pl,pr-pl+1);
+        }
+        Print();
+    }
+    return 0;
+}
diff --git a/HDOJ/4287_autoAC.cpp b/HDOJ/4287_autoAC.cpp
new file mode 100644
index 0000000..a34da3e
--- /dev/null
+++ b/HDOJ/4287_autoAC.cpp
@@ -0,0 +1,88 @@
+#include<stdio.h>
+#include<string.h>
+int hash[128];
+struct TrieNode{
+    int no;
+    TrieNode *next[10];
+}node[30005];
+TrieNode *root = &node[0];
+int cnt,result[5005];
+char word[10],s[10];
+void init()
+{
+    hash['a']=hash['b']=hash['c']=2;
+    hash['d']=hash['e']=hash['f']=3;
+    hash['g']=hash['h']=hash['i']=4;
+    hash['j']=hash['k']=hash['l']=5;
+    hash['m']=hash['n']=hash['o']=6;
+    hash['p']=hash['q']=hash['r']=hash['s']=7;
+    hash['t']=hash['u']=hash['v']=8;
+    hash['w']=hash['x']=hash['y']=hash['z']=9;
+}
+void initRoot()
+{
+    int i;
+    for(i=0;i<10;i++)
+    {
+        root->next[i]=NULL;
+    }
+}
+void insert(char str[],int num)
+{
+    TrieNode *p = root;
+    int len=strlen(str),i,j;
+    for(i=0;i<len;i++)
+    {
+        if(p->next[str[i]-'0']==NULL)
+        {
+            p->next[str[i]-'0']=&node[cnt];
+            for(j=0;j<10;j++)node[cnt].next[j]=NULL;
+            node[cnt].no=-1;
+            cnt++;
+        }
+        p=p->next[str[i]-'0'];
+    }
+    p->no=num;
+}
+void query(char str[])
+{
+    int len=strlen(str),i;
+    TrieNode *p=root;
+    for(i=0;i<len;i++)
+    {
+        p=p->next[hash[str[i]]];
+        if(p==NULL)break;
+    }
+    if(p==NULL)return;
+    else{
+        if(p->no!=-1)result[p->no]++;
+    }
+}
+int main()
+{
+    int t,m,n,i;
+    scanf("%d",&t);
+    init();
+    while(t--)
+    {
+        cnt=1;
+        initRoot();
+        memset(result,0,sizeof(result));
+        scanf("%d%d",&n,&m);
+        for(i=0;i<n;i++)
+        {
+            scanf("%s",word);
+            insert(word,i);
+        }
+        for(i=0;i<m;i++)
+        {
+            scanf("%s",s);
+            query(s);
+        }
+        for(i=0;i<n;i++)
+        {
+            printf("%d\n",result[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4288_autoAC.cpp b/HDOJ/4288_autoAC.cpp
new file mode 100644
index 0000000..93192e2
--- /dev/null
+++ b/HDOJ/4288_autoAC.cpp
@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int n;
+int a[100005],len;
+char str[10];
+__int64 sum;
+int main()
+{
+    int i,j,k;
+    while(~scanf("%d",&n))
+    {
+        len = 0;
+        while(n--)
+        {
+            scanf("%s",str);
+            if(!strcmp(str,"add"))
+            {
+                scanf("%d",&k);
+                for(i = len++; i>0; i--)
+                {
+                    if(a[i-1]>k)
+                        a[i] = a[i-1];
+                    else
+                        break;
+                }
+                a[i] = k;
+            }
+            else if(!strcmp(str,"del"))
+            {
+                scanf("%d",&k);
+                for(i = 0; i<len; i++)
+                    if(a[i] == k)
+                        break;
+                for(; i<len; i++)
+                    a[i] = a[i+1];
+                len--;
+            }
+            else if(!strcmp(str,"sum"))
+            {
+                sum = 0;
+                for(i = 2; i<len; i+=5)
+                    sum+=a[i];
+                printf("%I64d\n",sum);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4289_autoAC.cpp b/HDOJ/4289_autoAC.cpp
new file mode 100644
index 0000000..c4d12a0
--- /dev/null
+++ b/HDOJ/4289_autoAC.cpp
@@ -0,0 +1,116 @@
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int inf=1<<30;
+const int nMax=10105;
+const int mMax=3000005;
+struct Node
+{
+    int c,u,v,next;
+    void insert(int nu,int nv,int nc,int nnext)
+    {
+        u=nu;
+        v=nv;
+        c=nc;
+        next=nnext;
+    }
+}edge[mMax];
+int ne,head[nMax];
+int cur[nMax],ps[nMax],dep[nMax];
+void addedge(int u,int v,int w) 
+{
+    edge[ne].insert(u,v,w,head[u]);
+    head[u]=ne++;
+    edge[ne].insert(v,u,0,head[v]);
+    head[v]=ne++;
+}
+int dinic(int s, int t){                       
+    int tr, res = 0;
+    int i, j, k, f, r, top;
+    while(1){
+        memset(dep, -1, sizeof(dep));
+        for(f = dep[ps[0]=s] = 0, r = 1; f != r;)
+        {
+            for(i = ps[f ++], j = head[i]; j; j = edge[j].next)
+            {
+                if(edge[j].c && dep[k=edge[j].v] == -1)
+                {
+                    dep[k] = dep[i] + 1;
+                    ps[r ++] = k;
+                    if(k == t)
+                    {
+                        f = r; break;
+                    }
+                }
+            }
+        }
+        if(dep[t] == -1) break;
+        memcpy(cur, head, sizeof(cur));
+        i = s, top = 0;
+        while(1)
+        {
+            if(i == t)
+            {
+                for(tr =inf, k = 0; k < top; k ++)
+                {
+                    if(edge[ps[k]].c < tr)
+                    {
+                        tr = edge[ps[f=k]].c;
+                    }
+                }
+                for(k = 0; k < top; k ++)
+                {
+                    edge[ps[k]].c -= tr;
+                    edge[ps[k]^1].c += tr;
+                }
+                i = edge[ps[top=f]].u;
+                res += tr;
+            }
+            for(j = cur[i]; cur[i]; j = cur[i] =edge[cur[i]].next)
+            {
+                if(edge[j].c && dep[i]+1 == dep[edge[j].v])
+                {
+                    break;
+                }
+            }
+            if(cur[i])
+            {
+                ps[top ++] = cur[i];
+                i = edge[cur[i]].v;
+            }
+            else
+            {
+                if(top == 0)
+                {
+                    break;
+                }
+                dep[i] = -1;
+                i = edge[ps[-- top]].u;
+            }
+        }
+    }
+    return res;
+}
+int main()
+{
+    int i,j,a,b,s,t,m,n;
+    while(~scanf("%d%d%d%d",&n,&m,&s,&t))
+    {
+        ne=2;
+        memset(head,0,sizeof(head));
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d",&a);
+            addedge(i,i+n,a);
+        }
+        for(i=1;i<=m;i++)
+        {
+            scanf("%d%d",&a,&b);
+            addedge(a+n,b,inf);
+            addedge(b+n,a,inf);
+        }
+        int res=dinic(s,t+n);
+        printf("%d\n",res);
+    }
+    return 0;
+}
diff --git a/HDOJ/4290_autoAC.cpp b/HDOJ/4290_autoAC.cpp
new file mode 100644
index 0000000..99a8131
--- /dev/null
+++ b/HDOJ/4290_autoAC.cpp
@@ -0,0 +1,79 @@
+#include<stdio.h>
+#include<string.h>
+#define MAXD 33
+#define MOD 1000000007
+typedef __int64 LL;
+int N, M, K;
+LL C[MAXD][MAXD][MAXD], f[MAXD][MAXD], X[MAXD], S[MAXD];
+LL fac(LL a, int n)
+{
+    int i;
+    LL ans = 1;
+    for(i = 0; i < n; i ++) ans = ans * a % MOD;
+    return ans;
+}
+void exgcd(LL a, LL b, LL &x, LL &y)
+{
+    if(b == 0) x = 1, y = 0;
+    else exgcd(b, a % b, y, x), y -= x * (a / b);
+}
+LL getinv(LL a)
+{
+    LL x, y;
+    exgcd(a, MOD, x, y);
+    x %= MOD;
+    if(x < 0) x += MOD;
+    return x;
+}
+void prepare()
+{
+    int i, j, t;
+    memset(C, 0, sizeof(C));
+    C[1][0][0] = 1;
+    for(i = 1; i <= 32; i ++)
+    {
+        C[1][i][0] = 1;
+        for(j = 1; j <= i; j ++)
+            C[1][i][j] = (C[1][i - 1][j] + C[1][i - 1][j - 1]) % MOD;
+    }
+    for(t = 2; t <= 32; t ++)
+        for(i = 0; i <= 32; i ++)
+            for(j = 0; j <= 32; j ++)
+                C[t][i][j] = fac(C[1][i][j], t);
+}
+void solve()
+{
+    int i, j, k, t;
+    LL ans;
+    for(t = 1; t <= N; t ++)
+    {
+        memset(f, 0, sizeof(f)), f[0][0] = 1;
+        for(i = 1; i <= K; i ++)
+            for(j = 0; j <= M; j ++)
+                for(k = 0; k <= j; k ++)
+                    f[i][j] = (f[i][j] + f[i - 1][k] * C[t][M - k][j - k]) % MOD;
+        X[t] = f[K][M];
+    }
+    S[0] = 1, S[1] = X[1];
+    for(i = 2; i <= N; i ++)
+    {
+        S[i] = 0;
+        for(j = 1; j <= i; j ++)
+        {
+            if(j & 1) S[i] = (S[i] + S[i - j] * X[j] + MOD) % MOD;
+            else S[i] = (S[i] - S[i - j] * X[j] + MOD) % MOD;
+        }
+        S[i] = S[i] * getinv(i) % MOD;
+    }
+    ans = S[N];
+    for(i = 2; i <= N; i ++) ans = ans * i % MOD;
+    if(ans < 0) ans += MOD;
+    printf("%I64d\n", ans);
+}
+int main()
+{
+    prepare();
+    while(scanf("%d%d%d", &N, &M, &K) == 3)
+        solve();
+    return 0;
+}
diff --git a/HDOJ/4292_autoAC.cpp b/HDOJ/4292_autoAC.cpp
new file mode 100644
index 0000000..e9b5d3a
--- /dev/null
+++ b/HDOJ/4292_autoAC.cpp
@@ -0,0 +1,102 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+using namespace std;
+#define MAXN 1111
+#define MAXM 88888888
+struct Edge{
+    int v,cap,next;
+}edge[MAXM];
+int head[MAXN];
+int pre[MAXN];
+int cur[MAXN];
+int level[MAXN];
+int gap[MAXN];
+int NE,NV,vs,vt,n,f,d;
+int Food[MAXN];
+int Drink[MAXN];
+void Insert(int u,int v,int cap,int cc=0){
+    edge[NE].v=v;edge[NE].cap=cap;
+    edge[NE].next=head[u];head[u]=NE++;
+    edge[NE].v=u;edge[NE].cap=cc;
+    edge[NE].next=head[v];head[v]=NE++;
+}
+int SAP(int vs,int vt){
+    memset(pre,-1,sizeof(pre));
+    memset(level,0,sizeof(level));
+    memset(gap,0,sizeof(gap));
+    for(int i=0;i<NV;i++)cur[i]=head[i];
+    int u=pre[vs]=vs,maxflow=0,aug=-1;
+    gap[0]=NV;
+    while(level[vs]<NV){
+loop:
+        for(int &i=cur[u];i!=-1;i=edge[i].next){
+            int v=edge[i].v;
+            if(edge[i].cap&&level[u]==level[v]+1){
+                aug==-1?aug=edge[i].cap:aug=min(aug,edge[i].cap);
+                pre[v]=u;
+                u=v;
+                if(v==vt){
+                    maxflow+=aug;
+                    for(u=pre[u];v!=vs;v=u,u=pre[u]){
+                        edge[cur[u]].cap-=aug;
+                        edge[cur[u]^1].cap+=aug;
+                    }
+                    aug=-1;
+                }
+                goto loop;
+            }
+        }
+        int minlevel=NV;
+        for(int i=head[u];i!=-1;i=edge[i].next){
+            int v=edge[i].v;
+            if(edge[i].cap&&minlevel>level[v]){
+                cur[u]=i;
+                minlevel=level[v];
+            }
+        }
+        gap[level[u]]--;
+        if(gap[level[u]]==0)break;
+        level[u]=minlevel+1;
+        gap[level[u]]++;
+        u=pre[u];
+    }
+    return maxflow;
+}
+int main(){
+    char str[MAXN];
+    while(~scanf("%d%d%d",&n,&f,&d)){
+        vs=0,vt=f+2*n+d+1,NV=vt+1,NE=0;
+        memset(head,-1,sizeof(head));
+        for(int i=1;i<=f;i++){
+            scanf("%d",&Food[i]);
+            Insert(vs,i,Food[i]);
+        }
+        for(int i=1;i<=d;i++){
+            scanf("%d",&Drink[i]);
+            Insert(i+2*n+f,vt,Drink[i]);
+        }
+        for(int i=1;i<=n;i++){
+            Insert(i+f,i+f+n,1);
+        }
+        for(int i=1;i<=n;i++){
+            scanf("%s",str+1);
+            for(int j=1;j<=f;j++){
+                if(str[j]=='Y'){
+                    Insert(j,i+f,1);
+                }
+            }
+        }
+        for(int i=1;i<=n;i++){
+            scanf("%s",str+1);
+            for(int j=1;j<=d;j++){
+                if(str[j]=='Y'){
+                    Insert(i+f+n,f+2*n+j,1);
+                }
+            }
+        }
+        printf("%d\n",SAP(vs,vt));
+    }
+    return 0;
+}
diff --git a/HDOJ/4293_autoAC.cpp b/HDOJ/4293_autoAC.cpp
new file mode 100644
index 0000000..9dfb912
--- /dev/null
+++ b/HDOJ/4293_autoAC.cpp
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+int dp[510][510];    
+int tt[510][510], an[510];
+int main()
+{
+    int i, j, k;
+    int n, a, b;
+    while(scanf("%d", &n) != EOF)
+    {
+        memset(dp, 0, sizeof(dp));
+        memset(an, 0, sizeof(an));
+        memset(tt, 0, sizeof(tt));
+        for(i = 0; i < n; ++i) {
+            scanf("%d %d", &a, &b);
+            if(a+b < n && tt[a][n-b] < (n-a-b))
+                tt[a][n-b]++;
+        }
+        for(i = 1; i <= n; ++i)
+        for(j = 0; j < i; ++j) {
+            dp[j][i] = an[j]+tt[j][i];
+            an[i] = max(an[i], dp[j][i]);
+        }
+        printf("%d\n", an[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4294_autoAC.cpp b/HDOJ/4294_autoAC.cpp
new file mode 100644
index 0000000..68916c9
--- /dev/null
+++ b/HDOJ/4294_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <cstdio>
+#include <iostream>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+#define N 1000020
+int n, k, num[2], m, ans, sl, ssl;
+int ss[N], s[N];
+bool v[10002];
+struct node {
+    int pre, val, mod;
+} q[N];
+void bfs() {
+    memset(v, false, sizeof(v));
+    int l = 1, r = 1;
+    for (int i=0; i<m; i++) if (num[i]) {
+        q[r].pre = 0; q[r].mod = num[i] % n;
+        q[r].val = num[i];
+        if (q[r].mod == 0) { ans = r; break; }
+        r++;
+    }
+    while (l < r && ans == -1) {
+        for (int i=0; i<m; i++) {
+            q[r].mod = (q[l].mod * k + num[i]) % n;
+            if (!v[q[r].mod]) {
+                v[q[r].mod] = true;
+                q[r].pre = l;
+                q[r].val = num[i];
+                if (q[r].mod == 0) { ans = r; break; }
+                r++;
+            }
+        }
+        l++;
+    }
+}
+int cmp() {
+    if (sl < ssl) return -1;
+    if (sl > ssl) return 1;
+    for (int i=0; i<sl; i++) if (s[i] != ss[i]) return s[i]-ss[i];
+    return 0;
+}
+void cpy() {
+    ssl = sl;
+    for (int i=0; i<sl; i++) ss[i] = s[i];
+}
+void get_s(int x) {
+    if (x == 0) return ;
+    get_s(q[x].pre); s[sl++] = q[x].val;
+}
+void print() {
+    for (int i=0; i<ssl; i++) printf("%d", ss[i]);
+    printf("\n");
+}
+int main() {
+    while (scanf("%d%d", &n, &k) == 2) {
+        ssl = 0;
+        for (int i=1; i<k; i++) {
+            num[0] = i, m = 1;
+            ans = -1;
+            bfs();
+            if (ans != -1) {
+                sl = 0; get_s(ans);
+                if (cmp() < 0 || ssl == 0) cpy();
+            }
+        }
+        if (ssl == 0) {
+            for (int i=0; i<k; i++) for (int j=i+1; j<k; j++) {
+                num[0] = i, num[1] = j; m = 2;
+                ans = -1;
+                bfs();
+                if (ans != -1) {
+                    sl = 0; get_s(ans);
+                    if (cmp() < 0 || ssl == 0) cpy();
+                }
+            }
+        }
+        print();
+    }
+    return 0;
+}
diff --git a/HDOJ/4295_autoAC.cpp b/HDOJ/4295_autoAC.cpp
new file mode 100644
index 0000000..4fda34c
--- /dev/null
+++ b/HDOJ/4295_autoAC.cpp
@@ -0,0 +1,47 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int N=4100;
+char s[N],ss[70];
+short l,sl[4],maxl;
+short flag[N],d1[N][16][65],d2[N][16][65];
+int main()
+{
+    int i,j,k,x;
+    while(~scanf("%s",s))
+    {
+        l=strlen(s);
+        memset(flag,0,sizeof(flag[0])*l);
+        for(i=0;i<4;i++)
+        {
+            scanf("%s",ss);
+            sl[i]=strlen(ss);
+            for(j=0;j+sl[i]<=l;j++)
+            {
+                for(k=0;ss[k];k++)if(s[j+k]!=ss[k])break;
+                if(ss[k]=='\0') flag[j]|=1<<i;
+            }
+            if(sl[i]>maxl) maxl=sl[i];
+        }
+        memset(d1,0x3f,sizeof(d1[0])*(l+1));
+        memset(d2,0xc3,sizeof(d1[0])*(l+1));
+        d1[0][0][0]=d2[0][0][0]=0;
+        for(i=0;i<l;i++)for(j=0;j<16;j++)for(k=0;k<=maxl;k++)
+        {
+            d1[i+1][j][k?k-1:0]=min(d1[i][j][k],d1[i+1][j][k?k-1:0]);
+            d2[i+1][j][k?k-1:0]=max(d2[i][j][k],d2[i+1][j][k?k-1:0]);
+            for(x=0;x<4;x++)
+            {
+                if((1<<x&~j)&&(1<<x&flag[i]))
+                {
+                    short t=max((short)k,sl[x]);
+                    d1[i][1<<x|j][t]=min((short)(d1[i][j][k]+t-k),d1[i][1<<x|j][t]);
+                    d2[i][1<<x|j][t]=max((short)(d2[i][j][k]+t-k),d2[i][1<<x|j][t]);
+                }
+            }
+        }
+        printf("%hd %hd\n",d1[l][15][0],d2[l][15][0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4296_autoAC.cpp b/HDOJ/4296_autoAC.cpp
new file mode 100644
index 0000000..175eb71
--- /dev/null
+++ b/HDOJ/4296_autoAC.cpp
@@ -0,0 +1,20 @@
+#include<cstdio>
+#define ll __int64
+int main()
+{
+    int n,w,s;
+    while(~scanf("%d",&n))
+    {
+        ll max=0,ans=0,sum=0;
+        while(n--)
+        {
+            scanf("%d%d",&w,&s);
+            if(w+s>max) max=w+s;
+            sum+=w;
+        }
+        sum-=max;
+        if(sum>ans) ans=sum;
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4297_autoAC.cpp b/HDOJ/4297_autoAC.cpp
new file mode 100644
index 0000000..0a42c4d
--- /dev/null
+++ b/HDOJ/4297_autoAC.cpp
@@ -0,0 +1,199 @@
+#pragma comment(linker, "/STACK:16777216")
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <string.h>
+#include <queue>
+using namespace std;
+const int maxn = 1000010;
+struct node {
+    int be, ne, weight;
+    void init(int b, int e, int v) {
+        be = b;
+        ne = e;
+        weight = v;
+    }
+};
+int rmq[maxn * 2];
+struct RMQ {
+    int lg[maxn + 1], minn[20][maxn + 1], n;
+    RMQ() {
+        lg[0] = -1;
+        for (int i = 1; i <= maxn; i++) {
+            lg[i] = ((i & (i - 1)) == 0) ? lg[i - 1] + 1 : lg[i - 1];
+            minn[0][i] = i;
+        }
+    }
+    void init(int n) {
+        this->n = n;
+        for (int i = 1; i <= lg[n]; i++)
+            for (int j = 1; j <= n + 1 - (1 << i); j++) {
+                int a = minn[i - 1][j];
+                int b = minn[i - 1][j + (1 << (i - 1))];
+                minn[i][j] = rmq[a] < rmq[b] ? a : b;
+            }
+    }
+    int getmin(int s, int t) {
+        if (s > t) {
+            int temp = t;
+            t = s;
+            s = temp;
+        }
+        int k = lg[t - s + 1];
+        int a = minn[k][s];
+        int b = minn[k][t - (1 << k) + 1];
+        if (rmq[a] < rmq[b])
+            return a;
+        else
+            return b;
+    }
+} st;
+int root[maxn];
+struct LCA {
+    int n, len, E[maxn];
+    node buf[maxn * 2];
+    int F[maxn * 2], pos[maxn], cnt;
+    int dis[maxn];
+    void init(int n) {
+        this->n = n;
+        len = 0;
+        memset(E, -1, sizeof(E));
+    }
+    void addedge(int a, int b, int w) {
+        buf[len].init(b, E[a], w);
+        E[a] = len++;
+        buf[len].init(a, E[b], w);
+        E[b] = len++;
+    }
+    int query(int a, int b) {
+        int k = st.getmin(pos[a], pos[b]);
+        return F[k];
+    }
+    void dfs(int a, int lev) {
+        F[++cnt] = a;
+        rmq[cnt] = lev;
+        pos[a] = cnt;
+        for (int i = E[a]; i != -1; i = buf[i].ne) {
+            int b = buf[i].be;
+            if (pos[b] != -1)
+                continue;
+            dis[b] = dis[a] + buf[i].weight;
+            dfs(b, lev + 1);
+            F[++cnt] = a;
+            rmq[cnt] = lev;
+        }
+    }
+    void dfs2(int a, int r) {
+        root[a] = r;
+        for (int i = E[a]; i != -1; i = buf[i].ne)
+            if (root[buf[i].be] == -1)
+                dfs2(buf[i].be, r);
+    }
+    void solve(int root) {
+        cnt = 0;
+        memset(pos, -1, sizeof(pos));
+        memset(dis, 0, sizeof(dis));
+        dfs(root, 0);
+        st.init(2*n-1);
+    }
+} lca;
+int nxt[maxn],n;
+int cc[maxn],pos[maxn],len[maxn],num;
+int f[maxn];
+int find(int x) {
+    if (x != f[x])
+        f[x] = find(f[x]);
+    return f[x];
+}
+void circle() {
+    for (int i = 1; i <= n; i++)
+        f[i] = i;
+    num = 0;
+    memset(cc, -1, sizeof(cc));
+    memset(pos, -1, sizeof(pos));
+    for (int i = 1; i <= n; i++) {
+        int a = find(i);
+        int b = find(nxt[i]);
+        if (a == b)
+            cc[i]=++num;
+        f[a] = b;
+    }
+    for (int i = 1; i <= n; i++)
+        if (cc[i] != -1) {
+            int k = nxt[i];
+            int cnt = 0;
+            pos[i] = ++cnt;
+            root[i] = i;
+            while (k != i) {
+                pos[k] =++cnt;
+                root[k]=k;
+                cc[k]=cc[i];
+                k=nxt[k];
+            }
+            len[cc[i]] = cnt;
+        }
+}
+int main() {
+    int m;
+    while (scanf("%d %d", &n, &m) != EOF) {
+        lca.init(n + 1);
+        memset(root, -1, sizeof(root));
+        for (int i = 1; i <= n; i++)
+            scanf("%d", nxt + i);
+        circle();
+        for (int i = 1; i <= n; i++)
+            if (root[i]!=i)
+                lca.addedge(nxt[i], i, 1);
+        for (int i = 1; i <= n; i++){
+            if (root[i] == i){
+                lca.dfs2(i,i);
+                lca.addedge(0, i, 0);
+            }
+        }
+        lca.solve(0);
+        int a, b;
+        while (m-- > 0) {
+            scanf("%d %d", &a, &b);
+            int p = lca.query(a, b);
+            if (p != 0)
+                printf("%d %d\n", (lca.dis[a] - lca.dis[p]), (lca.dis[b]-lca.dis[p]));
+            else {
+                int ra = root[a], rb = root[b];
+                if (cc[ra] != cc[rb])
+                    printf("-1 -1\n");
+                else {
+                    int cnt=len[cc[ra]];
+                    int temp1 = lca.dis[a];
+                    int temp2 = lca.dis[b];
+                    if (pos[ra] < pos[rb])
+                        temp1 += pos[rb] - pos[ra];
+                    else
+                        temp1 += (cnt - pos[ra] + pos[rb]);
+                    int temp3 = lca.dis[a];
+                    int temp4 = lca.dis[b];
+                    if (pos[rb]<pos[ra])
+                        temp4 += pos[ra]- pos[rb];
+                    else
+                        temp4 +=(cnt-pos[rb]+pos[ra]);
+                    if (max(temp1, temp2) < max(temp3, temp4))
+                        printf("%d %d\n", temp1, temp2);
+                    if (max(temp1, temp2) > max(temp3, temp4))
+                        printf("%d %d\n", temp3, temp4);
+                    if (max(temp1, temp2) == max(temp3, temp4)) {
+                        if (min(temp1, temp2) < min(temp3, temp4))
+                            printf("%d %d\n", temp1, temp2);
+                        if (min(temp1, temp2) > min(temp3, temp4))
+                            printf("%d %d\n", temp3, temp4);
+                        if (min(temp1,temp2)==min(temp3, temp4)) {
+                            if (temp1>=temp2)
+                                printf("%d %d\n",temp1,temp2);
+                            else
+                                printf("%d %d\n",temp3,temp4);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4300_autoAC.cpp b/HDOJ/4300_autoAC.cpp
new file mode 100644
index 0000000..791fd7d
--- /dev/null
+++ b/HDOJ/4300_autoAC.cpp
@@ -0,0 +1,54 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+char a[100001],c[100001];
+int ne[100001];
+int main()
+{
+    int T,i,j,len,nima[27],mid;
+    char b[27];
+    while(scanf("%d",&T)!=EOF)
+    {
+        getchar();
+        while(T--)
+        {
+            scanf("%s%s",b+1,a+1);
+            for(i=1;i<=26;i++)
+               nima[b[i]-'a']=i-1;
+            len=strlen(a+1);
+            for(i=1;i<=len;i++)
+                c[i]='a'+nima[a[i]-'a'];
+            i=1;j=0;ne[1]=0;
+            while(i<len)
+            {
+                if(j==0||c[i]==c[j])
+                {
+                    i++;j++;
+                    ne[i]=j;
+                }
+                else
+                    j=ne[j];
+            }
+            if(len%2==0)
+                i=len/2+1;
+            else
+                i=len/2+2;
+            j=1;mid=i;
+            while(i<=len)
+            {
+                if(j==0||a[i]==c[j])
+                {
+                    i++;j++;
+                }
+                else
+                    j=ne[j];
+            }
+            for(i=1;i<=len;i++)
+                printf("%c",a[i]);
+            for(i=j;i<j+len-2*j+2;i++)
+                printf("%c",c[i]);
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4301_autoAC.cpp b/HDOJ/4301_autoAC.cpp
new file mode 100644
index 0000000..1b25f8f
--- /dev/null
+++ b/HDOJ/4301_autoAC.cpp
@@ -0,0 +1,36 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <math.h>
+#include <cstdlib>
+#include <queue>
+#include <algorithm>
+using namespace std;
+#define N 1050
+#define mod 100000007
+int dp[N][N*2][2];
+int main ()
+{
+        memset(dp,0,sizeof(dp));
+        dp[1][1][0]=1;
+        dp[1][2][1]=1;
+        for(int i=1;i<=1000;++i)
+        {
+            for(int j=1;j<=2*i;++j)
+            {
+                dp[i+1][j][0]=(dp[i+1][j][0]+dp[i][j][0]+2*dp[i][j][1])%mod;
+                dp[i+1][j+1][0]=(dp[i+1][j+1][0]+dp[i][j][1]+dp[i][j][0])%mod;
+                dp[i+1][j][1]=(dp[i+1][j][1]+dp[i][j][1])%mod;
+                dp[i+1][j+1][1]=(dp[i+1][j+1][1]+2*dp[i][j][0]+2*dp[i][j][1])%mod;
+                dp[i+1][j+2][1]=(dp[i+1][j+2][1]+dp[i][j][0]+dp[i][j][1])%mod;
+            }
+        }
+            int n,k;
+    int t;scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&k);
+        printf("%d\n",(dp[n][k][0]+dp[n][k][1])%mod);
+    }
+    return 0;
+}
diff --git a/HDOJ/4302_autoAC.cpp b/HDOJ/4302_autoAC.cpp
new file mode 100644
index 0000000..6996648
--- /dev/null
+++ b/HDOJ/4302_autoAC.cpp
@@ -0,0 +1,86 @@
+#include <queue>
+#include <iostream>
+#define LL __int64
+using namespace std;
+struct cmp
+{
+    bool operator()(LL a, LL b)
+    {
+        return a > b;
+    }
+};
+int main()
+{
+    int t,l,n,f1,f2;
+    LL sum,a,b,x,y;
+    int i,j;
+    scanf("%d", &t);
+    for(j = 0; j < t; j++)
+    {    
+        priority_queue<LL> asc;
+        priority_queue<LL, vector<LL>, cmp> desc;
+        scanf("%d%d", &l, &n);
+        y = 0;
+        sum = 0;
+        for(i = 0; i < n; i++)
+        {
+            scanf("%d", &f2);
+            if(!f2)
+            {
+                scanf("%I64d", &x);
+                if(x > y) desc.push(x);
+                else asc.push(x);
+            }
+            else
+            {
+                a = b = -1;
+                if(!asc.empty()) b = asc.top();
+                if(!desc.empty()) a = desc.top();
+                if(b == y)
+                {
+                    asc.pop();
+                    continue;
+                }
+                if(a+1 && b+1)
+                {
+                    if(a-y > y-b)
+                    {
+                        sum += y-b;
+                        y = b;
+                        asc.pop();
+                        f1 = 0;
+                    }
+                    else if(a-y == y-b)
+                    {
+                        sum += a-y;
+                        if(f1) {y = a; desc.pop();}
+                        else {y = b; asc.pop();}
+                    }
+                    else
+                    {
+                        sum += a-y;
+                        y = a;
+                        desc.pop();
+                        f1 = 1;
+                    }
+                }
+                else if(a+1)
+                {
+                    sum += a-y;
+                    y = a;
+                    desc.pop();
+                    f1 = 1;
+                }
+                else if(b+1)
+                {
+                    sum += y-b;;
+                    y = b;
+                    asc.pop();
+                    f1 = 0;
+                }
+            }
+        }
+        printf("Case %d: %I64d\n", j+1, sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4303_autoAC.cpp b/HDOJ/4303_autoAC.cpp
new file mode 100644
index 0000000..7c9df24
--- /dev/null
+++ b/HDOJ/4303_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<set>
+#include<vector>
+#include<algorithm>
+using namespace std;
+#define pb push_back
+#define NN 301000
+typedef pair<int,int> pii;
+vector<pii> ed[NN];
+long long ans;
+int son[NN],fc[NN];
+int val[NN];
+void dfs2(int u,int fa,int ecol,int fcnt){
+    ans+=((long long)son[u]-fc[u])*fcnt*val[u];
+    int i,j,sz=ed[u].size(),v,tcol=-1,vv,tfcnt;
+    int totc=0,tott=0;
+    for(i=0,j=0;i<sz;++i){
+        v=ed[u][i].second;
+        if (v==fa) continue;
+        if (tcol!=ed[u][i].first){
+            tcol=ed[u][i].first;
+            totc=0;
+            if (j<sz&&ed[u][j].second==fa) ++j;
+            for(;j<sz&&ed[u][j].first==tcol;++j){
+                vv=ed[u][j].second;
+                if (vv==fa) continue;
+                totc=totc+son[vv]-fc[vv];
+            }
+            tott+=totc;
+        }
+        ans+=((long long)son[u]-tott)*(son[v]-fc[v])*val[u];
+        if (ecol==ed[u][i].first) tfcnt=son[u]-totc;
+        else tfcnt=son[u]-totc+fcnt;
+        dfs2(v,u,ed[u][i].first,tfcnt);
+    }
+}
+int dfs1(int u,int fa,int ecol){
+    son[u]=1;
+    fc[u]=0;
+    int i,sz=ed[u].size(),v,tmp;
+    sort(ed[u].begin(),ed[u].end());
+    for(i=0;i<sz;++i){
+        if (ed[u][i].second==fa) continue;
+        v=ed[u][i].second;
+        tmp=dfs1(v,u,ed[u][i].first);
+        son[u]+=tmp;
+        if (ecol==ed[u][i].first) fc[u]+=tmp;
+    }
+    return son[u]-fc[u];
+}
+int main(){
+    int n,i,a,b,c;
+    while(scanf("%d",&n)!=EOF){
+        for(i=1;i<=n;++i){
+            scanf("%d",&val[i]);
+            ed[i].clear();
+        }
+        for(i=1;i<n;++i){
+            scanf("%d%d%d",&a,&b,&c);
+            ed[a].pb(make_pair(c,b));
+            ed[b].pb(make_pair(c,a));
+        }
+        dfs1(1,-1,-1);
+        ans=0;
+        dfs2(1,-1,-1,0);
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4304_autoAC.cpp b/HDOJ/4304_autoAC.cpp
new file mode 100644
index 0000000..cbbbea8
--- /dev/null
+++ b/HDOJ/4304_autoAC.cpp
@@ -0,0 +1,89 @@
+#include <cstdio>
+#include <cstring>
+int coef[20],delt[20],inx[20],base[20];
+int mark[1000010],pri[1000010],priN;
+__int64 dp[2000][20];
+void init()
+{
+    int i,j;
+    for(i=2; i<=1000000; i++) mark[i]=i;
+    for(i=2; i<=1000000; i++)
+    {
+        if(mark[i]==i) pri[priN++]=i;
+        for(j=0; j<priN&&i*pri[j]<=1000000; j++)
+        {
+            mark[i*pri[j]]=pri[j];
+            if(i%pri[j]==0) break;
+        }
+    }
+}
+void deal()
+{
+    __int64 u,ans,num,t,tmpv;
+    int cnt,i,j,k,l,prod,tot,amn,m;
+    scanf("%I64d", &u);
+    for(cnt=0,num=u; num-1;)
+    {
+        if(num>1000000)
+        {
+            t=num;
+            for(j=0; j<priN; j++)
+            {
+                if(num%pri[j]==0)
+                {
+                    t=pri[j];
+                    break;
+                }
+            }
+        }
+        else t=mark[num];
+        inx[cnt]=0;
+        while(num%t==0) num/=t,inx[cnt]++;
+        cnt++;
+    }
+    for(tot=0,prod=1,i=cnt-1; i>=0; i--)
+    {
+        tot+=inx[i],base[i]=prod,prod*=(inx[i]+1);
+    }
+    for(i=0; i<=tot; i++) for(j=0; j<prod; j++) dp[j][i]=0;
+    dp[0][0]=1;
+    for(i=1; i<prod; i++)
+    {
+        for(j=0; j<cnt; j++) delt[j]=i/base[j]%(inx[j]+1);
+        for(j=prod-1; j>=0; j--)
+        {
+            amn=0x3fffffff;
+            for(k=0; k<cnt; k++)
+            {
+                coef[k]=j/base[k]%(inx[k]+1);
+                if(delt[k])
+                {
+                    tmpv=(inx[k]-coef[k])/delt[k];
+                    if(tmpv<amn) amn=tmpv;
+                }
+            }
+            for(l=1; l<=amn; l++)
+            {
+                for(k=0; k+l<=tot; k++)
+                {
+                    tmpv=dp[j][k];
+                    for(m=1; m<=l; m++) tmpv*=m+k,tmpv/=m;
+                    dp[j+i*l][k+l]+=tmpv;
+                }
+            }
+        }
+    }
+    for(ans=dp[prod-1][tot]*dp[prod-1][tot],i=0; i<tot; i++)
+    {
+        ans+=(dp[prod-1][i]+dp[prod-1][i+1])*(dp[prod-1][i]+dp[prod-1][i+1]);
+    }
+    printf("%I64d\n", ans);
+}
+int main()
+{
+    init();
+    int t;
+    scanf("%d", &t);
+    while(t--) deal();
+    return 0;
+}
diff --git a/HDOJ/4305_autoAC.cpp b/HDOJ/4305_autoAC.cpp
new file mode 100644
index 0000000..22f4d1b
--- /dev/null
+++ b/HDOJ/4305_autoAC.cpp
@@ -0,0 +1,141 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+#include <vector>
+#include <queue>
+#include <map>
+#include <set>
+#include <list>
+#include <string>
+#include <math.h>
+using namespace std;
+struct Point
+{
+    int x,y;
+    Point(int _x = 0,int _y = 0)
+    {
+        x = _x,y = _y;
+    }
+    Point operator - (const Point &b)const
+    {
+        return Point(x-b.x,y-b.y);
+    }
+    int operator ^(const Point &b)const
+    {
+        return x*b.y - y*b.x;
+    }
+    void input()
+    {
+        scanf("%d%d",&x,&y);
+    }
+};
+struct Line
+{
+    Point s,e;
+    Line(){}
+    Line(Point _s,Point _e)
+    {
+        s = _s;
+        e = _e;
+    }
+};
+bool onSeg(Point P,Line L)
+{
+    return
+    ((L.s-P)^(L.e-P)) == 0 &&
+    (P.x-L.s.x)*(P.x-L.e.x) <= 0 &&
+    (P.y-L.s.y)*(P.y-L.e.y) <= 0;
+}
+int sqdis(Point a,Point b)
+{
+    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
+}
+const int MOD = 10007;
+int INV[MOD];
+long long inv(long long a,long long m)
+{
+    if(a == 1)return 1;
+    return inv(m%a,m)*(m-m/a)%m;
+}
+struct Matrix
+{
+    int mat[330][330];
+    void init()
+    {
+        memset(mat,0,sizeof(mat));
+    }
+    int det(int n)
+    {
+        for(int i = 0;i < n;i++)
+            for(int j = 0;j < n;j++)
+                mat[i][j] = (mat[i][j]%MOD+MOD)%MOD;
+        int res = 1;
+        for(int i = 0;i < n;i++)
+        {
+            for(int j = i;j < n;j++)
+                if(mat[j][i]!=0)
+                {
+                    for(int k = i;k < n;k++)
+                        swap(mat[i][k],mat[j][k]);
+                    if(i != j)
+                        res = (-res+MOD)%MOD;
+                    break;
+                }
+            if(mat[i][i] == 0)
+            {
+                res = -1;
+                break;
+            }
+            for(int j = i+1;j < n;j++)
+            {
+                int mut = (mat[j][i]*inv(mat[i][i],MOD))%MOD;
+                for(int k = i;k < n;k++)
+                    mat[j][k] = (mat[j][k]-(mat[i][k]*mut)%MOD+MOD)%MOD;
+            }
+            res = (res * mat[i][i])%MOD;
+        }
+        return res;
+    }
+};
+Point p[330];
+int n,R;
+bool check(int k1,int k2)
+{
+    if(sqdis(p[k1],p[k2]) > R*R)return false;
+    for(int i = 0;i < n;i++)
+        if(i!=k1 && i!=k2)
+            if(onSeg(p[i],Line(p[k1],p[k2])))
+                return false;
+    return true;
+}
+int g[330][330];
+int main()
+{
+    for(int i = 1;i < MOD;i++)
+        INV[i] = inv(i,MOD);
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&n,&R);
+        for(int i = 0;i < n;i++)
+            p[i].input();
+        memset(g,0,sizeof(g));
+        for(int i = 0;i < n;i++)
+            for(int j = i+1;j <n;j++)
+                if(check(i,j))
+                    g[i][j] = g[j][i] = 1;
+        Matrix ret;
+        ret.init();
+        for(int i = 0;i < n;i++)
+            for(int j = 0;j < n;j++)
+                if(i != j && g[i][j])
+                {
+                    ret.mat[i][j] = -1;
+                    ret.mat[i][i]++;
+                }
+        printf("%d\n",ret.det(n-1));
+    }
+    return 0;
+}
diff --git a/HDOJ/4306_autoAC.cpp b/HDOJ/4306_autoAC.cpp
new file mode 100644
index 0000000..fda1310
--- /dev/null
+++ b/HDOJ/4306_autoAC.cpp
@@ -0,0 +1,343 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int MAXN = 305;
+const int MAXM = 100010;
+struct Edge
+{
+    int v, next;
+} shift[MAXN*MAXN*2], edge[MAXN*MAXN*4];
+int shiftNumber, edgeNumber;
+int shiftHead[MAXN*MAXN*2], edgeHead[MAXN*MAXN*2];
+int a[MAXN][MAXN], b[MAXN][MAXN];
+int al[MAXN*MAXN], bl[MAXN*MAXN];
+int ta[MAXN], tb[MAXN];
+int na[MAXM], nb[MAXM];
+int pa[MAXM][2], pb[MAXM][2];
+bool va[MAXM], vb[MAXM];
+int n, nn, ca, cb;
+int differ[MAXN*MAXN], differNumber;
+int maxNumber;
+bool inStack[MAXN*MAXN*2];
+int dfn[MAXN*MAXN*2], low[MAXN*MAXN*2];
+int stack[MAXN*MAXN*2], belong[MAXN*MAXN*2];
+int top, index, componentNumber;
+inline int min(int x, int y)
+{
+    return x < y ? x : y;
+}
+inline int max(int x, int y)
+{
+    return x > y ? x : y;
+}
+inline void swap(int &x, int &y)
+{
+    int temp = x;
+    x = y;
+    y = temp;
+}
+inline int getPosition(int x, int y)
+{
+    return x * n + y;
+}
+inline int getRow(int pos)
+{
+    return pos / n;
+}
+inline int getColumn(int pos)
+{
+    return pos % n;
+}
+void clearEdges()
+{
+    shiftNumber = 0;
+    edgeNumber = 0;
+    memset(shiftHead, -1, sizeof(shiftHead));
+    memset(edgeHead, -1, sizeof(edgeHead));
+}
+inline void addShift(int u, int v)
+{
+    shift[shiftNumber].v = v;
+    shift[shiftNumber].next = shiftHead[u];
+    shiftHead[u] = shiftNumber ++;
+}
+inline void addEdge(int u, int v)
+{
+    edge[edgeNumber].v = v;
+    edge[edgeNumber].next = edgeHead[u];
+    edgeHead[u] = edgeNumber ++;
+}
+void transpose()
+{
+    for(int i=0; i<n; ++i)
+    {
+        for(int j=i+1; j<n; ++j)
+        {
+            swap(a[i][j], a[j][i]);
+            swap(b[i][j], b[j][i]);
+        }
+    }
+}
+void getDifference()
+{
+    differ[al[0]] = 0;
+    differNumber = 1;
+    for(int i=1; i<nn; ++i)
+    {
+        if(al[i] != al[i-1])
+        {
+            differ[al[i]] = differNumber ++;
+        }
+    }
+}
+void getNumberPosition()
+{
+    memset(na, 0, sizeof(na));
+    memset(nb, 0, sizeof(nb));
+    for(int i=0; i<n; ++i)
+    {
+        for(int j=0; j<n; ++j)
+        {
+            pa[a[i][j]][na[a[i][j]]++] = getPosition(i, j);
+            pb[b[i][j]][nb[b[i][j]]++] = getPosition(i, j);
+        }
+    }
+}
+bool isUnreachable()
+{
+    sort(al, al + nn);
+    sort(bl, bl + nn);
+    for(int i=0; i<nn; ++i)
+    {
+        if(al[i] != bl[i])
+        {
+            return true;
+        }
+    }
+    return false;
+}
+bool isReachableByOneStep()
+{
+    for(int i=0; i<n; ++i)
+    {
+        for(int j=0; j<n; ++j)
+        {
+            ta[j] = a[i][j];
+            tb[j] = b[i][j];
+        }
+        sort(ta, ta + n);
+        sort(tb, tb + n);
+        for(int j=0; j<n; ++j)
+        {
+            if(ta[j] != tb[j])
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+int myStack[MAXN * MAXN * 8];
+int myStackTop;
+void push(int x)
+{
+    myStack[myStackTop ++] = x;
+}
+int pop()
+{
+    return myStack[-- myStackTop];
+}
+bool isEmpty()
+{
+    return myStackTop == 0;
+}
+void dfs(int x, int depth)
+{
+    int i, t;
+    myStackTop = 0;
+start:
+    dfn[x] = low[x] = index ++;
+    inStack[x] = true;
+    stack[top++] = x;
+    for(i=edgeHead[x]; i!=-1; i=edge[i].next)
+    {
+        if(dfn[edge[i].v] == -1)
+        {
+            push(x);
+            push(depth);
+            push(i);
+            push(t);
+            x = edge[i].v;
+            depth = depth + 1;
+            goto start;
+ret:
+            low[x] = min(low[x], low[edge[i].v]);
+        }
+        else if(inStack[edge[i].v])
+        {
+            low[x] = min(low[x] ,dfn[edge[i].v]);
+        }
+    }
+    if(dfn[x] == low[x])
+    {
+        do
+        {
+            t = stack[--top];
+            inStack[t] = false;
+            belong[t] = componentNumber;
+        }
+        while(t != x);
+        ++ componentNumber;
+    }
+    if(isEmpty())
+    {
+        return;
+    }
+    t = pop();
+    i = pop();
+    depth = pop();
+    x = pop();
+    goto ret;
+}
+void tarjan()
+{
+    memset(inStack, false, sizeof(inStack));
+    memset(dfn, -1, sizeof(dfn));
+    memset(low, -1, sizeof(low));
+    top = index = componentNumber = 0;
+    for(int i=0; i<differNumber*2; ++i)
+    {
+        if(dfn[i] == -1)
+        {
+            dfs(i, 0);
+        }
+    }
+}
+bool isReachableByTwoStep()
+{
+    clearEdges();
+    for(int i=1; i<=maxNumber; ++i)
+    {
+        if(na[i] == 1)
+        {
+            addShift(getPosition(getRow(pa[i][0]), getColumn(pb[i][0])), differ[i]<<1);
+            addShift(getPosition(getRow(pa[i][0]), getColumn(pb[i][0])), (differ[i]<<1) + 1);
+        }
+        else if(na[i] == 2)
+        {
+            addShift(getPosition(getRow(pa[i][0]), getColumn(pb[i][1])), differ[i]<<1);
+            addShift(getPosition(getRow(pa[i][0]), getColumn(pb[i][0])), (differ[i]<<1) + 1);
+            addShift(getPosition(getRow(pa[i][1]), getColumn(pb[i][0])), differ[i]<<1);
+            addShift(getPosition(getRow(pa[i][1]), getColumn(pb[i][1])), (differ[i]<<1) + 1);
+        }
+    }
+    for(int i=0; i<n; ++i)
+    {
+        for(int j=0; j<n; ++j)
+        {
+            for(int k=shiftHead[getPosition(i, j)]; k!=-1; k=shift[k].next)
+            {
+                for(int l=shift[k].next; l!=-1; l=shift[l].next)
+                {
+                    if((shift[k].v ^ 1) == shift[l].v)
+                    {
+                        continue;
+                    }
+                    addEdge(shift[k].v, shift[l].v ^ 1);
+                    addEdge(shift[l].v, shift[k].v ^ 1);
+                }
+            }
+        }
+    }
+    tarjan();
+    for(int i=0; i<differNumber; ++i)
+    {
+        if(belong[i<<1] == belong[(i<<1)+1])
+        {
+            return false;
+        }
+    }
+    return true;
+}
+int main()
+{
+    int caseNumber;
+    scanf("%d", &caseNumber);
+    for(int cas=1; cas<=caseNumber; ++cas)
+    {
+        scanf("%d%d%d", &n, &ca, &cb);
+        nn = n * n;
+        bool isSame = true;
+        maxNumber = 0;
+        for(int i=0,k=0; i<n; ++i)
+        {
+            for(int j=0; j<n; ++j)
+            {
+                scanf("%d", &a[i][j]);
+                al[k++] = a[i][j];
+                maxNumber = max(maxNumber, a[i][j]);
+            }
+        }
+        for(int i=0,k=0; i<n; ++i)
+        {
+            for(int j=0; j<n; ++j)
+            {
+                scanf("%d", &b[i][j]);
+                bl[k++] = b[i][j];
+                if(a[i][j] != b[i][j])
+                {
+                    isSame = false;
+                }
+            }
+        }
+        printf("Case #%d: ", cas);
+        if(isSame)
+        {
+            printf("0\n");
+        }
+        else
+        {
+            if(isUnreachable())
+            {
+                printf("Take off the shoes!\n");
+            }
+            else
+            {
+                int ans = min(ca * 2 + cb, cb * 2 + ca);
+                if(isReachableByOneStep())
+                {
+                    ans = ca;
+                }
+                transpose();
+                if(ans > cb)
+                {
+                    if(isReachableByOneStep())
+                    {
+                        ans = cb;
+                    }
+                }
+                if(ans > ca + cb)
+                {
+                    getDifference();
+                    getNumberPosition();
+                    if(isReachableByTwoStep())
+                    {
+                        ans = ca + cb;
+                    }
+                    else
+                    {
+                        transpose();
+                        getNumberPosition();
+                        if(isReachableByTwoStep())
+                        {
+                            ans = ca + cb;
+                        }
+                    }
+                }
+                printf("%d\n", ans);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4307_autoAC.cpp b/HDOJ/4307_autoAC.cpp
new file mode 100644
index 0000000..ab3eb5e
--- /dev/null
+++ b/HDOJ/4307_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#define MAXD 1010
+#define MAXM 2004010
+#define INF 0x7fffffff
+int N, first[MAXD], e, v[MAXM], next[MAXM], flow[MAXM];
+int S, T, d[MAXD], q[MAXD], work[MAXD];
+long long SUM;
+void add(int x, int y, int z)
+{
+    v[e] = y, flow[e] = z;
+    next[e] = first[x], first[x] = e ++;    
+}
+void init()
+{
+    int i, j, x, a;
+    scanf("%d", &N);
+    S = 0, T = N + 1;
+    memset(first, -1, sizeof(first[0]) * (T + 1));
+    SUM = e = 0;
+    for(i = 1; i <= N; i ++)
+    {
+        a = 0;
+        for(j = 1; j <= N; j ++)
+        {
+            scanf("%d", &x), a += x;
+            add(i, j, x), add(j, i, 0);
+        }
+        SUM += a;
+        add(S, i, a), add(i, S, 0);
+    }
+    for(i = 1; i <= N; i ++)
+    {
+        scanf("%d", &x);
+        add(i, T, x), add(T, i, 0);
+    }
+}
+int bfs()
+{
+    int i, j, rear = 0;
+    memset(d, -1, sizeof(d[0]) * (T + 1));
+    d[S] = 0, q[rear ++] = S;
+    for(i = 0; i < rear; i ++)
+        for(j = first[q[i]]; j != -1; j = next[j])
+            if(flow[j] && d[v[j]] == -1)
+            {
+                d[v[j]] = d[q[i]] + 1, q[rear ++] = v[j];
+                if(v[j] == T) return 1;
+            }
+    return 0;
+}
+int dfs(int cur, int a)
+{
+    if(cur == T)
+        return a;
+    for(int &i = work[cur]; i != -1; i = next[i])
+        if(flow[i] && d[v[i]] == d[cur] + 1)
+            if(int t = dfs(v[i], std::min(a, flow[i])))
+            {
+                flow[i] -= t, flow[i ^ 1] += t;
+                return t;    
+            }
+    return 0;
+}
+long long dinic()
+{
+    long long ans = 0;
+    while(bfs())
+    {
+        memcpy(work, first, sizeof(first[0]) * (T + 1));
+        while(int t = dfs(S, INF))
+            ans += t;
+    }
+    return ans;
+}
+void solve()
+{
+    printf("%lld\n", SUM - dinic());
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    while(t --)
+    {
+        init();
+        solve();    
+    }
+    return 0;    
+}
diff --git a/HDOJ/4310_autoAC.cpp b/HDOJ/4310_autoAC.cpp
new file mode 100644
index 0000000..dbeb6a9
--- /dev/null
+++ b/HDOJ/4310_autoAC.cpp
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <algorithm>
+using namespace std;
+struct Node
+{
+    int dps;
+    int hp;
+}a[30];
+int cmp(Node x,Node y)
+{
+    return x.hp*y.dps<y.hp*x.dps;
+}
+int main()
+{
+    int t,i;
+    int sum,ans;
+    while(~scanf("%d",&t))
+    {
+        sum = ans = 0;
+        for(i = 0;i<t;i++)
+        {
+            scanf("%d%d",&a[i].dps,&a[i].hp);
+            sum+=a[i].dps;
+        }
+        sort(a,a+t,cmp);
+        for(i = 0;i<t;i++)
+        {
+            ans+=sum*a[i].hp;
+            sum-=a[i].dps;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4311_autoAC.cpp b/HDOJ/4311_autoAC.cpp
new file mode 100644
index 0000000..fadb4a4
--- /dev/null
+++ b/HDOJ/4311_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#define MAXN 100010
+using namespace std;
+struct point{long long x,y;}a[MAXN];
+bool cmp(point A,point B)
+{
+    if(A.x<B.x) return true;
+    if(A.x==B.x&&A.y<B.y) return true;
+    return false;
+}
+long long ABS(long long A)
+{
+    if(A<0) A=-A;
+    return A;
+}
+long long work(int k,int n)
+{
+    int i;
+    long long ans=0;
+    for(i=0;i<n;i++)
+    {
+        ans+=ABS(a[k].x-a[i].x);
+        ans+=ABS(a[k].y-a[i].y);
+    }
+    return ans;
+}
+int main()
+{
+    int test,n,s,e,i;
+    long long ans,t;
+    scanf("%d",&test);
+    while(test--)
+    {
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+        {
+            scanf("%I64d%I64d",&a[i].x,&a[i].y);
+        }
+        sort(a,a+n,cmp);
+        s=n/2-250;e=n/2+250;
+        if(s<0) s=0;
+        if(e>n-1) e=n-1;
+        ans=1;ans<<=60;
+        for(i=s;i<=e;i++)
+        {
+            t=work(i,n);
+            if(ans>t) ans=t;
+        }
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4312_autoAC.cpp b/HDOJ/4312_autoAC.cpp
new file mode 100644
index 0000000..e7f1042
--- /dev/null
+++ b/HDOJ/4312_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+typedef long long int Int64;
+int N;
+struct Point
+{
+    Int64 x, y, sum;
+}e[100005];
+bool cmpx(Point a, Point b)
+{
+    return a.x < b.x;
+}
+bool cmpy(Point a, Point b)
+{
+    return a.y < b.y;
+}
+int main()
+{
+    int T, t;
+    Int64 sum, Min;
+    scanf("%d", &T);
+    while (T--) {
+        Min = 1LL << 62;
+        scanf("%d", &N);
+        for (int i = 1; i <= N; ++i) {
+            scanf("%I64d %I64d", &e[i].x, &e[i].y);
+            t = e[i].x, e[i].x += e[i].y;
+            e[i].y -= t, e[i].sum = 0;
+        }
+        sort(e+1, e+1+N, cmpx);
+        sum = 0;
+        for (int i = 1; i <= N; ++i) {
+            e[i].sum += (i-1) * e[i].x - sum;
+            sum += e[i].x;
+        }
+        sum = 0;
+        for (int i = N; i >= 1; --i) {
+            e[i].sum += sum - (N-i) * e[i].x;
+            sum += e[i].x;
+        }
+        sort(e+1, e+1+N, cmpy);
+        sum = 0;
+        for (int i = 1; i <= N; ++i) {
+            e[i].sum += (i-1) * e[i].y - sum;
+            sum += e[i].y;
+        }
+        sum = 0;
+        for (int i = N; i >= 1; --i) {
+            e[i].sum += sum - (N-i) * e[i].y;
+            Min = min(Min, e[i].sum);
+            sum += e[i].y;
+        }
+        printf("%I64d\n", Min >> 1);
+    }
+    return 0;
+}
diff --git a/HDOJ/4313_autoAC.cpp b/HDOJ/4313_autoAC.cpp
new file mode 100644
index 0000000..e8ce21a
--- /dev/null
+++ b/HDOJ/4313_autoAC.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+using namespace std;
+const int maxn = 100010;
+int t, n, k;
+int mach[maxn], father[maxn];
+struct Edge {
+    int u, v, c;
+}edge;
+vector<Edge> vv;
+bool cmp(Edge a, Edge b)
+{
+    return a.c > b.c;
+}
+void initSet()
+{
+    for (int i = 0; i < maxn; ++i) {
+        father[i] = i;
+        mach[i] = 0;
+    }
+}
+int find(int x)
+{
+    if (x != father[x]) {
+        father[x] = find(father[x]);
+    }
+    return father[x];
+}
+void merge(int a, int b)
+{
+    a = find(a);
+    b = find(b);
+    if (a == b) return ;
+    if (a < b) {
+        father[b] = a;
+        mach[a] += mach[b];
+    } else {
+        father[a] = b;
+        mach[b] += mach[a];
+    }
+}
+int main()
+{
+    scanf("%d", &t);
+    while (t--) {
+        scanf("%d%d", &n, &k);
+        vv.clear();
+        initSet();
+        int u, v, c;
+        __int64 ans = 0;
+        for (int i = 0; i < n - 1; ++i) {
+            scanf("%d%d%d", &u, &v, &c);
+            edge.u = u; edge.v = v; edge.c = c;
+            vv.push_back(edge);
+            ans += c;
+        }
+        for (int i = 0; i < k; ++i) {
+            scanf("%d", &u);
+            mach[u] = 1;
+        }
+        sort(vv.begin(), vv.end(), cmp);
+        for (int i = 0; i < n - 1; ++i) {
+            u = find(vv[i].u);
+            v = find(vv[i].v);
+            if (mach[u] + mach[v] <= 1) {
+                merge(u, v);
+                ans -= vv[i].c;
+            }
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4314_autoAC.cpp b/HDOJ/4314_autoAC.cpp
new file mode 100644
index 0000000..ae9be47
--- /dev/null
+++ b/HDOJ/4314_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+const int N=3000;
+const int inf=1e9;
+using namespace std;
+struct node
+{
+    int a,b;
+    void read(){ scanf("%d%d",&a,&b); }
+    bool operator <(const node tmp)const { return a+b<tmp.a+tmp.b; }
+}no[N];
+int opt[N][N],n,h;
+int solve()
+{
+    int sum=0;
+    for(int i=1;i<=n;i++) sum+=no[i].a;
+    for(int j=1;j<=n;j++) opt[0][j]=inf;
+    opt[0][0]=0;
+    for(int i=1;i<=n;i++)
+    {
+        opt[i][0]=0;
+        for(int j=1;j<=n;j++){
+            opt[i][j]=opt[i-1][j];
+            if(sum-opt[i-1][j-1]+no[i].b>=h)
+                opt[i][j]=min(opt[i][j],opt[i-1][j-1]+no[i].a);
+        }
+    }
+    for(int j=n;j>=0;j--)
+        if(opt[n][j]!=inf)
+            return j;
+}
+int main()
+{
+    while(scanf("%d",&n)!=-1)
+    {
+        for(int i=1;i<=n;i++)
+            no[i].read();
+        scanf("%d",&h);
+        sort(no+1,no+n+1);
+        cout<<solve()<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4315_autoAC.cpp b/HDOJ/4315_autoAC.cpp
new file mode 100644
index 0000000..416f4b7
--- /dev/null
+++ b/HDOJ/4315_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<stdio.h>
+#define N 1001
+int n,k,a[N],i,tmp,sg;
+int main()
+{
+    while(scanf("%d%d",&n,&k)!=-1)
+    {
+        a[0]=-1;
+        for(i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        if(k==1)
+        {
+            puts("Alice");
+            continue;
+        }
+        sg=0;
+        for(i=n;i>0;i-=2)
+            sg^=(tmp=a[i]-a[i-1]-1);
+        if(n%2==1&&k==2)
+            sg=sg^(tmp-1)^tmp;
+        if(sg==0)
+            puts("Bob");
+        else
+            puts("Alice");
+    }
+    return 0;
+}
diff --git a/HDOJ/4316_autoAC.cpp b/HDOJ/4316_autoAC.cpp
new file mode 100644
index 0000000..459725f
--- /dev/null
+++ b/HDOJ/4316_autoAC.cpp
@@ -0,0 +1,216 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const int MAXN = 1001;
+const double eps = 1e-12;
+int dblcmp(double x)
+{
+if(fabs(x) < eps)
+{
+return 0;
+}
+return x > 0 ? 1 : -1;
+}
+struct Point
+{
+double x, y, z;
+inline void input2d()
+{
+scanf("%lf%lf",&x,&y);
+z = 100.0;
+}
+inline void input3d()
+{
+scanf("%lf%lf%lf",&x,&y,&z);
+}
+bool operator < (const Point &point) const
+{
+if(y == point.y)
+{
+return x < point.x;
+}
+return y < point.y;
+}
+}machine[MAXN], light[3], shadow[3][MAXN], final[MAXN * 3];
+int n, shadowNumber[3], shadowPoly[3][MAXN], shadowPolyTop[3], finalNumber;
+double operator * (const Point &x, const Point &y)
+{
+return x.x * y.y - x.y * y.x;
+}
+Point operator - (const Point &x, const Point &y)
+{
+Point r;
+r.x = x.x - y.x;
+r.y = x.y - y.y;
+return r;
+}
+bool operator == (const Point &a, const Point &b)
+{
+return fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps;
+}
+struct Line
+{
+Point a, b;
+double ang;
+}line[MAXN*3], stack[MAXN*3];
+int lineNumber, stackTop;
+bool operator < (const Line &x, const Line &y)
+{
+if(fabs(x.ang - y.ang) < eps)
+{
+return (y.b - x.a) * (x.b - y.a) > eps;
+}
+return x.ang < y.ang;
+}
+Point operator * (const Line &x, const Line &y)
+{
+double a1 = (y.b - x.a) * (y.a - x.a);
+double a2 = (y.a - x.b) * (y.b - x.b);
+Point r;
+r.x = (x.a.x * a2 + x.b.x * a1) / (a1 + a2);
+r.y = (x.a.y * a2 + x.b.y * a1) / (a1 + a2);
+return r;
+}
+bool mult(const Point &s, const Point &e, const Point &o)
+{
+return (s.x - o.x) * (e.y - o.y) >= (e.x - o.x) * (s.y - o.y);
+}
+void graham(Point p[], int n, int res[], int &top)
+{
+int len;
+top = 1;
+sort(p, p + n);
+if(n == 0) return;
+res[0] = 0;
+if(n == 1) return;
+res[1] = 1;
+if(n == 2) return;
+res[2] = 2;
+for(int i=2;i<n;++i)
+{
+while(top && mult(p[i], p[res[top]], p[res[top-1]]))
+{
+-- top;
+}
+res[++top] = i;
+}
+len = top;
+res[++top] = n - 2;
+for(int i=n-3;i>=0;--i)
+{
+while(top!=len && mult(p[i], p[res[top]], p[res[top-1]]))
+{
+-- top;
+}
+res[++top] = i;
+}
+}
+double cross(Point &a, Point &b, Point &o)
+{
+return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+bool judgeOut(const Line &x, const Point &p)
+{
+return (p - x.a) * (x.b - x.a) > eps;
+}
+bool isParellel(const Line &x, const Line &y)
+{
+return fabs((x.b - x.a) * (y.b - y.a)) < eps;
+}
+double getArea(Point p[], int n)
+{
+double ans = 0.0;
+for(int i=2;i<n;++i)
+{
+ans += fabs(cross(p[i], p[i-1], p[0]));
+}
+return ans * 0.5;
+}
+void halfPlane()
+{
+finalNumber = 0;
+sort(line, line + lineNumber);
+stackTop = 1;
+int bottom = 0, tmp = 1;
+for(int i=1;i<lineNumber;++i)
+{
+if(line[i].ang - line[i-1].ang > eps)
+{
+line[tmp++] = line[i];
+}
+}
+lineNumber = tmp;
+stack[0] = line[0], stack[1] = line[1];
+for(int i=2;i<lineNumber;++i)
+{
+if(isParellel(stack[stackTop], stack[stackTop-1]) || isParellel(stack[bottom], stack[bottom+1]))
+{
+return;
+}
+while(bottom < stackTop && judgeOut(line[i], stack[stackTop] * stack[stackTop - 1]))
+{
+-- stackTop;
+}
+while(bottom < stackTop && judgeOut(line[i], stack[bottom] * stack[bottom + 1]))
+{
+++ bottom;
+}
+stack[++stackTop] = line[i];
+}
+while(bottom < stackTop && judgeOut(stack[bottom], stack[stackTop] * stack[stackTop - 1]))
+{
+-- stackTop;
+}
+while(bottom < stackTop && judgeOut(stack[stackTop], stack[bottom] * stack[bottom + 1]))
+{
+++ bottom;
+}
+if(stackTop <= bottom + 1)
+{
+return;
+}
+stack[++stackTop] = stack[bottom];
+for(int i=bottom;i<stackTop;++i)
+{
+final[finalNumber ++] = stack[i] * stack[i+1];
+}
+}
+int main()
+{
+while(~scanf("%d", &n))
+{
+for(int i=0;i<n;++i)
+{
+machine[i].input3d();
+}
+for(int i=0;i<3;++i)
+{
+light[i].input2d();
+}
+lineNumber = 0;
+for(int i=0;i<3;++i)
+{
+shadowNumber[i] = 0;
+for(int j=0;j<n;++j)
+{
+shadow[i][j].x = 100.0 * (light[i].x - machine[j].x) / (machine[j].z - 100.0) + light[i].x;
+shadow[i][j].y = 100.0 * (light[i].y - machine[j].y) / (machine[j].z - 100.0) + light[i].y;
+}
+graham(shadow[i], n, shadowPoly[i], shadowPolyTop[i]);
+shadowPoly[i][shadowPolyTop[i]] = shadowPoly[i][0];
+for(int j=0;j<shadowPolyTop[i];++j)
+{
+line[lineNumber].a = shadow[i][shadowPoly[i][j]];
+line[lineNumber].b = shadow[i][shadowPoly[i][j+1]];
+line[lineNumber].ang = atan2(line[lineNumber].b.y - line[lineNumber].a.y,
+line[lineNumber].b.x - line[lineNumber].a.x);
+++ lineNumber;
+}
+}
+halfPlane();
+printf("%.2lf\n", getArea(final, finalNumber));
+}
+return 0;
+}
diff --git a/HDOJ/4317_autoAC.cpp b/HDOJ/4317_autoAC.cpp
new file mode 100644
index 0000000..8fb3ad1
--- /dev/null
+++ b/HDOJ/4317_autoAC.cpp
@@ -0,0 +1,79 @@
+#include<iostream>
+#include<cstdio>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+const int M=1<<11;
+const int MAX=0x1f1f1f1f;
+int s[25],dp[25][M];
+int t[M];
+int a[11];
+int main()
+{
+    int N,i,j,k,len,tmp,r;
+    for(i=0;i<M;i++)
+    {
+        tmp=0;
+        j=i;
+        while(j!=0)
+        {
+            tmp+=(j&1);
+            j=j>>1;
+        }
+        t[i]=tmp;
+    }
+    while(scanf("%d",&N)!=EOF)
+    {
+        memset(s,0,sizeof(s));;
+        for(i=0;i<N;i++)
+        {
+            scanf("%d",&a[i]);
+        }
+        if(N<2)
+        {
+            printf("impossible\n");
+            continue;
+        }
+        for(i=1;i<=22;i++)
+        {
+            for(j=0;j<N;j++)
+            {
+                if(a[j]&(1<<(i-1)))
+                {
+                    s[i]|=(1<<j);
+                }
+            }
+            if(s[i]!=0)
+            len=i+1;
+        }
+        memset(dp,MAX,sizeof(dp));
+        dp[0][0]=0;
+        for(r=1;r<=len;r++)
+        {
+            for(j=0;j<(1<<N);j++)
+            {
+                if(dp[r-1][j]<MAX)
+                {
+                    tmp=j&s[r];
+                    for(k=tmp;k<(1<<N);k++)
+                    {
+                        if((k&tmp)==tmp&&
+                           ((s[r]^j)&(k^tmp))==(k^tmp)&&
+                           ((t[(s[r]^j)^(k^tmp)]&1)==0||t[(s[r]^j)^(k^tmp)]<N))
+                           {
+                               dp[r][k]=min(dp[r][k],dp[r-1][j]+(t[k^tmp]+(t[(s[r]^j)^(k^tmp)]&1))*(1<<(r-1)));
+                           }
+                    }
+                }
+            }
+        }
+        int Min=MAX;
+        for(j=0;j<(1<<N);j++)
+        {
+            if((s[j]&1)==0)
+                Min=min(Min,dp[len][j]);
+        }
+        printf("%d\n",Min);
+    }
+    return 0;
+}
diff --git a/HDOJ/4318_autoAC.cpp b/HDOJ/4318_autoAC.cpp
new file mode 100644
index 0000000..337c88f
--- /dev/null
+++ b/HDOJ/4318_autoAC.cpp
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std;
+struct p
+{
+    int a[50][2];
+}p[50010];
+double b[51000];
+queue<int> q;
+int s,t,n;
+double m;
+int main()
+{
+    while(scanf("%d",&n)!=EOF)
+    {
+        memset(p,-1,sizeof(p));
+    for(int i=0;i<51000;i++)
+     b[i]=-1;
+    for(int i=1;i<=n;i++)
+    {
+        int x;
+        scanf("%d",&x);
+        for(int j=0;j<x;j++)
+        {
+            scanf("%d",&p[i].a[j][0]);
+            scanf("%d",&p[i].a[j][1]);
+        }
+    }
+    scanf("%d%d%lf",&s,&t,&m);
+    b[s]=0;
+    q.push(s);
+    int hd;
+    while(!q.empty())
+    {
+        hd=q.front();
+        q.pop();
+        for(int i=0;i<50;i++)
+        {
+            if(p[hd].a[i][0]==hd)
+              continue;
+            if(p[hd].a[i][0]!=-1&&(b[p[hd].a[i][0]]+1<1e-8||b[p[hd].a[i][0]]>b[hd]+(100.0-b[hd])*p[hd].a[i][1]/100))
+            {
+                q.push(p[hd].a[i][0]);
+                b[p[hd].a[i][0]]=b[hd]+(100.0-b[hd])*p[hd].a[i][1]/100;
+            }
+        }
+    }
+   if(b[t]+1<1e-8)
+       cout<<"IMPOSSIBLE!\n";
+    else
+    printf("%.2lf\n",m*b[t]/100);
+    }
+    return 0;
+}
diff --git a/HDOJ/4319_autoAC.cpp b/HDOJ/4319_autoAC.cpp
new file mode 100644
index 0000000..ccf8856
--- /dev/null
+++ b/HDOJ/4319_autoAC.cpp
@@ -0,0 +1,183 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+const int MAXN = 100010;
+struct Point
+{
+    __int64 x, y;
+}point[MAXN], high[2][MAXN], low[2][MAXN], merge[MAXN * 2];
+int pointNumber, highNumber[2], lowNumber[2], mergeNumber;
+int n, stack[MAXN], top;
+__int64 a[MAXN];
+Point operator + (const Point &a, const Point &b)
+{
+    Point r;
+    r.x = a.x + b.x;
+    r.y = a.y + b.y;
+    return r;
+}
+Point operator - (const Point &a, const Point &b)
+{
+    Point r;
+    r.x = a.x - b.x;
+    r.y = a.y - b.y;
+    return r;
+}
+inline __int64 operator * (const Point &a, const Point &b)
+{
+    return a.x * b.y - a.y * b.x;
+}
+inline __int64 absolute(int x)
+{
+    return x >= 0 ? x : -x;
+}
+inline double max(const double &x, const double &y)
+{
+    return x > y ? x : y;
+}
+inline __int64 cross(const Point &a, const Point &b, const Point &o)
+{
+    return (a - o) * (b - o);
+}
+void getBound(Point result[], int &resultNumber, bool isHigh)
+{
+    if(pointNumber == 1)
+    {
+        result[0] = point[0];
+        resultNumber = 1;
+        return;
+    }
+    stack[0] = 0;
+    stack[1] = 1;
+    top = 2;
+    if(isHigh)
+    {
+        for(int i=2;i<pointNumber;++i)
+        {
+            while(top >= 2 && cross(point[stack[top-2]], point[i], point[stack[top-1]]) < 0)
+            {
+                -- top;
+            }
+            stack[top++] = i;
+        }
+    }
+    else
+    {
+        for(int i=2;i<pointNumber;++i)
+        {
+            while(top >= 2 && cross(point[stack[top-2]], point[i], point[stack[top-1]]) > 0)
+            {
+                -- top;
+            }
+            stack[top++] = i;
+        }
+    }
+    resultNumber = top;
+    for(int i=0;i<top;++i)
+    {
+        result[i].x = point[stack[i]].x;
+        result[i].y = point[stack[i]].y;
+    }
+}
+void mergeBound(Point p1[], int len1, Point p2[], int len2, bool isHigh)
+{
+    merge[mergeNumber++] = p1[0] + p2[0];
+    int pNum1 = 1, pNum2 = 1;
+    while(pNum1 < len1 || pNum2 < len2)
+    {
+        if(pNum1 == len1)
+        {
+            merge[mergeNumber++] = p1[pNum1 - 1] + p2[pNum2 ++];
+        }
+        else if(pNum2 == len2)
+        {
+            merge[mergeNumber++] = p1[pNum1 ++] + p2[pNum2 - 1];
+        }
+        else
+        {
+            Point temp0 = p1[pNum1 - 1] + p2[pNum2 - 1];
+            Point temp1 = p1[pNum1] + p2[pNum2 - 1];
+            Point temp2 = p1[pNum1 - 1] + p2[pNum2];
+            if(isHigh)
+            {
+                if(cross(temp1, temp2, temp0) < 0)
+                {
+                    merge[mergeNumber++] = temp1;
+                    ++ pNum1;
+                }
+                else
+                {
+                    merge[mergeNumber++] = temp2;
+                    ++ pNum2;
+                }
+            }
+            else
+            {
+                if(cross(temp1, temp2, temp0) > 0)
+                {
+                    merge[mergeNumber++] = temp1;
+                    ++ pNum1;
+                }
+                else
+                {
+                    merge[mergeNumber++] = temp2;
+                    ++ pNum2;
+                }
+            }
+        }
+    }
+}
+double solve(int l, int r)
+{
+    if(l == r)
+    {
+        return absolute(a[l]);
+    }
+    int mid = (l + r) >> 1;
+    double ansL = solve(l, mid);
+    double ansR = solve(mid + 1, r);
+    double ans = max(ansL, ansR);
+    __int64 sum = 0;
+    pointNumber = 0;
+    for(int i=mid;i>=l;--i)
+    {
+        sum += a[i];
+        point[pointNumber].x = mid - i + 1;
+        point[pointNumber].y = sum;
+        ++ pointNumber;
+    }
+    getBound(high[0], highNumber[0], true);
+    getBound(low[0], lowNumber[0], false);
+    sum = 0;
+    pointNumber = 0;
+    for(int i=mid+1;i<=r;++i)
+    {
+        sum += a[i];
+        point[pointNumber].x = i - mid;
+        point[pointNumber].y = sum;
+        ++ pointNumber;
+    }
+    getBound(high[1], highNumber[1], true);
+    getBound(low[1], lowNumber[1], false);
+    mergeNumber = 0;
+    mergeBound(high[0], highNumber[0], high[1], highNumber[1], true);
+    mergeBound(low[0], lowNumber[0], low[1], lowNumber[1], false);
+    for(int i=0;i<mergeNumber;++i)
+    {
+        ans = max(ans, fabs((double)merge[i].y) / sqrt((double)merge[i].x));
+    }
+    return ans;
+}
+int main()
+{
+    while(~scanf("%d", &n))
+    {
+        for(int i=0;i<n;++i)
+        {
+            scanf("%I64d", &a[i]);
+        }
+        double ans = solve(0, n - 1);
+        printf("%.6lf\n", ans * ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4320_autoAC.cpp b/HDOJ/4320_autoAC.cpp
new file mode 100644
index 0000000..9d163f9
--- /dev/null
+++ b/HDOJ/4320_autoAC.cpp
@@ -0,0 +1,57 @@
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+typedef long long int Int64;
+int p[1000005], rec[100005], cnt;
+void getprime()
+{
+    int k;
+    for (int i = 4; i <= 1000000; i += 2) {
+        p[i] = 1;
+    }
+    for (int i = 3; i <= 1000; i += 2) {
+        k = 2 * i;
+        for (int j = i * i; j <= 1000000; j += k) {
+            p[j] = 1;    
+        }    
+    }
+    rec[1] = 2;
+    cnt = 1;
+    for (int i = 3; i <= 1000000; i += 2) {
+        if (!p[i]) {
+            rec[++cnt] = i;    
+        }    
+    }
+}
+int main()
+{
+    int T, LIM, flag, ca = 0;
+    Int64 a, b;
+    getprime();
+    scanf("%d", &T);
+    while (T--) {
+        flag = 0;
+        scanf("%I64d %I64d", &a, &b);
+        LIM = (int)sqrt(double(a));
+        for (int i = 1; rec[i] <= LIM; ++i) {
+            if (a % rec[i] == 0) {
+                if (b % rec[i] != 0) {
+                    flag = 1;
+                    break;
+                }
+                while (a % rec[i] == 0) {
+                    a /= rec[i];    
+                }
+            }
+        }
+        if (a != 1 && b % a != 0) {
+            flag = 1;    
+        }
+        printf("Case #%d: ", ++ca);
+        printf(flag ? "NO\n" : "YES\n");
+    }
+    return 0;    
+}
diff --git a/HDOJ/4321_autoAC.cpp b/HDOJ/4321_autoAC.cpp
new file mode 100644
index 0000000..876745a
--- /dev/null
+++ b/HDOJ/4321_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+void Solve(LL a,LL b,LL n)
+{
+    LL cnt=0;
+    LL max=b+a*n;
+    for(LL i=0;i<64;i++)
+    {
+        LL m=(LL)1<<i;
+        LL mm=m;
+        if(m>max) break;
+        m<<=1;
+        LL cur=a+b;
+        LL j=0;
+        while(j<m&&j<n)
+        {
+            LL upper=cur+(mm-(cur%mm))-(LL)1;
+            LL step=(upper-cur)/a+(LL)1;
+            if(j+step>=n) step=n-j;
+            if(j+step>=m) step=m-j;
+            if(cur&(LL)1<<i)
+            {
+                cnt+=step*(n/m);
+                if(j+step<(n%m)) cnt+=step;
+                else if(j<(n%m)) cnt+=(n%m)-j;
+            }
+            cur+=a*step;
+            j+=step;
+        }
+    }
+    cout<<cnt<<endl;
+}
+int main()
+{
+    int t,k=1;
+    LL a,b,n,i,j;
+    cin>>t;
+    while(t--)
+    {
+        cin>>a>>b>>n;
+        cout<<"Case #"<<k++<<": ";
+        Solve(a,b,n);
+    }
+    return 0;
+}
diff --git a/HDOJ/4323_autoAC.cpp b/HDOJ/4323_autoAC.cpp
new file mode 100644
index 0000000..c44b201
--- /dev/null
+++ b/HDOJ/4323_autoAC.cpp
@@ -0,0 +1,115 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#include<iostream>
+#include<vector>
+#include<string>
+#include<math.h>
+#include<map>
+#include<set>
+#include<stack>
+#include<queue>
+#include<algorithm>
+using namespace std;
+int dp[40][40];
+char s1[100], s2[100], st[10010][30];
+const int inf  = 0x7f7f7f7f;
+struct node
+{
+  char word[30]; 
+  node *next[30];
+}root;
+node p[100000];
+int num, flag, vnum, fuck;
+map<string,int>mp;
+int f[100000];
+void init( )
+{
+  for( int i = 0; i < 40; i++)
+       for( int j = 0; j < 40; j++)
+            dp[i][j] = inf;      
+}
+int diff( char *s1, char *s2)
+{
+  init();
+  int x = strlen(s1+1);
+  int y = strlen(s2+1);
+    for( int i = 0; i <= x; i++)
+        dp[i][0] = i;
+   for( int j = 0; j <= y; j++)
+        dp[0][j] = j;
+   for( int i = 1; i <= x; i++)
+   {
+        for( int j = 1; j <= y; j++)
+        {
+             dp[i][j] = min(min(dp[i-1][j]+1, dp[i][j-1]+1), dp[i-1][j-1]+ !(s1[i]==s2[j]) );
+        }  
+  }
+  return dp[x][y]; 
+} 
+void insert(node *q, char *str)
+{
+  node *l = q;
+  while( l )
+  {
+     int dis = diff( l->word, str);
+     if( ! l->next[dis] )
+     {
+        l->next[dis] = &p[num++];
+        strcpy(l->next[dis]->word + 1, str + 1);
+        break;
+     }
+     l = l->next[dis];               
+  }        
+}
+void sfind(node *q, char *str, int d)
+{
+  if( flag ) 
+      return ;
+  node *l = q;
+  if( l == NULL )
+      return;
+  int dis = diff(str, l->word);
+  if( dis <= d )
+  {
+    fuck++;
+  }
+  for( int x = dis-d; x <= dis+d; x++)
+  {  
+     if( x >= 0 && x <= 20 && l->next[x] )
+         sfind(l->next[x], str, d);     
+  }
+}
+int main( )
+{
+  int N, M, d, cnt, T, abc = 1;
+  char str[1000];
+  scanf("%d",&T);
+  while( T-- )
+  {
+    scanf("%d%d",&N,&M);
+    memset(p,0,sizeof(p));
+    for( int i = 0; i < 30; i++)
+         root.next[i] = NULL;
+    num = 0;
+    int cnum = 1;
+    strcpy(st[0] + 1, root.word+1);
+    for( int i = 1; i <= N; i++)
+    {
+       scanf("%s",st[i]+1);
+       insert(&root, st[i]);
+    }
+    d = 1;
+    printf("Case #%d:\n", abc++);
+    for( int i = 1; i <= M; i++)
+    {
+       vnum = 0;
+       flag = 0;
+       fuck = 0;
+       scanf("%s%d",str+1, &d);
+       sfind(&root, str, d); 
+       printf("%d\n", fuck);
+    }
+  }
+  return 0;
+}
diff --git a/HDOJ/4324_autoAC.cpp b/HDOJ/4324_autoAC.cpp
new file mode 100644
index 0000000..d9d951a
--- /dev/null
+++ b/HDOJ/4324_autoAC.cpp
@@ -0,0 +1,42 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int N=2010;
+int n,indeg[N];     
+char str[N][N];
+int main(){
+    int t,cases=0;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        int flag=0;
+        memset(indeg,0,sizeof(indeg));  
+        int i,j;
+        for(i=0;i<n;i++){
+            scanf("%s",str[i]);
+            for(j=0;j<n;j++)
+                if(str[i][j]=='1')  
+                    indeg[j]++;
+        }
+        for(i=0;i<n;i++){
+            for(j=0;j<n;j++)
+                if(indeg[j]==0)    
+                    break;
+            if(j==n){       
+                flag=1;
+                break;
+            }else{
+                indeg[j]--; 
+                for(int k=0;k<n;k++)    
+                    if(str[j][k]=='1')
+                        indeg[k]--;
+            }
+        }
+        if(flag)
+            printf("Case #%d: Yes\n",++cases);
+        else
+            printf("Case #%d: No\n",++cases);
+    }
+    return 0;
+}
diff --git a/HDOJ/4325_autoAC.cpp b/HDOJ/4325_autoAC.cpp
new file mode 100644
index 0000000..0b0c116
--- /dev/null
+++ b/HDOJ/4325_autoAC.cpp
@@ -0,0 +1,74 @@
+#include<iostream>
+#include<algorithm>
+using namespace std;
+#define lson u<<1
+#define rson u<<1|1
+const int maxn=100010;
+int st[maxn],ed[maxn];
+int q[maxn],dat[maxn<<1];
+struct Node{
+    int lef,rig,delta;
+}T[maxn<<2];
+void Build(int u,int l,int r){
+    T[u].lef=l;
+    T[u].rig=r;
+    T[u].delta=0;
+    if(l==r)return;
+    int mid=(l+r)>>1;
+    Build(lson,l,mid);
+    Build(rson,mid+1,r);
+}
+void PushDown(int u){
+    if(T[u].delta>0){
+        T[lson].delta+=T[u].delta;
+        T[rson].delta+=T[u].delta;
+        T[u].delta=0;
+    }
+}
+void Update(int u,int l,int r){
+    if(l<=T[u].lef&&T[u].rig<=r){T[u].delta++;return;}
+    else {
+        PushDown(u);
+        if(l<=T[lson].rig)Update(lson,l,r);
+        if(r>=T[rson].lef)Update(rson,l,r);
+    }
+}
+int Query(int u,int index){
+    if(T[u].lef==T[u].rig)return T[u].delta;
+    else {
+        PushDown(u);
+        if(index<=T[lson].rig)return Query(lson,index);
+        else return Query(rson,index);
+    }
+}
+int main(){
+    int t,n,m;
+    int cnt;
+    scanf("%d",&t);
+    for(int cas=1;cas<=t;cas++){
+        scanf("%d%d",&n,&m);
+        cnt=0;
+        for(int i=1;i<=n;i++){
+            scanf("%d%d",&st[i],&ed[i]);
+            dat[cnt++]=st[i];
+            dat[cnt++]=ed[i];
+        }
+        for(int i=1;i<=m;i++){
+            scanf("%d",&q[i]);
+            dat[cnt++]=q[i];
+        }
+        sort(dat,dat+cnt);
+        cnt=unique(dat,dat+cnt)-dat;
+        Build(1,1,cnt);
+        for(int i=1;i<=n;i++){
+            st[i]=lower_bound(dat,dat+cnt,st[i])-dat+1;
+            ed[i]=lower_bound(dat,dat+cnt,ed[i])-dat+1;
+            Update(1,st[i],ed[i]);
+        }
+        printf("Case #%d:\n",cas);
+        for(int i=1;i<=m;i++){
+            q[i]=lower_bound(dat,dat+cnt,q[i])-dat+1;
+            printf("%d\n",Query(1,q[i]));
+        }
+    }
+}
diff --git a/HDOJ/4326_autoAC.cpp b/HDOJ/4326_autoAC.cpp
new file mode 100644
index 0000000..648f6ca
--- /dev/null
+++ b/HDOJ/4326_autoAC.cpp
@@ -0,0 +1,102 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+#include<cmath>
+using namespace std;
+#define maxn 102
+#define eps 1e-10
+double g[maxn][maxn];
+double x[maxn];
+int n,m,k;
+void add(int cnt,int i,int j,double val)
+{
+    int t=i*n+j;
+    if(i==m)
+    {
+        if(j==1)    
+            g[cnt][m*n+1]+=-1.0*val;  
+        return;
+    }
+    g[cnt][t]+=val;
+}
+void gauss(int n,int m)
+{
+    int row,col,i,j,k;
+    for(row=1,col=1;row<n,col<m;row++,col++)
+    {
+        k=row;
+        for(i=row+1;i<=n;i++)  
+            if(fabs(g[i][col])>fabs(g[k][col]))
+                k=i;
+        if(k!=row)  
+        {
+            for(i=col; i<=m; i++)
+                swap(g[k][i],g[row][i]);
+        }
+        for(i=row+1; i<=n; i++)  
+        {
+            if(fabs(g[i][col])<eps)
+                continue;
+            double t=g[i][col]/g[row][col];
+            g[i][col]=0.0;
+            for(j=col+1;j<=m;j++)
+                g[i][j]-=t*g[row][j];
+        }
+    }
+    for(i=n;i>=1;i--)  
+    {
+        x[i]=g[i][m];
+        for(j=i+1;j<=n;j++)
+            x[i]-=x[j]*g[i][j];
+        x[i]/=g[i][i];
+    }
+}
+int main()
+{
+    int i,j,cs,nn=0;
+    scanf("%d",&cs);
+    while(cs--){
+        scanf("%d%d%d",&n,&m,&k);
+        memset(g,0,sizeof(g));
+        int cnt=0;
+        for(i=0;i<m;i++)
+            for(j=1;j<=n;j++)
+            {
+                cnt++;
+                add(cnt,i,j,1.0);
+                if(j==1)
+                {
+                    add(cnt,i+1,j,-0.25);
+                    add(cnt,1,n-2,-0.75);
+                }
+                else if(j==2)
+                {
+                    add(cnt,i+1,n-2,-0.25);
+                    add(cnt,1,1,-0.25);
+                    add(cnt,1,n-1,-0.5);
+                }
+                else if(j==3)
+                {
+                    add(cnt,i+1,n-1,-0.25);
+                    add(cnt,1,1,-0.25);
+                    add(cnt,1,n-1,-0.25);
+                    add(cnt,1,n,-0.25);
+                }
+                else if(j==4)
+                {
+                    add(cnt,i+1,n,-0.25);
+                    add(cnt,1,n,-0.5);
+                    add(cnt,1,1,-0.25);
+                }
+                else
+                {
+                    add(cnt,i+1,j-3,-0.25);
+                    add(cnt,1,j-3,-0.75);
+                }
+            }
+        gauss(cnt,cnt+1);
+        printf("Case #%d: %.6lf\n",++nn,x[k]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4327_autoAC.cpp b/HDOJ/4327_autoAC.cpp
new file mode 100644
index 0000000..42cf9cd
--- /dev/null
+++ b/HDOJ/4327_autoAC.cpp
@@ -0,0 +1,161 @@
+#include <cmath>
+#include <cstdio>
+#include<algorithm>
+using namespace std;
+const  double INF = 1000000000.0;
+const  int maxn = 1010;
+const double eps = 1e-12;
+inline double sgn(double x) {return fabs(x)<eps?0:(x>0?1:-1);}
+struct Point{
+    double x,y;
+    Point(double tx=0,double ty=0){x=tx;y=ty;}
+    bool operator == (const Point& t) const {
+        return sgn(x-t.x)==0 && sgn(y-t.y)==0;
+    }
+     Point operator - (const Point& t) const {
+        Point tmp;
+        tmp.x = x - t.x;
+        tmp.y = y - t.y;
+        return tmp;
+    }
+}p[maxn],tmp[maxn],pp[maxn],GP;
+struct Seg{Point s,e;};
+struct Line {
+    double a, b, c;
+};
+double cross(Point a,Point b,Point c){return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x);}
+inline Point intersect(Point x,Point y,double a,double b,double c){  
+    double u = fabs(a * x.x + b * x.y + c);  
+    double v = fabs(a * y.x + b * y.y + c);  
+    return Point( (x.x * v + y.x * u) / (u + v) , (x.y * v + y.y * u) / (u + v) );  
+}  
+int n,ban_tot;
+void CUT1(double a,double b,double c){
+    int i,tot=0;
+    for(int i = 1; i <= ban_tot; ++i){  
+        if(a*p[i].x + b*p[i].y + c >= eps) pp[++tot] = p[i];  
+        else {  
+            if(a*p[i-1].x + b*p[i-1].y + c > eps){  
+                pp[++tot] = intersect(p[i],p[i-1],a,b,c);  
+            }  
+            if(a*p[i+1].x + b*p[i+1].y + c > eps){  
+                pp[++tot] = intersect(p[i],p[i+1],a,b,c);  
+            }  
+        }  
+    }  ban_tot=tot;
+    pp[tot+1]=pp[1];pp[0]=pp[tot];
+    memcpy(p,pp,sizeof(pp));
+}
+void CUT2(double a,double b,double c){       
+    int i,tot=0;
+    for(int i = 1; i <= ban_tot; ++i){  
+        if(!(a*p[i].x + b*p[i].y + c > eps) ) pp[++tot] = p[i];
+        else {  
+            if(a*p[i-1].x + b*p[i-1].y + c < -eps){  
+                pp[++tot] = intersect(p[i],p[i-1],a,b,c);  
+            }  
+            if(a*p[i+1].x + b*p[i+1].y + c < -eps){  
+                pp[++tot] = intersect(p[i],p[i+1],a,b,c);  
+            }  
+        }  
+    }  ban_tot=tot;
+    pp[tot+1]=pp[1];pp[0]=pp[tot];
+    memcpy(p,pp,sizeof(pp));
+}
+Line Turn(Point s, Point e) {                                        
+    Line ln;
+    ln.a = s.y - e.y;
+    ln.b = e.x - s.x;
+    ln.c = s.x*e.y - e.x*s.y;
+    return ln;
+}
+Line make(Point a,Point b)
+{
+    double x0=(a.x+b.x)/2;
+    double y0=(a.y+b.y)/2;
+    Line tmp=Turn(a,b);
+    Line ans;
+    ans.a=tmp.b;
+    ans.b=-tmp.a;
+    ans.c=tmp.a*y0-tmp.b*x0;
+    return ans;
+}
+Line ln[maxn];
+inline double PPdis(Point a, Point b) {                               
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+inline double PLdis(Point p,Point l1,Point l2){                      
+    return fabs(cross(p,l1,l2))/PPdis(l1,l2);
+}
+double calc(Point *p,int n)
+{
+      if(n<3) return 0;
+      double area=0,V=0;
+      for(int i=0;i<n;i++) area+=p[(i+1)%n].y*(p[i].x-p[(i+2)%n].x);
+      area/=2;
+      area=fabs(area);
+      double H=10;
+      int pos=0;
+      for(int i=0;i<n;i++)
+      {
+          if(2-p[i].x-p[i].y<H)
+          {
+                  H=2-p[i].x-p[i].y;
+                  pos=i;
+          }
+      }
+      V+=area*H;
+      for(int i=pos+1;;i++)
+      {  
+          int id1=i%n;
+          int id2=(i+1)%n;
+          if(id2==pos) break;
+          double h=PLdis(p[pos],p[id1],p[id2]);
+          double s=((2-p[id1].x-p[id1].y-H) + (2-p[id2].x-p[id2].y-H)) * PPdis(p[id1],p[id2])/2;
+          V+=s*h/3;
+      }
+      return V;
+}
+double ans[110];
+int main(){
+    int t,ca=1,n;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++) scanf("%lf%lf",&tmp[i].x,&tmp[i].y);
+        for(int i=1;i<=n;i++)
+        {
+            p[1]=Point(0,0);
+            p[2]=Point(0,1);
+            p[3]=Point(1,1);
+            p[4]=Point(1,0);
+            p[0]=p[4];
+            p[5]=p[1];
+            ban_tot=4;
+            double x0=tmp[i].x,y0=tmp[i].y;
+            for(int j=1;j<=n;j++)
+            {
+                if(i==j) continue;
+                Line mid_line = make(tmp[i],tmp[j]);
+                double a=mid_line.a,b=mid_line.b,c=mid_line.c;
+                if(a*x0+b*y0+c >= eps)
+                {
+                    CUT1(a,b,c);
+                }
+                else 
+                {
+                    CUT2(a,b,c);
+                }
+            }
+            double tmpv=calc(p,ban_tot);
+            ans[i]=tmpv;
+        }
+        printf("Case #%d:\n",ca++);
+        for(int i=1;i<=n;i++)
+        {
+            printf("%.6lf\n",ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4328_autoAC.cpp b/HDOJ/4328_autoAC.cpp
new file mode 100644
index 0000000..5d970b1
--- /dev/null
+++ b/HDOJ/4328_autoAC.cpp
@@ -0,0 +1,210 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+char map[1010][1010];
+int lefts[1010][1010],heights[1010][1010],rights[1010][1010];
+int CountSingle(int n,int m,char sing){
+    int ret=0;
+    for(int i=1;i<=n;i++){
+        if(i==1){
+            int l=0;
+            for(int j=1;j<=m;j++){
+                if(map[i][j]!=sing){
+                    heights[i][j]=0;
+                    lefts[i][j]=m+1;
+                    l=j;
+                }
+                else{
+                    heights[i][j]=1;
+                    lefts[i][j]=l+1;
+                }
+            }
+            int r=m+1;
+            for(int j=m;j>=1;j--){
+                if(map[i][j]!=sing){
+                    rights[i][j]=0;
+                    r=j;
+                }
+                else{
+                    rights[i][j]=r-1;
+                    ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
+                }
+            }
+        }
+        else{
+            int l=0;
+            for(int j=1;j<=m;j++){
+                if(map[i][j]!=sing){
+                    heights[i][j]=0;
+                    lefts[i][j]=m+1;
+                    l=j;
+                }
+                else{
+                    if(map[i-1][j]==sing){
+                        heights[i][j]=heights[i-1][j]+1;
+                        lefts[i][j]=max(lefts[i-1][j],l+1);
+                    }
+                    else{
+                        heights[i][j]=1;
+                        lefts[i][j]=l+1;
+                    }
+                }
+            }
+            int r=m+1;
+            for(int j=m;j>=1;j--){
+                if(map[i][j]!=sing){
+                    rights[i][j]=0;
+                    r=j;
+                }
+                else{
+                    if(map[i-1][j]==sing){
+                        rights[i][j]=min(rights[i-1][j],r-1);
+                        ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
+                    }
+                    else{
+                        rights[i][j]=r-1;
+                        ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
+                    }
+                }
+            }
+        }
+    }
+    return ret;
+}
+int CountCross(int n,int m){
+    int ret=0;
+    for(int i=1;i<=n;i++){
+        if(i==1){
+            int l=0;
+            for(int j=1;j<=m;j++){
+                if(j==1){
+                    heights[i][j]=1;
+                    lefts[i][j]=1;
+                }
+                else{
+                    if(map[i][j-1]==map[i][j]){
+                        lefts[i][j]=j;
+                        l=j-1;
+                        heights[i][j]=1;
+                    }
+                    else{
+                        lefts[i][j]=l+1;
+                        heights[i][j]=1;
+                    }
+                }
+            }
+            int r=m+1;
+            for(int j=m;j>=1;j--){
+                if(j==m){
+                    heights[i][j]=1;
+                    rights[i][j]=m;
+                }
+                else{
+                    if(map[i][j]==map[i][j+1]){
+                        heights[i][j]=1;
+                        rights[i][j]=j;
+                        r=j+1;
+                    }
+                    else{
+                        rights[i][j]=r-1;
+                        heights[i][j]=1;
+                    }
+                }
+                ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
+            }
+        }
+        else{
+            int l=0;
+            for(int j=1;j<=m;j++){
+                if(j==1){
+                    if(map[i][j]!=map[i-1][j]){
+                        heights[i][j]=heights[i-1][j]+1;
+                        lefts[i][j]=1;
+                    }
+                    else{
+                        heights[i][j]=1;
+                        lefts[i][j]=1;
+                    }
+                }
+                else{
+                    if(map[i][j]!=map[i-1][j]){
+                        heights[i][j]=heights[i-1][j]+1;
+                        if(map[i][j]==map[i][j-1]){
+                            lefts[i][j]=j;
+                            l=j-1;
+                        }
+                        else{
+                            lefts[i][j]=max(lefts[i-1][j],l+1);
+                        }
+                    }
+                    else{
+                        heights[i][j]=1;
+                        if(map[i][j]==map[i][j-1]){
+                            lefts[i][j]=j;
+                            l=j-1;
+                        }
+                        else{
+                            lefts[i][j]=l+1;
+                        }
+                    }
+                }
+            }
+            int r=m+1;
+            for(int j=m;j>=1;j--){
+                if(j==m){
+                    if(map[i][j]!=map[i-1][j]){
+                        heights[i][j]=heights[i-1][j]+1;
+                        rights[i][j]=m;
+                    }
+                    else{
+                        heights[i][j]=1;
+                        rights[i][j]=m;
+                    }
+                }
+                else{
+                    if(map[i][j]!=map[i-1][j]){
+                        heights[i][j]=heights[i-1][j]+1;
+                        if(map[i][j]==map[i][j+1]){
+                            rights[i][j]=j;
+                            r=j+1;
+                        }
+                        else{
+                            rights[i][j]=min(rights[i-1][j],r-1);
+                        }
+                    }
+                    else{
+                        heights[i][j]=1;
+                        if(map[i][j]==map[i][j+1]){
+                            rights[i][j]=j;
+                            r=j+1;
+                        }
+                        else{
+                            rights[i][j]=r-1;
+                        }
+                    }
+                }
+                ret=max(ret,heights[i][j]*2+2*(rights[i][j]-lefts[i][j]+1));
+            }
+        }
+    }
+    return ret;
+}
+int main(){
+    int ansR,ansB,ansC,kase=0;
+    int T,n,m;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d%d",&n,&m);
+        getchar();
+        for(int i=1;i<=n;i++)
+            gets(map[i]+1);
+        ansR=CountSingle(n,m,'R');
+        ansB=CountSingle(n,m,'B');
+        ansC=CountCross(n,m);
+        cout<<"Case #"<<++kase<<": "<<max(ansR,max(ansB,ansC))<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4329_autoAC.cpp b/HDOJ/4329_autoAC.cpp
new file mode 100644
index 0000000..7afc9f5
--- /dev/null
+++ b/HDOJ/4329_autoAC.cpp
@@ -0,0 +1,74 @@
+#include<cstdio>  
+#include<cstring>  
+#include<map>  
+#include<string>  
+#include<iostream>  
+using namespace std;  
+int main(){  
+    int t,T,i,j,k,n;  
+    int sta;  
+    double sum[110],ans;  
+    int all[110];  
+    int ss,num;  
+    string str;  
+    char sss[10010];  
+    map<string,int> m[100];  
+    scanf("%d",&T);  
+    for(t=1;t<=T;t++){  
+        memset(all,0,sizeof(all));  
+        memset(sum,0,sizeof(sum));  
+        scanf("%d",&n);  
+        for(i=0;i<n;i++){  
+            scanf("%s",str);  
+            getline(cin,str);  
+            for(j=0;j<str.length() && str[j]==' ';j++);  
+            sta=j;  
+            for(;j<str.length();j++){  
+                if(str[j]==' '){  
+                    m[i].insert(make_pair(str.substr(sta,j-sta),1));  
+                    all[i]++;  
+                    for(;j<str.length() && str[j]==' ';j++);  
+                    sta=j;  
+                    if(sta==str.length())break;  
+                    j--;  
+                }  
+            }  
+            if(sta!=str.length()){  
+                m[i].insert(make_pair(str.substr(sta,j-sta),1));  
+                all[i]++;  
+            }  
+        }  
+        for(i=0;i<n;i++){  
+            scanf("%s",str);  
+            getline(cin,str);  
+            for(j=0;j<str.length() && str[j]==' ';j++);  
+            sta=j;  
+            ss=num=0;  
+            for(;j<str.length();j++){  
+                if(str[j]==' '){  
+                    num++;  
+                    if(m[i].find(str.substr(sta,j-sta))!=m[i].end()){  
+                        ss++;  
+                        sum[i]+=(double)ss/num;  
+                    }  
+                    for(;j<str.length() && str[j]==' ';j++);  
+                    sta=j;  
+                    if(sta==str.length())break;  
+                    j--;  
+                }  
+            }  
+            if(sta!=str.length()){  
+                num++;  
+                if(m[i].find(str.substr(sta,j-sta))!=m[i].end()){  
+                     ss++;  
+                     sum[i]+=(double)ss/num;  
+                }  
+            }  
+            sum[i]/=all[i];  
+        }  
+        ans=0;  
+        for(i=0;i<n;i++)  
+            ans+=sum[i];  
+        printf("Case #%d: %.6lf\n",t,ans/n);  
+    }  
+}
diff --git a/HDOJ/4330_autoAC.cpp b/HDOJ/4330_autoAC.cpp
new file mode 100644
index 0000000..6e18630
--- /dev/null
+++ b/HDOJ/4330_autoAC.cpp
@@ -0,0 +1,231 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-8;
+int getNumberOnce(char stage[10][10])
+{
+    bool remove[10][10];
+    memset(remove, false, sizeof(remove));
+    for(int i=0;i<8;++i)
+    {
+        for(int j=0;j<8;++j)
+        {
+            if(i<6)
+            {
+                if(stage[i][j])
+                {
+                    if(stage[i][j] == stage[i+1][j])
+                    {
+                        if(stage[i][j] == stage[i+2][j])
+                        {
+                            remove[i][j] = true;
+                            remove[i+1][j] = true;
+                            remove[i+2][j] = true;
+                        }
+                    }
+                }
+            }
+            if(j<6)
+            {
+                if(stage[i][j])
+                {
+                    if(stage[i][j] == stage[i][j+1])
+                    {
+                        if(stage[i][j] == stage[i][j+2])
+                        {
+                            remove[i][j] = true;
+                            remove[i][j+1] = true;
+                            remove[i][j+2] = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    int num = 0;
+    for(int i=0;i<8;++i)
+    {
+        for(int j=0;j<8;++j)
+        {
+            if(remove[i][j])
+            {
+                stage[i][j] = 0;
+                ++ num;
+            }
+        }
+    }
+    return num;
+}
+void fallDown(char stage[10][10])
+{
+    for(int j=0;j<8;++j)
+    {
+        int k = 7;
+        for(int i=7;i>=0;--i)
+        {
+            if(stage[i][j])
+            {
+                stage[k--][j] = stage[i][j];
+            }
+        }
+        for(int i=k;i>=0;--i)
+        {
+            stage[i][j] = 0;
+        }
+    }
+}
+int getNumber(char stage[10][10])
+{
+    int num = 0;
+    while(true)
+    {
+        int temp = getNumberOnce(stage);
+        if(temp == 0)
+        {
+            break;
+        }
+        num += temp;
+        fallDown(stage);
+    }
+    return num;
+}
+char stage[10][10];
+bool simpleJudge()
+{
+    char temp[10][10];
+    memcpy(temp, stage, sizeof(temp));
+    return getNumber(temp) >= 8;
+}
+struct Point
+{
+    int x, y;
+};
+int getPow5(int x)
+{
+    int res = 1;
+    while(x--)
+    {
+        res *= 5;
+    }
+    return res;
+}
+double completeJudge(char stage[10][10], int remain)
+{
+    char temp[10][10];
+    memcpy(temp, stage, sizeof(temp));
+    int num = getNumberOnce(temp);
+    if(num >= remain)
+    {
+        return 1.0;
+    }
+    if(num == 0)
+    {
+        return 0.0;
+    }
+    remain -= num;
+    fallDown(temp);
+    Point stack[8];
+    int top = 0;
+    for(int i=0;i<8;++i)
+    {
+        for(int j=0;j<8;++j)
+        {
+            if(!temp[i][j])
+            {
+                stack[top].x = i;
+                stack[top].y = j;
+                ++ top;
+            }
+        }
+    }
+    int total = getPow5(top);
+    double ret = 0.0;
+    for(int i=0;i<total;++i)
+    {
+        int bit = i;
+        for(int j=0;j<top;++j)
+        {
+            temp[stack[j].x][stack[j].y] = '0' + (bit % 5);
+            bit /= 5;
+        }
+        ret += completeJudge(temp, remain);
+    }
+    return ret / total;
+}
+int main()
+{
+    int caseNumber;
+    scanf("%d", &caseNumber);
+    for(int cas=1;cas<=caseNumber;++cas)
+    {
+        for(int i=0;i<8;++i)
+        {
+            scanf("%s", stage[i]);
+        }
+        double ans = 0.0;
+        bool end = false;
+        for(int i=0;i<8 && !end;++i)
+        {
+            for(int j=0;j<8 && !end;++j)
+            {
+                if(i!=7)
+                {
+                    swap(stage[i][j], stage[i+1][j]);
+                    if(simpleJudge())
+                    {
+                        ans = 1.0;
+                        end = true;
+                    }
+                    swap(stage[i][j], stage[i+1][j]);
+                }
+                if(j!=7)
+                {
+                    swap(stage[i][j], stage[i][j+1]);
+                    if(simpleJudge())
+                    {
+                        ans = 1.0;
+                        end = true;
+                    }
+                    swap(stage[i][j], stage[i][j+1]);
+                }
+            }
+        }
+        if(!end)
+        {
+            double temp;
+            for(int i=0;i<8 && !end;++i)
+            {
+                for(int j=0;j<8 && !end;++j)
+                {
+                    if(i!=7)
+                    {
+                        swap(stage[i][j], stage[i+1][j]);
+                        temp = completeJudge(stage, 8);
+                        ans = max(ans, temp);
+                        swap(stage[i][j], stage[i+1][j]);
+                    }
+                    if(ans > 1.0 - eps)
+                    {
+                        ans = 1.0;
+                        end = true;
+                    }
+                    if(j!=7)
+                    {
+                        swap(stage[i][j], stage[i][j+1]);
+                        temp = completeJudge(stage, 8);
+                        ans = max(ans, temp);
+                        swap(stage[i][j], stage[i][j+1]);
+                    }
+                    if(ans > 1.0 - eps)
+                    {
+                        ans = 1.0;
+                        end = true;
+                    }
+                }
+            }
+        }
+        printf("Case #%d: %.3lf\n", cas, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4331_autoAC.cpp b/HDOJ/4331_autoAC.cpp
new file mode 100644
index 0000000..8436307
--- /dev/null
+++ b/HDOJ/4331_autoAC.cpp
@@ -0,0 +1,125 @@
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#define MAXN 1005
+using namespace std;
+int N, G[MAXN][MAXN], c[MAXN], idx;
+int dgn[MAXN];
+int l[MAXN][MAXN], r[MAXN][MAXN], u[MAXN][MAXN], d[MAXN][MAXN];
+struct Node
+{
+    int x, sign, key;
+    bool operator < (Node temp) const
+    {
+        if (x != temp.x) {
+            return x < temp.x;
+        }    
+        else {
+            return sign < temp.sign;    
+        }
+    }
+}p[MAXN<<1];  
+int lowbit(int x)
+{
+    return x  & -x;
+}
+void addpoint(int a, int b)
+{ 
+    ++idx;
+    p[idx].x = a, p[idx].sign = 0;
+    p[idx].key = a;
+    ++idx;
+    p[idx].x = b, p[idx].sign = 1;
+    p[idx].key = a;
+}
+void add(int x)
+{
+    for (int i = x; i <= N; i += lowbit(i)) {
+        c[i] += 1;    
+    }
+}
+int sum(int x)
+{
+    int ret = 0;
+    for (int i = x; i > 0; i -= lowbit(i)) {
+        ret += c[i];
+    }    
+    return ret;
+}
+int solve()
+{
+    int ret = 0;
+    for (int i = N; i >= 1; --i) {
+        idx = -1;
+        for (int j = 1; j <= (N-i+1); ++j) {  
+            if (G[i+j-1][j]) {
+                addpoint(j, j+min(r[i+j-1][j], d[i+j-1][j])-1);
+                dgn[j] = j - min(u[i+j-1][j], l[i+j-1][j])+1;
+            }
+        }
+        if (idx == -1) { continue; }
+        sort(p, p+idx+1);  
+        memset(c, 0, sizeof (c));
+        for (int k = 0; k <= idx; ++k) {
+            if (!p[k].sign) {  
+                ret -= sum(p[k].key);
+                add(dgn[p[k].x]);
+            }
+            else {  
+                ret += sum(p[k].key);
+            }
+        }
+    }
+    for (int j = 2; j <= N; ++j) {
+        idx = -1;
+        for (int i = 1; i <= (N-j+1); ++i) {
+            if (G[i][j+i-1]) {
+                addpoint(i, i+min(r[i][j+i-1], d[i][j+i-1])-1);
+                dgn[i] = i - min(u[i][j+i-1], l[i][j+i-1])+1;
+            }    
+        }
+        if (idx == -1) { continue; }
+        sort(p, p+idx+1);
+        memset(c, 0, sizeof (c));
+        for (int k = 0; k <= idx; ++k) {
+            if (!p[k].sign) {
+                ret -= sum(p[k].key);
+                add(dgn[p[k].x]);
+            }
+            else {
+                ret += sum(p[k].key);
+            }
+        }
+    }
+    return ret;
+}
+int main()
+{
+    int T, ca = 0;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d", &N);
+        memset(d, 0, sizeof (d));
+        memset(r, 0, sizeof (r));
+        for (int i = 1;  i<= N; ++i) {
+            for (int j = 1; j <= N; ++j) {
+                scanf("%d", &G[i][j]);
+                if (G[i][j]) {
+                    u[i][j] = G[i-1][j] ? u[i-1][j] + 1 : 1;
+                    l[i][j] = G[i][j-1] ? l[i][j-1] + 1 : 1;
+                }
+            }
+        }
+        for (int  i = N; i >= 1; --i) {
+            for (int j = N; j >= 1; --j) {
+                if (G[i][j]) {
+                    d[i][j] = G[i+1][j] ? d[i+1][j] + 1 : 1;
+                    r[i][j] = G[i][j+1] ? r[i][j+1] + 1 : 1;    
+                }
+            }
+        }
+        printf("Case %d: %d\n", ++ca, solve());
+    }
+    return 0;    
+}
diff --git a/HDOJ/4332_autoAC.cpp b/HDOJ/4332_autoAC.cpp
new file mode 100644
index 0000000..2d9121e
--- /dev/null
+++ b/HDOJ/4332_autoAC.cpp
@@ -0,0 +1,145 @@
+#include <stdio.h>
+#include <string.h>
+#include <map>
+#include <algorithm>
+typedef __int64 LL ;
+const LL Mod = 1000000007LL ;
+const int m = (1 << 8) ;
+const int mm = 70 ;
+bool ok[m]  ;
+int a[8] , N ;
+int min[m] ;
+struct Matrix{
+    LL mat[mm][mm] ;
+    void init(){
+        memset( mat,  0 ,sizeof(mat) ) ;
+    }
+}M[31] , res ,mid ;
+LL ans[mm] ;
+bool is_ok(int s){
+    if( s==0 )  return true ;
+    if( s==m-1 )  return true ;
+    int val[8] ;
+    int i ;
+    for(i=0;i<8;i++)
+        if( s&a[i] )    val[i] = 1 ;
+        else    val[i] = 0;
+    i = 0 ;
+    while( val[i] ) ++ i ;
+    for(int ii=0;ii<8;ii++  ){
+        if( val[ (ii+i)%8 ] == 0 )   continue ;
+        if( ii+1<8 && val[ (ii+i+1)%8 ] ){
+            ii ++ ;
+        }
+        else    return false ;
+    }
+    return true ;
+}
+int getmin( int n ){
+    int val[8] ;
+    for(int i=0;i<8;i++) {
+        if( n&a[i] )    val[i] = 1 ;
+        else    val[i] = 0 ;
+    }
+    int v = 0 ;
+    int res = n ;
+    for(int ii=0;ii<8;ii++)
+        if( val[ (2+ii)%8 ] )   v |= a[ ii ]  ;
+    if( res > v )   res = v ;
+    v = 0 ;
+    for(int ii=0;ii<8;ii++)
+        if( val[ (4+ii)%8 ] )   v |= a[ ii ]  ;
+    if( res > v )   res =v ;
+    v = 0 ;
+    for(int ii=0;ii<8;ii++)
+        if( val[ (6+ii)%8 ] )   v |= a[ ii ]  ;
+    if( res > v )   res =v ;
+    return res ;
+}
+std::map<int , int> mp ;
+bool vis[m + 10][m + 10]  ;
+void deal(int sou , int to){
+    int val[8]  ;
+    for(int i=0;i<8;i++){
+        if( to&a[i] )  val[i] = 1 ;
+        else    val[i] = 0 ;
+    }
+    LL v1 , v2 ;
+    v1 = sou ;
+    for(int j=0; j<=6;j+=2 ){
+        v2 = 0  ;
+        for(int jj=0;jj<8;jj++){
+            if( val[ (j+jj)%8 ] )  v2 |= a[jj]  ;
+        }
+        if( ( v1|v2 )==m-1 && ok[ v1&v2 ] && !vis[v1][v2] ){
+            M[0].mat[ mp[ min[v1] ] ][ mp[ min[v2] ] ] ++ ;
+            vis[v1][v2] = 1 ;
+        }
+    }
+}
+void build_matrix(){
+    M[0].init() ;
+    memset( vis , 0 , sizeof(vis) );
+    std::map<int, int>::iterator it1 ,it2  ;
+    for( it1 = mp.begin() ; it1!=mp.end() ; it1++ ){
+        for( it2=mp.begin() ; it2!=mp.end() ; it2++ ){
+            deal( it1->first , it2->first ) ;
+        }
+    }
+    M[0].mat[mm-1][mm-1] = 2 ;
+    for(int ii=1;ii<=30;ii++){
+        for(int i=0;i<mm;i++){
+                for(int j=0;j<mm;j++){
+                    mid.mat[i][j] = 0 ;
+                    for(int k=0;k<mm;k++){
+                        mid.mat[i][j] = ( mid.mat[i][j] + M[ii-1].mat[i][k] * M[ii-1].mat[k][j] % Mod ) % Mod ;
+                    }
+                }
+            }
+        M[ii] = mid ;
+    }
+}
+void init(){
+    a[0] = 1 ;
+    for(int i=1;i<8;i++)    a[i] = a[i-1]<<1 ;
+    for(int i=0;i<m;i++)    min[i] = getmin(i)  ;
+    for(int i=0;i<m;i++){
+        ok[i] = is_ok( i ) ;
+        mp[ min[i] ] = 1 ;
+    }
+    std::map<int,int>::iterator it = mp.begin() ;
+    int ss = 0 ;
+    for( it ; it != mp.end(); it ++ ){
+        it->second = ss ++ ;
+    }
+    build_matrix() ;
+}
+void calc( int n ){
+    memset( ans , 0 , sizeof(ans) )  ;
+    int jj = 0 ;
+    ans[ mm-1 ] = 1 ;
+    LL CC[mm] ;
+    while( n ){
+        if( n&1 ){
+            for(int i=0;i<mm;i++){
+                CC[i] = 0;
+                for(int j=0;j<mm;j++){
+                    CC[i] = ( CC[i] + ans[j] * M[jj].mat[i][j]% Mod ) % Mod ;
+                }
+            }
+            for(int i=0;i<mm;i++)  ans[i] = CC[i] ;
+        }
+        n >>= 1 ; jj ++ ;
+    }
+}
+int main(){
+    init() ;
+    int T ;scanf("%d",&T) ;
+    int cas = 0 ;
+    while( T-- ){
+        scanf("%d",&N) ;
+        calc(N + 1) ;
+        printf("Case %d: %I64d\n",++cas,ans[0] ) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/4333_autoAC.cpp b/HDOJ/4333_autoAC.cpp
new file mode 100644
index 0000000..e91e6c7
--- /dev/null
+++ b/HDOJ/4333_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<iostream>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<string>
+#include<queue>
+#include<algorithm>
+#include<map>
+#include<iomanip>
+#define INF 999999999
+using namespace std;
+const int MAX=100000+10;
+char s[MAX*2];
+int ne[MAX];
+void get_next(char *a,int len){
+    int i=-1,j=0;
+    ne[0]=-1;
+    while(j<len){
+        if(i == -1 || a[i] == a[j])ne[++j]=++i;
+        else i=ne[i];
+    }
+}
+void get_extend(char *a,int len){
+    int k=0,i=1;
+    ne[0]=len;
+    while(k+1<len && a[k] == a[k+1])++k;
+    ne[1]=k;
+    k=1;
+    while(++i<len/2){
+        int maxr=k+ne[k]-1;
+        ne[i]=min(ne[i-k],max(maxr-i+1,0));
+        while(i+ne[i]<len && a[ne[i]] == a[i+ne[i]])++ne[i];
+        if(i+ne[i]>k+ne[k])k=i;
+    }
+}
+int main(){
+    int t,num=0;
+    cin>>t;
+    while(t--){
+        scanf("%s",s);
+        int len=strlen(s);
+        get_next(s,len);
+        int temp=len%(len-ne[len]) == 0?len/(len-ne[len]):1; 
+        for(int i=0;i<=len;++i)s[i+len]=s[i];
+        get_extend(s,len+len);
+        int a=0,b=0,c=0;
+        for(int i=0;i<len;++i){
+            if(ne[i]>=len)++b;
+            else if(s[ne[i]]<s[i+ne[i]])++c;
+            else ++a; 
+        }
+        cout<<"Case "<<++num<<": "<<a/temp<<' '<<b/temp<<' '<<c/temp<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4334_autoAC.cpp b/HDOJ/4334_autoAC.cpp
new file mode 100644
index 0000000..a60bb8a
--- /dev/null
+++ b/HDOJ/4334_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<stdio.h>
+#include<stdlib.h>
+int n;
+__int64 que[5][210],a[41000],b[41000];
+int cmp(const void*a,const void*b)
+{
+    if(*(__int64 *)a-*(__int64 *)b > 0)
+    return 1;
+    return -1;
+}
+void fun()
+{
+    int i,f,ji=0;
+    for(i=0;i<n;i++)
+    {
+        for(f=0;f<n;f++)
+        {
+            a[ji]=que[0][i]+que[1][f];
+            ji++;            
+        }        
+    }
+    qsort(a,n*n,sizeof(a[0]),cmp);
+    ji=0;    
+    for(i=0;i<n;i++)
+    {
+        for(f=0;f<n;f++)
+        {
+            b[ji]=que[2][i]+que[3][f];
+            ji++;            
+        }        
+    }    
+    qsort(b,n*n,sizeof(b[0]),cmp);
+}
+int sea(__int64 x)
+{
+    int head=0,tail=n*n-1;
+    while(1)
+    {
+        if(x == a[head]+b[tail])
+        {
+            return 1;
+        }
+        if(a[head]+b[tail] > x)
+        {
+            tail--;
+            if(-1 == tail)
+            {
+                break;
+            }
+        }
+        else
+        {
+            head++;
+            if(n*n == head)
+            {
+                break;
+            }
+        }    
+    }
+    return 0;
+}
+int main()
+{
+    int i,num,f,g;
+    scanf("%d",&num);
+    for(i=0;i<num;i++)
+    {
+        scanf("%d",&n);
+        for(f=0;f<5;f++)
+        {
+            for(g=0;g<n;g++)
+            {
+                scanf("%I64d",&que[f][g]);            
+            }
+        }
+        fun();
+        for(g=0;g<n;g++)
+        {
+            if(1 == sea(-que[4][g]))
+            {
+                printf("Yes\n");
+                break;
+            }
+        }
+        if(g == n)
+        {
+            printf("No\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4335_autoAC.cpp b/HDOJ/4335_autoAC.cpp
new file mode 100644
index 0000000..21baccb
--- /dev/null
+++ b/HDOJ/4335_autoAC.cpp
@@ -0,0 +1,79 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<queue>
+#include<vector>
+#include<cmath>
+#define LL unsigned long long
+#define eps 1e-6
+#define zero(a)  fabs(a)<eps
+using namespace std;
+LL get_eular(LL m){
+    LL ret=1;
+    for(LL i=2;i*i<=m;i++)
+        if(m%i==0){
+            ret*=i-1;
+            m/=i;
+            while(m%i==0){
+                m/=i;
+                ret*=i;
+            }
+        }
+    if(m>1)
+        ret*=m-1;
+    return ret;
+}
+LL PowMod(LL a,LL b,LL MOD){
+    LL ret=1;
+    while(b){
+        if(b&1)
+            ret=(ret*a)%MOD;
+        a=(a*a)%MOD;
+        b>>=1;
+    }
+    return ret;
+}
+LL b,p,m,ring[100005];
+int main(){
+    int t,cas=0;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%I64u%I64u%I64u",&b,&p,&m);
+        printf("Case #%d: ",++cas);
+        if(p==1){
+            if(m==18446744073709551615ULL)
+                printf("18446744073709551616\n");       
+            else                 
+                printf("%I64u\n",m+1);
+            continue;
+        }
+        LL i=0,phi=get_eular(p),fac=1,ans=0;
+        for(i=0;i<=m&&fac<=phi;i++){
+            if(PowMod(i,fac,p)==b)
+                ans++;
+            fac*=i+1;
+        }
+        fac=fac%phi;
+        for(;i<=m&&fac;i++){
+            if(PowMod(i,fac+phi,p)==b)
+                ans++;
+            fac=(fac*(i+1))%phi;
+        }
+        if(i<=m){
+            LL cnt=0;
+            for(int j=0;j<p;j++){
+                ring[j]=PowMod(i+j,phi,p);
+                if(ring[j]==b)
+                    cnt++;
+            }
+            LL idx=(m-i+1)/p;
+            ans+=cnt*idx;
+            LL remain=(m-i+1)%p;
+            for(int j=0;j<remain;j++)
+                if(ring[j]==b)
+                    ans++;
+        }
+        printf("%I64u\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4336_autoAC.cpp b/HDOJ/4336_autoAC.cpp
new file mode 100644
index 0000000..6e82c75
--- /dev/null
+++ b/HDOJ/4336_autoAC.cpp
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+int n;
+double f[1<<20], p[25];
+int main()
+{
+    while(scanf("%d", &n)!=EOF)
+    {
+        for(int i=0; i<n; i++)
+            scanf("%lf", &p[i]);
+        int all=(1<<n)-1;
+        f[all]=0;
+        for(int s=all-1; s>=0; s--)
+        {
+            double temp=0;
+            f[s]=1;
+            for(int i=0; i<n; i++)
+            {
+                if(s&(1<<i)) continue;
+                f[s]+=f[s|(1<<i)]*p[i];
+                temp+=p[i];
+            }
+            f[s]/=temp;
+        }
+        printf("%lf\n", f[0]);
+    }
+}
diff --git a/HDOJ/4337_autoAC.cpp b/HDOJ/4337_autoAC.cpp
new file mode 100644
index 0000000..bebec42
--- /dev/null
+++ b/HDOJ/4337_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <string.h>
+#include <iostream>
+#include <stdio.h>
+using namespace std;
+#define V 200
+int n,m;
+bool c[V][V];
+int x[V];
+bool flag[V];
+void hamilton()
+{
+    int i, k;
+    bool s[V];
+    for(i = 0; i < n; i++)
+    {
+        x[i] = -1;
+        s[i] = false;
+    }
+    k = 1;
+    s[0] = true;
+    x[0] = 0;
+    while(k >= 0)
+    {
+        x[k]++;
+        while(x[k] < n)
+            if(!s[x[k]] && c[x[k - 1]][x[k]])
+                break;
+            else
+                x[k]++;
+        if((x[k] < n) && (k != n - 1))
+        {
+            s[x[k]] = true;
+            k++;
+        }
+        else if((x[k] < n) && k == n - 1 && c[x[k]][x[0]])
+        {
+            break;
+        }
+        else
+        {
+            x[k] = -1;
+            k--;
+            s[x[k]] = false;
+        }
+    }
+}
+int main()
+{
+    int a,b;
+    while(cin >> n >> m){
+        memset(c,0,sizeof(c));
+        memset(flag,0,sizeof(flag));
+        memset(x,0,sizeof(x));
+        for(int i=0;i<m;i++){
+            cin >> a >> b;
+            c[a-1][b-1]=c[b-1][a-1]=true;
+        }
+        hamilton();
+        bool f=0;
+        for(int i=0;i<n;i++){
+            flag[x[i]]=1;
+        }
+        for(int i=0;i<n;i++){
+            if(!flag[i]) f=1;
+        }
+        if(f) cout <<"no solution" <<endl;
+        else{
+            for(int i=0;i<n;i++){
+                if(i==n-1) cout << x[i]+1 <<endl;
+                else cout << x[i]+1 <<" ";
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4338_autoAC.cpp b/HDOJ/4338_autoAC.cpp
new file mode 100644
index 0000000..3b2e2b2
--- /dev/null
+++ b/HDOJ/4338_autoAC.cpp
@@ -0,0 +1,186 @@
+#pragma comment(linker, "/STACK:102400000,102400000")
+#include <algorithm>
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <stack>
+using namespace std;
+const int N=200005;
+#define Log 22
+struct Edge
+{
+    int v;
+    Edge *nxt;
+}memo[N*10],*cur,*h_bef[N],*h_aft[N];
+void addEdge(int u,int v,Edge* head[])
+{
+    cur->v=v; cur->nxt=head[u];
+    head[u]=cur++;
+}
+int bnum,bn[N];
+vector<int> block[N];
+bool iscut[N];
+bool vis[N];
+stack<int> stk;
+int dfn[N],low[N],son_root,idx;
+int lab[N],id[N],son[N],fa[N];
+int dp[N][Log],dep[N];
+void tarjan(int pt_u,int pt_pre)
+{
+    stack<int> stk_tar;
+    stk_tar.push(pt_u);    fa[pt_u]=pt_pre;
+    while(stk_tar.size())
+    {
+        int u=stk_tar.top();
+        int pre=fa[u];
+        if(dfn[u]==0) dfn[u]=low[u]=++idx,stk.push(u);
+        Edge* it;
+        for(it=h_bef[u];it;it=it->nxt)
+        {
+            int v=it->v;
+            if(v==pre) continue;
+            if(fa[v]==-1)
+            {
+                fa[v]=u;  stk_tar.push(v);
+                h_bef[u]=it;
+                break;
+            }
+            else
+            {
+                if(fa[v]==u)
+                {
+                    low[u]=min(low[u],low[v]);
+                    if(dfn[u]<=low[v])
+                    {
+                        if(pre==-1) son_root++;
+                        else iscut[u]=1;
+                        while(1)
+                        {
+                            int top=stk.top(); stk.pop();
+                            block[bnum].push_back(top);
+                            if(top==v) break;
+                        }
+                        block[bnum].push_back(u);
+                        bnum++;
+                    }
+                }
+                else low[u]=min(low[u],dfn[v]);
+            }
+        }
+        if(it==NULL) stk_tar.pop();
+    }
+}
+void dfs(int u,int pre,int cnt,int iid)
+{
+    dep[u]=dep[ dp[u][0] ]+1;
+    for(int i=1;i<Log;i++) dp[u][i]= dp[ dp[u][i-1] ][ i-1 ];
+    id[u]=iid;    son[u]=cnt+bn[u];
+    for(Edge* it=h_aft[u];it;it=it->nxt)
+    {
+        int v=it->v;
+        if(v!=pre)
+        {
+            dp[v][0]=u;
+            dfs(v,u,son[u],iid);
+        }
+    }
+}
+int lca(int u,int v)
+{
+    if(dep[u]<dep[v]) swap(u,v);
+    for(int st=(1<<(Log-1)),i=Log-1;i>=0;st>>=1,i--)
+    {
+        if(st<=dep[u]-dep[v])
+        {
+            u=dp[u][i];
+        }
+    }
+    if(u==v) return u;
+    for(int i=Log-1;i>=0;i--)
+    {
+        if(dp[u][i]!=dp[v][i])
+        {
+            u=dp[u][i];
+            v=dp[v][i];
+        }
+    }
+    return dp[u][0];
+}
+void init()
+{
+    cur=memo;
+    memset(h_bef,0,sizeof(h_bef));
+    memset(h_aft,0,sizeof(h_aft));
+    memset(dp,0,sizeof(dp));
+    bnum=0; idx=0;    son_root=0;
+    while(stk.size()) stk.pop();
+    for(int i=0;i<N;i++)
+    {
+        block[i].clear();
+        dfn[i]=0;    low[i]=0;    lab[i]=-1;
+        id[i]=i;    iscut[i]=0;    bn[i]=0;
+        son[i]=0;    dep[i]=0;      vis[i]=0;
+        fa[i]=-1;
+    }
+}
+int main()
+{
+    int n,m,Q,t_cnt=0;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        init();
+        for(int i=0;i<m;i++)
+        {
+            int u,v; scanf("%d%d",&u,&v);
+            addEdge(u,v,h_bef);
+            addEdge(v,u,h_bef);
+        }
+        for(int i=0;i<n;i++) if(dfn[i]==0)
+        {
+            son_root=0;
+            tarjan(i,-2);
+            if(son_root>1) iscut[i]=1;
+        }
+        int k=0;
+        for(int i=0;i<n;i++) if(iscut[i])
+        {
+            lab[i]=k; bn[k]=1; k++;
+        }
+        for(int i=0;i<bnum;i++)
+        {
+            for(int j=0;j<(int)block[i].size();j++)
+            {
+                int u=block[i][j];
+                if(iscut[u])
+                {
+                    addEdge(lab[u],k,h_aft);
+                    addEdge(k,lab[u],h_aft);
+                }
+                else lab[u]=k;
+            }
+            bn[k]=(int)block[i].size();
+            k++;
+        }
+        for(int i=0;i<k;i++) if(dep[i]==0) dfs(i,-1,0,i);
+        scanf("%d",&Q);
+        printf("Case #%d:\n",++t_cnt);
+        while(Q--)
+        {
+            int s,t; scanf("%d%d",&s,&t);
+            if(s==t) printf("%d\n",n-1);
+            else if(lab[s]==-1||lab[t]==-1||id[lab[s]]!=id[lab[t]]) printf("%d\n",n);
+            else
+            {
+                s=lab[s]; t=lab[t];
+                int parent=lca(s,t);
+                int cnt=son[s]+son[t]-2*son[parent]+bn[parent];
+                int len=dep[s]+dep[t]-2*dep[parent];
+                int ans=cnt-len;
+                printf("%d\n",n-ans);
+            }
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/4339_autoAC.cpp b/HDOJ/4339_autoAC.cpp
new file mode 100644
index 0000000..90d3d1e
--- /dev/null
+++ b/HDOJ/4339_autoAC.cpp
@@ -0,0 +1,91 @@
+#include"iostream"
+#include"cstdio"
+#include"cstring"
+using namespace std;
+const int N=1000010;
+int ltr[N<<2];
+char s[2][N];
+void build(int l,int r,int k)
+{
+    if(l==r)
+    {
+        if(s[0][l]==s[1][l])    ltr[k]=1;
+        else    ltr[k]=0;
+        return ;
+    }
+    int mid=(l+r)>>1;
+    int l_son=k<<1;
+    int r_son=l_son+1;
+    build(l,mid,l_son);
+    build(mid+1,r,r_son);
+    ltr[k]=ltr[l_son];
+    if(ltr[l_son]==mid-l+1)    ltr[k]+=ltr[r_son];
+}
+void update(int l,int r,int z,int aim,char c,int k)
+{
+    if(l==r)
+    {
+        s[z][aim]=c;
+        ltr[k]=s[0][aim]==s[1][aim];
+        return ;
+    }
+    int mid=(l+r)>>1;
+    int l_son=k<<1;
+    int r_son=l_son+1;
+    if(aim<=mid)update(l,mid,z,aim,c,l_son);
+    else        update(mid+1,r,z,aim,c,r_son);
+    ltr[k]=ltr[l_son];
+    if(ltr[l_son]==mid-l+1)    ltr[k]+=ltr[r_son];
+}
+int find(int l,int r,int aim,int k)
+{
+    if(l==aim)    return ltr[k];
+    int mid=(l+r)>>1;
+    int l_son=k<<1;
+    int r_son=l_son+1;
+    int ans;
+    if(aim<=mid)
+    {
+        ans=find(l,mid,aim,l_son);
+        if(ans==mid-aim+1)    ans+=find(mid+1,r,mid+1,r_son);
+    }
+    else    ans=find(mid+1,r,aim,r_son);
+    return ans;
+}
+int main()
+{
+    int T,Case;
+    int i;
+    int len,q;
+    int x,a,b;
+    char c[10];
+    cin>>T;
+    for(Case=1;Case<=T;Case++)
+    {
+        scanf("%s%s",s[0]+1,s[1]+1);
+        i=1;
+        while(s[0][i] && s[1][i])    i++;
+        len=i-1;
+        i=1;
+        build(1,len,1);
+        cin>>q;
+        printf("Case %d:\n",Case);
+        while(q--)
+        {
+            scanf("%d",&x);
+            if(x==1)
+            {
+                scanf("%d%d%s",&a,&b,c);
+                if(b+1>len)    continue;
+                update(1,len,a-1,b+1,c[0],1);
+            }
+            else
+            {
+                scanf("%d",&b);
+                if(b+1>len)    printf("0\n");
+                else        printf("%d\n",find(1,len,b+1,1));
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4340_autoAC.cpp b/HDOJ/4340_autoAC.cpp
new file mode 100644
index 0000000..a5bcd1c
--- /dev/null
+++ b/HDOJ/4340_autoAC.cpp
@@ -0,0 +1,69 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<vector>
+#include<string>
+#include<set>
+#include<algorithm>
+#include<map>
+#include<iostream>
+using namespace std;
+const int inf = 100000;
+const int maxn = 101;
+vector<int> edge[maxn];
+int a[maxn],b[maxn];
+int f[maxn][2],g[maxn][2];
+void dfs(int u,int fa)
+{
+    f[u][0]=0;
+    g[u][0]=0;
+    int sz=edge[u].size();
+    int m1=inf,m2=inf;
+    bool leaf=true;
+    for(int i=0;i<sz;i++)
+    {
+        int v=edge[u][i];
+        if(v==fa) continue;
+        dfs(v,u);
+        leaf=false;
+        int tmp=min(f[v][0],g[v][1]);
+        f[u][0]+=tmp;
+        m1=min(m1,f[v][1]-tmp);
+        tmp=min(g[v][0],f[v][1]);
+        g[u][0]+=tmp;
+        m2=min(m2,g[v][1]-tmp);
+    }
+    if(leaf)
+    {
+        f[u][1]=a[u];
+        f[u][0]=a[u]/2;
+        g[u][1]=b[u];
+        g[u][0]=b[u]/2;
+    }
+    else 
+    {
+        f[u][1]=f[u][0] + min(a[u],m1+a[u]/2);
+        f[u][0]+=a[u]/2;
+        g[u][1]=g[u][0] + min(b[u],m2+b[u]/2);
+        g[u][0]+=b[u]/2;
+    }
+}
+int main()
+{
+    int n;
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(int i=0;i<=n;i++) edge[i].clear();
+        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
+        for(int i=1;i<=n;i++) scanf("%d",&b[i]);
+        for(int i=1,u,v;i<n;i++)
+        {
+            scanf("%d%d",&u,&v);
+            edge[u].push_back(v);
+            edge[v].push_back(u);
+        }
+        dfs(1,0);
+        printf("%d\n",min(f[1][1],g[1][1]));
+    }
+    return 0;
+}
diff --git a/HDOJ/4341_autoAC.cpp b/HDOJ/4341_autoAC.cpp
new file mode 100644
index 0000000..b3ef143
--- /dev/null
+++ b/HDOJ/4341_autoAC.cpp
@@ -0,0 +1,77 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<queue>
+#include<set>
+#include<map>
+#include<vector>
+#include<stack>
+#include<cmath>
+#include<string>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const int sigma_size=26;
+const int N=200+100;
+const int MAXN=40000+100;
+const double eps=1e-8;
+const int inf=0x3fffffff;
+const int mod=1000000000+7;
+#define L(x) (x<<1)
+#define R(x) (x<<1|1)
+int n,T;
+int dp[MAXN],res[MAXN],st[MAXN];
+struct node{
+    int x,y,t,val;
+}p[N];
+vector<int>G[N];
+bool judge(node a,node b){
+    return a.x*b.y == b.x*a.y;
+}
+bool cmp(int a,int b){
+    return p[a].x*p[a].x+p[a].y*p[a].y<p[b].x*p[b].x+p[b].y*p[b].y;
+}
+int main()
+{
+    int kase=0;
+    while(~scanf("%d%d",&n,&T)){
+        for(int i=1;i<=n;i++)
+            scanf("%d%d%d%d",&p[i].x,&p[i].y,&p[i].t,&p[i].val);
+        int cnt=0;
+        for(int i=1;i<=n;i++){
+            int flag=1;
+            for(int j=0;j<cnt;j++){
+                if(!flag)
+                    break;
+                if(judge(p[i],p[G[j][0]])){
+                    G[j].push_back(i);
+                    flag=0;
+                }
+            }
+            if(!flag)
+                continue;
+            G[cnt].clear(); G[cnt++].push_back(i);
+        }
+        memset(dp,0,sizeof(dp));
+        for(int i=0;i<cnt;i++){
+            sort(G[i].begin(),G[i].end(),cmp);
+            memcpy(res,dp,sizeof(dp));
+            memcpy(st,dp,sizeof(dp));
+            int val=0,t=0;
+            for(int j=0;j<G[i].size();j++){
+                int id=G[i][j];
+                t+=p[id].t; val+=p[id].val;
+                if(t>T)
+                    break;
+                for(int k=T;k>=t;k--)
+                    if(res[k]<=res[k-t]+val)
+                        res[k]=res[k-t]+val;
+                for(int k=t;k<=T;k++)
+                    dp[k]=max(dp[k],res[k]);
+                memcpy(res,st,sizeof(st));
+            }
+        }
+        printf("Case %d: %d\n",++kase,dp[T]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4342_autoAC.cpp b/HDOJ/4342_autoAC.cpp
new file mode 100644
index 0000000..5febbd0
--- /dev/null
+++ b/HDOJ/4342_autoAC.cpp
@@ -0,0 +1,20 @@
+#include<stdio.h>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    long long  a;
+    while(T--)
+    {
+        scanf("%I64d",&a);
+        double temp=ceil((1+sqrt(1+4*a))/2)-1;
+        long long n=(long long)temp;
+        long long res1=n+a;
+        long long res2=n*(n+1)*(2*n+1)/3-3*(n+1)*n/2+n+(n+a-n*n+1)*n;
+        printf("%I64d %I64d\n",res1,res2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4343_autoAC.cpp b/HDOJ/4343_autoAC.cpp
new file mode 100644
index 0000000..84545d4
--- /dev/null
+++ b/HDOJ/4343_autoAC.cpp
@@ -0,0 +1,72 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+using namespace std;
+const int N=100050;
+int n,m,opt[20][N*2],x[N*2],cnt;
+struct node
+{
+    int l,r;
+    void read(){ scanf("%d%d",&l,&r); x[cnt++]=l; x[cnt++]=r; }
+    void print(){ printf("%d %d\n",l,r); }
+    bool operator <(const node tmp) const{ return l<tmp.l||(l==tmp.l&&r<tmp.r); }
+}no[N];
+inline int getid(int val,bool f)
+{
+    if(!f) return lower_bound(x,x+cnt,val)-x;
+    return upper_bound(x,x+cnt,val)-x-1;
+}
+int calc(int l,int r)
+{
+    if(l>r) return 0;
+    if(l==cnt||r==-1) return 0;
+    int ret=0;
+    for(int i=19;i>=0;i--){
+        if(opt[i][l]<=r) {
+            ret+=(1<<i);
+            l=opt[i][l];
+        }
+    }
+    return ret;
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m)!=-1)
+    {
+        cnt=0;
+        for(int i=0;i<n;i++){
+            no[i].read();
+        }
+        sort(no,no+n);
+        sort(x,x+cnt);
+        cnt=unique(x,x+cnt)-x;
+        for(int i=0;i<n;i++){
+            no[i].l=getid(no[i].l,0);
+            no[i].r=getid(no[i].r,1);
+        }
+        x[cnt]=cnt;
+        int mn=cnt,r=n;
+        for(int i=cnt-1;i>=0;i--)
+        {
+            while(r>0&&no[r-1].l>=i){
+                r--;
+                mn=min(mn,no[r].r);
+            }
+            opt[0][i]=mn;
+        }
+        for(int i=0;i<20;i++) opt[i][cnt]=cnt;
+        for(int i=1;i<20;i++){
+            for(int j=0;j<cnt;j++){
+                opt[i][j]=opt[i-1][opt[i-1][j]];
+            }
+        }
+        while(m--)
+        {
+            int l,r;
+            scanf("%d%d",&l,&r);
+            l=getid(l,0); r=getid(r,1);
+            printf("%d\n",calc(l,r));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4344_autoAC.cpp b/HDOJ/4344_autoAC.cpp
new file mode 100644
index 0000000..c650840
--- /dev/null
+++ b/HDOJ/4344_autoAC.cpp
@@ -0,0 +1,142 @@
+#include <cstdio>  
+#include <iostream>  
+#include <algorithm>  
+#include <cmath>  
+#include <cstring>  
+#include <map>  
+using namespace std;  
+#define Times 10  
+typedef __int64 LL;  
+map<LL,int>m;  
+LL Random(LL n)  
+{  
+    return ((double)rand()/RAND_MAX*n+0.5);  
+}  
+LL multi(LL a,LL b,LL mod)  
+{  
+    LL ans=0;  
+    while(b)  
+    {  
+        if(b&1)  
+        {  
+            b--;  
+            ans=(ans+a)%mod;  
+        }  
+        else  
+        {  
+            b/=2;  
+            a=(a+a)%mod;  
+        }  
+    }  
+    return ans;  
+}  
+LL Pow(LL a,LL b,LL mod)  
+{  
+    LL ans=1;  
+    while(b)  
+    {  
+        if(b&1)  
+        {  
+            b--;  
+            ans=multi(ans,a,mod);  
+        }  
+        else  
+        {  
+            b/=2;  
+            a=multi(a,a,mod);  
+        }  
+    }  
+    return ans;  
+}  
+bool witness(LL a,LL n)  
+{  
+    LL d=n-1;  
+    while(!(d&1))  
+        d>>=1;  
+    LL t=Pow(a,d,n);  
+    while(d!=n-1 && t!=1 && t!=n-1)  
+    {  
+        t=multi(t,t,n);  
+        d<<=1;  
+    }  
+    return t==n-1 || d&1;  
+}  
+bool miller_rabin(LL n)  
+{  
+    if(n==2)  
+        return true;  
+    if(n<2||!(n&1))  
+        return false;  
+    for(int i=1;i<=Times;i++)  
+    {  
+        LL a=Random(n-2)+1;  
+        if(!witness(a,n))  
+            return false;  
+    }  
+    return true;  
+}  
+LL gcd(LL a,LL b)  
+{  
+    if(b==0)  
+        return a;  
+    return gcd(b,a%b);  
+}  
+LL pollard_rho(LL n,LL c)  
+{  
+    LL x,y,d,i=1,k=2;  
+    x=Random(n-1)+1;  
+    y=x;  
+    while(1)  
+    {  
+        i++;  
+        x=(multi(x,x,n)+c)%n;  
+        d=gcd(y-x,n);  
+        if(1<d&&d<n)  
+            return d;  
+        if(y==x)  
+            return n;  
+        if(i==k)  
+        {  
+            y=x;  
+            k<<=1;  
+        }  
+    }  
+}  
+void find(LL n,LL c)  
+{  
+    if(n==1)  
+        return ;  
+    if(miller_rabin(n))  
+    {  
+        m[n]++;  
+        return ;  
+    }  
+    LL p=n;  
+    while(p>=n)  
+        p=pollard_rho(p,c--);  
+    find(p,c);  
+    find(n/p,c);  
+}  
+int main()  
+{  
+    int t;  
+    cin>>t;  
+    while(t--)  
+    {  
+        LL n;  
+        cin>>n;  
+        m.clear();  
+        find(n,2013724);  
+        if(m.size()==1)  
+            cout<<1<<" "<<n/m.begin()->first<<endl;  
+        else  
+        {  
+            LL ans=0;  
+            map<LL,int>::iterator it=m.begin();  
+            for(;it!=m.end();it++)  
+                ans+=Pow(it->first,it->second,n);  
+            cout<<m.size()<<" "<<ans<<endl;  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4345_autoAC.cpp b/HDOJ/4345_autoAC.cpp
new file mode 100644
index 0000000..637f1a8
--- /dev/null
+++ b/HDOJ/4345_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<stdio.h>
+#include<string.h>
+const int MAXN=1100;
+int prime[MAXN+1];
+int getPrime()
+{
+    memset(prime,0,sizeof(prime));
+    for(int i=2;i<=MAXN;i++)
+    {
+        if(!prime[i]) prime[++prime[0]]=i;
+        for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++)
+        {
+            prime[prime[j]*i]=1;
+            if(i%prime[j]==0)break;
+        }
+    }
+    return prime[0];
+}
+long long dp[MAXN][MAXN];
+long long DP(int n,int i) 
+{
+    if(dp[n][i]!=-1)return dp[n][i];
+    if(prime[i]>n)
+    {
+        dp[n][i]=1;
+        return dp[n][i];
+    }
+    int k=0;
+    dp[n][i]=0;
+    while(k<=n)
+    {
+        dp[n][i]+=DP(n-k,i+1);
+        if(k==0)k=prime[i];
+        else k*=prime[i];
+    }
+    return dp[n][i];
+}
+int main()
+{
+    getPrime();
+    memset(dp,-1,sizeof(dp));
+    int n;
+    while(scanf("%d",&n)!=EOF)
+    {
+        printf("%I64d\n",DP(n,1));
+    }
+    return 0;
+}
diff --git a/HDOJ/4346_autoAC.cpp b/HDOJ/4346_autoAC.cpp
new file mode 100644
index 0000000..beda406
--- /dev/null
+++ b/HDOJ/4346_autoAC.cpp
@@ -0,0 +1,47 @@
+#include<cstdio>
+#include<cstring>
+using namespace std;
+#define mod 1000000007
+int t;
+long long mod_pow(int a,int n,int p)
+{
+    long long ret=1;
+    long long A=a;
+    while(n){
+        if (n & 1)
+            ret=(ret*A)%p;
+        A=(A*A)%p;
+        n>>=1;
+    }
+    return ret;
+}
+int main(){
+    scanf("%d",&t);
+    while( t -- ){
+        char str[808];
+        scanf("%s",str);
+        int len = strlen(str);
+        int unknown = 0, r_num = 0;
+        for(int i = 0; i < len; i ++){
+            if(str[i] == '?') unknown ++;
+            else if(str[i] == 'R') r_num ++;
+        }
+        long long unbea = (r_num == 0);
+        for(int i = 0; i < len; i ++){
+            if(str[i] == 'R' || str[i] == '?'){
+                int x = (str[i] == 'R');
+                unbea = (unbea + (x == r_num) ) % mod;
+                for(int dis = 1; dis + i < len; dis += 2){
+                    int y = x;
+                    for(int sta = i + dis; sta < len; sta += dis){
+                        y += (str[sta] == 'R');
+                        if(str[sta] == 'G') break;
+                        unbea = (unbea + (y == r_num) )% mod;
+                    }
+                }
+            }
+        }
+        printf("%I64d\n",mod_pow(2,unknown,mod) - unbea);
+    }
+    return 0;
+}
diff --git a/HDOJ/4347_autoAC.cpp b/HDOJ/4347_autoAC.cpp
new file mode 100644
index 0000000..df47dc5
--- /dev/null
+++ b/HDOJ/4347_autoAC.cpp
@@ -0,0 +1,76 @@
+#include<queue>  
+#include<cstdio>  
+#include<cstring>  
+#include<algorithm>  
+using namespace std;  
+const int N=55555,K=5;  
+const int inf=0x3f3f3f3f;  
+#define sqr(x) (x)*(x)  
+int k,n,idx;     
+struct point  
+{  
+    int x[K];  
+    bool operator < (const point &u) const  
+    {  
+        return x[idx]<u.x[idx];  
+    }  
+}po[N];  
+typedef pair<double,point>tp;  
+priority_queue<tp>nq;  
+struct kdTree  
+{  
+    point pt[N<<2];  
+    int son[N<<2];  
+    void build(int l,int r,int rt=1,int dep=0)  
+    {  
+        if(l>r) return;  
+        son[rt]=r-l;  
+        son[rt*2]=son[rt*2+1]=-1;  
+        idx=dep%k;  
+        int mid=(l+r)/2;  
+        nth_element(po+l,po+mid,po+r+1);  
+        pt[rt]=po[mid];  
+        build(l,mid-1,rt*2,dep+1);  
+        build(mid+1,r,rt*2+1,dep+1);  
+    }  
+    void query(point p,int m,int rt=1,int dep=0)  
+    {  
+        if(son[rt]==-1) return;  
+        tp nd(0,pt[rt]);  
+        for(int i=0;i<k;i++) nd.first+=sqr(nd.second.x[i]-p.x[i]);  
+        int dim=dep%k,x=rt*2,y=rt*2+1,fg=0;  
+        if(p.x[dim]>=pt[rt].x[dim]) swap(x,y);  
+        if(~son[x]) query(p,m,x,dep+1);  
+        if(nq.size()<m) nq.push(nd),fg=1;  
+        else  
+        {  
+            if(nd.first<nq.top().first) nq.pop(),nq.push(nd);  
+            if(sqr(p.x[dim]-pt[rt].x[dim])<nq.top().first) fg=1;  
+        }  
+        if(~son[y]&&fg) query(p,m,y,dep+1);  
+    }  
+}kd;  
+void print(point &p)  
+{  
+    for(int j=0;j<k;j++) printf("%d%c",p.x[j],j==k-1?'\n':' ');  
+}  
+int main()  
+{  
+    while(scanf("%d%d",&n,&k)!=EOF)  
+    {  
+        for(int i=0;i<n;i++) for(int j=0;j<k;j++) scanf("%d",&po[i].x[j]);  
+        kd.build(0,n-1);  
+        int t,m;  
+        for(scanf("%d",&t);t--;)  
+        {  
+            point ask;  
+            for(int j=0;j<k;j++) scanf("%d",&ask.x[j]);  
+            scanf("%d",&m); kd.query(ask,m);  
+            printf("the closest %d points are:\n", m);  
+            point pt[20];  
+            for(int j=0;!nq.empty();j++) pt[j]=nq.top().second,nq.pop();  
+            for(int j=m-1;j>=0;j--) print(pt[j]);  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4348_autoAC.cpp b/HDOJ/4348_autoAC.cpp
new file mode 100644
index 0000000..7da1e0c
--- /dev/null
+++ b/HDOJ/4348_autoAC.cpp
@@ -0,0 +1,109 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+using namespace std;
+const int maxn = 100010;
+int n, m;
+struct Node {
+    long long d, td;
+    int timelabel;
+    Node() {};
+    Node(long long _d, long long _td, int t) {
+        d = _d; td = _td; timelabel = t;
+    }
+};
+vector<Node> bit[maxn];
+long long a[maxn], sum[maxn] = {0};
+inline int lowbit(int x)
+{
+    return x & (-x);
+}
+inline void update(int x, long long w, int timelabel)
+{
+    int size;
+    long long tw = w * x;
+    while (x <= n) {
+        size = bit[x].size();
+        bit[x].push_back(bit[x][size-1]);
+        size++;
+        bit[x][size-1].d += w;
+        bit[x][size-1].td += tw;
+        bit[x][size-1].timelabel = timelabel;
+        x += lowbit(x);
+    }
+}
+inline long long getsum(int x, int timelabel)
+{
+    long long sd = 0, std = 0;
+    int size, ox = x;
+    while (x > 0) {
+        size = bit[x].size();
+        while (bit[x][size-1].timelabel > timelabel) {
+            size--;
+        }
+        sd += bit[x][size-1].d;
+        std += bit[x][size-1].td;
+        x -= lowbit(x);
+    }
+    return (ox + 1) * sd - std;
+}
+inline long long getans(int x, int y, int timelabel)
+{
+    return sum[y] - sum[x-1] + getsum(y, timelabel) - getsum(x - 1, timelabel);
+}
+inline void back(int timelabel)
+{
+    int size;
+    for (int i = 1; i <= n; ++i) {
+        size = bit[i].size();
+        while (bit[i][size-1].timelabel > timelabel) {
+            bit[i].pop_back();
+            size--;
+        }
+    }
+}
+void build()
+{
+    for (int i = 1; i <= n; ++i) {
+        bit[i].clear();
+        bit[i].push_back(Node(0LL, 0LL, 0));
+    }
+}
+int main()
+{
+    int cas = 0;
+    while (scanf("%d%d", &n, &m) != EOF) {
+        if (cas++) printf("\n");
+        for (int i = 1; i <= n; ++i) {
+            scanf("%lld\n", &a[i]);
+            sum[i] = sum[i-1] + a[i];
+        }
+        char op[3];
+        int x, y, z;
+        int timelabel = 0;
+        build();
+        while (m--) {
+            scanf("%s", op);
+            if (op[0] == 'Q') {
+                scanf("%d%d", &x, &y);
+                printf("%lld\n", getans(x, y, timelabel));
+            } else if (op[0] == 'C') {
+                scanf("%d%d%d", &x, &y, &z);
+                timelabel++;
+                update(x, z, timelabel);
+                update(y + 1, -z, timelabel);
+            } else if (op[0] == 'H') {
+                scanf("%d%d%d", &x, &y, &z);
+                printf("%lld\n", getans(x, y, z));
+            } else {
+                scanf("%d", &x);
+                timelabel = x;
+                back(x);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4349_autoAC.cpp b/HDOJ/4349_autoAC.cpp
new file mode 100644
index 0000000..18c5a7d
--- /dev/null
+++ b/HDOJ/4349_autoAC.cpp
@@ -0,0 +1,24 @@
+#include"cstdlib"
+#include"cstdio"
+#include"cstring"
+#include"cmath"
+#include"stack"
+#include"algorithm"
+#include"iostream"
+#define ll __int64
+using namespace std;
+int main()
+{
+    int n;
+    while(cin>>n)
+    {
+        int cnt=0;
+        while(n)
+        {
+            if(n%2==1) cnt++;
+            n/=2;
+        }
+        printf("%d\n",1<<cnt);
+    }
+    return 0;
+}
diff --git a/HDOJ/4350_autoAC.cpp b/HDOJ/4350_autoAC.cpp
new file mode 100644
index 0000000..1f1a4d0
--- /dev/null
+++ b/HDOJ/4350_autoAC.cpp
@@ -0,0 +1,41 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+int ans[10000][53];
+int main(){
+    int T, op, left, right;
+    scanf("%d", &T);
+    for(int t=1; t<=T; t++){
+       for(int i=1; i<=52; i++)
+           scanf("%d", &ans[0][i]);
+       scanf("%d %d %d", &op, &left, &right);
+       int len = 1;
+       while(1){
+           int tag = 1;
+           for(int i=left; i<=right; i++)
+              ans[len][tag++] = ans[len-1][i];
+           for(int i=1; i<left; i++)
+              ans[len][tag++] = ans[len-1][i];
+           for(int i=right+1; i<=52; i++)
+              ans[len][tag++] = ans[len-1][i];
+           bool flag = true;
+           for(int i=1; i<=52; i++)
+              if(ans[0][i] != ans[len][i]){
+                  flag = false;
+                  break;
+              }
+           if(flag){
+              tag = op%len;
+              printf("Case #%d:", t);
+              for(int i=1; i<=52; i++)
+                  printf(" %d", ans[tag][i]);
+              printf("\n");
+              break;
+           }
+           len++;
+       }
+    }
+    return 0;
+}
diff --git a/HDOJ/4351_autoAC.cpp b/HDOJ/4351_autoAC.cpp
new file mode 100644
index 0000000..4753032
--- /dev/null
+++ b/HDOJ/4351_autoAC.cpp
@@ -0,0 +1,125 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+typedef struct
+{
+    int l,r,sum;
+    int lsum,rsum,midsum;
+}Tree;
+Tree tree[500005];
+int a[100005];
+int c[2000][2000];
+int ans,rans;
+int Count(int t)
+{
+    if (t==0) return 0;
+    int s=0;
+    while(t)
+    {
+        s+=t%10;
+        t/=10;
+    }
+    s%=9;
+    if (s==0) return 9;
+    return s;
+}
+int Pre()
+{
+    int i,j,x,y;
+    for (i=0;i<1024;i++)
+    {
+        for (j=i;j<1024;j++)
+        {
+            c[i][j]=0;
+            for (x=0;x<10;x++)
+            {
+                if ((i & (1<<x))==0) continue;
+                for (y=0;y<10;y++)
+                {
+                    if ((j & (1<<y))==0) continue;
+                    c[i][j]=(c[i][j]|(1<<Count(x+y)));
+                }
+            }
+            c[j][i]=c[i][j];
+        }
+    }
+}
+void Build(int t,int l,int r)
+{
+    tree[t].l=l;
+    tree[t].r=r;
+    if (l==r)
+    {
+        tree[t].sum=a[l];
+        tree[t].lsum=(1<<a[l]);
+        tree[t].rsum=(1<<a[l]);
+        tree[t].midsum=(1<<a[l]);
+        return;
+    }
+    int mid=(l+r)/2;
+    Build(2*t+1,l,mid);
+    Build(2*t+2,mid+1,r);
+    tree[t].sum=Count(tree[2*t+1].sum+tree[2*t+2].sum);
+    tree[t].lsum=(tree[2*t+1].lsum | c[1<<tree[2*t+1].sum][tree[2*t+2].lsum]);
+    tree[t].rsum=(tree[2*t+2].rsum | c[tree[2*t+1].rsum][1<<tree[2*t+2].sum]);
+    tree[t].midsum=(tree[2*t+1].midsum | tree[2*t+2].midsum | c[tree[2*t+1].rsum][tree[2*t+2].lsum]);
+}
+void Query(int t,int x,int y)
+{
+    int l,r;
+    l=tree[t].l;
+    r=tree[t].r;
+    if (l==x && r==y)
+    {
+        ans=(ans | tree[t].midsum | c[rans][tree[t].lsum]);
+        rans=(c[rans][1<<tree[t].sum] | tree[t].rsum);
+        return;
+    }
+    int mid=(l+r)/2;
+    if (mid>=x) Query(2*t+1,x,min(y,mid));
+    if (mid<y) Query(2*t+2,max(x,mid+1),y);
+}
+int main()
+{
+    int T,i,j,n,x,y,m,s,cnt=1;
+    Pre();
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        for (i=0;i<n;i++)
+        {
+            scanf("%d",&a[i]);
+            a[i]=Count(a[i]);
+        }
+        Build(0,0,n-1);
+        scanf("%d",&m);
+        printf("Case #%d:\n",cnt++);
+        while(m--)
+        {
+            scanf("%d%d",&x,&y);
+            ans=rans=0;
+            Query(0,x-1,y-1);
+            s=0;
+            for (i=9;i>=0;i--)
+            {
+                if (ans>=(1<<i))
+                {
+                    ans-=(1<<i);
+                    if (s==0) printf("%d",i);
+                    else printf(" %d",i);
+                    s++;
+                    if (s==5) break;
+                }
+            }
+            for (i=s;i<5;i++)
+            {
+                printf(" -1");
+            }
+            printf("\n");
+        }
+        if (T>0) printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4352_autoAC.cpp b/HDOJ/4352_autoAC.cpp
new file mode 100644
index 0000000..5a38ffa
--- /dev/null
+++ b/HDOJ/4352_autoAC.cpp
@@ -0,0 +1,81 @@
+#include<cstdio>
+#include<cstring>
+#include<bitset>
+#include<cstdlib>
+#include<cmath>
+#include<iostream>
+#include<string>
+#include<vector>
+#include<queue>
+#include<deque>
+#include<set>
+#include<map>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const int N = 20;
+ll dp[N][10][1<<10][11];
+int has[1<<10];
+int ne[1<<10][10];
+int bit[N],K;
+int go(int mask,int number){
+    int pos = -1;
+    for(int i = number;i <=9;i++)
+        if(mask & (1<<i)){
+            pos = i;
+            break;
+        }
+    if(pos == -1)mask |= 1<<number;
+    else{
+        mask ^= 1<<pos;
+        mask |= 1<<number;
+    }
+    return mask;
+}
+void init(){
+    memset(dp,-1,sizeof(dp));
+    for(int i=0;i<1<<10;i++){
+        has[i] = 0;
+        for(int j=0;j<10;j++)
+            if(i&(1<<j))has[i]++;
+    }
+    for(int i = 0;i < 1<<10;i++)
+        for(int j = 0;j < 10;j++)
+            ne[i][j] = go(i,j);
+    for(int i = 0;i < 15;i++){
+        for(int j=0;j<10;j++){
+        }
+    }
+}
+ll dfs(int pos,int number,int mask,bool isZero,bool flag){
+    if(pos == 0)return has[mask] == K;
+    if(flag && ~dp[pos][number][mask][K])return dp[pos][number][mask][K];
+    ll ans = 0;
+    int u = flag ? 9:bit[pos];
+    for(int d = 0;d <= u;d++){
+        if(isZero && d == 0)ans += dfs(pos-1,d,0,1,flag || d < u);
+        else{
+            ans += dfs(pos-1,d,ne[mask][d],0,flag || d < u);
+        }
+    }
+    if(flag)dp[pos][number][mask][K] = ans ;
+    return ans;
+}
+ll solve(ll n){
+    int len = 0;
+    while(n){
+        bit[++len] = n % 10;
+        n /= 10;
+    }
+    return dfs(len,0,0,1,0);
+}
+int main(){
+    init();
+    ll L,R;
+    int T;cin >> T;
+    for(int cas = 1;cas <= T;cas++){
+        cin >> L >> R >> K;
+        cout<<"Case #"<<cas<<": "<<solve(R) - solve(L - 1)<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4353_autoAC.cpp b/HDOJ/4353_autoAC.cpp
new file mode 100644
index 0000000..03018d3
--- /dev/null
+++ b/HDOJ/4353_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+using namespace std;
+struct point{
+    int x, y;
+    point() {}
+    point(int a, int b) : x(a), y(b){}
+    void input(){
+        scanf("%d%d", &x, &y);
+    }
+    friend point operator - (const point &a, const point &b){
+        return point(a.x - b.x, a.y - b.y);
+    }
+    friend bool operator < (const point &a, const point &b){
+        return a.x < b.x;
+    }
+};
+const int maxn = 200 + 10, maxm = 500 + 10;
+point po[maxn], mi[maxm];
+int det(point a, point b){
+    return a.x * b.y - a.y * b.x;
+}
+int num[maxn][maxn];
+int n, m, cs;
+void init(point a, point b, int &cnt){
+    int x1 = a.x, x2 = b.x;
+    for (int i = 0; i < m; i++)
+        if (mi[i].x >= x1 && mi[i].x < x2)
+            if (det(mi[i] - a, b - a) > 0)
+                cnt += 1;
+}
+int main(){
+    scanf("%d", &cs);
+    for (int kase = 1; kase <= cs; ++kase){
+        scanf("%d%d", &n, &m);
+        for (int i = 0; i < n; i++)
+            po[i].input();
+        for (int i = 0; i < m; i++)
+            mi[i].input();
+        sort(po, po + n);
+        for (int i = 0; i < n; i++)
+            for (int j = i + 1; j < n; j++)
+                init(po[i], po[j], num[i][j] = 0);
+        printf("Case #%d: ", kase);
+        double ans = -1;
+        for (int i = 0; i < n; i++)
+            for (int j = i + 1; j < n; j++)
+                for (int k = j + 1; k < n; k++){
+                    int cnt = num[i][k] - num[i][j] - num[j][k];
+                    if (!cnt) continue;
+                    double area = det(po[j] - po[i], po[k] - po[i]) / 2.0;
+                    double tmp = area / (double)cnt;
+                    if (ans == -1 || ans > tmp) ans = tmp;
+                }
+        if (ans == -1) puts("-1");
+        else printf("%.6lf\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4354_autoAC.cpp b/HDOJ/4354_autoAC.cpp
new file mode 100644
index 0000000..a9bf0fc
--- /dev/null
+++ b/HDOJ/4354_autoAC.cpp
@@ -0,0 +1,108 @@
+#include<cstdio>
+#include<cstring>
+#include<bitset>
+#include<cstdlib>
+#include<cmath>
+#include<iostream>
+#include<string>
+#include<vector>
+#include<queue>
+#include<deque>
+#include<set>
+#include<map>
+#include<algorithm>
+using namespace std;
+const int C = 5005;
+const int N = 2005;
+const int M = 1005;
+int cnt[N]; 
+int vis[C];
+int dp[C][2];
+int c, n, k, m;
+vector<int>v[N];
+struct city
+{
+    int x, y;
+    bool operator<(const city &a) const
+    {
+        return x<a.x;
+    }
+}ct[C];
+int min(int x, int y)
+{
+    if(x==-1) return y;
+    return x<y?x:y;
+}
+void dfs(int s)
+{
+    vis[s] = 1;
+    dp[s][1] = 1;
+    dp[s][0] = 0;
+    for(int i=0; i<v[s].size(); i++)
+    {
+        int ss = v[s][i];
+        if(vis[ss]==1 || cnt[ss]==0) continue;
+        dfs(ss);
+        dp[s][1] += dp[ss][0];
+        dp[s][0] += max(dp[ss][1], dp[ss][0]);
+    }
+}
+bool ok(int l, int r)
+{
+    int res = 0;
+    memset(vis, 0, sizeof(vis));
+    for(int i = l; i<=r; i++)
+    if(vis[ ct[i].y ]==0)
+    {
+        dfs( ct[i].y );
+        res += max( dp[ ct[i].y ][0], dp[ ct[i].y ][1] );
+    }
+    if(res>=k) return true;
+    else return false;
+}
+int solve()
+{
+    int kk, l, r;
+    kk = l = r = 1;
+    cnt[ ct[1].y ]++;
+    int ans = -1;
+    while(r<=c)
+    {
+        if(kk>=k && ok(l, r))
+        {
+            ans = min(ans, ct[r].x - ct[l].x);
+            cnt[ ct[l].y ]--;
+            if( cnt[ ct[l].y ]==0 ) kk--;
+            l++;
+        }
+        else
+        {
+            r++;
+            cnt[ ct[r].y ]++;
+            if( cnt[ ct[r].y ]==1 ) kk++;
+        }
+    }
+    return ans;
+}
+int main()
+{
+    int t, tt=0, i, x, y;
+    scanf("%d", &t);
+    while(t--)
+    {
+        scanf("%d%d%d%d", &c, &n, &k, &m);
+        for(i=1; i<=n; i++) v[i].clear();
+        memset(cnt, 0, sizeof(cnt));
+        memset(vis, 0, sizeof(vis));
+        for(i=1; i<=c; i++) scanf("%d%d", &ct[i].x, &ct[i].y);
+        sort(ct+1, ct+1+c);
+        for(i=1; i<=m; i++)
+        {
+            scanf("%d%d", &x, &y);
+            v[x].push_back(y);
+            v[y].push_back(x);
+        }
+        printf("Case #%d: %d\n", ++tt, solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/4355_autoAC.cpp b/HDOJ/4355_autoAC.cpp
new file mode 100644
index 0000000..52bbf93
--- /dev/null
+++ b/HDOJ/4355_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+using namespace std;
+const int N = 10e4+1;
+const float eps = 1e-2;
+struct po
+{
+    double x;
+    double w;
+} point[N];
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    for(int cases = 1; cases<=t; cases++)
+    {
+        int n;
+        scanf("%d",&n);
+        for(int i=1; i<=n; i++)
+            scanf("%lf %lf",&point[i].x,&point[i].w);
+        double low = point[1].x;
+        double high = point[n].x;
+        double sum1 = 10;
+        double sum2 = 0;
+        while(fabs(sum1-sum2)>eps)
+        {
+            double mid1 = low + (high-low)/3;
+            double mid2 = high - (high-low)/3;
+            sum1 = sum2 = 0;
+            for(int i=1; i<=n; i++)
+            {
+                sum1 += pow((fabs(point[i].x - mid1)),3)*point[i].w;
+                sum2 += pow((fabs(point[i].x - mid2)),3)*point[i].w;
+            }
+            if(sum1<sum2)
+                high = mid2;
+            else if(sum1>sum2)
+                low = mid1;
+            else if(sum1==sum2)
+                low = high;
+        }
+        printf("Case #%d: %.0lf\n",cases,sum1);
+    }
+    return 0;
+}
diff --git a/HDOJ/4356_autoAC.cpp b/HDOJ/4356_autoAC.cpp
new file mode 100644
index 0000000..e94c925
--- /dev/null
+++ b/HDOJ/4356_autoAC.cpp
@@ -0,0 +1,58 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <algorithm>
+#define MOD 1000000007
+#define N 2010
+using namespace std;
+int n,ans;
+int a[N],w[N];
+int f[N][N];
+int fac[N];
+void init(){
+    fac[0]=1;
+    int i,j;
+    for (i=1;i<=n;i++)
+        fac[i]=(1ll*fac[i-1]*i)%MOD;
+    for (i=0;i<=n;i++) f[1][i]=n-i;
+    for (i=1;i<=n;i++){
+        for (j=0;j<w[i];j++) f[i+1][j]=f[i][j]-1;
+        for (j=w[i];j<=n;j++) f[i+1][j]=f[i][j];
+    }
+}
+int dfs(int k){
+    if (k==n) return 0;
+    int tp=(1ll*fac[n-k]*f[k][w[k]])%MOD;
+    int tp1=dfs(k+1);
+    if (w[k]>=a[k]) ans=(1ll*ans+tp1)%MOD;
+    return (1ll*tp1+tp)%MOD;
+}
+void work(){
+    int i,j,k;
+    for (i=1;i<=n;i++){
+        if (a[i]>w[i]) ans=(1ll*ans+1ll*f[i][a[i]-1]*fac[n-i])%MOD;
+        else ans=(1ll*ans+1ll*f[i][w[i]]*fac[n-i])%MOD;
+        for (j=i+1;j<=n;j++){
+            k=f[i][w[i]]*f[i][a[j]-1]-min(f[i][w[i]],f[i][a[j]-1]);
+            ans=(1ll*ans+1ll*k*fac[n-i-1])%MOD;
+        }
+    }
+}
+int main(){
+    int test;
+    scanf("%d",&test);
+    for (int cas=1;cas<=test;cas++){
+        scanf("%d",&n);
+        for (int i=1;i<=n;i++)
+            scanf("%d",&w[i]);
+        for (int i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        ans=0;
+        init();
+        work();
+        dfs(1);
+        printf("Case #%d: %d\n",cas,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4357_autoAC.cpp b/HDOJ/4357_autoAC.cpp
new file mode 100644
index 0000000..837058e
--- /dev/null
+++ b/HDOJ/4357_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<iostream>
+#include<string>
+using namespace std;
+int t;
+string a,b;
+int main()
+{
+    cin>>t;
+    for(int cas=1;cas<=t;cas++){
+        cin>>a>>b;
+        int len=a.length();
+        cout<<"Case #"<<cas<<": ";
+        if(len>2){
+            int n=0,m=0;
+            for(int i=0;i<len;i++){
+                n+=a[i];
+                m+=b[i];
+            }
+            if((n&1)==(m&1)) cout<<"YES"<<endl;
+            else cout<<"NO"<<endl;
+        }
+        else{
+            if(((a[0]-b[0]+26)%26)==((a[1]-b[1]+26)%26)&&(a[0]-b[0])%2==0||((a[0]-b[1]+26)%26)==((a[1]-b[0]+26)%26)&&(a[1]-b[0]+1)%2==0) cout<<"YES"<<endl;
+            else cout<<"NO"<<endl;
+        }
+    }
+}
diff --git a/HDOJ/4358_autoAC.cpp b/HDOJ/4358_autoAC.cpp
new file mode 100644
index 0000000..2aa8dfb
--- /dev/null
+++ b/HDOJ/4358_autoAC.cpp
@@ -0,0 +1,155 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+#include <cstdlib>
+#include <vector>
+#include <deque>
+#include <map>
+#pragma comment(linker, "/STACK:102400000,102400000")
+using namespace std;
+#define print(x) cout<<x<<endl
+#define input(x) cin>>x
+#define SIZE 100100
+struct BIT
+{
+    int baum[SIZE];
+    void init()
+    {
+        memset(baum,0,sizeof(baum));
+    }
+    inline int lowbit(int x)
+    {
+        return x&(-x);
+    }
+    void add(int x,int val)
+    {
+        while(x<SIZE)
+        {
+            baum[x]+=val;
+            x+=lowbit(x);
+        }
+    }
+    int sum(int x)
+    {
+        int res=0;
+        while(x>0)
+        {
+            res+=baum[x];
+            x-=lowbit(x);
+        }
+        return res;
+    }
+    int sum(int l,int r)
+    {
+        return sum(r)-sum(l-1);
+    }
+};
+struct query
+{
+    int l,r,id;
+    query(){}
+    query(int il,int ir,int iid)
+    {
+        l=il;r=ir;id=iid;
+    }
+    friend bool operator < (const query& a,const query& b)
+    {
+        return a.r<b.r;
+    }
+};
+int n,k,q;
+int w[SIZE];
+vector<int> pl[SIZE];
+vector<int> g[SIZE];
+int lson[SIZE],rson[SIZE],val[SIZE];
+int cnt,ind;
+void dfs(int now,int father)
+{
+    lson[now]=rson[now]=++ind;
+    val[now]=w[now];
+    for(int i=0;i<(int)g[now].size();i++)
+    {
+        int next=g[now][i];
+        if(next!=father)
+        {
+            dfs(next,now);
+            rson[now]=rson[next];
+        }
+    }
+}
+int main()
+{
+    int T,a,b;
+    BIT bit;
+    query ask[SIZE];
+    int ans[SIZE];
+    map<int,int> mp;
+    input(T);
+    int cas=1;
+    while(T--)
+    {
+        bit.init();
+        cnt=ind=0;
+        mp.clear();
+        memset(ans,0,sizeof(ans));
+        for(int i=0;i<SIZE;i++) g[i].clear();
+        scanf("%d%d",&n,&k);
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&w[i]);
+            if(!mp[w[i]])
+            {
+                mp[w[i]]=++cnt;
+                pl[cnt].clear();
+            }
+            w[i]=mp[w[i]];
+        }
+        for(int i=1;i<n;i++)
+        {
+            scanf("%d%d",&a,&b);
+            g[a].push_back(b);
+            g[b].push_back(a);
+        }
+        dfs(1,-1);
+        scanf("%d",&q);
+        for(int i=0;i<q;i++)
+        {
+            scanf("%d",&a);
+            ask[i]=query(lson[a],rson[a],i);
+        }
+        sort(ask,ask+q);
+        int ptr=0;
+        for(int i=1;i<=n;i++)
+        {
+            int v=val[i];
+            pl[v].push_back(i);
+            int sz=pl[v].size();
+            if(sz>=k)
+            {
+                if(sz==k)
+                {
+                    bit.add(pl[v][sz-k],1);
+                }
+                if(sz>k)
+                {
+                    bit.add(pl[v][sz-k-1],-2);
+                    bit.add(pl[v][sz-k],1);
+                }
+            }
+            while(ask[ptr].r==i)
+            {
+                int id=ask[ptr].id;
+                ans[id]=bit.sum(ask[ptr].l,ask[ptr].r);
+                ptr++;
+            }
+        }
+        printf("Case #%d:\n",cas++);
+        for(int i=0;i<q;i++)
+        {
+            printf("%d\n",ans[i]);
+        }
+        if(T) puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/4359_autoAC.cpp b/HDOJ/4359_autoAC.cpp
new file mode 100644
index 0000000..7cc5350
--- /dev/null
+++ b/HDOJ/4359_autoAC.cpp
@@ -0,0 +1,60 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<stack>
+#include<cmath>
+#include<vector>
+#define inf 0x3f3f3f3f
+#define Inf 0x3FFFFFFFFFFFFFFFLL
+#define eps 1e-9
+#define pi acos(-1.0)
+using namespace std;
+typedef long long ll;
+const int maxn=365;
+const int mod=1000000000+7;
+ll dp[maxn][maxn],C[maxn][maxn];
+void Init()
+{
+    memset(C,0,sizeof(C));
+    C[0][0]=1;
+    for(int i=1;i<maxn;++i)
+    {
+        C[i][0]=1;
+        for(int j=1;j<=i;++j)
+        {
+            C[i][j]=C[i-1][j-1]+C[i-1][j];
+            if(C[i][j]>=mod) C[i][j]-=mod;
+        }
+    }
+}
+ll f(int n,int d)
+{
+    if(n==1&&d>=1) return 1;
+    if(n==1||d==0) return 0;
+    if(dp[n][d]!=-1) return dp[n][d];
+    ll &ans=dp[n][d];
+    ans=0;
+    ans=(ans+f(n-1,d-1)*n*2)%mod;
+    for(int k=1;k<=n-2;++k)
+        ans=(ans+(f(k,d-1)*f(n-k-1,d-1)%mod*C[n-2][k]%mod)*n)%mod;
+    return ans;
+}
+int main()
+{
+    Init();
+    memset(dp,0xff,sizeof(dp));
+    int t,tcase=0,n,d;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&d);
+        ll ans=f(n,d)-f(n,d-1);
+        ans=(ans+mod)%mod;
+        printf("Case #%d: %I64d\n",++tcase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4360_autoAC.cpp b/HDOJ/4360_autoAC.cpp
new file mode 100644
index 0000000..a751f62
--- /dev/null
+++ b/HDOJ/4360_autoAC.cpp
@@ -0,0 +1,100 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+typedef long long lld;
+const int mn=3333;
+const int mm=33333;
+const lld oo=1e15;
+int  reach[mm], ne[mm], flow[mm], ch[mm];
+lld  head[mn], que[mn], dis[mn][4], cnt[mn][4], inque[mn];
+int n, edge;
+void addedge(int u, int v, int c1, int c2,  char c)
+{
+    ch[edge]=c, reach[edge]=v, flow[edge]=c1, ne[edge]=head[u], head[u]=edge++;
+    ch[edge]=c, reach[edge]=u, flow[edge]=c2, ne[edge]=head[v], head[v]=edge++;
+}
+int find(char c)
+{
+   if(c=='L') return 0;
+   else if(c=='O') return 1;
+   else if(c=='V') return 2;
+   else return 3;
+}
+bool spfa()
+{
+    int l=0, h=0;
+    memset(inque,0,sizeof(inque));
+    for(int i=1; i<=n; i++)
+        for(int j=0; j<4; j++) dis[i][j]=oo, cnt[i][j]=0;
+    inque[1]=1;
+    dis[1][0]=0;
+    que[l++]=1;
+    while(l!=h)
+    {
+        int u=que[h++];
+        if(h==mn) h=0;
+        inque[u]=0;
+        for(int i=head[u]; i>=0; i=ne[i])
+        {
+            int s=find(ch[i]), v=reach[i], val=flow[i];
+            if(dis[v][(s+1)%4]>=dis[u][s]+val)
+            {
+                if(dis[v][(s+1)%4]==dis[u][s]+val)
+                {
+                    if(cnt[u][s]+1>cnt[v][(s+1)%4]) cnt[v][(s+1)%4]=cnt[u][s]+1;
+                    else continue;
+                }
+                else
+                {
+                    dis[v][(s+1)%4]=dis[u][s]+val;
+                    cnt[v][(s+1)%4]=cnt[u][s]+1;
+                }
+                if(!inque[v])
+                {
+                    inque[v]=1;
+                    que[l++]=v;
+                    if(l==mn) l=0;
+                }
+            }
+        }
+    }
+    if(dis[n][0]==oo||!cnt[n][0]) return false;
+    else return true;
+}
+int main()
+{
+    int m, T, tcase=0;
+    cin >> T;
+    while(T--)
+    {
+        cin >> n >> m;
+        edge=0;
+        memset(head,-1,sizeof(head));
+        int mp[4]={0,0,0,0}, ct=0;
+        while(m--)
+        {
+            int u, v, val, se;
+            char sh[3];
+            scanf("%d%d%d%s",&u,&v,&val,sh);
+            addedge(u,v,val,val,sh[0]);
+            if(n==1&&u==1&&v==1)
+            {
+                se=find(sh[0]);
+                if(!mp[se]) ct++, mp[se]=val;
+                else mp[se]=min(mp[se],val);
+            }
+        }
+        if(ct==4)
+        {
+           lld sum=mp[0]+mp[1]+mp[2]+mp[3];
+           printf("Case %d: Cute Sangsang, Binbin will come with a donkey after travelling %I64d meters and finding %d LOVE strings at last.\n",++tcase,sum,ct/4);
+           continue;
+        }
+        bool ok=spfa();
+        if(!ok) printf("Case %d: Binbin you disappoint Sangsang again, damn it!\n",++tcase);
+        else printf("Case %d: Cute Sangsang, Binbin will come with a donkey after travelling %I64d meters and finding %d LOVE strings at last.\n",++tcase,dis[n][0],cnt[n][0]/4);
+    }
+    return 0;
+}
diff --git a/HDOJ/4361_autoAC.cpp b/HDOJ/4361_autoAC.cpp
new file mode 100644
index 0000000..dfa8a72
--- /dev/null
+++ b/HDOJ/4361_autoAC.cpp
@@ -0,0 +1,11 @@
+#include <cstdio>
+#include <cstdlib>
+int main()
+{
+    srand(1121139700);
+    int caseNumber;
+    scanf("%d", &caseNumber);
+    while(caseNumber --)
+        if(rand() & 1) printf("alive!\n");
+        else          printf("dead!\n");
+}
diff --git a/HDOJ/4362_autoAC.cpp b/HDOJ/4362_autoAC.cpp
new file mode 100644
index 0000000..24a8736
--- /dev/null
+++ b/HDOJ/4362_autoAC.cpp
@@ -0,0 +1,111 @@
+#include <iostream>
+#include <cstring>
+#include <queue>
+#include <algorithm>
+#include <cstdio>
+using namespace std;
+const int Ni = 1005;
+const int inf=1<<27;
+struct node{
+    int x,w;
+    bool operator < (const node &a) const
+    {
+        return x<a.x;
+    }
+}arr[52][Ni];
+struct qnode{
+    int val,x;
+    bool operator < (const qnode &a) const
+    {
+        if(val>a.val) return 1;
+        if(val==a.val&&x>a.x) return 1;
+        return 0;
+    }
+};
+int dp[52][Ni];
+int n,m;
+inline void cInit()
+{
+    int i,j;
+    for(i=0;i<n;i++)
+    {
+        for(j=0;j<m;j++)
+        {
+            scanf("%d",&arr[i][j].x);
+        }
+    }
+    for(i=0;i<n;i++)
+    {
+        for(j=0;j<m;j++)
+        {
+            scanf("%d",&arr[i][j].w);
+        }
+    }
+    for(i=0;i<n;i++)
+    {
+        sort(arr[i],arr[i]+m);
+    }
+}
+int main()
+{
+    int cs,x,i,j,ans;
+    cin>>cs;
+    while(cs--)
+    {
+        scanf("%d%d%d",&n,&m,&x);
+        cInit();
+        for(j=0;j<m;j++)
+        {
+            dp[0][j]=x-arr[0][j].x;
+            if(dp[0][j]<0) dp[0][j]=-dp[0][j];
+            dp[0][j]+=arr[0][j].w;
+        }
+        for(i=1;i<n;i++)
+        {
+            priority_queue<qnode> ql,qr;
+            qnode qn;
+            for(j=0;j<m;j++)
+            {
+                qn.val=dp[i-1][j]+arr[i-1][j].x;
+                qn.x=arr[i-1][j].x;
+                qr.push(qn);
+            }
+            int k=0;
+            for(j=0;j<m;j++)
+            {
+                dp[i][j]=inf;
+                while(k<m&&arr[i-1][k].x<=arr[i][j].x)
+                {
+                    qn.val=dp[i-1][k]-arr[i-1][k].x;
+                    qn.x=arr[i-1][k].x;
+                    ql.push(qn);
+                    k++;
+                }
+                if(!ql.empty())
+                {
+                    qn=ql.top();
+                    dp[i][j]=min(dp[i][j],qn.val+arr[i][j].x+arr[i][j].w);
+                }
+                if(!qr.empty())
+                {
+                    qn=qr.top();
+                    while(!qr.empty()&&qn.x<arr[i][j].x)
+                    {
+                        qr.pop();
+                        qn=qr.top();
+                    }
+                    if(qn.x>=arr[i][j].x)
+                    dp[i][j]=min(dp[i][j],qn.val-arr[i][j].x+arr[i][j].w);
+                }
+            }
+        }
+        ans=inf;
+        for(i=0;i<m;i++)
+        {
+            if(ans>dp[n-1][i])
+                ans=dp[n-1][i];
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4363_autoAC.cpp b/HDOJ/4363_autoAC.cpp
new file mode 100644
index 0000000..6c69e11
--- /dev/null
+++ b/HDOJ/4363_autoAC.cpp
@@ -0,0 +1,70 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#define inf 1<<29
+#define LL long long
+#define MOD 1000000007
+using namespace std;
+int dp[41][41][5][5][5][5][2];
+int get_dp(int x,int y,int l,int r,int u,int d,int k){
+    if(dp[x][y][l][r][u][d][k]!=-1)
+        return dp[x][y][l][r][u][d][k];
+    dp[x][y][l][r][u][d][k]=0;
+    if((x==1&&k==0)||(y==1&&k)){
+        for(int i=1;i<5;i++)
+           if(i!=l&&i!=r&&i!=u&&i!=d)
+               dp[x][y][l][r][u][d][k]++;
+        return dp[x][y][l][r][u][d][k];
+    }
+    dp[x][y][l][r][u][d][k]=0;
+    if(!k){
+        for(int i=1;i<x;i++)
+            for(int j=1;j<5;j++){
+                if(j!=u&&j!=l&&j!=r)
+                    dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+get_dp(x-i,y,l,r,j,d,1))%MOD;
+                if(j!=d&&j!=l&&j!=r)
+                    dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+get_dp(i,y,l,r,u,j,1))%MOD;
+            }
+        int t=0;
+        for(int i=1;i<=4;i++)
+            if(i!=u&&i!=l&&i!=r)
+                for(int j=1;j<=4;j++)
+                    if(j!=d&&j!=l&&j!=r&&j!=i)
+                       t++;
+        dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+MOD-t*(x-1))%MOD;
+        for(int i=1;i<5;i++)
+            if(i!=l&&i!=r&&i!=u&&i!=d)
+                dp[x][y][l][r][u][d][k]++;
+    }
+    else{
+        for(int i=1;i<y;i++)
+            for(int j=1;j<5;j++){
+                if(j!=l&&j!=d&&j!=u)
+                    dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+get_dp(x,y-i,j,r,u,d,0))%MOD;
+                if(j!=r&&j!=d&&j!=u)
+                    dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+get_dp(x,i,l,j,u,d,0))%MOD;
+            }
+        int t=0;
+        for(int i=1;i<=4;i++)
+            if(i!=l&&i!=u&&i!=d)
+                for(int j=1;j<=4;j++)
+                   if(j!=r&&j!=u&&j!=d&&j!=i)
+                      t++;
+        dp[x][y][l][r][u][d][k]=(dp[x][y][l][r][u][d][k]+MOD-t*(y-1))%MOD;
+        for(int i=1;i<5;i++)
+            if(i!=l&&i!=r&&i!=u&&i!=d)
+                dp[x][y][l][r][u][d][k]++;
+    }
+    return dp[x][y][l][r][u][d][k]%MOD;
+}
+int main(){
+    memset(dp,-1,sizeof(dp));
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        int x,y;
+        scanf("%d%d",&x,&y);
+        printf("%d\n",get_dp(x,y,0,0,0,0,0));
+    }
+    return 0;
+}
diff --git a/HDOJ/4364_autoAC.cpp b/HDOJ/4364_autoAC.cpp
new file mode 100644
index 0000000..f37587f
--- /dev/null
+++ b/HDOJ/4364_autoAC.cpp
@@ -0,0 +1,63 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+using namespace std;
+int ans[5][5]={{2,3,1,1},{1,2,3,1},{1,1,2,3},{3,1,1,2}};
+int matrix[5][5];
+int a[5][5];
+void multi()
+{
+   for(int i=0;i<4;i++)
+   {
+       for(int j=0;j<4;j++)
+       {
+           for(int k=0;k<4;k++)
+           {
+              int t=matrix[k][j];
+              t<<=1;
+              if(t>0xFF)//225
+              t=(t^0x1B)%(0xFF+1);
+              if(ans[i][k]==1)
+              {
+                  a[i][j]^=matrix[k][j];
+              }
+              else if(ans[i][k]==2)
+              {
+                  a[i][j]^=t;
+              }
+              else if(ans[i][k]==3)
+              {
+                  t^=matrix[k][j];
+                  a[i][j]^=t;
+              }
+           }
+       }
+   }
+}
+int main()
+{
+    int cas;
+    scanf("%d",&cas);
+    while(cas--)
+    {
+        memset(a,0,sizeof(a));
+        for(int i=0;i<4;i++)
+        for(int j=0;j<4;j++)
+         scanf("%X",&matrix[i][j]);
+        multi();
+        for(int i=0;i<4;i++)
+        {
+            for(int j=0;j<4;j++)
+            {
+              if(j!=0)
+              cout<<' ';
+              printf("%02X",a[i][j]);
+            }
+          puts("");
+        }
+        if(cas != 0)
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/4365_autoAC.cpp b/HDOJ/4365_autoAC.cpp
new file mode 100644
index 0000000..ee5dbb8
--- /dev/null
+++ b/HDOJ/4365_autoAC.cpp
@@ -0,0 +1,90 @@
+#include<iostream>
+#include<cstdio>
+#include<cstdlib>
+#include<algorithm>
+#include<cmath>
+#include<queue>
+#include<set>
+#include<map>
+#include<cstring>
+#include<vector>
+#include<string>
+#define LL long long
+#define MOD 100000007
+using namespace std;
+class Point
+{
+public:
+     int x,y;
+     bool operator == (const Point &tmp) const{
+        return  (x==tmp.x && y==tmp.y);        
+     }    
+}p[2024];
+int midx,midy;
+bool cmp(const Point &a,const Point &b){
+    if(a.x != b.x)
+    return a.x < b.x;
+    return a.y < b.y;
+}
+void Solve1( int x, int y , int cnt )
+{
+    if( x > midx) 
+    {
+        x = (midx<<1) - x;
+    } 
+    if( y > midy ) y = (midy<<1) - y;
+    if( x > y ) swap( x ,y );
+    p[cnt].x = x; p[cnt].y = y;
+}
+void Solve2( int x, int y , int  cnt )
+{
+    if( x > midx )
+    {
+        int d = x - midx - 1;
+        x = midx - d;
+    }
+    if( y > midy )
+    {
+        int d = y - midy - 1;
+        y = midy - d;
+    }
+    if( x > y ) swap( x , y );
+    p[cnt].x = x ; p[cnt].y = y;    
+}
+LL Pow( LL k , LL a )
+{
+    LL ans = 1;
+    while( k )    
+    {
+         if( k &1 ) ans = (ans*a)%MOD;
+         a = (a*a)%MOD;
+         k >>= 1;    
+    }
+    return ans;
+}
+int main(  )
+{
+    int n,m,k,x,y;
+    while( scanf( "%d %d %d",&n,&m,&k )==3 )
+    {
+           midx =  (n+1) /2;midy = midx;
+           for( int i = 0; i < m ; i ++ )
+           {
+                scanf( "%d %d",&x,&y );
+                x += 1 ; y += 1;
+                if( n & 1 ) Solve1( x ,y , i );
+                else Solve2( x , y , i );
+           }
+           LL L = ( n + 1 )/2;
+           LL ans = L*L/2  + (L + 1) /2;
+           sort(p,p+m,cmp);           
+           ans -= unique(p,p+m)-p;
+           if( ans > 0 )
+           {
+           ans = Pow( ans , (LL)k );
+           printf( "%I64d\n",ans ); 
+           }
+           else printf( "0\n" );    
+    }
+    return 0;
+}
diff --git a/HDOJ/4366_autoAC.cpp b/HDOJ/4366_autoAC.cpp
new file mode 100644
index 0000000..9cc8fd9
--- /dev/null
+++ b/HDOJ/4366_autoAC.cpp
@@ -0,0 +1,116 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <map>
+#include <stack>
+#include <algorithm>
+#define lson l, m , rt << 1
+#define rson m + 1, r, rt << 1 | 1
+#define maxn 50010
+using namespace std;
+struct people{
+    int id,loty,abty;
+    bool operator < (const people& cmp)const {
+        return abty > cmp.abty;
+    }
+}emp[maxn];
+int Max[maxn << 2],t,n,m,ans[maxn],L[maxn],R[maxn],head[maxn],tot,ed;
+map <int, int> mp;
+struct Edge{
+    int v,next;
+}edge[maxn];
+void add(int u,int v){
+    edge[ed].v = v;
+    edge[ed].next = head[u];
+    head[u] = ed ++;
+}
+void dfs(int root){
+    bool vis[maxn];
+    memset(vis,0,sizeof(vis));
+    tot = 0;    stack <int> ss;
+    while(!ss.empty()){ss.pop();}
+    ss.push(root); vis[root] = true;    L[root] = tot ++;
+    while(!ss.empty()){
+        int now = ss.top();
+        bool flag = false;
+        for(int i = head[now]; i != - 1; i = edge[i].next){
+            int x = edge[i].v;
+            if(!vis[x]){
+                flag = true;
+                vis[x] = true;
+                L[x] = tot ++;
+                ss.push(x);
+                head[now] = edge[i].next;
+                break;
+            }
+        }
+        if(flag)    continue;
+        if(vis[now]){
+            R[now] = tot;
+            ss.pop();
+        }
+    }
+}
+int query(int L, int R, int l, int r, int rt){
+    if(L > R) return -1;
+    if(L <= l && r <= R){
+        return Max[rt];
+    }int m = (l + r) >> 1;
+    int ll = -1, rr = -1;
+    if(L <= m) ll = query(L,R,lson);
+    if(R > m) rr = query(L,R,rson);
+    return max(ll,rr);
+}
+void update(int &pos, int &val, int l, int r, int rt){
+    if(l == r){
+        Max[rt] = val;  return ;
+    }int m = (l + r) >> 1;
+    if(pos <= m) update(pos,val,lson);
+    else update(pos,val,rson);
+    Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]);
+}
+void pre(){
+    mp.clear(); mp[-1] = -1;    tot = ed = 0;
+    memset(L,0,sizeof(L));  memset(R,0,sizeof(R));  memset(ans,-1,sizeof(ans));
+    memset(head,-1,sizeof(head));   memset(Max,-1,sizeof(Max));
+    for(int i = 1,fa; i < n; i ++){
+        scanf("%d%d%d",&fa,&emp[i].loty, &emp[i].abty);
+        add(fa,i);
+        mp[emp[i].loty] = i;
+        emp[i].id = i;
+    }
+    dfs(0);
+    sort(emp + 1,emp + n);
+}
+void showans(){
+    int fired;
+    while(m --){
+        scanf("%d",&fired);
+        printf("%d\n",ans[fired]);
+    }
+}
+int main(){
+    scanf("%d",&t);
+    while(t --){
+        scanf("%d%d",&n,&m);
+        pre();
+        for(int i = 1, j; i < n; i = j){
+            j = i;
+            while(j < n && emp[j].abty == emp[i].abty){
+                int id = emp[j].id;
+                int lo = query(L[id] + 1,R[id] - 1,0,tot - 1, 1);
+                ans[id] = mp[lo];
+                j ++;
+            }
+            j = i;
+            while(j < n && emp[j].abty == emp[i].abty){
+                int id = emp[j].id;
+                update(L[id],emp[j].loty,0,tot - 1, 1);
+                j ++;
+            }
+        }
+        showans();
+    }
+    return 0;
+}
diff --git a/HDOJ/4367_autoAC.cpp b/HDOJ/4367_autoAC.cpp
new file mode 100644
index 0000000..4d93cc1
--- /dev/null
+++ b/HDOJ/4367_autoAC.cpp
@@ -0,0 +1,164 @@
+#include <string.h>
+#include <algorithm>
+#include <math.h>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+const int N=210;
+const int M=41000;
+const int MOD=1000000007;
+const double eps=1e-8;
+const double PI=acos(-1.0);
+const double PI2=PI*2;
+struct Point
+{
+    double x,y;
+    LL index;
+    double angle;
+    inline void input()
+    {
+        scanf("%lf%lf",&x,&y);
+    }
+}point[N],temp[N];
+int n;
+bool visit[M];
+LL fib[M];
+LL fk[M];
+int num[N][N];
+int left[N][N];
+int right[N][N];
+inline Point operator-(const Point &a, const Point &b)
+{
+    Point c;
+    c.x=a.x-b.x;
+    c.y=a.y-b.y;
+    return c;
+}
+inline double operator*(const Point &a, const Point &b)
+{
+    return a.x*b.y-a.y*b.x;
+}
+inline bool operator==(const Point &a, const Point &b)
+{
+    return a.x==b.x&&a.y==b.y;
+}
+inline int cross(const Point &a, const Point &b, const Point &o)
+{
+    return (a-o)*(b-o)>0? 1:-1;
+}
+inline int cross(const int &a, const int &b, const int &o)
+{
+    return cross(point[a],point[b],point[o]);
+}
+inline double positiveAtan(const Point &a, const Point &o)
+{
+    double res=atan2(a.y-o.y,a.x-o.x);
+    if(res<0)
+        res+=PI2;
+    return res;
+}
+bool operator<(const Point &a, const Point &b)
+{
+    return a.angle<b.angle;
+}
+int abs1(int x)
+{
+    return x<0? -x:x;
+}
+int getAngleNumber(int a,int b,int c)
+{
+    if(point[c].y<point[b].y&&point[a].y>=point[b].y)
+        return n-abs1(right[b][c]-right[b][a]+2)+3;
+    return abs1(right[b][a]-right[b][c])+2;
+}
+int getTriangleNumber(int a, int b, int c)
+{
+    return n-left[a][b]-left[b][c]-left[c][a]+getAngleNumber(a,b,c)+getAngleNumber(b,c,a)+getAngleNumber(c,a,b)-6;
+}
+LL quick_mod(LL a,LL b)
+{
+    LL ans=1;
+    a%=MOD;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans=ans*a%MOD;
+            b--;
+        }
+        b>>=1;
+        a=a*a%MOD;
+    }
+    return ans;
+}
+LL solve(int x)
+{
+    if(visit[x])
+        return fk[x];
+    visit[x]=true;
+    fib[0]=x;
+    fib[1]=x;
+    for(int i=2;i<=x;++i)
+        fib[i]=(fib[i-1]*fib[i-2])%MOD;
+    return fk[x]=fib[x]+1;
+}
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        for(int i=0;i<n;++i)
+        {
+            point[i].input();
+            temp[i]=point[i];
+            temp[i].index=i;
+        }
+        memset(left,0,sizeof(left));
+        memset(right,0,sizeof(right));
+        for(int i=0;i<n;++i)
+        {
+            for(int j=i+1;j<n;++j)
+            {
+                for(int k=0;k<n;++k)
+                {
+                    if(k!=i&&k!=j)
+                    {
+                        if(cross(k,j,i)<0)
+                            ++left[i][j];
+                        else if(cross(k,i,j)<0)
+                            ++left[j][i];
+                    }
+                }
+            }
+            for(int j=0;j<n;++j)
+            {
+                if(temp[j].index==i)
+                    temp[j].angle=-1e100;
+                else
+                    temp[j].angle=positiveAtan(temp[j],point[i]);
+            }
+            sort(temp,temp+n);
+            int cnt=0;
+            for(int j=0;j<n;++j)
+                right[i][temp[j].index]=++cnt;
+        }
+        memset(num,0,sizeof(num));
+        for(int i=0;i<n;++i)
+        {
+            for(int j=i+1;j<n;++j)
+            {
+                for(int k=0;k<n;++k)
+                {
+                    if(k==i||k==j) continue;
+                    if(cross(point[k], point[j], point[i]) < 0)
+                        num[i][j]+=getAngleNumber(j,k,i)-getTriangleNumber(i,j,k);
+                }
+            }
+        }
+        LL ans=1;
+        for(int i=0;i<n;++i)
+            for(int j=i+1;j<n;++j)
+                ans=(ans*solve(num[i][j]))%MOD;
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4368_autoAC.cpp b/HDOJ/4368_autoAC.cpp
new file mode 100644
index 0000000..3f10173
--- /dev/null
+++ b/HDOJ/4368_autoAC.cpp
@@ -0,0 +1,63 @@
+#include<stdio.h>
+#include<math.h>
+#define eps 1e-5
+#define PI 3.1415926535897932384626
+int n,a[10001];
+double angle;
+int i,j,k,maxtop;
+double dis[10001],t,top,ans,low,h;
+int main()
+{
+    while(~scanf("%d%lf",&n,&angle))
+    {
+        if(angle<-eps) for(i=n-1;i>=0;i--) scanf("%d",&a[i]);
+        else for(i=0;i<n;i++) scanf("%d",&a[i]);
+        if(angle<-eps) angle=-angle;
+        angle=PI*angle/180.0;
+        t=-1;ans=0;
+        for(i=0;i<n;i++)
+        {
+            dis[i]=((i+1)*tan(angle)+a[i]*1.0)/sqrt(tan(angle)*tan(angle)+1);
+            if(t<dis[i]){t=dis[i];maxtop=i;} 
+        }
+        for(i=0;i<maxtop;i++)
+        {
+            top=a[i];
+            for(j=i+1;j<=maxtop;j++)
+            {
+                if(dis[j]>dis[i]+eps)
+                {
+                    if(dis[j]-sin(angle)>dis[i]+eps)
+                    {
+                        top-=(j-i-1)*1.0*tan(angle);
+                        ans+=(j-i-1)*(j-i-1)*0.5*tan(angle);
+                    }
+                    else
+                    {
+                        top-=(a[i]-a[j])*1.0;
+                        ans+=(a[i]-a[j])*(a[i]-a[j])*0.5/tan(angle);
+                    }
+                    for(k=i+1;k<j;k++)
+                        ans+=(top-a[k])*1.0;
+                    i=j-1;
+                    break;
+                }
+            }
+        }
+        for(i=n-1;i>maxtop;i--)
+        {
+            for(j=i-1;j>=maxtop;j--)
+            {
+                    h=i-j;
+                    low=h*tan(angle)-(a[j+1]-a[i]);
+                    top=(h-1)*tan(angle)-(a[j+1]-a[i]);
+                    ans+=(top+low)/2.0;
+                if(dis[j]>dis[i]+eps)
+                    break;
+            }
+            i=j+1;
+        }
+        printf("%.2lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4370_autoAC.cpp b/HDOJ/4370_autoAC.cpp
new file mode 100644
index 0000000..c09eeda
--- /dev/null
+++ b/HDOJ/4370_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+const int INF=0x3f3f3f3f;
+const int MAXN=330;
+int cost[MAXN][MAXN];
+int dist[MAXN];
+int que[MAXN];
+bool vis[MAXN];
+void SPFA(int start,int n)
+{
+    int front=0,rear=0;
+    for(int v=1;v<=n;v++)
+    {
+        if(v==start)
+        {
+            dist[v]=INF;
+            vis[v]=false;
+        }
+        else if(cost[start][v]!=INF)
+        {
+            dist[v]=cost[start][v];
+            que[rear++]=v;
+            vis[v]=true;
+        }
+        else
+        {
+            dist[v]=INF;
+            vis[v]=false;
+        }
+    }
+    while(front!=rear)
+    {
+        int u=que[front++];
+        for(int v=1;v<=n;v++)
+        {
+            if(dist[v]>dist[u]+cost[u][v])
+            {
+                dist[v]=dist[u]+cost[u][v];
+                if(!vis[v])
+                {
+                    vis[v]=true;
+                    que[rear++]=v;
+                    if(rear>=MAXN) rear=0;
+                }
+            }
+        }
+        vis[u]=false;
+        if(front>=MAXN)front=0;
+    }
+}
+int main()
+{
+    int n;
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(int i=1;i<=n;i++)
+          for(int j=1;j<=n;j++)
+            scanf("%d",&cost[i][j]);
+        SPFA(1,n);
+        int ans=dist[n];
+        int loop1=dist[1];
+        SPFA(n,n);
+        int loopn=dist[n];
+        ans=min(ans,loop1+loopn);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4371_autoAC.cpp b/HDOJ/4371_autoAC.cpp
new file mode 100644
index 0000000..ee4fd3b
--- /dev/null
+++ b/HDOJ/4371_autoAC.cpp
@@ -0,0 +1,23 @@
+#include<iostream>
+#include<cstdio>
+using namespace std;
+int main()
+{
+    int test,n,m,tmin,t,i,k;
+    scanf("%d",&test);
+    for(k=1;k<=test;k++)
+    {
+        tmin=1000000;
+        scanf("%d %d",&n,&m);
+        for(i=0;i<m;i++)
+        {
+            scanf("%d",&t);
+            if(tmin>t)
+                tmin=t;
+        }
+        n=n/tmin;
+        if(n&1) printf("Case #%d: Bob\n",k);
+        else printf("Case #%d: Alice\n",k);
+    }
+    return 0;
+}
diff --git a/HDOJ/4372_autoAC.cpp b/HDOJ/4372_autoAC.cpp
new file mode 100644
index 0000000..57b7d29
--- /dev/null
+++ b/HDOJ/4372_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+const int N=2005;
+const LL MOD=1000000007;
+LL C[N][N];
+LL S[N][N];
+void Init()
+{
+    int i,j;
+    for(i=0;i<N;i++)
+    {
+        C[i][0]=1;
+        C[i][i]=1;
+        S[i][0]=0;
+        S[i][i]=1;
+        for(j=1;j<i;j++)
+        {
+            C[i][j]=(C[i-1][j]%MOD+C[i-1][j-1]%MOD)%MOD;
+            S[i][j]=((i-1)%MOD*S[i-1][j]%MOD+S[i-1][j-1]%MOD);
+        }
+    }
+}
+int main()
+{
+    LL t,n,f,b,ans;
+    Init();
+    scanf("%I64d",&t);
+    while(t--)
+    {
+        scanf("%I64d%I64d%I64d",&n,&f,&b);
+        ans=C[f+b-2][f-1]%MOD*S[n-1][f+b-2]%MOD;
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4373_autoAC.cpp b/HDOJ/4373_autoAC.cpp
new file mode 100644
index 0000000..f6e60c7
--- /dev/null
+++ b/HDOJ/4373_autoAC.cpp
@@ -0,0 +1,159 @@
+#include<iostream>
+#include<algorithm>
+#include<cstdio>
+#include<queue>
+#include<map>
+#include<set>
+#include<cmath>
+#include<cstring>
+#include<iomanip>
+using namespace std;
+#define i64 __int64
+#define MM(name,what)   memset(name,what,sizeof(name))
+const int inf = 0x3f3f3f3f;
+const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
+const double oo = 10e9;
+const double eps = 10e-9;
+const double pi = acos(-1.0);
+const int maxn = 100111;
+const i64 mod = 364875103;
+const i64 mod1 = 97;
+const i64 mod2 = 3761599;
+const int maxc = 111;
+i64 gcd(i64 _a, i64 _b)  
+{  
+    if (!_a || !_b)  
+    {  
+        return max(_a, _b);  
+    }  
+    i64 _t;  
+    while ((_t = _a % _b))  
+    {  
+        _a = _b;  
+        _b = _t;  
+    }  
+    return _b;  
+}  
+i64 ext_gcd (i64 _a, i64 _b, i64 &_x, i64 &_y)  
+{  
+    if (!_b)  
+    {  
+        _x = 1;  
+        _y = 0;  
+        return _a;  
+    }  
+    i64 _d = ext_gcd (_b, _a % _b, _x, _y);  
+    i64 _t = _x;  
+    _x = _y;  
+    _y = _t - _a / _b * _y;  
+    return _d;  
+}  
+i64 invmod (i64 _a, i64 _p)  
+{  
+    i64 _ans, _y;  
+    ext_gcd (_a, _p, _ans, _y);  
+    _ans < 0 ? _ans += _p : 0;  
+    return _ans;  
+}  
+i64 dp[maxn];
+i64 inv[maxn];
+i64 c[maxc][maxc];
+i64 n,m;
+i64 ans;
+i64 a[21];
+i64 cx;
+void init()
+{
+    for(int i=1;i<maxn;i++)
+    {
+        inv[i]=invmod(i,mod2);
+    }
+    MM(c,0);
+    for(int i=0;i<maxc;i++)    
+    {
+        c[i][i]=1;
+        c[i][0]=1;
+    }
+    for(int i=1;i<maxc;i++)
+    {
+        for(int j=1;j<maxc;j++)
+        {
+            c[i][j]=c[i-1][j-1]+c[i-1][j];
+            c[i][j]%=mod1;
+        }    
+    }
+    cx = invmod(mod1,mod2);
+    return ;
+}
+i64 lucas(i64 x,i64 y,i64 p=mod1)
+{
+    if(y>x) return 0;
+    i64 re=1;
+    i64 dx = x%p;
+    i64 dy = y%p;
+    re*=c[dx][dy];
+    dx = x/p;
+    dy = y/p;
+    if(dx || dy)
+    {
+        re*=lucas(dx,dy);
+    }
+    re%=p;
+    return re;
+}
+i64 find(int x)
+{
+    i64 t1 = lucas(n+x-1,x);
+    i64 t2 = dp[x]; 
+    i64 temp = cx;
+    temp *= t2-t1;
+    temp %= mod2;
+    temp = (temp+mod2)%mod2;
+    temp *= mod1;
+    temp += t1;
+    temp %= mod;
+    return temp;
+}
+void start()
+{    
+    dp[0]=1;
+    i64 now,temp;
+    for(int i=1;i<=m;i++)
+    {
+        now = n+i-1;
+        dp[i]=dp[i-1]*now;
+        dp[i]%=mod2;
+        dp[i]*=inv[i];
+        dp[i]%=mod2; 
+    }    
+    return ;
+}
+int main()
+{
+    init();
+    int k,T;    
+    cin>>T;
+    for(int tt=1;tt<=T;tt++)
+    {
+        cin>>n>>m;
+        start();
+        cin>>k;
+        for(int i=1;i<=k;i++)    
+        {
+            cin>>a[i];
+            a[i]++;
+        }
+        ans=1;
+        i64 pre = m;
+        i64 now;
+        for(int i=k;i>=1;i--)
+        {
+            now = pre - a[i]+1;
+            ans *= find(now);
+            ans %= mod;
+            pre = a[i]-1;
+        }
+        cout<<"Case #"<<tt<<": "<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4374_autoAC.cpp b/HDOJ/4374_autoAC.cpp
new file mode 100644
index 0000000..9ab62ba
--- /dev/null
+++ b/HDOJ/4374_autoAC.cpp
@@ -0,0 +1,99 @@
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+#include <string>
+#include <cstdio>
+#include <cmath>
+#include <queue>
+#include <map>
+#include <set>
+#define eps 1e-5
+#define MAXN 105
+#define MAXM 11111
+#define INF 1000000000
+#define lch(x) x<<1
+#define rch(x) x<<1|1
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1|1
+using namespace std;
+int n, m, x, t;
+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;
+}
+int dp[MAXN][MAXM];
+int sum[MAXN][MAXM];
+int lmx[4 * MAXM];
+int rmx[4 * MAXM];
+int a[MAXN][MAXM];
+int q[MAXM];
+int main()
+{
+    while(scanf("%d%d%d%d", &n, &m, &x, &t) != EOF)
+    {
+        for(int i = 1; i <= n + 2; i++)
+            for(int j = 1; j <= m; j++)
+                sum[i][j] = 0, dp[i][j] = -INF, a[i][j] = 0;
+        for(int i = 1; i <= n; i++)
+            for(int j = 1; j <= m; j++)
+            {
+                a[i][j] = in();
+                sum[i][j] = sum[i][j - 1] + a[i][j];
+            }
+        int tmp = 0;
+        for(int i = x; i <= x + t; i++)
+        {
+            tmp += a[1][i];
+            dp[1][i] = tmp;
+            dp[2][i] = dp[1][i] + a[2][i];
+        }
+        tmp = 0;
+        for(int i = x; i >= x - t; i--)
+        {
+            tmp += a[1][i];
+            dp[1][i] = tmp;
+            dp[2][i] = dp[1][i] + a[2][i];
+        }
+        for(int i = 3; i <= n + 1; i++)
+        {
+            for(int j = 1; j <= m; j++)
+            {
+                lmx[j] = dp[i - 1][j] - sum[i - 1][j];
+                rmx[j] = dp[i - 1][j] + sum[i - 1][j - 1];
+            }
+            int head = 1, rear = 0;
+            for(int j = 1; j <= m; j++)
+            {
+                while(head <= rear && lmx[q[rear]] <= lmx[j]) rear--;
+                q[++rear] = j;
+                while(head <= rear && q[head] < j - t) head++;
+                dp[i][j] = max(lmx[q[head]] + sum[i - 1][j] + a[i][j], dp[i][j]);
+            }
+            head = 1, rear = 0;
+            for(int j = m; j >= 1; j--)
+            {
+                while(head <= rear && rmx[q[rear]] <= rmx[j]) rear--;
+                q[++rear] = j;
+                while(head <= rear && q[head] > j + t) head++;
+                dp[i][j] = max(rmx[q[head]] - sum[i - 1][j - 1] + a[i][j], dp[i][j]);
+            }
+        }
+        int ans = -INF;
+        for(int i = 1; i <= m; i++)
+            if(dp[n + 1][i] > ans) ans = dp[n + 1][i];
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4375_autoAC.cpp b/HDOJ/4375_autoAC.cpp
new file mode 100644
index 0000000..d20f2cf
--- /dev/null
+++ b/HDOJ/4375_autoAC.cpp
@@ -0,0 +1,114 @@
+#include<iostream>
+#include<sstream>
+#include<vector>
+#include<list>
+#include<deque>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<bitset>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cctype>
+#include<cmath>
+#include<ctime>
+#include<iomanip>
+using namespace std;
+const double eps(1e-8);
+typedef long long lint;
+int dx[] = {-1, 0, 1, 0};
+int dy[] = {0, 1, 0, -1};
+int H, W, N;
+#define next nex
+char lr[1000100];
+int next[1000100][4];
+int dir[1000100];
+const int inf = 1e9 + 7;
+char maz[1010][1010];
+int vis[1010][1010][4];
+int sx, sy, ex, ey;
+#define mp make_pair
+int cas;
+int tot;
+struct Edge
+{
+    int x, y, nex;
+};
+Edge edge[4000010];
+int head[1000010];
+void addEdge(int s, int x, int y)
+{
+    edge[tot].x = x, edge[tot].y = y;
+    edge[tot].nex = head[s];
+    head[s] = tot++;
+}
+bool bfs()
+{
+    memset(head, -1, sizeof(head));
+    tot = 0;
+    while(sx >= 0 && sx < H && sy >= 0 && sy < W && vis[sx][sy][0] != cas && maz[sx][sy] != '#')
+    {
+        addEdge(0, sx, sy);
+        vis[sx][sy][0] = cas;
+        if(sx == ex && sy == ey) return true;
+        sx += dx[0], sy += dy[0];
+    }
+    for(int i = 0; i <= N; i++)
+    {
+        for(int j = head[i]; j + 1; j = edge[j].nex)
+        {
+            int nx = edge[j].x, ny = edge[j].y;
+            for(int d = 0; d < 4; d++)
+            {
+                if(next[i][d] == inf) continue;
+                int tx = nx + dx[d], ty = ny + dy[d];
+                while(tx >= 0 && tx < H && ty >= 0 && ty < W && vis[tx][ty][d] != cas && maz[tx][ty] != '#')
+                {
+                    addEdge(next[i][d], tx, ty);
+                    vis[tx][ty][d] = cas;
+                    if(tx == ex && ty == ey) return true;
+                    tx += dx[d], ty += dy[d];
+                }
+            }
+        }
+    }
+    return false;
+}
+void init()
+{
+    dir[0] = 0;
+    for(int i = 0; i < N; i++)
+        dir[i + 1] = (lr[i] == 'L') ? (dir[i] + 3) % 4 : (dir[i] + 1) % 4;
+    int last[4] = {inf, inf, inf, inf};
+    for(int i = N; i >= 0; i--)
+    {
+        for(int j = 0; j < 4; j++)
+            next[i][j] = last[j];
+        last[dir[i]] = i;
+    }
+    return;
+}
+int main()
+{
+    cas = 0;
+    memset(vis, 0, sizeof(vis));
+    while(~scanf("%d %d %d", &H, &W, &N))
+    {
+        cas++;
+        scanf("%s", lr);
+        init();
+        for(int i = 0; i < H; i++)
+        {
+            scanf("%s", maz[i]);
+            for(int j = 0; j < W; j++)
+                if(maz[i][j] == 'S') sx = i, sy = j;
+                else if(maz[i][j] == 'E') ex = i, ey = j;
+        }
+        if(bfs()) puts("Yes");
+        else puts("No");
+    }
+    return 0;
+}
diff --git a/HDOJ/4376_autoAC.cpp b/HDOJ/4376_autoAC.cpp
new file mode 100644
index 0000000..0a81bd2
--- /dev/null
+++ b/HDOJ/4376_autoAC.cpp
@@ -0,0 +1,171 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+#define MAXL 22
+#define KIND 9
+#define MAXNODE 42
+typedef long long LL;
+vector<int> A, B, RA, RB;
+char subA[MAXL], subB[MAXL];
+int N, en[MAXNODE], suffix[MAXNODE], q[MAXNODE], child[MAXNODE][KIND];
+LL dp[MAXL][3][3][3][3][MAXNODE][1 << 2];
+int change(char ch) {
+    return ch - '1';
+}
+void Trie() {
+    memset(en, 0, sizeof(en));
+    memset(child, 0, sizeof(child));
+    N = 1;
+    for(int i = 0; i < 2; ++i) {
+        char* s = i == 0? subA: subB;
+        int p = 1;
+        for (int j = 0; s[j]; ++j) {
+            int ch = change(s[j]);
+            if (!child[p][ch]) child[p][ch] = ++N;
+            p = child[p][ch];
+        }
+        en[p] |= 1 << i;
+    }
+}
+void AC() {
+    int ql = 0, qr = 0;
+    for (int i = 0; i < KIND; ++i)
+        if (child[1][i]) {
+            suffix[child[1][i]] = 1;
+            q[qr++] = child[1][i];
+        }
+        else child[1][i] = 1;
+    while (ql < qr) {
+        int u = q[ql++];
+        for (int i = 0; i < KIND; ++i)
+            if (child[u][i]) {
+                suffix[child[u][i]] = child[suffix[u]][i];
+                q[qr++] = child[u][i];
+            }
+            else child[u][i] = child[suffix[u]][i];
+    }
+    for (int i = 1; i <= N; ++i)
+        for (int j = i; j != 1; j = suffix[j]) en[i] |= en[j];
+}
+int cal1(int pos, int val, int pre, vector<int>& vec) {
+    if(pos >= vec.size()) return 2;
+    if(pre != 0) return pre;
+    if(val > vec[pos]) return 2;
+    if(val < vec[pos]) return 1;
+    return 0;
+}
+int cal2(int pos, int val, int pre, vector<int>& vec) {
+    if(pos >= vec.size()) return 2;
+    if(val > vec[pos]) return 2;
+    if(val < vec[pos]) return 1;
+    return pre;
+}
+int main() {
+    int T;
+    scanf("%d", &T);
+    for(int cas = 1; cas <= T; ++cas) {
+        LL a, b;
+        cin >> a >> b;
+        scanf("%s%s", subA, subB);
+        LL sub = 0, rsub = 0;
+        for(int i = 0; subA[i]; ++i)
+            sub = sub * 10 + subA[i] - '0';
+        for(int i = 0; subB[i]; ++i)
+            rsub = rsub * 10 + subB[i] - '0';
+        reverse(subB, subB + strlen(subB));
+        Trie();
+        AC();
+        A.clear();
+        B.clear();
+        RA.clear();
+        RB.clear();
+        LL ta = a, tb = b;
+        while(ta) {
+            RA.push_back(ta % 10);
+            ta /= 10;
+        }
+        while(tb) {
+            RB.push_back(tb % 10);
+            tb /= 10;
+        }
+        A = RA;
+        B = RB;
+        reverse(A.begin(), A.end());
+        reverse(B.begin(), B.end());
+        int l = B.size();
+        memset(dp, 0, sizeof(dp));
+        for(int j = 1; j < 10; ++j) {
+            int s1 = cal1(0, j, 0, A);
+            int s2 = cal1(0, j, 0, B);
+            int rs1 = cal2(0, j, 0, RA);
+            int rs2 = cal2(0, j, 0, RB);
+            int v = child[1][j - 1];
+            ++dp[0][s1][s2][rs1][rs2][v][en[v]];
+        }
+        for(int i = 0; i + 1 < l; ++i) {
+            for(int s1 = 0; s1 < 3; ++s1) for(int s2 = 0; s2 < 3; ++s2) for(int rs1 = 0; rs1 < 3; ++rs1) for(int rs2 = 0; rs2 < 3; ++rs2)
+                for(int u = 1; u <= N; ++u)
+                    for(int mask = 0; mask < (1 << 2); ++mask) if(dp[i][s1][s2][rs1][rs2][u][mask]) {
+                        for(int val = 1; val < 10; ++val) {
+                            int ns1 = cal1(i + 1, val, s1, A);
+                            int ns2 = cal1(i + 1, val, s2, B);
+                            int nrs1 = cal2(i + 1, val, rs1, RA);
+                            int nrs2 = cal2(i + 1, val, rs2, RB);
+                            int v = child[u][val - 1];
+                            dp[i + 1][ns1][ns2][nrs1][nrs2][v][mask | en[v]] += dp[i][s1][s2][rs1][rs2][u][mask];
+                        }
+                    }
+        }
+        LL res = 0;
+        int la = A.size(), lb = B.size();
+        for(int len = la; len < lb - 1; ++len) {
+            for(int s1 = 0; s1 < 3; ++s1) for(int s2 = 0; s2 < 3; ++s2) for(int rs1 = 0; rs1 < 3; ++rs1) for(int rs2 = 0; rs2 < 3; ++rs2)
+                for(int u = 1; u <= N; ++u)
+                    for(int mask = 1; mask < (1 << 2); ++mask)
+                        res += dp[len][s1][s2][rs1][rs2][u][mask];
+        }
+        if(la != lb) {
+            for(int s1 = 0; s1 < 3; ++s1) for(int s2 = 0; s2 < 3; ++s2) for(int rs1 = 0; rs1 < 3; ++rs1) for(int rs2 = 0; rs2 < 3; ++rs2)
+                for(int u = 1; u <= N; ++u)
+                    for(int mask = 1; mask < (1 << 2); ++mask) {
+                        bool flaga = false;
+                        if(mask == 1 || mask == 3) {
+                            if(s1 == 0 || s1 == 2) flaga = true;
+                        }
+                        if(mask == 2 || mask == 3) {
+                            if(rs1 == 0 || rs1 == 2) flaga = true;
+                        }
+                        if(flaga)
+                            res += dp[la - 1][s1][s2][rs1][rs2][u][mask];
+                        bool flagb = false;
+                        if(mask == 1 || mask == 3) {
+                            if(s2 == 0 || s2 == 1) flagb = true;
+                        }
+                        if(mask == 2 || mask == 3) {
+                            if(rs2 == 0 || rs2 == 1) flagb = true;
+                        }
+                        if(flagb)
+                            res += dp[lb - 1][s1][s2][rs1][rs2][u][mask];
+                    }
+        } else {
+            for(int s1 = 0; s1 < 3; ++s1) for(int s2 = 0; s2 < 3; ++s2) for(int rs1 = 0; rs1 < 3; ++rs1) for(int rs2 = 0; rs2 < 3; ++rs2)
+                for(int u = 1; u <= N; ++u)
+                    for(int mask = 1; mask < (1 << 2); ++mask) {
+                        bool flag = false;
+                        if(mask == 1 || mask == 3) {
+                            if((s1 == 0 || s1 == 2) && (s2 == 0 || s2 == 1)) flag = true;
+                        }
+                        if(mask == 2 || mask == 3) {
+                            if((rs1 == 0 || rs1 == 2) && (rs2 == 0 || rs2 == 1)) flag = true;
+                        }
+                        if(flag) res += dp[la - 1][s1][s2][rs1][rs2][u][mask];
+                    }
+        }
+        printf("Case #%d: ", cas);
+        cout << res << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4377_autoAC.cpp b/HDOJ/4377_autoAC.cpp
new file mode 100644
index 0000000..af88b06
--- /dev/null
+++ b/HDOJ/4377_autoAC.cpp
@@ -0,0 +1,35 @@
+#include<stdio.h>
+#include<math.h>
+int T,n;
+int i,j,qujian[100001],began,t,res;
+int main()
+{
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        t=(int)(sqrt(n)+0.99999);
+        res=t*t-n;
+        for(i=0;i<t;i++) qujian[i]=t;
+        for(i=0;i<t;i++)
+            if(qujian[i]<res+1)
+            {
+                qujian[i]=1;
+                res-=(t-1);
+            }
+            else
+            {
+                qujian[i]-=res;
+                break;
+            }
+        began=0;
+        for(i=0;i<t;i++)
+        {
+            began+=qujian[i];
+            for(j=0;j<qujian[i];j++)
+                if(i==t-1&&j==qujian[i]-1) printf("%d\n",began-j);
+                else printf("%d ",began-j);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4379_autoAC.cpp b/HDOJ/4379_autoAC.cpp
new file mode 100644
index 0000000..446f1e2
--- /dev/null
+++ b/HDOJ/4379_autoAC.cpp
@@ -0,0 +1,36 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+unsigned int a,b,k,n,l,last;
+unsigned int mod;
+bool v[21000000];
+int main()
+{
+    while(cin>>n>>l>>a>>b>>mod)
+    {
+        for(unsigned int i=1;i<=n;i++)
+        v[i]=false;
+        unsigned int ans=0;unsigned int max=0,t;
+        last=b;
+        for(unsigned int i=1;i<=n;i++)
+        {
+            t=(last+a)%mod;
+            if(t*2<=l)
+            {
+                ans++;v[i]=true;
+                if(t>max)max=t;
+            }
+            last=t;
+        }
+        last=b;
+        for(unsigned int i=1;i<=n;i++)
+        {
+            t=(last+a)%mod;
+            if((!v[i])&&t+max<=l){ans++;break;}
+            last=t;
+        }
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4380_autoAC.cpp b/HDOJ/4380_autoAC.cpp
new file mode 100644
index 0000000..dfb0f77
--- /dev/null
+++ b/HDOJ/4380_autoAC.cpp
@@ -0,0 +1,92 @@
+#include<cstdio>
+#include<algorithm>
+#include<cmath>
+#include<cstring>
+using namespace std;
+typedef long long LL;
+const int N=105;
+const int M=1005;
+struct Point
+{
+    LL x,y;
+}P1[N],P2[M];
+int f[N][N][N];
+int n,m;
+LL cross(Point a,Point b,Point s)
+{
+    LL x1=a.x-s.x,y1=a.y-s.y;
+    LL x2=b.x-s.x,y2=b.y-s.y;
+    return x1*y2-x2*y1;
+}
+int dis2(Point a,Point b)
+{
+    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*((a.y-b.y));
+}
+int cmp(Point a,Point b)
+{
+    if(cross(a,b,P1[0])>0)
+        return 1;
+    else return 0;
+}
+void init()
+{
+    int i,t;
+    for(t=0,i=0;i<n;i++){
+        if((P1[i].y-P1[t].y)<0 || (P1[i].y-P1[t].y==0 && P1[i].x-P1[t].x<0))
+        t=i;
+    }
+    swap(P1[0],P1[t]);
+    sort(P1+1,P1+n,cmp);
+}
+int cal(int x,int y,int z)
+{
+    int i;
+    int sum=0;
+    LL a,b,c;
+    for (i=0;i<m;i++)
+    {
+        a=cross(P1[y],P2[i],P1[x]);
+        b=cross(P1[z],P2[i],P1[y]);
+        c=cross(P1[x],P2[i],P1[z]);
+        if ((a>=0 && b>=0 && c>=0) || (a<=0 && b<=0 && c<=0))
+        {
+            sum++;
+        }
+    }
+    return sum;
+}
+int main()
+{
+    int i,j,k;
+    int CA=0;
+    int ans=0;
+    while (scanf("%d%d",&n,&m)!=EOF)
+    {
+        ans=0;
+        memset(P1,0,sizeof(P1));
+        memset(P2,0,sizeof(P2));
+        memset(f,0,sizeof(f));
+        for (i=0;i<n;i++)
+            scanf("%I64d%I64d",&P1[i].x,&P1[i].y);
+        for (i=0;i<m;i++)
+            scanf("%I64d%I64d",&P2[i].x,&P2[i].y);
+        init();
+        for (i=2;i<n;i++){
+            for (j=1;j<i;j++){
+                f[0][j][i]=cal(0,j,i);
+                if (f[0][j][i]%2!=0) ans++;
+            }
+        }
+        for (i=2;i<n;i++)
+            for (j=1;j<i;j++)
+                for (k=j+1;k<i;k++){
+                    if (cross(P1[k],P1[i],P1[j])>0)
+                        f[j][k][i]=f[0][j][k]+f[0][k][i]-f[0][j][i];
+                    else
+                        f[j][k][i]=f[0][j][i]-(f[0][j][k]+f[0][k][j]);
+                    if (f[j][k][i]%2!=0) ans++;
+                }
+        printf("Case %d: ",++CA);
+        printf("%d\n",ans);
+    }
+}
diff --git a/HDOJ/4381_autoAC.cpp b/HDOJ/4381_autoAC.cpp
new file mode 100644
index 0000000..1b3adb0
--- /dev/null
+++ b/HDOJ/4381_autoAC.cpp
@@ -0,0 +1,74 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <vector>
+#include <cmath>
+using namespace std;
+const int maxn = 2005;
+struct node{
+    int aa,cor;
+    node(){}
+    node(int _aa,int _cor){
+       aa = _aa;   cor = _cor;
+    }
+}x1[maxn],x2[maxn];
+int n,m;
+int dp1[maxn],dp2[maxn];
+int sumx1,sumx2;
+bool cmp(const node &p,const node &q){
+    return p.aa < q.aa;
+}
+int min(int a,int b)
+{
+    return a<b?a:b;
+}
+int main()
+{
+    int cas,ta=1;
+    scanf("%d",&cas);
+    while(cas--){
+         int i,j;
+         scanf("%d%d",&n,&m);
+         sumx1 = sumx2 = 1;
+         for(i=0; i<m; i++){
+             int key,yy,z;
+             scanf("%d%d%d",&key,&yy,&z);
+             if(key == 1){
+                x1[sumx1++] = node(yy,z);
+             }else{
+                x2[sumx2++] = node(n+1-yy,z);
+             }
+         }
+         sort(x1+1,x1+sumx1,cmp);
+         sort(x2+1,x2+sumx2,cmp);
+         memset(dp1,0x3f,sizeof(dp1));
+         memset(dp2,0x3f,sizeof(dp2));
+         dp1[0] = dp2[0] = 0;
+         for(i=1; i<sumx1; i++){
+             for(j=x1[i].aa; j>=x1[i].cor; j--){
+                dp1[j] = min(dp1[j],dp1[j-x1[i].cor]+1);
+             }
+         }
+         for(i=1; i<sumx2; i++){
+             for(j=x2[i].aa; j>=x2[i].cor; j--){
+                dp2[j] = min(dp2[j],dp2[j-x2[i].cor]+1);
+             }
+         }
+         int ans = 0,anssum = 0,tmp;
+         for(i=1; i<=n; i++){
+            for(j=0; j<=i; j++){
+               tmp = dp1[j] + dp2[i-j];
+               if(tmp <= m){
+                  if(ans != i){
+                    ans = i;   anssum = tmp;
+                  }else if(tmp < anssum){
+                      anssum = tmp;
+                  }
+               }
+            }
+         }
+         printf("Case %d: %d %d\n",ta++,ans,anssum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4382_autoAC.cpp b/HDOJ/4382_autoAC.cpp
new file mode 100644
index 0000000..f3c2bf1
--- /dev/null
+++ b/HDOJ/4382_autoAC.cpp
@@ -0,0 +1,2 @@
+     SET|ADD    C1|C2,    C1|C2|IntegerNumber
+     MUL        C1|C2,    IntegerNumber
diff --git a/HDOJ/4383_autoAC.cpp b/HDOJ/4383_autoAC.cpp
new file mode 100644
index 0000000..5349495
--- /dev/null
+++ b/HDOJ/4383_autoAC.cpp
@@ -0,0 +1,94 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#include<cstdio>
+#include<deque>
+#include<map>
+#include<queue>
+#define iinf 2000000000
+#define linf 1000000000000000000LL
+#define dinf 1e200
+#define eps 1e-5
+#define lng long long
+#define sqr(a) ((a)*(a))
+#define pi 3.14159265359
+#define ff(i,xi,n) for(int i=xi;i<=(int)(n);++i)
+#define ffd(i,xi,n) for(int i=xi;i>=(int)(n);--i)
+#define ffl(i,r) for(int i=head[r];i!=-1;i=edge[i].next)
+#define cc(i,j) memset(i,j,sizeof(i))
+#define two(x)            ((lng)1<<(x))
+#define N 11111
+#define M 1000000
+#define lson l , mid , rt << 1
+#define rson mid + 1 , r , rt << 1 | 1
+#define Mod  n
+#define Pmod(x) (x%Mod+Mod)%Mod
+using namespace std;
+typedef vector<int>  vi;
+typedef vector<string>  vs;
+typedef unsigned int uint;
+typedef unsigned lng ulng;
+template<class T> inline void checkmax(T &x,T y){if(x<y) x=y;}
+template<class T> inline void checkmin(T &x,T y){if(x>y) x=y;}
+template<class T> inline T Min(T x,T y){return (x>y?y:x);}
+template<class T> inline T Max(T x,T y){return (x<y?y:x);}
+template<class T> T gcd(T a,T  b){return (a%b)==0?b:gcd(b,a%b);}
+template<class T> T lcm(T a,T b){return a*b/gcd(a,b);}
+template<class T> T Abs(T a){return a>0?a:(-a);}
+template<class T> inline T lowbit(T n){return (n^(n-1))&n;}
+template<class T> inline int countbit(T n){return (n==0)?0:(1+countbit(n&(n-1)));}
+template<class T> inline bool isPrimeNumber(T n)
+{if(n<=1)return false;for (T i=2;i*i<=n;i++) if (n%i==0) return false;return true;}
+template<class T> inline T Minmin(T a,T b,T c,T d){return Min(Min(a,b),Min(c,d));}
+int dp[N][2][2],ini[N],head[N],tot,n;
+struct pp
+{
+    int v,next;
+}edge[N*2];
+inline void add(int u,int v)
+{
+    edge[tot].v=v;
+    edge[tot].next=head[u];
+    head[u]=tot++;
+}
+void dfs(int  r,int pre)
+{
+    int clo=ini[r],rev=1-clo;
+    int sum=0,dps[3]={};
+    dps[1]=dps[2]=iinf;
+    ffl(i,r)
+    {
+        int v=edge[i].v;
+        if(v==pre) continue;
+        dfs(v,r);
+        sum+=dp[v][clo][0];
+        dps[2]=Min(dps[1]+dp[v][rev][1],dps[2]+dp[v][rev][0]);
+        dps[1]=Min(dps[0]+dp[v][rev][1],dps[1]+dp[v][rev][0]);
+        dps[0]+=dp[v][rev][0];
+    }
+    dp[r][clo][0]=Minmin(sum,dps[0]+2,dps[1]+2,dps[2]+2);
+    dp[r][clo][1]=Min(dps[1]+1,dps[0]+1);
+    dp[r][rev][0]=Minmin(sum+1,dps[0]+1,dps[1]+1,dps[2]+1);
+    dp[r][rev][1]=Min(dps[0],dps[1]);
+}
+int main()
+{
+    int o=0;
+    while(scanf("%d",&n)==1)
+    {
+        cc(head,-1);
+        tot=0;
+        ff(i,2,n)
+        {
+            int u,v;
+            scanf("%d%d",&u,&v);
+            add(u,v);
+            add(v,u);
+        }
+        ff(i,1,n)
+        scanf("%d",ini+i);
+        dfs(1,-1);
+        printf("Case %d: %d\n",++o,Min(dp[1][0][0],dp[1][1][0]));
+    }
+    return 0;
+}
diff --git a/HDOJ/4385_autoAC.cpp b/HDOJ/4385_autoAC.cpp
new file mode 100644
index 0000000..7747a04
--- /dev/null
+++ b/HDOJ/4385_autoAC.cpp
@@ -0,0 +1,103 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+#define clr(x)memset(x,0,sizeof(x))
+#define min(a,b)(a)<(b)?(a):(b)
+#define INF 0x1f1f1f1f
+#define N 21
+struct node
+{
+    int x,y;
+}p[N],be;
+int dis(node a,node b)
+{
+    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
+}
+int g[N][N];
+int dp[1<<N];
+int pre[1<<N];
+struct ans
+{
+    int fi,se,num;
+}res[N];
+bool cmp(ans a,ans b)
+{
+    return a.fi<b.fi;
+}
+int main()
+{
+    int ca=1,n,i,j,k,t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d %d",&be.x,&be.y);
+        scanf("%d",&n);
+        p[n]=be;
+        for(i=0;i<n;i++)
+            scanf("%d%d",&p[i].x,&p[i].y);
+        memset(dp,INF,sizeof(dp));
+        pre[0]=0;
+        int st=1<<n;
+        dp[0]=0;
+        for(i=0;i<=n;i++)
+            for(j=0;j<=n;j++)
+                g[i][j]=dis(p[i],p[j]);
+        printf("Case %d:\n",ca++);
+        int stat,tmp,ss;
+        for(i=0;i<st;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                if((1<<j)&i)
+                    continue;
+                stat=i|(1<<j);
+                tmp=dp[i]+g[n][j]*2;
+                if(tmp<dp[stat])
+                {
+                    dp[stat]=tmp;
+                    pre[stat]=i;
+                }
+                for(k=j+1;k<n;k++)
+                {
+                    if((1<<k)&i)
+                        continue;
+                    ss=stat|(1<<k);
+                    tmp=dp[i]+g[n][j]+g[j][k]+g[n][k];
+                    if(tmp<dp[ss])
+                    {
+                        dp[ss]=tmp;
+                        pre[ss]=i;
+                    }
+                }
+            }
+        }
+        st-=1;
+        printf("%d\n",dp[st]);
+        int top=0;
+        while(st)
+        {
+            stat=pre[st]^st;
+            st=pre[st];
+            res[top].num=0;
+            for(i=0;i<n;i++)
+                if((1<<i)&stat)
+                {
+                    res[top].num++;
+                    if(res[top].num==1)
+                        res[top].fi=i+1;
+                    else res[top].se=i+1;
+                }
+            top++;
+        }
+        sort(res,res+top,cmp);
+        for(i=0;i<top;i++)
+        {
+            if(res[i].num==1)
+                printf("%d%c",res[i].fi,i==top-1?'\n':' ');
+            else 
+                printf("%d %d%c",res[i].fi,res[i].se,i==top-1?'\n':' ');
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4386_autoAC.cpp b/HDOJ/4386_autoAC.cpp
new file mode 100644
index 0000000..4fe1ddf
--- /dev/null
+++ b/HDOJ/4386_autoAC.cpp
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include<math.h>
+int main()
+{
+      int t;
+      int a,b,c,d,max,count=0;
+      double p,ans;
+      scanf("%d",&t);
+      while(t--)
+      {
+            scanf("%d%d%d%d",&a,&b,&c,&d);
+            if(a>b) max=a;
+            else max=b;
+            if(max<b) max=b;
+            if(max<c) max=c;
+            if(max<d) max=d;
+            if(max-(a+b+c+d-max)>=0)
+            {
+                  printf("Case %d: -1\n",++count);
+                  continue;
+            }
+            p=(a+b+c+d)*1.0/2;
+            ans=sqrt((p-a)*(p-b)*(p-c)*(p-d));
+            printf("Case %d: %.6lf\n",++count,ans);
+      }
+}
diff --git a/HDOJ/4387_autoAC.cpp b/HDOJ/4387_autoAC.cpp
new file mode 100644
index 0000000..8009af3
--- /dev/null
+++ b/HDOJ/4387_autoAC.cpp
@@ -0,0 +1,23 @@
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+int n,k;
+int main(void)
+{
+    int cas = 1;
+    while(scanf("%d %d",&n,&k)!=EOF){
+        printf("Case %d: ",cas++);
+        int r = n - 2 * k;
+        int ans = 1;
+        bool sig = true;
+        if(r&1){
+            if(k == 1) sig = false;
+            else if(r == 1) ans = k;
+        }
+        if(sig)
+            printf("Alice %d\n",ans);
+        else
+            puts("Bob");
+    }
+    return 0;
+}
diff --git a/HDOJ/4388_autoAC.cpp b/HDOJ/4388_autoAC.cpp
new file mode 100644
index 0000000..d7ff5b3
--- /dev/null
+++ b/HDOJ/4388_autoAC.cpp
@@ -0,0 +1,45 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+int getOneNumber(int x)
+{
+    int count = 0;
+    for(int i=0;(1<<i)<=x;++i)
+    {
+        if(x & (1 << i))
+        {
+            ++ count;
+        }
+    }
+    return count;
+}
+int main()
+{
+    int caseNumber;
+    int n, m, a;
+    scanf("%d", &caseNumber);
+    for(int cas=1;cas<=caseNumber;++cas)
+    {
+        scanf("%d", &n);
+        int a = 0;
+        while(n--)
+        {
+            scanf("%d", &m);
+            if(!(getOneNumber(m) & 1))
+            {
+                ++ a;
+            }
+        }
+        printf("Case %d: ", cas);
+        if(a & 1)
+        {
+            printf("Yes\n");
+        }
+        else
+        {
+            printf("No\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4389_autoAC.cpp b/HDOJ/4389_autoAC.cpp
new file mode 100644
index 0000000..1c6d807
--- /dev/null
+++ b/HDOJ/4389_autoAC.cpp
@@ -0,0 +1,5 @@
+Here is a function f(x):
+int f ( int x ) {
+    if ( x == 0 ) return 0;
+    return f ( x / 10 ) + x % 10;
+}
diff --git a/HDOJ/4390_autoAC.cpp b/HDOJ/4390_autoAC.cpp
new file mode 100644
index 0000000..1ceda08
--- /dev/null
+++ b/HDOJ/4390_autoAC.cpp
@@ -0,0 +1,103 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <vector>
+#include <cstring>
+#include <algorithm>
+#include <string>
+#include <set>
+#include <ctime>
+#include <queue>
+#include <map>
+#include <sstream>
+#define CL(arr, val)    memset(arr, val, sizeof(arr))
+#define REP(i, n)       for((i) = 0; (i) < (n); ++(i))
+#define FOR(i, l, h)    for((i) = (l); (i) <= (h); ++(i))
+#define FORD(i, h, l)   for((i) = (h); (i) >= (l); --(i))
+#define L(x)    (x) << 1
+#define R(x)    (x) << 1 | 1
+#define MID(l, r)   (l + r) >> 1
+#define Min(x, y)   x < y ? x : y
+#define Max(x, y)   x < y ? y : x
+#define E(x)    (1 << (x))
+const double eps = 1e-4;
+typedef long long LL;
+const int inf = ~0u>>2;
+using namespace std;
+const int N = 110;
+const int M = 1000010;
+const int MOD = 1e9 + 7;
+int c[N][N];
+int k[M], t[M];
+int num, n;
+int prime[N*20];
+bool vis[N*20];
+int cnt;
+void get_prime() {
+    CL(vis, true);
+    int i, j;
+    for(i = 2; i < N*20; ++i) {
+        for(j = i*i; j < N*20; j += i) {
+            vis[j] = false;
+        }
+    }
+    cnt = 0;
+    for(i = 2; i < N*20; ++i) {
+        if(vis[i])  prime[cnt++] = i;
+    }
+}
+void init() {
+    get_prime();
+    CL(c, 0);
+    int i , j;
+    for(i = 0; i < N; ++i)  c[i][0] = c[i][i] = 1;
+    for(i = 2; i < N; ++i) {
+        for(j = 1; j < i; ++j) {
+            c[i][j] = (c[i-1][j] + c[i-1][j-1])%MOD;
+        }
+    }
+}
+LL solve(int x) {
+    int m = n, flag = 1, i;
+    for(i = 0; i < n; ++i) {
+        if(((1<<i)&x) == 0) {
+            flag *= -1; m--;
+        }
+    }
+    LL tmp = 1;
+    for(i = 0; i < num; ++i) {
+        tmp = tmp*LL(c[k[i]+m-1][m-1])%MOD;
+    }
+    return tmp*flag;
+}
+int main() {
+    init();
+    int x, i, j;
+    LL ans;
+    while(~scanf("%d", &n)) {
+        CL(t, 0);
+        for(i = 0; i < n; ++i) {
+            scanf("%d", &x);
+            for(j = 0; prime[j]*prime[j] <= x; ++j) {
+                if(x%prime[j] == 0) {
+                    while(x%prime[j] == 0) {
+                        t[prime[j]]++; x /= prime[j];
+                    }
+                }
+            }
+            if(x != 1)   t[x]++;
+        }
+        num = 0;
+        for(i = 2; i < M; ++i) {
+            if(t[i] != 0) {
+                k[num++] = t[i];
+            }
+        }
+        ans = 0;
+        for(i = (1<<n)-1; i >= 1; --i) {
+            ans = (ans + solve(i))%MOD;
+        }
+        cout << (ans%MOD + MOD)%MOD << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4391_autoAC.cpp b/HDOJ/4391_autoAC.cpp
new file mode 100644
index 0000000..82e2091
--- /dev/null
+++ b/HDOJ/4391_autoAC.cpp
@@ -0,0 +1,79 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <map>
+using namespace std;
+#define for if(0); else for
+const int N=65537*2;
+struct SegTree{
+    int a[N<<1],mi[N<<1],mx[N<<1];
+    int Q;
+    void init(int n,int c[]){
+        for(Q=1;Q<=n+2;Q<<=1);
+        memset(a,0,sizeof(a));
+        for(int i=Q+0;i<Q+n;i++) a[i]=mi[i]=mx[i]=c[i-Q];
+        for(int i=Q-1;i>=1;i--) pushup(i);
+    }
+    void pushup(int rt) {
+        a[rt]=a[rt<<1]==a[rt<<1|1]?a[rt<<1]:-1;
+        mi[rt]=min(mi[rt<<1],mi[rt<<1|1]);
+        mx[rt]=max(mx[rt<<1],mx[rt<<1|1]);
+    }
+    void update_one(int rt,int x) {
+        a[rt]=mi[rt]=mx[rt]=x;
+    }
+    void pushdown(int rt) {
+        if(a[rt]!=-1) {
+            update_one(rt<<1,a[rt]);
+            update_one(rt<<1|1,a[rt]);
+        }
+    }
+    void update(int L,int R,int l,int r,int rt,int c) {
+        if(a[rt]==c) return;
+        if(L<=l && r<=R) {
+            update_one(rt,c);
+            return;
+        }
+        pushdown(rt);
+        if(rt>=Q) return;
+        int m=(l+r)>>1;
+        if(L<=m) update(L,R,l,m,rt<<1,c);
+        if(m<R) update(L,R,m+1,r,rt<<1|1,c);
+        pushup(rt);
+    }
+    int query(int L,int R,int l,int r,int rt,int c) {
+        int ret=0;
+        if(L<=l && r<=R) {
+            if(c>=mi[rt]&&c<=mx[rt]){
+                int m=(l+r)>>1;
+                if(a[rt]!=-1) return (a[rt]==c)?r-l+1:0;
+                else return query(L,R,l,m,rt<<1,c)+query(L,R,m+1,r,rt<<1|1,c);
+            }else return 0;
+        }
+        if(rt>=Q) return ret;
+        pushdown(rt);
+        int m=(l+r)>>1;
+        if(L<=m) ret+=query(L,R,l,m,rt<<1,c);
+        if(m<R) ret+=query(L,R,m+1,r,rt<<1|1,c);
+        return ret;
+    }
+}st;
+int a[N];
+int n,m;
+int main() {
+    while(scanf("%d%d",&n,&m)!=EOF) {
+        for(int i=0;i<n;i++) scanf("%d",&a[i]);
+        st.init(n,a);
+        for(int i=0;i<m;i++) {
+            int cmd,l,r,c;
+            scanf("%d%d%d%d",&cmd,&l,&r,&c);
+            if(cmd==1){
+                st.update(l,r,0,st.Q-1,1,c);
+            }else {
+                printf("%d\n",st.query(l,r,0,st.Q-1,1,c));
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4392_autoAC.cpp b/HDOJ/4392_autoAC.cpp
new file mode 100644
index 0000000..ae5a5e7
--- /dev/null
+++ b/HDOJ/4392_autoAC.cpp
@@ -0,0 +1,126 @@
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<vector>
+using namespace std;
+const double eps=1e-8;
+int pr[1231];
+struct A{vector<int> a;double s;}e,te;
+struct P{int p[100],n;double s;}p,da;
+long long mx;
+int pt1(A &e,int n){
+    double k=1;
+    for(int i=0;i<n;i++){
+        k*=pow(pr[i]+0.0,e.a[i]+0.0);
+        if(k>p.s*1.00000001)return 0;
+    }
+    return 1;
+}
+void cf(P &p,int k){
+    p.p[p.n]=0;
+    for(int i=0;i<p.n;i++)
+        p.p[i]*=k;
+    for(int i=0;i<p.n;i++)
+        p.p[i+1]+=p.p[i]/10,p.p[i]%=10;
+    while(p.p[p.n]){
+        p.p[p.n+1]=p.p[p.n]/10;
+        p.p[p.n]%=10;
+        p.n++;
+    }
+}
+P qiu(A &a,int n){
+    P p;
+    p.n=1;
+    p.p[0]=1;
+    for(int i=0;i<n;i++)
+        for(int q=0;q<a.a[i];q++)
+            cf(p,pr[i]);
+    return p;
+}
+int pt(P a,P b){
+    if(a.n!=b.n){
+        return a.n<b.n;
+    }
+    for(int i=a.n;i--;){
+        if(a.p[i]!=b.p[i])
+            return a.p[i]<b.p[i];
+    }
+    return 1;
+}
+int s[123],x[123];
+int n;
+long long js(A &e,int n){
+    long long da=1;
+    for(int i=0;i<n;i++)
+        da*=e.a[i]+1;
+    return da;
+}
+void dfs(int rt,A& e,long long k){
+    if(rt>n)return ;
+    if(k>=mx){
+        if(!pt1(e,rt))return ;
+        if(k>mx||(k==mx&& pt(qiu(e,rt),da))){
+            if(!pt(qiu(e,rt),p))return ;
+            mx=k;
+            da=qiu(e,rt);
+        }
+    }
+    int ss=s[rt];
+    if(rt)ss=min(ss,e.a[rt-1]);
+    for(int i=ss;i>=x[rt];i--){
+        e.a[rt]=i;
+        dfs(rt+1,e,k*(e.a[rt]+1));
+    }
+}
+int gs(int k){ return 2*(log(pr[n]+0.0)/log(k+0.0))-1;}
+int gx(int k){ return (log(pr[n]+0.0)/log(k+0.0));}
+void qiu(){
+    for(n=1;;n++){
+        e.a.clear();
+        for(int i=0;i<n;i++)
+            s[i]=gs(pr[i]),x[i]=gx(pr[i]);
+        if(x[0]<3)x[0]=1;
+        for(int i=0;i<n;i++)
+            e.a.push_back(1);
+        if(!pt1(e,n))break;
+    }
+    if(n<15)
+        for(int i=0;i<n;i++)
+            x[i]=1;
+    e.a.clear();
+    for(int i=0;i<n;i++)e.a.push_back(0);
+    dfs(0,e,1);
+}
+int main(){
+    int ind=0;
+    for(int i=2;i<1e3;i++){
+        if(pr[i]==0){
+            pr[ind++]=i;
+            for(int q=i*i;q<1e3;q+=i)
+                pr[q]=1;
+        }
+    }
+    string s;
+    while(cin>>s){
+        if(s=="1"){
+            puts("1 1");
+            continue;
+        }
+        mx=-1;
+        reverse(s.begin(),s.end());
+        p.n=s.size();
+        p.s=0;
+        for(int i=0;i<s.size();i++){
+            p.p[i]=s[i]-'0';
+            p.s+=p.p[i]*pow(10.0,i);
+        }
+        qiu();
+        p=da;
+        for(int i=p.n;i--;)
+            cout<<p.p[i];
+        cout<<' '<<mx;cout<<endl;
+    }
+}
diff --git a/HDOJ/4393_autoAC.cpp b/HDOJ/4393_autoAC.cpp
new file mode 100644
index 0000000..7e4dd20
--- /dev/null
+++ b/HDOJ/4393_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<iostream>
+#include<algorithm>
+#include<set>
+#include<map>
+#include<queue>
+#include<vector>
+#include<string>
+#define Min(a,b) a<b?a:b
+#define Max(a,b) a>b?a:b
+#define CL(a,num) memset(a,num,sizeof(a));
+#define maxn  60100
+#define eps  1e-6
+#define inf 9999999
+using namespace std;
+struct node
+{
+    int f;
+    int s;
+    int id;
+}p[maxn] ;
+int vis[maxn];
+int cmp(const node a,const node b)
+{
+    if( a.s != b.s) return a.s > b.s;
+    else
+       if(a.f != b.f) return a.f > b.f ;
+       else
+        return a.id < b.id;
+}
+int main()
+{
+    int t,i,j,n,k,cnt;
+    int cas = 0 ;
+    scanf("%d",&t);
+    while(t--)
+    {
+        memset(vis,0,sizeof(vis));
+          int mx = -1;
+      scanf("%d",&n);
+      for(i = 1;i <=n;i++ )
+      {
+          scanf("%d%d",&p[i].f,&p[i].s);
+          p[i].id = i;
+          if(mx < p[i].f)
+          {
+              mx = p[i].f ;
+              k  = i;
+          }
+     }
+      printf("Case #%d:\n",++cas);
+      printf("%d",k);
+      vis[k] = 1 ;
+      if(n > 510)cnt = 510;
+      else cnt = n;
+      for(i = 1;i <= cnt - 1;i++)
+      {
+          mx = -1;
+          for(j = 1;j <= n;j++)
+          {
+              if(!vis[j])
+              {
+                  p[j].f +=p[j].s;
+                  if(mx < p[j].f)
+                  {
+                      k = j;
+                      mx = p[j].f;
+                  }
+              }
+          }
+          printf(" %d",k);
+          vis[k] = 1;
+      }
+      if(cnt < n)
+      {
+          sort(p + 1,p+1+n,cmp);
+          for(i = 1; i <= n;i++)
+          {
+              if(!vis[p[i].id])
+              {
+                  printf(" %d",p[i].id);
+                  vis[p[i].id] = 1;
+              }
+          }
+      }
+      printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4394_autoAC.cpp b/HDOJ/4394_autoAC.cpp
new file mode 100644
index 0000000..9a11703
--- /dev/null
+++ b/HDOJ/4394_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<stdio.h>
+__int64 T,n,tag;
+__int64 ans,mod[11]={0,1},dig[11];
+__int64 i,j,k,t;
+struct node
+{
+    __int64 id,val;
+}que[100000001];
+__int64 wei(__int64 x)
+{
+    __int64 z=1;
+    if(!x) return 0;
+    while(x/=10) z++;
+    return z;
+}
+__int64 cmp(__int64 a, __int64 b, __int64 k)
+{
+    while(k--)
+    {
+        if(a%10!=b%10) return 0;
+        a/=10;b/=10;
+    }
+    return 1;
+}
+__int64 bfs(__int64 x)
+{
+    __int64 t=0,pop=0,push=1,i,j,bl,ans,sw,k=0;
+    que[0].id=que[0].val=0;ans=sw=0x7fffffff;
+    while(pop<push)
+    {
+        t=que[pop].val;
+        k=que[pop++].id+1;
+        if(cmp(t*t,x,wei(x))) 
+        {
+            ans=t<ans?t:ans;
+            sw=wei(ans);
+        }
+        if(wei(t)>=wei(x)) return 0;
+        if(k>sw) continue;
+        for(i=0;i<10;i++)
+        {
+            if(cmp((i*mod[k]+t)*(i*mod[k]+t),x%mod[k+1],k))
+            {
+                if(cmp((i*mod[k]+t)*(i*mod[k]+t),x,wei(x)))
+                {
+                    ans=(i*mod[k]+t)<ans?(i*mod[k]+t):ans;
+                    sw=wei(ans);
+                    continue;
+                }
+                if(k>=sw) continue;
+                que[push].val=i*mod[k]+t;
+                que[push++].id=k;
+            }
+        }
+    }
+    if(ans==0x7fffffff) return 0;
+    return ans;
+}
+int main()
+{
+    scanf("%I64d",&T);
+    for(i=2;i<=10;i++) mod[i]=mod[i-1]*10;
+    while(T--)
+    {
+        scanf("%I64d",&tag);
+        ans=bfs(tag);
+        if(ans) printf("%I64d\n",ans);
+        else printf("None\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4395_autoAC.cpp b/HDOJ/4395_autoAC.cpp
new file mode 100644
index 0000000..7da7404
--- /dev/null
+++ b/HDOJ/4395_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+const int N = 2e5 + 2e4;
+const int shift = 2e5;
+bool reach[N];
+int w[205];
+inline int read(){
+    double x;
+    scanf("%lf",&x);
+    if(x > 0)
+        return x * 10000 + 1e-8;
+    else
+        return x * 10000 - 1e-8;
+}
+int main()
+{
+    int T,n;
+    scanf("%d",&T);
+    while(T--)
+    {
+        memset(reach,false,sizeof(reach));
+        int goal = read();
+        scanf("%d",&n);
+        for(int i=0;i<n;i++)
+            w[i] = read();
+        sort(w,w+n);
+        reach[ 0 + shift ] = true;
+        for(int i=0;i<n;i++)
+        {
+            bool f = w[i] > 0;
+            if(f)
+            {
+                for(int j=N-1-w[i];j>=0;j--)
+                    if(reach[j])
+                        reach[ j + w[i] ] = true;
+            }
+            else
+            {
+                for(int j=-w[i];j<N;j++)
+                    if(reach[j])
+                        reach[ j + w[i] ] = true;
+            }
+        }
+        int i = goal + shift , j = 0;
+        int ans = -1;
+        while(1)
+        {
+            if(i-j >= 0 && reach[i-j])
+            {
+                ans = i - j;
+                break;
+            }
+            if(i+j < N && reach[i+j])
+            {
+                ans = i + j;
+                break;
+            }
+            ++j;
+        }
+        printf("%.4f\n",(ans-shift)/10000.0);
+    }
+    return 0;
+}
diff --git a/HDOJ/4396_autoAC.cpp b/HDOJ/4396_autoAC.cpp
new file mode 100644
index 0000000..ee1c3ae
--- /dev/null
+++ b/HDOJ/4396_autoAC.cpp
@@ -0,0 +1,86 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <queue>
+using namespace std;
+typedef long long ll;
+const int N = 5005;
+const int M = 200005;
+const int NN = 505;
+const int Lum = 10;
+const int INF = 0x3f3f3f3f;
+int vis[N][NN], d[N][NN], en;
+int head[M];
+int n, m, s, t, k;
+struct node {  
+    int to, dis, next;  
+}edge[M];  
+void addEdge(int u,int v,int x) {  
+    edge[en].to = v;  
+    edge[en].next = head[u];  
+    edge[en].dis = x;  
+    head[u] = en++;  
+    edge[en].to = u;  
+    edge[en].next = head[v];  
+    edge[en].dis = x;  
+    head[v] = en++;  
+}  
+struct Node{
+    int u, m;
+};
+void SPFA() {  
+    queue<Node> Q;  
+    for(int i = 1; i <= n; i++) {  
+        for (int j = 0; j <= NN; j++) {
+            d[i][j] = INF;  
+            vis[i][j] = 0;  
+        }
+    }  
+    d[s][0] = 0;  
+    vis[s][0] = 1;  
+    Q.push((Node){s, 0});  
+    while(!Q.empty()) {  
+        int u = Q.front().u;  
+        int m = Q.front().m;
+        vis[u][m] = 0;  
+        Q.pop();  
+        int temp = m + Lum;
+        if (temp >= NN) continue;
+        if (temp > k) temp = k;
+        for(int i = head[u]; i != -1; i = edge[i].next) {  
+            int v = edge[i].to;  
+            if(d[u][m] + edge[i].dis < d[v][temp]) {  
+                d[v][temp] = d[u][m] + edge[i].dis;  
+                if(!vis[v][temp]) {  
+                    Q.push((Node){v, temp});  
+                    vis[v][temp] = 1;  
+                }  
+            }  
+        }  
+    }  
+} 
+void input() {
+    int u, v, c;
+    for (int i = 0; i < m; i++) {
+        scanf("%d %d %d", &u, &v, &c);  
+        addEdge(u, v, c);
+    }   
+    scanf("%d %d %d", &s, &t, &k);
+}
+int main() {
+    while (scanf("%d %d", &n, &m) == 2) {
+        en = 0;
+        memset(head, -1, sizeof(head));
+        input();    
+        if (k % 10) {
+            k = 10 * ((k / 10) + 1);
+        }
+        SPFA();
+        if (d[t][k] == INF) {
+            printf("-1\n"); 
+        } else printf("%d\n", d[t][k]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4397_autoAC.cpp b/HDOJ/4397_autoAC.cpp
new file mode 100644
index 0000000..c869440
--- /dev/null
+++ b/HDOJ/4397_autoAC.cpp
@@ -0,0 +1,159 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+#include <queue>
+using namespace std;
+struct node{
+    int a[59];
+    void init()
+    {
+        for(int i=0;i<59;i++) a[i]=i;
+    }
+    void chface(int a0,int a1,int a2,int a3,int a4,int a5,int a6,int a7,int a8)
+    {
+        int tmp= a[a0];
+        a[a0]=a[a6],a[a6]=a[a8],a[a8]=a[a2],a[a2]=tmp;
+        tmp = a[a1];
+        a[a1]=a[a3],a[a3]=a[a7],a[a7]=a[a5],a[a5]=tmp;
+    }
+    void chline(int a0,int a1,int a2,int a3,int a4,int a5,int a6,int a7,int a8,int a9,int a10,int a11)
+    {
+        int tmp = a[a0];
+        a[a0]=a[a9],a[a9]=a[a6],a[a6]=a[a3],a[a3]=tmp;
+        tmp = a[a1];
+        a[a1]=a[a10],a[a10]=a[a7],a[a7]=a[a4],a[a4]=tmp;
+        tmp = a[a2];
+        a[a2]=a[a11],a[a11]=a[a8],a[a8]=a[a5],a[a5]=tmp;
+    }
+    bool check()
+    {
+        for(int i=0;i<59;i++)
+        if(a[i]!=i) return false;
+        return true;
+    }
+    void U()
+    {
+        chface(36,37,38, 39,40,41, 42,43,44);
+        chline(2,1,0, 29,28,27, 20,19,18 ,11,10,9);
+    }
+    void u()
+    {
+        chface(38,37,36, 41,40,39, 44,43,42);
+        chline(9,10,11,18,19,20,27,28,29,0,1,2);
+    }
+    void R()
+    {
+        chface(9,10,11,12,13,14,15,16,17);
+        chline(44,41,38,18,21,24,53,50,47,8,5,2);
+    }
+    void r()
+    {
+        chface(11,10,9, 14,13,12, 17,16,15);
+        chline(2,5,8,47,50,53,24,21,18,38,41,44);
+    }
+    void F()
+    {
+        chface(0,1,2,3,4,5,6,7,8);
+        chline(42,43,44 ,9,12,15, 47,46,45, 35,32,29);
+    }
+    void f()
+    {
+        chface(2,1,0, 5,4,3, 8,7,6);
+        chline(29,32,35,45,46,47,15,12,9,44,43,42);
+    }
+    void D()
+    {
+        chface(45,46,47,48,49,50,51,52,53);
+        chline(6,7,8 ,15,16,17, 24,25,26, 33,34,35);
+    }
+    void d()
+    {
+        chface(47,46,45, 50,49,48, 53,52,51);
+        chline(35,34,33,26,25,24,17,16,15,8,7,6);
+    }
+    void L()
+    {
+        chface(27,28,29,30,31,32,33,34,35);
+        chline(0,3,6, 45,48,51, 26,23,20, 36,39,42);
+    }
+    void l()
+    {
+        chface(29,28,27,32,31,30,35,34,33);
+        chline(42,39,36,20,23,26,51,48,45,6,3,0);
+    }
+    void B()
+    {
+        chface(18,19,20,21,22,23,24,25,26);
+        chline(38,37,36, 27,30,33, 51,52,53, 17,14,11);
+    }
+    void b()
+    {
+        chface(20,19,18, 23,22,21,26,25,24);
+        chline(11,14,17,53,52,51,33,30,27,36,37,38);
+    }
+    void X()
+    {
+        chline(5,4,3, 32,31,30, 23,22,21, 14,13,12);
+    }
+    void x()
+    {
+        chline(12,13,14,21,22,23,30,31,32,3,4,5);
+    }
+    void Y()
+    {
+        chline(7,4,1, 43,40,37, 19,22,25, 52,49,46);
+    }
+    void y()
+    {
+        chline(46,49,52,25,22,19,37,40,43,1,4,7);
+    }
+    void Z()
+    {
+        chline(41,40,39,28,31,34, 48,49,50, 16,13,10);
+    }
+    void z()
+    {
+        chline(10,13,16,50,49,48,34,31,28,39,40,41);
+    }
+};
+int main()
+{
+    char a[2009];
+    node t;
+    bool ou = false;
+    while(~scanf("%s",a))
+    {
+        if(ou) printf("\n");
+        ou = true;
+        t.init();
+        int len = strlen(a);
+        for(int i=0;i<len;i++)
+        {
+            if(a[i]=='U') t.U();
+            else if(a[i]=='R') t.R();
+            else if(a[i]=='F') t.F();
+            else if(a[i]=='D') t.D();
+            else if(a[i]=='L') t.L();
+            else if(a[i]=='B') t.B();
+            else if(a[i]=='X') t.X();
+            else if(a[i]=='Y') t.Y();
+            else if(a[i]=='Z') t.Z();
+            else if(a[i]=='u') t.u();
+            else if(a[i]=='r') t.r();
+            else if(a[i]=='f') t.f();
+            else if(a[i]=='d') t.d();
+            else if(a[i]=='l') t.l();
+            else if(a[i]=='b') t.b();
+            else if(a[i]=='x') t.x();
+            else if(a[i]=='y') t.y();
+            else if(a[i]=='z') t.z();
+        }
+        if(t.check())
+        printf("Yes\n");
+        else
+        printf("No\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4398_autoAC.cpp b/HDOJ/4398_autoAC.cpp
new file mode 100644
index 0000000..600eb28
--- /dev/null
+++ b/HDOJ/4398_autoAC.cpp
@@ -0,0 +1,88 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<algorithm>
+#include<queue>
+#include<map>
+#include<set>
+using namespace std;
+const int MAXN=100010;
+int Ti[MAXN];
+int ne[MAXN];
+map<int,int>mp;
+struct Node
+{
+    int next_id;
+    int ti;
+};
+struct classcomp
+{
+    bool operator()(const Node &a,const Node &b)const
+    {
+        return a.next_id<b.next_id;
+    }
+};
+multiset<Node,classcomp>T_info;
+multiset<Node>::iterator it_n;
+set<int>Te;
+set<int>::iterator it;
+int main()
+{
+    int n,m;
+    while(scanf("%d%d",&n,&m)==2)
+    {
+        for(int i=1;i<=n;i++)
+          scanf("%d",&Ti[i]);
+        mp.clear();
+        for(int i=n;i>=1;i--)
+        {
+            if(mp[Ti[i]])
+               ne[i]=mp[Ti[i]];
+            else ne[i]=n+1;
+            mp[Ti[i]]=i;
+        }
+        Te.clear();
+        T_info.clear();
+        for(int i=1;i<=m;i++)
+        {
+            if(!mp[i])mp[i]=n+1;
+            Node temp;
+            temp.next_id=mp[i];
+            temp.ti=i;
+            T_info.insert(temp);
+            Te.insert(i);
+        }
+        int ans=0;
+        for(int i=1;i<=n;i++)
+        {
+            it=Te.find(Ti[i]);
+            if(it!=Te.end())
+            {
+                Node temp;
+                temp.next_id=i;
+                temp.ti=Ti[i];
+                T_info.erase(temp);
+                temp.next_id=ne[i];
+                T_info.insert(temp);
+            }
+            else
+            {
+                ans++;
+                it_n=T_info.end();
+                it_n--;
+                if(ne[i]<(*it_n).next_id)
+                {
+                    Te.erase((*it_n).ti);
+                    T_info.erase(it_n);
+                    Te.insert(Ti[i]);
+                    Node temp;
+                    temp.next_id=ne[i];
+                    temp.ti=Ti[i];
+                    T_info.insert(temp);
+                }
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4400_autoAC.cpp b/HDOJ/4400_autoAC.cpp
new file mode 100644
index 0000000..63f421a
--- /dev/null
+++ b/HDOJ/4400_autoAC.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <cstdio>
+#include <cmath>
+#include <string>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+using namespace std;
+const int maxn = 110005;
+const int inf = 2000000005;
+struct NODE{
+    int y, dis;
+    NODE(){
+    }
+    NODE(int _y, int _dis){
+        y = _y; dis = _dis;
+    }
+    bool operator <(const NODE &tmp)const{
+        if(y == tmp.y) return dis < tmp.dis;
+        return y < tmp.y;
+    }
+};
+struct POINT{
+    int x, y, dis;
+    POINT() {
+    }
+    POINT(int _x, int _y, int _dis){
+        x = _x;
+        y = _y;
+        dis = _dis;
+    }
+}df[maxn], myque[1111111];
+int n, m, has[maxn], num;
+vector<NODE>mygraph[maxn];
+void init(){
+    num = 0;
+    for(int i = 0; i < maxn; i++) mygraph[i].clear();
+}
+void readdata(){
+    for(int i = 1; i <= n ; i++){
+        scanf("%d%d%d", &df[i].x, &df[i].y, &df[i].dis);
+        has[num++] = df[i].x;
+    }
+    sort(has, has + num);
+    num = unique(has, has + num) - has;
+    for(int i = 1; i <= n; i++){
+        int id = lower_bound(has, has + num, df[i].x) - has;
+        mygraph[id].push_back(NODE(df[i].y, df[i].dis));
+    }
+}
+int fuckit(int fuckid){
+    int head = 0, tail = 0, ret = 0;
+    vector<NODE>::iterator vectoriterator1, vectoriterator2, tmpvectoriterator;
+    myque[tail++] = POINT(df[fuckid].x, df[fuckid].y, df[fuckid].dis);
+    while(head < tail){
+        POINT now = myque[head++];
+        int pos1 = lower_bound(has, has + num, now.x - now.dis) - has;
+        int pos2 = upper_bound(has, has + num, now.x + now.dis) - has;
+        for(; pos1 != pos2; pos1++){
+            int fucknum = has[pos1];
+            int fucky = now.dis - abs(fucknum - now.x);
+            int id = lower_bound(has, has + num, fucknum) - has;
+            vectoriterator1 = lower_bound(mygraph[id].begin(), mygraph[id].end(), NODE(now.y - fucky, -1));
+            vectoriterator2 = upper_bound(mygraph[id].begin(), mygraph[id].end(), NODE(now.y + fucky, inf));
+            tmpvectoriterator = vectoriterator1;
+            for(; vectoriterator1 != vectoriterator2; vectoriterator1++){
+                NODE tmp  = *vectoriterator1;
+                myque[tail++] = POINT(fucknum, tmp.y, tmp.dis);
+                ret++;
+            }
+            mygraph[id].erase(tmpvectoriterator, vectoriterator2);
+        }
+    }
+    return ret;
+}
+int main(){
+    int testcases = 0;
+    while(scanf("%d", &n) != EOF && n){
+        init();
+        readdata();
+        printf("Case #%d:\n", ++testcases);
+        for(int i = 0; i < num; i++) {
+            sort(mygraph[i].begin(), mygraph[i].end());
+        }
+        scanf("%d", &m);
+        for(int i = 1; i <= m; i++){
+            int k;
+            scanf("%d", &k);
+            int sum = fuckit(k);;
+            printf("%d\n", sum);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4401_autoAC.cpp b/HDOJ/4401_autoAC.cpp
new file mode 100644
index 0000000..9b2f486
--- /dev/null
+++ b/HDOJ/4401_autoAC.cpp
@@ -0,0 +1,111 @@
+ #include <iostream>
+ #include <cstdio>
+ #include <cstring>
+ #include <cmath>
+ #include <algorithm>
+ #define PI acos(-1.0)
+ using namespace std;
+ struct Node
+ {
+     double h,x;
+ };
+ Node a[1005],b[1005],st[1005];
+ double L;
+ int n,T1,T2,top;
+ inline int DB(double x)
+ {
+     if(x>1e-10) return 1;
+     if(x<-1e-10) return -1;
+     return 0;
+ }
+ double cal1(Node a,Node b)
+ {
+     double k=(a.h-b.h)/(a.x-b.x);
+     double x=a.x-a.h/k;
+     return x;
+ }
+ double cal2(double x1,double x2,double h,int t)
+ {
+     double a=sqrt(h*h+x2*x2)-sqrt(h*h+x1*x1);
+     double b=(x2-x1)*cos(PI/12.0*t);
+     double c=12.0/PI;
+     return c*(a-b);
+ }
+ double cal(double x1,double x2,double h,int t)
+ {
+     double B1,B2,B3;
+     if(DB(x1)==0) B1=PI/2;
+     else B1=atan(fabs(h/x1));
+     B2=atan(fabs(h/x2));
+     B3=PI/12*t;
+     if(DB(B3-B1)>=0) return cal2(x1,x2,h,t);
+     if(DB(B2-B3)>=0) return 0;
+     double k=-tan(B3);
+     return cal2(-h/k,x2,h,t);
+ }
+ int OK(Node a,Node b,Node c)
+ {
+     double k1=(a.h-b.h)/(a.x-b.x);
+     double k2=(b.h-c.h)/(b.x-c.x);
+     if(DB(k1-k2)==-1) return 1;
+     return 0;
+ }
+ double solve(int t,Node a[])
+ {
+     top=0;
+     st[++top]=a[1];
+     double ans=0;
+     int i,j;
+     double x1,x2;
+     for(i=2;i<=n;i++)
+     {
+         x1=a[i-1].x;
+         x2=a[i-1].x;
+         for(j=top;j>=2;j--)
+         {
+             x2=cal1(st[j-1],st[j]);
+             if(DB(x2-a[i].x)>=0) break;
+             ans+=cal(x1-st[j].x,x2-st[j].x,st[j].h,t);
+             x1=x2;
+         }
+         ans+=cal(x1-st[j].x,a[i].x-st[j].x,st[j].h,t);
+         while(top>=2&&OK(st[top-1],st[top],a[i])||top>=1&&DB(a[i].h-st[top].h)>=0)
+              top--;
+         st[++top]=a[i];
+     }
+     return ans;
+ }
+ int cmp(Node a,Node b)
+ {
+     return a.x<b.x;
+ }
+ double deal(int t)
+ {
+     double ans=0;
+     int i;
+     for(i=1;i<=n;i++)
+     {
+         b[i]=a[n+1-i];
+         b[i].x=L-b[i].x;
+     }
+     double xx,yy,zz;
+     if(t<=6) ans=solve(t,a);
+     else
+     {
+         ans=solve(6,a);
+         ans+=solve(6,b)-solve(12-t,b);
+     }
+     return ans;
+ }
+ int main()
+ {
+     while(scanf("%lf%d",&L,&n),n||L)
+     {
+         scanf("%d%d",&T1,&T2);
+         int i;
+         for(i=1;i<=n;i++) scanf("%lf%lf",&a[i].x,&a[i].h);
+         sort(a+1,a+n+1,cmp);
+         printf("%.5lf\n",deal(T2-6)-deal(T1-6));
+     }
+     return 0;
+ }
diff --git a/HDOJ/4403_autoAC.cpp b/HDOJ/4403_autoAC.cpp
new file mode 100644
index 0000000..c9bdc08
--- /dev/null
+++ b/HDOJ/4403_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <iostream>
+#include <queue>
+#include <cstring>
+#include <cstdio>
+using namespace std;
+char seq[50];
+char str[50];
+int n,ans,eq;
+bool ok(int len)
+{
+    long long a,sum=0;
+    int i,flg=1;
+    queue<char> q;
+    q.push('+');
+    seq[len]='\0';
+    for(i=0; i<len; i++)
+    {
+        a=0;
+        while(i<=len&&seq[i]>='0'&&seq[i]<='9') a=a*10+seq[i]-'0',i++;
+        q.push(seq[i]);
+        if(flg&&q.front()=='+')
+            sum+=a;
+        else
+            flg=0,sum-=a;
+        q.pop();
+    }
+    if(sum==0) return 1;
+    else return 0;
+}
+void dfs(int cur,int q)
+{
+    if(eq>1) return;
+    if(q>n)
+    {
+        if(ok(cur)) ans++;
+        return;
+    }
+    seq[cur]=str[q];
+    dfs(cur+1,q+1);
+    seq[cur]='+';
+    seq[cur+1]=str[q];
+    dfs(cur+2,q+1);
+    seq[cur]='=';
+    seq[cur+1]=str[q];
+    eq++;
+    dfs(cur+2,q+1);
+    eq--;
+}
+int main()
+{
+    while(cin>>str,str[0]!='E')
+    {
+        ans=0;eq=0;
+        seq[0]=str[0];
+        n=strlen(str)-1;
+        dfs(1,1);
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4404_autoAC.cpp b/HDOJ/4404_autoAC.cpp
new file mode 100644
index 0000000..1ff4e59
--- /dev/null
+++ b/HDOJ/4404_autoAC.cpp
@@ -0,0 +1,69 @@
+#include<cstdio>
+#include<iostream>
+#include<cmath>
+#include<cstring>
+using namespace std;
+const double Pi=acos(-1.0);
+const double EP=1e-10;
+struct Point{
+    double x,y;
+};
+double x_mult(Point sp, Point ep, Point op){
+    return (sp.x-op.x)*(ep.y-op.y)-(sp.y-op.y)*(ep.x-op.x);
+}
+double cross(Point a,Point b,Point c){
+    return (a.x-c.x)*(b.x-c.x)+(a.y-c.y)*(b.y-c.y);
+}
+double dist(Point a,Point b){
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+double cal_area(Point a,Point b,Point c,double r){
+    double A,B,C,x,y,tS;
+    A=dist(b,c);
+    B=dist(a,c);
+    C=dist(b,a);
+    if(A<r&&B<r)
+    return x_mult(a,b,c)/2;
+    else if(A<r&&B>=r){
+        x=(cross(a,c,b)+sqrt(r*r*C*C-x_mult(a,c,b)*x_mult(a,c,b)))/C;
+        tS=x_mult(a,b,c)/2;
+        return asin(tS*(1-x/C)*2/r/B*(1-EP))*r*r/2+tS*x/C;
+    }
+    else if(A>=r&&B<r){
+        y=(cross(b,c,a)+sqrt(r*r*C*C-x_mult(b,c,a)*x_mult(b,c,a)))/C;
+        tS=x_mult(a,b,c)/2;
+        return asin(tS*(1-y/C)*2/r/A*(1-EP))*r*r/2+tS*y/C;
+    }
+    else if(fabs(x_mult(a,b,c))>=r*C||cross(b,c,a)<=0||cross(a,c,b)<=0){
+        if(cross(a,b,c)<0)
+            if(x_mult(a,b,c)<0)
+                return (-acos(-1.0)-asin(x_mult(a,b,c)/A/B*(1-EP)))*r*r/2;
+            else return (acos(-1.0)-asin(x_mult(a,b,c)/A/B*(1-EP)))*r*r/2;
+        else return asin(x_mult(a,b,c)/A/B*(1-EP))*r*r/2;
+    }
+    else{
+        x=(cross(a,c,b)+sqrt(r*r*C*C-x_mult(a,c,b)*x_mult(a,c,b)))/C;
+        y=(cross(b,c,a)+sqrt(r*r*C*C-x_mult(b,c,a)*x_mult(b,c,a)))/C;
+        tS=x_mult(a,b,c)/2;
+        return (asin(tS*(1-x/C)*2/r/B*(1-EP))+asin(tS*(1-y/C)*2/r/A*(1-EP)))*r*r/2+tS*((y+x)/C-1);
+    }
+}
+int main(){
+    Point p[105],cir;
+    double r,area, x0, y0, v, angle, t, g;
+    int i, n;
+    while(scanf("%lf%lf%lf%lf%lf%lf%lf", &x0, &y0, &v, &angle, &t, &g, &r)!=EOF){
+        if(fabs(x0)+fabs(y0)+fabs(v)+fabs(angle)+fabs(t)+fabs(g)+
+           fabs(r)<0.0000001)break;
+        scanf("%d", &n);
+        for(i=0; i<n; i++)
+        scanf("%lf%lf", &p[i].x, &p[i].y);
+        area=0;cir.x=x0+v*cos(angle/180.0*Pi)*t;
+        cir.y=y0+v*sin(angle/180.0*Pi)*t-0.5*g*t*t;
+        for(i=0;i<n;i++){
+            area+=cal_area(p[i], p[(i+1)%n], cir, r);
+        }
+        printf("%.2f\n",fabs(area));
+    }
+    return 0;
+}
diff --git a/HDOJ/4405_autoAC.cpp b/HDOJ/4405_autoAC.cpp
new file mode 100644
index 0000000..2744f65
--- /dev/null
+++ b/HDOJ/4405_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+const int N=100005;
+struct node
+{
+    int y,next;
+};
+bool vis[N];
+node path[N];
+int first[N],t;
+double dp[N];
+void add(int x,int y)
+{
+    path[t].y=y;
+    path[t].next=first[x];
+    first[x]=t++;
+}
+int main()
+{
+    double s;
+    int n,m,v;
+    while(cin>>n>>m)
+    {
+        if(m==0&&n==0) break;
+        memset(dp,0,sizeof(dp));
+        memset(vis,0,sizeof(vis));
+        memset(first,0,sizeof(first));
+        int x,y;
+        t=1;
+        while(m--)
+        {
+            cin>>x>>y;
+            add(y,x);
+        }
+        dp[n]=-1;
+        for(int i=n; i>=0; i--)
+        {
+            if(!vis[i])
+            {
+                vis[i]=true;
+                s=0;
+                for(int k=1; k<=6; k++)
+                    s+=dp[i+k];
+                s/=6;
+                dp[i]+=(s+1);
+            }
+            for(int k=first[i]; k; k=path[k].next)
+            {
+                v=path[k].y;
+                dp[v]=dp[i];
+                vis[v]=true;
+            }
+        }
+        printf("%.4lf\n",dp[0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4406_autoAC.cpp b/HDOJ/4406_autoAC.cpp
new file mode 100644
index 0000000..cac2168
--- /dev/null
+++ b/HDOJ/4406_autoAC.cpp
@@ -0,0 +1,142 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+#include <algorithm>
+#include <cmath>
+#include <stack>
+#include <vector>
+#include <string>
+#include <set>
+#define LL long long
+#define myabs(x) ((x)>0?(x):(-(x)))
+using namespace std;
+const int inf=0x3f3f3f3f;
+const double tinf=100000;
+const int maxn=100;
+const int maxm=1500*2;
+struct Edge
+{
+    int from,to,next;
+    double val,cap,flow;
+};
+Edge e[maxm];
+int head[maxn];
+int cre[maxn],bas[maxn],vis[maxn];
+double dis[maxn],score[110];
+int p[maxn];
+int n,kin,m,tot,s,t;
+void addedge(int from,int to,double cap,double val)
+{
+    e[tot].from=from; e[tot].to=to;
+    e[tot].cap=cap; e[tot].flow=0;
+    e[tot].val=val;
+    e[tot].next=head[from];
+    head[from]=tot++;
+    e[tot].from=to; e[tot].to=from;
+    e[tot].cap=0; e[tot].flow=0;
+    e[tot].next=head[to];
+    e[tot].val=-val;
+    head[to]=tot++;
+}
+double mfmc()
+{
+    queue<int> q;
+    int f;
+    double sum=0;
+    int i;
+    for(;;)
+    {
+        for(i=s;i<=t;i++) dis[i]=-inf;
+        memset(vis,0,sizeof(vis));
+        dis[s]=0;
+        vis[s]=1;
+        q.push(s);
+        int i,v;
+        while(!q.empty())
+        {
+            f=q.front(); q.pop();
+            vis[f]=0;
+            for(i=head[f];i!=-1;i=e[i].next)
+            {
+                v=e[i].to;
+                if(e[i].cap>e[i].flow&&dis[f]+e[i].val>dis[v])
+                {
+                    p[v]=i;
+                    dis[v]=dis[f]+e[i].val;
+                    if(!vis[v])
+                    {
+                        vis[v]=1;
+                        q.push(v);
+                    }
+                }
+            }
+        }
+        if(dis[t]<=0) break;
+        double a=(double)inf;
+        for(i=t;i!=s;)
+        {
+            a=min(a,e[p[i]].cap-e[p[i]].flow);
+            i=e[p[i]].from;
+        }
+        sum+=a*dis[t];
+        for(i=t;i!=s;)
+        {
+            e[p[i]].flow+=a;
+            e[p[i]^1].flow-=a;
+            i=e[p[i]].from;
+        }
+    }
+    return sum;
+}
+int main()
+{
+    int i;
+    for(i=60;i<=100;i++) score[i]=4.0-3.0*(100-i)*(100-i)/1600;
+    while(~scanf("%d%d%d",&n,&kin,&m))
+    {
+        if(!n&&!kin&&!m) break;
+        memset(head,-1,sizeof(head));
+        int j,k,tem;
+        s=0; t=n+m+1;
+        tot=0;
+        double w=0,basic=0,sum=0;
+        for(i=1;i<=m;i++)
+        {
+            scanf("%d",&cre[i]);
+            w+=cre[i];
+        }
+        for(i=1;i<=m;i++)
+        {
+            scanf("%d",&bas[i]);
+            if(bas[i]<60)
+            {
+                addedge(0,i,60-bas[i],tinf);
+                sum=sum+(60-bas[i])*tinf;
+                bas[i]=60;
+            }
+            basic=basic+score[bas[i]]*cre[i];
+            for(j=bas[i]+1;j<=100;j++)
+                addedge(0,i,1,(score[j]-score[j-1])*cre[i]);
+        }
+        for(i=1;i<=n;i++)
+        {
+            for(j=1;j<=m;j++)
+            {
+                scanf("%d",&tem);
+                if(tem)
+                    addedge(j,m+i,inf,0);
+            }
+        }
+        for(i=m+1;i<t;i++)
+            addedge(i,t,kin,0);
+        double ans=mfmc();
+        if(ans>=sum)
+        {
+            ans=(basic+(ans-sum))/w;
+            printf("%.6lf\n",ans);
+        }
+        else printf("0.000000\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4407_autoAC.cpp b/HDOJ/4407_autoAC.cpp
new file mode 100644
index 0000000..6d8f931
--- /dev/null
+++ b/HDOJ/4407_autoAC.cpp
@@ -0,0 +1,98 @@
+#include <map>
+#include <stdio.h>
+typedef __int64 LL;
+using namespace std;
+#define N 650
+bool np[N];
+int prime[120],fac[9],F_top,p;
+LL ans;
+void get_prime()
+{
+    int top = -1;
+    for(int i=2;i<N;i++)
+        if(!np[i])
+        {
+            prime[++top] = i;
+            for(int j=i+i;j<N;j+=i)
+                np[j] = true;
+        }
+}
+void Div(int n)
+{
+    F_top = 0;
+    for(int i=0;prime[i]*prime[i]<=n;i++)
+    {
+        if(n % prime[i])
+            continue;
+        while(n % prime[i] == 0)
+            n /= prime[i];
+        fac[F_top++] = prime[i];
+    }
+    if(n != 1)
+        fac[F_top++] = n;
+}
+LL PreSum(int n)
+{
+    return (LL)n*(n+1)/2;
+}
+void dfs(int i,int cnt,int m,int n,int num,int x)       
+{
+    if(cnt == m)
+    {
+        LL sum = num * PreSum(x/num);
+        m&1 ? ans -= sum : ans += sum;
+        return ;
+    }
+    if(num*fac[i] > x || n-i < m-cnt)
+        return ;
+    dfs(i+1,cnt+1,m,n,num*fac[i],x);
+    dfs(i+1,cnt,m,n,num,x);
+}
+LL sovle(int n)
+{
+    ans = PreSum(n);
+    for(int m=1;m<=F_top;m++)
+        dfs(0,0,m,F_top,1,n);
+    return ans;
+}
+int gcd(int a,int b)
+{
+    return b ? gcd(b,a%b) : a;
+}
+int main()
+{
+    int z,n,Q,cmd,a,b;
+    get_prime();
+    scanf("%d",&z);
+    map<int,int> M;
+    while(z--)
+    {
+        M.clear();
+        scanf("%d%d",&n,&Q);
+        while(Q--)
+        {
+            scanf("%d",&cmd);
+            if(cmd == 1)
+            {
+                scanf("%d%d%d",&a,&b,&p);
+                Div(p);
+                ans = sovle(b) - sovle(a-1);
+                for(map<int,int>::iterator it=M.begin();it!=M.end();it++)
+                    if((*it).first >= a && (*it).first <= b)
+                    {
+                        if(gcd((*it).first,p) == 1)
+                            ans -= (*it).first;
+                        if(gcd((*it).second,p) == 1)
+                            ans += (*it).second;
+                    }
+                printf("%I64d\n",ans);
+            }
+            else
+            {
+                scanf("%d%d",&a,&b);
+                M[a] = b;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4408_autoAC.cpp b/HDOJ/4408_autoAC.cpp
new file mode 100644
index 0000000..1496525
--- /dev/null
+++ b/HDOJ/4408_autoAC.cpp
@@ -0,0 +1,125 @@
+#include <map>
+#include <stack>
+#include <queue>
+#include <math.h>
+#include <vector>
+#include <string>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <iostream>
+#include <algorithm>
+#define N 405
+#define M 4005
+#define E
+#define inf 0x3f3f3f3f
+#define dinf 1e10
+#define linf (LL)1<<60
+#define LL long long
+#define clr(a,b) memset(a,b,sizeof(a))
+using namespace std;
+LL mod;
+struct Edge
+{
+    int a,b,c;
+    bool operator<(const Edge & t)const
+    {
+        return c<t.c;
+    }
+}edge[M];
+int n,m;
+LL ans;
+int fa[N],ka[N],vis[N];
+LL gk[N][N],tmp[N][N];
+vector<int>gra[N];
+int findfa(int a,int b[]){return a==b[a]?a:b[a]=findfa(b[a],b);}
+LL det(LL a[][N],int n)
+{
+    for(int i=0;i<n;i++)for(int j=0;j<n;j++)a[i][j]%=mod;
+    long long ret=1;
+    for(int i=1;i<n;i++)
+    {
+        for(int j=i+1;j<n;j++)
+            while(a[j][i])
+            {
+                LL t=a[i][i]/a[j][i];
+                for(int k=i;k<n;k++)
+                    a[i][k]=(a[i][k]-a[j][k]*t)%mod;
+                for(int k=i;k<n;k++)
+                    swap(a[i][k],a[j][k]);
+                ret=-ret;
+            }
+        if(a[i][i]==0)return 0;
+        ret=ret*a[i][i]%mod;
+    }
+    return (ret+mod)%mod;
+}
+int main()
+{
+    while(scanf("%d%d%I64d",&n,&m,&mod)==3)
+    {
+        if(n==0 && m==0 && mod==0)break;
+        memset(gk,0,sizeof(gk));
+        memset(tmp,0,sizeof(tmp));
+        memset(fa,0,sizeof(fa));
+        memset(ka,0,sizeof(ka));
+        memset(tmp,0,sizeof(tmp));
+        for(int i=0;i<N;i++)gra[i].clear();
+        for(int i=0;i<m;i++)
+            scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].c);
+        sort(edge,edge+m);
+        for(int i=1;i<=n;i++)fa[i]=i,vis[i]=0;
+        int pre=-1;
+        ans=1;
+        for(int h=0;h<=m;h++)
+        {
+            if(edge[h].c!=pre||h==m)
+            {
+                for(int i=1;i<=n;i++)
+                    if(vis[i])
+                    {
+                        int u=findfa(i,ka);
+                        gra[u].push_back(i);
+                        vis[i]=0;
+                    }
+                for(int i=1;i<=n;i++)
+                    if(gra[i].size()>1)
+                    {
+                        for(int a=1;a<=n;a++)
+                            for(int b=1;b<=n;b++)
+                                tmp[a][b]=0;
+                        int len=gra[i].size();
+                        for(int a=0;a<len;a++)
+                            for(int b=a+1;b<len;b++)
+                            {
+                                int la=gra[i][a],lb=gra[i][b];
+                                tmp[a][b]=(tmp[b][a]-=gk[la][lb]);
+                                tmp[a][a]+=gk[la][lb];tmp[b][b]+=gk[la][lb];
+                            }
+                        long long ret=(long long)det(tmp,len);
+                        ret%=mod;
+                        ans=(ans*ret%mod)%mod;
+                        for(int a=0;a<len;a++)fa[gra[i][a]]=i;
+                    }
+                for(int i=1;i<=n;i++)
+                {
+                    ka[i]=fa[i]=findfa(i,fa);
+                    gra[i].clear();
+                }
+                if(h==m)break;
+                pre=edge[h].c;
+            }
+            int a=edge[h].a,b=edge[h].b;
+            int pa=findfa(a,fa),pb=findfa(b,fa);
+            if(pa==pb)continue;
+            vis[pa]=vis[pb]=1;
+            ka[findfa(pa,ka)]=findfa(pb,ka);
+            gk[pa][pb]++;gk[pb][pa]++;
+        }
+        int flag=0;
+        for(int i=2;i<=n&&!flag;i++)if(ka[i]!=ka[i-1])flag=1;
+        ans%=mod;
+        printf("%I64d\n",flag?0:ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4409_autoAC.cpp b/HDOJ/4409_autoAC.cpp
new file mode 100644
index 0000000..9be1a36
--- /dev/null
+++ b/HDOJ/4409_autoAC.cpp
@@ -0,0 +1,144 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<vector>
+#include<map>
+#include<set>
+#include<stack>
+using namespace std;
+#define M 30005
+map<int,string> hasht;
+map<string,int> hashx;
+struct cmp
+{
+    bool operator()(const int &a, const int &b)
+    {
+        return hasht.find(a)->second<hasht.find(b)->second;
+    }
+};
+struct point
+{
+    int pre;
+    set<int,cmp> son;
+    string name;
+}node[M];
+struct px
+{
+    int idx,len;
+} temp;
+int cnt;
+stack<struct px> father;
+void dfs(int idx,int len)
+{
+    for(int i=0; i<len; ++i) printf(".");
+    printf("%s\n",node[idx].name.c_str());
+    for(set<int,cmp>::iterator it=node[idx].son.begin(); it!=node[idx].son.end(); ++it)
+        dfs(*it,len+1);
+}
+void out_all()
+{
+    dfs(0,0);
+}
+void out_child()
+{
+    char s[70];
+    scanf("%s",s);
+    if(hashx.count(string(s))==0)
+    {
+        printf("0\n");
+        return;
+    }
+    if(string(s)==node[0].name)
+    {
+        printf("1\n");
+        return;
+    }
+    int idx=hashx.find(string(s))->second;
+    printf("%d\n",node[node[idx].pre].son.size());
+}
+void out_pre()
+{
+    char a[70],b[70];
+    scanf("%s%s",a,b);
+    set<int> ax;
+    int ida=hashx.find(string(a))->second;
+    int idb=hashx.find(string(b))->second;
+    for(; ida!=-1;)
+    {
+        ida=node[ida].pre;
+        ax.insert(ida);
+    }
+    for(; idb!=-1;)
+    {
+        idb=node[idb].pre;
+        if(ax.count(idb)!=0) break;
+    }
+    printf("%s\n",node[idb].name.c_str());
+}
+int main()
+{
+    int n,m,pre;
+    char s[70],c,ord[10];
+    string sx;
+    for(; scanf("%d",&n),n;)
+    {
+        for(int i=0; i<=n; ++i)
+        {
+            node[i].pre=-1;
+            node[i].son.clear();
+        }
+        hashx.clear();
+        hasht.clear();
+        for(; !father.empty(); father.pop());
+        cnt=0;
+        temp.idx=0;
+        temp.len=0;
+        scanf("%s",s);
+        sx=string(s);
+        node[cnt++].name=sx;
+        hashx.insert(make_pair(sx,0));
+        hasht.insert(make_pair(0,sx));
+        father.push(temp);
+        for(int i=1; i<n; ++i)
+        {
+            for(; getchar()!='.';);
+            int ll=1;
+            for(; (c=getchar())=='.'; ++ll);
+            s[0]=c;
+            int llt;
+            for(llt=1;(s[llt]=getchar())!='\n';++llt);
+            s[llt]='\0';
+            temp.len=ll;
+            temp.idx=cnt;
+            for(;;)
+            {
+                struct px tx=father.top();
+                if(tx.len>=temp.len)
+                    father.pop();
+                else
+                    break;
+            }
+            sx=string(s);
+            int tx=father.top().idx;
+            node[cnt].pre=tx;
+            node[cnt].name=sx;
+            hasht.insert(make_pair(cnt,sx));
+            hashx.insert(make_pair(sx,cnt));
+            node[tx].son.insert(cnt);
+            cnt++;
+            father.push(temp);
+        }
+        scanf("%d",&m);
+        for(; m--;)
+        {
+            scanf("%s",ord);
+            if(ord[0]=='L')
+                out_all();
+            else if(ord[0]=='b')
+                out_child();
+            else if(ord[0]=='c')
+                out_pre();
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4410_autoAC.cpp b/HDOJ/4410_autoAC.cpp
new file mode 100644
index 0000000..c1544fa
--- /dev/null
+++ b/HDOJ/4410_autoAC.cpp
@@ -0,0 +1,168 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+#include <queue>
+#include <stack>
+using namespace std;
+const double INF = 1e19;
+double EPS = 1e-12;
+bool zero(double t){return -EPS<t&&t<EPS;}
+struct cvector{
+    double x,y;
+    cvector(double a,double b){x=a,y=b;}
+    cvector(){}
+};
+cvector operator-(cvector a,cvector b){
+    return cvector(a.x-b.x,a.y-b.y);
+}
+cvector operator+(cvector a,cvector b){
+    return cvector(a.x+b.x,a.y+b.y);
+}
+double operator^(cvector a,cvector b){
+    return a.x*b.y-b.x*a.y;
+}
+double operator*(cvector a,cvector b){
+    return a.x*b.x+a.y*b.y;
+}
+struct cpoint{
+    double x,y;
+    void get(){scanf("%lf%lf",&x,&y);}
+} p[19];
+cvector operator-(cpoint a,cpoint b){
+    return cvector(a.x-b.x,a.y-b.y);
+}
+double dist(cpoint a,cpoint b){
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+struct segline{
+    cpoint a,b;
+    segline(cpoint x,cpoint y){a=x,b=y;}
+    segline(){}
+};
+bool intersect(segline s1,segline s2){
+    return ((s1.a-s2.a)^(s2.b-s2.a))*((s1.b-s2.a)^(s2.b-s2.a))<-EPS&&
+        ((s2.a-s1.a)^(s1.b-s1.a))*((s2.b-s1.a)^(s1.b-s1.a))<-EPS;
+}
+int n;
+double solve4(){    
+    return min(fabs(p[0].x-p[2].x),fabs(p[0].y-p[2].y));
+}
+double solve6()     
+{
+    double re[10];
+    int t=0,k;
+    for(int i=0;i<n;i++){
+        re[i]=(p[i]-p[(i+n-1)%n])^(p[(i+1)%n]-p[i]);
+        if(re[i]>0) t++;
+    }
+    if(t==1){
+        for(int i=0;i<6;i++)
+        if(re[i]>0) k=i;
+    }else{
+        for(int i=0;i<6;i++)
+        if(re[i]<0) k=i;
+    }
+    return min(dist(p[k],p[(k+3)%n]),min(fabs(p[(k+2)%n].x-p[(k+n-2)%n].x),fabs(p[(k+2)%n].y-p[(k+n-2)%n].y)));
+}
+double oor6(int a,int  b) 
+{
+    cpoint t1 = p[(a+n-2)%n],t2 = p[(b+3)%n];
+    return min(fabs(t1.x-t2.x),min(fabs(t1.y-t2.y),max(dist(p[a],p[(a+n-3)%n]),dist(p[b],p[(b+3)%n]))));
+}
+double oor5(int a,int b)   
+{
+    cpoint t1 = p[(a+n-2)%n],t2 = p[(b+2)%n];
+    return min(fabs(t1.x-t2.x),min(fabs(t1.y-t2.y),min(dist(p[a],p[(a+n-3)%n]),dist(p[b],p[(b+3)%n]))));
+}
+double oor4(int a,int b)   
+{
+    double ans;
+    if(zero(p[(a-2+n)%n].y-p[(b+2)%n].y))
+    {
+        ans = min(fabs(p[(a-1+n)%n].x-p[(b+1)%n].x),fabs(p[(a-2+n)%n].y-p[(a+2)%n].y));
+    }else{
+        ans = min(fabs(p[(a-1+n)%n].y-p[(b+1)%n].y),fabs(p[(a-2+n)%n].x-p[(a+2)%n].x));
+    }
+    ans = min(ans,min(dist(p[a],p[(a-3+n)%n]),dist(p[b],p[(b+3)%n])));
+    return ans;
+}
+double oor3(int a,int b)   
+{
+    cpoint t1 = p[(a+2)%n],t2 = p[(b+2)%n];
+    double ans = min(fabs(t1.x-t2.x),fabs(t1.y-t2.y));
+    double A1=INF,A2=INF,B1=INF,B2=INF;
+    if(intersect(segline(p[a],p[(a+3)%n]),segline(p[(a+4)%n],p[(a+5)%n])))
+    A1=min(dist(p[(a+1)%n],p[(a+2)%n]),dist(p[b],p[(a+1)%n]));
+    if(intersect(segline(p[a],p[(a-3+n)%n]),segline(p[(a-4+n)%n],p[(a-5+n)%n])))
+    A2=min(dist(p[(a-1+n)%n],p[(a-2+n)%n]),dist(p[b],p[(a-1+n)%n]));
+    if(intersect(segline(p[b],p[(b+3)%n]),segline(p[(b+4)%n],p[(b+5)%n])))
+    B1=min(dist(p[(b+1)%n],p[(b+2)%n]),dist(p[a],p[(b+1)%n]));
+    if(intersect(segline(p[b],p[(b-3+n)%n]),segline(p[(b-4+n)%n],p[(b-5+n)%n])))
+    B2=min(dist(p[(b-1+n)%n],p[(b-2+n)%n]),dist(p[a],p[(b-1+n)%n]));
+    if(A1!=INF)
+    ans = min(ans,max(B1,A1));
+    if(A2!=INF)
+    ans = min(ans,max(B2,A2));
+   // if(B1!=INF)
+   // ans = min(ans,max(dist(p[b],p[(b+5)%n]),B1));
+   // if(B2!=INF)
+   // ans = min(ans,max(dist(p[b],p[(b+3)%n]),B2));
+    //double A = max(min(dist(p[a],p[(a+3)%n]),A1),min(dist(p[a],p[(a+5)%n]),A2));
+   // double B = max(min(dist(p[b],p[(b+3)%n]),B1),min(dist(p[b],p[(b+5)%n]),B2));
+    ans = min(ans,max(min(dist(p[a],p[(a-3+n)%n]),dist(p[b],p[(b+3)%n])),
+                      min(dist(p[a],p[(a+3)%n]),dist(p[b],p[(b-3+n)%n]))));
+    return ans;
+}
+double solve8()
+{
+    double re[10];
+    int t=0;
+    for(int i=0;i<n;i++){
+        re[i]=(p[i]-p[(i+n-1)%n])^(p[(i+1)%n]-p[i]);
+        if(re[i]>0) t++;
+    }
+    if(t==2){
+    }else{
+        for(int i=0;i<n;i++) re[i] = 0-re[i];
+    }
+    int a,b;  
+    int s = 0,k=0;
+    for(int i=0;i<(n<<1);i++)
+    {
+        if(re[i%n]>0){
+            s=max(s,k);
+            k=0;
+            if(i<n)
+            a=b,b=i;
+        }else{
+            k++;
+        }
+    }
+    if(b-a>4) swap(a,b);
+    if(s==6)
+    return oor6(a,b);
+    if(s==5)
+    return oor5(a,b);
+    if(s==4)
+    return oor4(a,b);
+    if(s==3)
+    return oor3(a,b);
+    return 0;
+}
+int main()
+{
+    while(scanf("%d",&n)&&n)
+    {
+        for(int i=0;i<n;i++)
+            p[i].get();
+        if(n==4)
+        printf("%.2lf\n",solve4());
+        if(n==6)
+        printf("%.2lf\n",solve6());
+        if(n==8)
+        printf("%.2lf\n",solve8());
+    }
+    return 0;
+}
diff --git a/HDOJ/4411_autoAC.cpp b/HDOJ/4411_autoAC.cpp
new file mode 100644
index 0000000..95b1172
--- /dev/null
+++ b/HDOJ/4411_autoAC.cpp
@@ -0,0 +1,127 @@
+#include<stdio.h>
+#include<string.h>
+#define clr(x)memset(x,0,sizeof(x))
+#define INF 0x1f1f1f1f
+#define min(a,b)(a)<(b)?(a):(b)
+#define max(a,b)(a)>(b)?(a):(b)
+struct node
+{
+    int next,from,to,w,c;
+}e[1000010];
+int tot;
+int head[210];
+void add(int st,int u,int wi,int flow)
+{
+    e[tot].from=st;
+    e[tot].to=u;
+    e[tot].w=wi;
+    e[tot].c=flow;
+    e[tot].next=head[st];
+    head[st]=tot++;
+    e[tot].from=u;
+    e[tot].to=st;
+    e[tot].w=-wi;
+    e[tot].c=0;
+    e[tot].next=head[u];
+    head[u]=tot++;
+}
+int q[100010];
+int pre[2010];
+int dis[2010];
+int v[220];
+int s,t;
+int spfa()
+{
+    int i,x,front,rear,k;
+    front=rear=0;
+    for(i=0;i<=t;i++)
+        dis[i]=INF;
+    clr(v);
+    pre[s]=-1;
+    q[rear++]=s;
+    dis[s]=0;
+    v[s]=1;
+    while(front<rear)
+    {
+        x=q[front++];
+        v[x]=0;
+        for(i=head[x];i!=-1;i=e[i].next)
+        {
+            k=e[i].to;
+            if(e[i].c&&dis[x]+e[i].w<dis[k])
+            {
+                dis[k]=dis[x]+e[i].w;
+                pre[k]=i;
+                if(!v[k])
+                {
+                    v[k]=1;
+                    if(dis[k]<=dis[x]&&front>0)
+                        q[--front]=k;
+                    else q[rear++]=k;
+                }
+            }
+        }
+    }
+    if(dis[t]!=INF)
+        return 1;
+    return 0;
+}
+int costflow()
+{
+    int tt=0;
+    int tot=0,flow=0,u,minf=INF;
+    while(spfa())
+    {
+        for(u=pre[t];u!=-1;u=pre[e[u].from])
+            minf=min(minf,e[u].c);
+        for(u=pre[t];u!=-1;u=pre[e[u].from])
+        {
+            e[u].c-=minf;
+            e[u^1].c+=minf;
+            flow+=e[u].w*minf;
+        }
+    }
+    return flow;
+}
+int g[105][105];
+int main()
+{
+    int m,n,a,b,c,k,K,w,z,i,j;
+    while(scanf("%d%d%d",&n,&m,&K)!=EOF)
+    {
+        if(n==0&&m==0&&K==0)
+            break;
+        memset(g,INF,sizeof(g));
+        for(i=0;i<=n;i++)
+            g[i][i]=0;
+        while(m--)
+        {
+            scanf("%d%d%d",&a,&b,&w);
+            if(w<g[a][b])
+                g[a][b]=g[b][a]=w;
+        }
+        for(k=0;k<=n;k++)
+            for(i=0;i<=n;i++)
+                for(j=0;j<=n;j++)
+                    if(g[i][k]+g[k][j]<g[i][j])
+                        g[i][j]=g[i][k]+g[k][j];
+        int res;
+        s=2*n+1;
+        t=2*n+2;
+        tot=0;
+        memset(head,-1,sizeof(head));
+        add(s,0,0,K);
+        add(0,t,0,w);
+        for(i=1;i<=n;i++)
+        {
+            add(0,i,g[0][i],1);
+            add(i,i+n,-1000000,1);
+            add(i+n,t,g[0][i],1);
+        }
+        for(i=1;i<=n;i++)
+            for(j=i+1;j<=n;j++)
+                add(i+n,j,g[i][j],1);
+        printf("%d\n",costflow()+1000000*n);
+    }
+    return 0;
+}
diff --git a/HDOJ/4412_autoAC.cpp b/HDOJ/4412_autoAC.cpp
new file mode 100644
index 0000000..092086b
--- /dev/null
+++ b/HDOJ/4412_autoAC.cpp
@@ -0,0 +1,78 @@
+#include<stdio.h>
+#include<iostream>
+#include<map>
+#include<algorithm>
+#include<string.h>
+#include<stdlib.h>
+#define MAXN 1005
+using namespace std;
+double dp[55][MAXN], cost[MAXN][MAXN];
+map<int ,double> has;
+struct Info{
+double pos;
+double p;
+}info[MAXN];
+int main()
+{
+    int N, M, i, n, a, j, k, pos;
+    double l, r, suml, sumr;
+    double b, min, temp, t;
+    while(scanf("%d%d",&N, &M)&&(N + M))
+    {
+        has.clear();
+        for( i = 1; i <= N; ++ i )
+        {
+            scanf("%d", &n);++n;
+            while(--n)
+            {
+                scanf("%d%lf", &a, &b);
+                has[a]+=b;
+            }
+        }
+        N = 0;
+        for(map<int, double>::iterator it = has.begin(); it != has.end(); ++it)
+        {
+            info[++N].pos = it->first;
+            info[N].p = it->second;
+        }
+          for(j = N; j >= 1; j--)
+            {
+                pos = j;
+                cost[j][j] = 0;
+                l = r = suml = 0;
+                sumr = info[j].p;
+                for(k = j-1; k >= 1; --k )
+                {
+                    suml += info[k].p;
+                    l += (info[pos].pos-info[k].pos) * info[k].p;
+                    temp =  l + r;
+                    while((pos > 1)&&(temp>(t = (l + r + (sumr - suml) * (info[pos].pos - info[pos - 1].pos)))))
+                    {
+                        l -= suml *  (info[pos].pos - info[pos - 1].pos);
+                        r +=  sumr *  (info[pos].pos - info[pos - 1].pos);
+                        --pos;
+                        suml -= info[pos].p;
+                        sumr +=info[pos].p;
+                        temp = t;
+                    }
+                    cost[k][j] = temp;
+                }
+            }
+        for(i = 1; i <= N; i++)dp[0][i] = 1e300;
+        for(i = 0; i <= M; i++)dp[i][0] = 0;
+        for(i = 1; i <= M; i++)
+        {
+            for(j = N; j >= 1; j--)
+            {
+                min = dp[i-1][j-1] + cost[j][j];
+                for(k = j-1; k >= 1; --k )
+                {
+                        if(dp[i - 1][k - 1] + cost[k][j] < min)min = dp[i - 1][k - 1] + cost[k][j];
+                }
+                dp[i][j] = min;
+            }
+        }
+        printf("%0.2lf\n",dp[M][N]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4413_autoAC.cpp b/HDOJ/4413_autoAC.cpp
new file mode 100644
index 0000000..643efe5
--- /dev/null
+++ b/HDOJ/4413_autoAC.cpp
@@ -0,0 +1,136 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<algorithm>
+#include<string>
+using namespace std;
+typedef pair<string, int> node;
+vector<node> ans;
+bool vis[50];
+int V[50];
+bool cmp(string s1,string s2){
+    return s1+s2<s2+s1;
+}
+bool cmp2(string s1,string s2){
+    return s1+"+"+s2<s2+"+"+s1;
+}
+bool hmr(node a, node b) {
+    if (a.second==b.second) {
+        if (a.first.length()==b.first.length()) return a.first<b.first;
+        return a.first.length()<b.first.length();
+    }
+    return a.second<b.second;
+}
+bool operator==(node a, node b) {
+    return a.first==b.first && a.second==b.second;
+}
+string StInS(int s,int n,int ors){
+    int i;
+    vector<string> tmpAns;
+    for (i=0;i<(1<<n);i++){
+        if ((i&s)==(ors&s))
+            if (V[i]==0) return "";
+    }
+    if (s==0) return "1";
+    string tmp;
+    for (i=0;i<n;i++) if (s&(1<<i)){
+        tmp="";
+        if (!(ors&(1<<i)))
+            tmp+='-';
+        tmp+=(char)(i+'A');
+        tmpAns.push_back(tmp);
+    }
+    sort(tmpAns.begin(),tmpAns.end(),cmp);
+    tmp="";
+    for (i=0;i<tmpAns.size();i++)
+        tmp+=tmpAns[i];
+    return tmp;
+}
+void getans(int s, int n) {
+    int i,j;
+    int minsize = 0x3fff;
+    vector<node> tmp;
+    for (i=0;i<(1<<n);i++) {
+        int ctrl=__builtin_popcount(i);
+        if (ctrl>minsize) continue;
+        string tans2=StInS(i,n,s);
+        if (tans2.empty()) continue;
+        if (ctrl<minsize) {
+            minsize = ctrl;
+            tmp.clear();
+        }
+        int res = 0;
+        for (j = 0; j < 1<<n; ++j)
+            if ((j&i)==(s&i)) res |= 1<<j;
+        tmp.push_back(make_pair(tans2, res));
+    }
+    for (i = 0; i < tmp.size(); ++i)
+        ans.push_back(tmp[i]);
+}
+int N, M;
+int all;
+int best;
+bool use[64], ause[64];
+void dfs(int i, int len, int cover) {
+    if (len >= best) return;
+    if (cover==all) {
+        memcpy(ause, use, sizeof(use));
+        best = len;
+        return;
+    }
+    if (i==M) return;
+    use[i] = 1;
+    dfs(i+1, len+ans[i].first.length()+1, cover|ans[i].second);
+    use[i] = 0;
+    dfs(i+1, len, cover);
+}
+int main(){
+    int i,s,j,v;
+    int cas=0;
+    for (;;){
+        scanf("%d",&N);
+        if (N==0) break;
+        for (i=0;i<(1<<N);i++){
+            s=0;
+            vis[i] = 0;
+            for (j=0;j<N;j++){
+                scanf("%d",&v);
+                s^=(v<<j);
+            }
+            scanf("%d",&V[s]);
+        }
+        ans.clear();
+        memset(vis, 0, sizeof vis);
+        all = 0;
+        for (s = 0; s < 1<<N; ++s)
+            if (V[s]){
+                all |= 1<<s;
+                getans(s, N);
+            }
+        if (ans.size()==0) {
+            puts("-AA");
+            continue;
+        }
+        if (ans[0].first[0]=='1') {
+            puts("-A+A");
+            continue;
+        }
+        sort(ans.begin(), ans.end(), hmr);
+        M = unique(ans.begin(), ans.end())-ans.begin();
+        sort(ans.begin(), ans.begin()+M);
+        best = 0x3fffffff;
+        memset(use, 0, sizeof use);
+        memset(ause, 0, sizeof ause);
+        dfs(0, 0, 0);
+        vector<string> astr;
+        for (i = 0; i < M; ++i)
+            if (ause[i]) astr.push_back(ans[i].first);
+        sort(astr.begin(), astr.end(), cmp2);
+        string fin = astr[0];
+        for (i = 1; i < astr.size(); ++i)
+            fin += "+"+astr[i];
+        cout << fin << '\n';
+    }
+    return 0;
+}
diff --git a/HDOJ/4414_autoAC.cpp b/HDOJ/4414_autoAC.cpp
new file mode 100644
index 0000000..989dbd2
--- /dev/null
+++ b/HDOJ/4414_autoAC.cpp
@@ -0,0 +1,90 @@
+#include<stdio.h>
+#include<string.h>
+char grid[70][70];
+int vis[70][70],midx[70],midy[70],top;
+int dx[4]={-1,1,0,0};
+int dy[4]={0,0,-1,1};
+int N,acquire;
+typedef struct node
+{
+    int x,y;
+}Node;
+Node queue[30000];    
+int BFS(int x,int y)
+{
+    int rear,front;
+    int nx,ny,ox,oy;
+    int i,j,k,cnt,step=4;
+    cnt=rear=front=0;
+    queue[rear].x=x;
+    queue[rear++].y=y;
+    vis[x][y]=1;
+    while(front<rear)
+    {
+        cnt=0;
+        ox=queue[front].x;oy=queue[front++].y;
+        for(i=0;i<4;i++)
+        {
+            nx=ox+dx[i];ny=oy+dy[i];
+            if(nx>=0&&nx<N&&ny>=0&&ny<N&&grid[nx][ny]=='#'&&!vis[nx][ny])
+            {
+                cnt++;
+                queue[rear].x=nx;queue[rear++].y=ny;
+                vis[nx][ny]=1;
+            }
+        } 
+        if(cnt==1)step++;
+    }
+    step/=4;
+    if(rear==step*4+1)acquire++;
+    return 0;     
+}   
+int DFS(int x,int y)
+{
+    int nx,ny;
+    int i,j,k,cnt=0;
+    for(i=0;i<4;i++)
+    {
+        nx=x+dx[i];ny=y+dy[i];
+        if(nx>=0&&nx<N&&ny>=0&&ny<N&&!vis[nx][ny]&&grid[nx][ny]=='#')
+        {
+            cnt++;
+            vis[nx][ny]=1;
+            DFS(nx,ny);
+        }    
+    }
+    if(cnt==3)
+    {
+        midx[top]=x;
+        midy[top++]=y;
+    }
+    return 0;      
+}     
+int main()
+{
+    int i,j,k;
+    while(scanf("%d",&N)!=EOF&&N)
+    {
+        memset(vis,0,sizeof(vis));
+        acquire=top=0;
+        for(i=0;i<N;i++)scanf("%s",grid[i]);
+        for(i=0;i<N;i++)
+        {
+            for(j=0;j<N;j++)
+            {
+                if(!vis[i][j]&&grid[i][j]=='#')
+                {
+                    vis[i][j]=1;
+                    DFS(i,j);
+                }    
+            }
+        }  
+        memset(vis,0,sizeof(vis));
+        for(i=0;i<top;i++)
+        {
+            if(!vis[midx[i]][midy[i]])BFS(midx[i],midy[i]);
+        }        
+        printf("%d\n",acquire);
+    }
+    return 0;
+}
diff --git a/HDOJ/4415_autoAC.cpp b/HDOJ/4415_autoAC.cpp
new file mode 100644
index 0000000..fc364bf
--- /dev/null
+++ b/HDOJ/4415_autoAC.cpp
@@ -0,0 +1,112 @@
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<algorithm>
+using namespace std;
+struct px
+{
+    int a,b;
+} node;
+vector<struct px> a,b;
+bool cmp(const struct px &x,const struct px &y)
+{
+    return x.a<y.a;
+}
+int main()
+{
+    int tt;
+    int x,y,n,m,ida,idb;
+    scanf("%d",&tt);
+    for(int cas=1; cas<=tt; ++cas)
+    {
+        int ans=0,bx=0,mm=0,mn=0,ansn=0;
+        a.clear();
+        b.clear();
+        scanf("%d%d",&n,&m);
+        for(int i=0; i<n; i++)
+        {
+            scanf("%d%d",&node.a,&node.b);
+            if(node.b!=0) a.push_back(node);
+            else          b.push_back(node);
+        }
+        sort(a.begin(),a.end(),cmp);
+        sort(b.begin(),b.end(),cmp);
+        ida=0;
+        idb=b.size()-1;
+        for(int i=0; i<b.size(); ++i)
+        {
+            if(m-mn>=b[i].a)
+            {
+                ansn++;
+                mn+=b[i].a;
+            }
+        }
+        if(a.size()>0&&a[0].a<=m)
+        {
+            node=a[0];
+            mm+=node.a;
+            for(int i=0; i<a.size(); i++)
+            {
+                bx+=(a[i].b-1);
+                ans++;
+            }
+            bx++;
+        }
+        if(a.size()>0&&a[0].a<=m-mn)
+        {
+            node=a[0];
+            mn+=node.a;
+            for(int i=0; i<a.size(); i++)
+                ansn++;
+        }
+        for(; bx!=0&&idb>=0; --idb,--bx,++ans);
+        if(idb<0)
+        {
+            if(ans>ansn) printf("Case %d: %d %d\n",cas,ans,mm);
+            else if(ans<ansn) printf("Case %d: %d %d\n",cas,ansn,mn);
+            else printf("Case %d: %d %d\n",cas,ansn,mn>mm?mm:mn);
+        }
+        else
+        {
+            int i,j;
+            for(i=1,j=0; i<a.size()&&j<=idb;)
+            {
+                if(a[i].a<=b[j].a)
+                {
+                    if(m>=a[i].a+mm)
+                    {
+                        mm+=a[i].a;
+                        i++;
+                        ans++;
+                        idb--;
+                    }
+                    else break;
+                }
+                else
+                {
+                    if(m>=b[j].a+mm)
+                    {
+                        mm+=b[j].a;
+                        ans++;
+                        j++;
+                    }
+                    else break;
+                }
+            }
+            for(;j<=idb;++j)
+            {
+                    if(m>=b[j].a+mm)
+                    {
+                        mm+=b[j].a;
+                        ans++;
+                        j++;
+                    }
+                    else break;
+            }
+            if(ans>ansn) printf("Case %d: %d %d\n",cas,ans,mm);
+            else if(ans<ansn) printf("Case %d: %d %d\n",cas,ansn,mn);
+            else printf("Case %d: %d %d\n",cas,ansn,mn>mm?mm:mn);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4416_autoAC.cpp b/HDOJ/4416_autoAC.cpp
new file mode 100644
index 0000000..1d40558
--- /dev/null
+++ b/HDOJ/4416_autoAC.cpp
@@ -0,0 +1,100 @@
+#include<iostream>
+#include<cstdio>
+#include<map>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<algorithm>
+#include<set>
+#include<string>
+#include<queue>
+#define inf 1<<28
+#define M 6000005
+#define N 1000005
+#define maxn 300005
+#define Min(a,b) ((a)<(b)?(a):(b))
+#define Max(a,b) ((a)>(b)?(a):(b))
+#define pb(a) push_back(a)
+#define mem(a,b) memset(a,b,sizeof(a))
+#define LL long long
+#define MOD 1000000007
+using namespace std;
+int wa[maxn],wb[maxn],wv[maxn],Ws[maxn];  
+int cmp(int *r,int a,int b,int l)  
+{return r[a]==r[b]&&r[a+l]==r[b+l];}  
+void da(const int *r,int *sa,int n,int m){  
+    int i,j,p,*x=wa,*y=wb,*t;   
+    for(i=0;i<m;i++) Ws[i]=0;   
+    for(i=0;i<n;i++) Ws[x[i]=r[i]]++;   
+    for(i=1;i<m;i++) Ws[i]+=Ws[i-1];   
+    for(i=n-1;i>=0;i--) sa[--Ws[x[i]]]=i;   
+    for(j=1,p=1;p<n;j*=2,m=p){   
+        for(p=0,i=n-j;i<n;i++) y[p++]=i;   
+        for(i=0;i<n;i++) if(sa[i]>=j) y[p++]=sa[i]-j;   
+        for(i=0;i<n;i++) wv[i]=x[y[i]];   
+        for(i=0;i<m;i++) Ws[i]=0;   
+        for(i=0;i<n;i++) Ws[wv[i]]++;   
+        for(i=1;i<m;i++) Ws[i]+=Ws[i-1];   
+        for(i=n-1;i>=0;i--) sa[--Ws[wv[i]]]=y[i];   
+        for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;i<n;i++)   
+            x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;   
+    }   
+    return;   
+}  
+int sa[maxn],Rank[maxn],height[maxn];  
+void calheight(const int *r,int *sa,int n){  
+    int i,j,k=0;  
+    for(i=1;i<=n;i++) Rank[sa[i]]=i;  
+    for(i=0;i<n;height[Rank[i++]]=k)  
+        for(k?k--:0,j=sa[Rank[i]-1];r[i+k]==r[j+k];k++);  
+    return;  
+} 
+int a[maxn],pos[maxn];
+char str[maxn];
+int main(){
+    int t,cas=0,n;
+    scanf("%d",&t);
+    while(t--){
+        int len,m=0,num=30;
+        scanf("%d",&n);
+        scanf("%s",str);
+        len=strlen(str);
+        for(int i=0;i<len;i++) a[m++]=str[i]-'a'+1;
+        for(int i=0;i<n;i++){
+            a[m++]=num++;
+            scanf("%s",str);
+            int l=strlen(str);
+            for(int j=0;j<l;j++)
+                a[m++]=str[j]-'a'+1;
+        }
+        a[m]=0;
+        da(a,sa,m+1,num+1);
+        calheight(a,sa,m);
+        mem(pos,0);
+        int tmp=inf;
+        for(int i=1;i<=m;i++){
+            if(sa[i]<len){
+                if(height[i]<tmp) tmp=height[i];
+                if(pos[sa[i]]<tmp) pos[sa[i]]=tmp;
+            }
+            else tmp=inf;
+        }
+        tmp=inf;
+        for(int i=m;i>=1;i--){
+            if(sa[i-1]<len){
+                if(height[i]<tmp) tmp=height[i];
+                if(pos[sa[i-1]]<tmp) pos[sa[i-1]]=tmp;
+            }
+            else tmp=inf;
+        }
+        for(int i=1;i<=m;i++)
+             if(sa[i]<len&& sa[i-1]<len)
+                if(pos[sa[i-1]]<height[i])  
+                    pos[sa[i-1]]=height[i];  
+        LL ans=(LL)len*(len+1)/2;
+        for(int i=0;i<len;i++)
+            ans-=pos[i];
+        printf("Case %d: %I64d\n",++cas,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4417_autoAC.cpp b/HDOJ/4417_autoAC.cpp
new file mode 100644
index 0000000..1936e01
--- /dev/null
+++ b/HDOJ/4417_autoAC.cpp
@@ -0,0 +1,71 @@
+#include <iostream>
+#include <cstdio>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+const int N = 100010;
+struct dit{
+    int num,id;
+}dd[N];
+struct ask{
+    int lp,rp,value,id;
+}aa[N];
+int cnt[N];
+bool cmp1(dit a,dit b){
+    return a.num < b.num;
+}
+bool cmp2(ask a,ask b){
+    return a.value < b.value;
+}
+int inline lowbit(int x){
+    return x & (-x);
+}
+void inline update(int x){
+    while(x < N){
+       cnt[x]++;
+       x += lowbit(x);
+    }
+}
+int inline sum(int x){
+    int s = 0;
+    while(x > 0){
+      s += cnt[x];
+      x -= lowbit(x);
+    }
+    return s;
+}
+int main(){
+    int numcase;
+    scanf("%d",&numcase);
+    for(int ca = 1; ca <= numcase; ++ca){
+       int n,m;
+       memset(cnt,0,sizeof(cnt));
+       scanf("%d%d",&n,&m);
+       for(int i = 0; i < n; ++i){
+          scanf("%d",&dd[i].num);
+          dd[i].id = i + 1;
+       }
+       int x,y;
+       for(int i = 0; i < m; ++i){
+          scanf("%d%d%d",&x,&y,&aa[i].value);
+          aa[i].lp = x + 1;
+          aa[i].rp = y + 1;
+          aa[i].id = i + 1;
+       }
+       sort(dd,dd+n,cmp1);
+       sort(aa,aa+m,cmp2);
+       int ans[N] = {0};
+       for(int aski = 0,ditj = 0; aski < m; ++aski){
+           while(ditj < n && aa[aski].value >= dd[ditj].num){
+              update(dd[ditj].id);
+              ditj++;
+           }
+           ans[aa[aski].id] = sum(aa[aski].rp) - sum(aa[aski].lp - 1);
+       }
+       printf("Case %d:\n",ca);
+       for(int i = 1; i <= m; ++i){
+          printf("%d\n",ans[i]);
+       }
+    }
+    return 0;
+}
diff --git a/HDOJ/4418_autoAC.cpp b/HDOJ/4418_autoAC.cpp
new file mode 100644
index 0000000..be5f1fa
--- /dev/null
+++ b/HDOJ/4418_autoAC.cpp
@@ -0,0 +1,109 @@
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <queue>
+#include <algorithm>
+#include <math.h>
+using namespace std;
+#define M 205
+#define eps 1e-8
+int equ, var;
+double a[M][M], x[M];
+int Gauss ()
+{
+    int i, j, k, col, max_r;
+    for (k = 0, col = 0; k < equ && col < var; k++, col++)
+    {
+        max_r = k;
+        for (i = k+1; i < equ; i++)
+            if (fabs (a[i][col]) > fabs (a[max_r][col]))
+                max_r = i;
+        if (k != max_r)
+        {
+            for (j = col; j < var; j++)
+                swap (a[k][j], a[max_r][j]);
+            swap (x[k], x[max_r]);
+        }
+        x[k] /= a[k][col];
+        for (j = col+1; j < var; j++) a[k][j] /= a[k][col];
+        a[k][col] = 1;
+        for (i = 0; i < equ; i++) if (i != k)
+        {
+            x[i] -= x[k] * a[i][k];
+            for (j = col+1; j < var; j++) a[i][j] -= a[k][j] * a[i][col];
+            a[i][col] = 0;
+        }
+    }
+    return 1;
+}
+int has[M], vis[M], k, e, n, m;
+double p[M], sum;
+int bfs (int u)
+{
+    memset (has, -1, sizeof(has));
+    memset (a, 0, sizeof(a));            
+    memset (vis, 0, sizeof(vis));
+    int v, i, flg = 0;
+    queue<int> q;
+    q.push (u);
+    k = 0;
+    has[u] = k++;
+    while (!q.empty ())
+    {
+        u = q.front ();
+        q.pop ();
+        if (vis[u]) continue;
+        vis[u] = 1;
+        if (u == e || u == n-e)        
+        {
+            a[has[u]][has[u]] = 1;
+            x[has[u]] = 0;
+            flg = 1;
+            continue;
+        }
+        a[has[u]][has[u]] = 1;
+        x[has[u]] = sum;
+        for (i = 1; i <= m; i++)
+        {
+            if (fabs (p[i]) < eps) continue;
+            v = (u + i) % n;
+            if (has[v] == -1) has[v] = k++;
+            a[has[u]][has[v]] -= p[i];
+            q.push (v);
+        }
+    }
+    return flg;
+}
+int main()
+{
+    int t, s, d, i;
+    scanf ("%d", &t);
+    while (t--)
+    {
+        scanf ("%d%d%d%d%d", &n, &m, &e, &s, &d);
+        n = 2*(n-1);
+        sum = 0;
+        for (i = 1; i <= m; i++)
+        {
+            scanf ("%lf", p+i);
+            p[i] = p[i] / 100;
+            sum += p[i] * i;
+        }
+        if (s == e)
+        {
+            puts ("0.00");
+            continue;
+        }
+        if (d > 0) s = (n - s) % n;
+        if (!bfs (s))
+        {
+            puts ("Impossible !");
+            continue;
+        }
+        equ = var = k;
+        Gauss ();
+        printf ("%.2f\n", x[has[s]]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4419_autoAC.cpp b/HDOJ/4419_autoAC.cpp
new file mode 100644
index 0000000..1fa41b0
--- /dev/null
+++ b/HDOJ/4419_autoAC.cpp
@@ -0,0 +1,119 @@
+#include<iostream>
+#include<cstdio>
+#include<map>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<algorithm>
+#include<set>
+#include<string>
+#include<queue>
+#define inf 1<<28
+#define M 6000005
+#define N 11005
+#define maxn 300005
+#define Min(a,b) ((a)<(b)?(a):(b))
+#define Max(a,b) ((a)>(b)?(a):(b))
+#define pb(a) push_back(a)
+#define mem(a,b) memset(a,b,sizeof(a))
+#define LL long long
+#define MOD 1000000007
+#define lson step<<1
+#define rson step<<1|1
+using namespace std;
+struct segment{
+    int x1,x2,y,val;
+    segment(){}
+    segment(int _x1,int _x2,int _y,int _v):x1(_x1),x2(_x2),y(_y),val(_v){}
+    bool operator<(const segment s)const{
+        return y<s.y;
+    }
+}seg[N*2];
+struct Node{
+    int left,right,len[8],cnt[5];
+}L[N*2*4];
+int x[N*2]={-1},cnt;
+LL ans[8];
+void Bulid(int step,int l,int r){
+    L[step].left=l;
+    L[step].right=r;
+    mem(L[step].len,0);
+    mem(L[step].cnt,0);
+    if(l==r) return;
+    int m=(l+r)>>1;
+    Bulid(lson,l,m);
+    Bulid(rson,m+1,r);
+}
+void Push_Up(int step){
+    int state=(L[step].cnt[1]>0?1:0)|(L[step].cnt[2]>0?2:0)|(L[step].cnt[4]>0?4:0);
+    if(state){
+        mem(L[step].len,0);
+        L[step].len[state]=x[L[step].right+1]-x[L[step].left];
+        for(int i=1;i<8;i++){
+            if(state!=(state|i)){
+                int tmp=L[lson].len[i]+L[rson].len[i];
+                L[step].len[state|i]+=tmp;
+                L[step].len[state]-=tmp;
+            }
+        }
+    }
+    else if(L[step].left!=L[step].right)
+        for(int i=1;i<8;i++) L[step].len[i]=L[lson].len[i]+L[rson].len[i];
+    else mem(L[step].len,0);
+}
+void Update(int step,int l,int r,int val){
+    if(L[step].left==l&&r==L[step].right)
+        val>0?++L[step].cnt[val]:--L[step].cnt[-val];
+    else{
+        int m=(L[step].left+L[step].right)>>1;
+        if(r<=m) Update(lson,l,r,val);
+        else if(l>m) Update(rson,l,r,val);
+        else{
+            Update(lson,l,m,val);
+            Update(rson,m+1,r,val);
+        }
+    }
+    Push_Up(step);
+}
+int Bin(int m){
+    int low=1,high=cnt,mid;
+    while(low<=high){
+        mid=(low+high)>>1;
+        if(x[mid]==m) return mid;
+        if(x[mid]<m) low=mid+1;
+        else high=mid-1;
+    }
+}
+int main(){
+    int t,cas=0,n;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(int i=0;i<n;i++){
+            char str[6];
+            int x1,x2,y1,y2;
+            scanf("%s%d%d%d%d",str,&x1,&y1,&x2,&y2);
+            seg[2*i]=segment(x1,x2,y1,str[0]=='R'?1:(str[0]=='G'?2:4));
+            seg[2*i+1]=segment(x1,x2,y2,str[0]=='R'?-1:(str[0]=='G'?-2:-4));
+            x[2*i+2]=x1;x[2*i+1]=x2;
+        }
+        sort(seg,seg+2*n);
+        sort(x+1,x+1+2*n);
+        cnt=0;
+        for(int i=1;i<=2*n;i++)
+            if(x[i]!=x[cnt])
+                x[++cnt]=x[i];
+        Bulid(1,1,cnt);
+        mem(ans,0);
+        for(int i=0;i<2*n;i++){
+            int l=Bin(seg[i].x1),r=Bin(seg[i].x2)-1;
+            Update(1,l,r,seg[i].val);
+            if(seg[i].y!=seg[i+1].y)
+                for(int j=1;j<8;j++)
+                    ans[j]+=(LL)(seg[i+1].y-seg[i].y)*(LL)L[1].len[j];
+        }
+        printf("Case %d:\n",++cas);
+        printf("%I64d\n%I64d\n%I64d\n%I64d\n%I64d\n%I64d\n%I64d\n",ans[1],ans[2],ans[4],ans[3],ans[5],ans[6],ans[7]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4421_autoAC.cpp b/HDOJ/4421_autoAC.cpp
new file mode 100644
index 0000000..12fb103
--- /dev/null
+++ b/HDOJ/4421_autoAC.cpp
@@ -0,0 +1,111 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+using namespace std;
+inline int min(int a,int b) { return a<b? a: b ; }
+const int maxn =  4000 +10  ;
+const int maxm =  4000000 + 10;
+struct  TwoSAT {
+    int col[maxn],dfn[maxn],low[maxn],s[maxn],cnt,scnt, stop,n;
+    int pre[maxm],ad[maxn],v[maxm], tot ;
+    void init()
+    {
+        tot=0 ;
+        memset(ad,0,sizeof(ad));
+    }
+    void add(int x,int y)
+    {
+        pre[++tot] = ad[x];
+        ad[x] = tot ;
+        v[tot] = y; 
+    }
+    void add_clause(int x, int xval, int y, int yval)
+    {
+        add(x+xval*n,y+(!yval)*n);
+        add(y+yval*n,x+(!xval)*n);
+    }
+    void dfs(int u) {
+        dfn[u]=low[u]=++cnt ;
+        s[++stop]=u;
+        for (int j=ad[u];j;j=pre[j]){
+            if (!dfn[v[j]]){
+                dfs(v[j]);
+                low[u] = min(low[u],low[v[j]]) ;
+            }
+            else if (!col[v[j]]) 
+                low[u] = min(low[u] , dfn[v[j]]); 
+        }
+        if(low[u]==dfn[u]){
+            ++scnt; 
+            while(1){
+                int x=s[stop--];
+                col[x]=scnt; 
+                if(x==u)break; 
+            }
+        }
+    }
+    bool slove()
+    {
+        memset(dfn,0,sizeof(dfn));
+        memset(col,0,sizeof(col));
+        cnt=scnt=stop= 0 ; 
+        for (int i=0; i<2*n; ++i)
+            if (!dfn[i])
+                dfs(i);
+        for(int i=0;i<n;++i)
+            if (col[i] ==col[i+n])
+                return 0;
+        return 1;
+    }
+};
+TwoSAT TSAT; 
+int b[600][600]; 
+int main()
+{
+    int n ; 
+    while (scanf("%d",&n)!=EOF) {
+        for (int i=0; i<n; ++i) 
+            for (int j=0; j<n; ++j) 
+                scanf("%d",&b[i][j]) ; 
+        TSAT.n=n;
+        int flag = 1; 
+        for (int k=0; k<31; ++k) {
+            TSAT.init() ; 
+            for (int i=0; i<n; ++i) 
+                for (int j=i; j<n; ++j)
+                if (i==j)
+                    continue; 
+                else if (i %2 ==1 && j%2 ==1) {
+                    if (b[i][j] & (1<<k)){
+                        TSAT.add_clause(i,1,j,1);
+                    }
+                    else{
+                        TSAT.add_clause(i,0,i,0);
+                        TSAT.add_clause(j,0,j,0);
+                    }
+                }
+                else if (i%2==0 && j%2==0) {
+                    if (b[i][j] & (1<<k)){
+                        TSAT.add_clause(i,1,i,1);
+                        TSAT.add_clause(j,1,j,1);
+                    }
+                    else {
+                        TSAT.add_clause(i,0,j,0);
+                    }
+                } 
+                else {
+                    if (b[i][j] & (1<<k)) {
+                        TSAT.add_clause(i,0,j,0);
+                        TSAT.add_clause(i,1,j,1);
+                    }
+                    else {
+                        TSAT.add_clause(i,0,j,1);
+                        TSAT.add_clause(i,1,j,0);
+                    }
+                }
+                flag = TSAT.slove();
+            if (!flag) break ; 
+        }
+        if (flag) puts("YES"); else puts("NO"); 
+    }
+}
diff --git a/HDOJ/4422_autoAC.cpp b/HDOJ/4422_autoAC.cpp
new file mode 100644
index 0000000..dae05b0
--- /dev/null
+++ b/HDOJ/4422_autoAC.cpp
@@ -0,0 +1,71 @@
+#include"stdio.h"
+#include"string.h"
+#include"stdlib.h"
+int main()
+{
+    int n,num[11];
+    int i,l,j,k;
+    int flag;
+    int temp;
+    int ans;
+    while(scanf("%d",&n)!=-1)
+    {
+        for(i=0;i<n;i++)    scanf("%d",&num[i]);
+        if(n<=3)    {printf("1024\n");continue;}
+        if(n==4)
+        {
+            flag=0;
+            for(i=0;i<4;i++)
+            {
+                temp=0;
+                for(l=0;l<4;l++)
+                {
+                    if(i==l)    continue;
+                    temp+=num[l];
+                }
+                if(temp%1024==0)    flag=1;
+                if(flag)    break;
+            }
+            if(flag)    {printf("1024\n");continue;}
+            else
+            {
+                ans=0;
+                for(i=0;i<4;i++)
+                for(l=0;l<4;l++)
+                {
+                    if(i==l)    continue;
+                    temp=num[i]+num[l];
+                    while(temp>1024)    temp-=1024;
+                    ans=ans>temp?ans:temp;
+                }
+                printf("%d\n",ans);
+                continue;
+            }
+        }
+        else
+        {
+            flag=0;
+            ans=0;
+            for(i=0;i<5;i++)
+            for(l=0;l<5;l++)
+            for(j=0;j<5;j++)
+            {
+                if(i!=l && i!=j && l!=j)
+                {
+                    temp=num[i]+num[l]+num[j];
+                    if(temp%1024==0)
+                    {
+                        temp=0;
+                        for(k=0;k<5;k++)    if(k!=i && k!=l && k!=j)    temp+=num[k];
+                        while(temp>1024)    temp-=1024;
+                        ans=ans>temp?ans:temp;
+                        flag=1;
+                    }
+                }
+            }
+            if(flag)    printf("%d\n",ans);
+            else        printf("0\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4424_autoAC.cpp b/HDOJ/4424_autoAC.cpp
new file mode 100644
index 0000000..7978348
--- /dev/null
+++ b/HDOJ/4424_autoAC.cpp
@@ -0,0 +1,63 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define MAXN 200200
+typedef long long LL;
+int parent[MAXN];
+LL sum[MAXN];
+int cnt[MAXN];
+struct Edge{
+   int u,v,w;
+}edge[MAXN];
+int n;
+void Initiate()
+{
+   memset(sum,0,(n+2)*sizeof(sum[0]));
+   for(int i=0;i<=n;i++){
+      parent[i]=i;
+      cnt[i]=1;
+   }
+}
+int Find(int x)
+{
+   if(x==parent[x])
+      return x;
+   parent[x]=Find(parent[x]);
+   return parent[x];
+}
+void Union(int r1,int r2,LL w)
+{
+   parent[r1]=r2;
+   cnt[r2]+=cnt[r1];
+   sum[r2]+=w;
+}
+int cmp(const Edge &p,const Edge &q)
+{
+   return p.w>q.w;
+}
+int main()
+{
+   while(~scanf("%d",&n))
+   {
+      Initiate();
+      for(int i=0;i<n-1;i++){
+         scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
+      }
+      sort(edge,edge+n-1,cmp);
+      for(int i=0;i<n-1;i++){
+         int r1=Find(edge[i].u);
+         int r2=Find(edge[i].v);
+         LL w=(LL)edge[i].w;
+         LL tmp1=cnt[r2]*w+sum[r1];
+         LL tmp2=cnt[r1]*w+sum[r2];
+         if(tmp1>tmp2){
+            Union(r2,r1,tmp1-sum[r1]);
+         }else
+            Union(r1,r2,tmp2-sum[r2]);
+      }
+      printf("%I64d\n",sum[Find(1)]);
+   }
+   return 0;
+}
diff --git a/HDOJ/4426_autoAC.cpp b/HDOJ/4426_autoAC.cpp
new file mode 100644
index 0000000..36197c6
--- /dev/null
+++ b/HDOJ/4426_autoAC.cpp
@@ -0,0 +1,200 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <queue>
+#include <math.h>
+using namespace std;
+const int maxn=4e5+9,maxm=11371111;;
+const long long mod=777777777;
+char a[maxn];
+int dp[maxn];
+unsigned long long sum[maxn],po[maxn];
+int n,m;
+int score[maxn];
+int has[maxm],lon;
+struct D
+{
+    int next,pos,size;
+    long long sum;
+    unsigned long long _key;
+    long long key;
+    bool operator <(const D & xx) const
+    {
+        return key<xx.key;
+    }
+}data[maxn];
+void getpal()
+{
+    int top=0;
+    dp[0]=0,a[0]=-1,a[n+1]=-2;
+    for(int i=1,t,s;i<=n;i++)
+    {
+        if(top+dp[top]<i)
+        {
+            top=i;
+            t=i-1,s=i+1;
+            while(a[t]==a[s]) t--,s++;
+            dp[i]=s-i-1;
+        }
+        else
+        {
+            if(dp[top-(i-top)]+i<top+dp[top])
+            dp[i]=dp[top-(i-top)];
+            else
+            {
+                s=top+dp[top]+1;
+                t=i-(s-i);
+                while(a[t]==a[s]) t--,s++;
+                dp[i]=s-i-1;
+                top=i;
+            }
+        }
+    }
+}
+bool insert(int pos,int size,long long ff)
+{
+    if(a[pos]=='#') pos++;
+    unsigned long long _key=(sum[pos+(size-1)*2]-sum[pos-2]);
+    _key*=po[n-pos];
+    int key=_key%maxm;
+    for(int k=has[key];k!=-1;k=data[k].next)
+    {
+        if(data[k]._key==_key)
+        {
+            data[k].sum+=ff;
+            return false;
+        }
+    }
+    data[++lon].sum=ff;
+    data[lon].pos=pos;
+    data[lon].size=size;
+    data[lon]._key=_key;
+    data[lon].next=has[key];
+    has[key]=lon;
+    return true;
+}
+void getkey()
+{
+    sum[0]=0;
+    for(int i=2;i<=n;i+=2)
+    {
+        sum[i]=sum[i-2];
+        sum[i]+=(a[i]-'a'+1)*po[i];
+    }
+}
+struct R
+{
+    int t,key;
+    bool operator <(const R & xx) const
+    {
+        return key<xx.key;
+    }
+};
+void gethash()
+{
+    memset(has,-1,sizeof(has));
+    lon=0;
+    getkey();
+    for(int i=1;i<=n;i++)
+    if(dp[i]>0)
+    insert(i,dp[i]+1>>1,1);
+    priority_queue <R> q;
+    while(!q.empty()) q.pop();
+    for(int i=1;i<=lon;i++)
+    {
+        R now;
+        now.key=data[i].size;
+        now.t=i;
+        q.push(now);
+    }
+    while(!q.empty())
+    {
+        int pos=data[q.top().t].pos;
+        int size=data[q.top().t].size;
+        long long ff=data[q.top().t].sum;
+        size--;
+        q.pop();
+        if(size&&insert(pos,size,ff))
+        {
+            R now;
+            now.t=lon;
+            now.key=size;
+            q.push(now);
+        }
+    }
+}
+long long nn[maxn],pp[maxn];
+void getkey(int t)
+{
+    data[t].key=nn[data[t].pos];
+    int ff=data[t].pos+data[t].size*2;
+    if(ff>n) return ;
+    long long tmp=(nn[ff]*pp[data[t].size])%mod;
+    data[t].key=((data[t].key+mod-tmp))%mod;
+}
+void getnow()
+{
+    pp[0]=1;
+    for(int i=1;i<=n+1;i++)
+    {
+        pp[i]=(pp[i-1]*26)%mod;
+    }
+    nn[n+1]=0;
+    for(int i=n-1;i>=1;i-=2)
+    {
+        nn[i]=(nn[i+2]*26)%mod;
+        nn[i]=(nn[i]+score[(a[i]-'a'+1)])%mod;
+    }
+}
+void solve(long long num)
+{
+    getnow();
+    for(int i=1;i<=lon;i++)
+    getkey(i);
+    sort(data+1,data+1+lon);
+    long long now=0;
+    for(int i=1;i<=lon;i++)
+    {
+        now+=data[i].sum;
+        if(now>=num)
+        {
+            printf("%I64d\n",data[i].key);
+            break;
+        }
+    }
+    if(now<num)
+    printf("0\n");
+}
+int main()
+{
+    po[0]=1;
+    for(int i=1;i<maxn;i++)
+    po[i]=po[i-1]*27;
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&n,&m);
+        scanf("%s",a+1);
+        for(int i=n;i>=1;i--)
+        {
+            a[i*2]=a[i];
+            a[i*2-1]='#';
+        }
+        n<<=1;
+        a[++n]='#';
+        getpal();
+        gethash();
+        for(int i=1;i<=m;i++)
+        {
+            long long tmp;
+            scanf("%I64d",&tmp);
+            for(int j=1;j<=26;j++)
+            scanf("%d",&score[j]);
+            solve(tmp);
+        }
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4427_autoAC.cpp b/HDOJ/4427_autoAC.cpp
new file mode 100644
index 0000000..1f3c912
--- /dev/null
+++ b/HDOJ/4427_autoAC.cpp
@@ -0,0 +1,68 @@
+#include <iostream>
+#include<stdio.h>
+#include<string.h>
+#include<math.h>
+using namespace std;
+const int maxn=1010;
+const int mod=1000000007;
+int dp[2][maxn][maxn];
+int lcm[maxn][maxn];
+int fac[maxn];
+int gcd(int a,int b)
+{
+    int t;
+    while(b)
+    {
+        t=a%b;
+        a=b;
+        b=t;
+    }
+    return a;
+}
+int main()
+{
+    int n,m,k,cnt,i,j,p,q,e,f,t,v,mul,tt;
+    for(i=1; i<maxn; i++)
+        for(j=i; j<maxn; j++)
+            lcm[i][j]=lcm[j][i]=i*j/gcd(i,j);
+    while(~scanf("%d%d%d",&n,&m,&k))
+    {
+        cnt=0;
+        for(i=1; i<=m; i++)
+        {
+            if(m%i==0)
+                fac[cnt++]=i;
+        }
+        v=0;
+        memset(dp,0,sizeof dp);
+        for(i=0; i<cnt; i++)
+            dp[v][fac[i]][fac[i]]=1;
+        for(i=1; i<k; i++) 
+        {
+            for(e=i; e<=n; e++)
+                for(f=0; f<cnt; f++)
+                    dp[v^1][e][fac[f]]=0;
+            for(j=i; j<n; j++) //sum
+            {
+                for(p=0; p<cnt; p++) 
+                {
+                    mul=fac[p];
+                    if(!dp[v][j][mul])
+                        continue;
+                    for(q=0; q<cnt; q++) 
+                    {
+                        tt=j+fac[q];
+                        if(tt>n)
+                            break;
+                        t=lcm[mul][fac[q]];
+                        dp[v^1][tt][t]+=dp[v][j][mul];
+                        dp[v^1][tt][t]%=mod;
+                    }
+                }
+            }
+            v^=1;
+        }
+        printf("%d\n",dp[v][n][m]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4429_autoAC.cpp b/HDOJ/4429_autoAC.cpp
new file mode 100644
index 0000000..0b9fe9f
--- /dev/null
+++ b/HDOJ/4429_autoAC.cpp
@@ -0,0 +1,170 @@
+#include<stdio.h>
+#include<math.h>
+#include<string.h>
+#include<algorithm>
+#define maxn 2220
+using namespace std;
+struct node{
+    int xl,yl;
+    int xr,yr;
+    int num;
+    int deep;
+    int flag;
+    int l;
+    int r;
+    int fat;
+    void output()
+    {
+        printf("%d %d %d %d\n",xl,yl,xr,yr);
+        printf("l = %d r = %d %d\n",l,r,fat);
+    }
+    bool inside(int x,int y)
+    {
+        return (xl<x && x<xr && yl<y&&y<yr);
+    }
+    bool in(int x,int y)
+    {
+        return (xl<=x && x<=xr && yl<=y&&y<=yr);
+    }
+}seq[maxn];
+int tot;
+int total;
+void build(int xl,int yl,int xr,int yr,int root,int fat)
+{
+    seq[root].xl = xl;
+    seq[root].yl = yl;
+    seq[root].xr = xr;
+    seq[root].yr = yr;
+    seq[root].deep = 0;
+    seq[root].l = 0;
+    seq[root].r = 0;
+    seq[root].flag = 0;
+    seq[root].fat = fat;
+    seq[root].num = 0;
+    return ;
+}
+int n,m;
+int get(int xl,int yl,int xr,int yr)
+{
+    for (int i=tot;i>=1;i--)
+        if (seq[i].flag == 0 && seq[i].in(xl,yl) && seq[i].in(xr,yr))
+            return i;
+    return 0;
+}
+void update(int xl,int yl,int xr,int yr)
+{
+    int root = get(xl,yl,xr,yr);
+    int xxl = seq[root].xl;
+    int yyl = seq[root].yl;
+    int xxr = seq[root].xr;
+    int yyr = seq[root].yr;
+    seq[root].flag = 1;
+    if (xl == xxl){
+        build(xxl,yyl,xr,yr,++tot,root);
+        seq[root].l = tot;
+        build(xl,yl,xxr,yyr,++tot,root);
+        seq[root].r = tot;
+    }else{
+        build(xxl,yyl,xr,yr,++tot,root);
+        seq[root].l = tot;
+        build(xl,yl,xxr,yyr,++tot,root);
+        seq[root].r = tot;
+    }
+    return ;
+}
+int find(int x,int y)
+{
+    for (int i=tot;i>=1;i--)
+        if (seq[i].flag==0 && seq[i].inside(x,y))
+            return i;
+    return 0;
+}
+bool fff[maxn][maxn];
+void dfs(int root,int niuniu)
+{
+    fff[niuniu][root] = true;
+    if (seq[root].l > 0)
+        dfs(seq[root].l,niuniu);
+    if (seq[root].r > 0)
+        dfs(seq[root].r,niuniu);
+    return ;
+}
+void dfs1(int root,int deep)
+{
+    int l = seq[root].l;
+    int r = seq[root].r;
+    seq[root].deep = deep;
+    if (l > 0){
+        dfs1(l,deep+1);
+        seq[root].num += seq[l].num;
+    }
+    if (r > 0){
+        dfs1(r,deep+1);
+        seq[root].num += seq[r].num;
+    }
+    return ;
+}
+void init()
+{
+    total = 0;
+    for (int i=1;i<=tot;i++)
+        if (seq[i].flag==0){
+            seq[i].num = 1;
+            total++;
+        }
+    memset(fff,0,sizeof(fff));
+    dfs1(1,1);
+    for (int i=1;i<=tot;i++)
+        dfs(i,i);
+    return ;
+}
+int solve(int u,int v)
+{
+    for (int i=tot;i>=1;i--)
+    {
+        if (fff[i][u] && fff[i][v]){
+            int res = total - seq[i].num + 1;
+            return res;
+        }
+    }
+    return 0;
+}
+int main()
+{
+    int xl,yl,xr,yr;
+    while (scanf("%d%d%d%d",&xl,&yl,&xr,&yr)==4)
+    {
+        tot = 0;
+        build(xl,yl,xr,yr,++tot,0);
+        scanf("%d%d",&n,&m);
+        for (int i=1;i<=n;i++)
+        {
+            scanf("%d%d%d%d",&xl,&yl,&xr,&yr);
+            if (xl == xr)
+            {
+                if (yl > yr)
+                {
+                    swap(yl,yr);
+                }
+            }
+            if (yl==yr)
+            {
+                if (xl > xr)
+                {
+                    swap(xl,xr);
+                }
+            }
+            update(xl,yl,xr,yr);
+        }
+        init();
+        for (int i=1;i<=m;i++)
+        {
+            scanf("%d%d%d%d",&xl,&yl,&xr,&yr);
+            int p1 = find(xl,yl);
+            int p2 = find(xr,yr);
+            int ans = solve(p1,p2);
+            printf("%d\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4430_autoAC.cpp b/HDOJ/4430_autoAC.cpp
new file mode 100644
index 0000000..bcf46ad
--- /dev/null
+++ b/HDOJ/4430_autoAC.cpp
@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <algorithm>
+using namespace std;
+#define ll __int64
+ll n;
+ll bin(ll s)
+{
+    ll l = 2,r = n,mid,i;
+    while(l<=r)
+    {
+        mid = (l+r)/2;
+        ll sum = 1,ans = 0;;
+        for(i = 1; i<=s; i++)
+        {
+            if(n/sum<mid)
+            {
+                ans = n+1;
+                break;
+            }
+            sum*=mid;
+            ans+=sum;
+            if(ans>n)
+                break;
+        }
+        if(ans == n || ans == n-1) return mid;
+        else if(ans<n-1) l = mid+1;
+        else r = mid-1;
+    }
+    return -1;
+}
+int main()
+{
+    ll s,k,l,r,mid,i;
+    while(~scanf("%I64d",&n))
+    {
+        l = 1,r = n-1;
+        for(i = 2; i<=45; i++)
+        {
+            k = bin(i);
+            if(k!=-1 && i*k<l*r)
+            {
+                l = i,r = k;
+            }
+        }
+        printf("%I64d %I64d\n",l,r);
+    }
+    return 0;
+}
diff --git a/HDOJ/4431_autoAC.cpp b/HDOJ/4431_autoAC.cpp
new file mode 100644
index 0000000..e9d9eca
--- /dev/null
+++ b/HDOJ/4431_autoAC.cpp
@@ -0,0 +1,132 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#include<vector>
+#include<map>
+#include<set>
+#include<queue>
+#include<cmath>
+#define LL long long
+#define mem(a,b) memset(a,b,sizeof(a))
+using namespace std;
+map<string,int>m;
+void Init()
+{
+    m["1m"]=1;m["2m"]=2;m["3m"]=3;
+    m["4m"]=4;m["5m"]=5;m["6m"]=6;
+    m["7m"]=7;m["8m"]=8;m["9m"]=9;
+    m["1s"]=10;m["2s"]=11;m["3s"]=12;
+    m["4s"]=13;m["5s"]=14;m["6s"]=15;
+    m["7s"]=16;m["8s"]=17;m["9s"]=18;
+    m["1p"]=19;m["2p"]=20;m["3p"]=21;
+    m["4p"]=22;m["5p"]=23;m["6p"]=24;
+    m["7p"]=25;m["8p"]=26;m["9p"]=27;
+    m["1c"]=28;m["2c"]=29;m["3c"]=30;
+    m["4c"]=31;m["5c"]=32;m["6c"]=33;
+    m["7c"]=34;
+}
+int c[35];int b[14];
+int c13[13]={1,9,10,18,19,27,28,29,30,31,32,33,34};
+bool judge1()
+{
+    int c1=0,c2=0;
+    for(int i=0;i<13;i++)
+    {
+        if(c[c13[i]]) c1++;
+        if(c[c13[i]]>1) c2++;
+    }
+    if(c1==13&&c2==1) return true;
+    return false;
+}
+bool judge2()
+{
+    for(int i=0;i<14;i+=2)
+    {
+        if((i&&b[i]==b[i-1])||b[i]!=b[i+1]) return false;
+    }
+    return true;
+}
+bool flag;
+bool check(int idx)
+{
+    if(idx>=1&&idx<=7) return true;
+    if(idx>=10&&idx<=16) return true;
+    if(idx>=19&&idx<=25) return true;
+    return false;
+}
+void dfs(int idx,int k1,int k2)
+{
+    if(flag) return;
+    if(k1>4||k2>1) return ;
+    if(idx==14)
+    {
+        if(k1==4&&k2==1){flag=true;}
+        return ;
+    }
+    for(int i=1;i<=34;i++)
+    {
+        int mark=0;
+        if(c[i]>=3) {c[i]-=3;mark++;dfs(idx+3,k1+1,k2);c[i]+=3;}
+        if(c[i]>=2) {c[i]-=2;mark++;dfs(idx+2,k1,k2+1);c[i]+=2;}
+        if(check(i)&&c[i]&&c[i+1]&&c[i+2]) {c[i]--;c[i+1]--;c[i+2]--;mark++;dfs(idx+3,k1+1,k2);c[i]++;c[i+1]++;c[i+2]++;}
+        if(c[i]&&mark==0) return ;
+        if(c[i]) break;
+    }
+}
+int a[14];
+int slove()
+{
+    memcpy(b,a,sizeof(a));
+    sort(b,b+14);
+    mem(c,0);
+    for(int i=0;i<14;i++)
+    {
+        c[b[i]]++;
+        if(c[b[i]]>4)return false;
+    }
+    if(judge1()) return true;
+    if(judge2()) return true;
+    flag=false;
+    dfs(0,0,0);
+    return flag;
+}
+int main()
+{
+    m.clear();
+    Init();
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        for(int i=0;i<13;i++)
+        {
+            string s;
+            cin>>s;
+            a[i]=m[s];
+        }
+        int ans[50],cnt=0;
+        for(int i=1;i<=34;i++)
+        {
+            a[13]=i;
+            if(slove()) ans[cnt++]=i;
+        }
+        if(cnt==0) cout<<"Nooten"<<endl;
+        else
+        {
+            cout<<cnt;
+            for(int i=0;i<cnt;i++)
+            {
+                for(map<string,int>::iterator it=m.begin();it!=m.end();it++)
+                {
+                    if(it->second==ans[i])
+                    {
+                        cout<<" "<<(it->first);
+                        break;
+                    }
+                }
+            }
+            cout<<endl;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4432_autoAC.cpp b/HDOJ/4432_autoAC.cpp
new file mode 100644
index 0000000..b1889a9
--- /dev/null
+++ b/HDOJ/4432_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<string.h>
+#include<math.h>
+using namespace std;
+int bit[100];
+int cnt;
+void change(int n,int base)
+{
+    cnt=0;
+    while(n)
+    {
+        bit[cnt++]=n%base;
+        n/=base;
+    }
+}
+int main()
+{
+    int n,m;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        int sum=0;
+        int t=(int)sqrt(n*1.0);
+        for(int i=1;i<=t;i++)
+        {
+            if(n%i==0)
+            {
+                int tmp=i;
+                while(tmp)
+                {
+                    sum+=((tmp%m)*(tmp%m));
+                    tmp/=m;
+                }
+                tmp=n/i;
+                if(tmp==i)continue;
+                while(tmp)
+                {
+                    sum+=((tmp%m)*(tmp%m));
+                    tmp/=m;
+                }
+            }
+        }
+        change(sum,m);
+        for(int i=cnt-1;i>=0;i--)
+        {
+            if(bit[i]>9)printf("%c",bit[i]-10+'A');
+            else printf("%d",bit[i]);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4433_autoAC.cpp b/HDOJ/4433_autoAC.cpp
new file mode 100644
index 0000000..b9b299a
--- /dev/null
+++ b/HDOJ/4433_autoAC.cpp
@@ -0,0 +1,58 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#define MAXN 1000+100
+using namespace std;
+int f[MAXN][12][12];
+int times[12][12];
+int n,m;
+char s[MAXN],t[MAXN];
+int a[MAXN],b[MAXN];
+int min(int a,int b){return (a<b)?a:b;}
+int main()
+{
+    for (int i=0;i<10;++i){
+        int j=1;
+        while ((i+j)%10!=i) {
+              times[i][(i+j)%10]=j;
+              j++;
+        }
+    }
+    while (scanf("%s%s",s,t)!=EOF)
+    {
+          n=strlen(s);
+          for (int i=0;i<=n;++i)
+              for (int j=0;j<=10;++j)
+              for (int k=0;k<=10;++k) f[i][j][k]=n*10;
+          int ans=n*10;    
+          for (int i=0;i<n;++i) 
+          {
+              a[i+1]=s[i]-'0';
+              b[i+1]=t[i]-'0';
+          }
+          f[0][a[1]][a[2]]=0;
+          for (int i=0;i<n;++i)
+          for (int j=0;j<10;++j)
+          for (int k=0;k<10;++k)
+          if (f[i][j][k]<10*n)
+          {
+              int t=times[j][b[i+1]];               
+              for (int l=0;l<=t;++l)
+                  for(int p=0;p<=l;++p){
+                  f[i+1][(k+l)%10][(a[i+3]+p)%10]=
+                  min(f[i+1][(k+l)%10][(a[i+3]+p)%10],f[i][j][k]+t); 
+              }
+              for (int l=0;l<=10-t;++l)
+                  for(int p=0;p<=l;++p){
+                  f[i+1][(k-l+10)%10][(a[i+3]-p+10)%10]=
+                  min(f[i+1][(k-l+10)%10][(a[i+3]-p+10)%10],f[i][j][k]+10-t);
+              }
+          }
+          for (int i=0;i<10;++i)
+              for (int j=0;j<10;++j)
+              if(f[n][i][j]<ans) ans=f[n][i][j];
+          cout << ans << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4435_autoAC.cpp b/HDOJ/4435_autoAC.cpp
new file mode 100644
index 0000000..656cc9a
--- /dev/null
+++ b/HDOJ/4435_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#define clr(x)memset(x,0,sizeof(x))
+const double eps = 1e-8;
+#define maxn 130
+struct pos
+{
+    double x, y;
+}p[maxn];
+double d[maxn][maxn];
+double dis(pos a, pos b)
+{
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+double D;
+int n;
+int res[maxn];
+bool ok()
+{
+    int tot = 1;
+    int q[maxn];
+    bool v[maxn];
+    int front = 0, rear = 0;
+    int u, i;
+    memset(v,false,sizeof(v));
+    v[0] = true;
+    q[rear++] = 0;
+    while(front < rear)
+    {
+        u = q[front++];
+        for(i=0; i<n; i++)
+        {
+            if(!v[i])
+            {
+                if(res[i] == 1)
+                {
+                    if(d[u][i] < D+eps)
+                    {
+                        v[i] = true;
+                        q[rear++] = i;
+                        tot++;
+                    }
+                }
+                else if(d[u][i] < D/2.0+eps)
+                {
+                    v[i] = true;
+                    tot++;
+                }
+            }
+        }
+    }
+    return tot == n ? true:false;
+}
+int main()
+{
+    int i, j;
+    while(scanf("%d %lf",&n, &D)!=EOF)
+    {
+        for(i=0; i<n; i++)
+            scanf("%lf %lf",&p[i].x, &p[i].y);
+        for(i=0; i<n; i++)
+            for(j=0; j<n; j++)
+                d[i][j] = ceil(dis(p[i], p[j]));
+         for(i=0; i<n; i++)
+            res[i] = 1;
+         int f = 0;
+         for(i=n; i>0; i--)
+         {
+            res[i] = 0;
+            if(!ok()){
+                res[i] = 1;
+                if(i == n)
+                { f = 1;
+                  break;
+                }
+            }
+         }
+         if(f == 1)
+         {
+             printf("-1\n");
+             continue;
+         }
+         int flag = 0;
+         for(i=n-1; i>=0; i--)
+            if(flag || res[i] !=0)
+            {
+                printf("%d",res[i]);
+                flag = 1;
+            }
+        putchar('\n');
+    }
+    return 0;
+}
diff --git a/HDOJ/4436_autoAC.cpp b/HDOJ/4436_autoAC.cpp
new file mode 100644
index 0000000..4177457
--- /dev/null
+++ b/HDOJ/4436_autoAC.cpp
@@ -0,0 +1,95 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <vector>
+#include <map>
+#include <queue>
+#define maxn 300000
+#define MOD 2012
+using namespace std;
+int wa[maxn],wb[maxn],wv[maxn];
+int ran[maxn],height[maxn],wS[maxn],sa[maxn],P[maxn],Pow[maxn],V[maxn],
+T[maxn],Len[maxn],S[maxn],arrive[maxn],n,len,value;
+char s[maxn];
+int cmp(int *r,int a,int b,int l) {return r[a]==r[b]&&r[a+l]==r[b+l];}
+void da(int *r,int *sa,int n,int m)
+{
+     int i,j,p,*x=wa,*y=wb,*t;
+     for(i=0;i<m;i++) wS[i]=0;
+     for(i=0;i<n;i++) wS[x[i]=r[i]]++;
+     for(i=1;i<m;i++) wS[i]+=wS[i-1];
+     for(i=n-1;i>=0;i--) sa[--wS[x[i]]]=i;
+     for(j=1,p=1;p<n;j*=2,m=p)
+     {
+         for(p=0,i=n-j;i<n;i++) y[p++]=i;
+         for(i=0;i<n;i++) if(sa[i]>=j) y[p++]=sa[i]-j;
+         for(i=0;i<n;i++) wv[i]=x[y[i]];
+         for(i=0;i<m;i++) wS[i]=0;
+         for(i=0;i<n;i++) wS[wv[i]]++;
+         for(i=1;i<m;i++) wS[i]+=wS[i-1];
+         for(i=n-1;i>=0;i--) sa[--wS[wv[i]]]=y[i];
+         for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;i<n;i++)
+         x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
+     }
+     return;
+}
+void calheight(int *r,int *sa,int n)
+{
+     int i,j,k=0;
+     for(i=0;i<n;i++) ran[sa[i]]=i;
+     for(i=0;i<n;height[ran[i++]]=k)
+     if(ran[i])for(k?k--:0,j=sa[ran[i]-1];r[i+k]==r[j+k];k++);
+     return;
+}
+int  get(int l,int r)
+{
+     if(l>r) return 0;
+     int ans=(T[r+1]-T[l])%MOD;
+     ans-=V[l]*(Pow[r-l+1]);
+     ans%=MOD;
+     if (ans<0) ans+=MOD;
+     return ans;
+}
+int main()
+{
+    Pow[0]=1;Pow[1]=10;
+    for (int i=2;i<200000;++i) 
+        Pow[i]=(Pow[i-1]+1)*10%MOD;
+    while (scanf("%d",&n)!=EOF)
+    {     
+          len = 0; value = 0;
+          for (int i=0;i < n ;++i){
+              scanf("%s",s);
+              Len[i]= strlen(s);
+              for (int j = 0 ; j < Len[i]; ++j){
+                  S[len]=s[j]-'0'+1;
+                  value = (value*10+S[len]-1)%MOD;
+                  V[len+1]=value;
+                  T[len+1]=(T[len]+value)%MOD;
+                  P[len]=i;
+                  len++;
+              }
+                  S[len]=11;
+                  value = (value*10+10)%MOD;
+                  V[len+1]=value;
+                  T[len+1]=(T[len]+value)%MOD;
+                  P[len]=i;
+                  len++;
+                  arrive[i]=len-2;
+          }
+          S[len-1]=0;
+          da(S,sa,len,12);
+          calheight(S,sa,len);
+          int ans = 0;
+          for (int  i = 0;i < len;++i)
+          if (S[i]%10 !=1){
+              if (i+height[ran[i]]<= arrive[P[i]]){
+               ans+=get(i,arrive[P[i]])-get(i,i+height[ran[i]]-1); 
+               ans%=MOD;if (ans<0) ans+=MOD;           
+               }
+          }
+          cout << ans << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4438_autoAC.cpp b/HDOJ/4438_autoAC.cpp
new file mode 100644
index 0000000..cc8f73c
--- /dev/null
+++ b/HDOJ/4438_autoAC.cpp
@@ -0,0 +1,21 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+int main()
+{
+    int X,Y;
+    double P,Q;
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%lf%lf",&X,&Y,&P,&Q);
+        double ans1=(1-Q)*X+Q*(P*X+P*Y);
+        double ans2=Q*Y+(1-Q)*(P*X+P*Y);
+        if(ans1>ans2)printf("tiger %.4lf\n",ans1);
+        else printf("wolf %.4lf\n",ans2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4439_autoAC.cpp b/HDOJ/4439_autoAC.cpp
new file mode 100644
index 0000000..124110f
--- /dev/null
+++ b/HDOJ/4439_autoAC.cpp
@@ -0,0 +1,104 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+const int maxn = 1011;
+const double eps = 1e-8;
+const double pi = acos(-1.0);
+inline double dcmp(double x) {return (x > eps) - (x < -eps);}
+inline double Sqr(double x) {return x * x;}
+struct Point
+{
+    double x, y, v;
+    Point(){}
+    Point(double x_, double y_){x = x_, y = y_;}
+    double Dis(Point &b){return sqrt(Sqr(x - b.x) + Sqr(y - b.y));}
+};
+Point p[maxn], th;
+int n;
+void AngManage(double &x)
+{
+    while(x + pi < -eps) x += pi + pi;
+    while(x - pi > -eps) x -= pi + pi;
+}
+inline double CounterAng(double s, double e)
+{return e > s + eps ? e - s : pi + pi + e - s;}
+struct Cov
+{
+    double s, e;
+    void Read(double s_, double e_)
+    {
+        AngManage(s_), AngManage(e_);
+        s = s_, e = e_;
+    }
+    bool operator<(const Cov &b)const
+    {
+        if(!dcmp(s - b.s)) return CounterAng(s, e) > CounterAng(b.s, b.e);
+        return s < b.s;
+    }
+} cover[maxn], cc[maxn];
+int main()
+{
+    int t, i, j, k, ans, cnt;
+    bool flag;
+    for(scanf("%d", &t); t --; )
+    {
+        flag = false;
+        scanf("%d", &n);
+        scanf("%lf%lf%lf", &th.v, &th.x, &th.y);
+        for(i = 0; i < n; ++ i)
+        {
+            scanf("%lf%lf%lf", &p[i].v, &p[i].x, &p[i].y);
+            if(p[i].v > th.v + eps || !dcmp(p[i].Dis(th))) flag = true;
+        }
+        if(flag) {printf("1\n"); continue;}
+        if(!dcmp(th.v)) {printf("0\n"); continue;}
+        for(i = 0; i < n; ++ i)
+        {
+            double ang = atan2(p[i].y - th.y, p[i].x - th.x);
+            if(p[i].v > th.v - eps)
+            {
+                cover[i].Read(ang - pi * 0.5, ang + pi * 0.5);
+                continue;
+            }
+            double c = p[i].Dis(th);
+            double T = sqrt(Sqr(c) / (Sqr(th.v) - Sqr(p[i].v)));
+            double cs = acos(c / T / th.v);
+            cover[i].Read(ang - cs, ang + cs);
+        }
+        sort(cover, cover + n);
+        for(i = k = 1; i < n; ++ i)
+            if(dcmp(cover[i].s - cover[i - 1].s)) cover[k ++] = cover[i];
+        n = k;
+        for(i = 0, ans = 0x3f3f3f3f; i < n; ++ i)
+        {
+            for(j = i, k = 0; ; j = (j + 1) % n)
+            {
+                cc[k].Read(cover[j].s - cover[i].s - pi, cover[j].e - cover[i].s - pi);
+                if(cc[k].s > cc[k].e) cc[k].e = pi + pi;
+                ++ k;
+                if(j == (i + n - 1) % n) break;
+            }
+            double now = -pi - pi, nex = -pi;
+            flag = false;
+            for(j = cnt = 0; j < n; ++ j)
+            {
+                if(cc[j].e < now + eps) continue;
+                if(cc[j].s > nex + eps) break;
+                if(cc[j].s > now + eps)
+                {
+                    ++ cnt;
+                    now = nex;
+                }
+                if(cc[j].e > nex + eps) nex = cc[j].e;
+                if(nex > pi - eps) {flag = true; break;}
+            }
+            if(flag) ans = min(ans, cnt);
+        }
+        if(ans == 0x3f3f3f3f) ans = 0;
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4441_autoAC.cpp b/HDOJ/4441_autoAC.cpp
new file mode 100644
index 0000000..b8f56ca
--- /dev/null
+++ b/HDOJ/4441_autoAC.cpp
@@ -0,0 +1,405 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#define MAXD 200010
+typedef long long LL;
+namespace SP
+{
+    int T, node;
+    struct Splay
+    {
+        int ls, rs, pre, size, num[2], key;
+        LL sum;
+        void update(); void zig(int x); void zag(int x); void splay(int x, int goal);
+        void init()
+        {
+            ls = rs = pre = 0;
+            key = size = sum = num[0] = num[1] = 0;
+        }
+    }sp[MAXD];
+    void init()
+    {
+        T = 1, node = 2;
+        sp[0].init(), sp[1].init(), sp[2].init();
+        sp[1].rs = 2, sp[2].pre = 1;
+        sp[1].size = 2, sp[2].size = 1;
+    }
+    inline void Splay::update()
+    {
+        size = sp[ls].size + sp[rs].size + 1;
+        sum = sp[ls].sum + sp[rs].sum + key;
+        num[0] = sp[ls].num[0] + sp[rs].num[0] + (key < 0);
+        num[1] = sp[ls].num[1] + sp[rs].num[1] + (key > 0);
+    }
+    inline void Splay::zig(int x)
+    {
+        int y = rs, fa = pre;
+        rs = sp[y].ls, sp[rs].pre = x;
+        sp[y].ls = x, pre = y;
+        sp[y].pre = fa;
+        if(fa == 0) T = y;
+        else sp[fa].ls == x ? sp[fa].ls = y : sp[fa].rs = y;
+        update();
+    }
+    inline void Splay::zag(int x)
+    {
+        int y = ls, fa = pre;
+        ls = sp[y].rs, sp[ls].pre = x;
+        sp[y].rs = x, pre = y;
+        sp[y].pre = fa;
+        if(fa == 0) T = y;
+        else sp[fa].ls == x ? sp[fa].ls = y : sp[fa].rs = y;
+        update();
+    }
+    void Splay::splay(int x, int goal)
+    {
+        int y, z;
+        for(; pre != goal;)
+        {
+            y = pre;
+            if(sp[y].pre == goal) sp[y].rs == x ? sp[y].zig(y) : sp[y].zag(y);
+            else
+            {
+                z = sp[y].pre;
+                if(sp[z].rs == y)
+                {
+                    if(sp[y].rs == x) sp[z].zig(z), sp[y].zig(y);
+                    else sp[y].zag(y), sp[z].zig(z);
+                }
+                else
+                {
+                    if(sp[y].ls == x) sp[z].zag(z), sp[y].zag(y);
+                    else sp[y].zig(y), sp[z].zag(z);
+                }
+            }
+        }
+        update();
+    }
+    void newnode(int &cur)
+    {
+        cur = ++ node;
+        sp[cur].init();
+    }
+    int insert(int &cur, int fa, int key)
+    {
+        newnode(cur);
+        sp[cur].key = key, sp[cur].pre = fa, sp[cur].update();
+        return cur;
+    }
+    int find(int k)
+    {
+        if(sp[T].size < k) return -1;
+        int i = T;
+        for(;;)
+        {
+            int n = sp[sp[i].ls].size;
+            if(n + 1 == k) break;
+            if(k <= n) i = sp[i].ls;
+            else i = sp[i].rs, k -= n + 1;
+        }
+        return i;
+    }
+}
+int N, D, min[4 * MAXD], loc[MAXD][2];
+void update(int i)
+{
+    for(; i ^ 1; i >>= 1) min[i >> 1] = std::min(min[i], min[i ^ 1]);
+}
+void init()
+{
+    for(D = 1; D < N + 2; D <<= 1);
+    memset(min, 0, sizeof(min[0]) * D * 2);
+    min[D] = 1, update(D);
+    SP::init();
+}
+int find()
+{
+    int i = 1;
+    for(; i < D;)
+    {
+        if(min[i << 1] == 0) i <<= 1;
+        else i = i << 1 | 1;
+    }
+    return i - D;
+}
+void insert(int p)
+{
+    int i = find(), x, y, t;
+    min[D + i] = 1, update(D + i);
+    x = SP::find(p + 1), SP::sp[x].splay(x, 0);
+    y = SP::find(p + 2), SP::sp[y].splay(y, x);
+    t = SP::insert(SP::sp[y].ls, y, i);
+    SP::sp[y].update(), SP::sp[x].update();
+    loc[i][1] = t, SP::sp[t].splay(t, 0);
+    int n = SP::sp[SP::sp[t].ls].num[1] + 1;
+    if(n > SP::sp[t].num[0])
+    {
+        int k = SP::sp[t].size;
+        x = SP::find(k - 1), SP::sp[x].splay(x, 0);
+        y = SP::find(k), SP::sp[y].splay(y, x);
+        t = SP::insert(SP::sp[y].ls, y, -i);
+        SP::sp[y].update(), SP::sp[x].update();
+        loc[i][0] = t;
+    }
+    else
+    {
+        int j = SP::T, k = n;
+        for(;;)
+        {
+            int n = SP::sp[SP::sp[j].ls].num[0], d = SP::sp[j].key < 0;
+            if(d == 1 && n + d == k) break;
+            if(k <= n) j = SP::sp[j].ls;
+            else j = SP::sp[j].rs, k -= n + d;
+        }
+        SP::sp[j].splay(j, 0);
+        x = SP::find(SP::sp[SP::sp[j].ls].size);
+        SP::sp[x].splay(x, j);
+        t = SP::insert(SP::sp[x].rs, x, -i);
+        SP::sp[x].update(), SP::sp[j].update();
+        loc[i][0] = t;
+    }
+}
+void remove(int i)
+{
+    min[D + i] = 0, update(D + i);
+    for(int j = 0; j < 2; j ++)
+    {
+        SP::sp[loc[i][j]].splay(loc[i][j], 0);
+        int x, y, n = SP::sp[SP::sp[SP::T].ls].size + 1;
+        x = SP::find(n - 1), SP::sp[x].splay(x, 0);
+        y = SP::find(n + 1), SP::sp[y].splay(y, x);
+        SP::sp[y].ls = 0;
+        SP::sp[y].update(), SP::sp[x].update();
+    }
+}
+void query(int i)
+{
+    int x = loc[i][1], y = loc[i][0];
+    SP::sp[x].splay(x, 0), SP::sp[y].splay(y, x);
+    printf("%I64d\n", SP::sp[SP::sp[y].ls].sum);
+}
+void solve()
+{
+    char op[10];
+    for(int i = 0; i < N; i ++)
+    {
+        int k;
+        scanf("%s%d", op, &k);
+        if(op[0] == 'i') insert(k);
+        else if(op[0] == 'r') remove(k);
+        else query(k);
+    }
+}
+int main()
+{
+    int t = 0;
+    while(scanf("%d", &N) == 1)
+    {
+        init();
+        printf("Case #%d:\n", ++ t);
+        solve();
+    }
+    return 0;
+}#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#define MAXD 200010
+typedef long long LL;
+namespace SP
+{
+    int T, node;
+    struct Splay
+    {
+        int ls, rs, pre, size, num[2], key;
+        LL sum;
+        void update(); void zig(int x); void zag(int x); void splay(int x, int goal);
+        void init()
+        {
+            ls = rs = pre = 0;
+            key = size = sum = num[0] = num[1] = 0;
+        }
+    }sp[MAXD];
+    void init()
+    {
+        T = 1, node = 2;
+        sp[0].init(), sp[1].init(), sp[2].init();
+        sp[1].rs = 2, sp[2].pre = 1;
+        sp[1].size = 2, sp[2].size = 1;
+    }
+    inline void Splay::update()
+    {
+        size = sp[ls].size + sp[rs].size + 1;
+        sum = sp[ls].sum + sp[rs].sum + key;
+        num[0] = sp[ls].num[0] + sp[rs].num[0] + (key < 0);
+        num[1] = sp[ls].num[1] + sp[rs].num[1] + (key > 0);
+    }
+    inline void Splay::zig(int x)
+    {
+        int y = rs, fa = pre;
+        rs = sp[y].ls, sp[rs].pre = x;
+        sp[y].ls = x, pre = y;
+        sp[y].pre = fa;
+        if(fa == 0) T = y;
+        else sp[fa].ls == x ? sp[fa].ls = y : sp[fa].rs = y;
+        update();
+    }
+    inline void Splay::zag(int x)
+    {
+        int y = ls, fa = pre;
+        ls = sp[y].rs, sp[ls].pre = x;
+        sp[y].rs = x, pre = y;
+        sp[y].pre = fa;
+        if(fa == 0) T = y;
+        else sp[fa].ls == x ? sp[fa].ls = y : sp[fa].rs = y;
+        update();
+    }
+    void Splay::splay(int x, int goal)
+    {
+        int y, z;
+        for(; pre != goal;)
+        {
+            y = pre;
+            if(sp[y].pre == goal) sp[y].rs == x ? sp[y].zig(y) : sp[y].zag(y);
+            else
+            {
+                z = sp[y].pre;
+                if(sp[z].rs == y)
+                {
+                    if(sp[y].rs == x) sp[z].zig(z), sp[y].zig(y);
+                    else sp[y].zag(y), sp[z].zig(z);
+                }
+                else
+                {
+                    if(sp[y].ls == x) sp[z].zag(z), sp[y].zag(y);
+                    else sp[y].zig(y), sp[z].zag(z);
+                }
+            }
+        }
+        update();
+    }
+    void newnode(int &cur)
+    {
+        cur = ++ node;
+        sp[cur].init();
+    }
+    int insert(int &cur, int fa, int key)
+    {
+        newnode(cur);
+        sp[cur].key = key, sp[cur].pre = fa, sp[cur].update();
+        return cur;
+    }
+    int find(int k)
+    {
+        if(sp[T].size < k) return -1;
+        int i = T;
+        for(;;)
+        {
+            int n = sp[sp[i].ls].size;
+            if(n + 1 == k) break;
+            if(k <= n) i = sp[i].ls;
+            else i = sp[i].rs, k -= n + 1;
+        }
+        return i;
+    }
+}
+int N, D, min[4 * MAXD], loc[MAXD][2];
+void update(int i)
+{
+    for(; i ^ 1; i >>= 1) min[i >> 1] = std::min(min[i], min[i ^ 1]);
+}
+void init()
+{
+    for(D = 1; D < N + 2; D <<= 1);
+    memset(min, 0, sizeof(min[0]) * D * 2);
+    min[D] = 1, update(D);
+    SP::init();
+}
+int find()
+{
+    int i = 1;
+    for(; i < D;)
+    {
+        if(min[i << 1] == 0) i <<= 1;
+        else i = i << 1 | 1;
+    }
+    return i - D;
+}
+void insert(int p)
+{
+    int i = find(), x, y, t;
+    min[D + i] = 1, update(D + i);
+    x = SP::find(p + 1), SP::sp[x].splay(x, 0);
+    y = SP::find(p + 2), SP::sp[y].splay(y, x);
+    t = SP::insert(SP::sp[y].ls, y, i);
+    SP::sp[y].update(), SP::sp[x].update();
+    loc[i][1] = t, SP::sp[t].splay(t, 0);
+    int n = SP::sp[SP::sp[t].ls].num[1] + 1;
+    if(n > SP::sp[t].num[0])
+    {
+        int k = SP::sp[t].size;
+        x = SP::find(k - 1), SP::sp[x].splay(x, 0);
+        y = SP::find(k), SP::sp[y].splay(y, x);
+        t = SP::insert(SP::sp[y].ls, y, -i);
+        SP::sp[y].update(), SP::sp[x].update();
+        loc[i][0] = t;
+    }
+    else
+    {
+        int j = SP::T, k = n;
+        for(;;)
+        {
+            int n = SP::sp[SP::sp[j].ls].num[0], d = SP::sp[j].key < 0;
+            if(d == 1 && n + d == k) break;
+            if(k <= n) j = SP::sp[j].ls;
+            else j = SP::sp[j].rs, k -= n + d;
+        }
+        SP::sp[j].splay(j, 0);
+        x = SP::find(SP::sp[SP::sp[j].ls].size);
+        SP::sp[x].splay(x, j);
+        t = SP::insert(SP::sp[x].rs, x, -i);
+        SP::sp[x].update(), SP::sp[j].update();
+        loc[i][0] = t;
+    }
+}
+void remove(int i)
+{
+    min[D + i] = 0, update(D + i);
+    for(int j = 0; j < 2; j ++)
+    {
+        SP::sp[loc[i][j]].splay(loc[i][j], 0);
+        int x, y, n = SP::sp[SP::sp[SP::T].ls].size + 1;
+        x = SP::find(n - 1), SP::sp[x].splay(x, 0);
+        y = SP::find(n + 1), SP::sp[y].splay(y, x);
+        SP::sp[y].ls = 0;
+        SP::sp[y].update(), SP::sp[x].update();
+    }
+}
+void query(int i)
+{
+    int x = loc[i][1], y = loc[i][0];
+    SP::sp[x].splay(x, 0), SP::sp[y].splay(y, x);
+    printf("%I64d\n", SP::sp[SP::sp[y].ls].sum);
+}
+void solve()
+{
+    char op[10];
+    for(int i = 0; i < N; i ++)
+    {
+        int k;
+        scanf("%s%d", op, &k);
+        if(op[0] == 'i') insert(k);
+        else if(op[0] == 'r') remove(k);
+        else query(k);
+    }
+}
+int main()
+{
+    int t = 0;
+    while(scanf("%d", &N) == 1)
+    {
+        init();
+        printf("Case #%d:\n", ++ t);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4442_autoAC.cpp b/HDOJ/4442_autoAC.cpp
new file mode 100644
index 0000000..560e50e
--- /dev/null
+++ b/HDOJ/4442_autoAC.cpp
@@ -0,0 +1,35 @@
+#include"stdio.h"
+#include"string.h"
+#include"stdlib.h"
+struct A
+{
+    __int64 a,b;
+}E[100011];
+int cmp(const void *a,const void *b)
+{
+    struct A *c,*d;
+    c=(struct A *)a;
+    d=(struct A *)b;
+    __int64 t1,t2;
+    t1=(c->a)*(d->b);
+    t2=(d->a)*(c->b);
+    if(t1>t2)   return 1;
+    else        return -1;
+}
+int main()
+{
+    int n;
+    int i,l;
+    int temp;
+    __int64 ans;
+    while(scanf("%d",&n),n)
+    {
+        for(i=0;i<n;i++)    scanf("%I64d%I64d",&E[i].a,&E[i].b);
+        qsort(E,n,sizeof(E[0]),cmp);
+        ans=0;
+        temp=365*24*60*60;
+        for(i=0;i<n;i++)    {ans+=E[i].a+ans*E[i].b;ans%=temp;}
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4443_autoAC.cpp b/HDOJ/4443_autoAC.cpp
new file mode 100644
index 0000000..7f130a6
--- /dev/null
+++ b/HDOJ/4443_autoAC.cpp
@@ -0,0 +1,453 @@
+#pragma comment(linker, "/STACK:102400000,102400000")  
+#include<iostream>  
+#include<vector>  
+#include<algorithm>  
+#include<cstdio>  
+#include<queue>  
+#include<stack>  
+#include<string>  
+#include<map>  
+#include<set>  
+#include<cmath>  
+#include<cassert>  
+#include<cstring>  
+#include<iomanip>  
+using namespace std;  
+#ifdef _WIN32  
+#define i64 __int64  
+#define out64 "%I64d\n"  
+#define in64 "%I64d"  
+#else  
+#define i64 long long  
+#define out64 "%lld\n"  
+#define in64 "%lld"  
+#endif  
+#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)  
+#define FF(i,a)        for( int i = 0 ; i < (a) ; i ++)  
+#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)  
+#define S64(a)          scanf(in64,&a)  
+#define SS(a)           scanf("%d",&a)  
+#define LL(a)           ((a)<<1)  
+#define RR(a)           (((a)<<1)+1)  
+#define pb              push_back  
+#define pf              push_front  
+#define X               first  
+#define Y               second  
+#define CL(Q)           while(!Q.empty())Q.pop()  
+#define MM(name,what)   memset(name,what,sizeof(name))  
+#define MC(a,b)         memcpy(a,b,sizeof(b))  
+#define MAX(a,b)        ((a)>(b)?(a):(b))  
+#define MIN(a,b)        ((a)<(b)?(a):(b))  
+#define read            freopen("in.txt","r",stdin)  
+#define write           freopen("out.txt","w",stdout)  
+const int inf = 0x3f3f3f3f;  
+const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;  
+const double oo = 10e9;  
+const double eps = 10e-9;  
+const double pi = acos(-1.0);  
+const int maxn = 100011;  
+vector<int>v[maxn];  
+vector<int>g[maxn];  
+vector<int>s;  
+int n;  
+double nn;  
+int t[maxn];  
+int f[maxn];  
+int dfn[maxn];  
+int low[maxn];  
+int df,nf;  
+bool ins[maxn];  
+int tot;  
+bool hash[maxn];  
+int yes[33];  
+double go[33][33];  
+double back[33][33];  
+double dpx[maxn];  
+double dpy[maxn];  
+bool vis[maxn];  
+int cnt[maxn];  
+double dp[maxn];  
+double dps[maxn];  
+vector<double>ans;  
+void tarjan(int now)  
+{  
+    low[now] = dfn[now] = df++;  
+    s.push_back(now);  
+    ins[now]=true;  
+    int to;  
+    for(int i=0;i<g[now].size();i++)  
+    {  
+        to = g[now][i];  
+        if(!dfn[to])  
+        {  
+            t[to]=now;  
+            tarjan(to);  
+            low[now] = min(low[to],low[now]);  
+        }  
+        else if(to!=t[now])  
+        {  
+            low[now]=min(dfn[to],low[now]);  
+        }  
+    }  
+    if(dfn[now] == low[now])  
+    {  
+        while(s.back() != now)  
+        {  
+            to = s.back();  
+            f[to] = nf;  
+            s.pop_back();  
+            ins[to]=false;  
+        }  
+        to = s.back();  
+        s.pop_back();  
+        ins[to]=false;  
+        f[to] = nf++;  
+    }  
+    return ;  
+}  
+void dfs(int now)  
+{  
+    vis[now] = true;  
+    int to;  
+    for(int i=0;i<g[now].size();i++)  
+    {  
+        to = g[now][i];  
+        if(!ins[to] && !vis[to])  
+        {  
+            cnt[now]++;  
+        }  
+    }  
+    for(int i=0;i<g[now].size();i++)  
+    {  
+        to = g[now][i];  
+        if(!ins[to] && !vis[to])  
+        {  
+            dfs(to);  
+            dps[now]+=dpx[to];  
+            if(ins[now])  
+            {  
+                dpx[now]+=2.0*dpx[to]/double(cnt[now]+1.0);  
+            }  
+            else  
+            {  
+                dpx[now]+=dpx[to]/double(cnt[now]);  
+            }  
+        }  
+    }  
+    if(ins[now])  
+    {  
+        double temp = 2.0/double(cnt[now]+2.0);  
+        dpx[now] += nn*temp;  
+    }  
+    else  
+    {  
+        double temp = 1.0/double(cnt[now]+1.0);  
+        dpx[now] += nn*temp;  
+    }  
+    return ;  
+}  
+void df2(int now)  
+{  
+    vis[now]=true;  
+    int to;  
+    for(int i=0;i<g[now].size();i++)  
+    {  
+        to = g[now][i];  
+        if(!ins[to] && !vis[to])  
+        {  
+            dpy[to] = dpy[now]/double(cnt[now]);  
+            dpy[to] += nn*double(cnt[to])/double(cnt[to]+1.0);  
+            if(ins[now])  
+            {  
+                dpy[to]+=(dps[now]-dpx[to])/(cnt[now]+1.0);  
+            }  
+            else  
+            {  
+                dpy[to]+=(dps[now]-dpx[to])/double(cnt[now]);  
+            }  
+            df2(to);  
+        }  
+    }  
+    if(!cnt[now])  
+    {  
+        dp[now] = dpy[now];  
+    }  
+    return ;  
+}  
+void find()  
+{  
+    int now=s[0];  
+    int to;  
+    vis[now] = true;  
+    bool ok;  
+    while(true)  
+    {  
+        ok = false;  
+        for(int i=0;i<g[now].size();i++)  
+        {  
+            to = g[now][i];  
+            if(ins[to] && !vis[to])  
+            {  
+                vis[to]=true;  
+                s.pb(to);  
+                now = to;  
+                ok = true;  
+                break;  
+            }  
+        }  
+        if(!ok) break;  
+    }  
+    return ;  
+}  
+void start()  
+{  
+    for(int i=0;i<=n;i++)  
+    {  
+        f[i]=0;  
+        t[i]=0;  
+        dfn[i]=0;  
+        low[i]=0;  
+        ins[i]=false;  
+    }  
+    s.clear();  
+    df=nf=1;  
+    tarjan(1);  
+    nf--;  
+    for(int i=1;i<=n;i++)  
+    {  
+        v[f[i]].pb(i);  
+    }  
+    int tv;  
+    for(int i=1;i<=nf;i++)  
+    {  
+        if(v[i].size()>1)  
+        {  
+            tv=i;  
+            break;  
+        }  
+    }  
+    s.clear();  
+    tot = v[tv].size();  
+    for(int i=0;i<=n;i++)  
+    {  
+        ins[i]=false;  
+        vis[i]=false;  
+    }  
+    for(int i=0;i<v[tv].size();i++)  
+    {  
+        ins[v[tv][i]] = true;  
+    }  
+    s.pb(v[tv][0]);  
+    find();  
+    int now,to;  
+    MM(yes,0);  
+    for(int i=0;i<s.size();i++)  
+    {  
+        now = s[i];  
+        for(int j=0;j<g[now].size();j++)  
+        {  
+            to = g[now][j];  
+            if(!ins[to])  
+            {  
+                yes[i]++;  
+            }  
+        }  
+    }  
+    MM(go,0);  
+    MM(back,0);  
+    int ss = s.size();  
+    for(int i=0;i<ss;i++)  
+    {  
+        if(yes[i])  
+        {  
+            go[i][(i+1)%ss]=1.0/(yes[i]+1.0);  
+            back[i][(i-1+ss)%ss]=1.0/(yes[i]+1.0);  
+        }  
+        else  
+        {  
+            go[i][(i+1)%ss]=1.0;  
+            back[i][(i-1+ss)%ss]=1.0;  
+        }  
+    }  
+    for(int u=2;u<ss;u++)  
+    {  
+        for(int i=0;i<ss;i++)  
+        {  
+            go[i][(i+u)%ss]=go[i][(i+u-1)%ss]*go[(i+u-1)%ss][(i+u)%ss];  
+            back[i][(i-u+ss)%ss]=back[i][(i-(u-1)+ss)%ss]*back[(i-(u-1)+ss)%ss][(i-u+ss)%ss];  
+        }  
+    }  
+    for(int i=0;i<=n;i++)  
+    {  
+        vis[i]=false;  
+        dpx[i]=0;  
+        dpy[i]=0;  
+        dp[i]=0;  
+        dps[i]=0;  
+        cnt[i]=0;  
+    }  
+    double temp;  
+    for(int i=0;i<ss;i++)  
+    {  
+        if(yes[i])  
+        {  
+            dfs(s[i]);  
+        }  
+    }  
+    for(int i=0;i<ss;i++)  
+    {  
+        if(!yes[i]) continue;  
+        for(int j=0;j<ss;j++)  
+        {  
+            if(j==i)  
+            {  
+                temp = double(yes[i])/(yes[i]+2.0);  
+                dpy[s[j]]+=temp*nn;  
+                continue;  
+            }  
+            if(!yes[j]) continue;  
+            temp = dpx[s[i]]*go[i][j];  
+            temp *= yes[i]+1.0;  
+            temp /= 2.0;  
+            if((i-j+ss)%ss==1)  
+            {  
+                dpy[s[j]]+=temp;  
+            }  
+            else  
+            {  
+                temp/=yes[j]+1.0;  
+                temp*=yes[j];  
+                dpy[s[j]]+=temp;  
+            }  
+            temp = dpx[s[i]]*back[i][j];  
+            temp *= yes[i]+1.0;  
+            temp /= 2.0;  
+            if((i-j+ss)%ss==ss-1)  
+            {  
+                dpy[s[j]]+=temp;  
+            }  
+            else  
+            {  
+                temp/=yes[j]+1.0;  
+                temp*=yes[j];  
+                dpy[s[j]]+=temp;  
+            }  
+        }  
+    }  
+    for(int i=0;i<ss;i++)  
+    {  
+        if(yes[i]) continue;  
+        for(int j=0;j<ss;j++)  
+        {  
+            if(yes[j])  
+            {  
+                temp = nn*go[i][j]*0.5;  
+                if((i-j+ss)%ss==1)  
+                {  
+                    dpy[s[j]]+=temp;  
+                }  
+                else  
+                {  
+                    temp/=yes[j]+1.0;  
+                    temp*=yes[j];  
+                    dpy[s[j]]+=temp;  
+                }  
+                temp = nn*back[i][j]*0.5;  
+                if((i-j+ss)%ss==ss-1)  
+                {  
+                    dpy[s[j]]+=temp;  
+                }  
+                else  
+                {  
+                    temp/=yes[j]+1.0;  
+                    temp*=yes[j];  
+                    dpy[s[j]]+=temp;  
+                }  
+            }  
+        }  
+    }    
+    for(int i=0;i<=n;i++)  
+    {  
+        vis[i]=0;  
+    }  
+    for(int i=0;i<ss;i++)  
+    {  
+        if(yes[i])  
+        {  
+            df2(s[i]);  
+        }  
+    }  
+    for(int i=0;i<ss;i++) if(yes[i])  
+    {  
+        if(!yes[(i+1)%ss])  
+        {  
+            temp = dpx[s[i]]*back[i][(i+1)%ss];  
+            temp *= yes[i]+1.0;  
+            temp /= 2.0;  
+            dp[s[(i+1)%ss]] += temp;  
+        }  
+        if(!yes[(i-1+ss)%ss])  
+        {  
+            temp = dpx[s[i]]*go[i][(i-1+ss)%ss];  
+            temp *= yes[i]+1.0;  
+            temp /= 2.0;  
+            dp[s[(i-1+ss)%ss]] += temp;  
+        }  
+    }  
+    for(int i=0;i<ss;i++) if(!yes[i])  
+    {  
+        if(!yes[(i+1)%ss])  
+        {  
+            dp[s[(i+1)%ss]] += nn*back[i][(i+1)%ss]*0.5;  
+        }  
+        if(!yes[(i-1+ss)%ss])  
+        {  
+            dp[s[(i-1+ss)%ss]] += nn*go[i][(i-1+ss)%ss]*0.5;  
+        }  
+    }  
+    ans.clear();  
+    for(int i=1;i<=n;i++)  
+    {  
+        if(dp[i]>eps)  
+        {  
+            ans.pb(dp[i]);  
+        }  
+    }  
+    for(int i=1;i<=5;i++)  
+    {  
+        ans.pb(0.0);  
+    }  
+    sort(ans.begin(),ans.end());  
+    return ;  
+}  
+int main()  
+{  
+    while(cin>>n)  
+    {  
+        if(!n) return 0;  
+        nn = n;  
+        nn = 1.0/nn;  
+        for(int i=0;i<=n;i++)  
+        {  
+            v[i].clear();  
+            g[i].clear();  
+        }  
+        int now,to;  
+        for(int i=1;i<=n;i++)  
+        {  
+            SS(now);  
+            SS(to);  
+            g[now].pb(to);  
+            g[to].pb(now);  
+        }  
+        start();  
+        double re=0.0;  
+        int ix = ans.size()-1;  
+        for(int i=1;i<=5;i++)  
+        {  
+            re+=ans[ix--];  
+        }  
+        printf("%.5lf\n",re);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4444_autoAC.cpp b/HDOJ/4444_autoAC.cpp
new file mode 100644
index 0000000..c187fb5
--- /dev/null
+++ b/HDOJ/4444_autoAC.cpp
@@ -0,0 +1,161 @@
+#include <cstdio>
+#include <cstring>
+#include <queue>
+#include <stack>
+#include <algorithm>
+#include <cmath>
+#include <map>
+#include <iostream>
+using namespace std;
+const int INF = 0x3f3f3f3f;
+const int N=109;
+bool visit[N<<1][N<<1];
+map<int,int> mpx;
+map<int,int> mpy;
+int n;
+struct cpoint{
+    int x,y;
+    void get()
+    {
+         scanf("%d%d",&x,&y);x<<=1;y<<=1;
+    }
+} st,en,re[59][2];
+int hashx[N<<1],hashy[N<<1],cnx,cny;
+bool  can[N][N][4][4];
+void init()
+{
+    mpx.clear();mpy.clear();
+    memset(can,false,sizeof(can));
+    cnx=0;cny=0;
+    for(int i=0;i<n;i++)
+    {
+        hashx[cnx++] = re[i][0].x;
+        hashx[cnx++] = re[i][0].x+1;
+        hashx[cnx++] = re[i][1].x;
+        hashx[cnx++] = re[i][1].x+1;
+        hashy[cny++] = re[i][0].y;
+        hashy[cny++] = re[i][0].y+1;
+        hashy[cny++] = re[i][1].y;
+        hashy[cny++] = re[i][1].y+1;
+    }
+    sort(hashx,hashx+cnx);sort(hashy,hashy+cny);
+    int tx=0,ty=0;
+    mpx[hashx[0]] = 0;
+    mpy[hashy[0]] = 0;
+    for(int i=1;i<cnx;i++)
+    if(hashx[tx]!=hashx[i])
+    {
+        hashx[++tx] = hashx[i];
+        mpx[hashx[i]] = tx;
+    }
+    for(int i=1;i<cny;i++)
+    if(hashy[ty]!=hashy[i])
+    {
+        hashy[++ty] = hashy[i];
+        mpy[hashy[i]] = ty;
+    }
+    cnx = tx+1,cny = ty+1;
+    memset(visit,true,sizeof(visit));
+    for(int i=1;i<n;i++)
+    {
+        int X = mpx[re[i][1].x],Y = mpy[re[i][1].y];
+        for(int j=mpx[re[i][0].x]+1;j<=X;j++)
+        for(int k=mpy[re[i][0].y]+1;k<=Y;k++)
+        visit[j][k] = 0;
+    }
+    cnx>>=1;cny>>=1;
+    for(int i=0;i<cnx;i++)
+    for(int j=0;j<cny;j++)
+    {
+        if((visit[i<<1][j<<1]&&visit[i<<1][j<<1|1])||(visit[i<<1|1][j<<1]&&visit[i<<1|1][j<<1|1]))
+            can[i][j][3][3] = can[i][j][1][1] = 1;
+        if((visit[i<<1][j<<1]&&visit[i<<1|1][j<<1])||(visit[i<<1][j<<1|1]&&visit[i<<1|1][j<<1|1]))
+            can[i][j][2][2] = can[i][j][0][0] = 1;
+        if(visit[i<<1][j<<1])
+            can[i][j][2][3] = can[i][j][1][0] = 1;
+        if(visit[i<<1][j<<1|1])
+            can[i][j][2][1] = can[i][j][3][0] = 1;
+        if(visit[i<<1|1][j<<1])
+            can[i][j][0][3] = can[i][j][1][2] = 1;
+        if(visit[i<<1|1][j<<1|1])
+            can[i][j][0][1] = can[i][j][3][2] = 1;
+        if(visit[i<<1][j<<1]&&visit[i<<1][j<<1|1]&&visit[i<<1|1][j<<1])
+            can[i][j][0][1] = can[i][j][3][2] = 1;
+        if(visit[i<<1][j<<1]&&visit[i<<1][j<<1|1]&&visit[i<<1|1][j<<1|1])
+            can[i][j][1][2] = can[i][j][0][3] = 1;
+        if(visit[i<<1][j<<1]&&visit[i<<1|1][j<<1]&&visit[i<<1|1][j<<1|1])
+            can[i][j][2][1] = can[i][j][3][0] = 1;
+        if(visit[i<<1][j<<1|1]&&visit[i<<1|1][j<<1]&&visit[i<<1|1][j<<1|1])
+            can[i][j][1][0] = can[i][j][2][3] = 1;
+    }
+}
+queue<int> que;
+bool oor(int x,int y)
+{
+    if(x<0||x>=cnx) return false;
+    if(y<0||y>=cny) return false;
+    return true;
+}
+int dx[] = {-1,0,1,0};
+int dy[] = {0,1,0,-1};
+int dis[N][N][4];
+bool in[N][N][4];
+void solve()
+{
+    memset(in,0,sizeof(in));
+    memset(dis,INF,sizeof(dis));
+    while(!que.empty()) que.pop();
+    int stx=mpx[st.x]/2,sty=mpy[st.y]/2,enx=mpx[en.x]/2,eny=mpy[en.y]/2;
+    for(int i=0;i<4;i++)
+    {
+        que.push((stx<<12)|(sty<<2)|i);
+        dis[stx][sty][i]= 0;
+    }
+    while(!que.empty())
+    {
+        int e = que.front(); que.pop();
+        int ed,ex,ey;
+        ed = e&3;e>>=2;
+        ey = e&1023;e>>=10;
+        ex = e;
+        in[ex][ey][ed] = false;
+        for(int i=0;i<4;i++)
+        {
+            int tx=ex+dx[i],ty=ey+dy[i];
+            if(i==ed&&oor(tx,ty)&&can[ex][ey][ed][i]&&dis[tx][ty][i]>dis[ex][ey][ed])
+            {
+                dis[tx][ty][i]=dis[ex][ey][ed];
+                if(!in[tx][ty][i]) que.push((tx<<12)|(ty<<2)|i);
+            }
+            else if(i!=ed&&oor(tx,ty)&&can[ex][ey][ed][i]&&dis[tx][ty][i]>dis[ex][ey][ed]+1)
+            {
+                dis[tx][ty][i]=dis[ex][ey][ed]+1;
+                if(!in[tx][ty][i]) que.push((tx<<12)|(ty<<2)|i);
+            }
+        }
+    }
+    int ans=INF;
+    for(int i=0;i<4;i++)
+    ans = min(dis[enx][eny][i],ans);
+    printf("%d\n",ans==INF?-1:ans);
+}
+int main()
+{
+    while(~scanf("%d%d%d%d",&st.x,&st.y,&en.x,&en.y))
+    {
+        if(st.x==0&&st.y==0&&en.x==0&&en.y==0) break;
+        st.x<<=1;st.y<<=1;en.x<<=1;en.y<<=1;
+        re[0][0] = st;
+        re[0][1] = en;
+        scanf("%d",&n);n+=1;
+        for(int i=1;i<n;i++)
+        {
+            re[i][0].get(),re[i][1].get();
+            if(re[i][0].x>re[i][1].x) swap(re[i][0].x,re[i][1].x);
+            if(re[i][0].y>re[i][1].y) swap(re[i][0].y,re[i][1].y);
+        }
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4445_autoAC.cpp b/HDOJ/4445_autoAC.cpp
new file mode 100644
index 0000000..01b6608
--- /dev/null
+++ b/HDOJ/4445_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<cstdio>
+#include<cmath>
+const double PI=acos(-1.0);
+const double eps=PI/276;
+int n;
+double h,l1,r1,l2,r2,v[200];
+int cal(double x)
+{
+    int i,c=0;
+    for(i=0;i<n;i++)
+    {
+        double v0=v[i]*sin(x),v1=v[i]*cos(x);
+        double t=(sqrt(2*9.8*h+v1*v1)-v1)/9.8;
+        double s=v0*t;
+        if(s>=l2&&s<=r2) return 0;
+        if(s>=l1&&s<=r1) c++;
+    }
+    return c;
+}
+int main()
+{
+    int i,ans;
+    while(scanf("%d",&n),n)
+    {
+        scanf("%lf%lf%lf%lf%lf",&h,&l1,&r1,&l2,&r2);
+        for(i=0;i<n;i++)scanf("%lf",&v[i]);
+        double j=0;ans=0;
+        while(j<PI)
+        {
+            int tmp=cal(j);
+            if(tmp>ans) ans=tmp;
+            j+=eps;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4446_autoAC.cpp b/HDOJ/4446_autoAC.cpp
new file mode 100644
index 0000000..eaef64a
--- /dev/null
+++ b/HDOJ/4446_autoAC.cpp
@@ -0,0 +1,127 @@
+#include <iostream>
+#include <queue>
+#include <cstring>
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1|1
+using namespace std;
+const int ma=1000010;
+const int inf=1<<25;
+int n;
+int c[ma<<2];
+int rc[ma];
+int add[ma<<2];
+int rrt;
+void pushup(int rt)
+{
+     c[rt]=min(c[rt<<1],c[rt<<1|1]);
+}
+void pushdown(int rt,int m)
+{
+     if(add[rt])
+     {
+         add[rt<<1]+=add[rt];
+         add[rt<<1|1]+=add[rt];
+         c[rt<<1]+=add[rt];
+         c[rt<<1|1]+=add[rt];
+         add[rt]=0;
+     }
+}
+void build(int l,int r,int rt)
+{
+     add[rt]=0;
+     if(l==r)
+     {
+           scanf("%d",&c[rt]);
+           return ;
+     }
+     int m=(l+r)>>1;
+     build (lson);
+     build (rson);
+     pushup(rt);
+} 
+int query(int l,int r,int rt)
+{
+    if(l==r){rrt=rt;return l;}
+    pushdown(rt,r-l+1);
+    int m=(l+r)>>1;
+    if(c[rt<<1]<=c[rt<<1|1])
+    return query(lson);
+    else return query(rson);
+}
+void update(int L,int R,int l,int r,int rt)
+{
+    if(L<=l&&r<=R)
+    {
+        add[rt]--;
+        c[rt]--;
+        return ;
+    }
+    pushdown(rt,r-1+1);
+    int m=(l+r)>>1;
+    if(L<=m) update(L,R,lson);
+    if(m<R)update(L,R,rson); 
+    pushup(rt);
+}
+void update2(int p,int l,int r,int rt)
+{
+     if(l==r)
+     {
+         c[rt]=inf;
+         return ;
+     }
+     int m=(l+r)>>1;
+     if(p<=m)update2(p,lson);
+     else update2(p,rson);
+     pushup(rt);
+}
+int main()
+{
+    while(scanf("%d",&n),n)
+    {
+        int id=0;
+        int flag=0;
+        build(1,n,1);
+        queue <int> a;
+        queue <int> b;
+        while(a.size()+b.size()!=2*n)
+        {
+            int qq=query(1,n,1);
+            if(c[rrt]<0)
+            {
+                    flag=1;break;
+            } 
+            if(c[rrt]==0)
+            {
+                 a.push(qq);
+                 b.push(-qq);
+                 if(qq!=1)
+                 update(1,qq-1,1,n,1);                
+                 update2(qq,1,n,1);
+            }
+            else
+            {
+                if(b.size()==0){flag=1;break;}
+                int t=b.front();
+                if(-t<n)
+                update(-t+1,n,1,n,1);
+                b.pop();
+                a.push(t);
+            }
+        }
+        if(flag)
+        {
+                printf("Impossible\n");
+                }else{
+                      int d[200010];
+                      int i=0; 
+        while(a.size()!=0)
+        {d[i++]=a.front();a.pop();} 
+        while(b.size()!=0)
+        {d[i++]=b.front();b.pop();} 
+        for(i=2*n-1;i>=0;i--)
+        printf("%d ",d[i]);
+        puts("");
+        }
+    }
+    return 0; 
+}
diff --git a/HDOJ/4447_autoAC.cpp b/HDOJ/4447_autoAC.cpp
new file mode 100644
index 0000000..5325b26
--- /dev/null
+++ b/HDOJ/4447_autoAC.cpp
@@ -0,0 +1,124 @@
+#include<iostream>
+#include<sstream>
+#include<fstream>
+#include<vector>
+#include<list>
+#include<deque>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<bitset>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cctype>
+#include<cmath>
+#include<ctime>
+#include<iomanip>
+using namespace std;
+const double eps(1e-8);
+typedef long long lint;
+#define maxn 1110
+vector <int> v[maxn];
+struct polynomial
+{
+    int coe[maxn];
+    int len;
+    polynomial()
+    {
+        memset(coe, 0, sizeof(coe));
+        len = 1;
+    }
+    void output()
+    {
+        printf("(");
+        for(int i = len - 1; i >= 0; i--)
+        {
+            if(coe[i] == 0) continue;
+            if(i == 0)
+            {
+                if(coe[i] > 0) printf("+");
+                printf("%d", coe[i]);
+                continue;
+            }
+            if(coe[i] > 0 && i != len - 1) printf("+");
+            if(coe[i] == -1) printf("-");
+            if(abs(coe[i]) != 1) printf("%d", coe[i]);
+            if(i > 1)
+                printf("x^%d", i);
+            else printf("x");
+        }
+        printf(")");
+        return;
+    }
+    polynomial operator / (const polynomial pol);
+};
+polynomial polynomial :: operator / (const polynomial pol)
+{
+    polynomial ret;
+    ret.len = len - pol.len + 1;
+    for(int i = len - 1; i >= pol.len - 1; i--)
+    {
+        int tim = coe[i] / pol.coe[pol.len - 1];
+        if(tim != 0)
+        {
+            for(int j = 0; j < pol.len; j++)
+                coe[i - j] -= tim*pol.coe[pol.len - 1 - j];
+            ret.coe[i - pol.len + 1] = tim;
+        }
+    }
+    return ret;
+}
+polynomial p[maxn];
+bool cmp(int i, int j)
+{
+    if(p[i].len != p[j].len) return p[i].len < p[j].len;
+    for(int k = p[i].len - 1; k >= 0; k--)
+        if(p[i].coe[k] != p[j].coe[k])
+        {
+            if(abs(p[i].coe[k]) == abs(p[j].coe[k]))
+                return p[i].coe[k] < 0;
+            else return abs(p[i].coe[k]) < abs(p[j].coe[k]);
+        }
+    return false;
+}
+int main()
+{
+    p[1].coe[0] = -1;
+    p[1].coe[1] = 1;
+    p[1].len = 2;
+    for(int i = 2; i <= 1100; i++)
+    {
+        p[i].coe[0] = -1;
+        p[i].coe[i] = 1;
+        p[i].len = i + 1;
+        p[i] = p[i]/p[1];
+        v[i].push_back(1);
+        for(int j = 2; j*j <= i; j++)
+        {
+            if(i % j == 0)
+            {
+                p[i] = p[i]/p[j];
+                v[i].push_back(j);
+                if(j*j != i) p[i] = p[i]/p[i / j], v[i].push_back(i / j);
+            }
+        }
+        v[i].push_back(i);
+    }
+    int n;
+    while(scanf("%d", &n), n)
+    {
+        if(n == 1)
+        {
+            printf("x-1\n");
+            continue;
+        }
+        sort(v[n].begin(), v[n].end(), cmp);
+        for(int i = 0, sz = v[n].size(); i < sz; i++)
+            p[v[n][i]].output();
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4449_autoAC.cpp b/HDOJ/4449_autoAC.cpp
new file mode 100644
index 0000000..f676d44
--- /dev/null
+++ b/HDOJ/4449_autoAC.cpp
@@ -0,0 +1,323 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cmath>
+#include <algorithm>
+using namespace std;
+#define INF (1<<30)
+#define PI acos(-1)
+#define SET(a,b) memset(a,b,sizeof(a))
+#define M 10010
+#define N 505
+#define EPS 1e-8
+struct pt
+{
+    double x,y,z;
+    pt() {}
+    pt(double _x,double _y,double _z): x(_x),y(_y),z(_z) {}
+    pt operator - (const pt p1)
+    {
+        return pt(x-p1.x,y-p1.y,z-p1.z);
+    }
+    pt operator * (pt p)
+    {
+        return pt(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);
+    }
+    double operator ^ (pt p)
+    {
+        return x*p.x+y*p.y+z*p.z;
+    }
+};
+struct _3DCH
+{
+    struct fac
+    {
+        int a,b,c;
+        bool ok;
+    };
+    int n;
+    pt P[N];
+    int cnt;
+    fac  F[N*8];
+    int to[N][N];
+    double vlen(pt a)
+    {
+        return sqrt(a.x*a.x+a.y*a.y+a.z*a.z);
+    }
+    double area(pt a,pt b,pt c)
+    {
+        return vlen((b-a)*(c-a));
+    }
+    double volume(pt a,pt b,pt c,pt d)
+    {
+        return (b-a)*(c-a)^(d-a);
+    }
+    double ptof(pt &p,fac &f)
+    {
+        pt m=P[f.b]-P[f.a],n=P[f.c]-P[f.a],t=p-P[f.a];
+        return (m*n)^t;
+    }
+    void deal (int p,int a,int b)
+    {
+        int f=to[a][b];
+        fac add;
+        if(F[f].ok)
+        if(ptof(P[p],F[f])>EPS) dfs(p,f);
+        else
+        {
+            add.a=b; add.b=a; add.c=p; add.ok=1;
+            to[p][b]=to[a][p]=to[b][a]=cnt;
+            F[cnt++]=add;
+        }
+    }
+    void dfs(int p,int cur)
+    {
+        F[cur].ok=0;
+        deal(p,F[cur].b,F[cur].a);
+        deal(p,F[cur].c,F[cur].b);
+        deal(p,F[cur].a,F[cur].c);
+    }
+    bool same(int s,int t)
+    {
+        pt &a=P[F[s].a],&b=P[F[s].b],&c=P[F[s].c];
+        return fabs(volume(a,b,c,P[F[t].a]))<EPS && fabs(volume(a,b,c,P[F[t].b]))<EPS && fabs(volume(a,b,c,P[F[t].c]))<EPS;
+    }
+    void construct()
+    {
+        cnt=0;
+        if(n<4) return;
+        bool sb=1;
+        for(int i=1;i<n;i++)
+            if(vlen(P[0]-P[i])>EPS)
+            {
+                swap(P[1],P[i]);
+                sb=0;
+                break;
+            }
+        if(sb) return; sb=1;
+        for(int i=2;i<n;i++)
+            if(vlen((P[0]-P[1])*(P[1]-P[i]))>EPS)
+            {
+                swap(P[2],P[i]);
+                sb=0;
+                break;
+            }
+        if(sb) return; sb=1;    
+        for(int i=3;i<n;i++)
+            if(fabs((P[0]-P[1])*(P[1]-P[2])^(P[0]-P[i]))>EPS)
+            {
+                swap(P[3],P[i]);
+                sb=0;
+                break;
+            }
+        if(sb) return;
+        fac add;
+        for(int i=0;i<4;i++)
+        {
+            add.a=(i+1)%4;
+            add.b=(i+2)%4;
+            add.c=(i+3)%4;
+            add.ok=1;
+            if(ptof(P[i],add)>0) swap(add.b,add.c);
+            to[add.a][add.b]=to[add.b][add.c]=to[add.c][add.a]=cnt;
+            F[cnt++]=add;
+        }
+        for(int i=4;i<n;i++)
+        for(int j=0;j<cnt;j++)
+            if(F[j].ok && ptof(P[i],F[j])>EPS)
+            {
+                dfs(i,j);
+                break;
+            }
+        int tmp=cnt;
+        cnt=0;
+        for(int i=0;i<tmp;i++)
+        if(F[i].ok) F[cnt++]=F[i];
+    }
+    double ptoface(pt p,int i)
+    {
+        return fabs(volume(P[F[i].a],P[F[i].b],P[F[i].c],p)/vlen((P[F[i].b]-P[F[i].a])*(P[F[i].c]-P[F[i].a])));
+    }
+    void get_panel(double &a,double &b,double &c,double &d,pt p1,pt p2,pt p3)
+    {
+        a=(p2.y-p1.y)*(p3.z-p1.z)-(p2.z-p1.z)*(p3.y-p1.y);
+        b=(p2.z-p1.z)*(p3.x-p1.x)-(p2.x-p1.x)*(p3.z-p1.z);
+        c=(p2.x-p1.x)*(p3.y-p1.y)-(p2.y-p1.y)*(p3.x-p1.x);
+        d=-(a*p1.x+b*p1.y+c*p1.z);
+    }
+    inline double dist(pt p1, pt p2)
+    {
+        return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y)+(p1.z-p2.z)*(p1.z-p2.z));
+    }
+}hull;
+inline int sign(double d)
+{
+    if(d>EPS) return 1;
+    if(d<-EPS) return -1;
+    return 0;
+}
+struct point
+{
+    double x,y,z;
+    point(double x=0,double y=0,double z=0): x(x),y(y),z(z) {}
+    point operator - (point p)
+    {
+        return point(x-p.x,y-p.y,z-p.z);
+    }
+    point operator + (point p)
+    {
+        return point(x+p.x,y+p.y,z+p.z);
+    }
+    point operator / (double len)
+    {
+        return point(x/len,y/len,z/len);
+    }
+    point operator * (double len)
+    {
+        return point(x*len,y*len,z*len);
+    }
+    double operator ^ (point p)
+    {
+        return x*p.x+y*p.y+z*p.z;
+    }
+    point operator * (point p)
+    {
+        return point(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);
+    }
+    double getlen()
+    {
+        return sqrt(x*x+y*y+z*z);
+    }
+}con[N],ps[N],org;
+double a,b,c,d;
+int n;
+inline point get_point(point u,point v,point p)
+{
+    double a,b,t;
+    a=(v.x-u.x)*(v.x-u.x)+(v.y-u.y)*(v.y-u.y)+(v.z-u.z)*(v.z-u.z);
+    b=(p.x-u.x)*(v.x-u.x)+(p.y-u.y)*(v.y-u.y)+(p.z-u.z)*(v.z-u.z);
+    t=b/a;
+    point ans;
+    ans.x=v.x*t+(1-t)*u.x;
+    ans.y=v.y*t+(1-t)*u.y;
+    ans.z=v.z*t+(1-t)*u.z;
+    return ans;
+}
+inline double dist(point a,point b)
+{
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)+(a.z-b.z)*(a.z-b.z));
+}
+point rotate(point u,point v,point p,double ang)
+{
+    point root=get_point(u,v,p),e,r;
+    point ans;
+    e=(v-u)/dist(u,v);
+    r=p-root;
+    e=e*r;
+    ans=r*cos(ang)+e*sin(ang)+root;
+    return ans;
+}
+double inter_pro(point u1,point v1,point u2,point v2)
+{
+    return (v1.x-u1.x)*(v2.y-u2.y)-(v1.y-u1.y)*(v2.x-u2.x);
+}
+bool cmp(point a,point b)
+{
+    return a.y<b.y || a.y==b.y && a.x<b.x;
+}
+void Graham(point* pol, int n, point* con, int& len){  
+ sort(pol, pol+ n, cmp);
+ con[0] = pol[0];
+ con[1] = pol[1];
+ int top = 1;
+ for(int i = 2; i < n; i++){
+  while(top > 0 && inter_pro(con[top - 1], con[top], con[top - 1], pol[i]) <= 0) top--;
+  con[++top] = pol[i];
+ }
+ int tmp = top;  
+ for(int i = n - 2; i >= 0; i--){
+  while(top > tmp && inter_pro(con[top - 1], con[top], con[top - 1], pol[i]) <= 0) top--;
+  con[++top] = pol[i]; 
+ }
+ len = top;
+}
+double polyArea(point* ps, int n){
+ ps[n] = ps[0];
+ int i;
+ double ans=0;
+ for(i = 0; i < n; i++){
+  ans += (ps[i].x*ps[i+1].y-ps[i].y*ps[i+1].x);
+ }
+ return fabs(ans/2.0);
+}
+double solve()
+{
+    point tp(0,0,0),end(0,0,1),vec;
+    double ang;
+    int i,cn;
+    if(sign(a)) tp.x=d/a;
+    else if(sign(b)) tp.y=d/b;
+    else if(sign(c)) tp.z=d/c;
+    ps[n+1]=tp;
+    vec=(point(a,b,c))*(end);
+    if(sign(vec.x)==0) vec.x=0;
+    if(sign(vec.y)==0) vec.y=0;
+    if(sign(vec.z)==0) vec.z=0;
+    ang=(a*end.x+b*end.y+c*end.z)/(point(a,b,c).getlen());
+    ang=acos(ang);
+    if(sign(ang)!=-0 && sign(ang-PI)!=0)
+        for(i=0;i<n;i++)
+            ps[i]=rotate(org,vec,ps[i],ang);
+    for(int i=0;i<n;i++) ps[i].z=0;
+    Graham(ps,n,con,cn);
+    double ans=fabs(polyArea(con,cn));
+    return ans;
+}
+int main()
+{
+    while (scanf("%d",&hull.n) && hull.n)
+    {
+        for(int i=0;i<hull.n;i++)
+            scanf("%lf%lf%lf",&hull.P[i].x,&hull.P[i].y,&hull.P[i].z);
+        if(n==1)
+        {
+            printf("0.000 0.000\n");
+            continue;
+        }
+        if(n==2)
+        {
+            printf("%.3lf 0.000\n",hull.dist(hull.P[0],hull.P[1]));
+            continue;
+        }
+        hull.construct();
+        n=hull.n;
+        double ans1=0,ans2=1e100;
+        if(hull.cnt==0)
+        {
+            double max0=0;
+            for(int i=0;i<hull.n;i++)
+            for(int j=0;j<hull.n;j++)
+                max0=max(max0,hull.dist(hull.P[i],hull.P[j]));
+            printf("%.3lf 0.000\n",max0);
+            continue;
+        }
+        n=hull.n;
+        for(int i=0;i<hull.cnt;i++)
+        {
+            for(int j=0;j<hull.n;j++)
+                ps[j].x=hull.P[j].x,
+                ps[j].y=hull.P[j].y,
+                ps[j].z=hull.P[j].z;
+            hull.get_panel(a,b,c,d,hull.P[hull.F[i].a],hull.P[hull.F[i].b],hull.P[hull.F[i].c]);
+            d=-d;
+            double dist=0;
+            for(int j=0;j<hull.n;j++)
+                dist=max(dist,hull.ptoface(hull.P[j],i));
+            double ans=solve();
+            if(dist>ans1) ans1=dist,ans2=ans;
+            else if(fabs(dist-ans1)<EPS) if(ans2>ans) ans1=dist,ans2=ans;
+        }
+        printf("%.3f %.3f\n",ans1,ans2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4450_autoAC.cpp b/HDOJ/4450_autoAC.cpp
new file mode 100644
index 0000000..888473b
--- /dev/null
+++ b/HDOJ/4450_autoAC.cpp
@@ -0,0 +1,12 @@
+#include<cstdio>
+int main()
+{
+    int n,i,s,a;
+    while(scanf("%d",&n),n)
+    {
+        s=0;
+        while(n--){scanf("%d",&a);s+=a*a;}
+        printf("%d\n",s);
+    }
+    return 0;
+}
diff --git a/HDOJ/4451_autoAC.cpp b/HDOJ/4451_autoAC.cpp
new file mode 100644
index 0000000..58114e1
--- /dev/null
+++ b/HDOJ/4451_autoAC.cpp
@@ -0,0 +1,31 @@
+#include<cstdio>
+#include<cstring>
+int v1[1001],v2[1001];
+int main()
+{
+    int n,m,k,x,y,p;
+    char s1[10],s2[10];
+    while(scanf("%d%d%d",&n,&m,&k),n||m||k)
+    {
+        memset(v1,0,sizeof(v1));
+        memset(v2,0,sizeof(v2));
+        int ans=n*m*k;
+        scanf("%d",&p);
+        while(p--)
+        {
+            scanf("%s%d%s%d",s1,&x,s2,&y);
+            if(s1[0]=='c') 
+            {
+                v1[y]++;
+                ans-=(k-v2[y]);
+            }
+            else 
+            {
+                v2[x]++;
+                ans-=(n-v1[x]);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4452_autoAC.cpp b/HDOJ/4452_autoAC.cpp
new file mode 100644
index 0000000..d8f77ec
--- /dev/null
+++ b/HDOJ/4452_autoAC.cpp
@@ -0,0 +1,129 @@
+#include<iostream>
+using namespace std;
+int f[4][2]={-1,0,0,-1,1,0,0,1};
+int n;
+int x_1,y_1,x_2,y_2;
+int dis_1,speed_1,time_1;
+int dis_2,speed_2,time_2;
+inline int Get_f(char f)
+{
+    if(f=='N')
+        return 0;
+    else if(f=='W') 
+        return 1;
+    else if(f=='S')
+        return 2;
+    else
+        return 3;
+}
+void Get_next(int &x,int &y,int speed,int &dis)
+{
+    int temp=2*(n-1);
+    speed%=temp;
+    x+=speed*f[dis][0];
+    y+=speed*f[dis][1];
+    if(f[dis][0])
+    {
+        if(x<=0)
+        {
+            x+=temp;
+            dis=2;
+            if(x>n&&x<=temp)
+            {
+                x=2*n-x;
+            }
+        }
+        else if(x>temp)
+        {
+            x-=temp;
+            dis=0;
+            if(x>n&&x<=temp)
+            {
+                x=2*n-x;
+            }
+        }
+        else if(x>n&&x<=temp)
+        {
+            x=2*n-x;
+            dis=0;
+        }
+    }
+    else
+    {
+        if(y<=0)
+        {
+            y+=temp;
+            dis=3;
+            if(y>n&&y<=temp)
+            {
+                y=2*n-y;
+            }
+        }
+        else if(y>temp)
+        {
+            y-=temp;
+            dis=1;
+            if(y>n&&y<=temp)
+            {
+                y=2*n-y;
+            }
+        }
+        else if(y>n&&y<=temp)
+        {
+            y=2*n-y;
+            dis=1;
+        }
+    }
+}
+void run(int k)
+{
+    int t_1=0;
+    int t_2=0;
+    x_1=y_1=1;
+    x_2=y_2=n;
+    while(k--)
+    {
+        Get_next(x_1,y_1,speed_1,dis_1);
+        Get_next(x_2,y_2,speed_2,dis_2);
+        t_1++;
+        t_2++;
+        if(x_1==x_2&&y_1==y_2)
+        {
+            int temp=dis_1;
+            dis_1=dis_2;
+            dis_2=temp;
+            t_1%=time_1;
+            t_2%=time_2;
+            continue;
+        }
+        if(t_1==time_1)
+        {
+            dis_1++;
+            dis_1%=4;
+        }
+        if(t_2==time_2)
+        {
+            dis_2++;
+            dis_2%=4;
+        }
+        t_1%=time_1;
+        t_2%=time_2;
+    }
+}
+int main()
+{
+    int k;
+    char temp_1[2],temp_2[2];
+    while(scanf("%d",&n)!=EOF&&n)
+    {
+        scanf("%s%d%d",&temp_1,&speed_1,&time_1);
+        scanf("%s%d%d",&temp_2,&speed_2,&time_2);
+        dis_1=Get_f(temp_1[0]);
+        dis_2=Get_f(temp_2[0]);
+        scanf("%d",&k);
+        run(k);
+        printf("%d %d\n",x_1,y_1);
+        printf("%d %d\n",x_2,y_2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4453_autoAC.cpp b/HDOJ/4453_autoAC.cpp
new file mode 100644
index 0000000..2a5c4ed
--- /dev/null
+++ b/HDOJ/4453_autoAC.cpp
@@ -0,0 +1,207 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <queue>
+#include <set>
+#include <map>
+using namespace std;
+typedef long long LL;
+typedef pair<int,int> PII;
+#define LL(x)    (ch[x][0])
+#define RR(x)    (ch[x][1])
+#define Kt       (ch[ ch[Rt][1] ][0])
+#define MID(a,b) (a+((b-a)>>1))
+const int N=1e6+5;
+int n,m,k1,k2;
+int a[N/2];
+struct SplayTree
+{
+    int Rt,top;
+    int pre[N],sz[N],ch[N][2];
+    int key[N],add[N],pos;
+    bool flip[N];
+    inline void Link(int x,int y,int f)
+    {
+        pre[x]=y; if(y) ch[y][f]=x;
+    }
+    inline void Rotate(int x,int f)
+    {
+        int y=pre[x],z=pre[y];
+        PushDown(y); PushDown(x);
+        Link(x,z,RR(z)==y);
+        Link(ch[x][f],y,!f);
+        Link(y,x,f);
+        PushUp(y);
+    }
+    inline void Splay(int x,int goal)
+    {
+        while(pre[x]!=goal)
+        {
+            int y=pre[x],z=pre[y];
+            int cx=(LL(y)==x),cy=(LL(z)==y);
+            if(z==goal) Rotate(x,cx);
+            else
+            {
+                if(cx==cy) Rotate(y,cy);
+                else Rotate(x,cx);
+                Rotate(x,cy);
+            }
+        }
+        PushUp(x);
+        if(goal==0) Rt=x;
+    }
+    inline void Select(int K,int goal)
+    {
+        int x=Rt;
+        PushDown(x);
+        while(1)
+        {
+            if(sz[LL(x)]>=K) x=LL(x);
+            else if(sz[LL(x)]+1==K) break;
+            else K-=sz[LL(x)]+1,x=RR(x);
+            PushDown(x);
+        }
+        Splay(x,goal);
+    }
+    inline void fun_add(int x,int valu)
+    {
+        add[x]+=valu;
+        key[x]+=valu;
+    }
+    inline void fun_flip(int x)
+    {
+        flip[x]^=1;
+        swap(LL(x),RR(x));
+    }
+    inline void PushDown(int x)
+    {
+        if(add[x])
+        {
+            fun_add(LL(x),add[x]);
+            fun_add(RR(x),add[x]);
+            add[x]=0;
+        }
+        if(flip[x])
+        {
+            fun_flip(LL(x));
+            fun_flip(RR(x));
+            flip[x]=0;
+        }
+    }
+    inline void PushUp(int x)
+    {
+        sz[x]=1+sz[LL(x)]+sz[RR(x)];
+    }
+    inline void Add(int x)
+    {
+        Select(1,0); Select(k2+2,Rt);
+        fun_add(Kt,x);
+    }
+    inline void Reverse()
+    {
+        Select(1,0); Select(k1+2,Rt);
+        fun_flip(Kt);
+    }
+    inline void Insert(int x,int pos)
+    {
+        Select(pos,0); Select(pos+1,Rt);
+        addNode(x,Kt,RR(Rt));
+        PushUp(RR(Rt)); PushUp(Rt);
+    }
+    inline int Delete(bool top)
+    {
+        int valu;
+        if(top)
+        {
+            Select(1,0);    Select(3,Rt);
+            valu=key[Kt];
+            Kt=0;
+            PushUp(RR(Rt)); PushUp(Rt);
+        }
+        else
+        {
+            int len=sz[Rt];
+            Select(len-2,0);Select(len,Rt);
+            valu=key[Kt];
+            Kt=0;
+            PushUp(RR(Rt)); PushUp(Rt);
+        }
+        return valu;
+    }
+    inline void Move(int x)
+    {
+        if(x==1)
+        {
+            int valu=Delete(0);
+            Insert(valu,1);
+        }
+        else
+        {
+            int valu=Delete(1);
+            Insert(valu,sz[Rt]-1);
+        }
+    }
+    inline void Query()
+    {
+        Select(2,0);
+        printf("%d\n",key[Rt]);
+    }
+    void addNode(int valu,int &x,int f)
+    {
+        x=++top;
+        pre[x]=f; sz[x]=1; LL(x)=RR(x)=0;
+        key[x]=valu; add[x]=flip[x]=0;
+    }
+    void build(int lft,int rht,int &x,int f)
+    {
+        if(lft>rht) return;
+        int mid=MID(lft,rht);
+        addNode(a[mid],x,f);
+        build(lft,mid-1,LL(x),x);
+        build(mid+1,rht,RR(x),x);
+        PushUp(x);
+    }
+    void init()
+    {
+        Rt=top=0;
+        pre[0]=sz[0]=LL(0)=RR(0)=0;
+        addNode(0,Rt,0);    addNode(0,RR(Rt),Rt);
+        build(0,n-1,Kt,RR(Rt));
+        PushUp(RR(Rt));     PushUp(Rt);
+    }
+}spt;
+int main()
+{
+    int t_cnt=0;
+    while(scanf("%d%d%d%d",&n,&m,&k1,&k2)!=EOF)
+    {
+        if(n==0&&m==0&&k1==0&&k2==0) break;
+        for(int i=0;i<n;i++) scanf("%d",&a[i]);
+        spt.init();
+        printf("Case #%d:\n",++t_cnt);
+        char op[100]; int x;
+        while(m--)
+        {
+            scanf("%s",op);
+            if(op[0]=='a')
+            {
+                scanf("%d",&x); spt.Add(x);
+            }
+            else if(op[0]=='r') spt.Reverse();
+            else if(op[0]=='i')
+            {
+                scanf("%d",&x); spt.Insert(x,2);
+            }
+            else if(op[0]=='d') spt.Delete(1);
+            else if(op[0]=='m')
+            {
+                scanf("%d",&x); spt.Move(x);
+            }
+            else spt.Query();
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4454_autoAC.cpp b/HDOJ/4454_autoAC.cpp
new file mode 100644
index 0000000..fb16acb
--- /dev/null
+++ b/HDOJ/4454_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <iostream>
+#include <cmath>
+using namespace std;
+const double eps = 1e-6;
+const double PI = acos(-1.0);
+double cx, cy, cr; 
+inline int sign(double x) {
+    return x < -eps ? -1 : x > eps ? 1 : 0;
+}
+struct Point {
+    double x, y;
+    Point (double xx = 0, double yy = 0) : x(xx), y(yy) {}
+    Point operator - (const Point &ot) const { 
+        return Point(x - ot.x , y - ot.y);
+    }
+    double operator * (const Point &ot) const {
+        return x * ot.x + y * ot.y;
+    }
+    double operator ^ (const Point &ot) const { 
+        return x * ot.y - y * ot.x;
+    }
+    bool operator < (const Point &ot) const {
+        if (sign(x - ot.x)) {
+            return sign(x - ot.x) < 0; 
+        } else {  
+            return sign(y - ot.y) < 0;
+        }
+    }
+    void show() {
+        printf("x = %.2f, y = %.2f\n", x, y);
+    }
+};
+Point it, rp[4];
+double dist(const Point &a, const Point &b) {
+    return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
+}
+double dtoL(const Point &np, const Point &st, const Point &ed) {
+    double ret; 
+    if (sign((ed-st)*(np-st)) > 0 && sign((st-ed)*(np-ed) > 0)) { 
+        ret = fabs((st-np)^(ed-np)) / dist(st, ed);
+    } else {
+        ret = min(dist(np, st), dist(np, ed)); 
+    }
+    return ret;
+}
+double dtoR(const Point &np) { 
+    double d1 = min(dtoL(np, rp[0], rp[1]), dtoL(np, rp[0], rp[2]));
+    double d2 = min(dtoL(np, rp[1], rp[3]), dtoL(np, rp[2], rp[3]));
+    return min(d1, d2);
+}
+double tsearch(double l, double r) {
+    double delta;
+    while (r - l >= eps) {
+        delta = (r - l) / 3.0; 
+        Point Lp(cr*cos(l+delta), cr*sin(l+delta));
+        Point Rp(cr*cos(r-delta), cr*sin(r-delta));
+        double d1 = dist(it, Lp) + dtoR(Lp);
+        double d2 = dist(it, Rp) + dtoR(Rp);
+        if (sign(d1 - d2) > 0) {
+            l += delta;
+        } else {
+            r -= delta;
+        }
+    }
+    Point fp(cr*cos(r), cr*sin(r));
+    return dist(it, fp) + dtoR(fp);
+}
+void solve() {
+    printf("%.2f\n", min(tsearch(0, PI), tsearch(PI, 2*PI)));
+}
+int main() {
+    while (scanf("%lf %lf", &it.x, &it.y), sign(it.x) | sign(it.y)) {
+        scanf("%lf %lf %lf", &cx, &cy, &cr);
+        it.x -= cx, it.y -= cy;           
+        scanf("%lf %lf", &rp[0].x, &rp[0].y);
+        rp[0].x -= cx, rp[0].y -= cy;
+        scanf("%lf %lf", &rp[1].x, &rp[1].y);
+        rp[1].x -= cx, rp[1].y -= cy;
+        rp[2].x = rp[0].x, rp[2].y = rp[1].y;
+        rp[3].x = rp[1].x, rp[3].y = rp[0].y;
+        sort(rp, rp+4); 
+        double t = sqrt(2.0) / 2;
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4455_autoAC.cpp b/HDOJ/4455_autoAC.cpp
new file mode 100644
index 0000000..234a1da
--- /dev/null
+++ b/HDOJ/4455_autoAC.cpp
@@ -0,0 +1,56 @@
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+typedef __int64 LL;
+const int maxn=1e6+10;
+int c[maxn],a[maxn],pre[maxn],sum[maxn],num[maxn];
+LL dp[maxn];
+int main()
+{
+    int n,m;
+    while(scanf("%d",&n)!=EOF)
+    {
+        if(n==0)break;
+        int i,j,k,t;
+        for(i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        memset(c,0,sizeof(c));
+        memset(pre,0,sizeof(pre));
+        for(i=1;i<=n;i++)
+        {
+            c[i-pre[a[i]]]++;
+            pre[a[i]]=i;
+        }
+        sum[n]=c[n];
+        for(i=n-1;i>=1;i--)
+            sum[i]=sum[i+1]+c[i];
+        memset(c,0,sizeof(c));
+        num[1]=1;
+        c[a[n]]++;
+        for(i=2;i<=n;i++)
+        {
+            if(c[a[n-i+1]]==0)
+            {
+                num[i]=num[i-1]+1;
+                c[a[n-i+1]]=1;
+            }
+            else
+            num[i]=num[i-1];
+        }
+        dp[1]=n;
+        for(i=2;i<=n;i++)
+        {
+            dp[i]=dp[i-1]-num[i-1]+sum[i];
+        }
+        scanf("%d",&m);
+        for(i=0;i<m;i++)
+        {
+            scanf("%d",&t);
+            printf("%I64d\n",dp[t]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4456_autoAC.cpp b/HDOJ/4456_autoAC.cpp
new file mode 100644
index 0000000..f3b4f3b
--- /dev/null
+++ b/HDOJ/4456_autoAC.cpp
@@ -0,0 +1,82 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+#define MAXN 4001003
+#define MAXM 88888
+using namespace std;
+int n, m;
+int W;
+int h[MAXN], cnt;
+int a[MAXN];
+int pp[MAXN], xx[MAXN], yy[MAXN], zz[MAXN];
+inline int lowbit(int x)
+{
+    return x & -x;
+}
+void ready(int x, int y)
+{
+    for (int i = x; i <= W; i += lowbit(i)){
+        for (int j = y; j <= W; j += lowbit(j)) {
+            h[cnt++] = i * W + j;
+        }
+    }
+}
+void add(int x, int y, int val)
+{
+    for(int i = x; i <= W; i += lowbit(i))
+        for(int j = y; j <= W; j += lowbit(j))
+        {
+            int pos = lower_bound(h, h + cnt, i * W + j) - h;
+            a[pos] += val;
+        }
+}
+int getsum(int x, int y)
+{
+    int sum = 0;
+    for(int i = x; i > 0; i -= lowbit(i))
+        for(int j = y; j > 0; j -= lowbit(j))
+        {
+            int pos = lower_bound(h, h + cnt, i * W + j) - h;
+            if(h[pos] == i * W + j)
+                sum += a[pos];
+        }
+    return sum;
+}
+int main()
+{
+    int p, x, y, z, xa, xb, ya, yb, newx, newy;
+    while(scanf("%d", &n) != EOF && n)
+    {
+        scanf("%d", &m);
+        W = n * 2;
+        cnt = 0;
+        memset(a, 0, sizeof(a));
+        for (int i = 0; i < m; i++)
+        {
+            scanf("%d%d%d%d", &pp[i], &xx[i], &yy[i], &zz[i]);
+            newx = xx[i] - yy[i] + n;
+            newy = xx[i] + yy[i];
+            if (pp[i] == 1)
+                ready(newx, newy);
+        }
+        sort(h, h + cnt);
+        cnt = unique(h, h + cnt) - h;
+        for(int i = 0; i < m; i++)
+        {
+            newx = xx[i] - yy[i] + n;
+            newy = xx[i] + yy[i];
+            if(pp[i] == 1) add(newx, newy, zz[i]);
+            else
+            {
+                xa = max(1, newx - zz[i]);
+                ya = max(1, newy - zz[i]);
+                xb = min(W, newx + zz[i]);
+                yb = min(W, newy + zz[i]);
+                printf("%d\n", getsum(xb, yb) - getsum(xa - 1, yb) - getsum(xb, ya - 1) + getsum(xa - 1, ya - 1));
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4458_autoAC.cpp b/HDOJ/4458_autoAC.cpp
new file mode 100644
index 0000000..f8c2520
--- /dev/null
+++ b/HDOJ/4458_autoAC.cpp
@@ -0,0 +1,102 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+const double EPS=1e-8;
+const int maxn=100;
+int n;
+struct Point
+{
+    double x,y;
+    Point (double x=0,double y=0):x(x),y(y){}
+};
+Point poly[maxn];
+typedef Point Vector;
+Vector operator + (Vector A,Vector B) {return Vector(A.x+B.x,A.y+B.y);}
+Vector operator - (Point A,Point B) {return Vector(A.x-B.x,A.y-B.y);}
+Vector operator * (Vector A,double p) {return Vector(A.x*p,A.y*p);}
+Vector operator / (Vector A,double p) {return Vector(A.x/p,A.y/p);}
+bool operator < (const Point &a,const Point &b){
+    return a.x < b.x ||(a.x==b.x &&a.y < b.y);
+}
+int dcmp (double x){
+    if(fabs(x)<EPS)
+        return 0;
+    else return x < 0?-1:1;
+}
+bool operator == (const Point &a ,const Point &b){
+    return dcmp(a.x-b.x) ==0 && dcmp(a.y - b.y)==0;
+}
+double Cross (Vector A,Vector B) {return A.x*B.y - A.y*B.x;}
+double Dot (Vector A,Vector B) {return A.x*B.x + A.y*B.y;}
+bool isPointOnSegment (Point p,Point a1,Point a2)
+{
+    return dcmp ( Cross(a1-p,a2-p)  )==0 && dcmp(Dot (a1-p,a2-p))<0;
+}
+int online(Point a,Point b,Point p)
+{
+    Point v1,v2;
+    v1=p-a;v2=p-b;
+    if( dcmp(Cross(v1,v2))!=0)  //绉涓涓0 灏变ㄧ寸嚎涓
+         return 0;
+    else
+       {
+           if(dcmp(min(a.x,b.x)- p.x)<=0 && dcmp(p.x-max(a.x,b.x))<=0
+               &&dcmp(min(a.y,b.y)- p.y)<=0 &&dcmp( p.y-max(a.y,b.y))<=0)
+               return 1;
+            else
+                return 0;
+       }
+}
+int isPointInPolygon (Point p)
+{
+    int wn=0;
+    for(int i=0;i<n;i++){
+        if( online (poly[i], poly[(i+1)%n],p)) return 0;
+        int k=dcmp (Cross(poly[(i+1)%n]-poly[i],p-poly[i]));
+        int d1=dcmp(poly[i].y-p.y);
+        int d2=dcmp(poly[(i+1)%n].y-p.y);
+        if(k>0 && d1<=0 && d2>0) wn++;
+        if(k<0 && d2<=0 && d1>0) wn--;
+    }
+    if(wn!=0) return 1;
+    return 0;
+}
+int main()
+{
+    double v,b,g;
+    while (scanf("%lf %lf %lf",&v,&b,&g),v||b||g)
+    {
+        v=-v;
+        scanf("%d",&n);
+        bool flag=false;
+        int i;
+        double minx=1e12,maxx=-1e12,maxy=-1e12;
+        for(i=0;i<n;i++)
+        {
+            scanf("%lf %lf",&poly[i].x,&poly[i].y);
+            if(poly[i].x>maxx)  maxx=poly[i].x;
+            if(poly[i].x<minx)  minx=poly[i].x;
+            if(poly[i].y>maxy)  maxy=poly[i].y;
+        }
+        double t;
+        for(int i=0;;i++)
+        {
+            t=i*0.001;
+            Point temp;
+            temp.x=v*t;temp.y=b*t-0.5*g*t*t;
+            if( isPointInPolygon(temp) )
+            {
+                printf("%.2f\n",t-EPS);
+                flag=true;
+                break;
+            }
+            if(!g && temp.y>maxy) break;
+            if(temp.y<0) break;
+        }
+        if(!flag) printf("Miss!\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4459_autoAC.cpp b/HDOJ/4459_autoAC.cpp
new file mode 100644
index 0000000..0fa893e
--- /dev/null
+++ b/HDOJ/4459_autoAC.cpp
@@ -0,0 +1,218 @@
+#include <cstdio>
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+typedef long long LL;
+struct fac
+{
+    LL fz,fm;
+    fac(){}
+    fac (LL a,LL b):fz(a),fm(b) {}
+    fac fix()
+    {
+        LL d=__gcd(fz,fm);
+        return fac(fz/d,fm/d);
+    }
+    fac operator + (const fac & b) const { return fac(fz*b.fm+fm*b.fz,fm*b.fm).fix(); }
+    fac operator * (const fac & b) const { return fac(fz*b.fz,fm*b.fm).fix(); }
+    fac operator / (const fac & b) const { return fac(fz*b.fm,fm*b.fz).fix(); }
+    fac operator - (const fac & b) const { return fac(fz*b.fm-fm*b.fz,fm*b.fm).fix() ;}
+};
+struct node
+{
+    fac xs;
+    int d[5],x[5];
+    node () { 
+        xs=fac(1,1);
+        for(int i=0;i<5;i++) { d[i]=x[i]=0;}
+    }
+    node operator * (const node & b) const {
+        node ans;
+        ans.xs=xs*b.xs;
+        for(int i=0;i<5;i++) {
+            ans.d[i]=d[i]+b.d[i];
+            ans.x[i]=x[i]+b.x[i];
+        }
+        return ans;
+    }
+    bool operator < (const node & b) const
+    {
+        for(int i=0;i<5;i++) {
+            if(d[i]!=b.d[i]) return d[i]<b.d[i];
+        }
+        return 0;
+    }
+    bool operator == (const node & b)
+    {
+        for(int i=0;i<5;i++) if(d[i]!=b.d[i]) return false;
+        return true;
+    }
+    void output()
+    {
+        cout << xs.fz << "/" << xs.fm << " ";
+        for(int i=0;i<5;i++){
+            cout << d[i] << " ";
+        }
+        for(int i=0;i<5;i++){
+            cout << x[i] << " ";
+        }
+        cout << endl;
+    }
+};
+vector <node> dep[10],ans;
+vector <node> v_mult(vector <node> & a,vector <node> & b)
+{
+    vector<node> ans;
+    int s1=a.size(),s2=b.size();
+    for(int i=0;i<s1;i++){
+        for(int j=0;j<s2;j++){
+            ans.push_back(a[i]*b[j]);
+        }
+    }
+    return ans;
+}
+vector <node> v_exp(vector <node> & a,int b)
+{
+    vector <node> c=a;
+    while(--b){
+        c=v_mult(c,a);
+    }
+    return c;
+}
+void init()
+{
+    node a;
+    dep[5].push_back(a);
+    for(int i=4;i>=0;i--){
+        int s=dep[i+1].size();
+        vector <node > tmp;
+        node b;
+        b.d[i]=1;
+        tmp.push_back(b);
+        for(int j=0;j<i;j++){
+            node b;
+            b.xs=fac(-1,1);
+            b.x[j]=1;
+            tmp.push_back(b);
+        }
+        for(int j=0;j<s;j++){
+            vector<node> q=v_exp(tmp,dep[i+1][j].x[i]+1);
+            int s1=q.size();
+            for(int k=0;k<s1;k++){
+                node tt=dep[i+1][j]*q[k];
+                tt.xs=tt.xs*fac(1,dep[i+1][j].x[i]+1);
+                dep[i].push_back(tt);
+            }
+        }
+    }
+    sort(dep[0].begin(),dep[0].end());
+    int ss=dep[0].size();
+    node pre=dep[0][0];
+    for(int i=1;i<ss;i++){
+        if(dep[0][i]==pre){
+            pre.xs=pre.xs+dep[0][i].xs;
+        }
+        else {
+            if(pre.xs.fz) ans.push_back(pre);
+            pre=dep[0][i];
+        }
+    }
+    if(pre.xs.fz) ans.push_back(pre);
+}
+struct work
+{
+    int s1,s2,d;
+    bool operator < (const work & b) const{
+        return d<b.d;
+    }
+}tt[10];
+int n;
+int a[5],d[5];
+fac cal()
+{
+    fac res=fac(0,1);
+    for(size_ i=0;i<ans.size();i++){
+        fac tmp=ans[i].xs;
+        for(int j=0;j<5;j++){
+            for(int k=0;k<ans[i].d[j];k++){
+                tmp.fz=tmp.fz*d[j];
+            }
+        }
+        tmp=tmp.fix();
+        res=res+tmp;
+    }
+    return res;
+}        
+void dfs(fac & ans,int s,int t)
+{
+    if(s==5){
+        for(int i=0;i<5;i++) d[i]=tt[i].d;
+        for(int i=0;i<5;i++){
+            if(a[i]){
+                for(int j=i;j<5;j++) d[j]-=tt[i].s2;
+            }
+        }
+        for(int i=3;i>=0;i--) {
+            d[i]=min(d[i],d[i+1]);
+            if(d[i]<0) return;
+        }
+        fac p=cal();
+        if(t) ans=ans+p;
+        else ans=ans-p;
+        return;
+    }
+    a[s]=1;
+    dfs(ans,s+1,1-t);
+    a[s]=0;
+    dfs(ans,s+1,t);
+}
+fac solve()
+{
+    while(n<5){
+        tt[n].s2=1;
+        tt[n++].d=2000;
+    }
+    fac ans=fac(0,1);
+    dfs(ans,0,1);    
+    for(int i=0;i<5;i++) ans.fm=ans.fm*tt[i].s2;
+    return ans.fix();
+}
+int main()
+{
+    init();
+    while(scanf("%d",&n)&&n){
+        for(int i=0;i<n;i++) scanf("%d%d%d",&tt[i].s1,&tt[i].s2,&tt[i].d);
+        sort(tt,tt+n);
+        int flag=1;
+        for(int i=0;i<n;i++){
+            if(tt[i].s1==tt[i].s2){
+                for(int j=i+1;j<n;j++) tt[j].d-=tt[i].s1;
+                if(i==0) {
+                    if(tt[i].s1>tt[i].d) { flag=0;break;}
+                }
+                else {
+                    tt[i-1].d=min(tt[i-1].d,tt[i].d-tt[i].s1);
+                }
+                for(int j=i;j<n-1;j++){
+                    tt[j]=tt[j+1];
+                }
+                i-- , n--;
+            }
+        }
+        for(int i=0;i<n;i++) {
+            for(int j=i;j<n;j++) tt[j].d-=tt[i].s1;
+            tt[i].s2-=tt[i].s1;
+            if(tt[i].d<0) { flag=0;break;}
+        }
+        if(!flag) puts("Poor boy!");
+        else if(n==0) puts("Congratulations!");
+        else {
+            fac ans=solve();
+            if(ans.fm<0) { ans.fz=-ans.fz , ans.fm=-ans.fm;}
+            if(ans.fz<=0) puts("Poor boy!");
+            else if(ans.fz>=ans.fm) puts("Congratulations!");
+            else printf("%I64d/%I64d\n",ans.fz,ans.fm);
+        }          
+    } 
+}
diff --git a/HDOJ/4460_autoAC.cpp b/HDOJ/4460_autoAC.cpp
new file mode 100644
index 0000000..bb2f71d
--- /dev/null
+++ b/HDOJ/4460_autoAC.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <map>
+#include <math.h>
+#include <queue>
+#include <vector>
+#include<string>
+using namespace std;
+const int MAXN=1010;
+const int INF=0x3f3f3f3f;
+int dis[MAXN][MAXN];
+bool used[MAXN];
+vector<int>vec[MAXN];
+queue<int>que;
+void bfs(int i)
+{
+    memset(used,false,sizeof(used));
+    dis[i][i]=0;
+    used[i]=true;
+    que.push(i);
+    while(!que.empty())
+    {
+        int t=que.front();
+        que.pop();
+        int m=vec[t].size();
+        for(int j=0;j<m;j++)
+        {
+            int v=vec[t][j];
+            if(used[v])continue;
+            if(dis[i][v]>dis[i][t]+1)
+            dis[i][v]=dis[i][t]+1;
+            que.push(v);
+            used[v]=true;
+        }
+    }
+}
+map<string,int>mp;
+int main() {
+    string str;
+    string str2;
+    int n,m,i,j;
+    while(scanf("%d",&n)==1 && n)
+    {
+        mp.clear();
+        for(i=0;i<n;i++)
+        {
+            cin>>str;
+            mp[str]=i;
+        }
+        for(i=0;i<n;i++)
+        {
+            dis[i][i]=0;
+            for(j=i+1;j<n;j++)
+                dis[i][j]=dis[j][i]=INF;
+        }
+        scanf("%d",&m);
+        for(i=0;i<n;i++)vec[i].clear();
+        while(m--)
+        {
+            cin>>str>>str2;
+            int t1=mp[str];
+            int t2=mp[str2];
+            vec[t1].push_back(t2);
+            vec[t2].push_back(t1);
+        }
+        for(i=0;i<n;i++)bfs(i);
+        int ans=0;
+        for(i=0;i<n;i++)
+             for(j=i+1;j<n;j++)
+                 ans=ans>dis[i][j]?ans:dis[i][j];
+        if(ans==INF)ans=-1;
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4462_autoAC.cpp b/HDOJ/4462_autoAC.cpp
new file mode 100644
index 0000000..eefa380
--- /dev/null
+++ b/HDOJ/4462_autoAC.cpp
@@ -0,0 +1,76 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+using namespace std;
+#define MAXN 60
+bool flag;
+int n,m;
+int x[20],y[20],r[20];
+int map[MAXN][MAXN];
+int node[MAXN],total;
+void func()
+{
+  int L,R,T,D;
+  memset(map,0,sizeof(map));
+  for(int i=1;i<=m;i++)
+    map[x[i]][y[i]]=1;
+  for(int i=0;i<total;i++)
+  {
+    int k=node[i]; 
+    L=(x[k]-r[k]>0?x[k]-r[k]:1);
+    R=(x[k]+r[k]<=n?x[k]+r[k]:n);
+    T=(y[k]-r[k]>0?y[k]-r[k]:1);
+    D=(y[k]+r[k]<=n?y[k]+r[k]:n);
+    for(int j=L;j<=R;j++)
+      for(int l=T;l<=D;l++)
+        if(abs(j-x[k])+abs(l-y[k])<=r[k])
+          map[j][l]=1;
+  }
+  for(int i=1;i<=n;i++)
+    for(int j=1;j<=n;j++)
+      if(!map[i][j]) return;
+  flag=1;
+}
+void dfs(int sel,int cnt)
+{
+  if(sel==total)
+    func();
+  else
+    for(int i=cnt;i<=m;i++)
+    {
+      node[sel]=i;
+      dfs(sel+1,i+1);
+    }
+}
+void solve()
+{
+  scanf("%d",&m);
+  for(int i=1;i<=m;i++)
+    scanf("%d%d",&x[i],&y[i]);
+  for(int i=1;i<=m;i++)
+    scanf("%d",&r[i]);
+  flag=0;
+  if(m>=n*n)
+  {
+    printf("0\n");
+    return;
+  }
+  for(int i=1;i<=m;i++)
+  {
+    total=i;
+    dfs(0,1);
+    if(flag==1)
+    {
+      printf("%d\n",i);
+      return;
+    }
+  }
+  printf("-1\n");
+}
+int main()
+{
+  while(~scanf("%d",&n) && n)
+    solve();
+  return 0;
+}
diff --git a/HDOJ/4463_autoAC.cpp b/HDOJ/4463_autoAC.cpp
new file mode 100644
index 0000000..a61057d
--- /dev/null
+++ b/HDOJ/4463_autoAC.cpp
@@ -0,0 +1,70 @@
+#include"stdio.h"
+#include"string.h"
+#include"stdlib.h"
+#include"math.h"
+int pre[100];
+struct A
+{
+    int a,b,len;
+}eage[3000];
+int k;
+int x[100],y[100];
+void build(int n)
+{
+    int i;
+    for(i=0;i<n;i++)    pre[i]=i;
+}
+int find(int k)
+{
+    if(pre[k]==k)    return k;
+    pre[k]=find(pre[k]);
+    return pre[k];
+}
+void Union(int f1,int f2)
+{
+    pre[f1]=f2;
+}
+int cmp(const void *a,const void *b)
+{
+    struct A *c,*d;
+    c=(struct A *)a;
+    d=(struct A *)b;
+    return c->len-d->len;
+}
+int main()
+{
+    int n;
+    int i,l;
+    int d1,d2;
+    int f1,f2;
+    double ans;
+    while(scanf("%d",&n),n)
+    {
+        build(n);
+        scanf("%d%d",&d1,&d2);
+        d1--;d2--;
+        for(i=0;i<n;i++)    scanf("%d%d",&x[i],&y[i]);
+        k=0;
+        for(i=1;i<n;i++)
+        for(l=0;l<i;l++)
+        {
+            eage[k].a=i;
+            eage[k].b=l;
+            eage[k].len=(x[i]-x[l])*(x[i]-x[l])+(y[i]-y[l])*(y[i]-y[l]);
+            k++;
+        }
+        qsort(eage,k,sizeof(eage[0]),cmp);
+        ans=sqrt((double)(x[d1]-x[d2])*(x[d1]-x[d2])+(y[d1]-y[d2])*(y[d1]-y[d2]));
+        Union(d1,d2);
+        for(i=0;i<k;i++)
+        {
+            f1=find(eage[i].a);
+            f2=find(eage[i].b);
+            if(f1==f2)    continue;
+            Union(f1,f2);
+            ans+=sqrt((double)eage[i].len);
+        }
+        printf("%.2lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4464_autoAC.cpp b/HDOJ/4464_autoAC.cpp
new file mode 100644
index 0000000..9b49d81
--- /dev/null
+++ b/HDOJ/4464_autoAC.cpp
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <string.h>
+int main() {
+    int n, t = 0;
+    while(scanf("%d", &n)!=EOF) {
+        int maxx = 0;
+        while(n--) {
+            int i, tmp = 0;
+            char s[105];
+            scanf("%s", s);
+            for(i = 0; s[i]; i++) 
+                tmp += s[i];
+            if(tmp > maxx)
+                maxx = tmp;
+        }
+        printf("Case %d: %d\n", ++t, maxx);
+    }
+    return 0;
+}
diff --git a/HDOJ/4465_autoAC.cpp b/HDOJ/4465_autoAC.cpp
new file mode 100644
index 0000000..3cf2a32
--- /dev/null
+++ b/HDOJ/4465_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<stdio.h>
+#include<string.h>
+#include<math.h>
+#define N 400200
+double f[N];
+double logc(int n,int m)
+{
+    return f[m]-f[n]-f[m-n];
+}
+int main ()
+{
+    int n;
+    int i,j,k=0;
+    double p,ans,ret;
+    f[0]=0;
+    for (i=1;i<N;++i) f[i]=f[i-1]+log(1.0*i);
+    while (scanf("%d%lf",&n,&p)!=EOF)
+    {
+        ans=0;
+        double p1=log(p),p2=log(1-p);
+        double q1=(n+1)*p1,q2=(n+1)*p2;
+        for (i=0;i<n;++i)
+        {
+            ans+=((n-i)*exp(logc(n,n+i)+q1+i*p2));
+            ans+=((n-i)*exp(logc(n,n+i)+q2+i*p1));
+        }
+        printf("Case %d: %.6lf\n",++k,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4466_autoAC.cpp b/HDOJ/4466_autoAC.cpp
new file mode 100644
index 0000000..dcf4dcc
--- /dev/null
+++ b/HDOJ/4466_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <cstring>
+#include <algorithm>
+#include <cstdio>
+#define maxn 5000500
+#define M 1000000007
+#define ll long long
+using namespace std;
+ll f[maxn];
+ll count(ll x)
+{
+    ll tot=0;
+    for (int i=1; i<=x/3; i++)
+    {
+        int tep=x-i;
+        if (tep/2>=max(i,(tep-i)/2+1))
+        {
+            tot=(tot+tep/2-max(i,(tep-i)/2+1)+1);
+            if (tot>=M) tot-=M;
+        }
+    }
+    return tot;
+}
+ll get(ll x) 
+{
+    if (f[x]!=0) return f[x];
+    ll tot=0;
+    for (int i=3; i<=x/2; i++)
+        if (x%i==0)
+        {
+            tot=(tot+get(i));
+            if (tot>=M) tot-=M;
+        }
+    f[x]=count(x)-tot;
+    if (f[x]<0) f[x]+=M;
+    return f[x];
+}
+ll power(ll x,ll y)
+{
+    ll tot=1;
+    while (y)
+    {
+        if (y&1) tot=(tot*x)%M;
+        x=(x*x)%M;
+        y>>=1;
+    }
+    return tot;
+}
+int main()
+{
+    ll n,ans,tep,cas=0;
+    while (scanf("%I64d",&n)!=EOF)
+    {
+        ans=0;
+        for (int i=1; i*i<=n; i++)
+        {
+            if (n%i==0)
+            {
+                tep=get(i); 
+                tep=(tep*power(2,n/i-1))%M;
+                ans+=tep;
+                if (ans>=M) ans-=M;
+                if (i*i!=n)
+                {
+                    tep=get(n/i);
+                    tep=(tep*power(2,i-1))%M;
+                    ans+=tep;
+                    if (ans>=M) ans-=M;
+                }
+            }
+        }
+        printf("Case %I64d: %I64d\n",++cas,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4467_autoAC.cpp b/HDOJ/4467_autoAC.cpp
new file mode 100644
index 0000000..ac25b45
--- /dev/null
+++ b/HDOJ/4467_autoAC.cpp
@@ -0,0 +1,99 @@
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+#include<cmath>
+#include<algorithm>
+#include<vector>
+using namespace std;
+typedef long long LL;
+const int N = 101010;
+int n, m;
+LL ans[3], sum[N][2];
+vector<LL> c[N];
+vector<int> lin[N];
+int color[N], key[N], deg[N];
+struct node{
+    int a,b; LL c;
+    bool operator < (const node &tmp)const{
+        return (a<tmp.a)||(a==tmp.a&&b<tmp.b);    
+    }
+}e[N];
+void init(){
+    int lim = (int)sqrt(n);        
+    for(int i = 0; i <= n; i++) c[i].clear(), lin[i].clear();
+    memset( sum, 0, sizeof(sum));
+    memset( ans, 0, sizeof(ans));
+    memset( key, 0, sizeof(key));
+    memset( deg, 0, sizeof(deg));
+    for(int i = 1; i <= n; i++) scanf("%d", &color[i] );
+    for(int i = 1; i <= m; i++){
+        scanf("%d%d%I64d",&e[i].a,&e[i].b,&e[i].c);
+        if( e[i].a > e[i].b ) swap( e[i].a, e[i].b );        
+    }    
+    sort( e+1, e+m+1 );
+    int t = 1;
+    for(int i = 2; i <= m; i++) 
+        if( e[i].a != e[t].a || e[i].b != e[t].b ) e[++t] = e[i];
+        else    e[t].c += e[i].c;
+    m = t; 
+    for(int i = 1; i <= m; i++){
+        int a = e[i].a, b = e[i].b; 
+        ans[ color[a]+color[b] ] += e[i].c;
+        deg[a]++; deg[b]++;    
+    }        
+    lim = round(sqrt(n));    
+    for(int i = 1; i <= n; i++) if( deg[i] > lim ) key[i] = 1;
+    for(int i = 1; i <= m; i++){
+        int a = e[i].a, b = e[i].b;
+        sum[a][ color[b] ] += e[i].c;
+        sum[b][ color[a] ] += e[i].c;
+        if( key[a] && key[b] ){
+            lin[a].push_back(b); c[a].push_back(e[i].c);
+            lin[b].push_back(a); c[b].push_back(e[i].c);    
+        }     
+        if( key[a] == 0 ) lin[a].push_back(b),c[a].push_back(e[i].c);
+        if( key[b] == 0 ) lin[b].push_back(a),c[b].push_back(e[i].c);
+    }
+}
+void change(int x){
+    if( key[x] ){ 
+        for(int i = 0; i < (int)(lin[x].size()); i++){
+            sum[ lin[x][i] ][ color[x] ] -= c[x][i];
+            sum[ lin[x][i] ][ color[x]^1 ] += c[x][i]; 
+        }    
+    }
+    else{ 
+        sum[x][0] = sum[x][1] = 0;
+        for(int i = 0; i < (int)(lin[x].size()); i++){
+            sum[x][ color[ lin[x][i] ] ] += c[x][i];
+            if( key[ lin[x][i] ] ){
+                sum[ lin[x][i] ][ color[x] ] -= c[x][i];
+                sum[ lin[x][i] ][ color[x]^1 ] += c[x][i];
+            }        
+        }
+    }    
+    ans[ color[x]+0 ] -= sum[x][0]; ans[ color[x]+1 ] -= sum[x][1];
+    ans[ (color[x]^1)+0 ] += sum[x][0]; ans[ (color[x]^1)+1 ] += sum[x][1];
+    color[x] ^= 1;    
+} 
+int main(){
+    int Case = 1;
+    while( scanf("%d%d",&n,&m) != EOF){
+        printf("Case %d:\n", Case++);
+        init();
+        char op[110]; int Q, a, b;
+        scanf("%d", &Q );
+        while( Q-- ){
+            scanf("%s", op);
+            if( op[0] == 'A' ){
+                scanf("%d%d",&a,&b);
+                printf("%I64d\n", ans[a+b] );
+            }
+            else{
+                scanf("%d",&a);
+                change( a );
+            }        
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4468_autoAC.cpp b/HDOJ/4468_autoAC.cpp
new file mode 100644
index 0000000..4d48ce8
--- /dev/null
+++ b/HDOJ/4468_autoAC.cpp
@@ -0,0 +1,77 @@
+#include<cstring>
+#include<iostream>
+#include<cstdio>
+using namespace std;
+#define MAXN 100005
+int ne[MAXN];
+char s[MAXN],p[MAXN];
+void getnext(int n,int st)
+{
+    for(int i=st+1;i<n;i++)
+    {
+        int j=ne[i];
+        while(j&&p[i]!=p[j])
+        {
+            j=ne[j];
+        }
+        if(p[i]==p[j])
+        {
+            ne[i+1]=j+1;
+        }
+        else
+        {
+            ne[i+1]=0;
+        }
+    }
+}
+int ans;
+int updata(int last,int now,int st)
+{
+    int len=st+1;
+    for(int i=last+1;i<=now;i++)
+    {
+        p[len++]=s[i];
+    }
+    p[len]='\0';
+    getnext(len,st);
+    return len;
+}
+int kmp(int m)
+{
+    getnext(m,0);
+    int j=0;
+    int last;
+    for(int i=0;s[i];i++)
+    {
+        while(j&&s[i]!=p[j])
+            j=ne[j];
+        if(j==0&&s[i]!=p[j])
+        {
+            m=updata(last,i,m-1);
+            last=i;
+        }
+        if(s[i]==p[j])
+          j++;
+        if(j==m)
+        {
+            last=i;
+        }
+    }
+    for(int i=last+1;s[i];i++)
+        m++;
+    ans=m;
+    return -1;
+}
+int main()
+{
+    int cas=1;
+    while(scanf("%s",&s)!=EOF)
+    {
+        memset(ne,0,sizeof(ne));
+        p[0]=s[0];
+        p[1]='\0';
+        ans=1;
+        kmp(1);
+        printf("Case %d: %d\n",cas++,ans);
+    }
+}
diff --git a/HDOJ/4471_autoAC.cpp b/HDOJ/4471_autoAC.cpp
new file mode 100644
index 0000000..f7ab173
--- /dev/null
+++ b/HDOJ/4471_autoAC.cpp
@@ -0,0 +1,94 @@
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+const int N =102;
+const int mod = 1000000007;
+int h;
+struct matrix
+{
+    int row,col;
+    int m[N][N];
+    void init(int row,int col)
+    {
+        this->row = row;
+        this->col = col;
+        for(int i=0; i<=row; ++i)
+            for(int j=0; j<=col; ++j)
+                m[i][j] = 0;
+    }
+} A,pm[33],ans;
+matrix operator*(const matrix & a,const matrix& b)
+{
+    matrix res;
+    res.init(a.row,b.col);
+    for(int k=1; k<=a.col; ++k)
+    {
+        for(int i=1; i<= res.row; ++i)
+        {
+            if(a.m[i][k] == 0 ) continue;
+            for(int j = 1; j<=res.col; ++j)
+            {
+                if(b.m[k][j] == 0 ) continue;
+                res.m[i][j] = (1LL *a.m[i][k]*b.m[k][j] + res.m[i][j])%mod;
+            }
+        }
+    }
+    return res;
+}
+void cal(int x)
+{
+    for(int i=0; i<=31; ++i)
+        if(x & (1<<i) ) ans = pm[i]*ans;
+}
+void getPm()
+{
+    pm[0] = A;
+    for(int i=1; i<=31; ++i)
+        pm[i] = pm[i-1]*pm[i-1];
+}
+struct sp
+{
+    int nk,tk;
+    int ck[N];
+    bool operator<(const sp & o)const
+    {
+        return nk<o.nk;
+    }
+} p[N];
+int main()
+{
+    int n,m,q,t,f[N],c[N],kase=0;
+    while(~scanf("%d%d%d",&n,&m,&q))
+    {
+        for(int i=m; i>0; --i)   scanf("%d",&f[i]);
+        scanf("%d",&t);
+        h =t;
+        for(int i=1; i<=t; ++i)  scanf("%d",&c[i]);
+        for(int i=0; i<q; ++i)
+        {
+            scanf("%d%d",&p[i].nk,&p[i].tk);
+            if(p[i].tk > h) h = p[i].tk;
+            for(int j=1; j<=p[i].tk; ++j) scanf("%d",&p[i].ck[j]);
+        }
+        sort(p,p+q);
+        A.init(h,h);
+        for(int i=1; i<=t; ++i) A.m[1][i] = c[i];
+        for(int i=2; i<=h; ++i)  A.m[i][i-1] = 1;
+        getPm();
+        ans.init(h,1);
+        for(int i = m; i > 0; --i)   ans.m[i][1] = f[i];
+        int last=m;
+        for(int i=0; i<q; ++i)
+        {
+            if( p[i].nk <=last ||  p[i].nk >n ) continue;
+            cal( p[i].nk-last-1);
+            last =  p[i].nk;
+            for(int j=1; j<=p[i].tk; ++j)  A.m[1][j] = p[i].ck[j];
+            for(int j=p[i].tk+1; j<=h; ++j) A.m[1][j] = 0;
+            ans  =A*ans;
+        }
+        cal(n-last);
+        printf("Case %d: %d\n",++kase,ans.m[1][1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4472_autoAC.cpp b/HDOJ/4472_autoAC.cpp
new file mode 100644
index 0000000..b45b29a
--- /dev/null
+++ b/HDOJ/4472_autoAC.cpp
@@ -0,0 +1,25 @@
+#include <cstdio>
+#include <cstring>
+#define N 1010
+#define MOD 1000000007
+long long dp[N];
+int n;
+void DP()
+{
+    memset(dp,0,sizeof(dp));
+    dp[1]=1; dp[2]=1;
+    for(int i=3; i<=1000; i++)
+        for(int j=1; j<=i-1; j++)
+            if((i-1)%j == 0)
+                dp[i] = (dp[i]+dp[j])%MOD;
+}
+int main()
+{
+    DP();
+    int ccase=0;
+    while(scanf("%d",&n)!=EOF)
+    {
+        printf("Case %d: %lld\n",++ccase,dp[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4473_autoAC.cpp b/HDOJ/4473_autoAC.cpp
new file mode 100644
index 0000000..e15a530
--- /dev/null
+++ b/HDOJ/4473_autoAC.cpp
@@ -0,0 +1,38 @@
+#include<iostream>
+#include<stdio.h>
+#include<string.h>
+#include<set>
+#include <stack>
+#include<queue>
+#include<algorithm>
+#include<cmath>
+#define oo 1000000007
+#define MAXN 100005
+#define ll long long
+#define pi acos(-1.0) 
+using namespace std;    
+ll n,i,j,k,ans=0;
+int main()
+{         
+      int cases=0; 
+      while (~scanf("%I64d",&n))
+      {
+              ans=0;
+              for (i=1;i*i*i<=n;i++) ans++;
+              for (i=1;i*i<=n;i++)
+              {
+                      k=n/i/i;
+                      if (k>=i) ans+=(k-1)*3; 
+                           else ans+=k*3;
+              }
+              for (i=1;i*i*i<=n;i++) 
+                 for (j=i+1;j<=n;j++)
+                 {
+                          k=n/i/j;
+                          if (k>j) ans+=(k-j)*6; 
+                              else break;
+                 } 
+              printf("Case %d: %I64d\n",++cases,ans);
+      }
+      return 0;
+}
diff --git a/HDOJ/4474_autoAC.cpp b/HDOJ/4474_autoAC.cpp
new file mode 100644
index 0000000..55f32a4
--- /dev/null
+++ b/HDOJ/4474_autoAC.cpp
@@ -0,0 +1,62 @@
+#include<cstdio>
+#include<cstring>
+using namespace std;
+struct{
+    int m,f;
+    char c;
+}d[10010],tmp;
+int n,m,l,r;
+bool h[10010],k[10];
+void out(int x){
+    if(x==-1)return;
+    out(d[x].f);
+    putchar(d[x].c);
+}
+int main()
+{
+    int C=0;
+    while (~scanf("%d%d",&n,&m)){
+        printf("Case %d: ",++C);
+        memset(h,true,sizeof(h));
+        memset(k,true,sizeof(k));
+        l=r=0;
+        for(int i=0;i<m;i++){
+            int x;
+            scanf("%d",&x);
+            k[x]=0;
+        }
+        int ans=-1;
+        for(int i=1;i<10;i++)if(k[i]){
+            tmp.c=i+'0';
+            h[tmp.m=i%n]=false;
+            tmp.f=-1;
+            d[r++]=tmp;
+            if(tmp.m==0){
+                ans=r-1;
+                break;
+            }
+        }
+        while(l<r && ans==-1){
+            for(int i=0;i<10;i++)if(k[i]){
+                tmp.c=i+'0';
+                tmp.m=(d[l].m*10 + i)%n;
+                if(h[tmp.m]){
+                    h[tmp.m]=false;
+                    tmp.f=l;
+                    d[r++]=tmp;
+                    if(tmp.m==0){
+                        ans=r-1;
+                        break;
+                    }
+                }
+            }
+            l++;
+        }
+        if(ans==-1) puts("-1");
+        else{
+            out(ans);
+            putchar('\n');
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4475_autoAC.cpp b/HDOJ/4475_autoAC.cpp
new file mode 100644
index 0000000..051e5aa
--- /dev/null
+++ b/HDOJ/4475_autoAC.cpp
@@ -0,0 +1,26 @@
+#include<iostream>
+#include<cstdio>
+#include<math.h>
+using namespace std;
+const int con=1000003;
+__int64 arr[con+1000];
+int main()
+{
+    int T;
+    __int64 n;
+    arr[0]=0;
+    arr[1]=2;
+    for(int i=2;i<=con;i++)
+    {
+        arr[i]=(arr[i-1]*2*i)%con;
+    }
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%I64d",&n);
+         if(n<=con)
+             printf("%I64d\n",arr[n%con]);
+         else printf("0\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4476_autoAC.cpp b/HDOJ/4476_autoAC.cpp
new file mode 100644
index 0000000..0fd3949
--- /dev/null
+++ b/HDOJ/4476_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+#include <set>
+using namespace std;
+const int MaxN = 200000;
+int N;
+int bit[MaxN+5];
+inline int lwb(int x) {
+    return x & -x;
+}
+void add(int x, int val) {
+    for (int i = x; i <= MaxN; i += lwb(i)) {
+        bit[i] += val;    
+    }
+}
+int sum(int x) {
+    int ret = 0;
+    for (int i = x; i > 0; i -= lwb(i)) {
+        ret += bit[i];
+    }
+    return ret;
+}
+int cal(int x) {
+    if (x <= MaxN/2) {
+        int k = x << 1;
+        return sum(k) - sum(k-1) + sum(MaxN) - sum(x - 1);
+    } else {
+        return sum(MaxN) - sum(x - 1);
+    }
+}
+char vis[100005];
+int que[100005];
+int tail;
+int main() {
+    int T, x;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d", &N);
+        tail = 0;
+        memset(bit, 0, sizeof (bit));
+        memset(vis, 0, sizeof (vis));
+        for (int i = 0; i < N; ++i)    {
+            scanf("%d", &x);
+            add(x<<1, 1);
+            if (!vis[x]) {
+                vis[x] = 1;
+                que[tail++] = x;
+            }
+        }
+        int Max = 0;
+        for (int i = 0; i < tail; ++i) {
+            Max = max(Max, cal(que[i]));
+        }
+        printf("%d\n", Max);
+    }
+    return 0;    
+}
diff --git a/HDOJ/4477_autoAC.cpp b/HDOJ/4477_autoAC.cpp
new file mode 100644
index 0000000..c3dcbbf
--- /dev/null
+++ b/HDOJ/4477_autoAC.cpp
@@ -0,0 +1,34 @@
+#include <stdio.h>  
+#define N 50000  
+#define M 1000000  
+#define K 316  
+int main()  
+{  
+    int dp[2][N+2];  
+    int ans[N+2];  
+    for(int i=3;i<=N;i++)  
+    {  
+        ans[i]=dp[0][i]=dp[0][i-2]+1;  
+    }  
+    for(int k=3;k<=K;k++)  
+    {  
+        int *p1=dp[k&1];int *p2=dp[(k+1)&1];  
+        for(int i=0;i<=k*(k+1)/2-1;i++) p1[i]=0;  
+        for(int i=k*(k+1)/2;i<=N;i++)  
+        {  
+            p1[i]=p1[i-k]+p2[i-k];  
+            if(p1[i]>=M)  
+            p1[i]-=M;  
+            ans[i]+=p1[i];  
+            if(ans[i]>=M)  
+            ans[i]-=M;  
+        }  
+    }  
+    int t,n;  
+    scanf("%d",&t);  
+    while(t--)  
+    {  
+        scanf("%d",&n);  
+        printf("%d\n",ans[n]);  
+    }  
+}
diff --git a/HDOJ/4478_autoAC.cpp b/HDOJ/4478_autoAC.cpp
new file mode 100644
index 0000000..691ed65
--- /dev/null
+++ b/HDOJ/4478_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <iostream>
+#include <queue>
+using namespace std;
+int N, T, sx, sy;
+char mp[105][105];
+char vis[105][105][2];
+struct Sta {
+    int x, y, t;    
+};
+queue<Sta>q;
+int dir[8][2]={{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1}};
+inline bool judge(int x, int y) {
+    if (x >= 0 && x < N && y >= 0 && y < N) return true;
+    return false;
+}
+void cover(const Sta &cur) {
+    Sta nxt;
+    bool flag = false;
+    for (int k = 0; k < 8; ++k) {
+        nxt.x = cur.x + dir[k][0];
+        nxt.y = cur.y + dir[k][1];
+        nxt.t = cur.t + 1;
+        if (judge(nxt.x, nxt.y) && mp[nxt.x][nxt.y] == '.') {
+            flag = true;
+            if (!vis[nxt.x][nxt.y][nxt.t&1]) {
+                vis[nxt.x][nxt.y][nxt.t&1] = 1;
+                if (nxt.t < T) {
+                    q.push(nxt);
+                }
+            }
+        }
+    }
+    if (!flag) {
+        nxt = cur;
+        ++nxt.t;
+        if (!vis[nxt.x][nxt.y][nxt.t&1]) {
+            vis[nxt.x][nxt.y][nxt.t&1] = 1;
+            if (nxt.t < T) {
+                q.push(nxt);
+            }
+        }
+    }
+}
+void solve() {
+    while (!q.empty()) q.pop();
+    memset(vis, 0, sizeof (vis));
+    Sta cur, nxt;
+    nxt.x = sx, nxt.y = sy, nxt.t = 0;
+    vis[sx][sy][0] = 1;
+    q.push(nxt);
+    while (!q.empty()) {
+        cur = q.front(), q.pop();
+        cover(cur);
+    }
+    int odd = 0, even = 0;
+    for (int i = 0; i < N; ++i) {
+        for (int j = 0; j < N; ++j) {
+            if (vis[i][j][0]) ++even;
+            if (vis[i][j][1]) ++odd;
+        }
+    }
+    if (T & 1) printf("%d\n", odd);
+    else printf("%d\n", even);
+}
+int main() {
+    int C;
+    scanf("%d", &C);
+    while (C--) {
+        scanf("%d %d %d %d", &N, &T, &sx, &sy);
+        sx--, sy--;
+        for (int i = 0; i < N; ++i) {
+            scanf("%s", mp[i]);
+        }
+        solve();
+    }
+    return 0;    
+}
diff --git a/HDOJ/4479_autoAC.cpp b/HDOJ/4479_autoAC.cpp
new file mode 100644
index 0000000..921f648
--- /dev/null
+++ b/HDOJ/4479_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <cstdlib>
+#include <cstdio>
+#include <algorithm>
+#include <iostream>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+int N, M;
+struct Edge {
+    int x, y, d;
+    bool operator < (const Edge & ot) const {
+        return d < ot.d;
+    }
+}e[50005];
+const LL INF = 0x3f3f3f3f3f3f3f3fLL;
+LL   dis[10005];
+struct Rec {
+    int v;
+    LL d;
+}rec[10005];
+void update(int l, int r) {
+    int u, v, d, idx = 0;
+    for (int i = l; i <= r; ++i) {
+        u = e[i].x, v = e[i].y, d = e[i].d;
+        if (dis[u] != INF && dis[v] > dis[u] + d) {
+            rec[idx].v = v, rec[idx++].d = dis[u] + d;
+        }
+        if (dis[v] != INF && dis[u] > dis[v] + d) {
+            rec[idx].v = u, rec[idx++].d = dis[v] + d;
+        }
+    }
+    for (int i = 0; i < idx; ++i) {
+        dis[rec[i].v] = min(dis[rec[i].v], rec[i].d);
+    }
+}
+void solve() {
+    memset(dis, 0x3f, sizeof (dis));
+    dis[1] = 0;
+    for (int i = 0, j; i < M; i = j) {
+        for (j = i + 1; j < M; ++j) {
+            if (e[j].d != e[i].d) break;
+        }
+        update(i, j-1); 
+    }
+    if (dis[N] == INF) puts("No answer");
+    else printf("%I64d\n", dis[N]);
+}
+int main() {
+    int T;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d %d", &N, &M);
+        for (int i = 0; i < M; ++i) {
+            scanf("%d %d %d", &e[i].x, &e[i].y, &e[i].d);
+        }
+        sort(e, e + M);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4483_autoAC.cpp b/HDOJ/4483_autoAC.cpp
new file mode 100644
index 0000000..e63726e
--- /dev/null
+++ b/HDOJ/4483_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <iostream>
+using namespace std;
+#define maxn 100001
+#define LL long long
+const LL mod=1000000007;
+LL x[maxn],y[maxn],z[maxn],phi[maxn],n;
+void init()
+{
+    LL i,j,k;
+    for(i=2;i<maxn;i++)phi[i]=0;
+    phi[1]=1;
+    for(i=2;i<maxn;i++)
+        if(!phi[i])
+        for(j=i;j<=maxn;j+=i){
+            if(!phi[j])phi[j]=j;
+            phi[j]=phi[j]/i*(i-1);
+        }
+    x[1]=z[1]=1;
+    y[1]=2;
+    for(i=2;i<maxn;i++)
+    {
+        x[i]=(x[i-1]+phi[i]*2)%mod;
+        y[i]=(y[i-1]+phi[i]*i*3)%mod;
+        z[i]=(z[i-1]+phi[i]*i%mod*i)%mod;
+    }
+}
+int main()
+{
+    LL T;
+    init();
+    cin>>T;
+    while(T--)
+    {
+        LL k,t,ans,m;
+        cin>>n;
+        n++;
+        t=(n*n)%mod;
+        LL md=mod*6;
+        ans=t*(t-1)%md*(t-2)%md/6;
+        ans-=t*(n-1)%md*(n-2)*2%md/6;
+        t=0;
+        for(k=2;k<n;k++)
+        {
+            m=(n-1)/k;
+            t=(t+(k-1)*(x[m]*n%mod*n%mod-n*k%mod*y[m]%mod+k*k%mod*z[m]%mod))%mod;
+        }
+        ans-=t*2;
+        cout<<(ans%mod+mod)%mod<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4484_autoAC.cpp b/HDOJ/4484_autoAC.cpp
new file mode 100644
index 0000000..800c3c9
--- /dev/null
+++ b/HDOJ/4484_autoAC.cpp
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+using namespace std;
+int cal(int n) {
+  int Max = n;
+  while (n!=1) {
+    if ((n&1) == 0) {
+      n /= 2;
+    } else {
+      n = n * 3 + 1;
+    }
+    if (n > Max) Max = n;
+  }
+  return Max;
+}
+void solve() {
+  int n; scanf("%d", &n);
+  int i, t, ca;
+  for (i = 0; i < n; ++i) {
+    scanf("%d%d", &t, &ca);
+    int ans = cal(ca);
+    printf("%d %d\n", t, ans);
+  }
+}
+int main(void) {
+  solve();
+  return 0;
+}
diff --git a/HDOJ/4485_autoAC.cpp b/HDOJ/4485_autoAC.cpp
new file mode 100644
index 0000000..7b4cda9
--- /dev/null
+++ b/HDOJ/4485_autoAC.cpp
@@ -0,0 +1,26 @@
+#include<stdio.h>
+#include<string.h>
+#include<iostream>
+#include<string>
+#include<algorithm>
+using namespace std;
+int p,a,b;
+char s[10000000+1];
+int main()
+{
+    scanf("%d",&p);
+    while(p--)
+    {
+        scanf("%d%d%s",&a,&b,s);
+        int j=0;
+        int ans=0;
+        int l=strlen(s)-1;
+        for(int i=l;i>=0;i--)
+        {
+            ans+=(s[i]-'0')%(b-1);
+            ans%=b-1;
+        }
+        printf("%d %d\n",a,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4486_autoAC.cpp b/HDOJ/4486_autoAC.cpp
new file mode 100644
index 0000000..61a2b44
--- /dev/null
+++ b/HDOJ/4486_autoAC.cpp
@@ -0,0 +1,25 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<cmath>
+using namespace std;
+int main()
+{
+    int cas;
+    scanf("%d",&cas);
+    while(cas--)
+    {
+        int id,n,tot=0;
+        scanf("%d %d",&id,&n);
+        if(n%3==0) tot++;
+        int top=(int)ceil(n*1.0/3);
+        for(int i=n/2;i>=top;i--)
+        {
+            if(n-i==i) continue;
+            if((n-i)&1) {tot+=(i-(n-i+1)/2+1)*2;tot--;}
+            else {tot+=(i-(n-i)/2+1)*2;tot-=2;}
+        }
+        printf("%d %d\n",id,tot);
+    }
+    return 0;
+}
diff --git a/HDOJ/4487_autoAC.cpp b/HDOJ/4487_autoAC.cpp
new file mode 100644
index 0000000..4be3bc1
--- /dev/null
+++ b/HDOJ/4487_autoAC.cpp
@@ -0,0 +1,42 @@
+#include<algorithm>
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<cmath>
+#define LL long long
+#define CLR(a, b) memset(a, b, sizeof(a))
+using namespace std;
+const int N = 205;
+double dp[2][N][N];
+int main()
+{
+    int t, n,cas;double L, R, ans;
+    scanf("%d", &t);
+    while(t --)
+    {
+        scanf("%d%d%lf%lf", &cas, &n, &L, &R);
+        CLR(dp, 0);dp[0][0][100] = 1;
+        for(int i = 1; i <= n; i ++)
+        {
+            CLR(dp[i&1], 0);
+            for(int j = 0; j <= i; j ++)
+            {
+                for(int k = 100 - i; k <= 100 + j; k ++)
+                {
+                    dp[i&1][j][k] += dp[(i-1)&1][j][k-1] * R;
+                    dp[i&1][j][k] += dp[(i-1)&1][j][k+1] * L;
+                    dp[i&1][j][k] += dp[(i-1)&1][j][k] * (1.0 - L - R);
+                }
+                dp[i&1][j][100+j] += dp[(i-1)&1][j-1][99+j] * R;
+            }
+        }ans = 0;
+        for(int i = 0; i <= n; i ++)
+        {
+            for(int j = 100 - n; j <= 100 + n; j ++)
+            {
+                ans += i * dp[n&1][i][j];
+            }
+        }
+        printf("%d %.4lf\n", cas, ans);
+    }
+}
diff --git a/HDOJ/4488_autoAC.cpp b/HDOJ/4488_autoAC.cpp
new file mode 100644
index 0000000..fab7e8e
--- /dev/null
+++ b/HDOJ/4488_autoAC.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#define N 100000
+using namespace std;
+__int64 f[405][405][2],MIN,sum1,sum2;
+__int64 getsMIN(__int64 x,__int64 y)
+{
+    x=(x<0)?-x:x;
+    y=(y<0)?-y:y;
+    __int64 t=x%y;
+    while(t!=0)
+    {
+        x=y;
+        y=t;
+        t=x%y;
+    }
+    return y;
+}
+int main()
+{
+    f[0][1][1]=1;f[0][1][2]=1;
+    f[1][2][1]=1;f[1][2][2]=2;
+    f[1][1][1]=1;f[1][1][2]=2;
+    int i,j,P,T,m,k,ans;
+    for(i=2;i<=400;i++)
+    {
+        for(j=i+1,sum1=0,sum2=1;j>1;j--)
+        {
+            f[i][j][1] = i*f[i-1][j-1][1];
+            f[i][j][2] = j*f[i-1][j-1][2];
+            MIN=getsMIN(f[i][j][1],f[i][j][2]);
+            f[i][j][1] /= MIN;
+            f[i][j][2] /= MIN;
+            if(sum2%f[i][j][2])
+            {
+                sum1 = sum1*f[i][j][2]+f[i][j][1]*sum2;
+                sum2 *= f[i][j][2];
+            }
+            else sum1 = sum1 + f[i][j][1]*(sum2/f[i][j][2]);
+            MIN=getsMIN(sum1,sum2);
+            sum1 /= MIN;
+            sum2 /= MIN;
+        }
+        f[i][1][2] = sum2;
+        f[i][1][1] = sum2-sum1;
+        MIN=getsMIN(f[i][1][1],f[i][1][2]);
+            f[i][1][1] /= MIN;
+            f[i][1][2] /= MIN;
+    }
+    scanf("%d",&P);
+    while(P--)
+    {
+        scanf("%d %d %d",&T,&m,&k);
+        if(!f[m][k][1])
+            printf("%d 0\n",T);
+        else
+        {
+            if(f[m][k][2]==1)
+                printf("%d %I64d\n",T,f[m][k][1]);
+            else printf("%d %I64d/%I64d\n",T,f[m][k][1],f[m][k][2]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4489_autoAC.cpp b/HDOJ/4489_autoAC.cpp
new file mode 100644
index 0000000..08c4a12
--- /dev/null
+++ b/HDOJ/4489_autoAC.cpp
@@ -0,0 +1,43 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+#include <queue>
+#include <cstdlib>
+#include <stack>
+#include <vector>
+#include <set>
+#include <map>
+#define LL long long
+#define mod 1000000007
+#define inf 0x3f3f3f3f
+#define N 1000010
+#define clr(a) (memset(a,0,sizeof(a)))
+using namespace std;
+LL dp[21][2],ans[21],c[21][21];
+void init()
+{
+    for(int i=0;i<=20;i++)c[i][0]=c[i][i]=1;
+    for(int i=1;i<=20;i++)
+        for(int j=1;j<i;j++)c[i][j]=c[i-1][j-1]+c[i-1][j];
+    dp[0][0]=dp[0][1]=dp[1][1]=dp[1][0]=1;ans[1]=1;
+    for(int i=2;i<=20;i++)
+    {
+        for(int j=1;j<=i;j++)
+        {
+            ans[i]+=c[i-1][j-1]*dp[j-1][0]*dp[i-j][1];
+        }
+        dp[i][0]=dp[i][1]=ans[i]/2;
+    }
+}
+int main()
+{
+    int t,cas,n;init();
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&cas,&n);
+        printf("%d %I64d\n",cas,ans[n]);
+    }
+}
diff --git a/HDOJ/4490_autoAC.cpp b/HDOJ/4490_autoAC.cpp
new file mode 100644
index 0000000..eb2cb2c
--- /dev/null
+++ b/HDOJ/4490_autoAC.cpp
@@ -0,0 +1,149 @@
+#include <iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+#include<cstdlib>
+#include<cctype>
+#include<map>
+#include<string>
+#include<set>
+#include<queue>
+#include<vector>
+using namespace std;
+const int N = 100005;
+const int M = 8;
+const int INF = 0x3f3f3f3f;
+const double eps = 1e-5;
+const double PI = acos(-1.0);
+typedef __int64 ll;
+map<int,int> mp[M][M];
+struct node
+{
+    int num[3];
+    string ans;
+}ss,now;
+int lcm[3][3];
+int sa,sb,sc,ea,eb,ec;
+struct wocao
+{
+    struct node t[N];
+    int head,tail;
+    void init()
+    {
+        head = tail = 0;
+    }
+    bool empty()
+    {
+        return head == tail;
+    }
+    void push(struct node a)
+    {
+        t[tail] = a;
+        tail ++;
+        if(tail >= N)
+            tail -= N;
+    }
+    struct node front()
+    {
+        return t[head];
+    }
+    void pop()
+    {
+        head ++;
+        if(head >= N)
+            head -= N;
+    }
+}q;
+void bfs()
+{
+    ss.ans.clear();
+    ss.num[0] = sa;ss.num[1] = sb;ss.num[2] = sc;
+    for(int i = 0;i < M;i ++)
+        for(int j = 0;j < M;j ++)
+            mp[i][j].clear();
+    mp[sa][sb][sc] = 1;
+    q.init();
+    q.push(ss);
+    while(!q.empty())
+    {
+        now = q.front();
+        q.pop();
+        int i;
+        for(i = 0;i < 3;i ++)
+        {
+            ss = now;
+            if(ss.num[i])
+            {
+                ss.num[i] --;
+                ss.num[0] += lcm[i][0];
+                ss.num[1] += lcm[i][1];
+                ss.num[2] += lcm[i][2];
+                if(ss.num[0] >= M || ss.num[1] >= M || ss.num[2] >= M)
+                    continue;
+                if(mp[ss.num[0]][ss.num[1]].find(ss.num[2]) == mp[ss.num[0]][ss.num[1]].end())
+                {
+                    mp[ss.num[0]][ss.num[1]][ss.num[2]] = 1;
+                    ss.ans += 'A' + i;
+                    if(ss.num[0] == ea && ss.num[1] == eb && ss.num[2] == ec)
+                    {
+                        cout<<ss.ans.length()<<" "<<ss.ans<<endl;
+                        return;
+                    }
+                    q.push(ss);
+                }
+            }
+        }
+        for(i = 0;i < 3;i ++)
+        {
+            ss = now;
+            if(ss.num[0] >= lcm[i][0] && ss.num[1] >= lcm[i][1] && ss.num[2] >= lcm[i][2])
+            {
+                ss.num[0] -= lcm[i][0];
+                ss.num[1] -= lcm[i][1];
+                ss.num[2] -= lcm[i][2];
+                ss.num[i] ++;
+                if(ss.num[0] >= M || ss.num[1] >= M || ss.num[2] >= M)
+                    continue;
+                if(mp[ss.num[0]][ss.num[1]].find(ss.num[2]) == mp[ss.num[0]][ss.num[1]].end())
+                {
+                    mp[ss.num[0]][ss.num[1]][ss.num[2]] = 1;
+                    ss.ans += 'a' + i;
+                    if(ss.num[0] == ea && ss.num[1] == eb && ss.num[2] == ec)
+                    {
+                        cout<<ss.ans.length()<<" "<<ss.ans<<endl;
+                        return;
+                    }
+                    q.push(ss);
+                }
+            }
+        }
+    }
+    puts("NO SOLUTION");
+}
+int main()
+{
+    int cas,t,n;
+    int i,j;
+    scanf("%d",&t);
+    while(t --)
+    {
+        scanf("%d%d",&cas,&n);
+        for(i = 0;i < 3;i ++)
+        {
+            for(j = 0;j < 3;j ++)
+            {
+                scanf("%d",&lcm[i][j]);
+            }
+        }
+        int ca;
+        printf("%d %d\n",cas,n);
+        while(n --)
+        {
+            scanf("%d%d%d%d%d%d%d",&ca,&sa,&sb,&sc,&ea,&eb,&ec);
+            printf("%d ",ca);
+            bfs();
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4491_autoAC.cpp b/HDOJ/4491_autoAC.cpp
new file mode 100644
index 0000000..6219b55
--- /dev/null
+++ b/HDOJ/4491_autoAC.cpp
@@ -0,0 +1,109 @@
+#include<iostream>
+#include<cmath>
+#include<cstdio>
+#include<cstdlib>
+#include<string>
+#include<cstring>
+#include<algorithm>
+#include<vector>
+#include<map>
+#include<set>
+#include<stack>
+#include<list>
+#include<queue>
+#define eps 1e-6
+#define INF 0x1f1f1f1f
+#define PI acos(-1.0)
+#define ll __int64
+#define lson l,m,(rt<<1)
+#define rson m+1,r,(rt<<1)|1
+using namespace std;
+struct Point
+{
+   double x,y;
+}pp[22],p1,p2,p3;
+Point oa,ob; 
+double dis(Point a) 
+{
+   return sqrt(a.x*a.x+a.y*a.y);
+}
+double dmult(Point a,Point b)
+{
+   return a.x*b.x+a.y*b.y;
+}
+double xmult(Point a,Point b) 
+{
+   return a.x*b.y-a.y*b.x;
+}
+int main()
+{
+   int t,d,m,s,be,aa;
+   double an;
+   scanf("%d",&t);
+   while(t--)
+   {
+      scanf("%d%d%d%d%lf",&d,&m,&s,&be,&an);
+      an=(an/180.0)*PI;
+      for(int i=1;i<=m;i++)
+         scanf("%d%lf%lf",&aa,&pp[i].x,&pp[i].y);
+      int la=be;
+      oa.x=cos(an),oa.y=sin(an);
+      ob.x=-oa.x,ob.y=-oa.y;
+      int flag,find;
+      double Max;
+      printf("%d ",d);
+      while(s--)
+      {
+         Max=-120;
+         for(int i=1;i<=m;i++)
+         {
+            if(i==be||i==la) 
+               continue;
+            Point tmp;
+            tmp.x=pp[i].x-pp[be].x;
+            tmp.y=pp[i].y-pp[be].y;
+            double tt=xmult(oa,tmp);
+            if(tt>0) 
+            {
+               double t=dmult(oa,tmp)/dis(oa)/dis(tmp);
+               if(t>Max) 
+               {
+                  Max=t;
+                  flag=1;
+                  find=i;
+               }
+            }
+            else if(tt<0)
+            {
+               double t=dmult(ob,tmp)/dis(ob)/dis(tmp);
+               if(t>Max)
+               {
+                  Max=t;flag=2;find=i;
+               }
+            }
+         }
+         printf("%d",find);
+         la=be;
+         be=find;
+         if(s)
+            putchar(' ');
+         else
+            putchar('\n');
+         if(flag==1) 
+         {
+            ob.x=pp[la].x-pp[be].x; 
+            ob.y=pp[la].y-pp[be].y;
+            oa.x=-ob.x;  
+            oa.y=-ob.y;
+         }
+         else
+         {
+            oa.x=pp[la].x-pp[be].x;
+            oa.y=pp[la].y-pp[be].y;
+            ob.x=-oa.x;
+            ob.y=-oa.y;
+         }
+      }
+   }
+   return 0;
+}
diff --git a/HDOJ/4492_autoAC.cpp b/HDOJ/4492_autoAC.cpp
new file mode 100644
index 0000000..6eff3fc
--- /dev/null
+++ b/HDOJ/4492_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std;
+char str1[200];
+char str2[200];
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int d,n;
+        scanf("%d%*c",&d);
+        gets(str1);
+        int len=strlen(str1);
+        scanf(" %d",&n);
+        int p=0;
+        for(int i=0;i<n;i++)
+        {
+            int x;
+            scanf("%d",&x);
+            p = (p+x+len)%len;
+            str2[i]=str1[p];
+        }
+        printf("%d ",d);
+        for(int i=0;i<n;i++)
+            printf("%c",str2[i]);
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4493_autoAC.cpp b/HDOJ/4493_autoAC.cpp
new file mode 100644
index 0000000..1a6c26c
--- /dev/null
+++ b/HDOJ/4493_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        double sum = 0;
+        double a;
+        for(int i = 0;i < 12;i++)
+        {
+            scanf("%lf",&a);
+            sum += a;
+        }
+        sum /= 12;
+        char str[1000];
+        sprintf(str,"%.2f",sum);
+        int len = strlen(str);
+        if(str[len-2] == '0' && str[len-1] == '0')
+            str[len-3] = 0;
+        else if(str[len-1] == '0')
+            str[len-1] = 0;
+        printf("$%s\n",str);
+    }
+    return 0;
+}
diff --git a/HDOJ/4494_autoAC.cpp b/HDOJ/4494_autoAC.cpp
new file mode 100644
index 0000000..dfc7604
--- /dev/null
+++ b/HDOJ/4494_autoAC.cpp
@@ -0,0 +1,151 @@
+#include<iostream>
+#include<cstring>
+#include<cstring>
+#include<cmath>
+#include<cstdio>
+#define inf 100000000
+using namespace std;
+const int Maxn = 600;
+struct Edge{
+    int v;
+    int val;
+    int cost;
+    int next;
+}edge[Maxn*600];
+struct Point{
+    double x,y;
+}p[Maxn];
+int head[Maxn],n,m,k;
+int e;
+int dis[Maxn],pre[Maxn], pos[Maxn],sta[Maxn],en[Maxn],ty[Maxn][20],flow;
+int  que[Maxn*600];
+double d[Maxn][Maxn];
+bool vis[Maxn];
+void add(int u, int v, int val, int cost)
+{
+    edge[e].v = v;
+    edge[e].val = val;
+    edge[e].cost = cost;
+    edge[e].next = head[u];
+    head[u] = e++;
+    edge[e].v = u;
+    edge[e].val = 0;
+    edge[e].cost = -cost;
+    edge[e].next = head[v];
+    head[v] = e++;
+}
+double DIS(Point a,Point b)
+{
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+void init()
+{
+    memset(head,-1,sizeof(head));
+    e=0;
+}
+bool spfa(int s, int t)
+{
+    int i;
+    memset(pre, -1, sizeof(pre));
+    memset(vis, 0, sizeof(vis));
+    int Head, tail;
+    Head = tail = 0;
+    for(i = 0; i < Maxn; i++)
+        dis[i] = inf;
+    que[tail++] = s;
+    pre[s] = s;
+    dis[s] = 0;
+    vis[s] = 1;
+    while(Head != tail)
+    {
+        int now = que[Head++];
+        vis[now] = 0;
+        for(i=head[now]; i != -1; i = edge[i].next)
+        {
+            int adj = edge[i].v;
+            if(edge[i].val > 0 && dis[now] + edge[i].cost < dis[adj])
+            {
+                dis[adj] = dis[now] + edge[i].cost;
+                pre[adj] = now;
+                pos[adj] = i;
+                if(!vis[adj])
+                {
+                    vis[adj] = 1;
+                    que[tail++] = adj;
+                }
+            }
+        }
+    }
+    return pre[t] != -1;
+}
+int MinCostFlow(int s, int t)
+{
+    int i;
+    int cost = 0;
+    flow = 0;
+    while(spfa(s, t))
+    {
+        int f = 100000000;
+        for(i = t; i != s; i = pre[i])
+        if (edge[pos[i]].val < f)
+            f = edge[pos[i]].val;
+            flow += f;
+            cost += dis[t] * f;
+            for(i = t; i != s; i = pre[i])
+            {
+                edge[pos[i]].val -= f;
+                edge[pos[i] ^ 1].val += f;
+            }
+    }
+    return cost;
+}
+void build(int type)
+{
+    int i,j;
+    init();
+    for(i=2;i<=n;i++){
+        add(1,i,ty[i][type],1);
+        add(i,i+2*n,ty[i][type],0);
+        add(1,i+n,ty[i][type],0);
+        add(i+2*n,3*n+1,ty[i][type],0);
+        for(j=2;j<=n;j++){
+            if(sta[i]+en[i]+d[i][j]<=sta[j]){
+                add(i+n,j+2*n,ty[i][type],0);
+            }
+        }
+    }
+}
+int solve()
+{
+    int i,j,u,v;
+    int ans=0;
+    for(i=1;i<=m;i++){
+        build(i);
+        ans+=MinCostFlow(1,3*n+1);
+    }
+    return ans;
+}
+int main()
+{
+    int i,j,u,v,c,t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        init();
+        scanf("%d%d",&n,&m);
+        scanf("%lf%lf",&p[1].x,&p[1].y);
+        for(i=2;i<=n;i++){
+            scanf("%lf%lf%d%d",&p[i].x,&p[i].y,&sta[i],&en[i]);
+            for(j=1;j<=m;j++){
+                scanf("%d",&ty[i][j]);
+            }
+        }
+        for(i=1;i<=n;i++){
+            for(j=i+1;j<=n;j++){
+                d[i][j]=d[j][i]=DIS(p[i],p[j]);
+            }
+        }
+        printf("%d\n",solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/4495_autoAC.cpp b/HDOJ/4495_autoAC.cpp
new file mode 100644
index 0000000..56aaf1d
--- /dev/null
+++ b/HDOJ/4495_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <vector>
+#define MAXN 505
+#define INF 1000000007
+using namespace std;
+const int dir[4][2]={{1,1},{-1,1},{1,-1},{-1,-1}};
+int n, m,ans;
+int dp[MAXN][MAXN][4],to[4]={3,2,1,0};
+char st[MAXN][MAXN];
+long long p[MAXN], r[MAXN][MAXN], c[MAXN][MAXN];
+void cal(int x,int y,int k)
+{
+    int now=dp[x][y][k];
+    x+=dir[k][0],y+=dir[k][1];
+    while(x>=0&&x<n&&y>=0&&y<m)
+    {
+        if(dp[x][y][to[k]]<=now)    now=dp[x][y][to[k]];
+        else    if(dp[x][y][to[k]]>=now+2)
+            now+=2;
+        else    ++now;
+        ans=max(now,ans);
+        x+=dir[k][0],y+=dir[k][1];
+    }
+}
+long long ac1(int rr,int x,int y)
+{
+    int l=y-x+1;
+    if (!x) return r[rr][y];
+    return r[rr][y]-r[rr][x-1]*p[l];
+}
+long long ac2(int cc,int x,int y)
+{
+    int l=y-x+1;
+    if (!x) return c[cc][y];
+    return c[cc][y]-c[cc][x-1]*p[l];
+}
+int main()
+{
+    int cas;
+    scanf("%d",&cas);
+    p[0]=1;
+    for (int i=1;i<=500;i++) p[i]=p[i-1]*131;
+    while (cas--)
+    {
+        ans=1;
+        scanf("%d%d",&n,&m);
+        for (int i=0;i<n;i++)
+            scanf("%s",st[i]);
+        for (int i=0;i<n;i++)
+        {
+            r[i][0]=st[i][0];
+            for (int j=1;j<m;j++)
+                r[i][j]=r[i][j-1]*131+st[i][j];
+        }
+        for (int i=0;i<m;i++)
+        {
+            c[i][0]=st[0][i];
+            for (int j=1;j<n;j++)
+                c[i][j]=c[i][j-1]*131+st[j][i];
+        }
+        for(int i=0;i<n;++i)
+            for(int j=0;j<m;++j)
+                for(int k=0;k<4;++k)
+                {
+                    int a=k&1?i+1:n-i,b=k<2?m-j:j+1,l=0,r,mid,nx,ny,x2,y2;
+                    r=min(a-1,b-1);
+                    while(l<r)
+                    {
+                        mid=(l+r+1)/2;
+                        nx=i+mid*dir[k][0],ny=j+mid*dir[k][1];
+                        x2=i,y2=j;
+                        if(x2<nx)   swap(x2,nx);
+                        if(y2<ny)   swap(y2,ny);
+                        if(ac1(i,ny,y2)==ac2(j,nx,x2))  l=mid;
+                        else    r=mid-1;
+                    }
+                    dp[i][j][k]=l+1;
+                }
+        for(int i=0;i<m;++i)
+            cal(0,i,2),cal(0,i,0),cal(n-1,i,1),cal(n-1,i,3);
+        for(int i=0;i<n;++i)
+            cal(i,m-1,2),cal(i,m-1,3),cal(i,0,1),cal(i,0,0);
+        printf("%d\n",ans*(ans+1)/2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4496_autoAC.cpp b/HDOJ/4496_autoAC.cpp
new file mode 100644
index 0000000..5b58e47
--- /dev/null
+++ b/HDOJ/4496_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int MAXN = 10010;
+int F[MAXN];
+int find(int x)
+{
+    if(F[x] == -1)return x;
+    return F[x] = find(F[x]);
+}
+pair<int,int>p[100010];
+int ans[100010];
+int main()
+{
+    int n,m;
+    while(scanf("%d%d",&n,&m) == 2)
+    {
+        memset(F,-1,sizeof(F));
+        for(int i = 1;i <= m;i++)
+        {
+            scanf("%d%d",&p[i].first,&p[i].second);
+        }
+        ans[m] = n;
+        for(int i = m;i > 1;i --)
+        {
+            int t1 = find(p[i].first);
+            int t2 = find(p[i].second);
+            if(t1 != t2)
+            {
+                ans[i-1] = ans[i] - 1;
+                F[t1] = t2;
+            }
+            else ans[i-1] = ans[i];
+        }
+        for(int i = 1;i <= m;i++)
+            printf("%d\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4497_autoAC.cpp b/HDOJ/4497_autoAC.cpp
new file mode 100644
index 0000000..0736118
--- /dev/null
+++ b/HDOJ/4497_autoAC.cpp
@@ -0,0 +1,72 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <cctype>
+#include <algorithm>
+#include <queue>
+#include <deque>
+#include <queue>
+#include <list>
+#include <map>
+#include <set>
+#include <vector>
+#include <utility>
+#include <functional>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <numeric>
+#include <cassert>
+#include <ctime>
+#include <iterator>
+const int INF = 0x3f3f3f3f;
+const int dir[8][2] = {{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{-1,1},{1,-1},{1,1}};
+using namespace std;
+#define LL __int64
+const int MAX=100002;
+int prime[MAX];
+bool flag[MAX];
+int main(void)
+{
+    int t;
+    scanf("%d", &t);
+        memset(flag, true, sizeof(flag));
+    int cnt = 0;
+    for (int i = 2; i * i <= 100000; ++i)
+    {
+            if (flag[i])
+                for (int j = i*2; j <= 100000; j+=i)
+                    flag[j] = false;
+    }
+        for (int i = 2; i <= 100000; ++i) if(flag[i]) prime[cnt++] = i;
+    while (t--)
+    {
+        int G, L;
+        scanf("%d%d", &G, &L);
+        int ans = 1;
+        if (L % G)
+        {
+            printf("0\n");
+            continue;
+        }
+        int K = L / G, S = K;
+        for (int i = 0; i < cnt; ++i)
+        {
+            if (prime[i] * prime[i] > S) break;
+            if (K%prime[i] == 0)
+            {
+                int touch = 0;
+                while (K%prime[i] == 0)
+                {
+                    K /= prime[i]; touch++;
+                }
+                ans *= touch * 6;
+            }
+        }
+        if (K != 1) ans *= 6;
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4498_autoAC.cpp b/HDOJ/4498_autoAC.cpp
new file mode 100644
index 0000000..8341aff
--- /dev/null
+++ b/HDOJ/4498_autoAC.cpp
@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+vector<double>x;
+void add(int a1,int b1,int c1)
+{
+    if(a1 == 0 && b1 == 0)
+    {
+        return;
+    }
+    if(a1 == 0)
+    {
+        double t = -c1*1.0/b1;
+        if(t >= 0 && t <= 100)
+            x.push_back(t);
+        return;
+    }
+    long long deta = b1*b1 - 4LL*a1*c1;
+    if(deta < 0)return;
+    if(deta == 0)
+    {
+        double t = (-1.0 * b1)/(2.0 * a1);
+        if(t >= 0 && t <= 100)
+            x.push_back(t);
+    }
+    else
+    {
+        double t1 = (-1.0 * b1 + sqrt(1.0*deta))/(2.0*a1);
+        double t2 = (-1.0 * b1 - sqrt(1.0*deta))/(2.0*a1);
+        if(t1 >= 0 && t1 <= 100)
+            x.push_back(t1);
+        if(t2 >= 0 && t2 <= 100)
+            x.push_back(t2);
+    }
+}
+int A[100],B[100],C[100];
+int best;
+double F(double x1)
+{
+    return sqrt(1.0 + (x1*2*A[best] + 1.0 * B[best])*(x1*2*A[best] + 1.0 * B[best]));
+}
+double simpson(double a,double b)
+{
+    double c = a + (b-a)/2;
+    return (F(a) + 4*F(c) + F(b))*(b-a)/6;
+}
+double asr(double a,double b,double eps,double A)
+{
+    double c = a + (b-a)/2;
+    double L = simpson(a,c);
+    double R = simpson(c,b);
+    if(fabs(L+R-A) <= 15*eps)return L+R+(L+R-A)/15;
+    return asr(a,c,eps/2,L) + asr(c,b,eps/2,R);
+}
+double asr(double a,double b,double eps)
+{
+    return asr(a,b,eps,simpson(a,b));
+}
+int main()
+{
+    int T;
+    int k,a,b;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int n;
+        scanf("%d",&n);
+        A[0] = 0;
+        B[0] = 0;
+        C[0] = 100;
+        for(int i = 1;i <= n;i++)
+        {
+            scanf("%d%d%d",&k,&a,&b);
+            A[i] = k;
+            B[i] = -2*a*k;
+            C[i] = k*a*a + b;
+        }
+        x.clear();
+        for(int i = 0;i <= n;i++)
+            for(int j = i+1;j <= n;j++)
+                add(A[i]-A[j],B[i] - B[j],C[i] - C[j]);
+        double ans = 0;
+        x.push_back(0);
+        x.push_back(100);
+        sort(x.begin(),x.end());
+        int sz = x.size();
+        for(int i = 0;i < sz-1;i++)
+        {
+            double x1 = x[i];
+            double x2 = x[i+1];
+            if(fabs(x2-x1) < 1e-8)continue;
+            double mid = (x1 + x2)/2;
+            best = 0;
+            for(int j = 1;j <= n;j++)
+            {
+                double tmp1 = mid*mid*A[best] + mid*B[best] + C[best];
+                double tmp2 = mid*mid*A[j] + mid*B[j] + C[j];
+                if(tmp2 < tmp1)best = j;
+            }
+            ans += asr(x1,x2,1e-8);
+        }
+        printf("%.2lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4499_autoAC.cpp b/HDOJ/4499_autoAC.cpp
new file mode 100644
index 0000000..103696d
--- /dev/null
+++ b/HDOJ/4499_autoAC.cpp
@@ -0,0 +1,74 @@
+#include <iostream>
+#include <cstring>
+#include <stdio.h>
+using namespace std;
+const int MAX_N = 5 + 2;
+int vis[MAX_N][MAX_N];
+int n, m, q, _max;
+bool decide(int i, int j)
+{
+    int flag = 0;
+    if(vis[i][j] == 1)
+        return false;
+    for(int k = i - 1; k >= 0; k--)
+    {
+        if(vis[k][j] == 1)
+            flag++;
+        else if(vis[k][j] == 2)
+        {
+            if(flag == 1)
+                return false;
+            else
+                flag++;
+        }
+    }
+    flag = 0;
+    for(int k = j - 1; k >= 0; k--)
+    {
+        if(vis[i][k] == 1)
+            flag++;
+        else if(vis[i][k] == 2)
+        {
+            if(flag == 1)
+                return false;
+            else
+                flag++;
+        }
+    }
+    return true;
+}
+void dfs(int cnt, int x, int y)
+{
+    for(int i = x; i < n; i++)
+    {
+        for(int j = 0; j < m; j++)
+        {
+            if(x == i && j < y)
+                continue;
+            if(decide(i, j))
+            {
+                vis[i][j] = 2;
+                dfs(cnt + 1, i, j + 1);
+                vis[i][j] = 0;
+            }
+        }
+    }
+    _max = max(_max, cnt);
+}
+int main()
+{
+    while(scanf("%d%d%d", &n, &m, &q) != EOF)
+    {
+        int a, b;
+        _max = 0;
+        memset(vis, 0, sizeof(vis));
+        for(int i = 0; i < q; i++)
+        {
+            scanf("%d%d", &a, &b);
+            vis[a][b] = 1;
+        }
+        dfs(0, 0, 0);
+        cout << _max << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4500_autoAC.cpp b/HDOJ/4500_autoAC.cpp
new file mode 100644
index 0000000..d73695d
--- /dev/null
+++ b/HDOJ/4500_autoAC.cpp
@@ -0,0 +1,64 @@
+#include<stdio.h>
+#include<math.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+int n,m;
+int i,j;
+struct node{
+    int x,y,sum;
+}s[520];
+int a[22][22];
+int cmp(node a,node b)
+{
+    if(a.sum!=b.sum)
+    return a.sum>b.sum;
+    else if(a.x!=b.x) 
+    return a.x<b.x;
+    else if(a.y!=b.y)
+    return a.y<b.y;
+}
+int main()
+{
+    while(~scanf("%d%d",&n,&m),n||m)
+    {
+        memset(a,0,sizeof(a));
+        memset(s,0,sizeof(s));
+        for(i=1;i<=n;++i)
+        {
+            for(j=1;j<=m;++j)
+            {
+                scanf("%d",&a[i][j]);
+            }
+        }
+        int cnt=0;
+        for(i=1;i<=n;++i)
+        {
+            for(j=1;j<=m;++j)
+            {
+                if(a[i][j]*a[i-1][j]<0)
+                s[cnt].sum+=abs(a[i-1][j]);
+                else
+                s[cnt].sum-=abs(a[i-1][j]);
+                if(a[i][j]*a[i+1][j]<0)
+                s[cnt].sum+=abs(a[i+1][j]);
+                else
+                s[cnt].sum-=abs(a[i+1][j]);
+                if(a[i][j]*a[i][j-1]<0)
+                s[cnt].sum+=abs(a[i][j-1]);
+                else
+                s[cnt].sum-=abs(a[i][j-1]);
+                if(a[i][j]*a[i][j+1]<0)
+                s[cnt].sum+=abs(a[i][j+1]);
+                else
+                s[cnt].sum-=abs(a[i][j+1]);
+                s[cnt].x=i;
+                s[cnt].y=j;
+                cnt++;
+            }
+        }
+        sort(s,s+cnt,cmp);
+        printf("%d %d %d\n",s[0].x,s[0].y,s[0].sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4501_autoAC.cpp b/HDOJ/4501_autoAC.cpp
new file mode 100644
index 0000000..fb654d5
--- /dev/null
+++ b/HDOJ/4501_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+int dp[2][105][105][10];
+int val[105];
+int c1[105];
+int c2[105];
+int main()
+{
+    int n,v1,v2,k;
+    while(scanf("%d%d%d%d",&n,&v1,&v2,&k)!=EOF)
+    {
+        int i;
+        for(i=1;i<=n;i++)
+            scanf("%d%d%d",&c1[i],&c2[i],&val[i]);
+        memset(dp,0,sizeof(dp));
+        int now=0;
+        for(i=1;i<=n;i++)
+        {
+            now=now^1;
+            for(int j=0;j<=v1;j++)
+            {
+                for(int l1=0;l1<=v2;l1++)
+                {
+                    for(int l2=0;l2<=k;l2++)
+                    {
+                        dp[now][j][l1][l2]=dp[now^1][j][l1][l2];
+                        if(j>=c1[i]&&dp[now][j][l1][l2]<dp[now^1][j-c1[i]][l1][l2]+val[i])
+                            dp[now][j][l1][l2]=dp[now^1][j-c1[i]][l1][l2]+val[i];
+                        if(l1>=c2[i]&&dp[now][j][l1][l2]<dp[now^1][j][l1-c2[i]][l2]+val[i])
+                            dp[now][j][l1][l2]=dp[now^1][j][l1-c2[i]][l2]+val[i];
+                        if(l2>=1&&dp[now][j][l1][l2]<dp[now^1][j][l1][l2-1]+val[i])
+                            dp[now][j][l1][l2]=dp[now^1][j][l1][l2-1]+val[i];
+                    }
+                }
+            }
+        }
+        printf("%d\n",dp[now][v1][v2][k]);
+    }
+}
diff --git a/HDOJ/4502_autoAC.cpp b/HDOJ/4502_autoAC.cpp
new file mode 100644
index 0000000..cb356f2
--- /dev/null
+++ b/HDOJ/4502_autoAC.cpp
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int main()
+{
+    int n,m,i,j,t;
+    int a[105][105],dp[105];
+    scanf("%d",&t);
+    while(t--)
+    {
+        memset(a,0,sizeof(a));
+        memset(dp,0,sizeof(dp));
+        scanf("%d%d",&n,&m);
+        for(i = 1;i<=m;i++)
+        {
+            int x,y,c;
+            scanf("%d%d%d",&x,&y,&c);
+            a[x][y] = max(a[x][y],c);
+        }
+        for(i = 1;i<=n;i++)
+        {
+            for(j = i;j>=1;j--)
+            dp[i] = max(dp[i],dp[j-1]+a[j][i]);
+        }
+        printf("%d\n",dp[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4503_autoAC.cpp b/HDOJ/4503_autoAC.cpp
new file mode 100644
index 0000000..03aa70e
--- /dev/null
+++ b/HDOJ/4503_autoAC.cpp
@@ -0,0 +1,20 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+int n,num[1010];
+int main(){
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        int ans=0;
+        for(int i=0;i<n;i++){
+            scanf("%d",&num[i]);
+            ans+=1*num[i]*(n-1-num[i]);
+        }
+        ans/=2;
+        printf("%.3f\n",1.0-ans*1.0/((n*(n-1)*(n-2))/6));
+    }
+    return 0;
+}
diff --git a/HDOJ/4504_autoAC.cpp b/HDOJ/4504_autoAC.cpp
new file mode 100644
index 0000000..1d1e90e
--- /dev/null
+++ b/HDOJ/4504_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<iostream>
+#include<cstdio>
+#include<cstdlib>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+__int64 d[100][300];
+int main()
+{
+    __int64 A,B,t;
+    while(scanf("%I64d%I64d%I64d",&A,&B,&t)!=-1)
+    {
+        t/=15;
+        B+=t/2;
+        t=(t+1)/2;
+        d[0][0]=1;
+        for(__int64 j=1;j<=3*t;j++)
+        {
+            d[0][j]=0;
+        }
+        for(__int64 i=1;i<=t;i++)
+        {
+            d[i][0]=0;
+            d[i][1]=d[i-1][0];
+            d[i][2]=d[i-1][0]+d[i-1][1];
+            for(__int64 j=3;j<=3*t;j++)
+            {
+                d[i][j]=d[i-1][j-1]+d[i-1][j-2]+d[i-1][j-3];
+            }
+        }
+        __int64 ans=0;
+        __int64 j=B-A+1;
+        if(j<0)
+        {
+            j=0;
+        }
+        for(;j<=3*t;j++)
+        {
+            ans+=d[t][j];
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4505_autoAC.cpp b/HDOJ/4505_autoAC.cpp
new file mode 100644
index 0000000..da57045
--- /dev/null
+++ b/HDOJ/4505_autoAC.cpp
@@ -0,0 +1,28 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    int a, i, c, n, cnt[105];
+    scanf("%d",&c);
+    while(c--)
+    {
+        scanf("%d",&n);
+        memset(cnt, 0, sizeof(cnt));
+        int Max = 0;
+        for(i = 0; i < n; i++)
+        {
+            scanf("%d",&a);
+            cnt[a]++;
+            if(a > Max)
+                Max = a;
+        }
+        int ans = Max * 10;  
+        for(i = 1; i <= Max; i++)
+        {
+            if(cnt[i])
+                ans += 5 + cnt[i]; 
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4506_autoAC.cpp b/HDOJ/4506_autoAC.cpp
new file mode 100644
index 0000000..356bc16
--- /dev/null
+++ b/HDOJ/4506_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int mod=1e9+7;
+long long n,t,k;
+long long num[10010],res[10010];
+int main(){
+    int T;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%I64d%I64d%I64d",&n,&t,&k);
+        long long tmpt=t,tmpk=1;
+        while(tmpt){
+            if(tmpt&1)
+                tmpk=(tmpk*k)%mod;
+            tmpt>>=1;
+            k=(k*k)%mod;
+        }
+        for(int i=0;i<n;i++){
+            scanf("%I64d",&num[i]);
+            num[i]=(num[i]*tmpk)%mod;
+        }
+        t=t%n;
+        for(int i=0;i<n;i++)
+            res[(i+t)%n]=num[i];
+        for(int i=0;i<n-1;i++)
+            printf("%I64d ",res[i]);
+        printf("%I64d\n",res[n-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4507_autoAC.cpp b/HDOJ/4507_autoAC.cpp
new file mode 100644
index 0000000..5807a72
--- /dev/null
+++ b/HDOJ/4507_autoAC.cpp
@@ -0,0 +1,66 @@
+#include <math.h>
+#include <string>
+#include <stdio.h>
+#include <string.h>
+using namespace std;
+typedef long long LL;
+typedef pair< int,pair<LL,LL> > PILL;
+#define F first
+#define S second
+#define MP make_pair
+const int mod = 1e9 + 7;
+int digit[20];
+LL pow10[20];
+PILL dp[20][7][7][2];
+bool vis[20][7][7][2];
+PILL dfs(int len,int sum,int remain,bool contain,bool fp)
+{
+    if(!len)
+        if(!contain && sum && remain)
+            return MP(1,MP(0LL,0LL));
+        else
+            return MP(0,MP(0LL,0LL));
+    if(!fp && vis[len][sum][remain][contain])
+        return dp[len][sum][remain][contain];
+    PILL ret = MP(0,MP(0,0));
+    int fpmax = fp ? digit[len] : 9;
+    for(int i=0;i<=fpmax;i++)
+    {
+        PILL nxt = dfs(len-1,(sum + i) % 7,(remain * 10 + i) % 7,contain | (i == 7),fp && i == fpmax);
+        LL pref = i * pow10[len-1] % mod;
+        (ret.F += nxt.F) %= mod;
+        (ret.S.F += nxt.S.F + pref * nxt.F) %= mod;
+        (ret.S.S += nxt.S.S + pref * pref % mod * nxt.F + 2 * pref * nxt.S.F) %= mod;
+    }
+    if(!fp)
+    {
+        vis[len][sum][remain][contain] = true;
+        dp[len][sum][remain][contain] = ret;
+    }
+    return ret;
+}
+long long f(long long n)
+{
+    int len = 0;
+    while(n)
+    {
+        digit[++len] = n % 10;
+        n /= 10;
+    }
+    return dfs(len,0,0,0,true).S.S;
+}
+int main()
+{
+    pow10[0] = 1;
+    for(int i=1;i<20;i++)
+        pow10[i] = pow10[i-1] * 10 % mod;
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        long long a,b;
+        scanf("%I64d%I64d",&a,&b);
+        printf("%I64d\n",(f(b) - f(a-1) + mod) % mod);
+    }
+    return 0;
+}
diff --git a/HDOJ/4508_autoAC.cpp b/HDOJ/4508_autoAC.cpp
new file mode 100644
index 0000000..5fe2fe5
--- /dev/null
+++ b/HDOJ/4508_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<iostream>
+#include<string.h>
+const int N=110;
+using namespace std;
+int dp[N*N*10];
+struct Node{
+    int a,b;
+}node[N];
+int main(){
+    int n;
+    while(~scanf("%d",&n)){
+        for(int i=0;i<n;i++){
+            scanf("%d%d",&node[i].a,&node[i].b);
+        }
+        int m;
+        scanf("%d",&m);
+        memset(dp,0,sizeof(dp));
+        for(int i=0;i<n;i++){
+            for(int j=0;j<=m;j++){
+                if(j<node[i].b)continue;
+                dp[j]=max(dp[j],dp[j-node[i].b]+node[i].a);
+            }
+        }
+        printf("%d\n",dp[m]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4509_autoAC.cpp b/HDOJ/4509_autoAC.cpp
new file mode 100644
index 0000000..d0218e6
--- /dev/null
+++ b/HDOJ/4509_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<cstdio>
+#include<stdlib.h>
+const int maxn=500005;
+struct time
+{
+    int start;
+    int end;
+}t[maxn];
+int cmp(const void*a,const void*b)
+{
+    time*c=(time*)a;
+    time*d=(time*)b;
+    return c->start-d->start;
+}
+int max(int a,int b)
+{
+    return a>b?a:b;
+}
+int main()
+{
+    int N;
+    while(~scanf("%d",&N))
+    {
+        int a,b,c,d;
+        char ss;
+        int i;
+        for(i=0;i<N;i++)
+        {
+            scanf("%d%c%d%d%c%d",&a,&ss,&b,&c,&ss,&d);
+            t[i].start=a*60+b;
+            t[i].end=c*60+d;
+        }
+        qsort(t,N,sizeof(t[0]),cmp);
+        int starttime=t[0].start,endtime=t[0].end;
+        int alltime=0;
+        for(i=1;i<N;i++)
+        {
+            if(t[i].start<=endtime)
+            {
+                endtime=max(endtime,t[i].end);
+            }
+            else 
+            {
+                alltime+=(endtime-starttime);
+                starttime=t[i].start;
+                endtime=t[i].end;
+            }
+        }
+        alltime+=(endtime-starttime);
+        printf("%d\n",1440-alltime);
+    }
+    return 0;
+}
diff --git a/HDOJ/4510_autoAC.cpp b/HDOJ/4510_autoAC.cpp
new file mode 100644
index 0000000..8192ff3
--- /dev/null
+++ b/HDOJ/4510_autoAC.cpp
@@ -0,0 +1,34 @@
+#include<stdio.h>
+int main(){
+    int h,m,s,a,b,c,T;
+    scanf("%d",&T);
+    while(T--) {
+        scanf("%d%*c%d%*c%d",&h,&m,&s);
+        scanf("%d%*c%d%*c%d",&a,&b,&c);
+        a=a%12;
+        s=s-c;
+        if(s<0) {
+            s+=60;
+            m--;
+            if(m<0){
+                m+=60;
+                h--;
+                if(h<0) h+=12;
+            }
+        }
+        m-=b;
+        if(m<0){
+                m+=60;
+                h--;
+                if(h<0) h+=12;
+        }
+        h=(h-a+12)%12;
+        if(h<10) printf("0%d:",h);
+        else printf("%d:",h);
+        if(m<10) printf("0%d:",m);
+        else printf("%d:",m);
+        if(s<10) printf("0%d\n",s);
+        else printf("%d\n",s);
+    }
+    return 0; 
+}
diff --git a/HDOJ/4511_autoAC.cpp b/HDOJ/4511_autoAC.cpp
new file mode 100644
index 0000000..4441cf5
--- /dev/null
+++ b/HDOJ/4511_autoAC.cpp
@@ -0,0 +1,127 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const double INF = 1e20;
+int n;
+pair<int,int> p[100];
+double dis(pair<int,int>a,pair<int,int>b)
+{
+    return sqrt((double)(1.0 * a.first - b.first) * (1.0 * a.first - b.first) + (double)(1.0 * a.second - b.second)*(1.0 * a.second - b.second));
+}
+double dp[55][1000];
+void CheckMin(double &a,double b)
+{
+    a = min(a,b);
+}
+struct Trie
+{
+    int next[1000][55],fail[1000],end[1000];
+    int root,L;
+    int newnode()
+    {
+        for(int i = 1; i <= n;i++)
+            next[L][i] = -1;
+        end[L++] = 0;
+        return L-1;
+    }
+    void init()
+    {
+        L = 0;
+        root = newnode();
+    }
+    void insert(int a[],int cnt)
+    {
+        int now = root;
+        for(int i  = 0;i < cnt;i++)
+        {
+            if(next[now][a[i]] == -1)
+                next[now][a[i]] = newnode();
+            now = next[now][a[i]];
+        }
+        end[now] = 1;
+    }
+    void build()
+    {
+        queue<int>Q;
+        fail[root] = root;
+        for(int i = 1;i <= n;i++)
+            if(next[root][i] == -1)
+                next[root][i] = root;
+            else 
+            {
+                fail[next[root][i]] = root;
+                Q.push(next[root][i]);
+            }
+        while(!Q.empty())
+        {
+            int now = Q.front();
+            Q.pop();
+            end[now] |= end[fail[now]];
+            for(int i = 1;i <= n;i++)
+                if(next[now][i] == -1)
+                    next[now][i] = next[fail[now]][i];
+                else
+                {
+                    fail[next[now][i]] = next[fail[now]][i];
+                    Q.push(next[now][i]);
+                }
+        }
+    }
+    void solve()
+    {
+        for(int i = 1;i <= n;i++)
+            for(int j = 0;j < L;j++)
+                dp[i][j] = INF;
+        dp[1][next[root][1]] = 0;
+        for(int i = 1;i < n;i++)
+            for(int j = 0;j < L;j++)
+                if(dp[i][j] < INF)
+                {
+                    for(int k = i+1;k <= n;k++)
+                    {
+                        int ss = next[j][k];
+                        if(end[ss])continue;
+                        CheckMin(dp[k][ss],dp[i][j] + dis(p[i],p[k]));
+                    }
+                }
+        double ans = INF;
+        for(int i = 0;i < L;i++)
+            if(dp[n][i] < INF)
+                CheckMin(ans,dp[n][i]);
+        if(ans == INF)printf("Can not be reached!\n");
+        else printf("%.2f\n",ans);
+    }
+}ac;
+int a[10];
+int main()
+{
+    int m;
+    while(scanf("%d%d",&n,&m) == 2)
+    {
+        if(n == 0 && m == 0)break;
+        for(int i = 1;i <= n;i++)
+            scanf("%d%d",&p[i].first,&p[i].second);
+        ac.init();
+        int k;
+        while(m--)
+        {
+            scanf("%d",&k);
+            for(int i = 0;i < k;i++)
+                scanf("%d",&a[i]);
+            ac.insert(a,k);
+        }
+        ac.build();
+        ac.solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4512_autoAC.cpp b/HDOJ/4512_autoAC.cpp
new file mode 100644
index 0000000..a3b6e69
--- /dev/null
+++ b/HDOJ/4512_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define MAXN 205
+int a[MAXN];
+int f[MAXN][MAXN];
+int main()
+{
+    int T, N;
+    for(scanf("%d", &T); T--; )
+    {
+        scanf("%d", &N);
+        for(int i = 1; i <= N; ++i)
+            scanf("%d", &a[i]);
+        memset(f, 0, sizeof(f));
+        int ans = 1;
+        for(int i = 1; i <= N; ++i)
+        {
+            int max = 0;
+            for(int j = N; i < j;  --j)
+            {
+                f[i][j] = f[i-1][j];
+                if((a[i] == a[j]) && (f[i][j] < max + 1))
+                    f[i][j] = max + 1;
+                else if((a[i] > a[j]) &&(f[i-1][j] > max)) max = f[i-1][j];
+                if(f[i][j] * 2 > ans) ans = f[i][j] * 2;
+                for(int k = i + 1; k < j; ++k)
+                {
+                    if(a[k] > a[j])
+                    {
+                        if(2 * f[i][j] + 1 > ans)
+                            ans = 2 * f[i][j] + 1;
+                    }
+                }
+            }
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4513_autoAC.cpp b/HDOJ/4513_autoAC.cpp
new file mode 100644
index 0000000..5ac0b2f
--- /dev/null
+++ b/HDOJ/4513_autoAC.cpp
@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#define MAXN 100005
+int a[MAXN * 2];
+struct Rem{
+    int left;
+    int right;
+}rem;
+int odd[2 * MAXN];
+int min(int a, int b)
+{
+    return (a < b) ? a : b;
+}
+int fun(int i, int m, int N)
+{
+    int l = i - m - 1, r = i + m + 1;
+    int ret = 0;
+    for(;(l > 0)&&(r <= N);--l, ++r)
+    {
+        if((a[r] == -1) ||  ((a[l] == a[r]) && ((r - l == 2)||(a[r] <= a[r - 2])  )))
+            ++ret;
+        else break;
+    }
+    return ret;
+}
+int main()
+{
+    int T, N;
+    for(scanf("%d", &T); T--; )
+    {
+        scanf("%d", &N);
+        int i = 0;
+        a[++i] = -1;
+        while(N--)
+        {
+            scanf("%d", &a[++i]);
+            a[++i] = -1;
+        }
+        N = i;
+        rem.left = rem.right = 0;
+        int ans = 1;
+        memset(odd, 0, sizeof(odd));
+        for(int i = 1; i <= N; ++i)
+        {
+            int m = 0;
+            if(rem.right > i)
+                m = min(rem.right - i, odd[rem.left + (rem.right - i)]);
+            odd[i] = m + fun(i, m, N);
+            if(i + odd[i] > rem.right)
+            {
+                rem.left = i - odd[i];
+                rem.right = i + odd[i];
+            }
+            if(odd[i] > ans)
+                ans = odd[i];
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4514_autoAC.cpp b/HDOJ/4514_autoAC.cpp
new file mode 100644
index 0000000..ed08fa4
--- /dev/null
+++ b/HDOJ/4514_autoAC.cpp
@@ -0,0 +1,64 @@
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <vector>
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+using namespace std;
+const int N = 100005;
+int n, m, ans;
+int set[N];
+int dp[N];
+struct Edge {
+    int v, f;
+    Edge() {}
+    Edge(int _v, int _f) : v(_v), f(_f) {}
+};
+vector<Edge>vt[N];
+int find(int x) {
+    return x == set[x] ? x : x = find(set[x]);
+}
+void dfs(int p, int u) {
+    int forkmax = 0;
+    for (int i = 0; i < (int)vt[u].size(); ++i) {
+        int v = vt[u][i].v, f = vt[u][i].f;
+        if (v == p) continue;
+        dfs(u, v);
+        ans = max(ans, dp[v]+f+forkmax);
+        forkmax = max(forkmax, dp[v] + f);
+    }
+    dp[u] = forkmax;
+}
+void solve() {
+    for (int i = 1; i <= n; ++i) {
+        if (dp[i] == -1) dfs(0, i);
+    }
+    printf("%d\n", ans);
+}
+int main() {
+    while (scanf("%d %d", &n, &m) != EOF) {
+        int a, b, c, x, y;
+        bool loop = false;
+        ans = 0;
+        for (int i = 1; i <= n; ++i) {
+            dp[i] = -1;
+            set[i] = i;
+            vt[i].clear();
+        }
+        for (int i = 0; i < m; ++i) {
+            scanf("%d %d %d", &a, &b, &c);
+            if (loop) continue;
+            x = find(a), y = find(b);
+            if (x != y) set[x] = y;
+            else loop = true;
+            vt[a].push_back(Edge(b, c));
+            vt[b].push_back(Edge(a, c));
+        }
+        if (loop) {
+            puts("YES");
+            continue;
+        }
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4515_autoAC.cpp b/HDOJ/4515_autoAC.cpp
new file mode 100644
index 0000000..8ba3b97
--- /dev/null
+++ b/HDOJ/4515_autoAC.cpp
@@ -0,0 +1,68 @@
+#include <stdio.h>
+int a[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
+const int Y = 2013,M = 3,D = 24;
+int leap(int y)
+{
+    if(y%400 == 0 || (y%4==0 && y%100!=0))
+        return 1;
+    return 0;
+}
+void deal1(int k)
+{
+    int y = Y,m = M,d = D;
+    while(k--)
+    {
+        if(leap(y))
+            a[2] = 29;
+        else
+            a[2] = 28;
+        d--;
+        if(d<=0)
+        {
+            m--;
+            if(m<=0)
+            {
+                m = 12;
+                y--;
+            }
+            d = a[m];
+        }
+    }
+    printf("%04d/%02d/%02d",y,m,d);
+}
+void deal2(int k)
+{
+    int y = Y,m = M,d = D;
+    while(k--)
+    {
+        if(leap(y))
+            a[2] = 29;
+        else
+            a[2] = 28;
+        d++;
+        if(d>a[m])
+        {
+            m++;
+            if(m>12)
+            {
+                m = 1;
+                y++;
+            }
+            d = 1;
+        }
+    }
+    printf("%04d/%02d/%02d ",y,m,d);
+}
+int main()
+{
+    int n,m;
+    scanf("%d",&n);
+    while(n--)
+    {
+        scanf("%d",&m);
+        deal2(m);
+        deal1(m);
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4516_autoAC.cpp b/HDOJ/4516_autoAC.cpp
new file mode 100644
index 0000000..55d50f1
--- /dev/null
+++ b/HDOJ/4516_autoAC.cpp
@@ -0,0 +1,122 @@
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <cctype>
+#include <vector>
+using namespace std;
+char str[500];
+int seq[10];
+long long _pow(int a, int b) {
+    long long ret = 1;
+    for (int i = 0; i < b; ++i) {
+        ret *= a;
+    }
+    return ret;
+}
+int jiechen[10] = {1, 1, 2, 6, 24, 120};
+void qiudao(int *rec, int k) {
+    for (int i = k; i <= 5; ++i) {
+        rec[i-k] = jiechen[i] / jiechen[i-k] * seq[i];
+    }
+}
+bool judge(int rec[], int x) {
+    long long sum = 0;
+    for (int i = 0; i <= 5; ++i) {
+        sum += 1LL * rec[i] * _pow(x, i);
+    }
+    return sum == 0;
+}
+void gao(char ts[]) {
+    int len = strlen(ts);
+    int p = -1, a, b;
+    for (int i = 0; i < len; ++i) {
+        if (ts[i] == 'x') {
+            if (isdigit(ts[i-1])) { 
+                ts[i] = '\0';
+            } else {
+                ts[i] = '1';
+            }
+            p = -2;
+        } else if (ts[i] == '^') {
+            ts[i] = '\0';
+            p = i+1;    
+        }
+    }
+    a = atoi(ts);
+    if (!a && p != -1) a = 1;
+    if (p == -1) {
+        b = 0;
+    } else if (p == -2) {
+        b = 1;
+    }else {
+        b = atoi(ts+p);
+    }
+    seq[b] += a;
+}
+void solve() {
+    vector<int>v;
+    int cnt = 0;
+    memset(seq, 0, sizeof (seq));
+    char ts[50], *p;
+    p = strtok(str, "+");
+    while (p) {
+        strcpy(ts, p);
+        gao(ts);
+        p = strtok(NULL, "+");
+    }
+    for (int i = 5; i >= 0; --i) {
+        if (seq[i] != 0) {
+            cnt = i;
+            break;
+        }
+    }
+    for (int i = -1000; i <= 1000; ++i) { 
+        for (int j = 0; j < cnt; ++j) {
+            int rec[10]    = {0};
+            qiudao(rec, j);
+            if (judge(rec, i)) {
+                v.push_back(i);
+            } else {
+                break;
+            }
+        }
+    }
+    if (v.size() != cnt || seq[cnt] != 1 || cnt == 0) {
+        printf("-1\n");
+    } else {
+        sort(v.begin(), v.end());
+        for (int i = v.size()-1; i >= 0; --i) {
+            if (v[i] < 0) {
+                printf("(x+%d)", -v[i]);
+            } else if (v[i] == 0) {
+                printf("x");    
+            } else {
+                printf("(x-%d)", v[i]);    
+            }
+        }
+        puts("");
+    }
+}
+int main() {
+    int T, ca = 0;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%s", str);
+        int len = strlen(str);
+        for (int i = 0; i < len; ++i) {
+            if (str[i] == '-') {
+                for (int j = len-1; j >= i; --j) {
+                    str[j+1] = str[j];
+                }
+                str[i] = '+';
+                len += 1;
+                ++i;
+                str[len] = '\0';
+            }
+        }
+        printf("Case #%d: ", ++ca);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4517_autoAC.cpp b/HDOJ/4517_autoAC.cpp
new file mode 100644
index 0000000..b8d89c4
--- /dev/null
+++ b/HDOJ/4517_autoAC.cpp
@@ -0,0 +1,76 @@
+#include <cstdio>
+#include <cstdlib>
+#include <sstream>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+#include <queue>
+#include <stack>
+#include <map>
+#include <set>
+using namespace std;
+typedef long long ll;
+#define REP(i,n) for(int i=0;i < (n);i++)
+#define REPD(i,n) for(int i=(n-1);i >= 0;i--)
+#define FOR(i,s,t) for(int i = (s);i <= (t);i++)
+#define FORD(i,s,t) for(int i = (s);i >= (t);i--)
+#define PII pair<int,int>
+#define PB push_back
+#define MP make_pair
+#define ft first
+#define sd second
+#define lowbit(x) (x&(-x))
+#define INF (1<<30)
+int n,m;
+int C[2011][2011];
+char str[2011][2011];
+void fun(){
+    C[0][0] = 0;
+    FOR(i,1,n){
+        C[i][0] = 0;
+        FOR(j,1,m){
+            C[i][j] = C[i][j-1]+(str[i][j]=='*'?1:0);
+        }
+    }
+    FOR(i,2,n){
+        FOR(j,1,m){
+            C[i][j] += C[i-1][j];
+        }
+    }
+}
+int Area(int x1,int y1,int x2,int y2){
+    if(x1>x2)swap(x1,x2);
+    if(y1>y2)swap(y1,y2);
+    return C[x2][y2]-C[x2][y1-1]-C[x1-1][y2]+C[x1-1][y1-1];
+}
+ int main()
+{
+     while(~scanf("%d%d",&n,&m),n,m){
+        int x,y;
+        scanf("%d%d",&x,&y);
+        FOR(i,1,n)scanf("%s",str[i]+1);
+        fun();
+        int ans = 0;
+        FOR(i,1,n){
+            FOR(j,1,m){
+                if(str[i][j] != '*')continue;
+                int xx1 = i+x-1;
+                int yy1 = j+y-1;
+                if(!(xx1<1||yy1<1||xx1>n||yy1>m)){
+                    if(Area(i,j,xx1,yy1) == x*y)ans++;
+                }
+                int xx2 = i+y-1;
+                int yy2 = j+x-1;
+                if(xx2 == xx1 && yy2==yy1)continue;
+                if(xx2<1||yy2<1||xx2>n||yy2>m)continue;
+                if(Area(i,j,xx2,yy2) == x*y)ans++;
+            }
+        }
+        printf("%d\n",ans);
+     }
+     return 0;
+ }
diff --git a/HDOJ/4518_autoAC.cpp b/HDOJ/4518_autoAC.cpp
new file mode 100644
index 0000000..5a659c4
--- /dev/null
+++ b/HDOJ/4518_autoAC.cpp
@@ -0,0 +1,137 @@
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <queue>
+using namespace std;
+typedef long long LL;
+const int N = 600;
+LL n;
+int bit[20];
+LL f[60];
+LL dp[15][N]; 
+LL POW[15]; 
+LL seq[60];
+LL suf[20];
+queue<int>q;
+struct Ac_Auto{
+    int ch[N][10];
+    int fail[N];
+    bool flag[N];
+    int idx, root;
+    int newnd() {
+        memset(ch[idx], 0, sizeof (ch[idx]));
+        flag[idx] = false, fail[idx] = 0;
+        return idx++;
+    }
+    void init() {
+        idx = 0, root = newnd();
+    }
+    void insert(LL x) {
+        int id = 0;
+        while (x) bit[id++] = x%10, x/=10;
+        int p = root;
+        for (int i = id-1; i >= 0; --i) {
+            if (!ch[p][bit[i]]) ch[p][bit[i]] = newnd();
+            p = ch[p][bit[i]];
+        }
+        flag[p] = true;
+    }
+    void build() {
+        for (int i = 0; i < 10; ++i) {
+            if (ch[root][i]) {
+                q.push(ch[root][i]);
+            }
+        }
+        while (!q.empty()) {
+            int u = q.front();
+            q.pop();
+            for (int i = 0; i < 10; ++i) {
+                int &v = ch[u][i];
+                int x = fail[u];
+                if (v) {
+                    q.push(v);
+                    while (x && !ch[x][i]) x = fail[x];
+                    fail[v] = ch[x][i];
+                    flag[v] = flag[v] || flag[fail[v]];
+                } else {
+                    v = ch[x][i]; 
+                }
+            }
+        }
+    }
+    void find(LL x) {
+        int id = 0;
+        while (x) bit[id++] = x%10, x/=10;
+        int p = root;
+        for (int i = id-1; i >= 0; --i) {
+            p = ch[p][bit[i]];
+            if (flag[p]) {
+                cout << "OMG" << endl;
+                return;
+            }
+        }
+    }
+};
+Ac_Auto ac;
+LL count(int p, int sta, bool bound) {
+    if (p == 0) return 0;
+    if (!bound && ~dp[p][sta]) return dp[p][sta];
+    int y = bound ? bit[p] : 9;
+    LL sum = 0;
+    int tsta;
+    for (int i = 0; i <= y; ++i) {
+        tsta = ac.ch[sta][i];
+        if (ac.flag[tsta]) {
+            if (bound&&i==y) sum += suf[p-1]+1;
+            else sum += POW[p-1];
+            continue;
+        }
+        sum += ::count(p-1, tsta, bound&&i==y);
+    }
+    if (!bound) dp[p][sta] = sum;
+    return sum;
+}
+LL cal(LL x) {
+    int idx = 1;
+    while (x) suf[idx] = suf[idx-1]+x%10*POW[idx-1], bit[idx++] = x%10, x/=10;
+    return ::count(idx-1, ac.root, true);
+}
+void prepare() {
+    f[1] = 1, f[2] = 1;
+    for (int i = 3; i <= 55; ++i) {
+        f[i] = f[i-1] + f[i-2];
+    }
+    ac.init();
+    for (int i = 7; i <= 55; ++i) {
+        ac.insert(f[i]);
+    }
+    ac.build();
+    POW[0] = 1;
+    for (int i = 1; i < 15; ++i) POW[i] = POW[i-1] * 10;
+    memset(dp, 0xff, sizeof (dp));
+    LL tmp;
+    for (int i = 2; i <= 55; ++i) {
+        LL l = 13, r = POW[12], mid;
+        while (l <= r) {
+            mid = (l + r) >> 1;
+            if ((tmp=cal(mid)) < f[i]) l = mid + 1;
+            else if (tmp > f[i]) r = mid - 1;
+            else seq[i] = mid, r = mid - 1;
+        }
+    }
+}
+int main() {
+    prepare();
+    while (cin >> n, n != -1) {
+        LL ret = 1LL << 60;
+        for (int i = 2; i <= 55; ++i) {
+            LL t = seq[i] - n;
+            if (t < 0) t = -t;
+            ret = min(ret, t);
+        }
+        cout << ret << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4519_autoAC.cpp b/HDOJ/4519_autoAC.cpp
new file mode 100644
index 0000000..1792530
--- /dev/null
+++ b/HDOJ/4519_autoAC.cpp
@@ -0,0 +1,23 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+    int n,k,m,t;
+    cin >> t;
+    while(t--)
+    {
+        cin >> n >> k >> m;
+        if(m>n)
+            cout << k<< endl;
+        else
+        {
+            int sub = n*k;
+            if(sub%m==0)
+                cout << sub/m;
+            else
+                cout << sub/m+1;
+            cout << endl;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4520_autoAC.cpp b/HDOJ/4520_autoAC.cpp
new file mode 100644
index 0000000..3b00df1
--- /dev/null
+++ b/HDOJ/4520_autoAC.cpp
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <iostream>
+#include <string>
+#include <string.h>
+#include <algorithm>
+#include <math.h>
+using namespace std;
+double s[25],temp[25];
+int main()
+{
+    int n;
+    while(scanf("%d", &n) && n)
+    {
+        for(int i = 1; i <= n; ++i)
+        {
+            scanf("%lf", &s[i]);
+            temp[i] = s[i];
+        }
+        sort(temp + 1, temp + n + 1);
+        double sum = 0;
+        for(int i = 2; i < n; ++i)
+            sum += temp[i];
+        sum /= (n - 2);
+        double min = 10000000;
+        int ans;
+        for(int i = 1; i <= n; ++i)
+        {
+            if(fabs(s[i] - sum) < min)
+            {
+                min = fabs(s[i] - sum);
+                ans = i;
+            }
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4521_autoAC.cpp b/HDOJ/4521_autoAC.cpp
new file mode 100644
index 0000000..c8f322c
--- /dev/null
+++ b/HDOJ/4521_autoAC.cpp
@@ -0,0 +1,51 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+#include <algorithm>
+using namespace std;
+#define lz 2*u,l,mid
+#define rz 2*u+1,mid+1,r
+const int maxn=110000;
+int sum[2*maxn], dp[maxn+5], a[maxn+5];
+void Update(int u, int l, int r, int p, int c)
+{
+    sum[u]=max(sum[u],c);
+    if(l==r)return ;
+    int mid=(l+r)>>1;
+    if(p<=mid) Update(lz,p,c);
+    else Update(rz,p,c);
+}
+int Query(int u, int l, int r, int tl, int tr)
+{
+    if(tl>tr) return 0;
+    if(tl<=l&&r<=tr) return sum[u];
+    int mid=(l+r)>>1;
+    if(tr<=mid) return Query(lz,tl,tr);
+    else if(tl>mid) return Query(rz,tl,tr);
+    else
+    {
+        int t1=Query(lz,tl,mid);
+        int t2=Query(rz,mid+1,tr);
+        return max(t1,t2);
+    }
+}
+int main()
+{
+    int n, d;
+    while(scanf("%d%d",&n,&d)!=EOF)
+    {
+        memset(sum,0,sizeof(sum));
+        for(int i=1; i<=n; i++)
+            scanf("%d",a+i);
+        int maxx=0;
+        for(int i=1; i<=n; i++)
+        {
+            if(i>d+1) Update(1,1,maxn,a[i-d-1]+1,dp[i-d-1]);  
+            dp[i]=Query(1,1,maxn,1,a[i])+1;
+            maxx=max(dp[i],maxx);
+        }
+        printf("%d\n",maxx);
+    }
+    return 0;
+}
diff --git a/HDOJ/4522_autoAC.cpp b/HDOJ/4522_autoAC.cpp
new file mode 100644
index 0000000..26eab3c
--- /dev/null
+++ b/HDOJ/4522_autoAC.cpp
@@ -0,0 +1,113 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+const int N=207;
+const int inf=1e7;
+using namespace std;
+int dist1[N];
+int dist0[N];
+int visited[N];
+int edge1[N][N];
+int edge0[N][N];
+int n,m,k;
+void Dijkstra1(int u){
+    memset(visited,0,sizeof(visited));
+    for(int i=1;i<=n;i++){
+        dist1[i]=edge1[u][i];
+    }
+    visited[u]=1;
+    for(int i=1;i<n;i++){
+        int min=inf,v=u;
+        for(int j=1;j<=n;j++){
+            if(dist1[j]<min&&!visited[j]){
+                min=dist1[j];
+                v=j;
+            }
+        }
+        if(min==inf)return ;
+        visited[v]=1;
+        for(int k=1;k<=n;k++){
+            if(!visited[k]&&edge1[v][k]<inf&&dist1[v]+edge1[v][k]<dist1[k]){
+                dist1[k]=dist1[v]+edge1[v][k];
+            }
+        }
+    }
+}
+void Dijkstra0(int u){
+    memset(visited,0,sizeof(visited));
+    for(int i=1;i<=n;i++){
+        dist0[i]=edge0[u][i];
+    }
+    visited[u]=1;
+    for(int i=1;i<n;i++){
+        int min=inf,v=u;
+        for(int j=1;j<=n;j++){
+            if(dist0[j]<min&&!visited[j]){
+                min=dist0[j];
+                v=j;
+            }
+        }
+        if(min==inf)return ;
+        visited[v]=1;
+        for(int k=1;k<=n;k++){
+            if(!visited[k]&&edge0[v][k]<inf&&dist0[v]+edge0[v][k]<dist0[k]){
+                dist0[k]=dist0[v]+edge0[v][k];
+            }
+        }
+    }
+}
+int main(){
+    int _case;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        char str[10100];
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=n;j++){
+                edge1[i][j]=edge1[j][i]=inf;
+                edge0[i][j]=edge0[j][i]=inf;
+            }
+        }
+        for(int i=1;i<=m;i++){
+            scanf("%s%d",str,&k);
+            int len=strlen(str);
+            int s1=0,s2=0;
+            if(k==1){
+                for(int j=0;j<len;j++){
+                    while(str[j]!='+'&&j<len){
+                        s2=s2*10+str[j]-'0';
+                        j++;
+                    }
+                    edge1[s1][s2]=1;
+                    edge0[s1][s2]=1;
+                    s1=s2;
+                    s2=0;
+                }
+            }else if(k==0){
+                for(int j=0;j<len;j++){
+                    while(str[j]!='+'&&j<len){
+                        s2=s2*10+str[j]-'0';
+                        j++;
+                    }
+                    edge0[s1][s2]=1;
+                    s1=s2;
+                    s2=0;
+                }
+            }
+        }
+        int d1,d2,u,v;
+        scanf("%d%d%d%d",&d1,&d2,&u,&v);
+        Dijkstra1(u);
+        Dijkstra0(u);
+        if(dist1[v]==inf&&dist0[v]==inf){
+            printf("-1\n");
+        }else if(dist1[v]==inf&&dist0[v]<inf){
+            printf("%d\n",dist0[v]*d1);
+        }else if(dist1[v]<inf&&dist0[v]==inf){
+            printf("%d\n",dist1[v]*d2);
+        }else {
+            printf("%d\n",min(dist1[v]*d2,dist0[v]*d1));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4523_autoAC.cpp b/HDOJ/4523_autoAC.cpp
new file mode 100644
index 0000000..9c44932
--- /dev/null
+++ b/HDOJ/4523_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<stdio.h>
+#include<string.h>
+char n[111],m[111],p[111],mid[111];
+int compare(char *s1,char *s2)
+{
+      int len1=strlen(s1);
+      int len2=strlen(s2);
+      if(len1>len2) return 1;
+      else if(len1<len2) return 0;
+      for(int i=0;i<len1;i++)
+      {
+          if(s1[i]>s2[i]) return 1;
+          else if(s2[i]>s1[i]) return 0;
+      }
+      return 1;
+}
+void solve(char *s1,char *s2)
+{
+    int len=strlen(s2);
+    int len1=strlen(s1);
+    strrev(s1);
+    strrev(s2);
+    for(int i=0;i<len;i++)
+    {
+        s1[i]=s1[i]-'0'+s2[i]-'0'+'0';
+    }
+    for(int i=0;i<len1;i++)
+    {
+        if(s1[i]>'9')
+        {
+            s1[i]=s1[i]-10;
+            if(i+1==len1) {s1[len1]='1';s1[len1+1]='\0';}
+            else
+            s1[i+1]++;
+        }
+    }
+    strrev(s1);
+    if(compare(s1,m)) printf("YES\n");
+    else printf("NO\n");
+}
+int main()
+{
+    while(scanf("%s %s %s",n,m,p)!=EOF)
+    {
+        if(strlen(m)==1&&m[0]-'0'<3) {printf("NO\n");continue;}
+        if(strcmp(p,"0")==0)
+        {
+            if(strcmp(n,m)==0) printf("YES\n");
+            else printf("NO\n");
+            continue;
+        }
+        if(compare(n,m)) {printf("YES\n"); continue;}
+        if(strlen(p)>strlen(n))
+          solve(p,n);
+        else solve(n,p);
+    }
+     return 0;
+}
diff --git a/HDOJ/4524_autoAC.cpp b/HDOJ/4524_autoAC.cpp
new file mode 100644
index 0000000..2a60c36
--- /dev/null
+++ b/HDOJ/4524_autoAC.cpp
@@ -0,0 +1,30 @@
+#include <stdio.h>
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int n;
+        scanf("%d",&n);
+        __int64 a,t = 0;
+        int flag = 1;
+        while(n--)
+        {
+            scanf("%I64d",&a);
+           if(flag)
+           {
+               t = a - t;
+               if(t<0)
+               {
+                   flag = 0;
+               }
+           }
+        }
+        if(flag && !t)
+        printf("yeah~ I escaped ^_^\n");
+        else
+        printf("I will never go out T_T\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4525_autoAC.cpp b/HDOJ/4525_autoAC.cpp
new file mode 100644
index 0000000..ccca986
--- /dev/null
+++ b/HDOJ/4525_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <cmath>
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+typedef long long LL;
+const int N = 10005;
+int n;
+int seq[N];
+int k1, k2;
+LL K;
+int main() {
+    int T, ca = 0;
+    scanf("%d", &T);
+    while (T--) {
+        LL sum = 0;
+        int c;
+        scanf("%d %d %d %I64d", &n, &k1, &k2, &K);
+        for (int i = 0; i < n; ++i) {
+            scanf("%d", &c);
+            sum += c;
+        }
+        printf("Case #%d: ", ++ca);
+        if (sum > K) {
+            puts("0");
+            continue;
+        }
+        int k3 = k1 + k2;
+        if (k3 >= 0) {
+            if (k3 <= 1) {
+                puts("inf");
+            } else {
+                int d = 1;
+                while ((long double)1.0*sum <= (long double)1.0*K/k3) ++d, sum*=k3;
+                printf("%d\n", d);
+            }
+        } else {
+            if (k3 == -1) {
+                puts("inf");
+            } else {
+                k3 *= -1;
+                int d = 1;
+                while ((long double)1.0*sum <= (long double)1.0*K/k3) ++d, sum*=k3;
+                if (d & 1) printf("%d\n", d+1);
+                else printf("%d\n", d);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4526_autoAC.cpp b/HDOJ/4526_autoAC.cpp
new file mode 100644
index 0000000..66352de
--- /dev/null
+++ b/HDOJ/4526_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+const int MaX = 105;
+int N, K, D, S;
+struct Node {
+    int ti;
+    int qz;
+}seq[MaX];
+int dp[MaX][MaX];
+void solve() {
+    memset(dp, 0xff, sizeof (dp));
+    dp[0][N] = 0;
+    for (int i = 1; i <= K; ++i) {
+        const int &ti = seq[i].ti;
+        const int &qz = seq[i].qz;
+        for (int j = 0; j <= N; ++j) {
+            if (dp[i-1][j] != -1) dp[i][j] = dp[i-1][j] + j*(ti-seq[i-1].ti);
+            if (j == 0) { 
+                for (int k = 1; k <= qz; ++k) {
+                    if (k <= N && dp[i-1][k] != -1) {
+                        if (dp[i][0] == -1) {
+                            dp[i][0] = D + dp[i-1][k] + k*(ti-seq[i-1].ti);
+                        } else {
+                            dp[i][0] = min(dp[i][0], D + dp[i-1][k] + k*(ti-seq[i-1].ti));
+                        }
+                    }
+                }
+            } else {
+                if ((j+qz) <= N && dp[i-1][j+qz] != -1) {
+                    if (dp[i][j] == -1) {
+                        dp[i][j] = D + dp[i-1][j+qz] + (j+qz)*(ti-seq[i-1].ti);
+                    } else {
+                        dp[i][j] = min(dp[i][j], D + dp[i-1][j+qz] + (j+qz)*(ti-seq[i-1].ti));
+                    }
+                }
+            }
+        }
+    }
+    printf("%d\n", dp[K][0]);
+}
+int main() {
+    int T;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d %d %d %d", &N, &K, &D, &S);
+        int sum = 0;
+        for (int i = 1; i <= K; ++i) {
+            scanf("%d %d", &seq[i].ti, &seq[i].qz);
+            sum += seq[i].qz;
+        }
+        if (sum < N) {
+            puts("impossible");
+            continue;
+        }
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4527_autoAC.cpp b/HDOJ/4527_autoAC.cpp
new file mode 100644
index 0000000..74a898e
--- /dev/null
+++ b/HDOJ/4527_autoAC.cpp
@@ -0,0 +1,83 @@
+#include<cstdio>
+#include<cmath>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+typedef long long int64;
+const int INF = 0x3f3f3f3f;
+const int MAXN = 10010;
+int m;
+int mat[8][8];
+int blast[8][8];
+const int dir[][2] = {{-1,0},{1,0},{0,-1},{0,1}};
+struct Node{
+    int x, y;
+    int cnt;
+    int dir;
+}Q[500000];
+void addQue(int x, int y, int cnt, int& rear){
+    mat[x][y] = 0;
+    for(int i=0; i<4; ++i){
+        int dx = x + dir[i][0];
+        int dy = y + dir[i][1];
+        if(dx>=1&&dx<=6&&dy>=1&&dy<=6){
+            Q[rear].x = dx;
+            Q[rear].y = dy;
+            Q[rear].cnt = cnt;
+            Q[rear++].dir = i;
+        }
+    }
+}
+void bfs(int x, int y){
+    int front=0, rear=0;
+    addQue(x, y, 0, rear);
+    int cur = 0; 
+    while(front < rear){
+        while(front < rear && Q[front].cnt==cur){ 
+            Node &t = Q[front++];
+            if(mat[t.x][t.y]){
+                ++mat[t.x][t.y];
+            } else{
+                Node& now = Q[rear];
+                now.x = t.x + dir[t.dir][0];
+                now.y = t.y + dir[t.dir][1];
+                now.cnt = t.cnt + 1;
+                now.dir = t.dir;
+                if(now.x>=1&&now.x<=6&&now.y>=1&&now.y<=6)
+                    ++rear;
+            }
+        }
+        for(int i=1; i<=6; ++i){
+            for(int j=1; j<=6; ++j)if(mat[i][j]>4){
+                addQue(i,j,cur+1,rear);
+            }
+        }
+        ++cur;
+    }
+}
+int main(){
+    int x, y;
+    while(~scanf("%d", &mat[1][1])){
+        for(int i=1; i<=6; ++i){
+            for(int j=(i==1?2:1); j<=6; ++j){
+                scanf("%d", &mat[i][j]);
+            }
+        }
+        scanf("%d", &m);
+        for(int i=0; i<m; ++i){
+            scanf("%d%d", &x, &y);
+            if(++mat[x][y]>4){
+                bfs(x, y);
+            }
+        }
+        for(int i=1; i<=6; ++i){
+            for(int j=1; j<=6; ++j)
+                if(j!=1) printf(" %d", mat[i][j]);
+                else printf("%d", mat[i][j]);
+            putchar('\n');
+        }
+        putchar('\n'); 
+    }
+    return 0;
+}
diff --git a/HDOJ/4528_autoAC.cpp b/HDOJ/4528_autoAC.cpp
new file mode 100644
index 0000000..5a242df
--- /dev/null
+++ b/HDOJ/4528_autoAC.cpp
@@ -0,0 +1,96 @@
+#include<iostream>
+#include<algorithm>
+#include<queue>
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+using namespace std;
+const int N = 100 + 10;
+char g[N][N];
+int n, m, t;
+int sx, sy, dx, dy, ex, ey;
+bool vis[N][N][4];
+int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+struct node
+{
+    int x, y, step;
+    int state;
+    node(){}
+    node(int xx, int yy, int st):x(xx), y(yy), step(st){ state = 0;}
+};
+int BFS()
+{
+    memset(vis, false, sizeof(vis));
+    queue<node> Q;
+    Q.push(node(sx, sy, 0));
+    vis[sx][sy][0] = true;
+    while(!Q.empty())
+    {
+        node cur = Q.front();
+        Q.pop();
+        if(cur.step > t) return -1;
+        for(int k = 0; k < 4; ++k)
+        {
+            int x = cur.x + dir[k][0], y = cur.y + dir[k][1];
+            if(x < 0 || x >= n || y < 0 || y >= m) continue;
+            bool flag = false;
+            if(!(cur.state & 1) && (dx == cur.x || dy == cur.y)) flag = true;
+            if(!(cur.state & 2) && (ex == cur.x || ey == cur.y)) flag = true;
+            if(!flag) continue;
+            while(true)
+            {    
+                if(g[x][y] == 'X') break;
+                if(g[x][y] == 'D') {
+                    cur.state |= 1;
+                    break;
+                }
+                if(g[x][y] == 'E') {
+                    cur.state |= 2;
+                    break;
+                }
+                x += dir[k][0], y += dir[k][1];            
+                if(x < 0 || x >= n || y < 0 || y >= m) break;
+            }
+        }
+        if(cur.state == 3) {
+            return cur.step;
+        }
+        for(int k = 0; k < 4; ++k)
+        {
+            int x = cur.x + dir[k][0], y = cur.y + dir[k][1];
+            if(x < 0 || x >= n || y < 0 || y >= m || vis[x][y][cur.state] || g[x][y] == 'X') continue;
+            if(g[x][y] == 'D' || g[x][y] == 'E') continue;
+            vis[x][y][cur.state] = true;
+            node tmp = node(x, y, cur.step + 1);
+            tmp.state = cur.state;
+            Q.push(tmp);
+        }
+    }
+    return -1;
+}
+int main()
+{
+    int T, cas = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d %d %d",&n, &m, &t);
+        for(int i = 0; i < n; ++i)
+        {
+            scanf("%s",g[i]);
+            for(int j = 0; j < m; ++j)
+            {
+                if(g[i][j] == 'S')
+                    sx = i, sy = j;
+                if(g[i][j] == 'E')
+                    ex = i, ey = j;
+                if(g[i][j] == 'D')
+                    dx = i, dy = j;
+            }
+        }
+        g[sx][sy] = '.';
+        int ans = BFS();
+        printf("Case %d:\n%d\n", ++cas, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4529_autoAC.cpp b/HDOJ/4529_autoAC.cpp
new file mode 100644
index 0000000..c873fc5
--- /dev/null
+++ b/HDOJ/4529_autoAC.cpp
@@ -0,0 +1,95 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+int t,N;
+char s[10][10];
+bool suit[10][1<<8+5];
+int dp[8][11][1<<8][1<<8];
+int one[1<<8+5];
+inline void init()
+{
+    memset(suit,0,sizeof(suit));
+    for(int i=0;i<8;i++)
+    {
+        for(int j=0;j< 1<<8;j++)
+        {
+            int tag=1;
+            for(int k=0;k<8;k++)
+            {
+                if(s[i][k]=='*'&&(j&(1<<k)))
+                {
+                    tag=0;break;
+                }
+            }
+            if(tag) suit[i][j]=1;
+        }
+    }
+}
+inline int getOne(int i)
+{
+    int ans=0;
+    while(i)
+    {
+        ans+=i%2;
+        i/=2;
+    }
+    return ans;
+}
+int main()
+{
+    for(int i=0;i< 1<<8;i++)
+    {
+        one[i]=getOne(i);
+    }
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&N);
+        for(int i=0;i<8;i++) scanf("%s",s[i]);
+        init();
+        memset(dp,0,sizeof(dp));
+        for(int i=0;i< 1<<8;i++)
+        {
+            if(suit[0][i]&&one[i]<=N)
+            {
+                dp[0][one[i]][i][0]=1;
+            }
+        }
+        for(int i=1;i<8;i++)
+            for(int n=0;n<=N;n++)
+            for(int j=0;j< 1<<8;j++)
+        {
+            if(one[j]>n) continue;
+            if(!suit[i][j]) continue;
+            for(int k=0;k< 1<<8;k++)
+            {
+                if(one[k]+one[j]>n) continue;
+                if(k&(j<<2)) continue;
+                if(k&(j>>2)) continue;
+                for(int r=0;r< 1<<8;r++)
+                {
+                    if(one[k]+one[j]+one[r]>n) continue;
+                    if(r&(j<<1)) continue;
+                    if(r&(j>>1)) continue;
+                    dp[i][n][j][k]+=dp[i-1][n-one[j]][k][r];
+                }
+            }
+        }
+        int ans=0;
+        for(int i=0;i< 1<<8;i++)
+        {
+            if(suit[7][i])
+            {
+                for(int j=0;j< 1<<8;j++)
+                {
+                    if(suit[6][j])
+                    {
+                        ans+=dp[7][N][i][j];
+                    }
+                }
+            }
+        }
+        printf("%d\n",ans);
+    }
+}
diff --git a/HDOJ/4530_autoAC.cpp b/HDOJ/4530_autoAC.cpp
new file mode 100644
index 0000000..3c2e60a
--- /dev/null
+++ b/HDOJ/4530_autoAC.cpp
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int main()
+{
+    int t,q,a,b,i;
+    double x,ans;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%lf%d",&x,&q);
+        for(i = 1; i<=q; i++)
+        {
+            scanf("%d%d",&a,&b);
+            if(a == 1)
+                ans = b*60.0-b*x;
+            else if(a == 2)
+                ans = b*3600.0/(60.0-x);
+            else if(a == 3)
+                ans = 43200*b*60/x;
+            printf("%.2lf\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4531_autoAC.cpp b/HDOJ/4531_autoAC.cpp
new file mode 100644
index 0000000..1b064fb
--- /dev/null
+++ b/HDOJ/4531_autoAC.cpp
@@ -0,0 +1,328 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <map>
+#include <set>
+#include <string>
+#include <queue>
+#include <iostream>
+using namespace std;
+char str[3][3][6];
+char g[3][3][6];
+map<int,int>mp;
+queue<int>q;
+bool mo[6];
+int F[50];
+int find(int x)
+{
+    if(F[x]==-1)return x;
+    return F[x]=find(F[x]);
+}
+void bing(int x,int y)
+{
+    int t1=find(x);
+    int t2=find(y);
+    if(t1!=t2)F[t1]=t2;
+}
+bool judge(int state)
+{
+    char temp[10];
+    int t[10];
+    sprintf(temp,"%09d",state);
+    for(int i=0;i<9;i++)t[i]=temp[i]-'0';
+    for(int i=0;i<3;i++)
+      for(int j=0;j<3;j++)
+      {
+          int p=t[3*i+j];
+          int x=p/3;
+          int y=p%3;
+          strcpy(g[i][j],str[x][y]);
+      }
+    memset(F,-1,sizeof(F));
+    for(int i=0;i<3;i++)
+      for(int j=0;j<3;j++)
+      {
+          if(g[i][j][0]==g[i][j][2])bing(12*i+4*j,12*i+4*j+2);
+          if(g[i][j][0]==g[i][j][3])bing(12*i+4*j,12*i+4*j+3);
+          if(g[i][j][1]==g[i][j][2])bing(12*i+4*j+1,12*i+4*j+2);
+          if(g[i][j][1]==g[i][j][3])bing(12*i+4*j+1,12*i+4*j+3);
+      }
+    for(int i=0;i<3;i++)
+    {
+        if(g[i][0][3]==g[i][1][2])bing(12*i+3,12*i+4+2);
+        if(g[i][1][3]==g[i][2][2])bing(12*i+4+3,12*i+8+2);
+    }
+    for(int j=0;j<3;j++)
+    {
+        if(g[0][j][1]==g[1][j][0])bing(4*j+1,12+4*j+0);
+        if(g[1][j][1]==g[2][j][0])bing(12+4*j+1,24+4*j+0);
+    }
+    int R=-1,G=-1,B=-1,O=-1;
+    for(int i=0;i<3;i++)
+      for(int j=0;j<3;j++)
+        for(int k=0;k<4;k++)
+        {
+            int t1=find(12*i+4*j+k);
+            if(g[i][j][k]=='R')
+            {
+                if(R==-1)R=t1;
+                else if(t1!=R)return false;
+            }
+            else if(g[i][j][k]=='G')
+            {
+                if(G==-1)G=t1;
+                else if(t1!=G)return false;
+            }
+            else if(g[i][j][k]=='B')
+            {
+                if(B==-1)B=t1;
+                else if(t1!=B)return false;
+            }
+            else
+            {
+                if(O==-1)O=t1;
+                else if(t1!=O)return false;
+            }
+        }
+    return true;
+}
+int bfs()
+{
+    mp.clear();
+    while(!q.empty())q.pop();
+    int tmp,now;
+    char ss1[10],ss2[10];
+    tmp=12345678; 
+    mp[tmp]=0;
+    q.push(tmp);
+    while(!q.empty())
+    {
+        tmp=q.front();
+        q.pop();
+        if(judge(tmp))return mp[tmp];
+        sprintf(ss1,"%09d",tmp);
+        for(int i=0;i<3;i++)
+          for(int j=0;j<3;j++)
+          {
+              int t=ss1[3*i+j]-'0';
+             strcpy(g[i][j],str[t/3][t%3]);
+          }
+        if(mo[0])
+        {
+            strcpy(ss2,ss1);
+            ss2[0]=ss1[1];
+            ss2[1]=ss1[2];
+            ss2[2]=ss1[0];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+            ss2[0]=ss1[2];
+            ss2[1]=ss1[0];
+            ss2[2]=ss1[1];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+        }
+        if(mo[1])
+        {
+            strcpy(ss2,ss1);
+            ss2[3]=ss1[4];
+            ss2[4]=ss1[5];
+            ss2[5]=ss1[3];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+            ss2[3]=ss1[5];
+            ss2[4]=ss1[3];
+            ss2[5]=ss1[4];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+        }
+        if(mo[2])
+        {
+            strcpy(ss2,ss1);
+            ss2[6]=ss1[7];
+            ss2[7]=ss1[8];
+            ss2[8]=ss1[6];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+            ss2[6]=ss1[8];
+            ss2[7]=ss1[6];
+            ss2[8]=ss1[7];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+        }
+        if(mo[3])
+        {
+            strcpy(ss2,ss1);
+            ss2[0]=ss1[3];
+            ss2[3]=ss1[6];
+            ss2[6]=ss1[0];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+            ss2[0]=ss1[6];
+            ss2[3]=ss1[0];
+            ss2[6]=ss1[3];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+        }
+        if(mo[4])
+        {
+            strcpy(ss2,ss1);
+            ss2[1]=ss1[4];
+            ss2[4]=ss1[7];
+            ss2[7]=ss1[1];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+            ss2[1]=ss1[7];
+            ss2[4]=ss1[1];
+            ss2[7]=ss1[4];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+        }
+        if(mo[5])
+        {
+            strcpy(ss2,ss1);
+            ss2[2]=ss1[5];
+            ss2[5]=ss1[8];
+            ss2[8]=ss1[2];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+            ss2[2]=ss1[8];
+            ss2[5]=ss1[2];
+            ss2[8]=ss1[5];
+            now=0;
+            for(int i=0;i<9;i++)
+            {
+                now*=10;
+                now+=ss2[i]-'0';
+            }
+            if(mp.find(now)==mp.end())
+            {
+                mp[now]=mp[tmp]+1;
+                q.push(now);
+            }
+        }
+    }
+    return -1;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    int iCase=0;
+    while(T--)
+    {
+        iCase++;
+        printf("Case #%d: ",iCase);
+        for(int i=0;i<6;i++)mo[i]=true;
+        for(int i=0;i<3;i++)
+          for(int j=0;j<3;j++)
+          {
+              scanf("%s",&str[i][j]);
+              if(str[i][j][4]=='1')
+              {
+                  mo[i]=false;
+                  mo[3+j]=false;
+              }
+          }
+        printf("%d\n",bfs());
+    }
+    return 0;
+}
diff --git a/HDOJ/4532_autoAC.cpp b/HDOJ/4532_autoAC.cpp
new file mode 100644
index 0000000..0d799c0
--- /dev/null
+++ b/HDOJ/4532_autoAC.cpp
@@ -0,0 +1,47 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int mod=1000000007;
+long long dp[50][520];  
+long long C[520][520];   
+long long A[520];       
+int a[50];
+void Init(){
+    C[0][0]=1;
+    for(int i=1;i<480;i++){     
+        C[i][0]=1;
+        for(int j=1;j<i;j++)
+            C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
+        C[i][i]=1;
+    }
+    A[0]=A[1]=1;
+    for(int i=2;i<480;i++)
+        A[i]=(A[i-1]*i)%mod;
+}
+int main(){
+    Init();
+    int t,n,cases=0;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        memset(dp,0,sizeof(dp));
+        dp[1][a[1]-1]=1;    
+        long long sum=a[1];
+        for(int i=2;i<=n;i++){
+            for(int j=0;j<sum;j++)  
+                for(int k=1;k<=a[i];k++)  
+                    for(int u=0;u<=j && u<=k;u++)   
+                        dp[i][j-u+a[i]-1-(k-1)]=(dp[i][j-u+a[i]-k]+(((dp[i-1][j]*C[j][u])%mod*C[sum+1-j][k-u])%mod*C[a[i]-1][k-1])%mod)%mod;
+            sum+=a[i];
+        }
+        printf("Case %d: ",++cases);
+        long long ans=dp[n][0];
+        for(int i=1;i<=n;i++)   
+            ans=(ans*A[a[i]])%mod;
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4533_autoAC.cpp b/HDOJ/4533_autoAC.cpp
new file mode 100644
index 0000000..5f36ebe
--- /dev/null
+++ b/HDOJ/4533_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <cstdio>
+#include <cstring>
+const int v = 200005;
+int T, N, x;
+__int64 a, b, c, A[v], B[v], C[v];
+void f(int s, int t) {
+    A[s] += a;
+    B[s] += b;
+    C[s] += c;
+    A[t + 1] += -a;
+    B[t + 1] += -b;
+    C[t + 1] += -c;
+}
+void insert(__int64 x1, __int64 y1, __int64    x2, __int64 y2) {
+    int m = x1 > y1 ? x1 : y1, t = x2 > y2 ? x2 : y2, t2 = x2 > y2 ? y2 : x2;
+    a = b = c = 0;
+    c = (x2 - x1) * (y2 - y1);
+    f(t + 1, v - 5);
+    a = 1;
+    b = -(x1 + y1);
+    c = x1 * y1;
+    if(t2 >= m)
+        f(m + 1, t2);
+    else
+        t2 = m;
+    if(y2 > x2) {
+        a -= 1;
+        b +=  x2 + y1;
+        c -=  x2 * y1;
+    }
+    else if(x2 > y2) {
+        a -= 1;
+        b +=  x1 + y2;
+        c -=  x1 * y2;
+    }
+    f(t2 + 1, t);
+}
+int main() {
+    scanf("%d", &T);
+    while(T--) {
+        memset(A, 0, sizeof(A));
+        memset(B, 0, sizeof(B));
+        memset(C, 0, sizeof(C));
+        scanf("%d", &N);
+        for(int i = 0; i < N; ++i) {
+            __int64 x1, y1, x2, y2;
+            scanf("%I64d%I64d%I64d%I64d", &x1, &y1, &x2, &y2);
+            insert(x1, y1, x2, y2);
+        }
+        for(int i = 1; i < v; ++i) {
+            A[i] += A[i-1];
+            B[i] += B[i-1];
+            C[i] += C[i-1];
+        }
+        scanf("%d", &x);
+        while(x--) {
+            __int64 t;
+            scanf("%I64d", &t);
+            printf("%I64d\n", t * t * A[t] + t * B[t] + C[t]);
+        }
+    }    
+}
diff --git a/HDOJ/4534_autoAC.cpp b/HDOJ/4534_autoAC.cpp
new file mode 100644
index 0000000..97473d2
--- /dev/null
+++ b/HDOJ/4534_autoAC.cpp
@@ -0,0 +1,144 @@
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+#include <queue>
+using namespace std;
+const int N = 1605;
+const int inf = 0x3f3f3f3f;
+int n;
+int sz;
+char str[105];
+int del[2][N][1<<8]; 
+int sco[2][N][1<<8];
+struct Ac_auto {
+    int ch[N][26];
+    int fail[N];
+    int sta[N];
+    int gain[N];
+    char kill[N]; 
+    int idx, root;
+    int newnd() {
+        memset(ch[idx], 0, sizeof (ch[idx]));
+        gain[idx] = sta[idx] = fail[idx] = kill[idx] = 0;
+        return idx++;
+    }
+    void init() {
+        idx = 0, root = newnd();
+    }
+    void insert(char ss[], int val) {
+        int len = strlen(ss);
+        int p = root;
+        for (int i = 0; i < len; ++i) {
+            char c = ss[i]-'a';
+            if (!ch[p][c]) ch[p][c] = newnd();
+            p = ch[p][c];
+        }
+        if (val == 999) sta[p] = 1 << sz;
+        else if (val == -999) kill[p] = 1;
+        else gain[p] = val;
+    }
+    void build() { 
+        queue<int>q;
+        for (int i = 0; i < 26; ++i) {
+            if (ch[root][i]) {
+                q.push(ch[root][i]);
+            }
+        }
+        while (!q.empty()) {
+            int p = q.front();
+            q.pop();
+            for (int i = 0; i < 26; ++i) {
+                int v = ch[p][i];
+                int x = fail[p];
+                if (v) {
+                    q.push(v);
+                    while (x && !ch[x][i]) x = fail[x]; 
+                    fail[v] = ch[x][i]; 
+                    kill[v] |= kill[fail[v]]; 
+                    sta[v] |= sta[fail[v]]; 
+                    gain[v] += gain[fail[v]];
+                } else {
+                    ch[p][i] = ch[x][i];
+                }
+            }
+        }
+    }
+};
+Ac_auto ac;
+void solve() {
+    memset(del, 0x3f, sizeof (del)); 
+    memset(sco, 0x80, sizeof (sco)); 
+    int cur = 0, nxt = 1;
+    del[cur][0][0] = 0; 
+    sco[cur][0][0] = 0; 
+    int len = strlen(str);
+    int lim = 1 << sz;
+    const int &idx = ac.idx;
+    for (int i = 0; i < len; ++i) { 
+        int c = str[i]-'a';
+        memset(del[nxt], 0x3f, sizeof (del[nxt]));
+        memset(sco[nxt], 0x80, sizeof (sco[nxt]));
+        for (int j = 0; j < idx; ++j) {
+            for (int k = 0; k < lim; ++k) { 
+                if (del[cur][j][k] == inf) continue; 
+                if (del[nxt][j][k] > del[cur][j][k] + 1) {
+                    del[nxt][j][k] = del[cur][j][k] + 1;
+                    sco[nxt][j][k] = sco[cur][j][k];
+                } else if (del[nxt][j][k] == del[cur][j][k] + 1) {
+                    if (sco[nxt][j][k] < sco[cur][j][k]) {
+                        sco[nxt][j][k] = sco[cur][j][k];
+                    }
+                }
+                int np = ac.ch[j][c];
+                if (ac.kill[np]) continue; 
+                int gain = ac.gain[np];
+                int nsta = k|ac.sta[np];
+                if (del[nxt][np][nsta] > del[cur][j][k]) {
+                    del[nxt][np][nsta] = del[cur][j][k];
+                    sco[nxt][np][nsta] = sco[cur][j][k] + gain;
+                } else if (del[nxt][np][nsta] == del[cur][j][k]) {
+                    if (sco[nxt][np][nsta] < sco[cur][j][k] + gain) {
+                        sco[nxt][np][nsta] = sco[cur][j][k] + gain;
+                    }
+                }
+            }
+        }
+        swap(cur, nxt);
+    }
+    int xdel = inf, xsco;
+    for (int i = 0; i < idx; ++i) {
+        if (xdel > del[cur][i][lim-1]) {
+            xdel = del[cur][i][lim-1];
+            xsco = sco[cur][i][lim-1];
+        } else if (xdel == del[cur][i][lim-1]) {
+            xsco = max(xsco, sco[cur][i][lim-1]);
+        }
+    }
+    if (xdel == inf) {
+        puts("Banned");
+    } else {
+        printf("%d %d\n", xdel, xsco);
+    }
+}
+int main() {
+    int T, ca = 0;
+    scanf("%d", &T);
+    while (T--) {
+        int val;
+        sz = 0;
+        ac.init();
+        scanf("%d", &n);
+        for (int i = 0; i < n; ++i) {
+            scanf("%s %d", str, &val);
+            ac.insert(str, val);
+            if (val == 999) ++sz;
+        }
+        ac.build();
+        scanf("%s", str);
+        printf("Case %d: ", ++ca);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4535_autoAC.cpp b/HDOJ/4535_autoAC.cpp
new file mode 100644
index 0000000..ce3bffd
--- /dev/null
+++ b/HDOJ/4535_autoAC.cpp
@@ -0,0 +1,26 @@
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <vector>
+#include <algorithm>
+using namespace std;
+#define MAXN (100+10)
+__int64 f[MAXN]={0,0,1};
+__int64 h = 1000000007;
+int main()
+{
+    int t;
+    int n;
+    for (int i=3;i<=100;i++)
+    {
+        f[i]=((i-1)*f[i-1]%h+f[i-2]*(i-1)%h)%h;
+    }
+    scanf(" %d",&t);
+    while (t--)
+    {
+        scanf(" %d",&n);
+        printf("%I64d\n",f[n]);
+    }
+}
diff --git a/HDOJ/4536_autoAC.cpp b/HDOJ/4536_autoAC.cpp
new file mode 100644
index 0000000..72dafb8
--- /dev/null
+++ b/HDOJ/4536_autoAC.cpp
@@ -0,0 +1,67 @@
+#include <iostream>
+#include <cstdio>
+#include <vector>
+#include <algorithm>
+using namespace std;
+const int maxn = 20;
+int p[maxn], nervous[maxn], n, m, k, max_cnt;
+int att[110][3];
+void dfs(int cn) {
+    if(max_cnt >= k) return ;
+    if(cn >= k) {
+        max_cnt = k; return ;
+    }
+    int a[3], bak[3];
+    for(int v=0; v<3; v++) {    
+        a[0] = att[cn][v];  
+        a[1] = att[cn][(v+1)%3];
+        a[2] = att[cn][(v+2)%3];
+        bak[0] = nervous[a[0]];  
+        bak[1] = nervous[a[1]];
+        bak[2] = nervous[a[2]];
+        nervous[a[0]] -= 2;
+        if(nervous[a[0]] < 1) nervous[a[0]] = 1;
+        nervous[a[1]] += 2;
+        nervous[a[2]] += 2;
+        for(int i=0; i<n; i++) {
+            if(p[i] == p[a[1]] && i != a[1]) nervous[i]++;
+            if(p[i] == p[a[2]] && i != a[2]) nervous[i]++;
+        }
+        int flag = true;
+        for(int i=0; i<n; i++) {
+            if(nervous[i] > 5) {
+                max_cnt = max(max_cnt, cn);
+                flag = false;
+            }
+        }
+        if(flag) dfs(cn+1);
+        for(int i=0; i<n; i++) {
+            if(p[i] == p[a[1]] && i != a[1]) nervous[i]--;
+            if(p[i] == p[a[2]] && i != a[2]) nervous[i]--;
+        }
+        nervous[a[0]] = bak[0];
+        nervous[a[1]] = bak[1];
+        nervous[a[2]] = bak[2];
+    }
+}
+int main(){
+    int T;
+    scanf("%d", &T);
+    for(int kase=1; kase<=T; kase++) {
+        scanf("%d%d%d", &n, &m, &k);
+        for(int i=0; i<n; i++) {
+            scanf("%d", &p[i]);
+        }
+        for(int i=0; i<n; i++) {
+            scanf("%d", &nervous[i]);
+        }
+        for(int i=0; i<k; i++) {
+            scanf("%d %d %d", &att[i][0], &att[i][1], &att[i][2]);
+        }
+        max_cnt = 0;
+        printf("Case #%d: ", kase);
+        dfs(0);
+        printf("%d\n", max_cnt);
+    }
+    return 0;
+}
diff --git a/HDOJ/4538_autoAC.cpp b/HDOJ/4538_autoAC.cpp
new file mode 100644
index 0000000..54686de
--- /dev/null
+++ b/HDOJ/4538_autoAC.cpp
@@ -0,0 +1,15 @@
+This is a line with example text
+&lt;----&lt;--&lt;-&lt;----&lt;----&lt;-------&lt;---
+  b    b b  b    b     b      b 
+This is a line with example text
+&lt;--&lt;--&lt;-&lt;----&lt;----&lt;-------&lt;-----
+ ge ge ge ge   ge     ge    ge  
+This is a line with example text
+-----&gt;--&gt;-&gt;----&gt;----&gt;-------&gt;--&gt;
+   w  w  w  w    w      w     w 
+This is a line with example text
+---&gt;--&gt;-&gt;----&gt;----&gt;-------&gt;----&gt;
+ e  e  e  e     e      e      e 
+while ((((true)))) printf("Hello VIM!")
+------&gt;---&gt;---&gt;----&gt;-------------&gt;--&gt;-&gt;
+   w    w   w    w      W         w  w
diff --git a/HDOJ/4539_autoAC.cpp b/HDOJ/4539_autoAC.cpp
new file mode 100644
index 0000000..7ae51de
--- /dev/null
+++ b/HDOJ/4539_autoAC.cpp
@@ -0,0 +1,109 @@
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+int N, M, idx;
+int sta[175], num[175];
+int cnt[15], mp[105];
+int f[105][175][175];
+void print(int x) {
+    int rec[50] = {0}, p = 0;
+    while (x) {
+        rec[p++] = x % 2;
+        x /= 2;
+    }
+    for (int i = 9; i >= 0; --i) {
+        printf(i == 0 ? "%d\n" : "%d", rec[i]);
+    }
+}
+inline bool legal(int x) {
+    if (x & (x << 2)) return false;
+    return true;
+}
+void init() {
+    int lim;
+    idx = 1;
+    for (int k = 1; k <= 10; ++k) {
+        lim = 1 << k;
+        for (int i = 1<<(k-1); i < lim; ++i) {
+            if (legal(i)) {
+                sta[idx] = i;
+                for (int j = 0; j < k; ++j) {
+                    if (i & (1 << j)) ++num[idx];
+                }
+                idx++;
+            }
+        }
+        cnt[k] = idx;
+    }
+}
+inline bool place(int x, int y) {
+    return (x & y) == x;
+}
+inline bool judge_1(int x, int y) { 
+    if ((x << 1) & y || (x >> 1) & y) return false;
+    return true;
+}
+inline bool judge_2(int x, int y) { 
+    if (x & y) return false;
+    return true;
+}
+int solve() {
+    int ret = 0;
+    memset(f, 0, sizeof (f));
+    if (N == 1) {
+        for (int i = 0; i < cnt[M]; ++i) {
+            if (place(sta[i], mp[1])) {
+                ret = max(ret, num[i]);
+            }
+        }
+        return ret;
+    }
+    for (int i = 0; i < cnt[M]; ++i) {
+        if (!place(sta[i], mp[2])) continue;
+        for (int j = 0; j < cnt[M]; ++j) {
+            if (!place(sta[j], mp[1])) continue;
+            if (judge_1(sta[i], sta[j])) {
+                f[2][i][j] = num[i] + num[j];
+            }
+        }
+    }
+    for (int i = 3; i <= N; ++i) {
+        for (int j = 0; j < cnt[M]; ++j) {
+            if (!place(sta[j], mp[i])) continue;
+            for (int k = 0; k < cnt[M]; ++k) {
+                if (!place(sta[k], mp[i-1]) || !judge_1(sta[j], sta[k])) continue;
+                for (int h = 0; h < cnt[M]; ++h) {
+                    if (!place(sta[h], mp[i-2]) || !judge_1(sta[k], sta[h])) continue;
+                    if (judge_2(sta[j], sta[h])) {
+                        f[i][j][k] = max(f[i][j][k], f[i-1][k][h] + num[j]);    
+                    }
+                }
+            }
+        }    
+    }
+    for (int i = 0; i < cnt[M]; ++i) {
+        for (int j = 0; j < cnt[M]; ++j) {
+            ret = max(ret, f[N][i][j]);
+        }
+    }
+    return ret;
+}
+int main() {
+    init();
+    int c;
+    while (scanf("%d %d", &N, &M) != EOF) {
+        memset(mp, 0, sizeof (mp));
+        for (int i = 1; i <= N; ++i) {
+            for (int j = 1; j <= M; ++j) {
+                scanf("%d", &c);
+                mp[i] <<= 1;
+                mp[i] |= c;
+            }
+        }
+        printf("%d\n", solve());
+    }
+    return 0;    
+}
diff --git a/HDOJ/4540_autoAC.cpp b/HDOJ/4540_autoAC.cpp
new file mode 100644
index 0000000..2744015
--- /dev/null
+++ b/HDOJ/4540_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<iostream>
+const int inf=1<<30;
+using namespace std;
+int map[22][22];
+int dp[22][22];
+int n,m;
+int main(){
+    while(~scanf("%d%d",&n,&m)){
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=m;j++){
+                scanf("%d",&map[i][j]);
+                dp[i][j]=inf;
+            }
+        }
+        for(int i=1;i<=m;i++){
+            dp[1][i]=0;
+        }
+        for(int i=2;i<=n;i++){
+            for(int j=1;j<=m;j++){
+                for(int k=1;k<=m;k++){
+                    dp[i][j]=min(dp[i][j],dp[i-1][k]+abs(map[i][j]-map[i-1][k]));
+                }
+            }
+        }
+        int ans=inf;
+        for(int i=1;i<=m;i++){
+            ans=min(ans,dp[n][i]);
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4541_autoAC.cpp b/HDOJ/4541_autoAC.cpp
new file mode 100644
index 0000000..8ea2bd2
--- /dev/null
+++ b/HDOJ/4541_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <stdio.h>  
+#include <string.h>  
+#include <stdlib.h>
+#include <iostream>
+#include <queue>
+#include <algorithm>
+using namespace std;
+int s[20][100];
+void inite()
+{
+    s[3][0]= 4; s[3][1] = 1, s[3][2] = 2, s[3][3] = 6, s[3][4] = 10;
+    s[4][0] = 4;s[4][1] = 0, s[4][2] = 4, s[4][3] = 5, s[4][4] = 9;
+    s[5][0] = 6; s[5][1] = 3, s[5][2] = 7, s[5][3] = 8, s[5][4] = 40;
+    s[5][5] = 50, s[5][6] = 60;
+    s[6][0] = 6, s[6][1] = 11, s[6][2] = 12, s[6][3] = 20, s[6][4] = 30;
+    s[6][5] = 80, s[6][6] = 90;
+    s[7][0] = 3, s[7][1] = 15, s[7][2] = 16, s[7][3] = 70;
+    s[8][0] = 13, s[8][1] = 13, s[8][2] = 14, s[8][3] = 18, s[8][4] = 19;
+    s[8][5] = 41, s[8][6] = 42, s[8][7] = 46, s[8][8] = 51, s[8][9] = 52;
+    s[8][10] = 56,s[8][11] =61 ,s[8][12] = 62,s[8][13] = 66;
+    s[9][0] = 22, s[9][1] = 17,s[9][2] = 21, s[9][3] = 22,s[9][4] = 26;
+    s[9][5] = 31, s[9][6] = 32,s[9][7] = 36, s[9][8] = 44,s[9][9] = 45;
+    s[9][10] = 49,s[9][11] = 54,s[9][12] = 55, s[9][13] = 59,s[9][14] = 64;
+    s[9][15] = 65, s[9][16] = 69,s[9][17] = 81, s[9][18] = 82,s[9][19] = 86;
+    s[9][20] = 91, s[9][21] = 92, s[9][22] = 96;
+    s[10][0] = 25, s[10][1] = 24,s[10][2] = 25, s[10][3] = 29,s[10][4] = 34;
+    s[10][5] = 35, s[10][6] = 39,s[10][7] = 43, s[10][8] = 47,s[10][9] = 48;
+    s[10][10] = 53, s[10][11] = 57,s[10][12] = 58, s[10][13] = 63,s[10][14] = 67;
+    s[10][15] = 68, s[10][16] = 71,s[10][17] = 72, s[10][18] = 76,s[10][19] = 84;
+    s[10][20] = 85, s[10][21] = 89,s[10][22] = 94, s[10][23] = 95,s[10][24] = 99;
+    s[10][25] = 100;
+    s[11][0] = 15, s[11][1] = 23,s[11][2] = 27,s[11][3] = 28,s[11][4] = 33;
+    s[11][5] = 37, s[11][6] = 38,s[11][7] = 74,s[11][8] = 75,s[11][9] = 79;
+    s[11][10] = 83, s[11][11] = 87,s[11][12] = 88,s[11][13] = 93,s[11][14] = 97;
+    s[11][15] = 98;
+    s[12][0] = 3,s[12][1] = 73,s[12][2] = 77,s[12][3] = 78;
+}
+int main()
+{
+    inite();
+    int T, cas = 0;
+    for(scanf("%d", &T); T--; )
+    {
+        int a, b;
+        scanf("%d%d", &a, &b);
+        if((a < 3) || a > 12)
+            printf("Case #%d: -1\n", ++cas);
+        else
+        {
+            if(((s[a][0] < b) && (a != 9)) || ((a == 9) && (s[a][0] + 4< b)))
+                printf("Case #%d: -1\n", ++cas);
+            else
+            {
+                if(a == 9)
+                {
+                    if(b <= 22)
+                        printf("Case #%d: %d\n", ++cas, s[a][b]);
+                    else if(b == 23)
+                    printf("Case #%d: 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas);
+                    else if(b == 24)
+                        printf("Case #%d: 20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas);
+                    else if(b == 25)
+                        printf("Case #%d: 60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas);
+                    else if(b == 26)
+                        printf("Case #%d: 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n", ++cas);
+                }
+                else
+                    printf("Case #%d: %d\n", ++cas, s[a][b]);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4542_autoAC.cpp b/HDOJ/4542_autoAC.cpp
new file mode 100644
index 0000000..89bef63
--- /dev/null
+++ b/HDOJ/4542_autoAC.cpp
@@ -0,0 +1,112 @@
+#include <stdio.h>
+#include <iostream>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+const int MAXN=100000;
+int prime[MAXN+1];
+void getPrime()
+{
+    memset(prime,0,sizeof(prime));
+    for(int i=2;i<=MAXN;i++)
+    {
+        if(!prime[i])prime[++prime[0]]=i;
+        for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++)
+        {
+            prime[prime[j]*i]=1;
+            if(i%prime[j]==0)break;
+        }
+    }
+}
+long long factor[100][2];
+int fatCnt;
+int getFactors(long long x)
+{
+    fatCnt=0;
+    long long tmp=x;
+    for(int i=1;prime[i]<=tmp/prime[i];i++)
+    {
+        factor[fatCnt][1]=0;
+        if(tmp%prime[i]==0)
+        {
+            factor[fatCnt][0]=prime[i];
+            while(tmp%prime[i]==0)
+            {
+                factor[fatCnt][1]++;
+                tmp/=prime[i];
+            }
+            fatCnt++;
+        }
+    }
+    if(tmp!=1)
+    {
+        factor[fatCnt][0]=tmp;
+        factor[fatCnt++][1]=1;
+    }
+    return fatCnt;
+}
+const long long INF=(1LL<<62)+1;
+int N;
+long long ans;
+long long a[47787];
+void dfs(int i,long long x,int n)
+{
+    if(n>47777)return;
+    if(x<INF && (a[n]==0||a[n]>x))a[n]=x;
+    for(int j=1;j<=62;j++)
+    {
+        if(INF/prime[i]<x)break;
+        x*=prime[i];
+        if(x>=INF)break;
+        dfs(i+1,x,n*(j+1));
+    }
+}
+int get(int x)
+{
+    getFactors(x);
+    int ans=1;
+    for(int i=0;i<fatCnt;i++)
+       ans*=(factor[i][1]+1);
+    return ans;
+}
+void solve2()
+{
+    int x=2;
+    while(x*x<=4*(N+x))
+    {
+        if(x==get(N+x))
+        {
+            printf("%d\n",N+x);
+            return;
+        }
+        x++;
+    }
+    printf("Illegal\n");
+}
+void init()
+{
+    memset(a,0,sizeof(a));
+    dfs(1,1,1);
+}
+int main()
+{
+    int T;
+    getPrime();
+    int iCase=0;
+    scanf("%d",&T);
+    int Type;
+    init();
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d",&Type,&N);
+        printf("Case %d: ",iCase);
+        if(Type==0)
+        {
+            if(a[N]!=0)printf("%I64d\n",a[N]);
+            else printf("INF\n");
+        }
+        else solve2();
+    }
+    return 0;
+}
diff --git a/HDOJ/4543_autoAC.cpp b/HDOJ/4543_autoAC.cpp
new file mode 100644
index 0000000..922c130
--- /dev/null
+++ b/HDOJ/4543_autoAC.cpp
@@ -0,0 +1,131 @@
+#include<cstdio>
+#include<cmath>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+struct P{
+    int x,y,dis;
+};
+int N,M,pnum;
+int map[80][80],a[80][80];
+P queue[100000];
+int front,rear;
+char s[200];
+P point[10000];
+void push(P p){
+    queue[rear++] = p;
+}
+P pop(){
+    ++front;
+    return queue[front - 1];
+}
+P D(P p,int dir){
+    P p2 = p;
+    if(dir == 0) --p2.x;
+    else if(dir == 1) ++ p2.x;
+    else if(dir == 2) -- p2.y;
+    else ++p2.y;
+    return p2;
+}
+bool check(P p){
+    if(p.x >=0 && p.x < N && p.y >=0 && p.y < M && a[p.x][p.y] == 0)
+        return true;
+    return false;
+}
+void BFS()
+{
+    rear = front = 0;
+    for(int i=0; i<N; ++i)
+        for(int j=0; j<M; ++j){
+            if(a[i][j] == 1){
+                P p;
+                p.x = i;
+                p.y = j;
+                push(p);
+            }
+        }
+    while(rear > front){
+        P p = pop();
+        for(int dir =0; dir < 4; dir ++){
+            P p2;
+            p2 = D(p,dir);
+            if(check(p2)){
+                a[p2.x][p2.y] = a[p.x][p.y] + 1;
+                push(p2);
+            }
+        }
+    }
+}
+bool cmp(P p1, P p2){
+    return p1.dis < p2.dis;
+}
+int DIS(P p1,P p2){
+    return abs(p1.x - p2.x) + abs(p1.y - p2.y);
+}
+int solve()
+{
+    BFS();
+    pnum = 0;
+    for(int i=0; i<N; ++i){
+        for(int j=0; j<M; ++j){
+            if(a[i][j] > 1){
+                P p;
+                p.x = i;
+                p.y = j;
+                p.dis = a[i][j] - 1;
+                point[pnum++] = p;
+            }
+        }
+    }
+    if(pnum == 0){
+        if(N == 1) return (M-1) / 2;
+        if(M == 1) return (N-1) / 2;
+        return (2*N + 2*M - 4)/3;
+    }
+    sort(point,point+pnum,cmp);
+    int q = 0,d = 1;
+    while(q < pnum){
+        bool flag = false;
+        for(int i=q; i<pnum; ++i){
+            for(int j=i+1;j<pnum; ++j){
+                if(DIS(point[i],point[j]) < d) continue;
+                for(int k=j+1; k<pnum; ++k){
+                    if(DIS(point[i],point[k]) >= d &&
+                            DIS(point[j],point[k]) >= d){
+                        flag = true;
+                        break;
+                    }
+                }
+                if(flag) break;
+            }
+            if(flag) break;
+        }
+        if(flag == false) break;
+        ++d;
+        while(q < pnum && point[q].dis < d){
+            ++q;
+        }
+    }
+    return d-1;
+}
+int main()
+{
+    int T,cas = 0;
+    scanf("%d",&T);
+    while(T--){
+        ++cas;
+        int ans  = 1;
+        scanf("%d %d",&N,&M);
+        gets(s);
+        for(int i=0; i<N; ++i){
+            gets(s);
+            for(int j=0; j<M; ++j){
+                map[i][j] = (s[j] == '.' ? 0 : 1);
+                a[i][j] = map[i][j];
+            }
+        }
+        ans = solve();
+        printf("Case %d: %d\n",cas,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4544_autoAC.cpp b/HDOJ/4544_autoAC.cpp
new file mode 100644
index 0000000..d685c40
--- /dev/null
+++ b/HDOJ/4544_autoAC.cpp
@@ -0,0 +1,65 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<algorithm>
+#include<iostream>
+#include<queue>
+#include<map>
+#include<vector>
+#include<math.h>
+using namespace std;
+typedef long long ll;
+typedef __int64 int64;
+const int maxn = 2000005;
+const int inf = 0x7fffffff;
+const double pi=acos(-1.0);
+const double eps = 1e-8;
+struct node{
+    int pi,di;
+}a[ maxn ];
+int cmp( node a,node b ){
+    if( a.di!=b.di ) return a.di>b.di;
+    else return a.pi<b.pi;
+}
+int main(){
+    int n,m;
+    while( scanf("%d%d",&n,&m)==2 ){
+        int cnt = 0;
+        for( int i=0;i<n;i++ ){
+            scanf("%d",&a[ i ].di);
+            a[ i ].pi = -1;
+        }
+        cnt = n;
+        for( int i=0;i<m;i++ ){
+            scanf("%d",&a[ cnt ].di);
+            cnt++;
+        }
+        cnt = n;
+        for( int i=0;i<m;i++ ){
+            scanf("%d",&a[ cnt ].pi);
+            cnt++;
+        }
+        sort( a,a+cnt,cmp );
+        __int64 ans = 0;
+        bool flag = true;
+        int kill = 0;
+        priority_queue< int,vector<int>,greater<int> > q;
+        for( int i=0;i<cnt&&kill<n;i++ ){
+            if( a[ i ].pi<0 ){
+                if( q.empty() ){
+                    flag = false;
+                    break;
+                }
+                ans += q.top();
+                q.pop();
+                kill++;
+            }
+            else{
+                q.push( a[ i ].pi );
+            }
+        }
+        if( flag == false ) printf("No\n");
+        else printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4545_autoAC.cpp b/HDOJ/4545_autoAC.cpp
new file mode 100644
index 0000000..c266c0c
--- /dev/null
+++ b/HDOJ/4545_autoAC.cpp
@@ -0,0 +1,65 @@
+#include<stdio.h>
+#include<string.h>
+#define N 1005
+int main()
+{
+    char s1[N],s2[N];
+    int mark[27][27];
+    int i,j;
+    int flag;
+    int T;
+    char x,y;
+    scanf("%d",&T);
+    int count=1;
+    while(T--)
+    {
+        getchar();
+        gets(s1);
+        gets(s2);
+        int n;
+        scanf("%d",&n);
+        memset(mark,0,sizeof(mark));
+        while(n--)
+        {
+            getchar();
+            scanf("%c %c",&x,&y);
+            mark[x-'a'+1][y-'a'+1]=1;
+        }
+        int ln1,ln2;
+        ln1=strlen(s1);
+        ln2=strlen(s2);
+        i=0;
+        j=0;
+        flag=0;
+        for(i=0;i<ln1;i++)
+        {
+            if(j==ln2)
+                break;
+            if(s1[i]==s2[j])
+            {
+                j++;
+                continue;
+            }
+            while(s2[j]!=s1[i])
+            {
+                if(j==ln2)
+                {
+                    flag=1;
+                    break;
+                }
+                if(mark[s2[j]-'a'+1][s1[i]-'a'+1]==1)
+                {
+                    j++;
+                    break;
+                }
+                else 
+                    j++;
+            }
+        }
+        if(!flag)
+            printf("Case #%d: happy\n",count++);
+        else
+            printf("Case #%d: unhappy\n",count++);
+    }
+    return 0;
+}
diff --git a/HDOJ/4546_autoAC.cpp b/HDOJ/4546_autoAC.cpp
new file mode 100644
index 0000000..b5d9f53
--- /dev/null
+++ b/HDOJ/4546_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<algorithm>
+#include<queue>
+using namespace std;
+int n, m;
+const int maxn = 10011;
+struct Node
+{
+    int sum;
+    int nex;
+    int ith;
+    Node(){}
+    Node(int sum_, int nex_, int ith_){sum = sum_, nex = nex_, ith = ith_;}
+    bool operator<(const Node &b)const
+    {return b.nex < nex;}
+};
+int a[maxn];
+int Cal(int m)
+{
+    priority_queue<Node> q;
+    Node lin;
+    lin.sum = 0, lin.nex = a[0], lin.ith = 0;
+    q.push(lin);
+    int cnt = 0;
+    a[n] = 0;
+    while(cnt < m)
+    {
+        lin = q.top(); q.pop();
+        if(lin.ith >= n) continue;
+        q.push(Node(lin.sum, lin.sum + a[lin.ith + 1], lin.ith + 1));
+        q.push(Node(lin.nex, lin.nex + a[lin.ith + 1], lin.ith + 1));
+        cnt += 1;
+    }
+    for(m = 0; !q.empty(); m ++) a[m] = q.top().sum, q.pop();
+    sort(a, a + m);
+    return a[m - 1];
+}
+int main()
+{
+    int i, t, ca;
+    for(scanf("%d", &t), ca = 1; ca <= t; ca ++)
+    {
+        scanf("%d%d", &n, &m);
+        for(i = 0; i < n; i ++)
+            scanf("%d", &a[i]);
+        sort(a, a + n);
+        printf("Case #%d: %d\n", ca, Cal(m));
+    }
+    return 0;
+}
diff --git a/HDOJ/4547_autoAC.cpp b/HDOJ/4547_autoAC.cpp
new file mode 100644
index 0000000..d87b1d7
--- /dev/null
+++ b/HDOJ/4547_autoAC.cpp
@@ -0,0 +1,128 @@
+#include <iostream>
+#include <cstdio>
+#include <string>
+#include <map>
+#include <cstring>
+using namespace std;
+const int MAX_ = 400010;
+map<string,int>mp;
+struct point {
+    int to,next, num;
+} edge[MAX_], qedge[MAX_];
+struct query {
+    int u,v,lca;
+} q[MAX_];
+int V[MAX_], head[MAX_], d[MAX_], fa[MAX_], ind[MAX_];
+bool vis[MAX_];
+int M,L, T;
+int n, m;
+void adde(int from,int to,int c) {
+    edge[M].to = to;
+    edge[M].num = c;
+    edge[M].next = V[from];
+    V[from] = M++;
+}
+void addq(int from,int to,int c) {
+    qedge[L].to = to;
+    qedge[L].num = c;
+    qedge[L].next = head[from];
+    head[from] = L++;
+}
+int find(int x) {
+    if(fa[x] == x)return fa[x];
+    else return fa[x] = find(fa[x]);
+}
+void dfs(int k,int pri,int x) {
+    d[x] = k;
+    for(int i = V[x]; i != -1; i = edge[i].next) {
+        if(edge[i].to != pri) {
+            dfs(k+1,x,edge[i].to);
+        }
+    }
+}
+void tarjan(int x) {
+    fa[x] = x;
+    vis[x] = 1;
+    for(int i = V[x]; i != -1; i = edge[i].next) {
+        if(!vis[edge[i].to]) {
+            tarjan(edge[i].to);
+            fa[edge[i].to] = x;
+        }
+    }
+    for(int i = head[x]; i != -1; i = qedge[i].next) {
+        if(vis[qedge[i].to]) {
+            q[qedge[i].num].lca = find(qedge[i].to);
+        }
+    }
+}
+void solve() {
+    for(int i = 1; i <= n; i++) {
+        if(ind[i] == 0) {
+            dfs(0,-1,i);
+            tarjan(i);
+            break;
+        }
+    }
+}
+int capture(char s[]) {
+    if(mp.find(s) == mp.end()) {
+        return mp[s] = ++T;
+    } else return mp[s];
+}
+void init() {
+    memset(V,-1,sizeof(V));
+    memset(head,-1,sizeof(head));
+    memset(ind,0,sizeof(ind));
+    memset(vis,0,sizeof(vis));
+    M = L = T = 0;
+    mp.clear();
+    for(int i = 0; i <= n; i++) {
+        fa[i] = i;
+    }
+}
+void read() {
+    int s,t;
+    char c1[50],c2[50];
+    for(int i = 1; i < n; i++) {
+        scanf("%s",c1);
+        scanf("%s",c2);
+        t = capture(c1);
+        s = capture(c2);
+        adde(s,t,1);
+        adde(t,s,1);
+        ind[t]++;
+    }
+    for(int i = 0; i < m; i++) {
+        scanf("%s",c1);
+        scanf("%s",c2);
+        t = capture(c1);
+        s = capture(c2);
+        addq(s,t,i);
+        addq(t,s,i);
+        q[i].u = t;
+        q[i].v = s;
+    }
+}
+void print_ans() {
+    for(int i = 0; i < m; i++) {
+        int t;
+        t = d[q[i].u] - d[q[i].lca];
+        if(q[i].v != q[i].lca) {
+            t++;
+        }
+        if(q[i].u == q[i].v) t = 0;
+        printf("%d\n",t);
+    }
+}
+int main() {
+    int Case;
+    scanf("%d",&Case);
+    while(Case--) {
+        scanf("%d%d",&n,&m);
+        init();
+        read();
+        solve();
+        print_ans();
+    }
+    return 0;
+}
diff --git a/HDOJ/4548_autoAC.cpp b/HDOJ/4548_autoAC.cpp
new file mode 100644
index 0000000..abf1214
--- /dev/null
+++ b/HDOJ/4548_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+bool mark[1000010];
+int num[1000010];
+int k;
+int Judge(int n){
+    int ans=0;
+    while(n){
+        ans+=n%10;
+        n/=10;
+    }
+    return ans;
+}
+void IsPrime(){
+    memset(mark,true,sizeof(mark));
+    mark[0]=mark[1]=false;
+    k=0;
+    for(int i=2;i*i<1000000;i++){
+        if(mark[i]){
+            for(int j=i*i;j<1000000;j+=i)
+                mark[j]=false;
+        }
+    }
+    for(int i=2;i<=1000010;i++){
+        if(mark[i]&&mark[Judge(i)]){
+            num[++k]=i;
+        }
+    }
+}
+int Binary_Search(int l,int h,int number){
+    while(l<=h){
+        int mid=(l+h)/2;
+        if(num[mid]==number)return mid;
+        else if(num[mid]>number)h=mid-1;
+        else l=mid+1;
+    }
+    return l;
+}
+int main(){
+    IsPrime();
+    int _case,n,m,t=1;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        int cnt=0;
+        int pos1=Binary_Search(1,k,n);
+        int pos2=Binary_Search(1,k,m);
+        pos1--;
+        if(num[pos2]==m)pos2++;
+        cnt=pos2-pos1-1;
+        printf("Case #%d: %d\n",t++,cnt);
+    }
+    return 0;
+}
diff --git a/HDOJ/4549_autoAC.cpp b/HDOJ/4549_autoAC.cpp
new file mode 100644
index 0000000..c44ce16
--- /dev/null
+++ b/HDOJ/4549_autoAC.cpp
@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+using namespace std;
+const int MOD=1e9+7;
+struct Matrix
+{
+    long long mat[2][2];
+};
+Matrix mul(Matrix a,Matrix b)
+{
+    Matrix ret;
+    for(int i=0;i<2;i++)
+        for(int j=0;j<2;j++)
+        {
+            ret.mat[i][j]=0;
+            for(int k=0;k<2;k++)
+            {
+                ret.mat[i][j]+=a.mat[i][k]*b.mat[k][j];
+                ret.mat[i][j]%=(MOD-1);
+            }
+        }
+    return ret;
+}
+Matrix pow_M(Matrix a,int n)
+{
+    Matrix ret;
+    memset(ret.mat,0,sizeof(ret.mat));
+    ret.mat[0][0]=ret.mat[1][1]=1;
+    Matrix temp=a;
+    while(n)
+    {
+        if(n&1)ret=mul(ret,temp);
+        temp=mul(temp,temp);
+        n>>=1;
+    }
+    return ret;
+}
+long long pow_m(long long a,long long n)
+{
+    long long ret=1;
+    long long temp=a%MOD;
+    while(n)
+    {
+        if(n&1)
+        {
+            ret*=temp;
+            ret%=MOD;
+        }
+        temp*=temp;
+        temp%=MOD;
+        n>>=1;
+    }
+    return ret;
+}
+int main()
+{
+    int a,b,n;
+    Matrix tmp;
+    tmp.mat[0][0]=0;
+    tmp.mat[0][1]=tmp.mat[1][0]=tmp.mat[1][1]=1;
+    while(scanf("%d%d%d",&a,&b,&n)==3)
+    {
+        Matrix p=pow_M(tmp,n);
+        int ans=(pow_m(a,p.mat[0][0])*pow_m(b,p.mat[1][0]))%MOD;
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4550_autoAC.cpp b/HDOJ/4550_autoAC.cpp
new file mode 100644
index 0000000..7d6cc1c
--- /dev/null
+++ b/HDOJ/4550_autoAC.cpp
@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <algorithm>
+#include <string.h>
+#include <iostream>
+using namespace std;
+const int MAXN=110;
+char str[MAXN];
+char sta1[MAXN],sta2[MAXN];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%s",&str);
+        int n=strlen(str);
+        int t1=0,t2=0;
+        int t=n-1;
+        while(t>0 && str[t]=='0')t--;
+        for(int i=t;i>=0;i--)
+            if(str[i]!='0'&&str[i]<str[t])
+                t=i;
+        sta1[t1++]=str[t];
+        for(int i=n-1;i>t;i--)sta2[t2++]=str[i];
+        while(t1+t2<n && t>0)
+        {
+            int tmp=t-1;
+            for(int j=tmp-1;j>=0;j--)
+                if(str[j]<str[tmp])
+                    tmp=j;
+            sta1[t1++]=str[tmp];
+            for(int i=t-1;i>tmp;i--)sta2[t2++]=str[i];
+            t=tmp;
+        }
+        for(int i=0;i<t1;i++)printf("%c",sta1[i]);
+        for(int i=t2-1;i>=0;i--)printf("%c",sta2[i]);
+        printf("\n");
+    }
+}
diff --git a/HDOJ/4551_autoAC.cpp b/HDOJ/4551_autoAC.cpp
new file mode 100644
index 0000000..dc8eaf1
--- /dev/null
+++ b/HDOJ/4551_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+#include <stdio.h>
+using namespace std;
+int gcd(int a,int b)
+{
+    if(b==0) return a;
+    return gcd(b,a%b);
+}
+bool run_year(int z)
+{
+    if((z%4==0&&z%100!=0)||(z%400==0))
+        return true;
+    else
+        return false;
+}
+int month[]={0,31,29,31,30,31,30,31,31,30,31,30,31};
+int main()
+{
+   int T,num=0;
+   scanf("%d",&T);
+   while(T--)
+   {
+       num++;
+       int x,y,z;
+       int fx,fy;
+       int a,b;
+       scanf("%d%d%d",&a,&b,&z);
+       int ans=0;
+       for(x=1;x<=12;x++)
+       {
+           for(y=1;y<=month[x];y++)
+           {
+               int g=gcd(x,y);
+               if(a==g&&(b==(x*y)/g))
+               {
+                   if(x==2&&y==29&&!run_year(z)) continue;
+                   ans++;
+                   fx=x;fy=y;
+               }
+           }
+       }
+       if(ans==0) printf("Case #%d: -1\n",num);
+       else if(ans==1)  printf("Case #%d: %04d/%02d/%02d\n",num,z,fx,fy);
+       else
+          printf("Case #%d: 1\n",num);
+   }
+    return 0;
+}
diff --git a/HDOJ/4553_autoAC.cpp b/HDOJ/4553_autoAC.cpp
new file mode 100644
index 0000000..928e48d
--- /dev/null
+++ b/HDOJ/4553_autoAC.cpp
@@ -0,0 +1,196 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+const int L = 100000+10;
+struct node
+{
+    int d,n,s;
+    int ls,rs,ms;
+    int nsl,nsr,nsm;
+} a[L<<2];
+void diaosi(int l,int r,int i)
+{
+    a[i].d = 1;
+    a[i].ls = a[i].rs = a[i].ms = 0;
+}
+void nvshen(int l,int r,int i)
+{
+    a[i].n = 1;
+    a[i].d = 0;
+    a[i].ls = a[i].rs = a[i].ms = 0;
+    a[i].nsl = a[i].nsr = a[i].nsm = 0;
+}
+void xuexi(int l,int r,int i)
+{
+    a[i].s = 1;
+    a[i].d = a[i].n = 0;
+    a[i].ls = a[i].rs = a[i].ms = r-l+1;
+    a[i].nsl = a[i].nsr = a[i].nsm = r-l+1;
+}
+void pushup(int l,int r,int i)
+{
+    int mid = (l+r)>>1;
+    a[i].ms = max(a[2*i].ms,a[2*i+1].ms);
+    a[i].ms = max(a[i].ms,a[2*i].rs+a[2*i+1].ls);
+    a[i].ls = a[2*i].ls;
+    a[i].rs = a[2*i+1].rs;
+    if(a[2*i].ls == mid-l+1)
+        a[i].ls+=a[2*i+1].ls;
+    if(a[2*i+1].rs == r-mid)
+        a[i].rs+= a[2*i].rs;
+    a[i].nsm = max(a[2*i].nsm,a[2*i+1].nsm);
+    a[i].nsm = max(a[i].nsm,a[2*i].nsr+a[2*i+1].nsl);
+    a[i].nsl = a[2*i].nsl;
+    a[i].nsr = a[2*i+1].nsr;
+    if(a[2*i].nsl == mid-l+1)
+        a[i].nsl+=a[2*i+1].nsl;
+    if(a[2*i+1].nsr == r-mid)
+        a[i].nsr+= a[2*i].nsr;
+}
+void pushdown(int l,int r,int i)
+{
+    int mid = (l+r)>>1;
+    if(a[i].s)
+    {
+        xuexi(l,mid,2*i);
+        xuexi(mid+1,r,2*i+1);
+        a[i].s = 0;
+    }
+    if(a[i].d)
+    {
+        diaosi(l,mid,2*i);
+        diaosi(mid+1,r,2*i+1);
+        a[i].d = 0;
+    }
+    if(a[i].n)
+    {
+        nvshen(l,mid,2*i);
+        nvshen(mid+1,r,2*i+1);
+        a[i].n = 0;
+    }
+}
+void study(int L,int R,int l,int r,int i)
+{
+    if(L == l && R == r)
+    {
+        xuexi(l,r,i);
+        return ;
+    }
+    int mid  = (l+r)>>1;
+    pushdown(l,r,i);
+    if(R<=mid)
+        study(L,R,l,mid,2*i);
+    else if(L>mid)
+        study(L,R,mid+1,r,2*i+1);
+    else
+    {
+        study(L,mid,l,mid,2*i);
+        study(mid+1,R,mid+1,r,2*i+1);
+    }
+    pushup(l,r,i);
+}
+void insert(int flag,int L,int R,int l,int r,int i)
+{
+    if(l == L && r == R)
+    {
+        if(!flag)
+            diaosi(l,r,i);
+        else
+            nvshen(l,r,i);
+        return ;
+    }
+    int mid  = (l+r)>>1;
+    pushdown(l,r,i);
+    if(R<=mid)
+        insert(flag,L,R,l,mid,2*i);
+    else if(L>mid)
+        insert(flag,L,R,mid+1,r,2*i+1);
+    else
+    {
+        insert(flag,L,mid,l,mid,2*i);
+        insert(flag,mid+1,R,mid+1,r,2*i+1);
+    }
+    pushup(l,r,i);
+}
+int query(int flag,int t,int l,int r,int i)
+{
+    if(l==r)
+        return l;
+    int mid = (l+r)>>1;
+    pushdown(l,r,i);
+    if(!flag)
+    {
+        if(a[2*i].ms>=t)
+            return query(flag,t,l,mid,2*i);
+        else if(a[2*i].rs+a[2*i+1].ls>=t)
+            return mid-a[2*i].rs+1;
+        else
+            return query(flag,t,mid+1,r,2*i+1);
+    }
+    else
+    {
+        if(a[2*i].nsm>=t)
+            return query(flag,t,l,mid,2*i);
+        else if(a[2*i].nsr+a[2*i+1].nsl>=t)
+            return mid-a[2*i].nsr+1;
+        else
+            return query(flag,t,mid+1,r,2*i+1);
+    }
+}
+int main()
+{
+    int t,i,x,y,ans,cas = 1,n,m;
+    char str[20];
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&m);
+        printf("Case %d:\n",cas++);
+        study(1,n,1,n,1);
+        while(m--)
+        {
+            scanf("%s",str);
+            if(str[0] == 'D')
+            {
+                scanf("%d",&x);
+                if(a[1].ms<x)
+                    printf("fly with yourself\n");
+                else
+                {
+                    ans = query(0,x,1,n,1);
+                    insert(0,ans,ans+x-1,1,n,1);
+                    printf("%d,let's fly\n",ans);
+                }
+            }
+            else if(str[0] == 'N')
+            {
+                scanf("%d",&x);
+                if(a[1].ms<x)
+                {
+                    if(a[1].nsm<x)
+                        printf("wait for me\n");
+                    else
+                    {
+                        ans = query(1,x,1,n,1);
+                        insert(1,ans,ans+x-1,1,n,1);
+                        printf("%d,don't put my gezi\n",ans);
+                    }
+                }
+                else
+                {
+                    ans = query(0,x,1,n,1);
+                    insert(1,ans,ans+x-1,1,n,1);
+                    printf("%d,don't put my gezi\n",ans);
+                }
+            }
+            else
+            {
+                scanf("%d%d",&x,&y);
+                study(x,y,1,n,1);
+                printf("I am the hope of chinese chengxuyuan!!\n");
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4554_autoAC.cpp b/HDOJ/4554_autoAC.cpp
new file mode 100644
index 0000000..e904a73
--- /dev/null
+++ b/HDOJ/4554_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<cstdlib>
+using namespace std;
+int numa[11],numb[11];
+int main()
+{
+    int T,a,b;
+    scanf("%d",&T);
+    while(T--)
+    {
+    scanf("%d%d",&a,&b);
+    int x=(a+b)/2;
+    int y=a-x;
+    int coua=0,coub=0;
+    int ita=abs(x);
+    int itb=abs(y);
+    while(ita)
+    {
+        numa[coua++]=ita%10;
+        ita/=10;
+    }
+    while(itb)
+    {
+        numb[coub++]=itb%10;
+        itb/=10;
+    }
+    int xx=0,yy=0;
+    for(int i=0;i<coua;i++)
+        xx=xx*10+numa[i];
+    for(int i=0;i<coub;i++)
+        yy=yy*10+numb[i];
+    if(x<0)
+        xx=-xx;
+    if(y<0)
+        yy=-yy;
+    printf("%d %d\n",xx+yy,xx-yy);
+    }
+    return 0;
+}
diff --git a/HDOJ/4556_autoAC.cpp b/HDOJ/4556_autoAC.cpp
new file mode 100644
index 0000000..84f7714
--- /dev/null
+++ b/HDOJ/4556_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std;
+const int maxn=1000011;
+int n;
+long long ans[maxn],phi[maxn];
+void Phi(int n)
+{
+    phi[1]=1;
+    for(int i=2;i<=n;i++)
+    if(!phi[i])
+        for(int j=i;j<=n;j+=i)
+        {
+        if(!phi[j])
+            phi[j]=j;
+        phi[j]=phi[j]/i*(i-1);
+        }
+}
+int main()
+{
+    Phi(maxn-1);
+    ans[1]=2;
+    ans[2]=3;
+    for(int i=3;i<maxn;i++)
+    ans[i]=ans[i-1]+phi[i];
+    while(scanf("%d",&n)!=EOF)
+    {
+    long long s=(ans[n]-2)*2+3;
+    printf("%I64d\n",s);
+    }
+    return 0;
+}
diff --git a/HDOJ/4557_autoAC.cpp b/HDOJ/4557_autoAC.cpp
new file mode 100644
index 0000000..b171041
--- /dev/null
+++ b/HDOJ/4557_autoAC.cpp
@@ -0,0 +1,60 @@
+#include<iostream>
+#include<list>
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+struct node
+{
+    string name;
+    int grade;
+    int time;
+    node(string s,int a,int b):name(s),grade(a),time(b){}
+    friend bool operator<(const node& a,const node& b)
+    {
+        if(a.grade!=b.grade)
+        return a.grade<b.grade;
+        else return a.time<b.time;
+    }
+    friend bool operator==(const node& a,const node& b)
+    {
+        return a.grade>=b.grade;
+    }
+};
+int main()
+{
+    int cas,n,num;
+    cin>>cas;
+    string op,name;
+    int time;
+    for(int c=1;c<=cas;c++)
+    {
+        cin>>n;printf("Case #%d:\n",c);
+        list<node>li;
+        time=1;
+        for(int i=0;i<n;i++)
+        {
+            cin>>op;
+            if(op[0]=='A')
+            {
+                cin>>name>>num;
+                li.push_back(node(name,num,i));
+                li.sort();
+                cout<<li.size()<<endl;
+            }
+            else
+            {
+                cin>>num;
+                list<node>::iterator iter=find(li.begin(),li.end(),node("",num,0));
+                if(iter!=li.end())
+                {
+                    cout<<iter->name<<endl;
+                    li.erase(iter);
+                }
+                else
+                {
+                    cout<<"WAIT..."<<endl;
+                }
+            }
+        }
+    }
+}
diff --git a/HDOJ/4558_autoAC.cpp b/HDOJ/4558_autoAC.cpp
new file mode 100644
index 0000000..98f1bb4
--- /dev/null
+++ b/HDOJ/4558_autoAC.cpp
@@ -0,0 +1,50 @@
+#include<iostream>
+#include<cstdio>
+#include<math.h>
+#include<cstring>
+#define MP make_pair
+#define SQ(x) ((x)*(x))
+typedef long long int64;
+const double PI = acos(-1.0);
+const int MAXN = 110;
+const int INF = 0x3f3f3f3f;
+using namespace std;
+const int MOD = 1000000007;
+int n, m;
+int f[2][480][22][2];
+int mat[480][480];
+char str[1000];
+int main(){
+    int nCase, cas=1;
+    scanf("%d", &nCase);
+    while(nCase--){
+        scanf("%d%d%*c", &n, &m);
+        for(int i=1; i<=n; ++i){
+            gets(str);
+            for(int j=1; j<=m; ++j)
+                mat[i][j] = str[j-1]-'0';
+        }
+        memset(f, 0, sizeof(f));
+        int ans = 0;
+        bool p = 0;
+        for(int i=1; i<=n; ++i){
+            p = !p;
+            memset(f[p], 0, sizeof(f[p]));
+            for(int j=1; j<=m; ++j){
+                for(int k=0; k<=10; ++k){
+                    int x1 = (k+mat[i][j])%11;
+                    int x2 = (k-mat[i][j]+11)%11;
+                    f[p][j][k][0] += ((f[!p][j][x1][1]+f[p][j-1][x1][1])%MOD)%MOD;
+                    f[p][j][k][1] += ((f[!p][j][x2][0]+f[p][j-1][x2][0])%MOD)%MOD;
+                }
+                ++f[p][j][11-mat[i][j]][0]; 
+            }
+            for(int j=1; j<=m; ++j){
+                ans += (f[p][j][0][0] + f[p][j][0][1])%MOD;
+                ans %= MOD;
+            }
+        }
+        printf("Case %d: %d\n",cas++, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4559_autoAC.cpp b/HDOJ/4559_autoAC.cpp
new file mode 100644
index 0000000..85177e3
--- /dev/null
+++ b/HDOJ/4559_autoAC.cpp
@@ -0,0 +1,54 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+#include<iomanip>
+#include<cmath>
+#include<cstring>
+#include<vector>
+#define ll __int64
+#define pi acos(-1.0)
+#define MAX 5000
+using namespace std;
+int an[2][MAX],sg[MAX];
+bool vis[MAX];
+int getsg(int x)
+{
+    int i;
+    if(sg[x]>=0) return sg[x];
+    memset(vis,0,sizeof(vis));
+    for(i=0;i<=x-i-1;i++)
+        vis[getsg(i)^getsg(x-i-1)^1]=1;
+    for(i=0;i<=x-i-2;i++)
+        vis[getsg(i)^getsg(x-i-2)]=1;
+    i=0;
+    while(vis[i]) i++;
+    return sg[x]=i;
+}
+int main(){
+    int t,m,n,s,c,ans,i,k=0,len;
+    memset(sg,-1,sizeof(sg));
+    sg[0]=0;
+    for(i=1;i<=4747;i++) sg[i]=getsg(i);
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d %d",&n,&m);
+        memset(an,0,sizeof(an));
+        for(i=0;i<m;i++){
+            scanf("%d %d",&s,&c);
+            an[s-1][c-1]=1;
+        }
+        ans=0;len=0;
+        for(i=0;i<n;i++){
+            if(an[0][i]||an[1][i]){
+                ans^=sg[len];
+                ans^=an[0][i];
+                ans^=an[1][i];
+                len=0;
+            }
+            else len++;
+        }
+        ans^=sg[len];
+        printf("Case %d: %s\n",++k,ans?"Alice":"Bob");
+    }
+    return 0;
+}
diff --git a/HDOJ/4560_autoAC.cpp b/HDOJ/4560_autoAC.cpp
new file mode 100644
index 0000000..9dc0354
--- /dev/null
+++ b/HDOJ/4560_autoAC.cpp
@@ -0,0 +1,104 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <queue>
+#include <vector>
+#include <map>
+#include <set>
+#include <string>
+#include <math.h>
+using namespace std;
+const int MAXN=1100;
+int maze[MAXN][MAXN];
+int gap[MAXN],dis[MAXN],pre[MAXN],cur[MAXN];
+int flow[MAXN][MAXN];
+int sap(int start,int end,int nodenum)
+{
+    memset(cur,0,sizeof(cur));
+    memset(dis,0,sizeof(dis));
+    memset(gap,0,sizeof(gap));
+    memset(flow,0,sizeof(flow));
+    int u=pre[start]=start,maxflow=0,aug=-1;
+    gap[0]=nodenum;
+    while(dis[start]<nodenum)
+    {
+        loop:
+          for(int v=cur[u];v<nodenum;v++)
+            if(maze[u][v]-flow[u][v] && dis[u]==dis[v]+1)
+            {
+                if(aug==-1 || aug>maze[u][v]-flow[u][v])aug=maze[u][v]-flow[u][v];
+                pre[v]=u;
+                u=cur[u]=v;
+                if(v==end)
+                {
+                    maxflow+=aug;
+                    for(u=pre[u];v!=start;v=u,u=pre[u])
+                    {
+                        flow[u][v]+=aug;
+                        flow[v][u]-=aug;
+                    }
+                    aug=-1;
+                }
+                goto loop;
+            }
+            int mindis=nodenum-1;
+            for(int v=0;v<nodenum;v++)
+               if(maze[u][v]-flow[u][v]&&mindis>dis[v])
+               {
+                   cur[u]=v;
+                   mindis=dis[v];
+               }
+            if((--gap[dis[u]])==0)break;
+            gap[dis[u]=mindis+1]++;
+            u=pre[u];
+    }
+    return maxflow;
+}
+bool used[MAXN][MAXN];
+int main()
+{
+    int T;
+    int N,M,L,K;
+    scanf("%d",&T);
+    int iCase=0;
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d%d%d",&N,&M,&L,&K);
+        memset(maze,0,sizeof(maze));
+        int u,v;
+        memset(used,false,sizeof(used));
+        while(L--)
+        {
+            scanf("%d%d",&u,&v);
+            used[u][v]=true;
+        }
+        for(int i=N+1;i<=N+M;i++)maze[i][i+M]=K;
+        for(int i=1;i<=N;i++)
+            for(int j=1;j<=M;j++)
+            {
+                if(used[i][j])
+                {
+                    maze[i][j+N+M]=1;
+                }
+                else maze[i][j+N]=1;
+            }
+        int ans=0;
+        int l=0,r=M;
+        while(l<=r)
+        {
+            int mid=(l+r)/2;
+            for(int i=1;i<=N;i++)maze[0][i]=mid;
+            for(int i=N+M+1;i<=N+2*M;i++)maze[i][N+2*M+1]=mid;
+            if(sap(0,N+2*M+1,N+2*M+2)==mid*N)
+            {
+                ans=mid;
+                l=mid+1;
+            }
+            else r=mid-1;
+        }
+        printf("Case %d: %d\n",iCase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4561_autoAC.cpp b/HDOJ/4561_autoAC.cpp
new file mode 100644
index 0000000..41a7ebc
--- /dev/null
+++ b/HDOJ/4561_autoAC.cpp
@@ -0,0 +1,72 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+int tCase,n,a[10000+1];
+int num[10000+1];
+int z,f,o;
+int solve(int s,int t)
+{
+    f=0;
+    for(int i=s;i<t;i++)
+    {
+        if(a[i]<0) f++;
+    }
+    if(f%2==0)
+    {
+        return t-s;
+    }
+    else
+    {
+        int ans=0,tag1=s-1,tag2=t,a1,a2,a3,a4,m=t-s;
+        for(int i=s;i<t;i++)
+        {
+            if(a[i]<0)
+            {
+                tag1=i;
+                break;
+            }
+        }
+        a1=m-(tag1-s+1);
+        a3=tag1-s;
+        if(a1<a3) a1=a3;
+        for(int i=t-1;i>=s;i--)
+        {
+            if(a[i]<0)
+            {
+                tag2=i;
+                break;
+            }
+        }
+        a2=tag2-s;
+        a4=t-1-tag2;
+        if(a2<a4) a2=a4;
+        ans=max(ans,max(a1,a2));
+        return ans;
+    }
+}
+int main()
+{
+    scanf("%d",&tCase);
+    for(int i=1;i<=tCase;i++)
+    {
+        scanf("%d",&n);
+        o=0;
+        for(int j=1;j<=n;j++)
+        {
+            scanf("%d",&a[j]);
+            if(a[j]==0)
+            num[o++]=j;
+        }
+        num[o++]=n+1;
+        int t=1;
+        int ans=0;
+        for(int j=0;j<o;j++)
+        {
+            ans=max(ans,solve(t,num[j]));
+            t=num[j]+1;
+        }
+        printf("Case #%d: %d\n",i,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4562_autoAC.cpp b/HDOJ/4562_autoAC.cpp
new file mode 100644
index 0000000..3299c45
--- /dev/null
+++ b/HDOJ/4562_autoAC.cpp
@@ -0,0 +1,99 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <map>
+#include <vector>
+#include <set>
+#include <queue>
+#include <string>
+#include <math.h>
+using namespace std;
+const int MAXN=1010;
+struct Node
+{
+    int x,y;
+    int r;
+};
+bool cmp(Node a,Node b)
+{
+    return a.r<b.r;
+}
+int dis2(Node a,Node b)
+{
+    return ((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+Node node[MAXN];
+Node node1[MAXN];
+Node node2[MAXN];
+int dp1[MAXN];
+int dp2[MAXN];
+int main()
+{
+    int T;
+    int n;
+    int iCase=0;
+    Node st;
+    st.x=0;st.y=0;
+    Node ed;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        printf("Case %d: ",iCase);
+        scanf("%d",&n);
+        scanf("%d%d",&ed.x,&ed.y);
+        int t1=0;
+        int t2=0;
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d%d%d",&node[i].x,&node[i].y,&node[i].r);
+            int d1=dis2(st,node[i]);
+            int d2=dis2(ed,node[i]);
+            if(d1==node[i].r*node[i].r||d2==node[i].r*node[i].r)
+                continue;
+            if(d1<node[i].r*node[i].r&&d2<node[i].r*node[i].r)continue;
+            if(d1>node[i].r*node[i].r&&d2>node[i].r*node[i].r)continue;
+            if(d1<node[i].r*node[i].r)
+            {
+                node1[t1++]=node[i];
+            }
+            else node2[t2++]=node[i];
+        }
+        sort(node1,node1+t1,cmp);
+        sort(node2,node2+t2,cmp);
+        int ans1=0,ans2=0;
+        for(int i=0;i<t1;i++)
+        {
+            dp1[i]=1;
+            for(int j=0;j<i;j++)
+            {
+                int d=dis2(node1[i],node1[j]);
+                if(node1[i].r>node1[j].r && d<(node1[i].r-node1[j].r)*(node1[i].r-node1[j].r))
+                    dp1[i]=max(dp1[i],dp1[j]+1);
+            }
+            ans1=max(ans1,dp1[i]);
+        }
+        for(int i=0;i<t2;i++)
+        {
+            dp2[i]=1;
+            for(int j=0;j<i;j++)
+            {
+                int d=dis2(node2[i],node2[j]);
+                if( node2[i].r>node2[j].r && d<(node2[i].r-node2[j].r)*(node2[i].r-node2[j].r))
+                    dp2[i]=max(dp2[i],dp2[j]+1);
+            }
+            ans2=max(ans2,dp2[i]);
+        }
+        int ans=max(ans1,ans2);
+        for(int i=0;i<t1;i++)
+            for(int j=0;j<t2;j++)
+            {
+                int d1=dis2(node1[i],node2[j]);
+                if(d1>(node1[i].r+node2[j].r)*(node1[i].r+node2[j].r))
+                    ans=max(ans,dp1[i]+dp2[j]);
+            }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4563_autoAC.cpp b/HDOJ/4563_autoAC.cpp
new file mode 100644
index 0000000..739bc8e
--- /dev/null
+++ b/HDOJ/4563_autoAC.cpp
@@ -0,0 +1,72 @@
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <vector>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <list>
+#include <set>
+#include <map>
+using namespace std;
+#define N  100010
+#define E  100010
+#define ll long long
+const int INF   =0x3fffffff;
+const int PRIME =999983;
+const int MOD   =1000000007;
+const int MULTI =1000000007;
+const double EPS=1e-8;
+#define CUBE(x) ((x)*(x)*(x))
+#define SQ(x)     ((x)*(x))
+#define ALL(x)     x.begin(),x.end()
+#define CLR(x,a) memset(x,a,sizeof(x))
+#define maxAry(a,n) max_element(a,a+(n))
+#define minAry(a,n) min_element(a,a+(n))
+inline bool isodd(int x){return x&1;}
+inline bool isodd(ll x) {return x&1;}
+double dp[110];
+int vx[110],vy[110];
+int n,L;
+double gao(int x)
+{
+    fill(dp,dp+L+1,-1);
+    dp[0]=0;
+    for(int i=0;i<n;i++){
+        if(i==x) continue;
+        for(int j=L;j>=0;j--){
+            for(int k=0;k<=100;k++){
+                if(j-vx[i]*k<0 || dp[j-vx[i]*k]==-1) continue;
+                if(dp[j]==-1) dp[j]=dp[j-vx[i]*k]+vy[i]*k-0.5*9.8*SQ(k);
+                else dp[j]=max(dp[j],dp[j-vx[i]*k]+vy[i]*k-0.5*9.8*SQ(k));
+            }
+        }
+    }
+    double ans=-INF;
+    for(int i=0;i<=L;i++){
+        if(dp[i]==-1) continue;
+        double t=1.0*(L-i)/vx[x];
+        ans=max(ans,dp[i]+vy[x]*t-0.5*9.8*SQ(t));
+    }
+    return ans;
+}
+int main()
+{
+    int re,Case=1;
+    double ans;
+    scanf("%d",&re);
+    while(re--){
+        scanf("%d%d",&n,&L);
+        for(int i=0;i<n;i++)
+            scanf("%d%d",&vx[i],&vy[i]);
+        ans=-INF;
+        for(int i=0;i<n;i++)
+            ans=max(ans,gao(i));
+        printf("Case %d: %.3lf\n",Case++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4565_autoAC.cpp b/HDOJ/4565_autoAC.cpp
new file mode 100644
index 0000000..14e2852
--- /dev/null
+++ b/HDOJ/4565_autoAC.cpp
@@ -0,0 +1,24 @@
+#include <cstdio>
+typedef long long llg;
+llg a,b,n,m;
+void solve(){
+    llg ans1(1),ans2(0),t1(a),t2(1);
+    llg tmp;
+    while(n){
+        if(n&1){
+            tmp = ans1;
+            ans1 = (ans1*t1+ans2*t2*b)%m;
+            ans2 = (tmp*t2+ans2*t1)%m;
+        }
+        tmp = t1;
+        t1 = (t1*t1+t2*t2*b)%m;
+        t2 = 2*tmp*t2%m;
+        n >>= 1;
+    }
+    printf("%lld\n",ans1*2%m);
+}
+int main(){
+    while(~scanf("%lld%lld%lld%lld",&a,&b,&n,&m))
+        solve();
+    return 0;
+}
diff --git a/HDOJ/4566_autoAC.cpp b/HDOJ/4566_autoAC.cpp
new file mode 100644
index 0000000..c98fa73
--- /dev/null
+++ b/HDOJ/4566_autoAC.cpp
@@ -0,0 +1,106 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <bitset>
+#include <vector>
+#include <ctime>
+using namespace std;
+typedef long long LL;
+const int N = 100000;
+const int M = 50;
+const LL MAXS = 1LL<<50;
+const LL MAXT = (LL)1e16;
+inline LL two( int x ) { return 1LL<<x; }
+LL  f[M+1][N+5], g[M+1][N+5], a[N+5];
+int ran[2][2][N+5];
+int n , m;
+LL  s;
+void solve( LL t , LL &ans1, LL &ans2) {
+   fill( f[0], f[0]+n+1, 0 );
+   fill( g[0], g[0]+n+1, 0 );
+   f[0][0] = 1;
+   int bits[55], bitt[55];
+   for( int i = 0 ; i < m; ++i ) {
+        bits[i] = (s&two(i))>0;
+        bitt[i] = (t&two(i))>0;
+   }
+   ran[0][0][0] = n;
+   ran[0][1][0] = 0;
+   for( int i = 1; i <= n; ++i ) {
+        ran[0][0][i] = i-1;
+   }
+   for( int i = 1; i <= m; ++i ) {
+        int cur = i&1, pre = cur^1 ;
+        fill( f[i], f[i]+n+1, 0 );
+        fill( g[i], g[i]+n+1, 0 );
+        for( int j = 0 ; j < 2; ++j ) ran[cur][j][0] = 0;
+        for( int j = 1 ; j >= 0; --j ) {
+             for( int k = 1 ; k <= ran[pre][j][0]; ++k ) {
+                  int idx = ran[pre][j][k];
+                  if( a[idx] & two(i-1) ) ran[cur][1][ ++ran[cur][1][0] ] = idx ;
+                  else ran[cur][0][ ++ran[cur][0][0] ] = idx ;
+             }
+        }
+        int oneCnt = 0, curOnes = ran[cur][1][0], curZeros = ran[cur][0][0];
+        for( int j = 0; j <= n; ++j ) {
+             int idx = -1, presize1 = ran[pre][1][0];
+             if( j > presize1 ) {
+                 idx = ran[pre][0][j-presize1];
+             } else {
+                  if( j > 0 ) idx = ran[pre][1][j];
+             }
+             if( idx != -1 && (a[idx]&two(i-1)) != 0 ) {
+                 ++oneCnt;
+             }
+             int tBit = bitt[i-1];
+             int curOne = curOnes + j - 2*oneCnt;
+             if( (curOne&1) == bits[i-1] ) {
+                 if( tBit == 0 ) {
+                     f[i][ oneCnt ] += f[i-1][j];
+                     g[i][ oneCnt ] += g[i-1][j];
+                 } else {  
+                     f[i][ oneCnt ] += f[i-1][j]+g[i-1][j];
+                 }
+             }
+             curOne = curZeros - j + 2*oneCnt;
+             int nextOne = j + curOnes - oneCnt;
+             if( (curOne&1) == bits[i-1] ) {
+                 if( tBit == 0 ) {
+                     g[i][ nextOne ] += g[i-1][j] + f[i-1][j];
+                 } else {
+                     f[i][ nextOne] += f[i-1][j];
+                     g[i][ nextOne] += g[i-1][j];
+                 }
+             }
+        }
+   }
+   ans1 = ans2 = 0;
+   for( int i = 0 ; i <= n; ++i ) {
+        ans1 += f[m][i];
+        ans2 += g[m][i];
+   }
+   ans2 += ans1;
+   return ;
+}
+int main() {
+    LL  t;
+    int start = clock();
+    while( scanf("%d%d%lld%lld",&n,&m,&s,&t) != EOF ) {
+           if( t > MAXT ) {
+               cerr<<t<<" "<<MAXT<<endl;
+           }
+           LL x = 0;
+           for( int i = 0 ; i < n; ++i ) {
+                scanf("%lld",&a[i]);
+                x ^= a[i];
+           }
+           LL M = 1LL << m, loops = t/M;
+           LL ans1, ans2;
+           solve( t%M ,ans1, ans2);
+           loops *= ans2;
+           loops += ans1;
+           if( x == s ) loops--;
+           printf("%lld\n", loops);
+    }
+    return 0;
+}
diff --git a/HDOJ/4567_autoAC.cpp b/HDOJ/4567_autoAC.cpp
new file mode 100644
index 0000000..bc96f0d
--- /dev/null
+++ b/HDOJ/4567_autoAC.cpp
@@ -0,0 +1,34 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+#include<cstring>
+#include<algorithm>
+#include<string>
+using namespace std;
+__int64 l[1000005],v[1000005],r;
+int main()
+{
+    __int64 n,i,j,k,b;
+    int t=0;
+    while(~scanf("%I64d",&n))
+    {
+        t++;
+        if(t>=40) continue;
+        memset(l,0,sizeof l);
+        for(i=1;i<=n;i++)
+        {
+            scanf("%I64d",&v[i]);
+            l[i]=l[i-1]+v[i]+1;
+            if(l[i-1]<=v[i]) k=i;
+        }
+        for(i=k+1,r=0,b=0;i<=n;i++)
+        {
+            b+=(v[i]<=b);
+            r+=max(0ll,v[i]-b);
+        }
+        if((r+l[k-1])==v[k]) printf("%I64d\n",k);
+        else if((r+l[k-1])>v[k]) printf("Unknown\n");
+        else printf("Bad Rescue\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4568_autoAC.cpp b/HDOJ/4568_autoAC.cpp
new file mode 100644
index 0000000..c531a25
--- /dev/null
+++ b/HDOJ/4568_autoAC.cpp
@@ -0,0 +1,92 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<queue>
+using namespace std;
+#define MAXN 222
+#define inf 1<<30
+struct Point{
+    int x,y;
+}point[MAXN];
+int value[MAXN][MAXN];
+int map[MAXN][MAXN];
+int dist[MAXN][MAXN];
+int dd[MAXN];
+bool mark[MAXN][MAXN];
+int dp[1<<14][14];
+int n,m,k;
+int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
+void spfa(int num)
+{
+    memset(mark,false,sizeof(mark));
+    for(int i=0;i<n;i++)
+        for(int j=0;j<m;j++)dist[i][j]=inf;
+    queue<pair<int,int> >que;
+    que.push(make_pair(point[num].x,point[num].y));
+    if(dist[point[num].x][point[num].y]==-1)return;
+    dist[point[num].x][point[num].y]=0;
+    while(!que.empty()){
+        int x=que.front().first,y=que.front().second;
+        que.pop();
+        mark[x][y]=false;
+        if(x==0||x==(n-1)||y==0||y==(m-1)){
+            dd[num]=min(dd[num],dist[x][y]);
+        }
+        for(int i=0;i<4;i++){
+            int xx=x+dir[i][0],yy=y+dir[i][1];
+            if(xx>=0&&xx<n&&yy>=0&&yy<m&&value[xx][yy]!=-1){
+                if(dist[x][y]+value[xx][yy]<dist[xx][yy]){
+                    dist[xx][yy]=dist[x][y]+value[xx][yy];
+                    if(!mark[xx][yy]){
+                        mark[xx][yy]=true;
+                        que.push(make_pair(xx,yy));
+                    }
+                }
+            }
+        }
+    }
+}
+int main()
+{
+    int _case;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        for(int i=0;i<n;i++)
+            for(int j=0;j<m;j++)
+                scanf("%d",&value[i][j]);
+        scanf("%d",&k);
+        for(int i=0;i<k;i++)scanf("%d%d",&point[i].x,&point[i].y);
+        for(int i=0;i<k;i++)
+            for(int j=0;j<k;j++)
+                map[i][j]=(i==j)?0:inf;
+        for(int i=0;i<(1<<k);i++)
+            for(int j=0;j<k;j++)dp[i][j]=inf;
+        fill(dd,dd+MAXN,inf);
+        for(int i=0;i<k;i++){
+            spfa(i);
+            for(int j=0;j<k;j++){
+                if(i==j)continue;
+                map[i][j]=min(map[i][j],dist[point[j].x][point[j].y]);
+            }
+            dp[1<<i][i]=dd[i]+value[point[i].x][point[i].y];
+        }
+        for(int s=0;s<(1<<k);s++){
+            for(int i=0;i<k;i++){
+                if(s&(1<<i)==0)continue;
+                if(dp[s][i]==inf)continue;
+                for(int j=0;j<k;j++){
+                    if(s&(1<<j)==1)continue;
+                    dp[s|(1<<j)][j]=min(dp[s|(1<<j)][j],dp[s][i]+map[i][j]);
+                }
+            }
+        }
+        int ans=inf;
+        for(int i=0;i<k;i++){
+            ans=min(ans,dp[(1<<k)-1][i]+dd[i]);
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4569_autoAC.cpp b/HDOJ/4569_autoAC.cpp
new file mode 100644
index 0000000..f3502d2
--- /dev/null
+++ b/HDOJ/4569_autoAC.cpp
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stack>
+#include <queue>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+int a[5], pri, n;
+__int64 f(int x,int i)
+{
+    int j;
+    __int64 sum=0;
+    for(j=0;j<i;j++){
+        sum = (sum+a[j])*x;
+    }
+    return sum+a[j];
+}
+void solve()
+{
+    int i, j, k;
+    int pri2 = pri*pri;
+    for(i=0;i<pri;i++)
+    {
+        if( (f(i,n))%pri==0 ){
+            for(j=i;j<pri2;j+=pri)
+            {
+                if( f(j,n)%pri2==0 ){
+                    printf("%d\n",j);
+                    return;
+                }
+            }
+        }
+    }
+    printf("No solution!\n");
+}
+int main()
+{
+    int cse;
+    cin>>cse;
+    for(int t=1;t<=cse;t++)
+    {
+        scanf("%d",&n);
+        for(int i=0;i<=n;i++) scanf("%d",&a[i]);
+        scanf("%d",&pri);
+        printf("Case #%d: ",t);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4570_autoAC.cpp b/HDOJ/4570_autoAC.cpp
new file mode 100644
index 0000000..39ef8da
--- /dev/null
+++ b/HDOJ/4570_autoAC.cpp
@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int n;
+__int64 dp[70][70],a[70],sum[70];
+__int64 pow(__int64 n)
+{
+    __int64 ans= 1;
+    int i;
+    for(i = 1; i<=n; i++)
+        ans*=2;
+    return ans;
+}
+int main()
+{
+    int t,i,j,k,s;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        memset(sum,0,sizeof(sum));
+        for(i = 1; i<=n; i++)
+        {
+            scanf("%I64d",&a[i]);
+            sum[i] = sum[i-1]+a[i];
+        }
+        memset(dp,0,sizeof(dp));
+        for(s = 0; s<=n; s++)
+        {
+            for(i = 1; i<=n && i+s<=n; i++)
+            {
+                j = i+s;
+                if(s<=19)
+                    dp[i][j] =a[i]*pow(j-i)*2;
+                else
+                    dp[i][j] = (sum[j]-sum[i-1])*2;
+                for(k = i; k<=j; k++)
+                    dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]);
+            }
+        }
+        printf("%I64d\n",dp[1][n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4571_autoAC.cpp b/HDOJ/4571_autoAC.cpp
new file mode 100644
index 0000000..4841c88
--- /dev/null
+++ b/HDOJ/4571_autoAC.cpp
@@ -0,0 +1,102 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <queue>
+#include <cstring>
+using namespace std;
+const int maxn=110;
+const int oo=0x3fffffff;
+int S[maxn], C[maxn];
+int mp[maxn], visit[maxn][3*maxn];
+int map[maxn][maxn], cap[maxn][maxn], dis[maxn][3*maxn];
+int n, m, V, T, st, sd, ss, dd;
+struct node
+{
+    int u, t;
+};
+void floyd()
+{
+    ss=n, dd=n+1, S[dd]=0;
+    for(int k=0; k<n; k++)
+        for(int i=0; i<n; i++)
+            for(int j=0; j<n; j++)
+                if(map[i][j]>map[i][k]+map[k][j]) map[i][j]=map[i][k]+map[k][j];
+    for(int i=0; i<n; i++)
+        for(int j=i+1; j<n; j++)
+        {
+            if(map[i][j]!=oo)
+            {
+                if(S[i]<S[j]) cap[i][j]=map[i][j]+C[j];
+                if(S[j]<S[i]) cap[j][i]=map[i][j]+C[i];
+            }
+        }
+    cap[ss][st]=C[st];
+    for(int i=0; i<n; i++)
+        if(i!=st&&map[st][i]!=oo) cap[ss][i]=map[st][i]+C[i];
+    for(int i=0; i<n; i++)
+        if(i!=sd&&map[i][sd]!=oo) cap[i][dd]=map[i][sd];
+}
+int spfa()
+{
+    queue<node>q;
+    for(int i=0; i<=n+1; i++)
+        for(int j=0; j<=V; j++) dis[i][j]=-oo, visit[i][j]=0;
+    node s, p;
+    s.u=ss, s.t=0;
+    q.push(s);
+    dis[ss][0]=0;
+    visit[ss][0]=1;
+    while(!q.empty())
+    {
+        p=q.front();
+        q.pop();
+        visit[p.u][p.t]=0;
+        for(int i=0; i<=n+1; i++)
+        {
+            if(p.u!=i&&cap[p.u][i]!=oo)
+            {
+                int tp=p.t+cap[p.u][i];
+                if(tp<=V&&dis[i][tp]<dis[p.u][p.t]+S[i])
+                {
+                    dis[i][tp]=dis[p.u][p.t]+S[i];
+                    s.u=i, s.t=tp;
+                    if(!visit[s.u][s.t]) visit[s.u][s.t]=1,q.push(s);
+                }
+            }
+        }
+    }
+    int maxx=0;
+    for(int i=0; i<=V; i++)
+    {
+        maxx=max(maxx,dis[sd][i]);
+        maxx=max(maxx,dis[dd][i]);
+    }
+    return maxx;
+}
+int main()
+{
+    cin >> T;
+    for(int tcase=1; tcase<=T; tcase++)
+    {
+        scanf("%d%d%d%d%d",&n,&m,&V,&st,&sd);
+        for(int i=0; i<=n+1; i++)
+            for(int j=0; j<=n+1; j++)
+            {
+                  map[i][j]=oo, cap[i][j]=oo;
+                  if(i==j) map[i][j]=cap[i][j]=0;
+            }
+        for(int i=0; i<n; i++) scanf("%d",C+i);
+        for(int i=0; i<n; i++) scanf("%d",S+i);
+        while(m--)
+        {
+            int u, v, val;
+            scanf("%d%d%d",&u,&v,&val);
+            map[u][v]=min(map[u][v],val);
+            map[v][u]=min(map[v][u],val);
+        }
+        floyd();
+        int ans=spfa();
+        printf("Case #%d:\n%d\n",tcase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4572_autoAC.cpp b/HDOJ/4572_autoAC.cpp
new file mode 100644
index 0000000..8b245ed
--- /dev/null
+++ b/HDOJ/4572_autoAC.cpp
@@ -0,0 +1,14 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std;
+int main()
+{
+    int N,M;
+    while(scanf("%d%d",&M,&N)!=EOF)
+    {
+        printf("%d\n",(M+(M-(N-1)/2)+1)*(N-1)/4+(M+(M-(N+1)/2)+1)*(N+1)/4);
+    }
+    return 0;
+}
diff --git a/HDOJ/4573_autoAC.cpp b/HDOJ/4573_autoAC.cpp
new file mode 100644
index 0000000..08b6c2c
--- /dev/null
+++ b/HDOJ/4573_autoAC.cpp
@@ -0,0 +1,121 @@
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define db double
+#define rt return
+#define cs const
+#define cp const P&
+#define op operator
+cs db eps = 1e-9;
+inline int sig(db x){rt (x>eps)-(x<-eps);}
+cs int N = 10001;
+struct P {
+    db x, y, z;
+    P(db a = 0, db b = 0, db c = 0):x(a),y(b),z(c){}
+    void in(){scanf("%lf%lf%lf", &x, &y, &z);}
+    P op+(cp a)cs{rt P(x+a.x, y+a.y, z+a.z);}
+    P op-(cp a)cs{rt P(x-a.x, y-a.y, z-a.z);}
+    P op*(cs db&k)cs{rt P(x*k, y*k, z*k);}
+    P op^(cp a)cs{rt P(y*a.z-a.y*z, z*a.x-a.z*x, x*a.y-a.x*y);}
+    db op*(cp a)cs{rt x*a.x + y*a.y + z*a.z;}
+    P cross(P a, P b){rt a-*this ^ b-*this;}
+    db dot(P a, P b){rt (a-*this) * (b-*this);}
+    db L(){rt sqrt(x*x + y*y + z*z);}
+    db V6(P b, P c){rt (b ^ c) * (*this);}
+}p[N];
+int n;
+db diff_vol, max_diff;
+struct convex {
+    int cnt, blg[N][N];
+    struct face {
+       int a, b, c, is;
+       face(int x=0,int y=0,int z=0,int w=0):a(x),b(y),c(z),is(w){}
+       int visible(P me) {
+           rt sig(p[a].cross(p[b],p[c]) * (me-p[a])) > 0;
+       }
+    }fac[N*10];
+    int col(int a, int b, int c){rt p[a].cross(p[b],p[c]).L() < eps;}
+    int cop(int a, int b, int c, int d){rt !sig(p[a].cross(p[b],p[c])*(p[d]-p[a]));}
+    void deal(int k, int a, int b) {
+       int f = blg[a][b];
+       if(fac[f].is) {
+           if(fac[f].visible(p[k])) dfs(k, f);
+           else {
+               diff_vol += p[b].V6(p[a], p[k]);
+               face add = face(b, a, k, 1);
+               blg[b][a] = blg[a][k] = blg[k][b] = cnt;
+               fac[cnt++] = add;
+           }
+       }
+    }
+    void dfs(int k, int cur) {
+       diff_vol -= p[fac[cur].a].V6(p[fac[cur].b], p[fac[cur].c]);
+       fac[cur].is = 0;
+       deal(k, fac[cur].b, fac[cur].a);
+       deal(k, fac[cur].c, fac[cur].b);
+       deal(k, fac[cur].a, fac[cur].c);
+    }
+    void init() {
+        cnt = 0;
+        for(int i = 0; i < 4; i++) {
+           face add = face((i+1)%4, (i+2)%4, (i+3)%4, 1);
+           if(add.visible(p[i])) swap(add.b, add.c);
+           blg[add.a][add.b] = blg[add.b][add.c] = blg[add.c][add.a] = cnt;
+           fac[cnt++] = add;
+        }
+    }
+    void update(int k) {
+        for(int i = 0; i < cnt; i++)
+            if(fac[i].is && fac[i].visible(p[k])) {
+                dfs(k, i); break;
+            }
+    }
+    db volume() {
+       db v = 0.;
+       for(int i = 0; i < cnt; i++)
+           v += fac[i].is * p[fac[i].a].V6(p[fac[i].b], p[fac[i].c]);
+       rt v / 6.;
+    }
+}hull;
+void solve(int number, int cas) {
+    max_diff = 0.;
+    int king = 1, tag = 1;
+    p[0].in();
+    for(int i = 1; i < number; i++) {
+        p[i].in();
+        if(tag == 1) {
+            tag += sig((p[0]-p[i]).L());
+            if(tag > 1) swap(p[1], p[i]);
+            continue;
+        }
+        if(tag == 2) {
+            tag += sig((p[0].cross(p[1], p[i])).L());
+            if(tag > 2) swap(p[2], p[i]);
+            continue;
+        }
+        if(tag == 3) {
+            tag += sig(p[0].cross(p[1], p[2]) * (p[i]-p[0])) != 0;
+            if(tag > 3) {
+                swap(p[3], p[i]);
+                hull.init();
+                for(int j = 4; j <= i; j++) hull.update(j);
+                king = i + 1, max_diff = hull.volume();
+            }
+            continue;
+        }
+        diff_vol = 0.;
+        hull.update(i);
+        diff_vol /= 6.;
+        if(sig(diff_vol - max_diff) > 0) {
+            max_diff = diff_vol;
+            king = i + 1;
+        }
+    }
+    printf("Case #%d:\n%d %.2lf\n", cas, king, max_diff);
+}
+int main() {
+    int number, cas = 1;
+    while(scanf("%d", &number) != -1) solve(number, cas++);
+    rt 0;
+}
diff --git a/HDOJ/4574_autoAC.cpp b/HDOJ/4574_autoAC.cpp
new file mode 100644
index 0000000..2db884d
--- /dev/null
+++ b/HDOJ/4574_autoAC.cpp
@@ -0,0 +1,84 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <queue>
+#include <vector>
+#define mp(a , b) make_pair(a , b)
+using namespace std;
+typedef long long LL;
+const LL inf = 1000000000LL;
+int a , b , l , r , k;
+int pow (int a , int b) {
+    int ret = 1;
+    for (int i = 0 ; i < b ; i ++) {
+        ret = ret * a;
+        if (ret > inf || ret <= 0)
+            return inf + 1;
+    }
+    return ret;
+}
+int gao (int c , int a , int b , int l , int r , int k) {
+    if (c == 0) return l <= r;
+    if (c == 1) {
+        if (l > r) return 0;
+        return max (0 , min(r , b) - max (l , a) + 1);
+    }
+    int down = max(a , l / pow(b , c - 1));
+    int up = min (b , r / pow(a , c - 1));
+    int ret = 0;
+    for (int i = down ; i <= up ; i ++) {
+        ret += gao (c - 1 , i , b , (l + i - 1) / i , r / i , k - ret);
+        if (ret > k) return ret;  
+    }
+    return ret;
+}
+int ret , ans[50];
+void fuck (int c , int a , int b , int l , int r , int k) {
+    if (c == 0) return;
+    if (c == 1) {
+        int num = k + max(l , a) - 1;
+        ret = ret * num;
+        ans[c] = num;
+        return ;
+    }
+    int down = max(a , l / pow(b , c - 1));
+    int up = min (b , r / pow(a , c - 1));
+    for (int i = down ; i <= up ; i ++) {
+        int cnt = gao (c - 1 , i , b , (l + i - 1) / i , r / i , k);
+        if (k > cnt) {
+            k -= cnt;
+            continue;
+        }
+        ret = ret * i;
+        ans[c] = i;
+        fuck (c - 1 , i , b , (l + i - 1) / i , r / i , k);
+        return ;
+    }
+}
+int main () {
+    int t , cas = 0;
+    scanf ("%d" , &t);
+    while (t --) {
+        bool ok = false;
+        scanf ("%d %d %d %d %d" , &a , &b , &l , &r , &k);
+        printf ("Case #%d: " , ++ cas);
+        for (int i = 1 ; i <= 30 ; i ++) {
+            int cnt = gao (i , a , b , l , r , k);
+            if (k > cnt) {
+                k -= cnt;
+                continue;
+            }
+            ret = 1;
+            fuck (i , a , b , l , r , k);
+            printf ("%d\n" , ret);
+            for (int j = i ; j >= 1 ; j --) {
+                printf ("%d%c" , ans[j] , j == 1 ? '\n' : ' ');
+            }
+            ok = true;
+            break;
+        }
+        if (!ok) puts("-1");
+    }
+    return 0;
+}
diff --git a/HDOJ/4575_autoAC.cpp b/HDOJ/4575_autoAC.cpp
new file mode 100644
index 0000000..7466d77
--- /dev/null
+++ b/HDOJ/4575_autoAC.cpp
@@ -0,0 +1,196 @@
+#include <iostream>
+#include <cassert>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+#include <map>
+using namespace std;
+#define inf 9e99
+#define eps 1e-9
+#define x first
+#define y second
+#define pb push_back
+#define sz(a) int(a.size())
+#define rep(i,a,b) for(int i=a;i<=b;i++)
+template<class T> inline void gmin(T&a,T b) {if(a>b)a=b;}
+template<class T> inline T sqr(T a) {return a*a;}
+#define N 20020
+vector<int> to[N],len[N];
+int col[N],n;
+double sum[N],L;
+#define is_leaf(x) sz(to[x])==1 && sum[to[x][0]]<sum[x]
+void pre_dfs(int x) {
+    rep(i,0,sz(to[x])-1) {
+        int y=to[x][i];
+        if (sum[y]<0) {
+            col[y]=x==1?y:col[x];
+            sum[y]=sum[x]+len[x][i];
+            pre_dfs(y);
+        }
+    }
+}
+vector<int> path,tmp[N];
+double dp1[N],ans1[N];
+double dp2[N],ans2[N];
+double Y1(int j) {return dp1[j]+sqrt(dp1[j])+sqr(sum[j])+2.0*sum[j]*L;}
+double Y2(int j) {return dp2[j]+sqrt(dp2[j])+sqr(sum[j])-2.0*sum[j]*L;}
+double slope1(int j,int k) {return (Y1(j)-Y1(k))/(sum[j]-sum[k]);}
+double slope2(int j,int k) {return (Y2(j)-Y2(k))/(sum[j]-sum[k]);}
+double calc(double Ej,double sum) {return Ej+sqrt(Ej)+sum*sum;}
+struct Queue {
+    map<double,int> q;
+    void clear() {q.clear();}
+    int size() {return q.size();}
+    int front() {return sz(q)?q.begin()->y:0;}
+    int front2() {return sz(q)?(++q.begin())->y:0;}
+    int back() {return sz(q)?q.rbegin()->y:0;}
+    int back2() {return sz(q)?(++q.rbegin())->y:0;}
+    void pop_front() {q.erase(q.begin());}
+    void pop_back() {q.erase(--q.end());}
+    void insert(int x,int y) {q[x]=y;}
+    void merge(Queue *b) {
+        while (b->size()) {
+            int cur=b->front();
+            b->pop_front();
+            if (q.find(sum[cur])!=q.end()) {
+                int j=cur,k=q[sum[cur]];
+                if (Y2(j)>=Y2(k)) continue;
+            }
+            q[sum[cur]]=cur;
+            if (sz(q)<=2) continue;
+            map<double,int>::iterator i=q.find(sum[cur]),l1,l2,r1,r2;
+            if (i!=q.begin() && i!=(--q.end())) {
+                l1=i, l1--;
+                r1=i, r1++;
+                if (slope2(l1->y,i->y)>=slope2(i->y,r1->y)) {
+                    q.erase(i);
+                    continue;
+                }
+            }
+            while (i!=q.begin() && i!=(++q.begin())) {
+                l1=i, l1--;
+                l2=l1, l2--;
+                if (slope2(l2->y,l1->y)<=slope2(l1->y,i->y)) break;
+                q.erase(l1);
+            }
+            while (i!=(--q.end()) && i!=(--(--q.end()))) {
+                r1=i, r1++;
+                r2=r1, r2++;
+                if (slope2(i->y,r1->y)<=slope2(r1->y,r2->y)) break;
+                q.erase(r1);
+            }
+        }
+    }
+} q1,*q2[N];
+void first_run(int x) {
+    rep(i,0,sz(to[x])-1) {
+        int y=to[x][i];
+        if (sum[y]<=sum[x]) continue;
+        path.pb(y);
+        tmp[x].clear();
+        while (sz(q1)>=2 && slope1(q1.front(),q1.front2())<=2.0*sum[y] ) {
+            tmp[x].pb(q1.front());
+            q1.pop_front();
+        }
+        dp1[y]=calc(dp1[q1.front()],sum[y]-sum[q1.front()]-L);
+        while (sz(q1)>=2 && slope1(q1.back2(),q1.back())>=slope1(q1.back(),y) ) {
+            tmp[x].pb(q1.back());
+            q1.pop_back();
+        }
+        q1.insert(sum[y],y);
+        first_run(y);
+        q1.pop_back();
+        rep(i,0,sz(tmp[x])-1)
+            q1.insert(sum[tmp[x][i]],tmp[x][i]);
+        path.pop_back();
+    }
+    if (is_leaf(x)) {
+        gmin(ans1[col[x]],dp1[x]);
+    }
+}
+void merge(Queue *&a,Queue *&b) {
+    if (b->size() < a->size()) {
+        a->merge(b);
+    } else {
+        b->merge(a);
+        a=b;
+    }
+}
+double get_val(Queue *q,int x) {
+    while (q->size()>=2 && slope2(q->back(),q->back2())>=2.0*sum[x]) q->pop_back();
+    dp2[x]=calc(dp2[q->back()],sum[q->back()]-sum[x]-L);
+    while (q->size()>=2 && slope2(q->front2(),q->front())<=slope2(q->front(),x) ) q->pop_front();
+    return dp2[x];
+}
+void second_run(int x) {
+    q2[x]=new Queue;
+    rep(i,0,sz(to[x])-1){
+        int y=to[x][i];
+        if (sum[y]<=sum[x]) continue;
+        second_run(y);
+        if (x==1) {
+            gmin(ans2[y],get_val(q2[y],x));
+        } else {
+            merge(q2[x],q2[y]);
+        }
+    }
+    if (x!=1) {
+        dp2[x]=is_leaf(x)?0:get_val(q2[x],x);
+        q2[x]->insert(sum[x],x);
+    }
+}
+double get_answer() {
+    vector<int> part;
+    rep(i,2,n) if (col[i]==i) part.pb(i);
+    double min1=inf,min2=inf;
+    int pos1;
+    rep(i,0,sz(part)-1) {
+        if (min1>ans2[part[i]]) {
+            min2=min1;
+            min1=ans2[part[i]];
+            pos1=i;
+        } else
+        if (min2>ans2[part[i]]) {
+            min2=ans2[part[i]];
+        }
+    }
+    double res=inf;
+    rep(i,0,sz(part)-1)
+        gmin(res,ans1[part[i]]+(pos1==i?min2:min1));
+    return res;
+}
+int main() {
+    while (~scanf("%d%lf",&n,&L)) {
+        rep(i,1,n) {
+            to[i].clear();
+            len[i].clear();
+        }
+        rep(i,1,n-1) {
+            int u,v,w;
+            scanf("%d%d%d",&u,&v,&w);
+            to[u].pb(v);
+            to[v].pb(u);
+            len[u].pb(w);
+            len[v].pb(w);
+        }
+        if (sz(to[1])<2) {
+            puts("-1");
+            continue;
+        }
+        fill(sum+2,sum+n+1,-1);
+        pre_dfs(1);
+        fill(dp1+2,dp1+n+1,inf);
+        fill(dp2+1,dp2+n+1,inf);
+        fill(ans1,ans1+n+1,inf);
+        fill(ans2,ans2+n+1,inf);
+        path.clear();
+        path.pb(1);
+        q1.clear();
+        q1.insert(0,1);
+        first_run(1);
+        second_run(1);
+        printf("%.2lf\n",get_answer());
+    }
+    return 0;
+}
diff --git a/HDOJ/4576_autoAC.cpp b/HDOJ/4576_autoAC.cpp
new file mode 100644
index 0000000..49f162a
--- /dev/null
+++ b/HDOJ/4576_autoAC.cpp
@@ -0,0 +1,34 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int N=220;
+int n,m,l,r;
+double dp[2][N];
+int main(){
+    while(~scanf("%d%d%d%d",&n,&m,&l,&r)){
+        if(n==0 && m==0 && l==0 && r==0)
+            break;
+        for(int i=0;i<=n;i++)
+            dp[0][i]=0;
+        dp[0][0]=1;
+        int x,cur=0;
+        while(m--){
+            scanf("%d",&x);
+            for(int i=0;i<n;i++)
+                dp[cur^1][i]=0;
+            for(int i=0;i<n;i++){
+                if(dp[cur][i]==0)
+                    continue;
+                dp[cur^1][((i-x)%n+n)%n]+=0.5*dp[cur][i];
+                dp[cur^1][(i+x)%n]+=0.5*dp[cur][i];
+            }
+            cur^=1;
+        }
+        double ans=0;
+        for(int i=l-1;i<r;i++)  
+            ans+=dp[cur][i];
+        printf("%.4lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4578_autoAC.cpp b/HDOJ/4578_autoAC.cpp
new file mode 100644
index 0000000..809f634
--- /dev/null
+++ b/HDOJ/4578_autoAC.cpp
@@ -0,0 +1,147 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+using namespace std;
+#define lz 2*u,l,mid
+#define rz 2*u+1,mid+1,r
+typedef long long lld;
+const int maxn=100005;
+const int mod=10007;
+lld add[4*maxn], mul[4*maxn], ch[4*maxn], sum[4*maxn];
+void build(int u, int l, int r)
+{
+    mul[u]=1;
+    add[u]=sum[u]=0;
+    ch[u]=0;
+    if(l==r)
+    {
+        ch[u]=1;
+        return ;
+    }
+    int mid=(l+r)>>1;
+    build(lz);
+    build(rz);
+}
+void push_down(int u, int l, int r)
+{
+    if(l==r) return ;
+    int mid=(l+r)>>1;
+    if(ch[u])
+    {
+        add[2*u]=0, mul[2*u]=1;
+        add[2*u+1]=0, mul[2*u+1]=1;
+        ch[2*u]=ch[2*u+1]=1;
+        sum[2*u]=sum[2*u+1]=sum[u];
+        ch[u]=0;
+    }
+    else
+    {
+        if(add[u])
+        {
+            if(ch[2*u]) sum[2*u]=(sum[2*u]+add[u])%mod;
+            else
+            {
+                push_down(lz);
+                add[2*u]=(add[2*u]+add[u])%mod;
+            }
+            if(ch[2*u+1]) sum[2*u+1]=(sum[2*u+1]+add[u])%mod;
+            else
+            {
+                push_down(rz);
+                add[2*u+1]=(add[2*u+1]+add[u])%mod;
+            }
+            add[u]=0;
+        }
+        if(mul[u]>1)
+        {
+            if(ch[2*u]) sum[2*u]=(sum[2*u]*mul[u])%mod;
+            else
+            {
+                push_down(lz);
+                mul[2*u]=(mul[2*u]*mul[u])%mod;
+            }
+            if(ch[2*u+1]) sum[2*u+1]=(sum[2*u+1]*mul[u])%mod;
+            else
+            {
+                push_down(rz);
+                mul[2*u+1]=(mul[2*u+1]*mul[u])%mod;
+            }
+            mul[u]=1;
+        }
+    }
+}
+void Update(int u, int l, int r, int tl, int tr, int c, int op)
+{
+    if(tl<=l&&r<=tr)
+    {
+        if(op==3)
+        {
+            ch[u]=1;
+            mul[u]=1, add[u]=0;
+            sum[u]=c;
+        }
+        else
+        {
+            if(ch[u])
+            {
+                if(op==1) sum[u]=(sum[u]+c)%mod;
+                else   sum[u]=sum[u]*c%mod;
+            }
+            else
+            {
+                push_down(u,l,r);
+                if(op==1) add[u]=(add[u]+c)%mod;
+                else mul[u]=mul[u]*c%mod;
+            }
+        }
+        return ;
+    }
+    push_down(u,l,r);
+    int mid=(l+r)>>1;
+    if(tr<=mid) Update(lz,tl,tr,c,op);
+    else if(tl>mid) Update(rz,tl,tr,c,op);
+    else
+    {
+        Update(lz,tl,mid,c,op);
+        Update(rz,mid+1,tr,c,op);
+    }
+}
+lld Query(int u, int l, int r, int tl, int tr, int p)
+{
+    if(tl<=l&&r<=tr)
+    {
+        if(ch[u])
+        {
+            lld ans=1, tp=sum[u];
+            for(int i=1; i<=p; i++) ans=ans*tp%mod;
+            return (r-l+1)*ans%mod;
+        }
+    }
+    push_down(u,l,r);
+    int mid=(l+r)>>1;
+    if(tr<=mid) return Query(lz,tl,tr,p);
+    else if(tl>mid) return Query(rz,tl,tr,p);
+    else
+    {
+        lld t1=Query(lz,tl,mid,p);
+        lld t2=Query(rz,mid+1,tr,p);
+        return (t1+t2)%mod;
+    }
+}
+int main()
+{
+    int n, m;
+    while(cin >> n >> m, n+m)
+    {
+        build(1,1,n);
+        for(int i=1; i<=m; i++)
+        {
+            int l, r, c, op;
+            scanf("%d%d%d%d",&op,&l,&r,&c);
+            if(op<=3) Update(1,1,n,l,r,c,op);
+            else printf("%I64d\n",Query(1,1,n,l,r,c)%mod);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4579_autoAC.cpp b/HDOJ/4579_autoAC.cpp
new file mode 100644
index 0000000..06424f1
--- /dev/null
+++ b/HDOJ/4579_autoAC.cpp
@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+using namespace std;
+const int MAXN = 50010;
+double c[MAXN][10];
+double p[MAXN][20];
+double a[MAXN][10];
+double b[MAXN];
+double dp[MAXN];
+int main()
+{
+    int n,m;
+    while( scanf("%d%d",&n,&m) == 2 )
+    {
+        if(n == 0 && m == 0)break;
+        for(int i = 1;i <= n;i++)
+            for(int j = 1;j <= m;j++)
+                scanf("%lf",&c[i][j]);
+        for(int i = 1;i < n;i++)
+        {
+            double sum = 0;
+            for(int j = 1;j <= m;j++)
+                sum += c[i][j];
+            double s = 0;
+            for(int j = 1;j <= m && i-j >= 1;j++)
+            {
+                p[i][m-j] = 0.3*c[i][j]/(1+sum);
+                s += p[i][m-j];
+            }
+            for(int j = 1;j <= m && i+j <= n;j++)
+            {
+                p[i][m+j] = 0.7*c[i][j]/(1+sum);
+                s += p[i][m+j];
+            }
+            p[i][m] = -s;
+            b[i] = -1;
+        }
+        for(int i = 1;i <= m+1 && i <= n;i++)
+            a[1][i] = p[1][m+i-1];
+        for(int i = 2;i < n;i++)
+        {
+            int end = min(i+m,n);
+            int start = max(1,i-m);
+            for(int j = start;j < i;j++)
+                if(fabs(p[i][m+j-i]) > 1e-6)
+                {
+                    double t = p[i][m+j-i]/a[j][1];
+                    for(int k = 1; k <= m+1 && j+k-1 <= n ;k++)
+                    {
+                        p[i][m+j-i+k-1] -= t*a[j][k];
+                    }
+                    b[i] -= t*b[j];
+                }
+            for(int j = 1;j <= end-i+1;j++)
+                a[i][j] = p[i][m+j-1];
+        }
+        dp[n] = 0;
+        for(int i = n-1;i >= 1;i--)
+        {
+            for(int j = 2;j <= m+1 && i+j-1 <= n;j++)
+                b[i] -= dp[i+j-1] * a[i][j];
+            dp[i] = b[i]/a[i][1];
+        }
+        printf("%.2f\n",dp[1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4582_autoAC.cpp b/HDOJ/4582_autoAC.cpp
new file mode 100644
index 0000000..6076861
--- /dev/null
+++ b/HDOJ/4582_autoAC.cpp
@@ -0,0 +1,51 @@
+#include <bitset>
+#include <iostream>
+using namespace std;
+const int maxn=2013;
+int first[maxn],pre[maxn],vv[maxn*20],nxt[maxn*20];
+bitset<2001> to[2001];
+bool vis[maxn];
+int ans;
+void dfs(int u,int p)
+{
+    vis[u]=true;
+    to[u].reset();
+    for(int e=pre[u];e;e=nxt[e]) if(vis[vv[e]])
+        to[u].set(vv[e]);
+    for(int e=first[u];e;e=nxt[e]) if(vv[e]!=p)
+        dfs(vv[e],u);
+    if(p==-1)
+        return;
+    if(to[u].test(p))
+        ans++;
+    else
+        to[p]|=to[u];
+}
+int main()
+{
+    int n,m;
+    while(~scanf("%d%d",&n,&m) && n|m)
+    {
+        memset(vis,0,sizeof(vis));
+        memset(first,0,sizeof(first));
+        memset(pre,0,sizeof(pre));
+        int e=2;
+        for(int i=1;i<n;i++)
+        {
+            int u,v;
+            scanf("%d%d",&u,&v);
+            nxt[e]=first[u],vv[e]=v,first[u]=e++;
+            nxt[e]=first[v],vv[e]=u,first[v]=e++;
+        }
+        for(int i=n;i<=m;i++)
+        {
+            int u,v;
+            scanf("%d%d",&u,&v);
+            nxt[e]=pre[u],vv[e]=v,pre[u]=e++;
+            nxt[e]=pre[v],vv[e]=u,pre[v]=e++;
+        }
+        ans=0;
+        dfs(1,-1);
+        printf("%d\n",ans);
+    }
+}
diff --git a/HDOJ/4583_autoAC.cpp b/HDOJ/4583_autoAC.cpp
new file mode 100644
index 0000000..f148453
--- /dev/null
+++ b/HDOJ/4583_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <iostream>
+#include <cstdio>
+#include <bitset>
+#include <algorithm>
+using namespace std;
+#define LL long long
+#define Bool bitset<maxn>
+const int maxn=60;
+int a[maxn];
+Bool to[maxn];
+LL num[maxn];
+LL ans;
+bool gcd(int a,int b)
+{
+    return b==0?a!=1:gcd(b,a%b);
+}
+LL DFS(int n,Bool p)
+{
+    if(n==-1)
+        return 1;
+    LL res=DFS(n-1,p);
+    if(p.test(n))
+        return res;
+    if((p|to[n])==p)
+        return res*num[n];
+    else
+        return res+DFS(n-1,(p|to[n]))*(num[n]-1);
+}
+int main()
+{
+    int n;
+    while(~scanf("%d",&n) && n)
+    {
+        for(int i=0;i<n;i++)
+            scanf("%d",a+i);
+        sort(a,a+n);
+        int m=0;
+        num[0]=2;
+        for(int i=1;i<n;i++)
+        {
+            if(a[i]==a[m])
+                num[m]++;
+            else
+            {
+                a[++m]=a[i];
+                num[m]=2;
+            }
+        }
+        for(int i=0;i<=m;i++)
+        {
+            to[i].reset();
+            for(int j=0;j<i;j++)
+                if(gcd(a[j],a[i]))
+                    to[i].set(j);
+        }
+        ans=0;
+        Bool p;
+        printf("%I64d\n",DFS(m,p));
+    }
+}
diff --git a/HDOJ/4584_autoAC.cpp b/HDOJ/4584_autoAC.cpp
new file mode 100644
index 0000000..1cd9411
--- /dev/null
+++ b/HDOJ/4584_autoAC.cpp
@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+using namespace std;
+struct Point
+{
+    int x,y;
+    Point(int _x = 0,int _y = 0)
+    {
+        x = _x; y = _y;
+    }
+};
+int dis(Point a,Point b)
+{
+    return abs(a.x-b.x)+abs(a.y-b.y);
+}
+Point p1[2000];
+Point p2[2000];
+char str[50][50];
+int main()
+{
+    int n,m;
+    while(scanf("%d%d",&n,&m) == 2)
+    {
+        if(n == 0 && m == 0)break;
+        for(int i = 0;i < n;i++)
+            scanf("%s",str[i]);
+        int uN = 0, vN = 0;
+        for(int i = 0;i < n;i++)
+            for(int j = 0;j < m;j++)
+            {
+                if(str[i][j] == 'H')p1[uN++] = Point(i,j);
+                else if(str[i][j] == 'C') p2[vN++] = Point(i,j);
+            }
+        int ans1 = 0,ans2 = 0;
+        int Min = 100000000;
+        for(int i = 0;i < uN;i++)
+            for(int j = 0;j < vN;j++)
+            {
+                if(dis(p1[i],p2[j]) < Min)
+                {
+                    Min = dis(p1[i],p2[j]);
+                    ans1 = i;
+                    ans2 = j;
+                }
+            }
+        printf("%d %d %d %d\n",p1[ans1].x,p1[ans1].y,p2[ans2].x,p2[ans2].y);
+    }
+    return 0;
+}
diff --git a/HDOJ/4585_autoAC.cpp b/HDOJ/4585_autoAC.cpp
new file mode 100644
index 0000000..2dd0374
--- /dev/null
+++ b/HDOJ/4585_autoAC.cpp
@@ -0,0 +1,28 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <map>
+using namespace std;
+int main()
+{
+    int n, id, p;
+    while(cin >> n,n)
+    {
+        map<int,int>mp;
+        mp[1000000000]=1;
+        for(int i=1; i<=n; i++)
+        {
+            scanf("%d%d",&id,&p);
+            map<int,int>::iterator it=mp.lower_bound(p);
+            if(it==mp.begin()) cout << id << " " << it->second <<endl;
+            else
+            {
+                map<int,int>::iterator a=it, b=--it;
+                if((a->first)-p>=p-(b->first))cout << id << " " << b->second <<endl;
+                else cout << id << " " << a->second <<endl;
+            }
+            mp[p]=id;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4586_autoAC.cpp b/HDOJ/4586_autoAC.cpp
new file mode 100644
index 0000000..d67cc3a
--- /dev/null
+++ b/HDOJ/4586_autoAC.cpp
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <iostream>
+#include <map>
+#include <stack>
+#include <vector>
+#include <math.h>
+#include <string.h>
+#include <queue>
+#include <string>
+#include <stdlib.h>
+#include <algorithm>
+#define LL long long
+#define _LL __int64
+#define eps 1e-8
+#define PI acos(-1.0)
+using namespace std;
+int n,m;
+int vis[210];
+int a[210];
+int sum,cnt;
+double p,q;
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        sum = 0;
+        cnt = 0;
+        memset(vis,0,sizeof(vis));
+        for(int i = 1; i <= n; i++)
+        {
+            cin >> a[i];
+            sum += a[i];
+        }
+        p = (sum*1.0)/n;
+        scanf("%d",&m);
+        int x;
+        for(int i = 1; i <= m; i++)
+        {
+            cin >> x;
+            if(vis[x]) continue;
+            cnt++;
+            vis[x] = 1;
+        }
+        q = (cnt*1.0)/n;
+        if(fabs(p) < eps)
+            cout << "0.00" << endl;
+        else if(fabs(q-1) < eps)
+            cout << "inf" << endl;
+        else
+            printf("%.2lf\n",p/(1-q));
+    }
+    return 0;
+}
diff --git a/HDOJ/4587_autoAC.cpp b/HDOJ/4587_autoAC.cpp
new file mode 100644
index 0000000..caabd34
--- /dev/null
+++ b/HDOJ/4587_autoAC.cpp
@@ -0,0 +1,70 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<stack>
+using namespace std;
+#define MAXN 5555
+struct Edge{
+    int v,next;
+}edge[MAXN*MAXN];
+int n,m,NE;
+int head[MAXN];
+void Insert(int u,int v)
+{
+    edge[NE].v=v;
+    edge[NE].next=head[u];
+    head[u]=NE++;
+}
+int cnt,rt_son,block;
+int low[MAXN],dfn[MAXN];
+int blocks[MAXN];
+bool mark[MAXN];
+void Tarjan(int u,int vv)
+{
+    low[u]=dfn[u]=++cnt;
+    mark[u]=true;
+    for(int i=head[u];i!=-1;i=edge[i].next){
+        int v=edge[i].v;
+        if(v==vv)continue;
+        if(dfn[v]==0){
+            Tarjan(v,vv);
+            low[u]=min(low[u],low[v]);
+            if(low[v]>=dfn[u]){
+               blocks[u]++;
+           }
+        }else if(mark[v]){
+            low[u]=min(low[u],dfn[v]);
+        }
+    }
+}
+int main()
+{
+    int u,v,ans;
+    while(~scanf("%d%d",&n,&m)){
+        NE=0;
+        memset(head,-1,sizeof(head));
+        while(m--){
+            scanf("%d%d",&u,&v);
+            Insert(u,v);
+            Insert(v,u);
+        }
+        ans=0;
+        for(int u=0;u<n;u++){
+            memset(mark,false,sizeof(mark));
+            memset(dfn,0,sizeof(dfn));
+            fill(blocks,blocks+n,1);
+            cnt=block=0;
+            for(int v=0;v<n;v++)if(u!=v&&!mark[v]){
+                block++;
+                blocks[v]=0;
+                Tarjan(v,u);
+            }
+            for(int v=0;v<n;v++)if(v!=u){
+                ans=max(ans,block+blocks[v]-1);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4588_autoAC.cpp b/HDOJ/4588_autoAC.cpp
new file mode 100644
index 0000000..32ad1c1
--- /dev/null
+++ b/HDOJ/4588_autoAC.cpp
@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+using namespace std;
+typedef long long ll;
+const int N = 40;
+ll ti[N], p[N], q[N];
+void cat (ll x, ll* a) {
+    if (x <= 0) return;
+    ll ans = 0, s = 0;
+    for (int i = 0; i <= 32; i++) {
+        ll t = ti[i+1];
+        ll c = x/t, d = x%t;
+        d -= ti[i];
+        a[i] = c * ti[i] + (d <= 0 ? 0 : d);
+    }
+}
+ll solve () {
+    ll ans = 0, s = 0;
+    for (int i = 0; i <= 32; i++) {
+        s = s + p[i] - q[i];
+        s /= 2;
+        ans += s;
+    }
+    while (s) {
+        s /= 2;
+        ans += s;
+    }
+    return ans;
+}
+int main () {
+    ti[0] = 1;
+    for (int i = 1; i <= 35; i++)
+        ti[i] = ti[i-1] * 2;
+    ll a, b;
+    while (cin >> a >> b) {
+        memset(p, 0, sizeof(p));
+        memset(q, 0, sizeof(q));
+        cat (b+1, p);
+        cat (a, q);
+        cout << solve () << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4593_autoAC.cpp b/HDOJ/4593_autoAC.cpp
new file mode 100644
index 0000000..f840f98
--- /dev/null
+++ b/HDOJ/4593_autoAC.cpp
@@ -0,0 +1,27 @@
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+#include <algorithm>
+#include <iostream>
+#include <cstring>
+using namespace std;
+const int maxn = 10010;
+int cnt[maxn];
+int main()
+{
+    int n;
+    while(scanf("%d", &n) == 1)
+    {
+        memset(cnt, 0, sizeof(cnt));
+        int ans = -1;
+        for(int i = 0; i < n+1; i++)
+        {
+            int tmp;
+            scanf("%d", &tmp);
+            cnt[tmp]++;
+            if(cnt[tmp] >= 2)
+                ans = tmp;
+        }
+        printf("%d\n", ans);
+    }
+}
diff --git a/HDOJ/4594_autoAC.cpp b/HDOJ/4594_autoAC.cpp
new file mode 100644
index 0000000..3e9daac
--- /dev/null
+++ b/HDOJ/4594_autoAC.cpp
@@ -0,0 +1,210 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+#include<map>
+#include<iostream>
+#include<string>
+using namespace std;
+typedef long long ll;
+int T,t,n,m;
+map<string,string> match[4];
+char str[1010],str2[1010],s1[1010],s2[1010];
+int type1,type2,Err,Over;
+void init()
+{
+    int i,j,k;
+    for(i=0;i<=3;i++)
+       match[i].clear();
+    Err=1;
+    Over=0;
+}
+bool Has_Equal()
+{
+    int i,j,k,len=strlen(str);
+    bool flag=0,flag2=0;
+    for(i=0;i<len;i++)
+    {
+        if(str[i]==34)
+          flag2=1;
+        if(str[i]=='=' && flag2==0)
+        {
+            flag=true;
+            str[i]=' ';
+        }
+        if(str[i]==9)
+          str[i]=32;
+    }
+    return flag;
+}
+bool kong()
+{
+    int i,j,k,len=strlen(str);
+    bool flag=0;
+    for(i=0;i<len;i++)
+       if(!(str[i]==' ' || str[i]==9))
+         return false;
+    return true;
+}
+void solve()
+{
+    int i,j,k,len=strlen(str);
+    m=0;
+    for(i=0;i<len;i++)
+       if(str[i]==34)
+         break;
+    m=i;
+    for(i=m;i<len;i++)
+       if(!(str[i]==' ' || str[i]==9))
+         str[m++]=str[i];
+    str[m]='\0';
+}
+int main()
+{
+    int i,j,k,pos;
+    string string1,string2;
+    scanf("%d",&T);
+    for(t=1;t<=T;t++)
+    {
+        if(t!=1)
+          printf("\n");
+        scanf("%d",&n);
+        getchar();
+        init();
+        while(n--)
+        {
+            gets(str);
+            solve();
+            if(Over==1)
+              continue;
+            if(kong())
+              continue;
+            if(Has_Equal())
+            {
+                sscanf(str,"%s %s",s1,s2);
+                if(s1[0]=='$')
+                  type1=0;
+                else
+                  type1=1;
+                if(s2[0]!=34)
+                  type2=0;
+                else
+                  type2=1;
+                if(type1==0)
+                {
+                    match[0].erase(s1);
+                    match[1].erase(s1);
+                    match[type2][s1]=s2;
+                }
+                else
+                {
+                    if(match[2].find(s1)==match[2].end() && match[3].find(s1)==match[3].end())
+                      match[2+type2][s1]=s2;
+                    else if(Err==1)
+                      printf("WARNING: Constant %s Already Defined!\n",s1);
+                }
+            }
+            else
+            {
+                sscanf(str,"%s %s",s1,s2);
+                if(s1[0]=='P' && s1[1]=='a') //Panic
+                {
+                    printf("Script was KILLED.\n");
+                    Over=1;
+                }
+                else if(s1[0]=='E' && s2[1]=='N') //Errmsg ON
+                  Err=1;
+                else if(s1[0]=='E' && s2[1]=='F') //Errmsg OFF
+                  Err=0;
+                else if(s1[0]=='P') //Print
+                {
+                    if(s2[0]=='$')
+                    {
+                        if(match[0].find(s2)!=match[0].end())
+                        {
+                            string1=match[0][s2];
+                            cout<<string1<<endl;
+                        }
+                        else if(match[1].find(s2)!=match[1].end())
+                        {
+                            string1=match[1][s2];
+                            string2=string1.substr(1,string1.length()-2);
+                            cout<<string2<<endl;
+                        }
+                        else
+                        {
+                            printf("NULL\n");
+                            if(Err==1)
+                              printf("NOTICE: Undefined Variable %s.\n",s2);
+                        }
+                    }
+                    else
+                    {
+                        if(match[2].find(s2)!=match[2].end())
+                        {
+                            string1=match[2][s2];
+                            cout<<string1<<endl;
+                        }
+                        else if(match[3].find(s2)!=match[3].end())
+                        {
+                            string1=match[3][s2];
+                            string2=string1.substr(1,string1.length()-2);
+                            cout<<string2<<endl;
+                        }
+                        else
+                        {
+                            printf("%s\n",s2);
+                            if(Err==1)
+                              printf("NOTICE: Undefined Constant %s.\n",s2);
+                        }
+                    }
+                }
+                else if(s1[0]=='D') //Dump
+                {
+                    if(s2[0]=='$')
+                    {
+                        if(match[0].find(s2)!=match[0].end())
+                        {
+                            string1=match[0][s2];
+                            printf("integer: ");
+                            cout<<string1<<endl;
+                        }
+                        else if(match[1].find(s2)!=match[1].end())
+                        {
+                            string1=match[1][s2];
+                            printf("string: ");
+                            cout<<string1<<endl;
+                        }
+                        else
+                        {
+                            printf("NULL\n");
+                            if(Err==1)
+                              printf("NOTICE: Undefined Variable %s.\n",s2);
+                        }
+                    }
+                    else
+                    {
+                        if(match[2].find(s2)!=match[2].end())
+                        {
+                            string1=match[2][s2];
+                            printf("integer: ");
+                            cout<<string1<<endl;
+                        }
+                        else if(match[3].find(s2)!=match[3].end())
+                        {
+                            string1=match[3][s2];
+                            printf("string: ");
+                            cout<<string1<<endl;
+                        }
+                        else
+                        {
+                            printf("string: %c%s%c\n",34,s2,34);
+                            if(Err==1)
+                              printf("NOTICE: Undefined Constant %s.\n",s2);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/HDOJ/4595_autoAC.cpp b/HDOJ/4595_autoAC.cpp
new file mode 100644
index 0000000..5f73735
--- /dev/null
+++ b/HDOJ/4595_autoAC.cpp
@@ -0,0 +1,67 @@
+#include<cstdio>
+#include<cstring>
+#include<map>
+#include<string>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+map<string,int> match;
+char s[100010][20];
+int n,m,point[100010],one[100010],two[100010],sum_one[100010],sum_two[100010];
+bool cmp(char a,char b)
+{
+    return a<b;
+}
+int main()
+{
+    int i,j,k,a,b,len,c,pos;
+    ll l,r,ans;
+    while(~scanf("%d%d",&n,&m))
+    {
+        for(i=1;i<=n;i++)
+           scanf("%s",s[i]);
+        match.clear();
+        for(i=n;i>=1;i--)
+        {
+            len=strlen(s[i]);
+            sort(s[i],s[i]+len,cmp);
+            k=match[s[i]];
+            if(k==0)
+              point[i]=n+1;
+            else
+              point[i]=k;
+            match[s[i]]=i;
+        }
+        a=n+1;b=n+1;
+        for(i=n;i>=1;i--)
+        {
+            c=point[i];
+            if(c<a)
+              b=a,a=c;
+            else if(c<b)
+              b=c;
+            one[i]=a;
+            two[i]=b;
+        }
+        for(i=1;i<=n;i++)
+        {
+            sum_one[i]=sum_one[i-1]+(one[i]-1);
+            sum_two[i]=sum_two[i-1]+(two[i]-1);
+        }
+        ans=0;
+        while(m--)
+        {
+            scanf("%I64d%I64d",&l,&r);
+            l+=ans;
+            r-=ans;
+            ans=0;
+            pos=upper_bound(one+1,one+n,r)-one-1;
+            if(pos>=l)
+            ans+=r*(pos-l+1)-(sum_one[pos]-sum_one[l-1]);
+            pos=upper_bound(two+1,two+n,r)-two-1;
+            if(pos>=l)
+            ans-=r*(pos-l+1)-(sum_two[pos]-sum_two[l-1]);
+            printf("%I64d\n",ans);
+        }
+    }
+}
diff --git a/HDOJ/4596_autoAC.cpp b/HDOJ/4596_autoAC.cpp
new file mode 100644
index 0000000..0b9e836
--- /dev/null
+++ b/HDOJ/4596_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+#define maxn 100001
+#define Max(a,b) (a)>(b)?(a):(b)
+#define Min(a,b) (a)<(b)?(a):(b)
+struct Node
+{
+    int x,y,z;
+}node[1005];
+int gcd(int a,int b)
+{
+    if(b==0) return a;
+    else return gcd(b,a%b);
+}
+int check2(int d,int l,int r)
+{
+    if(l%d==0 || r%d==0) return 1;
+    else if(r/d>l/d) return 1;
+    else return 0;
+}
+int check(int i,int j)
+{
+    if(node[i].y>node[j].z || node[j].y>node[i].z)
+    {
+        if(node[i].y>node[i].z) swap(i,j);
+        int d=gcd(node[i].x,node[j].x);
+        if(check2(d,node[j].y-node[i].z,node[j].z-node[i].y))
+            return 1;
+        else
+            return 0;
+    }
+    return 1;
+}
+int main(){
+    int n,i,j;
+    while(~scanf("%d",&n))
+    {
+        for(i=1;i<=n;i++)
+            scanf("%d %d %d",&node[i].x,&node[i].y,&node[i].z);
+        int flag=0;
+        for(i=1;i<=n;i++)
+        {
+            for(j=i+1;j<=n;j++)
+            {
+                if(check(i,j)) {flag=1;break;}    
+            }
+            if(flag) break;
+        }
+        if(!flag)printf("Can Take off\n");
+        else printf("Cannot Take off\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4597_autoAC.cpp b/HDOJ/4597_autoAC.cpp
new file mode 100644
index 0000000..52cd726
--- /dev/null
+++ b/HDOJ/4597_autoAC.cpp
@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+int a[30],b[30];
+int sum1[30];
+int sum2[30];
+int dp[30][30][30][30];
+int solve(int l1,int r1,int l2,int r2)
+{
+    if(dp[l1][r1][l2][r2] != -1)return dp[l1][r1][l2][r2];
+    if(l1 > r1 && l2 > r2)
+        return dp[l1][r1][l2][r2] = 0;
+    int ans = 0;
+    int sum = 0;
+    if(l1 <= r1)
+        sum += sum1[r1] - sum1[l1-1];
+    if(l2 <= r2)
+        sum += sum2[r2] - sum2[l2-1];
+    if(l1 <= r1)
+    {
+        ans = max(ans,sum - solve(l1+1,r1,l2,r2));
+        ans = max(ans,sum - solve(l1,r1-1,l2,r2));
+    }
+    if(l2 <= r2)
+    {
+        ans = max(ans,sum - solve(l1,r1,l2+1,r2));
+        ans = max(ans,sum - solve(l1,r1,l2,r2-1));
+    }
+    return dp[l1][r1][l2][r2] = ans;
+}
+int main()
+{
+    int n;
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        sum1[0] = sum2[0] = 0;
+        for(int i = 1;i <= n;i++)
+        {
+            scanf("%d",&a[i]);
+            sum1[i] = sum1[i-1] + a[i];
+        }
+        for(int i = 1;i <= n;i++)
+        {
+            scanf("%d",&b[i]);
+            sum2[i] = sum2[i-1] + b[i]; 
+        }
+        memset(dp,-1,sizeof(dp));
+        printf("%d\n",solve(1,n,1,n));
+    }
+    return 0;
+}
diff --git a/HDOJ/4598_autoAC.cpp b/HDOJ/4598_autoAC.cpp
new file mode 100644
index 0000000..66ad341
--- /dev/null
+++ b/HDOJ/4598_autoAC.cpp
@@ -0,0 +1,129 @@
+#include<iostream>
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+#include<queue>
+#include<stack>
+#include<vector>
+#include<climits>
+#include<map>
+using namespace std;
+#define rep(i,n) for(int i=0; i<n; i++)
+#define repf(i,n,m) for(int i=(n); i<=(m); ++i)
+#define repd(i,n,m) for(int i=(n); i>=(m); --i) 
+#define ll long long
+#define arc(a) ((a)*(a))
+#define inf 10000000
+#define exp 0.000001
+#define N 305
+#define T 400
+int cont[N];
+struct node
+{
+    int y,w,pre;
+};
+node a[N*N];
+int pre[N];
+int color[N];
+bool vis[N];
+int dp[N];
+char s[N][N];
+int n,len;
+bool dfs(int x)
+{
+    color[x]=0;
+    queue<int>q; q.push(x);
+    while(!q.empty())
+    {
+        int x=q.front(); q.pop();
+        rep(i,n)
+            if(s[x][i]=='1')
+                if(color[i]==-1)
+                    color[i]=color[x]^1,q.push(i);
+                else if(color[i]==color[x])
+                    return false;
+    }
+    return true;
+}
+void init()
+{
+    memset(color,-1,sizeof(color));
+    len=1;
+    memset(pre,-1,sizeof(pre));
+    rep(i,n) dp[i]=inf;
+    memset(cont,0,sizeof(cont));
+    memset(vis,false,sizeof(vis));
+}
+void addpage(int s,int t,int w)
+{
+    a[len].y=t;
+    a[len].w=w;
+    a[len].pre=pre[s];
+    pre[s]=len++;
+}
+bool spfa()
+{
+     queue<int>q;
+     q.push(0);
+     vis[0]=true; dp[0]=0;
+     while(!q.empty())
+     {
+         int x=q.front(); q.pop(); vis[x]=false;
+         for(int i=pre[x]; i!=-1; i=a[i].pre)
+         {
+             int y=a[i].y;
+             if(dp[x]+a[i].w<dp[y])
+             {
+                 dp[y]=dp[x]+a[i].w;
+                 if(vis[y]==false)
+                 {
+                     q.push(y);
+                     vis[y]=true;
+                     cont[y]++;
+                     if(cont[y]>n)
+                         return false;
+                 }
+             }
+         }
+     }
+     return true;
+}
+bool solve()
+{
+    init();
+    rep(i,n)
+        if(color[i]==-1) 
+            if(!dfs(i))
+                return false;
+    rep(i,n)
+        repf(j,i+1,n-1)
+        {
+            if(s[i][j]=='0')
+                if(color[i]==0)
+                    addpage(j,i,T-1);
+                else
+                    addpage(i,j,T-1);
+            else
+                if(color[i]==0)
+                    addpage(i,j,-T);
+                else addpage(j,i,-T);
+        }
+    return spfa();
+}
+int main()
+{ 
+   int test;
+   scanf("%d",&test);
+   while(test--)
+   {
+       scanf("%d",&n);
+       rep(i,n) scanf("%s",s[i]);
+       if(solve())
+           printf("Yes\n");
+       else 
+           printf("No\n");
+   }
+   return 0;
+}
diff --git a/HDOJ/4599_autoAC.cpp b/HDOJ/4599_autoAC.cpp
new file mode 100644
index 0000000..f708c03
--- /dev/null
+++ b/HDOJ/4599_autoAC.cpp
@@ -0,0 +1,76 @@
+#include <cstring>  
+#include <iostream>  
+#include <cmath>  
+#include <algorithm>  
+#include <cstdio>  
+using namespace std;  
+typedef long long LL;  
+using namespace std;  
+LL n;  
+LL mod =2011;  
+LL exgcd(LL a,LL b,LL &x,LL &y)  
+{  
+    if(b==0)  
+    {  
+        x=1;  
+        y=0;  
+        return a;  
+    }  
+    else  
+    {  
+        LL ans=exgcd(b,a%b,x,y);  
+        LL tmp=x;  
+        x=y;  
+        y=tmp-a/b*y;  
+        return ans;  
+    }  
+}  
+LL Pow(LL a,LL b,LL mod)  
+{  
+    LL ans=1;  
+    while(b)  
+    {  
+        if(b&1)  
+        {  
+            b--;  
+            ans=(ans*a)%mod;  
+        }  
+        else  
+        {  
+            b/=2;  
+            a=(a*a)%mod;  
+        }  
+    }  
+    return ans;  
+}  
+LL solve0(LL n)  
+{  
+    LL ans=Pow(6,n%2010,2011);  
+    ans+=24;  
+    ans%=mod;  
+    LL x,y;  
+    exgcd(30,mod,x,y);  
+    LL niyuan=(x%mod+mod)%mod;  
+    ans=(ans*niyuan)%mod;  
+    return ans;  
+}  
+LL solve(LL n)  
+{  
+    LL ans=Pow(6,n%2010,2011);  
+    ans=(ans+2010)%mod;  
+    LL x,y;  
+    exgcd(5,mod,x,y);  
+    LL niyuan=(x%mod+mod)%mod;  
+    ans=(ans*niyuan)%mod;  
+    return ans;  
+}  
+int main()  
+{  
+    while(scanf("%I64d",&n)!=EOF)  
+    {  
+        if(n==0)  
+            break;  
+        printf("%I64d %I64d\n",solve0(n),solve(n));  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4600_autoAC.cpp b/HDOJ/4600_autoAC.cpp
new file mode 100644
index 0000000..9fed935
--- /dev/null
+++ b/HDOJ/4600_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <stdio.h>
+#include <string.h>
+#define LL __int64
+struct corns {
+    int q, p, n, m;
+}a[1111];
+int s[11] , ss[11], D, Y;
+LL ans , val[1002];
+void solve1(int i) {
+    LL cur = Y;
+    int day = 0, j;
+    while(day <= D) {
+        if(day + a[i].n <= D) {
+            LL tot = cur/a[i].q;
+            for(j = 9;j >= 1; j--) if(s[j]) {
+                if(j*a[i].p > a[i].q)   {
+                    if(tot <= s[j]) {
+                        cur += tot * (LL)( j*a[i].p - a[i].q );
+                        tot = 0;
+                        break;
+                    }
+                    else {
+                        cur += (LL)s[j] * ( j*a[i].p - a[i].q );
+                        tot -= s[j];
+                    }
+                }
+                else    break;
+            }
+        }
+        day += a[i].n;
+    }
+    if(cur > ans)        ans = cur;
+}
+void solve2(int i) {
+    int j, k, l;
+    memset(val, 0, sizeof(val));
+    LL cur = Y;
+    for(j = 1;j <= 9; j++)    ss[j] = s[j];
+    for(j=  0;j <= D; j++) {
+        cur += val[j];
+        LL tot = cur/a[i].q;
+        for(k = 9;k >= 1; k--) if(ss[k]){
+            int to = j+a[i].n;
+            if(to > D)    break;
+            LL now = k*a[i].p;
+            now += (LL)(D-to)/a[i].m * k*a[i].p;
+            if(now > a[i].q) {
+                LL get;
+                if(tot > ss[k])    get = ss[k];
+                else    get = tot;
+                ss[k] -= (int)get;
+                tot -= get;
+                cur -= get*a[i].q;
+                val[to] += get * k *a[i].p;
+                for(l = to+a[i].m;l <= D; l += a[i].m)    val[l] += get *k * a[i].p;
+            }
+            else    break;
+        }
+    }
+    if(cur > ans)    ans = cur;
+}
+int main() {
+    int t, w, h, A, i;
+    scanf("%d", &t);
+    while(t--) {
+        scanf("%d%d%d%d%d", &w, &h, &A, &D, &Y);
+        memset(s, 0, sizeof(s));
+        s[9] = (w/3) * (h/3);
+        s[(w%3)*3] += h/3;
+        s[(h%3)*3] += w/3;
+        if((w%3) * (h%3) == 1) {
+            s[5]++;    s[3] -= 2; s[1] += 2;
+        }
+        else if((w%3) * (h%3) == 4) {
+            s[8]++; s[6] -= 2; s[4] += 2;
+        }
+        else if((w%3)*(h%3) == 2) {
+            s[7]++; s[6]--; s[3]--; s[2] += 2;
+        }
+        else    s[(w%3)*(h%3)] ++;
+        for(i =0;i < A; i++)    scanf("%d%d%d%d", &a[i].q, &a[i].p, &a[i].n, &a[i].m);
+        ans = Y;
+        for(i = 0;i < A ; i++) {
+            if(a[i].m == 0)    solve1(i);
+            else    solve2(i);
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4601_autoAC.cpp b/HDOJ/4601_autoAC.cpp
new file mode 100644
index 0000000..315ff74
--- /dev/null
+++ b/HDOJ/4601_autoAC.cpp
@@ -0,0 +1,179 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<vector>
+#define ll __int64
+using namespace std ;
+const int maxn = 211111 ;
+int c[26][maxn] , tot , dis[maxn] , pos[maxn] , rk[maxn] ;
+int tim[maxn] , dp[25][maxn] , cnt[maxn] , g[maxn] , line[maxn] , lon[maxn] ;
+ll val[maxn] , f[25] , pow26[maxn] ;
+const int mod = 1000000007 ;
+struct Edge
+{
+    int to , next , v ;
+} edge[maxn<<1] ;
+int head[maxn] , E , n ;
+struct Point
+{
+    int id ;
+    int tim ;
+    bool operator < ( const Point &t ) const
+    {
+        return tim < t.tim ;
+    }
+} ;
+vector<Point> vec[maxn] ;
+void new_edge ( int a , int b , char *s )
+{
+    edge[E].to = b ;
+    edge[E].next = head[a] ;
+    edge[E].v = s[0] - 'a' ;
+    head[a] = E ++ ;
+    edge[E].to = a ;
+    edge[E].next = head[b] ;
+    edge[E].v = s[0] - 'a' ;
+    head[b] = E ++ ;
+}
+int new_node ()
+{
+    int i ;
+    for ( i = 0 ; i < 26 ; i ++ ) c[i][tot] = 0 ;
+    val[tot] = 0 ;
+    return tot ++ ;
+}
+int step ;
+void cal ( int u , int fa , int now )
+{
+    int i ;
+    Point fuck ;
+    for ( i = head[u] ; i != -1 ; i = edge[i].next )
+    {
+        int v = edge[i].to ;
+        if ( v == fa ) continue ;
+        dis[v] = dis[u] + 1 ;
+        tim[v] = ++ step ;
+        fuck.id = v , fuck.tim = step ;
+        vec[dis[v]].push_back ( fuck ) ;
+        int k = edge[i].v ;
+        if ( !c[k][now] ) 
+        {
+            c[k][now] = new_node () ;
+            val[c[k][now]] = ( (ll) val[now] * 26 % mod + k ) % mod ;
+        }
+        pos[v] = c[k][now] ;
+        cal ( v , u , c[k][now] ) ;
+        lon[u] = max ( lon[u] , lon[v] ) ;
+        cnt[u] += cnt[v] ;
+    }
+    lon[u] = max ( lon[u] , dis[u] ) ;
+    cnt[u] ++ ;
+}
+void cal1 ( int now )
+{
+    rk[now] = step ++ ;
+    g[rk[now]] = now ;
+    int i ;
+    for ( i = 0 ; i < 26 ; i ++ )
+        if ( c[i][now] )
+            cal1 ( c[i][now] ) ;
+}
+int dep ;
+void init ()
+{
+    for ( int i = 0 ; i <= n ; i ++ )
+    {
+        head[i] = -1 , vec[i].clear () ;
+        lon[i] = dis[i] = rk[i] = cnt[i] = 0 ;
+    }
+    tot = E = 0 ;
+    new_node () ;
+}
+int T ;
+void rmq ()
+{
+    int i , j ;
+    T = 0 ;
+    for ( i = 1 ; i <= n ; i ++ )
+    {
+        int l = vec[i].size () ;
+        if ( l == 0 ) break ;
+        line[i] = T + 1 ;
+        for ( j = 0 ; j < l ; j ++ )
+            dp[0][++T] = rk[pos[vec[i][j].id]] ;
+    }
+    for ( i = 1 ; f[i] <= T ; i ++ )
+        for ( j = 1 ; j + f[i] - 1 <= T ; j ++ )
+            dp[i][j] = max ( dp[i-1][j] , dp[i-1][j+f[i-1]] ) ;
+}
+int query ( int l , int r )
+{
+    if ( l == r ) return dp[0][l] ;
+    if ( l > r ) swap ( l , r ) ;
+    int i , j , k ;
+    for ( i = 0 ; i <= 22 ; i ++ )
+        if ( f[i] >= ( r - l + 1 ) )
+        {
+            k = i - 1 ;
+            break ;
+        }
+    return max ( dp[k][l] , dp[k][r-f[k]+1] ) ;
+}
+char s[111] ;
+int main ()
+{
+    int cas , i , j , a , b , q ;
+    f[0] = pow26[0] = 1 ;
+    for ( i = 1 ; i <= 22 ; i ++ )
+        f[i] = (ll) f[i-1] * 2 % mod ;
+    for ( i = 1 ; i < 100005 ; i ++ )
+        pow26[i] = (ll) pow26[i-1] * 26 % mod ;
+    scanf ( "%d" , &cas ) ;
+    while ( cas -- )
+    {
+        scanf ( "%d" , &n ) ;
+        init () ;
+        for ( i = 1 ; i < n ; i ++ )
+        {
+            scanf ( "%d%d%s" , &a , &b , s ) ;
+            new_edge ( a , b , s ) ;
+        }
+        step = 0 ;
+        cal ( 1 , 0 , 0 ) ;
+        step = 0 ;
+        cal1 ( 0 ) ;
+        rmq () ;
+        pos[1] = 0 ;
+        scanf ( "%d" , &q ) ;
+        while ( q -- )
+        {
+            int u , m ;
+            scanf ( "%d%d" , &u , &m ) ;
+            if ( m == 0 )
+            {
+                puts ( "0" ) ;
+                continue ;
+            }
+            if ( dis[u] + m > lon[u] )
+            {
+                puts ( "IMPOSSIBLE" ) ;
+                continue ;
+            }
+            int dep = dis[u] + m ;
+            Point fuck ;
+            fuck.tim = tim[u] ;
+            int l = lower_bound ( vec[dep].begin () , vec[dep].end () , fuck ) - vec[dep].begin () ;
+            if ( l == vec[dep].size () ) l -- ;
+            l += line[dep] ;
+            fuck.tim = tim[u] + cnt[u] - 1 ;
+            int r = upper_bound ( vec[dep].begin () , vec[dep].end () , fuck ) - vec[dep].begin () ;
+            r -- ;
+            r += line[dep] ;
+            int k = query ( l , r ) ;
+            k = g[k] ;
+            u = pos[u] ;
+            printf ( "%I64d\n" , ( val[k] - val[u] * pow26[m] % mod + mod ) % mod ) ;
+        }
+    }
+}
diff --git a/HDOJ/4602_autoAC.cpp b/HDOJ/4602_autoAC.cpp
new file mode 100644
index 0000000..701503d
--- /dev/null
+++ b/HDOJ/4602_autoAC.cpp
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int mod=1000000007;
+struct Matrix{
+    long long arr[2][2];
+};
+Matrix init,unit;
+int n,k;
+long long num[2][2]={{4,-4},{1,0}};
+void Init(){
+    for(int i=0;i<2;i++)
+        for(int j=0;j<2;j++){
+            init.arr[i][j]=num[i][j];
+            unit.arr[i][j]=(i==j)?1:0;
+        }
+}
+Matrix Mul(Matrix a,Matrix b){
+    Matrix c;
+    for(int i=0;i<2;i++)
+        for(int j=0;j<2;j++){
+            c.arr[i][j]=0;
+            for(int k=0;k<2;k++)
+                c.arr[i][j]=(c.arr[i][j]%mod+a.arr[i][k]*b.arr[k][j]%mod+mod)%mod;
+            c.arr[i][j]%=mod;
+        }
+    return c;
+}
+Matrix Pow(Matrix a,Matrix b,int k){
+    while(k){
+        if(k&1){
+            b=Mul(a,b);
+        }
+        a=Mul(a,a);
+        k>>=1;
+    }
+    return b;
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&k);
+        Init();
+        if(k>n){
+            printf("0\n");
+            continue;
+        }
+        int tmp=n-k+1;
+        if(tmp==1){
+            printf("1\n");
+            continue;
+        }
+        if(tmp==2){
+            printf("2\n");
+            continue;
+        }
+        if(tmp==3){
+            printf("5\n");
+            continue;
+        }
+        Matrix res=Pow(init,unit,tmp-3);
+        long long ans=(res.arr[0][0]*5+res.arr[0][1]*2)%mod;
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4603_autoAC.cpp b/HDOJ/4603_autoAC.cpp
new file mode 100644
index 0000000..212a703
--- /dev/null
+++ b/HDOJ/4603_autoAC.cpp
@@ -0,0 +1,370 @@
+#pragma comment(linker, "/STACK:102400000,102400000")  
+#include<iostream>  
+#include<vector>  
+#include<algorithm>  
+#include<cstdio>  
+#include<queue>  
+#include<stack>  
+#include<string>  
+#include<map>  
+#include<set>  
+#include<cmath>  
+#include<cassert>  
+#include<cstring>  
+#include<iomanip>  
+#include<ctime>  
+using namespace std;  
+#ifdef _WIN32  
+typedef __int64 i64;  
+#define out64 "%I64d\n"  
+#define in64 "%I64d"  
+#else  
+typedef long long i64;  
+#define out64 "%lld\n"  
+#define in64 "%lld"  
+#endif  
+#define foreach(c,itr)  for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)  
+#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)  
+#define FF(i,a)         for( int i = 0 ; i < (a) ; i ++)  
+#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)  
+#define S64(a)          scanf(in64,&a)  
+#define SS(a)           scanf("%d",&a)  
+#define LL(a)           ((a)<<1)  
+#define RR(a)           (((a)<<1)+1)  
+#define pb              push_back  
+#define pf              push_front  
+#define X               first  
+#define Y               second  
+#define CL(Q)           while(!Q.empty())Q.pop()  
+#define MM(name,what)   memset(name,what,sizeof(name))  
+#define MC(a,b)     memcpy(a,b,sizeof(b))  
+#define MAX(a,b)        ((a)>(b)?(a):(b))  
+#define MIN(a,b)        ((a)<(b)?(a):(b))  
+const int inf = 0x3f3f3f3f;  
+const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;  
+const double oo = 10e9;  
+const double eps = 10e-9;  
+const double pi = acos(-1.0);  
+const int maxn = 100111;  
+const int maxlevel = 21;  
+struct Node  
+{  
+    int now;  
+    int to;  
+    int c;  
+    int tot;  
+    int ss;  
+    const bool operator <  (const Node& cmp) const {  
+        return tot > cmp.tot;  
+    }  
+};  
+int all;  
+int n, m;  
+vector<Node>g[maxn];  
+int t[maxn];  
+int dep[maxn];  
+int df;  
+int dfn[maxn];  
+int dfv[maxn * 2];  
+int st[maxn * 2][maxlevel];  
+int up[maxn][maxlevel];  
+int dp[maxn];   //down sum   
+int xtof[maxn];  
+int ftox[maxn];  
+int vis[maxn];  
+int lg2[maxn*2];  
+void dfs(int now)  
+{  
+    vis[now] = true;  
+    int to;  
+    for (int i = 0; i < (int)g[now].size(); i++) {  
+        to = g[now][i].to;  
+        if (!vis[to])   {  
+            t[to] = now;  
+            dfs(to);  
+        }  
+    }  
+}  
+int treedp(int now)  
+{     
+    int to,id;  
+    dp[now] = 0;  
+    for (int i = 0; i < (int)g[now].size(); i++) {  
+        to = g[now][i].to;  
+        if (to != t[now]) {  
+            int temp = treedp(to) + g[now][i].c;  
+            g[now][i].tot = temp;  
+            dp[now] += temp;  
+        }  
+        else {  
+            id = i;  
+        }  
+    }  
+    if (t[now] != -1) {  
+        g[now][id].tot = all - dp[now];  
+    }  
+    return dp[now];  
+}  
+void euler_circuit(int now ,int step)  
+{  
+    dep[now] = step;  
+    dfn[now] = df;  
+    dfv[df++] = now;  
+    int to;  
+    for (int i = 0; i < (int)g[now].size(); i++) {  
+        to = g[now][i].to;  
+        if (to != t[now]) {  
+            euler_circuit(to,step+1);  
+            dfv[df++] = now;  
+        }  
+    }  
+}  
+void get_up_node()  
+{  
+    for (int i = 1; i <= n; i++) {  
+        up[i][0] = t[i];  
+    }  
+    int to;  
+    for (int step = 1; step < maxlevel; step++) {  
+        for (int now = 1; now <= n; now++) {  
+            to = up[now][step - 1];  
+            if (to == -1) {  
+                up[now][step] = -1;  
+            }  
+            else {  
+                up[now][step] = up[to][step - 1];  
+            }  
+        }  
+    }  
+}  
+void sparse_table()  
+{  
+    for (int i = 1; i < df; i++){  
+        st[i][0] = dep[dfv[i]];  
+    }  
+    int to;  
+    for (int step = 1; step <= lg2[n] + 1; step++){  
+        for (int now = 1; now < df; now++) {  
+            to = now + (1 << (step - 1));  
+            if (to < df){  
+                st[now][step] = min(st[now][step - 1], st[to][step - 1]);  
+            }  
+            else{  
+                st[now][step] = st[now][step - 1];  
+            }  
+        }  
+    }  
+}  
+void relation()  
+{  
+    int to;  
+    for (int now = 1; now <= n; now++){  
+        for (int i = 0; i < (int)g[now].size(); i++){  
+            to = g[now][i].to;  
+            if (to == t[now]){  
+                xtof[now] = i;  
+            }  
+            else{  
+                ftox[to] = i;  
+            }  
+        }  
+    }  
+}  
+int rmq(int l,int r)  
+{  
+    return min(st[l][lg2[r - l]], st[r - (1 << lg2[r - l])][lg2[r - l]] );  
+}  
+int calculate(int x,bool first,int id1,int id2=-1)  
+{  
+    if (id2 != -1){  
+        if (id1 > id2){  
+            swap(id1, id2);  
+        }  
+    }  
+    int sum = g[x][0].ss;  
+    sum -= g[x][id1].tot;  
+    if (id2 != -1){  
+        sum -= g[x][id2].tot;  
+    }  
+    int size = (int)g[x].size() - 1;  
+    if (size >= 1){  
+        sum += g[x][1].ss;  
+    }  
+    int ans = g[x][0].ss;  
+    if (id1 % 2 ){  
+        if (id1 + 1 <= size){  
+            ans -= g[x][id1 + 1].ss;  
+            if (id1 + 2 <= size){  
+                ans += g[x][id1 + 2].ss;  
+            }  
+        }  
+        if (id2 != -1){  
+            if (id2 % 2){  
+                ans -= g[x][id2].ss;  
+                if (id2 + 1 <= size){  
+                    ans += g[x][id2 + 1].ss;  
+                }  
+            }  
+            else{  
+                if (id2 + 1 <= size){  
+                    ans -= g[x][id2 + 1].ss;  
+                    if (id2 + 2 <= size){  
+                        ans += g[x][id2 + 2].ss;  
+                    }  
+                }  
+            }  
+        }  
+    }  
+    else{  
+        ans -= g[x][id1].ss;  
+        if (id1 + 1 <= size){  
+            ans += g[x][id1 + 1].ss;  
+        }  
+        if (id2 != -1){  
+            if (id2 % 2){  
+                ans -= g[x][id2].ss;  
+                if (id2 + 1 <= size){  
+                    ans += g[x][id2 + 1].ss;  
+                }  
+            }  
+            else{  
+                if (id2 + 1 <= size){  
+                    ans -= g[x][id2 + 1].ss;  
+                    if (id2 + 2 <= size){  
+                        ans += g[x][id2 + 2].ss;  
+                    }  
+                }  
+            }  
+        }  
+    }  
+    if (first) return ans;  
+    else return sum - ans;  
+}  
+int go_up(int now, int x)  
+{  
+    int step = 0;  
+    while (x) {  
+        if (x & 1) {  
+            now = up[now][step];  
+        }  
+        step++;  
+        x >>= 1;  
+    }  
+    return now;  
+}  
+int find(int a,int b)  
+{  
+    int l = dfn[a];  
+    int r = dfn[b];  
+    if (l == r){  
+        return g[a][0].ss;  
+    }  
+    if (l > r){  
+        swap(l, r);  
+    }  
+    int lca = rmq(l, r + 1);    
+    if (dep[a] - lca + dep[b] - lca == 1){  
+        if (dep[a] == lca){  
+            return g[b][xtof[b]].tot + calculate(b, false, xtof[b]);  
+        }  
+        else if (dep[b] == lca){  
+            return g[b][ftox[a]].tot + calculate(b, false, ftox[a]);  
+        }  
+    }  
+    else if (dep[a] > dep[b]+1){  
+        int temp = dep[a] - dep[b];  
+        int mid = lca + temp / 2;  
+        int child = go_up(a, dep[a] - mid - 1);  
+        if (temp % 2){  
+            return g[t[child]][ftox[child]].tot + calculate(t[child], false, ftox[child], xtof[t[child]]);  
+        }  
+        else{  
+            return g[t[child]][ftox[child]].tot + calculate(t[child], true, ftox[child], xtof[t[child]]);  
+        }  
+    }  
+    else if (dep[a] == dep[b] + 1) {  
+        int ca = go_up(a, dep[a] - lca - 1);  
+        int cb = go_up(b, dep[b] - lca - 1);  
+        int meet = t[ca];  
+        return g[meet][ftox[ca]].tot + calculate(meet, false, ftox[ca], ftox[cb]);  
+    }  
+    else if (dep[a] < dep[b]){  
+        int temp = dep[b] - dep[a];  
+        int mid = lca + (temp + 1)/ 2;  
+        int child = go_up(b, dep[b] - mid - 1);  
+        if (temp % 2){  
+            return g[t[child]][xtof[t[child]]].tot + calculate(t[child], false, xtof[t[child]], ftox[child]);  
+        }  
+        else{  
+            return g[t[child]][xtof[t[child]]].tot + calculate(t[child], true, xtof[t[child]], ftox[child]);  
+        }  
+    }  
+    else if(dep[a] == dep[b]) {  
+        int ca = go_up(a, dep[a] - lca - 1);  
+        int cb = go_up(b, dep[b] - lca - 1);  
+        int meet = t[ca];  
+        return g[meet][ftox[ca]].tot + calculate(meet, true, ftox[ca], ftox[cb]);  
+    }  
+    assert(false);    
+}  
+void start()  
+{  
+    for (int i = 1; i <= n; i++) {  
+        vis[i] = false;  
+    }  
+    t[0] = t[1] = -1;  
+    dfs(1);  
+    treedp(1);  
+    for (int now = 1; now <= n; now++) {  
+        sort(g[now].begin(), g[now].end());  
+        for (int i =(int) g[now].size() - 1; i >= 0; i--) {  
+            g[now][i].ss = g[now][i].tot;  
+            if (i + 3 <= (int)g[now].size()) {  
+                g[now][i].ss += g[now][i + 2].ss;  
+            }  
+        }  
+    }  
+    df = 1;  
+    euler_circuit(1, 0);  
+    get_up_node();  
+    sparse_table();  
+    relation();  
+}  
+int main()  
+{  
+    for (int i = 0; i < maxlevel; i++){  
+        if ( (1<<i) < maxn*2)  
+        lg2[1 << i] = i;  
+    }  
+    for (int i = 3; i < maxn*2; i++) {  
+        if (!lg2[i]){  
+            lg2[i] = lg2[i - 1];  
+        }  
+    }  
+    int T;  
+    cin >> T;  
+    while (T--) {  
+        all = 0;  
+        cin >> n >> m;  
+        for (int i = 0; i <= n; i++){  
+            g[i].clear();  
+        }  
+        Node node;  
+        for (int i = 1; i <= n - 1; i++) {  
+            SS(node.now);  
+            SS(node.to);  
+            SS(node.c);  
+            g[node.now].push_back(node);  
+            swap(node.now, node.to);  
+            g[node.now].push_back(node);  
+            all += node.c;  
+        }  
+        start();  
+        int a, b;  
+        for (int i = 1; i <= m; i++){  
+            SS(a); SS(b);  
+            printf("%d\n", find(a, b));  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4604_autoAC.cpp b/HDOJ/4604_autoAC.cpp
new file mode 100644
index 0000000..dc5f372
--- /dev/null
+++ b/HDOJ/4604_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#include <cmath>
+#include <map>
+#include <queue>
+#include <set>
+#include <vector>
+#define MAXM 111111
+#define MAXN 111111
+#define INF 1000000007
+#define eps 1e-8
+using namespace std;
+typedef vector<int>::iterator Viter;
+int n;
+vector<int>g;
+int a[MAXN];
+int dp1[MAXN], dp2[MAXN], num1[MAXN], num2[MAXN];
+void gao(int dp[], int num[])
+{
+    g.clear();
+    Viter it;
+    for(int i = n - 1; i >= 0; i--)
+    {
+        int sz = g.size();
+        if(!sz || a[i] >= g[sz - 1])
+        {
+            g.push_back(a[i]);
+            dp[i] = sz + 1;
+        }
+        else
+        {
+            it = upper_bound(g.begin(), g.end(), a[i]);
+            dp[i] = it - g.begin() + 1;
+            *it = a[i];
+        }
+        pair<Viter, Viter>bounds = equal_range(g.begin(), g.end(), a[i]);
+        num[i] = bounds.second - bounds.first;
+    }
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%d", &n);
+        for(int i = 0; i < n; i++) scanf("%d", &a[i]);
+        gao(dp1, num1);
+        for(int i = 0; i < n; i++) a[i] = -a[i];
+        gao(dp2, num2);
+        int ans = 0;
+        for(int i = 0; i < n; i++)
+            ans = max(ans, dp1[i] + dp2[i] - min(num1[i], num2[i]));
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4605_autoAC.cpp b/HDOJ/4605_autoAC.cpp
new file mode 100644
index 0000000..377b892
--- /dev/null
+++ b/HDOJ/4605_autoAC.cpp
@@ -0,0 +1,142 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<stdio.h>
+#include<iostream>
+#include<vector>
+#include<algorithm>
+#include<string.h>
+using namespace std;
+#define maxn 100005
+struct list
+{
+    int l,r;
+    int w;
+}node[maxn];
+int fs[maxn*2];
+int fss[maxn*2];
+struct qq
+{
+    int x;
+    int id;
+}xx;
+vector<qq>num[maxn];
+int ans[maxn][2];
+int sum[maxn][2];
+int w[maxn];
+int n,m,q,len;
+int lowbit(int x)
+{
+     return (x&(-x));
+}
+int search(int l,int r,int w)
+{
+    while(l<r)
+    {
+        int mid=(l+r)/2;
+        if(fs[mid]==w)return mid;
+        if(fs[mid]<w)l=mid+1;
+        else r=mid;
+    }
+}
+void add(int x,int bs,int num)
+{
+    for(;x<len;x+=lowbit(x))
+    {
+        sum[x][bs]+=num;
+    }
+}
+int allsum(int s,int bs)
+{
+    int ss;
+    ss=0;
+    while(s>0)
+    {
+        ss+=sum[s][bs];
+        s=s-lowbit(s);
+    }
+    return ss;
+}
+void dfs(int x)
+{
+    int s;
+    s=num[x].size();
+    for(int i=0;i<s;i++)
+    {
+        xx=num[x][i];
+        int z,id;
+        z=search(1,len,xx.x);
+        id=xx.id;
+        if(allsum(z,0)-allsum(z-1,0)+allsum(z,1)-allsum(z-1,1)>0)
+        {
+            ans[id][0]=-1;
+            continue;
+        }
+        int ll,lr,rl,rr;
+        ll=allsum(len-1,0)-allsum(z,0);
+        rl=allsum(z,0);
+        lr=allsum(len-1,1)-allsum(z,1);
+        rr=allsum(z,1);
+        ans[id][0]=rr;
+        ans[id][1]=(rl+rr)*3+ll+lr;
+    }
+    s=search(1,len,node[x].w);
+    if(node[x].l!=-1)
+    {
+        add(s,0,1);
+        dfs(node[x].l);
+        add(s,0,-1);
+    }
+    if(node[x].r!=-1)
+    {
+        add(s,1,1);
+        dfs(node[x].r);
+        add(s,1,-1);
+    }
+}
+int main()
+{
+    int T,a,b,c,i;
+    cin>>T;
+    while(T--)
+    {
+        cin>>n;
+        int ll=1;
+        memset(fs,0,sizeof(fs));
+        memset(ans,0,sizeof(ans));
+        memset(fss,0,sizeof(fss));
+        for (i = 1; i <= n; ++i) node[i].l = node[i].r = node[i].w = -1;
+        for(i=1;i<=n;i++)
+        {
+            num[i].clear();
+            scanf("%d",&w[i]);
+            node[i].w=w[i];
+            fss[ll++]=w[i];
+        }
+        cin>>m;
+        for(i=1;i<=m;i++)
+        {
+            scanf("%d%d%d",&a,&b,&c);
+            node[a].l=b;
+            node[a].r=c;
+        }
+        cin>>q;
+        for(i=1;i<=q;i++)
+        {
+            scanf("%d%d",&a,&b);
+            fss[ll++]=b;
+            xx.id=i;
+            xx.x=b;
+            num[a].push_back(xx);
+        }
+        len=1;
+        sort(fss,fss+ll);
+        for(i=1;i<ll;i++)
+            if(fss[i]!=fss[i-1])fs[len++]=fss[i];
+        dfs(1);
+        for(i=1;i<=q;i++)
+        {
+            if(ans[i][0]==-1)printf("0\n");
+            else printf("%d %d\n",ans[i][0],ans[i][1]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4606_autoAC.cpp b/HDOJ/4606_autoAC.cpp
new file mode 100644
index 0000000..77c8158
--- /dev/null
+++ b/HDOJ/4606_autoAC.cpp
@@ -0,0 +1,191 @@
+#include <stdio.h>
+#include <iostream>
+#include <algorithm>
+#include <string.h>
+#include <math.h>
+#include <vector>
+using namespace std;
+const double eps = 1e-6;
+int sgn(double x)
+{
+    if(fabs(x) < eps)return 0;
+    if(x < 0)return -1;
+    else return 1;
+}
+struct Point
+{
+    double x,y;
+    Point(double _x = 0,double _y = 0)
+    {
+        x = _x; y = _y;
+    }
+    Point operator -(const Point &b)const
+    {
+        return Point(x-b.x,y-b.y);
+    }
+    double operator ^(const Point &b)const
+    {
+        return x*b.y - y*b.x;
+    }
+    double operator *(const Point &b)const
+    {
+        return x*b.x + y*b.y;
+    }
+    void input()
+    {
+        scanf("%lf%lf",&x,&y);
+    }
+};
+struct Line
+{
+    Point s,e;
+    Line(){}
+    Line(Point _s,Point _e)
+    {
+        s = _s; e = _e;
+    }
+    void input()
+    {
+        s.input();
+        e.input();
+    }
+};
+double dist(Point a,Point b)
+{
+    return sqrt((a-b)*(a-b));
+}
+bool inter(Line l1,Line l2)
+{
+    return
+    sgn((l2.s-l1.e)^(l1.s-l1.e))*sgn((l2.e-l1.e)^(l1.s-l1.e)) < 0 &&
+    sgn((l1.s-l2.e)^(l2.s-l2.e))*sgn((l1.e-l2.e)^(l2.s-l2.e)) < 0;
+}
+const int MAXN = 440;
+Point p[MAXN];
+Line line[MAXN];
+const double INF = 100000000.0;
+double dis[MAXN][MAXN];
+int n,m,P;
+int b[MAXN];
+int uN,vN;
+struct Edge
+{
+    int to,next;
+}edge[MAXN*MAXN];
+int head[MAXN];
+int tot;
+void addedge(int u,int v)
+{
+    edge[tot].to = v;
+    edge[tot].next = head[u];
+    head[u] = tot++;
+}
+void init()
+{
+    tot = 0;
+    memset(head,-1,sizeof(head));
+}
+int linker[MAXN];
+bool used[MAXN];
+bool dfs(int u)
+{
+    for(int i = head[u]; i!= -1;i = edge[i].next)
+    {
+        int v = edge[i].to;
+        if(!used[v])
+        {
+            used[v] = true;
+            if(linker[v]==-1 || dfs(linker[v]))
+            {
+                linker[v] = u;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int hungary()
+{
+    int res = 0;
+    memset(linker,-1,sizeof(linker));
+    for(int u = 0;u < uN;u ++)
+    {
+        memset(used,false,sizeof(used));
+        if(dfs(u))res++;
+    }
+    return res;
+}
+bool check(double d)
+{
+    uN = vN = n;
+    init();
+    for(int i = 0;i < n;i++)
+        for(int j = i+1;j < n;j++)
+           if(dis[b[i]][b[j]] < d + eps)
+              addedge(b[i],b[j]);
+    if(n - hungary() <= P)return true;
+    else return false;
+}
+double solve()
+{
+    double l = 0, r = 100000.0;
+    double ans;
+    while(r-l >= eps)
+    {
+        double mid = (l+r)/2;
+        if(check(mid))
+        {
+            ans = mid;
+            r = mid - eps;
+        }
+        else l = mid + eps;
+    }
+    return ans;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d",&n,&m,&P);
+        for(int i = 0;i < n;i++)
+            p[i].input();
+        int t = n;
+        for(int i = 0;i < m;i++)
+        {
+            line[i].input();
+            p[n+2*i] = line[i].s;
+            p[n+2*i+1] = line[i].e;
+        }
+        for(int i = 0;i < n+2*m;i++)
+            for(int j = 0;j < n+2*m;j++)
+            {
+                if(i == j)
+                {
+                    dis[i][j] = 0;
+                    continue;
+                }
+                bool flag = false;
+                for(int k = 0;k < m;k++)
+                    if(inter(line[k],Line(p[i],p[j])))
+                    {
+                        flag = true;
+                        break;
+                    }
+                if(flag)dis[i][j] = 1e20;
+                else dis[i][j] = dist(p[i],p[j]);
+            }
+        for(int k = 0;k < n+2*m;k++)
+            for(int i = 0;i < n+2*m;i++)
+                for(int j = 0;j < n+2*m;j++)
+                    dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j]);
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d",&b[i]);
+            b[i]--;
+        }
+        printf("%.2lf\n",solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/4607_autoAC.cpp b/HDOJ/4607_autoAC.cpp
new file mode 100644
index 0000000..76851a7
--- /dev/null
+++ b/HDOJ/4607_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+const int N=200010;
+int head[N],to[N],ne[N],w[N];
+int dis[N],que[N];
+bool vis[N];
+int edge,m,n;
+void init()
+{
+    memset(head,-1,sizeof(head));
+    edge=0;
+}
+void add(int u,int v,int c)
+{
+    to[edge]=v,w[edge]=c,ne[edge]=head[u],head[u]=edge++;
+    to[edge]=u,w[edge]=c,ne[edge]=head[v],head[v]=edge++;
+}
+void bfs(int s)
+{
+    memset(vis,0,sizeof(vis));
+    memset(dis,0,sizeof(dis));
+    int l,r,v,u;
+    l=r=0;
+    vis[s]=1;
+    dis[s]=0;
+    que[r++]=s;
+    while(r>l)
+    {
+        u=que[l++];
+        for(int i=head[u]; ~i; i=ne[i])
+        {
+            if(!vis[v=to[i]])
+            {
+                vis[v]=1;
+                dis[v]=dis[u]+w[i];
+                que[r++]=v;
+            }
+        }
+    }
+}
+int treediameter(int s)
+{
+    int u,maxl;
+    bfs(s);
+    maxl=0,u=s;
+    for(int i=1; i<=n; i++)
+        if(dis[i]>maxl)
+            u=i,maxl=dis[i];
+    bfs(u);
+    maxl=0;
+    for(int i=1; i<=n; i++)
+        if(dis[i]>maxl)
+            maxl=dis[i];
+    return maxl;
+}
+int main()
+{
+    int u,v,d=1,t,i,j,x;
+    scanf("%d",&t);
+    while(t--)
+    {
+        init();
+        scanf("%d%d",&n,&m);
+        for(i=1;i<=n-1;i++)
+        {
+            scanf("%d%d",&u,&v);
+            add(u,v,1);
+        }
+        int ans=treediameter(1);
+        ans++;
+        while(m--)
+        {
+            scanf("%d",&x);
+            if(x<=ans) printf("%d\n",x-1);
+            else       printf("%d\n",(x-ans)*2+ans-1);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4608_autoAC.cpp b/HDOJ/4608_autoAC.cpp
new file mode 100644
index 0000000..6034c59
--- /dev/null
+++ b/HDOJ/4608_autoAC.cpp
@@ -0,0 +1,61 @@
+#include <iostream>
+#include <stdio.h>
+#include <cstring>
+using namespace std;
+char str[100050];
+int num[100050];
+int main()
+{
+    int t,i;
+    while(~scanf("%d",&t))
+    {
+        while(t--)
+        {
+            scanf("%s",str);
+            int n;
+            n = strlen(str);
+            for(i = 0;i < n;i++)
+            num[i] = str[i]-'0';
+            int rest;
+            rest  = 0;
+            for(i = 0;i < n;i++)
+            rest += num[i];
+            rest = 10-rest%10;
+            num[n-1] += rest;
+            int bit;
+            bit = 0;
+            if(num[n-1] > 9)
+            {
+                for(i = n-2;i >= 0;i--)
+                {
+                    bit++;
+                    num[i]++;
+                    num[i] %= 10;
+                    if(num[i])
+                    break;
+                }
+                if(i<0)
+                {
+                    printf("1");
+                    for(i = n-1;i > 0;i--)
+                    printf("0");
+                    puts("9");
+                }
+                else
+                {
+                    num[n-1] = (num[n-1]+1000000-bit)%10;
+                    for(i = 0;i < n;i++)
+                    printf("%d",num[i]);
+                    puts("");
+                }
+            }
+            else
+            {
+                for(i = 0;i < n;i++)
+                printf("%d",num[i]);
+                puts("");
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4609_autoAC.cpp b/HDOJ/4609_autoAC.cpp
new file mode 100644
index 0000000..a4ae71e
--- /dev/null
+++ b/HDOJ/4609_autoAC.cpp
@@ -0,0 +1,121 @@
+#include <stdio.h>
+#include <iostream>
+#include <string.h>
+#include <algorithm>
+#include <math.h>
+using namespace std;
+const double PI = acos(-1.0);
+struct complex
+{
+    double r,i;
+    complex(double _r = 0,double _i = 0)
+    {
+        r = _r; i = _i;
+    }
+    complex operator +(const complex &b)
+    {
+        return complex(r+b.r,i+b.i);
+    }
+    complex operator -(const complex &b)
+    {
+        return complex(r-b.r,i-b.i);
+    }
+    complex operator *(const complex &b)
+    {
+        return complex(r*b.r-i*b.i,r*b.i+i*b.r);
+    }
+};
+void change(complex y[],int len)
+{
+    int i,j,k;
+    for(i = 1, j = len/2;i < len-1;i++)
+    {
+        if(i < j)swap(y[i],y[j]);
+        k = len/2;
+        while( j >= k)
+        {
+            j -= k;
+            k /= 2;
+        }
+        if(j < k)j += k;
+    }
+}
+void fft(complex y[],int len,int on)
+{
+    change(y,len);
+    for(int h = 2;h <= len;h <<= 1)
+    {
+        complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
+        for(int j = 0;j < len;j += h)
+        {
+            complex w(1,0);
+            for(int k = j;k < j+h/2;k++)
+            {
+                complex u = y[k];
+                complex t = w*y[k+h/2];
+                y[k] = u+t;
+                y[k+h/2] = u-t;
+                w = w*wn;
+            }
+        }
+    }
+    if(on == -1)
+        for(int i = 0;i < len;i++)
+            y[i].r /= len;
+}
+const int MAXN = 400040;
+complex x1[MAXN];
+int a[MAXN/4];
+long long num[MAXN];
+long long sum[MAXN];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        memset(num,0,sizeof(num));
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d",&a[i]);
+            num[a[i]]++;
+        }
+        sort(a,a+n);
+        int len1 = a[n-1]+1;
+        int len = 1;
+        while( len < 2*len1 )len <<= 1;
+        for(int i = 0;i < len1;i++)
+            x1[i] = complex(num[i],0);
+        for(int i = len1;i < len;i++)
+            x1[i] = complex(0,0);
+        fft(x1,len,1);
+        for(int i = 0;i < len;i++)
+            x1[i] = x1[i]*x1[i];
+        fft(x1,len,-1);
+        for(int i = 0;i < len;i++)
+            num[i] = (long long)(x1[i].r+0.5);
+        len = 2*a[n-1];
+        for(int i = 0;i < n;i++)
+            num[a[i]+a[i]]--;
+        for(int i = 1;i <= len;i++)
+        {
+            num[i]/=2;
+        }
+        sum[0] = 0;
+        for(int i = 1;i <= len;i++)
+            sum[i] = sum[i-1]+num[i];
+        long long cnt = 0;
+        for(int i = 0;i < n;i++)
+        {
+            cnt += sum[len]-sum[a[i]];
+            cnt -= (long long)(n-1-i)*i;
+            cnt -= (n-1);
+            cnt -= (long long)(n-1-i)*(n-i-2)/2;
+        }
+        long long tot = (long long)n*(n-1)*(n-2)/6;
+        printf("%.7lf\n",(double)cnt/tot);
+    }
+    return 0;
+}
diff --git a/HDOJ/4610_autoAC.cpp b/HDOJ/4610_autoAC.cpp
new file mode 100644
index 0000000..72ee2c3
--- /dev/null
+++ b/HDOJ/4610_autoAC.cpp
@@ -0,0 +1,142 @@
+#include<cstdio>
+#include<iostream>
+#include<bitset>
+#include<cmath>
+#include<cstring>
+#include<vector>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const int N = (int)4e6+10;
+const int M = (int)1e6+10;
+typedef pair<int,int> pii;
+bool p[N];
+int prime[M];
+void init(){
+    memset(p,true,sizeof(p));
+    p[0] = p[1] = false;
+    for(int i=2;i*i<N;i++)
+        for(int j=i;j*i<N;j++)
+            p[i*j] = 0;
+    prime[0] = 0;
+    for(int i=2;i<N;i++)
+        if(p[i])prime[++prime[0]] = i;
+}
+vector<pii>factor;
+void div(int n){
+    factor.clear();
+    for(int i=1;prime[i] * prime[i] <= n;i++){
+        if(n % prime[i]  == 0){
+            int cnt = 0;
+            while(n % prime[i] == 0){
+                n /= prime[i];
+                ++cnt;
+            }
+            factor.push_back(make_pair(prime[i],cnt));
+        }
+    }
+    if(n > 1)factor.push_back(make_pair(n,1));
+}
+ll Pow(ll a,ll b){
+    ll ans = 1;
+    while(b){
+        if(b&1)ans = ans * a;
+        a = a * a;
+        b >>= 1;
+    }
+    return ans;
+}
+bool isPrime_amount(int n){
+    if(factor.size() > 1|| n==1 )return false;
+    return p[factor[0].second + 1];
+}
+bool isPrime_sum(int n){
+    if(factor.size() > 1|| n== 1)return false;
+    int a = factor[0].first,b = factor[0].second;
+    int sum = 1LL*(Pow(a,b+1) - 1) / (a - 1);
+    return p[sum];
+}
+bool isSquare(ll n){
+    ll _ = sqrt(n*1.0);
+    return _ * _ == n;
+}
+bool isSquare_product(int n){
+    int all = 1;
+    for(int i=0;i<factor.size();i++)
+        all *= factor[i].second + 1;
+    ll sq = sqrt(n*1.0);
+    ll cur = 1;
+    int p = all >> 1;
+    if(p & 1)cur *= n;
+    if(all & 1)cur *= sq;
+    return isSquare(cur);
+}
+int extra[5];
+int V[16],cur[5],hash[16];
+int have[16];
+int main(){
+    for(int i=0;i<16;i++){
+        int all = 0;
+        for(int j=0;j<4;j++)
+            if(!(i&(1<<j)))++all;
+        have[i] = all;
+    }
+    init();
+    int T,n,K;
+    scanf("%d",&T);
+    while(T--){
+        memset(V,0,sizeof(V));
+        scanf("%d%d",&n,&K);
+        for(int i=1;i<=n;i++){
+            int a,b;
+            scanf("%d%d",&a,&b);
+            int flag = 15,cnt = 0;
+            div(a);
+            if(p[a])flag ^= 1<<0 ,cnt ++;
+            if(isPrime_amount(a)) flag ^= 1<<1,cnt ++;
+            if(isPrime_sum(a))flag ^= 1<<2,cnt ++;
+            if(isSquare_product(a)) flag ^= 1<<3,cnt++;
+            V[flag] += b;
+            if(i!=1)printf(" ");
+            printf("%d",cnt);
+        }
+        puts("");
+        int ans = -(~0u>>2);
+        for(int i=0;i< 4;i++)scanf("%d",&extra[i]);
+        for(int i=0;i < 1<<16;i++){
+            memset(cur,0,sizeof(cur));
+            int res = K,number = 0,all = 0;
+            int flag = 15;
+            for(int j = 0;j < 16;j++){
+                if(i&(1<<j)){
+                    if(V[j] > 0){
+                        flag &= j;
+                        res --;
+                        all += have[j];
+                        cur[have[j]] += V[j] - 1;
+                    }else{
+                        res = -1;
+                        break;
+                    }
+                }
+            }
+            if(res < 0 )continue;
+            for(int k=4;k >= 0 && res > 0;k--){
+                if(cur[k] <= res){
+                    all += k * cur[k];
+                    res -= cur[k];
+                }else{
+                    all += res * k;
+                    res =0;
+                }
+            }
+            if(res == 0){
+                for(int j=0;j<4;j++)
+                    if(flag & (1<<j))all += extra[j];
+                ans = max(ans,all);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4611_autoAC.cpp b/HDOJ/4611_autoAC.cpp
new file mode 100644
index 0000000..538073b
--- /dev/null
+++ b/HDOJ/4611_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+long long gcd(long long x,long long y)
+{
+    return y==0?x:gcd(y,x%y);
+}
+long long Count(long long n,long long a,long long b)
+{
+    long long now=0,ret=0,tmp,x=0,y=0;
+    while(now<n)
+    {
+        tmp=min(a-x,b-y);
+        if (now+tmp>n) tmp=n-now;
+        ret+=tmp*abs(x-y);
+        x=(x+tmp)%a;
+        y=(y+tmp)%b;
+        now+=tmp;
+    }
+    return ret;
+}
+int main()
+{
+    int i,j,T;
+    long long a,b,n,l,ans;
+    scanf("%d",&T);
+    while(T--)
+    {
+        cin>>n>>a>>b;
+        l=a*b/gcd(a,b);
+        if (l>=n) ans=Count(n,a,b);
+        else ans=Count(l,a,b)*(n/l)+Count(n%l,a,b);
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4612_autoAC.cpp b/HDOJ/4612_autoAC.cpp
new file mode 100644
index 0000000..b824bc4
--- /dev/null
+++ b/HDOJ/4612_autoAC.cpp
@@ -0,0 +1,171 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include<iostream>
+#include<string>
+#include<algorithm>
+#include<cstdlib>
+#include<cstdio>
+#include<set>
+#include<map>
+#include<vector>
+#include<cstring>
+#include<stack>
+#include<cmath>
+#include<queue>
+using namespace std;
+#define CL(x,v); memset(x,v,sizeof(x));
+#define INF 0x3f3f3f3f
+#define LL long long
+#define REP(i,r,n) for(int i=r;i<=n;i++)
+#define RREP(i,n,r) for(int i=n;i>=r;i--)
+const int MAXN=2e5+100;
+int n,m;
+struct Edge{
+    int u,v;
+    Edge(){}
+    Edge(int a,int b){
+        u=a;
+        v=b;
+    }
+};
+vector<Edge> edges;
+vector<int> G[MAXN];
+vector<int> P[MAXN];
+int dfs_clock,bcc_cnt;
+int pre[MAXN];
+int T[MAXN];
+int dfs1(int u,int fa)
+{
+    int lowu=pre[u]=++dfs_clock;
+    for(int i=0;i<G[u].size();i++)
+    {
+        int mm=G[u][i];
+        int v=edges[mm].v;
+        if(fa==(mm^1))continue;
+        if(!pre[v])
+        {
+            int lowv=dfs1(v,mm);
+            lowu=min(lowu,lowv);
+            if(lowv>pre[u])
+            {
+                P[v].push_back(u);
+                P[u].push_back(v);
+            }
+        }
+        else if(pre[v]<pre[u])
+        {
+            lowu=min(pre[v],lowu);
+        }
+    }
+    return lowu;
+}
+void dfs2(int u,int fa)
+{
+    T[u]=bcc_cnt;
+    for(int i=0;i<G[u].size();i++)
+    {
+        int v=edges[G[u][i]].v;
+        bool f=true;
+        for(int j=0;j<P[u].size();j++)
+        {
+            int vv=P[u][j];
+            if(v==vv)
+            {
+                f=false;break;
+            }
+        }
+        if(!f||T[v])continue;
+        dfs2(v,u);
+    }
+}
+void find_bcc(int n)
+{
+     dfs_clock=0,bcc_cnt=0;
+    memset(pre,0,sizeof(pre));
+    memset(T,0,sizeof(T));
+    for(int i=1;i<=n;i++)
+        if(!pre[i])
+            dfs1(i,-1);
+    for(int i=1;i<=n;i++)
+        if(!T[i])
+        {
+            bcc_cnt++;
+            dfs2(i,-1);
+        }
+}
+vector<int> GG[MAXN];
+int d[MAXN];
+void dfs(int u,int dep)
+{
+    d[u]=dep;
+    for(int i=0;i<GG[u].size();i++)
+    {
+        int v=GG[u][i];
+        if(!d[v])
+        {
+            dfs(v,dep+1);
+        }
+    }
+}
+int main()
+{
+    while(~scanf("%d%d",&n,&m))
+    {
+        if(n+m==0)break;
+        REP(i,0,n){
+            G[i].clear();
+            P[i].clear();
+        }
+        edges.clear();
+        int a,b;
+        REP(i,1,m)
+        {
+            scanf("%d%d",&a,&b);
+            Edge e;
+            e=Edge(a,b);
+            edges.push_back(e);
+            e=Edge(b,a);
+            edges.push_back(e);
+            int mm=edges.size();
+            G[a].push_back(mm-2);
+            G[b].push_back(mm-1);
+        }
+        find_bcc(n);
+        REP(i,0,n)
+        {
+            GG[i].clear();
+        }
+        for(int i=1;i<=n;i++)
+        {
+            for(int j=0;j<P[i].size();j++)
+            {
+                int v=P[i][j];
+                if(T[i]!=T[v])
+                {
+                    GG[T[i]].push_back(T[v]);
+                }
+            }
+        }
+        CL(d,0);
+        dfs(1,1);
+        int maxn=0;
+        int flag=0;
+        for(int i=1;i<=bcc_cnt;i++)
+        {
+            if(d[i]>maxn)
+            {
+                maxn=d[i];
+                flag=i;
+            }
+        }
+        CL(d,0);
+        dfs(flag,1);
+        maxn=0;
+        for(int i=1;i<=bcc_cnt;i++)
+        {
+            if(d[i]>maxn)
+                maxn=d[i];
+        }
+        cout<<bcc_cnt-maxn<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4614_autoAC.cpp b/HDOJ/4614_autoAC.cpp
new file mode 100644
index 0000000..a8dd213
--- /dev/null
+++ b/HDOJ/4614_autoAC.cpp
@@ -0,0 +1,205 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+#include <set>
+#include <map>
+#include <vector>
+#include <queue>
+#include <string>
+#include <math.h>
+using namespace std;
+const int MAXN = 50010;
+struct Node
+{
+    int l,r;
+    int sum;
+    int lazy;
+    int first;
+    int last;
+}segTree[MAXN*3];
+void push_up(int i)
+{
+    if(segTree[i].l==segTree[i].r)return;
+    segTree[i].sum = segTree[i<<1].sum+segTree[(i<<1)|1].sum;
+    if(segTree[i<<1].first != -1)segTree[i].first = segTree[i<<1].first;
+    else segTree[i].first = segTree[(i<<1)|1].first;
+    if(segTree[(i<<1)|1].last != -1)segTree[i].last = segTree[(i<<1)|1].last;
+    else segTree[i].last = segTree[(i<<1)].last;
+}
+void push_down(int i)
+{
+    if(segTree[i].r == segTree[i].l)return;
+    if(segTree[i].lazy==1)
+    {
+        segTree[i<<1].first = segTree[i<<1].l;
+        segTree[i<<1].last = segTree[i<<1].r;
+        segTree[i<<1].sum = segTree[i<<1].r-segTree[i<<1].l+1;
+        segTree[i<<1].lazy=1;
+        segTree[(i<<1)|1].first = segTree[(i<<1)|1].l;
+        segTree[(i<<1)|1].last = segTree[(i<<1)|1].r;
+        segTree[(i<<1)|1].sum = segTree[(i<<1)|1].r-segTree[(i<<1)|1].l+1;
+        segTree[(i<<1)|1].lazy=1;
+    }
+    if(segTree[i].lazy == -1)
+    {
+        segTree[i<<1].first = -1;
+        segTree[i<<1].last = -1;
+        segTree[i<<1].sum = 0;
+        segTree[i<<1].lazy=-1;
+        segTree[(i<<1)|1].first = -1;
+        segTree[(i<<1)|1].last = -1;
+        segTree[(i<<1)|1].sum = 0;
+        segTree[(i<<1)|1].lazy=-1;
+    }
+    segTree[i].lazy = 0;
+}
+void build(int i,int l,int r)
+{
+    segTree[i].l = l;
+    segTree[i].r = r;
+    segTree[i].sum = r-l+1;
+    segTree[i].lazy = 0;
+    segTree[i].first = l;
+    segTree[i].last = r;
+    if(l==r)return ;
+    int mid = (l+r)/2;
+    build(i<<1,l,mid);
+    build((i<<1)|1,mid+1,r);
+}
+void update(int i,int l,int r,int type)
+{
+    if(segTree[i].l == l && segTree[i].r==r)
+    {
+        if(type == 0)
+        {
+            if(segTree[i].sum == 0)return;
+            segTree[i].sum = 0;
+            segTree[i].lazy = -1;
+            segTree[i].first = -1;
+            segTree[i].last = -1;
+            return;
+        }
+        else if(type == 1)
+        {
+            if(segTree[i].sum == segTree[i].r-segTree[i].l+1)return;
+            segTree[i].sum = segTree[i].r-segTree[i].l+1;
+            segTree[i].lazy = 1;
+            segTree[i].first = segTree[i].l;
+            segTree[i].last = segTree[i].r;
+            return;
+        }
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)/2;
+    if(r <= mid)update(i<<1,l,r,type);
+    else if(l > mid)update((i<<1)|1,l,r,type);
+    else
+    {
+        update(i<<1,l,mid,type);
+        update((i<<1)|1,mid+1,r,type);
+    }
+    push_up(i);
+}
+int sum(int i,int l,int r)
+{
+    if(segTree[i].l == l && segTree[i].r == r)
+    {
+        return segTree[i].sum;
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)/2;
+    if(r <= mid)return sum(i<<1,l,r);
+    else if(l > mid)return sum((i<<1)|1,l,r);
+    else return sum((i<<1)|1,mid+1,r)+sum(i<<1,l,mid);
+}
+int n,m;
+int query1(int i,int l,int r)
+{
+    if(segTree[i].l == l && segTree[i].r == r)
+    {
+        return segTree[i].first;
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)/2;
+    int ans1,ans2;
+    if(r <= mid)return query1(i<<1,l,r);
+    else if(l > mid)return query1((i<<1)|1,l,r);
+    else
+    {
+        ans1 = query1(i<<1,l,mid);
+        if(ans1 != -1)return ans1;
+        return query1((i<<1)|1,mid+1,r);
+    }
+}
+int query2(int i,int l,int r)
+{
+    if(segTree[i].l == l && segTree[i].r == r)
+    {
+        return segTree[i].last;
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)/2;
+    int ans1,ans2;
+    if(r <= mid)return query2(i<<1,l,r);
+    else if(l > mid)return query2((i<<1)|1,l,r);
+    else
+    {
+        ans1 = query2((i<<1)|1,mid+1,r);
+        if(ans1 != -1)return ans1;
+        return query2(i<<1,l,mid);
+    }
+}
+int bisearch(int A,int F)
+{
+    if(sum(1,A,n)==0)return -1;
+    if(sum(1,A,n)<F)return n;
+    int l= A,r = n;
+    int ans=A;
+    while(l<=r)
+    {
+        int mid = (l+r)/2;
+        if(sum(1,A,mid)>=F)
+        {
+            ans = mid;
+            r = mid-1;
+        }
+        else l = mid+1;
+    }
+    return ans;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&n,&m);
+        build(1,1,n);
+        int op,u,v;
+        while(m--)
+        {
+            scanf("%d%d%d",&op,&u,&v);
+            if(op == 1)
+            {
+                u++;
+                int t = bisearch(u,v);
+                if(t==-1)
+                {
+                    printf("Can not put any one.\n");
+                    continue;
+                }
+                printf("%d %d\n",query1(1,u,t)-1,query2(1,u,t)-1);
+                update(1,u,t,0);
+            }
+            else
+            {
+                u++;v++;
+                printf("%d\n",v-u+1-sum(1,u,v));
+                update(1,u,v,1);
+            }
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4616_autoAC.cpp b/HDOJ/4616_autoAC.cpp
new file mode 100644
index 0000000..40dc7b7
--- /dev/null
+++ b/HDOJ/4616_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <cstdio>
+#include <cstring>
+#define  N 50005
+#define INF 99999999
+struct Edge
+{
+    int e, next;
+}edge[N*2];
+int head[N], eNum;
+int c[N], val[N], n, k, ans, dp[N][4][2];
+void init()
+{
+    memset(head, -1, sizeof(head));
+    eNum = 0; ans = 0;
+    for(int i=0; i<n; i++)
+    {
+        for(int j=0; j<4; j++)
+        {
+            for(int l=0; l<2; l++)
+                dp[i][j][l] = -INF;
+        }
+    }
+}
+void AddEdge(int u, int v)
+{
+    edge[eNum].e = v;
+    edge[eNum].next = head[u];
+    head[u] = eNum++;
+}
+int max2(int x, int y)
+{
+    return x > y ? x : y;
+}
+void dfs(int u, int fa)
+{
+    dp[u][c[u]][c[u]] = val[u]; 
+    for(int i=head[u]; i!=-1; i=edge[i].next)
+    {
+        int v = edge[i].e;
+        if(v==fa) continue;
+        dfs(v, u);
+        for(int j=0; j<=k; j++) 
+        {
+            for(int l=0; l+j<=k; l++)
+            {
+                ans = max2(ans, dp[u][j][1]+dp[v][l][1]); 
+                if(j+l!=k) ans = max2(ans, dp[u][j][0]+dp[v][l][0]); 
+                ans = max2(ans, dp[u][j][0]+dp[v][l][1]); 
+                ans = max2(ans, dp[u][j][1]+dp[v][l][0]); 
+            }
+        }
+        for(int j=0; j<k; j++)
+        {
+            dp[u][j+c[u]][1] = max2(dp[u][j+c[u]][1],dp[v][j][1]+val[u]); 
+            dp[u][j+c[u]][0] = max2(dp[u][j+c[u]][0],dp[v][j][0]+val[u]);
+        }
+        if(c[u]==0) dp[u][k][1] = max2(dp[u][k][1], dp[v][k][1]+val[u]); 
+    }
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&k);
+        for(int i=0; i<n; i++)
+            scanf("%d%d",&val[i],&c[i]);
+        init();
+        int u, v;
+        for(int i=0; i<n-1; i++)
+        {
+            scanf("%d%d",&u,&v);
+            AddEdge(u, v);
+            AddEdge(v, u);
+        }
+        dfs(0,-1);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4617_autoAC.cpp b/HDOJ/4617_autoAC.cpp
new file mode 100644
index 0000000..c4ea368
--- /dev/null
+++ b/HDOJ/4617_autoAC.cpp
@@ -0,0 +1,120 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+#include <set>
+#include <map>
+#include <vector>
+#include <queue>
+#include <string>
+#include <math.h>
+using namespace std;
+const double eps = 1e-8;
+int sgn(double x)
+{
+    if(fabs(x) < eps)return 0;
+    if(x < 0)return -1;
+    else return 1;
+}
+struct Point3D
+{
+    double x,y,z;
+    Point3D(double _x = 0,double _y = 0,double _z = 0)
+    {
+        x = _x;
+        y = _y;
+        z = _z;
+    }
+    Point3D operator -(const Point3D &b)const
+    {
+        return Point3D(x-b.x,y-b.y,z-b.z);
+    }
+    Point3D operator ^(const Point3D &b)const
+    {
+        return Point3D(y*b.z-z*b.y,z*b.x-x*b.z,x*b.y-y*b.x);
+    }
+    double operator *(const Point3D &b)const
+    {
+        return x*b.x+y*b.y+z*b.z;
+    }
+    void input()
+    {
+        scanf("%lf%lf%lf",&x,&y,&z);
+    }
+};
+double Norm(Point3D p)
+{
+    return sqrt(p*p);
+}
+double calc(Point3D a,Point3D k1,Point3D b,Point3D k2)
+{
+    Point3D tmp = k1^k2;
+    return fabs(tmp*(a-b))/sqrt(tmp*tmp);
+}
+struct Node
+{
+    Point3D o,p1,p2;
+    void input()
+    {
+        o.input();
+        p1.input();
+        p2.input();
+    }
+}node[50];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        for(int i = 0;i < n;i++)
+            node[i].input();
+        bool flag = false;
+        double Min = 1e20;
+        for(int i = 0;i < n;i++)
+            for(int j = i+1;j < n;j++)
+            {
+                if(flag)break;
+                double  r1 = sqrt((node[i].p1-node[i].o)*(node[i].p1-node[i].o));
+                double  r2 = sqrt((node[j].p1-node[j].o)*(node[j].p1-node[j].o));
+                Point3D  k1 = (node[i].p1-node[i].o)^(node[i].p2-node[i].o);
+                Point3D  k2 = (node[j].p1-node[j].o)^(node[j].p2-node[j].o);
+                if(sgn(Norm(k1^k2))==0)
+                {
+                    if(sgn( Norm( k1^(node[i].o-node[j].o)) ) == 0)
+                    {
+                        if(sgn(r1-r2) == 0)
+                        {
+                            flag = true;
+                            break;
+                        }
+                        else continue;
+                    }
+                    else
+                    {
+                        double dd = (k1*(node[i].o-node[j].o))/Norm(k1);
+                        double d = sqrt( Norm(node[i].o-node[j].o)*Norm(node[i].o-node[j].o) - dd*dd );
+                        if(d > fabs(r1-r2) &&d < fabs(r1+r2))
+                        {
+                            flag = true;
+                            break;
+                        }
+                        Min = min(Min,d-r1-r2);
+                    }
+                    continue;
+                }
+                double d = calc(node[i].o,k1,node[j].o,k2);
+                if(d < r1 + r2 -eps)
+                {
+                    flag = true;
+                    break;
+                }
+                Min = min(Min,d-r1-r2);
+            }
+        if(flag || sgn(Min)<=0)printf("Lucky\n");
+        else printf("%.2lf\n",Min);
+    }
+    return 0;
+}
diff --git a/HDOJ/4619_autoAC.cpp b/HDOJ/4619_autoAC.cpp
new file mode 100644
index 0000000..3feca92
--- /dev/null
+++ b/HDOJ/4619_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<string.h>
+#include<vector>
+using namespace std;
+const int MAXN=2505;
+int linker[MAXN];
+bool used[MAXN];
+vector<int>map[MAXN];
+int uN;
+bool dfs(int u)
+{
+    for(int i=0;i<map[u].size();i++)
+    {
+        if(!used[map[u][i]])
+        {
+            used[map[u][i]]=true;
+            if(linker[map[u][i]]==-1||dfs(linker[map[u][i]]))
+            {
+                linker[map[u][i]]=u;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int hungary()
+{
+    int u;
+    int res=0;
+    memset(linker,-1,sizeof(linker));
+    for(u=0;u<uN;u++)
+    {
+        memset(used,false,sizeof(used));
+        if(dfs(u)) res++;
+    }
+    return res;
+}
+pair<int,int>p1[MAXN];
+pair<int,int>p2[MAXN];
+int main()
+{
+    int n,m;
+    int x,y;
+    while(scanf("%d%d",&n,&m)==2)
+    {
+        if(n==0 &&m==0)break;
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d%d",&x,&y);
+            p1[i]= make_pair(x,y);
+        }
+        for(int i = 0;i < m;i++)
+        {
+            scanf("%d%d",&x,&y);
+            p2[i]= make_pair(x,y);
+        }
+        uN = n;
+        for(int i = 0;i < n;i++)
+            map[i].clear();
+        for(int i = 0;i < n;i++)
+        {
+            for(int j = 0;j < m;j++)
+            {
+                int x1 = p1[i].first;
+                int y1 = p1[i].second;
+                int x2 = p2[j].first;
+                int y2 = p2[j].second;
+                if( (x1==x2 && y1==y2)
+                   ||(x1==x2 && y1==y2+1)
+                   ||(x1+1==x2 && y1==y2)
+                   ||(x1+1==x2 && y1==y2+1)
+                   )
+                    map[i].push_back(j);
+            }
+        }
+        int ans = n+m-hungary();
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4620_autoAC.cpp b/HDOJ/4620_autoAC.cpp
new file mode 100644
index 0000000..cf1c9d3
--- /dev/null
+++ b/HDOJ/4620_autoAC.cpp
@@ -0,0 +1,76 @@
+#include <iostream>
+#include <cstring>
+#include <string>
+#include <cstdio>
+#include <algorithm>
+#include <vector>
+#include <cmath>
+using namespace std;
+struct node
+{
+    int t,p[15],c,id;
+}cut[35];
+bool cmp(node x,node y)
+{
+    return x.t<y.t;
+}
+int T,longe,ans[35],tmpa[35],tmpl,n,w,m,vis[205],num;
+void dfs(int pos,int lastt)
+{
+    if(n-pos+tmpl<=longe) return;
+    int num,i,j,tmp;
+    for(i=pos+1;i<=n;i++)
+    {
+        for(j=1,num=0;j<=cut[i].c;j++)
+        {
+            tmp=cut[i].p[j];
+            if(vis[tmp]==0)
+                num++;
+            vis[tmp]++;
+        }
+        if((cut[i].t-lastt<=w||!tmpl)&&num>=3)
+        {
+            tmpl++;
+            tmpa[tmpl]=cut[i].id;
+            dfs(i,cut[i].t);
+            tmpl--;
+        }
+        for(j=1;j<=cut[i].c;j++)
+        {
+            tmp=cut[i].p[j];
+            vis[tmp]--;
+        }
+    }
+    if(longe<tmpl)
+    {
+        longe=tmpl;
+        for(j=0;j<longe;j++)
+            ans[j]=tmpa[j+1];
+    }
+}
+int main()
+{
+    int i,j;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d",&n,&m,&w);
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d%d",&cut[i].c,&cut[i].t);
+            for(j=1;j<=cut[i].c;j++)
+                scanf("%d",&cut[i].p[j]);
+            cut[i].id=i;
+        }
+        sort(cut+1,cut+n+1,cmp);
+        memset(vis,0,sizeof vis);
+        longe=0;tmpl=0;
+        dfs(0,cut[1].t);
+        sort(ans,ans+longe);
+        printf("%d\n",longe);
+        for(i=0;i<longe-1;i++)
+            printf("%d ",ans[i]);
+        printf("%d\n",ans[longe-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4622_autoAC.cpp b/HDOJ/4622_autoAC.cpp
new file mode 100644
index 0000000..bee8be0
--- /dev/null
+++ b/HDOJ/4622_autoAC.cpp
@@ -0,0 +1,116 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include <stdlib.h>
+#define ll __int64
+using namespace std ;
+const int maxn = 1111111 ;
+ll f[maxn] , g[maxn] ;
+int wa[maxn] , wb[maxn] , wv[maxn] , ws[maxn] , pos[maxn] ;
+struct suf
+{
+    int sa[maxn] , hei[maxn] , rank[maxn] ;
+    int cmp ( int *r , int i , int j , int l )
+    {
+        return r[i] == r[j] && r[i+l] == r[j+l] ;
+    }
+    void da ( int *r , int n , int m )
+    {
+        int *x = wa , *y = wb , *t ;
+        int i , j , p ;
+        for ( i = 0 ; i < m ; i ++ ) ws[i] = 0 ;
+        for ( i = 0 ; i < n ; i ++ ) ws[x[i]=r[i]] ++ ;
+        for ( i = 1 ; i < m ; i ++ ) ws[i] += ws[i-1] ;
+        for ( i = n - 1 ; i >= 0 ; i -- ) sa[--ws[x[i]]] = i ;
+        for ( j = 1 , p = 1 ; p < n ; j *= 2 , m = p )
+        {
+            for ( p = 0 , i = n - j ; i < n ; i ++ ) y[p++] = i ;
+            for ( i = 0 ; i < n ; i ++ ) if ( sa[i] >= j ) y[p++] = sa[i] - j ;
+            for ( i = 0 ; i < m ; i ++ ) ws[i] = 0 ;
+            for ( i = 0 ; i < n ; i ++ ) ws[x[i]] ++ ;
+            for ( i = 1 ; i < m ; i ++ ) ws[i] += ws[i-1] ;
+            for ( i = n - 1 ; i >= 0 ; i -- ) sa[--ws[x[y[i]]]] = y[i] ;
+            for ( t = x , x = y , y = t , p = 1 , x[sa[0]] = 0 , i = 1 ; i < n ; i ++ )
+                x[sa[i]] = cmp ( y , sa[i-1] , sa[i] , j ) ? p - 1 : p ++ ;
+        }
+        int k = 0 ;
+        for ( i = 1 ; i < n ; i ++ ) rank[sa[i]] = i ; 
+        for ( i = 0 ; i < n - 1 ; hei[rank[i++]] = k )
+            for ( k ? k -- : 0 , j = sa[rank[i]-1] ; r[i+k] == r[j+k] ; k ++ ) ;
+    }
+    int solve ( int n )
+    {
+        int ans = 0 , i ;
+        for ( i = 1 ; i <= n ; i ++ )
+            ans += n - sa[i] - hei[i] ;
+        return ans ;
+    }
+} arr ;
+int s1[maxn] , dp[20][2222] ;
+void rmq ( int n )
+{
+    int i , j ;
+    f[0] = 1 ;
+    for ( i = 1 ; i <= 15 ; i ++ )
+        f[i] = f[i-1] * 2 ;
+    g[0] = -1 ;
+    for ( i = 1 ; i < 2222 ; i ++ )
+        g[i] = g[i>>1] + 1 ;
+    for ( i = 1 ; f[i] <= n ; i ++ )
+        for ( j = 1 ; j + f[i] - 1 <= n ; j ++ )
+            dp[i][j] = min ( dp[i-1][j] , dp[i-1][j+f[i-1]] ) ;
+}
+int query ( int l , int r )
+{
+    if ( l == r ) return dp[0][l] ;
+    if ( l > r ) swap ( l , r ) ;
+    int i , j , k ;
+    k = g[r-l+1] ;
+    return min ( dp[k][l] , dp[k][r-f[k]+1] ) ;
+}
+char s[maxn] ;
+int num[maxn] ;
+int main ()
+{
+    int n , k , i , l , r ;
+    int cas ;
+    scanf ( "%d" , &cas ) ;
+    while ( cas -- )
+    {
+        int q ;
+        scanf ( "%s" , s ) ;
+        int len = strlen ( s ) ;
+        for ( i = 0 ; i < len ; i ++ ) s1[i] = s[i] ;
+        s1[len] = 0 ;
+        arr.da ( s1 , len + 1 , 555 ) ;
+        for ( i = 1 ; i <= len ; i ++ )
+            dp[0][i] = arr.hei[i] ;
+        rmq ( len ) ;
+        n = len ;
+        scanf ( "%d" , &q ) ;
+        while ( q -- )
+        {
+            scanf ( "%d%d" , &l , &r ) ;
+            int ans = ( r - l + 1 ) * ( r - l + 2) / 2 ;
+            for ( i = 0 ; i <= n ; i ++ ) pos[i] = -1 ;
+            for ( i = l ; i <= r ; i ++ ) 
+                pos[arr.rank[i-1]] = i - 1 ;
+            int last = -1 , d = 0 ;
+            for ( i = 1 ; i <= n ; i ++ )
+            {
+                if ( pos[i] != -1 )
+                {
+                    if ( last != -1 )
+                    {
+                        int t = query ( arr.rank[last] + 1 , arr.rank[pos[i]] ) ;
+                        d = min ( d , t ) ;
+                        d = max ( d , min ( t , r - last ) ) ;
+                        ans -= min ( d , r - pos[i] ); 
+                    }
+                    last = pos[i] ;
+                }
+            }
+            printf ( "%d\n" , ans ) ;
+        }
+    }
+}
diff --git a/HDOJ/4623_autoAC.cpp b/HDOJ/4623_autoAC.cpp
new file mode 100644
index 0000000..16a0a56
--- /dev/null
+++ b/HDOJ/4623_autoAC.cpp
@@ -0,0 +1,123 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+const int prime[]={2,3,5,7,11,13,17,19,23};
+const int np=9;
+int state[30];
+int g[300][300];
+int vi[300];
+int num[30];
+int base[30];
+short dp[19][2000000];
+bool ok[29];
+int n,m,ns,st;
+void ini()
+{
+    scanf("%d%d",&n,&m);
+    memset(g,0,sizeof(g));
+    memset(vi,0,sizeof(vi));
+    memset(num,0,sizeof(num));
+    ns=0;
+    state[++ns]=0;
+    num[ns]=1;
+    for(int i=2;i<=n;i++)
+    {
+        st=0;
+        if(ok[i])
+        {
+            num[1]++;
+            continue;
+        }
+        for(int j=0;j<np;j++)
+        {
+            if(i%prime[j]==0)
+            {
+                st|=(1<<j);
+            }
+        }
+        if(!vi[st])
+        {
+            state[++ns]=st;
+            num[ns]=1;
+            vi[st]=ns;
+        }
+        else
+        {
+            num[vi[st]]++;
+        }
+    }
+    for(int i=1;i<=ns;i++)
+    {
+        for(int j=1;j<=ns;j++)
+        {
+            if((state[i]&state[j])==0)
+                g[i][j]=1;
+        }
+    }
+    base[1]=1;
+    st=0;
+    for(int i=1;i<=ns;i++)
+    {
+        base[i+1]=base[i]*(num[i]+1);
+        st+=base[i]*num[i];
+    }
+}
+int getnum(int i,int x)
+{
+    int res=(x%base[i+1])/(base[i]);
+    return res;
+}
+int getstate(int i,int num)
+{
+    return num*base[i];
+}
+void dfs(int t,int x)
+{
+    if(t==0)
+    {
+        dp[x][0]=1;
+        return ;
+    }
+    if(dp[x][t]!=-1)
+        return;
+    dp[x][t]=0;
+    for(int i=1;i<=ns;i++)
+    {
+        if(g[x][i]&&getnum(i,t)>=1)
+        {
+            dfs(t-base[i],i);
+            dp[x][t]=((int)dp[x][t]+dp[i][t-base[i]])%m;
+        }
+    }
+    return;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    memset(ok,0,sizeof(ok));
+    ok[17]=1;
+    ok[19]=1;
+    ok[23]=1;
+    while(T--)
+    {
+        ini();
+        memset(dp,-1,sizeof(dp));
+        int ans=0;
+        for(int i=1;i<=ns;i++)
+        {
+            dfs(st-base[i],i);
+            ans=((int)ans+dp[i][st-base[i]])%m;
+        }
+        for(int i=1;i<=ns;i++)
+        {
+            while(num[i]>1)
+            {
+                ans=((int)ans*num[i])%m;
+                num[i]--;
+            }
+        }
+        printf("%d\n",ans);
+    }
+}
diff --git a/HDOJ/4625_autoAC.cpp b/HDOJ/4625_autoAC.cpp
new file mode 100644
index 0000000..32ef270
--- /dev/null
+++ b/HDOJ/4625_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <vector>
+using namespace std;
+const int maxn = 5e4 + 10;
+const int maxk = 5e2 + 10;
+const int mod = 10007;
+typedef long long LL;
+struct edge {
+  int v, to;
+};
+vector<edge> E;
+int L[maxn];
+void graph_init()
+{
+  E.clear();
+  memset(L, -1, sizeof(L));
+}
+void graph_add(int u, int v)
+{
+  edge t = {v, L[u]};
+  L[u] = E.size();
+  E.push_back(t);
+}
+int s[maxk][maxk];  
+int f[maxk];       
+int c[maxk][maxk]; 
+void init()
+{
+  s[0][0] = f[0] = c[0][0] = 1;
+  for (int i = 1; i < maxk; i++) {
+    f[i] = f[i-1] * i % mod;
+    c[i][0] = 1;
+    for (int j = 1; j < maxk; j++) {
+      s[i][j] = (j * s[i-1][j] % mod + s[i-1][j-1]) % mod;
+      c[i][j] = (c[i-1][j] + c[i-1][j-1]) % mod;
+    }
+  }
+}
+int n, k;
+int d[maxn][maxk];
+void dp_son(int u = 0, int p = -1)
+{
+  memset(d[u], 0, sizeof(d[u]));
+  for (int i = L[u]; i != -1; i = E[i].to)
+    if (i != p) {
+      int v = E[i].v;
+      dp_son(v, i^1);
+      for (int j = 0; j <= k; j++)
+        d[u][j] = (d[u][j] + d[v][j] + (j? d[v][j-1]: 0) + c[1][j]) % mod;
+    }
+}
+int tmp[maxk];
+void dp_father(int u = 0, int p = -1)
+{
+  if (p != -1) {
+    int v = E[p].v;
+    memcpy(tmp, d[v], sizeof(d[v]));
+    for (int j = 0; j <= k; j++)
+      tmp[j] = (tmp[j] - (d[u][j] + (j? d[u][j-1]: 0) + c[1][j]) % mod + mod) % mod;
+    for (int j = 0; j <= k; j++)
+      d[u][j] = (d[u][j] + tmp[j] + (j? tmp[j-1]: 0) + c[1][j]) % mod;
+  }
+  for (int i = L[u]; i != -1; i = E[i].to)
+    if (i != p) dp_father(E[i].v, i^1);
+}
+int main()
+{
+  init();
+  int T;
+  scanf("%d", &T);
+  for ( ; T--; ) {
+    graph_init();
+    scanf("%d%d", &n, &k);
+    for (int i = 0; i < n-1; i++) {
+      int u, v;
+      scanf("%d%d", &u, &v);
+      u--, v--;
+      graph_add(u, v);
+      graph_add(v, u);
+    }
+    dp_son();
+    dp_father();
+    for (int u = 0; u < n; u++) {
+      int sum = 0;
+      for (int i = 0; i <= k; i++)
+        sum = (sum + s[k][i]*f[i]%mod*d[u][i]%mod) % mod;
+      printf("%d\n", sum);
+    }
+  }
+  return 0;
+}
diff --git a/HDOJ/4627_autoAC.cpp b/HDOJ/4627_autoAC.cpp
new file mode 100644
index 0000000..2899bec
--- /dev/null
+++ b/HDOJ/4627_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std;
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+    __int64 n;
+    scanf("%I64d",&n);
+    if(n==2)
+    {
+        printf("1\n");
+        continue;
+    }
+    if(n&1)
+        printf("%I64d\n",(n/2)*(n/2+1));
+    else
+    {
+        n/=2;
+        if(n&1)
+        printf("%I64d\n",(n-2)*(n+2));
+        else
+        printf("%I64d\n",(n-1)*(n+1));
+    }
+    }
+    return 0;
+}
diff --git a/HDOJ/4628_autoAC.cpp b/HDOJ/4628_autoAC.cpp
new file mode 100644
index 0000000..2ce41ba
--- /dev/null
+++ b/HDOJ/4628_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <cstdio>  
+#include <cstring>  
+#include <algorithm>  
+#include <cmath>  
+#include <iostream>  
+using namespace std;  
+bool legal[(1<<16)+1];  
+int dp[(1<<16)+1];  
+char s[20];  
+char str[20];  
+int main()  
+{  
+    int t;  
+    scanf("%d",&t);  
+    while(t--)  
+    {  
+        scanf("%s",s);  
+        int num=0;  
+        int len=strlen(s);  
+        for(int i=1;i<(1<<len);i++)  
+        {  
+            int cnt=0;  
+            for(int j=0;j<len;j++)  
+                if(i&(1<<j))  
+                    str[cnt++]=s[j];  
+            int l=0,r=cnt-1;  
+            while(l<r && str[l]==str[r])  
+            {  
+                l++;  
+                r--;  
+            }  
+            if(l==r || l-1==r)  
+                legal[i]=true;  
+            else  
+                legal[i]=false;  
+        }  
+        memset(dp,0x3f,sizeof(dp));  
+        dp[0]=0;  
+        for(int i=1;i<(1<<len);i++)  
+        {  
+            for(int j=i;j>0;j=i&(j-1))  
+                if(legal[j])  
+                    dp[i]=min(dp[i],dp[i-j]+1);  
+        }  
+        printf("%d\n",dp[(1<<len)-1]);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4629_autoAC.cpp b/HDOJ/4629_autoAC.cpp
new file mode 100644
index 0000000..bc3c29b
--- /dev/null
+++ b/HDOJ/4629_autoAC.cpp
@@ -0,0 +1,168 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<vector>
+#include<cstdlib>
+#define pbk push_back
+using namespace std;
+const int N = 25050+10;
+const double eps = 1e-10;
+inline double sqr(double x){
+    return x * x;
+}
+inline int dcmp(double x){
+    return x < -eps ? -1 : x > eps;
+}
+struct Point{
+    double x,y;
+    int kind;
+    Point(){}
+    Point(double x,double y,int kind = 0):x(x),y(y),kind(kind){}
+    bool operator < (const Point &p)const{
+        return dcmp(x - p.x) < 0 || ( dcmp(x - p.x) == 0 && dcmp(y - p.y) < 0 );
+    }
+    Point operator - (const Point &p)const{
+        return Point(x - p.x, y - p.y);
+    }
+    Point operator + (const Point &p)const{
+        return Point(x + p.x, y + p.y);
+    }
+    Point operator * (const double &k)const{
+        return Point (x*k , y*k);
+    }
+    Point operator / (const double &k)const{
+        return Point (x/k, y/k);
+    }
+    double operator * (const Point &p)const{
+        return x * p.y - y * p.x;
+    }
+    double operator / (const Point &p)const{
+        return x * p.x + y * p.y;
+    }
+    void input(){
+        scanf("%lf%lf",&x,&y);
+    }
+    void ot(){
+        printf("%lf %lf\n",x,y);
+    }
+};
+struct Line{
+    Point a,b;
+    int kind;
+    Line (){}
+    Line (Point a,Point b,int kind = 0):a(a),b(b),kind(kind){}
+    double operator * (const Point &p)const{
+        return ( b - a ) * ( p - a );
+    }
+    double operator / (const Point &p)const{
+        return ( p - a) / ( p - b);
+    }
+    bool parallel(const Line &v){
+        return !dcmp( ( b - a ) * ( v.b - v.a ) ); 
+    }
+    int LineCrossLine(const Line &v){
+        if ( (*this).parallel(v) ){
+            return ( dcmp( v * a ) == 0);
+        }return 2;
+    }
+    int SegCrossSeg(const Line &v){
+        int d1 = dcmp( (*this) * v.a);
+        int d2 = dcmp( (*this) * v.b);
+        int d3 = dcmp( v * a);
+        int d4 = dcmp( v * b);
+        if ( ( d1 ^ d2 ) == -2 && ( d3 ^ d4 ) == -2 ) return 2;
+        return ( ( d1 == 0 && dcmp( (*this) / v.a ) <= 0 )
+            ||   ( d2 == 0 && dcmp( (*this) / v.b ) <= 0 )
+            ||   ( d3 == 0 && dcmp( v / a ) <= 0 )
+            ||   ( d4 == 0 && dcmp( v / b ) <= 0 )
+            );
+    }
+    Point CrossPoint(const Line &v){
+        double s1 = v * a, s2 = v * b;
+        return ( a * s2 - b * s1) / (s2 - s1);
+    }
+    void input(){
+        a.input(); b.input();
+    }
+    void ot(){
+        a.ot(); b.ot();
+    }
+};
+int n,poly_n,xn;
+vector<double> lx;
+vector<Line> line;
+double ans[N];
+void init(){
+    int sz = line.size();
+    for (int i = 0; i < sz; i++){
+        for (int j = i+1; j < sz; j++){
+            if (line[i].SegCrossSeg(line[j]) == 2){
+                Point p = line[i].CrossPoint(line[j]);
+                lx.pbk(p.x);
+            }
+        }
+    }
+    sort(lx.begin(),lx.end());
+    xn = unique(lx.begin(),lx.end()) - lx.begin();
+}
+vector<Point> qu[N];
+void work(){
+    for (int i = 0; i <= n; i++) ans[i] = 0;
+    for (int i = 0; i < xn-1; i++){
+        int k = 0;
+        for (int j = 0; j+1 < qu[i].size(); j++){
+            k += qu[i][j].kind;
+            ans[ k ] += (lx[i+1] - lx[i]) * (qu[i][j+1].x+qu[i][j+1].y - qu[i][j].x - qu[i][j].y) / 2;        
+        }
+    }
+    for (int i = 1; i <= n; i++) printf("%.10lf\n",ans[i]);
+}
+void solve(){
+    for (int i = 0; i < xn; i++) qu[i].clear();
+    for (int i = 0; i < line.size(); i++){
+        int j = lower_bound(lx.begin(),lx.begin()+xn,line[i].a.x) - lx.begin();
+        for (; j+1 < xn; j++ ){
+            double l = lx[j], r = lx[j+1];
+            if (dcmp(r - line[i].b.x) > 0) break;
+            Point p1 = line[i].CrossPoint(Line(Point(l,0), Point(l,1)));
+            Point p2 = line[i].CrossPoint(Line(Point(r,0), Point(r,1)));
+            qu[j].pbk(Point(p1.y, p2.y,line[i].kind));
+        }
+    }
+    for (int i = 0; i < xn - 1; i++) sort(qu[i].begin(), qu[i].end());
+    work();
+}
+int main(){
+    int T; scanf("%d",&T);
+    while (T--){
+        scanf("%d",&n);
+        lx.clear(); line.clear();;
+        for (int i = 0; i < n ;i++){
+            Point t[4];
+            for (int j = 0; j < 3; j++ ){
+                t[j].input(); 
+            }
+            t[3] = t[0];
+            int flag = 1;
+            if (dcmp( (t[1] - t[0])*(t[2] - t[0]) ) == 0) flag = 0;
+            for (int i = 0; i < 3 && flag; i++ ){
+                lx.pbk(t[i].x);
+                for (int j = i+1; j < 3; j++){
+                    Line tmp; tmp.a = t[i]; tmp.b = t[j];
+                    if (dcmp( tmp.a.x - tmp.b.x ) > 0) swap(tmp.a, tmp.b);
+                    Line tmp2 = Line(t[3-i-j], Point(t[3-i-j].x, t[3-i-j].y - 1));
+                    if (tmp.LineCrossLine(tmp2) != 2) continue;
+                    Point tp = tmp.CrossPoint(tmp2);
+                    if (dcmp(tp.y - t[3-i-j].y) < 0) tmp.kind = 1;
+                        else tmp.kind = -1;    
+                    line.pbk(tmp);
+                }
+            }
+        }
+        init();
+        solve();    
+    }
+    return 0;
+}
diff --git a/HDOJ/4630_autoAC.cpp b/HDOJ/4630_autoAC.cpp
new file mode 100644
index 0000000..e9fac84
--- /dev/null
+++ b/HDOJ/4630_autoAC.cpp
@@ -0,0 +1,121 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <algorithm>
+using namespace std;
+#define lz 2*u,l,mid
+#define rz 2*u+1,mid+1,r
+const int maxn=50005;
+int maxx[4*maxn], flag[4*maxn];
+int a[maxn];
+int pre[maxn];
+int n, m, T;
+vector<int>vt;
+struct node
+{
+    int l, r, id;
+    int ans;
+    friend bool operator<(const node A, const node B)
+    {
+        return A.r<B.r;
+    }
+}f[maxn];
+bool cmp(node A, node B)
+{
+    return A.id<B.id;
+}
+void push_down(int u, int l, int r)
+{
+    if(flag[u])
+    {
+        flag[2*u]=max(flag[2*u],flag[u]);
+        flag[2*u+1]=max(flag[2*u+1],flag[u]);
+        maxx[2*u]=max(maxx[2*u],flag[u]);
+        maxx[2*u+1]=max(maxx[2*u+1],flag[u]);
+        flag[u]=0;
+    }
+}
+void Update(int u, int l, int r, int tl, int tr, int val)
+{
+    maxx[u]=max(maxx[u],val);
+    if(tl<=l&&r<=tr)
+    {
+        flag[u]=max(flag[u],val);
+        maxx[u]=max(maxx[u],val);
+        return ;
+    }
+    push_down(u,l,r);
+    int mid=(l+r)>>1;
+    if(tr<=mid) Update(lz,tl,tr,val);
+    else if(tl>mid) Update(rz,tl,tr,val);
+    else
+    {
+        Update(lz,tl,mid,val);
+        Update(rz,mid+1,tr,val);
+    }
+}
+int Query(int u, int l, int r, int tl, int tr)
+{
+    if(tl<=l&&r<=tr) return maxx[u];
+    push_down(u,l,r);
+    int mid=(l+r)>>1;
+    if(tr<=mid) return Query(lz,tl,tr);
+    else if(tl>mid) return Query(rz,tl,tr);
+    else
+    {
+        int t1=Query(lz,tl,mid);
+        int t2=Query(rz,mid+1,tr);
+        return max(t1,t2);
+    }
+}
+void Solve(int x, int r)
+{
+    vt.clear();
+    vt.push_back(x);
+    for(int i=2; i*i<=x; i++)
+        if(x%i==0)
+        {
+            vt.push_back(i);
+            vt.push_back(x/i);
+        }
+    for(int i=0; i<vt.size(); i++)
+    {
+        int l=pre[ vt[i] ];
+        pre[ vt[i] ]=r;
+        if(l==-1||l==r) continue;
+        Update(1,1,n,l,l,vt[i]);
+    }
+}
+int main()
+{
+    cin >> T;
+    while(T--)
+    {
+        cin >> n;
+        for(int i=1; i<=n; i++) scanf("%d", a+i), pre[i]=-1;
+        cin >> m;
+        for(int i=1; i<=m; i++) f[i].id=i, scanf("%d%d",&f[i].l,&f[i].r);
+        sort(f+1,f+m+1);
+        for(int i=1; i<=4*n; i++) maxx[i]=1, flag[i]=0;
+        int i=1, j=1;
+        while(j<=m)
+        {
+            if(i<=f[j].r&&i<=n)
+            {
+                Solve(a[i],i);
+                i++;
+            }
+            else
+            {
+                if(f[j].l!=f[j].r)f[j].ans=Query(1,1,n,f[j].l,f[j].r);
+                else f[j].ans=0;
+                j++;
+            }
+        }
+        sort(f+1,f+m+1,cmp);
+        for(int i=1; i<=m; i++)
+            printf("%d\n",f[i].ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4631_autoAC.cpp b/HDOJ/4631_autoAC.cpp
new file mode 100644
index 0000000..191c04c
--- /dev/null
+++ b/HDOJ/4631_autoAC.cpp
@@ -0,0 +1,113 @@
+#include <stdio.h>
+#include <algorithm>
+#include <string.h>
+#include <iostream>
+#include <map>
+#include <vector>
+#include <queue>
+#include <set>
+#include <string>
+#include <math.h>
+using namespace std;
+const int MAXN = 500010;
+struct Point
+{
+    int x,y;
+    int id;
+    int index;
+    Point(int _x = 0,int _y = 0,int _index = 0)
+    {
+        x = _x;
+        y = _y;
+        index = _index;
+    }
+};
+Point P[MAXN];
+long long dist(Point a,Point b)
+{
+    return ((long long)(a.x-b.x)*(a.x-b.x) + (long long)(a.y-b.y)*(a.y-b.y));
+}
+Point p[MAXN];
+Point tmpt[MAXN];
+bool cmpxy(Point a,Point b)
+{
+    if(a.x != b.x)return a.x < b.x;
+    else return a.y < b.y;
+}
+bool cmpy(Point a,Point b)
+{
+    return a.y < b.y;
+}
+pair<int,int> Closest_Pair(int left,int right)
+{
+    long long d = (1LL<<50);
+    if(left == right)return make_pair(left,right);
+    if(left + 1 == right)
+        return make_pair(left,right);
+    int mid = (left+right)/2;
+    pair<int,int>pr1 = Closest_Pair(left,mid);
+    pair<int,int>pr2 = Closest_Pair(mid+1,right);
+    long long d1,d2;
+    if(pr1.first == pr1.second)
+        d1 = (1LL<<50);
+    else d1 = dist(p[pr1.first],p[pr1.second]);
+    if(pr2.first == pr2.second)
+        d2 = (1LL<<50);
+    else d2 = dist(p[pr2.first],p[pr2.second]);
+    pair<int,int>ans;
+    if(d1 < d2)ans = pr1;
+    else ans = pr2;
+    d = min(d1,d2);
+    int k = 0;
+    for(int i = left;i <= right;i++)
+    {
+        if((long long)(p[mid].x - p[i].x)*(p[mid].x - p[i].x) <= d)
+            tmpt[k++] = p[i];
+    }
+    sort(tmpt,tmpt+k,cmpy);
+    for(int i = 0;i <k;i++)
+    {
+        for(int j = i+1;j < k && (long long)(tmpt[j].y - tmpt[i].y)*(tmpt[j].y - tmpt[i].y) < d;j++)
+        {
+            if(d > dist(tmpt[i],tmpt[j]))
+            {
+                d = dist(tmpt[i],tmpt[j]);
+                ans = make_pair(tmpt[i].id,tmpt[j].id);
+            }
+        }
+    }
+    return ans;
+}
+int main()
+{
+    int T;
+    int n,Ax,Ay,Bx,By,Cx,Cy;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d%d%d%d%d",&n,&Ax,&Bx,&Cx,&Ay,&By,&Cy);
+        P[0] = Point(0,0,0);
+        for(int i = 1;i <= n;i++)
+        {
+            long long x= ((long long)P[i-1].x*Ax + Bx)%Cx;
+            long long y = ((long long)P[i-1].y*Ay + By)%Cy;
+            P[i] = Point(x,y,i);
+        }
+        int end = n;
+        long long ans = 0;
+        while(end > 1)
+        {
+            for(int i = 0;i < end;i++)
+                p[i] = P[i+1];
+            sort(p,p+end,cmpxy);
+            for(int i = 0;i < end;i++)
+                p[i].id = i;
+            pair<int,int>pr = Closest_Pair(0,end-1);
+            int Max = max(p[pr.first].index,p[pr.second].index);
+            ans += (long long)(end-Max+1)*dist(p[pr.first],p[pr.second]);
+            end = Max-1;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4632_autoAC.cpp b/HDOJ/4632_autoAC.cpp
new file mode 100644
index 0000000..ffccee1
--- /dev/null
+++ b/HDOJ/4632_autoAC.cpp
@@ -0,0 +1,66 @@
+#include"iostream"
+#include"cstdio"
+#include"cstring"
+using namespace std;
+const int N=1006;
+const int mod=10007;
+int n,lowbit[N];
+__int64 C[N],ans[N];
+char str[N];
+void update(int k,int dir)
+{
+    while(0<k && k<=n)
+    {
+        C[k]=(C[k]+dir)%mod;
+        k+=lowbit[k];
+    }
+}
+int sum(int k)
+{
+    __int64 p=0;
+    while(0<k && k<=n)
+    {
+        p=(p+C[k])%mod;
+        k-=lowbit[k];
+    }
+    return p;
+}
+int main()
+{
+    int T,Case;
+    int i,l;
+    __int64 a,b,t;
+    __int64 hehe;
+    for(i=1;i<=1000;i++)    lowbit[i]=i&(-i);
+    cin>>T;
+    for(Case=1;Case<=T;Case++)
+    {
+        hehe=0;
+        scanf("%s",str+1);
+        memset(C,0,sizeof(C));
+        memset(ans,0,sizeof(ans));
+        for(n=1;str[n];n++);
+        n--;
+        for(i=n;i>=1;i--)
+        {
+            ans[i]=1;
+            update(i,1);
+            for(l=n;l>i;l--)
+            {
+                if(str[l]==str[i])
+                {
+                    a=sum(i);
+                    b=sum(l-1);
+                    t=(b-a)%mod;
+                    while(t<0)    t+=mod;
+                    ans[i]=(ans[i]+1+t)%mod;
+                    update(l,1+t);
+                }
+            }
+        }
+        hehe=0;
+        for(i=1;i<=n;i++)    hehe=(hehe+ans[i])%mod;
+        printf("Case %d: %I64d\n",Case,hehe);
+    }
+    return 0;
+}
diff --git a/HDOJ/4633_autoAC.cpp b/HDOJ/4633_autoAC.cpp
new file mode 100644
index 0000000..b3e60b3
--- /dev/null
+++ b/HDOJ/4633_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+const LL MOD=10007;
+LL quick_mod(LL a,LL b)
+{
+    LL ans=1;
+    a%=MOD;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans=ans*a%MOD;
+            b--;
+        }
+        b>>=1;
+        a=a*a%MOD;
+    }
+    return ans;
+}
+int main()
+{
+    LL tt=1,t,k,ans;
+    cin>>t;
+    while(t--)
+    {
+        cin>>k;
+        ans=quick_mod(k,74);
+        ans+=3*(2*quick_mod(k,20)+quick_mod(k,38))%MOD;
+        ans+=6*quick_mod(k,38);
+        ans+=8*quick_mod(k,26);
+        ans%=MOD;
+        ans*=quick_mod(24,MOD-2);
+        ans%=MOD;
+        printf("Case %I64d: %I64d\n",tt++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4634_autoAC.cpp b/HDOJ/4634_autoAC.cpp
new file mode 100644
index 0000000..3c422b7
--- /dev/null
+++ b/HDOJ/4634_autoAC.cpp
@@ -0,0 +1,142 @@
+#include <stdio.h>
+#include <algorithm>
+#include <string.h>
+#include <iostream>
+#include <map>
+#include <vector>
+#include <queue>
+#include <set>
+#include <string>
+#include <math.h>
+using namespace std;
+char g[220][220];
+int sx,sy,ex,ey;
+int n,m;
+int keynum;
+int key_s[220][220];
+int mo[][2] = {{0,1},{0,-1},{1,0},{-1,0}};
+struct Node
+{
+    int key;
+    int num;
+    int x,y;
+};
+queue<Node>q;
+bool used[202][202][1<<7];
+bool used2[202][202][1<<7][4];
+int bfs()
+{
+    while(!q.empty())q.pop();
+    Node tmp,now;
+    tmp.key = 0;
+    tmp.num = 0;
+    tmp.x = sx;
+    tmp.y = sy;
+    q.push(tmp);
+    memset(used,false,sizeof(used));
+    memset(used2,false,sizeof(used2));
+    used[sx][sy][0] = true;
+    while(!q.empty())
+    {
+        tmp = q.front();
+        q.pop();
+        for(int i = 0;i < 4;i++)
+        {
+            int mx = mo[i][0];
+            int my = mo[i][1];
+            int x = tmp.x;
+            int y = tmp.y;
+            int ss = tmp.key;
+            while(1)
+            {
+                if(g[x][y] =='L')
+                {
+                    mx = 0; my = -1;
+                }
+                if(g[x][y] == 'U')
+                {
+                    mx = -1;my = 0;
+                }
+                if(g[x][y] == 'D')
+                {
+                    mx = 1;my = 0;
+                }
+                if(g[x][y] == 'R')
+                {
+                    mx = 0; my = 1;
+                }
+                int dir;
+                if(mx==-1&&my==0)dir=0;
+                else if(mx==1&&my==0)dir=1;
+                else if(mx==0&&my==1)dir=2;
+                else if(mx==0&&my==-1)dir=3;
+                if(used2[x][y][ss][dir])break;
+                used2[x][y][ss][dir] = true;
+                x += mx;
+                y += my;
+                if(x < 0 || y < 0 || x >= n || y >= m)break;
+                if(g[x][y] =='#')break;
+                if( x == ex && y== ey && ss ==((1<<keynum)-1) )
+                    return tmp.num+1;
+                if(g[x][y] =='L')
+                {
+                    mx = 0; my = -1;
+                }
+                if(g[x][y] == 'U')
+                {
+                    mx = -1;my = 0;
+                }
+                if(g[x][y] == 'D')
+                {
+                    mx = 1;my = 0;
+                }
+                if(g[x][y] == 'R')
+                {
+                    mx = 0; my = 1;
+                }
+                if(g[x][y] == 'K')
+                    ss |= key_s[x][y];
+                if(x+mx >=0 && x+mx < n && y+my>=0 && y+my < m && g[x+mx][y+my]=='#')
+                {
+                    if(used[x][y][ss])break;
+                    now.x = x;now.y = y;
+                    now.key = ss;
+                    now.num = tmp.num + 1;
+                    q.push(now);
+                    used[x][y][ss] = true;
+                    break;
+                }
+            }
+        }
+    }
+    return -1;
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m)==2)
+    {
+        keynum = 0;
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%s",g[i]);
+            for(int j = 0;j < m;j++)
+            {
+                if(g[i][j] == 'S')
+                {
+                    sx = i;sy = j;
+                }
+                if(g[i][j] == 'E')
+                {
+                    ex = i;ey = j;
+                }
+                if(g[i][j] == 'K')
+                {
+                    key_s[i][j] = (1<<keynum);
+                    keynum++;
+                }
+            }
+        }
+        printf("%d\n",bfs());
+    }
+    return 0;
+}
diff --git a/HDOJ/4635_autoAC.cpp b/HDOJ/4635_autoAC.cpp
new file mode 100644
index 0000000..43d4422
--- /dev/null
+++ b/HDOJ/4635_autoAC.cpp
@@ -0,0 +1,93 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int VM=200010;
+const int EM=200010;
+const int INF=0x3f3f3f3f;
+struct Edge{
+    int to,nxt;
+}edge[EM<<1];
+long long n,m,cnt,head[VM];
+long long dep,top,atype;
+long long dfn[VM],low[VM],vis[VM],stack[VM],belong[VM],indeg[VM],outdeg[VM],sum[VM];
+void addedge(int cu,int cv){
+    edge[cnt].to=cv;    edge[cnt].nxt=head[cu];     head[cu]=cnt++;
+}
+void Tarjan(int u){
+    dfn[u]=low[u]=++dep;
+    stack[top++]=u;
+    vis[u]=1;
+    for(int i=head[u];i!=-1;i=edge[i].nxt){
+        int v=edge[i].to;
+        if(!dfn[v]){
+            Tarjan(v);
+            low[u]=min(low[u],low[v]);
+        }else if(vis[v]){
+            low[u]=min(low[u],dfn[v]);
+        }
+    }
+    int j;
+    if(dfn[u]==low[u]){
+        atype++;
+        do{
+            j=stack[--top];
+            belong[j]=atype;
+            sum[atype]++;   
+            vis[j]=0;
+        }while(u!=j);
+    }
+}
+void init(){
+    cnt=0;
+    memset(head,-1,sizeof(head));
+    dep=0,  top=0,  atype=0;
+    memset(dfn,0,sizeof(dfn));
+    memset(low,0,sizeof(low));
+    memset(vis,0,sizeof(vis));
+    memset(belong,0,sizeof(belong));
+    memset(indeg,0,sizeof(indeg));
+    memset(outdeg,0,sizeof(outdeg));
+    memset(sum,0,sizeof(sum));
+}
+int main(){
+    int t,cases=0;
+    scanf("%d",&t);
+    while(t--){
+        cin>>n>>m;
+        if(n==1){
+            printf("Case %d: -1\n",++cases);
+            continue;
+        }
+        init();
+        int u,v;
+        for(int i=0;i<m;i++){
+            scanf("%d%d",&u,&v);
+            addedge(u,v);
+        }
+        for(int i=1;i<=n;i++)
+            if(!dfn[i])
+                Tarjan(i);
+        if(atype==1){
+            printf("Case %d: -1\n",++cases);
+            continue;
+        }
+        for(int u=1;u<=n;u++)
+            for(int i=head[u];i!=-1;i=edge[i].nxt){
+                int v=edge[i].to;
+                if(belong[u]!=belong[v]){
+                    outdeg[belong[u]]++;
+                    indeg[belong[v]]++;
+                }
+            }
+        long long ans=0,tmp;
+        for(long long i=1;i<=atype;i++)
+            if(indeg[i]==0 || outdeg[i]==0){   
+                tmp=sum[i];
+                ans=max(ans,tmp*(tmp-1)+(n-tmp)*(n-tmp-1)+tmp*(n-tmp)-m);
+            }
+        cout<<"Case "<<(++cases)<<": "<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4636_autoAC.cpp b/HDOJ/4636_autoAC.cpp
new file mode 100644
index 0000000..487232d
--- /dev/null
+++ b/HDOJ/4636_autoAC.cpp
@@ -0,0 +1,98 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#include <cmath>
+#include <queue>
+#include <vector>
+#define MID(x,y) ((x+y)>>1)
+#define iabs(x) ((x)>0?(x):-(x))
+using namespace std;
+vector <int>v[40];
+inline void v_pb(int a,int b){
+    v[a].push_back(b);
+}
+int num[40];
+queue<int>q;
+bool vis[40];
+bool bfs(int s,int flag){
+    while(!q.empty()) q.pop();
+    q.push(s);
+    int cnt = -1;
+    while(!q.empty()){
+        int k = q.front(); q.pop();
+        cnt++;
+        for (int i = 0; i < v[k].size(); i++){
+            int d = v[k][i];
+            if (!vis[d] && num[d] == flag){
+                vis[d] = 1;
+                q.push(d);
+            }
+        }
+    }
+    if(flag == 0 && cnt == 0)return 1;
+    return 0;
+}
+int main(){
+    v_pb(1,2);v_pb(1,3);v_pb(1,17);v_pb(1,18);v_pb(1,20);v_pb(1,13);
+    v_pb(2,1);v_pb(2,3);v_pb(2,4);v_pb(2,7);v_pb(2,12);v_pb(2,13);
+    v_pb(3,1);v_pb(3,2);v_pb(3,4);v_pb(3,5);v_pb(3,20);
+    v_pb(4,2);v_pb(4,3);v_pb(4,5);v_pb(4,6);v_pb(4,7);v_pb(4,8);
+    v_pb(5,3);v_pb(5,4);v_pb(5,6);v_pb(5,20);v_pb(5,21);v_pb(5,24);
+    v_pb(6,4);v_pb(6,5);v_pb(6,8);v_pb(6,9);v_pb(6,24);
+    v_pb(7,2);v_pb(7,4);v_pb(7,8);v_pb(7,10);v_pb(7,12);
+    v_pb(8,4);v_pb(8,6);v_pb(8,7);v_pb(8,9);v_pb(8,10);v_pb(8,11);
+    v_pb(9,6);v_pb(9,8);v_pb(9,11);v_pb(9,24);v_pb(9,26);v_pb(9,27);
+    v_pb(10,7);v_pb(10,8);v_pb(10,11);v_pb(10,12);v_pb(10,14);v_pb(10,16);
+    v_pb(11,8);v_pb(11,9);v_pb(11,10);v_pb(11,16);v_pb(11,27);
+    v_pb(12,2);v_pb(12,7);v_pb(12,10);v_pb(12,13);v_pb(12,14);v_pb(12,15);
+    v_pb(13,12);v_pb(13,15);v_pb(13,2);v_pb(13,1);v_pb(13,17);
+    v_pb(14,10);v_pb(14,12);v_pb(14,15);v_pb(14,16);v_pb(14,30);
+    v_pb(15,12);v_pb(15,13);v_pb(15,14);v_pb(15,30);v_pb(15,32);v_pb(15,17);
+    v_pb(16,10);v_pb(16,11);v_pb(16,14);v_pb(16,27);v_pb(16,29);v_pb(16,30);
+    v_pb(17,1);v_pb(17,18);v_pb(17,19);v_pb(17,13);v_pb(17,15);v_pb(17,32);
+    v_pb(18,1);v_pb(18,17);v_pb(18,19);v_pb(18,20);v_pb(18,22);
+    v_pb(19,17);v_pb(19,18);v_pb(19,31);v_pb(19,22);v_pb(19,23);v_pb(19,32);
+    v_pb(20,1);v_pb(20,3);v_pb(20,5);v_pb(20,18);v_pb(20,21);v_pb(20,22);
+    v_pb(21,5);v_pb(21,20);v_pb(21,22);v_pb(21,24);v_pb(21,25);
+    v_pb(22,19);v_pb(22,18);v_pb(22,20);v_pb(22,21);v_pb(22,23);v_pb(22,25);
+    v_pb(23,19);v_pb(23,22);v_pb(23,25);v_pb(23,28);v_pb(23,31);
+    v_pb(24,5);v_pb(24,6);v_pb(24,9);v_pb(24,21);v_pb(24,25);v_pb(24,26);
+    v_pb(25,21);v_pb(25,22);v_pb(25,23);v_pb(25,24);v_pb(25,26);v_pb(25,28);
+    v_pb(26,9);v_pb(26,24);v_pb(26,25);v_pb(26,27);v_pb(26,28);
+    v_pb(27,9);v_pb(27,11);v_pb(27,16);v_pb(27,26);v_pb(27,28);v_pb(27,29);
+    v_pb(28,25);v_pb(28,26);v_pb(28,27);v_pb(28,29);v_pb(28,31);v_pb(28,23);
+    v_pb(29,16);v_pb(29,27);v_pb(29,28);v_pb(29,30);v_pb(29,31);
+    v_pb(30,14);v_pb(30,15);v_pb(30,16);v_pb(30,29);v_pb(30,31);v_pb(30,32);
+    v_pb(31,28);v_pb(31,29);v_pb(31,30);v_pb(31,32);v_pb(31,23);v_pb(31,19);
+    v_pb(32,30);v_pb(32,31);v_pb(32,15);v_pb(32,19);v_pb(32,17);
+    int t;
+    scanf("%d", &t);
+    for (int cas = 1; cas <= t; cas++){
+        printf("Case %d: ", cas);
+        int black = 0,white = 0;
+        for (int i = 1; i <= 32; ++i){
+            scanf("%d", &num[i]);
+            if(num[i]) black ++;
+        }
+        if (black == 0) {puts("0");continue;}
+        memset(vis,0,sizeof(vis));
+        black = 0;
+        for (int i = 1; i <= 32; ++i){
+            if (!vis[i]){
+                vis[i] = 1;
+                if (num[i]){
+                    black ++;
+                    bfs(i,1);
+                }else {
+                    white ++;
+                    if(bfs(i,0)) white --;
+                }
+            }
+        }
+        if(black <= 2) printf("%d\n", black);
+        else if (white == 1) puts("2");
+        else puts("3");
+    }
+    return 0;
+}
diff --git a/HDOJ/4637_autoAC.cpp b/HDOJ/4637_autoAC.cpp
new file mode 100644
index 0000000..22d0d87
--- /dev/null
+++ b/HDOJ/4637_autoAC.cpp
@@ -0,0 +1,317 @@
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <set>
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+const double eps=1e-10;
+const int INF=1<<29;
+const double PI=acos(-1.0);
+int doublecmp(double x){
+    if(fabs(x)<eps)return 0;else return x<0?-1:1;
+}
+struct Point{
+    double x,y;
+    Point(double x=0,double y=0):x(x),y(y){}
+};
+typedef Point Vector;
+Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
+Vector operator-(Point a,Point b){return Vector(a.x-b.x,a.y-b.y);}
+Vector operator*(Vector a,double p){return Vector(a.x*p,a.y*p);}
+Vector operator/(Vector a,double p){return Vector(a.x/p,a.y/p);}
+bool operator<(const Point&a,const Point&b){return a.x<b.x||(a.x==b.x&&a.y<b.y);}
+bool operator==(const Point&a,const Point&b){
+    return doublecmp(a.x-b.x)==0&&doublecmp(a.y-b.y)==0;
+}
+bool operator!=(const Point&a,const Point&b){return a==b?false:true;}
+struct Segment{
+    Point a,b;
+    Segment(){}
+    Segment(Point _a,Point _b){a=_a,b=_b;}
+    bool friend operator<(const Segment& p,const Segment& q){return p.a<q.a||(p.a==q.a&&p.b<q.b);}
+    bool friend operator==(const Segment& p,const Segment& q){return (p.a==q.a&&p.b==q.b)||(p.a==q.b&&p.b==q.a);}
+};
+struct Circle{
+    Point c;
+    double r;
+    Circle(){}
+    Circle(Point _c, double _r):c(_c),r(_r) {}
+    Point point(double a)const{return Point(c.x+cos(a)*r,c.y+sin(a)*r);}
+    bool friend operator<(const Circle& a,const Circle& b){return a.r<b.r;}
+};
+struct Line{
+    Point p;
+    Vector v;
+    double ang;
+    Line() {}
+    Line(const Point &_p, const Vector &_v):p(_p),v(_v){ang = atan2(v.y, v.x);}
+    bool operator<(const Line &L)const{return  ang < L.ang;}
+};
+double Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
+double Length(Vector a){return sqrt(Dot(a,a));}
+double Angle(Vector a,Vector b){return acos(Dot(a,b)/Length(a)/Length(b));}
+double Cross(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
+double Area2(Point a,Point b,Point c){return Cross(b-a,c-a);}
+double DegreeToRadius(double deg){return deg/180*PI;}
+double GetRerotateAngle(Vector a,Vector b){
+    double tempa=Angle(a,Vector(1,0));
+    if(a.y<0) tempa=2*PI-tempa;
+    double tempb=Angle(b,Vector(1,0));
+    if(b.y<0) tempb=2*PI-tempb;
+    if((tempa-tempb)>0) return tempa-tempb;
+    else return tempa-tempb+2*PI;
+}
+Vector Rotate(Vector a,double rad){
+    return Vector(a.x*cos(rad)-a.y*sin(rad),a.x*sin(rad)+a.y*cos(rad));
+}
+Vector Normal(Vector a){
+    double L=Length(a);
+    return Vector(-a.y/L,a.x/L);
+}
+Point GetLineProjection(Point p,Point a,Point b){
+    Vector v=b-a;
+    return a+v*(Dot(v,p-a)/Dot(v,v));
+}
+Point GetLineIntersection(Point p,Vector v,Point q,Vector w){
+    Vector u=p-q;
+    double t=Cross(w,u)/Cross(v,w);
+    return p+v*t;
+}
+int ConvexHull(Point* p,int n,Point* ch){
+    sort(p,p+n);
+    int m=0;
+    for(int i=0;i<n;i++){
+        while(m>1&&Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2])<=0) m--;
+        ch[m++]=p[i];
+    }
+    int k=m;
+    for(int i=n-2;i>=0;i--){
+        while(m>k&&Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2])<=0) m--;
+        ch[m++]=p[i];
+    }
+    if(n>0) m--;
+    return m;
+}
+double Heron(double a,double b,double c){
+    double p=(a+b+c)/2;
+    return sqrt(p*(p-a)*(p-b)*(p-c));
+}
+bool SegmentProperIntersection(Point a1,Point a2,Point b1,Point b2){
+    double c1=Cross(a2-a1,b1-a1),c2=Cross(a2-a1,b2-a1);
+    double c3=Cross(b2-b1,a1-b1),c4=Cross(b2-b1,a2-b1);
+    return doublecmp(c1)*doublecmp(c2)<0&&doublecmp(c3)*doublecmp(c4)<0;
+}
+double CutConvex(const int n,Point* poly, const Point a,const Point b, vector<Point> result[3]){
+    vector<Point> points;
+    Point p;
+    Point p1=a,p2=b;
+    int cur,pre; 
+    result[0].clear(); 
+    result[1].clear(); 
+    result[2].clear();
+    if(n==0) return 0;
+    double tempcross;
+    tempcross=Cross(p2-p1,poly[0]-p1);
+    if(doublecmp(tempcross)==0) pre=cur=2;
+    else if(tempcross>0) pre=cur=0;
+    else pre=cur=1;
+    for(int i=0;i<n;i++){
+        tempcross=Cross(p2-p1,poly[(i+1)%n]-p1);
+        if(doublecmp(tempcross)==0) cur=2;
+        else if(tempcross>0) cur=0;
+        else cur=1;
+        if(cur==pre){
+            result[cur].push_back(poly[(i+1)%n]); 
+        }
+        else{
+            p1=poly[i]; 
+            p2=poly[(i+1)%n];
+            p=GetLineIntersection(p1,p2-p1,a,b-a);
+            points.push_back(p); 
+            result[pre].push_back(p); 
+            result[cur].push_back(p); 
+            result[cur].push_back(poly[(i+1)%n]); 
+            pre=cur;
+        }
+    }
+    sort(points.begin(),points.end());
+    if(points.size()<2){
+        return 0; 
+    }
+    else{
+        return Length(points.front()-points.back());
+    }
+}
+double DistanceToSegment(Point p,Segment s){
+    if(s.a==s.b) return Length(p-s.a);
+    Vector v1=s.b-s.a,v2=p-s.a,v3=p-s.b;
+    if(doublecmp(Dot(v1,v2))<0) return Length(v2);
+    else if(doublecmp(Dot(v1,v3))>0) return Length(v3);
+    else return fabs(Cross(v1,v2))/Length(v1);
+}
+bool isPointOnSegment(Point p,Segment s){
+    return doublecmp(DistanceToSegment(p,s))==0;
+}
+int isPointInPolygon(Point p, Point* poly,int n){
+    int wn=0;
+    for(int i=0;i<n;i++){
+        Point& p2=poly[(i+1)%n];
+        if(isPointOnSegment(p,Segment(poly[i],p2))) return -1;
+        int k=doublecmp(Cross(p2-poly[i],p-poly[i]));
+        int d1=doublecmp(poly[i].y-p.y);
+        int d2=doublecmp(p2.y-p.y);
+        if(k>0&&d1<=0&&d2>0)wn++;
+        if(k<0&&d2<=0&&d1>0)wn--;
+    }
+    if(wn) return 1;
+    else return 0;
+}
+double PolygonArea(vector<Point> p){
+    double area=0;
+    int n=p.size();
+    for(int i=1;i<n-1;i++)
+        area+=Cross(p[i]-p[0],p[i+1]-p[0]);
+    return area/2;
+}
+int PSLGtoPolygons(Segment arr[],int n,vector<Point>* Polygons){
+    int count=n-1;
+    bool vis[9999];memset(vis,0,sizeof vis);
+    Point star=arr[0].a,pre=arr[0].a,cur=arr[0].b,purpose=arr[0].b;vis[0]=true;
+    int mark;
+    while(purpose!=star){
+        double theta=-INF;
+        for(int i=0;i<n;i++)if(!vis[i]&&arr[i].a==cur&&arr[i].b!=pre){
+            if(theta<GetRerotateAngle(pre-cur,arr[i].b-cur)){
+                theta=GetRerotateAngle(pre-cur,arr[i].b-cur);
+                purpose=arr[i].b;
+                mark=i;
+            }
+        }
+        vis[mark]=true;count--;
+        pre=cur;cur=purpose;
+    }
+    int polyidx=0;
+    while(count>0){
+        for(int i=0;i<n;i++)if(!vis[i]){
+            star=arr[i].a,pre=arr[i].a,cur=arr[i].b,purpose=arr[i].b;vis[i]=true;count--;
+            Polygons[polyidx].clear();
+            Polygons[polyidx].push_back(cur);
+            break;
+        }
+        while(purpose!=star){
+            double theta=-INF;
+            for(int i=0;i<n;i++)if(!vis[i]&&arr[i].a==cur&&arr[i].b!=pre){
+                if(theta<GetRerotateAngle(pre-cur,arr[i].b-cur)){
+                    theta=GetRerotateAngle(pre-cur,arr[i].b-cur);
+                    purpose=arr[i].b;
+                    mark=i;
+                }
+            }
+            vis[mark]=true;count--;
+            Polygons[polyidx].push_back(purpose);
+            pre=cur;cur=purpose;
+        }
+        polyidx++;
+    }
+    return polyidx;
+}
+int GetLineCircleIntersection(Line L,Circle C,Point& p1,Point& p2){
+    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y-C.c.y;
+    double e = a*a + c*c, f = 2*(a*b+c*d), g = b*b + d*d -C.r*C.r;
+    double delta = f*f - 4*e*g;
+    if(doublecmp(delta) < 0)  return 0;
+    if(doublecmp(delta) == 0) {
+        p1=p1=C.point(-f/(2*e));
+        return 1;
+    }
+    p1=(L.p+L.v*(-f-sqrt(delta))/(2*e));
+    p2=(L.p+L.v*(-f+sqrt(delta))/(2*e));
+    return 2;
+}
+struct Allpoint{
+    Point p;
+    int pos;
+    bool friend operator<(Allpoint a,Allpoint b){
+        if(a.pos==-1&&a.pos==b.pos) return a.p<b.p;
+        else if(a.pos==-1) return true;
+        else if(b.pos==-1) return false;
+        else return a.p<b.p;
+    }
+}allpoint[8000];
+int idx=0;
+int lpint(Line l, Point a, Point b, Point c, Allpoint *sol) {
+    int ret = 0;
+    if (doublecmp(Cross(l.v, a - b)) != 0) {
+        sol[ret].p = GetLineIntersection(l.p,l.v, a, b-a);
+        if (isPointOnSegment(sol[ret].p, Segment(a, b))) ret++;
+    }
+    if (doublecmp(Cross(l.v, c - b)) != 0) {
+        sol[ret].p = GetLineIntersection(l.p,l.v,c, b-c);
+        if (isPointOnSegment(sol[ret].p, Segment(c, b))) ret++;
+    }
+    if (doublecmp(Cross(l.v, a - c)) != 0) {
+        sol[ret].p = GetLineIntersection(l.p,l.v, a, c-a);
+        if (isPointOnSegment(sol[ret].p, Segment(a, c))) ret++;
+    }
+    if (ret < 2) return 0;
+    sort(sol, sol + ret);
+    if (ret == 3) {
+        if (sol[0].p == sol[1].p) sol[1].p = sol[2].p;
+    }
+    if (sol[0].p == sol[1].p) return 0;
+    return 2;
+}
+int main()
+{
+    int T,cas=1;
+    scanf("%d",&T);
+    while(T--){
+        double v1,v2,v,t,x;
+        int n;
+        idx=0;
+        scanf("%lf%lf%lf%lf%lf",&v1,&v2,&v,&t,&x);
+        scanf("%d",&n);
+        double time = v2 * t / (v2 - v1);
+        Line l = Line(Point(x, 0), Point(x - v1 * time, v * time)-Point(x,0));
+        for(int i=0;i<n;i++){
+            Point O;
+            double r,h;
+            Allpoint ip[4];
+            scanf("%lf%lf%lf%lf", &O.x, &O.y, &r, &h);
+            int ipp = lpint(l, Point(O.x + r, O.y), Point(O.x - r, O.y), Point(O.x, O.y + h), ip);
+            if (ipp) {
+                if (ip[1] < ip[0]) swap(ip[0], ip[1]);
+                for (int i = 0; i < 2; i++) ip[i].pos= i & 1, allpoint[idx++] = ip[i];
+            }
+            int ipc = GetLineCircleIntersection(l,Circle(O, r), ip[0].p,ip[1].p);
+            if (ipc==2) {
+                if (ip[1] < ip[0]) swap(ip[0], ip[1]);
+                if (doublecmp(ip[1].p.y - O.y) >= 0) continue;
+                if (doublecmp(ip[0].p.y - O.y) > 0) ip[0].p = GetLineIntersection(l.p,l.v, O, Point(1.0, 0));
+                for (int i = 0; i < 2; i++) ip[i].pos = i & 1, allpoint[idx++] = ip[i];
+            }
+        }
+        sort(allpoint, allpoint + idx);
+        int cnt = 0;
+        double sum = 0, lp = x - v1 * time, rp = x, ls = lp;
+        for (int i = 0; i < idx; i++) {
+            if (allpoint[i].p.x > rp) break;
+            if (allpoint[i].p.x < lp) {
+                if (allpoint[i].pos) cnt--; 
+                else cnt++;
+            } else {
+                if (allpoint[i].pos) {
+                    if (cnt == 1) sum += allpoint[i].p.x - ls;
+                    cnt--;
+                } else {
+                    if (cnt == 0) ls = allpoint[i].p.x;
+                    cnt++;
+                }
+            }
+        }
+        if (cnt > 0) sum += rp - ls;
+        printf("Case %d: %.4f\n", cas++, sum / v1);
+    }
+}
diff --git a/HDOJ/4638_autoAC.cpp b/HDOJ/4638_autoAC.cpp
new file mode 100644
index 0000000..0132df1
--- /dev/null
+++ b/HDOJ/4638_autoAC.cpp
@@ -0,0 +1,101 @@
+#include<iostream>
+#include<string>
+#include<algorithm>
+#include<cstdlib>
+#include<cstdio>
+#include<set>
+#include<map>
+#include<vector>
+#include<cstring>
+#include<stack>
+#include<cmath>
+#include<queue>
+using namespace std;
+#define CL(x,v); memset(x,v,sizeof(x));
+#define INF 0x3f3f3f3f
+#define LL long long
+#define REP(i,r,n) for(int i=r;i<=n;i++)
+#define RREP(i,n,r) for(int i=n;i>=r;i--)
+const int MAXN=1e5+100;
+int tree[MAXN];
+int n;
+int lowbit(int x)
+ {
+     return x&(-x);
+ }
+ void add(int pos,int val)
+ {
+     while(pos <=n)
+     {
+         tree[pos] += val;
+         pos += lowbit(pos);
+     }
+ }
+ int read(int x)
+ {
+     int s=0;
+     while(x>0)
+     {
+         s += tree[x];
+         x -= lowbit(x);
+     }
+     return s;
+ }
+int A[MAXN],pos[MAXN];
+struct node{
+    int l,r,index;
+    bool operator <(const node& rsh)const{
+        if(r==rsh.r)
+            return l<rsh.l;
+        else return r<rsh.r;
+    }
+};
+vector<node> Q;
+int ans[MAXN];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int m;
+        scanf("%d%d",&n,&m);
+        REP(i,1,n){
+            scanf("%d",&A[i]);
+            pos[A[i]]=i;
+        }
+        Q.clear();
+        node tmp;
+        REP(i,1,m)
+        {
+            scanf("%d%d",&tmp.l,&tmp.r);
+            tmp.index=i;
+            Q.push_back(tmp);
+        }
+        sort(Q.begin(),Q.end());
+        CL(tree,0);
+        int j=0;
+        for(int i=1;i<=n;i++)
+        {
+            add(i,1);
+            if(A[i]+1<=n&&pos[A[i]+1]<i)
+            {
+                add(pos[A[i]+1],-1);
+            }
+            if(A[i]-1>=1&&pos[A[i]-1]<i)
+            {
+                add(pos[A[i]-1],-1);
+            }
+            while(Q[j].r==i)
+            {
+                ans[Q[j].index]=read(Q[j].r)-read(Q[j].l-1);
+                j++;
+            }
+        }
+        REP(i,1,m)
+        {
+            printf("%d\n",ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4639_autoAC.cpp b/HDOJ/4639_autoAC.cpp
new file mode 100644
index 0000000..7594a26
--- /dev/null
+++ b/HDOJ/4639_autoAC.cpp
@@ -0,0 +1,37 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <cmath>
+#include <vector>
+using namespace std;
+const int V = 5050 + 50;
+const int MaxN = 500 + 5;
+const int mod = 10000 + 7;
+int T, ans, num[V];
+char ch[10100];
+int main() {
+    int i, j, k;
+    scanf("%d", &T);
+    num[0] = num[1] = 1;
+    for(i = 2; i <= V; ++i)
+        num[i] = (num[i - 1] + num[i - 2]) % mod;
+    for(i = 1; i <= T; ++i) {
+        ans = 1;
+        int sum = 0;
+        scanf("%s", &ch);
+        int len = strlen(ch);
+        for(j = 1; j < len; ++j) {
+            if(ch[j] == 'e' && ch[j - 1] == 'h') {
+                sum++;
+                j++;
+            }
+            else {
+                ans = (ans * num[sum]) % mod;
+                sum = 0;
+            }
+        }
+        ans = (ans * num[sum]) % mod;
+        printf("Case %d: %d\n", i, ans);
+    }
+}
diff --git a/HDOJ/4640_autoAC.cpp b/HDOJ/4640_autoAC.cpp
new file mode 100644
index 0000000..9e8ccbb
--- /dev/null
+++ b/HDOJ/4640_autoAC.cpp
@@ -0,0 +1,91 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+#define INF 2000000000
+int q[4*(1<<17)][2];
+int maxQ=4*(1<<17)-3;
+int front,rear,n,m;
+int mat[20][20];
+int dp[1<<17],f[1<<17],dist[1<<17][18],vis[1<<17][18];
+int main ()
+{
+    int T;scanf("%d",&T);
+    for(int kk=1;kk<=T;++kk)
+    {
+        scanf("%d%d",&n,&m);
+        memset(dist,127,sizeof(dist));
+        memset(dp,127,sizeof(dp));
+        memset(vis,0,sizeof(vis));
+        memset(mat,127,sizeof(mat));
+        front=rear=0;
+        int u,v,s;
+        for(int i=1;i<=m;++i)
+        {
+            scanf("%d%d%d",&u,&v,&s);
+            u--;v--;
+            if(mat[u][v]>s)
+                mat[u][v]=mat[v][u]=s;
+        }
+        dist[0][0]=0;
+        q[++rear][0]=0;q[rear][1]=0;
+        vis[0][0]=1;
+        while(front!=rear)
+        {
+            if(++front==maxQ) front=0;
+            int u_sta=q[front][0],u=q[front][1];
+            vis[u_sta][u]=0;
+            for(int i=0;i<n;++i)
+            {
+                int v_sta=u_sta|(1<<i);
+                if(dist[v_sta][i]>dist[u_sta][u]+mat[u][i])
+                {
+                    dist[v_sta][i]=dist[u_sta][u]+mat[u][i];
+                    if(!vis[v_sta][i])
+                    {
+                        if(++rear==maxQ) rear=0;
+                        vis[v_sta][i]=1;
+                        q[rear][0]=v_sta;q[rear][1]=i;
+                    }
+                }
+            }
+        }
+        for(int i=0;i<(1<<n);++i)
+            for(int j=0;j<n;++j)
+            dp[i>>1]=min(dp[i>>1],dist[i][j]);
+        int tot_sta=1<<n-1;
+        for(int i=0;i<tot_sta;++i)
+            f[i]=dp[i];
+        for(int k=1;k<=2;++k)
+        {
+            for(int i=tot_sta-1;i;--i)
+                for(u=i;u;u=(--u)&i)
+            {
+                v=i^u;
+                if(dp[i]>max(dp[u],f[v]))
+                {
+                    if(i==224 && max(dp[u],f[v])==5)
+                        cout<<"dd";
+                    dp[i]=max(dp[u],f[v]);
+                }
+            }
+        }
+        int query;scanf("%d",&query);
+        int sta=0;
+        while(query--)
+        {
+            scanf("%d",&u);
+            sta|=1<<u-2;
+        }
+        int ans=INF;
+        for(int i=0;i<tot_sta;++i)
+            if((i&sta)==sta)
+        {
+            ans=min(ans,dp[i]);
+        }
+        if(ans>=INF)
+            printf("Case %d: -1\n",kk);
+        else printf("Case %d: %d\n",kk,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4641_autoAC.cpp b/HDOJ/4641_autoAC.cpp
new file mode 100644
index 0000000..ae4cdac
--- /dev/null
+++ b/HDOJ/4641_autoAC.cpp
@@ -0,0 +1,131 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define Maxn 250009
+int root,last;
+int tots;
+int l;
+int sv[Maxn*2];
+struct query{int a;long long ans;}qu[Maxn];
+struct sam_node{
+    int fa,son[26];
+    int len;
+    void init(int _len){len=_len;fa=-1;memset(son,-1,sizeof(son));}
+}t[Maxn*2];
+void sam_init(){
+    tots=0;
+    root=last=0;
+    t[tots].init(0);
+}
+void extend(int w){
+    int p=last;
+    int np=++tots;t[tots].init(t[p].len+1);
+    sv[l]=np;
+    int q,nq;
+    while(p!=-1&&t[p].son[w]==-1){t[p].son[w]=np;p=t[p].fa;}
+    if (p==-1) t[np].fa=root;
+    else{
+        q=t[p].son[w];
+        if (t[p].len+1==t[q].len){t[np].fa=q;}
+        else{
+            nq=++tots;t[nq].init(0);
+            t[nq]=t[q];
+            t[nq].len=t[p].len+1;
+            t[q].fa=nq;t[np].fa=nq;
+            while(p!=-1&&t[p].son[w]==q){t[p].son[w]=nq;p=t[p].fa;}
+        }
+    }
+    last=np;
+}
+int w[Maxn],r[Maxn*2];
+void topsort(){
+    int i;
+    for(i=0;i<=l;++i)   w[i]=0;
+    for(i=1;i<=tots;++i)w[t[i].len]++;
+    for(i=1;i<=l;++i)   w[i]+=w[i-1];
+    for(i=tots;i>=1;--i)r[w[t[i].len]--]=i;
+    r[0]=0;
+}
+int dp[Maxn*2];
+int sub[Maxn*2];
+char s[Maxn];
+int set[Maxn*2];
+int findset(int x){
+    int y;
+    while(x!=set[x]){
+        y=set[x];
+        set[x]=set[y];
+        x=y;
+    }
+    return x;
+}
+int main(){
+    int n,m,k,f,y,p,i,a;
+    long long ans;
+    while(scanf("%d%d%d",&n,&m,&k)!=EOF){
+        scanf("%s",s);
+        int tl=strlen(s);
+        l=0;
+        sam_init();
+        for(i=0;i<tl;++i){
+            ++l;
+            extend(s[i]-'a');
+        }
+        char ts[20];
+        for(i=1;i<=m;++i){
+            scanf("%d",&a);
+            if (a==1){
+                scanf("%s",ts);
+                s[l++]=ts[0];
+                qu[i].a=a;
+                extend(ts[0]-'a');
+            }
+            else if (a==2) qu[i].a=a;
+        }
+        for(i=0;i<=tots;++i){dp[i]=0;}
+        topsort();
+        p=root;
+        for(i=0;i<l;++i){
+            p=t[p].son[s[i]-'a'];
+            dp[p]++;
+        }
+        for(i=tots;i>=1;--i){
+            p=r[i];
+            if (t[p].fa!=-1) dp[t[p].fa]+=dp[p];
+        }
+        ans=0;
+        for(i=1;i<=tots;++i)
+            if (dp[i]>=k) ans+=t[i].len-t[t[i].fa].len;
+        for(i=0;i<=tots;++i){set[i]=i;sub[i]=0;}
+        for(i=m;i>=1;--i){
+            if (qu[i].a==2) qu[i].ans=ans;
+            else{
+                p=sv[l];
+                l--;
+                y=findset(p);
+                while(y!=0&&dp[y]<k){          
+                    f=t[y].fa;
+                    set[y]=f=findset(f);
+                    y=f;
+                }
+                y=findset(p);
+                if (y==root) {continue;}
+                sub[y]++;
+                while(y!=0&&(dp[y]-sub[y]<k)){   
+                    ans=ans-t[y].len+t[t[y].fa].len;
+                    f=t[y].fa;
+                    f=findset(f);
+                    sub[f]+=sub[y];
+                    set[y]=f;
+                    y=f;
+                }
+            }
+        }
+        for(i=1;i<=m;++i)if (qu[i].a==2){
+            printf("%I64d\n",qu[i].ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4642_autoAC.cpp b/HDOJ/4642_autoAC.cpp
new file mode 100644
index 0000000..9b59166
--- /dev/null
+++ b/HDOJ/4642_autoAC.cpp
@@ -0,0 +1,22 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+int n,m;
+int main(){
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&m);
+        int x;
+        for(int i=0;i<n;i++)
+            for(int j=0;j<m;j++)
+                scanf("%d",&x);
+        if(x)
+            puts("Alice");
+        else
+            puts("Bob");
+    }
+    return 0;
+}
diff --git a/HDOJ/4643_autoAC.cpp b/HDOJ/4643_autoAC.cpp
new file mode 100644
index 0000000..78124f8
--- /dev/null
+++ b/HDOJ/4643_autoAC.cpp
@@ -0,0 +1,190 @@
+#include<stdio.h>
+#include<algorithm>
+#include<math.h>
+using namespace std;
+const double eps=1e-11;
+struct point
+{
+    double x,y;
+}city[55],base[55];
+int N,M,K,a,b;
+struct node
+{
+    int i,j;
+    point p;
+    double dist;
+}jiao[3000];
+inline bool mo_ee(double x,double y)
+{
+    double ret=x-y;
+    if(ret<0) ret=-ret;
+    if(ret<eps) return 1;
+    return 0;
+}
+inline bool mo_gg(double x,double y)  {   return x > y + eps;} // x > y   
+inline bool mo_ll(double x,double y)  {   return x < y - eps;} // x < y   
+inline bool mo_ge(double x,double y) {   return x > y - eps;} // x >= y   
+inline bool mo_le(double x,double y) {   return x < y + eps;}     // x <= y   
+inline double min(double a,double b)
+{
+    if(a<b) return a;
+    return b;
+}
+inline double max(double a,double b)
+{
+    if(a>b) return a;
+    return b;
+}
+point getxiang(point xiang)
+{
+    point a;
+    if(mo_ee(xiang.x,0))
+    {
+        a.x=1;
+        a.y=0;
+        return a;
+    }else if(mo_ee(xiang.y,0))
+    {
+        a.x=0;
+        a.y=1;
+        return a;
+    }else
+    {
+        a.x=1;
+        a.y=-1.0*xiang.x/xiang.y;
+        return a;
+    }
+}
+inline double mo_distance(point p1,point p2)
+{
+    return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
+}
+point mo_intersection(point u1,point u2,point v1,point v2)
+{
+    point ret=u1;
+    double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x))
+             /((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x));
+    ret.x+=(u2.x-u1.x)*t;
+    ret.y+=(u2.y-u1.y)*t;
+    return ret;
+}
+int segjiao(point &ji,point a,point b,point c,point d)
+{
+    ji=mo_intersection(a,b,c,d);
+    if(mo_ll(ji.x,min(c.x,d.x))) return 0;
+    if(mo_ll(ji.y,min(c.y,d.y))) return 0;
+    if(mo_gg(ji.x,max(c.x,d.x))) return 0;
+    if(mo_gg(ji.y,max(c.y,d.y))) return 0;
+    return 1;
+}
+node jiaojiao(int a,int b,int ii,int jj)
+{
+    node cur;
+    point xiang1,xiang2;
+    xiang1.x=city[b].x-city[a].x,xiang1.y=city[b].y-city[a].y;
+    xiang2.x=base[jj].x-base[ii].x,xiang2.y=base[jj].y-base[ii].y;
+    if(mo_ee(xiang1.x*xiang2.x,xiang1.y*xiang2.y))
+    {
+        cur.i=-1;
+        return cur;
+    }
+    xiang2=getxiang(xiang2);
+    point zhong;
+    zhong.x=(base[ii].x+base[jj].x)/2,zhong.y=(base[ii].y+base[jj].y)/2;
+    point zhongxia;
+    zhongxia.x=zhong.x+xiang2.x;
+    zhongxia.y=zhong.y+xiang2.y;
+    point jiaodian;
+    int jjao=segjiao(jiaodian,zhong,zhongxia,city[a],city[b]);
+    if(jjao==0)
+    {
+        cur.i=-1;
+        return cur;
+    }
+    cur.p=jiaodian;
+    cur.i=ii;
+    cur.j=jj;
+    cur.dist=mo_distance(jiaodian,city[a]);
+    return cur;
+}
+bool cmp(const node &aa,const node &bb)
+{
+    if(mo_ee(aa.dist,bb.dist))
+    {
+        point temp;
+        temp.x=(base[aa.i].x+base[aa.j].x)/2;
+        temp.y=(base[aa.i].y+base[aa.j].y)/2;
+        double dist1=mo_distance(aa.p,temp);
+        temp.x=(base[bb.i].x+base[bb.j].x)/2;
+        temp.y=(base[bb.i].y+base[bb.j].y)/2;
+        double dist2=mo_distance(bb.p,temp);
+        return mo_ll(dist1,dist2);
+    }
+    return mo_ll(aa.dist,bb.dist);
+}
+inline int nextno(int j,int no)
+{
+    if(jiao[j].i==no) return jiao[j].j;
+    if(jiao[j].j==no) return jiao[j].i;
+    return no;
+}
+int main()
+{
+    int i,j,ncase;
+    while(scanf("%d%d",&N,&M)!=EOF)
+    {
+        for(i=1;i<=N;++i)
+        {
+            scanf("%lf%lf",&city[i].x,&city[i].y);
+        }
+        for(i=1;i<=M;++i)
+        {
+            scanf("%lf%lf",&base[i].x,&base[i].y);
+        }
+        scanf("%d",&K);
+        for(ncase=0;ncase<K;++ncase)
+        {
+            int yong=0;
+            scanf("%d%d",&a,&b);
+            for(i=1;i<=M;++i)
+            {
+                for(j=i+1;j<=M;++j)
+                {
+                    if(i==j) continue;
+                    node cur=jiaojiao(a,b,i,j);
+                    if(cur.i<0)
+                    {
+                        continue;
+                    }else
+                    {
+                        jiao[yong++]=cur;
+                    }
+                }
+            }
+            sort(jiao,jiao+yong,cmp);
+            double mindist=-1;
+            int minno;
+            for(i=1;i<=M;++i)
+            {
+                double disttemp=sqrt((city[a].x-base[i].x)*(city[a].x-base[i].x)+(city[a].y-base[i].y)*(city[a].y-base[i].y));
+                if(mindist<0||mo_ll(disttemp,mindist))
+                {
+                    mindist=disttemp;
+                    minno=i;
+                }
+            }
+            int dang=minno,ret=0;
+            for(i=0;i<yong;++i)
+            {
+                int xinno=nextno(i,dang);
+                if(xinno!=dang)
+                {
+                    dang=xinno;
+                    ret++;
+                }
+            }
+            printf("%d\n",ret);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4644_autoAC.cpp b/HDOJ/4644_autoAC.cpp
new file mode 100644
index 0000000..22117ff
--- /dev/null
+++ b/HDOJ/4644_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+char str[2000100];
+char t[100100];
+pair<int,int>s[100100];
+int index[100100];
+int n;
+int ne[100100];
+void get_next(char* str,int len){
+    ne[0]=0;
+    for(int i=1;i<len;i++){
+        int j=ne[i-1];
+        while(j&&str[i]!=str[j])j=ne[j-1];
+        if(str[i]==str[j])j++;
+        ne[i]=j;
+    }
+}
+bool match(char *s,int len){
+    int k=0;
+    for(int i=0;i<n;i++){
+        while(k&&str[k]!=s[i])k=ne[k-1];
+        if(str[k]==s[i])k++;
+        if(k==len)return true;
+    }
+    return false;
+}
+int main(){
+    while(~scanf("%s",str)){
+        n=strlen(str);
+        for(int i=0;i<n;i++){
+            s[i].first=str[i];
+            s[i].second=i;
+        }
+        stable_sort(s,s+n);
+        for(int i=0;i<n;i++)index[i]=s[i].second;
+        int now=index[0];
+        n--;
+        for(int i=0;i<n;i++){
+            t[i]=s[now].first;
+            now=index[now];
+        }
+        t[n]='\0';
+        int q;
+        scanf("%d",&q);
+        while(q--){
+            scanf("%s",str);
+            int len=strlen(str);
+            get_next(str,len);
+            if(match(t,len))printf("YES\n");
+            else printf("NO\n");
+        }
+    }
+}
diff --git a/HDOJ/4646_autoAC.cpp b/HDOJ/4646_autoAC.cpp
new file mode 100644
index 0000000..e8b08da
--- /dev/null
+++ b/HDOJ/4646_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#define ll long long
+using namespace std;
+ll t,n;
+map<ll,ll> g;
+ll f(ll x)
+{
+    if (x%2==0) return 2*(x/6+1)-1;
+        else return 2*((x-3)/6+1);
+}
+ll get(ll x)
+{
+    if (g[x]!=0) return g[x];
+    g[x]=f(x);
+    for (ll i=2; i*i<=x; i++)
+    {
+        if (x%i>0) continue;
+        g[x]-=get(i);
+        if (i*i!=x)
+        {
+            g[x]-=get(x/i);
+        }
+    }
+    return g[x];
+}
+int main()
+{
+    scanf("%I64d",&t);
+    while (t--)
+    {
+        scanf("%I64d",&n);
+        if (n%3==0)
+        {
+            printf("0\n");
+            continue;
+        }
+        if ((n&1)==0)
+        {
+            printf("0\n");
+            continue;
+        }
+        if (n==1)
+        {
+            printf("1\n");
+            continue;
+        }
+        if (n==3)
+        {
+            printf("0\n");
+            continue;
+        }
+        n=(n+3)>>1;
+        printf("%I64d\n",get(n));
+    }
+    return 0;
+}
diff --git a/HDOJ/4647_autoAC.cpp b/HDOJ/4647_autoAC.cpp
new file mode 100644
index 0000000..8e11728
--- /dev/null
+++ b/HDOJ/4647_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int N=100010;
+int n,m;
+double a[N];
+int cmp(double x,double y){
+    return x>y;
+}
+int main(){
+    while(~scanf("%d%d",&n,&m)){
+        for(int i=1;i<=n;i++)
+            scanf("%lf",&a[i]);
+        int u,v,w;
+        while(m--){
+            scanf("%d%d%d",&u,&v,&w);
+            a[u]+=1.0*w/2;
+            a[v]+=1.0*w/2;
+        }
+        double t1=0,t2=0;
+        sort(a+1,a+1+n,cmp);
+        for(int i=1;i<=n;i++)
+            if(i&1)
+                t1+=a[i];
+            else
+                t2+=a[i];
+        printf("%.0lf\n",t1-t2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4648_autoAC.cpp b/HDOJ/4648_autoAC.cpp
new file mode 100644
index 0000000..25f1c7a
--- /dev/null
+++ b/HDOJ/4648_autoAC.cpp
@@ -0,0 +1,32 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <vector>
+#include <cmath>
+using namespace std;
+const int V = 100000 + 50;
+const int MaxN = 80 + 5;
+const int mod = 10000 + 7;
+const __int64 INF = 0x7FFFFFFFFFFFFFFFLL;
+const int inf = 0x7fffffff;
+int n, m, sum[V], ans;
+int main() {
+    int i, j;
+    while(~scanf("%d%d", &n, &m)) {
+        ans = 0;
+        for(i = 1; i <= n; ++i) {
+            int temp;
+            scanf("%d", &temp);
+            sum[i] = (sum[i - 1] + temp) % m;
+        }
+        for(i = n; i >= 1 && i > ans; --i) {
+            for(j = 1; j + i - 1 <= n; ++j)
+                if((sum[j + i - 1] - sum[j - 1]) % m == 0) {
+                    ans = max(ans, i);
+                    break;
+                }
+        }
+        printf("%d\n", ans);
+    }
+}
diff --git a/HDOJ/4649_autoAC.cpp b/HDOJ/4649_autoAC.cpp
new file mode 100644
index 0000000..7ecc2a6
--- /dev/null
+++ b/HDOJ/4649_autoAC.cpp
@@ -0,0 +1,72 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <stack>
+#include <queue>
+#include <map>
+#include <set>
+#include <vector>
+#include <math.h>
+#include <bitset>
+#include <algorithm>
+#include <climits>
+using namespace std;
+#define ls 2*i
+#define rs 2*i+1
+#define UP(i,x,y) for(i=x;i<=y;i++)
+#define DOWN(i,x,y) for(i=x;i>=y;i--)
+#define MEM(a,x) memset(a,x,sizeof(a))
+#define W(a) while(a)
+#define gcd(a,b) __gcd(a,b)
+#define LL long long
+#define N 205
+#define MOD 1000000007
+#define INF 0x3f3f3f3f
+#define EXP 1e-8
+#define rank rank1
+const int mod = 10007;
+int n,a[N];
+double dp[N],p[N],ans;
+char op[N][5];
+int main()
+{
+    int i,j,k,cas=1;
+    while(~scanf("%d",&n))
+    {
+        for(i = 0; i<=n; i++)
+            scanf("%d",&a[i]);
+        for(i = 1; i<=n; i++)
+            scanf("%s",op[i]);
+        for(i = 1; i<=n; i++)
+            scanf("%lf",&p[i]);
+        ans = 0;
+        for(i = 0; i<=20; i++)
+        {
+            double q;
+            if(a[0]&(1<<i)) q = 1;
+            else q = 0;
+            for(j = 1; j<=n; j++)
+            {
+                if(a[j]&(1<<i))
+                {
+                    if(op[j][0]=='&')
+                        continue;
+                    else if(op[j][0]=='^')
+                        q = q*p[j]+(1-q)*(1-p[j]);
+                    else
+                        q = q*p[j]+(1-p[j]);
+                }
+                else
+                {
+                    if(op[j][0]=='&')
+                        q = q*p[j];
+                    else
+                        continue;
+                }
+            }
+            ans += q*(1<<i);
+        }
+        printf("Case %d:\n%lf\n",cas++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4650_autoAC.cpp b/HDOJ/4650_autoAC.cpp
new file mode 100644
index 0000000..cea90cc
--- /dev/null
+++ b/HDOJ/4650_autoAC.cpp
@@ -0,0 +1,61 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+const int N = 101;
+const double INF = 10000000000.0;
+const int INF_INT =10000000;
+int side[N][N];
+int dis[N][N];
+int vis[N][N];
+int tmp[N][N];
+double ans[N][N];
+int main(){
+    int n,m;
+    while(~scanf("%d%d",&n,&m)){
+        memset(vis,-1,sizeof(vis));
+        for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){ans[i][j]=INF;side[i][j]=INF_INT;}
+        for(int i=0;i<m;i++){
+            int u,v,w;
+            scanf("%d%d%d",&u,&v,&w);
+            side[u][v]=w;
+            vis[u][v]=1;
+        }
+        for(int k=1;k<=n;k++)for(int i=1;i<=n;i++)if(vis[i][k]!=-1){
+            for(int j=1;j<=n;j++)if(vis[k][j]!=-1){
+                if(vis[i][j]==-1)vis[i][j]=vis[i][k]+vis[k][j];
+                else vis[i][j]=min(vis[i][j],vis[i][k]+vis[k][j]);
+            }
+        }
+        for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)dis[i][j]=side[i][j];
+        for(int k=1;k<=n;k++){
+            for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(vis[i][j]!=-1&&k>=vis[i][j]){
+                ans[i][j]=min(ans[i][j],(double)dis[i][j]/k);
+            }
+            for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){tmp[i][j]=dis[i][j];dis[i][j]=INF_INT;}
+            for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){
+                for(int h=1;h<=n;h++){
+                    if(vis[i][h]==-1||k<vis[i][h])continue;
+                    if(vis[h][j]==-1||k<vis[h][j])continue;
+                    dis[i][j]=min(dis[i][j],tmp[i][h]+side[h][j]);
+                }
+            }
+        }
+        for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(vis[i][j]!=-1){
+            for(int k=1;k<=n;k++)if(vis[i][k]!=-1&&vis[k][j]!=-1&&vis[k][k]!=-1){
+                ans[i][j]=min(ans[i][j],ans[k][k]);
+            }
+        }
+        for(int i=1;i<=n;i++){
+            int j=1;
+            if(vis[i][j]==-1)printf("NO");
+            else printf("%.3lf",ans[i][j]);
+            for(j=2;j<=n;j++){
+                if(vis[i][j]==-1)printf(" NO");
+                else printf(" %.3lf",ans[i][j]);
+            }
+            printf("\n");
+        }
+    }
+}
diff --git a/HDOJ/4651_autoAC.cpp b/HDOJ/4651_autoAC.cpp
new file mode 100644
index 0000000..b49175c
--- /dev/null
+++ b/HDOJ/4651_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <cstring>
+#include <cmath>
+using namespace std;
+long long tar[100002];
+const int MOD=1000000007;
+void init()
+{
+    memset(tar,0,sizeof(tar));
+    tar[0]=1;
+    for(int i=1;i<=100000;i++)
+    {
+        int nbit;
+        for(int j=1;;j++)
+        {
+            int element1,element2;
+            element1=i-j*(3*j-1)/2;
+            element2=i-j*(3*j+1)/2;
+            if(j&1)
+                nbit=1;
+            else if(j%2==0)
+                nbit=-1;
+            if(element2<0 && element1<0)
+                break;
+            if(element1>=0)
+            {
+                tar[i]=(tar[i]+nbit*tar[element1])%MOD;
+            }
+            if(element2>=0)
+            {
+                tar[i]=(tar[i]+nbit*tar[element2])%MOD;
+            }
+        }
+        tar[i]=(tar[i]+MOD)%MOD;
+    }
+}
+int main()
+{
+    int testcase;
+    init();
+    cin>>testcase;
+    while(testcase--)
+    {
+        int rat;
+        cin>>rat;
+        cout<<tar[rat]<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4652_autoAC.cpp b/HDOJ/4652_autoAC.cpp
new file mode 100644
index 0000000..172628e
--- /dev/null
+++ b/HDOJ/4652_autoAC.cpp
@@ -0,0 +1,41 @@
+#include <cstdio>  
+#include <iostream>  
+#include <cstring>  
+#include <algorithm>  
+#include <cmath>  
+using namespace std;  
+double solve0(int m,int n)  
+{  
+    double ans=0;  
+    for(int i=0;i<=n-1;i++)  
+        ans+=pow(1.0*m,i);  
+    return ans;  
+}  
+double solve1(int m,int n)  
+{  
+    double ans=0;  
+    double tmp=1;  
+    for(int i=1;i<=n;i++)  
+    {  
+        ans+=tmp;  
+        tmp*=(m+0.0)/(m-i);  
+    }  
+    return ans;  
+}  
+int main()  
+{  
+    int t;  
+    while(scanf("%d",&t)!=EOF)  
+    {  
+        while(t--)  
+        {  
+            int n,m,op;  
+            scanf("%d%d%d",&op,&m,&n);  
+            if(op==0)  
+                printf("%.9lf\n",solve0(m,n));  
+            else  
+                printf("%.9lf\n",solve1(m,n));  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4654_autoAC.cpp b/HDOJ/4654_autoAC.cpp
new file mode 100644
index 0000000..1fbb142
--- /dev/null
+++ b/HDOJ/4654_autoAC.cpp
@@ -0,0 +1,102 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+using namespace std;
+#define inf (1<<29)
+const int maxn = 105;
+int g[maxn][maxn],a[maxn][maxn],p[maxn];
+bool vis[maxn],combine[maxn],par[maxn];
+int d[maxn],node[maxn],st[maxn],k,s,t;
+vector <int> vst[maxn];
+vector <int> pa , pb;
+int prim(int n) {
+    memset(vis,0,sizeof(vis));
+    memset(d,0,sizeof(d));
+    int mincut = 0 , tmp = -1;
+    s = t = -1;
+    int top = 0;
+    for(int i=0;i<k;i++) {
+        int maxi = -inf;
+        for(int j=0;j<k;j++) {
+            int u = node[j];
+            if(!combine[u]&&!vis[u]&&d[u]>maxi) {
+                tmp = u;
+                maxi = d[u];
+            }
+        }
+        st[top++] = tmp;
+        vis[tmp] = true;
+        if(i == k-1)
+            mincut = d[tmp];
+        for(int j=0;j<k;j++) {
+            int u = node[j];
+            if(!combine[u]&&!vis[u])
+                d[u] += g[tmp][u];
+        }
+    }
+    s = st[top-2];
+    t = st[top-1];
+    for(int i=0;i<top;i++) node[i] = st[i];
+    return mincut;
+}
+int stoer_wagner(int n) {
+    for(int i=0;i<n;i++) {
+        vst[i].clear();
+        vst[i].push_back(i);
+    }
+    int ans = inf;
+    memset(combine,0,sizeof(combine));
+    for(int i=0;i<n;i++) node[i] = i;
+    for(int i=1;i<n;i++) {
+        k = n - i + 1;
+        int cur = prim(n);
+        if(cur < ans) {
+            ans = cur;
+            for(int j=0;j<n;j++) par[j] = 0;
+            for(int j=0;j<vst[t].size();j++) par[ vst[t][j] ] = 1;
+        }
+        combine[t] = true;
+        for(int j=0;j<vst[t].size();j++) vst[s].push_back(vst[t][j]);
+        for(int j=0;j<n;j++) {
+            if(j == s) continue;
+            if(!combine[j]) {
+                g[s][j] += g[t][j];
+                g[j][s] += g[j][t];
+            }
+        }
+    }
+    pa.clear(); pb.clear();
+    for(int i=0;i<n;i++)
+        if(par[i]) pa.push_back(i);
+        else pb.push_back(i);
+    return ans;
+}
+int K;
+int dfs(vector <int> t) {
+    int n = t.size();
+    for(int i=0;i<n;i++) for(int j=0;j<n;j++) g[i][j] = a[t[i]][t[j]];
+    if(stoer_wagner(n) >= K) return 1;
+    vector <int> x , y;
+    for(int i=0;i<pa.size();i++) x.push_back(t[pa[i]]);
+    for(int i=0;i<pb.size();i++) y.push_back(t[pb[i]]);
+    return dfs(x) + dfs(y);
+}
+int main() {
+    int n , m;
+    while(~scanf("%d%d%d",&n,&m,&K)) {
+        memset(a , 0 ,sizeof(a));
+        while(m--) {
+            int u , v;
+            scanf("%d%d",&u,&v);
+            u --; v --;
+            a[u][v] += 1;
+            a[v][u] += 1;
+        }
+        vector <int> t;
+        for(int i=0;i<n;i++) t.push_back(i);
+        printf("%d\n" , dfs(t));
+    }
+    return 0;
+}
diff --git a/HDOJ/4655_autoAC.cpp b/HDOJ/4655_autoAC.cpp
new file mode 100644
index 0000000..a283c14
--- /dev/null
+++ b/HDOJ/4655_autoAC.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <stack>
+#include <queue>
+#include <set>
+#include <time.h>
+using namespace std;
+const int MOD = 1e9+7;
+long long inv(long long a,long long m)
+{
+    if(a == 1)return 1;
+    return inv(m%a,m)*(m-m/a)%m;
+}
+const int MAXN = 1000010;
+int a[MAXN];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        long long S = 1;
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d",&a[i]);
+            S *= a[i];
+            S %=MOD;
+        }
+        long long ans = S*n%MOD;
+        sort(a,a+n);
+        reverse(a,a+n);
+        int cnt = n-1;
+        for(int i = 0;i < n;i++)
+        {
+            if(cnt == 0)break;
+            long long tmp = S*inv(a[i],MOD)%MOD;
+            ans -= tmp;
+            ans = (ans%MOD+MOD)%MOD;
+            cnt--;
+            if(cnt == 0)break;
+            ans -= tmp;
+            ans = (ans%MOD+MOD)%MOD;
+            cnt--;
+            if(cnt == 0)break;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4656_autoAC.cpp b/HDOJ/4656_autoAC.cpp
new file mode 100644
index 0000000..f65f045
--- /dev/null
+++ b/HDOJ/4656_autoAC.cpp
@@ -0,0 +1,116 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int P = 1000003;
+const int N1 = 262144;
+const int N2 = N1+1;
+const int P1 = 998244353;
+const int P2 = 995622913;
+const int E1 = 996173970;
+const int E2 = 88560779;
+const int F1 = 121392023;
+const int F2 = 840835547;
+const int I1 = 998240545;
+const int I2 = 995619115;
+const long long M1 = 397550359381069386LL;
+const long long M2 = 596324591238590904LL;
+const long long MM = 993874950619660289LL;
+long long mul(long long x,long long y,long long z){
+    return (x*y - (long long)(x/(long double)z*y+1e-3)*z+z)%z;
+}
+int trf(int x1,int x2){
+    return (mul(M1,x1,MM)+mul(M2,x2,MM))%MM%P;
+}
+int A[N2],B[N2],C[N2];
+int A1[N2],B1[N2],C1[N2];
+void fft(int *A,int PM,int PW){
+    for(int m = N1,h;h = m/2, m >= 2;PW = (long long)PW*PW%PM,m=h)
+        for(int i = 0,w=1;i < h;i++, w = (long long)w*PW%PM)
+            for(int j = i;j < N1;j += m){
+                int k = j+h, x = (A[j]-A[k]+PM)%PM;
+                (A[j]+=A[k])%=PM;
+                A[k] = (long long)w*x%PM;
+            }
+    for(int i = 0,j = 1;j < N1-1;j++){
+        for(int k = N1/2; k > (i^=k);k /= 2);
+        if(j < i)swap(A[i],A[j]);
+    }
+}
+void mul(){
+    memset(C,0,sizeof(C));
+    memcpy(A1,A,sizeof(A));
+    memcpy(B1,B,sizeof(B));
+    fft(A1,P1,E1); fft(B1,P1,E1);
+    for(int i = 0;i < N1;i++)C1[i] = (long long)A1[i]*B1[i]%P1;
+    fft(C1,P1,F1);
+    for(int i = 0;i < N1;i++)C1[i] = (long long)C1[i]*I1%P1;
+    fft(A,P2,E2); fft(B,P2,E2);
+    for(int i = 0;i < N1;i++)C[i] = (long long)A[i]*B[i]%P2;
+    fft(C,P2,F2);
+    for(int i = 0;i < N1;i++)C[i] = (long long)C[i]*I2%P2;
+    for(int i = 0;i < N1;i++)C[i] = trf(C1[i],C[i]);
+}
+int INV[P];
+const int MAXN = 100010;
+int F[MAXN];
+int a[MAXN];
+int pd[MAXN];
+int pb[MAXN];
+int pc2[MAXN];
+int p[MAXN];
+int main()
+{
+    INV[1] = 1;
+    for(int i = 2;i < P;i++)
+        INV[i] = (long long)P/i*(P-INV[P%i])%P;
+    F[0] = 1;
+    for(int i = 1;i < MAXN;i++)
+        F[i] = (long long)F[i-1]*i%P;
+    int n,b,c,d;
+    while(scanf("%d%d%d%d",&n,&b,&c,&d) == 4){
+        for(int i = 0;i < n;i++)scanf("%d",&a[i]);
+        pd[0] = 1;
+        for(int i = 1;i < n;i++)
+            pd[i] = (long long)pd[i-1]*d%P;
+        memset(A,0,sizeof(A));
+        memset(B,0,sizeof(B));
+        for(int i = 0;i < n;i++)
+            A[i] = (long long)a[n-1-i]*F[n-1-i]%P;
+        for(int i = 0;i < n;i++)
+            B[i] = (long long)pd[i]*INV[F[i]]%P;
+        mul();
+        for(int i = 0;i < n;i++)p[i] = C[i];
+        reverse(p,p+n);
+        memset(A,0,sizeof(A));
+        pb[0] = 1;
+        for(int i = 1;i < n;i++)
+            pb[i] = (long long)pb[i-1]*b%P;
+        pc2[0] = 1;
+        int c2 = (long long)c*c%P;
+        for(int i = 1, s = c;i < n;i++){
+            pc2[i] = (long long)pc2[i-1]*s%P;
+            s = (long long)s*c2%P;
+        }
+        for(int i = 0;i < n;i++)
+            A[i] = (long long)pb[i]*INV[F[i]]%P*p[i]%P*pc2[i]%P;
+        memset(B,0,sizeof(B));
+        B[0] = 1;
+        for(int i = 1;i < n;i++)
+            B[i] = B[N1-i] = INV[pc2[i]];
+        mul();
+        for(int i = 0;i < n;i++)C[i] = (long long)C[i]*pc2[i]%P;
+        for(int i = 0;i < n;i++)
+            printf("%d\n",C[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4657_autoAC.cpp b/HDOJ/4657_autoAC.cpp
new file mode 100644
index 0000000..4894574
--- /dev/null
+++ b/HDOJ/4657_autoAC.cpp
@@ -0,0 +1,45 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+#include<iomanip>
+#include<cmath>
+#include<ctime>
+#include<cstring>
+#include<vector>
+#define ll __int64
+#define pi acos(-1.0)
+#define MAX 100005
+#define mod 1000003
+using namespace std;
+int a[MAX],b[MAX],c[MAX],index[MAX];
+int main(){
+    int t,n,i,j;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(i=0;i<n;i++) scanf("%d",&b[i]);
+        for(i=0;i<n;i++) a[i]=c[i]=index[i]=i;
+        for(i=0;i<n;i++){
+            int cur=i;
+            while((a[cur]+b[cur])%n!=c[cur]){
+                int l = index[(c[cur]-b[cur]+n)%n];
+                swap(a[l],a[cur]);
+                swap(index[a[l]],index[a[cur]]);
+                if(l>i) break;
+                cur=l;
+                swap(c[i+1],c[cur]);
+            }
+        }
+        for(i=0;i<n;i++){
+            printf("%d",a[i]);
+            if(i!=n-1) printf(" ");
+            else printf("\n");
+        }
+        for(i=0;i<n;i++){
+            printf("%d",c[i]);
+            if(i!=n-1) printf(" ");
+            else printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4658_autoAC.cpp b/HDOJ/4658_autoAC.cpp
new file mode 100644
index 0000000..a050fd3
--- /dev/null
+++ b/HDOJ/4658_autoAC.cpp
@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <iostream>
+using namespace std;
+const int mod=1e9+7;
+int f[100010];
+void init()
+{
+    f[0]=1;
+    int i,j,k,flag,t,tt;
+    for(i=1;i<=100000;i++)
+    {
+        f[i]=0;
+        flag=1;
+        for(j=1;;j++)
+        {
+            t=i-j*(3*j-1)/2;
+            tt=i-j*(3*j+1)/2;
+            if(t<0)break;
+            f[i]=(f[i]+flag*f[t])%mod;
+            if(tt<0)break;
+            f[i]=(f[i]+flag*f[tt])%mod;
+            flag=-flag;
+        }
+        f[i]=(f[i]+mod)%mod;
+    }
+}
+int find(int n,int k)
+{
+    int i,j,ans,flag=-1,t,tt;
+    ans=f[n];
+    for(i=1;;i++)
+    {
+        t=k*i*(i*3-1)/2;
+        tt=k*i*(i*3+1)/2;
+        if(t>n)break;
+        ans=(ans+flag*f[n-t])%mod;
+        if(tt>n)break;
+        ans=(ans+flag*f[n-tt])%mod;
+        flag=-flag;
+    }
+    return (ans+mod)%mod;
+}
+int main()
+{
+    init();
+    int T;
+    cin>>T;
+    while(T--)
+    {
+        int n,k,ans;
+        scanf("%d%d",&n,&k);
+        ans=find(n,k) ;
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4661_autoAC.cpp b/HDOJ/4661_autoAC.cpp
new file mode 100644
index 0000000..4099a54
--- /dev/null
+++ b/HDOJ/4661_autoAC.cpp
@@ -0,0 +1,141 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include<cstdio>
+#include<cstring>
+typedef long long LL;
+#define MAXN 1000010
+#define MAXM 2000010
+#define MOD 1000000007
+int n;
+LL fac[MAXN];
+LL invfac[MAXN];
+int first[MAXN], next[MAXM], v[MAXM], e;
+bool vis[MAXN];
+LL dp[MAXN];
+LL f[MAXN];
+int size[MAXN];
+LL ext_gcd(LL a, LL b, LL &x, LL &y) {
+    LL t, d;
+    if (b == 0) {
+        x = 1;
+        y = 0;
+        return a;
+    }
+    d = ext_gcd(b, a % b, x, y);
+    t = x;
+    x = y;
+    y = t - a / b * y;
+    return d;
+}
+LL invmod(LL a, LL n = MOD) {
+    LL x, y;
+    if (ext_gcd(a, n, x, y) != 1)
+        return -1;
+    return (x % n + n) % n;
+}
+void init() {
+    int i;
+    fac[0] = 1;
+    for (i = 1; i < MAXN; i++) {
+        fac[i] = fac[i - 1] * i;
+        fac[i] %= MOD;
+    }
+    for (i = 0; i < MAXN; i++) {
+        invfac[i] = invmod(fac[i]);
+    }
+}
+inline void addEdge(int x, int y) {
+    v[e] = y;
+    next[e] = first[x];
+    first[x] = e++;
+}
+void getSize(int x) {
+    vis[x] = true;
+    size[x] = 1;
+    for (int i = first[x]; i != -1; i = next[i]) {
+        int y = v[i];
+        if (!vis[y]) {
+            getSize(y);
+            size[x] += size[y];
+        }
+    }
+}
+void dfs(int x) {
+    vis[x] = true;
+    dp[x] = fac[size[x] - 1];
+    for (int i = first[x]; i != -1; i = next[i]) {
+        int y = v[i];
+        if (!vis[y]) {
+            dfs(y);
+            dp[x] *= invfac[size[y]];
+            dp[x] %= MOD;
+            dp[x] *= dp[y];
+            dp[x] %= MOD;
+        }
+    }
+}
+void search(int x, int pre) {
+    vis[x] = true;
+    if (pre != -1) {
+        f[x] = fac[n - 1];
+        f[x] *= invfac[n - size[x]];
+        f[x] %= MOD;
+        LL tmp = f[pre];
+        tmp *= invfac[n - 1];
+        tmp %= MOD;
+        tmp *= fac[n - 1 - size[x]];
+        tmp %= MOD;
+        tmp *= fac[size[x]];
+        tmp %= MOD;
+        tmp *= invmod(dp[x]);
+        tmp %= MOD;
+        f[x] *= tmp;
+        f[x] %= MOD;
+        for (int i = first[x]; i != -1; i = next[i]) {
+            int y = v[i];
+            if (!vis[y]) {
+                f[x] *= invfac[size[y]];
+                f[x] %= MOD;
+                f[x] *= dp[y];
+                f[x] %= MOD;
+            }
+        }
+    }
+    for (int i = first[x]; i != -1; i = next[i]) {
+        int y = v[i];
+        if (!vis[y]) {
+            search(y, x);
+        }
+    }
+}
+int main() {
+    int T;
+    int i;
+    int x, y;
+    int ans;
+    init();
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d", &n);
+        e = 0;
+        memset(first, -1, sizeof(first));
+        for (i = 1; i < n; i++) {
+            scanf("%d%d", &x, &y);
+            addEdge(x, y);
+            addEdge(y, x);
+        }
+        memset(vis, false, sizeof(vis));
+        getSize(1);
+        memset(vis, false, sizeof(vis));
+        dfs(1);
+        memset(vis, false, sizeof(vis));
+        f[1] = dp[1];
+        search(1, -1);
+        ans = 0;
+        for (i = 1; i <= n; i++) {
+            ans += (f[i] * f[i]) % MOD;
+            ans %= MOD;
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4662_autoAC.cpp b/HDOJ/4662_autoAC.cpp
new file mode 100644
index 0000000..1f2da7d
--- /dev/null
+++ b/HDOJ/4662_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<cstdio>
+#include<cstring>
+#define MAXN 1000010
+char str[MAXN];
+bool isOK(int len) {
+    if (str[0] != 'M') {
+        return false;
+    }
+    for (int i = 1; i < len; i++) {
+        if (str[i] == 'M') {
+            return false;
+        }
+    }
+    return true;
+}
+int main() {
+    int T;
+    int len;
+    int cnt;
+    int i;
+    scanf("%d", &T);
+    while (T--) {
+        scanf(" %s", str);
+        len = strlen(str);
+        if (isOK(len)) {
+            cnt = 0;
+            for (i = 1; i < len; i++) {
+                if (str[i] == 'U') {
+                    cnt += 3;
+                } else {
+                    cnt++;
+                }
+            }
+            if (len == 2 && str[1] == 'I') {
+                puts("Yes");
+            } else if (cnt % 6 == 2 || cnt % 6 == 4) {
+                puts("Yes");
+            } else {
+                puts("No");
+            }
+        } else {
+            puts("No");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4664_autoAC.cpp b/HDOJ/4664_autoAC.cpp
new file mode 100644
index 0000000..c417625
--- /dev/null
+++ b/HDOJ/4664_autoAC.cpp
@@ -0,0 +1,65 @@
+#include<cstdio>
+#include<cstring>
+#define MAXN 1010
+int sg[MAXN];
+bool vis[MAXN];
+int SG(int n) {
+    if (n == 0) {
+        sg[n] = 0;
+    } else if (n == 1) {
+        sg[n] = 0;
+    } else if (n == 2) {
+        sg[n] = 1;
+    } else if (n == 3) {
+        sg[n] = 1;
+    } else if (sg[n] == -1) {
+        int i;
+        memset(vis, false, sizeof(vis));
+        for (i = 0; i <= n - 2; i++) {
+            vis[SG(i) ^ SG(n - i - 2)] = true;
+        }
+        for (i = 0;; i++) {
+            if (!vis[i]) {
+                break;
+            }
+        }
+        sg[n] = i;
+    }
+    return sg[n];
+}
+void init() {
+    int i;
+    memset(sg, -1, sizeof(sg));
+    for (i = 0; i < MAXN; i++) {
+        sg[i] = SG(i);
+    }
+}
+int getSG(int n) {
+    if (n < MAXN) {
+        return sg[n];
+    } else {
+        return sg[n % 34 + 2 * 34];
+    }
+}
+int main() {
+    int T;
+    int n;
+    int tmp;
+    int res;
+    init();
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d", &n);
+        res = 0;
+        while (n--) {
+            scanf("%d", &tmp);
+            res ^= getSG(tmp);
+        }
+        if (res) {
+            puts("Carol");
+        } else {
+            puts("Dave");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4665_autoAC.cpp b/HDOJ/4665_autoAC.cpp
new file mode 100644
index 0000000..3ce23f8
--- /dev/null
+++ b/HDOJ/4665_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+#include<vector>
+#define MAXN 2010
+using namespace std;
+int arr[MAXN];
+char str[MAXN];
+bool flag;
+int idx[MAXN];
+int cnt[MAXN];
+int st[2][MAXN];
+int belong[MAXN];
+int n;
+vector<int> pos[MAXN];
+void dfs(int x, int p1, int p2) {
+    if (x > n) {
+        flag = true;
+    }
+    if (flag) {
+        return;
+    }
+    if (p1 > 0 && p2 > 0
+            && arr[st[0][min(p1, p2)]] != arr[st[1][min(p1, p2)]]) {
+        return;
+    }
+    if (belong[x] == 0) {
+        st[0][p1 + 1] = x;
+        dfs(x + 1, p1 + 1, p2);
+    } else if (belong[x] == 1) {
+        st[1][p2 + 1] = x;
+        dfs(x + 1, p1, p2 + 1);
+    } else {
+        st[0][p1 + 1] = x;
+        belong[pos[arr[x]][2]] = 1;
+        dfs(x + 1, p1 + 1, p2);
+        if (!flag) {
+            st[1][p2 + 1] = x;
+            belong[pos[arr[x]][2]] = 0;
+            dfs(x + 1, p1, p2 + 1);
+            belong[pos[arr[x]][2]] = -1;
+        }
+    }
+}
+int main() {
+    int T;
+    int i;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d", &n);
+        memset(idx, 0, sizeof(idx));
+        memset(cnt, 0, sizeof(cnt));
+        for (i = 1; i <= n; i++) {
+            scanf("%d", &arr[i]);
+            cnt[arr[i]]++;
+            idx[i] = cnt[arr[i]];
+            pos[arr[i]].clear();
+        }
+        memset(belong, -1, sizeof(belong));
+        for (i = 1; i <= n; i++) {
+            if (idx[i] == 1) {
+                belong[i] = 0;
+            } else if (idx[i] == 2 && cnt[arr[i]] == 2) {
+                belong[i] = 1;
+            } else if (idx[i] == 4) {
+                belong[i] = 1;
+            }
+            pos[arr[i]].push_back(i);
+        }
+        flag = false;
+        dfs(1, 0, 0);
+        for (i = 1; i <= (n >> 1); i++) {
+            str[st[0][i]] = '0';
+            str[st[1][i]] = '1';
+        }
+        for (i = 1; i <= n; i++) {
+            putchar(str[i]);
+        }
+        putchar('\n');
+    }
+    return 0;
+}
diff --git a/HDOJ/4666_autoAC.cpp b/HDOJ/4666_autoAC.cpp
new file mode 100644
index 0000000..f02700e
--- /dev/null
+++ b/HDOJ/4666_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<set>
+using namespace std;
+#define maxn 60002
+int maps[maxn][6];
+multiset<int>se[1<<5];
+multiset<int>::iterator i1,i2;
+int main()
+{
+    int i,j,leap,x,n,m,a;
+    while(~scanf("%d%d",&n,&m))
+    {
+        for(i=0;i<(1<<5);i++)
+            se[i].clear();
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d",&leap);
+            if(leap==0)
+            {
+                for(j=0;j<m;j++)
+                {
+                    scanf("%d",&maps[i][j]);
+                }
+                for(a=0;a<(1<<m);a++)
+                {
+                    int as;
+                    as=0;
+                    for(j=0;j<m;j++)
+                    {
+                        if(a&(1<<j))as+=maps[i][j];
+                        else as-=maps[i][j];
+                    }
+                    se[a].insert(as);
+                }
+            }
+            else
+            {
+                scanf("%d",&x);
+                for(a=0;a<(1<<m);a++)
+                {
+                    int as;
+                    as=0;
+                    for(j=0;j<m;j++)
+                    {
+                        if(a&(1<<j))as+=maps[x][j];
+                        else as-=maps[x][j];
+                    }
+                    i1=se[a].find(as);
+                    se[a].erase(i1);
+                }
+            }
+            int ans=0;
+            for(a=0;a<(1<<m);a++)
+            {
+                i1=se[a].begin();
+                i2=se[a].end();
+                i2--;
+                ans=max(ans,(*i2)-(*i1));
+            }
+            cout<<ans<<endl;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4667_autoAC.cpp b/HDOJ/4667_autoAC.cpp
new file mode 100644
index 0000000..054d117
--- /dev/null
+++ b/HDOJ/4667_autoAC.cpp
@@ -0,0 +1,116 @@
+#include<stdio.h>
+#include<iostream>
+#include<math.h>
+#include<algorithm>
+#define PI  3.1415926
+using namespace std;
+struct list
+{
+    double x;
+    double y;
+    int r;
+    int pos;
+}point[500001],tu[500001],pp;
+int tops,num;
+int cmp1(struct list a,struct list b)
+{
+    if(a.y!=b.y)return a.y<b.y;
+    else return a.x<b.x;
+}
+int cmp2(struct list a,struct list b)
+{
+    if((a.x-point[0].x)*(b.y-point[0].y)==(b.x-point[0].x)*(a.y-point[0].y))
+        return ((a.x-point[0].x)*(a.x-point[0].x)+(a.y-point[0].y)*(a.y-point[0].y))<((point[0].x-b.x)*(point[0].x-b.x)+(point[0].y-b.y)*(point[0].y-b.y));
+    return (a.x-point[0].x)*(b.y-point[0].y)>(b.x-point[0].x)*(a.y-point[0].y);
+}
+int ts;
+void yuan(int x,int y,int r)
+{
+    pp.r=r;
+    for(int i=0;i<500;i++)
+    {
+        double du;
+        du=(double)2.0*PI*i/500.0;
+        pp.x=1.0*x+1.0*r*cos(du);
+        pp.y=1.0*y+1.0*r*sin(du);
+        pp.pos=ts;
+        point[tops++]=pp;
+    }
+}
+int pan(int z,int b,int a)
+{
+    double x1,y1,x2,y2;
+    if(a<0)return 1;
+    x1=tu[b].x-tu[a].x;
+    y1=tu[b].y-tu[a].y;
+    x2=point[z].x-tu[b].x;
+    y2=point[z].y-tu[b].y;
+    if(x1*y2>x2*y1)return 1;
+    return 0;
+}
+double len(struct list p1,struct list p2)
+{
+    return (double)sqrt(1.0*((p1.x-p2.x)*(p1.x-p2.x)+1.0*(p1.y-p2.y)*(p1.y-p2.y)));
+}
+void init(int n,int m)
+{
+    int i,j;
+    tops=0;
+    int a,b,c;
+    ts=0;
+    for(i=0;i<n;i++)
+    {
+        scanf("%d%d%d",&a,&b,&c);
+        ts++;
+        yuan(a,b,c);
+    }
+    for(i=0;i<m;i++)
+    for(j=0;j<3;j++)
+    {
+        scanf("%lf%lf",&point[tops].x,&point[tops].y);
+        point[tops].pos=0;
+        tops++;
+    }
+}
+void jiantu()
+{
+    int i;
+    sort(point,point+tops,cmp1);
+    sort(point+1,point+tops,cmp2);
+    tu[0]=point[0];
+    tu[1]=point[1];
+    tu[2]=point[2];
+    num=3;
+    for(i=3;i<tops;i++)
+    {
+        while(!pan(i,num-1,num-2))num--;
+        tu[num++]=point[i];
+    }
+}
+void print()
+{
+    double lens;
+    int i;
+    lens=0.0;
+    for(i=0;i<num;i++)
+    {
+        if(tu[i].pos>0&&(tu[i].pos==tu[(i+1)%num].pos))
+        {
+            lens+=1.0*tu[i].r*2*PI/500.0;
+        }
+        else
+        lens+=len(tu[i],tu[(i+1)%num]);
+    }
+    printf("%.5lf\n",lens);
+}
+int main()
+{
+    int n,m;
+    while(~scanf("%d%d",&n,&m))
+    {
+        init(n,m);
+        jiantu();
+        print();
+    }
+    return 0;
+}
diff --git a/HDOJ/4668_autoAC.cpp b/HDOJ/4668_autoAC.cpp
new file mode 100644
index 0000000..6997604
--- /dev/null
+++ b/HDOJ/4668_autoAC.cpp
@@ -0,0 +1,147 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <vector>
+#include <string>
+#include <queue>
+#include <cmath>
+#include <algorithm>
+#define lson step << 1
+#define rson step << 1 | 1
+#pragma comment(linker,"/STACK:102400000,102400000")
+using namespace std;
+typedef long long LL;
+const int N = 5005;
+struct Node {
+    string s;
+    int cnt;
+    Node () {}
+    Node (string _s , int c) :s(_s) , cnt(c) {}
+    string cat () {
+        string t = s;
+        for (int i = 1 ; i < cnt ; i ++)
+            s = s + t;
+        cnt = 1;
+        return s;
+    }
+    LL len () {
+        return (LL)s.size() * cnt;
+    }
+    string prefix (int l) {
+        string str = s;
+        for (int i = 1 ; i < cnt && str.size() < l ; i ++) {
+            str += s;
+        }
+        return str.substr (0 , l);
+    }
+    string suffix (int l) {
+        string str = s;
+        for (int i = 1 ; i < cnt && str.size() < l ; i ++) {
+            str += s;
+        }
+        return str.substr (str.size() - l , l);
+    }
+}a[N];
+char str[N] , pat[N];
+int ne[N] , idx , l , p;
+void get_next (char *s , int l) {
+    ne[0] = -1;
+    int i = 0 , j = -1;
+    while (i < l) {
+        if (j == -1 || s[i] == s[j]) {
+            i ++; j ++;
+            ne[i] = j;
+        }
+        else j = ne[j];
+    }
+}
+void gao (string s , int tot) {
+    if (s == "") return ;
+    if (idx == 0 || s.size() * tot >= p || a[idx - 1].len() >= p) {
+        a[idx ++] = Node (s , tot);
+    }
+    else {
+        a[idx - 1].cat ();
+        a[idx - 1].s += Node (s , tot).cat();
+    }
+} 
+int match (string s , char *t , int p) {
+    int l = s.size() ;
+    int i = 0 , j = 0 , ans = 0;
+    while (i < s.size()) {
+        if (j == - 1 || s[i] == t[j]) {
+            i ++; j ++;
+            if (j == p) {
+                ans ++;
+                j = ne[j];
+            }
+        }
+        else j = ne[j];
+    }
+    return ans;
+} 
+int main () {
+    while (scanf ("%s %s" , str , pat) != EOF) {
+        idx = 0;
+        l = strlen (str);p = strlen (pat);
+        get_next (pat , p);
+        string s = "";
+        int tot = 1;
+        for (int i = 0 ; i < l ; i ++) {
+            if (str[i] == '[') {
+                if (s == "") continue;
+                gao (s , tot);
+                s = ""; tot = 1;
+            }
+            else if (str[i] == ']') {
+                tot = 0;
+                i ++;
+                while (isdigit(str[i]))
+                    tot = tot * 10 + str[i ++] - '0';
+                i --;
+                gao (s , tot);
+                s = ""; tot = 1;
+            }
+            else s += str[i];
+        }
+        gao (s , tot);
+        s = ""; tot = 1;
+        LL ans = 0;
+        for (int i = 0 ; i < idx ; i ++) {
+            if (a[i].len() < p) continue;
+            if (a[i].cnt == 1) ans += match (a[i].s , pat , p);
+            else {
+                int use = min(a[i].cnt , 1 + (p - 1 + (int)a[i].s.size() - 1) / (int)a[i].s.size());
+                string s = "";
+                for (int j = 1 ; j < use ; j ++) {
+                    s += a[i].s;
+                }
+                s = a[i].s + s.substr (0 , min ((int)s.size() , p - 1));
+                int tmp = match (s , pat , p);
+                ans += (LL)tmp * (a[i].cnt - use + 1);
+                if (p) {
+                    s = "";
+                    for (int j = 1 ; j < use ; j ++)
+                        s += a[i].s;
+                    ans += match (s , pat , p);
+                }
+            }
+        }
+        for (int i = 0 ; i < idx - 1 ; i ++) {
+            s = a[i].suffix (min (a[i].len () , p - 1LL));
+            if (a[i + 1].len () < p - 1) {
+                s += a[i + 1].cat ();
+                if (i + 2 < idx) {
+                    s += a[i + 2].prefix (min (a[i + 2].len () , p - 1 - a[i + 2].len ()));
+                }
+            }
+            else {
+                s += a[i + 1].prefix (min (a[i + 1].len () , p - 1LL));
+            }
+            ans += match (s , pat , p);
+        }
+        printf ("%I64d\n" , ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4669_autoAC.cpp b/HDOJ/4669_autoAC.cpp
new file mode 100644
index 0000000..cb71410
--- /dev/null
+++ b/HDOJ/4669_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <vector>
+#include <string>
+#include <queue>
+#include <cmath>
+#include <algorithm>
+#define lson step << 1
+#define rson step << 1 | 1
+#pragma comment(linker,"/STACK:102400000,102400000")
+using namespace std;
+typedef long long LL;
+const int N = 50005;
+const int M = 205;
+int n , k , a[N] ,l[N];
+int dp[2][M] , prefix[N] , fac[N << 2] , suffix[N];
+int cnt[M];
+int cal (int x) {
+    int cnt = 0;
+    while (x) x /= 10 , cnt ++;
+    return cnt;
+}
+int main () {
+    while (scanf ("%d %d" , &n , &k) != EOF) {
+        fac[0] = 1;
+        for (int i = 1 ; i <= (n << 2) ; i ++)
+            fac[i] = fac[i - 1] * 10 % k;
+        for (int i = 1 ; i <= n ; i ++) {
+            scanf ("%d" , &a[i]);
+            l[i] = cal (a[i]);
+        }
+        for (int i = 0 ; i < 2 ; i ++) {
+            for (int j = 0 ; j < k ; j ++)
+                dp[i][j] = 0;
+        }
+        dp[1][a[1] % k] = 1;
+        LL ans = dp[1][0];
+        for (int i = 2 ; i <= n ; i ++) {
+            for (int j = 0 ; j < k ; j ++)
+                dp[i & 1][j] = 0;
+            dp[i & 1][a[i] % k] ++;
+            for (int j = 0 ; j < k ; j ++) {
+                dp[i & 1][(j * fac[l[i]] + a[i]) %k] += dp[(i - 1) & 1][j];
+            }
+            ans += dp[i & 1][0];
+        }
+        prefix[0] = 0;suffix[n + 1] = 0;
+        for (int i = 1 ; i <= n ; i ++) {
+            prefix[i] = (prefix[i - 1] * fac[l[i]] + a[i]) % k;
+        }
+        int len = 0;
+        for (int i = n ; i >= 1 ; i --) {
+            suffix[i] = (a[i] * fac[len] + suffix[i + 1]) % k;
+            len += l[i];
+        }
+        len = 0;
+        for (int i = 0 ; i < k ; i ++)
+            cnt[i] = 0;
+        for (int i = 1 ; i <= n ; i ++) {
+            cnt[suffix[i]] ++;
+            len += l[i];
+            int p = prefix[i];
+            for (int j = 0 ; j < k ; j ++) {
+                if ((j * fac[len] + p) % k) continue;
+                ans += dp[n & 1][j] - cnt[j];
+            }
+        }
+        printf ("%I64d\n" , ans);
+    }
+    return 0;    
+}
diff --git a/HDOJ/4670_autoAC.cpp b/HDOJ/4670_autoAC.cpp
new file mode 100644
index 0000000..061abc9
--- /dev/null
+++ b/HDOJ/4670_autoAC.cpp
@@ -0,0 +1,171 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <map>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+#define rep(i,s,t) for(int i=s;i<t;i++)
+#define red(i,s,t) for(int i=s-1;i>=t;i--)
+#define ree(i,now) for(int i=head[now];i!=-1;i=edge[i].next)
+#define clr(a,v) memset(a,v,sizeof a)
+const int N=50005;
+const int K=33;
+struct Edge{
+    int v,next;
+}edge[N*2];
+int head[N],e;
+int Num[N][K];
+int son[N],MaxSize;
+int root,all;
+int n,k,a[K],d[K],x,y,cnt;
+ll v[N],dis[N],three[K],mark[N];
+int Ans;
+bool vis[N];
+map<ll,int>mp,mpp;
+inline void Init(){
+    three[0]=1;
+    rep(i,1,K) three[i]=three[i-1]*3;
+}
+inline int getPos(ll v,int x){
+    return v%three[x+1]/three[x];
+}
+inline ll get(ll val,int *x){
+    ll ans=0;
+    rep(i,0,k) ans+=((getPos(val,i)+x[i])%3)*three[i];
+    return ans;
+}
+inline void getCh(ll b,int i){
+    bool ok=1;
+    mark[i]=0;
+    if(b==0)return;
+    rep(j,0,k){
+        Num[i][j]=0;
+        while(b>1 && b%a[j]==0){
+            Num[i][j]++;
+            b/=a[j];
+        }
+        Num[i][j]%=3;
+        mark[i]+=three[j]*Num[i][j];
+        if(Num[i][j]!=0) ok=0;
+    }
+    if(ok) Ans++;
+}
+inline void addEdge(int u,int v){
+    edge[e].v=v;
+    edge[e].next=head[u];
+    head[u]=e++;
+}
+inline void In(){
+    scanf("%d",&k);
+    rep(i,0,k) scanf("%d",&a[i]);
+    rep(i,1,n+1){
+        scanf("%I64d",&v[i]);
+        getCh(v[i],i);
+    }
+    clr(head,-1),e=0;
+    rep(i,1,n){
+        scanf("%d%d",&x,&y);
+        addEdge(x,y);addEdge(y,x);
+    }
+    clr(vis,0);
+}
+inline void dfs_Size(int now,int pre){
+    all++;
+    ree(i,now){
+        int nxt=edge[i].v;
+        if(!vis[nxt] && nxt!=pre) dfs_Size(nxt,now);
+    }
+}
+inline void dfs_Root(int now,int pre){
+    int Max=0;
+    son[now]=0;
+    ree(i,now){
+        int nxt=edge[i].v;
+        if(!vis[nxt] && pre!=nxt){
+            dfs_Root(nxt,now);
+            son[now]+=son[nxt]+1;
+            if(son[nxt]+1>Max) Max=son[nxt]+1;
+        }
+    }
+    int res=all-son[now]-1;
+    if(Max<res) Max=res;
+    if(Max<MaxSize){
+        MaxSize=Max;root=now;
+    }
+}
+inline ll Val(int *c){
+    ll ans=0;
+    rep(j,0,k) ans+=c[j]*three[j];
+    return ans;
+}
+inline ll Transform(ll a,ll b){
+    ll ans=0;
+    rep(j,0,k) ans+=(getPos(a,j)+getPos(b,j))%3*three[j];
+    return ans;
+}
+inline void dfs_Dis(int now,int pre,ll val){
+    dis[cnt++]=val;
+    ree(i,now){
+        int nxt=edge[i].v;
+        if(!vis[nxt] && nxt!=pre){
+            dfs_Dis(nxt,now,Transform(val,mark[nxt]));
+        }
+    }
+}
+inline ll Suit(ll v){
+    ll ans=0;
+    rep(i,0,k){
+        int x=getPos(v,i);
+        int y=(3-x)%3;
+        ans+=three[i]*y;
+    }
+    return ans;
+}
+inline void Work(int now){
+    all=0;
+    dfs_Size(now,-1);
+    MaxSize=n+10;
+    dfs_Root(now,-1);
+    vis[root]=1;
+    mp.clear();
+    ree(i,root){
+        int nxt=edge[i].v;cnt=0;
+        if(vis[nxt]) continue;
+        dfs_Dis(nxt,root,mark[nxt]);
+        rep(j,0,cnt){
+            int vv=mp[Suit(dis[j])];
+            if(vv) Ans+=vv;
+        }
+        rep(j,0,cnt){
+            ll p=get(dis[j],Num[root]);
+            if(p==0) Ans++;
+            mp[p]++;
+        }
+    }
+    ree(i,root){
+        int nxt=edge[i].v;
+        if(!vis[nxt]){
+            Work(nxt);
+        }
+    }
+}
+inline void app(){
+    int a[]={2,3,5,7,11,13,17,19,23,29};
+    rep(j,0,10){
+        printf("3000 10 2 3 5 7 11 13 17 19 23 29\n");
+        rep(i,0,3000) printf("%d ",a[rand()%10]);
+        rep(i,1,3000) printf("%d 1\n",i+1);
+    }
+}
+int main(){
+    Init();
+    while(~scanf("%d",&n)){
+        Ans=0;
+        In();
+        Work(1);
+        printf("%d\n",Ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4671_autoAC.cpp b/HDOJ/4671_autoAC.cpp
new file mode 100644
index 0000000..b226398
--- /dev/null
+++ b/HDOJ/4671_autoAC.cpp
@@ -0,0 +1,42 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int V = 105;
+int n, m, ans[V][V];
+bool vis[V][V];
+int main() {
+    int i, j, k;
+    while(~scanf("%d%d", &n, &m)) {
+        memset(ans, 0, sizeof(ans));
+        memset(vis, false, sizeof(vis));
+        for(i = 0, j = 1; i < m; ++i) {
+            ans[i][0] = j;
+            vis[i][j] = true;
+            j = j == n ? 1 : j + 1;
+        }
+        for(i = 0; i < m; ++i) {
+            if(ans[i][1] != 0)
+                continue;
+            int now = m % n + 1;
+            for(j = i; j < m; j += n) {
+                if(now == ans[j][0])
+                    now = now == n ? 1 : now + 1;
+                ans[j][1] = now;
+                vis[j][now] = true;
+                now = now == n ? 1 : now + 1;
+            }
+        }
+        for(i = 0; i < m; ++i)
+            for(j = 2, k = 1; j < n; ++j) {
+                while(vis[i][k])
+                    k++;
+                ans[i][j] = k++;
+            }
+        for(i = 0; i < m; ++i) {
+            for(j = 0; j < n - 1; ++j)
+                printf("%d ", ans[i][j]);
+            printf("%d\n", ans[i][n - 1]);
+        }
+    }
+}
diff --git a/HDOJ/4672_autoAC.cpp b/HDOJ/4672_autoAC.cpp
new file mode 100644
index 0000000..e816a14
--- /dev/null
+++ b/HDOJ/4672_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+#include<cmath>
+#include<cstring>
+#define I(x) scanf("%d",&x)
+using namespace std;
+int sg[10001],a[100001];
+char x[20],y[20];
+int main(){
+    int n,m,i,j,MIN,b,t,ans;
+    while(scanf("%d%d%s%s",&n,&m,x,y)!=EOF){
+        memset(sg,-1,sizeof(sg));
+        sg[0]=0;MIN=1e9;
+        bool flag=0;
+        for(i=0;i<n;i++) I(a[i]);
+        for(i=0;i<m;i++){
+            I(b);
+            MIN=min(MIN,b);
+            for(j=0;j+b<=10000;j++)
+                if(sg[j]>=0)
+                    sg[j+b]=max(sg[b+j],sg[j]+1);
+        }
+        ans=0;
+        for(i=0;i<n;i++){
+            t=a[i];
+            if(t<=10000){
+                if(sg[t]<0) flag=1;
+                else ans^=sg[t];
+            }
+            else{
+                t=(t-10000+MIN)%MIN+10000-MIN;
+                if(sg[t]<0) flag=1;
+                else ans^=sg[t]+(a[i]-t)/MIN;
+            }
+        }
+        if(!flag&&ans) puts(x);
+        else puts(y);
+    }
+    return 0;
+}
diff --git a/HDOJ/4674_autoAC.cpp b/HDOJ/4674_autoAC.cpp
new file mode 100644
index 0000000..3c17029
--- /dev/null
+++ b/HDOJ/4674_autoAC.cpp
@@ -0,0 +1,153 @@
+#pragma comment(linker, "/STACK:65536000")
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <vector>
+#include <map>
+#include <math.h>
+#include <queue>
+#include <set>
+#include <algorithm>
+#define clr(a,b) memset(a,b,sizeof(a))
+#define mpr(a,b) make_pair(a,b)
+#define ll long long
+#define eps 1e-6
+using namespace std;
+const int N=100005,M=300005;
+int n,m,q,eid,id,now,top;
+int head[N],ed[M],nxt[M];
+int dfn[N],low[N],gid[N];
+int sta[N],block[N];
+vector<pair<int,int> >gra[N],qu[N];
+int f[N],vis[N],come[N],out[N],fa[N];
+int tlca[3*N],pt[3*N][2];
+int aa[N],bb[N],cc[N];
+int findfa(int s){return s==fa[s]?s:fa[s]=findfa(fa[s]);}
+void addedge(int s,int e){
+     ed[eid]=e;nxt[eid]=head[s];head[s]=eid++;
+}
+void tarjan(int s,int f,int b){
+     dfn[s]=low[s]=++now;
+     sta[top++]=s;block[s]=b;
+     for(int i=head[s];~i;i=nxt[i]){
+          int e=ed[i];
+          if(i==f||i==(f^1))continue;
+          if(!dfn[e]){
+               tarjan(e,i,b);
+               low[s]=min(low[s],low[e]);
+          }else
+               low[s]=min(low[s],dfn[e]);
+     }
+     if(low[s]==dfn[s]){
+          id++;
+          while(top){
+               int k=sta[--top];
+               gid[k]=id;
+               if(k==s)return ;
+          }
+     }
+}
+void lca(int s,int f){
+     fa[s]=s;
+     for(int i=0;i<(int)gra[s].size();i++){
+          int e=gra[s][i].first;
+          if(e==f)continue;
+          lca(e,s);
+          fa[findfa(e)]=s;
+     }
+     vis[s]=1;
+     for(int i=0;i<(int)qu[s].size();i++){
+          int e=qu[s][i].first,d=qu[s][i].second;
+          if(vis[e])tlca[d]=findfa(e);
+     }
+}
+void dfs(int s,int f){
+     for(int i=0;i<(int)qu[s].size();i++){
+          int d=qu[s][i].second;
+          int k=(tlca[d]==s)?-1:out[tlca[d]];
+          if(~pt[d][0])pt[d][1]=k;
+          else pt[d][0]=k;
+     }
+     for(int i=0;i<(int)gra[s].size();i++){
+          int e=gra[s][i].first,g=gra[s][i].second;
+          if(e==f){
+               come[s]=g;continue;
+          }
+          out[s]=g;
+          dfs(e,s);
+     }
+}
+int main(){
+     while(~scanf("%d%d",&n,&m)){
+          eid=0;clr(head,-1);
+          for(int i=0;i<m;i++){
+               int a,b;scanf("%d%d",&a,&b);
+               addedge(a,b);addedge(b,a);
+          }
+          id=now=top=0;
+          for(int i=1;i<=n;i++)dfn[i]=0;
+          int cnt=0;
+          for(int i=1;i<=n;i++)
+               if(!dfn[i])tarjan(i,-1,++cnt);
+          for(int i=1;i<=id;i++){
+               gra[i].clear();qu[i].clear();
+          }
+          for(int i=1;i<=n;i++)
+               for(int j=head[i];~j;j=nxt[j]){
+                    int s=gid[i],e=gid[ed[j]];
+                    if(s!=e)gra[s].push_back(mpr(e,i));
+               }
+          clr(f,0);
+          scanf("%d",&q);
+          for(int i=0;i<q;i++){
+               int a,b,c;scanf("%d%d%d",&a,&b,&c);
+               if(block[a]!=block[b]){f[i]=1;continue;}
+               if(block[b]!=block[c]){f[i]=1;continue;}
+               if(block[a]!=block[c]){f[i]=1;continue;}
+               if(a==b&&a!=c){f[i]=1;continue;}
+               int s=gid[a],e=gid[b],k=gid[c];
+               qu[s].push_back(mpr(e,i*3));
+               qu[e].push_back(mpr(s,i*3));
+               qu[s].push_back(mpr(k,i*3+1));
+               qu[k].push_back(mpr(s,i*3+1));
+               qu[e].push_back(mpr(k,i*3+2));
+               qu[k].push_back(mpr(e,i*3+2));
+               aa[i]=a;bb[i]=b;cc[i]=c;
+          }
+          for(int i=1;i<=id;i++)vis[i]=0;
+          for(int i=0;i<q*3;i++)
+               pt[i][0]=pt[i][1]=-1;
+          for(int i=1;i<=id;i++)
+               if(!vis[i]){
+                    lca(i,-1);
+                    dfs(i,-1);
+               }
+          for(int i=0;i<q;i++){
+               if(f[i]){
+                    puts("No");continue;
+               }
+               if(gid[aa[i]]==gid[bb[i]]){
+                    if(gid[cc[i]]==gid[aa[i]])puts("Yes");
+                    else puts("No");
+               }
+               else if(gid[cc[i]]==tlca[i*3]){
+                    if(pt[i*3][1]==-1){
+                         int k=(gid[aa[i]]==gid[cc[i]])?aa[i]:bb[i];
+                         if(k==pt[i*3][0]&&cc[i]!=k) puts("No");
+                         else puts("Yes");
+                    }else{
+                         if(pt[i*3][0]==pt[i*3][1]&&cc[i]!=pt[i*3][0]) puts("No");
+                         else puts("Yes");
+                    }
+               }else if(tlca[i*3+1]==gid[cc[i]]&&tlca[i*3+2]==tlca[i*3]){
+                    int k=(pt[i*3+1][0]==-1)?aa[i]:pt[i*3+1][0];
+                    if(come[gid[cc[i]]]==k&&k!=cc[i])puts("No");
+                    else puts("Yes");
+               }else if(tlca[i*3+2]==gid[cc[i]]&&tlca[i*3+1]==tlca[i*3]){
+                    int k=(pt[i*3+2][0]==-1)?bb[i]:pt[i*3+2][0];
+                    if(come[gid[cc[i]]]==k&&k!=cc[i])puts("No");
+                    else puts("Yes");
+               }else puts("No");
+          }
+     }
+}
diff --git a/HDOJ/4675_autoAC.cpp b/HDOJ/4675_autoAC.cpp
new file mode 100644
index 0000000..ce17e83
--- /dev/null
+++ b/HDOJ/4675_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+using namespace std;
+const int MOD = 1e9+7;
+long long pow_m(long long a,long long n)
+{
+    long long ret = 1;
+    long long tmp = a%MOD;
+    while(n)
+    {
+        if(n&1)
+        {
+            ret *= tmp;
+            ret %= MOD;
+        }
+        tmp *= tmp;
+        tmp %= MOD;
+        n >>= 1;
+    }
+    return ret;
+}
+long long C[300010];
+long long inv(long long a,long long m)
+{
+    if(a == 1)return 1;
+    return inv(m%a,m)*(m-m/a)%m;
+}
+long long ans[300010];
+int a[300010];
+int num[300010];
+int b[300010];
+int main()
+{
+    int N,M,K;
+    while(scanf("%d%d%d",&N,&M,&K) == 3)
+    {
+        memset(num,0,sizeof(num));
+        for(int i = 1;i <= N;i++)
+        {
+            scanf("%d",&a[i]);
+            num[a[i]]++;
+        }
+        C[N-K] = 1;
+        for(int i = N-K+1;i <= N;i++)
+        {
+            C[i] = C[i-1]*i%MOD*inv(i-(N-K),MOD)%MOD;
+        }
+        for(int i = M;i>= 1;i--)
+        {
+            int cnt = 0;
+            long long ss = 0;
+            for(int j = 1; j*i <= M;j++)
+            {
+                cnt += num[i*j];
+                if(j > 1)ss = (ss + ans[i*j])%MOD;
+            }
+            int t = M/i;
+            if(t == 1)
+            {
+                if(cnt == N-K)ans[i] = 1;
+                else ans[i] = 0;
+                continue;
+            }
+            if(cnt < N-K)
+            {
+                ans[i] = 0;
+                continue;
+            }
+            long long tmp = 1;
+            tmp =(tmp*C[cnt])%MOD;
+            tmp = ( tmp * pow_m(t-1,cnt-(N-K)) )%MOD;
+            tmp = (tmp * pow_m(t,N-cnt));
+            ans[i] = (tmp - ss + MOD)%MOD;
+        }
+        for(int i = 1;i <= M;i++)
+        {
+            printf("%I64d",ans[i]);
+            if(i < M)printf(" ");
+            else printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4676_autoAC.cpp b/HDOJ/4676_autoAC.cpp
new file mode 100644
index 0000000..8e9221a
--- /dev/null
+++ b/HDOJ/4676_autoAC.cpp
@@ -0,0 +1,102 @@
+#include<cstdio>
+#include<cstring>
+#include<climits>
+#include<string>
+#include<algorithm>
+#include<cmath>
+#include<iostream>
+#include<queue>
+#include<vector>
+#include<stack>
+#include<map>
+#include<set>
+#include<stdlib.h>
+using namespace std;
+typedef long long ll;
+const int MAXN = 20007;
+vector<int> divisor[MAXN];
+int f[MAXN], a[MAXN], L[MAXN], R[MAXN], cnt[MAXN], qid[MAXN], M;
+ll ans[MAXN];
+void getdivisor() {
+    int i, j;
+    for(i = 1; i < MAXN; i++) for(j = i; j < MAXN; j += i) divisor[j].push_back(i);
+}
+void getf() {
+    for(int i = 1; i < MAXN; i++) {
+        int t = i;
+        int j, sz = divisor[i].size();
+        for(j = 0; j < sz; j++) t -= f[divisor[i][j]];
+        f[i] = t;
+    }
+}
+int qcmp(int x, int y) {
+    int px = L[x] / M; 
+    int py = L[y] / M;
+    if(px != py) return px < py;
+    return R[x] < R[y];
+}
+ll erase(int x) {
+    int i, y, sz = divisor[x].size();
+    ll ret = 0;
+    for(i = 0; i < sz; i++) {
+        y = divisor[x][i];
+        ret += 1LL*f[y]*(--cnt[y]);
+    }
+    return ret;
+}
+ll insert(int x) {
+    int i, y, sz = divisor[x].size();
+    ll ret = 0;
+    for(i = 0; i < sz; i++) {
+        y = divisor[x][i];
+        ret += 1LL*f[y]*(cnt[y]++);
+    }
+    return ret;
+}
+void solve(int n, int q) {
+    int i;
+    for(i = 1; i <= q; i++) qid[i] = i;
+    M = (int)sqrt(n*1.0);
+    sort(qid+1, qid+1+q, qcmp);
+    memset(cnt, 0, sizeof(cnt));
+    int l = 0, r = 0;
+    ll now = 0;
+    for(i = 1; i <= q; i++) {
+        int id = qid[i];
+        int nl = L[id], nr = R[id];
+        while(l < nl) {
+            now -= erase(a[l]);
+            l++;
+        }
+        while(l > nl) {
+            l--;
+            now += insert(a[l]);
+        }
+        while(r < nr) {
+            r++;
+            now += insert(a[r]);
+        }
+        while(r > nr) {
+            now -= erase(a[r]);
+            r--;
+        }
+        ans[id] = now;
+    }
+}
+int main() {
+    getdivisor();
+    getf();
+    int T, id = 0;
+    scanf("%d", &T);
+    while(T--) {
+        int i, n, q;
+        scanf("%d", &n);
+        for(i = 1; i <= n; i++) scanf("%d", a+i);
+        scanf("%d", &q);
+        for(i = 1; i <= q; i++) scanf("%d%d", L+i, R+i);
+        solve(n, q);
+        printf("Case #%d:\n", ++id);
+        for(i = 1; i <= q; i++) printf("%I64d\n", ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4677_autoAC.cpp b/HDOJ/4677_autoAC.cpp
new file mode 100644
index 0000000..ffb4aba
--- /dev/null
+++ b/HDOJ/4677_autoAC.cpp
@@ -0,0 +1,122 @@
+#include <iostream>
+#include <cstdio>
+#include <vector>
+#include <cmath>
+#include <algorithm>
+#include <cstring>
+using namespace std;
+#define N 30050
+struct Q
+{
+    int r,idx;
+    Q(int _r=0,int _idx=0):r(_r),idx(_idx){}
+};
+vector<Q>que[N];
+vector<int>edge[N];
+int fa[N][200],scc[200],rr[200];
+int ta[N],first[N],ans[N];
+int n,m,tot,every;
+int find(int i,int pos)
+{
+    return fa[i][pos]==i?i:fa[i][pos]=find(fa[i][pos],pos);
+}
+void init()
+{
+    for(int i=0;i<=n;++i)
+        edge[i].clear(),que[i].clear();
+    memset(scc,0,sizeof(scc));
+    every=tot=sqrt(n*1.0);
+    if(n*n!=tot) tot++;
+    for(int i=0;;++i)
+    {
+        rr[i]=i*every;
+        if(i*every>=n) break;
+    }
+    for(int i=0;i<=tot;++i)
+        for(int j=0;j<=n;++j)
+        fa[j][i]=j;
+    memset(first,-1,sizeof(first));
+}
+int main ()
+{
+    int T;scanf("%d",&T);
+    for(int kk=1;kk<=T;++kk)
+    {
+        scanf("%d%d",&n,&m);
+        init();
+        for(int i=1,u,v;i<=m;++i)
+        {
+            scanf("%d%d",&u,&v);
+            if(u==v) continue;
+            edge[u].push_back(v);
+            edge[v].push_back(u);
+        }
+        int q;scanf("%d",&q);
+        for(int i=1,u,v;i<=q;++i)
+        {
+            scanf("%d%d",&u,&v);
+            que[u].push_back(Q(v,i));
+        }
+        int run_clock=0;
+        for(int u=n;u>=1;--u)
+        {
+            for(int j=1;j<=tot;++j)
+            {
+                if(u>rr[j]) continue;
+                scc[j]++;
+                int inc=0;
+                for(int i=0;i<edge[u].size();++i)
+                {
+                    int v=edge[u][i];
+                    if(u<v&&v<=rr[j])
+                    {
+                        int u1=find(u,j);
+                        int v1=find(v,j);
+                        if(u1!=v1)
+                        {
+                            inc++;
+                            fa[v1][j]=u1;
+                        }
+                    }
+                }
+                scc[j]-=inc;
+            }
+            for(int z=0;z<que[u].size();++z)
+            {
+                run_clock++;
+                int right=que[u][z].r;
+                int pos;int inc=0;
+                for(pos=0;pos<tot;++pos)
+                    if(rr[pos]<right&&right<=rr[pos+1]) break;
+                for(int i=max(u+1,rr[pos]+1);i<=right;++i)
+                {
+                    if(first[i]!=run_clock)
+                    {
+                        first[i]=run_clock;
+                        fa[i][tot+1]=i;
+                    }
+                    for(int j=0;j<edge[i].size();++j)
+                        if(u<=edge[i][j]&&edge[i][j]<i)
+                        {
+                            int v1=find(edge[i][j],pos);
+                            if(first[v1]!=run_clock)
+                            {
+                                first[v1]=run_clock;
+                                fa[v1][tot+1]=v1;
+                            }
+                            if(find(i,tot+1)!=find(v1,tot+1))
+                            {
+                                fa[find(v1,tot+1)][tot+1]=find(i,tot+1);
+                                inc++;
+                            }
+                        }
+                }
+                ans[que[u][z].idx]=scc[pos]+right-max(rr[pos],u-1)-inc;
+            }
+        }
+        printf("Case #%d:\n",kk);
+        for(int i=1;i<=q;++i)
+            printf("%d\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4678_autoAC.cpp b/HDOJ/4678_autoAC.cpp
new file mode 100644
index 0000000..f10d31d
--- /dev/null
+++ b/HDOJ/4678_autoAC.cpp
@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <queue>
+#include <stack>
+#define loop(s,i,n) for(i = s;i < n;i++)
+#define cl(a,b) memset(a,b,sizeof(a))
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+using namespace std;
+int map[1005][1005];
+int vis[1005][1005];
+int n,m,k;
+int num,odd,uod;
+int to[8][2] = {{0,1},{0,-1},{1,0},{1,-1},{1,1},{-1,-1},{-1,0,},{-1,1}};
+int judge(int a,int b)
+{
+    if(a >= 0 && a < n && b>= 0 &&b < m)
+    return 1;
+    return 0;
+}
+void paint(int x,int y)
+{
+    int i,j;
+    for(i = 0;i < 8;i++)
+    {
+        int a,b;
+        a = x+to[i][0];
+        b = y+to[i][1];
+        if(judge(a,b) && !vis[a][b])
+        map[a][b]++;
+    }
+}
+void dfs(int x,int y)
+{
+    if(map[x][y] == -1 || vis[x][y])
+    return;
+    vis[x][y] = 1;
+    int i;
+    for(i = 0;i < 8;i++)
+    {
+        int a,b;
+        a = x+to[i][0];
+        b = y+to[i][1];
+        if(judge(a,b)&&vis[a][b] == 0)
+        {
+            if(map[a][b] > 0)
+            num++,vis[a][b] = 1;
+            else if(map[a][b] == 0)
+            dfs(a,b);
+        }
+    }
+    return;
+}
+int main()
+{
+    int t,i,j,x,y;
+    scanf("%d",&t);
+    int icase = 0;
+    while(t--)
+    {
+        scanf("%d %d %d",&n,&m,&k);
+        loop(0,i,n)
+        {
+            loop(0,j,m)
+            map[i][j] = vis[i][j] = 0;
+        }
+        while(k--)
+        {
+            scanf("%d %d",&x,&y);
+            map[x][y] = -1;
+            vis[x][y] = 1;
+            paint(x,y);
+        }
+        odd = uod = 0;
+        loop(0,i,n)
+        {
+            loop(0,j,m)
+            {
+                num = 0;
+                if(map[i][j] == 0 && !vis[i][j])
+                {
+                    dfs(i,j);
+                    if(num%2)
+                    odd++;
+                    else
+                    uod++;
+                }
+            }
+        }
+        loop(0,i,n)
+        {
+            loop(0,j,m)
+            {
+                if(!vis[i][j] && map[i][j] > 0)
+                uod++;
+            }
+        }
+        printf("Case #%d: ",++icase);
+        if(uod%2 || odd%2)
+        puts("Xiemao");
+        else
+        puts("Fanglaoshi");
+    }
+    return 0;
+}
diff --git a/HDOJ/4679_autoAC.cpp b/HDOJ/4679_autoAC.cpp
new file mode 100644
index 0000000..81dd0b4
--- /dev/null
+++ b/HDOJ/4679_autoAC.cpp
@@ -0,0 +1,177 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<queue>
+using namespace std;
+#define maxn 100011
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#define INF 99999999
+struct list
+{
+    int u,v,w,number;
+    int next;
+} node[maxn*4];
+struct list2
+{
+    int point;
+    int len;
+}no[4][maxn],pp;
+int head[maxn*10];
+int low[maxn*2];
+int f[maxn];
+int ipf[maxn][2];
+int ips[maxn][2];
+int h[maxn];
+int tops,maxx,ipos,n;
+void add(int u,int v,int w,int number)
+{
+    node[tops].u=u;
+    node[tops].v=v;
+    node[tops].w=w;
+    node[tops].number=number;
+    node[tops].next=head[u];
+    head[u]=tops++;
+}
+void init()
+{
+    memset(head,-1,sizeof(head));
+    memset(f,0,sizeof(f));
+    memset(h,0,sizeof(h));
+    memset(ipf,0,sizeof(ipf));
+    memset(low,0,sizeof(low));
+    memset(ips,0,sizeof(ips));
+    tops=0;
+    maxx=INF;
+    ipos=maxn+10;
+    scanf("%d",&n);
+    for(int i=0;i<=n;i++)
+    {
+        no[1][i].len=no[2][i].len=no[3][i].len=0;
+        no[1][i].point=no[2][i].point=no[3][i].point=0;
+    }
+    int a,b,c;
+    for(int i=1; i<n; i++)
+    {
+        scanf("%d%d%d",&a,&b,&c);
+        add(a,b,c,i);
+        add(b,a,c,i);
+    }
+}
+int dfs(int x,int pre)
+{
+    int ts,tt;
+    ts=0;
+    f[x]=0;
+    for(int i=head[x]; i!=-1; i=node[i].next)
+    {
+        int y=node[i].v;
+        if(y==pre)continue;
+        tt=dfs(y,x)+1;
+        ts=max(tt,ts);
+        if(f[y]>=ipf[x][0])
+        {
+            ipf[x][1]=ipf[x][0];
+            ipf[x][0]=f[y];
+            ips[x][1]=ips[x][0]=y;
+        }
+        else if(f[y]>=ipf[x][1])
+        {
+            ipf[x][1]=f[y];
+        }
+        f[x]=max(f[x],f[y]);
+        pp.point=y;
+        pp.len=tt;
+        for(int j=1; j<=3; j++)
+            if(no[j][x].len<=tt)
+            {
+                for(int k=3; k>=j+1; k--)
+                {
+                    no[k][x]=no[k-1][x];
+                }
+                no[j][x]=pp;
+                break;
+            }
+    }
+    int ds=no[1][x].len+no[2][x].len;
+    f[x]=max(f[x],ds);
+    return ts;
+}
+int chu(int pre,int x,int y)
+{
+    int s1,s2,s3,s4;
+    int leap=0;
+    s1=s2=s3=s4=0;
+    if(ips[x][0]!=y)s1=ipf[x][0];
+    else s1=ipf[x][1];
+    if(no[1][x].point!=y)s2=no[1][x].len,leap++;
+    if(no[2][x].point!=y)s2+=no[2][x].len,leap++;
+    if(no[3][x].point!=y&&leap==1)s2+=no[3][x].len,leap++;
+    s3=h[x];
+    if(no[1][pre].point!=x)s4=no[1][pre].len;
+    else s4=no[2][pre].len;
+    s4=max(s4,low[pre]);
+    if(no[1][x].point!=y)s4+=no[1][x].len;
+    else s4+=no[2][x].len;
+    if(pre!=0)s4++;
+    return max(max(s1,s2),max(s3,s4));
+}
+void spfa(int x,int pre)
+{
+    int visit[maxn];
+    memset(visit,0,sizeof(visit));
+    queue<int>q;
+    queue<int>qp;
+    q.push(x);
+    qp.push(pre);
+    visit[x]=1;
+    while(!q.empty())
+    {
+        x=q.front();
+        q.pop();
+        pre=qp.front();
+        qp.pop();
+        for(int i=head[x]; i!=-1; i=node[i].next)
+        {
+            int y=node[i].v;
+            if(y==pre)continue;
+            h[y]=chu(pre,x,y);
+            int ss=max(h[y],f[y])*node[i].w;
+            if(ss<maxx)
+            {
+                maxx=ss;
+                ipos=node[i].number;
+            }
+            else if(ss==maxx)ipos=min(ipos,node[i].number);
+            q.push(y);
+            qp.push(x);
+        }
+    }
+}
+void panlow(int x,int pre)
+{
+    for(int i=head[x]; i!=-1; i=node[i].next)
+    {
+        int y=node[i].v;
+        if(y==pre)continue;
+        if(y!=no[1][x].point)
+        {
+            low[y]=max(no[1][x].len+1,low[x]+1);
+        }
+        else low[y]=max(no[2][x].len+1,low[x]+1);
+        panlow(y,x);
+    }
+}
+int main()
+{
+    int t,T;
+    scanf("%d",&T);
+    for(t=1; t<=T; t++)
+    {
+        init();
+        if(dfs(1,0));
+        panlow(1,0);
+        spfa(1,0);
+        printf("Case #%d: %d\n",t,ipos);
+    }
+    return 0;
+}
diff --git a/HDOJ/4680_autoAC.cpp b/HDOJ/4680_autoAC.cpp
new file mode 100644
index 0000000..29511dc
--- /dev/null
+++ b/HDOJ/4680_autoAC.cpp
@@ -0,0 +1,336 @@
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+#define L x->c[0]
+#define R x->c[1]
+#define KT root->c[1]->c[0]
+using namespace std;
+const int maxn = 300010;
+const int inf = 1000000007;
+int n,Type;
+int gcd(int a,int b)
+{
+    if(a<0||a>=inf) return b;
+    if(b<0||b>=inf) return a;
+    return b == 0?a:gcd(b,a%b);
+}
+struct Node
+{
+    struct Node *c[2],*fa;
+    int id,size,g,val,who;
+}S[maxn],*null = &S[0];
+Node* Q[maxn];
+Node* ID[maxn];
+int scnt;
+struct snode
+{
+    int type;
+    Node*root;
+    inline Node *NewNode(int value,Node *p)
+    {
+        Node *e = S+(++scnt);
+        e->val = value;
+        e->id = scnt;
+        e->size = 1;
+        e->fa = p;
+        e->g = value;
+        e->c[0] = e->c[1] = null;
+        ID[scnt] = e;
+        return e;
+    }
+    inline void Update(Node *p)
+    {
+        p->size = p->c[0]->size+p->c[1]->size+1;
+        p->g = gcd(p->c[0]->g,p->c[1]->g);
+        p->g = gcd(p->val,p->g);
+    }
+    inline void Rotate(Node *x,int k)
+    {
+        Node *y=x->fa;
+        y->c[k]=x->c[!k];
+        y->c[k]->fa=y;
+        x->fa=y->fa;
+        if(y->fa->c[0]==y)
+            y->fa->c[0]=x;
+        else
+            y->fa->c[1]=x;
+        y->fa=x;
+        x->c[!k]=y;
+        Update(y);
+        Update(x);
+        if(root==y) root=x;
+    }
+    inline void Splay(Node *x,Node *y)
+    {
+        while(x->fa!=y)
+        {
+            if(x->fa->fa==y)
+            {
+                if(x->fa->c[0]==x)
+                    Rotate(x,0);
+                else
+                    Rotate(x,1);
+            }
+            else if(x->fa->fa->c[0]==x->fa)
+            {
+                if(x->fa->c[0]==x)
+                    Rotate(x->fa,0),Rotate(x,0);
+                else
+                    Rotate(x,1),Rotate(x,0);
+            }
+            else
+            {
+                if(x->fa->c[1]==x)
+                    Rotate(x->fa,1),Rotate(x,1);
+                else
+                    Rotate(x,0),Rotate(x,1);
+            }
+        }
+        Update(x);
+    }
+    inline void Select(int k,Node *y)
+    {
+        Node *x=root;
+        while(k!=x->c[0]->size+1)
+        {
+            if(k<=x->c[0]->size)
+                x=x->c[0];
+            else
+            {
+                k-=x->c[0]->size+1;
+                x=x->c[1];
+            }
+        }
+        Splay(x,y);
+    }
+    inline void Init(int v)
+    {
+        root = NewNode(v,null);
+        type = ++Type;
+        root->who = type;
+    }
+    inline void Delete(Node *x)
+    {
+        Splay(x,null);
+        Node *t = root;
+        if(t->c[1]!=null)
+        {
+            root = t->c[1];
+            Select(1,null);
+            root->c[0] = t->c[0];
+            if(root->c[0]!=null)
+                root->c[0]->fa = root;
+        }
+        else
+        {
+            root = t->c[0];
+        }
+        root->fa = null;
+        if(root!=null)Update(root);
+    }
+    inline void Insert(Node *x)
+    {
+        x->c[0] = x->c[1] = null;
+        insert(root,x);
+        Splay(x,null);
+        x->who = type;
+    }
+    inline void insert(Node* &x,Node* y)
+    {
+        if(x == null)
+        {
+            x = y;
+            return;
+        }
+        if(y->val<=x->val)
+        {
+            insert(x->c[0],y);
+            x->c[0]->fa = x;
+        }
+        else
+        {
+            insert(x->c[1],y);
+            x->c[1]->fa = x;
+        }
+        Update(x);
+    }
+    inline void Change(Node* tmp,int v)
+    {
+        Delete(tmp);
+        tmp->val = v;
+        Insert(tmp);
+    }
+    inline Node *FindSucc(Node *x,int v,int opt)
+    {
+        if(x == null)return x;
+        if(x->val == v&&opt)return x;
+        else if(x->val>v)
+        {
+            Node *tmp = FindSucc(x->c[0],v,opt);
+            return tmp == null?x:tmp;
+        }
+        else
+        {
+            return FindSucc(x->c[1],v,opt);
+        }
+    }
+    inline Node *FindSucc(int v,int opt)
+    {
+        Node *tmp = FindSucc(root,v,opt);
+        Splay(tmp,null);
+        return tmp;
+    }
+    inline Node *FindPre(Node *x,int v)
+    {
+        if(x == null)return x;
+        if(x->val<v)
+        {
+            Node *tmp = FindPre(x->c[1],v);
+            return tmp == null?x:tmp;
+        }
+        else return FindPre(x->c[0],v);
+    }
+    inline Node *FindPre(int v)
+    {
+        Node* tmp = FindPre(root,v);
+        Splay(tmp,null);
+        return tmp;
+    }
+    inline void Merge(snode &tree)
+    {
+        int head,tail;
+        head = tail = 0;
+        tree.Select(1,null);
+        tree.Select(tree.root->size,tree.root);
+        Q[++tail] = tree.KT;
+        while(head<tail)
+        {
+            Node* f = Q[++head];
+            if(f->c[0]!=null)Q[++tail] = f->c[0];
+            if(f->c[1]!=null)Q[++tail] = f->c[1];
+            Insert(f);
+            f->who = type;
+        }
+        tree.KT = null;
+        tree.Update(tree.root->c[1]);
+        tree.Update(tree.root);
+    }
+    inline int SolveTri()
+    {
+        if(root->size<=4)return root->size-2;
+        Select(2,null);
+        int a = root->val;
+        Select(3,null);
+        int b = root->val;
+        int ans = 2;
+        while(true)
+        {
+            if(a+b>=inf)break;
+            int c = FindSucc(a+b,1)->val;
+            if(c>=inf||c == -1)break;
+            a = b;
+            b = c;
+            ans++;
+        }
+        return ans;
+    }
+    inline int SolveGcd(int l,int r)
+    {
+        Node *pre = FindPre(l);
+        Node *succ = FindSucc(r,0);
+        Splay(pre,null);
+        Splay(succ,root);
+        return KT->g;
+    }
+    void vist(Node *x)
+    {
+        if(x != null)
+        {
+            printf("root %2d:  left-son: %2d    right-son: %2d  size:%2d val=%2d   gcd: %2d\n",x->id,x->c[0]->id,x->c[1]->id,x->size,x->val,x->g);
+            vist(x->c[0]);
+            vist(x->c[1]);
+        }
+    }
+}spt[maxn];
+void prepare()
+{
+    null->id = 0;
+    null->c[0] = null->c[1] = null->fa = NULL;
+    null->size = null->val = 0;
+    null->g = -1;
+    Type = 0;
+    scnt = 0;
+}
+int main()
+{
+    int t,n,m,a,u,v,op,l,r,x,cas = 1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        prepare();
+        printf("Case #%d:\n",cas++);
+        scanf("%d%d",&n,&m);
+        for(int i = 1;i<=n;i++)
+        {
+            spt[i].Init(-1);
+            Node *tmp = spt[i].NewNode(inf,null);
+            spt[i].Insert(tmp);
+        }
+        for(int i = 1;i<=n;i++)
+        {
+            scanf("%d",&a);
+            Node *tmp = spt[i].NewNode(a,null);
+            spt[i].Insert(tmp);
+        }
+        int tot = 0;
+        while(m--)
+        {
+            scanf("%d",&op);
+            if(op == 1)
+            {
+                scanf("%d%d",&u,&v);
+                Node *t1 = ID[u+2*n];
+                Node *t2 = ID[v+2*n];
+                int tree1 = t1->who;
+                int tree2 = t2->who;
+                if(tree1 == tree2)continue;
+                int size1 = spt[tree1].root->size;
+                int size2 = spt[tree2].root->size;
+                if(size1>size2)spt[tree1].Merge(spt[tree2]);
+                else spt[tree2].Merge(spt[tree1]);
+            }
+            else if(op == 2)
+            {
+                scanf("%d%d",&u,&v);
+                Node *t1 = ID[u+2*n];
+                Node *t2 = ID[v+2*n];
+                int tree1 = t1->who;
+                int tree2 = t2->who;
+                spt[tree1].Delete(t1);
+                spt[tree2].Insert(t1);
+            }
+            else if(op == 3)
+            {
+                scanf("%d%d",&u,&x);
+                Node *tmp = ID[u+2*n];
+                int tree = tmp->who;
+                spt[tree].Change(tmp,x);
+            }
+            else if(op == 4)
+            {
+                scanf("%d",&u);
+                Node *tmp = ID[u+2*n];
+                int tree = tmp->who;
+                printf("%d\n",spt[tree].SolveTri());
+            }
+            else
+            {
+                scanf("%d%d%d",&u,&l,&r);
+                Node *tmp = ID[u+2*n];
+                int tree = tmp->who;
+                printf("%d\n",spt[tree].SolveGcd(l,r));
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4681_autoAC.cpp b/HDOJ/4681_autoAC.cpp
new file mode 100644
index 0000000..cfdbab6
--- /dev/null
+++ b/HDOJ/4681_autoAC.cpp
@@ -0,0 +1,125 @@
+#include<iostream>
+#include<stdio.h>
+#include<vector>
+#include<algorithm>
+#include<string.h>
+using namespace std;
+char sta[1001];
+char stb[1001];
+char stc[1001];
+int lena,lenb,lenc;
+int dp[1001][1001];
+int dpf[1001][1001];
+struct list
+{
+    int x;
+    int y;
+}node,n1,n2;
+vector<list>vec[5];
+void dps()
+{
+    int i,j;
+    for(i=0;i<lena;i++)
+        if(sta[i]==stb[0])
+            for(i;i<lena;i++)dp[i][0]=1;
+    for(i=0;i<lenb;i++)
+        if(sta[0]==stb[i])
+            for(i;i<lenb;i++)dp[0][i]=1;
+    for(i=1;i<lena;i++)
+    {
+        for(j=1;j<lenb;j++)
+        {
+            if(sta[i]==stb[j])dp[i][j]=dp[i-1][j-1]+1;
+            else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
+        }
+    }
+}
+void dpfs()
+{
+    int i,j;
+    for(i=lena-1;i>=0;i--)
+        if(sta[i]==stb[lenb-1])
+            for(i;i>=0;i--)dpf[i][lenb-1]=1;
+    for(i=lenb-1;i>=0;i--)
+        if(sta[lena-1]==stb[i])
+            for(i;i>=0;i--)dpf[lena-1][i]=1;
+    for(i=lena-2;i>=0;i--)
+    {
+        for(j=lenb-2;j>=0;j--)
+        {
+            if(sta[i]==stb[j])dpf[i][j]=dpf[i+1][j+1]+1;
+            else dpf[i][j]=max(dpf[i+1][j],dpf[i][j+1]);
+        }
+    }
+}
+void init()
+{
+    memset(dp,0,sizeof(dp));
+    memset(dpf,0,sizeof(dpf));
+    vec[0].clear();
+    vec[1].clear();
+    gets(sta);
+    gets(stb);
+    gets(stc);
+    lena=strlen(sta);
+    lenb=strlen(stb);
+    lenc=strlen(stc);
+}
+void sear(char str[],int pos)
+{
+    int lens=strlen(str);
+    int i,j,k;
+    for(i=0;i<lens;i++)
+    {
+        if(str[i]==stc[0])
+        {
+            for(k=0,j=i;j<lens;j++)
+            {
+                if(str[j]==stc[k])k++;
+                if(k==lenc)break;
+            }
+            if(j<lens)
+            {
+                node.x=i;
+                node.y=j;
+                vec[pos].push_back(node);
+            }
+        }
+    }
+}
+void prin(int cas)
+{
+    int l1=vec[0].size();
+    int l2=vec[1].size();
+    int maxx=0;
+    int i,j;
+    for(i=0;i<l1;i++)
+    {
+        for(j=0;j<l2;j++)
+        {
+            n1=vec[0][i];
+            n2=vec[1][j];
+            int c1,c2;
+            c1=c2=0;
+            if(n1.x-1>=0&&n2.x-1>=0)c1=dp[n1.x-1][n2.x-1];
+            if(n1.y+1<lena&&n2.y+1<lenb)c2=dpf[n1.y+1][n2.y+1];
+            maxx=max(maxx,c1+c2+lenc);
+        }
+    }
+    printf("Case #%d: %d\n",cas,maxx);
+}
+int main()
+{
+    int T,t;
+    scanf("%d%*c",&T);
+    for(t=1;t<=T;t++)
+    {
+        init();
+        dps();
+        dpfs();
+        sear(sta,0);
+        sear(stb,1);
+        prin(t);
+    }
+    return 0;
+}
diff --git a/HDOJ/4685_autoAC.cpp b/HDOJ/4685_autoAC.cpp
new file mode 100644
index 0000000..7959c0f
--- /dev/null
+++ b/HDOJ/4685_autoAC.cpp
@@ -0,0 +1,125 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<stack>
+#include<vector>
+using namespace std;
+#define MAXN 1111
+int n,m,N,cnt;
+bool map[MAXN][MAXN];
+bool mark[MAXN];
+int ly[MAXN];
+int lx[MAXN];
+int dfs(int u,int m)
+{
+    for(int v=1;v<=m;v++){
+        if(map[u][v]&&!mark[v]){
+            mark[v]=true;
+            if(ly[v]==-1||dfs(ly[v],m)){
+                ly[v]=u;
+                lx[u]=v;
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+int MaxMatch(int n,int m)
+{
+    memset(ly,-1,sizeof(ly));
+    memset(lx,-1,sizeof(lx));
+    int ans=0;
+    for(int i=1;i<=n;i++){
+        memset(mark,false,sizeof(mark));
+        ans+=dfs(i,m);
+    }
+    return ans;
+}
+vector<vector<int> >g;
+vector<vector<int> >ans;
+int dfn[MAXN],low[MAXN];
+int color[MAXN],_count;
+stack<int>S;
+void Tarjan(int u)
+{
+    low[u]=dfn[u]=++cnt;
+    mark[u]=true;
+    S.push(u);
+    for(int i=0;i<g[u].size();i++){
+        int v=g[u][i];
+        if(dfn[v]==0){
+            Tarjan(v);
+            low[u]=min(low[u],low[v]);
+        }else if(mark[v]){
+            low[u]=min(low[u],dfn[v]);
+        }
+    }
+    if(low[u]==dfn[u]){
+        _count++;
+        int x;
+        do{
+            x=S.top();
+            S.pop();
+            mark[x]=false;
+            color[x]=_count;
+        }while(x!=u);
+    }
+}
+int main()
+{
+    int _case,k,x,t=1;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        memset(map,false,sizeof(map));
+        for(int i=1;i<=n;i++){
+            scanf("%d",&k);
+            while(k--){
+                scanf("%d",&x);
+                map[i][x]=true;
+            }
+        }
+        cnt=MaxMatch(n,m);
+        N=n+m-cnt;
+        for(int i=n+1;i<=N;i++)
+            for(int j=1;j<=N;j++)
+                map[i][j]=true;
+        for(int i=m+1;i<=N;i++)
+            for(int j=1;j<=N;j++)
+                map[j][i]=true;
+        MaxMatch(N,N);
+        g.clear();
+        g.resize(N+2);
+        ans.clear();
+        ans.resize(N+2);
+        for(int i=1;i<=N;i++){
+            for(int j=1;j<=N;j++){
+                if(lx[i]!=j&&map[i][j]){
+                    g[lx[i]].push_back(j);
+                }
+            }
+        }
+        memset(dfn,0,sizeof(dfn));
+        memset(mark,false,sizeof(mark));
+        _count=cnt=0;
+        for(int i=1;i<=N;i++)
+            if(dfn[i]==0)Tarjan(i);
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=m;j++){
+                if(map[i][j]&&color[lx[i]]==color[j]){
+                    ans[i].push_back(j);
+                }
+            }
+        }
+        printf("Case #%d:\n",t++);
+        for(int i=1;i<=n;i++){
+            printf("%d",(int)ans[i].size());
+            for(int j=0;j<ans[i].size();j++){
+                printf(" %d",ans[i][j]);
+            }
+            puts("");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4686_autoAC.cpp b/HDOJ/4686_autoAC.cpp
new file mode 100644
index 0000000..bc21a3d
--- /dev/null
+++ b/HDOJ/4686_autoAC.cpp
@@ -0,0 +1,76 @@
+#include<stdio.h>
+#include<string.h>
+#define LL long long
+#define M 1000000007
+struct Matrix
+{
+    LL a[6][6];
+}origin,res,tmp,A,ans;
+int n;
+Matrix mul(Matrix x,Matrix y)
+{
+    int i,j,k;
+    memset(tmp.a,0,sizeof(tmp.a));
+    for(i=1;i<=n;i++)
+        for(j=1;j<=n;j++)
+            for(k=1;k<=n;k++)
+            {
+                tmp.a[i][j]+=(x.a[i][k]*y.a[k][j])%M;
+                tmp.a[i][j]%=M;
+            }
+    return tmp;
+}
+void quickpow(LL k)
+{
+    int i;
+    memset(res.a,0,sizeof(res.a));
+    for(i=1;i<=n;i++)
+        res.a[i][i]=1;
+    while(k)
+    {
+        if(k&1)
+            res=mul(res,A);
+        A=mul(A,A);
+        k>>=1;
+    }
+}
+int main()
+{
+    LL N,a0,ax,ay,b0,bx,by;
+    LL f1,a1,b1,s0;
+    while(scanf("%lld %lld %lld %lld %lld %lld %lld",&N,&a0,&ax,&ay,&b0,&bx,&by)!=EOF)
+    {
+        if(N==0)
+        {
+            printf("0\n");
+            continue;
+        }
+        a1=(a0*ax+ay)%M;
+        b1=(b0*bx+by)%M;
+        f1=(a1*b1)%M;
+        s0=(a0*b0)%M;
+        n=5;
+        memset(origin.a,0,sizeof(origin.a));
+        origin.a[1][1]=f1;
+        origin.a[1][2]=a1;
+        origin.a[1][3]=b1;
+        origin.a[1][4]=1;
+        origin.a[1][5]=s0;
+        memset(A.a,0,sizeof(A.a));
+        A.a[1][1]=(ax*bx)%M;
+        A.a[1][5]=1;
+        A.a[2][1]=(ax*by)%M;
+        A.a[2][2]=ax%M;
+        A.a[3][1]=(ay*bx)%M;
+        A.a[3][3]=bx%M;
+        A.a[4][1]=(ay*by)%M;
+        A.a[4][2]=ay%M;
+        A.a[4][3]=by%M;
+        A.a[4][4]=1;
+        A.a[5][5]=1;
+        quickpow(N-1);
+        ans=mul(origin,res);
+        printf("%lld\n",ans.a[1][5]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4687_autoAC.cpp b/HDOJ/4687_autoAC.cpp
new file mode 100644
index 0000000..681bc52
--- /dev/null
+++ b/HDOJ/4687_autoAC.cpp
@@ -0,0 +1,187 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int MAXN = 50;
+int N; 
+bool Graph[MAXN][MAXN];
+int Match[MAXN];
+bool InQueue[MAXN],InPath[MAXN],InBlossom[MAXN];
+int Head,Tail;
+int Queue[MAXN];
+int Start,Finish;
+int NewBase;
+int Father[MAXN],Base[MAXN];
+int Count;
+void Push(int u)
+{
+    Queue[Tail] = u;
+    Tail++;
+    InQueue[u] = true;
+}
+int Pop()
+{
+    int res = Queue[Head];
+    Head++;
+    return res;
+}
+int FindCommonAncestor(int u,int v)
+{
+    memset(InPath,false,sizeof(InPath));
+    while(true)
+    {
+        u = Base[u];
+        InPath[u] = true;
+        if(u == Start) break;
+        u = Father[Match[u]];
+    }
+    while(true)
+    {
+        v = Base[v];
+        if(InPath[v])break;
+        v = Father[Match[v]];
+    }
+    return v;
+}
+void ResetTrace(int u)
+{
+    int v;
+    while(Base[u] != NewBase)
+    {
+        v = Match[u];
+        InBlossom[Base[u]] = InBlossom[Base[v]] = true;
+        u = Father[v];
+        if(Base[u] != NewBase) Father[u] = v;
+    }
+}
+void BloosomContract(int u,int v)
+{
+    NewBase = FindCommonAncestor(u,v);
+    memset(InBlossom,false,sizeof(InBlossom));
+    ResetTrace(u);
+    ResetTrace(v);
+    if(Base[u] != NewBase) Father[u] = v;
+    if(Base[v] != NewBase) Father[v] = u;
+    for(int tu = 1; tu <= N; tu++)
+        if(InBlossom[Base[tu]])
+        {
+            Base[tu] = NewBase;
+            if(!InQueue[tu]) Push(tu);
+        }
+}
+void FindAugmentingPath()
+{
+    memset(InQueue,false,sizeof(InQueue));
+    memset(Father,0,sizeof(Father));
+    for(int i = 1;i <= N;i++)
+        Base[i] = i;
+    Head = Tail = 1;
+    Push(Start);
+    Finish = 0;
+    while(Head < Tail)
+    {
+        int u = Pop();
+        for(int v = 1; v <= N; v++)
+            if(Graph[u][v] && (Base[u] != Base[v]) && (Match[u] != v))
+            {
+                if((v == Start) || ((Match[v] > 0) && Father[Match[v]] > 0))
+                    BloosomContract(u,v);
+                else if(Father[v] == 0)
+                {
+                    Father[v] = u;
+                    if(Match[v] > 0)
+                        Push(Match[v]);
+                    else
+                    {
+                        Finish = v;
+                        return;
+                    }
+                }
+            }
+    }
+}
+void AugmentPath()
+{
+    int u,v,w;
+    u = Finish;
+    while(u > 0)
+    {
+        v = Father[u];
+        w = Match[v];
+        Match[v] = u;
+        Match[u] = v;
+        u = w;
+    }
+}
+void Edmonds()
+{
+    memset(Match,0,sizeof(Match));
+    for(int u = 1; u <= N; u++)
+        if(Match[u] == 0)
+        {
+            Start = u;
+            FindAugmentingPath();
+            if(Finish > 0)AugmentPath();
+        }
+}
+int getMatch()
+{
+    Edmonds();
+    Count = 0;
+    for(int u = 1; u <= N;u++)
+        if(Match[u] > 0)
+            Count++;
+    return Count/2;
+}
+bool g[MAXN][MAXN];
+pair<int,int>p[150];
+int main()
+{
+    int m;
+    while(scanf("%d%d",&N,&m)==2)
+    {
+        memset(g,false,sizeof(g));
+        memset(Graph,false,sizeof(Graph));
+        int u,v;
+        for(int i = 1;i <= m;i++)
+        {
+            scanf("%d%d",&u,&v);
+            p[i] = make_pair(u,v);
+            g[u][v] = true;
+            g[v][u] = true;
+            Graph[u][v] = true;
+            Graph[v][u] = true;
+        }
+        int cnt0 = getMatch();
+        vector<int>ans;
+        for(int i = 1;i <= m;i++)
+        {
+            u = p[i].first;
+            v = p[i].second;
+            memcpy(Graph,g,sizeof(g));
+            for(int j = 1;j <= N;j++)
+                Graph[j][u] = Graph[u][j] = Graph[j][v] = Graph[v][j] = false;
+            int cnt = getMatch();
+            if(cnt < cnt0-1)
+                ans.push_back(i);
+        }
+        int sz = ans.size();
+        printf("%d\n",sz);
+        for(int i = 0;i < sz;i++)
+        {
+            printf("%d",ans[i]);
+            if(i < sz-1)printf(" ");
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4689_autoAC.cpp b/HDOJ/4689_autoAC.cpp
new file mode 100644
index 0000000..1c5c5ba
--- /dev/null
+++ b/HDOJ/4689_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <vector>
+using namespace std;
+#define ll long long
+char a[100];
+ll dp[22][22][22];
+int main ()
+{
+    while(scanf("%s",a)!=EOF)
+    {
+        if(a[0]=='-')
+        {
+            printf("0\n");
+            continue;
+        }
+        memset(dp,0,sizeof(dp));
+        dp[1][0][1]=1;
+        int cnt=0;
+        for(int i=1;i<strlen(a);++i)
+        {
+            if(a[i]=='-')
+            {
+                cnt++;
+                for(int j=0;j<i;++j)
+                    for(int k=0;k<=i;++k)
+                {
+                    if(i-j-k>0)
+                        dp[i+1][j+1][k]+=dp[i][j][k]*(i-j-k);
+                    if(k)
+                        dp[i+1][j+1][k-1]+=dp[i][j][k]*k;
+                }
+            }
+            else
+            {
+                for(int j=0;j<=i;++j)
+                    for(int k=0;k<=i;++k)
+                    {
+                        dp[i+1][j][k+1]+=dp[i][j][k];
+                        if(i-j-k>0)
+                            dp[i+1][j][k+1]+=dp[i][j][k]*(i-j-k);
+                        dp[i+1][j][k]+=dp[i][j][k]*k;
+                    }
+            }
+        }
+        cout<<dp[strlen(a)][cnt][0]<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4690_autoAC.cpp b/HDOJ/4690_autoAC.cpp
new file mode 100644
index 0000000..1febc21
--- /dev/null
+++ b/HDOJ/4690_autoAC.cpp
@@ -0,0 +1,105 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <cctype>
+#include <algorithm>
+#include <queue>
+#include <deque>
+#include <queue>
+#include <list>
+#include <map>
+#include <set>
+#include <vector>
+#include <utility>
+#include <functional>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <numeric>
+#include <cassert>
+#include <ctime>
+#include <iterator>
+const int INF = 0x3f3f3f3f;
+const int dir[8][2] = {{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{-1,1},{1,-1},{1,1}};
+using namespace std;
+string A[16][16] = {
+    "NUL","SOH","STX","ETX","","HT","","DEL","","","","VT","FF","CR","SO","SI",
+    "DLE","DC1","DC2","DC3","","","BS","","CAN","EM","","","IFS","IGS","IRS","IUS ITB",
+    "","","","","","LF","ETB","ESC","","","","","","ENQ","ACK","BEL",
+    "","","SYN","","","","","EOT","","","","","DC4","NAK","","SUB",
+    "SP","","","","","","","","","","",".","<","(","+","|",
+    "&","","","","","","","","","","!","$","*",")",";","",
+    "-","/","","","","","","","","","",",","%","_",">","?",
+    "","","","","","","","","","`",":","#","@","'","=","\"",
+    "","a","b","c","d","e","f","g","h","i","","","","","","",
+    "","j","k","l","m","n","o","p","q","r","","","","","","",
+    "","~","s","t","u","v","w","x","y","z","","","","","","",
+    "^","","","","","","","","","","[","]","","","","",
+    "{","A","B","C","D","E","F","G","H","I","","","","","","",
+    "}","J","K","L","M","N","O","P","Q","R","","","","","","",
+    "\\","","S","T","U","V","W","X","Y","Z","","","","","","",
+    "0","1","2","3","4","5","6","7","8","9","","","","","",""
+};
+string B[8][16] = {
+"NUL",    "SOH",    "STX",    "ETX",    "EOT",    "ENQ",    "ACK",    "BEL",    "BS",    "HT",    "LF",    "VT",    "FF",    "CR",    "SO",    "SI",
+"DLE",    "DC1",    "DC2",    "DC3",    "DC4",    "NAK",    "SYN",    "ETB",    "CAN",    "EM",    "SUB",    "ESC",    "IFS",    "IGS",    "IRS",    "IUS ITB",
+"SP",    "!",    "\"",    "#",    "$",    "%",    "&",    "'",    "(",    ")",    "*",    "+",    ",",    "-",    ".",    "/",
+"0",    "1",    "2",    "3",    "4",    "5",    "6",    "7",    "8",    "9",    ":",    ";",    "<",    "=",    ">",    "?",
+"@",    "A",    "B",    "C",    "D",    "E",    "F",    "G",    "H",    "I",    "J",    "K",    "L",    "M",    "N",    "O",
+"P",    "Q",    "R",    "S",    "T",    "U",    "V",    "W",    "X",    "Y",    "Z",    "[", "\\","]","^","_",
+"`",    "a",    "b",    "c",    "d",    "e",    "f",    "g",    "h",    "i",    "j",    "k",    "l",    "m",    "n",    "o",
+"p",    "q",    "r",    "s",    "t",    "u",    "v",    "w",    "x",    "y",    "z",    "{",    "|",    "}",    "~",    "DEL"
+};
+map<pair<int,int>, pair<int,int> > coll;
+int main(void)
+{
+    string sad;
+    ios::sync_with_stdio(false);
+    cin>>sad; coll.clear();
+    string tmp; pair<int,int> so, to;
+    for (int i = 0; i < 16; ++i)
+    {
+        for (int j = 0; j < 16; ++j)
+        {
+            if (A[i][j]!="")
+            {
+                so.first=i, so.second=j;
+                bool mrk = false;
+                for (int k = 0; k < 8; ++k)
+                {
+                    for (int h = 0; h < 16; ++h)
+                    {
+                        if (A[i][j]==B[k][h])
+                        {
+                            mrk = true;
+                            to.first=k,to.second=h;
+                            coll[so] = to; break;
+                        }
+                    }
+                    if (mrk) break;
+                }
+            }
+        }
+    }
+    for (int i = 0; i < sad.size(); i+=2)
+    {
+        int X, Y; tmp.clear();
+        if (sad[i]>='A'&&sad[i]<='F') X = sad[i]- 'A'+10;
+        else X = sad[i] - '0';
+        if (sad[i+1]>='A'&&sad[i+1]<='F') Y = sad[i+1]- 'A'+10;
+        else Y = sad[i+1] - '0';
+        pair<int,int> hehe, TM;
+        hehe.first = X, hehe.second = Y;
+        TM = coll[hehe];
+        int j = TM.first, k = TM.second;
+        char XX, YY;
+        XX = j+ '0';
+        if (k >= 10) YY = k - 10 + 'A';
+        else YY = k + '0';
+        printf("%c%c", XX, YY);
+    }
+    printf("\n");
+    return 0;
+}
diff --git a/HDOJ/4691_autoAC.cpp b/HDOJ/4691_autoAC.cpp
new file mode 100644
index 0000000..21097d4
--- /dev/null
+++ b/HDOJ/4691_autoAC.cpp
@@ -0,0 +1,140 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int MAXN=100010;
+int t1[MAXN],t2[MAXN],c[MAXN];
+bool cmp(int *r,int a,int b,int l)
+{
+    return r[a] == r[b] && r[a+l] == r[b+l];
+}
+void da(int str[],int sa[],int ran[],int height[],int n,int m)
+{
+    n++;
+    int i, j, p, *x = t1, *y = t2;
+    for(i = 0;i < m;i++)c[i] = 0;
+    for(i = 0;i < n;i++)c[x[i] = str[i]]++;
+    for(i = 1;i < m;i++)c[i] += c[i-1];
+    for(i = n-1;i >= 0;i--)sa[--c[x[i]]] = i;
+    for(j = 1;j <= n; j <<= 1)
+    {
+        p = 0;
+        for(i = n-j; i < n; i++)y[p++] = i;
+        for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
+        for(i = 0; i < m; i++)c[i] = 0;
+        for(i = 0; i < n; i++)c[x[y[i]]]++;
+        for(i = 1; i < m;i++)c[i] += c[i-1];
+        for(i = n-1; i >= 0;i--)sa[--c[x[y[i]]]] = y[i];
+        swap(x,y);
+        p = 1; x[sa[0]] = 0;
+        for(i = 1;i < n;i++)
+            x[sa[i]] = cmp(y,sa[i-1],sa[i],j)?p-1:p++;
+        if(p >= n)break;
+        m = p;
+    }
+    int k = 0;
+    n--;
+    for(i = 0;i <= n;i++)ran[sa[i]] = i;
+    for(i = 0;i < n;i++)
+    {
+        if(k)k--;
+        j = sa[ran[i]-1];
+        while(str[i+k] == str[j+k])k++;
+        height[ran[i]] = k;
+    }
+}
+int ran[MAXN],height[MAXN];
+int RMQ[MAXN];
+int mm[MAXN];
+int best[20][MAXN];
+void initRMQ(int n)
+{
+    mm[0]=-1;
+    for(int i=1;i<=n;i++)
+        mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
+    for(int i=1;i<=n;i++)best[0][i]=i;
+    for(int i=1;i<=mm[n];i++)
+        for(int j=1;j+(1<<i)-1<=n;j++)
+        {
+            int a=best[i-1][j];
+            int b=best[i-1][j+(1<<(i-1))];
+            if(RMQ[a]<RMQ[b])best[i][j]=a;
+            else best[i][j]=b;
+        }
+}
+int askRMQ(int a,int b)
+{
+    int t;
+    t=mm[b-a+1];
+    b-=(1<<t)-1;
+    a=best[t][a];b=best[t][b];
+    return RMQ[a]<RMQ[b]?a:b;
+}
+int lcp(int a,int b)
+{
+    a=ran[a];b=ran[b];
+    if(a>b)swap(a,b);
+    return height[askRMQ(a+1,b)];
+}
+char str[MAXN];
+int r[MAXN];
+int sa[MAXN];
+int A[MAXN],B[MAXN];
+int calc(int n)
+{
+    if(n == 0)return 1;
+    int ret = 0;
+    while(n)
+    {
+        ret++;
+        n /= 10;
+    }
+    return ret;
+}
+int main()
+{
+    while(scanf("%s",str)==1)
+    {
+        int n = strlen(str);
+        for(int i = 0;i < n;i++)
+            r[i] = str[i];
+        r[n] = 0;
+        da(r,sa,ran,height,n,128);
+        for(int i = 1;i <= n;i++)
+            RMQ[i] = height[i];
+        initRMQ(n);
+        int k,u,v;
+        long long ans1 = 0, ans2 = 0;
+        scanf("%d",&k);
+        for(int i = 0;i < k;i++)
+        {
+            scanf("%d%d",&A[i],&B[i]);
+            if(i == 0)
+            {
+                ans1 += B[i] - A[i] + 1;
+                ans2 += B[i] - A[i] + 3;
+                continue;
+            }
+            int tmp ;
+            if(A[i]!= A[i-1])tmp = lcp(A[i],A[i-1]);
+            else tmp = 10000000;
+            tmp = min(tmp,B[i]-A[i]);
+            tmp = min(tmp,B[i-1]-A[i-1]);
+            ans1 += B[i] - A[i] + 1;
+            ans2 += B[i] - A[i] - tmp + 1;
+            ans2 += 1;
+            ans2 += calc(tmp);
+        }
+        printf("%I64d %I64d\n",ans1,ans2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4696_autoAC.cpp b/HDOJ/4696_autoAC.cpp
new file mode 100644
index 0000000..c605388
--- /dev/null
+++ b/HDOJ/4696_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+#define LL __int64
+#define maxn 100011
+int t[maxn],c[maxn],n,q,m[maxn],vis[maxn],a[maxn],b[maxn];
+map<int,map<int,int> >nn;
+map<int,int>mm;
+map<int,int>ll;
+int bb[1001];
+int flag[maxn],s[maxn],ss[maxn];
+void find(int x)
+{
+    ll.clear();
+    int tt=1,i,j,k,y,z,d;
+    s[0]=0;s[1]=c[x];ll[x]=1,ss[1]=x;
+    for(i=2;;i++)
+    {
+        vis[x]=1;
+        x=t[x];
+        ss[i]=x;
+        if(ll[x])
+            break;
+        if(vis[x])
+        {
+            for(j=i-1;j>=1;j--)
+            {
+                a[ss[j]]=s[i-1]-s[j-1]+a[x];
+                b[ss[j]]=b[x];
+            }
+            return;
+        }
+        ll[x]=++tt;
+        s[i]=s[i-1]+c[x];
+    }
+    d=s[i-1]-s[ll[x]-1];
+    for(j=1;j<i;j++)
+    {
+        if(j<=ll[x])
+            a[ss[j]]=s[ll[x]-1]-s[j-1];
+        else
+            a[ss[j]]=s[i-1]-s[j-1];
+        b[ss[j]]=d;
+    }
+}
+int main()
+{
+    while(scanf("%d%d",&n,&q)!=EOF)
+    {
+        int i,j,k;
+        for(i=1;i<=n;i++)
+            scanf("%d",&t[i]);
+        for(i=1;i<=n;i++)
+            scanf("%d",&c[i]);
+        for(i=1;i<=q;i++)
+            scanf("%d",&m[i]);
+        memset(vis,0,sizeof(vis));
+        for(i=1;i<=n;i++)
+        {
+            if(!vis[i])
+            find(i);
+        }
+        mm.clear();
+        nn.clear();
+        int tt=0;
+        for(i=1;i<=n;i++)
+        {
+            if(mm[b[i]]==0)
+            {
+                mm[b[i]]=++tt;
+                bb[tt]=b[i];
+            }
+            nn[tt][a[i]]=1;
+        }
+        memset(flag,0,sizeof(flag));
+        for(j=1;j<=q;j++)
+        {
+            if(m[j]<=0)continue;
+            for(i=1;i<=tt;i++)
+            if(nn[i][m[j]%bb[i]]){flag[j]=1;break;}
+        }
+        for(i=1;i<=q;i++)
+            if(flag[i])printf("YES\n");
+            else printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4697_autoAC.cpp b/HDOJ/4697_autoAC.cpp
new file mode 100644
index 0000000..d09a44d
--- /dev/null
+++ b/HDOJ/4697_autoAC.cpp
@@ -0,0 +1,129 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-9;
+inline int dcmp(double x) {
+    if (fabs(x) < eps)
+        return 0;
+    return x > eps ? 1 : -1;
+}
+struct point {
+    double x, y;
+    int id;
+    inline void in(int i) {
+        scanf("%lf%lf", &x, &y);
+        id = i;
+    }
+    point(double x = 0, double y = 0) :
+            x(x), y(y) {
+    }
+    inline point operator -(const point &t) const {
+        return point(x - t.x, y - t.y);
+    }
+    inline point operator +(const point &t) const {
+        return point(x + t.x, y + t.y);
+    }
+    point operator /(const double &t) const {
+        return point(x / t, y / t);
+    }
+    point operator *(const double &t) const {
+        return point(x * t, y * t);
+    }
+    inline double operator *(const point &t) const {            
+        return x*t.y-y*t.x;
+    }
+    bool operator <(const point &t) const {
+        if(y == t.y) return x < t.x;
+        return y < t.y;
+    }
+}p[55], v[55], tp[55], st[55];
+double t[55*55*55], T, cur, ans;
+int sz, n, m;
+double a, b, c;
+inline double cross(const point &o, const point &a, const point &b) {
+    return (a.x-o.x)*(b.y-o.y)-(a.y-o.y)*(b.x-o.x);
+}
+int graham(point *p, int n, point *st) {        
+    sort(p, p + n);
+    int top = 0;
+    int i;
+    for (i = 0; i < n; i++) {
+        while (top >= 2 && cross(st[top - 2], st[top - 1], p[i]) < eps)
+            top--;
+        st[top++] = p[i];
+    }
+    int t = top + 1;
+    for (i = n - 2; i >= 0; i--) {
+        while (top >= t && cross(st[top - 2], st[top - 1], p[i]) < eps)
+            top--;
+        st[top++] = p[i];
+    }
+    return top;
+}
+inline void gao(int i, int j, int k) {        
+    point a1 = p[i]-p[j], a2 = p[i]-p[k];
+    point b1 = v[i]-v[j], b2 = v[i]-v[k];
+    a += b1*b2; b += a1*b2+b1*a2; c += a1*a2;
+}
+inline void solve(double a, double b, double c) {    
+    double x;
+    if(a == 0) {
+        if(b!= 0) {
+            x = -c/b;
+            if(x >= 0 && x <= T) t[sz++] = x;
+        }
+        return;
+    }
+    double dlt = b*b-4*a*c;
+    if(dlt < 0) return;
+    if(dlt == 0) {
+        x = -b*0.5/a;
+        if(x >= 0 && x <= T) t[sz++] = x;
+        return;
+    }
+    dlt = sqrt(dlt);
+    x = 0.5*(-b+dlt)/a;
+    if(x >= 0 && x <= T) t[sz++] = x;
+    x = 0.5*(-b-dlt)/a;
+    if(x >= 0 && x <= T) t[sz++] = x;
+}
+inline double F(double x) {        
+    return a*x*x*x/3.0+b*x*x/2.0+c*x;
+}
+int main() {
+    int i, j, k;
+    while( ~scanf("%d%lf", &n, &T)) {
+        for(i = 0; i < n; i++) p[i].in(i), v[i].in(i);
+        if(n <= 2) {
+            printf("%.10f\n", 0.0);
+            continue;
+        }
+        t[0] = 0; t[1] = T;    
+        sz = 2;
+        for(i = 0; i < n; i++)
+            for(j = i+1; j < n; j++)
+                for(k = j+1; k < n; k++) {
+                    a = b = c = 0;
+                    gao(i, j, k);
+                    solve(a, b, c);
+                }
+        sort(t, t+sz);
+        ans = 0;
+        for(i = 0; i < sz-1; i++) {
+            cur = 0.5*(t[i]+t[i+1]);
+            a = b = c = 0;
+            for(j = 0; j < n; j++) {
+                tp[j] = p[j]+v[j]*cur;
+                tp[j].id = p[j].id;
+            }
+            m = graham(tp, n, st);
+            for(j = 2; j < m; j++)
+                gao(st[0].id, st[j-1].id, st[j].id);    
+            ans += F(t[i+1])- F(t[i]);
+        }
+        printf("%.10f\n", fabs(ans*0.5/T));
+    }
+    return 0;
+}
diff --git a/HDOJ/4698_autoAC.cpp b/HDOJ/4698_autoAC.cpp
new file mode 100644
index 0000000..2e1a306
--- /dev/null
+++ b/HDOJ/4698_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <cstdio>  
+#include <cstdlib>  
+#include <cmath>  
+#include <cstring>  
+#include <algorithm>  
+#include <vector>  
+#include <stack>  
+#include <queue>  
+#include <set>  
+#define LL long long  
+#define mod 1000000007  
+#define M 1005  
+#define INF 0x7fffffff  
+using namespace std;  
+struct Point  
+{  
+    int x, y;  
+    bool operator < (const Point &temp) const  
+    {  
+        if(x!=temp.x) return x<temp.x;  
+        else return y<temp.y;  
+    }  
+    int readPoint()  
+    {  
+        return scanf("%d%d", &x, &y);  
+    }  
+} p[M];  
+int n, m, k;  
+int val[M];  
+set<int>sset;  
+set<int>::iterator it;  
+int main ()  
+{  
+    while(~scanf("%d%d%d", &n, &m, &k))  
+    {  
+        for(int i = 1; i <= k; ++i)  
+        {  
+            p[i].readPoint();  
+            val[i] = p[i].x;  
+        }  
+        sort(p+1, p+1+k);  
+        sort(val+1, val+1+k);  
+        int tot = unique(val+1, val+1+k) - val;  
+        val[0] = 0;  
+        val[tot] = n+1;  
+        LL ans = 0;  
+        for(int i = 1; i < tot; ++i)  
+        {  
+            LL tt = 0;  
+            int pre = val[i]-val[i-1];  
+            int r;  
+            for(r = 1; r <= k && p[r].x < val[i]; ++r);  
+            sset.clear();  
+            sset.insert(0);  
+            sset.insert(m+1);  
+            for(int j = i; j < tot; ++j)  
+            {  
+                int top, bottom;  
+                for( ; r <= k && p[r].x == val[j]; ++r)  
+                {  
+                    if(sset.count(p[r].y)) continue;  
+                    it = sset.lower_bound(p[r].y);  
+                    top = *it;  
+                    bottom = *(--it);  
+                    tt = (tt+(LL)(top-p[r].y)*(p[r].y-bottom)%mod)%mod;  
+                    sset.insert(p[r].y);  
+                }  
+                int rear = val[j+1]-val[j];  
+                ans = (ans+tt*rear%mod*pre%mod)%mod;  
+            }  
+        }  
+        printf("%I64d\n", ans);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4699_autoAC.cpp b/HDOJ/4699_autoAC.cpp
new file mode 100644
index 0000000..4087cd2
--- /dev/null
+++ b/HDOJ/4699_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<iostream>
+#include<cstdio>
+#include<vector>
+using namespace std;
+#define max(a,b) a>b?a:b
+#define min(a,b) a<b?a:b
+struct node
+{
+    int sum;
+    int m;
+    int v;
+}ne,cur;
+vector<node>a,b;
+int main()
+{
+    int num,j,n;
+    char k;
+    while(scanf("%d",&num)!=EOF)
+    {
+        a.clear();
+        b.clear();
+        while(num--)
+        {
+            getchar();
+            scanf("%c",&k);
+            if(k=='I')
+            {
+                scanf("%d",&n);
+                ne.m=n;
+                ne.v=n;
+                ne.sum=n;
+                if(a.size()==0)
+                    a.push_back(ne);
+                else
+                {
+                    int sz=a.size();
+                    cur=a[sz-1];
+                    ne.sum = cur.sum + ne.v;
+                    ne.m = max(ne.sum,cur.m);
+                    a.push_back(ne);
+                }
+            }
+            else if(k=='L')
+            {
+                int sz = a.size() ;
+                if(sz)
+                {    
+                    cur = a[sz-1] ;
+                    a.pop_back();
+                    b.push_back(cur);
+                }
+            }
+            else if(k=='R')
+            {
+                j = b.size();
+                if(j)
+                {                
+                    ne=b[j-1];
+                    b.pop_back();
+                    ne.sum=ne.v;
+                    ne.m=ne.v;
+                    int sz = a.size();
+                    if(sz==0)
+                    {
+                        ne.sum=ne.v;
+                        ne.m=ne.v;
+                        a.push_back(ne);
+                    }
+                    else
+                    {
+                        cur = a[sz-1];
+                        ne.sum = cur.sum + ne.v;
+                        ne.m = max(ne.sum,cur.m);
+                        a.push_back(ne);
+                    }
+                }
+            }
+            else if(k=='D')
+            {
+                if(a.size())
+                a.pop_back();
+            }
+            else if(k=='Q')
+            {
+                scanf("%d",&n);
+                printf("%d\n",a[n-1].m);
+            }
+        }
+    }
+    return 0;
+}