diff --git a/HDOJ/4700_autoAC.cpp b/HDOJ/4700_autoAC.cpp
new file mode 100644
index 0000000..fd39a62
--- /dev/null
+++ b/HDOJ/4700_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <iostream>
+#include <cstdio>
+#include <vector>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+#define N 110
+#define INF (1e9)+5
+int graph[N][N],cut[N][N];
+int n;
+bool check(vector<int>v)
+{
+    if(v.size()<=1) return true;
+    int bridge=INF;
+    for(int i=0;i<v.size();++i)
+        for(int j=0;j<v.size();++j)
+        bridge=min(bridge,cut[v[i]][v[j]]);
+    vector<int>v0,v1;
+    for(int i=0,x=v[0];i<v.size();++i)
+    {
+        if(cut[v[i]][x]>bridge) v0.push_back(v[i]);
+        else v1.push_back(v[i]);
+    }
+    if(v0.empty()||v1.empty()) return false;
+    for(int i=0;i<v0.size();++i)
+        for(int j=0;j<v1.size();++j)
+        {
+            if(cut[v0[i]][v1[j]]!=bridge) return false;
+        }
+    graph[v0[0]][v1[0]]=graph[v1[0]][v0[0]]=bridge;
+    return check(v0)&&check(v1);
+}
+int main ()
+{
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(int i=1;i<=n;++i)
+        {
+            for(int j=1;j<=n;++j)
+                scanf("%d",&cut[i][j]);
+            cut[i][i]=INF;
+        }
+        memset(graph,0,sizeof(graph));
+        vector<int>v;
+        for(int i=1;i<=n;++i) v.push_back(i);
+        if(check(v))
+        {
+            for(int i=1;i<=n;++i) graph[i][i]=-1;
+            printf("YES\n");
+            for(int i=1;i<=n;++i)
+                for(int j=1;j<=n;++j)
+                {
+                    printf("%d",graph[i][j]);
+                    if(j<n) printf(" ");
+                    else printf("\n");
+                }
+        }
+        else printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4701_autoAC.cpp b/HDOJ/4701_autoAC.cpp
new file mode 100644
index 0000000..5fd0953
--- /dev/null
+++ b/HDOJ/4701_autoAC.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <vector>
+#include <cmath>
+#include <cstring>
+using namespace std;
+long long s[1000500];
+int main ()
+{
+    int n,a,b;
+    while(scanf("%d%d%d",&n,&a,&b)!=EOF)
+    {
+        for(int i=1;i<=n;++i)
+            scanf("%I64d",&s[i]);
+        for(int i=n-1;i>=1;--i)
+            s[i]+=s[i+1];
+        long long pre_min=0,now_min;
+        for(int i=n;i>=1;--i)
+        {
+            now_min=pre_min+s[i];
+            pre_min=min(pre_min,max(-s[i],a+b-s[1]+1-now_min));
+        }
+        if(a>=now_min)
+            printf("ALICE\n");
+        else printf("BOB\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4704_autoAC.cpp b/HDOJ/4704_autoAC.cpp
new file mode 100644
index 0000000..af610f8
--- /dev/null
+++ b/HDOJ/4704_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<algorithm>
+#include<iostream>
+#include<queue>
+#include<map>
+#include<stack>
+#include<set>
+#include<math.h>
+using namespace std;
+typedef long long int64;
+typedef pair<int64,int64> PII;
+#define MP(a,b) make_pair((a),(b)) 
+const int maxn = 100015;
+const int inf = 0x7fffffff;
+const double pi=acos(-1.0);
+const double eps = 1e-8;
+const int64 mod = 1000000000+7;
+int64 Fast_Pow( int64 a,int64 n,int64 mod ){
+    int64 res = 1;
+    while( n>=1 ){
+        if( n&1 ){
+            res = res*a%mod;
+        }
+        a = a*a%mod;
+        n >>= 1;
+    }
+    return res%mod;
+}
+int64 GetNum( char str[],int64 mod ){
+    int64 res = 0;
+    int len = strlen( str );
+    for( int i=0;i<len;i++ ){
+        res = (res*10+str[i]-'0')%mod;
+    }
+    return res;
+}
+int main(){
+    char str[ maxn ];
+    while( scanf("%s",str)!=EOF ){
+        int64 n = GetNum( str,mod-1 );
+        printf("%I64d\n",Fast_Pow( 2,(n-1+mod)%mod,mod ));
+    }
+    return 0;
+}
diff --git a/HDOJ/4705_autoAC.cpp b/HDOJ/4705_autoAC.cpp
new file mode 100644
index 0000000..f92c462
--- /dev/null
+++ b/HDOJ/4705_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define MAXN 100100
+#pragma comment(linker, "/STACK:16777216")
+struct Edge{
+    int v,next;
+}edge[MAXN*4];
+int NE;
+long long n;
+int head[MAXN];
+void Insert(int u,int v)
+{
+    edge[NE].v=v;
+    edge[NE].next=head[u];
+    head[u]=NE++;
+}
+bool mark[MAXN];
+long long sum,ans;
+int dfs(int u)
+{
+    mark[u]=true;
+    int son,tmp=0;
+    for(int i=head[u];i!=-1;i=edge[i].next){
+        int v=edge[i].v;
+        if(mark[v])continue;
+        son=dfs(v);
+        tmp+=son;
+        ans+=(long long )(n-1-tmp)*son;
+    }
+    return tmp+1;
+}
+int main()
+{
+    int u,v;
+    while(~scanf("%I64d",&n)){
+        NE=0;
+        memset(head,-1,sizeof(head));
+        for(int i=1;i<n;i++){
+            scanf("%d%d",&u,&v);
+            Insert(u,v);
+            Insert(v,u);
+        }
+        memset(mark,false,sizeof(mark));
+        ans=0;
+        dfs(1);
+        sum=n*(n-1)*(n-2)/6;
+        printf("%I64d\n",sum-ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4706_autoAC.cpp b/HDOJ/4706_autoAC.cpp
new file mode 100644
index 0000000..77b0735
--- /dev/null
+++ b/HDOJ/4706_autoAC.cpp
@@ -0,0 +1,3 @@
+a e
+bdf
+c g
diff --git a/HDOJ/4707_autoAC.cpp b/HDOJ/4707_autoAC.cpp
new file mode 100644
index 0000000..66d74b8
--- /dev/null
+++ b/HDOJ/4707_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+struct node
+{
+    int next,to;
+    int step;
+} a[100005];
+int head[100005];
+int n,d,len,ans;
+void add(int x,int y)
+{
+    a[len].to = y;
+    a[len].next = head[x];
+    head[x] = len++;
+}
+void dfs(int x,int step)
+{
+    int i,j,k;
+    if(-1 == head[x])
+        return ;
+    for(i = head[x]; i!=-1; i = a[i].next)
+    {
+        k = a[i].to;
+        a[i].step = step+1;
+        if(a[i].step>d)
+            ans++;
+        dfs(k,a[i].step);
+    }
+}
+int main()
+{
+    int T,i,j,x,y;
+    scanf("%d",&T);
+    while(T--)
+    {
+        memset(head,-1,sizeof(head));
+        memset(a,0,sizeof(a));
+        scanf("%d%d",&n,&d);
+        len = 0;
+        for(i = 1; i<n; i++)
+        {
+            scanf("%d%d",&x,&y);
+            add(x,y);
+        }
+        ans = 0;
+        dfs(0,0);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4708_autoAC.cpp b/HDOJ/4708_autoAC.cpp
new file mode 100644
index 0000000..dba870e
--- /dev/null
+++ b/HDOJ/4708_autoAC.cpp
@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+long long a[20][20];
+int n;
+void change(int &x,int &y,int k)
+{
+    if(x == k)
+    {
+        if(y == k)
+        {
+            x++;
+        }
+        else y--;
+    }
+    else if(x == n+1-k)
+    {
+        if(y == n+1-k)
+            x--;
+        else y++;
+    }
+    else if(y == k)
+        x++;
+    else x--;
+}
+int main()
+{
+    while(scanf("%d",&n) && n)
+    {
+        for(int i = 1;i <=  n;i++)
+            for(int j = 1;j <= n;j++)
+                cin>>a[i][j];
+        long long ans1 = 0, ans2 = 0;
+        for(int i = 1;i <= n/2;i++)
+        {
+            int x0 = i,y0 = i;
+            int x1 = i,y1 = n+1-i;
+            int x2 = n+1-i,y2 = i;
+            int x3 = n+1-i,y3 = n+1-i;
+            int tmp1 = a[x0][y0] + a[x1][y1] + a[x2][y2] + a[x3][y3];
+            int tmp2 = 0;
+            for(int j = 0;j < (n+2-2*i-2);j++)
+            {
+                change(x0,y0,i);
+                change(x1,y1,i);
+                change(x2,y2,i);
+                change(x3,y3,i);
+                int tt = min(j+1,n+2-2*i-1-(j+1));
+                if(tmp1 < a[x0][y0] + a[x1][y1] + a[x2][y2] + a[x3][y3])
+                {
+                    tmp1 = a[x0][y0] + a[x1][y1] + a[x2][y2] + a[x3][y3];
+                    tmp2 = tt;
+                }
+                else if(tmp1 == a[x0][y0] + a[x1][y1] + a[x2][y2] + a[x3][y3] && tmp2 > tt)
+                {
+                    tmp2 = tt;
+                }
+            }
+            ans1 += tmp1;
+            ans2 += tmp2;
+        }
+        ans1 += a[n/2+1][n/2+1];
+        cout<<ans1<<" "<<ans2<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4709_autoAC.cpp b/HDOJ/4709_autoAC.cpp
new file mode 100644
index 0000000..3cb2ea6
--- /dev/null
+++ b/HDOJ/4709_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<vector>
+#include<cstdio>
+using namespace std;
+struct point
+{
+    double x;
+    double y;
+};
+double area(point A,point B,point C)
+{
+   double abx=B.x-A.x;
+   double aby=B.y-A.y;
+   double acx=C.x-A.x;
+   double acy=C.y-A.y;
+   double ans=(abx*acy-acx*aby)/2;
+   return fabs(ans);
+}
+int main()
+{
+   int T;
+   int n;
+   cin>>T;
+   while(T--)
+   {
+      cin>>n;
+      point p[n];
+      double x,y;
+      for(int i=0;i<n;i++)
+      {
+      scanf("%lf %lf",&x,&y);
+      p[i].x=x;
+      p[i].y=y;
+      }
+      vector<double> v;
+      for(int i=0;i<n;i++)
+        for(int j=i+1;j<n;j++)
+          for(int k=j+1;k<n;k++)
+           {
+             v.push_back(area(p[i],p[j],p[k]));
+           }
+       sort(v.begin(),v.end());
+       double ans=0;
+       for(int i=0;i<v.size();i++)
+         if(v[i]!=0)
+         {
+             ans=v[i];
+             break;
+         }
+       if(ans==0)  cout<<"Impossible"<<endl;
+       else printf("%.2lf\n",ans);
+   }
+}
diff --git a/HDOJ/4711_autoAC.cpp b/HDOJ/4711_autoAC.cpp
new file mode 100644
index 0000000..4878294
--- /dev/null
+++ b/HDOJ/4711_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <map>
+using namespace std;
+#define MP(x,y) make_pair(x,y)
+const int MAXN= 110;
+const double EPS = 1e-14;
+const double INF = 1e50;
+long double dp[1010][MAXN];
+int fa[1010][MAXN],ord[1010];
+double pm[MAXN][MAXN],pw[MAXN][MAXN];
+int main()
+{
+    int ncase,n,m,w;
+    scanf("%d",&ncase);
+    while(ncase--)
+    {
+        scanf("%d%d%d",&n,&m,&w);
+        for(int i=0;i<n;++i)    scanf("%d",&ord[i]);
+        for(int i=0;i<m;++i)
+            for(int j=0;j<m;++j)
+            {
+                scanf("%lf",&pm[i][j]);
+                if(pm[i][j]>EPS)
+                    pm[i][j]=log(pm[i][j]);
+                else    pm[i][j]=-INF;
+            }
+        for(int i=0;i<m;++i)
+            for(int j=0;j<w;++j)
+            {
+                scanf("%lf",&pw[i][j]);
+                if(pw[i][j]>EPS)
+                    pw[i][j]=log(pw[i][j]);
+                else    pw[i][j]=-INF;
+            }
+        for(int i=0;i<m;++i)    dp[n-1][i]=pw[i][ord[n-1]];
+        for(int i=n-2;i>=0;--i)
+        {
+            for(int j=0;j<m;++j)    dp[i][j]=-INF;
+            for(int j=0;j<m;++j)
+                if(pw[j][ord[i]]>-INF+EPS)
+                    for(int k=0;k<m;++k)
+                        if(pm[j][k]>-INF+EPS&&dp[i][j]+EPS<dp[i+1][k]+pm[j][k]+pw[j][ord[i]])
+                            dp[i][j]=dp[i+1][k]+pm[j][k]+pw[j][ord[i]],fa[i][j]=k;
+        }
+        int pos=0;
+        long double best=-INF;
+        for(int i=0;i<m;++i)
+            if(best+EPS<dp[0][i]+pm[0][i])
+                best=dp[0][i]+pm[0][i],pos=i;
+        printf("%d",pos);
+        for(int i=0;i<n-1;++i)
+            printf(" %d",pos=fa[i][pos]);
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4712_autoAC.cpp b/HDOJ/4712_autoAC.cpp
new file mode 100644
index 0000000..20a38ad
--- /dev/null
+++ b/HDOJ/4712_autoAC.cpp
@@ -0,0 +1,75 @@
+#include<algorithm>
+#include<iostream>
+#include<cstring>
+#include<cstdlib>
+#include<fstream>
+#include<sstream>
+#include<bitset>
+#include<vector>
+#include<string>
+#include<cstdio>
+#include<cmath>
+#include<stack>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#define FF(i, a, b) for(int i=a; i<b; i++)
+#define FD(i, a, b) for(int i=a; i>=b; i--)
+#define REP(i, n) for(int i=0; i<n; i++)
+#define CLR(a, b) memset(a, b, sizeof(a))
+#define LL long long
+#define PB push_back
+#define eps 1e-10
+using namespace std;
+const int maxn = 100010;
+const int INF = (1<<21) + 10;
+int T, n, a[maxn];
+int has[INF];
+char ch[10];
+int calc(char *ch)
+{
+    int ret = 0;
+    REP(i, 5)
+    {
+        if(isupper(ch[i])) ret = ret*16 + (ch[i]-'A') + 10;
+        else ret = ret*16 + (ch[i]-'0');
+    }
+    return ret;
+}
+bool dfs(int val, int now, int len, int num)
+{
+    if(len == num)
+    {
+        REP(i, n) if(has[a[i]^val] == T) return true;
+        return false;
+    }
+    FF(i, now, 21) if(dfs(val+(1<<i), i+1, len+1, num)) return true;
+    return false;
+}
+int main()
+{
+    int ncas;
+    scanf("%d", &ncas);
+    for(T=1; T<=ncas; T++)
+    {
+        scanf("%d", &n);
+        bool flag = 0;
+        REP(i, n)
+        {
+            scanf("%s", ch);
+            a[i] = calc(ch);
+            if(has[a[i]] == T) flag = 1;
+            has[a[i]] = T;
+        }
+        if(flag)
+        {
+            puts("0");
+            continue;
+        }
+        int ans = 1;
+        while(!dfs(0, 0, 0, ans)) ans++;
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4713_autoAC.cpp b/HDOJ/4713_autoAC.cpp
new file mode 100644
index 0000000..376086a
--- /dev/null
+++ b/HDOJ/4713_autoAC.cpp
@@ -0,0 +1 @@
+p(p(....p(i)...)) = i
diff --git a/HDOJ/4714_autoAC.cpp b/HDOJ/4714_autoAC.cpp
new file mode 100644
index 0000000..9434dcc
--- /dev/null
+++ b/HDOJ/4714_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<iostream>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<string>
+#include<queue>
+#include<algorithm>
+#include<map>
+#include<iomanip>
+#define INF 99999999
+using namespace std;
+#pragma comment(linker,"/STACK:102400000,102400000")
+const int MAX=1000000+10;
+int head[MAX],size,sum=0; 
+struct Edge{
+    int v,next;
+    Edge(){}
+    Edge(int V,int NEXT):v(V),next(NEXT){}
+}edge[MAX*2];
+void Init(int num){
+    memset(head,-1,sizeof(int)*(num+1));
+    size=sum=0;
+}
+void InsertEdge(int u,int v){
+    edge[size]=Edge(v,head[u]);
+    head[u]=size++;
+}
+int dfs(int u,int father){
+    int num=0,v;
+    for(int i=head[u];i != -1;i=edge[i].next){
+        int v=edge[i].v;
+        if(v == father)continue;
+        num+=dfs(v,u);
+    }
+    if(num>=2){
+        if(u == 1)sum+=num-2;
+        else sum+=num-1;
+        return 0;
+    }else return 1;
+}
+int main(){
+    int t,n,u,v;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        Init(n);
+        for(int i=1;i<n;++i){
+            scanf("%d%d",&u,&v);
+            InsertEdge(u,v);
+            InsertEdge(v,u);
+        }
+        dfs(1,0);
+        printf("%d\n",sum*2+1);
+    }
+    return 0;
+}
diff --git a/HDOJ/4715_autoAC.cpp b/HDOJ/4715_autoAC.cpp
new file mode 100644
index 0000000..685bb2c
--- /dev/null
+++ b/HDOJ/4715_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+#define MAX 1000005
+int is_prime[MAX];
+int num[MAX];
+int len;
+void Init() {
+    memset(is_prime, 1, sizeof(is_prime));
+    is_prime[0] = is_prime[1] = 0;
+    for(int i=2; i<sqrt(MAX*1.0); i++) {
+        if(is_prime[i]) {
+            for(int j=i*i; j<MAX; j+=i) {
+                is_prime[j] = 0;
+            }
+        }
+    }
+    len = 0;
+    for(int i=2; i<MAX; i++) {
+        if(is_prime[i])
+            num[len++] = i;
+    }
+}
+int main() {
+    int t;
+    Init();
+    scanf("%d",&t);
+    while(t--) {
+        int n;
+        scanf("%d", &n);
+        if(!n) puts("2 2");
+        else if(n<0) {
+            n = -1*n;
+            int flag = 0;
+            for(int i=0; i<len; i++) {
+                if(is_prime[num[i]+n]) {
+                    flag = 1;
+                    printf("%d %d\n", num[i], num[i]+n);
+                    break;
+                }
+            }
+            if(!flag) printf("FAIL\n");
+        }
+        else {
+            int flag = 0;
+            for(int i=0; i<len; i++) {
+                if(is_prime[num[i]+n]) {
+                    flag = 1;
+                    printf("%d %d\n", num[i]+n, num[i]);
+                    break;
+                }
+            }
+            if(!flag) printf("FAIL\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4716_autoAC.cpp b/HDOJ/4716_autoAC.cpp
new file mode 100644
index 0000000..20aab19
--- /dev/null
+++ b/HDOJ/4716_autoAC.cpp
@@ -0,0 +1,12 @@
+*------------*
+|............|
+|............|
+|............|
+|............|
+|............|
+|............|
+|............|
+|............|
+|............|
+|............|
+*------------*
diff --git a/HDOJ/4717_autoAC.cpp b/HDOJ/4717_autoAC.cpp
new file mode 100644
index 0000000..0117ecc
--- /dev/null
+++ b/HDOJ/4717_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+const double eps=1e-14;
+const int maxn=303;
+int n;
+struct node{
+    double x,y,vx,vy;
+}e[maxn*maxn];
+double cross(node a,node b,double t)
+{
+    return (a.x+a.vx*t-b.x-b.vx*t)*(a.x+a.vx*t-b.x-b.vx*t)+(a.y+a.vy*t-b.y-b.vy*t)*(a.y+a.vy*t-b.y-b.vy*t);
+}
+double find(double t)
+{
+    double ans=0;
+    int i,j;
+    for(i=0;i<n;i++)
+    for(j=i+1;j<n;j++)
+        ans=max(ans,cross(e[i],e[j],t));
+    return ans;
+}
+int main()
+{
+    int T,tt=0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int i,j,k;
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+        scanf("%lf%lf%lf%lf",&e[i].x,&e[i].y,&e[i].vx,&e[i].vy);
+        double l,r,m1,m2;
+        l=0,r=1e8;
+        for(i=0;i<100;i++)
+        {
+            m1=l+(r-l)/3;
+            m2=r-(r-l)/3;
+            if(find(m1)<find(m2)) r=m2;
+            else l=m1;
+        }
+        printf("Case #%d: %.2lf %.2lf\n",++tt,l,sqrt(find(l)));
+    }
+    return 0;
+}
diff --git a/HDOJ/4718_autoAC.cpp b/HDOJ/4718_autoAC.cpp
new file mode 100644
index 0000000..08ea028
--- /dev/null
+++ b/HDOJ/4718_autoAC.cpp
@@ -0,0 +1,178 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define MAXN 100005
+int anc[MAXN][17];
+int LL[MAXN][17][2], RR[MAXN][17][2];
+int ans[MAXN][17][2];
+int dep[MAXN];
+struct EDGE
+{
+    EDGE() {}
+    EDGE(int _to, int _next) { to = _to, next = _next; }
+    int to, next;
+}edge[MAXN];
+int edgecnt, head[MAXN];
+void init()
+{
+    memset(anc, -1, sizeof(anc));
+    memset(head, -1, sizeof(head));
+    edgecnt = 0;
+}
+void add(int s, int t)
+{
+    edge[edgecnt] = EDGE(t, head[s]);
+    head[s] = edgecnt++;
+}
+int val[MAXN];
+void dfs(int u, int fa, int deep)
+{
+    anc[u][0] = fa;
+    dep[u] = deep;
+    if (val[u] < val[fa])
+    {
+        LL[u][0][0] = 2;
+        LL[u][0][1] = 1;
+        RR[u][0][0] = 2;
+        RR[u][0][1] = 1;
+        ans[u][0][0] = 2;
+        ans[u][0][1] = 1;
+    }
+    else if (val[u]>val[fa])
+    {
+        LL[u][0][0] = 1;
+        LL[u][0][1] = 2;
+        RR[u][0][0] = 1;
+        RR[u][0][1] = 2;
+        ans[u][0][0] = 1;
+        ans[u][0][1] = 2;
+    }
+    else
+    {
+        LL[u][0][0] = LL[u][0][1] = RR[u][0][0] = RR[u][0][1] = ans[u][0][0] = ans[u][0][1] = 1;
+    }
+    for (int i = head[u]; ~i; i = edge[i].next) dfs(edge[i].to, u, deep + 1);
+}
+void process(int n)
+{
+    for (int j = 0; j < 16; j++)
+        for (int i = 1; i <= n; i++)
+        {
+            if (dep[anc[i][j]]>(1 << j))
+            {
+                anc[i][j + 1] = anc[anc[i][j]][j];
+                int A = anc[i][j];
+                int len = (1 << j) + 1;
+                if (LL[i][j][0] == len) LL[i][j + 1][0] = len - 1 + LL[A][j][0];
+                else LL[i][j + 1][0] = LL[i][j][0];
+                if (RR[A][j][0] == len) RR[i][j + 1][0] = len - 1 + RR[i][j][0];
+                else RR[i][j + 1][0] = RR[A][j][0];
+                if (LL[i][j][1] == len) LL[i][j + 1][1] = len - 1 + LL[A][j][1];
+                else LL[i][j + 1][1] = LL[i][j][1];
+                if (RR[A][j][1] == len) RR[i][j + 1][1] = len - 1 + RR[i][j][1];
+                else RR[i][j + 1][1] = RR[A][j][1];
+                ans[i][j + 1][0] = max(ans[i][j][0], ans[A][j][0]);
+                ans[i][j + 1][0] = max(ans[i][j + 1][0], RR[i][j][0] + LL[A][j][0] - 1);
+                ans[i][j + 1][1] = max(ans[i][j][1], ans[A][j][1]);
+                ans[i][j + 1][1] = max(ans[i][j + 1][1], RR[i][j][1] + LL[A][j][1] - 1);
+            }
+        }
+}
+int lca(int u, int v)
+{
+    if (dep[u] < dep[v]) swap(u, v);
+    for (int i = 16; i >= 0; i--) if (dep[u] - (1 << i) >= dep[v]) u = anc[u][i];
+    if (u == v) return u;
+    for (int i = 16; i >= 0; i--)
+        if (anc[u][i] != anc[v][i])
+        {
+            u = anc[u][i];
+            v = anc[v][i];
+        }
+    return anc[u][0];
+}
+int getans(int u, int v)
+{
+    int l = lca(u, v);
+    int Ru = 1, ansu = 1;
+    bool first = 1;
+    for (int i = 16; i >= 0; i--)
+        if (dep[u] - (1 << i) >= dep[l])
+        {
+            if (first)
+            {
+                Ru = RR[u][i][0];
+                ansu = ans[u][i][0];
+                first = 0;
+                u = anc[u][i];
+                continue;
+            }
+            ansu = max(ansu, ans[u][i][0]);
+            ansu = max(ansu, Ru + LL[u][i][0] - 1);
+            int len = (1 << i) + 1;
+            if (len == RR[u][i][0]) Ru += RR[u][i][0] - 1;
+            else Ru = RR[u][i][0];
+            u = anc[u][i];
+        }
+    int Rv = 1, ansv = 1;
+    first = 1;
+    for (int i = 16; i >= 0; i--)
+        if (dep[v] - (1 << i) >= dep[l])
+        {
+            if (first)
+            {
+                Rv = RR[v][i][1];
+                ansv = ans[v][i][1];
+                first = 0;
+                v = anc[v][i];
+                continue;
+            }
+            ansv = max(ansv, ans[v][i][1]);
+            ansv = max(ansv, Rv + LL[v][i][1] - 1);
+            int len = (1 << i) + 1;
+            if (len == RR[v][i][1]) Rv += RR[v][i][1] - 1;
+            else Rv = RR[v][i][1];
+            v = anc[v][i];
+        }
+    int ans = max(ansu, ansv);
+    ans = max(ans, Ru + Rv - 1);
+    return ans;
+}
+int main()
+{
+    int T;
+    int ks = 0;
+    scanf("%d", &T);
+    bool ok = 0;
+    while (T--)
+    {
+        if (ok != 0)
+        {
+            puts("");
+        }
+        ok = 1;
+        printf("Case #%d:\n", ++ks);
+        int n;
+        scanf("%d", &n);
+        init();
+        for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
+        for (int i = 2; i <= n; i++)
+        {
+            int s;
+            scanf("%d", &s);
+            add(s, i);
+        }
+        dfs(1, -1, 1);
+        process(n);
+        int Q;
+        scanf("%d", &Q);
+        while (Q--)
+        {
+            int u, v;
+            scanf("%d %d", &u, &v);
+            printf("%d\n", getans(u, v));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4719_autoAC.cpp b/HDOJ/4719_autoAC.cpp
new file mode 100644
index 0000000..83f14fa
--- /dev/null
+++ b/HDOJ/4719_autoAC.cpp
@@ -0,0 +1,3 @@
+ o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   o
+/F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\ /F\
+/ \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \
diff --git a/HDOJ/4721_autoAC.cpp b/HDOJ/4721_autoAC.cpp
new file mode 100644
index 0000000..8cbbc9c
--- /dev/null
+++ b/HDOJ/4721_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <set>
+#include <map>
+#include <vector>
+#include <queue>
+#include <stack>
+#define lson step << 1
+#define rson step << 1 | 1
+#define lowbit(x) (x & (-x))
+#define Key_value ch[ch[root][1]][0] 
+using namespace std;
+typedef long long LL;
+const int N = 505;
+int n , m , r , q;
+int food[N][N] , prod[N][N];
+int a[N * N] , b[N * N] , tot , x[N * N];
+int s[N * N] , cnt;
+void add (int x , int v) {
+    for (int i = x ; i <= cnt ; i += lowbit (i)) {
+        s[i] = max (s[i] , v);
+    }
+}
+int ask (int x) {
+    int ret = 0;
+    for (int i = x ; i > 0 ; i -= lowbit (i)) {
+        ret = max (ret , s[i]);
+    }
+    return ret;
+}
+int main () {
+    int t , cas = 0;
+    scanf ("%d" , &t);
+    while (t --) {
+        memset (food , 0 , sizeof(food));
+        memset (prod , 0 , sizeof(prod));
+        memset (s , 0 , sizeof(s));
+        scanf ("%d %d %d %d" , &n , &m , &r , &q);
+        for (int i = 1 ; i <= n ; i ++) {
+            for (int j = 1 ; j <= m ; j ++) {
+                scanf ("%d" , &food[i][j]);
+                food[i][j] += food[i - 1][j] + food[i][j - 1] - food[i - 1][j - 1];
+            }
+        }
+        for (int i = 1 ; i <= n ; i ++) {
+            for (int j = 1 ; j <= m ; j ++) {
+                scanf ("%d" , &prod[i][j]);
+                prod[i][j] += prod[i - 1][j] + prod[i][j - 1] - prod[i - 1][j - 1];
+            }
+        }
+        tot = 0;
+        r = 2 * r + 1;
+        for (int i = r ; i <= n ; i ++) {
+            for (int j = r ; j <= m ; j ++) {
+                a[tot] = food[i][j] - food[i][j - r] - food[i - r][j] + food[i - r][j - r];
+                b[tot] = prod[i][j] - prod[i][j - r] - prod[i - r][j] + prod[i - r][j - r];
+                x[tot] = a[tot];
+                tot ++;
+            }
+        }
+        sort (x , x + tot);
+        cnt = unique (x , x + tot) - x;
+        for (int i = 0 ; i < tot ; i ++) {
+            int y = cnt - (lower_bound (x , x + cnt , a[i]) - x);
+            add (y , b[i]);
+        }
+        printf ("Case #%d:\n" , ++ cas);
+        while (q --) {
+            int A , B;
+            scanf ("%d %d" , &A , &B);
+            int low = min (A , B) + r * r * 1 , high = min (A , B) + r * r * 3 , mid , ans;
+            while (low <= high) {
+                mid = (low + high) >> 1;
+                int y = cnt - (lower_bound (x , x + cnt , mid - A) - x);
+                if (y < 1) {
+                    high = mid - 1;
+                    continue;
+                }
+                int tmp = ask (y);
+                if (tmp + B >= mid) {
+                    ans = mid;
+                    low = mid + 1;
+                }
+                else high = mid - 1;
+            }
+            printf ("%d\n" , ans);
+        }
+        if (t) puts ("");
+    }
+    return 0;
+}
diff --git a/HDOJ/4722_autoAC.cpp b/HDOJ/4722_autoAC.cpp
new file mode 100644
index 0000000..2966063
--- /dev/null
+++ b/HDOJ/4722_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+__int64 bit[20];
+__int64 dp[20][10];
+__int64 solve(__int64 n)
+{
+    __int64 ans;
+    __int64 tem1 = n,len,sum,i,x,j,k;
+    len = sum = ans = 0;
+    memset(dp,0,sizeof(dp));
+    while(tem1)
+    {
+        bit[++len] = tem1%10;
+        tem1/=10;
+    }
+    for(i = 1; i<=len/2; i++)
+    {
+        int t;
+        t = bit[i];
+        bit[i] = bit[len-i+1];
+        bit[len-i+1] = t;
+    }
+    x = 0;
+    for(i = 1; i<=len; i++)
+    {
+        for(j = 0; j<10; j++)
+            for(k = 0; k<10; k++)
+                dp[i][(j+k)%10]+=dp[i-1][j];
+        for(j = 0; j<bit[i]; j++)
+            dp[i][(x+j)%10]++;
+        x = (x+bit[i])%10;
+    }
+    if(!x)
+        dp[len][0]++;
+    return dp[len][0];
+}
+int main()
+{
+    __int64 T,l,r,cas = 1;
+    __int64 ans;
+    scanf("%I64d",&T);
+    while(T--)
+    {
+        ans = 0;
+        scanf("%I64d%I64d",&l,&r);
+        ans = solve(r)-solve(l-1);
+        printf("Case #%I64d: %I64d\n",cas++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4723_autoAC.cpp b/HDOJ/4723_autoAC.cpp
new file mode 100644
index 0000000..43ec8a2
--- /dev/null
+++ b/HDOJ/4723_autoAC.cpp
@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <cmath>
+#define maxn 100010
+double a[maxn],b[maxn],up,down,ans,g;
+int n,m,x,y;
+int main(){
+    int i,j,k,t,cas=0;
+    scanf("%d",&t);
+    while(t--){
+        ans=0;
+        scanf("%lf%lf",&up,&down);
+        g=(up-down)*(up-down);
+        scanf("%d%d",&n,&m);
+        for(i=0;i<n;i++)
+        scanf("%lf",&a[i]);
+        for(i=0;i<m;i++)
+        scanf("%lf",&b[i]);
+        x=0,y=0;
+        while(x<n && y < m){
+            ans+=sqrt(g+(a[x]-b[y])*(a[x]-b[y]));
+            if(x==n-1) y++;
+            else if(y==m-1) x++;
+            else{
+                if(fabs(a[x]-b[y+1]) < fabs(b[y]-a[x+1]))
+                y++;
+                else x++;
+            }
+        }
+        printf("Case #%d: %.2lf\n",++cas,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4724_autoAC.cpp b/HDOJ/4724_autoAC.cpp
new file mode 100644
index 0000000..269a2bb
--- /dev/null
+++ b/HDOJ/4724_autoAC.cpp
@@ -0,0 +1 @@
+    g++ a.o b.o -o main
diff --git a/HDOJ/4725_autoAC.cpp b/HDOJ/4725_autoAC.cpp
new file mode 100644
index 0000000..ec9d797
--- /dev/null
+++ b/HDOJ/4725_autoAC.cpp
@@ -0,0 +1,100 @@
+#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 INF=0x3f3f3f3f;
+const int MAXN=1000010;
+struct qnode
+{
+    int v;
+    int c;
+    qnode(int _v=0,int _c=0):v(_v),c(_c){}
+    bool operator <(const qnode &r)const
+    {
+        return c>r.c;
+    }
+};
+struct Edge
+{
+    int v,cost;
+    Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
+};
+vector<Edge>E[MAXN];
+bool vis[MAXN];
+int dist[MAXN];
+void Dijkstra(int n,int start)
+{
+    memset(vis,false,sizeof(vis));
+    for(int i=1;i<=n;i++)dist[i]=INF;
+    priority_queue<qnode>que;
+    while(!que.empty())que.pop();
+    dist[start]=0;
+    que.push(qnode(start,0));
+    qnode tmp;
+    while(!que.empty())
+    {
+        tmp=que.top();
+        que.pop();
+        int u=tmp.v;
+        if(vis[u])continue;
+        vis[u]=true;
+        for(int i=0;i<E[u].size();i++)
+        {
+            int v=E[tmp.v][i].v;
+            int cost=E[u][i].cost;
+            if(!vis[v]&&dist[v]>dist[u]+cost)
+            {
+                dist[v]=dist[u]+cost;
+                que.push(qnode(v,dist[v]));
+            }
+        }
+    }
+}
+void addedge(int u,int v,int w)
+{
+    E[u].push_back(Edge(v,w));
+}
+int main()
+{
+    int T;
+    int N,M,C;
+    scanf("%d",&T);
+    int iCase = 0;
+    while(T--)
+    {
+        scanf("%d%d%d",&N,&M,&C);
+        for(int i = 1;i <= 3*N;i++) E[i].clear();
+        int u,v,w;
+        for(int i = 1;i <= N;i++)
+        {
+            scanf("%d",&u);
+            addedge(i,N + 2*u - 1,0);
+            addedge(N + 2*u ,i,0);
+        }
+        for(int i = 1;i < N;i++)
+        {
+            addedge(N + 2*i-1,N + 2*(i+1),C);
+            addedge(N + 2*(i+1)-1,N + 2*i,C);
+        }
+        while(M--)
+        {
+            scanf("%d%d%d",&u,&v,&w);
+            addedge(u,v,w);
+            addedge(v,u,w);
+        }
+        Dijkstra(3*N,1);
+        iCase++;
+        if(dist[N] == INF)dist[N] = -1;
+        printf("Case #%d: %d\n",iCase,dist[N]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4726_autoAC.cpp b/HDOJ/4726_autoAC.cpp
new file mode 100644
index 0000000..d1a179b
--- /dev/null
+++ b/HDOJ/4726_autoAC.cpp
@@ -0,0 +1,91 @@
+#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[20];
+int b[20];
+char A[2000020],B[2000020];
+int num1[2000020],num2[2000020];
+int ans[2000020];
+int main()
+{
+    int T;
+    int iCase = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%s%s",A,B);
+        int n = strlen(A);
+        for(int i = 0;i < n;i++)
+        {
+            num1[i] = A[i] - '0';
+            num2[i] = B[i] - '0';
+        }
+        if(n == 1)
+        {
+            printf("Case #%d: %d\n",iCase,(num1[0]+num2[0])%10);
+            continue;
+        }
+        memset(a,0,sizeof(a));
+        memset(b,0,sizeof(b));
+        for(int i = 0;i < n;i++)
+        {
+            a[num1[i]] ++;
+            b[num2[i]] ++;
+        }
+        int x = 0, y = 0;
+        int ttt = -1;
+        for(int i = 1;i <= 9;i++)
+            for(int j = 1;j <= 9;j++)
+                if(a[i] && b[j] && ((i+j)%10) > ttt )
+                {
+                    x = i;
+                    y = j;
+                    ttt = (x+y)%10;
+                }
+        a[x]--;
+        b[y]--;
+        int cnt = 0;
+        ans[cnt++] = (x+y)%10;
+        for(int p = 9;p >= 0;p--)
+        {
+            for(int i = 0;i <= 9;i++)
+                if(a[i])
+                {
+                    if(i <= p)
+                    {
+                        int j = p-i;
+                        int k = min(a[i],b[j]);
+                        a[i] -= k;
+                        b[j] -= k;
+                        while(k--)
+                            ans[cnt++] = p;
+                    }
+                    int j = 10 + p - i;
+                    if(j > 9)continue;
+                    int k = min(a[i],b[j]);
+                    a[i] -= k;
+                    b[j] -= k;
+                    while(k--)
+                        ans[cnt++] = p;
+                }
+        }
+        printf("Case #%d: ",iCase);
+        int s = 0;
+        while(s < cnt-1 && ans[s] == 0)s++;
+        for(int i = s;i < cnt;i++)
+            printf("%d",ans[i]);
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4727_autoAC.cpp b/HDOJ/4727_autoAC.cpp
new file mode 100644
index 0000000..6cd70f4
--- /dev/null
+++ b/HDOJ/4727_autoAC.cpp
@@ -0,0 +1,37 @@
+#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[100010];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    int iCase = 0;
+    while(T--)
+    {
+        iCase++;
+        scanf("%d",&n);
+        for(int i = 0;i < n;i++)
+            scanf("%d",&a[i]);
+        int ans = 1;
+        for(int i = 1;i < n;i++)
+            if(a[i] != a[i-1] + 1)
+            {
+                ans = i+1;
+                break;
+            }
+        printf("Case #%d: %d\n",iCase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4730_autoAC.cpp b/HDOJ/4730_autoAC.cpp
new file mode 100644
index 0000000..56e5227
--- /dev/null
+++ b/HDOJ/4730_autoAC.cpp
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <string.h>
+int main() {
+    char a[120];
+    int t, tt = 0;
+    scanf("%d", &t);
+    while(t--) {
+        scanf("%s", a);
+        printf("Case #%d: ", ++tt);
+        int len = strlen(a);
+        if(a[len-1] == 'u' && a[len-2] == 's' && a[len-3] == 'e' && a[len-4] == 'd' &&
+           a[len-5] == 'o' && a[len-6] == 'n' && a[len-7] == 'a' && a[len-8] == 'n') {
+            printf("%s", a);
+        }
+        else if(a[len-1] == 'u' && a[len-2] == 's' && a[len-3] == 'e' && a[len-4] == 'd') {
+            for(int i=0; i<len-4; i++) {
+                printf("%c", a[i]);
+            }
+            printf("nanodesu\n");
+        }
+        else {
+            printf("%s", a);
+            printf("nanodesu\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4731_autoAC.cpp b/HDOJ/4731_autoAC.cpp
new file mode 100644
index 0000000..ba46fae
--- /dev/null
+++ b/HDOJ/4731_autoAC.cpp
@@ -0,0 +1,71 @@
+#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;
+char str[10000];
+int main()
+{
+    int T;
+    int m,n;
+    int iCase = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&m,&n);
+        iCase++;
+        printf("Case #%d: ",iCase);
+        if(m == 1)
+        {
+            for(int i = 0;i < n;i++)printf("a");
+            printf("\n");
+            continue;
+        }
+        if(m >= 3)
+        {
+            int index = 0;
+            for(int i = 0;i < n;i++)
+            {
+                printf("%c",index + 'a');
+                index = (index + 1)%3;
+            }
+            printf("\n");
+            continue;
+        }
+        if(n == 1)printf("a");
+        else if(n == 2)printf("ab");
+        else if(n == 3)printf("aab");
+        else if(n == 4)printf("aabb");
+        else if(n == 5)printf("aaaba");
+        else if(n == 6)printf("aaabab");
+        else if(n == 7)printf("aaababb");
+        else if(n == 8)printf("aaababbb");
+        else if(n == 9)printf("aaaababba");
+        else
+        {
+            printf("aaaa");
+            n -= 4;
+            while(n >= 6)
+            {
+                printf("babbaa");
+                n -= 6;
+            }
+            if(n == 1)printf("a");
+            else if(n == 2)printf("aa");
+            else if(n == 3)printf("bab");
+            else if(n == 4)printf("babb");
+            else if(n == 5)printf("babba");
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4732_autoAC.cpp b/HDOJ/4732_autoAC.cpp
new file mode 100644
index 0000000..ce4a88a
--- /dev/null
+++ b/HDOJ/4732_autoAC.cpp
@@ -0,0 +1,124 @@
+#include <set>
+#include <map>
+#include <vector>
+#include <algorithm>
+#include <cstdio>
+#include <iostream>
+using namespace std;
+typedef long long LL;
+typedef pair<int,int> PII;
+#define MP make_pair
+#define PB push_back
+#define AA first
+#define BB second
+#define OP begin()
+#define ED end()
+#define SZ size()
+#define cmin(x,y) x=min(x,y)
+#define cmax(x,y) x=max(x,y)
+const LL MOD = 1000000007;
+const int MXN = 200005;
+int mu[MXN], p[MXN], pn;
+bool flag[MXN];
+void init(int n=MXN-5) {
+    pn = 0;
+    mu[1] = 1;
+    for(int i = 2; i <= n; i++) {
+        if(!flag[i]) {
+            p[pn ++ ] = i;
+            mu[i] = -1;                     
+        }
+        for(int j = 0; j < pn && i * p[j] <= n; j++) {
+            flag[i * p [j]] = true;
+            if(i % p[j] == 0) {
+                mu[i * p[j]] = 0;         
+                break;
+            } else  mu[i * p[j]] = -mu[i];  
+        }
+    }
+}
+LL inv[200005];
+LL fact[200005];
+LL ifac[200005];
+LL comb(LL a,LL b){
+    return fact[a]*ifac[b]%MOD*ifac[a-b]%MOD;
+}
+LL play(int n,int m){
+    return comb(n+m-1,n-1);
+}
+int N,M,K,n;
+LL solve(int n,int M){
+    LL ans=0;
+    for(int i=0;i<=n&&i*K<=M;i++){
+        LL mul=comb(n,i);
+        LL add=play(n,M-i*K);
+        if(i&1)ans-=mul*add%MOD;
+        else ans+=mul*add%MOD;
+    }
+    return ans%MOD;
+}
+LL g(int x){
+    int d=n/x;
+    if(M%d)return 0;
+    return solve(x,M/d);
+}
+LL gao(int x){
+    int y=x;
+    vector<int>L;
+    for(int i=2;i*i<=x;i++)if(x%i==0){
+        L.PB(i);
+        while(x%i==0)x/=i;
+    }
+    if(x>1)L.PB(x);
+    x=y;
+    LL ret=0;
+    for(int i=0;i<1<<L.SZ;i++){
+        int d=1,mu=1;
+        for(int j=0;j<L.SZ;j++)if(i>>j&1)
+            d*=L[j],mu=-mu;
+        ret+=mu*inv[d];
+    }
+    return ret%MOD;
+}
+int main(){
+    init();
+    int i,j,_T;
+    for(inv[0]=inv[1]=1,i=2;i<=200001;i++)
+        inv[i]=inv[MOD%i]*(MOD-MOD/i)%MOD;
+    for(fact[0]=i=1;i<=200001;i++)
+        fact[i]=fact[i-1]*i%MOD;
+    for(ifac[0]=i=1;i<=200001;i++)
+        ifac[i]=ifac[i-1]*inv[i]%MOD;
+    scanf("%d",&_T);
+    for(int CA=1;CA<=_T;CA++){
+        scanf("%d%d%d",&N,&M,&K);
+        printf("Case #%d: ",CA);
+        n=N-M;
+        if(n==0)printf("%d\n",N>=K?0:1);
+        else {
+            int gg=__gcd(n,M);
+            set<int>SD;
+            for(i=1;i*i<=gg;i++)if(gg%i==0)
+                SD.insert(i),SD.insert(gg/i);
+            vector<int>D(SD.OP,SD.ED);
+            LL ans=0;
+            map<int,LL>W;
+            for(i=0;i<D.SZ;i++){
+                int u=D[i],v=n/u;
+                for(int w=1;w*w<=v;w++)if(v%w==0){
+                    int d=w;
+                    W[d]+=inv[v]*mu[v/d];
+                    if(w*w!=v){
+                        d=v/w;
+                        W[d]+=inv[v]*mu[v/d];
+                    }
+                }
+            }
+            for(map<int,LL>::iterator it=W.OP;it!=W.ED;++it)
+                ans+=(*it).BB%MOD*g((*it).AA);
+            ans=(ans%MOD+MOD)%MOD;
+            printf("%d\n",int(ans));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4733_autoAC.cpp b/HDOJ/4733_autoAC.cpp
new file mode 100644
index 0000000..23446e0
--- /dev/null
+++ b/HDOJ/4733_autoAC.cpp
@@ -0,0 +1,149 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<stack>
+#include<cmath>
+#include<vector>
+#include<bitset>
+#define inf 0x3f3f3f3f
+#define Inf 0x3FFFFFFFFFFFFFFFLL
+#define eps 1e-6
+#define pi acos(-1.0)
+using namespace std;
+typedef long long ll;
+const int maxn=100000+10;
+const int mod=1000000000+7;
+char A[maxn],B[maxn];
+int n,lsts[maxn][2],zero[maxn];
+ll dp[maxn][2];
+bool check(int i)
+{
+    return (i+1>n)||(A[i+1]!='0'&&B[i+1]!='0'&&zero[i+2]);
+}
+void solve()
+{
+    lsts[0][0]=dp[0][0]=1;
+    lsts[0][1]=dp[0][1]=0;
+    for(int i=1;i<=n;++i)
+    {
+        if(A[i]=='?'&&B[i]=='?')
+        {
+            dp[i][0]=(dp[i-1][0]+dp[i-1][1])%mod;
+            dp[i][1]=(dp[i-1][0]+dp[i-1][1])%mod;
+            lsts[i][0]=lsts[i-1][0]+lsts[i-1][1];
+            lsts[i][1]=lsts[i-1][0]+lsts[i-1][1];
+            if(lsts[i][0]>2) lsts[i][0]=2;
+            if(lsts[i][1]>2) lsts[i][1]=2;
+        }
+        else if(A[i]=='?'||B[i]=='?'||(A[i]==B[i]))
+        {
+            if(A[i]=='0'||B[i]=='0')
+            {
+                dp[i][0]=dp[i-1][0];
+                dp[i][1]=dp[i-1][1];
+                lsts[i][0]=lsts[i-1][0];
+                lsts[i][1]=lsts[i-1][1];
+            }
+            else
+            {
+                dp[i][0]=dp[i-1][1];
+                dp[i][1]=dp[i-1][0];
+                lsts[i][0]=lsts[i-1][1];
+                lsts[i][1]=lsts[i-1][0];
+            }
+        }
+        else
+        {
+            dp[i][0]=dp[i][1]=0;
+            lsts[i][0]=lsts[i][1]=0;
+        }
+    }
+    zero[n+1]=1;
+    for(int i=n;i>=1;--i)
+    {
+        if(A[i]=='1'||B[i]=='1')
+            zero[i]=0;
+        else zero[i]=zero[i+1];
+    }
+    ll sum=0,tmp;
+    int dt=0,pos=-1,dtmp;
+    for(int i=1;i<=n;++i)
+    {
+        if(A[i]=='?'&&B[i]=='?')
+        {
+            tmp=(dp[i-1][0]+dp[i-1][1])%mod;
+            dtmp=lsts[i-1][0]+lsts[i-1][1];
+            if(dtmp&&check(i))
+            {
+                pos=i;
+                sum=(sum+tmp)%mod;
+                dt+=dtmp;
+                if(dt>2) dt=2;
+            }
+        }
+        else if(A[i]=='?'||B[i]=='?'||(A[i]!=B[i]))
+        {
+            if(A[i]=='0'||B[i]=='1')
+            {
+                tmp=dp[i-1][0];
+                dtmp=lsts[i-1][0];
+            }
+            else
+            {
+                tmp=dp[i-1][1];
+                dtmp=lsts[i-1][1];
+            }
+            if(dtmp&&check(i))
+            {
+                pos=i;
+                sum=(sum+tmp)%mod;
+                dt+=dtmp;
+                if(dt>2) dt=2;
+            }
+        }
+    }
+    if(dt==0) printf("Impossible\n");
+    else if(dt>1) printf("Ambiguous %I64d\n",sum);
+    else
+    {
+        for(int i=pos+1;i<=n;++i)
+            A[i]='1',B[i]='0';
+        char ch,last;
+        if(A[pos]=='0'||B[pos]=='1') ch='0';
+        else ch='1';
+        A[pos]='0';B[pos]='1';
+        for(int i=pos-1;i>=1;--i)
+        {
+            last=ch;
+            if(A[i]=='1'||B[i]=='1') ch=(ch=='0')?'1':'0';
+            A[i]=B[i]=last;
+        }
+        for(int i=n;i>1;--i)
+        {
+            if(A[i-1]==A[i]) A[i]='0';
+            else A[i]='1';
+            if(B[i-1]==B[i]) B[i]='0';
+            else B[i]='1';
+        }
+        printf("%s\n",A+1);
+        printf("%s\n",B+1);
+    }
+}
+int main()
+{
+    int t,tcase=0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%s",A+1);
+        scanf("%s",B+1);
+        n=strlen(A+1);
+        printf("Case #%d:\n",++tcase);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4734_autoAC.cpp b/HDOJ/4734_autoAC.cpp
new file mode 100644
index 0000000..01048e4
--- /dev/null
+++ b/HDOJ/4734_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+int dp[10][200000], mx[10];
+int dfs(int len, int pre, bool flag)
+{
+    if (len < 0) return pre >= 0;
+    if (pre < 0) return 0;
+    if (!flag && dp[len][pre] != -1) return dp[len][pre];
+    int end = flag?mx[len]:9, ans = 0;
+    for (int i = 0; i <= end; ++i) {
+        ans += dfs(len-1, pre-i*(1<<len), flag&&i==end);
+    }
+    if (!flag) dp[len][pre] = ans;
+    return ans;
+}
+int f(int x)
+{
+    int tmp = 1, ans = 0;
+    while (x) {
+        ans += x%10*tmp;
+        x /= 10;
+        tmp *= 2;
+    }
+    return ans;
+}
+int cal(int a, int b)
+{
+    int top = 0;
+    while (b) {
+        mx[top++] = b%10;
+        b /= 10;
+    }
+    return dfs(top-1, f(a), true);
+}
+int main()
+{
+    int iCase = 1, nCase;
+    int a, b;
+    scanf("%d", &nCase);
+    memset(dp, 0xff, sizeof(dp));
+    while (nCase--) {
+        scanf("%d %d", &a, &b);
+        printf("Case #%d: %d\n", iCase++, cal(a, b));
+    }
+    return 0;
+}
diff --git a/HDOJ/4735_autoAC.cpp b/HDOJ/4735_autoAC.cpp
new file mode 100644
index 0000000..35d93fb
--- /dev/null
+++ b/HDOJ/4735_autoAC.cpp
@@ -0,0 +1,224 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#define inf 0x3f3f3f
+using namespace std;
+const int maxn=60;
+const int maxr=maxn*maxn+maxn;
+int n,D;
+int child[maxn];
+int boys;
+bool flag;
+int map[maxn][maxn];
+void init_m()
+{
+    for(int i=0;i<=n;i++)
+        for(int j=0;j<=n;j++)
+        {
+            if(i==j)
+            {
+                map[i][j]=0;
+            }
+            else
+            {
+                map[i][j]=inf;
+            }
+        }
+}
+void floyd()
+{
+    for(int k=1;k<=n;k++)
+        for(int i=1;i<=n;i++)
+            for(int j=1;j<=n;j++)
+            {
+                if(map[i][k]+map[k][j]<map[i][j])
+                {
+                    map[i][j]=map[i][k]+map[k][j];
+                }
+            }
+}
+struct node
+{
+    int l,r;
+    int u,d;
+    int s,c;
+};
+node dlx[maxr];
+int h[maxn];
+int limit;
+int Q[maxn];
+int X[maxr];
+int has[maxn];
+int head,size;
+void init(int r,int c)
+{
+    head=0;
+    for(int i=0; i<=c; i++)
+    {
+        dlx[i].s=0;
+        dlx[i].u=dlx[i].d=i;
+        dlx[i].r=i+1;
+        dlx[i+1].l=i;
+    }
+    size=c;
+    dlx[c].r=0;
+    while(r)
+    {
+        h[r--]=-1;
+    }
+}
+void link(int r,int c)
+{
+    int tmp=++size;
+    dlx[c].s++;
+    dlx[tmp].c=c;
+    X[tmp]=r;
+    dlx[tmp].d=dlx[c].d;
+    dlx[tmp].u=c;
+    dlx[dlx[c].d].u=tmp;
+    dlx[c].d=tmp;
+    if(h[r]<0)
+    {
+        h[r]=dlx[tmp].l=dlx[tmp].r=tmp;
+    }
+    else
+    {
+        dlx[tmp].r=dlx[h[r]].r;
+        dlx[tmp].l=h[r];
+        dlx[dlx[h[r]].r].l=tmp;
+        dlx[h[r]].r=tmp;
+    }
+}
+void remove(int x)
+{
+    for(int i=dlx[x].d; i!=x; i=dlx[i].d)
+    {
+        dlx[dlx[i].r].l=dlx[i].l;
+        dlx[dlx[i].l].r=dlx[i].r;
+        dlx[dlx[i].c].s--;
+    }
+}
+void resume(int x)
+{
+    for(int i=dlx[x].u; i!=x; i=dlx[i].u)
+    {
+        dlx[dlx[i].r].l=i;
+        dlx[dlx[i].l].r=i;
+        dlx[dlx[i].c].s++;
+    }
+}
+int hh()
+{
+    int ret=0;
+    memset(has,0,sizeof(has));
+    for(int i=dlx[head].r; i!=head; i=dlx[i].r)
+    {
+        if(has[i]==false)
+        {
+            has[i]=true;
+            ret++;
+            for(int j=dlx[i].d; j!=i; j=dlx[j].d)
+            for(int k=dlx[j].r; k!=j; k=dlx[k].r)
+            {
+                has[dlx[k].c]=true;
+            }
+        }
+    }
+    return ret;
+}
+void dlx_dfs(int k)
+{
+    if(k+hh()>boys)
+    {
+        return;
+    }
+    int ssd=0;
+    for(int i=0;i<k;i++)
+    {
+        ssd+=child[Q[i]];
+    }
+    if(k-ssd>=limit) return;
+    if(dlx[head].r==head)
+    {
+        flag=true;
+        limit=k-ssd;
+        return;
+    }
+    int minn=n+2;
+    int tt;
+    for(int i=dlx[head].r; i!=head; i=dlx[i].r)
+    {
+        if(minn>dlx[i].s)
+        {
+            minn=dlx[i].s;
+            tt=i;
+        }
+    }
+    for(int i=dlx[tt].d; i!=tt; i=dlx[i].d)
+    {
+        Q[k]=X[i];
+        remove(i);
+        for(int j=dlx[i].r; j!=i; j=dlx[j].r)
+        {
+            remove(j);
+        }
+        dlx_dfs(k+1);
+        for(int j=dlx[i].l; j!=i; j=dlx[j].l)
+        {
+            resume(j);
+        }
+        resume(i);
+    }
+    return;
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    int cas=1;
+    while(t--)
+    {
+        printf("Case #%d: ",cas++);
+        scanf("%d%d",&n,&D);
+        boys=0;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&child[i]);
+            if(child[i]==1)
+            {
+                boys++;
+            }
+        }
+        init_m();
+        int a,b,c;
+        for(int i=0;i<n-1;i++)
+        {
+            scanf("%d%d%d",&a,&b,&c);
+            map[a][b]=c;
+            map[b][a]=c;
+        }
+        floyd();
+        init(n,n);
+        for(int i=1;i<=n;i++)
+            for(int j=1;j<=n;j++)
+            {
+                if(map[i][j]<=D)
+                {
+                    link(i,j);
+                }
+            }
+            flag=false;
+            limit=inf;
+        dlx_dfs(0);
+        if(!flag)
+        {
+            printf("-1\n");
+        }
+        else
+        {
+            printf("%d\n",limit);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4736_autoAC.cpp b/HDOJ/4736_autoAC.cpp
new file mode 100644
index 0000000..c58ccc6
--- /dev/null
+++ b/HDOJ/4736_autoAC.cpp
@@ -0,0 +1 @@
+                                                  - Kenneth Snow, The Hollow Bear
diff --git a/HDOJ/4737_autoAC.cpp b/HDOJ/4737_autoAC.cpp
new file mode 100644
index 0000000..85b335d
--- /dev/null
+++ b/HDOJ/4737_autoAC.cpp
@@ -0,0 +1,70 @@
+#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 = 100010;
+int a[MAXN];
+int num[40];
+int bit[40];
+int main()
+{
+    int T;
+    int n,m;
+    bit[0] = 1;
+    for(int i = 1;i <= 31;i++)
+        bit[i] = 2*bit[i-1];
+    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]);
+        long long tot = (long long)n*(n+1)/2;
+        int last = 0;
+        int i = 0,j = 0;
+        memset(num,0,sizeof(num));
+        long long sum = 0;
+        while(j < n)
+        {
+            for(int k = 0;k <=31;k++)
+                if(a[j] & bit[k])
+                    num[k]++;
+            int s = 0;
+            for(int k = 0;k <= 31;k++)
+                if(num[k])
+                    s += bit[k];
+            if(s >= m)
+            {
+                while(s >=m)
+                {
+                    for(int k = 0;k <= 31;k++)
+                        if(a[i] & bit[k])
+                            num[k]--;
+                    s = 0;
+                    for(int k = 0;k <= 31;k++)
+                        if(num[k])
+                            s += bit[k];
+                    i++;
+                }
+                sum += (long long)(n-j)*(i-last);
+                last = i;
+            }
+            j++;
+        }
+        printf("Case #%d: ",iCase);
+        cout<<tot-sum<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4738_autoAC.cpp b/HDOJ/4738_autoAC.cpp
new file mode 100644
index 0000000..cae797b
--- /dev/null
+++ b/HDOJ/4738_autoAC.cpp
@@ -0,0 +1,83 @@
+#include <stdio.h>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int MAXN = 1010;
+struct Edge
+{
+    int to;
+    int next;
+    int w;
+}edge[MAXN*MAXN];
+int tot;
+int head[MAXN];
+void add(int s, int u, int w)
+{
+    edge[tot].to = u;
+    edge[tot].w = w;
+    edge[tot].next = head[s];
+    head[s] = tot++;
+    edge[tot].to = s;
+    edge[tot].w = w;
+    edge[tot].next = head[u];
+    head[u] = tot++;    
+}
+int n, m;
+int dfn[MAXN], low[MAXN], sta[MAXN], col[MAXN];
+int tt, sum, scc, top;
+void tarjan(int u, int fa)
+{
+    dfn[u] = low[u] = ++tt;
+    sta[++top] = u;
+    int cnt=0;
+    for(int i = head[u]; i; i = edge[i].next) {
+        int v = edge[i].to;
+        if(!dfn[v]) {
+            sum++;
+            tarjan(v, u);
+            low[u] = min(low[u], low[v]);
+        } else if (fa == v) {
+            if (cnt) low[u] = min(low[u],dfn[v]);
+            cnt++;
+        } else low[u] = min(low[u],dfn[v]);
+    }
+    if(dfn[u]==low[u]) {
+        int x;
+        scc++;
+        do {
+            x = sta[top--];
+            col[x] = scc;
+        } while(x != u);
+    }
+}
+int main()
+{
+    int a, b, w;
+    int ans;
+    while (scanf("%d %d", &n, &m)) {
+        if (n == 0 && m == 0) break;
+        memset(dfn, 0, sizeof(dfn));
+        memset(low, 0, sizeof(low));
+        memset(col, 0, sizeof(col));
+        memset(head, 0, sizeof(head));
+        tot = sum = 1;
+        tt = scc = top = 0;
+        ans = 10010;
+        while (m--) {
+            scanf("%d %d %d", &a, &b, &w);
+            add(a, b, w);
+        }
+        tarjan(1, 1);
+        if (sum < n) puts("0");
+        else {
+            for (int i = 1; i <= n; ++i) {
+                for (int j = head[i]; j; j = edge[j].next) {
+                    int v = edge[j].to;
+                    if (col[i] != col[v]) ans = min(ans, edge[j].w);
+                }
+            }
+            printf("%d\n", ans?(ans == 10010?-1:ans):1);
+        }
+    }        
+    return 0;
+}
diff --git a/HDOJ/4739_autoAC.cpp b/HDOJ/4739_autoAC.cpp
new file mode 100644
index 0000000..e559e48
--- /dev/null
+++ b/HDOJ/4739_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<vector>
+using namespace std;
+struct Point{
+    int x,y;
+}point[22];
+int dp[(1<<20)+2];
+int n;
+int cmp(const Point &p,const Point &q)
+{
+    if(p.y==q.y){
+        return p.x<q.x;
+    }
+    return p.y<q.y;
+}
+bool Judge(int i,int j,int k,int l)
+{
+    if(point[i].x==point[j].x&&point[i].y==point[j].y)return false;
+    if(point[i].y!=point[j].y||point[i].x!=point[k].x||point[j].x!=point[l].x||point[k].y!=point[l].y)
+        return false;
+    if(abs(point[i].x-point[j].x)!=abs(point[i].y-point[k].y))
+        return false;
+    return true;
+}
+vector<int>g[22];
+int main()
+{
+    while(~scanf("%d",&n)){
+        if(n==-1)break;
+        for(int i=0;i<n;i++)scanf("%d%d",&point[i].x,&point[i].y);
+        sort(point,point+n,cmp);
+        memset(dp,0,sizeof(dp));
+        for(int i=0;i<=n;i++)g[i].clear();
+        for(int i=0;i<n;i++){
+            for(int j=i+1;j<n;j++){
+                for(int k=j+1;k<n;k++){
+                    for(int l=k+1;l<n;l++){
+                        if(Judge(i,j,k,l)){
+                            int state=0;
+                            state|=(1<<i);
+                            state|=(1<<j);
+                            state|=(1<<k);
+                            state|=(1<<l);
+                            g[i].push_back(state);
+                        }
+                    }
+                }
+            }
+        }
+        for(int state=0;state<(1<<n);state++){
+            for(int i=0;i<n;i++){
+                if(state&(1<<i)){
+                    for(int j=0;j<g[i].size();j++){
+                        int S=g[i][j];
+                        if((S|state)==state)dp[state]=max(dp[state],dp[state^S]+4);
+                    }
+                }
+            }
+        }
+        printf("%d\n",dp[(1<<n)-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4740_autoAC.cpp b/HDOJ/4740_autoAC.cpp
new file mode 100644
index 0000000..9494fda
--- /dev/null
+++ b/HDOJ/4740_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <algorithm>
+#include <math.h>
+using namespace std;
+#define MAXN 1005
+int dir[4][2] = { {0,1}, {1,0}, {0,-1}, {-1,0} } ;         
+int n, flag, p, q ;
+int donkey[MAXN][MAXN], tiger[MAXN][MAXN] ;
+void DFS(int a, int b, int c, int x, int y, int z) {
+    donkey[a][b] = 1;
+    tiger[x][y] = 1;
+    if(flag) return ;
+    if(a == x && b == y) {
+        flag = 1;
+        printf("%d %d\n", a, b);
+        return ;
+    }
+    if(p && q) {
+        flag = 1;
+        printf("-1\n");
+        return ;
+    }
+    int aa, bb, xx, yy;
+    if(p) {
+        aa = a;
+        bb = b;
+    }
+    else {
+        aa = a + dir[c][0];
+        bb = b + dir[c][1];
+        if(aa < 0 || bb < 0 || aa >= n || bb >= n || donkey[aa][bb] == 1) {
+            c = (c+1)%4;      
+            aa = a + dir[c][0];
+            bb = b + dir[c][1];
+            if(aa < 0 || bb < 0 || aa >= n || bb >= n || donkey[aa][bb] == 1) {
+                p = 1;
+                aa = a;
+                bb = b;
+            }
+        }
+    }
+    if(q) {
+        xx = x;
+        yy = y;
+    }
+    else {
+        xx = x + dir[z][0];
+        yy = y + dir[z][1];
+        if(xx < 0 || yy < 0 || xx >= n || yy >= n || tiger[xx][yy] == 1) {
+            z = (z-1+4)%4;      
+            xx = x + dir[z][0];
+            yy = y + dir[z][1];
+            if(xx < 0 || yy < 0 || xx >= n || yy >= n || tiger[xx][yy] == 1) {
+                q = 1;
+                xx = x;
+                yy = y;
+            }
+        }
+    }
+    DFS(aa, bb, c, xx, yy, z);
+}
+int main() {
+    int a, b, c, x, y, z ;
+    while(scanf("%d", &n), n) {
+        scanf("%d%d%d", &a, &b, &c);
+        scanf("%d%d%d", &x, &y, &z);
+        if(a == x && b == y) {
+            printf("%d %d\n", a, b);
+            continue;
+        }
+        else {
+            memset(donkey, 0, sizeof(donkey));
+            memset(tiger,  0, sizeof(tiger ));
+            flag = p = q = 0;
+            DFS(a, b, c, x, y, z);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4741_autoAC.cpp b/HDOJ/4741_autoAC.cpp
new file mode 100644
index 0000000..15a1a72
--- /dev/null
+++ b/HDOJ/4741_autoAC.cpp
@@ -0,0 +1,79 @@
+#include<stdio.h>
+#include<string.h>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+struct point
+{
+    double x,y,z;
+    point(double _x,double _y,double _z)
+        {
+            x=_x;y=_y;z=_z;
+        }
+};
+struct Vector  
+{
+    double x,y,z;
+    Vector(double _x,double _y,double _z)
+        {
+            x=_x,y=_y,z=_z;
+        }
+};
+struct plane   
+{
+    double a,b,c,d;
+    plane(double _a,double _b,double _c,double _d)
+        {
+            a=_a,b=_b,c=_c,d=_d;
+        }
+};
+Vector getvector(point a,point b)
+{
+    Vector ans=Vector(a.x-b.x,a.y-b.y,a.z-b.z);
+    return ans;
+}
+Vector Common_Vertical_Line(Vector a,Vector b)
+{
+    Vector ans=Vector(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x);
+    return ans;
+}
+double pointDis(Vector a)
+{
+    return sqrt((a.x*a.x+a.y*a.y+a.z*a.z));
+}
+plane getPlane(Vector a,Vector b,point c) 
+{
+    Vector line=Common_Vertical_Line(a,b);
+    plane ans=plane(line.x,line.y,line.z,line.x*(-1)*c.x+line.y*(-1)*c.y+line.z*(-1)*c.z);
+    return ans;
+}
+point getPoint(plane P,Vector B,point C)
+{
+    double k=((-1)*P.b*C.y-P.a*C.x-P.c*C.z-P.d)/(P.a*B.x+P.b*B.y+P.c*B.z);
+    point ans=point(B.x*k+C.x,B.y*k+C.y,B.z*k+C.z);
+    return ans;
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        double a,b,c;
+        scanf("%lf%lf%lf",&a,&b,&c);point x1=point(a,b,c);
+        scanf("%lf%lf%lf",&a,&b,&c);point y1=point(a,b,c);
+        scanf("%lf%lf%lf",&a,&b,&c);point x2=point(a,b,c);
+        scanf("%lf%lf%lf",&a,&b,&c);point y2=point(a,b,c);
+        Vector  l1=getvector(x1,y1);
+        Vector  l2=getvector(x2,y2);
+        Vector line=Common_Vertical_Line(l1,l2);
+        plane p1=getPlane(l1,line,x1);
+        plane p2=getPlane(l2,line,x2);
+        point ans2=getPoint(p1,l2,x2);
+        point ans1=getPoint(p2,l1,x1);
+        Vector ans=getvector(ans1,ans2);
+        printf("%.6lf\n",pointDis(ans));
+        printf("%.6lf %.6lf %.6lf %.6lf %.6lf %.6lf\n",ans1.x,ans1.y,ans1.z,ans2.x,ans2.y,ans2.z);
+    }
+    return 0;
+}
diff --git a/HDOJ/4742_autoAC.cpp b/HDOJ/4742_autoAC.cpp
new file mode 100644
index 0000000..5eb57f9
--- /dev/null
+++ b/HDOJ/4742_autoAC.cpp
@@ -0,0 +1,103 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <set>
+#include <map>
+#include <string>
+#include <vector>
+#include <queue>
+#include <stack>
+#define lowbit(x) (x & (-x))
+#define mp(a,b) make_pair (a , b)
+#pragma comment(linker, "/STACK:1024000000,1024000000")    
+using namespace std;
+typedef long long LL;
+const int N = 100005;
+typedef pair<int , int> pii;
+struct Node {
+    int x , y , z , id;
+    void input () {
+        scanf ("%d %d %d" , &x , &y, &z);
+    }
+    bool operator < (const Node &n) const {
+        return x != n.x ? x < n.x : (y != n.y ? y < n.y : z < n.z);
+    }
+}a[N] , b[N];
+int x[N] , m , n;
+pii dp[N] , bit[N];
+void update (pii &a , pii b) {
+    if (b.first > a.first) a = b;
+    else if (b.first == a.first) a.second += b.second;
+}
+void init () {
+    for (int i = 1 ; i <= m ; i ++)
+        bit[i] = mp(0 , 0);
+}
+void add (int idx , pii val) {
+    for (int i = idx ; i <= m ; i += lowbit (i))
+        update (bit[i] , val);
+}
+pii ask (int idx) {
+    pii ans = mp (0 , 0);
+    for (int i = idx ; i > 0 ; i -= lowbit (i))
+        update (ans , bit[i]);
+    return ans;
+}
+void clear (int idx) {
+    for (int i = idx ; i <= m ; i += lowbit (i))
+        bit[i] = mp (0 , 0);
+}
+void gao (int l , int r) {
+    if (l == r) return ;
+    int mid = (l + r) >> 1;
+    gao (l , mid);
+    int cnt = 0;
+    for (int i = l ; i <= r ; i ++) {
+        b[cnt ++] = a[i];
+        b[cnt - 1].x = 0;
+    }
+    sort (b , b + cnt);
+    for (int i = 0 ; i < cnt ; i ++) {
+        if (b[i].id <= mid) {
+            add (b[i].z , dp[b[i].id]);
+        }
+        else {
+            pii t = ask (b[i].z);
+            t.first ++;
+            update (dp[b[i].id] , t);
+        }
+    }
+    for (int i = 0 ; i < cnt ; i ++)
+        if (b[i].id <= mid)
+            clear (b[i].z);
+    gao (mid + 1 , r);
+}
+int main () {
+    int t ;
+    scanf ("%d" , &t);
+    while (t --) {
+        scanf ("%d" , &n);
+        for (int i = 0 ; i < n ; i ++) {
+            a[i].input ();
+            x[i] = a[i].z;
+            dp[i] = mp (1 , 1);
+        }
+        sort (x , x + n);
+        m = unique (x , x + n) - x;
+        for (int i = 0 ; i < n ; i ++)
+            a[i].z = lower_bound (x , x + m , a[i].z) - x + 1;
+        sort (a , a + n);
+        for (int i = 0 ; i < n ; i ++)
+            a[i].id = i;
+        init ();
+        gao (0 , n - 1);
+        pii ans = mp (0 , 0);
+        for (int i = 0 ; i < n ; i ++) {
+            update (ans , dp[i]);
+        }
+        printf ("%d %d\n" , ans.first , ans.second);
+    }
+    return 0;
+}
diff --git a/HDOJ/4744_autoAC.cpp b/HDOJ/4744_autoAC.cpp
new file mode 100644
index 0000000..d22c1e8
--- /dev/null
+++ b/HDOJ/4744_autoAC.cpp
@@ -0,0 +1,121 @@
+#include <cstdio>
+#include <queue>
+#include <cstring>
+#include <cmath>
+using namespace std;
+const int MAXN = 210;
+const int MAXE = 210 * 210 * 2;
+const int INF = 0x3f3f3f3f;
+struct ZKW_flow{
+    int st, ed, ecnt, n;
+    int head[MAXN];
+    int cap[MAXE], cost[MAXE], to[MAXE], next[MAXE];
+    void init(){
+        memset(head, 0, sizeof(head));
+        ecnt = 2;
+    }
+    void addEdge(int u, int v, int cc, int ww){
+        cap[ecnt] = cc; cost[ecnt] = ww; to[ecnt] = v;
+        next[ecnt] = head[u]; head[u] = ecnt++;
+        cap[ecnt] = 0; cost[ecnt] = -ww; to[ecnt] = u;
+        next[ecnt] = head[v]; head[v] = ecnt++;
+    }
+    int dis[MAXN];
+    void SPFA(){
+        for(int i = 1; i <= n; ++i) dis[i] = INF;
+        priority_queue<pair<int, int> > Q;
+        dis[st] = 0;
+        Q.push(make_pair(0, st));
+        while(!Q.empty()){
+            int u = Q.top().second, d = -Q.top().first;
+            Q.pop();
+            if(dis[u] != d) continue;
+            for(int p = head[u]; p; p = next[p]){
+                int &v = to[p];
+                if(cap[p] && dis[v] > d + cost[p]){
+                    dis[v] = d + cost[p];
+                    Q.push(make_pair(-dis[v], v));
+                }
+            }
+        }
+        for(int i = 1; i <= n; ++i) dis[i] = dis[ed] - dis[i];
+    }
+    int minCost, maxFlow;
+    bool use[MAXN];
+    int add_flow(int u, int flow){
+        if(u == ed){
+            maxFlow += flow;
+            minCost += dis[st] * flow;
+            return flow;
+        }
+        use[u] = true;
+        int now = flow;
+        for(int p = head[u]; p; p = next[p]){
+            int &v = to[p];
+            if(cap[p] && !use[v] && dis[u] == dis[v] + cost[p]){
+                int tmp = add_flow(v, min(now, cap[p]));
+                cap[p] -= tmp;
+                cap[p^1] += tmp;
+                now -= tmp;
+                if(!now) break;
+            }
+        }
+        return flow - now;
+    }
+    bool modify_label(){
+        int d = INF;
+        for(int u = 1; u <= n; ++u) if(use[u])
+            for(int p = head[u]; p; p = next[p]){
+                int &v = to[p];
+                if(cap[p] && !use[v]) d = min(d, dis[v] + cost[p] - dis[u]);
+            }
+        if(d == INF) return false;
+        for(int i = 1; i <= n; ++i) if(use[i]) dis[i] += d;
+        return true;
+    }
+    int min_cost_flow(int ss, int tt, int nn){
+        st = ss, ed = tt, n = nn;
+        minCost = maxFlow = 0;
+        SPFA();
+        while(true){
+            while(true){
+                for(int i = 1; i <= n; ++i) use[i] = 0;
+                if(!add_flow(st, INF)) break;
+            }
+            if(!modify_label()) break;
+        }
+        return minCost;
+    }
+} G;
+struct Point {
+    int x, y, z, w;
+    void read() {
+        scanf("%d%d%d%d", &x, &y, &z, &w);
+    }
+    int operator * (const Point &rhs) const {
+        double xx = x - rhs.x, yy = y - rhs.y, zz = z - rhs.z;
+        return (int)sqrt(xx * xx + yy * yy + zz * zz);
+    }
+};
+Point a[MAXN];
+int n;
+int main() {
+    while(scanf("%d", &n) != EOF && n) {
+        int sumw = 0;
+        for(int i = 1; i <= n; ++i) a[i].read(), sumw += a[i].w;
+        G.init();
+        int ss = 2 * n + 1, tt = ss + 1;
+        for(int i = 1; i <= n; ++i) {
+            G.addEdge(ss, i, a[i].w, 0);
+            G.addEdge(i + n, tt, a[i].w, 0);
+            for(int j = i + 1; j <= n; ++j) {
+                int cost = a[i] * a[j];
+                G.addEdge(i, j + n, INF, cost);
+                G.addEdge(j, i + n, INF, cost);
+            }
+        }
+        int ans = G.min_cost_flow(ss, tt, tt);
+        if(sumw != G.maxFlow) ans = -1;
+        printf("%d\n", ans);
+    }
+}
diff --git a/HDOJ/4745_autoAC.cpp b/HDOJ/4745_autoAC.cpp
new file mode 100644
index 0000000..7ef422b
--- /dev/null
+++ b/HDOJ/4745_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+using namespace std;
+int s[1005];
+int dp[1005][1005];
+int max(int a,int b)
+{
+    return a>b?a:b;
+}
+int main()
+{
+    int n;
+    while (cin>>n&&n)
+    {
+        memset(dp,0,sizeof(dp));
+        for (int i=1;i<=n;i++)
+            cin>>s[i];
+        for (int l=1;l<=n;l++)
+        {
+            for (int i=1;i+l-1<=n;i++)
+            {
+                int j=i+l-1;
+                int p=2;
+                if (i==j)
+                    p=1;
+                if (s[j]==s[i])
+                    dp[i][j]=p+dp[i+1][j-1];
+                else
+                    dp[i][j]=max(dp[i][j-1],dp[i+1][j]);
+            }
+        }
+        int ans=0;
+        for (int i=0;i<=n;i++)
+            ans=max(ans,dp[1][i]+dp[i+1][n]);
+        cout<<ans<<endl;
+    }
+}
diff --git a/HDOJ/4746_autoAC.cpp b/HDOJ/4746_autoAC.cpp
new file mode 100644
index 0000000..8bc0534
--- /dev/null
+++ b/HDOJ/4746_autoAC.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define LL long long
+#define M 500005
+#define N 19
+int cal(int n, int x)
+{
+    int res = 0;
+    do
+    {
+        ++res;
+        n /= x;
+    }
+    while (n % x == 0);
+    return res;
+}
+int F[M][N];
+int num[M];    
+int h[M];        
+int mob(int n)
+{
+    if (h[n] == -1) return 0;    
+    if (h[n] & 1) return -1;
+    return 1;                    
+}
+int main()
+{
+    int t, n, m, p, i, j;
+    for (i = 2; i < M; i++)
+    {
+        if (num[i]) continue;
+        for (j = i; j < M; j+=i)
+        {
+            int tp = cal(j, i);
+            num[j] += tp;
+            if (tp > 1)      
+            {
+                h[j] = -1;
+            }
+            else if (h[j] >= 0)
+            {
+                ++h[j];
+            }
+        }
+    }
+    for (i = 1; i < M; i++)
+    {
+        for (j = i; j < M; j+=i)
+        {
+            F[j][num[i]] += mob(j/i);
+        }
+    }
+    for (i = 1; i < M; i++)
+    {
+        for (j = 1; j < N; j++)
+        {
+            F[i][j] += F[i][j-1];
+        }
+    }
+    for (i = 1; i < M; i++)
+    {
+        for (j = 0; j < N; j++)
+        {
+            F[i][j] += F[i-1][j];
+        }
+    }
+    scanf("%d", &t);
+    while (t--)
+    {
+        scanf("%d%d%d", &n, &m, &p);
+        LL ans = 0;
+        if (p >= N)
+        {
+            ans = (LL)n*m;
+        }
+        else
+        {
+            if (n > m)
+            {
+                n ^= m;
+                m ^= n;
+                n ^= m;
+            }
+            for (i = 1; i <= n; i = j + 1)
+            {
+                j = min(n/(n/i), m/(m/i));
+                ans += ((LL)F[j][p]-F[i-1][p])*(n/i)*(m/i);
+            }
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4747_autoAC.cpp b/HDOJ/4747_autoAC.cpp
new file mode 100644
index 0000000..c757787
--- /dev/null
+++ b/HDOJ/4747_autoAC.cpp
@@ -0,0 +1,137 @@
+#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 = 200010;
+struct Node
+{
+    int l,r;
+    long long sum;
+    int mx;
+    int lazy;
+}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;
+    segTree[i].mx = max(segTree[i<<1].mx,segTree[(i<<1)|1].mx);
+}
+void Update_Same(int i,int v)
+{
+    segTree[i].sum = (long long)v*(segTree[i].r - segTree[i].l + 1);
+    segTree[i].mx = v;
+    segTree[i].lazy = 1;
+}
+void push_down(int i)
+{
+    if(segTree[i].l == segTree[i].r)return;
+    if(segTree[i].lazy)
+    {
+        Update_Same(i<<1,segTree[i].mx);
+        Update_Same((i<<1)|1,segTree[i].mx);
+        segTree[i].lazy = 0;
+    }
+}
+int mex[MAXN];
+void Build(int i,int l,int r)
+{
+    segTree[i].l = l;
+    segTree[i].r = r;
+    segTree[i].lazy = 0;
+    if(l == r)
+    {
+        segTree[i].mx = mex[l];
+        segTree[i].sum = mex[l];
+        return;
+    }
+    int mid = (l + r)>>1;
+    Build(i<<1,l,mid);
+    Build((i<<1)|1,mid+1,r);
+    push_up(i);
+}
+void Update(int i,int l,int r,int v)
+{
+    if(segTree[i].l == l && segTree[i].r == r)
+    {
+        Update_Same(i,v);
+        return;
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)>>1;
+    if(r <= mid)
+    {
+        Update(i<<1,l,r,v);
+    }
+    else if(l > mid)
+    {
+        Update((i<<1)|1,l,r,v);
+    }
+    else
+    {
+        Update(i<<1,l,mid,v);
+        Update((i<<1)|1,mid+1,r,v);
+    }
+    push_up(i);
+}
+int Get(int i,int v)
+{
+    if(segTree[i].l == segTree[i].r)
+        return segTree[i].l;
+    push_down(i);
+    if(segTree[i<<1].mx > v)
+        return Get(i<<1,v);
+    else return Get((i<<1)|1,v);
+}
+int a[MAXN];
+map<int,int>mp;
+int ne[MAXN];
+int main()
+{
+    int n;
+    while(scanf("%d",&n) && n)
+    {
+        for(int i = 1;i <= n;i++)
+            scanf("%d",&a[i]);
+        mp.clear();
+        int tmp = 0;
+        for(int i = 1;i <= n;i++)
+        {
+            mp[a[i]] = 1;
+            while(mp.find(tmp) != mp.end())tmp++;
+            mex[i] = tmp;
+        }
+        mp.clear();
+        for(int i = n;i >= 1;i--)
+        {
+            if(mp.find(a[i]) == mp.end())ne[i] = n+1;
+            else ne[i] = mp[a[i]];
+            mp[a[i]] = i;
+        }
+        Build(1,1,n);
+        long long sum = 0;
+        for(int i = 1;i <= n;i++)
+        {
+            sum += segTree[1].sum;
+            if(segTree[1].mx > a[i])
+            {
+                int l = Get(1,a[i]);
+                int r = ne[i];
+                if(l < r)
+                    Update(1,l,r-1,a[i]);
+            }
+            Update(1,i,i,0);
+        }
+        printf("%I64d\n",sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4749_autoAC.cpp b/HDOJ/4749_autoAC.cpp
new file mode 100644
index 0000000..0801ecc
--- /dev/null
+++ b/HDOJ/4749_autoAC.cpp
@@ -0,0 +1,135 @@
+#include <iostream>
+#include <cstring>
+#include <string>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#include <vector>
+using namespace std;
+#define INF 1000000000
+#define MAXN 100005
+int vis[30];
+int ne[MAXN];
+int s[MAXN],p[MAXN];
+int c1[30][MAXN],c2[30][MAXN];
+int cal_s(int pos,int k)
+{
+    if(pos<0) return 0;
+    int s=0;
+    for(int i=1;i<k;i++) s+=c1[i][pos];
+    return s;
+}
+int cal_p(int pos,int k)
+{
+    if(pos<0) return 0;
+    int s=0;
+    for(int i=1;i<k;i++) s+=c2[i][pos];
+    return s;
+}
+bool isok(int i,int j)
+{
+    if(!j) return true;
+    if (c2[p[j]][j]!=c1[s[i]][i]-c1[s[i]][i-j-1]) return false;
+    int cnt1=cal_s(i,s[i]);
+    int cnt2=cal_s(i-j-1,s[i]);
+    int cnt3=cal_p(j,p[j]);
+    return cnt1-cnt2==cnt3;
+}
+bool ok(int i,int j)
+{
+    if(!j) return true;
+    if (c2[p[j]][j]!=c2[p[i]][i]-c2[p[i]][i-j-1]) return false;
+    int cnt1=cal_p(i,p[i]);
+    int cnt2=cal_p(i-j-1,p[i]);
+    int cnt3=cal_p(j,p[j]);
+    return cnt1-cnt2==cnt3;
+}
+void getnext(int n)
+{
+    bool flag;
+    for(int i=1;i<n;i++)
+    {
+        int j=ne[i];
+        flag=ok(i,j);
+        while(j&&!flag)
+        {
+            j=ne[j];
+        }
+        if(flag)
+        {
+            ne[i+1]=j+1;
+        }
+        else
+        {
+            ne[i+1]=0;
+        }
+    }
+}
+int ans;
+int kmp(int n,int m)
+{
+    getnext(m);
+    bool flag;
+    int j=0;
+    for(int i=0;i<n;i++)
+    {
+        flag=isok(i,j);
+        while(j&&!flag) {j=ne[j];flag=isok(i,j);}
+        if(flag) j++;
+        if(j==m)
+        {
+            ans++;
+            j=0;
+        }
+    }
+    return -1;
+}
+inline int ReadInt()
+{
+    int flag=0;
+    char ch = getchar();
+    int data = 0;
+    while (ch < '0' || ch > '9')
+    {
+        if(ch=='-') flag=1;
+        ch = getchar();
+    }
+    do
+    {
+        data = data*10 + ch-'0';
+        ch = getchar();
+    }while (ch >= '0' && ch <= '9');
+        if(flag) data=-data;
+        return data;
+}
+int main()
+{
+    int n,m,kk;
+    while(~scanf("%d%d%d",&n,&m,&kk))
+    {
+        ans=0;
+        memset(c1,0,sizeof(c1));
+        memset(c2,0,sizeof(c2));
+        for(int i=0;i<n;i++)
+        {
+            s[i]=ReadInt();
+            if(i){
+            for(int j=1;j<=kk;j++){
+                c1[j][i]=c1[j][i-1];}
+            }
+            c1[s[i]][i]++;
+        }
+        for(int i=0;i<m;i++)
+        {
+            p[i]=ReadInt();
+            if(i)
+            for(int j=1;j<=kk;j++)
+                c2[j][i]=c2[j][i-1];
+            c2[p[i]][i]++;
+        }
+        getnext(m);
+        kmp(n,m);
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4750_autoAC.cpp b/HDOJ/4750_autoAC.cpp
new file mode 100644
index 0000000..8bd6666
--- /dev/null
+++ b/HDOJ/4750_autoAC.cpp
@@ -0,0 +1,107 @@
+#include <iostream>      
+#include <stdio.h>      
+#include <cmath>      
+#include <algorithm>      
+#include <iomanip>      
+#include <cstdlib>      
+#include <string>      
+#include <memory.h>      
+#include <vector>      
+#include <queue>      
+#include <stack>      
+#include <map>    
+#include <set>    
+#include <ctype.h>      
+#define INF 1000000010  
+#define ll long long  
+#define max3(a,b,c) max(a,max(b,c))  
+#define MAXN 100010  
+using namespace std;
+struct edge{
+    int u;
+    int v;
+    int w;
+};
+edge E[500010];
+bool cmp(edge e1,edge e2){
+    return e1.w<e2.w;
+}
+int p[10010];
+int find(int x){
+    if(x!=p[x])p[x]=find(p[x]);
+    return p[x];
+}
+int setsize[10010];
+void _union(int a,int b){
+    int fa=find(a);
+    int fb=find(b);
+    p[fa]=fb;
+    setsize[fb]+=setsize[fa];
+}
+map<ll,int> mp;
+int cnt[500010];
+int num[500010];
+int ans[10010];
+int main(){
+    int n,m;
+    while(cin>>n>>m){
+        for(int i=0;i<n;i++)p[i]=i;
+        for(int i=0;i<n;i++)setsize[i]=1;
+        memset(cnt,0,sizeof(cnt));
+        memset(num,0,sizeof(num));
+        mp.clear();
+        for(int i=1;i<=m;i++){
+            int a,b,c;
+            scanf("%d%d%d",&E[i].u,&E[i].v,&E[i].w);
+        }
+        sort(E+1,E+m+1,cmp);
+        for(int i=1;i<=m;i++){
+            int u=E[i].u;
+            int v=E[i].v;
+            int fu=find(u);
+            int fv=find(v);
+            int su=setsize[fu];
+            int sv=setsize[fv];
+            if(fu!=fv){
+                mp[E[i].w]+=su*sv*2; 
+                _union(u,v);
+            }
+        }
+        int q=1;
+        for(map<ll,int>::iterator it=mp.begin();it!=mp.end();it++){
+            num[q]=it->first;
+            cnt[q]=it->second;
+            q++;
+        }
+        int size=mp.size();
+        num[size+1]=INF;
+        for(int i=size;i>=0;i--){
+            cnt[i]+=cnt[i+1];  
+        }
+        int p;
+        cin>>p;
+        for(int k=0;k<p;k++){
+            int t;
+            scanf("%d",&t);
+            int l=0;
+            int r=size+1;
+            while(true){
+                int mid=(r+l)/2;
+                if(num[mid]==t){
+                    printf("%d\n",cnt[mid]);
+                    break;
+                }
+                if(num[mid]>t){
+                    r=mid;
+                }else{
+                    if(num[mid+1]>t){
+                        printf("%d\n",cnt[mid+1]);
+                        break;
+                    }
+                    l=mid;
+                }
+            }  
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4751_autoAC.cpp b/HDOJ/4751_autoAC.cpp
new file mode 100644
index 0000000..c82a227
--- /dev/null
+++ b/HDOJ/4751_autoAC.cpp
@@ -0,0 +1,84 @@
+#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 = 110;
+int color[MAXN];
+int head[MAXN];
+struct Edge
+{
+    int to,next;
+}edge[MAXN*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));
+}
+bool dfs(int u,int col)
+{
+    color[u] = col;
+    for(int i = head[u];i != -1;i = edge[i].next)
+    {
+        int v = edge[i].to;
+        if(color[v] != -1)
+        {
+            if(color[v]==col)return false;
+            continue;
+        }
+        if(!dfs(v,!col))return false;
+    }
+    return true;
+}
+int g[MAXN][MAXN];
+int main()
+{
+    int n;
+    while(scanf("%d",&n) == 1)
+    {
+        memset(g,0,sizeof(g));
+        int t;
+        for(int i = 1;i <= n;i++)
+        {
+            while(scanf("%d",&t) && t)
+            {
+                g[i][t] = 1;
+            }
+        }
+        init();
+        for(int i = 1;i <= n;i++)
+            for(int j = i+1;j <= n;j++)
+                if(g[i][j] == 0 || g[j][i] == 0)
+                {
+                    addedge(i,j);
+                    addedge(j,i);
+                }
+        memset(color,-1,sizeof(color));
+        bool flag = true;
+        for(int i = 1;i <= n;i++)
+            if(color[i] == -1 && dfs(i,0) == false)
+            {
+                flag = false;
+                break;
+            }
+        if(flag)printf("YES\n");
+        else printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4752_autoAC.cpp b/HDOJ/4752_autoAC.cpp
new file mode 100644
index 0000000..1479ae8
--- /dev/null
+++ b/HDOJ/4752_autoAC.cpp
@@ -0,0 +1,96 @@
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <ctime>
+#include <climits>
+#include <cmath>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <set>
+#include <map>
+#include <list>
+#include <queue>
+#include <stack>
+#include <deque>
+#include <algorithm>
+using namespace std;
+const int maxn = 20005;
+const double eps = 1e-8;
+int n, a, b, c, l, r;
+int x[maxn], y[maxn];
+double p[maxn*2];
+int tot;
+int dcmp(double x) {if (fabs(x) < eps) return 0; return x > 0 ? 1 : -1;}
+double func(double x)
+{
+    return (a * x + b) * x + c;
+}
+bool between(double a, double b, double c) {return dcmp(a - b) > 0 && dcmp(c - a) > 0;}
+bool solve(double a, double b, double c, double &x1, double &x2)
+{
+    double d = b*b - 4*a*c;
+    if (dcmp(d) <= 0) return 0;
+    d = sqrt(d);
+    x1 = (-b - d) / a * 0.5;
+    x2 = (-b + d) / a * 0.5;
+    return 1;
+}
+void get(int x1, int y1, int x2, int y2)
+{
+    if (x1 == x2)
+    {
+        double y = func(x1);
+        if (y1 > y2) swap(y1, y2);
+        if (between(y, y1, y2)) p[tot++] = x1;
+    }
+    else
+    {
+        double k = (double)(y2 - y1) / (x2 - x1), r1, r2;
+        if (solve(a, b - k, c + k * x1 - y1, r1, r2))
+        {
+            if (x1 > x2) swap(x1, x2);
+            if (between(r1, x1, x2)) p[tot++] = r1;
+            if (between(r2, x1, x2)) p[tot++] = r2;
+        }
+    }
+}
+double sqr(double x) {return x * x;}
+double f(double x)
+{
+    return sqrt(sqr(2*a*x + b) + 1);
+}
+double simpson(double p1, double p2)
+{
+    double mid = (p1 + p2) / 2, mid1 = (p1 + mid) / 2, mid2 = (mid + p2) / 2;
+    double f1 = f(p1), f2 = f(p2), fm = f(mid), fm1 = f(mid1), fm2 = f(mid2);
+    double tmp = (f1 + fm * 4 + f2) * (p2 - p1) / 6;
+    if (dcmp(tmp - (f1 + fm1 * 4 + fm) * (mid - p1) / 6 - (fm + fm2 * 4 + f2) * (p2 - mid) / 6) == 0) return tmp;
+    return simpson(p1, mid) + simpson(mid, p2);
+}
+int main()
+{
+    int nr;
+    double r1, r2;
+    while (scanf("%d", &n) == 1)
+    {
+        scanf("%d%d%d%d%d", &a, &b, &c, &l, &r);
+        for (int i=0;i<n;i++) scanf("%d%d", &x[i], &y[i]);
+        x[n] = x[0]; y[n] = y[0]; x[n+1] = x[1]; y[n+1] = y[1];
+        tot = 0;
+        for (int i=0;i<n;i++) get(x[i], y[i], x[i+1], y[i+1]);
+        for (int i=1;i<=n;i++)
+        {
+            double x1 = (x[i-1] - x[i]) * 1e-3 + x[i], y1 = (y[i-1] - y[i]) * 1e-3 + y[i];
+            double x2 = (x[i+1] - x[i]) * 1e-3 + x[i], y2 = (y[i+1] - y[i]) * 1e-3 + y[i];
+            if (dcmp(func(x1) - y1) * dcmp(func(x2) - y2) < 0) p[tot++] = x[i];
+        }
+        sort(p, p+tot);
+        double ans = 0;
+        tot--;
+        for (int i=0;i<tot;i++)
+            if (!(i&1)) ans += simpson(max((double)l, p[i]), min((double)r, p[i+1]));
+        printf("%.2lf\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4753_autoAC.cpp b/HDOJ/4753_autoAC.cpp
new file mode 100644
index 0000000..2c79449
--- /dev/null
+++ b/HDOJ/4753_autoAC.cpp
@@ -0,0 +1,108 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+int dp[10001];
+int visit[10001];
+int vis[25];
+int oth[25];
+int ts;
+int num(int vist[])
+{
+    int i;
+    int sum=0;
+    for(i=1;i<=9;i++)
+    {
+        if(vist[i]&&vist[i+3]&&vist[i+12+(i-1)/3]&&vist[i+13+(i-1)/3])sum++;
+    }
+    return sum;
+}
+int dos(int x)
+{
+    int sum=0,i;
+    int vist[26];
+    for(i=0;i<=24;i++)vist[i]=0;
+    for(i=1;i<=ts;i++)
+    {
+        if(x&(1<<(i-1)))
+        {
+            vist[oth[i-1]]=1;
+        }
+    }
+    for(i=1;i<=24;i++)
+    {
+        if(vis[i])vist[i]=1;
+    }
+    sum=num(vist);
+    return sum;
+}
+int dfs(int x)
+{
+    if(visit[x]!=-1)return visit[x];
+    int ans=0;
+    for(int i=1;i<=ts;i++)
+    {
+        if(!(x&(1<<(i-1))))
+        {
+            int y;
+            y=x+(1<<(i-1));
+            int ss;
+            ss=dfs(y);
+            ans=max(9-dp[x]-ss,ans);
+        }
+    }
+    visit[x]=ans;
+    return ans;
+}
+int main()
+{
+    int T,i,n,a,b;
+    int cas;
+    int anum,bnum,s;
+    cas=0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        cas++;
+        anum=bnum=0;
+        s=0;
+        scanf("%d",&n);
+        memset(vis,0,sizeof(vis));
+        memset(visit,-1,sizeof(visit));
+        for(i=0;i<n;i++)
+        {
+            scanf("%d%d",&a,&b);
+            if(a>b)swap(a,b);
+            if(b-a==4)ts=12+a;
+            else ts=a-a/4;
+            vis[ts]=1;
+            if(i%2==0)
+            {
+                anum+=num(vis)-s;
+            }
+            else bnum+=num(vis)-s;
+            s=num(vis);
+        }
+        ts=0;
+        for(i=1;i<=24;i++)if(vis[i]==0)oth[ts++]=i;
+        for(i=0;i<(1<<ts);i++)dp[i]=dos(i);
+        int have;
+        have=9-s;
+        int fs;
+        fs=dfs(0);
+        printf("Case #%d: ",cas);
+        if(n%2==0)
+        {
+            if(anum+fs>bnum+have-fs)cout<<"Tom200"<<endl;
+            else cout<<"Jerry404"<<endl;
+        }
+        else
+        {
+            if(anum+have-fs>bnum+fs)cout<<"Tom200"<<endl;
+            else cout<<"Jerry404"<<endl;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4756_autoAC.cpp b/HDOJ/4756_autoAC.cpp
new file mode 100644
index 0000000..bfedc61
--- /dev/null
+++ b/HDOJ/4756_autoAC.cpp
@@ -0,0 +1,142 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<algorithm>
+#include<math.h>
+using namespace std;
+const int maxn = 1015;
+const int maxm = maxn*maxn;
+const int inf1 = 0x3f3f3f3f;
+const double inf2 = 9999999999;
+struct Point {
+    double x,y;
+}pnt[ maxn ];
+struct Edge{
+    int u,v;
+    double val;
+    int id;
+}edge[ maxn<<1 ];
+int cnt_edge;
+double mat[ maxn ][ maxn ];
+double dis[ maxn ];
+bool vis[ maxn ];
+int pre[ maxn ];
+double LenPrim1;
+double LenPrim2;
+int fa[ maxn ],ran[ maxn ];
+int find( int x ){
+    if( x==fa[x] ) return x;
+    else return fa[ x ] = find( fa[x] );
+}
+void init( int n ){
+    for( int i=0;i<n;i++ ){
+        fa[ i ] = i;
+        ran[ i ] = 1;
+    }
+    return ;
+} 
+double dist( int i,int j ){
+    return sqrt( (pnt[i].x-pnt[j].x)*(pnt[i].x-pnt[j].x)+(pnt[i].y-pnt[j].y)*(pnt[i].y-pnt[j].y) );
+} 
+int cmp( Edge a,Edge b ){
+    return a.val<b.val;
+}    
+void GetMap( int n ){
+    for( int i=0;i<n;i++ )
+        for( int j=0;j<n;j++ ){
+            mat[i][j] = dist( i,j );
+        }
+    return ;
+}
+double prim( int n,int Belong ){
+    for( int i=0;i<n;i++ ){
+        dis[ i ] = mat[0][i];
+        vis[ i ] = false;
+        pre[ i ] = 0;
+    }
+    vis[0] = true;
+    double ans = 0;
+    for( int i=0;i<n;i++ ){
+        int id = -1;
+        double M = inf2;
+        for( int j=0;j<n;j++ ){
+            if( !vis[j] && M>dis[j] ){
+                M = dis[j];
+                id = j;
+            }
+        }
+        if( id==-1 ) break;
+        vis[ id ] = true;
+        ans += M;
+        edge[ cnt_ ].u = pre[ id ];
+        edge[ cnt_ ].v = id;
+        edge[ cnt_ ].id = Belong;
+        edge[ cnt_ ].val = mat[ id ][ pre[id] ];
+        cnt_edge ++ ;
+        for( int j=0;j<n;j++ ){
+            if( !vis[j] && dis[j]>mat[id][j] ){
+                dis[j] = mat[id][j];
+                pre[ j ] = id;
+            }
+        }
+    }
+    return ans;
+}    
+void Deal( int n ){
+    for( int i=0;i<cnt_edge;i++ ){
+        mat[ edge[i].u ][ edge[i].v ] = inf2;
+        mat[ edge[i].v ][ edge[i].u ] = inf2;
+    }
+}
+double Kruskal( int n,int id ){
+    double ans = 0;
+    init( n );
+    int cnt = 0;
+    for( int i=0;i<cnt_edge;i++ ){
+        if( i==id ) continue;
+        int fx = find( edge[i].u );
+        int fy = find( edge[i].v );
+        if( fx!=fy ){
+            if( ran[ fx ]<ran[ fy ] ){
+                ran[ fy ] += ran[ fx ];
+                fa[ fx ] = fy;
+            }
+            else {
+                ran[ fx ] += ran[ fy ];
+                fa[ fy ] = fx;
+            }
+            cnt ++ ;
+            ans += edge[i].val;
+            if( cnt==n-1 ) break;
+        }
+       }
+       return ans;
+}
+int main(){
+    int T;
+    scanf("%d",&T);
+    while( T-- ){
+        int n;
+        double k;
+        scanf("%d%lf",&n,&k);
+        for( int i=0;i<n;i++ )
+            scanf("%lf%lf",&pnt[i].x,&pnt[i].y);
+        GetMap( n );
+        cnt_edge = 0;
+        LenPrim1 = prim( n,1 );
+        Deal( n );
+        LenPrim2 = prim( n,2 );
+        double ans = LenPrim1;
+        double temp_ans = 0;
+        sort( edge,edge+cnt_edge,cmp );
+        for( int i=0;i<cnt_edge;i++ ){
+            if( edge[i].id==1 && edge[i].u!=0 && edge[i].v!=0 ){
+                temp_ans = Kruskal( n,i );
+                if( temp_ans>ans )
+                    ans = temp_ans;
+            }
+        }
+        printf("%.2lf\n",ans*k);
+    }
+    return 0;
+}
diff --git a/HDOJ/4757_autoAC.cpp b/HDOJ/4757_autoAC.cpp
new file mode 100644
index 0000000..ce7929e
--- /dev/null
+++ b/HDOJ/4757_autoAC.cpp
@@ -0,0 +1,102 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#define maxn 200010
+using namespace std;
+struct ww {
+    int son[2];
+    int cnt;
+    ww() {
+        cnt=0;
+        memset(son,0,sizeof son);
+    }
+}t[maxn<<5];
+int n,m,l,tot;
+int a[maxn],pre[maxn<<1],other[maxn<<1],last[maxn],que[maxn],dis[maxn],jump[maxn][20];
+void connect(int x,int y) {
+    pre[++l]=last[x];
+    last[x]=l;
+    other[l]=y;
+}
+int lca(int x,int y) {
+    if (dis[x]>dis[y]) swap(x,y);
+    int dep=dis[y]-dis[x];
+    for (int i=0;i<=18;i++) if (dep&(1<<i)) y=jump[y][i];
+    if (x==y) return x;
+    for (int i=18;i>=0;i--) if (jump[x][i]!=jump[y][i]) x=jump[x][i],y=jump[y][i];
+    return jump[x][0];
+}
+void build(int &x,int dep) {
+    if (!x) x=++tot;
+    if (dep<0) return ;
+    build(t[x].son[0],dep-1); build(t[x].son[1],dep-1);
+}    
+void insert(int &x,int rot,int dep,int key) {
+    if (!x) x=++tot;
+    if (dep==-2) return ; 
+    if (key&(1<<dep)) {
+        insert(t[x].son[1],t[rot].son[1],dep-1,key);
+        t[x].son[0]=t[rot].son[0];
+    } else {
+        insert(t[x].son[0],t[rot].son[0],dep-1,key);
+        t[x].son[1]=t[rot].son[1];
+    }
+    t[x].cnt+=t[rot].cnt+1;
+}
+int query(int rx,int lx,int key,int dep) {
+    if (dep==-2) return 0;
+    int ans=0;
+    if (key&(1<<dep)) {
+        if (t[t[rx].son[0]].cnt-t[t[lx].son[0]].cnt) {
+            ans=1<<dep;
+            ans+=query(t[rx].son[0],t[lx].son[0],key,dep-1);
+        } else ans=query(t[rx].son[1],t[lx].son[1],key,dep-1);
+    } else {
+        if (t[t[rx].son[1]].cnt-t[t[lx].son[1]].cnt) {
+            ans=1<<dep;
+            ans+=query(t[rx].son[1],t[lx].son[1],key,dep-1);
+        } else ans=query(t[rx].son[0],t[lx].son[0],key,dep-1);
+    }
+    return ans;
+}
+void work() {
+     memset(t,0,sizeof t);
+    memset(last,0,sizeof last);
+    memset(dis,0,sizeof dis);
+    tot=n; l=0;
+    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
+    for (int i=1;i<n;i++) {
+        int x,y; scanf("%d%d",&x,&y);
+        connect(x,y); connect(y,x);
+    }
+    int head=0,tail=1; que[1]=1; dis[1]=1;
+    while (head<tail) {
+        int cur=que[++head];
+        for (int p=last[cur];p;p=pre[p]) {
+            if (dis[other[p]]) continue;
+            que[++tail]=other[p]; dis[other[p]]=dis[cur]+1;
+        }
+    }
+    jump[1][0]=++tot;
+    for (int i=1;i<=n;i++) 
+        for (int p=last[que[i]];p;p=pre[p]) 
+            if (dis[other[p]]>dis[que[i]]) jump[other[p]][0]=que[i];
+    for (int i=1;i<=18;i++)
+        for (int j=1;j<=n;j++){
+            int cur=que[j];
+            jump[cur][i]=jump[jump[cur][i-1]][i-1];
+        }
+    build(jump[1][0],15);
+    for (int i=1;i<=n;i++) insert(que[i],jump[que[i]][0],15,a[que[i]]);
+    while (m--) {
+        int x,y,z; scanf("%d%d%d",&x,&y,&z);
+        int root=lca(x,y);
+        int ans=0;
+        ans=max(query(x,jump[root][0],z,15),query(y,jump[root][0],z,15));
+        printf("%d\n",ans);
+    }
+}
+int main() {
+    while (scanf("%d%d",&n,&m)!=EOF) work(); 
+    return 0;
+}
diff --git a/HDOJ/4758_autoAC.cpp b/HDOJ/4758_autoAC.cpp
new file mode 100644
index 0000000..b23fe7d
--- /dev/null
+++ b/HDOJ/4758_autoAC.cpp
@@ -0,0 +1,131 @@
+#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 MOD = 1e9+7;
+int dp[110][110][220][4];
+int n,m;
+    int ne[420][2],fail[420],en[420];
+    int root,L;
+    inline int change(char ch)
+    {
+        if(ch == 'R')return 0;
+        else return 1;
+    }
+    inline int newnode()
+    {
+        for(int i = 0;i < 2;i++)
+            ne[L][i] = -1;
+        en[L++] = 0;
+        return L-1;
+    }
+    inline void init()
+    {
+        L = 0;
+        root = newnode();
+    }
+    inline void insert(char buf[],int id)
+    {
+        int len = strlen(buf);
+        int now = root;
+        for(int i = 0;i < len;i++)
+        {
+            if(ne[now][change(buf[i])] == -1)
+                ne[now][change(buf[i])] = newnode();
+            now = ne[now][change(buf[i])];
+        }
+        en[now] |= (1<<id);
+    }
+    inline void build()
+    {
+        queue<int>Q;
+        fail[root] = root;
+        for(int i = 0;i < 2;i++)
+            if(ne[root][i] == -1)
+                ne[root][i] = root;
+            else
+            {
+                fail[ne[root][i]] = root;
+                Q.push(ne[root][i]);
+            }
+        while( !Q.empty() )
+        {
+            int now = Q.front();
+            Q.pop();
+            en[now] |= en[fail[now]];
+            for(int i = 0;i < 2;i++)
+                if(ne[now][i] == -1)
+                    ne[now][i] = ne[fail[now]][i];
+                else
+                {
+                    fail[ne[now][i]]=ne[fail[now]][i];
+                    Q.push(ne[now][i]);
+                }
+        }
+    }
+    inline int solve()
+    {
+        dp[0][0][0][0] = 1;
+        int ret = 0;
+            for(int x = 0;x <= n;x++)
+                for(int y = 0;y <= m;y++)
+                    for(int i = 0;i < L;i++)
+                    for(int k = 0;k < 4;k++)
+                    {
+                        if(dp[x][y][i][k] == 0)continue;
+                        if(x < n)
+                        {
+                            int nxt = ne[i][0];
+                            dp[x+1][y][nxt][k|en[nxt]] += dp[x][y][i][k];
+                            if(dp[x+1][y][nxt][k|en[nxt]] >= MOD)
+                                dp[x+1][y][nxt][k|en[nxt]] -= MOD;
+                        }
+                        if(y < m)
+                        {
+                            int nxt = ne[i][1];
+                            dp[x][y+1][nxt][k|en[nxt]] += dp[x][y][i][k];
+                            if(dp[x][y+1][nxt][k|en[nxt]] >= MOD)
+                                dp[x][y+1][nxt][k|en[nxt]] -= MOD;
+                        }
+                    }
+        for(int i = 0;i < L;i++)
+        {
+            ret += dp[n][m][i][3];
+            if(ret >= MOD)ret -= MOD;
+        }
+        return ret;
+    }
+char str[210];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&n,&m);
+        init();
+        for(int i = 0;i < 2;i++)
+        {
+            scanf("%s",str);
+            insert(str,i);
+        }
+        build();
+        for(int i = 0;i <= n;i++)
+            for(int j = 0;j <= m;j++)
+                for(int x = 0; x < L;x++)
+                    for(int y = 0;y < 4;y++)
+                        dp[i][j][x][y] = 0;
+        printf("%d\n",solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/4759_autoAC.cpp b/HDOJ/4759_autoAC.cpp
new file mode 100644
index 0000000..231d4a0
--- /dev/null
+++ b/HDOJ/4759_autoAC.cpp
@@ -0,0 +1,349 @@
+#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;
+#define MAXN 9999
+#define MAXSIZE 1010
+#define DLEN 4
+class BigNum
+{
+public:
+    int a[500];  
+    int len;
+public:
+    BigNum(){len=1;memset(a,0,sizeof(a));}  
+    BigNum(const int);     
+    BigNum(const char*);   
+    BigNum(const BigNum &); 
+    BigNum &operator=(const BigNum &); 
+    friend istream& operator>>(istream&,BigNum&); 
+    friend ostream& operator<<(ostream&,BigNum&);
+    BigNum operator+(const BigNum &)const; 
+    BigNum operator-(const BigNum &)const; 
+    BigNum operator*(const BigNum &)const;  
+    BigNum operator/(const int &)const;     
+    BigNum operator^(const int &)const;    
+    int operator%(const int &)const;       
+    bool operator>(const BigNum &T)const;   
+    bool operator>(const int &t)const;      
+    void print();        
+};
+BigNum::BigNum(const int b)  
+{
+    int c,d=b;
+    len=0;
+    memset(a,0,sizeof(a));
+    while(d>MAXN)
+    {
+        c=d-(d/(MAXN+1))*(MAXN+1);
+        d=d/(MAXN+1);
+        a[len++]=c;
+    }
+    a[len++]=d;
+}
+BigNum::BigNum(const char *s)  
+{
+    int t,k,index,L,i;
+    memset(a,0,sizeof(a));
+    L=strlen(s);
+    len=L/DLEN;
+    if(L%DLEN)len++;
+    index=0;
+    for(i=L-1;i>=0;i-=DLEN)
+    {
+        t=0;
+        k=i-DLEN+1;
+        if(k<0)k=0;
+        for(int j=k;j<=i;j++)
+            t=t*10+s[j]-'0';
+        a[index++]=t;
+    }
+}
+BigNum::BigNum(const BigNum &T):len(T.len)  
+{
+    int i;
+    memset(a,0,sizeof(a));
+    for(i=0;i<len;i++)
+        a[i]=T.a[i];
+}
+BigNum & BigNum::operator=(const BigNum &n)  
+{
+    int i;
+    len=n.len;
+    memset(a,0,sizeof(a));
+    for(i=0;i<len;i++)
+        a[i]=n.a[i];
+    return *this;
+}
+istream& operator>>(istream &in,BigNum &b)
+{
+    char ch[MAXSIZE*4];
+    int i=-1;
+    in>>ch;
+    int L=strlen(ch);
+    int count=0,sum=0;
+    for(i=L-1;i>=0;)
+    {
+        sum=0;
+        int t=1;
+        for(int j=0;j<4&&i>=0;j++,i--,t*=10)
+        {
+            sum+=(ch[i]-'0')*t;
+        }
+        b.a[count]=sum;
+        count++;
+    }
+    b.len=count++;
+    return in;
+}
+ostream& operator<<(ostream& out,BigNum& b) 
+{
+    int i;
+    cout<<b.a[b.len-1];
+    for(i=b.len-2;i>=0;i--)
+    {
+        printf("%04d",b.a[i]);
+    }
+    return out;
+}
+BigNum BigNum::operator+(const BigNum &T)const   
+{
+    BigNum t(*this);
+    int i,big;
+    big=T.len>len?T.len:len;
+    for(i=0;i<big;i++)
+    {
+        t.a[i]+=T.a[i];
+        if(t.a[i]>MAXN)
+        {
+            t.a[i+1]++;
+            t.a[i]-=MAXN+1;
+        }
+    }
+    if(t.a[big]!=0)
+       t.len=big+1;
+    else t.len=big;
+    return t;
+}
+BigNum BigNum::operator-(const BigNum &T)const  
+{
+    int i,j,big;
+    bool flag;
+    BigNum t1,t2;
+    if(*this>T)
+    {
+        t1=*this;
+        t2=T;
+        flag=0;
+    }
+    else
+    {
+        t1=T;
+        t2=*this;
+        flag=1;
+    }
+    big=t1.len;
+    for(i=0;i<big;i++)
+    {
+        if(t1.a[i]<t2.a[i])
+        {
+            j=i+1;
+            while(t1.a[j]==0)
+                j++;
+            t1.a[j--]--;
+            while(j>i)
+                t1.a[j--]+=MAXN;
+            t1.a[i]+=MAXN+1-t2.a[i];
+        }
+        else t1.a[i]-=t2.a[i];
+    }
+    t1.len=big;
+    while(t1.a[len-1]==0 && t1.len>1)
+    {
+        t1.len--;
+        big--;
+    }
+    if(flag)
+        t1.a[big-1]=0-t1.a[big-1];
+    return t1;
+}
+BigNum BigNum::operator*(const BigNum &T)const  
+{
+    BigNum ret;
+    int i,j,up;
+    int temp,temp1;
+    for(i=0;i<len;i++)
+    {
+        up=0;
+        for(j=0;j<T.len;j++)
+        {
+            temp=a[i]*T.a[j]+ret.a[i+j]+up;
+            if(temp>MAXN)
+            {
+                temp1=temp-temp/(MAXN+1)*(MAXN+1);
+                up=temp/(MAXN+1);
+                ret.a[i+j]=temp1;
+            }
+            else
+            {
+                up=0;
+                ret.a[i+j]=temp;
+            }
+        }
+        if(up!=0)
+           ret.a[i+j]=up;
+    }
+    ret.len=i+j;
+    while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
+    return ret;
+}
+BigNum BigNum::operator/(const int &b)const  
+{
+    BigNum ret;
+    int i,down=0;
+    for(i=len-1;i>=0;i--)
+    {
+        ret.a[i]=(a[i]+down*(MAXN+1))/b;
+        down=a[i]+down*(MAXN+1)-ret.a[i]*b;
+    }
+    ret.len=len;
+    while(ret.a[ret.len-1]==0 && ret.len>1)
+        ret.len--;
+    return ret;
+}
+int BigNum::operator%(const int &b)const   
+{
+    int i,d=0;
+    for(i=len-1;i>=0;i--)
+        d=((d*(MAXN+1))%b+a[i])%b;
+    return d;
+}
+BigNum BigNum::operator^(const int &n)const  
+{
+    BigNum t,ret(1);
+    int i;
+    if(n<0)exit(-1);
+    if(n==0)return 1;
+    if(n==1)return *this;
+    int m=n;
+    while(m>1)
+    {
+        t=*this;
+        for(i=1;(i<<1)<=m;i<<=1)
+           t=t*t;
+        m-=i;
+        ret=ret*t;
+        if(m==1)ret=ret*(*this);
+    }
+    return ret;
+}
+bool BigNum::operator>(const BigNum &T)const    
+{
+    int ln;
+    if(len>T.len)return true;
+    else if(len==T.len)
+    {
+        ln=len-1;
+        while(a[ln]==T.a[ln]&&ln>=0)
+          ln--;
+        if(ln>=0 && a[ln]>T.a[ln])
+           return true;
+        else
+           return false;
+    }
+    else
+       return false;
+}
+bool BigNum::operator>(const int &t)const  
+{
+    BigNum b(t);
+    return *this>b;
+}
+void BigNum::print()  
+{
+    int i;
+    printf("%d",a[len-1]);
+    for(i=len-2;i>=0;i--)
+      printf("%04d",a[i]);
+    printf("\n");
+}
+bool ONE(BigNum a)
+{
+    if(a.len == 1 && a.a[0] == 1)return true;
+    else return false;
+}
+BigNum A,B,X,Y;
+char str1[10010],str2[10010],str3[10010],str4[10010];
+int a[1010],b[1010],x[1010],y[1010];
+int c[1010];
+int main()
+{
+    int T;
+    int n;
+    int iCase = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%d",&n);
+        cin>>A>>X>>B>>Y;
+        printf("Case %d: ",iCase) ;
+        A = A-1;
+        X = X-1;
+        B = B-1;
+        Y = Y-1;
+        for(int i = 0;i < n;i++)
+        {
+            if(A.a[0]%2 == 0)a[i] = 0;
+            else a[i] = 1;
+            if(B.a[0]%2 == 0)b[i] = 0;
+            else b[i] = 1;
+            if(X.a[0]%2 == 0)x[i] = 0;
+            else x[i] = 1;
+            if(Y.a[0]%2 == 0)y[i] = 0;
+            else y[i] = 1;
+            A = A/2;
+            B = B/2;
+            X = X/2;
+            Y = Y/2;
+        }
+        bool flag = false;
+        for(int k = 0;k <= n;k++)
+        {
+            x[n] = x[0];
+            y[n] = y[0];
+            for(int i = 0;i < n;i++)
+            {
+                x[i] = x[i+1];
+                y[i] = y[i+1];
+            }
+            for(int i = 0;i < n;i++)
+            {
+                if(a[i] == x[i])c[i] = 0;
+                else c[i] = 1;
+            }
+            bool fff = true;
+            for(int i = 0;i < n;i++)
+                if(b[i]^c[i] != y[i])
+                {
+                    fff = false;
+                    break;
+                }
+            if(fff)flag = true;
+            if(flag)break;
+        }
+        if(flag)printf("Yes\n");
+        else printf("No\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4760_autoAC.cpp b/HDOJ/4760_autoAC.cpp
new file mode 100644
index 0000000..e689962
--- /dev/null
+++ b/HDOJ/4760_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <vector>
+#define pii pair<int,LL>
+using namespace std;
+typedef long long LL;
+const int N = 100005;
+struct Trie {
+    Trie *next[2];
+    vector<pii> a;
+}*root , s[N << 2];
+char ope[10];
+int tot = 0 , can[N] , ok[1025] , idx = 0;
+LL ip (int a , int b , int c , int d) {
+    LL ret = 0;
+    ret |= (LL)a << 24;
+    ret |= (LL)b << 16;
+    ret |= (LL)c << 8;
+    ret |= d;
+    return ret;
+}
+Trie *newnode () {
+    Trie *t = &s[tot ++];
+    t -> next[0] = t -> next[1] = NULL;
+    t -> a.clear();
+    return t;
+}
+void insert (Trie *p , LL ip , int l , int id) {
+    for (int i = 0 ; i < l ; i ++) {
+        int c = (ip >> (31 - i)) & 1;
+        if (p -> next[c] == NULL)
+            p -> next[c] = newnode ();
+        p = p -> next[c];
+    }
+    LL num = ip & ((1 << (32 - l)) - 1);
+    p -> a.push_back (make_pair (id , num));
+}
+void down (LL ip) {
+    Trie *p = root;
+    for (int i = 31 ; i >= 0 ; i --) {
+        int c = (ip >> i) & 1;
+        if (p -> next[c] == NULL) return ;
+        p = p -> next[c];
+        for (int j = 0 ; j < p -> a.size() ; j ++) {
+            if (can[p -> a[j].first] && p -> a[j].second <= (ip & ((1 << (i - 1)) - 1)))
+                ok[p -> a[j].first] = idx;
+        }
+    }
+}
+bool up (LL ip) {
+    Trie *p = root;
+    for (int i = 31 ; i >= 0 ; i --) {
+        int c = (ip >> i) & 1;
+        if (p -> next[c] == NULL) return false;
+        p = p -> next[c];
+        for (int j = 0 ; j < p -> a.size() ; j ++) {
+            if (can[p -> a[j].first] && p -> a[j].second <= (ip & ((1 << (i - 1)) - 1)) && ok[p -> a[j].first] == idx)
+                return true;
+        }
+    }
+    return false;
+}
+int main () {
+    root = newnode ();
+    while (scanf ("%s" , ope) != EOF) {
+        if (ope[0] == 'E') {
+            int id , k , a , b , c , d , u;
+            scanf ("%d %d" , &id , &k);
+            for (int i = 0 ; i < k ; i ++) {
+                scanf ("%d.%d.%d.%d/%d" , &a , &b , &c , &d , &u);
+                insert (root , ip (a , b , c , d) , u , id);
+            }
+            can[id] = 1;
+        }
+        else if (ope[0] == 'D') {
+            int id;scanf ("%d" , &id);
+            can[id] = 0;
+        }
+        else {
+            idx ++;
+            int a , b , c , d;
+            scanf ("%d.%d.%d.%d" , &a , &b , &c , &d);
+            down (ip (a , b , c , d));
+            scanf ("%d.%d.%d.%d" , &a , &b , &c , &d);
+            puts (up (ip (a , b , c , d)) ? "F" : "D");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4762_autoAC.cpp b/HDOJ/4762_autoAC.cpp
new file mode 100644
index 0000000..68cd4f8
--- /dev/null
+++ b/HDOJ/4762_autoAC.cpp
@@ -0,0 +1,304 @@
+#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;
+#define MAXN 9999
+#define MAXSIZE 1010
+#define DLEN 4
+class BigNum
+{
+private:
+    int a[500];  
+    int len;
+public:
+    BigNum(){len=1;memset(a,0,sizeof(a));}  
+    BigNum(const int);    
+    BigNum(const char*);   
+    BigNum(const BigNum &); 
+    BigNum &operator=(const BigNum &); 
+    friend istream& operator>>(istream&,BigNum&); 
+    friend ostream& operator<<(ostream&,BigNum&); 
+    BigNum operator+(const BigNum &)const; 
+    BigNum operator-(const BigNum &)const;  
+    BigNum operator*(const BigNum &)const;  
+    BigNum operator/(const int &)const;    
+    BigNum operator^(const int &)const;     
+    int operator%(const int &)const;      
+    bool operator>(const BigNum &T)const;  
+    bool operator>(const int &t)const;    
+    void print();       
+};
+BigNum::BigNum(const int b)   
+{
+    int c,d=b;
+    len=0;
+    memset(a,0,sizeof(a));
+    while(d>MAXN)
+    {
+        c=d-(d/(MAXN+1))*(MAXN+1);
+        d=d/(MAXN+1);
+        a[len++]=c;
+    }
+    a[len++]=d;
+}
+BigNum::BigNum(const char *s)  
+{
+    int t,k,index,L,i;
+    memset(a,0,sizeof(a));
+    L=strlen(s);
+    len=L/DLEN;
+    if(L%DLEN)len++;
+    index=0;
+    for(i=L-1;i>=0;i-=DLEN)
+    {
+        t=0;
+        k=i-DLEN+1;
+        if(k<0)k=0;
+        for(int j=k;j<=i;j++)
+            t=t*10+s[j]-'0';
+        a[index++]=t;
+    }
+}
+BigNum::BigNum(const BigNum &T):len(T.len)  
+{
+    int i;
+    memset(a,0,sizeof(a));
+    for(i=0;i<len;i++)
+        a[i]=T.a[i];
+}
+BigNum & BigNum::operator=(const BigNum &n) 
+{
+    int i;
+    len=n.len;
+    memset(a,0,sizeof(a));
+    for(i=0;i<len;i++)
+        a[i]=n.a[i];
+    return *this;
+}
+istream& operator>>(istream &in,BigNum &b)
+{
+    char ch[MAXSIZE*4];
+    int i=-1;
+    in>>ch;
+    int L=strlen(ch);
+    int count=0,sum=0;
+    for(i=L-1;i>=0;)
+    {
+        sum=0;
+        int t=1;
+        for(int j=0;j<4&&i>=0;j++,i--,t*=10)
+        {
+            sum+=(ch[i]-'0')*t;
+        }
+        b.a[count]=sum;
+        count++;
+    }
+    b.len=count++;
+    return in;
+}
+ostream& operator<<(ostream& out,BigNum& b)  
+{
+    int i;
+    cout<<b.a[b.len-1];
+    for(i=b.len-2;i>=0;i--)
+    {
+        printf("%04d",b.a[i]);
+    }
+    return out;
+}
+BigNum BigNum::operator+(const BigNum &T)const 
+{
+    BigNum t(*this);
+    int i,big;
+    big=T.len>len?T.len:len;
+    for(i=0;i<big;i++)
+    {
+        t.a[i]+=T.a[i];
+        if(t.a[i]>MAXN)
+        {
+            t.a[i+1]++;
+            t.a[i]-=MAXN+1;
+        }
+    }
+    if(t.a[big]!=0)
+       t.len=big+1;
+    else t.len=big;
+    return t;
+}
+BigNum BigNum::operator-(const BigNum &T)const  
+{
+    int i,j,big;
+    bool flag;
+    BigNum t1,t2;
+    if(*this>T)
+    {
+        t1=*this;
+        t2=T;
+        flag=0;
+    }
+    else
+    {
+        t1=T;
+        t2=*this;
+        flag=1;
+    }
+    big=t1.len;
+    for(i=0;i<big;i++)
+    {
+        if(t1.a[i]<t2.a[i])
+        {
+            j=i+1;
+            while(t1.a[j]==0)
+                j++;
+            t1.a[j--]--;
+            while(j>i)
+                t1.a[j--]+=MAXN;
+            t1.a[i]+=MAXN+1-t2.a[i];
+        }
+        else t1.a[i]-=t2.a[i];
+    }
+    t1.len=big;
+    while(t1.a[len-1]==0 && t1.len>1)
+    {
+        t1.len--;
+        big--;
+    }
+    if(flag)
+        t1.a[big-1]=0-t1.a[big-1];
+    return t1;
+}
+BigNum BigNum::operator*(const BigNum &T)const  
+{
+    BigNum ret;
+    int i,j,up;
+    int temp,temp1;
+    for(i=0;i<len;i++)
+    {
+        up=0;
+        for(j=0;j<T.len;j++)
+        {
+            temp=a[i]*T.a[j]+ret.a[i+j]+up;
+            if(temp>MAXN)
+            {
+                temp1=temp-temp/(MAXN+1)*(MAXN+1);
+                up=temp/(MAXN+1);
+                ret.a[i+j]=temp1;
+            }
+            else
+            {
+                up=0;
+                ret.a[i+j]=temp;
+            }
+        }
+        if(up!=0)
+           ret.a[i+j]=up;
+    }
+    ret.len=i+j;
+    while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
+    return ret;
+}
+BigNum BigNum::operator/(const int &b)const  
+{
+    BigNum ret;
+    int i,down=0;
+    for(i=len-1;i>=0;i--)
+    {
+        ret.a[i]=(a[i]+down*(MAXN+1))/b;
+        down=a[i]+down*(MAXN+1)-ret.a[i]*b;
+    }
+    ret.len=len;
+    while(ret.a[ret.len-1]==0 && ret.len>1)
+        ret.len--;
+    return ret;
+}
+int BigNum::operator%(const int &b)const   
+{
+    int i,d=0;
+    for(i=len-1;i>=0;i--)
+        d=((d*(MAXN+1))%b+a[i])%b;
+    return d;
+}
+BigNum BigNum::operator^(const int &n)const  
+{
+    BigNum t,ret(1);
+    int i;
+    if(n<0)exit(-1);
+    if(n==0)return 1;
+    if(n==1)return *this;
+    int m=n;
+    while(m>1)
+    {
+        t=*this;
+        for(i=1;(i<<1)<=m;i<<=1)
+           t=t*t;
+        m-=i;
+        ret=ret*t;
+        if(m==1)ret=ret*(*this);
+    }
+    return ret;
+}
+bool BigNum::operator>(const BigNum &T)const    
+{
+    int ln;
+    if(len>T.len)return true;
+    else if(len==T.len)
+    {
+        ln=len-1;
+        while(a[ln]==T.a[ln]&&ln>=0)
+          ln--;
+        if(ln>=0 && a[ln]>T.a[ln])
+           return true;
+        else
+           return false;
+    }
+    else
+       return false;
+}
+bool BigNum::operator>(const int &t)const 
+{
+    BigNum b(t);
+    return *this>b;
+}
+void BigNum::print()   
+{
+    int i;
+    printf("%d",a[len-1]);
+    for(i=len-2;i>=0;i--)
+      printf("%04d",a[i]);
+    printf("\n");
+}
+int main()
+{
+    int m,n;
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&m,&n);
+        BigNum tt = 1;
+        for(int i = 1;i < n;i++)
+            tt = tt*m;
+        int tmp = n;
+        for(int i = 2;i <= n;i++)
+        {
+            while( tmp%i == 0 && (tt%i == 0) )
+            {
+                tmp /= i;
+                tt = tt/i;
+            }
+        }
+        printf("%d/",tmp);
+        tt.print();
+    }
+    return 0;
+}
diff --git a/HDOJ/4763_autoAC.cpp b/HDOJ/4763_autoAC.cpp
new file mode 100644
index 0000000..c7aa123
--- /dev/null
+++ b/HDOJ/4763_autoAC.cpp
@@ -0,0 +1,80 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <algorithm>
+#include <cstdlib>
+#include <cmath>
+#include <map>
+#include <sstream>
+#include <queue>
+#include <vector>
+#define MAXN 1111111
+#define MAXM 211111
+#define PI acos(-1.0)
+#define eps 1e-8
+#define INF 1e10
+using namespace std;
+int A[MAXN], B[MAXN];
+char sa[MAXN];
+void preExKmp(char x[],int m,int A[]){
+    int ind=0,k=1;
+    A[0]=m;
+    while (ind + 1 < m && x[ind+1]==x[ind]) ++ind;
+    A[1]=ind;
+    for (int i=2;i<m;++i){
+        if (i<=k+A[k]-1 && A[i-k]+i<k+A[k])
+            A[i]=A[i-k];
+        else{
+            ind=max(0,k+A[k]-i);
+            while (ind + i < m && x[ind+i]==x[ind]) ++ind;
+            A[i]=ind,k=i;
+        }
+    }
+}
+void exKmp(char x[],int m , char y[],int n,int A[],int B[]){
+    preExKmp(x,m,A);
+    int ind=0,k=0;
+    while (ind<n && ind<m && x[ind]==y[ind]) ind++;
+    B[0]=ind;
+    for (int i=1;i<n;++i){
+        if (i < k+B[k]-1 && A[i-k]+i<k+B[k])
+            B[i]=A[i-k];
+        else{
+            ind = max(0,k+B[k]-i);
+            while (ind +i<n && ind<m && y[ind+i]==x[ind]) ++ind;
+            B[i]=ind;k=i;
+        }
+    }
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%s", sa);
+        int len = strlen(sa);
+        preExKmp(sa, len, A);
+        int ans = 0;
+        int lst = len - len / 3, mxlen;
+        for(int i = 0; i < len; i++)
+        {
+            mxlen = min(i, A[i]);
+            mxlen = min(mxlen, (len - i) / 2);
+            ans = max(ans, mxlen);
+        }
+        int res = 0;
+        for(int i = lst; i < len; i++)
+        {
+            if(A[i] + i != len) continue;
+            if(ans >= A[i])
+            {
+                res = A[i];
+                break;
+            }
+        }
+        printf("%d\n", res);
+    }
+    return 0;
+}
diff --git a/HDOJ/4764_autoAC.cpp b/HDOJ/4764_autoAC.cpp
new file mode 100644
index 0000000..97740bb
--- /dev/null
+++ b/HDOJ/4764_autoAC.cpp
@@ -0,0 +1,25 @@
+#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;
+int n,k;
+int main()
+{
+    while(scanf("%d%d",&n,&k) == 2)
+    {
+        if(n == 0 && k == 0)break;
+        if((n-1)%(k+1) == 0)printf("Jiang\n");
+        else printf("Tang\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4766_autoAC.cpp b/HDOJ/4766_autoAC.cpp
new file mode 100644
index 0000000..1093749
--- /dev/null
+++ b/HDOJ/4766_autoAC.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+using namespace std;
+const int maxn=1e3+9;
+const double inf=1e11,epx=0.00001;
+int n;
+double rx,ry,d;
+double x[maxn],y[maxn];
+double cal(double x1,double y1,double x2,double y2)
+{
+    double a=(x1-x2)*(x1-x2);
+    double b=(y1-y2)*(y1-y2);
+    return sqrt(a+b);
+}
+bool chk(double xx,double yy)
+{
+    for(int i=1;i<=n;i++)
+    if(cal(xx,yy,x[i],y[i])>d+epx) return false;
+    return true;
+}
+int main()
+{
+    while(scanf("%lf %lf",&rx,&ry)!=EOF)
+    {
+        scanf("%lf",&d);
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++)
+        scanf("%lf %lf",&x[i],&y[i]);
+        bool flag=false;
+        double ans=inf;
+        if(chk(rx,ry))
+        {
+            ans=0;
+            flag=true;
+        }
+        for(int i=1;i<=n;i++)
+        {
+            double tmp=cal(x[i],y[i],rx,ry);
+            double xx=x[i]+(rx-x[i])*(d/tmp);
+            double yy=y[i]+(ry-y[i])*(d/tmp);
+            if(ans>cal(xx,yy,rx,ry))
+            if(chk(xx,yy))
+            {
+                ans=cal(xx,yy,rx,ry);
+                flag=true;
+            }
+        }
+        for(int i=1;i<=n;i++)
+        for(int j=i+1;j<=n;j++)
+        {
+            if(cal(x[i],y[i],x[j],y[j])>2*d+epx) continue;
+            if(fabs(x[i]-x[j])<epx&&fabs(y[i]-y[j])<epx) continue;
+            double x1=x[j]-x[i];
+            double y1=y[j]-y[i];
+            double xx=x[i]+x1/2,yy=y[i]+y1/2;
+            double tmp=cal(xx,yy,x[i],y[i]);
+            double txt=sqrt(d*d-tmp*tmp);
+            double ex,ey;
+            if(fabs(x1-0)>epx) ey=1,ex=-y1/x1;
+            else ex=1,ey=-x1/y1;
+            double tt=sqrt(ex*ex+ey*ey);
+            xx+=txt*ex/tt;
+            yy+=txt*ey/tt;
+            if(cal(xx,yy,rx,ry)<ans)
+            if(chk(xx,yy))
+            {
+                ans=cal(xx,yy,rx,ry);
+                flag=true;
+            }
+            xx-=txt*ex*2/tt;
+            yy-=txt*ey*2/tt;
+            if(cal(xx,yy,rx,ry)<ans)
+            if(chk(xx,yy))
+            {
+                ans=cal(xx,yy,rx,ry);
+                flag=true;
+            }
+        }
+        if(!flag) printf("X\n");
+        else printf("%.2lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4767_autoAC.cpp b/HDOJ/4767_autoAC.cpp
new file mode 100644
index 0000000..69afa4a
--- /dev/null
+++ b/HDOJ/4767_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <stack>
+#include <queue>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <set>
+#include <vector>
+#include <cstring>
+#include <algorithm>
+#define INF 0x7ffffffffffLL
+#define N 50
+#define LL long long
+#define mod 95041567
+using namespace std;
+LL num[N][N], q[N];
+int p[5] = {31, 37, 41, 43, 47}, arr[5];
+void Preprocessing(){
+    q[0] = q[1]= 1;
+    num[0][0] = num[1][0] = 1, num[1][1] = 2;
+    for(int i = 2; i < 50; ++i){
+        q[i] = num[i][0] = num[i - 1][i - 1];
+        for(int j = 1; j <= i; ++j)
+            num[i][j] = (num[i - 1][j - 1] + num[i][j - 1]) %mod; 
+    }
+}
+int cal(int x, LL n){
+    int _q[N];
+    for(int i = 0; i <= x; ++i) _q[i] = q[i] % x;
+    int len = 0;
+    int _mod[15];
+    while(n){
+        _mod[len++] = n % x;
+        n /= x;
+    }
+    int _arr[N];
+    for(int i = 1; i < len; ++i)
+        for(int j = 1; j <= _mod[i]; ++j){
+            for(int k = 0; k < x; ++k)
+                _arr[k] = (_q[k] * i + _q[k + 1]) % x;
+            _arr[x] = (_arr[0] + _arr[1]) % x;
+            for(int k = 0; k <= x; ++k) _q[k] = _arr[k];
+        }
+    return _arr[_mod[0]];
+}
+void gcd(LL a, LL b, LL &x, LL &y){
+    if(!b){
+        x = 1;
+        y = 0;
+        return;
+    }
+    gcd(b, a % b, y, x);
+    y -= a / b * x;
+}
+LL china(){
+    LL d, y, x = 0;
+    for(int i = 0; i < 5; ++i){
+        LL w = mod / p[i];
+        gcd(p[i], w, d, y);
+        x = (x + y * w * arr[i]) % mod;
+    }
+    return (x + mod) % mod;
+}
+int main()
+{
+    Preprocessing();
+    int t;
+    scanf("%d", &t);
+    while(t--){
+        LL n;
+        scanf("%I64d", &n);
+        if(n < 50){
+            printf("%I64d\n", q[n]);
+            continue;
+        }
+        for(int i = 0; i < 5; ++i)
+            arr[i] = cal(p[i], n);
+    printf("%I64d\n", china());
+    }
+    return 0;
+}
diff --git a/HDOJ/4768_autoAC.cpp b/HDOJ/4768_autoAC.cpp
new file mode 100644
index 0000000..987eb7e
--- /dev/null
+++ b/HDOJ/4768_autoAC.cpp
@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+#define ll __int64
+#define L 20005
+ll a[L],b[L],c[L],l,r,n;
+ll solve(ll mid)
+{
+    ll k,sum = 0;
+    int i;
+    for(i = 0; i<n; i++)
+    {
+        k = min(mid,b[i]);
+        if(k>=a[i])
+            sum+=(k-a[i])/c[i]+1;
+    }
+    return sum;
+}
+int main()
+{
+    int i,j;
+    while(~scanf("%d",&n))
+    {
+        for(i = 0; i<n; i++)
+            scanf("%I64d%I64d%I64d",&a[i],&b[i],&c[i]);
+        l = 0,r = 1LL<<31;
+        ll mid;
+        while(l<r)
+        {
+            mid = (l+r)/2;
+            if(solve(mid)%2) r = mid;
+            else l = mid+1;
+        }
+        if(l == 1LL<<31)
+            printf("DC Qiang is unhappy.\n");
+        else
+        {
+            while(solve(l)%2==0)l--;
+            printf("%I64d %I64d\n",l,solve(l)-solve(l-1));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4770_autoAC.cpp b/HDOJ/4770_autoAC.cpp
new file mode 100644
index 0000000..21cf537
--- /dev/null
+++ b/HDOJ/4770_autoAC.cpp
@@ -0,0 +1,124 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+#include <algorithm>
+using namespace std;
+int getnum(int x)
+{
+    int sum=0;
+    while(x)
+    {
+        sum+=x%2;
+        x/=2;
+    }
+    return sum;
+}
+int dir[4][2]={-1,0,0,1,1,0,0,-1};
+char map[210][210];
+int vis[210][210];
+int po[20][2];
+int num,n,m;
+int check(int x,int y)
+{
+    if(x<1||y<1||x>n||y>m)
+    return 0;
+    return 1;
+}
+int isok(int flag,int limit)
+{
+    int i;
+    for(i=0;i<num;i++)
+    {
+        int x=po[i][0],y=po[i][1];
+        if(vis[x][y]==limit)
+        continue;
+        vis[x][y]=0;
+    }
+    for(i=0;i<num;i++)
+    {
+        if((flag>>i)&1)
+        {
+            int x=po[i][0],y=po[i][1];
+            if(check(x-1,y)&&map[x-1][y]=='#')
+            return 0;
+            if(!vis[x-1][y])
+            vis[x-1][y]=1;
+            if(check(x,y+1)&&map[x][y+1]=='#')
+            return 0;
+            if(!vis[x][y+1])
+            vis[x][y+1]=1;
+            if(!vis[x][y])
+            vis[x][y]=1;
+        }
+    }
+    for(i=0;i<num;i++)
+    {
+        int x=po[i][0],y=po[i][1];
+        if(vis[x][y]==0)
+        return 0;
+    }
+    return 1;
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m)&&(n+m))
+    {
+        memset(vis,0,sizeof(vis));
+        int i,j,k;
+        for(i=1;i<=n;i++)
+        {
+            scanf("%s",map[i]+1);
+        }
+        num=0;
+        for(i=1;i<=n;i++)
+        {
+            for(j=1;j<=m;j++)
+            {
+                if(map[i][j]=='.')
+                {
+                    po[num][0]=i;
+                    po[num++][1]=j;
+                }
+            }
+        }
+        if(num==0)
+        {
+            printf("0\n");
+            continue;
+        }
+        int limit=1<<num,sum=10000;
+        int ans=2100000000;
+        for(i=0;i<num;i++)
+        {
+            int x=po[i][0],y=po[i][1],tmp=0;
+            for(j=0;j<4;j++)
+            {
+                for(k=0;k<num;k++)
+                {
+                    int xx=po[k][0],yy=po[k][1];
+                    vis[xx][yy]=0;
+                }
+                if((check(dir[j][0]+x,dir[j][1]+y)&&map[dir[j][0]+x][dir[j][1]+y]=='#')||(check(dir[(j+1)%4][0]+x,dir[(j+1)%4][1]+y)&&map[dir[(j+1)%4][0]+x][dir[(j+1)%4][1]+y]=='#'))
+                continue;
+                sum++;
+                vis[dir[j][0]+x][dir[j][1]+y]=sum;
+                vis[dir[(j+1)%4][0]+x][dir[(j+1)%4][1]+y]=sum;
+                vis[x][y]=sum;
+                for(k=0;k<limit;k++)
+                {
+                    if((k>>i)&1)
+                    continue;
+                    if(isok(k,sum))
+                    {
+                        ans=min(ans,1+getnum(k));
+                    }
+                }
+            }
+        }
+        if(ans==2100000000)
+        printf("-1\n");
+        else
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4771_autoAC.cpp b/HDOJ/4771_autoAC.cpp
new file mode 100644
index 0000000..29e7763
--- /dev/null
+++ b/HDOJ/4771_autoAC.cpp
@@ -0,0 +1,102 @@
+#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 n,m;
+char g[110][110];
+int a[110][110];
+int sx,sy;
+int k;
+int dp[110][110][32];
+int px[10],py[10];
+struct Node
+{
+    int x,y;
+    int s;
+    Node(int _x = 0,int _y = 0,int _s = 0)
+    {
+        x = _x;
+        y = _y;
+        s = _s;
+    }
+};
+int mo[][2] = {{0,1},{0,-1},{1,0},{-1,0}};
+int bfs()
+{
+    queue<Node>q;
+    int s = 0;
+    for(int i = 0;i < k;i++)
+        if(sx == px[i] && sy == py[i])
+            s = s|(1<<i);
+    q.push(Node(sx,sy,s));
+    memset(dp,-1,sizeof(dp));
+    dp[sx][sy][s] = 0;
+    while(!q.empty())
+    {
+        Node tmp = q.front();
+        q.pop();
+        if(tmp.s == ((1<<k) - 1))
+        {
+            return dp[tmp.x][tmp.y][tmp.s];
+        }
+        for(int i = 0;i < 4;i++)
+        {
+            int nx = tmp.x + mo[i][0];
+            int ny = tmp.y + mo[i][1];
+            int s = tmp.s;
+            if(nx < 0 || nx >= n || ny < 0 || ny >= m)continue;
+            if(a[nx][ny] == -2)continue;
+            for(int j = 0;j < k;j++)
+                if(nx == px[j] && ny == py[j])
+                {
+                    s |= (1<<j);
+                }
+            if(dp[nx][ny][s] != -1)continue;
+            dp[nx][ny][s] = dp[tmp.x][tmp.y][tmp.s] + 1;
+            q.push(Node(nx,ny,s));
+        }
+    }
+    return -1;
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m) == 2)
+    {
+        if(n == 0 && m == 0)break;
+        for(int i = 0;i < n;i++)
+            scanf("%s",g[i]);
+        memset(a,-1,sizeof(a));
+        for(int i = 0;i < n;i++)
+            for(int j = 0;j < m;j++)
+            {
+                if(g[i][j] == '@')
+                {
+                    sx = i;
+                    sy = j;
+                }
+                if(g[i][j] == '#')
+                    a[i][j] = -2;
+            }
+        scanf("%d",&k);
+        int x,y;
+        for(int i = 0;i < k;i++)
+        {
+            scanf("%d%d",&x,&y);
+            x --;
+            y--;
+            px[i] = x;
+            py[i] = y;
+        }
+        printf("%d\n",bfs());
+    }
+    return 0;
+}
diff --git a/HDOJ/4772_autoAC.cpp b/HDOJ/4772_autoAC.cpp
new file mode 100644
index 0000000..49184d2
--- /dev/null
+++ b/HDOJ/4772_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <algorithm>
+using namespace std;
+const int N = 35;
+int n;
+int map1[N][N], map2[N][N];
+int a1[N][N], a2[N][N], a3[N][N];
+void Init() {
+    memset(map1, 0, sizeof(map1));
+    memset(map2, 0, sizeof(map2));
+    for(int i = 0; i < n ; i++)
+        for(int j = 0; j < n; j++)
+            scanf("%d", &map1[i][j]);
+    for(int i = 0; i < n ; i++)
+        for(int j = 0; j < n; j++)
+            scanf("%d", &map2[i][j]);
+    for(int i = 0; i < n; i++)
+        for(int j = 0; j < n; j++)
+            a1[i][j] = map2[j][n-i-1];
+    for(int i = 0; i < n; i++)
+        for(int j = 0; j < n; j++)
+            a2[i][j] = a1[j][n-i-1];
+    for(int i = 0; i < n; i++)
+        for(int j = 0; j < n; j++)
+            a3[i][j] = a2[j][n-i-1];
+}
+int main() {
+    while(scanf("%d", &n), n) {
+        Init() ;
+        int pwd1 = 0, pwd2 = 0, pwd3 = 0, pwd4 = 0;
+        for(int i = 0; i < n; i++)
+            for(int j = 0; j < n; j++) {
+                if(map1[i][j] == map2[i][j]) pwd1++;
+                if(map1[i][j] == a1[i][j])   pwd2++;
+                if(map1[i][j] == a2[i][j])   pwd3++;
+                if(map1[i][j] == a3[i][j])   pwd4++;
+            }
+        int sum = 0;
+        if(pwd1 > sum) sum = pwd1;
+        if(pwd2 > sum) sum = pwd2;
+        if(pwd3 > sum) sum = pwd3;
+        if(pwd4 > sum) sum = pwd4;
+        printf("%d\n", sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4773_autoAC.cpp b/HDOJ/4773_autoAC.cpp
new file mode 100644
index 0000000..26f434e
--- /dev/null
+++ b/HDOJ/4773_autoAC.cpp
@@ -0,0 +1,156 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#define eps 0.00000001
+double x_0, y_0;
+double a[5], b[5], c[5];
+double ansx[5], ansy[5], ansr[5];
+int flag[5];
+void exchange(double &x, double &y)
+{
+     double tmp = x;
+     x = y;
+     y = tmp;
+     return ;
+}
+double dis(double x_1, double y_1, double x_2, double y_2)
+{
+     return sqrt((x_1 - x_2) * (x_1 - x_2) + (y_1 - y_2) * (y_1 - y_2));
+}
+void changepoint(double x, double y, double &ex, double &ey) 
+{
+     double d = dis(x, y, x_0, y_0);
+     ey = y_0 + (y - y_0) / (d * d);
+     ex = x_0 + (x - x_0) / (d * d);
+     return ;
+}
+void changecircle(double x, double y, double r, double &ex, double &ey, double &er)
+{
+     double x_1, y_1, x_2, y_2;
+     if(fabs(x - x_0) < eps)
+     {
+          changepoint(x, y + r, x_1, y_1);
+          changepoint(x, y- r, x_2, y_2);
+     }
+     else
+     {
+          double k = (y - y_0) / (x - x_0);
+          double tmp = sqrt(r * r / (1 + k * k));
+          changepoint(tmp + x, k * tmp + y, x_1, y_1);
+          changepoint(-tmp + x, -k * tmp + y, x_2, y_2);
+     }
+     ex = (x_1 + x_2) / 2;
+     ey = (y_1 + y_2) / 2;
+     er = dis(x_1, y_1, x_2, y_2) / 2;
+     return ;
+}
+void rotate(double s, double t, double &aa, double &bb, double &cc, double sinct, double cosct) 
+{
+     double tmpa = aa, tmpb = bb, tmpc = cc;
+     aa = tmpa * cosct - tmpb * sinct;
+     bb = tmpa * sinct + tmpb * cosct;
+     cc = tmpc + tmpa * s * cosct + tmpa * t * sinct - tmpa * s
+          - tmpb * s * sinct + tmpb * t * cosct - tmpb * t;
+     return ;
+}
+void getline(double x_1, double y_1, double r_1, double x_2, double y_2, double r_2)
+{
+     double tmpa, tmpb, tmpc;
+     tmpa = y_2 - y_1;
+     tmpb = x_1 - x_2;
+     tmpc = y_1 * (x_1 - x_2) - x_1 * (y_1 - y_2);
+     double d, detr;
+     d = dis(x_1, y_1, x_2, y_2);
+     detr = r_2 - r_1;
+     double sinct = fabs(detr) / d;
+     double cosct = sqrt(d * d - detr * detr) / d;
+     double aa = tmpa, bb = tmpb, cc = tmpc;
+     rotate(x_1, y_1, aa, bb, cc, sinct, cosct);
+     a[0] = aa;
+     b[0] = bb;
+     c[0] = cc - r_1 * sqrt(a[0] * a[0] + b[0] * b[0]);
+     aa = tmpa, bb = tmpb, cc = tmpc;
+     rotate(x_1, y_1, aa, bb, cc, -sinct, cosct);
+     a[1] = aa;
+     b[1] = bb;
+     c[1] = cc + r_1 * sqrt(a[1] * a[1] + b[1] * b[1]);
+     return ;
+}
+void getcircle(double aa, double bb, double cc, int k) 
+{
+     if(fabs(aa * x_0 + bb * y_0 - cc) < eps)
+     {
+          flag[k] = 0;
+          return ;
+     }
+     double s, t, ex, ey;
+     s = (aa * cc + x_0 * bb * bb - aa * bb * y_0) / (aa * aa + bb * bb);
+     t = (bb * cc - x_0 * aa * bb + aa * aa * y_0) / (aa * aa + bb * bb);
+     changepoint(s, t, ex, ey);
+     ansx[k] = (x_0 + ex) / 2;
+     ansy[k] = (y_0 + ey) / 2;
+     ansr[k] = dis(x_0, y_0, ex, ey) / 2;
+     return ;
+}
+double x_00,y_00,x_11,y_11,x_22,y_22,r_11,r_22;
+bool check(double x, double y, double r)
+{
+     if (fabs(dis(x,y,x_00,y_00) - r) < eps)
+     if (fabs(dis(x,y,x_11,y_11) - r - r_11) < eps)
+     if (fabs(dis(x,y,x_22,y_22) - r - r_22) < eps)
+          return true;
+     return false;
+}
+double get_dis(double aa, double bb, double cc,double x, double y)
+{
+     return fabs((aa*x + bb*y - cc)/sqrt(aa*aa + bb*bb));
+}
+int main()
+{
+     int T = 100;
+     double x_1, y_1, r_1, x_2, y_2, r_2;
+     scanf("%d", &T);
+     while(T--)
+     {
+          scanf("%lf%lf%lf", &x_1, &y_1, &r_1);
+          scanf("%lf%lf%lf", &x_2, &y_2, &r_2);
+          scanf("%lf%lf", &x_0, &y_0);
+          x_00 = x_0;
+          y_00 = y_0;
+          x_11 = x_1;
+          y_11 = y_1;
+          x_22 = x_2;
+          y_22 = y_2;
+          r_11 = r_1;
+          r_22 = r_2;
+          double ex_1, ex_2, ey_1, ey_2, er_1, er_2;
+          changecircle(x_1, y_1, r_1, ex_1, ey_1, er_1);
+          changecircle(x_2, y_2, r_2, ex_2, ey_2, er_2);
+          if(er_1 > er_2)
+          {
+               exchange(ex_1, ex_2);
+               exchange(ey_1, ey_2);
+               exchange(er_1, er_2);
+          }
+          getline(ex_1, ey_1, er_1, ex_2, ey_2, er_2);
+          memset(flag, -1, sizeof(flag));
+          getcircle(a[0], b[0], c[0], 0);
+          getcircle(a[1], b[1], c[1], 1);
+          int ans = 0;
+          for (int i=0; i < 2;i++)
+          {
+               if (check(ansx[i],ansy[i],ansr[i])){
+                    ans++;
+                    flag[i] = 1;
+               }
+          }
+          printf("%d\n", ans);
+          for(int i = 0; i < 2; i++)
+          {
+               if(flag[i] == 1){
+                    printf("%.8lf %.8lf %.8lf\n", ansx[i], ansy[i], ansr[i]);
+               }
+          }
+     }
+     return 0;
+}
diff --git a/HDOJ/4775_autoAC.cpp b/HDOJ/4775_autoAC.cpp
new file mode 100644
index 0000000..6dae3f8
--- /dev/null
+++ b/HDOJ/4775_autoAC.cpp
@@ -0,0 +1,137 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <map>
+#include <algorithm>
+using namespace std;
+#define MAXN 10010
+#define MP(x,y) make_pair(x,y)
+#define FI first
+#define SE second
+map<pair<int,int>,int>ma;
+const int dis[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
+struct _no
+{
+    int x,y,c;
+    int to[4];
+    _no(int _x,int _y)
+    {
+        x=_x,y=_y;
+        c=-1;
+        for(int i=0;i<4;++i)    to[i]=-1;
+    }
+    _no(){}
+}no[MAXN];
+int top,fa[MAXN],col[MAXN],xy[MAXN];
+int que[MAXN];
+bool vi[MAXN];
+int findfa(int n)
+{
+    if(fa[n]!=n)
+        fa[n]=findfa(fa[n]);
+    return fa[n];
+}
+inline void smu(int a,int b)
+{
+    a=findfa(a),b=findfa(b);
+    if(a==b)    return ;
+    fa[b]=a;
+    col[a]+=col[b];
+}
+void del(int h)
+{
+    int he=0,ta=0;
+    que[ta++]=h;
+    while(he<ta)
+    {
+        h=que[he++];
+        for(int i=0;i<4;++i)
+        {
+            int p=no[h].to[i];
+            if(p!=-1)
+            {
+                if(no[p].c==no[h].c&&!vi[p])
+                    que[ta++]=p,vi[p]=1;
+                else    if(no[p].c==!no[h].c)
+                    ++col[findfa(p)];
+            }
+        }
+        no[h].c=-1;
+    }
+}
+int main()
+{
+    int ncase,n;
+    scanf("%d",&ncase);
+    while (ncase--)
+    {
+        memset(vi,0,sizeof(vi));
+        top=0;
+        ma.clear();
+        scanf("%d",&n);
+        for(int i=0;i<n;++i)
+        {
+            int x,y;
+            scanf("%d%d",&x,&y);
+            if(ma.find(MP(x,y))==ma.end())
+            {
+                ma[MP(x,y)]=top;
+                xy[i]=top;
+                no[top++]=_no(x,y);
+            }
+            else    xy[i]=ma[MP(x,y)];
+        }
+        for(int i=0;i<top;++i)
+            for(int j=0;j<4;++j)
+            {
+                int tx=no[i].x+dis[j][0],ty=no[i].y+dis[j][1];
+                map<pair<int,int>,int> ::iterator ite=ma.find(MP(tx,ty));
+                if(ite!=ma.end())
+                    no[i].to[j]=ite->SE;
+            }
+        for(int i=0;i<n;++i)    fa[i]=i,col[i]=0;
+        for(int i=0;i<n;++i)
+        {
+            int p=xy[i];
+            int c=no[p].c=i&1;
+            vi[p]=0;
+            for(int j=0;j<4;++j)
+            {
+                int tx=no[p].x+dis[j][0],ty=no[p].y+dis[j][1];
+                if(tx>0&&ty>0&&(no[p].to[j]==-1||no[no[p].to[j]].c==-1))
+                    ++col[p];
+            }
+            for(int j=0;j<4;++j)
+            {
+                int tmp=no[p].to[j];
+                if(tmp!=-1&&no[tmp].c!=-1)
+                {
+                    --col[findfa(tmp)];
+                    if(no[tmp].c==c)
+                        smu(tmp,p);
+                }
+            }
+            for(int j=0;j<4;++j)
+            {
+                int tmp=no[p].to[j];
+                if(tmp!=-1&&no[tmp].c==!c&&col[findfa(tmp)]==0)
+                    del(tmp);
+            }
+            for(int j=0;j<4;++j)
+            {
+                int tmp=no[p].to[j];
+                if(tmp!=-1&&no[tmp].c==c&&col[findfa(tmp)]==0)
+                    del(tmp);
+            }
+            if(no[p].c!=-1&&col[findfa(p)]==0)   del(p);
+        }
+        int nb=0,nw=0;
+        for(int i=0;i<top;++i)
+            if(no[i].c==0)
+                ++nb;
+            else    if(no[i].c==1)
+                ++nw;
+        printf("%d %d\n",nb,nw);
+    }
+    return 0;
+}
diff --git a/HDOJ/4776_autoAC.cpp b/HDOJ/4776_autoAC.cpp
new file mode 100644
index 0000000..1460cb3
--- /dev/null
+++ b/HDOJ/4776_autoAC.cpp
@@ -0,0 +1,166 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<stack>
+#include<cmath>
+#include<vector>
+#include<bitset>
+#define inf 0x3f3f3f3f
+#define Inf 0x3FFFFFFFFFFFFFFFLL
+#define eps 1e-6
+#define pi acos(-1.0)
+using namespace std;
+typedef long long ll;
+const int maxn=100000+10;
+const int Msize=61;
+int ch[maxn*Msize][2],size[maxn*Msize],tot;
+ll val[maxn*Msize],p[Msize];
+void Init()
+{
+    ch[0][0]=ch[0][1]=0;
+    tot=size[0]=0;
+    val[0]=-1;
+}
+void Insert(ll x)
+{
+    int u=0;
+    for(int i=Msize-1;i>=0;--i)
+    {
+        int c=(x&p[i])>0;
+        if(!ch[u][c])
+        {
+            ch[u][c]=++tot;
+            ch[tot][0]=ch[tot][1]=0;
+            size[tot]=0;val[tot]=-1;
+        }
+        u=ch[u][c];
+        size[u]++;
+    }
+    val[u]=x;
+}
+struct Edge
+{
+    int v;
+    ll w;
+    int next;
+    Edge(int v=0,ll w=0,int next=0):v(v),w(w),next(next){}
+}edges[maxn<<1];
+struct Query
+{
+    int id,k;
+    bool operator <(const Query &a) const
+    {
+        return k<a.k;
+    }
+}querys[maxn];
+int head[maxn],nEdge,n,m;
+ll xv[maxn],ans[maxn];
+void AddEdges(int u,int v,ll w)
+{
+    edges[++nEdge]=Edge(v,w,head[u]);
+    head[u]=nEdge;
+    edges[++nEdge]=Edge(u,w,head[v]);
+    head[v]=nEdge;
+}
+void dfs(int u,int fa,ll now)
+{
+    xv[u]=now;
+    Insert(now);
+    for(int k=head[u];k!=-1;k=edges[k].next)
+    {
+        int v=edges[k].v;
+        if(v==fa) continue;
+        dfs(v,u,now^edges[k].w);
+    }
+}
+struct Node
+{
+    int k;
+    ll num,mxv;
+    bool operator <(const Node &a) const
+    {
+        return mxv<a.mxv;
+    }
+    bool next()
+    {
+        k++;
+        if(k>=n) return false;
+        int kk=k,u=0;
+        for(int dep=Msize-1;dep>=0;--dep)
+        {
+            int c=((num&p[dep])>0)^1;
+            int v=ch[u][c];
+            if(v&&size[v]>=kk) u=ch[u][c];
+            else if(v&&size[v]<kk)
+            {
+                kk-=size[v];
+                u=ch[u][c^1];
+            }
+            else u=ch[u][c^1];
+        }
+        mxv=val[u]^num;
+        return true;
+    }
+};
+void solve()
+{
+    sort(querys,querys+m);
+    priority_queue<Node>q;
+    Node node;
+    for(int i=1;i<=n;++i)
+    {
+        node.k=0;
+        node.num=xv[i];
+        if(node.next()) q.push(node);
+    }
+    memset(ans,0xff,sizeof(ans));
+    int rank=0;
+    ll tmp;
+    for(int i=0;i<m;++i)
+    {
+        while(!q.empty()&&rank<querys[i].k)
+        {
+            rank++;
+            node=q.top();q.pop();
+            tmp=node.mxv;
+            if(node.next()) q.push(node);
+        }
+        if(querys[i].k==rank&&querys[i].k!=(ll)n*(n-1))
+            ans[querys[i].id]=tmp;
+    }
+}
+int main()
+{
+    p[0]=1;
+    for(int i=1;i<Msize;++i) p[i]=p[i-1]<<1;
+    while(~scanf("%d",&n))
+    {
+        if(n==0) break;
+        memset(head,0xff,sizeof(head));
+        nEdge=-1;
+        Init();
+        int u,v;
+        ll w;
+        for(int i=1;i<n;++i)
+        {
+            scanf("%d%d%I64d",&u,&v,&w);
+            AddEdges(u,v,w);
+        }
+        dfs(1,-1,0);
+        scanf("%d",&m);
+        for(int i=0;i<m;++i)
+        {
+            scanf("%d",&querys[i].k);
+            querys[i].id=i;
+        }
+        solve();
+        for(int i=0;i<m;++i)
+            printf("%I64d\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4777_autoAC.cpp b/HDOJ/4777_autoAC.cpp
new file mode 100644
index 0000000..09a50fd
--- /dev/null
+++ b/HDOJ/4777_autoAC.cpp
@@ -0,0 +1,168 @@
+#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 = 200010;
+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;
+}
+int L[MAXN],R[MAXN];
+int a[MAXN];
+int b[MAXN];
+int n,m;
+int lowbit(int x)
+{
+    return x & (-x);
+}
+int c[MAXN];
+void add(int i,int val)
+{
+    if(i == 0)return;
+    while(i <= n)
+    {
+        c[i] += val;
+        i += lowbit(i);
+    }
+}
+int sum(int i)
+{
+    int s = 0;
+    while(i > 0)
+    {
+        s += c[i];
+        i -= lowbit(i);
+    }
+    return s;
+}
+vector<int>vec[MAXN];
+struct Node
+{
+    int l,r;
+    int index;
+    void input()
+    {
+        scanf("%d%d",&l,&r);
+    }
+};
+bool cmp(Node p1,Node p2)
+{
+    return p1.r < p2.r;
+}
+Node node[MAXN];
+int ans[MAXN];
+int pp[MAXN][15];
+int main()
+{
+    getPrime();
+    while(scanf("%d%d",&n,&m) == 2)
+    {
+        if(n == 0 && m == 0)break;
+        for(int i = 1;i <= n;i++)
+            scanf("%d",&a[i]);
+        for(int i = 0;i < m;i++)
+        {
+            node[i].input();
+            node[i].index = i;
+        }
+        for(int i = 1;i < MAXN;i++)b[i] = n+1;
+        for(int i = n;i >= 1;i--)
+        {
+            getFactors(a[i]);
+            R[i] = n+1;
+            pp[i][0] = fatCnt;
+            for(int j = 0;j < fatCnt;j++)
+            {
+                R[i] = min(R[i],b[factor[j][0]]);
+                b[factor[j][0]] = i;
+                pp[i][j+1] = factor[j][0];
+            }
+        }
+        for(int i = 1;i < MAXN;i++)b[i] = 0;
+        for(int i = 1;i <= n;i++)
+        {
+            L[i] = 0;
+            fatCnt = pp[i][0];
+            for(int j = 0;j < fatCnt;j++)
+            {
+                factor[j][0] = pp[i][j+1];
+                L[i] = max(L[i],b[factor[j][0]]);
+                b[factor[j][0]] = i;
+            }
+        }
+        sort(node,node+m,cmp);
+        memset(c,0,sizeof(c));
+        for(int i = 1; i <= n+1;i++)
+        {
+            c[i] = 0;
+            vec[i].clear();
+        }
+        for(int i = 1;i <= n;i++)vec[R[i]].push_back(i);
+        int id = 1;
+        for(int i = 0;i < m;i++)
+        {
+            while(id <= n && id <= node[i].r)
+            {
+                add(L[id],1);
+                int sz = vec[id].size();
+                for(int j = 0;j < sz;j++)
+                {
+                    int v = vec[id][j];
+                    add(L[v],-1);
+                    add(v,1);
+                }
+                id++;
+            }
+            ans[node[i].index] = sum(node[i].r) - sum(node[i].l-1);
+            ans[node[i].index] = node[i].r - node[i].l +1 - ans[node[i].index];
+        }
+        for(int i = 0;i < m;i++)printf("%d\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4778_autoAC.cpp b/HDOJ/4778_autoAC.cpp
new file mode 100644
index 0000000..ba9da82
--- /dev/null
+++ b/HDOJ/4778_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+const int N = 1 << 21;
+bool vis[N];
+int n,g,s,dp[N],score[N],a[22][9];
+void get_score()
+{
+    int sum[9];
+    for(int mask=0;mask<(1<<n);mask++)
+    {
+        memset(sum,0,sizeof(sum));
+        for(int i=0;i<n;i++)
+            if(mask >> i & 1 ^ 1)
+                for(int j=1;j<=g;j++)
+                    sum[j] += a[i][j];
+        int ans = 0;
+        for(int j=1;j<=g;j++)
+            ans += sum[j] / s;
+        score[mask] = ans;
+    }
+}
+int dfs(int mask)
+{
+    if(vis[mask])
+        return dp[mask];
+    vis[mask] = true;
+    int ret = 0;
+    for(int i=0;i<n;i++)
+        if(mask >> i & 1)
+        {
+            int __mask = mask ^ (1 << i);
+            int _delta = score[__mask] - score[mask];
+            if(_delta > 0)
+                ret = max(ret,_delta + dfs(__mask));
+            else
+                ret = max(ret,score[0] - score[mask] - dfs(__mask));
+        }
+    return dp[mask] = ret;
+}
+int main()
+{
+    while(~scanf("%d%d%d",&g,&n,&s),g||n||s)
+    {
+        memset(vis,false,sizeof(vis));
+        memset(a,0,sizeof(a));
+        for(int i=0;i<n;i++)
+        {
+            int num,color;
+            scanf("%d",&num);
+            while(num--)
+            {
+                scanf("%d",&color);
+                a[i][color]++;
+            }
+        }
+        get_score();
+        printf("%d\n",2*dfs((1<<n)-1)-score[0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4779_autoAC.cpp b/HDOJ/4779_autoAC.cpp
new file mode 100644
index 0000000..e7a82ea
--- /dev/null
+++ b/HDOJ/4779_autoAC.cpp
@@ -0,0 +1,101 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<stack>
+#include<cmath>
+#include<vector>
+#include<bitset>
+#define inf 0x3f3f3f3f
+#define Inf 0x3FFFFFFFFFFFFFFFLL
+#define eps 1e-6
+#define pi acos(-1.0)
+using namespace std;
+typedef long long ll;
+const int maxn=200+5;
+const int mod=1e9+7;
+ll dp[maxn][maxn][maxn],C[maxn][maxn],A[maxn][maxn],pinv[maxn];
+ll pow_mod(ll x,ll n)
+{
+    ll res=1;
+    while(n)
+    {
+        if(n&1) res=res*x%mod;
+        x=x*x%mod;
+        n>>=1;
+    }
+    return res;
+}
+ll inv(ll x)
+{
+    return pow_mod(x,mod-2)%mod;
+}
+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<maxn;++j)
+        {
+            C[i][j]=C[i-1][j-1]+C[i-1][j];
+            if(C[i][j]>=mod) C[i][j]-=mod;
+        }
+    }
+    memset(A,0,sizeof(A));
+    A[0][0]=1;
+    for(int i=1;i<maxn;++i)
+    {
+        A[i][0]=1;
+        for(int j=i;j>=1;--j)
+            A[i][j]=A[i-1][j-1]*i%mod;
+    }
+    ll x=1;
+    pinv[0]=inv(x);
+    for(int i=1;i<maxn;++i)
+    {
+        x=(x<<1)%mod;
+        pinv[i]=inv(x);
+    }
+    memset(dp,0,sizeof(dp));
+    for(int i=0;i<maxn;++i)
+        for(int j=0;j<maxn;++j)
+            dp[i][j][0]=1;
+    for(int k=1;k<maxn;++k)
+        for(int i=1;i<maxn;++i)
+            for(int j=1;j<maxn;++j)
+                dp[i][j][k]=(dp[i][j][k-1]+C[i][k]*A[j][k])%mod;
+}
+int main()
+{
+    Init();
+    int t,n,m,p,q;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d%d%d",&n,&m,&p,&q);
+        ll ans=0,tmp,tmp2;
+        for(int x=0;x<=q;++x)
+            for(int i=0;i*2<=p;++i)
+                for(int j=0;i*2+j*2<=p;++j)
+                {
+                    int N=n-i-j*2-x;
+                    int M=m-i*2-j-x;
+                    if(N<0||M<0) continue;
+                    tmp2=C[n][x]*A[m][x]%mod;
+                    int tot=min(N*M,p-i*2-j*2);
+                    tmp=C[n-x][i]*A[m-x][i*2]%mod*pinv[i]%mod;
+                    tmp=tmp*C[m-i*2-x][j]%mod*A[n-i-x][j*2]%mod*pinv[j]%mod;
+                    if(i||j||x)
+                        ans=(ans+dp[N][M][tot]*tmp2%mod*tmp)%mod;
+                    else ans=((ans+dp[N][M][tot]-1)*tmp2%mod*tmp)%mod;
+                }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4780_autoAC.cpp b/HDOJ/4780_autoAC.cpp
new file mode 100644
index 0000000..c46e158
--- /dev/null
+++ b/HDOJ/4780_autoAC.cpp
@@ -0,0 +1,114 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <queue>
+using namespace std;
+const int N = 510;
+const int M = 1000010;
+const int INF = 0x7f7f7f7f;
+struct Edge {
+    int v, cap, cost, next;
+    Edge() {}
+    Edge(int a, int b, int c, int d)
+    :v(a), cap(b), cost(c), next(d) {}
+}e[M];
+int head[N], sz;
+int dis[N], pre[N], cur[N];
+bool inq[N];
+queue<int> q;
+void graphinit() {
+    memset(head, -1, sizeof(head));
+    sz = 0;
+}
+void addedge(int u, int v, int cp, int ct) {
+    e[sz] = Edge(v, cp, ct, head[u]);
+    head[u] = sz++;
+    e[sz] = Edge(u, 0, -ct, head[v]);
+    head[v] = sz++;
+}
+pair<int, int> mcmf(int s, int t) {
+    int mc = 0, mf = 0;
+    while (true) {
+        memset(pre, -1, sizeof(pre));
+        memset(inq, 0, sizeof(inq));
+        memset(dis, 0x7f, sizeof(dis));
+        dis[s] = 0;
+        q.push(s);
+        while (!q.empty()) {
+            int u = q.front(); q.pop();
+            inq[u] = false;
+            for (int i = head[u]; i != -1; i = e[i].next) {
+                int v = e[i].v;
+                if (e[i].cap > 0 && dis[v] > dis[u] + e[i].cost) {
+                    dis[v] = dis[u] + e[i].cost;
+                    pre[v] = u; cur[v] = i;
+                    if (!inq[v]) { inq[v] = true; q.push(v); }
+                }
+            }
+        }
+        if (pre[t] == -1) break;
+        int aug = INF;
+        for (int i = t; i != s; i = pre[i])
+            aug = min(aug, e[cur[i]].cap);
+        mf += aug;
+        mc += dis[t] * aug;
+        for (int i = t; i != s; i = pre[i]) {
+            e[cur[i]].cap -= aug;
+            e[cur[i] ^ 1].cap += aug;
+        }
+    }
+    return make_pair(mf, mc);
+}
+const int MAXN = 110;
+int n, m, k;
+int candy_s[MAXN], candy_t[MAXN];
+int start_time[MAXN][MAXN], start_cost[MAXN][MAXN];
+int change_time[MAXN][MAXN], change_cost[MAXN][MAXN];
+void read_matrix(int a[MAXN][MAXN], int n, int m) {
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < m; j++)
+            scanf("%d", &a[i][j]);
+}
+void work() {
+    for (int i = 0; i < n; i++)
+        scanf("%d%d", candy_s + i, candy_t + i);
+    read_matrix(start_time, n, m);
+    read_matrix(start_cost, n, m);
+    read_matrix(change_time, n, n);
+    read_matrix(change_cost, n, n);
+    graphinit();
+    int ss = 2 * n + m, tt = ss + 1;
+    for (int i = 0; i < n; i++)
+        addedge(ss, i, 1, 0);
+    for (int i = 0; i < m; i++)
+        addedge(i + n, tt, 1, 0);
+    for (int i = 0; i < n; i++)
+        addedge(i + n + m, tt, 1, 0);
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < m; j++) {
+            if (start_time[i][j] >= candy_t[i]) continue;
+            int cost = start_cost[i][j];
+            if (start_time[i][j] > candy_s[i])
+                cost += k * (start_time[i][j] - candy_s[i]);
+            addedge(i, j + n, 1, cost);
+        }
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < n; j++) if (i != j) {
+            int dt = candy_t[i] + change_time[i][j];
+            if (dt >= candy_t[j]) continue;
+            int cost = change_cost[i][j];
+            dt -= candy_s[j];
+            if (dt > 0)
+                cost += k * dt;
+            addedge(j, i + n + m, 1, cost);
+        }
+    pair<int, int> ans = mcmf(ss, tt);
+    if (ans.first < n) puts("-1");
+    else printf("%d\n", ans.second);
+}
+int main() {
+    while (scanf("%d%d%d", &n, &m, &k), n || m || k) {
+        work();
+    }
+    return 0;
+}
diff --git a/HDOJ/4781_autoAC.cpp b/HDOJ/4781_autoAC.cpp
new file mode 100644
index 0000000..5217bfb
--- /dev/null
+++ b/HDOJ/4781_autoAC.cpp
@@ -0,0 +1,98 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+#include <algorithm>
+using namespace std;
+int n,m;
+int map[85][85],sum[85],vis[5010];
+int has[3]={0,2,0};
+struct edge
+{
+    int from,to,len;
+}ans[5010];
+int solve(int len,int num)
+{
+    int tmp=len%3;
+    for(int i=1;i<=n;i++)
+    {
+        for(int j=1;j<=n;j++)
+        {
+            if(i!=j&&!map[i][j]&&!map[j][i])
+            {
+                if(j>i)
+                {
+                    if((sum[j]-sum[i]+3)%3==tmp)
+                    {
+                        map[i][j]=1;
+                        ans[num].from=i;
+                        ans[num].to=j;
+                        ans[num].len=len;
+                        return 1;
+                    }
+                }
+                else
+                {
+                    if((sum[i]-sum[j]+3+tmp)%3==0)
+                    {
+                        map[i][j]=1;
+                        ans[num].from=i;
+                        ans[num].to=j;
+                        ans[num].len=len;
+                        return 1;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
+int main()
+{
+    int ncase,T=0;
+    scanf("%d",&ncase);
+    while(ncase--)
+    {
+        memset(vis,0,sizeof(vis));
+        memset(map,0,sizeof(map));
+        memset(sum,0,sizeof(sum));
+        scanf("%d%d",&n,&m);
+        sum[1]=0;
+        for(int i=1;i<n;i++)
+        {
+            ans[i].from=i;
+            ans[i].to=i+1;
+            ans[i].len=i;
+            vis[i]=1;
+            map[ans[i].from][ans[i].to]=1;
+            if(i!=1)
+            sum[i]=(sum[i-1]+i-1)%3;
+        }
+        ans[n].from=n;
+        ans[n].to=1;
+        map[n][1]=1;
+        ans[n].len=n+has[n%3];
+        vis[ans[n].len]=1;
+        sum[n]=(sum[n-1]+n-1)%3;
+        int num=n,tru=1;
+        for(int i=1;i<=m;i++)
+        {
+            if(!vis[i])
+            {
+                tru=solve(i,++num);
+                if(!tru)
+                break;
+            }
+        }
+        printf("Case #%d:\n",++T);
+        if(!tru)
+        {
+            printf("-1\n");
+            continue;
+        }
+        for(int i=1;i<=m;i++)
+        {
+            printf("%d %d %d\n",ans[i].from,ans[i].to,ans[i].len);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4782_autoAC.cpp b/HDOJ/4782_autoAC.cpp
new file mode 100644
index 0000000..ec27277
--- /dev/null
+++ b/HDOJ/4782_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+using namespace std;
+const int maxn = 10005;
+char buf[maxn];
+int len;
+char ch;
+void skip(){
+    while(ch == ' ' || ch == '\t' || ch == '\n') ch = getchar();
+}
+void readTag(){
+    len = 0;
+    ch = getchar();
+    while(ch!='>'){
+        buf[len++] = ch;
+        ch = getchar();
+    }        
+    buf[len] = 0;
+}
+void readString(){
+    len = 0;
+    while(ch != ' ' && ch != '\t' && ch != '\n'  && ch != '<'){
+        buf[len++] = ch;
+        ch = getchar();
+    }
+    buf[len] = 0;
+}
+void solve(){
+    ch = ' ';
+    int dep = 0;
+    while(1){
+        skip();
+        if(ch == '<'){
+            readTag();
+            if(buf[len-1] == '/'){ 
+                for(int i = 0; i < dep; i++) putchar(' ');
+            }
+            else if(buf[0] == '/') { 
+                dep--;
+                for(int i = 0; i < dep; i++) putchar(' ');
+            }
+            else{ 
+                for(int i = 0; i < dep; i++) putchar(' ');
+                 dep++;
+            }
+            printf("<%s>\n", buf);
+            if(strcmp(buf, "/html") == 0)
+                break;
+            ch = getchar();
+        }else{
+            readString();
+            for(int i = 0; i < dep; i++) putchar(' ');
+            printf("%s", buf);
+            skip();
+            while( ch != '<' ){
+                readString();
+                printf(" %s", buf);
+                skip();
+            }
+            puts("");
+        }
+    }
+}
+int main(){
+    int t, cas = 1;
+    scanf("%d", &t);
+    while(t--) {
+        printf("Case #%d:\n", cas++);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4784_autoAC.cpp b/HDOJ/4784_autoAC.cpp
new file mode 100644
index 0000000..b9f38d3
--- /dev/null
+++ b/HDOJ/4784_autoAC.cpp
@@ -0,0 +1,156 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<cmath>
+#include<vector>
+#include<queue>
+using namespace std;
+typedef long long ll;
+const int maxn=100+10;
+const int maxm=200+10;
+struct Edge
+{
+    int v,tm,cost;
+    int next;
+};
+Edge edges[maxm<<1];
+int head[maxn],nEdge=-1;
+int n,m,B,K,R,T;
+int d[maxn][210][6][6];
+bool inq[maxn][210][6][6];
+int prices[6][maxn];
+void AddEdge(int u,int v,int tm,int cost)
+{
+    nEdge++;
+    edges[nEdge].v=v;
+    edges[nEdge].tm=tm;
+    edges[nEdge].cost=cost;
+    edges[nEdge].next=head[u];
+    head[u]=nEdge;
+}
+struct Node
+{
+    int u,times,k,b;
+    bool operator < (const Node &a) const
+    {
+        return times>a.times;
+    }
+};
+int bfs()
+{
+    memset(d,0xff,sizeof(d));
+    memset(inq,0,sizeof(inq));
+    d[1][0][0][0]=R;
+    Node node,tmp;
+    priority_queue<Node>q;
+    node.u=1;node.times=0;
+    node.k=0;node.b=0;
+    inq[1][0][0][0]=true;
+    q.push(node);
+    bool flag=false;
+    while(!q.empty())
+    {
+        node=q.top();q.pop();
+        if(node.times>T) break;
+        int u=node.u;
+        if(u==n) continue;
+        for(int i=head[u];i!=-1;i=edges[i].next)
+        {
+            int v=edges[i].v;
+            int cost,tim;
+            cost=d[u][node.times][node.k][node.b]-edges[i].cost;
+            tim=node.times+edges[i].tm;
+            if(tim>T||cost<0) continue;
+            if(v==n&&node.k!=0) continue;
+            if(v==n) flag=true;
+            tmp.u=v;tmp.times=tim;
+            tmp.k=node.k;
+            if(u!=1&&u!=n)
+            {
+                if(node.b+1<=B&&cost-prices[node.k][u]>d[v][tim][node.k][node.b+1])
+                {
+                    d[v][tim][node.k][node.b+1]=cost-prices[node.k][u];
+                    tmp.b=node.b+1;
+                    if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
+                    {q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
+                }
+                if(node.b>0&&cost+prices[node.k][u]>d[v][tim][node.k][node.b-1])
+                {
+                    d[v][tim][node.k][node.b-1]=cost+prices[node.k][u];
+                    tmp.b=node.b-1;
+                    if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
+                    {q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
+                }
+            }
+            if(cost>d[v][tim][node.k][node.b])
+            {
+                d[v][tim][node.k][node.b]=cost;
+                tmp.b=node.b;
+                if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
+                {q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
+            }
+        }
+        if(u!=1&&u!=n)
+        {
+            int cost=d[u][node.times][node.k][node.b];
+            tmp.u=u;tmp.k=(node.k+1)%K;
+            tmp.times=node.times+1;
+            if(tmp.times>T) continue;
+            if(node.b+1<=B&&cost-prices[node.k][u]>d[u][tmp.times][tmp.k][node.b+1])
+            {
+                d[u][tmp.times][tmp.k][node.b+1]=cost-prices[node.k][u];
+                tmp.b=node.b+1;
+                if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
+                {q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
+            }
+            if(node.b>0&&cost+prices[node.k][u]>d[u][tmp.times][tmp.k][node.b-1])
+            {
+                d[u][tmp.times][tmp.k][node.b-1]=cost+prices[node.k][u];
+                tmp.b=node.b-1;
+                if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
+                {q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
+            }
+            tmp.b=node.b;
+            if(cost>d[u][tmp.times][tmp.k][tmp.b])
+            {
+                d[u][tmp.times][tmp.k][tmp.b]=cost;
+                if(!inq[tmp.u][tmp.times][tmp.k][tmp.b])
+                {q.push(tmp);inq[tmp.u][tmp.times][tmp.k][tmp.b]=true;}
+            }
+        }
+    }
+    if(!flag) return -1;
+    int ans=0;
+    for(int i=0;i<=T;++i)
+      for(int j=0;j<=B;++j)
+        ans=max(ans,d[n][i][0][j]);
+    return ans;
+}
+int main()
+{
+    int t,tcase=0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        tcase++;
+        scanf("%d%d%d%d%d%d",&n,&m,&B,&K,&R,&T);
+        memset(head,0xff,sizeof(head));
+        nEdge=-1;
+        int u,v,tm,cost;
+        for(int i=0;i<K;++i)
+          for(int j=1;j<=n;++j)
+            scanf("%d",&prices[i][j]);
+        for(int i=0;i<m;++i)
+        {
+            scanf("%d%d%d%d",&u,&v,&tm,&cost);
+            AddEdge(u,v,tm,cost);
+        }
+        int ans=bfs();
+        printf("Case #%d: ",tcase);
+        if(ans!=-1) printf("%d\n",ans);
+        else printf("Forever Alone\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4786_autoAC.cpp b/HDOJ/4786_autoAC.cpp
new file mode 100644
index 0000000..502afc7
--- /dev/null
+++ b/HDOJ/4786_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<algorithm>
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+using namespace std;
+int fib[30];
+struct st
+{
+    int l,r,c;
+}edge[100005];
+int fa[100005];
+int cmp(const void *a,const void *b)
+{
+    return (*(st*)b).c-(*(st*)a).c;
+}
+int getfa(int a)
+{
+    if(0==fa[a])
+        return a;
+    else
+        return fa[a]=getfa(fa[a]);
+}
+int main()
+{
+    fib[0]=1,fib[1]=2;
+    int flag;
+    for(int i=2;fib[i-1]<=100000;i++)
+    {
+        fib[i]=fib[i-1]+fib[i-2];
+    }
+    int t,ti=1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int n,m;
+        scanf("%d%d",&n,&m);
+        for(int i=1;i<=m;i++)
+        {
+            scanf("%d%d%d",&edge[i].l,&edge[i].r,&edge[i].c);
+        }
+        memset(fa,0,sizeof(fa));
+        qsort(edge+1,m,sizeof(edge[0]),cmp);
+        int hi=0,sum=0;
+        for(int i=1;i<=m;i++)
+        {
+            int x=getfa(edge[i].l);
+            int y=getfa(edge[i].r);
+            if(x!=y)
+            {
+                fa[x]=y;
+                hi+=edge[i].c;
+                sum++;
+            }
+        }
+        if(sum!=n-1)
+        {
+            printf("Case #%d: No\n",ti);
+            ti++;
+            continue;
+        }
+        int lo=0;
+        memset(fa,0,sizeof(fa));
+        for(int i=m;i>0;i--)
+        {
+            int x=getfa(edge[i].l);
+            int y=getfa(edge[i].r);
+            if(x!=y)
+            {
+                fa[x]=y;
+                lo+=edge[i].c;
+            }
+        }
+        flag=0;
+        int i=0;
+        while(fib[i]<=hi)
+        {
+            if(fib[i]>=lo&&fib[i]<=hi)
+            {
+                flag=1;
+                break;
+            }
+            i++;
+        }
+        if(flag==1)
+            printf("Case #%d: Yes\n",ti);
+        else
+            printf("Case #%d: No\n",ti);
+        ti++;
+    }
+    return 0;
+}
diff --git a/HDOJ/4787_autoAC.cpp b/HDOJ/4787_autoAC.cpp
new file mode 100644
index 0000000..fa6db23
--- /dev/null
+++ b/HDOJ/4787_autoAC.cpp
@@ -0,0 +1,123 @@
+#pragma comment( linker, "/STACK:1024000000,1024000000")
+#include<stdio.h>
+#include<string.h>
+#include<queue>
+using namespace std;
+#define maxnode 511111
+#define sigma_size 2
+struct Trie{
+    int ch[maxnode][sigma_size];
+    bool val[maxnode];
+    int f[maxnode];
+    int sz;
+    void init(){
+        sz=1;
+        memset(ch,0,sizeof(ch));
+        memset(val, 0, sizeof(val));  
+        memset(f,0,sizeof(f));
+    }
+    int idx(char c){ return c-'0'; }
+    int insert(char *s){
+        int u = 0;
+        for(int i = 0; s[i] ;i++){
+            int c = idx(s[i]);
+            if(!ch[u][c])
+                ch[u][c] = sz++;
+            u = ch[u][c];
+        }
+        val[u] = 1;
+        return u;
+    }
+    bool search(char *s){
+        int u = 0;
+        for(int i = 0; s[i] ;i++){
+            int c = idx(s[i]);
+            if(!ch[u][c]) return 0;
+            u = ch[u][c];
+        }
+        return val[u];
+    }
+    void getFail(){
+        queue<int> q;
+        for(int i = 0; i<sigma_size; i++)
+            if(ch[0][i]) q.push(ch[0][i]);  
+        while(!q.empty()){
+            int r = q.front(); q.pop();  
+            for(int c = 0; c<sigma_size; c++){
+                int u = ch[r][c];
+                if(!u)continue;
+                q.push(u);
+                int v = f[r];
+                while(v && ch[v][c] == 0) v = f[v]; 
+                f[u] = ch[v][c];
+            }
+        }
+    }
+    int find(char *T){
+        int j = 0, ans = 0;
+        for(int i = 0; T[i] ; i++){
+            int c = idx(T[i]);
+            while(j && ch[j][c]==0) j = f[j];
+            j = ch[j][c];
+            int temp = j;
+            while(temp){ 
+                ans += val[temp];
+                temp = f[temp];
+            }
+        }
+        return ans;
+    }
+};
+Trie ac, buf;
+void dfs(int u, int v){
+    for(int i = 0;i < 2;i++){
+        if( buf.ch[v][i] )
+        {
+            int e2 = buf.ch[v][i];
+            if(! ac.ch[u][i]) 
+            { 
+                memset(ac.ch[ac.sz], 0, sizeof(ac.ch[ac.sz]));
+                ac.ch[u][i] = ac.sz++;
+            }
+            int e1 = ac.ch[u][i];
+            ac.val[e1] |= buf.val[e2];
+            dfs(e1, e2);
+        }
+    }
+}
+void join(){
+    dfs(0, 0);
+    buf.init();
+    ac.getFail();
+}
+char s[6000000],temp[6000000];
+int main(){
+    int Cas = 1, T, n;scanf("%d",&T);
+    while(T--){
+        scanf("%d",&n);
+        printf("Case #%d:\n",Cas++);
+        ac.init();
+        buf.init();
+        int L = 0;
+        while(n--){
+            scanf("%s",temp);
+            int len = strlen ( temp + 1 ) ; 
+            s[0] = temp[0] ; 
+            for (int i = 0 ; i < len ; i ++ )
+                s[i+1] = temp[1+(i+L%len+len)%len] ;  
+            s[len+1] = '\0';
+            if(s[0] == '+'){
+                if( buf.search(s+1) || ac.search(s+1) )continue;
+                buf.insert(s+1);
+                buf.getFail();
+                if(buf.sz > 2000) join();
+            }
+            else
+            {
+                L = buf.find(s+1) + ac.find(s+1);
+                printf("%d\n", L);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4788_autoAC.cpp b/HDOJ/4788_autoAC.cpp
new file mode 100644
index 0000000..5905a55
--- /dev/null
+++ b/HDOJ/4788_autoAC.cpp
@@ -0,0 +1,43 @@
+#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 change(char s[])
+{
+    if(strcmp(s,"B]") == 0)return 0;
+    if(strcmp(s,"KB]") == 0)return 1;
+    if(strcmp(s,"MB]") == 0)return 2;
+    if(strcmp(s,"GB]") == 0)return 3;
+    if(strcmp(s,"TB]") == 0)return 4;
+    if(strcmp(s,"PB]") == 0)return 5;
+    if(strcmp(s,"EB]") == 0)return 6;
+    if(strcmp(s,"ZB]") == 0)return 7;
+    if(strcmp(s,"YB]") == 0)return 8;
+}
+char s[100];
+int main()
+{
+    int T;
+    int iCase = 0;
+    double a;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%lf[%s",&a,s);
+        int t = change(s);
+        double ans = pow(1000.0,t)/pow(1024.0,t);
+        ans = 1-ans;
+        printf("Case #%d: %.2lf%%\n",iCase,ans*100);
+    }
+    return 0;
+}
diff --git a/HDOJ/4789_autoAC.cpp b/HDOJ/4789_autoAC.cpp
new file mode 100644
index 0000000..69a6eba
--- /dev/null
+++ b/HDOJ/4789_autoAC.cpp
@@ -0,0 +1,223 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#include <vector>
+#include <map>
+#include <string>
+#include <set>
+using namespace std;
+#define eps 1e-8
+#define LL long long
+#define mod 1000000007
+#define mxn 50005
+int n, m, T, t, cnt;
+struct Team {
+    string name;
+    int solve, penalty;
+    int ac_time[26];
+    int submit_forzen[26]; 
+    int submit_final[26];  
+    int submit_valid[26];  
+    bool ok_forzen[26];    
+    bool ok_final[26];    
+    int last[26];
+    vector<int> pending;
+    void init( string s ) {
+        name = s;
+        solve = penalty = 0;
+        memset(submit_forzen, 0, m * 4);
+        memset(submit_final, 0, m * 4);
+        memset(submit_valid, 0, m * 4);
+        memset(ok_forzen, 0, m);
+        memset(ok_final, 0, m);
+        memset(last, 0, m * 4);
+        pending.clear();
+    }
+    bool operator < (const Team &b) const {
+        if( solve > b.solve ) return true;
+        if( solve < b.solve ) return false;
+        if( penalty < b.penalty ) return true;
+        if( penalty > b.penalty ) return false;
+        for( int j = solve - 1; j >= 0; --j ) {
+            if( last[j] < b.last[j] )
+                return true;
+            else if( last[j] > b.last[j] )
+                return false;
+        }
+        return name > b.name;
+    }
+    void add( int id, int tim, int tp ) {
+        if( ok_forzen[id] ) return ;
+        if( ok_final[id] ) {
+            if( tim < t ) return ;
+            ++submit_final[id];
+            return ;
+        }
+        if( tp == 0 ) {
+            if( tim < t ) {
+                ok_forzen[id] = true;
+                ac_time[id] = tim;
+                penalty += ac_time[id] + submit_valid[id] * 20;
+                int j = solve++;
+                last[j] = tim;
+                while( j > 0 && last[j] < last[j-1] )
+                    swap(last[j], last[j-1]), --j;
+            }
+            else {
+                ok_final[id] = true;
+                ac_time[id] = tim;
+                ++submit_final[id];
+            }
+        }
+        else if( tp == 1 ) {
+            if( tim < t ) {
+                ++submit_forzen[id];
+                ++submit_valid[id];
+            }
+            else {
+                ++submit_final[id];
+                ++submit_valid[id];
+            }
+        }
+        else {
+            if( tim < t ) return ;
+            else {
+                ++submit_final[id];
+            }
+        }
+    }
+    void relax() {
+        int id = pending.back();
+        if( ok_final[id] ) {
+            penalty += ac_time[id] + submit_valid[id] * 20;
+            int j = solve++;
+            last[j] = ac_time[id];
+            while( j > 0 && last[j] < last[j-1] )
+                swap(last[j], last[j-1]), --j;
+        }
+        pending.pop_back();
+    }
+    void forzen() {
+        for( int i = m - 1; i >= 0; --i )
+            if( submit_final[i] )
+                pending.push_back(i);
+    }
+}p[mxn];
+struct Submit {
+    int team_id, problem_id, submit_time;
+    int tp; //0: Yes    1: No    2: Errors
+    bool operator < (const Submit &b) const {
+        return submit_time < b.submit_time || submit_time == b.submit_time && tp > b.tp;
+    }
+}Sub[mxn];
+struct Index {
+    int id;
+    Index(){}
+    Index(int id):id(id) {}
+    bool operator < (const Index &b) const {
+        return p[id] < p[b.id];
+    }
+}idx[mxn];
+map<string, int> mp;
+set<Index> st;
+void Forzen() {
+    st.clear();
+    for( int i = 1; i <= cnt; ++i )
+        st.insert(Index(i));
+    int rank = 0;
+    for( set<Index>::iterator it = st.begin(); it != st.end(); ++it ) {
+        Team &k = p[it->id];
+        printf( "%s %d %d %d", k.name.c_str(), ++rank, k.solve, k.penalty );
+        for( int i = 0; i < m; ++i ) {
+            if( k.ok_forzen[i] ) {
+                if( k.submit_valid[i] == 0 )
+                    printf( " +" );
+                else printf( " +%d", k.submit_valid[i] );
+            }
+            else if( k.submit_final[i] ) {
+                if( k.submit_forzen[i] == 0 )
+                    printf( " 0/%d", k.submit_final[i] );
+                else printf( " -%d/%d", k.submit_forzen[i], k.submit_final[i] );
+            }
+            else if( k.submit_forzen[i] )
+                printf( " -%d", k.submit_forzen[i] );
+            else printf( " ." );
+        }
+        puts( "" );
+    }
+}
+void Update() {
+    for( int i = 1; i <= cnt; ++i )
+        p[i].forzen();
+    while( st.size() ) {
+        set<Index>::iterator it = st.end();
+        --it;
+        Team &k = p[it->id];
+        Index nxt = Index(it->id);
+        st.erase(it);
+        if( k.pending.size() == 0 ) continue;
+        k.relax();
+        set<Index>::iterator fit = st.upper_bound(nxt);
+        if( fit != st.end() ) {
+            printf( "%s %s %d %d\n", k.name.c_str(), p[fit->id].name.c_str(), k.solve, k.penalty );
+        }
+        st.insert(fit, nxt);
+    }
+}
+void Final() {
+    for( int i = 1; i <= cnt; ++i ) idx[i].id = i;
+    sort(idx + 1, idx + cnt + 1);
+    for( int j = 1; j <= cnt; ++j ) {
+        Team &k = p[idx[j].id];
+        printf( "%s %d %d %d", k.name.c_str(), j, k.solve, k.penalty );
+        for( int i = 0; i < m; ++i ) {
+            if( k.ok_forzen[i] || k.ok_final[i] ) {
+                if( k.submit_valid[i] == 0 )
+                    printf( " +" );
+                else printf( " +%d", k.submit_valid[i] );
+            }
+            else if( k.submit_valid[i] )
+                printf( " -%d", k.submit_valid[i] );
+            else printf( " ." );
+        }
+        puts( "" );
+    }
+}
+int cal( char c ) {
+    if( c == 'Y' ) return 0;
+    if( c == 'N' ) return 1;
+    return 2;
+}
+int main()
+{
+    int tes, cas = 0, cur_time;
+    char sname[50], pro[10], ret[10];
+    scanf( "%d", &tes );
+    while( tes-- ) {
+        cnt = 0; mp.clear();
+        scanf( "%d%d%d%d", &n, &m, &T, &t );
+        for( int i = 0; i < n; ++i ) {
+            scanf( "%s%s%d%s", sname, pro, &cur_time, ret );
+            string s = sname;
+            if( !mp.count(s) ) {
+                mp[s] = ++cnt;
+                p[cnt].init(s);
+                Sub[i].team_id = cnt;
+            }
+            else Sub[i].team_id = mp[s];
+            Sub[i].problem_id = pro[0] - 'A';
+            Sub[i].submit_time = cur_time;
+            Sub[i].tp = cal(ret[0]);
+        }
+        sort(Sub, Sub + n);
+        for( int i = 0; i < n; ++i )
+            p[Sub[i].team_id].add(Sub[i].problem_id, Sub[i].submit_time, Sub[i].tp);
+        printf( "Case #%d:\n", ++cas );
+        Forzen();
+        Update();
+        Final();
+    }
+    return 0;
+}
diff --git a/HDOJ/4790_autoAC.cpp b/HDOJ/4790_autoAC.cpp
new file mode 100644
index 0000000..5fc073c
--- /dev/null
+++ b/HDOJ/4790_autoAC.cpp
@@ -0,0 +1,85 @@
+#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;
+long long gcd(long long a,long long b)
+{
+    if(b == 0)return a;
+    return gcd(b,a%b);
+}
+int main()
+{
+    long long a,b,c,d,p,m;
+    int T;
+    int iCase = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%I64d%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&d,&p,&m);
+        long long ans = 0;
+        if(b+c <= a+d)
+        {
+            long long t1 = (a+c)%p;
+            long long add = (m - t1 + p)%p;
+            long long cnt1 = (a+c + add-m)/p;
+            long long t2 = (b+c-1)%p;
+            long long sub = (t2 - m + p)%p;
+            long long cnt2 = (b+c-1-sub-m)/p;
+            ans += (cnt2 - cnt1 + 1)*(1+add) + (cnt2 - cnt1 + 1)*(cnt2 - cnt1)/2 * p;
+            t1 = (b+c)%p;
+            add = (m - t1 + p)%p;
+            cnt1 = (b+c+add-m)/p;
+            t2 = (a+d)%p;
+            sub = (t2 - m + p)%p;
+            cnt2 = (a+d-sub-m)/p;
+            ans += (cnt2 - cnt1 + 1)*(b-a+1);
+            t1 = (a+d+1)%p;
+            add = (m - t1 + p)%p;
+            cnt1 = (a+d+1+add-m)/p;
+            t2 = (b+d)%p;
+            sub = (t2 - m + p)%p;
+            cnt2 = (b+d-sub-m)/p;
+            ans += (cnt2 - cnt1 + 1)*(1+sub) + (cnt2 - cnt1 + 1)*(cnt2 - cnt1)/2*p;
+        }
+        else
+        {
+            long long t1 = (a+c)%p;
+            long long add = (m - t1 + p)%p;
+            long long cnt1 = (a+c + add-m)/p;
+            long long t2 = (a+d-1)%p;
+            long long sub = (t2 - m + p)%p;
+            long long cnt2 = (a+d-1-sub-m)/p;
+            ans += (cnt2 - cnt1 + 1)*(1+add) + (cnt2 - cnt1 + 1)*(cnt2 - cnt1)/2 * p;
+            t1 = (a+d)%p;
+            add = (m - t1 + p)%p;
+            cnt1 = (a+d+add-m)/p;
+            t2 = (b+ c)%p;
+            sub = (t2 - m + p)%p;
+            cnt2 = (b+c-sub-m)/p;
+            ans += (cnt2 - cnt1 + 1)*(d-c+1);
+            t1 = (b+c+1)%p;
+            add = (m - t1 + p)%p;
+            cnt1 = (b+c+1+add-m)/p;
+            t2 = (b+d)%p;
+            sub = (t2 - m + p)%p;
+            cnt2 = (b+d - sub-m)/p;
+            ans += (cnt2 - cnt1 + 1)*(1+sub) + (cnt2 - cnt1 + 1)*(cnt2 - cnt1)/2*p;
+        }
+        long long tot = (b-a+1)*(d-c+1);
+        long long GCD = gcd(ans,tot);
+        ans /= GCD;
+        tot /= GCD;
+        printf("Case #%d: %I64d/%I64d\n",iCase,ans,tot);
+    }
+    return 0;
+}
diff --git a/HDOJ/4791_autoAC.cpp b/HDOJ/4791_autoAC.cpp
new file mode 100644
index 0000000..e7fd2a6
--- /dev/null
+++ b/HDOJ/4791_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <map>
+#include <cstdlib>
+#include <queue>
+#include <stack>
+#include <vector>
+#include <ctype.h>
+#include <algorithm>
+#include <string>
+#include <set>
+#define PI acos(-1.0)
+#define maxn 100005
+#define INF 0x7fffffff
+#define eps 1e-8
+typedef long long LL;
+typedef unsigned long long ULL;
+using namespace std;
+struct aa
+{
+    LL p,s;
+    LL cost;
+} a[100005];
+struct bb
+{
+    LL i,q;
+    LL cost;
+} b[100005];
+bool cmp1(bb a,bb b)
+{
+    return a.i<b.i;
+}
+bool cmp2(bb a,bb b)
+{
+    return a.q<b.q;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int m,n;
+        scanf("%d%d",&m,&n);
+        for(int i=0; i<m; i++)
+        {
+            scanf("%I64d%I64d",&a[i].p,&a[i].s);
+        }
+        a[m-1].cost=a[m-1].p*a[m-1].s;
+        for(int i=m-2; i>=0; i--)
+            a[i].cost=min(a[i+1].cost,a[i].p*a[i].s);
+        for(int i=0; i<n; i++)
+        {
+            scanf("%I64d",&b[i].q);
+            b[i].i=i;
+        }
+        sort(b,b+n,cmp2);
+        int top1=0;
+        for(int i=0; i<n; i++)
+        {
+            while(b[i].q>=a[top1].p&&top1<m)
+                top1++;
+            if(top1==m)
+                b[i].cost=b[i].q*a[top1-1].s;
+            else
+                b[i].cost=min(b[i].q*a[top1-1].s,a[top1].cost);
+        }
+        sort(b,b+n,cmp1);
+        for(int i=0; i<n; i++)
+            printf("%I64d\n",b[i].cost);
+    }
+    return 0;
+}
diff --git a/HDOJ/4793_autoAC.cpp b/HDOJ/4793_autoAC.cpp
new file mode 100644
index 0000000..cbc4541
--- /dev/null
+++ b/HDOJ/4793_autoAC.cpp
@@ -0,0 +1,50 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cmath>
+#include <algorithm>
+#define eps 1e-8
+using namespace std;
+#define N 10007
+int sgn(double x)
+{
+    if(x > eps) return 1;
+    if(x < -eps) return -1;
+    return 0;
+}
+int main()
+{
+    double Rm,R,r,x,y,vx,vy;
+    while(scanf("%lf%lf%lf%lf%lf%lf%lf",&Rm,&R,&r,&x,&y,&vx,&vy)!=EOF)
+    {
+        double A1 = (vx*vx+vy*vy);
+        double B1 = (2*vx*x+2*y*vy);
+        double C1 = x*x+y*y-(R+r)*(R+r);
+        double A2 = A1;
+        double B2 = B1;
+        double C2 = x*x+y*y-(Rm+r)*(Rm+r);
+        double delta1 = B1*B1 - 4.0*A1*C1;
+        double delta2 = B2*B2 - 4.0*A2*C2;
+        if(sgn(delta1) <= 0)
+        {
+            puts("0.000");
+            continue;
+        }
+        double J11 = (-B1 + sqrt(delta1))/(2.0*A1);
+        double J12 = (-B1 - sqrt(delta1))/(2.0*A1);
+        if(sgn(J12) >= 0)
+        {
+            if(sgn(delta2) <= 0)
+            {
+                printf("%.3f\n",fabs(J11-J12));
+                continue;
+            }
+            double J22 = (-B2 - sqrt(delta2))/(2.0*A2);
+            printf("%.3f\n",(J22-J12)*2.0);
+        }
+        else
+            puts("0.000");
+    }
+    return 0;
+}
diff --git a/HDOJ/4794_autoAC.cpp b/HDOJ/4794_autoAC.cpp
new file mode 100644
index 0000000..e86c267
--- /dev/null
+++ b/HDOJ/4794_autoAC.cpp
@@ -0,0 +1,108 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <string.h>
+#include <cstring>
+#include <stdio.h>
+#include <cmath>
+#include <math.h>
+#define rep(i,a,b) for(int i=(a);i<(b);++i)
+#define rrep(i,b,a) for(int i = (b); i >= (a); --i)
+#define clr(a,x) memset(a,(x),sizeof(a))
+#define LL unsigned long long
+#define eps 1e-8
+using namespace std;
+LL n;
+LL gcd(LL a, LL b)
+{
+    while (a && b) {
+        if (a > b) a %= b;
+        else b %= a;
+    }
+    return a + b;
+}
+LL lcm(LL a,LL b)
+{
+    return a * b / gcd(a,b);
+}
+void mul(LL A[2][2],LL B[2][2],LL ret[2][2],LL mod)
+{
+    LL C[2][2] = { 0 };
+    rep(i,0,2) rep(j,0,2) rep(k,0,2)
+        C[i][j] = (C[i][j] + A[i][k] * B[k][j] % mod) % mod;
+    rep(i,0,2) rep(j,0,2)
+        ret[i][j] = C[i][j];
+}
+void qpow(LL base[2][2],LL p,LL dest[2][2],LL mod)
+{
+    LL ret[2][2] = { 0 };
+    ret[0][0] = ret[1][1] = 1;
+    while (p > 0) {
+        if (p & 1) mul(ret,base,ret,mod);
+        mul(base,base,base,mod);
+        p >>= 1;
+    }
+    rep(i,0,2) rep(j,0,2) dest[i][j] = ret[i][j];
+}
+LL qpow(LL base,LL p,LL mod)
+{
+    LL ret = 1;
+    while (p) {
+        if (p & 1) ret = ret * base % mod;
+        base = base * base % mod;
+        p >>= 1;
+    }
+    return ret;
+}
+LL S[10000],c;
+LL f1,f2;
+void F(LL p,LL mod)
+{
+    LL A[2][2] = { 0 };
+    A[0][0] = 1; A[0][1] = 1;
+    A[1][0] = 1; A[1][1] = 0;
+    qpow(A,p-1,A,mod);
+    f1 = (A[1][0]+A[1][1]) % mod; f2 = (A[0][0] + A[0][1]) % mod;
+}
+LL loop(LL mod)
+{
+    if (mod == 2) return 3;
+    else if (mod == 3) return 8;
+    else if (mod == 5) return 20;
+    LL p;
+    if (qpow(5,(mod-1)>>1,mod) == 1) p = mod - 1;
+    else p = 2*(mod + 1);
+    c = 0;
+    for(LL i = 1; i * i <= p; ++i) if (p % i == 0) {
+        LL x = i , y = p / i;
+        F(x,mod);
+        if (f1 == 0 && f2 == 1) return x;
+        if (y != x) S[c++] = y;
+    }
+    while (c > 0) {
+        F(S[--c],mod);
+        if (f1 == 0 && f2 == 1) return S[c];
+    }
+    return 0;
+}
+int main()
+{
+    while (cin >> n) {
+        LL x = n;
+        LL ans = 1;
+        for(LL i = 2; i * i <= x; ++i) if (x % i == 0) {
+            LL len = loop(i);
+            LL S = 1;
+            do x /= i, S = S * i;
+            while (x % i == 0);
+            S /= i; S = S * len;
+            ans = lcm(ans,S);
+        }
+        if (x > 1) {
+            LL len = loop(x);
+            ans = lcm(ans,len);
+        }
+        if (ans % 2 == 0) ans /= 2;
+        printf("%I64u\n",ans);
+    }
+}
diff --git a/HDOJ/4796_autoAC.cpp b/HDOJ/4796_autoAC.cpp
new file mode 100644
index 0000000..3350363
--- /dev/null
+++ b/HDOJ/4796_autoAC.cpp
@@ -0,0 +1,156 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <string.h>
+#include <cstring>
+#include <time.h>
+#include <stdio.h>
+#include <queue>
+#include <cmath>
+#include <set>
+#include <math.h>
+#include <map>
+#define rep(i,a,b) for(int i=(a);i<(b);++i)
+#define rrep(i,b,a) for(int i = (b); i >= (a); --i)
+#define clr(a,x) memset(a,(x),sizeof(a))
+#define LL long long
+#define eps 1e-10
+#define zero(x) -eps < (x) && (x) < eps
+using namespace std;
+short dp[2][1<<22];
+int q[2][1<<15];
+bool inq[2][1<<22];
+const int inf = 1<<14;
+char A[33][33];
+int N,M;
+inline int min(int a,int b) { return a < b ? a : b; }
+inline int max(int a,int b) { return a > b ? a : b; }
+inline int getBit(int s,int p)
+{
+    return (s & (3 << (p << 1))) >> (p << 1);
+}
+inline void setBit(int & s,int p,int x)
+{
+    s = (s ^ (s & (3 << (p<<1)))) | (x << (p<<1));
+}
+int cur;
+int rear[2];
+inline void update(int r,int c,int t,int cost)
+{
+    if (dp[cur^1][t] > cost) dp[cur^1][t] = cost;
+    if (!inq[cur^1][t]) inq[cur^1][t] = true, q[cur^1][rear[cur^1]++] = t;
+}
+inline void dp_block(int r,int c,int s)
+{
+    int t, c1 = getBit(s,M), c2 = getBit(s,c);
+    if (c1 || c2) return;
+    if (A[r][c] == '#') {
+        t = s;
+        update(r,c,t,dp[cur][s]);
+        return;
+    }
+    int side = 0;
+    rep(j,0,c)
+    if (getBit(s,j)) side ^= 1;
+    if (side == 0 && A[r][c] == 'L') return;
+    if (side == 1 && A[r][c] == 'W') return;
+    t = s;
+    update(r,c,t,dp[cur][s]);
+}
+inline void dp_digit(int r,int c,int s)
+{
+    int t;
+    int c1 = getBit(s,M);
+    int c2 = getBit(s,c);
+    if (c1 == 0 && c2 == 0) {
+        t = s;
+        update(r,c,t,dp[cur][s]);
+        setBit(t,M,2); setBit(t,c,1);
+        if (c < M-1) update(r,c,t,dp[cur][s] + A[r][c] - '0');
+    } else if (c1 == 0 || c2 == 0) {
+        int x = (c1 == 0 ? c2 : c1);
+        t = s;
+        setBit(t,M,x); setBit(t,c,0);
+        if (c < M-1) update(r,c,t,dp[cur][s] + A[r][c] - '0');
+        t = s;
+        setBit(t,c,x); setBit(t,M,0);
+        update(r,c,t,dp[cur][s] + A[r][c] - '0');
+    } else if (c1 == c2) {
+        int z = (c1 == 1 ? c : c-1);
+        for(; 0 <= z && z < M; z += (c1 == 1 ? 1 : -1))
+        if (getBit(s,z) == (c1 ^ 3)) break;
+        if (0 <= z && z < M) {
+            t = s;
+            setBit(t,z,c1);
+            setBit(t,M,0); setBit(t,c,0);
+            update(r,c,t,dp[cur][s] + A[r][c] - '0');
+        }
+    } else if (c1 == 2 && c2 == 1) {
+        t = s; setBit(t,M,0); setBit(t,c,0);
+        update(r,c,t,dp[cur][s] + A[r][c] - '0');
+    } else if (c1 == 3 && c2 == 1) {
+        int z = c;
+        for(; z < M; ++z)
+        if (getBit(s,z) == 2) break;
+        if (z < M) {
+            t = s;
+            setBit(t,c,0); setBit(t,M,0);
+            setBit(t,z,3);
+            update(r,c,t,dp[cur][s] + A[r][c] - '0');
+        }
+    } else if (c1 == 2 && c2 == 3) {
+        int z = c-1;
+        for(; z >= 0; --z)
+        if (getBit(s,z) == 1) break;
+        if (z >= 0) {
+            t = s;
+            setBit(t,c,0); setBit(t,M,0);
+            setBit(t,z,3);
+            update(r,c,t,dp[cur][s] + A[r][c] - '0');
+        }
+    }
+}
+void solve()
+{
+    cur = 0;
+    rear[0] = rear[1] = 0;
+    rep(i,0,(1<<((M+1)<<1))) dp[0][i] = dp[1][i] = inf;
+    clr(inq,0);
+    rep(i,0,M) {
+        int s = 0;
+        setBit(s,i,3);
+        dp[cur][s] = 0;
+        q[cur][rear[cur]++] = s;
+    }
+    rep(i,0,N) rep(j,0,M) {
+        rep(k,0,rear[cur]) {
+            int s = q[cur][k];
+            if (isdigit(A[i][j])) dp_digit(i,j,s);
+            else dp_block(i,j,s);
+            inq[cur][s] = false;
+            dp[cur][s] = inf;
+        }
+        rear[cur] = 0;
+        cur ^= 1;
+    }
+    int ans = inf;
+    int c = 0;
+    rep(j,0,M) {
+        int s = 0;
+        setBit(s,j,3);
+        ans = min(ans,dp[cur][s]);
+    }
+    if (ans == inf) ans = -1;
+    printf("%d\n",ans);
+}
+int main()
+{
+    while (scanf("%d%d",&N,&M)==2) {
+        rep(i,0,N) scanf("%s",A[i]);
+        int W = 0, L = 0;
+        rep(i,0,N) rep(j,0,M)
+        if (A[i][j] == 'W') ++W;
+        else if (A[i][j] == 'L') ++L;
+        solve();
+    }
+}
diff --git a/HDOJ/4798_autoAC.cpp b/HDOJ/4798_autoAC.cpp
new file mode 100644
index 0000000..abf2a64
--- /dev/null
+++ b/HDOJ/4798_autoAC.cpp
@@ -0,0 +1,43 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+const double pi=acos(-1);
+int R,r,H,t,S;
+double getlen(int n,double r)
+{
+    return 2.0*r*tan(pi/n);
+}
+int main()
+{
+    while(scanf("%d%d%d%d%d",&R,&r,&H,&t,&S)!=EOF)
+    {
+        double h=(double)H/t,ans=0;
+        int limit=100000;
+        for(int i=t;i>=1;i--)
+        {
+            double rr=1.0*(R-r)/t*(i-1)+r;
+            int mi=3,ma=limit,mid,num;
+            double s;
+            while(mi<=ma)
+            {
+                mid=(mi+ma)>>1;
+                double tmp=getlen(mid,rr)*h;
+                if(tmp-S>1e-8)
+                {
+                    s=tmp;
+                    num=mid;
+                    mi=mid+1;
+                }
+                else
+                ma=mid-1;
+            }
+            ans+=num*s;
+            limit=num;
+        }
+        printf("%.3lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4799_autoAC.cpp b/HDOJ/4799_autoAC.cpp
new file mode 100644
index 0000000..c6d055c
--- /dev/null
+++ b/HDOJ/4799_autoAC.cpp
@@ -0,0 +1,58 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include<cstdio>
+#include<algorithm>
+#include<vector>
+#include<cstring>
+using namespace std;
+#define maxn 50050
+int dp[maxn][2];
+int n,X,Y;
+bool state;
+int v[maxn],f,s[maxn],p;
+struct node{
+    int t,nxt;
+}edge[maxn<<1];
+int head[maxn];
+bool vis[maxn];
+void solve(int u)
+{
+    vis[u] = 1;
+    if(s[u])state ^= 1;
+    if(state)v[u] = -v[u];
+    dp[u][0] = v[u];
+    dp[u][1] = -v[u];
+    for (int i = head[u]; i!=-1; i = edge[i].nxt)
+    {
+        int y = edge[i].t;
+        if(!vis[y]){
+        solve(y);
+        dp[u][0] += max(dp[y][0],dp[y][1]-(s[y]?Y:X));
+        dp[u][1] += max(dp[y][1],dp[y][0]-(s[y]?Y:X));
+        }
+    }
+    if(s[u]) state ^= 1;
+}
+int main()
+{
+    while(scanf("%d%d%d",&n,&X,&Y)!=EOF)
+    {
+        memset(dp,0,sizeof(dp));
+        memset(head,-1,sizeof(head));
+        memset(vis,0,sizeof(vis));
+        int ind = 0;
+        state = 0;
+        for (int i = 1; i <= n; i++)
+        {
+            scanf("%d%d%d%d",&v[i],&f,&s[i],&p);
+            if(p) v[i] = -v[i];
+            edge[ind].t = i;
+            edge[ind].nxt = head[f];
+            head[f] = ind++;
+        }
+        solve(0);
+        if(dp[0][0] < 0)
+            puts("HAHAHAOMG");
+        else printf("%d\n",dp[0][0]);
+    }
+    return 0;
+}