diff --git a/HDOJ/4102_autoAC.cpp b/HDOJ/4102_autoAC.cpp
new file mode 100644
index 0000000..c578bab
--- /dev/null
+++ b/HDOJ/4102_autoAC.cpp
@@ -0,0 +1,177 @@
+#include <stdio.h>
+#include<algorithm>
+#include<math.h>
+#include<iostream>
+using namespace std;
+#define N 8005
+#define EPS 1e-8
+struct TPoint {
+    int x, y;
+    TPoint() {
+    }
+    TPoint(const int &_x, const int &_y) :
+        x(_x), y(_y) {
+    }
+    bool operator ==(const TPoint &b) const {
+        return (x == b.x && y == b.y);
+    }
+    TPoint operator-(const TPoint &b) const {
+        return TPoint(x - b.x, y - b.y);
+    }
+};
+TPoint p[N], hull[N],r;
+int tn;
+double cross(const TPoint & a, const TPoint & b, const TPoint & c) {
+    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}
+double len(const TPoint &a) {
+    return sqrt((double) (a.x * a.x + a.y * a.y));
+}
+double dis(const TPoint &a, const TPoint &b) {
+    return len(b - a);
+}
+bool graham_cmp(const TPoint &b, const TPoint &c) {
+    double tmp = cross(b, c, p[0]);
+    if (tmp > EPS)
+        return true;
+    if (fabs(tmp) < EPS && (dis(b, p[0]) < dis(c, p[0])))
+        return true;
+    return false;
+}
+int graham_scan(int n) {
+    int top, i, k = 0;
+    for (i = 1; i < n; ++i) {
+        if ((p[k].y - p[i].y < EPS) || (fabs((double)p[i].y - p[k].y) < EPS && p[k].x
+                - p[i].x > EPS))
+            k = i;
+    }
+    swap(p[0], p[k]);
+    sort(p + 1, p + n, graham_cmp);
+    hull[0] = p[0], hull[1] = p[1], hull[2] = p[2];
+    if (n < 3)
+        return n;
+    else
+        top = 3;
+    for (i = 3; i < n; ++i) {
+        while (top >= 2 && cross(hull[top - 2], hull[top - 1], p[i]) < EPS)
+            --top;
+        hull[top++] = p[i];
+    }
+    return top;
+}
+inline double dis_p2_line(TPoint & a,TPoint & b,TPoint & p)
+{ return fabs(cross(a,p,b))/dis(a,b); }
+struct node {
+    int x1, x2, y1, y2;
+    int level;
+    bool flag;
+} a[2005];
+int Max(int a, int b) {
+    return a > b ? a : b;
+}
+int Min(int a, int b) {
+    return a < b ? a : b;
+}
+int main() {
+    int i, j, n;
+    int level, t, x, y;
+    while (scanf("%d", &n) != EOF) {
+        for (i = 0; i < n; ++i) {
+            scanf("%d%d%d%d", &a[i].x1, &a[i].y1, &a[i].x2, &a[i].y2);
+            a[i].flag = false;
+            a[i].x1 *= 2;
+            a[i].y1 *= 2;
+            a[i].x2 *= 2;
+            a[i].y2 *= 2;
+            if (a[i].x1 > a[i].x2) {
+                t = a[i].x1;
+                a[i].x1 = a[i].x2;
+                a[i].x2 = t;
+            }
+            if (a[i].y1 > a[i].y2) {
+                t = a[i].y1;
+                a[i].y1 = a[i].y2;
+                a[i].y2 = t;
+            }
+        }
+        a[0].level = 1;
+        a[0].flag = true;
+        for (i = 1; i < n; ++i) {
+            level = 1;
+            for (j = i-1; j >= 0; --j) {
+                if (level >= a[j].level + 1)
+                    continue;
+                if (a[i].x2 <= a[j].x1)
+                    continue;
+                if (a[j].x2 <= a[i].x1)
+                    continue;
+                if (a[i].y2 <= a[j].y1)
+                    continue;
+                if (a[j].y2 <= a[i].y1)
+                    continue;
+                level = a[j].level + 1;
+            }
+            a[i].level = level;
+            tn = 0;
+            for (j = 0; j < i; ++j) {
+                if (level != a[j].level + 1)
+                    continue;
+                if (a[i].x2 <= a[j].x1)
+                    continue;
+                if (a[j].x2 <= a[i].x1)
+                    continue;
+                if (a[i].y2 <= a[j].y1)
+                    continue;
+                if (a[j].y2 <= a[i].y1)
+                    continue;
+                int x1,x2,y1,y2;
+                x1 = Max(a[i].x1,a[j].x1);
+                x2 = Min(a[i].x2,a[j].x2);
+                y1 = Max(a[i].y1,a[j].y1);
+                y2 = Min(a[i].y2,a[j].y2);
+                p[tn].x = x1;
+                p[tn++].y = y1;
+                p[tn].x = x1;
+                p[tn++].y = y2;
+                p[tn].x = x2;
+                p[tn++].y = y1;
+                p[tn].x = x2;
+                p[tn++].y = y2;
+            }
+            if(tn==0)
+            {
+                a[i].flag=true;
+                continue;
+            }
+            p[tn].x=((a[i].x1+a[i].x2)>>1);
+            p[tn++].y=((a[i].y1+a[i].y2)>>1);
+            tn=graham_scan(tn);
+            a[i].flag=true;
+            for(j=0;j<tn;++j)
+            {
+                if(hull[j]==TPoint(((a[i].x1+a[i].x2)>>1),((a[i].y1+a[i].y2)>>1)))
+                {
+                    a[i].flag=false;
+                    a[i].level=-1;
+                    break;
+                }
+                r=TPoint(((a[i].x1+a[i].x2)>>1),((a[i].y1+a[i].y2)>>1));
+                double s=fabs(dis_p2_line(hull[j],hull[(j+1)%tn],r));
+                if(s<EPS)
+                {
+                    a[i].flag=false;
+                    a[i].level=-1;
+                    break;
+                }
+            }
+        }
+        int ans=0;
+        for(i=0;i<n;++i)
+        {
+            if(a[i].flag)
+                ans++;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4103_autoAC.cpp b/HDOJ/4103_autoAC.cpp
new file mode 100644
index 0000000..7f1df9a
--- /dev/null
+++ b/HDOJ/4103_autoAC.cpp
@@ -0,0 +1,20 @@
+#include<stdio.h>
+#include<iostream>
+#include<string>
+#include<stdlib.h>
+#include<math.h>
+#include<algorithm>
+#include<queue>
+using namespace std;
+int a,b;
+double c,d,t,pi;
+bool flag;
+int main()
+{
+    pi = 3.1416926536;
+    while(scanf("%d%d%lf",&a,&b,&c)!=EOF && (a!=0 || b !=0 || fabs(c)>0.0000001))
+    {
+        printf("%d\n",a - 1);
+    }
+    return 0;
+}
diff --git a/HDOJ/4104_autoAC.cpp b/HDOJ/4104_autoAC.cpp
new file mode 100644
index 0000000..4958f7d
--- /dev/null
+++ b/HDOJ/4104_autoAC.cpp
@@ -0,0 +1,25 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+int a[1005],sum[1005];
+int main()
+{
+    int n,i;
+    while(scanf("%d",&n)!=EOF)
+    {
+        memset(sum,0,sizeof(sum));
+        for(i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        sort(a+1,a+1+n);
+        for(i=1;i<=n;i++)
+            sum[i]=sum[i-1]+a[i];
+        for(i=1;i<=n;i++)
+        {
+            if(a[i]>sum[i-1]+1)
+                break;
+        }
+        printf("%d\n",sum[i-1]+1);
+    }
+    return 0;
+}
diff --git a/HDOJ/4105_autoAC.cpp b/HDOJ/4105_autoAC.cpp
new file mode 100644
index 0000000..cf0cdad
--- /dev/null
+++ b/HDOJ/4105_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std;
+char a[5000];
+int main()
+{
+    int i,j,k,n,m,b,c;
+    while (1)
+    {
+          if (scanf("%d",&n)==EOF) break;
+          scanf("%s",a);
+          for (i=0;i<n;i++) a[i]-='0';
+          bool f=false;
+          int ans=0;
+          b=0;
+          c=10;
+          for (i=0;i<n;i++)
+          {
+              if (f==false)
+              {
+                 if (c>a[i]) b=a[i];
+                 else
+                 {
+                     i++;
+                     b=a[i];
+                 }
+              }
+              else
+              {
+                  if (a[i]>b) c=a[i];
+                  else
+                  {
+                      if (a[i]==0)
+                      {
+                         while (a[i]==0) i++;
+                         b=0;
+                         c=a[i];
+                      }
+                      else
+                      {
+                          i++;
+                          c=a[i-1]*10+a[i];
+                      }
+                  }
+              }
+              if (i>=n) break;
+              ans++;f=!f;
+          }
+          cout<<ans-1<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4106_autoAC.cpp b/HDOJ/4106_autoAC.cpp
new file mode 100644
index 0000000..83134f8
--- /dev/null
+++ b/HDOJ/4106_autoAC.cpp
@@ -0,0 +1,101 @@
+#include<cstdio>  
+#include<stdlib.h>  
+#include<cstring>  
+using namespace std;  
+const int inf=99999999;  
+struct{  
+    int v, cap, cost, next, re;  
+}edge[10005];  
+int n,ans;  
+int k,edgeHead[1050];  
+int que[10050],pre[1050],dis[1050];  
+bool vis[1050];  
+int wei[1050];  
+int min(int a,int b){  
+    return a>b?b:a;  
+}  
+int max(int a,int b){  
+    return a>b?a:b;  
+}  
+void addEdge(int u,int v,int ca,int co){  
+    edge[k].v=v;  
+    edge[k].cap=ca;  
+    edge[k].cost=co;  
+    edge[k].next=edgeHead[u];  
+    edge[k].re=k + 1;          
+    edgeHead[u]=k ++;  
+    edge[k].v=u;  
+    edge[k].cap=0;  
+    edge[k].cost=-co;               
+    edge[k].next=edgeHead[v];  
+    edge[k].re=k - 1;  
+    edgeHead[v]=k ++;  
+}  
+bool spfa(){                 
+    int i, head = 0, tail = 1;    
+    for(i = 0; i <= n; i ++){  
+        dis[i] = inf;
+        vis[i] = false;  
+    }  
+    dis[0] = 0;  
+    que[0] = 0;  
+    vis[0] = true;  
+    while(head != tail){  
+        int u = que[head];  
+        for(i = edgeHead[u]; i != 0; i = edge[i].next){  
+            int v = edge[i].v;  
+            if(edge[i].cap && dis[v] >dis[u] + edge[i].cost){ 
+                dis[v] = dis[u] + edge[i].cost;  
+                pre[v] = i;                       
+                if(!vis[v]){  
+                    vis[v] = true;  
+                    que[tail ++] = v;  
+                    if(tail == 10000) tail = 0;             
+                }  
+            }  
+        }  
+        vis[u] = false;  
+        head++;  
+        if(head ==10000) head = 0;  
+    }  
+    if(dis[n] ==inf) return false;
+    return true;  
+}  
+void end(){  
+    int u, p;  
+    for(u = n; u != 0; u = edge[edge[p].re].v){  
+        p = pre[u];  
+        edge[p].cap -= 1;  
+        edge[edge[p].re].cap += 1;  
+        ans += edge[p].cost;  
+    }  
+}  
+int main(){  
+    int i,j,v,lim,m,sum;  
+    while(scanf("%d %d %d",&v,&m,&lim)!=EOF){  
+        k=1;  
+        sum=0;  
+        memset(edgeHead,0,sizeof(edgeHead));  
+        for(i=1;i<=v;i++){  
+            scanf("%d",&wei[i]);  
+            sum+=wei[i];  
+        }  
+        if(m<=lim){  
+            printf("%d\n",sum);  
+            continue;  
+        }                            
+        n=v-m+2;  
+        for(i=0;i<=n;i++){  
+            addEdge(i,i+1,lim,0);  
+        }  
+        for(i=1;i<=v;i++){  
+            addEdge(max(1,i-m+1),min(n-1,i)+1,1,-wei[i]);  
+        }  
+        ans=0;  
+        n++;  
+        while(spfa())  
+            end();  
+        printf("%d\n",-ans);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4107_autoAC.cpp b/HDOJ/4107_autoAC.cpp
new file mode 100644
index 0000000..e872dda
--- /dev/null
+++ b/HDOJ/4107_autoAC.cpp
@@ -0,0 +1,113 @@
+#include<iostream>
+#include<cstring>
+#include<cstdlib>
+#include<cstdio>
+#define N  200005
+struct cam
+{
+    int x;
+    int y;
+    int min;
+    int max;
+    int v;
+}list[N*4];
+int n,m,p;
+int Min(int x,int y)
+{
+    return x<y?x:y;
+}
+int Max(int x,int y)
+{
+    return x>y?x:y;
+}
+void build(int k,int x,int y)
+{
+    list[k].x=x;
+    list[k].y=y;
+    list[k].min=list[k].max=list[k].v=0;
+    if(x==y)
+    return;
+    int mid=(x+y)/2;
+    build(k<<1,x,mid);
+    build(k<<1|1,mid+1,y);
+}
+void lazy(int k)
+{
+    int v=list[k].v;
+    if(v>0)
+    {
+        list[k<<1].v+=v;
+        list[k<<1].min+=v;
+        list[k<<1].max+=v;
+        list[k<<1|1].v+=v;
+        list[k<<1|1].min+=v;
+        list[k<<1|1].max+=v;
+        list[k].v=0;
+    }
+}
+void update(int k,int a,int b,int c)
+{
+    if(list[k].x==a&&list[k].y==b&&(list[k].min>=p||list[k].max<p))
+    {
+        if(list[k].max<p)
+        {
+            list[k].v+=c;
+            list[k].max+=c;
+            list[k].min+=c;
+        }
+        else
+        {
+            list[k].v+=c*2;
+            list[k].max+=c*2;
+            list[k].min+=c*2;
+        }
+        return;
+    }
+    if(list[k].v>0)
+    lazy(k);
+    int mid=(list[k].x+list[k].y)/2;
+    if(a>mid)
+    update(k<<1|1,a,b,c);
+    else if(b<=mid)
+    update(k<<1,a,b,c);
+    else
+    {
+        update(k<<1,a,mid,c);
+        update(k<<1|1,mid+1,b,c);
+    }
+    list[k].max=Max(list[k<<1].max,list[k<<1|1].max);
+    list[k].min=Min(list[k<<1].min,list[k<<1|1].min);
+}
+int query(int k,int id)
+{
+    if(list[k].x==id&&list[k].y==id) 
+    return list[k].v;
+    if(list[k].v>0)
+    lazy(k);
+    int mid=(list[k].x+list[k].y)/2;
+    if(id<=mid)
+    return query(k<<1,id);
+    else
+    return query(k<<1|1,id);
+}
+int main()
+{
+    int i,a,b,c;
+    while(scanf("%d%d%d",&n,&m,&p)!=EOF)
+    {
+        build(1,1,n);
+        while(m--)
+        {
+            scanf("%d%d%d",&a,&b,&c);
+            update(1,a,b,c);
+        }
+        for(i=1;i<=n;i++)
+        {
+            if(i==n)
+            printf("%d\n",query(1,i));
+            else
+            printf("%d ",query(1,i));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4109_autoAC.cpp b/HDOJ/4109_autoAC.cpp
new file mode 100644
index 0000000..4fdcc2b
--- /dev/null
+++ b/HDOJ/4109_autoAC.cpp
@@ -0,0 +1,59 @@
+#include<cstdio>
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<cstring>
+using namespace std;
+struct node
+{
+    int y,t;
+}edge[10009];
+int T[1009];
+vector<node> v[1009]; int n,m;
+int in[1009];
+void solve()
+{
+    queue<int> q;
+    for(int i=0;i<n;i++)
+    if(in[i]==0)
+    {
+        q.push(i);
+        T[i]=1;
+    }
+    while(!q.empty())
+    {
+        int x=q.front();q.pop();
+        for(int i=0;i<v[x].size();i++)
+        {
+            int y=v[x][i].y;
+            T[y]=max(T[y],T[x]+v[x][i].t);
+            in[y]--;
+            if(in[y]==0)
+            {
+                q.push(y);
+            }
+        }
+    }
+    int ans=0;
+    for(int i=0;i<n;i++)
+    ans=max(ans,T[i]);
+    cout<<ans<<endl;
+}
+int main()
+{
+   int a,b,t;
+   while(scanf("%d%d",&n,&m)!=EOF)
+   {
+       memset(in,0,sizeof(in));
+       memset(T,0,sizeof(T));
+       for(int i=0;i<n;i++)
+       v[i].clear();
+       for(int i=0;i<m;i++)
+       {
+           scanf("%d%d%d",&a,&edge[i].y,&edge[i].t);
+           v[a].push_back(edge[i]);
+           in[edge[i].y]++;
+       }
+       solve();
+   }
+}
diff --git a/HDOJ/4111_autoAC.cpp b/HDOJ/4111_autoAC.cpp
new file mode 100644
index 0000000..cb134cd
--- /dev/null
+++ b/HDOJ/4111_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<stdio.h>
+#include<string.h>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+int dp[55][55000];
+int a[55];
+int DP(int a,int b)
+{
+    if(dp[a][b]!=-1) return dp[a][b];
+    if(b==1) return dp[a][b]=DP(a+1,0);
+    dp[a][b]=0;
+    if(a>=1&&!DP(a-1,b))
+        dp[a][b]=1;
+    if(a>=1&&b&&!DP(a-1,b+1))
+        dp[a][b]=1;
+    if(a>=2&&((b&&!DP(a-2,b+3))||(b==0&&!DP(a-2,2))))
+        dp[a][b]=1;
+    if(b>=2&&!DP(a,b-1))
+        dp[a][b]=1;
+    return dp[a][b];
+}
+int main()
+{
+    memset(dp,-1,sizeof(dp));
+    int t,test=1,n,i,j,k;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(j=0,k=0,i=0;i<n;i++)
+        {
+            scanf("%d",&a[i]);
+            if(a[i]==1) j++;
+            else k+=a[i]+1;
+        }
+        if(k) k--;
+        DP(j,k);
+        printf("Case #%d: ",test++);
+        if(dp[j][k]) printf("Alice\n");
+        else printf("Bob\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4112_autoAC.cpp b/HDOJ/4112_autoAC.cpp
new file mode 100644
index 0000000..7441795
--- /dev/null
+++ b/HDOJ/4112_autoAC.cpp
@@ -0,0 +1,28 @@
+#include<stdio.h>
+#include<math.h>
+int main()
+{
+    int T;
+    int iCase=0;
+    int n,m,k;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d%d",&n,&m,&k);
+        int t1=n,t2,t3=n;
+        if(m<t1)t1=m;
+        if(k<t1)t1=k;
+        if(m>t3)t3=m;
+        if(k>t3)t3=k;
+        t2=n+m+k-t1-t3;
+        n=t1;m=t2;k=t3;
+        int res=0;
+        if(n>1)res+=(int)(log(1.0*n)/log(2.0)+0.999);
+        if(m>1)res+=(int)(log(1.0*m)/log(2.0)+0.999);
+        if(k>1)res+=(int)(log(1.0*k)/log(2.0)+0.999);
+        long long res1=(long long)n*m*k-1;
+        printf("Case #%d: %I64d %d\n",iCase,res1,res);
+    }    
+    return 0;
+}
diff --git a/HDOJ/4114_autoAC.cpp b/HDOJ/4114_autoAC.cpp
new file mode 100644
index 0000000..d109bc9
--- /dev/null
+++ b/HDOJ/4114_autoAC.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std;
+#define INF 0x3f3f3f3f
+typedef long long LL;
+const int N=55;
+int adj[N][N];
+int pos[N],T[N],FT[N],pass[N];
+int dis[N][1<<8][1<<8];
+int n,m,K;
+void floyed()
+{
+    for(int k=1;k<=n;k++)
+    {
+        for(int i=1;i<=n;i++) if(i!=k)
+        {
+            for(int j=1;j<=n;j++) if(j!=i&&j!=k)
+            {
+                adj[i][j]=min(adj[i][j],adj[i][k]+adj[k][j]);
+            }
+        }
+    }
+}
+int fun()
+{
+    int ans=INF;
+    dis[1][0][0]=0;
+    for(int s1=0;s1<(1<<K);s1++)
+    {
+        for(int s2=0;s2<(1<<K);s2++)
+        {
+            for(int i=1;i<=n;i++)
+            {
+                int now=dis[i][s1][s2];
+                if(now==INF) continue;
+                if(s2==((1<<K)-1)) ans=min(ans,now+adj[i][1]);
+                for(int j=0;j<K;j++) if((s2&(1<<j))==0)
+                {
+                    int &nxt=dis[pos[j]][ s1|pass[ pos[j] ] ][s2^(1<<j)];
+                    int add=adj[i][pos[j]];
+                    if(s1&(1<<j)) add+=FT[j];
+                    else add+=T[j];
+                    nxt=min(nxt,now+add);
+                }
+                for(int j=1;j<=n;j++)
+                {
+                    int &nxt=dis[j][s1|pass[j]][s2];
+                    int add=adj[i][j];
+                    nxt=min(nxt,now+add);
+                }
+            }
+        }
+    }
+    return ans;
+}
+int main()
+{
+    int t,t_cnt=0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        memset(dis,0x3f,sizeof(dis));
+        memset(adj,0x3f,sizeof(adj));
+        memset(pass,0,sizeof(pass));
+        for(int i=0;i<N;i++) adj[i][i]=0;
+        scanf("%d%d%d",&n,&m,&K);
+        for(int i=0;i<m;i++)
+        {
+            int a,b,c; scanf("%d%d%d",&a,&b,&c);
+            adj[a][b]=adj[b][a]=c;
+        }
+        floyed();
+        for(int i=0;i<K;i++)
+        {
+            scanf("%d%d%d",&pos[i],&T[i],&FT[i]);
+            int num; scanf("%d",&num);
+            for(int j=0;j<num;j++)
+            {
+                int tmp; scanf("%d",&tmp);
+                pass[tmp]|=(1<<i);
+            }
+        }
+        printf("Case #%d: %d\n",++t_cnt,fun());
+    }
+    return 0;
+}
diff --git a/HDOJ/4115_autoAC.cpp b/HDOJ/4115_autoAC.cpp
new file mode 100644
index 0000000..4dc0c42
--- /dev/null
+++ b/HDOJ/4115_autoAC.cpp
@@ -0,0 +1,152 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<vector>
+#include<queue>
+#include<string.h>
+using namespace std;
+const int MAXN=22000;
+bool visit[MAXN];
+queue<int>q1,q2;
+vector<vector<int> >adj; 
+vector<vector<int> >radj;
+vector<vector<int> >dag;
+int n,m,cnt;
+int id[MAXN],order[MAXN],ind[MAXN];
+void dfs(int u)
+{
+    visit[u]=true;
+    int i,len=adj[u].size();
+    for(i=0;i<len;i++)
+      if(!visit[adj[u][i]])
+        dfs(adj[u][i]);
+    order[cnt++]=u;
+}
+void rdfs(int u)
+{
+    visit[u]=true;
+    id[u]=cnt;
+    int i,len=radj[u].size();
+    for(i=0;i<len;i++)
+      if(!visit[radj[u][i]])
+        rdfs(radj[u][i]);
+}
+void korasaju()
+{
+    int i;
+    memset(visit,false,sizeof(visit));
+    for(cnt=0,i=0;i<2*n;i++)
+      if(!visit[i])
+        dfs(i);
+    memset(id,0,sizeof(id));
+    memset(visit,false,sizeof(visit));
+    for(cnt=0,i=2*n-1;i>=0;i--)
+      if(!visit[order[i]])
+      {
+          cnt++;
+          rdfs(order[i]);
+      }
+}
+bool solvable()
+{
+    for(int i=0;i<n;i++)
+      if(id[2*i]==id[2*i+1])
+        return false;
+   return true;
+}
+void add(int x,int y)
+{
+    adj[x].push_back(y);
+    radj[y].push_back(x);
+}
+int a[MAXN],b[MAXN];
+int main()
+{
+    int T;
+    int x,y,z;
+    scanf("%d",&T);
+    int iCase=0;
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d",&n,&m);
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d",&a[i]);
+            if(a[i]==1)b[i]=2;
+            else if(a[i]==2)b[i]=3;
+            else b[i]=1;
+            if(a[i]>b[i])swap(a[i],b[i]);
+        }
+        adj.assign(2*n,vector<int>());
+        radj.assign(2*n,vector<int>());
+        bool flag=true;
+        while(m--)
+        {
+            scanf("%d%d%d",&x,&y,&z);
+            x--;
+            y--;
+            if(!flag)continue;
+            if(x==y)
+            {
+                if(z==1)flag=false;
+                continue;
+            }
+            if(z==0)
+            {
+                if(a[x]!=a[y])
+                {
+                    add(2*x,2*y+1);
+                    add(2*y,2*x+1);
+                }
+                if(a[x]!=b[y])
+                {
+                    add(2*x,2*y);
+                    add(2*y+1,2*x+1);
+                }
+                if(b[x]!=a[y])
+                {
+                    add(2*x+1,2*y+1);
+                    add(2*y,2*x);
+                }
+                if(b[x]!=b[y])
+                {
+                    add(2*x+1,2*y);
+                    add(2*y+1,2*x);
+                }
+            }
+            else if(z==1)
+            {
+                if(a[x]==a[y])
+                {
+                    add(2*x,2*y+1);
+                    add(2*y,2*x+1);
+                }
+                if(a[x]==b[y])
+                {
+                    add(2*x,2*y);
+                    add(2*y+1,2*x+1);
+                }
+                if(b[x]==a[y])
+                {
+                    add(2*x+1,2*y+1);
+                    add(2*y,2*x);
+                }
+                if(b[x]==b[y])
+                {
+                    add(2*x+1,2*y);
+                    add(2*y+1,2*x);
+                }
+            }
+        }
+        if(!flag)
+        {
+            printf("Case #%d: no\n",iCase);
+            continue;
+        }
+        korasaju();
+        if(solvable())printf("Case #%d: yes\n",iCase);
+        else printf("Case #%d: no\n",iCase);
+    }
+    return 0;
+}
diff --git a/HDOJ/4117_autoAC.cpp b/HDOJ/4117_autoAC.cpp
new file mode 100644
index 0000000..fe09fb7
--- /dev/null
+++ b/HDOJ/4117_autoAC.cpp
@@ -0,0 +1,244 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <cstdio>
+#include <queue>
+#include <cstring>
+using namespace std;
+#define D(x)
+const int MAX_CHILD_NUM = 26;
+const int MAX_NODE_NUM = 3 * (int)1e5 + 10;
+const int MAX_LEN = 3 * (int)1e5 + 10;
+const int MAX_N = 2 * (int)1e4 + 10;
+#define MAX_EDGE_NUM MAX_NODE_NUM * 2
+struct Edge
+{
+    int v, next;
+    Edge()
+    {}
+    Edge(int v, int next):v(v), next(next)
+    {}
+} edge[MAX_EDGE_NUM];
+int head[MAX_NODE_NUM];
+int edge_cnt;
+void init_edge()
+{
+    memset(head, -1, sizeof(head));
+    edge_cnt = 0;
+}
+void add_edge(int u, int v)
+{
+    edge[edge_cnt] = Edge(v, head[u]);
+    head[u] = edge_cnt++;
+}
+struct Trie
+{
+    int next[MAX_NODE_NUM][MAX_CHILD_NUM];
+    int fail[MAX_NODE_NUM];
+    int count[MAX_NODE_NUM];
+    int node_cnt;
+    int root;
+    bool vis[MAX_NODE_NUM]; //set it to false
+    void init()
+    {
+        node_cnt = 0;
+        root = newnode();
+    }
+    int newnode()
+    {
+        for (int i = 0; i < MAX_CHILD_NUM; i++)
+            next[node_cnt][i] = -1;
+        count[node_cnt++] = 0;
+        return node_cnt - 1;
+    }
+    int get_id(char a)
+    {
+        return a - 'a';
+    }
+    void insert(char buf[], int index)
+    {
+        int now = root;
+        for (int i = 0; buf[i]; i++)
+        {
+            int id = get_id(buf[i]);
+            if (next[now][id] == -1)
+                next[now][id] = newnode();
+            now = next[now][id];
+        }
+        count[now] = index;
+    }
+    void build()
+    {
+        queue<int>Q;
+        fail[root] = root;
+        for (int i = 0; i < MAX_CHILD_NUM; i++)
+            if (next[root][i] == -1)
+                next[root][i] = root;
+            else
+            {
+                fail[next[root][i]] = root;
+                Q.push(next[root][i]);
+            }
+        while (!Q.empty())
+        {
+            int now = Q.front();
+            Q.pop();
+            for (int i = 0; i < MAX_CHILD_NUM; i++)
+                if (next[now][i] == -1)
+                    next[now][i] = next[fail[now]][i];
+                else
+                {
+                    fail[next[now][i]]=next[fail[now]][i];
+                    Q.push(next[now][i]);
+                }
+        }
+    }
+    void build_fail_tree()
+    {
+        init_edge();
+        for (int i = 1; i < node_cnt; i++)
+        {
+            add_edge(i, fail[i]);
+            add_edge(fail[i], i);
+        }
+    }
+}ac;
+const int MAX_INTERVAL = MAX_LEN;
+struct SegmentTree
+{
+    struct Node
+    {
+        int l, r;
+        Node *pleft, *pright;
+        int value;
+    }tree[MAX_INTERVAL *4];
+    int node_cnt;
+    void init()
+    {
+        node_cnt = 0;
+    }
+    Node* new_node()
+    {
+        node_cnt++;
+        return tree + node_cnt;
+    }
+    void build_tree(Node *proot, int s, int e)
+    {
+        proot->l = s;
+        proot->r = e;
+        proot->value = 0;
+        if (s == e)
+        {
+            proot->pleft = proot->pright = NULL;
+            return;
+        }
+        int mid = (s + e) / 2;
+        build_tree(proot->pleft = new_node(), s, mid);
+        build_tree(proot->pright = new_node(), mid + 1, e);
+    }
+    void pull_up(Node *proot)
+    {
+    }
+    void push_down(Node *proot)
+    {
+    }
+    void update(Node *proot, int start, int end, int value)
+    {
+        if (start > proot->r || end < proot->l)
+            return;
+        start = max(start, proot->l);
+        end = min(end, proot->r);
+        if (start == proot->l && end == proot->r)
+        {
+            proot->value = max(proot->value, value);
+            return;
+        }
+        push_down(proot);
+        update(proot->pleft, start, end, value);
+        update(proot->pright, start, end, value);
+        pull_up(proot);
+    }
+    int query(Node *proot, int start, int end)
+    {
+        int ret = proot->value;
+        if (start > proot->r || end < proot->l)
+            return 0;
+        start = max(start, proot->l);
+        end = min(end, proot->r);
+        if (start == proot->l && end == proot->r)
+        {
+            return ret;
+        }
+        push_down(proot);
+        ret = max(ret, query(proot->pleft, start, end));
+        ret = max(ret, query(proot->pright, start, end));
+        pull_up(proot);
+        return ret;
+    }
+}tree;
+char st[MAX_LEN];
+int pos[MAX_N];
+int dfn[MAX_LEN][2];
+int dfn_cnt;
+int n;
+int weight[MAX_N];
+void dfs(int u, int parent)
+{
+    dfn[u][0] = ++dfn_cnt;
+    for (int i = head[u]; i != -1; i = edge[i].next)
+    {
+        int v = edge[i].v;
+        if (v != parent)
+        {
+            dfs(v, u);
+        }
+    }
+    dfn[u][1] = dfn_cnt;
+}
+int work()
+{
+    int ret = 0;
+    tree.init();
+    tree.build_tree(tree.tree, 0, dfn_cnt);
+    for (int i = 0; i < n; i++)
+    {
+        int u = ac.root;
+        int temp = 0;
+        for (int j = pos[i]; j < pos[i + 1]; j++)
+        {
+            u = ac.next[u][ac.get_id(st[j])];
+            temp = max(temp, tree.query(tree.tree, dfn[u][0], dfn[u][0]) + weight[i]);
+        }
+        tree.update(tree.tree, dfn[u][0], dfn[u][1], temp);
+        ret = max(ret, temp);
+    }
+    return ret;
+}
+void input()
+{
+    scanf("%d", &n);
+    int temp = 0;
+    for (int i = 0; i < n; i++)
+    {
+        scanf("%s%d", st + temp, &weight[i]);
+        pos[i] = temp;
+        ac.insert(st + temp, i);
+        int len = strlen(st + temp);
+        temp += len;
+    }
+    pos[n] = temp;
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    for (int i = 1; i <= t; i++)
+    {
+        ac.init();
+        input();
+        ac.build();
+        ac.build_fail_tree();
+        dfn_cnt = 0;
+        dfs(0, -1);
+        printf("Case #%d: %d\n", i, work());
+    }
+    return 0;
+}
diff --git a/HDOJ/4118_autoAC.cpp b/HDOJ/4118_autoAC.cpp
new file mode 100644
index 0000000..812fc9b
--- /dev/null
+++ b/HDOJ/4118_autoAC.cpp
@@ -0,0 +1,68 @@
+#pragma comment(linker, "/STACK:10240000000000,10240000000000")
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#define MAXN 101005
+#define MAXM 400005
+#define INF 1000000000
+using namespace std;
+struct EDGE
+{
+    int v, next;
+    long long w;
+}edge[MAXM];
+int head[MAXN], e;
+int n;
+int num[MAXN];
+long long ans;
+void init()
+{
+    ans = 0;
+    memset(head, -1, sizeof(head));
+    e = 0;
+    memset(num, 0, sizeof(num));
+}
+void add(int u, int v, long long w)
+{
+    edge[e].v = v;
+    edge[e].w = w;
+    edge[e].next = head[u];
+    head[u] = e++;
+}
+void dfs(int u, int fa)
+{
+    num[u] = 1;
+    for(int i = head[u]; i != -1; i = edge[i].next)
+    {
+        int v = edge[i].v;
+        if(v != fa)
+        {
+            dfs(v, u);
+            num[u] += num[v];
+            long long tmp = min(num[v], n - num[v]);
+            ans += tmp * edge[i].w * 2LL;
+        }
+    }
+}
+int main()
+{
+    int T, cas = 0, x, y, z;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%d", &n);
+        init();
+        for(int i = 1; i < n; i++)
+        {
+            scanf("%d%d%d", &x, &y, &z);
+            add(x, y, z);
+            add(y, x, z);
+        }
+        dfs(1, 0);
+        printf("Case #%d: %I64d\n", ++cas, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4119_autoAC.cpp b/HDOJ/4119_autoAC.cpp
new file mode 100644
index 0000000..8f87fb0
--- /dev/null
+++ b/HDOJ/4119_autoAC.cpp
@@ -0,0 +1,111 @@
+#include <set>
+#include <string>
+#include <stdio.h>
+#include <algorithm>
+using namespace std;
+struct Point
+{
+    int x,y;
+    Point(){}
+    Point(int x,int y):x(x),y(y){}
+    bool operator <(const Point& S)const
+    {
+        return x<S.x || x==S.x && y<S.y;
+    }
+}P[4][666];
+struct TT
+{
+    string s;
+    bool ok;
+    bool operator <(const TT& S)const
+    {
+        return s < S.s;
+    }
+}Ans[4];
+int n,m;
+Point Rotary(Point A)
+{
+    return Point(A.y,n+1-A.x);
+}
+int main()
+{
+    int z,ncase=0;
+    char tmp[25],map[55][55];
+    set<string> Dic;
+    scanf("%d",&z);
+    while(z--)
+    {
+        Dic.clear();
+        scanf("%d",&n);
+        for(int i=1;i<=n;i++)
+            scanf("%s",map[i]+1);
+        int top = 0;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%s",map[0]+1);
+            for(int j=1;j<=n;j++)
+                if(map[0][j] == '*')
+                    P[0][top++] = Point(i,j);
+        }
+        for(int i=1;i<=3;i++)
+            for(int j=0;j<top;j++)
+                P[i][j] = Rotary(P[i-1][j]);
+        for(int i=0;i<=3;i++)
+            sort(P[i],P[i]+top);
+        for(int k=0;k<=3;k++)
+            Ans[k].ok = true;
+        scanf("%d",&m);
+        for(int i=0;i<m;i++)
+        {
+            scanf("%s",tmp);
+            Dic.insert(tmp);
+        }
+        for(int k=0;k<=3;k++)
+        {
+            int loc = -1;
+            string& str = Ans[k].s;
+            str = "";
+            for(int i=k;i<k+4;i++)
+                for(int j=0;j<top;j++)
+                {
+                    char ttmp = map[ P[i%4][j].x ][ P[i%4][j].y ];
+                    str += ttmp=='.' ? ' ' : ttmp;
+                }
+            while(!str.empty() && str[0]==' ')
+                str.erase(str.begin());
+            for(int i=1;i<str.length();i++)
+                if(str[i]==' ' && str[i-1]==' ')
+                    str.erase(str.begin()+(i--));
+            if(!str.empty() && str[ str.length()-1 ]==' ')
+                str.erase(str.end()-1);
+            if(str.empty())
+            {
+                Ans[k].ok = false;
+                continue;
+            }
+            while(++loc < str.length())
+            {
+                string word;
+                while(loc<str.length() && str[loc]!=' ')
+                    word += str[loc++];
+                if(Dic.find(word) == Dic.end())
+                {
+                    Ans[k].ok = false;
+                    break;
+                }
+            }
+        }
+        sort(Ans,Ans+4);
+        printf("Case #%d: ",++ncase);
+        int i;
+        for(i=0;i<4;i++)
+            if(Ans[i].ok)
+            {
+                puts(Ans[i].s.c_str());
+                break;
+            }
+        if(i == 4)
+            puts("FAIL TO DECRYPT");
+    }
+    return 0;
+}
diff --git a/HDOJ/4120_autoAC.cpp b/HDOJ/4120_autoAC.cpp
new file mode 100644
index 0000000..b0a6103
--- /dev/null
+++ b/HDOJ/4120_autoAC.cpp
@@ -0,0 +1,126 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<algorithm>
+#define LL __int64
+const int N = 10005;
+using namespace std;
+int a[N], n, k, s, t;
+int Ans()
+{
+    int i;
+    for( i = 1; i <= k; i ++ )
+        if( a[i] < 0 )
+            return 0;
+    for( i = 1; i < k; i ++ )
+    {
+        a[i] -= a[i+1];
+        if( a[i] )
+        {
+            n --;
+            t -= a[i] * i;
+        }
+    }
+    s = a[k];
+    a[k] = 0;
+    for( i = 1; i < k; i ++ )
+        if( a[i] < 0 )
+            return 0;
+    if( n < 0 || s < n)
+        return 0;
+    if( n == 0 )
+    {
+        if( t == 0 && s == 0 )
+            return 1;
+        else
+            return 0;
+    }
+    if( n == 1 )
+    {
+        if( t%s == 0 && t/s >= k )
+        {
+            a[t/s] = s;
+            return 1;
+        }
+        else
+            return 0;
+    }
+    int ans(0), j, tt, mm = ( n*n-n ) / 2;
+    for( i = k; i*s <= t-mm; i ++ )
+    {
+        tt = t-mm - i*s;
+        if( tt == 0 )
+        {
+            for( j = 1; j < n; j ++ )
+                a[k+j] = 1;
+            a[k] = s-n+1;
+            ans ++;
+        }
+        else if( tt > 1 && n > 2 )
+            return 2;
+        else if( tt > 1 && n == 2 )
+        {
+            tt += mm;
+            for( j = 1; j < s; j ++ )
+            {
+                if( j > tt )
+                    break;
+                else if( ans > 1 )
+                    return 2;
+                if( tt%j == 0 )
+                {
+                    a[ tt/j + i ] = j;
+                    a[i] = s-j;
+                    ans ++;
+                }
+            }
+        }
+        else if( s > n )
+            return 2;
+        else
+        {
+            for( j = 1; j < n-1; j ++ )
+                a[k+j] = 1;
+            a[k+n] = 1;
+            a[k] = s-n+1;
+            ans ++;
+        }
+        if( ans > 1 )
+            return 2;
+    }
+    return ans;
+}
+int main()
+{
+    int ca, cs, i, pre, now;
+    scanf( "%d", &ca );
+    for( cs = 1; cs <= ca; cs ++ )
+    {
+        memset( a, 0, sizeof(a) );
+        scanf( "%d%d", &n, &k );
+        scanf( "%d", &t );
+        pre = t;
+        for( i = 1; i <= k; i ++ )
+        {
+            scanf( "%d", &now );
+            a[i] = pre - now;
+            pre = now;
+        }
+        printf( "Case #%d:\n", cs );
+        now = Ans();
+        if( now < 1 )
+            printf( "No Solution\n" );
+        else if( now > 1 )
+            printf( "Multiple Solutions\n" );
+        else
+        {
+            printf( "Unique Solution\n" );
+            for( i = 1; i < N; i ++ )
+                if( a[i] )
+                    printf( "%d %d\n", i, a[i] );
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4121_autoAC.cpp b/HDOJ/4121_autoAC.cpp
new file mode 100644
index 0000000..ba1dbf5
--- /dev/null
+++ b/HDOJ/4121_autoAC.cpp
@@ -0,0 +1,160 @@
+#include <iostream>
+#include <algorithm>
+using namespace std ;
+int abs(int x)
+{
+    return x>0?x:-x ;
+}
+char map[11][11] ;
+int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}} ;
+int RGX,RGY ;
+int xx,yy ;
+int ok(int x,int y)
+{
+    if(y!=RGY)
+        return 1 ;
+    for(int i=x+1 ;i<RGX ;i++)
+        if(map[i][y]!='0')
+            return 1 ;
+    return 0 ;
+}
+int cha(int x,int y)
+{
+    if(x!=xx && y!=yy)
+        return 0 ;
+    if(x==xx)
+    {
+        int minn=min(y,yy) ;
+        int maxn=max(y,yy) ;
+        for(int i=minn+1 ;i<maxn ;i++)
+            if(map[x][i]!='0')
+                return 0 ;
+    }
+    if(y==yy)
+    {
+        int minn=min(x,xx) ;
+        int maxn=max(x,xx) ;
+        for(int i=minn+1 ;i<maxn ;i++)
+            if(map[i][y]!='0')
+                return 0 ;
+    }
+    return 1 ;
+}
+int hor(int x,int y)
+{
+    if((abs(x-xx)==1 && abs(y-yy)==2) || (abs(x-xx)==2 &&abs(y-yy)==1))
+    {
+        if(xx-x==-2)
+        {
+            if(map[x-1][y]!='0')
+                return 0 ;
+        }
+        if(xx-x==2)
+        {
+            if(map[x+1][y]!='0')
+                return 0 ;
+        }
+        if(yy-y==-2)
+        {
+            if(map[x][y-1]!='0')
+                return 0 ;
+        }
+        if(yy-y==2)
+        {
+            if(map[x][y+1]!='0')
+                return 0 ;
+        }
+        return 1 ;
+    }
+    return 0 ;
+}
+int can(int x,int y)
+{
+    if(x!=xx && y!=yy)
+        return 0 ;
+    int flag=0 ;
+    if(x==xx)
+    {
+        int minn=min(y,yy) ;
+        int maxn=max(y,yy) ;
+        for(int i=minn+1 ;i<maxn ;i++)
+            if(map[x][i]!='0')
+                flag++ ;
+    }
+    if(y==yy)
+    {
+        int minn=min(x,xx) ;
+        int maxn=max(x,xx) ;
+        for(int i=minn+1 ;i<maxn ;i++)
+            if(map[i][y]!='0')
+                flag++ ;
+    }
+    if(flag==1)
+        return 1 ;
+    return 0 ;
+}
+int main()
+{
+    int n ;
+    int x,y ;
+    while(~scanf("%d%d%d%*c",&n,&x,&y))
+    {
+        if(n==0 && x==0 && y==0)
+            break ;
+        for(int i=0 ;i<11 ;i++)
+            for(int j=0 ;j<11 ;j++)
+                map[i][j]='0' ;
+        for(int i=0 ;i<n ;i++)
+        {
+            char chr ;
+            int a,b ;
+            cin >> chr >> a >> b ;
+            map[a][b]=chr ;
+            if(chr=='G')
+            {
+                RGX=a ;RGY=b ;
+            }
+        }
+        int flag ;
+        for(int i=0 ;i<4 ;i++)
+        {
+            flag=0 ;
+            xx=x+dir[i][0] ;
+            yy=y+dir[i][1] ;
+            if(xx<1 || xx>3){flag=1 ;continue ;}
+            if(yy<4 || yy>6){flag=1 ;continue ;}
+            if(!ok(xx,yy)){flag=1 ;continue ;}
+            char t=map[xx][yy] ;
+            map[xx][yy]='0' ;
+            for(int j=1 ;j<=10 ;j++)
+            {
+                for(int k=1 ;k<=9 ;k++)
+                {
+                    if(map[j][k]=='R')
+                    {
+                        if(cha(j,k))
+                            flag=1 ;    
+                    }
+                    if(map[j][k]=='H')
+                    {
+                        if(hor(j,k))
+                            flag=1 ;
+                    }
+                    if(map[j][k]=='C')
+                    {
+                        if(can(j,k))
+                            flag=1 ;
+                    }
+                }
+            }
+            if(!flag)
+                break ;
+            map[xx][yy]=t ;
+         }
+        if(flag)
+            puts("YES") ;
+        else
+            puts("NO") ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/4122_autoAC.cpp b/HDOJ/4122_autoAC.cpp
new file mode 100644
index 0000000..43d01b8
--- /dev/null
+++ b/HDOJ/4122_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<iostream>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<string>
+#include<queue>
+#include<algorithm>
+#include<map>
+#include<iomanip>
+#define INF 99999999
+using namespace std;
+const int MAX=2500+10;
+char mon[5];
+int M[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
+struct Node{
+    int num,t;
+}order[MAX],q[MAX*4];
+int MON(char *m){
+    if(strcmp(m,"Jan") == 0)return 1;
+    if(strcmp(m,"Feb") == 0)return 2;
+    if(strcmp(m,"Mar") == 0)return 3;
+    if(strcmp(m,"Apr") == 0)return 4;
+    if(strcmp(m,"May") == 0)return 5;
+    if(strcmp(m,"Jun") == 0)return 6;
+    if(strcmp(m,"Jul") == 0)return 7;
+    if(strcmp(m,"Aug") == 0)return 8;
+    if(strcmp(m,"Sep") == 0)return 9;
+    if(strcmp(m,"Oct") == 0)return 10;
+    if(strcmp(m,"Nov") == 0)return 11;
+    return 12;
+}
+bool LeapYear(int &year){
+    return year%4 == 0 && year%100 || year%400 == 0;
+}
+int Time(int &year,int Mon,int &d,int &h){
+    int t=0;
+    for(int i=2000;i<year;++i){
+        if(LeapYear(i))t+=366;
+        else t+=365;
+    }
+    bool flag=LeapYear(year);
+    for(int i=1;i<Mon;++i){
+        if(flag && i == 2)t+=29;
+        else t+=M[i];
+    }
+    t+=d-1;
+    return t*24+h;
+}
+int main(){
+    int n,m,t,s,r,h,d,year,a;
+    while(~scanf("%d%d",&n,&m),n+m){
+        for(int i=0;i<n;++i){
+            scanf("%s%d%d%d%d",mon,&d,&year,&h,&r);
+            order[i].num=r,order[i].t=Time(year,MON(mon),d,h); 
+        }
+        int top=0,tail=0,p=0;
+        __int64 sum=0;
+        scanf("%d%d",&t,&s);
+        for(int i=0;i<m;++i){
+            scanf("%d",&a);
+            while(top<tail && q[tail-1].num+(i-q[tail-1].t)*s>=a)--tail;
+            q[tail].num=a,q[tail++].t=i;
+            while(p<n && i == order[p].t){
+                while(q[top].t+t<i)++top;
+                sum+=(q[top].num+(i-q[top].t)*s)*order[p++].num;
+            }
+        }
+        printf("%I64d\n",sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/4123_autoAC.cpp b/HDOJ/4123_autoAC.cpp
new file mode 100644
index 0000000..fb614f3
--- /dev/null
+++ b/HDOJ/4123_autoAC.cpp
@@ -0,0 +1,133 @@
+#include<cstdio>
+#include<iostream>
+#include<vector>
+using namespace std;
+#include<algorithm>
+#include<string>
+#define N 50010
+#define M 510
+#define inf 200000000 
+int w[N],edge,id[N],an[M];
+__int64 dp[N][2],dis[N];
+struct qq{
+    int id;
+    __int64 l;
+}q[M];
+bool cmp(const qq &a,const qq &b){
+    return a.l<b.l;
+}
+struct node{
+    int v,next;
+    __int64 l;
+}e[N*2];
+void add(int u,int v,__int64 l){
+    e[edge].v=v;
+    e[edge].l=l;
+    e[edge].next=w[u];
+    w[u]=edge++;
+}
+void dfs1(int u,int no){
+    for(int i=w[u];i!=-1;i=e[i].next){
+        int v=e[i].v;
+        if(v!=no){
+            dfs1(v,u);
+            if(dp[v][0]+e[i].l>dp[u][0]){
+                dp[u][1]=dp[u][0];
+                id[u]=v,dp[u][0]=dp[v][0]+e[i].l;
+            }
+            else if(dp[v][0]+e[i].l>dp[u][1]) dp[u][1]=dp[v][0]+e[i].l;
+        }
+    }
+}
+void dfs2(int u,int no,__int64 l){
+    dis[u]=max(l,dp[u][0]);
+    for(int i=w[u];i!=-1;i=e[i].next){
+        int v=e[i].v;
+        if(v!=no){
+            if(v==id[u]) dfs2(v,u,max(l,dp[u][1])+e[i].l);
+            else dfs2(v,u,dis[u]+e[i].l);
+        }
+    }
+}
+int dp_max[N][20],dp_min[N][20];
+__int64 p[20];
+int max_id(int x,int y){
+    return dis[x]>dis[y]?x:y;
+}
+int min_id(int x,int y){
+    return dis[x]>dis[y]?y:x;
+}
+int log(int x){
+    int i=0;
+    while(p[i]<=x) i++; 
+    return i-1;
+}
+int get_max_id(int x,int y){
+    int t=log(y-x+1);
+    return max_id(dp_max[x][t],dp_max[y-p[t]+1][t]);
+}
+int get_min_id(int x,int y){
+    int t=log(y-x+1);
+    return min_id(dp_min[x][t],dp_min[y-p[t]+1][t]);
+}
+__int64 get_min(int x,int y){
+    return dis[get_min_id(x,y)];
+}
+__int64 get_max(int x,int y){
+    return dis[get_max_id(x,y)];
+}
+void RMQ(int n){
+    int i,j,l=n,t=0;
+    p[0]=1;
+    for(i=1;i<18;i++) 
+        p[i]=p[i-1]<<1;
+    t=log(n);
+    for(i=1;i<=n;i++) 
+        dp_max[i][0]=dp_min[i][0]=i;
+    for(i=1;i<=t;i++){
+        l=n-p[i]+1;
+        for(j=1;j<=l;j++){
+            dp_max[j][i]=max_id(dp_max[j][i-1],dp_max[j+p[i-1]][i-1]);
+            dp_min[j][i]=min_id(dp_min[j][i-1],dp_min[j+p[i-1]][i-1]);
+        }
+    }
+}
+int main(){
+    int n,m,a,b;
+    __int64 c;
+    while(scanf("%d%d",&n,&m)){
+        if(!n&&!m) break;
+        edge=0;
+        memset(w,-1,sizeof(int)*(n+1));
+        for(int i=1;i<n;++i){
+            scanf("%d%d%I64d",&a,&b,&c);
+            add(a,b,c);
+            add(b,a,c);
+        }
+        memset(dis,0,sizeof(__int64)*(n+1));
+        memset(dp,0,sizeof(dp));
+        dfs1(1,1);
+        dfs2(1,1,0);
+        RMQ(n);
+        for(int i=0;i<m;++i){
+            scanf("%I64d",&q[i].l);
+            q[i].id=i;
+        }
+        sort(q,q+m,cmp);
+        for(int i=0;i<m;++i){
+            int ans,start=1;
+            if(!i) ans=1;
+            else ans=an[q[i-1].id];
+            while(1){
+                int j=start+ans-1;
+                for(;j<=n&&get_max(start,j)-get_min(start,j)<=q[i].l;++j);
+                if(ans<j-start) ans=j-start;
+                if(j==n+1) break;
+                ++start;
+            }
+            an[q[i].id]=ans;
+        }
+        for(int i=0;i<m;++i) printf("%d\n",an[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4125_autoAC.cpp b/HDOJ/4125_autoAC.cpp
new file mode 100644
index 0000000..b1729fa
--- /dev/null
+++ b/HDOJ/4125_autoAC.cpp
@@ -0,0 +1,175 @@
+#include<stdio.h>
+#include<string.h>
+char s[2000000],ss[10000];
+int sta[700000],top,root,ch[700000][2],cnt;
+int zhu[700000],C[700000];
+inline void f()
+{
+    zhu[root]=0;cnt=0;
+    sta[0]=root,top=1;
+    if(!ch[root][0]&&!ch[root][1])
+    {
+        s[0]=root%2+'0';
+        return;
+    }
+    int t=root;
+    while(t-root||((zhu[t]==1&&ch[t][1])||zhu[t]==0))
+    {
+        s[cnt++]=t%2+'0';
+        if(top<0)
+            return;
+        if(zhu[t]==0)
+        {
+            if(ch[t][0])
+            {
+                zhu[t]=1;
+                t=ch[t][0];
+                zhu[t]=0;
+                sta[top++]=t;
+            }
+            else if(ch[t][1])
+            {
+                zhu[t]=2;
+                t=ch[t][1];
+                zhu[t]=0;
+                sta[top++]=t;
+            }
+            else if(t==root)
+                return ;
+            else
+                zhu[t]=2,t=sta[--top-1];
+        }
+        else if(zhu[t]==1)
+        {
+            if(ch[t][1])
+            {
+                zhu[t]=2;
+                t=ch[t][1];
+                zhu[t]=0;
+                sta[top++]=t;
+            }
+            else if(t==root)
+                return ;
+            else
+                t=sta[--top-1];
+        }
+        else if(t==root)
+            return ;
+        else
+            t=sta[--top-1];
+    }
+    s[cnt++]=root%2+'0';
+}
+int P[10000];
+inline void scan(int &u)
+{
+    char c;
+    while(c=getchar(),c<'0'||c>'9');
+    u=c-'0';
+    while(c=getchar(),c<='9'&&c>='0')
+        u=u*10+c-'0';
+}
+int ff(int l)
+{
+    int i,j,ans=0;
+    P[0]=-1;
+    for(i=1,j=-1;i<l;i++)
+    {
+        while(j+1&&ss[j+1]-ss[i])
+            j=P[j];
+        if(ss[j+1]==ss[i])
+            j++;
+        P[i]=j;
+    }
+    for(i=0,j=-1;i<cnt;i++)
+    {
+        while(j+1&&ss[j+1]-s[i])
+            j=P[j];
+        if(ss[j+1]==s[i])
+            j++;
+        if(j==l-1)
+            ans++;
+    }
+    return ans;
+}
+int N,Min,Max;
+int cal(int n)
+{
+    int ans=0;
+    while(n>=1)
+        ans+=C[n],n-=n&(-n);
+    return ans;
+}
+void update(int n)
+{
+    while(n<=N)
+        C[n]++,n+=n&(-n);
+}
+void insert(int n)
+{
+    update(n);
+    int t=cal(n);
+    if(!root)
+    {
+        root=n;
+        Min=Max=n;
+        return;
+    }
+    if(n>Max)
+    {
+        ch[Max][1]=n;
+        Max=n;
+        return;
+    }
+    if(n<Min)
+    {
+        ch[Min][0]=n;
+        Min=n;
+        return;
+    }
+    int l=1,r=n-1,mid;
+    Min=Min<n?Min:n;
+    Max=Max>n?Max:n;
+    while(l<r)
+    {
+        mid=(l+r)>>1;
+        if(cal(mid)==t-1)
+            r=mid;
+        else
+            l=mid+1;
+    }
+    l=r;
+    if(!ch[l][1])
+    {
+        ch[l][1]=n;
+        return;
+    }
+    l=n+1,r=N;
+    while(l<r)
+    {
+        mid=(l+r)>>1;
+        if(cal(mid)-t)
+            r=mid;
+        else
+            l=mid+1;
+    }
+    ch[r][0]=n;
+}
+int main()
+{
+    int t,n,i,j;
+    scanf("%d",&t);
+    for(int ii=1;ii<=t;ii++)
+    {
+        memset(ch,0,sizeof(ch));
+        memset(C,0,sizeof(C));
+        Min=1000000,Max=0;
+        root=0;
+        scanf("%d",&n);N=n;
+        for(i=1;i<=n;i++)
+            scanf("%d",&j),insert(j);
+        f();
+        scanf("%s",ss);
+        printf("Case #%d: %d\n",ii,ff(strlen(ss)));
+    }
+}
diff --git a/HDOJ/4126_autoAC.cpp b/HDOJ/4126_autoAC.cpp
new file mode 100644
index 0000000..c262499
--- /dev/null
+++ b/HDOJ/4126_autoAC.cpp
@@ -0,0 +1,117 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<vector>
+using namespace std;
+const int maxn = 3003;
+const int maxm = maxn * maxn;
+const int inf = 1000000000;
+int n, m;
+__int64 mst;
+int map[maxn][maxn];
+int dp[maxn][maxn];
+int dis[maxn], pre[maxn];
+bool vis[maxn];
+vector<int> edge[maxn];
+int minz(int a, int b)
+{
+    return a < b ? a : b;
+}
+void init()
+{
+    int i, j;
+    for(i = 0; i < n; i++)
+    {
+        for(j = 0; j < n; j++)
+            map[i][j] = dp[i][j] = inf;
+        edge[i].clear();
+        vis[i] = 0;
+        pre[i] = -1;
+        dis[i] = inf;
+    }
+}
+void input()
+{
+    int x, y, z;
+    while(m--)
+    {
+        scanf("%d%d%d", &x, &y, &z);
+        map[x][y] = map[y][x] = z;
+    }
+}
+void prim()
+{
+    int i, j, k;
+    for(i = 1; i < n; i++)
+    {
+        dis[i] = map[0][i];
+        pre[i] = 0;
+    }
+    dis[0] = inf;
+    vis[0] = 1;
+    pre[0] = -1;
+    mst = 0;
+    for(i = 0; i < n-1; i++)
+    {
+        k = 0;
+        for(j = 1; j < n; j++)
+            if(!vis[j] && dis[k] > dis[j])
+                k = j;
+        vis[k] = 1;
+        mst += dis[k];
+        if(pre[k] != -1)
+            edge[k].push_back(pre[k]),
+            edge[pre[k]].push_back(k);
+        for(j = 1; j < n; j++)
+            if(!vis[j] && dis[j] > map[k][j] )
+                dis[j] = map[k][j], pre[j] = k;
+    }
+}
+int dfs(int pos, int u, int fa) 
+{
+    int i, ans = inf;
+    for(i = 0; i < edge[u].size(); i++)
+    {
+        int v = edge[u][i];
+        if(v == fa) continue;
+        int tmp = dfs(pos, v, u);
+        ans = minz(ans, tmp);
+        dp[u][v] = dp[v][u] = minz(dp[u][v], tmp); 
+    }
+    if(pos != fa) 
+        ans = minz(ans, map[pos][u]);
+    return ans;
+}
+void solve()
+{
+    int i;
+    for(i = 0; i < n; i++)
+        dfs(i, i, -1);
+}
+void query()
+{
+    int x, y, z;
+    double sum = 0;
+    scanf("%d", &m);
+    for(int ii = 1; ii <= m; ii++)
+    {
+        scanf("%d%d%d", &x, &y, &z);
+        if(pre[x] != y && pre[y] != x)
+            sum += mst * 1.0;
+        else
+            sum += mst * 1.0 - map[x][y] + minz(dp[x][y], z);
+    }
+    printf("%.4f\n", sum/m);
+}
+int main()
+{
+    while( ~scanf("%d%d", &n, &m) && n + m)
+    {
+        init();
+        input();
+        prim();
+        solve();
+        query();
+    }
+    return 0;
+}
diff --git a/HDOJ/4127_autoAC.cpp b/HDOJ/4127_autoAC.cpp
new file mode 100644
index 0000000..57f959e
--- /dev/null
+++ b/HDOJ/4127_autoAC.cpp
@@ -0,0 +1,118 @@
+#include<iostream>
+#include<cstdio>
+#include<map>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<algorithm>
+#include<set>
+#include<string>
+#include<queue>
+#define inf 1<<30
+#define M 60005
+#define N 10005
+#define maxn 300005
+#define eps 1e-10
+#define zero(a) fabs(a)<eps
+#define Min(a,b) ((a)<(b)?(a):(b))
+#define Max(a,b) ((a)>(b)?(a):(b))
+#define pb(a) push_back(a)
+#define mem(a,b) memset(a,b,sizeof(a))
+#define LL long long
+#define lson step<<1
+#define rson step<<1|1
+#define MOD 1000000009
+using namespace std;
+int maze[10][10];
+int n;
+int way[4][2]={0,1,0,-1,1,0,-1,0};
+int vis[10][10];
+bool check(int x,int y)
+{
+    if(x<0||y<0||x>=n||y>=n) return false;
+    return true;
+}
+void floodfill(int x,int y,int c)
+{
+    vis[x][y]=1;
+    for(int i=0;i<4;i++)
+    {
+        int tx=x+way[i][0];
+        int ty=y+way[i][1];
+        if(!check(tx,ty)) continue;
+        if(vis[tx][ty]==1) continue;
+        if(maze[tx][ty]==c) floodfill(tx,ty,c);
+        else vis[tx][ty]=2;
+    }
+}
+int get_cnt(int col)
+{
+    int cnt=0;
+    for(int i=0;i<n;i++)
+    {
+        for(int j=0;j<n;j++)
+        {
+            if(maze[i][j]==col&&vis[i][j]==2)
+            {
+                cnt++;
+                floodfill(i,j,maze[i][j]);
+            }
+        }
+    }
+    return cnt;
+}
+int get_h()
+{
+    bool flag[6];mem(flag,false);
+    int cnt=0;
+    for(int i=0;i<n;i++)
+    {
+        for(int j=0;j<n;j++)
+        {
+            if(vis[i][j]!=1&&!flag[maze[i][j]])
+            {
+                cnt++;
+                flag[maze[i][j]]=true;
+            }
+        }
+    }
+    return cnt;
+}
+int depth;
+bool IDAstar(int dep)
+{
+    if(depth==dep) return get_h()==0;
+    if(dep+get_h()>depth) return false;
+    for(int i=0;i<6;i++)
+    {
+        int tmp[10][10];
+        memcpy(tmp,vis,sizeof(vis));
+        if(get_cnt(i)==0) continue;
+        if(IDAstar(dep+1)) return true;
+        memcpy(vis,tmp,sizeof(vis));
+    }
+    return false;
+}
+int main()
+{
+    while(scanf("%d",&n)!=EOF&&n)
+    {
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<n;j++)
+            {
+                scanf("%d",&maze[i][j]);
+            }
+        }
+        mem(vis,0);
+        floodfill(0,0,maze[0][0]);
+        depth=get_h();
+        while(true)
+        {
+            if(IDAstar(0)) break;
+            depth++;
+        }
+        printf("%d\n",depth);
+    }
+    return 0;
+}
diff --git a/HDOJ/4128_autoAC.cpp b/HDOJ/4128_autoAC.cpp
new file mode 100644
index 0000000..ccac513
--- /dev/null
+++ b/HDOJ/4128_autoAC.cpp
@@ -0,0 +1,99 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+struct Node
+{
+    long long s,t;
+}node[11000];
+int cmp(const void *a,const void *b)
+{
+    return ((Node *)b)->s-((Node *)a)->s;
+}
+long long S[11000],T[11000],N;
+int ff(int s,int t)
+{
+    if(N==1)
+        return 1;
+    if(N==2)
+    {
+        if((T[1]-t)*(S[2]-s)<(S[1]-s)*(T[2]-t))
+            return 1;
+        return 2;
+    }
+    int l=2,r=N-1,mid;
+    while(l<r)
+    {
+        mid=(l+r)>>1;
+        if((T[mid]-t)*(S[mid-1]-s)<=(T[mid-1]-t)*(S[mid]-s)&&(T[mid]-t)*(S[mid+1]-s)<=(T[mid+1]-t)*(S[mid]-s))
+            l=r=mid;
+        else if((T[mid]-t)*(S[mid-1]-s)<(T[mid-1]-t)*(S[mid]-s)&&(T[mid]-t)*(S[mid+1]-s)>=(T[mid+1]-t)*(S[mid]-s))
+            l=mid+1;
+        else
+            r=mid-1;
+    }
+    if((T[1]-t)*(S[r]-s)<(T[r]-t)*(S[1]-s))
+        r=1;
+    if((T[N]-t)*(S[r]-s)<(T[r]-t)*(S[N]-s))
+        r=N;
+    return r;
+}
+int q[11000],f,r,qq[11000];
+int main()
+{
+    long long n,s,w,d,L,j;
+    int i,t;
+    double ans;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%I64d%I64d%I64d%I64d",&n,&d,&L,&w);
+        for(i=1,s=0;i<=n;i++)
+            scanf("%I64d%I64d",&node[i].s,&node[i].t),s+=d*node[i].t,w-=node[i].s*d;
+        L-=d*n;
+        if(L<0||w<0)
+        {
+            printf("No solution\n");
+            continue;
+        }
+        qsort(node+1,n,sizeof(Node),cmp);
+        for(i=1,f=1,r=0;i<=n;i++)
+        {
+            while(f<=r&&node[i].t<node[q[r]].t)
+                r--;
+            q[++r]=i;
+        }
+        n=r;
+        for(i=1;i<=n&&L*node[q[i]].s>w;i++);
+        if(i>n)
+        {
+            printf("No solution\n");
+            continue;
+        }
+        else if(L*(node[q[1]].s)<=w)
+        {
+            printf("%.2f\n",s+L*node[q[1]].t+0.0);
+            continue;
+        }
+        r=i;
+        S[1]=node[q[1]].s,T[1]=node[q[1]].t;
+        for(i=2,N=1,qq[1]=q[1];i<r;i++)
+        {
+            while(N>1&&((node[qq[N-1]].t-node[qq[N]].t)*(node[qq[N]].s-node[q[i]].s)<=(node[qq[N]].t-node[q[i]].t)*(node[qq[N-1]].s-node[qq[N]].s)))
+                N--;
+            qq[++N]=q[i];
+        }
+        for(i=1;i<=N;i++)
+            S[i]=node[qq[i]].s,T[i]=node[qq[i]].t;
+        for(ans=4000000000,i=r;i<=n;i++)
+        {
+            j=ff(node[q[i]].s,node[q[i]].t);
+            j=qq[j];
+            double tt=L*node[q[i]].t+(w-L*node[q[i]].s)*((node[q[i]].t-node[j].t+0.0)/(node[q[i]].s-node[j].s+0.0));
+            if(tt<ans)
+                ans=tt;
+        }
+        printf("%.2f\n",ans+s);
+    }
+}
diff --git a/HDOJ/4132_autoAC.cpp b/HDOJ/4132_autoAC.cpp
new file mode 100644
index 0000000..33c91fb
--- /dev/null
+++ b/HDOJ/4132_autoAC.cpp
@@ -0,0 +1,130 @@
+#include <iostream>
+#include <string.h>
+#include <cmath>
+#include <vector>
+#include <set>
+#include <map>
+#include <algorithm>
+using namespace std;
+const int maxn = 50000;
+struct node
+{
+    int s;
+    int e;
+    int v;
+}seg[maxn+5];
+struct hashnode
+{
+    int rv;
+    int id;
+}index[maxn*2+5];
+bool cmp(const hashnode &a, const hashnode &b)
+{
+    return a.rv<b.rv;
+}
+int f[maxn*2+5];
+inline int lowbit(int x)
+{
+    return x & (-x);
+}
+inline void _update(int x, int d)
+{
+    int i;
+    for (i=x; i>0; i-=lowbit(i))
+    {
+        f[i] += d;
+    }
+}
+inline void update(int l, int r, int d)
+{
+    _update(l-1, -d);
+    _update(r, d);
+}
+inline int getpt(int x, int n)
+{
+    int i, s = 0;
+    for (i=x; i<=n; i+=lowbit(i))
+    {
+        s += f[i];
+    }
+    return s;
+}
+int bs(int v, int s, int t)
+{
+    int l=s-1, r=t+1, m, ans;
+    while(l<=r)
+    {
+        m = (l+r)>>1;
+        if (v<=index[m].rv)
+        {
+            ans = m;
+            r = m-1;
+        }
+        else l = m+1;
+    }
+    return index[ans].id;
+}
+int main()
+{
+    int t;
+    int len;
+    double amt;
+    int n;
+    int i, j;
+    int a, b;
+    int end;
+    double ans;
+    scanf("%d", &t);
+    while(t--)
+    {
+        scanf("%d %lf", &len, &amt);
+        scanf("%d", &n);
+        index[1].rv = 0;
+        index[2].rv = len;
+        for (i=0,j=3; i<n; i++,j+=2)
+        {
+            scanf("%d %d %d", &seg[i].s, &seg[i].e, &seg[i].v);
+            index[j].rv = seg[i].s;
+            index[j+1].rv = seg[i].e;
+        }
+        end = j-1;
+        sort(index+1, index+end+1, cmp);
+        index[1].id = 1;
+        for (i=2,j=2; i<=end; i++)
+        {
+            if (index[i].rv!=index[j-1].rv)
+            {
+                index[j].rv = index[i].rv;
+                index[j].id = j;
+                j++;
+            }
+        }
+        end = j-1;
+        memset(f, 0, sizeof(f));
+        update(1, end-1, 1);
+        for (i=0; i<n; i++)
+        {
+            a = bs(seg[i].s, 1, end);
+            b = bs(seg[i].e, 1, end);
+            update(a, b-1, seg[i].v);
+        }
+        ans = 0;
+        for (i=1; i<end && fabs(amt)>1e-6; i++)
+        {
+            a = index[i+1].rv-index[i].rv;
+            b = getpt(i, end);
+            if (a*1.0>amt/b)
+            {
+                ans += amt/b;
+                amt = 0;
+            }
+            else
+            {
+                ans += a;
+                amt -= a*b;
+            }
+        }
+        printf("%.2lf\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4133_autoAC.cpp b/HDOJ/4133_autoAC.cpp
new file mode 100644
index 0000000..a8d3724
--- /dev/null
+++ b/HDOJ/4133_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<stdio.h>
+__int64 prime[16]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};
+__int64 n,cnter,ans;
+void dfs(__int64 cur,__int64 cnt,__int64 power,__int64 sub)
+{
+    __int64 i;
+    if(cur>n)
+        return;
+    if(cnt==cnter&&cur<ans)
+        ans=cur;
+    if(cnt>cnter)
+    {
+        ans=cur;
+        cnter=cnt;
+    }
+    __int64 p=prime[sub];
+    for(i=1;i<=power;i++)
+    {
+        if(cur*p>n)
+            break;
+        dfs(cur*p,cnt*(i+1),i,sub+1);
+        p=p*prime[sub];
+    }
+}
+int main()
+{
+    int t,T;
+    scanf("%d",&T);
+    for(t=1;t<=T;t++)
+    {
+        scanf("%I64d",&n);
+        cnter=0,ans=0;
+        dfs(1,1,50,0);
+        printf("Case #%d: %I64d\n",t,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4134_autoAC.cpp b/HDOJ/4134_autoAC.cpp
new file mode 100644
index 0000000..57458c7
--- /dev/null
+++ b/HDOJ/4134_autoAC.cpp
@@ -0,0 +1,31 @@
+#include<stdio.h> 
+int a[110];
+int main(){
+    int t;
+    scanf("%d",&t);
+    int ca = 1;
+    while(t--){
+        int n;
+        scanf("%d",&n);
+        int i,j;
+        for(i=1;i<=n;i++)scanf("%d",&a[i]);
+        int win = 0;
+        i = 1,j = n;
+        while(1){
+            if(j-i+1==2){
+                if(a[1]>a[2])win = 1;
+                else win = 2;
+                break;
+            }
+            int ii = i,jj = j;
+            while(ii<=jj){
+                a[ii++] += a[jj--];
+            }
+            i = 1,j = (j+1)/2;
+        }
+        printf("Case #%d: ",ca++);
+        if(win==1)puts("Alice");
+        else if(win==2)puts("Bob");
+    }
+    return 0;
+}
diff --git a/HDOJ/4135_autoAC.cpp b/HDOJ/4135_autoAC.cpp
new file mode 100644
index 0000000..ebca124
--- /dev/null
+++ b/HDOJ/4135_autoAC.cpp
@@ -0,0 +1,43 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<vector>
+using namespace std;
+long long a,b,n;
+vector<long long> vt;
+long long solve(long long x,long long n){
+    vt.clear();
+    long long i,j;
+    for(i=2;i*i<=n;i++)     
+        if(n%i==0){
+            vt.push_back(i);
+            while(n%i==0)
+                n/=i;
+        }
+    if(n>1)
+        vt.push_back(n);
+    long long sum=0,val,cnt;
+    for(i=1;i<(1<<vt.size());i++){  
+        val=1;
+        cnt=0;
+        for(j=0;j<vt.size();j++)
+            if(i&(1<<j)){       
+                val*=vt[j];
+                cnt++;
+            }
+        if(cnt&1)     
+            sum+=x/val;
+        else
+            sum-=x/val;
+    }
+    return x-sum;
+}
+int main(){
+    int t,cases=0;
+    scanf("%d",&t);
+    while(t--){
+        cin>>a>>b>>n;
+        cout<<"Case #"<<++cases<<": "<<solve(b,n)-solve(a-1,n)<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4136_autoAC.cpp b/HDOJ/4136_autoAC.cpp
new file mode 100644
index 0000000..bb265e4
--- /dev/null
+++ b/HDOJ/4136_autoAC.cpp
@@ -0,0 +1,59 @@
+#include<algorithm>
+#include<stdlib.h>
+#include<iostream>
+#include<string.h>
+#include<stdio.h>
+using namespace std;
+#define eps 1e-10
+#define N 100015
+#define db double
+db ans,p1,p2,win1,win2,win_num[2][2][2],dp[2][2][2];
+int sign(db x){
+    return (x > eps) - (x < -eps);
+}
+void dfs(int pl1,db p,int pl2,int v,int s){
+    if((pl1 == 6&&pl2 <= 4)||pl1 == 7){
+        win_num[s][0][v] += p*(pl1+pl2)*5.;
+        dp[s][0][v] += p;
+        return ;
+    }
+    if((pl2 == 6&&pl1 <= 4)||pl2 == 7){
+        win_num[s][1][v] += p*(pl1+pl2)*5.;
+        dp[s][1][v] += p;
+        return ;
+    }
+    if(v) dfs(pl1,p*p2,pl2+1,v^1,s),dfs(pl1+1,p*(1.-p2),pl2,v^1,s);
+    else dfs(pl1+1,p*p1,pl2,v^1,s),dfs(pl1,p*(1.-p1),pl2+1,v^1,s);
+}
+void dfs2(int l1,int l2,db pl1,db p,db pl2,int v){
+    if(l1 == 3||l2 == 3){
+        ans += p*(pl1+pl2);
+        return ;
+    }
+    dfs2(l1+1,l2,pl1+win_num[v][0][0],dp[v][0][0]*p,pl2,0);
+    dfs2(l1+1,l2,pl1+win_num[v][0][1],dp[v][0][1]*p,pl2,1);
+    dfs2(l1,l2+1,pl1,dp[v][1][0]*p,pl2+win_num[v][1][0],0);
+    dfs2(l1,l2+1,pl1,dp[v][1][1]*p,pl2+win_num[v][1][1],1);
+}
+char s[256];
+int main()
+{
+    int T,cas = 1;
+    int i,j,k;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%s%s%lf",&s,&s,&p1);
+        scanf("%s%s%lf",&s,&s,&p2);
+        p1 /= 100.;
+        p2 /= 100.;
+        ans = 0.;
+        for(i = 0; i < 2; i ++) for(j = 0; j < 2; j ++) for(k = 0; k < 2; k ++) win_num[i][j][k] = dp[i][j][k] = 0.;
+        dfs(0,1.,0,0,0);
+        dfs(0,1.,0,1,1);
+        for(i = 0; i < 2; i ++) for(j = 0; j < 2; j ++) for(k = 0; k < 2; k ++) if(sign(dp[i][j][k])) win_num[i][j][k] /= dp[i][j][k];
+        dfs2(0,0,0.,1.,0.,0);
+        printf("Case #%d: %.6lf\n",cas++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4137_autoAC.cpp b/HDOJ/4137_autoAC.cpp
new file mode 100644
index 0000000..cacf64a
--- /dev/null
+++ b/HDOJ/4137_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<stdio.h> 
+#include<math.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+struct node{
+    int id;
+    int v;
+}p[33];
+bool cmp(node a,node b){
+    return a.v<b.v;
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    int ca=1;
+    while(t--){
+        int n;
+        scanf("%d",&n);
+        int i;
+        int ans = 0;
+        for(i=1;i<=n;i++){
+            scanf("%d",&p[i].v);
+            p[i].id = i;
+        }
+        sort(p+1,p+1+n,cmp);
+        for(i=1;i<=n;i++){
+            ans += abs(p[i].id-i);
+        }
+        printf("Case #%d: %d\n",ca++,ans/2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4138_autoAC.cpp b/HDOJ/4138_autoAC.cpp
new file mode 100644
index 0000000..c6d57e1
--- /dev/null
+++ b/HDOJ/4138_autoAC.cpp
@@ -0,0 +1,74 @@
+#include<cstdio>
+#include<cstring>
+using namespace std;
+__int64 dp[100][30][30];
+int ans[100];
+int main(){
+    memset(dp,0,sizeof(dp));
+    dp[0][1][0]=1;
+    for(int i=2;i<=75;i++){
+        for(int j=1;j<=27;j++){
+            for(int k=0;k<=20;k++){
+                __int64 val=0;
+                if(j==1){
+                    if(k==0) continue;
+                    for(int jj=2;jj<=27;jj++){
+                        if(i>=j) val+=dp[i-j][jj][k-1];
+                    }
+                }else{
+                    for(int jj=1;jj<=27;jj++){
+                        if(i>=j) val+=dp[i-j][jj][k];
+                    }
+                }
+                dp[i][j][k]=val;
+            }
+        }
+    }
+    int t,cas=0;
+    scanf("%d",&t);
+    while(t--){
+        int V,W;
+        __int64 I;
+        scanf("%d%d%I64d",&V,&W,&I);
+        printf("Case #%d: ",++cas);
+        W-=1;
+        I-=1;
+        ans[0]=-1;
+        for(int i=2;i<=27;i++){
+            if(I>=dp[V][i][W]){
+                I-=dp[V][i][W];
+            }else{
+                V-=i;
+                ans[0]=i;
+                break;
+            }
+        }
+        if(ans[0]==-1){
+            puts("Corrupted!");
+            continue;
+        }
+        int cnt=1;
+        bool flag=false;
+        while(true){
+            for(int i=1;i<=27;i++){
+                if(flag&&(i==1)) continue;
+                if((W==0)&&(i==1)) continue;
+                flag=false;
+                if(I>=dp[V][i][W]){
+                    I-=dp[V][i][W];
+                }else{
+                    V-=i;
+                    if(i==1){W-=1;flag=true;}
+                    ans[cnt++]=i;
+                    break;
+                }
+            }
+            if(V==0) break;
+        }
+        for(int i=0;i<cnt;i++){
+            if(ans[i]==1) putchar(' ');
+            else putchar(ans[i]-2+'a');
+        }
+        puts("");
+    }
+}
diff --git a/HDOJ/4139_autoAC.cpp b/HDOJ/4139_autoAC.cpp
new file mode 100644
index 0000000..c5f9d77
--- /dev/null
+++ b/HDOJ/4139_autoAC.cpp
@@ -0,0 +1,60 @@
+#include<stdio.h> 
+#include<math.h>
+#include<string.h>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+#define N 1000005
+#define LL long long
+int max(int a,int b){return a>b?a:b;}
+LL cnt[N];
+void gao(int n,int p){
+    int i;
+    int a=1;
+    for(i=2;i*i<=n;i+=a,a=2){
+        if(n%i==0){
+            while(n%i==0){
+                cnt[i] += p;
+                n/=i;
+            }
+        }
+    }
+    if(n>1)cnt[n] += p;
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    int ca=1;
+    while(t--){
+        int n,m;
+        scanf("%d%d",&n,&m);
+        int i,j;
+        int a,b;
+        memset(cnt,0,sizeof(cnt));
+        int maxm = 0;
+        for(i=0;i<n;i++){
+            scanf("%d",&a);
+            maxm = max(a,maxm);
+            gao(a,1);
+        }
+        for(j=0;j<m;j++){
+            scanf("%d",&b);
+            maxm = max(b,maxm);
+            gao(b,-1);
+        }
+        int x = 1,y = 1;
+        for(i=2;i<=maxm;i++){
+            if(cnt[i] > 0){
+                while(cnt[i]--){
+                    x *= i;
+                }
+            } else if(cnt[i]<0){
+                while(cnt[i]++){
+                    y *= i;
+                }
+            }
+        }
+        printf("Case #%d: %d / %d\n",ca++,x,y);
+    }
+    return 0;
+}
diff --git a/HDOJ/4140_autoAC.cpp b/HDOJ/4140_autoAC.cpp
new file mode 100644
index 0000000..00cd96e
--- /dev/null
+++ b/HDOJ/4140_autoAC.cpp
@@ -0,0 +1,80 @@
+#include <stdio.h>
+#include <string.h>
+#define N 1000000
+char str[N];
+int x;
+int pow(int a,int b)
+{
+    int res =  1;
+    while(b--)
+        res *= a;
+    return res;
+}
+int solve()
+{
+    int res = 0,add = 0,flag = 1,c,e;
+    int i = 0,j = 0;
+    int len = strlen(str);
+    for(--len; str[len]!='+' && str[len] != '-' && len >= 0; --len);
+    if(str[0] == '-')
+    {
+        flag = -1;
+        i = 1;
+    }
+    for(;i < len; ++i)
+    {
+        c = 0;
+        for(j = i; str[j] != 'X'; ++j)
+            c = c*10 + str[j] - '0';
+        if(i == j)
+            c = 1;
+        ++j;
+        if(str[j] == '^')
+        {
+            e = 0;
+            for(++j;str[j] != '+' && str[j] !='-';++j)
+                e = e * 10 + str[j] - '0';
+        }
+        else
+            e = 1;
+        res += c* flag*pow(x,e);
+        if(str[j] == '+')
+            flag = 1;
+        else
+            flag = -1;
+        i = j;
+    }
+    c = 0;
+    for(j = i;str[j] && str[j] != 'X'; ++j)
+        c = c * 10 + str[j] - '0';
+    if(!str[j])
+        res += c * flag;
+    else
+    {
+        if(i == j)
+            c = 1;
+        ++j;
+        if(!str[j])
+            res += c * x * flag;
+        else
+        {
+            ++ j;
+            e = 0;
+            for(;str[j];++j)
+                e = e * 10 + str[j] - '0';
+            res += c * flag * pow(x,e);
+        }
+    }
+    return res;
+}
+int main()
+{
+    int t,sp = 0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%s",&x,str);
+        printf("Case #%d: %d\n",++sp, solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/4141_autoAC.cpp b/HDOJ/4141_autoAC.cpp
new file mode 100644
index 0000000..a49cd8e
--- /dev/null
+++ b/HDOJ/4141_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+using namespace std; 
+#define N 1010
+int vis[N][N],height[N][N];
+int m,n,cnt;
+int mo[][2] = {0,1, 0,-1, 1,0, -1,0};
+bool ok(int x,int y,int c)
+{
+     return x > 0 && x <= m && y > 0 && y <= n && height[x][y] >= c;
+}
+bool boundary(int x,int y)
+{
+     return x == 1 || y == 1 || x == m || y == n;
+}
+void dfs(int x,int y,int c)
+{
+     height[x][y] = 0;
+     if(boundary(x,y))
+         ++cnt;
+     int s,t;
+     for(int i = 0; i < 4; ++i)
+     {
+             s = x + mo[i][0];
+             t = y + mo[i][1];
+             if(ok(s,t,c))
+                 dfs(s,t,height[s][t]);
+     }
+}
+int main()
+{
+    int t,a;
+    int x,y;
+    int sp = 0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int i,j;
+        scanf("%d%d%d%d",&m,&n,&x,&y);
+        for( i = 1 ; i <= m; ++i)
+             for( j = 1 ; j <= n; ++j)
+                  scanf("%d",&height[i][j]);
+        cnt = 0;
+        dfs(x,y,height[x][y]);
+        printf("Case #%d: %d\n",++sp,cnt);
+    }
+    return 0;
+}
diff --git a/HDOJ/4142_autoAC.cpp b/HDOJ/4142_autoAC.cpp
new file mode 100644
index 0000000..75abe55
--- /dev/null
+++ b/HDOJ/4142_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<iostream>
+#include<string>
+#include<string.h>
+using namespace std;
+int main()
+{    
+    int n, p=1;
+    scanf("%d", &n);
+    while(n--)
+    {
+        int a, b, c;
+        scanf("%d%d%d", &a, &b, &c);
+        if(a > b)
+            swap(a, b);
+        if(b > c)
+            swap(b, c);
+        if(a > b)
+            swap(a, b);
+        printf("Case #%d: ", p++);
+        if(a+b <= c)
+            printf("invalid!\n");
+        else if(a==b && b==c)
+            printf("equilateral\n");
+        else if(a==b || b==c)
+            printf("isosceles\n");
+        else
+            printf("scalene\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4143_autoAC.cpp b/HDOJ/4143_autoAC.cpp
new file mode 100644
index 0000000..6a8ace0
--- /dev/null
+++ b/HDOJ/4143_autoAC.cpp
@@ -0,0 +1,27 @@
+#include"stdio.h"
+#include"math.h"
+int main()
+{
+    int i;
+    int t;
+    int n;
+    int x;
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        x=-1;
+        t=(int)sqrt(n);
+        for(i=t;i>0;i--)
+        {
+            if(n%i==0&&(n/i-i)%2==0&&(n/i-i)/2>0)
+            {
+                x=(n/i-i)/2;
+                break;
+            }
+        }
+        printf("%d\n",x);
+    }
+    return 0;
+}
diff --git a/HDOJ/4144_autoAC.cpp b/HDOJ/4144_autoAC.cpp
new file mode 100644
index 0000000..13fb148
--- /dev/null
+++ b/HDOJ/4144_autoAC.cpp
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <string.h>
+int num(char c)
+{
+    if(c>='A' && c<='Z')
+    return 0;
+    else return 1;
+}
+int main()
+{
+    int n,i,k;
+    char a[10005];
+    while(~scanf("%d%s",&n,a))
+    {
+        for(i = 0;i<n;i+=5)
+        {
+            k = 0;
+            if(num(a[i]))
+            k+=16;
+            if(num(a[i+1]))
+            k+=8;
+            if(num(a[i+2]))
+            k+=4;
+            if(num(a[i+3]))
+            k+=2;
+            if(num(a[i+4]))
+            k++;
+            printf("%c",k+'A');
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4145_autoAC.cpp b/HDOJ/4145_autoAC.cpp
new file mode 100644
index 0000000..7219090
--- /dev/null
+++ b/HDOJ/4145_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define N 100010
+struct enemy
+{
+    int x, y, da, db;
+}p[N], c1, c2;
+bool cmp(enemy a, enemy b)
+{
+    return a.da < b.da;
+}
+int dist(enemy a, enemy b)
+{
+    return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
+}
+int main()
+{
+    int ncase;
+    int num;
+    int ans, res, onlyb;
+    scanf("%d", &ncase);
+    while(ncase--)
+    {
+        scanf("%d%d%d%d", &c1.x, &c1.y, &c2.x, &c2.y);
+        scanf("%d", &num);
+        for(int i = 0; i < num; ++i)
+        {
+            scanf("%d%d", &p[i].x, &p[i].y);
+            p[i].da = dist(c1, p[i]);
+            p[i].db = dist(c2, p[i]);
+        }
+        sort(p, p + num, cmp);
+        res = p[num - 1].da; 
+        ans = 0;
+        for(int i = num - 2; i >= 0; --i)
+        {
+            ans = max(ans, p[i + 1].db);
+            res = min(res, ans + p[i].da);
+        }
+        ans = max(ans, p[0].db);
+        res = min(res, ans); 
+        printf("%d\n", res);
+    }
+    return 0;
+}
diff --git a/HDOJ/4146_autoAC.cpp b/HDOJ/4146_autoAC.cpp
new file mode 100644
index 0000000..317c8f3
--- /dev/null
+++ b/HDOJ/4146_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    int s,n,m,x,y,i,j,count,sum=1;
+    char str[1001][1001];
+    int a[1001],b[1001];
+    scanf("%d",&s);
+    while(s--)
+    {
+        memset(a,0,sizeof(a));
+        memset(b,0,sizeof(b));
+        count=0;
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+        {
+            scanf("%s",str[i]);
+        }
+        scanf("%d",&m);
+        for(i=0;i<m;i++)
+        {
+            scanf("%d %d",&x,&y);
+            x--,y--;
+            a[x]=1-a[x];
+            b[y]=1-b[y];
+        }
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                if(a[i]+b[j]==1)
+                {
+                    if(str[i][j]=='b') count++;
+                }
+                else
+                {
+                    if(str[i][j]=='w') count++;
+                }
+            }
+        }
+        printf("Case #%d: %d\n",sum++,count);
+    }
+    return 0;
+}
diff --git a/HDOJ/4147_autoAC.cpp b/HDOJ/4147_autoAC.cpp
new file mode 100644
index 0000000..6307e25
--- /dev/null
+++ b/HDOJ/4147_autoAC.cpp
@@ -0,0 +1,35 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    char str[10001];
+    int s,b,d,f,F,i,j,len,sum,min;
+    while(scanf("%d %d %d %d %d",&s,&b,&d,&f,&F)!=EOF)
+    {
+        min=99999;
+        for(j=1;j<=s;j++)
+        {
+            sum=0;
+            scanf("%s",str);
+            len=strlen(str);
+            for(i=0;i<=len-1;i++)
+            {
+                if(str[i]=='A')
+                {
+                    sum=sum+b+d+f;
+                }
+                if(str[i]=='B')
+                {
+                    sum=sum+2*b+2*d+F;
+                }
+                if(str[i]=='C')
+                {
+                    sum=sum+3*b+3*d+2*F;
+                }
+            }
+            if(min>sum) {min=sum;}
+        }
+        printf("%d\n",min);
+    }
+    return 0;
+}
diff --git a/HDOJ/4148_autoAC.cpp b/HDOJ/4148_autoAC.cpp
new file mode 100644
index 0000000..5f56c04
--- /dev/null
+++ b/HDOJ/4148_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+using namespace std;
+char s[31][10000];
+int main()
+{
+    int n,i,j,len;
+    s[1][0]='1';
+    s[1][2]='\0';
+    for(i=2;i<31;i++)
+    {
+        len=strlen(s[i-1]);
+        int sum=1,k=0;
+        for(j=0;j<len;j++)
+           if(s[i-1][j+1]==s[i-1][j]) sum++;
+           else
+           {
+               s[i][k]=sum+'0';
+               k++;
+               s[i][k]=s[i-1][j];
+               k++;
+               sum=1;
+           }
+           s[i][k]='\0';
+    }
+    while(cin>>n&&n)
+    {
+        len=strlen(s[n]);
+        cout<<len<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4149_autoAC.cpp b/HDOJ/4149_autoAC.cpp
new file mode 100644
index 0000000..30bdc9a
--- /dev/null
+++ b/HDOJ/4149_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <iostream>
+using namespace std;
+int x[10];
+int main()
+{
+    int m, p;
+    int i;
+    int t;
+    scanf("%d", &t);
+    while(t--)
+    {
+        for (i=1; i<=9; i++) scanf("%d", &x[i]);
+        m = 0;
+        p = 0;
+        int k=0;
+        while(1)
+        {
+            for (i=1; i<=8; i++)
+            {
+                if (x[i]!=0) break;
+            }
+            p >>= 1;
+            if (i>8 && p==0 && x[9]==0) break;
+            int ct = 0;
+            for (i=1; i<=8; i++)
+            {
+                if (x[i]&1) ct++;
+            }
+            int y = (ct&1);
+            int z = ((x[9]&1)+(p&1))&1;
+            int tm = y^z;
+            if (tm)
+            {
+                p += (8-ct);
+            }
+            else
+            {
+                p += ct;
+            }
+            m += (tm<<k);
+            k++;
+            for (i=1; i<=9; i++) x[i]>>=1;
+        }
+        printf("%d\n", m);
+    }
+    return 0;
+}
diff --git a/HDOJ/4150_autoAC.cpp b/HDOJ/4150_autoAC.cpp
new file mode 100644
index 0000000..6a4daed
--- /dev/null
+++ b/HDOJ/4150_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    char a[1000001],b[100001];
+    int s,i,j,p,count,len1,len2;
+    scanf("%d",&s);
+    while(s--)
+    {
+        count=0;
+        scanf("%s %s",a,b);
+        len1=strlen(a);
+        len2=strlen(b);
+        for(i=0;i<=len1-1;i++)
+        {
+            p=i;
+            for(j=0;j<=len2-1;j++)
+            {
+                if(a[p]==b[j]) {p++;}
+                else
+                    break;
+            }
+            if(j==len2)
+            {
+                count++;
+                i=i+len2-1;
+            }
+        }
+        printf("%d\n",count);
+    }
+    return 0;
+}
diff --git a/HDOJ/4151_autoAC.cpp b/HDOJ/4151_autoAC.cpp
new file mode 100644
index 0000000..827206f
--- /dev/null
+++ b/HDOJ/4151_autoAC.cpp
@@ -0,0 +1,53 @@
+#include"stdio.h"
+int main()
+{
+    int n;
+    int t1[10];
+    int ans;
+    int i,j;
+    int a,b,t;
+    int num[10],k;
+    int hash[10];
+    int fac[10];
+    fac[0]=1;
+    for(i=1;i<10;i++)    fac[i]=fac[i-1]*i;
+    t1[0]=1;
+    for(i=1;i<10;i++)    t1[i]=9*fac[9]/fac[9-(i-1)];
+    while(scanf("%d",&n)!=-1)
+    {
+        if(n<=0)    {printf("0\n");continue;}
+        if(n<10)    {printf("%d\n",n-1);continue;}
+        k=0;
+        while(n)
+        {
+            num[k++]=n%10;
+            n/=10;
+        }
+        a=0;
+        b=k-1;
+        while(a<b)
+        {
+            t=num[a];
+            num[a]=num[b];
+            num[b]=t;
+            a++;
+            b--;
+        }
+        ans=0;
+        for(i=0;i<10;i++)    hash[i]=1;
+        for(i=1;i<k;i++)    ans+=t1[i];
+        ans+=(num[0]-1)*fac[9]/fac[10-k];
+        hash[num[0]]=0;
+        for(i=1;i<k;i++)
+        {
+            for(j=0;j<num[i];j++)
+            {
+                if(hash[j])    ans+=fac[9-i]/fac[10-k];
+            }
+            if(hash[num[i]]==0)    break;
+            hash[num[i]]=0;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4152_autoAC.cpp b/HDOJ/4152_autoAC.cpp
new file mode 100644
index 0000000..489bc39
--- /dev/null
+++ b/HDOJ/4152_autoAC.cpp
@@ -0,0 +1,53 @@
+# include <cstdio>
+# include <cstring>
+int d[20]= {1},a[22][22],c[22],fn[22],n,m;
+int yes()
+{
+    for (int i(1); i<=n; i++)
+    {
+        if (c[i]<fn[i]) return 0;
+    }
+    return 1;
+}
+int main()
+{
+    for (int i(1); i<=18; i++) d[i]=d[i-1]*2;
+    while (scanf("%d",&n)!=EOF)
+    {
+        for (int i(1); i<=n; i++) scanf("%d",&fn[i]);
+        scanf("%d",&m);
+        for (int i(1); i<=m; i++)
+        {
+            for (int j(1); j<=n; j++)
+            {
+                scanf("%d",&a[i][j]);
+            }
+        }
+        int ans=0,ansi=0;
+        for (int i(d[m+1]-1); i>=0; i--)
+        {
+            memset(c,0,sizeof(c));
+            int num = 0;
+            for (int j(1); j<=m; j++)
+            {
+                if (i&d[j-1])
+                {
+                    num++;
+                    for (int k(1); k<=n; k++) c[k] += a[j][k];
+                }
+            }
+            if (yes() && num >= ans)
+            {
+                ans = num;
+                ansi = i;
+            }
+        }
+        printf("%d",ans);
+        for (int i(0); i<m; i++)
+        {
+            if (ansi & d[i]) printf(" %d",i+1);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4153_autoAC.cpp b/HDOJ/4153_autoAC.cpp
new file mode 100644
index 0000000..fe756fd
--- /dev/null
+++ b/HDOJ/4153_autoAC.cpp
@@ -0,0 +1,38 @@
+#include"stdio.h"
+#include"string.h"
+int main()
+{
+    int n,m;
+    int i;
+    int a[101];
+    int mark[101];
+    int s1,s2;
+    int max;
+    while(scanf("%d%d",&n,&m)!=-1,n||m)
+    {
+        memset(mark,0,sizeof(mark));
+        max=0;
+        for(i=0;i<n;i++)
+        {
+            scanf("%d",&a[i]);
+            mark[a[i]/m]++;
+            if(max<a[i])max=a[i];
+        }
+        s2=max/m;
+        max=0;
+        for(i=0;i<=s2;i++)
+        {
+            if(mark[i]>max)
+                max=mark[i];
+        }
+        s1=max;
+        double ans;
+        ans=0.01;
+        for(i=0;i<=s2;i++)
+        {
+            ans+=(i*1.0/s2)*(mark[s2-i]*1.0/s1);
+        }
+        printf("%.6f\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4154_autoAC.cpp b/HDOJ/4154_autoAC.cpp
new file mode 100644
index 0000000..32ab355
--- /dev/null
+++ b/HDOJ/4154_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<stdio.h>
+#include<stdlib.h>
+int f[1450]={0};
+int main()
+{
+    int cmp(const void *a,const void *b);
+    int t,i,max,p;
+    while(scanf("%d",&t),t!=0)
+    {
+        max=0;
+        p=0;
+        for(i=0;i<t;i++)
+        {
+            scanf("%d",&f[i]);
+        }
+        qsort(f,t,sizeof(int),cmp);
+        f[i]=1422;
+        if((f[i]-f[i-1])>100)
+        {
+            printf("IMPOSSIBLE\n");
+            p=1;
+        }
+        else
+        {
+            for(i=1;i<t;i++)
+            {
+                if((f[i]-f[i-1])>max)
+                {
+                    max=f[i]-f[i-1];
+                    if(max>200)
+                    {
+                        p=1;
+                        break;
+                    }
+                }
+            }
+            if(p==0)
+            {
+                printf("POSSIBLE\n");
+            }
+            else
+            {
+                printf("IMPOSSIBLE\n");
+            }
+        }
+    }
+    return 0;
+}
+int cmp(const void *a,const void *b)
+{
+    return *(int *)a-* (int*)b;
+}
diff --git a/HDOJ/4155_autoAC.cpp b/HDOJ/4155_autoAC.cpp
new file mode 100644
index 0000000..1e4088e
--- /dev/null
+++ b/HDOJ/4155_autoAC.cpp
@@ -0,0 +1,50 @@
+#include<stdio.h>
+#include<string.h>
+#define MAXD 16000
+int sg[MAXD], h[7];
+char b[30];
+int dfs(int st)
+{
+    if(sg[st] != -1)
+        return sg[st];
+    int i, j, k, s[10], sum = 0;
+    memset(s, 0, sizeof(s));
+    for(i = 1; i <= 6; i ++)
+        sum += h[i] * i;
+    for(i = 1; i <= 6; i ++)
+        if(h[i] < 4 && i + sum <= 31)
+        {
+            ++ h[i];
+            for(j = 1, k = 0; j <= 6; j ++)
+                k = k * 5 + h[j];
+            s[dfs(k)] = 1;
+            -- h[i];
+        }
+    for(i = 0; s[i]; i ++);
+    return sg[st] = i;
+}
+void solve()
+{
+    int i, j, k, turn;
+    memset(h, 0, sizeof(h));
+    for(i = 0; b[i]; i ++)
+        ++ h[b[i] - '0'];
+    turn = i % 2;
+    for(i = 1, j = 0; i <= 6; i ++)
+        j = j * 5 + h[i];
+    k = dfs(j);
+    printf("%s ", b);
+    if(turn == 0)
+        printf("%s\n", k == 0 ? "B" : "A");
+    else
+        printf("%s\n", k == 0 ? "A" : "B");
+}
+int main()
+{
+    memset(sg, -1, sizeof(sg));
+    while(scanf("%s", b) == 1)
+    {
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/4156_autoAC.cpp b/HDOJ/4156_autoAC.cpp
new file mode 100644
index 0000000..5400fc8
--- /dev/null
+++ b/HDOJ/4156_autoAC.cpp
@@ -0,0 +1,8 @@
+#include <cstdio>
+int main(){
+    for(int a,b,c,t;scanf("%d%d%d",&a,&b,&c)&&(a||b||c);){
+        if(a<b)t=a,a=b,b=t;
+        if(a<c)t=a,a=c,c=t;
+        printf("%s\n",(a+b>c)&&(a+c>b)&&(b+c>a)&&a*a==b*b+c*c?"right":"wrong");
+    }
+}
diff --git a/HDOJ/4158_autoAC.cpp b/HDOJ/4158_autoAC.cpp
new file mode 100644
index 0000000..36c7b43
--- /dev/null
+++ b/HDOJ/4158_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <cstring>
+#include <queue>
+#include <iostream>
+using namespace std;
+int map[21][21];
+bool vis[21][21];
+int dx[4]= {1,-1,0,0};
+int dy[4]= {0,0,-1,1};
+int cb,cw,n;
+struct point
+{
+    int x,y;
+}p,t;
+void bfs(int x,int y)
+{
+    p.x=x,p.y=y;
+    queue <point> q;
+    q.push(p);
+    int num=0;
+    vis[p.x][p.y]=true;
+    int r2=-1,r3=-1;
+    while(!q.empty())
+    {
+        t=q.front();
+        num++;
+        q.pop();
+        for(int i=0; i<4; i++)
+        {
+            p.x=t.x+dx[i];
+            p.y=t.y+dy[i];
+            if(vis[p.x][p.y]) continue;
+            if(p.x<1||p.x>n||p.y<1||p.y>n) continue;
+            if(map[p.x][p.y]==1) r2=1;
+            else if(map[p.x][p.y]==2) r3=1;
+            else q.push(p),vis[p.x][p.y]=true;
+        }
+    }
+    if(r2==1&&r3==1) return ;
+    if(r3==-1) cb+=num;
+    else if(r2==-1) cw+=num;
+    return ;
+}
+int main()
+{
+    int b,w,x,y;
+    while(scanf("%d",&n)==1&&n)
+    {
+        memset(map,0,sizeof(map));
+        memset(vis,false,sizeof(vis));
+        cb=cw=0;
+        scanf("%d%d",&b,&w);
+        for(int i=0; i<b; i++)
+            scanf("%d%d",&x,&y),map[x][y]=1;
+        for(int i=0; i<w; i++)
+            scanf("%d%d",&x,&y),map[x][y]=2;
+        for(int i=1; i<=n; i++)
+            for(int j=1; j<=n; j++)
+                if(!map[i][j]&&!vis[i][j]) bfs(i,j);
+        if(cb==cw) printf("Draw\n");
+        else if(cb>cw) printf("Black wins by %d\n",cb-cw);
+        else printf("White wins by %d\n",cw-cb);
+    }
+    return 0;
+}
diff --git a/HDOJ/4159_autoAC.cpp b/HDOJ/4159_autoAC.cpp
new file mode 100644
index 0000000..f4ee566
--- /dev/null
+++ b/HDOJ/4159_autoAC.cpp
@@ -0,0 +1,40 @@
+#include"stdio.h"
+#include"math.h"
+double jie(int n)
+{
+    double y=1;
+    int i;
+    for(i=2;i<=n;i++)
+        y*=i;
+    return y;
+}
+double c(int n,int x)
+{
+    double z;
+    z=jie(n)/jie(x)/jie(n-x);
+    return z;
+}
+int main()
+{
+    double ans;
+    int n;
+    int s;
+    double x,y;
+    int i;
+    while(scanf("%d%d",&n,&s)!=-1)
+    {
+        if(s>n)
+        {
+            printf("100.00000\n");
+            continue;
+        }
+        x=y=0;
+        for(i=0;i<s;i++)
+            x+=c(n,i)*pow(2,n-i);
+        for(i=0;i<=s;i++)
+            y+=c(n,i)*pow(2,n-i);
+        ans=x/y;
+        printf("%0.5lf\n",ans*100);
+    }
+    return 0;
+}
diff --git a/HDOJ/4160_autoAC.cpp b/HDOJ/4160_autoAC.cpp
new file mode 100644
index 0000000..d239e9e
--- /dev/null
+++ b/HDOJ/4160_autoAC.cpp
@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define max 510
+    struct  d
+    {
+        int w,l,h;
+    }doll[max];
+int match[max][max];
+int link[max];
+bool used[max];
+ int n;
+bool  dfs(int u)
+{
+    for(int v=1;v<=n;v++)
+        if(match[u][v]==1&&!used[v])
+        {
+            used[v]=true;
+            if(link[v]==-1||dfs(link[v]))
+            {
+                link[v]=u;
+                return true;
+            }
+        }
+    return false;
+}
+int Xiong()
+{
+    int res=0;
+    memset(link,-1,sizeof(link));
+    for(int i=1;i<=n;i++)
+    {
+        memset(used,false,sizeof(used));
+            if(dfs(i))
+                res++;
+    }
+    return res;
+}
+int main()
+{
+    int i,j;
+    while(scanf("%d",&n)==1&&n)
+    {
+        for(i=1;i<=n;i++)
+            scanf("%d%d%d",&doll[i].w,&doll[i].l,&doll[i].h);
+        memset(match,0,sizeof(match));                     
+         for(i=1;i<=n;i++) 
+             for(j=1;j<=n;j++)
+                 if(doll[i].w>doll[j].w&&doll[i].l>doll[j].l&&doll[i].h>doll[j].h)
+                     match[i][j]=1;
+         printf("%d\n",n-Xiong());        
+    }
+    return 0;
+}
diff --git a/HDOJ/4161_autoAC.cpp b/HDOJ/4161_autoAC.cpp
new file mode 100644
index 0000000..d4639e5
--- /dev/null
+++ b/HDOJ/4161_autoAC.cpp
@@ -0,0 +1,43 @@
+#include <stdio.h>
+int sum=-1;
+int dif(int a[],int n)
+{
+    int i,s=0;
+    bool zero=true;
+    sum++;
+    for(i=0;i<n-1;i++)
+    {    if(a[i]<0)
+            a[i]=0-a[i];
+        if(a[i+1]<0)
+            a[i+1]=0-a[i+1];
+        a[i]=a[i+1]-a[i];
+        if(a[i]!=0)
+            zero=false;
+        s+=a[i];
+    }
+    a[n-1]=s;
+    if(s==0 && zero)
+        return sum;
+    if(sum>1000)
+        return -1;
+    dif(a,n);
+}
+int main()
+{
+    int a[21];
+    int n,temp=1;
+    while(scanf("%d",&n)!=EOF && n)
+    {
+        sum=-1;
+        for(int i=0;i<n;i++)
+            scanf("%d",&a[i]);
+        int num=dif(a,n);
+        printf("Case %d: ",temp);
+        if(num==-1)
+            printf("not attained\n");
+        else
+            printf("%d iterations\n",num);
+        temp++;
+    }
+    return 0;
+}
diff --git a/HDOJ/4162_autoAC.cpp b/HDOJ/4162_autoAC.cpp
new file mode 100644
index 0000000..4c21eba
--- /dev/null
+++ b/HDOJ/4162_autoAC.cpp
@@ -0,0 +1,37 @@
+#include <cstdio>
+#include <cstring>
+using namespace std;
+int b[300100],len;
+char c[300100];
+inline int ca(int x)
+{return x<len?x:x-len;}
+int minp()
+{
+    int i=0,j=1,k=0;
+    while(i<len && j<len && k<len)
+    {
+        int det=b[ca(i+k)]-b[ca(j+k)];
+        if(det==0) k++;
+        else 
+        {
+            if(det>0) i+=k+1; else j+=k+1;
+            if(i==j) j++;
+            k=0;
+        }
+    }
+    return i>j?j:i;
+}
+int main()
+{
+    while(scanf("%s",c)==1)
+    {
+        len=strlen(c);c[len]=c[0];c[len+1]='\0';
+        for(int i=0;i<len;i++)
+        {
+            b[i]=c[i+1]-c[i];
+            if(c[i]>c[i+1]) b[i]+=8;
+        }
+        int k=minp();
+        for(int l=0;l<len;l++) printf("%d",b[ca(k+l)]); puts("");
+    }
+}
diff --git a/HDOJ/4163_autoAC.cpp b/HDOJ/4163_autoAC.cpp
new file mode 100644
index 0000000..f5adc3d
--- /dev/null
+++ b/HDOJ/4163_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+typedef struct
+{
+    int p,d;
+}Data;
+Data dt[1000003];
+bool cmp1(Data d1,Data d2)
+{
+    if(d1.p==d2.p) return d1.d<d2.d;
+    return d1.p<d2.p;
+}
+bool cmp2(Data d1,Data d2)
+{
+    if(d1.p==d2.p) return d1.d>d2.d;
+    return d1.p>d2.p;
+}
+bool cmp3(Data d1,Data d2)
+{
+     return d1.d<d2.d;
+}
+bool cmp4(Data d1,Data d2)
+{
+     return d1.d>d2.d;
+}
+void print()
+{
+    static int cnt=0;
+    printf("Case %d\n",++cnt);
+}
+int main()
+{
+    int n,k1,k2;
+    while(scanf("%d %d %d",&n,&k1,&k2),n&&k1&&k2)
+    {
+        for(int i=0;i<n;i++)
+        {
+            scanf("%d",&dt[i].p);
+            dt[i].d=i+1;
+        }
+        sort(dt,dt+n,cmp1);
+        print();
+        sort(dt,dt+k1,cmp3);
+        printf("%d",dt[0].d);
+        for(int i=1;i<k1;i++)
+        printf(" %d",dt[i].d);
+        printf("\n");
+        sort(dt,dt+n,cmp2);
+        sort(dt,dt+k2,cmp4);
+        printf("%d",dt[0].d);
+        for(int i=1;i<k2;i++)
+        printf(" %d",dt[i].d);
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4164_autoAC.cpp b/HDOJ/4164_autoAC.cpp
new file mode 100644
index 0000000..3e49c48
--- /dev/null
+++ b/HDOJ/4164_autoAC.cpp
@@ -0,0 +1,117 @@
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<set>
+#include<vector>
+#include<queue>
+#include<cstdlib>
+#include<ctime>
+#include<cmath>
+#include<bitset>
+using namespace std;
+#define N 210
+#define inf 50000000
+int dir[8][2] = { { 0, 1 }, { 1, 1 }, { 1, 0 }, { 1, -1 }, { 0, -1 },
+        { -1, -1 }, { -1, 0 }, { -1, 1 } };
+int T = 1, n, m, idx, tot;
+int maz[N][N], done[N * N], ans[N * N];
+char Map[N][N];
+struct position {
+    int x, y;
+} u, v, qu[N * N];
+void bfs(int x, int y) {
+    maz[x][y] = idx;
+    Map[x][y] = '0';
+    u.x = x;
+    u.y = y;
+    int l = 0, r = 1;
+    qu[0] = u;
+    while (l < r) {
+        u = qu[l++];
+        for (int i = 0; i < 8; i++) {
+            v.x = u.x + dir[i][0];
+            v.y = u.y + dir[i][1];
+            if (v.x >= 1 && v.x <= n && v.y >= 1 && v.y <= m
+                    && Map[v.x][v.y] == '1') {
+                maz[v.x][v.y] = idx;
+                Map[v.x][v.y] = '0';
+                qu[r++] = v;
+            }
+        }
+    }
+    if (r < 5)
+        done[idx] = 1;
+}
+void solve(int x, int y) {
+    u.x = x;
+    u.y = y;
+    int i = 1, to = 6;
+    qu[0] = u;
+    for (;;) {
+        int flag = 0;
+        for (int j = to; j != to || !flag; j = (j + 1) % 8) {
+            if (j == to)
+                flag = 1;
+            v.x = u.x + dir[j][0];
+            v.y = u.y + dir[j][1];
+            if (v.x >= 1 && v.x <= n && v.y >= 1 && v.y <= m
+                    && maz[v.x][v.y] == maz[x][y]) {
+                u.x = u.x + dir[(j + 7) % 8][0];
+                u.y = u.y + dir[(j + 7) % 8][1];
+                for (j = 0; j < 8; j++) {
+                    if (v.x + dir[j][0] == u.x && v.y + dir[j][1] == u.y) {
+                        to = j;
+                        break;
+                    }
+                }
+                qu[i++] = v;
+                u = v;
+                if (i >= 4 && qu[0].x == qu[i - 2].x && qu[0].y == qu[i - 2].y
+                        && qu[1].x == qu[i - 1].x && qu[1].y == qu[i - 1].y) {
+                    ans[tot++] = i - 2;
+                    return;
+                }
+                break;
+            }
+        }
+    }
+}
+int main() {
+    while (~scanf("%d%d", &n, &m)) {
+        if (!n && !m)
+            break;
+        for (int i = 1; i <= n; i++)
+            scanf("%s", Map[i] + 1);
+        idx = 0;
+        memset(maz, 0, sizeof(maz));
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (Map[i][j] == '1') {
+                    idx++;
+                    done[idx] = 0;
+                    bfs(i, j);
+                }
+            }
+        }
+        tot = 0;
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (maz[i][j] && !done[maz[i][j]]) {
+                    done[maz[i][j]] = 1;
+                    solve(i, j);
+                }
+            }
+        }
+        printf("Case %d\n", T++);
+        if (tot) {
+            sort(ans, ans + tot);
+            for (int i = 0; i < tot; i++)
+                printf("%d%s", ans[i], (i == tot - 1) ? "\n" : " ");
+        } else
+            printf("no objects found\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4165_autoAC.cpp b/HDOJ/4165_autoAC.cpp
new file mode 100644
index 0000000..397e9c0
--- /dev/null
+++ b/HDOJ/4165_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<cstdio>
+#include<cmath>
+#include<stack>
+#include<cstring>
+#include<string>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+#define clr(x) memset(x,0,sizeof(x))
+long long dp[31][31];
+bool inti(){
+    clr(dp);
+    for(int i=0;i<=30;i++){
+        dp[i][0]=1;
+    }
+    for(int i=1;i<=30;i++){
+        for(int j=1;j<=i;j++){
+            dp[i][j]=dp[i-1][j]+dp[i][j-1];
+        }
+    }
+    return true;
+}
+int main(){
+    inti();
+    int i,j,k,m,n;
+    while(cin>>n&&n){
+        cout<<dp[n][n]<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4166_autoAC.cpp b/HDOJ/4166_autoAC.cpp
new file mode 100644
index 0000000..8ffbf92
--- /dev/null
+++ b/HDOJ/4166_autoAC.cpp
@@ -0,0 +1,95 @@
+#include<stdio.h>
+#include<string.h>
+#include<iostream>
+#include<queue>
+using namespace std;
+const int maxn = 1005;
+const int inf = 1<<29;
+struct nd{
+    int x,y,d,t,id;
+};
+int has[maxn][maxn][4];
+int ans[maxn][maxn][4];
+int vis[maxn][maxn][4];
+int dx[] = {0,-1,0,1};
+int dy[] = {1,0,-1,0};
+char as[maxn][maxn],E[10],dd[128];
+int N,M,m,mn,cnt;
+int si,sj,di,dj;
+bool nok(int x,int y){
+    if(x<0||y<0||x==N||y==M||as[x][y]=='*')return true;
+    return false;
+}
+void bfs(int x,int y,int d)
+{
+    nd k,t;
+    int a,b,c,i;
+    cnt = 0;
+    for(a = 0; a < N; ++ a)
+        for(b = 0; b < M; ++ b)
+            for(c = 0; c < 4; ++ c)
+                has[a][b][c]=inf,ans[a][b][c]=0;
+    has[x][y][d]=0; ans[x][y][d]=1;
+    if(x==di&&y==dj)return;
+    queue<nd>que;
+    t.x=x;t.y=y;t.d=d;t.t=0; t.id = cnt; vis[x][y][d]=cnt++;
+    que.push(t);
+    while(!que.empty()){
+        t = que.front(); que.pop();
+        if(t.id ^ vis[t.x][t.y][t.d])continue;
+        for(i = 0; i < 4; ++ i){
+            k = t; k.t++; k.d = i;
+            k.x += dx[i]; k.y += dy[i];
+            if(nok(k.x,k.y))continue;
+            if(i^t.d)k.t++;
+            if((i+2)%4==t.d)k.t++;
+            if(k.t>has[k.x][k.y][k.d]||k.t>mn)continue;
+            if(k.t==has[k.x][k.y][k.d]){
+                ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
+                if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
+                if((i+2)%4==t.d){
+                    ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
+                    if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
+                }
+            }else{
+                ans[k.x][k.y][k.d]=ans[t.x][t.y][t.d];
+                if((i+2)%4==t.d)ans[k.x][k.y][k.d] += ans[t.x][t.y][t.d];
+                if(ans[k.x][k.y][k.d]>=m)ans[k.x][k.y][k.d]-=m;
+            }
+            has[k.x][k.y][k.d] = k.t;
+            if(k.x==di && k.y==dj){
+                if(has[k.x][k.y][k.d]<mn)mn=has[k.x][k.y][k.d];
+                continue;
+            }
+            k.id = cnt; vis[k.x][k.y][k.d] = cnt++;
+            que.push(k);
+        }
+        ans[t.x][t.y][t.d]=0;
+    }
+}
+int main()
+{
+    int cas=0,i,k;
+    dd['E']=0;dd['N']=1;dd['W']=2;dd['S']=3;
+    while(scanf("%d %d %d",&N,&M,&m)!=EOF){
+        if(!m)break;
+        for(i = 0; i < N; ++ i)
+            scanf("%s",as[i]);
+        scanf("%d %d %d %d %s",&si,&sj,&di,&dj,E);
+        mn = inf;
+        bfs(si,sj,dd[E[0]]);
+        k = 0;
+        for(i = 0; i < 4; ++ i){
+            if(has[di][dj][i]<mn){
+                mn = has[di][dj][i];
+                k = ans[di][dj][i];
+            }else if(has[di][dj][i]==mn){
+                k += ans[di][dj][i];
+                if(k >= m)k -= m;
+            }
+        }
+        if(mn==inf)printf("Case %d: %d -1\n",++cas,m);
+        else printf("Case %d: %d %d\n",++cas,m,k);
+    }
+    return 0;
+}
diff --git a/HDOJ/4167_autoAC.cpp b/HDOJ/4167_autoAC.cpp
new file mode 100644
index 0000000..f8568f0
--- /dev/null
+++ b/HDOJ/4167_autoAC.cpp
@@ -0,0 +1,40 @@
+#include<iostream>  
+#include<sstream>  
+#include<algorithm>  
+#include<set>  
+using namespace std;  
+int main()  
+{  
+    cin.sync_with_stdio(false);  
+    int n,maxlen,cas=1;  
+    while(cin>>n>>maxlen)  
+    {  
+        if(n==0&&maxlen==0) break;  
+        cout<<"Case "<<cas++<<endl;  
+        string s,a,b,ss;  
+        set<string>myset;  
+        getline(cin,s);  
+        for(int i=0;i<n;i++)  
+        {  
+            getline(cin,ss);  
+            for(int j=0;j<ss.length();j++)  
+                while(ss[j]==39||ss[j]==45) ss.erase(j,1);  
+            istringstream oss(ss);  
+            oss>>a;while(oss>>b);  
+            s=a[0]+b;  
+            for(int i=0;i<s.length();i++) s[i]=tolower(s[i]);             
+            string add;int id=1;  
+            if(s.length()>maxlen) s.erase(maxlen);  
+            while(myset.find(s+add)!=myset.end())  
+            {  
+                add.clear();  
+                if(id>9) add+=48+id/10;add+=48+id%10;  
+                if(add.length()+s.length()>maxlen)   
+                    s.erase(maxlen-add.length());  
+                id++;  
+            }  
+            myset.insert(s+add);cout<<s+add<<endl;  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4169_autoAC.cpp b/HDOJ/4169_autoAC.cpp
new file mode 100644
index 0000000..f5f8215
--- /dev/null
+++ b/HDOJ/4169_autoAC.cpp
@@ -0,0 +1,63 @@
+#include<algorithm>
+#include<vector>
+#include<iostream>
+using namespace std;
+const int N = 150010;
+vector<int> g[N];
+int n,dp[310],K,w[N];
+void init()
+{
+    for(int i=0;i<=n;i++)
+        g[i].clear();
+}
+int dfs(int u)
+{
+    int size=g[u].size();
+    int t=0;
+    int cur[310];
+    for(int i=1;i<=K;i++)
+        dp[i]=cur[i]=-INT_MAX;
+    cur[0]=dp[0]=0;
+    for(int i=0;i<size;i++)
+    {
+        int v=g[u][i];
+        int now=dfs(v);
+        for(int j=t;j>=0;j--)
+        {
+            for(int k=1;k<=now;k++)
+            {
+                if(k+j>K)
+                    break;
+                cur[k+j]=max(cur[k+j],dp[k]+cur[j]);
+            }
+        }
+            t+=now;
+    }
+    if(size==0) 
+        t++;
+    cur[1]=max(cur[1],w[u]);
+    for(int i=0;i<=K;i++)
+        dp[i]=cur[i];
+    return t;
+}
+int main()
+{
+    int x,root;
+    while(scanf("%d %d",&n,&K)==2)
+    {
+        init();
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d %d",&x,&w[i]);
+            if(x==0)
+                root=i;
+            else 
+                g[x].push_back(i);
+        }
+        dfs(root);
+        if(dp[K]==-INT_MAX)
+            printf("impossible\n");
+        else printf("%d\n",dp[K]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4170_autoAC.cpp b/HDOJ/4170_autoAC.cpp
new file mode 100644
index 0000000..460fca8
--- /dev/null
+++ b/HDOJ/4170_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<stdio.h>
+#include<math.h>
+#include<algorithm>
+#define eps 1e-6
+using namespace std;
+struct point
+{
+    int x,y;
+}a[10],v[10],s;
+double t,ans;
+int N,sv,i,p[10],T[3],js=1;
+double crosstime(double x0,double y0,double v0,double x1,double y1,double vx,double vy)
+{ 
+    double a,b,c,t;
+    a=vx*vx+vy*vy-v0*v0;
+    b=2*(vx*(x1-x0)+vy*(y1-y0));
+    c=(x1-x0)*(x1-x0)+(y1-y0)*(y1-y0);
+    if(a<eps&&a>-eps) return -c/b;
+    if(a<eps) {a=-a;b=-b;c=-c;}
+    return (-b+sqrt(b*b-4*a*c))/(2*a);
+}
+double back(double x0,double y0,double x1,double y1,double sv)
+{
+    return sqrt((x1-x0)*(x1-x0)+(y1-y0)*(y1-y0))/sv;
+}
+void trs(double ans,int T[3])
+{
+    T[0]=(int)ans;
+    ans-=T[0];
+    T[1]=(int)(ans*=60.0);ans-=T[1];
+    T[2]=(int)(ans*60.0+0.9999999);
+    if(T[2]==60) {T[2]=0;T[1]++;}
+    if(T[1]==60) {T[1]=0;T[0]++;}
+}
+int main()
+{
+    while(scanf("%d",&N),N)
+    {
+        for(i=0;i<N;i++) scanf("%d%d%d%d",&a[i].x,&a[i].y,&v[i].x,&v[i].y);
+        scanf("%d%d%d",&s.x,&s.y,&sv);
+        for(i=0;i<=N;i++) p[i]=i;
+        ans=1e9;
+        do
+        {
+            t=crosstime(s.x*1.0,s.y*1.0,sv*1.0,a[p[0]].x,a[p[0]].y,v[p[0]].x,v[p[0]].y)+1.0;
+            for(i=1;i<N;i++)
+                t+=1.0+crosstime(a[p[i-1]].x*1.0+t*v[p[i-1]].x,a[p[i-1]].y*1.0+t*v[p[i-1]].y,sv*1.0,a[p[i]].x*1.0+t*v[p[i]].x,a[p[i]].y*1.0+t*v[p[i]].y,v[p[i]].x*1.0,v[p[i]].y*1.0);
+            t+=back(a[p[N-1]].x*1.0+t*v[p[N-1]].x,a[p[N-1]].y*1.0+t*v[p[N-1]].y,s.x,s.y,sv);
+            if(t<ans) ans=t;
+        }
+        while(next_permutation(p,p+N));
+        trs(ans,T);
+        printf("Case %d: %d hour(s) %d minute(s) %d second(s)\n",js++,T[0],T[1],T[2]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4171_autoAC.cpp b/HDOJ/4171_autoAC.cpp
new file mode 100644
index 0000000..24b5d02
--- /dev/null
+++ b/HDOJ/4171_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <string.h>
+#include <cstdio>
+#include <vector>
+#include <queue>
+using namespace std;
+const int N = 100010;
+__int64 num[N],dis[N],num1 = 0,head[N];
+struct edge
+{
+    int rp,value,next;
+}ee[N];
+void init()
+{
+    num1 = 0;
+    memset(num,0,sizeof(num));
+    memset(dis,0,sizeof(dis));
+    memset(head,-1,sizeof(head));
+}
+void addedge(int x,int y,int v)
+{
+    ee[num1].rp = y;
+    ee[num1].value = v;
+    ee[num1].next = head[x];
+    head[x] = num1++;
+}
+void bfs(int x)
+{
+    queue<int> qq;
+    qq.push(x);
+    while(!qq.empty())
+    {
+        int y = qq.front();
+        qq.pop();
+        for(int i = head[y];i != -1;i = ee[i].next)
+        {
+            int k = ee[i].rp;
+            dis[k] = dis[y] + ee[i].value;
+            qq.push(k);
+        }
+    }
+}
+int main()
+{
+    int n;
+    while(~scanf("%d",&n))
+    {
+        init();
+        for(int i = 0;i <= n;++i)
+        {
+            scanf("%I64d",&num[i]);
+        }
+        int x,y,value;
+        __int64 sum = 0;
+        for(int i = 1;i <= n;++i)
+        {
+            scanf("%d%d%d",&x,&y,&value);
+            addedge(x,y,value);
+            sum += value;
+        }
+        bfs(0);
+        __int64 mmin = 2000000000;
+        __int64 ss = 0;
+        for(int i = 0;i <= n;++i)
+        {
+            ss = (sum - dis[i]) * 2 + num[i] + dis[i];
+             if(ss < mmin)
+            {
+                mmin = ss;
+            }
+        }
+        printf("%I64d\n",mmin);
+    }
+    return 0;
+}
diff --git a/HDOJ/4173_autoAC.cpp b/HDOJ/4173_autoAC.cpp
new file mode 100644
index 0000000..8d3d07e
--- /dev/null
+++ b/HDOJ/4173_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<iostream>
+#include<sstream>
+#include<fstream>
+#include<vector>
+#include<list>
+#include<deque>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<bitset>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cctype>
+#include<cmath>
+#include<ctime>
+#include<iomanip>
+using namespace std;
+const double eps(1e-8);
+typedef long long lint;
+const int maxn = 200 +5;
+pair<double,double>con[maxn];
+int main(){
+    int n;
+    while(cin >> n){
+        for(int i = 1 ; i <= n ; i++) scanf("%lf%lf",&con[i].first,&con[i].second);
+        int ans = 0;
+        for(int i = 1 ; i <= n ; i++){
+            for(int j = 1 ; j <= n ; j++){
+                pair<double,double> t;
+                t.first = (con[i].first + con[j].first) / 2.0;
+                t.second = (con[i].second + con[j].second) / 2.0;
+                int cnt = 0;
+                for(int k = 1 ; k <= n ; k++){
+                    double dis = pow(t.first - con[k].first,2) + pow(t.second - con[k].second,2);
+                    if(dis <= 6.25 + eps) cnt++;
+                }
+                ans = max(ans , cnt);
+            }
+        }
+        cout << ans << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4174_autoAC.cpp b/HDOJ/4174_autoAC.cpp
new file mode 100644
index 0000000..18192e5
--- /dev/null
+++ b/HDOJ/4174_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    int n,len,num[111],flag,k,b,i;
+    char a[111];
+      scanf("%d",&n);
+        while(n--)
+        {
+            flag=0;
+            scanf("%s",a);
+            len=strlen(a);
+            for(i=0;i<len;i++)
+            {
+                if(a[i]=='a'||a[i]=='b'||a[i]=='c'||a[i]=='A'||a[i]=='B'||a[i]=='C')
+                    num[i]=2;
+                else if(a[i]=='d'||a[i]=='e'||a[i]=='f'||a[i]=='D'||a[i]=='E'||a[i]=='F')
+                    num[i]=3;
+                else if(a[i]=='g'||a[i]=='h'||a[i]=='i'||a[i]=='G'||a[i]=='H'||a[i]=='I')
+                    num[i]=4;
+                else if(a[i]=='j'||a[i]=='k'||a[i]=='l'||a[i]=='J'||a[i]=='K'||a[i]=='L')
+                    num[i]=5;
+                else if(a[i]=='m'||a[i]=='n'||a[i]=='o'||a[i]=='M'||a[i]=='N'||a[i]=='O')
+                    num[i]=6;
+                else if(a[i]=='p'||a[i]=='q'||a[i]=='r'||a[i]=='s'||a[i]=='P'||a[i]=='Q'||a[i]=='R'||a[i]=='S')
+                    num[i]=7;
+                else if(a[i]=='t'||a[i]=='u'||a[i]=='v'||a[i]=='T'||a[i]=='U'||a[i]=='V')
+                    num[i]=8;
+                else if(a[i]=='w'||a[i]=='x'||a[i]=='y'||a[i]=='z'||a[i]=='W'||a[i]=='X'||a[i]=='Y'||a[i]=='Z')
+                    num[i]=9;
+            }
+            k=0;
+            b=len-1;
+            while(k<b)
+            {
+                if(num[k]!=num[b])
+                {
+                    flag=1;
+                    break;
+                }
+                else
+                {
+                    k++;
+                    b--;
+                }
+            }
+            if(flag==1)
+            {
+                printf("NO\n");
+            }
+            else
+                printf("YES\n");
+        }
+    return 0;
+}
diff --git a/HDOJ/4175_autoAC.cpp b/HDOJ/4175_autoAC.cpp
new file mode 100644
index 0000000..f907d69
--- /dev/null
+++ b/HDOJ/4175_autoAC.cpp
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <string.h>
+#include <cstdio>
+#include <math.h>
+using namespace std;
+struct point
+{
+    int pos,value;
+}pp[27][1010];
+int dp[27][1010];
+int main()
+{
+    int numcase;
+    scanf("%d",&numcase);
+    for(int k = 1;k <= numcase;++k)
+    {
+        int numl,numc,len,i,j,p;
+        memset(dp,0,sizeof(dp));
+        scanf("%d%d%d",&numl,&numc,&len);
+        for(i = 1;i <= numl;++i)
+        {
+            for(j = 1;j <= numc;++j)
+            {
+                scanf("%d%d",&pp[i][j].pos,&pp[i][j].value);
+            }
+        }
+       int mmin = 200000000;
+       for(i = 1;i <= numl;++i)
+       {
+           for(j = 1;j <= numc;++j)
+           {
+               mmin = 200000000;
+               for(p = 1;p <= numc;++p)
+               {
+                   dp[i][j] = dp[i-1][p] + abs(pp[i][j].pos - pp[i-1][p].pos) + pp[i][j].value;
+                   if(dp[i][j] < mmin)
+                   {
+                       mmin = dp[i][j];
+                   }
+               }
+               dp[i][j] = mmin;
+             }
+       }
+       mmin = 200000000;
+       for( i = 1;i <= numc;++i)
+       {
+           dp[numl][i] = dp[numl][i] + abs(len - pp[numl][i].pos);
+           if(dp[numl][i] < mmin)
+           {
+               mmin = dp[numl][i];
+           }
+       }
+       printf("%d\n",mmin);
+    }
+    return 0;
+}
diff --git a/HDOJ/4176_autoAC.cpp b/HDOJ/4176_autoAC.cpp
new file mode 100644
index 0000000..618ae47
--- /dev/null
+++ b/HDOJ/4176_autoAC.cpp
@@ -0,0 +1,31 @@
+#include <cstdlib>   
+#include <cstdio>  
+#include <cmath>  
+#include <algorithm>  
+#include <string.h>  
+#include <iostream>  
+using namespace std;  
+int main()  
+{  
+    int k;  
+    int n;  
+    cin>>k;  
+    int a[55];  
+    int cas=1;  
+    while(k--)  
+    {  
+        cin>>n;  
+        for(int i=0;i<n;i++)  
+            scanf("%d",&a[i]);  
+        int b,c,d=-1;  
+        sort(a,a+n);  
+        printf("Class %d\n",cas++);  
+        b=a[0],c=a[n-1];  
+        for(int i=1;i<n;i++)  
+        {  
+            d=max(d,a[i]-a[i-1]);  
+        }  
+        printf("Max %d, Min %d, Largest gap %d\n",c,b,d);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4177_autoAC.cpp b/HDOJ/4177_autoAC.cpp
new file mode 100644
index 0000000..804f5a2
--- /dev/null
+++ b/HDOJ/4177_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <stdio.h>
+inline int ab(int x) { return x >= 0 ? x : -x ;}
+int cal(int x,int y,int z,int &k)
+{
+    if(ab(x-y)==ab(y-z)) {
+        k = y; return ab(x-y);
+    }
+    else if(ab(x-z)==ab(y-z)) {
+        k = z; return ab(x-z);
+    }
+    else if(ab(x-y)==ab(z-x)) {
+        k = x; return ab(x-y);
+    }
+    else { k = -1 ; return -1;}
+}
+int tx[8] , ti[8];
+int h[4] , m[4] , re[4];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int re[4] , dis;
+        for(int i=1;i<=3;i++){
+            scanf("%d:%d",&h[i],&m[i]);
+        }
+        for(int i=1;i<=3;i++)
+        {
+            re[i] = h[i]*60+m[i];
+        }
+        int ok = 0;
+        tx[1] = cal(re[1],re[2],re[3],ti[1]);
+        tx[2] = cal(re[1]+720,re[2],re[3],ti[2]);
+        tx[3] = cal(re[1],re[2]+720,re[3],ti[3]);
+        tx[4] = cal(re[1],re[2],re[3]+720,ti[4]);
+        tx[5] = cal(re[1]-720,re[2],re[3],ti[5]);
+        tx[6] = cal(re[1],re[2]-720,re[3],ti[6]);
+        tx[7] = cal(re[1],re[2],re[3]-720,ti[7]);
+        for(int i=1;i<=7;i++)
+        {
+            if(tx[i] > 0) 
+            {
+                ok = 1;
+                if(tx[i] == 4*60) {
+                    printf("Look at the sun\n");
+                    break;
+                }
+                else {
+                    printf("The correct time is %d:%02d\n",
+                        ti[i]/60,ti[i]%60);
+                    break;
+                }
+            }
+        }
+        if(!ok) printf("Look at the sun\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4178_autoAC.cpp b/HDOJ/4178_autoAC.cpp
new file mode 100644
index 0000000..a1699e0
--- /dev/null
+++ b/HDOJ/4178_autoAC.cpp
@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <string.h>
+int main()
+{
+    char inf[50],ans[5];
+    int t,n,cnt,cas = 0,f,i,j,y[5];
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        memset(y,0,sizeof(y));
+        gets(inf);
+        for(j = 0; j < n; ++j)
+        {
+            cnt = f = 0;
+            gets(inf);
+            for(i = 0; inf[i] != ' ' && inf[i]; ++i);
+            for(; inf[i]; ++i){
+                if(inf[i-1] == ' ' && inf[i] == 'y'){
+                    if(cnt == 0)
+                        ++y[1];
+                    else
+                        ++y[2];
+                    ++cnt;
+                    f = 1;
+                }
+                else if(inf[i-1] ==' ' && inf[i] =='n'){
+                    ++cnt;
+                }
+            }
+            if(cnt == 0)
+                ++y[4];
+            else if(!f)
+                ++y[3];
+        }
+        printf("Roll-call: %d\n",++cas);
+        printf("Present: %d out of %d\n",y[1],n);
+        printf("Needs to study at home: %d out of %d\n",y[2],n);
+        printf("Needs remedial work after school: %d out of %d\n",y[3],n);
+        printf("Absent: %d out of %d\n",y[4],n);
+    }
+    return 0;
+}
diff --git a/HDOJ/4179_autoAC.cpp b/HDOJ/4179_autoAC.cpp
new file mode 100644
index 0000000..0176901
--- /dev/null
+++ b/HDOJ/4179_autoAC.cpp
@@ -0,0 +1,88 @@
+#include <cstdio>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+using namespace std;
+const int N = 11111;
+const int M = 55555;
+int eh[2][N], ec[2];
+struct Edge {
+    int id, nx, df;
+    double l;
+    Edge() {}
+    Edge(int id, int nx, int df, double l) : id(id), nx(nx), df(df), l(l) {}
+} edge[2][M << 1];
+inline void init() {
+    memset(eh, -1, sizeof(eh));
+    memset(ec, 0, sizeof(ec));
+}
+inline void addedge(int u, int v, int df, double l, int id) {
+    edge[id][ec[id]] = Edge(v, eh[id][u], df, l);
+    eh[id][u] = ec[id]++;
+}
+int x[N], y[N], z[N];
+template<class T> inline T sqr(T a) { return a * a;}
+int st[M << 1], ed[M << 1];
+inline int getdf(int a, int b) {
+    if (z[a] >= z[b]) return 0;
+    double len = sqrt(sqr((double) x[a] - x[b]) + sqr((double) y[a] - y[b]));
+    return (int) floor(100.0 * (z[b] - z[a]) / len);
+}
+inline double getdis(int a , int b) { return sqrt(sqr((double) x[a] - x[b]) + sqr((double) y[a] - y[b]) + sqr((double) z[a] - z[b]));}
+const double FINF = 1e50;
+double dis[2][N];
+int q[M << 1];
+bool vis[N];
+void spfa(int s, int id) {
+    for (int i = 0; i < N; i++) dis[id][i] = FINF;
+    int qh, qt;
+    qh = qt = 0;
+    dis[id][s] = 0;
+    q[qt++] = s;
+    vis[s] = true;
+    while (qh < qt) {
+        int cur = q[qh++];
+        vis[cur] = false;
+        for (int i = eh[id][cur]; ~i; i = edge[id][i].nx) {
+            if (dis[id][edge[id][i].id] > dis[id][cur] + edge[id][i].l) {
+                dis[id][edge[id][i].id] = dis[id][cur] + edge[id][i].l;
+                if (!vis[edge[id][i].id]) q[qt++] = edge[id][i].id, vis[edge[id][i].id] = true;
+            }
+        }
+    }
+}
+int main() {
+    int n, m;
+    while (~scanf("%d%d", &n, &m) && (n || m)) {
+        for (int i = 1; i <= n; i++) scanf("%d%d%d", &x[i], &y[i], &z[i]);
+        for (int i = 0; i < m; i++) scanf("%d%d", &st[i], &ed[i]);
+        int A, B, D;
+        scanf("%d%d%d", &A, &B, &D);
+        init();
+        for (int i = 0; i < m; i++) {
+            double tmp = getdis(st[i], ed[i]);
+            int df = getdf(st[i], ed[i]);
+            if (df <= D) {
+                addedge(st[i], ed[i], df, tmp, 0);
+                addedge(ed[i], st[i], df, tmp, 1);
+            }
+            df = getdf(ed[i], st[i]);
+            if (df <= D) {
+                addedge(ed[i], st[i], df, tmp, 0);
+                addedge(st[i], ed[i], df, tmp, 1);
+            }
+        }
+        spfa(A, 0);
+        spfa(B, 1);
+        double ans = FINF;
+        for (int i = 1; i <= n; i++) {
+            for (int t = eh[0][i]; ~t; t = edge[0][t].nx) {
+                if (edge[0][t].df == D) ans = min(ans, dis[0][i] + edge[0][t].l + dis[1][edge[0][t].id]);
+            }
+        }
+        if (ans < FINF) printf("%.1f\n", ans);
+        else puts("None");
+    }
+    return 0;
+}
diff --git a/HDOJ/4180_autoAC.cpp b/HDOJ/4180_autoAC.cpp
new file mode 100644
index 0000000..efd5121
--- /dev/null
+++ b/HDOJ/4180_autoAC.cpp
@@ -0,0 +1,50 @@
+#include <stdio.h>
+#define EPS 1e-20
+__int64 exgcd(__int64 a,__int64 b,__int64 &x,__int64 &y)
+{
+    if(b == 0LL)
+    {
+        x = 1LL;
+        y = 0LL;
+        return a;
+    }
+    __int64 d = exgcd(b,a%b,x,y);
+    __int64 t = x;
+    x = y;
+    y = t - a / b * y;
+    return d;
+}
+int main()
+{
+    __int64 t,a,b,x,y,c1,d1,c2,d2,d;
+    scanf("%I64d",&t);
+    while(t--)
+    {
+        scanf("%I64d/%I64d",&a,&b);
+        x = y = 0;
+        d = exgcd(a,b,x,y);
+        if(d != 1)
+        {
+            printf("%I64d/%I64d\n",a/d,b/d);
+            continue;
+        }
+        if(a == 1)
+        {
+            printf("1/%I64d\n",b-1);
+            continue;
+        }
+        while(x < 0)
+            x += b;
+        d1 = x;
+        c1 = (a * d1 - 1LL) / b;
+        while(y < 0)
+            y += a;
+        c2 = y;
+        d2 = (b * c2 - 1LL) / a;
+        if(d1 > d2)
+            printf("%I64d/%I64d\n",c1,d1);
+        else
+            printf("%I64d/%I64d\n",c2,d2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4182_autoAC.cpp b/HDOJ/4182_autoAC.cpp
new file mode 100644
index 0000000..f9e393b
--- /dev/null
+++ b/HDOJ/4182_autoAC.cpp
@@ -0,0 +1,61 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<queue>
+using namespace std ;
+#define maxn 201
+#define INF 10000000
+struct node
+{
+    int e , d ;
+}qe[maxn] ;
+int dp[maxn][maxn] , k ;
+int cmp( node a , node b )
+{
+    return a.d > b.d ;
+}
+bool check( int n , int m )
+{
+    int i , j ;
+    for( i = 0 ; i <= n ;i++ )
+        for( j = 0 ; j <= m ;j++ )
+          dp[i][j] = INF ;
+    dp[0][0] = 0 ;
+    for( i = 1 ; i <= n ;i++ )
+    {
+        dp[i][0] = dp[i-1][0]+qe[i].e ;
+        for( j = 1 ; j <= m && j <= i;j++ )
+        {
+           dp[i][j] = dp[i-1][j]+qe[i].e ;
+           dp[i][j] = min( dp[i][j],dp[i-1][j-1]+j*qe[i].d) ;
+        }
+    }
+    return dp[n][m] <= k ;
+}
+int main()
+{
+    int i , j , n , m ,ans ,case1 = 0 , tot ;
+    while( scanf("%d%d",&n , &k ) != EOF)
+    {
+        if( n == k && k == 0 ) break ;
+        tot = 0 ;
+        for( i = 1 ; i <= n ;i++ ) {
+            scanf("%d%d" , &qe[i].e,&qe[i].d) ;
+            tot += qe[i].e ;
+        }
+        sort(qe+1,qe+1+n,cmp) ;
+        ans = -1 ;
+        if( tot <= k ) ans = 0 ;
+        for( i = n ; i >= 0 ;i-- )
+        {
+            if(check(n,i))
+            {
+                ans = i ;
+                break ;
+            }
+        }
+        if( ans == -1 )printf("%d: Mission Impossible\n",++case1) ;
+        else printf("%d: %d\n",++case1,ans) ;
+    }
+}
diff --git a/HDOJ/4183_autoAC.cpp b/HDOJ/4183_autoAC.cpp
new file mode 100644
index 0000000..838e4e5
--- /dev/null
+++ b/HDOJ/4183_autoAC.cpp
@@ -0,0 +1,152 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <algorithm>
+using namespace std;
+int head[10000], s, t, nv, maxint=99999999, cnt;
+int cur[400], num[400], d[400], q[100000], pre[400];
+struct Node
+{
+    double q;
+    int x, y, r;
+}dian[1000];
+int cmp(Node x, Node y)
+{
+    return x.q<y.q;
+}
+struct node
+{
+    int u, v, cap, next;
+}edge[100000];
+void add(int u, int v, int cap)
+{
+    edge[cnt].v=v;
+    edge[cnt].cap=cap;
+    edge[cnt].next=head[u];
+    head[u]=cnt++;
+    edge[cnt].v=u;
+    edge[cnt].cap=0;
+    edge[cnt].next=head[v];
+    head[v]=cnt++;
+}
+void bfs()
+{
+    memset(num,0,sizeof(num));
+    memset(d,-1,sizeof(d));
+    int f1=0, f2=0, i;
+    q[f1++]=t;
+    d[t]=0;
+    num[0]=1;
+    while(f1>=f2)
+    {
+        int u=q[f2++];
+        for(i=head[u];i!=-1;i=edge[i].next)
+        {
+            int v=edge[i].v;
+            if(d[v]==-1)
+            {
+                d[v]=d[u]+1;
+                num[d[v]]++;
+                q[f1++]=v;
+            }
+        }
+    }
+}
+void isap()
+{
+    memcpy(cur,head,sizeof(cur));
+    bfs();
+    int flow=0, u=pre[s]=s, i;
+    while(d[s]<nv)
+    {
+        if(u==t)
+        {
+            int f=maxint, pos;
+            for(i=s;i!=t;i=edge[cur[i]].v)
+            {
+                if(f>edge[cur[i]].cap)
+                {
+                    f=edge[cur[i]].cap;
+                    pos=i;
+                }
+            }
+            for(i=s;i!=t;i=edge[cur[i]].v)
+            {
+                edge[cur[i]].cap-=f;
+                edge[cur[i]^1].cap+=f;
+            }
+            flow+=f;
+            u=pos;
+        }
+        for(i=cur[u];i!=-1;i=edge[i].next)
+        {
+            if(d[edge[i].v]+1==d[u]&&edge[i].cap)
+            {
+                break;
+            }
+        }
+        if(i!=-1)
+        {
+            cur[u]=i;
+            pre[edge[i].v]=u;
+            u=edge[i].v;
+        }
+        else
+        {
+            if(--num[d[u]]==0) break;
+            int mind=nv;
+            for(i=head[u];i!=-1;i=edge[i].next)
+            {
+                if(mind>d[edge[i].v]&&edge[i].cap)
+                {
+                    cur[u]=i;
+                    mind=d[edge[i].v];
+                }
+            }
+            d[u]=mind+1;
+            num[d[u]]++;
+            u=pre[u];
+        }
+    }
+    if(flow>=2)
+        printf("Game is VALID\n");
+    else
+        printf("Game is NOT VALID\n");
+}
+int main()
+{
+    int i, j, n, x, y, r, T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        memset(head,-1,sizeof(head));
+        cnt=0;
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+        {
+            scanf("%lf%d%d%d",&dian[i].q,&dian[i].x,&dian[i].y,&dian[i].r);
+        }
+        sort(dian,dian+n,cmp);
+        if(dian[0].r+dian[n-1].r*1.0>sqrt((dian[0].x-dian[n-1].x)*(dian[0].x-dian[n-1].x)*1.0+(dian[0].y-dian[n-1].y)*(dian[0].y-dian[n-1].y)*1.0))
+        {
+            printf("Game is VALID\n");
+            continue ;
+        }
+        for(i=0;i<n;i++)
+        {
+            for(j=i+1;j<n;j++)
+            {
+                if(dian[i].r*1.0+dian[j].r>sqrt((dian[i].x-dian[j].x)*(dian[i].x-dian[j].x)+(dian[i].y-dian[j].y)*(dian[i].y-dian[j].y)))
+                {
+                    add(i,j,1);
+                }
+            }
+        }
+        s=0;
+        t=n-1;
+        nv=t+1;
+        isap();
+    }
+    return 0;
+}
diff --git a/HDOJ/4185_autoAC.cpp b/HDOJ/4185_autoAC.cpp
new file mode 100644
index 0000000..df46655
--- /dev/null
+++ b/HDOJ/4185_autoAC.cpp
@@ -0,0 +1,75 @@
+#include<stdio.h>
+#include<vector>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+int map[700][700],p[700][700],vis[700],x[700],y[700],t,n,num,k;
+char s[700][700];
+bool search(int i)
+{
+    int j;
+    for(j=0;j<num;j++)
+    {
+        if(map[i][j]&&!vis[j])
+        {
+            vis[j]=1;
+            if(!y[j]||search(y[j]))
+            {
+                y[j]=i;
+                x[i]=j;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int match()
+{
+    memset(x,0,sizeof(x));
+    memset(y,0,sizeof(y));
+    int ans=0;
+    for(int i=0;i<num;i++)
+    {
+        memset(vis,0,sizeof(vis));
+        if(search(i)) ans++;
+    }
+    return ans/2;
+}
+int main()
+{
+    scanf("%d",&t);
+    k=1;
+    while(t--)
+    {
+        int i,j;
+        num=0;
+        memset(map,0,sizeof(map));
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+        scanf("%s",s[i]);
+        for(i=0;i<n;i++)
+        for(j=0;j<n;j++)
+        if(s[i][j]=='#')
+        p[i][j]=num++;
+        for(i=0;i<n;i++)
+        for(j=0;j<n;j++)
+        {
+            if(s[i][j]=='#')
+            {
+                if(j<n-1&&s[i][j+1]=='#')
+                {
+                    map[p[i][j]][p[i][j+1]]=1;
+                    map[p[i][j+1]][p[i][j]]=1;
+                }
+                if(i<n-1&&s[i+1][j]=='#')
+                {
+                    map[p[i][j]][p[i+1][j]]=1;
+                    map[p[i+1][j]][p[i][j]]=1;
+                }
+            }
+        }
+        int p=match();
+        printf("Case %d: %d\n",k++,p);
+    }
+    return 0;
+}
diff --git a/HDOJ/4187_autoAC.cpp b/HDOJ/4187_autoAC.cpp
new file mode 100644
index 0000000..b44fe81
--- /dev/null
+++ b/HDOJ/4187_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <algorithm>
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <vector>
+#define MOD 100000007
+#define PRIME_SIZE 500005
+#define _int64 long long
+using namespace std;
+int prime[PRIME_SIZE], phi[PRIME_SIZE];
+bool primes[PRIME_SIZE];
+void Euler_primes_phi_mu()
+{
+    phi[1]=1;
+    for (int i=2; i<PRIME_SIZE; i++)
+    {
+        if (primes[i]==0)
+            phi[i]=i-1, prime[++prime[0]]=i;
+        for (int j=1; j<=prime[0] && prime[j]*i<PRIME_SIZE; j++)
+        {
+            primes[prime[j]*i]=true;
+            if (i%prime[j]==0) { phi[i*prime[j]] = phi[i]*prime[j]; break; }
+            phi[i*prime[j]] = phi[i]*(prime[j]-1);
+        }
+    }
+}
+_int64 GCD(_int64 a, _int64 b) { for (_int64 t; a%b; t=a%b, a=b, b=t) ; return b; }
+_int64 pow_mod(_int64 a, _int64 n)
+{
+    _int64 ans=1;
+    for (; n; n>>=1, a=(a*a)%MOD) if (n&1) ans=(ans*a)%MOD;
+    return ans;
+}
+_int64 polay(int n, int base)
+{
+    _int64 ans=0;
+    for (int i=1; i*i<=n; i++)
+        if (n%i==0)
+        {
+            ans=(ans+pow_mod(base, i)*phi[n/i])%MOD;
+            if (i*i!=n)
+                ans=(ans+pow_mod(base, n/i)*phi[i])%MOD;
+        }
+    ans=(ans*pow_mod(n, MOD-2))%MOD;
+    return ans;
+}
+int ne[PRIME_SIZE], N[PRIME_SIZE], d[PRIME_SIZE];
+void Pre_next(int *s, int len)
+{
+    int i, j=0;
+    for (ne[0]=-1, i=2; i<=len; i++)
+    {
+        while (j>-1 && s[i-1]!=s[j]) j=ne[j];
+        ne[i]=++j;
+    }
+}
+int main()
+{
+    Euler_primes_phi_mu();
+    int n, m, i;
+    while (scanf("%d %d", &m, &n), ~m)
+    {
+        for (i=1; i<=n; i++) scanf("%d", &N[i]);
+        sort(N+1, N+n+1); N[n+1]=N[1]+360000;
+        for (i=1; i<=n; i++) d[i-1]=N[i+1]-N[i];
+        Pre_next(d, n);
+        int dif=n-ne[n];
+        _int64 gcd;
+        if (n%dif==0) gcd=GCD(n, dif);
+        else gcd=n;
+        _int64 ans=polay(n/gcd, pow_mod(m, gcd));
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4189_autoAC.cpp b/HDOJ/4189_autoAC.cpp
new file mode 100644
index 0000000..2127a66
--- /dev/null
+++ b/HDOJ/4189_autoAC.cpp
@@ -0,0 +1,139 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define N 100010
+#define M 260010
+typedef long long LL;
+struct node{
+    LL x,y;
+    int id;
+}w[150010];
+LL ty[150010],ans[100010];
+int ny;
+struct Tree{
+    int l,r;
+    LL val;
+}tree[1050010];
+bool cmp1(const node &a,const node &b){
+    if(a.x!=b.x) return a.x<b.x;
+    if(a.y!=b.y) return a.y<b.y;
+    return a.id<b.id;
+}
+bool cmp2(const node &a,const node &b){
+    if(a.x!=b.x) return a.x<b.x;
+    if(a.y!=b.y) return a.y>b.y;
+    return a.id<b.id;
+}
+bool cmp3(const node &a,const node &b){
+    if(a.x!=b.x) return a.x>b.x;
+    if(a.y!=b.y) return a.y<b.y;
+    return a.id<b.id;
+}
+bool cmp4(const node &a,const node &b){
+    if(a.x!=b.x) return a.x>b.x;
+    if(a.y!=b.y) return a.y>b.y;
+    return a.id<b.id;
+}
+int findy(LL y){
+    int l=0,r=ny-1;
+    while(l<=r){
+        int mid=(l+r)>>1;
+        if(ty[mid]<y) l=mid+1;
+        else if(ty[mid]>y) r=mid-1;
+        else return mid+1;
+    }
+}
+void build(int L,int R,int x){
+    tree[x].l=L;
+    tree[x].r=R;
+    tree[x].val=1000000000000;
+    if(L==R) return ;
+    int mid=(L+R)>>1;
+    build(L,mid,x<<1);
+    build(mid+1,R,x<<1|1);
+}
+LL find(int L,int R,int x){
+    if(tree[x].l>=L&&tree[x].r<=R)
+        return tree[x].val;
+    int mid=(tree[x].l+tree[x].r)>>1;
+    if(R<=mid) return find(L,R,x<<1);
+    if(L>mid) return find(L,R,x<<1|1);
+    return min(find(L,mid,x<<1),find(mid+1,R,x<<1|1));
+}
+void update(int id,int x,LL val){
+    if(tree[x].l==tree[x].r){
+        tree[x].val=min(tree[x].val,val);
+        return ;
+    }
+    int mid=(tree[x].l+tree[x].r)>>1;
+    if(id<=mid) update(id,x<<1,val);
+    else update(id,x<<1|1,val);
+    tree[x].val=min(tree[x<<1].val,tree[x<<1|1].val);
+}
+int main(){
+    int n,q,cs=0;
+    while(scanf("%d",&n)&&n!=-1){
+        if(cs) printf("\n");
+        else cs=1;
+        for(int i=0;i<n;++i){
+            scanf("%lld%lld",&w[i].x,&w[i].y);
+            w[i].id=-1;
+            ty[i]=w[i].y;
+        }
+        scanf("%d",&q);
+        for(int i=0;i<q;++i){
+            ans[i]=1000000000000;
+            scanf("%lld%lld",&w[i+n].x,&w[i+n].y);
+            w[i+n].id=i;
+            ty[i+n]=w[i+n].y;
+        }
+        sort(ty,ty+n+q);
+        ny=0;
+        for(int i=1;i<n+q;++i)
+            if(ty[i]!=ty[ny]) ty[++ny]=ty[i];
+        ny++;
+        LL my=ty[ny-1],iy=ty[0];
+        build(1,ny,1);
+        sort(w,w+n+q,cmp1);
+        LL mx=w[n+q-1].x,ix=w[0].x;
+        for(int i=0;i<n+q;++i){
+            if(w[i].id!=-1){
+                int j=findy(w[i].y);
+                ans[w[i].id]=min(ans[w[i].id],find(1,j,1)-(my-w[i].y)-(mx-w[i].x));
+            }
+            else update(findy(w[i].y),1,(my-w[i].y)+(mx-w[i].x));
+        }
+        build(1,ny,1);
+        sort(w,w+n+q,cmp2);
+        for(int i=0;i<n+q;++i){
+            if(w[i].id!=-1){
+                int j=findy(w[i].y);
+                ans[w[i].id]=min(ans[w[i].id],find(j,ny,1)-(w[i].y-iy)-(mx-w[i].x));
+            }
+            else update(findy(w[i].y),1,(w[i].y-iy)+(mx-w[i].x));
+        }
+        build(1,ny,1);
+        sort(w,w+n+q,cmp3);
+        for(int i=0;i<n+q;++i){
+            if(w[i].id!=-1){
+                int j=findy(w[i].y);
+                ans[w[i].id]=min(ans[w[i].id],find(1,j,1)-(my-w[i].y)-(w[i].x-ix));
+            }
+            else update(findy(w[i].y),1,(my-w[i].y)+(w[i].x-ix));
+        }
+        build(1,ny,1);
+        sort(w,w+n+q,cmp4);
+        for(int i=0;i<n+q;++i){
+            if(w[i].id!=-1){
+                int j=findy(w[i].y);
+                ans[w[i].id]=min(ans[w[i].id],find(j,ny,1)-(w[i].y-iy)-(w[i].x-ix));
+            }
+            else update(findy(w[i].y),1,(w[i].y-iy)+(w[i].x-ix));
+        }
+        for(int i=0;i<q;++i) printf("%lld\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4190_autoAC.cpp b/HDOJ/4190_autoAC.cpp
new file mode 100644
index 0000000..fab3e77
--- /dev/null
+++ b/HDOJ/4190_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<algorithm>
+#include<math.h>
+#define size 500010
+using namespace std;
+int n,m;
+int a[size];
+int ok(int x)
+{
+    int i = 0 , t = 0;
+    while ( i < n) 
+    {
+          t += ceil(a[i]*1.0 / x );
+          i++;
+    }    
+    if(t > m)  return 0;   
+    else return 1;
+}
+int find_ans(int low , int heigh)
+{
+    int mid , ans;
+    while (low < heigh)
+    {
+          mid = (low + heigh) /2; 
+          int temp = ok(mid); 
+          if( ok(mid) == 0 ) {  low = mid + 1; }
+          else {   heigh = mid ;}
+    }
+    return heigh;
+}
+int main()
+{
+    int max;
+    while ( scanf("%d%d",&n,&m) != EOF && n!=-1 && m!=-1)
+    {
+          int avg = m/n;
+          max = 0;
+          for(int i=0;i<n;i++)  
+          {
+               scanf("%d",&a[i]);
+               if(a[i] > max) max = a[i];
+          }
+          if( n == m ) printf("%d\n",max);
+          else
+               printf("%d\n",find_ans(1, max));
+    }
+    return 0;
+}
diff --git a/HDOJ/4191_autoAC.cpp b/HDOJ/4191_autoAC.cpp
new file mode 100644
index 0000000..6cb83c1
--- /dev/null
+++ b/HDOJ/4191_autoAC.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#define DB double
+using namespace std;
+const int MAXN = 20;
+DB dp[MAXN][MAXN];
+void init(){
+    for(int i = 0;i <= 10; i++)
+        for(int j = 0; j <= 10; j++)
+            dp[i][j] = 0.0;
+}
+int main()
+{
+    DB p;
+    while(scanf("%lf",&p) != EOF){
+        if(p == -1.0) break;
+        init();
+        for(int i = 0; i < 3; i++) dp[4][i] = 1.0;
+        dp[3][3] = p * p / (1 - p * (1 - p) * 2);
+        for(int i = 3; i >= 0; i--)
+            for(int j = 3; j >= 0;j--){
+                if(i == 3 && j == 3) continue;
+                dp[i][j] = p * dp[i+1][j] + (1 - p) * dp[i][j + 1];
+            }
+        DB gp = dp[0][0];
+        init();
+        for(int i = 0; i < 6; i++) dp[7][i] = 1.0;
+        dp[6][6] = p * p / (1 - p * (1 - p) * 2);
+        for(int i = 6; i >= 0; i--)
+            for(int j = 6; j >= 0;j--){
+                if(i == 6 && j == 6) continue;
+                dp[i][j] = p * dp[i+1][j] + (1 - p) * dp[i][j + 1];
+            }
+        DB p7 = dp[0][0];
+        init();
+        dp[6][6] = p7;
+        dp[6][5] = gp + (1.0 - gp) * dp[6][6];
+        dp[5][6] = gp * dp[6][6];
+        for(int i = 0; i <= 4;i++) dp[6][i] = 1.0;
+        for(int i = 5; i >= 0; i--)
+            for(int j = 5;j >= 0;j--){
+                dp[i][j] = gp * dp[i+1][j] + (1.0 - gp) * dp[i][j+1];
+            }
+        DB sp = dp[0][0];
+        init();
+        for(int i = 0; i < 2; i++) dp[2][i] = 1.0;
+        for(int i = 1; i >= 0; i--)
+            for(int j = 1; j >= 0; j--){
+                dp[i][j] = dp[i+1][j] * sp + dp[i][j+1] * (1.0 - sp);
+            }
+        DB mp = dp[0][0];
+        printf("%.11f %.11f %.11f\n",gp,sp,mp);
+    }
+    return 0;
+}
diff --git a/HDOJ/4192_autoAC.cpp b/HDOJ/4192_autoAC.cpp
new file mode 100644
index 0000000..c2980cc
--- /dev/null
+++ b/HDOJ/4192_autoAC.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+#define N 10005
+char str[N];
+int num[N];
+char op[N];
+int v[11];
+int id[11];
+char cmp(char a,char b){
+    if(a=='+'){
+        if(b=='+' || b=='-' || b==')')return '>';
+        else return '<';
+    }
+    if(a=='-'){
+        if(b=='+' || b=='-' || b==')')return '>';
+        else return '<';
+    }
+    if(a=='*'){
+        if(b=='(')return '<';
+        else return '>';
+    }
+    if(a=='('){
+       if(b==')')return '=';
+       else return '<';
+    }
+    if(a==')'){
+        return '>';
+    }
+}
+int cal(int a,int b,char c){
+    if(c=='+')return a+b;
+    if(c=='-')return a-b;
+    if(c=='*')return a*b;
+}
+int gao(){
+    int i,j;
+    int topnum = 0,topop = 1;
+    int k = 1;
+    op[1] = '(';
+    for(i=1;str[i];i++){
+        if(islower(str[i])){
+            topnum++;
+            num[topnum] = v[id[k++]];
+        } else {
+            char c = cmp(op[topop],str[i]);
+            char tag;
+            if(c=='<'){
+                topop++;
+                op[topop] = str[i];
+            } else if(c=='='){
+                topop--;
+            } else if(c=='>'){
+                int b = num[topnum--];
+                int a = num[topnum--];
+                tag = op[topop--];
+                int res = cal(a,b,tag);
+                topnum++;
+                num[topnum] = res;
+                i--;
+            }
+        }
+    }
+    return num[topnum];
+}
+int main(){
+    int n;
+    while(scanf("%d",&n) && n){
+        int i,j;
+        for(i=1;i<=n;i++){
+            scanf("%d",&v[i]);
+            id[i] = i;
+        }
+        int ans;
+        scanf("%d",&ans);
+        scanf("%s",str+1);
+        int len = strlen(str+1);
+        str[0] = '(',str[len+1] = ')',str[len+2] = '\0';
+        bool ok =0;
+        do{
+            int tmp = gao();
+            if(tmp==ans){
+                ok = 1;
+                break;
+            }
+        }while(next_permutation(id+1,id+1+n));
+        if(ok)puts("YES");
+        else puts("NO");
+    }
+    return 0;
+}
diff --git a/HDOJ/4193_autoAC.cpp b/HDOJ/4193_autoAC.cpp
new file mode 100644
index 0000000..8e33537
--- /dev/null
+++ b/HDOJ/4193_autoAC.cpp
@@ -0,0 +1,34 @@
+#include"iostream"
+#include"cstdio"
+#include"cstring"
+using namespace std;
+const int N=1000006;
+int n,num[N],ans;
+int main()
+{
+    int i,l;
+    int p,acc,sum,cnt;
+    while(scanf("%d",&n),n)
+    {
+        sum=0;
+        for(i=0;i<n;i++){scanf("%d",&num[i]);sum+=num[i];}
+        if(sum<0)    {printf("0\n");continue;}
+        p=n-1;
+        ans=cnt=sum=0;
+        while(cnt<=p)
+        {
+            sum+=num[cnt++];
+            while(sum<0)    sum+=num[p--];
+        }
+        acc=0;
+        while(p>=0)
+        {
+            if(acc>=0)        ans++;
+            if(acc<0)        acc+=num[p];
+            else if(num[p]<0)    acc=num[p];
+            p--;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4194_autoAC.cpp b/HDOJ/4194_autoAC.cpp
new file mode 100644
index 0000000..0853a1d
--- /dev/null
+++ b/HDOJ/4194_autoAC.cpp
@@ -0,0 +1,68 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cmath>
+#include <algorithm>
+#include <queue>
+#include <stack>
+#include <vector>
+#include <set>
+#include <map>
+#define MP(a, b) make_pair(a, b)
+#define PB(a) push_back(a)
+using namespace std;
+typedef long long ll;
+typedef pair<int, int> pii;
+typedef pair<unsigned int,unsigned int> puu;
+typedef pair<int, double> pid;
+typedef pair<ll, int> pli;
+typedef pair<int, ll> pil;
+const int INF = 0x3f3f3f3f;
+const double eps = 1E-6;
+const int LEN = 1001;
+map<string, int> mp;
+int n, k, top;
+int num[LEN];
+vector<int> tab[LEN];
+int ch(string s){
+    if(!mp.count(s)) mp[s] = top++;
+    return mp[s];
+}
+int main()
+{
+    char str[1010];
+    int tmp;
+    while(scanf("%d%d", &k, &n) != EOF){
+        if(!k && !n) break;
+        for(int i=0; i<LEN; i++) tab[i].clear();
+        top = 0; mp.clear();
+        for(int i=0; i<n; i++){
+            scanf("%s", &str);
+            num[i] = ch(str);
+            for(int j=0; j<k; j++){
+                scanf("%d", &tmp);
+                tmp --;
+                tab[tmp].PB(i);
+            }
+        }
+        int ans = 0;
+        for(int i=0; i<n; i++){
+            if(tab[i].size() != k) ans ++;
+            else{
+                map<int, int> st;
+                int cc = 0;
+                for(int j=0; j<tab[i].size(); j++){
+                    int x = tab[i][j], y = num[i];
+                    if(num[x] == y || st.count(x)){
+                        ans ++;break;
+                    }else st[x] = 1;
+                }
+            }
+        }
+        if(ans == 0) puts("NO PROBLEMS FOUND");
+        else if(ans == 1) puts("1 PROBLEM FOUND");
+        else printf("%d PROBLEMS FOUND\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4195_autoAC.cpp b/HDOJ/4195_autoAC.cpp
new file mode 100644
index 0000000..84ba13e
--- /dev/null
+++ b/HDOJ/4195_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<cmath>
+#define eps 1e-6
+#define pi acos(-1)
+using namespace std;
+struct node
+{
+    double x,y;
+};
+node p[4];
+double getdis(node p1,node p2)
+{
+    return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
+}
+double getang(double a,double b,double c)
+{
+    double ang= (a*a+b*b-c*c)/(2*a*b);
+    return acos(ang);
+}
+int main()
+{
+    char str[1000];
+    while(gets(str)&&strcmp(str,"END")!=0)
+    {
+        sscanf(str,"%lf%lf",&p[0].x,&p[0].y);
+        scanf("%lf%lf%lf%lf",&p[1].x,&p[1].y,&p[2].x,&p[2].y);
+        getchar();
+        double dis1=getdis(p[0],p[1]);
+        double dis2=getdis(p[1],p[2]);
+        double dis3=getdis(p[0],p[2]);
+        double ang1=getang(dis1,dis2,dis3);
+        double ang2=getang(dis2,dis3,dis1);
+        double ang3=getang(dis1,dis3,dis2);
+        for(int i=3; i<=1000; i++)
+        {
+            if(ang1*i/pi-(int)(ang1*i/pi+eps)<eps && ang2*i/pi-(int)(ang2*i/pi+eps)<eps && ang3*i/pi-(int)(ang3*i/pi+eps)<eps)
+            {
+                printf("%d\n",i);
+                break;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4196_autoAC.cpp b/HDOJ/4196_autoAC.cpp
new file mode 100644
index 0000000..e46606e
--- /dev/null
+++ b/HDOJ/4196_autoAC.cpp
@@ -0,0 +1,57 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+#define N 10000000
+#define MOD 1000000007
+#define LL long long
+using namespace std;
+bool flag[N+5]={0};
+int prime[1000000],cnt=0;
+void Prime(){
+    for(int i=2;i<sqrt(N+1.0);i++){
+        if(flag[i])
+            continue;
+        for(int j=2;j*i<=N;j++)
+            flag[i*j]=true;
+    }
+    for(int i=2;i<=N;i++)
+        if(!flag[i])
+            prime[cnt++]=i;
+}
+int getsum(int n,int p){
+    int sum=0;
+    while(n){
+        sum+=n/p;
+        n/=p;
+    }
+    return sum;
+}
+LL PowMod(LL a, LL b){
+    LL ans=1;
+    while(b){
+        if(b&1)
+            ans=(ans*a)%MOD;
+        a=(a*a)%MOD;
+        b>>=1;
+    }
+    return ans;
+}
+LL fac[N+5];
+int a;
+int main(){
+    int n;
+    fac[1]=1;
+    for(int i=2;i<=N;i++)
+        fac[i]=(fac[i-1]*i)%MOD;
+    Prime();
+    while(scanf("%d",&n)!=EOF&&n){
+        LL ret=1;
+        for(int i=0;i<cnt&&prime[i]<=n;i++){
+            a=getsum(n,prime[i]);
+            if(a&1)
+                ret=(ret*prime[i])%MOD;
+        }
+        printf("%I64d\n",(fac[n]*PowMod(ret,MOD-2))%MOD);
+    }
+    return 0;
+}
diff --git a/HDOJ/4197_autoAC.cpp b/HDOJ/4197_autoAC.cpp
new file mode 100644
index 0000000..9fb4600
--- /dev/null
+++ b/HDOJ/4197_autoAC.cpp
@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <math.h>
+#include <algorithm>
+using namespace std;
+const int N = 1001;
+const double PI = acos(-1),
+             EPS = 1e-8;
+struct Angle
+{
+    double l,r;
+};
+bool cmp(const Angle &a,const Angle &b)
+{
+    return a.l  < b.l;
+}
+int n;
+Angle A[N];
+int ok(double l,double r,double x)
+{
+    if(l - r < EPS)
+        return l - x < EPS && x - r < EPS;
+    return l - x < EPS || x - r < EPS ;
+}
+int main()
+{
+    int i,t;
+    double a,b,r;
+    double x,y;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(i = 0; i  < n; ++i)
+        {
+            scanf("%lf%lf%lf",&a,&b,&r);
+            double dis = sqrt(a * a + b * b);
+            double si = asin(r/dis);
+            double ta = atan2(b,a);
+            A[i].l = ta - si;
+            if(A[i].l < -PI)
+                A[i].l += 2 * PI;
+            A[i].r = ta + si;
+            if(A[i].r > PI)
+                A[i].r -= 2 * PI;
+        }
+        sort(A, A + n, cmp);
+        int res = n,tem;
+        for(i = 0; i < n;++i)
+        {
+            tem = 1;
+            double L = A[i].l,R = A[i].r;
+            for(int j = 1;j < n; ++j)
+            {
+                int k = (i + j) % n;
+                if(!ok(L,R,A[k].l))
+                {
+                    L = A[k].l;
+                    R = A[k].r;
+                    ++ tem ;
+                }
+                else if(ok(L,R,A[k].r))
+                {
+                    R = A[k].r;
+                }
+            }
+            if(tem < res)
+                res = tem;
+        }
+        printf("%d\n",res);
+    }
+    return 0;
+}
diff --git a/HDOJ/4198_autoAC.cpp b/HDOJ/4198_autoAC.cpp
new file mode 100644
index 0000000..b9ef025
--- /dev/null
+++ b/HDOJ/4198_autoAC.cpp
@@ -0,0 +1,81 @@
+#include<iostream>
+#include<queue>
+#include<string.h>
+using namespace std;
+int n,m,d;
+int t[4][2]={0,1,0,-1,1,0,-1,0},vist[510][510];
+int mx,my;
+char s[510][510];
+struct ss
+{
+    friend bool operator<(const ss a,const ss b)
+    {
+        return a.sum>b.sum;
+    }
+    int x,y,sum;
+};
+priority_queue<ss>Q;
+void bfs()
+{
+    memset(vist,0,sizeof(vist));
+    ss node1,node2;
+    node1.x=mx;
+    node1.y=my;
+    node1.sum=0;
+    while(!Q.empty())
+        Q.pop();
+    Q.push(node1);
+    vist[mx][my]=1;
+    while(!Q.empty())
+    {
+        node1=Q.top();
+        Q.pop();
+        if(node1.x==0||node1.y==0||node1.x==n-1||node1.y==m-1)
+        {
+            printf("%d\n",node1.sum+1);
+            return ;
+        }
+        for(int i=0;i<4;i++)
+        {
+            int xx=node1.x+t[i][0];
+            int yy=node1.y+t[i][1];
+            if(xx>=0&&xx<n&&yy>=0&&yy<m&&s[xx][yy]!='#'&&!vist[xx][yy])
+            {
+                vist[xx][yy]=1;
+                node2.x=xx;
+                node2.y=yy;
+                if(s[xx][yy]=='.')
+                    node2.sum=node1.sum+1;
+                else
+                    node2.sum=node1.sum+d+1;
+                Q.push(node2);
+            }
+        }
+    }
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d%d",&n,&m,&d);
+        int i,j;
+        for(i=0;i<n;i++)
+        {
+            getchar();
+            for(j=0;j<m;j++)
+            {
+                scanf("%c",&s[i][j]);
+                if(s[i][j]=='S')
+                {
+                    mx=i;
+                    my=j;
+                    s[i][j]='.';
+                }
+            }
+        }
+        bfs();
+    }
+    return 0;
+}