diff --git a/HDOJ/3900_autoAC.cpp b/HDOJ/3900_autoAC.cpp
new file mode 100644
index 0000000..0938134
--- /dev/null
+++ b/HDOJ/3900_autoAC.cpp
@@ -0,0 +1,115 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std;
+#define ll long long
+struct data
+{
+    int t,l,c;  
+}B[3545];       
+int n,r;   
+#include<map>
+#include<queue>
+#include<set>
+map<ll,bool > vis;
+ll s;
+inline bool check(ll s,int x) 
+{
+    int tx=(s&(7ll<<(x*3)))>>(x*3);
+    for(int i=0;i<n;i++)
+    {
+        if(i==x) continue;
+        int ti=(s&(7ll<<(i*3)))>>(i*3);
+        if(B[x].t==B[i].t) {
+            if(B[x].c!=B[i].c) continue;
+            if(tx+B[x].l<=ti||ti+B[i].l<=tx) continue;
+            return 0;
+        } else {
+            if(tx+B[x].l>B[i].c&&B[i].c>=tx&&
+               ti<=B[x].c&&B[x].c<B[i].l+ti) {
+                return 0;
+            }
+        }
+    }
+    return 1;
+}
+inline bool done(ll s)
+{
+    for(int i=0;i<n;i++) {
+        if(B[i].t==1) continue;
+        int tt= ((s&(7ll<<(3*r)))>>(r*3));
+        if(B[i].c<tt+B[r].l) continue;
+        int l=((s&(7ll<<(3*i)))>>(i*3)) , r=l+B[i].l;
+        if(r<=2||l>2) continue;
+        return 0;
+    }
+    return 1;
+}
+inline void cover(ll& s,int x,int p)
+{
+    s&=~(7ll<<(x*3));
+    s|=(ll)p<<(x*3);
+}
+#define pii  pair<ll,int>
+#define  mp  make_pair
+int bfs(ll s)
+{
+    if(done(s)) return 1;
+    queue< pii  > q;
+    q.push(mp(s,0));
+    vis.clear();
+    vis[s]=1;
+    while(!q.empty()) {
+        pii tt=q.front(); q.pop();
+        ll u=tt.first;
+        int d=tt.second+1;
+        for(int i=0;i<n;i++) {
+            int p=(u&(7ll<<(i*3)))>>(i*3);
+            for(int j=1;j<=p;j++) {
+                ll v=u;
+                cover(v,i,p-j);
+                if(!check(v,i)) break;
+                if(done(v)) return d+1;
+                if(vis[v]) continue;
+                vis[v]=1;
+                q.push(mp(v,d));
+            }
+            for(int j=1;p+j+B[i].l<=6;j++) {
+                ll v=u;
+                cover(v,i,p+j);
+                if(!check(v,i)) break;
+                if(done(v)) return d+1;
+                if(vis[v]) continue;
+                vis[v]=1;
+                q.push(mp(v,d));
+            }
+        }
+    }
+    return -1;
+}
+int main()
+{
+    while(cin>>n&&n)
+    {
+       ll s=0;
+        for(int i=0;i<n;i++)
+        {
+            int t,lx,ly,rx,ry;
+            cin>>t>>lx>>ly>>rx>>ry;
+            if(lx==rx) {
+                B[i].t=0;
+                B[i].l=ry-ly+1;
+                B[i].c=lx;
+                s|=((ll)ly<<(3*i));
+            }
+            else {
+                B[i].t=1;
+                B[i].l=rx-lx+1;
+                B[i].c=ly;
+                s|=((ll)lx<<(3*i));
+            }
+        }
+        cin>>r;
+        cout<<bfs(s)<<endl;
+    }
+}
diff --git a/HDOJ/3901_autoAC.cpp b/HDOJ/3901_autoAC.cpp
new file mode 100644
index 0000000..2bd17ed
--- /dev/null
+++ b/HDOJ/3901_autoAC.cpp
@@ -0,0 +1,133 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <utility>
+#include <queue>
+#include <vector>
+#include <algorithm>
+using namespace std;
+#define pb push_back
+typedef pair <int, int> pt;
+const int BUF_SIZE = 100000, SON = 26;
+char s[BUF_SIZE + 1], t[BUF_SIZE + 1];
+int lens, lent;
+vector <pt> vec;
+bool fir, las;
+struct node_t {
+    node_t *son[SON], *fail;
+    vector <int> lis;
+} node_pool[BUF_SIZE + 1], *node_idx, *root;
+node_t *node_alloc() {
+    node_t *ret = node_idx ++;
+    memset(ret -> son, 0, sizeof(ret -> son));
+    ret -> fail = NULL;
+    ret -> lis.clear();
+    return ret;
+}
+void init() {
+    node_idx = node_pool;
+    root = node_alloc();
+}
+void ins(char *st, char *ed, int p) {
+    node_t *pos = root;
+    while (st != ed) {
+        int t = *(st ++) - 'a';
+        if (!pos -> son[t]) pos -> son[t] = node_alloc();
+        pos = pos -> son[t];
+    }
+    pos -> lis.pb(p);
+}
+void build() {
+    static queue <node_t *> q;
+    for (int i = 0; i < SON; i ++)
+        if (root -> son[i]) {
+            root -> son[i] -> fail = root;
+            q.push(root -> son[i]);
+        }
+        else root -> son[i] = root;
+    while (q.size()) {
+        node_t *u = q.front();
+        q.pop();
+        for (int i = 0; i < SON; i ++)
+            if (u -> son[i]) {
+                u -> son[i] -> fail = u -> fail -> son[i];
+                for (vector <int>::iterator it = u -> fail -> son[i] -> lis.begin(); it != u -> fail -> son[i] -> lis.end(); it ++)
+                    u -> son[i] -> lis.pb(*it);
+                q.push(u -> son[i]);
+            }
+            else u -> son[i] = u -> fail -> son[i];
+    }
+}
+bool solve(int lb, int rb, bool st, bool ed) { 
+    init();
+    int pat = 0;
+    static int cnt[BUF_SIZE];
+    memset(cnt, 0, sizeof(cnt));
+    for (int i = lb; i < rb; )
+        if (t[i] == '?') i ++;
+        else {
+            int j = i;
+            while (j < rb && t[j] != '?') j ++;
+            ins(t + i, t + j, j - 1 - lb);
+            i = j;
+            pat ++;
+        }
+    build();
+    node_t *pos = root;
+    for (int i = 0; i < lens; i ++) {
+        int p = s[i] - 'a';
+        pos = pos -> son[p];
+        node_t *tmp = pos;
+        for (vector <int>::iterator it = tmp -> lis.begin(); it != tmp -> lis.end(); it ++) {
+            int q = *it;
+            if (i - q >= 0)
+                cnt[i - q] ++;
+        }
+    }
+    for (int i = 0; i < lens; i ++)
+        if (cnt[i] == pat) {
+            if (vec.empty()) {
+                if (!fir && st && i != 0) continue;
+                if (!las && ed && i + rb - lb != lens) continue;
+                vec.pb(make_pair(i, i + rb - lb));
+                return 1;
+            }
+            else {
+                vector <pair <int, int> >::reverse_iterator it = vec.rbegin();
+                if (i >= it -> second) {
+                    if (ed && !las && i + rb - lb != lens) continue;
+                    vec.pb(make_pair(i, i + rb - lb));
+                    return 1;
+                }
+            }
+        }
+    return 0;
+}
+int main() {
+    while (scanf("%s%s", s, t) != EOF) {
+        lens = strlen(s), lent = strlen(t);
+        fir = (t[0] == '*'), las = (t[lent - 1] == '*');
+        vec.clear();
+        bool fail = 0;
+        int split = 0;
+        int real_end = lent;
+        while (real_end && t[real_end - 1] == '*') real_end --;
+        for (int i = 0; i < lent; )
+            if (t[i] == '*') i ++;
+            else {
+                int j = i;
+                while (j < lent && t[j] != '*') j ++;
+                if (!solve(i, j, split == 0, j == real_end)) {
+                    fail = 1;
+                    split ++;
+                    break;
+                }
+                i = j;
+                split ++;
+            }
+        if (split == 0) printf("YES\n");
+        else if (fail) printf("NO\n");
+        else printf("YES\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3902_autoAC.cpp b/HDOJ/3902_autoAC.cpp
new file mode 100644
index 0000000..0b7a02b
--- /dev/null
+++ b/HDOJ/3902_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<iostream>
+using namespace std;
+#define N 40005
+struct node{
+    double x,y;
+}p[N];
+int n;
+double cal_dis(int x,int y){
+    double x1=p[x].x,y1=p[x].y;
+    double x2=p[y].x,y2=p[y].y;
+    return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
+}
+int main(void){
+    while(~scanf("%d",&n)){
+        int k=1;
+        for(int i=1;i<=n;i++){
+            scanf("%lf%lf",&p[k].x,&p[k].y);
+            if(k!=1&&k%2){
+                p[k-1].x=(p[k-2].x+p[k].x)/2.0;
+                p[k-1].y=(p[k-2].y+p[k].y)/2.0;
+            }
+            k+=2;
+        }
+        p[k-1].x=(p[1].x+p[k-2].x)/2.0;
+        p[k-1].y=(p[1].y+p[k-2].y)/2.0;
+        bool flag=0;
+        for(int i=1;i<=n;i++){
+            double x1=p[i].x-p[i+n].x;
+            double y1=p[i].y-p[i+n].y;
+            int j,k;
+            k=i-1;
+            j=i+1;
+            for(;j<=i+n;j++,k--){
+                if(k<=0) k=2*n;
+                double x2=p[j].x-p[k].x;
+                double y2=p[j].y-p[k].y;
+                if(x1*x2+y1*y2!=0)
+                    break;
+                if(cal_dis(i,j)!=cal_dis(i,k))
+                    break;
+            }
+            if(j>i+n){
+                flag=1;
+                break;
+            }
+        }
+        if(flag)
+            printf("YES\n");
+        else
+            printf("NO\n");
+    }
+}
diff --git a/HDOJ/3903_autoAC.cpp b/HDOJ/3903_autoAC.cpp
new file mode 100644
index 0000000..521e49c
--- /dev/null
+++ b/HDOJ/3903_autoAC.cpp
@@ -0,0 +1,18 @@
+#include<stdio.h>
+#include<math.h>
+int main()
+{
+    __int64 t, a, b, c, n, m, k;
+    scanf("%I64d",&t);
+    while(t--)
+    {
+        scanf("%I64d%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&n,&m,&k);
+        __int64 s = 4 * a * a * b * b - (a * a + b * b - c * c) * (a * a + b * b - c * c);
+        __int64 tmp = sqrt(s);
+        if(tmp * tmp == s)
+            printf("YES\n");
+        else
+            printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3905_autoAC.cpp b/HDOJ/3905_autoAC.cpp
new file mode 100644
index 0000000..e88ebd8
--- /dev/null
+++ b/HDOJ/3905_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<iostream>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+int dp[1005][1005],sum[1005],a[1005],s[1005][1005];
+int main()
+{
+    int n,m,r;
+    while(scanf("%d%d%d",&n,&m,&r)!=EOF)
+    {
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&a[i]);
+            sum[i]=sum[i-1]+a[i];
+        }
+        memset(dp,-1,sizeof(dp));
+        memset(s,-0x1f1f1f1f,sizeof(s));
+        dp[0][0]=0;s[0][0]=-sum[1];
+        for(int i=1;i<=n;i++)
+        {
+            if(i>=r)
+            {
+                dp[0][i]=sum[i];         
+            }
+            dp[i][i]=0;
+            s[0][i]=max(s[0][i-1],dp[0][i]-sum[i+1]);
+        }
+        for(int i=1;i<=m;i++)
+        {
+            for(int j=i;j<=n;j++)
+            {
+                if(dp[i-1][j-1]!=-1)
+                    dp[i][j]=max(dp[i-1][j-1],dp[i][j]);
+                if(j-r>=i&&s[i-1][j-r-1]!=-0x1f1f1f1f)
+                    dp[i][j]=max(dp[i][j],sum[j]+s[i-1][j-r-1]);
+                if(dp[i][j]!=-1)
+                    s[i][j]=max(s[i][j-1],dp[i][j]-sum[j+1]);
+                else
+                    s[i][j]=s[i][j-1];
+            }
+        }
+        printf("%d\n",dp[m][n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3907_autoAC.cpp b/HDOJ/3907_autoAC.cpp
new file mode 100644
index 0000000..bb415ec
--- /dev/null
+++ b/HDOJ/3907_autoAC.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <string.h>
+using namespace std;
+struct e{
+    int data;
+    int weight;
+    e *next;
+};
+e edge[1001];
+int n;
+void add(int s,int t,int weight){
+    e *p=new e;
+    p->data=t;
+    p->next=edge[s].next;
+    p->weight=weight;
+    edge[s].next=p;
+}
+int s[1001],q[1001];
+int f[1001][1001];
+int solve(int s1,int t1,int w){
+    int ans1=0;
+    int ans2=0;
+    int i,j,k;
+    if(f[s1][t1]!=-1) return f[s1][t1];
+    e *p=edge[s1].next;
+    e *q1=p;
+    if(w>q[s1])
+    {
+        while(p)
+        {
+            solve(p->data,s1,p->weight);
+            ans1+=f[p->data][s1];
+            p=p->next;
+        }
+        f[s1][t1]=ans1+s[s1];
+    }
+    else
+    {
+        while(p)
+        {
+            solve(p->data,s1,p->weight);
+            ans1+=f[p->data][s1];
+            p=p->next;
+        }
+        while(q1)
+        {
+            solve(q1->data,t1,w+q1->weight);
+            ans2+=f[q1->data][t1];
+            q1=q1->next;
+        }
+        f[s1][t1]=min(ans2,ans1+s[s1]);
+    }
+    return f[s1][t1];
+}
+void read(){
+    int i,j,k,s1,t,root;
+    int cas;
+    cin>>cas;
+    while(cas--)
+    {
+        cin>>n;
+        memset(edge,0,sizeof(edge));
+        memset(f,-1,sizeof(f));
+        for(i=1;i<=n;i++)
+        {
+            cin>>j>>k>>s1>>t;
+            if(j!=0) add(j,i,t);
+            else root=i;
+            q[i]=k;
+            s[i]=s1;
+        }
+        e *p=edge[root].next;
+        int ans=0;
+        while(p)
+        {
+            ans+=solve(p->data,root,p->weight);
+            p=p->next;
+        }
+        cout<<ans<<endl;
+    }
+}
+int main(){
+    read();
+    return 0;
+}
diff --git a/HDOJ/3908_autoAC.cpp b/HDOJ/3908_autoAC.cpp
new file mode 100644
index 0000000..ea79ef3
--- /dev/null
+++ b/HDOJ/3908_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#define N 1000
+int co_prime[N];    
+int unco_prime[N];    
+int s[N];
+int Gcd(int a, int b)
+{
+    return a%b?Gcd(b,a%b):b;
+}
+int main()
+{
+    int t,n,i,j,sum;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(i=1;i<=n;i++)
+            scanf("%d",&s[i]);
+        for(i=1;i<=n;i++){
+            for(j=1;j<=n;j++){
+                if(i == j)continue;
+                if(Gcd(s[i],s[j]) == 1)co_prime[i] ++;
+                else unco_prime[i] ++;
+            }
+        }
+        sum = 0;
+        for(i=1;i<=n;i++)sum += co_prime[i] * unco_prime[i];
+        printf("%d\n",n*(n-1)*(n-2)/6- sum/2);
+        for(i=0;i<=n;i++)co_prime[i] = unco_prime[i] = 0;
+    }
+    return 0;
+}
diff --git a/HDOJ/3910_autoAC.cpp b/HDOJ/3910_autoAC.cpp
new file mode 100644
index 0000000..dd412f0
--- /dev/null
+++ b/HDOJ/3910_autoAC.cpp
@@ -0,0 +1,11 @@
+#include<stdio.h>
+int main()
+{
+    int A,B,C;
+    while(scanf("%d%d%d",&A,&B,&C)!=EOF)
+    {
+        double x=(double)(B+C)/(A+B+C*2);
+        printf("%.6lf\n",(1-x)*B-x*C);
+    }    
+    return 0;
+}
diff --git a/HDOJ/3911_autoAC.cpp b/HDOJ/3911_autoAC.cpp
new file mode 100644
index 0000000..74613f3
--- /dev/null
+++ b/HDOJ/3911_autoAC.cpp
@@ -0,0 +1,147 @@
+#include<iostream>
+using namespace std;
+struct node{
+   int lone,lzero;
+   int rone,rzero;
+   int tmax0,tmax1;
+   int flag;
+   int l,r;
+   int mlen;
+}p[100001*4];
+int a[100001];
+int max(int x,int y)
+{
+    return x>y?x:y;
+}
+int min(int x,int y)
+{
+    return x<y?x:y;
+}
+void update_info(int n)
+{
+    p[n].lone=p[n*2].lone;
+    if(p[n*2].lone==p[n*2].mlen)
+        p[n].lone+=p[n*2+1].lone;
+    p[n].lzero=p[n*2].lzero;
+    if(p[n*2].lzero==p[n*2].mlen)
+        p[n].lzero+=p[n*2+1].lzero;
+    p[n].rone=p[n*2+1].rone;
+    if(p[n*2+1].rone==p[n*2+1].mlen)
+        p[n].rone+=p[n*2].rone;
+    p[n].rzero=p[n*2+1].rzero;
+    if(p[n*2+1].rzero==p[n*2+1].mlen)
+        p[n].rzero+=p[n*2].rzero;
+    p[n].tmax0=max(p[n*2].tmax0,p[n*2+1].tmax0);
+    p[n].tmax0=max(p[n].tmax0,p[n*2].rzero+p[n*2+1].lzero);
+    p[n].tmax1=max(p[n*2].tmax1,p[n*2+1].tmax1);
+    p[n].tmax1=max(p[n].tmax1,p[n*2].rone+p[n*2+1].lone);
+}
+void build(int l,int r,int n)
+{
+    p[n].l=l;
+    p[n].r=r;
+    p[n].flag=0;
+    p[n].mlen=(r-l+1);
+    if(l==r)
+    {
+        if(a[l]==1)
+        {
+            p[n].lone=1;
+            p[n].lzero=0;
+            p[n].rone=1;
+            p[n].rzero=0;
+            p[n].tmax0=0;
+            p[n].tmax1=1;
+        }
+        else
+        {
+            p[n].lone=0;
+            p[n].lzero=1;
+            p[n].rone=0;
+            p[n].rzero=1;
+            p[n].tmax0=1;
+            p[n].tmax1=0;
+        }
+        return ;
+    }
+    int mid=(l+r)/2;
+    build(l,mid,n*2);
+    build(mid+1,r,n*2+1);
+    update_info(n);
+}
+void pushdown(int n)
+{
+   p[n*2].flag=p[n*2].flag^1;
+   p[n*2+1].flag=p[n*2+1].flag^1;
+   swap(p[n*2].lone,p[n*2].lzero);
+   swap(p[n*2].rone,p[n*2].rzero);
+   swap(p[n*2].tmax1,p[n*2].tmax0);
+   swap(p[n*2+1].lone,p[n*2+1].lzero);
+   swap(p[n*2+1].rone,p[n*2+1].rzero);
+   swap(p[n*2+1].tmax1,p[n*2+1].tmax0);
+   p[n].flag=0;
+}
+void insert(int x,int y,int n)
+{
+    if(x==p[n].l&&y==p[n].r)
+    {
+        swap(p[n].lone,p[n].lzero);
+        swap(p[n].rzero,p[n].rone);
+        swap(p[n].tmax1,p[n].tmax0);
+        p[n].flag=p[n].flag^1;
+        return ;
+    }
+    if(p[n].flag==1)
+        pushdown(n);
+    int mid=(p[n].l+p[n].r)/2;
+    if(y<=mid)
+        insert(x,y,n*2);
+    else if(x>mid)
+        insert(x,y,n*2+1);
+    else
+    {
+        insert(x,mid,n*2);
+        insert(mid+1,y,n*2+1);
+    }
+    update_info(n);
+}
+int sum(int x,int y,int n)
+{
+    if(x==p[n].l&&y==p[n].r)
+       return p[n].tmax1;
+    int mid=(p[n].l+p[n].r)/2;
+    if(p[n].flag==1)
+        pushdown(n);
+    if(y<=mid)
+        return sum(x,y,n*2);
+    else if(x>mid)
+        return sum(x,y,n*2+1);
+    else
+    {
+        int left=0,right=0,midden=0;
+        midden=min(mid-x+1,p[n*2].rone)+min(y-mid,p[n*2+1].lone);
+        left=sum(x,mid,n*2);
+        right=sum(mid+1,y,n*2+1);
+        return max(midden,max(left,right));
+    }
+}
+int main()
+{
+    int n,m,i,nima,x,y;
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(i=1;i<=n;i++)
+            scanf("%d",&a[i]);
+        build(1,n,1);
+        scanf("%d",&m);
+        while(m--)
+        {
+            scanf("%d%d%d",&nima,&x,&y);
+            if(nima==1)
+                insert(x,y,1);
+            else
+                printf("%d\n",sum(x,y,1));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3912_autoAC.cpp b/HDOJ/3912_autoAC.cpp
new file mode 100644
index 0000000..971e8e1
--- /dev/null
+++ b/HDOJ/3912_autoAC.cpp
@@ -0,0 +1,167 @@
+#include <iostream>
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+#include<cmath>
+#include<algorithm>
+#include<ctime>
+using namespace std;
+#define N 50009
+int R,C,ER,EC,num;
+int map1[505][505];
+int map2[505][505];
+int vis[505][505];
+struct Point
+{
+    int x,y,f;
+    Point(int _x,int _y,int _f){x=_x;y=_y;f=_f;}
+};
+void init()
+{
+    scanf("%d%d%d%d",&R,&C,&ER,&EC);
+    memset(vis,0,sizeof(vis));
+    num=0;
+    for(int i=0;i<2*R-1;i++)
+    {
+        if(i&1)
+        {
+        for(int j=0;j<C;j++)
+        scanf("%d",&map1[i/2][j]);
+        }
+        else 
+        {
+        for(int j=0;j<C-1;j++)
+        scanf("%d",&map2[i/2][j]);
+        }
+    }
+}
+void dfs(Point s,Point ss)
+{
+    int ff=s.f;
+    for(;;)
+    {
+    if(!vis[s.x][s.y])num++;
+    vis[s.x][s.y]=1;
+    if(s.x==ss.x&&s.y==ss.y)
+    {
+        if((s.f==3&&ff==0)||(s.f==1&&ff==2))
+        break;
+        if(s.f==ff&&ff==0&&(s.y==0||map2[s.x][s.y-1]==1))
+        break;
+        if(s.f==ff&&ff==2&&(s.y==C-1||map2[s.x][s.y]==1))
+        break;
+    }
+    if(s.f==0)
+    {
+        if(s.y>0&&map2[s.x][s.y-1]==0)
+        {
+            s.y--;
+            s.f=1;
+        }
+        else if(s.x+1<R&&map1[s.x][s.y]==0)
+        {
+            s.x++;
+            s.f=0;
+        }
+        else if(s.y+1<C&&map2[s.x][s.y]==0)
+        {
+            s.y++;
+            s.f=3;
+        }
+        else if(s.x>0&&map1[s.x-1][s.y]==0)
+        {
+            s.x--;
+            s.f=2;
+        }
+    }
+    else if(s.f==1)
+    {
+         if(s.x>0&&map1[s.x-1][s.y]==0)
+        {
+            s.x--;
+            s.f=2;
+        }
+        else if(s.y>0&&map2[s.x][s.y-1]==0)
+        {
+            s.y--;
+            s.f=1;
+        }
+        else if(s.x+1<R&&map1[s.x][s.y]==0)
+        {
+            s.x++;
+            s.f=0;
+        }
+        else if(s.y+1<C&&map2[s.x][s.y]==0)
+        {
+            s.y++;
+            s.f=3;
+        }
+    }
+    else if(s.f==2)
+    {
+         if(s.y+1<C&&map2[s.x][s.y]==0)
+        {
+            s.y++;
+            s.f=3;
+        }
+        else  if(s.x>0&&map1[s.x-1][s.y]==0)
+        {
+            s.x--;
+            s.f=2;
+        }
+        else if(s.y>0&&map2[s.x][s.y-1]==0)
+        {
+            s.y--;
+            s.f=1;
+        }
+        else if(s.x+1<R&&map1[s.x][s.y]==0)
+        {
+            s.x++;
+            s.f=0;
+        }
+    }
+    else if(s.f==3)
+    {
+         if(s.x+1<R&&map1[s.x][s.y]==0)
+        {
+            s.x++;
+            s.f=0;
+        }
+         else if(s.y+1<C&&map2[s.x][s.y]==0)
+        {
+            s.y++;
+            s.f=3;
+        }
+        else  if(s.x>0&&map1[s.x-1][s.y]==0)
+        {
+            s.x--;
+            s.f=2;
+        }
+        else if(s.y>0&&map2[s.x][s.y-1]==0)
+        {
+            s.y--;
+            s.f=1;
+        }
+    }
+    }
+}
+void solve()
+{
+    Point s=Point(0,ER,0);    
+    Point ss=Point(R-1,EC,2);
+    dfs(s,ss);
+    dfs(ss,s);
+    if(num==R*C) puts("YES");
+    else puts("NO");
+}
+int main()
+{
+    int Case;
+    scanf("%d",&Case);
+    while(Case--)
+    {
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3913_autoAC.cpp b/HDOJ/3913_autoAC.cpp
new file mode 100644
index 0000000..56ffeac
--- /dev/null
+++ b/HDOJ/3913_autoAC.cpp
@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define MAXV 500
+#define MAXE 1000
+#define INF 0x7fffffff
+int list[MAXV];
+char s[MAXV];
+int f[MAXV + 1][26];
+bool equal[MAXV];
+int n;
+struct Edge {
+    int ed, next;
+} edge[MAXE];
+int head[MAXV], nEdge;
+void init() {
+    memset(head, 0xff, sizeof(head));
+    nEdge = 0;
+}
+void addEdge(const int a, const int b) {
+    edge[nEdge].ed = b;
+    edge[nEdge].next = head[a];
+    head[a] = nEdge++;
+}
+bool find(int cur, int tar){
+    int i, p;
+    if (cur >= n) return false;
+    if (tar >= n) return true;
+    for (i = head[cur]; ~i; i = edge[cur].next){
+        p = edge[i].ed;
+        if (p == tar) return true;
+        return find(p, tar);
+    }
+    return false;
+}
+int imin(int a, int b){
+    return a < b ? a : b;
+}
+void calc(){
+    int i, j, k;
+    for (i = 0; i < n - 1; i++){
+        equal[i] = find(list[i + 1] + 1, list[i] + 1);
+    }
+    equal[i] = true;
+    for (i = n - 1; i >= 0; i--){
+        for (j = 0; j < 26; j++){
+            f[i][j] = n + 1;
+            for (k = j + 1 - equal[i]; k < 26; k++){
+                f[i][j] = imin(f[i + 1][k], f[i][j]);
+            }
+            if (s[list[i]] != j + 'a') f[i][j]++;
+        }
+    }
+    j = n + 1;
+    for (i = 0; i < 26; i++)
+        j = imin(j, f[0][i]);
+    if (j > n) j = -1;
+    printf("%d\n", j);
+}
+int main(){
+    int i;
+    while(scanf("%d", &n) != EOF){
+        scanf("%s", s);
+        init();
+        memset(f, 0, sizeof(f));
+        memset(equal, 0, sizeof(equal));
+        for (i = 0; i < n; i++) scanf("%d", &list[i]);
+        for (i = 0; i < n - 1; i++){
+            addEdge(list[i + 1], list[i]);
+        }
+        calc();
+    }
+    return 0;
+}
diff --git a/HDOJ/3915_autoAC.cpp b/HDOJ/3915_autoAC.cpp
new file mode 100644
index 0000000..2422c1a
--- /dev/null
+++ b/HDOJ/3915_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<cstdio>
+#include<algorithm>
+#define MAXN 110
+#define MOD 1000007
+using namespace std;
+int a[MAXN], g[MAXN][MAXN];
+int Gauss(int n) {
+    int i, j, r, c, cnt;
+    for (c = cnt = 0; c < n; c++) {
+        for (r = cnt; r < 31; r++) {
+            if (g[r][c])
+                break;
+        }
+        if (r < 31) {
+            if (r != cnt) {
+                for (i = 0; i < n; i++)
+                    swap(g[r][i], g[cnt][i]);
+            }
+            for (i = cnt + 1; i < 31; i++) {
+                if (g[i][c]) {
+                    for (j = 0; j < n; j++)
+                        g[i][j] ^= g[cnt][j];
+                }
+            }
+            cnt++;
+        }
+    }
+    return n - cnt;
+}
+int main() {
+    int c;
+    int n, i, j;
+    int ans, vary;
+    scanf("%d", &c);
+    while (c--) {
+        scanf("%d", &n);
+        for (i = 0; i < n; i++)
+            scanf("%d", &a[i]);
+        for (i = 0; i < 31; i++) {
+            for (j = 0; j < n; j++)
+                g[i][j] = (a[j] >> i) & 1;
+        }
+        vary = Gauss(n);
+        for (ans = 1; vary--;) {
+            ans <<= 1;
+            ans %= MOD;
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3916_autoAC.cpp b/HDOJ/3916_autoAC.cpp
new file mode 100644
index 0000000..0c7c8f6
--- /dev/null
+++ b/HDOJ/3916_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<stdio.h>
+#include<string.h>
+#define MAXN 10010
+#define INF 0x3fffffff
+int v[MAXN],cur[MAXN];     
+int min(int x,int y)
+{
+    return x<y?x:y;
+}
+int main()
+{
+    int n,t,ans;
+    int i,j,s,sub;                
+    for(scanf("%d",&t);t;t--)
+    {
+        scanf("%d",&n);
+        if(!n)
+        {
+            puts("0");
+            continue;
+        }
+        for(i=1;i<=n;i++)
+            scanf("%d",v+i);
+        memset(cur,0,sizeof(cur));
+        v[n+1]=-INF;
+        for(i=1;v[i]==0;i++);         
+        j=i;
+        s=0;
+        ans=INF;
+        while(i<=n)
+        {
+            if(i>j)
+            {
+                s=0;
+                j=i;
+            }
+            while(j<=n && v[j]-cur[j]<=v[j+1])    
+                j++;
+            if(ans>j-i+1)
+                ans=j-i+1;                       
+            sub=v[j]-cur[j]-v[j+1];
+            cur[j]+=min(sub,v[i]-s);        
+            s+=min(sub,v[i]-s);
+            while(!(v[i]-s))            
+            {
+                s-=cur[i];               
+                i++;
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3917_autoAC.cpp b/HDOJ/3917_autoAC.cpp
new file mode 100644
index 0000000..0d4a6f4
--- /dev/null
+++ b/HDOJ/3917_autoAC.cpp
@@ -0,0 +1,116 @@
+#include<iostream>
+#include<algorithm>
+#include<cstdio>
+#include<cstring>
+#include<memory.h>
+using namespace std;
+const int M=10002;
+const int INF=(1e9)-1;
+int t,n,m,tot;
+int gap[M],dis[M],pre[M],head[M],cur[M],s[M];
+int NE,NV,sink,a[M],b[M],c[M],d[M];
+struct Node
+{
+    int c,pos,next;
+} E[M*4];
+#define FF(i,NV) for(int i=0;i<NV;i++)
+int sap(int s,int t)
+{
+    memset(dis,0,sizeof(int)*(NV+1));
+    memset(gap,0,sizeof(int)*(NV+1));
+    FF(i,NV) cur[i] = head[i];
+    int u = pre[s] = s,maxflow = 0,aug =INF;
+    gap[0] = NV;
+    while(dis[s] < NV)
+    {
+loop:
+        for(int &i = cur[u]; i != -1; i = E[i].next)
+        {
+            int v = E[i].pos;
+            if(E[i].c && dis[u] == dis[v] + 1)
+            {
+                aug=min(aug,E[i].c);
+                pre[v] = u;
+                u = v;
+                if(v == t)
+                {
+                    maxflow += aug;
+                    for(u = pre[u]; v != s; v = u,u = pre[u])
+                    {
+                        E[cur[u]].c -= aug;
+                        E[cur[u]^1].c += aug;
+                    }
+                    aug =INF;
+                }
+                goto loop;
+            }
+        }
+        if( (--gap[dis[u]]) == 0)   break;
+        int mindis = NV;
+        for(int i = head[u]; i != -1 ; i = E[i].next)
+        {
+            int v = E[i].pos;
+            if(E[i].c && mindis > dis[v])
+            {
+                cur[u] = i;
+                mindis = dis[v];
+            }
+        }
+        gap[ dis[u] = mindis+1 ] ++;
+        u = pre[u];
+    }
+    return maxflow;
+}
+void addEdge(int u,int v,int c )
+{
+    E[NE].c = c;
+    E[NE].pos = v;
+    E[NE].next = head[u];
+    head[u] = NE++;
+    E[NE].c = 0;
+    E[NE].pos = u;
+    E[NE].next = head[v];
+    head[v] = NE++;
+}
+int main()
+{
+    int n, m,sum, source, sink, vn,k;
+    while(scanf("%d %d", &n, &m),(n||m))
+    {
+        NE=0,tot=0;
+        sum = 0;
+        source = 0;
+        sink=m+1;
+        NV=sink+1;
+        memset(head, -1, sizeof(head));
+        memset(s,0,sizeof(s));
+        for(int i=1;i<=m;i++)
+        {
+            scanf("%d",&vn);
+            addEdge(source,i,vn);
+            sum+=vn;
+        }
+        scanf("%d",&k);
+        for(int i=1;i<=k;i++)
+        {
+            scanf("%d%d%d%d",&a[i],&b[i],&d[i],&c[i]);
+            s[d[i]]+=c[i];
+        }
+        for(int i=1;i<=k;i++)
+        {
+            for(int j=1;j<=k;j++)
+            {
+                if(i!=j&&b[i]==a[j]&&d[i]!=d[j])
+                {
+                    addEdge(d[i],d[j],INF);
+                }
+            }
+        }
+        for(int i=1;i<=m;i++)
+        {
+            addEdge(i,sink,s[i]);
+        }
+        printf("%d\n",sum-sap(source,sink));
+    }
+    return 0;
+}
diff --git a/HDOJ/3918_autoAC.cpp b/HDOJ/3918_autoAC.cpp
new file mode 100644
index 0000000..2fd44f5
--- /dev/null
+++ b/HDOJ/3918_autoAC.cpp
@@ -0,0 +1,215 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <memory.h>
+#include <cmath>
+#define MAXN 300
+#define eps 1e-5
+#define max(a,b) (a>b?a:b)
+#define min(a,b) (a<b?a:b)
+using namespace std;
+struct point {double x,y;};  
+struct point pnt[MAXN],ll[MAXN],rr[MAXN],center;   
+int N,M,l_pos,r_pos;  
+double ans,H;
+bool ne;  
+point bcenter(point pnt[], int n)
+{   
+    point p, s;   
+    if(n==1) 
+        return pnt[0];
+    if(n==2)
+    {
+        s.x=(pnt[0].x+pnt[1].x)/2;
+        s.y=(pnt[0].y+pnt[1].y)/2;
+        return s;
+    }
+    double tp, area = 0, tpx = 0, tpy = 0;   
+    p.x = pnt[0].x; p.y = pnt[0].y;   
+    for (int i = 1; i <= n; ++i) 
+    {   // point: 0 ~ n-1   
+        s.x = pnt[(i == n) ? 0 : i].x;   
+        s.y = pnt[(i == n) ? 0 : i].y;   
+        tp = (p.x * s.y - s.x * p.y); area += tp / 2;   
+        tpx += (p.x + s.x) * tp; tpy += (p.y + s.y) * tp;   
+        p.x = s.x; p.y = s.y;   
+    }   
+    s.x = tpx / (6 * area); s.y = tpy / (6 * area);   
+    return s;   
+}  
+void Print()
+{
+    int i;
+    printf("-------------------------------------\n");
+    for(i=0;i<M;i++)
+        printf("%.2lf %.2lf\n",ll[i].x,ll[i].y);
+    for(i=0;i<N;i++)
+        printf("%.2lf %.2lf\n",rr[i].x,rr[i].y);
+    printf("-------------------------------------\n");
+}
+point get_point(point c,point a,point b)
+{
+    point res;
+    double dx,dy;
+    dx=fabs(a.x-b.x);
+    dy=b.y-a.y;
+    res.y=c.y;
+    if(fabs(a.x-b.x)<=eps)
+        res.x=a.x;
+    else
+    {
+        if(a.x<b.x)
+            res.x=dx*(c.y-a.y)*1.0/dy+a.x;
+        else
+            res.x=a.x-dx*(c.y-a.y)*1.0/dy;
+    }
+    return res;
+}
+void ini()
+{
+    M=N=0;
+    l_pos=r_pos=0;
+    ans=H=0;
+    memset(pnt,0,sizeof(pnt));
+    memset(ll,0,sizeof(ll));
+    memset(rr,0,sizeof(rr));
+}
+void Init()
+{
+    int i;
+    ini();
+    scanf("%d%d",&M,&N);
+    for(i=0;i<M;i++)
+        scanf("%lf%lf",&ll[i].x,&ll[i].y);
+    for(i=0;i<N;i++)
+        scanf("%lf%lf",&rr[i].x,&rr[i].y);
+}
+bool Judge(point o)
+{
+    if((o.x-ll[0].x>=eps)&&(rr[0].x-o.x>=eps))
+        return true;
+    return false;
+}
+bool fuck(double mid,int l_pos,int r_pos)
+{
+    int i;
+    point temp,now1,now2;
+    temp.x=1;temp.y=mid;
+    int cnt=0;
+    if(fabs(ll[l_pos].y-rr[r_pos].y)<=eps)
+    {
+        for(i=l_pos;i>=0;i--)
+            pnt[cnt++]=ll[i];
+        for(i=0;i<=r_pos;i++)
+            pnt[cnt++]=rr[i];
+    }
+    else if(ll[l_pos].y<rr[r_pos].y)
+    {
+        now1=get_point(temp,ll[l_pos],ll[l_pos+1]);
+        now2=get_point(temp,rr[r_pos-1],rr[r_pos]);
+        pnt[cnt++]=now1;
+        for(i=l_pos;i>=0;i--)
+            pnt[cnt++]=ll[i];
+        for(i=0;i<r_pos;i++)
+            pnt[cnt++]=rr[i];
+        pnt[cnt++]=now2;
+    }
+    else
+    {
+        now1=get_point(temp,ll[l_pos-1],ll[l_pos]);
+        now2=get_point(temp,rr[r_pos],rr[r_pos+1]);
+        pnt[cnt++]=now1;
+        for(i=l_pos-1;i>=0;i--)
+            pnt[cnt++]=ll[i];
+        for(i=0;i<=r_pos;i++)
+            pnt[cnt++]=rr[i];
+        pnt[cnt++]=now2;
+    }
+    center=bcenter(pnt,cnt);
+    return Judge(center);
+}
+void Solve()
+{
+    ans=ll[0].y;;
+    double l,r,mid;
+    int i,cnt;
+    point now;
+    l_pos=r_pos=1;
+    while(true)
+    {
+        cnt=0;
+        if(l_pos==M||r_pos==N) break;
+        if(ll[l_pos].y<=rr[r_pos].y)
+        {
+            for(i=l_pos;i>=0;i--)
+                pnt[cnt++]=ll[i];
+            for(i=0;i<r_pos;i++)
+                pnt[cnt++]=rr[i];
+            now=get_point(ll[l_pos],rr[r_pos-1],rr[r_pos]);
+            pnt[cnt++]=now;
+            center=bcenter(pnt,cnt);
+            ne=Judge(center);
+            if(!ne)
+            {
+                l=max(rr[r_pos-1].y,ll[l_pos-1].y);r=ll[l_pos].y;
+                while(fabs(l-r)>eps)
+                {
+                    mid=(l+r)/2.0;
+                    if(fuck(mid,l_pos,r_pos-1))
+                        l=mid;
+                    else
+                        r=mid;
+                }
+                ans=max(ans,l);
+                break;
+            }
+            else
+            {
+                ans=max(ans,ll[l_pos].y);
+                l_pos++;
+            }
+        }
+        else
+        {
+            now=get_point(rr[r_pos],ll[l_pos-1],ll[l_pos]);
+            pnt[cnt++]=now;
+            for(i=l_pos-1;i>=0;i--)
+                pnt[cnt++]=ll[i];
+            for(i=0;i<=r_pos;i++)
+                pnt[cnt++]=rr[i];
+            center=bcenter(pnt,cnt);
+            ne=Judge(center);
+            if(!ne)
+            {
+                l=max(ll[l_pos-1].y,rr[r_pos-1].y);r=rr[r_pos].y;
+                while(fabs(l-r)>eps)
+                {
+                    mid=(l+r)/2.0;
+                    if(fuck(mid,l_pos-1,r_pos))
+                        l=mid;
+                    else
+                        r=mid;
+                }
+                ans=max(ans,l);
+                break;
+            }
+            else
+            {
+                ans=max(ans,rr[r_pos].y);
+                r_pos++;
+            }
+        }
+    }
+    printf("%.3lf\n",ans);
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        Init();
+        Solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3920_autoAC.cpp b/HDOJ/3920_autoAC.cpp
new file mode 100644
index 0000000..293e5be
--- /dev/null
+++ b/HDOJ/3920_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<cmath>
+#include<iostream>
+using namespace std;
+double dis[21][21],dp[1<<21];
+int n,fx,fy,mac;
+struct node
+{
+    int x,y;
+}nd[21];
+double DIS(double x,double y,double xx,double yy)
+{
+    return sqrt((x-xx)*(x-xx)+(y-yy)*(y-yy));
+}
+bool cmp(node a,node b)
+{
+    return DIS(a.x,a.y,fx,fy)<DIS(b.x,b.y,fx,fy);
+}
+double DP(int sta)
+{
+    if(dp[sta]!=0x7fffffff)
+        return dp[sta];
+    if(sta==0) {dp[0]=0.0;}
+    else
+    {
+        int tem=sta,i=0;
+        for(i=0;i<20;i++)
+        {
+            if((1<<i)&sta)break;
+        }
+        for(int j=i+1;j<2*n;j++)
+        {
+            if((sta&(1<<j))==0)continue;
+            dp[sta]=min(DP(sta-(1<<j)-(1<<i))+dis[i][j],dp[sta]);
+        }
+    }
+    return dp[sta];
+}
+int main()
+{
+    int c,ca=0;
+    scanf("%d",&c);
+    while(c--)
+    {
+        ca++;
+        scanf("%d%d",&fx,&fy);
+        scanf("%d",&n);
+        for(int i=0;i<2*n;i++)
+        {
+            scanf("%d%d",&nd[i].x,&nd[i].y);
+        }
+        sort(nd,nd+2*n,cmp);
+        for(int i=0;i<2*n;i++)
+            for(int j=i+1;j<2*n;j++)
+            {
+                dis[i][j]=DIS(nd[i].x,nd[i].y,fx,fy)+DIS(nd[i].x*1.0,nd[i].y*1.0,nd[j].x*1.0,nd[j].y*1.0);
+            }
+            printf("Case #%d: ",ca);
+            for(int i=0;i<(1<<2*n);i++)
+                dp[i]=0x7fffffff;
+            printf("%.2f\n",DP((1<<(2*n))-1));
+    }
+}
diff --git a/HDOJ/3921_autoAC.cpp b/HDOJ/3921_autoAC.cpp
new file mode 100644
index 0000000..21769a2
--- /dev/null
+++ b/HDOJ/3921_autoAC.cpp
@@ -0,0 +1,155 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <algorithm>
+using namespace std;
+struct Point
+{
+    double x, y;
+} node[201];
+struct T_T
+{
+    int id;
+    double dis;
+} que[201];
+double sx, sy;
+double ans;
+double dis[201];
+double map[201][201];
+int q[201][201], q2[201][201];
+int n;
+int m;
+bool vis[201];
+int ra, rb, rc, rd;
+double rmin;
+double rdis;
+double dist(int i, int j)
+{
+    return sqrt((node[i].x - node[j].x) * (node[i].x - node[j].x)
+                + (node[i].y - node[j].y) * (node[i].y - node[j].y));
+}
+bool cmp(T_ a, T_ b)
+{
+    return a.dis < b.dis;
+}
+void init()
+{
+    for(int i = 0; i < m; i++)  dis[i] = dist(i, m);
+    for(int i = 0; i < m; i++)
+        for(int j = i + 1; j < m; j++)
+            map[i][j] = map[j][i] = dist(i, j);
+    for(int i = 0; i < m; i++)
+    {
+        int temp = 0;
+        for(int j = 0; j < m; j++)
+            if(i != j)
+            {
+                que[temp].id = j;
+                que[temp].dis = dis[j] + map[j][i];
+                temp++;
+            }
+        sort(que, que + temp, cmp);
+        for(int j = 0; j < temp; j++)
+            q[i][j] = que[j].id;
+    }
+    for(int i = 0; i < m; i++)
+    {
+        int temp = 0;
+        for(int j = 0; j < m; j++)
+            if(i != j)
+            {
+                que[temp].id = j;
+                que[temp].dis = map[i][j];
+                temp++;
+            }
+        sort(que, que + temp, cmp);
+        for(int j = 0; j < temp; j++)
+            q2[i][j] = que[j].id;
+    }
+}
+void solve()
+{
+    rmin = -1;
+    int a, b, c, d;
+    for(b = 0; b < m; b++)
+        if(!vis[b])
+        {
+            for(c = 0; c < m; c++)
+                if(!vis[c] && b != c)
+                {
+                    int t = 0;
+                    a = q[b][t];
+                    while(vis[a] || a == c)
+                    {
+                        t++;
+                        a = q[b][t];
+                    }
+                    t = 0;
+                    d = q2[c][t];
+                    while(vis[d] || d == a || d == b)
+                    {
+                        t++;
+                        d = q2[c][t];
+                    }
+                    double cou = dis[a] + map[a][b] + map[b][c] + map[c][d];
+                    double cdis = (dis[a] + dis[b] + dis[c] + dis[d]) / 4.0;
+                    if(rmin < 0 || cou < rmin || (rmin == cou && cdis < rdis))
+                    {
+                        rmin = cou;
+                        rdis = cdis;
+                        ra = a, rb = b, rc = c, rd = d;
+                    }
+                    t = 0;
+                    d = q2[c][t];
+                    while(vis[d] || d == b)
+                    {
+                        t++;
+                        d = q2[c][t];
+                    }
+                    t = 0;
+                    a = q[b][t];
+                    while(vis[a] || a == c || a == d)
+                    {
+                        t++;
+                        a = q[b][t];
+                    }
+                    cou = dis[a] + map[a][b] + map[b][c] + map[c][d];
+                    cdis = (dis[a] + dis[b] + dis[c] + dis[d]) / 4.0;
+                    if(rmin < 0 || cou < rmin || (rmin == cou && cdis < rdis))
+                    {
+                        rmin = cou;
+                        rdis = cdis;
+                        ra = a, rb = b, rc = c, rd = d;
+                    }
+                }
+        }
+    vis[ra] = 1;
+    vis[rb] = 1;
+    vis[rc] = 1;
+    vis[rd] = 1;
+    ans += rmin;
+}
+int main()
+{
+    int T;
+    int cas = 1;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%lf%lf", &sx, &sy);
+        scanf("%d", &n);
+        m = 4 * n;
+        for(int i = 0; i < m; i++)  scanf("%lf%lf", &node[i].x, &node[i].y);
+        node[m].x = sx;
+        node[m].y = sy;
+        init();
+        ans = 0;
+        memset(vis, 0, sizeof(vis));
+        for(int i = 0; i < n; i++)
+        {
+        solve();
+        }
+        printf("Case #%d: %0.2lf\n", cas++, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3923_autoAC.cpp b/HDOJ/3923_autoAC.cpp
new file mode 100644
index 0000000..bd309b1
--- /dev/null
+++ b/HDOJ/3923_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <iostream>
+#include <cstdio>
+#include <string.h>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+using namespace std;
+const int mod=1000000007;
+__int64 n,c;
+__int64 fun(__int64 a,__int64 b)
+{
+    __int64 t=1,y=a;
+    for(int i=1;i<=b;i*=2)
+    {
+        if(b&i)
+          t=t*y%mod;
+        y=y*y%mod;
+    }
+    return t;
+}
+__int64 euler(__int64 a)
+{
+    __int64 ans=a;
+    for(int i=2;i<=a;i++)
+    {
+        if(a%i==0)
+            ans-=ans/i;
+        while(a%i==0)
+            a/=i;
+    }
+    if(a>1)
+        ans-=ans/a;
+    return ans;
+}
+__int64 Extend_euclid(__int64 a,__int64 b,__int64 &x,__int64 &y)
+{
+    __int64 d=0,t=0;
+    if(b==0)
+    {
+        x=1;
+        y=0;
+        return a;
+    }
+    else
+    {
+        d=Extend_euclid(b,a%b,x,y);
+        t=x;
+        x=y;
+        y=t-a/b*y;
+    }
+    return d;
+}
+__int64 Bignum_Div(__int64 a,__int64 b)
+{
+    __int64 x=0,y=0;
+    Extend_euclid(b,mod,x,y);
+    __int64 ans= a*x%mod;
+    while(ans<0)
+        ans+=mod;
+    return ans;
+}
+int main()
+{
+    __int64 ans=0,t=1,T=0;
+    scanf("%I64d",&T);
+    while(T--)
+    {
+        scanf("%I64d %I64d",&c,&n);
+        ans=0;
+        for(int i=1;i<=n;i++)
+        {
+            if(n%i==0)
+            {
+                ans+=fun(c,i)*euler(n/i);
+                ans%=mod;
+            }
+        }
+        if(n&1)
+        {
+            ans+=n*fun(c,n/2+1);
+            ans%=mod;
+        }
+        else
+        {
+            ans+=n/2*( fun(c,n/2)+fun(c,n/2+1));
+            ans%=mod;
+        }
+        ans=Bignum_Div(ans,2*n);
+        printf("Case #%I64d: %I64d\n",t++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3924_autoAC.cpp b/HDOJ/3924_autoAC.cpp
new file mode 100644
index 0000000..ebf4b53
--- /dev/null
+++ b/HDOJ/3924_autoAC.cpp
@@ -0,0 +1,100 @@
+#include<iostream>
+#include<algorithm>
+#include<cstring>
+#include<cstdio>
+using namespace std;
+typedef __int64 LL;
+const int MAX=30;
+const int LIM=21;
+LL num[MAX],rig[MAX],total[MAX];
+int b[4];
+LL gs(int L)
+{
+    LL res=0;
+    for(int i=0;i<=L;i++)
+    {
+        for(int j=i;j<=L;j++)
+        {
+            int k=L-i-j;
+            if(j>k) continue;
+            b[0]=i;
+            b[1]=j;
+            b[2]=k;
+            do
+            {
+                res+=num[b[0]]*num[b[1]]*num[b[2]];
+            }while(next_permutation(b,b+3));
+        }
+    }
+    return res;
+}
+LL getR(int L)
+{
+    LL res=0;
+    for(int i=0;i<=L;i++)
+    {
+        res+=num[i]*num[L-i];
+    }
+    return res;
+}
+void init()
+{
+    num[0]=num[1]=1;
+    for(int i=2;i<=LIM;i++) num[i]=gs(i-1);
+    total[0]=0;
+    for(int i=1;i<=LIM;i++) total[i]=total[i-1]+num[i];
+    rig[0]=1;
+    for(int i=1;i<=LIM;i++) rig[i]=getR(i);
+}
+int getNN(LL N)
+{
+    for(int i=1;i<=LIM;i++) if(total[i]>=N) return i;
+}
+void dfs(int L,LL N)
+{
+    if(L==1) {printf("X");return ;}
+    int x=L-1;
+    int ll,mm,rr;
+    for(ll=0;N>num[ll]*rig[x-ll];ll++) N-=num[ll]*rig[x-ll];
+    if(ll)
+    {
+        printf("(");
+        dfs(ll,(N-1)/rig[x-ll]+1);
+        printf(")");
+    }
+    N%=rig[x-ll];
+    if(N==0) N=rig[x-ll];
+    x-=ll;
+    for(mm=0;N>num[mm]*num[x-mm];mm++) N-=num[mm]*num[x-mm];
+    if(mm)
+    {
+        printf("(");
+        dfs(mm,(N-1)/num[x-mm]+1);
+        printf(")");
+    }
+    N%=num[x-mm];
+    if(N==0) N=num[x-mm];
+    x-=mm;
+    if(x)
+    {
+        printf("(");
+        dfs(x,N);
+        printf(")");
+    }
+    printf("X");
+}
+int main()
+{
+    init();
+    int T;scanf("%d",&T);
+    int CN=0;
+    while(T--)
+    {
+        LL N;scanf("%I64d",&N);
+        int nn=getNN(N);
+        printf("Case #%d: ",++CN);
+        dfs(nn,N-total[nn-1]);
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/3925_autoAC.cpp b/HDOJ/3925_autoAC.cpp
new file mode 100644
index 0000000..96e49e6
--- /dev/null
+++ b/HDOJ/3925_autoAC.cpp
@@ -0,0 +1,103 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int maxn = 100 + 10;
+bool cmp(char *s, int high, int low, char *sub)
+{
+ int j = 0;
+ for(int i = high; i <= low; i++) if(s[i] != sub[j++]) return 0;
+ return 1;
+}
+int cmpp(char *a, char *b) 
+{
+ int len_a = strlen(a), len_b = strlen(b), len = min(len_a, len_b), i;
+ if(len_a != len_b) 
+ {
+ if(len_a > len_b) return 1;
+ else return -1;
+ }
+ else 
+ {
+ for(i = 0; i < len; i++)
+ {
+ if(a[i] > b[i]) return 1; 
+ if(a[i] < b[i]) return -1; 
+ }
+ return 0; 
+ }
+}
+int to_int(char *s, int high, int low) 
+{
+ int ret = 0;
+ for(int i = high; i <= low; i++) ret = ret*10 + s[i]-'0';
+ return ret;
+}
+int main()
+{
+ int i, j, k, u, v, cnt = 1, T;
+ char a[maxn], b[maxn], B[maxn], c[maxn], minn[maxn];
+ scanf("%d", &T);
+ while(T--)
+ {
+ scanf("%s%s", a, b);
+ int len_a = strlen(a), len_b = strlen(b);
+ for(i = 0; i < maxn; i++) minn[i] = '9'; 
+ for(i = len_b; i < maxn; i++) b[i] = '0'; b[maxn-1] = 0; 
+ int bb = to_int(b, 0, len_b-1); 
+ if(len_a < len_b) 
+ {
+ int aa = to_int(a, 0, len_a-1);
+ printf("Case #%d: %d\n", cnt++, bb-aa);
+ continue;
+ }
+ bool ok = 0; 
+ for(i = len_a-len_b; i >= 0; i--) 
+ {
+ int aa = to_int(a, i, i+len_b-1);
+ if(aa == bb) 
+ {
+ ok = 1;
+ break;
+ }
+ else 
+ {
+ for(u = 0; u < maxn; u++) B[u] = b[u]; 
+ for(j = len_a-1, k = len_a-1-i; j >= i; j--, k--)
+ {
+ if(B[k] >= a[j]) c[k] = B[k] - a[j] + '0';
+ else 
+ {
+ if(k-1 >= 0) B[k-1]--;
+ c[k] = B[k] + 10 - a[j] + '0';
+ }
+ }
+ c[len_a-i] = 0; 
+ for(v = 0; v < len_a-i; v++) if(c[v] != '0') break; 
+ if(v != 0) for(u = 0; v <= len_a-i; u++,v++) c[u] = c[v];
+ if(cmpp(c, minn) < 0) for(u = 0; u <= len_a-i; u++) minn[u] = c[u]; 
+ }
+ }
+ if(ok) printf("Case #%d: %d\n", cnt++, 0);
+ else 
+ {
+ for(u = 0; u < maxn; u++) B[u] = b[u]; 
+ for(j = len_a-1, k = len_a; j >= 0; j--, k--)
+ {
+ if(B[k] >= a[j]) c[k] = B[k] - a[j] + '0';
+ else 
+ {
+ B[k-1]--;
+ c[k] = B[k] + 10 - a[j] + '0';
+ }
+ }
+ c[0] = B[0]; 
+ c[len_a+1] = 0; 
+ for(v = 0; v < len_a+1; v++) if(c[v] != '0') break; 
+ if(v != 0) for(u = 0; v <= len_a+1; u++,v++) c[u] = c[v];
+ if(cmpp(c, minn) == -1) for(u = 0; u <= len_a+1; u++) minn[u] = c[u]; 
+ printf("Case #%d: %s\n", cnt++, minn);
+ }
+ }
+ return 0;
+}
diff --git a/HDOJ/3926_autoAC.cpp b/HDOJ/3926_autoAC.cpp
new file mode 100644
index 0000000..1d31479
--- /dev/null
+++ b/HDOJ/3926_autoAC.cpp
@@ -0,0 +1,109 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<climits>
+#include<algorithm>
+using namespace std;
+#define MAXN 10010
+int pre1[MAXN], pre2[MAXN]; 
+int num1, num2;
+struct graph 
+{
+    int son;
+    bool ring;
+};
+graph g1[MAXN], g2[MAXN];
+bool cmb(const graph &g1, const graph &g2) 
+{
+    if(g1.son < g2.son)
+        return true;
+    else if(g1.son == g2.son && g1.ring < g2.ring)
+        return true;
+    else
+        return false;
+}
+int find(int x, int pre[]) 
+{
+    return x == pre[x] ? x : find(pre[x], pre);
+}
+void join(int x, int y, int pre[],graph g1[]) 
+{
+    int root1, root2;
+    root1 = find(x, pre);
+    root2 = find(y, pre);
+    if(root1 == root2)
+        g1[root1].ring = true; 
+    else
+    {
+        if(g1[root1].son >= g1[root2].son)
+        {
+            pre[root2] = root1;
+            g1[root1].son += g1[root2].son;
+        }
+        else
+        {
+            pre[root1] = root2;
+            g1[root2].son += g1[root1].son;
+        }
+    }
+}
+bool cmp(int num, graph g1[], graph g2[]) 
+{
+    sort(g1 + 1, g1 + num + 1, cmb); 
+    sort(g2 + 1, g2 + num + 1, cmb);
+    for(int i = 1; i <= num; ++i)
+        if(g1[i].son != g2[i].son || (g1[i].son == g2[i].son && g1[i].ring != g2[i].ring))
+            return false;
+    return true;
+}
+int main()
+{
+    int ncase, T = 0;
+    int link1, link2;
+    int hand1, hand2;
+    int ans1, ans2;
+    bool flag;
+    scanf("%d", &ncase);
+    while(ncase--)
+    {
+        flag = true;
+        scanf("%d%d", &num1, &link1);
+        for(int i = 1; i < MAXN; ++i)
+        {
+            pre1[i] = i;
+            pre2[i] = i;
+            g1[i].son = 1;
+            g2[i].son = 1;
+            g1[i].ring = false;
+            g2[i].ring = false;
+        }
+        for(int i = 1; i <= link1; ++i)
+        {
+            scanf("%d%d", &hand1, &hand2);
+            join(hand1, hand2, pre1, g1);
+        }
+        scanf("%d%d", &num2, &link2);
+        if(link2 != link1) 
+            flag = false;
+        for(int i = 1; i <= link2; ++i)
+        {
+            scanf("%d%d", &hand1, &hand2);
+            if(flag == false)
+                continue;
+            else
+                join(hand1, hand2, pre2, g2);
+        }
+        flag = cmp(num2, g1, g2);
+        if(flag == false)
+            printf("Case #%d: NO\n", ++T);
+        else
+        {
+            if(flag)
+                printf("Case #%d: YES\n", ++T);
+            else
+                printf("Case #%d: NO\n", ++T);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3927_autoAC.cpp b/HDOJ/3927_autoAC.cpp
new file mode 100644
index 0000000..d6cb2b3
--- /dev/null
+++ b/HDOJ/3927_autoAC.cpp
@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <memory.h>
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+#include <queue>
+#include <algorithm>
+#include <iostream>
+#define ll long long
+using namespace std;
+const int N = 200;
+int mtx[N][N], n;
+int row[N], col[N], dia[2];
+map<int, int> M;
+int cunt;
+void Change(int r1, int c1, int r2, int c2) {
+    int d = mtx[r1][c1] - mtx[r2][c2];
+    if (d == 0) return;
+    int res = 0;
+    if ((M[row[r1]]--) == 1) res--;
+    if ((M[col[c1]]--) == 1) res--;
+    if ((M[row[r2]]--) == 1) res--;
+    if ((M[col[c2]]--) == 1) res--;
+    if (r1 == c1 && (M[dia[0]]--) == 1) res--;
+    if (r1 == n - c1 - 1 && (M[dia[1]]--) == 1) res--;
+    if (r2 == c2 && (M[dia[0]]--) == 1) res--;
+    if (r2 == n - c2 - 1 && (M[dia[1]]--) == 1) res--;
+    swap(mtx[r1][c1], mtx[r2][c2]);
+    row[r1] -= d; col[c1] -= d; row[r2] += d; col[c2] += d;
+    if (r1 == c1) dia[0] -= d;
+    if (r1 == n - c1 - 1) dia[1] -= d;
+    if (r2 == c2) dia[0] += d;
+    if (r2 == n - c2 - 1) dia[1] += d;
+    if ((M[row[r1]]++) == 0) res++;
+    if ((M[col[c1]]++) == 0) res++;
+    if ((M[row[r2]]++) == 0) res++;
+    if ((M[col[c2]]++) == 0) res++;
+    if (r1 == c1 && (M[dia[0]]++) == 0) res++;
+    if (r1 == n - c1 - 1 && (M[dia[1]]++) == 0) res++;
+    if (r2 == c2 && (M[dia[0]]++) == 0) res++;
+    if (r2 == n - c2 - 1 && (M[dia[1]]++) == 0) res++;
+    if (res >= 0) {
+        cunt += res;
+        return;
+    }
+    M[row[r1]]--; M[col[c1]]--; M[row[r2]]--; M[col[c2]]--;
+    if (r1 == c1) M[dia[0]]--;
+    if (r1 == n - c1 - 1) M[dia[1]]--;
+    if (r2 == c2) M[dia[0]]--;
+    if (r2 == n - c2 - 1) M[dia[1]]--;
+    swap(mtx[r1][c1], mtx[r2][c2]);
+    row[r1] += d; col[c1] += d; row[r2] -= d; col[c2] -= d;
+    if (r1 == c1) dia[0] += d;
+    if (r1 == n - c1 - 1) dia[1] += d;
+    if (r2 == c2) dia[0] -= d;
+    if (r2 == n - c2 - 1) dia[1] -= d;
+    M[row[r1]]++; M[col[c1]]++; M[row[r2]]++; M[col[c2]]++;
+    if (r1 == c1)  M[dia[0]]++;
+    if (r1 == n - c1 - 1) M[dia[1]]++;
+    if (r2 == c2) M[dia[0]]++;
+    if (r2 == n - c2 - 1) M[dia[1]]++;
+}
+int main() {
+    int T, C, m, idx, s1, s2;
+    int r1, c1, r2, c2;
+    scanf("%d", &T);
+    for (C = 1; C <= T; C++) {
+        scanf("%d", &n);
+        idx = 0;
+        for (int i = 0; i < n; i++)
+            for (int j = 0; j < n; j++)
+                mtx[i][j] = ++idx;
+        M.clear();
+        cunt = 0;
+        for (int i = 0; i < n; i++) {
+            s1 = 0, s2 = 0;
+            for (int j = 0; j < n; j++) {
+                s1 += mtx[i][j];
+                s2 += mtx[j][i];
+            }
+            row[i] = s1; col[i] = s2;
+            if ((M[s1]++) == 0) cunt++;
+            if ((M[s2]++) == 0) cunt++;
+        }
+        s1 = s2 = 0;
+        for (int i = 0; i < n; i++) {
+            s1 += mtx[i][i];
+            s2 += mtx[i][n-i-1];
+        }
+        dia[0] = s1; dia[1] = s2;
+        if ((M[s1]++) == 0) cunt++;
+        if ((M[s2]++) == 0) cunt++;
+        m = 2 * n + 2;
+        while (cunt < m) {
+            r1 = rand() % n;
+            r2 = rand() % n;
+            c1 = rand() % n;
+            c2 = rand() % n;
+            Change(r1, c1, r2, c2);
+        }
+        printf("Case #%d:\n", C);
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (j) printf(" ");
+                printf("%d", mtx[i][j]);
+            }
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3928_autoAC.cpp b/HDOJ/3928_autoAC.cpp
new file mode 100644
index 0000000..59aa198
--- /dev/null
+++ b/HDOJ/3928_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <functional>
+#define Maxn 100
+#define inf 1<<30
+using namespace std;
+int T, n, f[Maxn][Maxn], out[Maxn][Maxn];
+int le[Maxn], ri[Maxn];
+int dfs(int x, int y)
+{
+     if (f[x][y] != -1) return f[x][y];
+     if (out[x][y] == 1) return f[x][y] = 0;
+     int t1, t2, t3, tmp = inf;
+     for (int i=1; i<=n; i++)
+     {
+         t1 = t2 = t3 = -inf;
+         int x1 = x, yy1 = min(le[i]-1, y);  
+         if (yy1 == y) continue;
+         if (x1 <= yy1 && out[x1][yy1]) t1 = dfs(x1, yy1);
+         int x2 = max(le[i]+1, x), y2 = min(ri[i]-1, y);  
+         if (x2 == x && y2 == y) continue;     
+         if (x2 <= y2 && out[x2][y2]) t2 = dfs(x2, y2);
+         int x3 = max(ri[i], x), y3 = y;     
+         if (x3 == x) continue;         
+         if (x3 <= y3 && out[x3][y3]) t3 = dfs(x3, y3); 
+         tmp = min(tmp, max(t1,max(t2, t3)));         
+     }
+     return f[x][y] = tmp + 1;
+     }
+int main()
+{
+    int k;
+    scanf("%d", &T);
+    for (int t=1; t<=T; t++)
+    {
+        memset(le, -1, sizeof(le));
+        memset(f, -1, sizeof(f));
+        memset(out, 0, sizeof(out));
+        scanf("%d", &n);
+        for (int i=1; i<=2*n; i++)
+        {
+            scanf("%d", &k);  
+            if (le[k] == -1) le[k] = i;
+            else ri[k] = i; 
+        }
+        for (int i=1; i<=2*n; i++)
+          for (int j=i; j<=2*n; j++)
+            for (int p=1; p<=n; p++)
+            if (ri[p] <= j && ri[p] >= i) out[i][j]++;
+        printf("Case #%d: %d\n", t, dfs(2, 2*n));
+    }
+    return 0;
+    }
diff --git a/HDOJ/3929_autoAC.cpp b/HDOJ/3929_autoAC.cpp
new file mode 100644
index 0000000..3f933de
--- /dev/null
+++ b/HDOJ/3929_autoAC.cpp
@@ -0,0 +1,34 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+const int N=20;
+LL w[N];
+LL ans,n;
+LL get(LL x)
+{
+    return x==0? 0:get(x-(x&-x))+1;
+}
+void dfs(LL beg,LL num,LL sym)
+{
+    ans+=((LL)1<<get(num))*sym;
+    for(LL i=beg+1;i<=n;i++)
+        dfs(i,num&w[i],-2*sym);
+}
+int main()
+{
+    LL k=1,t,i;
+    cin>>t;
+    while(t--)
+    {
+        cin>>n;
+        for(i=1;i<=n;i++)
+           cin>>w[i];
+        ans=0;
+        for(i=1;i<=n;i++)
+           dfs(i,w[i],1);
+        cout<<"Case #"<<k++<<": "<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/3930_autoAC.cpp b/HDOJ/3930_autoAC.cpp
new file mode 100644
index 0000000..1d796ef
--- /dev/null
+++ b/HDOJ/3930_autoAC.cpp
@@ -0,0 +1,179 @@
+#include <iostream>
+#include <string.h>
+#include <algorithm>
+#include <stdio.h>
+#include <math.h>
+#include <map>
+using namespace std;
+typedef long long LL;
+const int N=1000005;
+int p[N];
+bool prime[N];
+int num,cnt;
+LL k,m,newx,g;
+LL a[65],b[65];
+void isprime()
+{
+    num=0;
+    int i,j;
+    memset(prime,true,sizeof(prime));
+    for(i=2;i<N;i++)
+    {
+        if(prime[i])
+        {
+            p[num++]=i;
+            for(j=i+i;j<N;j+=i)
+            {
+                prime[j]=false;
+            }
+        }
+    }
+}
+LL multi(LL a,LL b,LL m)
+{
+    LL ans=0;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans=(ans+a)%m;
+            b--;
+        }
+        b>>=1;
+        a=(a+a)%m;
+    }
+    return ans;
+}
+LL quick_mod(LL a,LL b,LL m)
+{
+    LL ans=1;
+    a%=m;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans=multi(ans,a,m);
+            b--;
+        }
+        b>>=1;
+        a=multi(a,a,m);
+    }
+    return ans;
+}
+void factor(LL n)
+{
+    cnt=0;
+    for(int i=0;(LL)p[i]*p[i]<=n;i++)
+    {
+        if(n%p[i]==0)
+        {
+            a[cnt]=p[i];
+            int c=0;
+            while(n%p[i]==0)
+            {
+                c++;
+                n/=p[i];
+            }
+            b[cnt++]=c;
+        }
+    }
+    if(n>1)
+    {
+        a[cnt]=n;
+        b[cnt++]=1;
+    }
+}
+LL extend_Euclid(LL a,LL b,LL &x,LL &y)
+{
+    if(b==0)
+    {
+        x=1;
+        y=0;
+        return a;
+    }
+    LL gd=extend_Euclid(b,a%b,x,y);
+    LL temp=x;
+    x=y;
+    y=temp-(a/b)*y;
+    return gd;
+}
+LL Inv(LL n,LL p)
+{
+    return quick_mod(n,p-2,p);
+}
+bool dfs(int dept,LL t)
+{
+    if(dept==cnt)
+    {
+        LL ans=quick_mod(g,t,m);
+        if(ans==1&&t!=m-1) return false;
+        return true;
+    }
+    LL tmp=1;
+    for(int i=0;i<=b[dept];i++)
+    {
+        if(!dfs(dept+1,t*tmp)) return false;
+        tmp*=a[dept];
+    }
+    return true;
+}
+void find()
+{
+    factor(m-1);
+    for(g=2;;g++)
+        if(dfs(0,1)) break;
+}
+LL log_x(LL a,LL b,LL p)
+{
+    map<LL,int>x;
+    LL z=(LL)ceil(sqrt(p*1.0));
+    LL v=Inv(quick_mod(a,z,p),p);
+    LL e=1;
+    x[1]=0;
+    for(int i=1;i<z;i++)
+    {
+        e=multi(e,a,p);
+        if(!x.count(e))
+            x[e]=i;
+    }
+    for(int i=0;i<z;i++)
+    {
+        if(x.count(b))
+            return i*z+x[b];
+        b=multi(b,v,p);
+    }
+    return -1;
+}
+LL sol[1005];
+void Solve(LL a,LL b,LL n)
+{
+    LL d,x,y;
+    d=extend_Euclid(a,n,x,y);
+    if(b%d) puts("-1");
+    else
+    {
+        n/=d;b/=d;
+        sol[0]=(x*b%n+n)%n;
+        for(int i=1;i<d;i++)
+            sol[i]=sol[i-1]+n;
+        for(int i=0;i<d;i++)
+            sol[i]=quick_mod(g,sol[i],m);
+        sort(sol,sol+d);
+        for(int i=0;i<d;i++)
+            cout<<sol[i]<<endl;
+    }
+}
+int main()
+{
+    int t=1;
+    isprime();
+    while(cin>>k>>m>>newx)
+    {
+        find();
+        LL t1=log_x(g,newx,m);
+        LL t2=m-1;
+        cout<<"case"<<t++<<":"<<endl;
+        Solve(k,t1,t2);
+    }
+    return 0;
+}
diff --git a/HDOJ/3931_autoAC.cpp b/HDOJ/3931_autoAC.cpp
new file mode 100644
index 0000000..099c1ce
--- /dev/null
+++ b/HDOJ/3931_autoAC.cpp
@@ -0,0 +1,115 @@
+#include <cstdio>
+#include <cstring>
+const int maxN=255;
+const int maxn=550;
+const int inf=1<<25;
+const int s=0;
+int L , W , N , P;
+struct edge{
+       int v,next,w;
+}edge[maxn*maxn];
+int head[maxn],cnt;//for sap 
+void addedge(int u, int v, int w)
+{
+     edge[cnt].v=v;
+     edge[cnt].w=w;
+     edge[cnt].next=head[u];
+     head[u]=cnt++;
+     edge[cnt].v=u;
+     edge[cnt].w=0;
+     edge[cnt].next=head[v];
+     head[v]=cnt++;
+}
+int sap(int t)
+{
+    int pre[maxn],cur[maxn],dis[maxn],gap[maxn];
+    int flow=0 , aug=inf ,u;
+    bool flag;
+    for (int i=0 ; i<=t ; ++i)
+    {
+        cur[i]=head[i];
+        gap[i]=dis[i]=0;
+    }
+    gap[s]=t+1;
+    u=pre[s]=s;
+    while (dis[s]<=t)
+    {
+          flag=0 ; 
+          for (int &j=cur[u] ; ~j ; j=edge[j].next)
+          {
+              int v=edge[j].v;
+              if (edge[j].w>0 && dis[u]==dis[v]+1)
+              {
+                   flag=1;
+                   if(edge[j].w<aug)aug=edge[j].w;
+                   pre[v]=u;
+                   u=v;
+                   if (u==t)
+                   {
+                       flow+=aug;
+                       while (u!=s)
+                       {
+                             u=pre[u];
+                             edge[cur[u]].w-=aug;
+                             edge[cur[u]^1].w+=aug;
+                       }
+                       aug=inf;    
+                   }  
+                   break;        
+              }
+          }
+          if (flag)continue ;
+          int mindis=t+1;
+          for (int j=head[u]; ~j ; j=edge[j].next)
+          {
+              int v=edge[j].v;
+              if (edge[j].w>0 && dis[v]<mindis)
+              {
+                 mindis=dis[v];
+                 cur[u]=j;
+              }
+          }
+          if(--gap[dis[u]]==0)break;
+          gap[dis[u]=mindis+1]++;
+          u=pre[u];
+    }
+    return flow;
+}
+int x[maxN],y[maxN],r[maxN],p[maxN];//for build graph
+bool intersect (int a,int b)
+{
+     int dis=(x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]);
+     if(dis<=((r[a]+r[b])*(r[a]+r[b])))return true ;
+     else return false ;
+}
+void build_graph()
+{
+     int n=2*N;
+     for (int i=1 ; i<=N ; ++i)
+     {
+         addedge (i,i+N,p[i]);
+         if(y[i]<=r[i])addedge(0,i,inf);
+         if(y[i]+r[i]>=W)addedge(i+N,n+1,inf);
+         for (int j=i+1 ; j<=N ; ++j)//
+         if(intersect(i,j))addedge(i+N,j,inf),addedge(j+N,i,inf);
+     }
+}
+void init ()
+{
+     memset (head , -1 , sizeof(head));
+     cnt=0;
+}
+int main ()
+{
+    while (~scanf("%d%d%d%d",&L,&W,&N,&P))
+    {
+          init();
+          for (int i=1 ; i<=N ; ++i)
+           scanf("%d %d %d %d",x+i,y+i,r+i,p+i);
+          build_graph();
+          int ans=P-sap(2*N+1);
+          if(ans<0)printf("Our hero has been killed\n");
+          else printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3932_autoAC.cpp b/HDOJ/3932_autoAC.cpp
new file mode 100644
index 0000000..2bc0647
--- /dev/null
+++ b/HDOJ/3932_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <cstdio>
+#include <cmath>
+#include <time.h>
+#include <cstdlib>
+using namespace std;
+const double pi=acos(-1.0);
+const int maxn=1005;
+double x[maxn], y[maxn];
+int n;
+double dis2 (double x1,double y1 ,double x2,double y2)
+{
+       double tmp1=x1-x2,tmp2=y1-y2;
+       tmp1*=tmp1;
+       tmp2*=tmp2;
+       return tmp1+tmp2;
+}
+double test(double xx, double yy) 
+{
+       double max = 0,tmp;
+       for (int i=0;i<n;i++)
+           if(max<(tmp=dis2(xx,yy,x[i],y[i])))max=tmp;
+       return max;
+}
+int main()
+{
+    double xx,yy;
+    double delta,theta;
+    double X,Y;
+    double retx,rety,ans;
+    while (~scanf("%lf%lf%d",&X,&Y,&n))
+    {
+        for (int i=0 ; i<n ; i++)
+            scanf("%lf%lf",x+i,y+i);
+        double ans=1000000000.0;
+        for (int i=0 ; i<10 ; ++i)
+        {
+            xx=((double)(rand()%1001)/1000.0)*X;
+            yy=((double)(rand()%1001)/1000.0)*Y;
+            double dis=test(xx,yy);
+            for (delta=X ; delta>0.001 ; delta*=0.9) 
+            {
+                for (theta=0 ; theta<=2*pi ; theta+=(pi/25.0))
+                {
+                    double tx=xx+delta*cos(theta);
+                    double ty=yy+delta*sin(theta);
+                    double tdis=test(tx,ty);
+                    if(tdis<dis)
+                    {
+                        xx=tx;
+                        yy=ty;
+                        dis=tdis;
+                    }
+                }
+            }
+            if(dis<ans)
+            {
+                retx=xx;
+                rety=yy;
+                ans=dis;
+            }
+        }
+        printf("(%.1lf,%.1lf).\n%.1lf\n",retx,rety,sqrt(ans));
+    }
+    return 0;
+}
diff --git a/HDOJ/3933_autoAC.cpp b/HDOJ/3933_autoAC.cpp
new file mode 100644
index 0000000..77a0991
--- /dev/null
+++ b/HDOJ/3933_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <cctype>
+using namespace std;
+const int maxn=1001;
+const int maxs=101;
+int dp[maxs][maxn];
+int data[maxn];
+int min(int a,int b){
+    return a<b?a:b;
+}
+int main(){
+    int n,s,la,lb;
+    while(scanf("%d",&n)&&n){
+        scanf("%d%d%d",&lb,&la,&s);
+        memset(dp,0,sizeof(dp));
+        int i,j,k;
+        for(i=1;i<=n;i++){
+            scanf("%d",&data[i]);
+            dp[0][i]=data[i];
+            dp[0][i]+=dp[0][i-1];
+        }
+        for(i=1;i<=s;i++){
+            for(j=1;j<=n;j++){
+                dp[i][j]=dp[i][j-1]+data[j];
+                for(k=la;k<=lb && k<=j;k++){
+                    dp[i][j]=min(dp[i][j],dp[i-1][j-k]);
+                }
+            }
+        }
+        int ans=1<<30;
+        for(i=0;i<=s;i++){
+            ans=min(dp[s][n],ans);
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3934_autoAC.cpp b/HDOJ/3934_autoAC.cpp
new file mode 100644
index 0000000..8fba729
--- /dev/null
+++ b/HDOJ/3934_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<math.h>
+using namespace std;
+#define PR 1e-8
+#define N 50015
+struct TPoint
+{
+    double x,y;
+    TPoint(){}
+    TPoint(double _x,double _y):x(_x),y(_y){}
+    TPoint operator-(const TPoint p) {return TPoint(x-p.x,y-p.y);}
+}ply[N];
+int n;
+double MAX(double a,double b) {return a>b?a:b;}
+double dist(TPoint a,TPoint b)
+{
+    TPoint c(b-a);
+    return sqrt(c.x*c.x+c.y*c.y);
+}
+double cross(TPoint a,TPoint b,TPoint c)
+{
+    TPoint s(b-a),t(c-a);
+    return s.x*t.y-s.y*t.x;
+}
+int dblcmp(double a)
+{
+    if(fabs(a)<PR) return 0;
+    return a>0?1:-1;
+}
+bool cmpx(TPoint a,TPoint b) 
+{
+    if(fabs(a.x-b.x)<PR) return a.y<b.y;
+    return a.x<b.x;
+}
+bool cmp(TPoint a,TPoint b)
+{
+    int d1=dblcmp(cross(ply[0],a,b));
+    return d1>0||(d1==0&&dist(ply[0],a)<dist(ply[0],b));
+}
+double diss(TPoint a,TPoint b)
+{
+    return dist(a,b)*dist(a,b);
+}
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        int i,top=2,j,p,q,r;
+        for(i=0;i<n;i++)
+            scanf("%lf%lf",&ply[i].x,&ply[i].y);
+        sort(ply,ply+n,cmpx);
+        sort(ply+1,ply+n,cmp);
+        for(i=2;i<n;i++)
+        {
+            while(top>1&&(dblcmp(cross(ply[top-2],ply[i],ply[top-1])))>=0) top--;
+            ply[top++]=ply[i];
+        }
+        double max1=-1e20,tmp;
+        n=top; ply[n]=ply[0]; ply[n+1]=ply[1]; ply[n+2]=ply[2];
+        p=0; q=1; r=2;
+        while(1)
+        {
+            int pp=p,qq=q,rr=r;
+            while(cross(ply[p],ply[q],ply[r+1])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
+                r=(r+1)%n;
+            max1=MAX(max1,fabs(tmp)*0.5);
+            while(cross(ply[p],ply[q+1],ply[r])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
+                q=(q+1)%n;
+            max1=MAX(max1,fabs(tmp)*0.5);
+            while(cross(ply[p+1],ply[q],ply[r])-(tmp=cross(ply[p],ply[q],ply[r]))>PR)
+                p=(p+1)%n;
+            max1=MAX(max1,fabs(tmp)*0.5);
+            if(pp==p&&qq==q&&rr==r) r=(r+1)%n;
+            if(r==0) break;
+        }
+        if(n<3) max1=0;
+        printf("%.2lf\n",max1);
+    }
+    return 0;
+}
diff --git a/HDOJ/3935_autoAC.cpp b/HDOJ/3935_autoAC.cpp
new file mode 100644
index 0000000..0024c91
--- /dev/null
+++ b/HDOJ/3935_autoAC.cpp
@@ -0,0 +1,64 @@
+#include <cstdio>
+#include <iostream>
+#include <math.h>
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+using namespace std;
+#define maxn 105
+int g[maxn];
+int x[maxn];
+int n,m;
+int inf=100*100;
+int all;
+int Get(int n)
+{
+     n=(n&0x55555555)+((n>>1)&0x55555555);  
+     n=(n&0x33333333)+((n>>2)&0x33333333);  
+     n=(n&0x0f0f0f0f)+((n>>4)&0x0f0f0f0f);  
+     n=(n&0x00ff00ff)+((n>>8)&0x00ff00ff);  
+     n=(n&0x0000ffff)+((n>>16)&0x0000ffff);  
+     return n;
+}
+void heng(int &x,int i)
+{
+    x^=i;x^=i<<1;x^=i>>1;  
+    x=x&all;
+}
+int main()
+{
+    int i, j,k;
+    while(scanf("%d%d", &n,&m) != EOF)
+    {
+        memset(g,0,sizeof(g));
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<m;j++)
+            {
+                int tmp;
+                scanf("%d",&tmp);
+                g[i]=g[i]<<1|tmp;
+            }
+        }
+        all=(1<<m)-1;
+        int ans=inf;
+        for(i=0;i<(1<<m);i++)
+        {    
+            for(k=0;k<n;k++)x[k]=g[k];
+            int t=Get(i);
+            heng(x[0],i);
+            x[1]^=i;
+            for(j=1;j<n;j++)
+            {
+                int k=x[j-1]^all;
+                heng(x[j],k);
+                x[j+1]^=k;
+                t+=Get(k);
+            }
+            if(t<ans&&x[n-1]==all)ans=t;
+        }
+        if(ans==inf)printf("no solution\n");
+        else printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3936_autoAC.cpp b/HDOJ/3936_autoAC.cpp
new file mode 100644
index 0000000..e2241b4
--- /dev/null
+++ b/HDOJ/3936_autoAC.cpp
@@ -0,0 +1,58 @@
+#include <cstdio>
+#include <cstring>
+typedef long long ll;
+const ll mod=1000000007;
+ll mtrx[60][2][2];
+void pre_pro()
+{
+    memset (mtrx , 0 , sizeof(mtrx));
+    mtrx[0][0][0]=1;mtrx[0][0][1]=1;
+    mtrx[0][1][0]=1;mtrx[0][1][1]=0;
+    for (int t=0 ; t<60 ; ++t)
+       for (int i=0 ; i<2 ; ++i)
+         for (int j=0 ; j<2 ; ++j)
+         {
+             for (int k=0 ; k<2 ; ++k)
+              mtrx[t+1][i][j]+=mtrx[t][i][k]*mtrx[t][k][j];
+            mtrx[t+1][i][j]%=mod;
+         }
+}
+ll fib (ll a)
+{
+    a--;
+    ll mat[2][2]={1,0,0,1};
+    ll tmp[2][2];
+    for (int p=0 ; a ; a>>=1 , ++p)
+    {
+        if(!(a&1))continue;
+        tmp[0][0]=mat[0][0];tmp[0][1]=mat[0][1];
+        tmp[1][0]=mat[1][0];tmp[1][1]=mat[1][1];
+        memset (mat, 0 , sizeof(mat));
+        for (int i=0 ; i<2 ; ++i)
+         for (int j=0 ; j<2 ; ++j)
+         {
+             for (int k=0 ; k<2 ; ++k)
+                 mat[i][j]+=mtrx[p][i][k]*tmp[k][j];
+             mat[i][j]%=mod;
+         }
+    }
+    return mat[0][0];
+}
+ll sum(ll a)
+{
+    if(a==0)return 0;
+    else return fib(2*a)*fib(2*a+1)%mod;
+}
+int main ()
+{
+    pre_pro();
+    int cas;
+    scanf("%d",&cas);
+    while (cas--)
+    {
+        ll l,r;
+        scanf("%I64d%I64d",&l,&r);
+        printf("%d\n",(sum(r)-sum(l-1)+mod)%mod);
+    }
+    return 0;
+}
diff --git a/HDOJ/3937_autoAC.cpp b/HDOJ/3937_autoAC.cpp
new file mode 100644
index 0000000..933f7e2
--- /dev/null
+++ b/HDOJ/3937_autoAC.cpp
@@ -0,0 +1,107 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<cmath>
+#define N 64
+struct trie{
+ int next[N];
+ int tag;
+}data[3000000];
+int inp;
+int init(int a){
+ memset(data[a].next,0,sizeof(data[a].next));
+ data[a].tag=0;
+ return a;
+}
+int tran(char a){
+ if(a>='A'&&a<='Z') return a-'A';
+ if(a>='a'&&a<='z') return a-'a'+26;
+ return a-'0'+52;
+}
+void insert(char *a){
+ int p=0;
+ for(;*a;a++){
+ int d=tran(*a);
+ if(data[p].next[d]==0)data[p].next[d]=init(++inp);
+ p=data[p].next[d];
+ data[p].tag++;
+ }
+}
+int query(char *a){
+ int p=data[0].next[tran(*a)];
+ for(a++;*a&&p;a++){
+ int d=tran(*a);
+ p=data[p].next[d];
+ }
+ return data[p].tag;
+}
+bool isok(double x,double y){
+ return (fabs(x-y)/x)<0.11;
+}
+int getint(char *a){
+ int ret=0;
+ for(int i=0;i<8;i++)
+ ret=ret*2+a[i];
+ return ret;
+}
+char be[]="begin";
+char en[]="end";
+bool cmp(char *a,char *b,int len){
+ for(int i=0;i<len;i++)
+ if(a[i]!=b[i])
+ return false;
+ return true;
+}
+int T,n,m,tf;
+double a,b;
+char str[100],ss[10];
+int main(void){
+ while(scanf("%d%d",&T,&m)+1){
+ inp=0;init(0);
+ tf=0;
+ for(int i=0;i<T;i++){
+ scanf("%s",str);
+ insert(str);
+ }
+ for(;m;m--){
+ tf=0;
+ double temp;
+ scanf("%d",&n);
+ scanf("%lf%lf",&a,&b);
+ if(!(a<b&&isok(2*a,b))){
+ tf=1;
+ }
+ ss[0]=0,ss[1]=1;
+ for(int i=2;i<8;i++){
+ scanf("%lf",&temp);
+ if(isok(temp,a))
+ ss[i]=0;
+ else
+ ss[i]=1;
+ }
+ str[0]=getint(ss);
+ for(int i=1;i<n;i++){
+ for(int j=0;j<8;j++){
+ scanf("%lf",&temp);
+ if(isok(temp,a)){
+ ss[j]=0;
+ }
+ else{
+ ss[j]=1;
+ }
+ }
+ str[i]=getint(ss);
+ }
+ str[n]='\0';
+ if(!cmp(be,str,5)||!cmp(en,str+n-3,3))
+ tf=1;
+ if(tf){
+ printf("wrong barcode!\n");
+ }
+ else{
+ str[n-3]='\0';
+ printf("%d\n",query(str+5));
+ }
+ }
+ }
+}
diff --git a/HDOJ/3938_autoAC.cpp b/HDOJ/3938_autoAC.cpp
new file mode 100644
index 0000000..284c79f
--- /dev/null
+++ b/HDOJ/3938_autoAC.cpp
@@ -0,0 +1,103 @@
+#include <iostream>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <cctype>
+#include <string>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+#define INF 2000000000
+#define MAXN 10005
+#define L(x) x<<1
+#define R(x) x<<1|1
+using namespace std;
+int n, m, q;
+int father[MAXN],  num[MAXN];
+long long out[MAXN];
+struct node
+{
+    int u, v, w;
+    bool operator <(const node &a)const
+    {
+        return w < a.w;
+    }
+}edge[MAXN * 10];
+struct wen
+{
+    int l, id;
+    bool operator <(const wen &a)const
+    {
+        return l < a.l;
+    }
+}p[MAXN];
+void init()
+{
+    for(int i = 1; i <= n; i++)
+    {
+        father[i] = i;
+        num[i] = 1;
+    }
+}
+int find(int x)
+{
+    if(father[x] == x) return x;
+    int t = find(father[x]);
+    father[x] = t;
+    return t;
+}
+int join(int x, int y)
+{
+    int fx = find(x);
+    int fy = find(y);
+    if(fx == fy) return 0;
+    int t = num[fx] * num[fy];
+    num[fx] += num[fy];
+    num[fy] = 0;
+    father[fy] = fx;
+    return t;
+}
+int main()
+{
+    while(scanf("%d%d%d", &n, &m, &q) != EOF)
+    {
+        init();
+        for(int i = 1; i <= m; i++)
+            scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
+        sort(edge + 1, edge + m + 1);
+        for(int i = 1; i <= q; i++)
+        {
+            scanf("%d", &p[i].l);
+            p[i].id = i;
+        }
+        sort(p + 1, p + q + 1);
+        int pos = 1;
+        long long ans = 0;
+        for(int i = 1; i <= q; i++)
+        {
+            while(pos <= m && edge[pos].w <= p[i].l)
+            {
+                ans += join(edge[pos].u, edge[pos].v);
+                pos ++;
+            }
+            out[p[i].id] = ans;
+        }
+        for(int i = 1; i <= q; i++)
+        printf("%I64d\n", out[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3939_autoAC.cpp b/HDOJ/3939_autoAC.cpp
new file mode 100644
index 0000000..ad6a44c
--- /dev/null
+++ b/HDOJ/3939_autoAC.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+#define maxn 1000010
+int phi[maxn]; 
+int prime[maxn],cnt; 
+bool flag[maxn]; 
+int p[100],num; 
+LL ans,l; 
+void init()
+{   
+    cnt=0;
+    memset(flag,0,sizeof(flag));
+    for(int i=2;i<maxn;i++)
+      if(!flag[i])
+      {
+          prime[cnt++]=i;
+          for(int j=i+i;j<maxn;j+=i)
+              flag[j]=1;
+      }
+    for(int i=0;i<maxn;i++) phi[i]=i;
+    for(int i=2;i<maxn;i+=2) phi[i]>>=1;
+    for(int i=3;i<maxn;i+=2)
+      if(phi[i]==i)
+        for(int j=i;j<maxn;j+=i)
+          phi[j]=phi[j]-phi[j]/i;
+}
+void divide(int x)
+{
+    num=0;
+    for(int i=0;i<cnt&&prime[i]*prime[i]<=x;i++)
+      if(x%prime[i]==0)
+      {
+          p[num++]=prime[i];
+          while(x%prime[i]==0) x/=prime[i];
+      }
+    if(x>1) p[num++]=x;
+}
+void dfs(int id,int mul,int tot,int x)
+{
+    if(id==num)
+    {
+        if(tot&1) ans=ans-x/mul;
+        else ans=ans+x/mul;
+        return ;
+    }
+    dfs(id+1,mul*p[id],tot+1,x);
+    dfs(id+1,mul,tot,x);
+}
+int main()
+{
+    init();
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        scanf("%lld",&l);
+        int temp=sqrt(l+0.0);
+        ans=0;
+        for(int i=1;i<=temp;i++) 
+        {
+            int lim=sqrt(l-(LL)i*i+0.0);  
+            if(i&1) 
+            {
+                divide(i);
+                if(i<=lim) dfs(0,1,0,i>>1);
+                else dfs(0,1,0,lim>>1);
+            }
+            else 
+            {
+                if(i<=lim) ans+=phi[i];
+                else
+                {
+                    divide(i);
+                    dfs(0,1,0,lim);
+                }
+            }
+        }
+        printf("%lld\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3940_autoAC.cpp b/HDOJ/3940_autoAC.cpp
new file mode 100644
index 0000000..75cd829
--- /dev/null
+++ b/HDOJ/3940_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <cstring>
+#include <cmath>
+using namespace std;
+double fly_pos(double vx,double vy,double h)
+{
+    return vx*(vy+sqrt(vy*vy+19.6*h))/9.8;
+}
+double fly_h(double vy,double h,double t)
+{
+    return h+vy*t-4.9*t*t;
+}
+int main()
+{
+    double h,vx,vy,t,h0,l,v1,v2,v3;
+    char bird[10];
+    while(~scanf("%lf%s",&h,bird))
+    {
+        if(!strcmp("Red",bird))
+        {
+            scanf("%lf%lf",&vx,&vy);
+            printf("%.3lf\n",fly_pos(vx,vy,h));
+        }
+        else if(!strcmp("Blue",bird))
+        {
+            scanf("%lf%lf%lf%lf%lf%lf",&vx,&vy,&t,&v1,&v2,&v3);
+            if(fly_pos(vx,vy,h)<t*vx)
+            {
+                printf("%.3lf\n",fly_pos(vx,vy,h));
+                continue;
+            }
+            h0=fly_h(vy,h,t);
+            l=vx*t;
+            vy=vy-9.8*t;
+            printf("%.3lf %.3lf %.3lf\n",l+fly_pos(v1,vy,h0),l+fly_pos(v2,vy,h0),l+fly_pos(v3,vy,h0));
+        }
+        else
+        {
+            scanf("%lf%lf%lf",&vx,&vy,&t);
+            if(fly_pos(vx,vy,h)<t*vx)
+            {
+                printf("%.3lf\n",fly_pos(vx,vy,h));
+                continue;
+            }
+            h0=fly_h(vy,h,t);
+            l=vx*t;
+            vy=vy-9.8*t;
+            printf("%.3lf\n",l+fly_pos(2*vx,2*vy,h0));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3941_autoAC.cpp b/HDOJ/3941_autoAC.cpp
new file mode 100644
index 0000000..00ae8d3
--- /dev/null
+++ b/HDOJ/3941_autoAC.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <sstream>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <cmath>
+#include <iomanip>
+#include <cstring>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+using namespace std;
+const int MOD=1000000007;
+const int MaxN=103;
+const int MaxM=203;
+int N,K,f[2][MaxN][MaxM],s[MaxN][MaxM];
+int solve()
+{
+ int MaxK=2*K+1;
+ for (int i=0; i<=K; ++i)
+     for (int j=0; j<=MaxK; ++j) f[0][i][j]=s[i][j]=0;
+ f[0][0][0]=1;
+ s[0][0]=1;
+ int cur=0,last;
+ for (int i=1; i<=N; ++i)
+ {
+ last=cur;
+ cur=1-cur;
+ for (int j=0; j<=K; ++j)
+     for (int k=0; k<=MaxK; ++k) f[cur][j][k]=0;
+ f[cur][0][0]=1;
+ for (int j=1; j<=K; ++j)
+ {
+     for (int k=j; k<MaxK-1; ++k)
+     {
+         f[cur][j][k]=f[cur][j-1][k-1]+f[last][j][k-j];
+         f[cur][j][k]%=MOD;
+     }
+     for (int p=0; p<=j; ++p)
+     {
+      int cnt=MaxK-1-j;
+      f[cur][j][MaxK-1]+=s[p][cnt];
+      f[cur][j][MaxK-1]%=MOD;
+      cnt=MaxK-j;
+      f[cur][j][MaxK]+=s[p][cnt];
+      f[cur][j][MaxK]%=MOD;
+     }
+ }
+ for (int j=0; j<=K; ++j)
+     for (int k=MaxK; k>=0; --k) s[j][k]=f[cur][j][k];
+ for (int j=0; j<=K; ++j)
+     for (int k=MaxK-2; k>=0; --k)
+     {
+         s[j][k]+=s[j][k+2];
+         s[j][k]%=MOD;
+            } 
+ }
+ int ans=0;
+ for (int i=0; i<=K; ++i)
+     for (int j=i+i; j<MaxK; j+=2) 
+     {
+      ans+=f[cur][i][j];
+      ans%=MOD;
+     }
+ return ans;
+}
+int main()
+{
+ int Testnum;
+ scanf("%d",&Testnum);
+ for (int Test=1; Test<=Testnum; ++Test)
+ {
+ scanf("%d %d",&N,&K);
+ printf("Case #%d: %d\n",Test,solve());
+    }
+}
diff --git a/HDOJ/3943_autoAC.cpp b/HDOJ/3943_autoAC.cpp
new file mode 100644
index 0000000..a16a29c
--- /dev/null
+++ b/HDOJ/3943_autoAC.cpp
@@ -0,0 +1,76 @@
+#include"cstdlib"
+#include"cstdio"
+#include"cstring"
+#include"cmath"
+#include"queue"
+#include"algorithm"
+#include"iostream"
+using namespace std;
+__int64 dp[22][22][22];  
+int num[22];
+__int64 dfs(int site,int a,int b,int f,int x,int y)
+{
+    if(site==0)
+    {
+        if(a==x&&b==y) return 1;
+        return 0;
+    }
+    if(!f&&dp[site][a][b]!=-1) return dp[site][a][b];
+    int len=f?num[site]:9;
+    __int64 ans=0;
+    for(int i=0;i<=len;i++)
+    {
+        if(i==4) ans+=dfs(site-1,a+1,b,f&&i==len,x,y);
+        else if(i==7) ans+=dfs(site-1,a,b+1,f&&i==len,x,y);
+        else ans+=dfs(site-1,a,b,f&&i==len,x,y);
+    }
+    if(!f) dp[site][a][b]=ans;
+    return ans;
+}
+__int64 solve(__int64 a,int x,int y)
+{
+    int cnt=0;
+    while(a)
+    {
+        num[++cnt]=a%10;
+        a/=10;
+    }
+    return dfs(cnt,0,0,1,x,y);
+}
+int main()
+{
+    int t,cas=1;
+    cin>>t;
+    while(t--)
+    {
+        __int64 p,q;
+        int x,y;
+        scanf("%I64d%I64d%d%d",&p,&q,&x,&y);
+        memset(dp,-1,sizeof(dp));
+        int n;
+        scanf("%d",&n);
+        printf("Case #%d:\n",cas++);
+        while(n--)
+        {
+            __int64 k,s;
+            __int64 ans=-1;
+            s=solve(p,x,y);
+            scanf("%I64d",&k);
+            s+=k;
+            __int64 l=p+1,r=q;
+            while(l<=r)          
+            {
+                __int64 mid=(l+r)/2;
+                if(solve(mid,x,y)>=s)
+                {
+                    ans=mid;
+                    r=mid-1;
+                }
+                else l=mid+1;
+            }
+            if(ans!=-1) printf("%I64d\n",ans);
+            else puts("Nya!");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3944_autoAC.cpp b/HDOJ/3944_autoAC.cpp
new file mode 100644
index 0000000..7bab613
--- /dev/null
+++ b/HDOJ/3944_autoAC.cpp
@@ -0,0 +1,69 @@
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#define maxn 10000
+using namespace std;
+int flag[maxn],pim[maxn],tol;
+int p[1229][9973];
+int ni[1229][9973];
+int mp[10000];
+void init()
+{
+    tol=0;
+    for(int i=2; i<maxn; i++) 
+    {
+        if(!flag[i])  pim[tol++]=i;
+        for(int j=0; j<tol&&i*pim[j]<maxn; j++)
+        {
+            flag[i*pim[j]]=1;
+            if(i%pim[j]==0) break;
+        }
+    }
+    for(int i=0; i<tol; i++)
+    {
+        int k=pim[i];
+        mp[k]=i;
+        p[i][0]=1, p[i][1]=1;
+        ni[i][0]=1,ni[i][1]=1;
+        for(int j=2; j<k; j++) 
+        {
+            p[i][j]=j*p[i][j-1]%pim[i];
+            ni[i][j]=-k/j*ni[i][k%j]%k;
+            if(ni[i][j]<0) ni[i][j]+=k;
+        }
+    }
+    for(int i=0; i<tol; i++) 
+    {
+        int k=pim[i];
+        for(int j=1; j<k; j++)
+        {
+            ni[i][j]=ni[i][j]*ni[i][j-1]%k;
+        }
+    }
+}
+int cal(int n,int m,int v)
+{
+    if(n<m) return 0;
+    int x=mp[v];
+    return p[x][n] * ni[x][m]%v * ni[x][n-m]%v;
+}
+int main()
+{
+    int n,k,p,ca=0;
+    init();
+    while(scanf("%d %d %d",&n,&k,&p)==3)
+    {
+        if(k>n/2) k=n-k;
+        int res=1,u_u=n-k;
+        n++;
+        while(n&&k)
+        {
+            res=res*cal(n%p,k%p,p)%p;
+            if(res==0) break;
+            n/=p;
+            k/=p;
+        }
+        printf("Case #%d: %d\n",++ca,(res+u_u)%p);
+    }
+    return 0;
+}
diff --git a/HDOJ/3945_autoAC.cpp b/HDOJ/3945_autoAC.cpp
new file mode 100644
index 0000000..f1be25a
--- /dev/null
+++ b/HDOJ/3945_autoAC.cpp
@@ -0,0 +1,129 @@
+#include <cstdio>
+#include <iostream>
+#include <cstring>
+#include <vector>
+using namespace std;
+#define rep(i,n) for(int i=0;i<n;i++)
+#define mod 1000000009
+#define pb push_back
+vector <int> p[15];
+int st[15];
+int f[1<<16][20];
+int to[15][20][20];
+long long dp[15][25][25];
+int num[1<<16];
+int dx[]= {0,0,-1,1,1,1,-1,-1};
+int dy[]= {-1,1,0,0,1,-1,1,-1};
+int check(int x,int y)
+{
+    if(x>=0 && x<4 && y>=0 && y<4)return 1;
+    return 0;
+}
+int nxt(int t)
+{
+    int ret=0;
+    rep(i,17)
+    {
+        int x=i/4;
+        int y=i%4;
+        int cnt=0;
+        for(int j=0; j<8; j++)
+        {
+            int nx = x+dx[j];
+            int ny = y+dy[j];
+            if(check(nx,ny))
+            {
+                int pos = nx*4+ny;
+                if((1<<pos)&t)
+                    cnt++;
+            }
+        }
+        if((1<<i)&t)
+        {
+            if(cnt==2||cnt==3)
+                ret^=(1<<i);
+        }
+        else
+        {
+            if(cnt==3)
+                ret^=(1<<i);
+        }
+    }
+    return ret;
+}
+void init()
+{
+    int n = 1<<16;
+    memset(num,0,sizeof(num));
+    rep(i,n)rep(j,17)
+    if(i&(1<<j))
+        num[i]++;
+    rep(i,n)f[i][0]=nxt(i);
+    for(int i=1; i<=18; i++)
+        for(int j=0; j<n; j++)
+            f[j][i]=f[f[j][i-1]][i-1];
+}
+int getnxt(int s,int t)
+{
+    for(int i=18; i>=0; i--)
+        if((1<<i)<=t)
+        {
+            t-=(1<<i);
+            s=f[s][i];
+        }
+    return s;
+}
+int main()
+{
+    int L,K,M,T,N,t;
+    init();
+    scanf("%d",&L);
+    rep(cas,L)
+    {
+        scanf("%d%d%d%d",&K,&M,&T,&N);
+        rep(i,K)p[i].clear();
+        memset(st,0,sizeof(st));
+        rep(k,K)rep(i,4)rep(j,4)
+        {
+            scanf("%d",&t);
+            if(t)st[k]^=(1<<(i*4+j));
+        }
+        int n=1<<16;
+        memset(to,0,sizeof(to));
+        rep(k,K) // 10*2^16
+            rep(i,n)
+            if((st[k]&i) == st[k])
+            {
+                int j=i^st[k];
+                int cnt1=num[j];
+                int _nxt=getnxt(i,T);
+                int cnt2=num[_nxt];
+                to[k][cnt1][cnt2]++;
+            }
+        memset(dp,0,sizeof(dp));
+        dp[0][0][0]=1;
+        for(int k=0; k<K; k++)
+        {
+            for(int i=0; i<=M; i++)
+            {
+                for(int j=0; j<=N; j++)
+                {
+                    if(dp[k][i][j]==0)continue;
+                    for(int p=0; p<=16; p++)
+                    {
+                        for(int q=0; q<=16; q++)
+                        {
+                            if(to[k][p][q]==0)continue;
+                            if(i+p<=M && j+q<=N)
+                                dp[k+1][i+p][j+q]=(dp[k+1][i+p][j+q]+dp[k][i][j]*to[k][p][q])%mod;
+                        }
+                    }
+                }
+            }
+        }
+        long long ret=0;
+        for(int i=0; i<=M; i++)
+            ret=(ret+dp[K][i][N])%mod;
+        printf("Case #%d: %I64d\n",cas+1,ret);
+    }
+}
diff --git a/HDOJ/3946_autoAC.cpp b/HDOJ/3946_autoAC.cpp
new file mode 100644
index 0000000..31c7a57
--- /dev/null
+++ b/HDOJ/3946_autoAC.cpp
@@ -0,0 +1,43 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<algorithm>
+#include<cmath>
+using namespace std;
+int a[10005], b[10005];
+int res, pre, as[10005];
+bool cmp(int x, int y)
+{
+    return x>y;
+}
+int main()
+{
+    int n, m, an, bn, t=1, ca, i, end, lef, tmp;
+    scanf("%d", &ca);
+    while(ca-->0)
+    {
+        scanf("%d%d%d%d", &n, &m, &an, &bn);
+        for(i=0; i<an; i++)
+            scanf("%d", &a[i]);
+        for(i=0; i<bn; i++)
+            scanf("%d", &b[i]);
+        sort(a, a+an, cmp);
+        sort(b, b+bn, cmp);
+        memset(as, 0, sizeof(as));
+        for(i=1; i<=an; i++)as[i]=as[i-1]+a[i-1];
+        end=n*m/3;
+        if(((n==2)&&(m%3==2))||((m==2)&&(n%3==2)))end--;
+        end=min(end, bn);
+        res=as[min(n*m/2, an)];
+        pre=0;
+        for(i=1; i<=end; i++)
+        {
+            pre+=b[i-1];
+            lef=min((n*m-3*i)/2, an);
+            tmp=pre+as[lef];
+            if(tmp>res)res=tmp;
+        }
+        printf("Case #%d: %d\n", t++, res);
+    }
+    return 0;
+}
diff --git a/HDOJ/3947_autoAC.cpp b/HDOJ/3947_autoAC.cpp
new file mode 100644
index 0000000..b127b23
--- /dev/null
+++ b/HDOJ/3947_autoAC.cpp
@@ -0,0 +1,129 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<queue>
+using namespace std;
+#define sz 200
+#define inf 0x7fffffff
+int g[sz][sz];
+int s[sz],t[sz],v[sz];
+struct node{
+    int s, t, v, len, nxt;
+} e[sz * 40 + 20];
+int hd[sz], cnt, pre[sz] , pos[sz], dis[sz], vis[sz];
+int sum ;
+void insert(int s, int t, int v, int len){
+    e[cnt].s = s;e[cnt].t = t;e[cnt].v = v;e[cnt].len = len;
+    e[cnt].nxt = hd[s];hd[s] = cnt++;
+    e[cnt].s = t;e[cnt].t = s;e[cnt].v = 0;e[cnt].len = -len;
+    e[cnt].nxt = hd[t];hd[t] = cnt++;
+}
+bool spfa(int s, int t, int n){
+    for(int i = 0; i < n; i++){
+        dis[i]=inf;
+        vis[i]=0;
+        pre[i]=-1;
+    }
+    queue<int>q;
+    while(!q.empty())q.pop();
+    q.push(s);
+    pre[s] = s;
+    dis[s] = 0;
+    while( !q.empty() ){
+        int u = q.front();
+        q.pop();
+        vis[u] = 0;
+        for(int i = hd[u]; i!=-1; i=e[i].nxt){
+            int v = e[i].t;
+            if (e[i].v > 0 && dis[u] + e[i].len < dis[v]){
+                dis[v] = dis[u] + e[i].len;
+                pre[v] = u;
+                pos[v] = i;
+                if (!vis[v]){
+                    vis[v] = 1;
+                    q.push(v);
+                }
+            }
+        }
+    }
+    return pre[t] != -1 && dis[t] < inf;
+}
+int mcf(int s, int t, int n){
+    int fw = 0, ct = 0;
+    while(spfa(s,t,n)){
+        int v = inf;
+        for(int i = t; i != s; i = pre[i])
+            v = min(v, e[pos[i]].v);
+        fw += v;
+        ct += dis[t] * v;
+        for(int i = t; i != s; i = pre[i]){
+            e[pos[i]].v -= v;
+            e[pos[i] ^ 1].v += v;
+        }
+    }
+    if(fw != sum)return -1;
+    return ct; 
+}
+struct node1{
+    int s,t,v,nxt;
+}ne[sz*10];
+int nhd[sz],ncnt;
+void insert1(int s ,int t,int v){
+    ne[ncnt].s=s;
+    ne[ncnt].t=t;
+    ne[ncnt].v=v;
+    ne[ncnt].nxt = nhd[s];
+    nhd[s]=ncnt++;
+}
+int main(){
+    int TT;
+    scanf("%d",&TT);
+    for(int cas=1;cas<=TT;cas++){
+        int n;
+        scanf("%d",&n);
+        memset(pre,-1,sizeof(pre));
+        int S=0,T=n+1;
+        memset(hd,-1,sizeof(hd));
+        cnt = 0;
+        memset(g,-1,sizeof(g));
+        memset(pre,-1,sizeof(pre));
+        memset(nhd,-1,sizeof(nhd));
+        ncnt=0;
+        for(int i=1;i<n;i++){
+             scanf("%d%d%d",&s[i],&t[i],&v[i]);
+             g[s[i]][t[i]]=i;
+             pre[s[i]] = t[i];
+             insert1(t[i],s[i],v[i]);
+        }
+        s[n]=1;
+        t[n]=n+1;
+        v[n]=0;
+        insert1(n+1,1,0);
+        g[1][1+n]=n+1;
+        pre[1]=n+1;
+        sum=0;
+        for(int i=1;i<=n;i++){
+            int vv = v[i];
+            for(int j=nhd[s[i]];j!=-1;j=ne[j].nxt){
+                vv -= ne[j].v;
+                insert(i,g[ne[j].t][s[i]],inf,0);
+            }
+            if(vv>0){
+                sum+=vv;
+                insert(S,i,vv,0);
+            }
+            if(vv<0){
+                insert(i,T,-vv,0);
+            }
+        }
+        int m;
+        cin>>m;
+        int ss,tt,li,ci;
+        for(int i=0;i<m;i++){
+            scanf("%d%d%d%d",&ss,&tt,&li,&ci);
+            insert(g[ss][pre[ss]],g[tt][pre[tt]],li,ci);
+        }
+        printf("Case #%d: ",cas);
+        cout<<mcf(S,T,T+1)<<endl;
+    }
+}
diff --git a/HDOJ/3948_autoAC.cpp b/HDOJ/3948_autoAC.cpp
new file mode 100644
index 0000000..4995173
--- /dev/null
+++ b/HDOJ/3948_autoAC.cpp
@@ -0,0 +1,122 @@
+#include<cstdio>  
+#include<cmath>  
+#include<cstring>  
+#include<algorithm>  
+using namespace std;  
+#define MAXN 200100  
+int dp[MAXN][20];  
+char r[MAXN];  
+int sa[MAXN];  
+int wa[MAXN],wb[MAXN],wv[MAXN],ws[MAXN];  
+int height[MAXN],rk[MAXN];  
+int mm[MAXN];  
+int cas;  
+inline bool cmp(int *r,int a,int b,int len){  
+    return r[a]==r[b]&&r[a+len]==r[b+len];  
+}  
+void SA(int n,int m){  
+    int i,j,p,*x=wa,*y=wb,*t;  
+    for(i=0;i<m;i++)  
+        ws[i]=0;  
+    for(i=0;i<n;i++)  
+        ws[x[i]=r[i]]++;  
+    for(i=1;i<m;i++)  
+        ws[i]+=ws[i-1];  
+    for(i=n-1;i>=0;i--)  
+        sa[--ws[x[i]]]=i;  
+    for(j=p=1;p<n;j<<=1,m=p){  
+        for(p=0,i=n-j;i<n;i++)  
+            y[p++]=i;  
+        for(i=0;i<n;i++){  
+            if(sa[i]>=j)  
+                y[p++]=sa[i]-j;  
+        }  
+        for(i=0;i<m;i++)  
+            ws[i]=0;  
+        for(i=0;i<n;i++)  
+            ws[wv[i]=x[y[i]]]++;  
+        for(i=1;i<m;i++)  
+            ws[i]+=ws[i-1];  
+        for(i=n-1;i>=0;i--)  
+            sa[--ws[wv[i]]]=y[i];  
+        for(t=x,x=y,y=t,x[sa[0]]=0,p=i=1;i<n;i++)  
+            x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;  
+    }  
+}  
+void Height(int n){  
+    int i,j,k=0;  
+    for(i=0;i<=n;i++)    
+        rk[sa[i]]=i;  
+    for(i=0;i<n;height[rk[i++]]=k)  
+        for(k?k--:0,j=sa[rk[i]-1];r[i+k]==r[j+k];k++);  
+}  
+int init(){  
+    int i,j,len;  
+    memset(height,0,sizeof(height));  
+    len=strlen(r);  
+    r[len]='$';  
+    for(j=0;j<len;j++)  
+        r[j+len+1]=r[len-1-j];  
+    r[j+len+1]='\0';  
+    return len*2+1;  
+}  
+void st(int n){  
+    int i,j,p,q;  
+    for(i=1;i<=n;i++)  
+        dp[i][0]=i;  
+    for(j=1;j<=mm[n];j++)  
+        for(i=1;i+(1<<j)-1<=n;i++){  
+            p=height[dp[i][j-1]];  
+            q=height[dp[i+(1<<(j-1))][j-1]];  
+            if(p>q)  
+                dp[i][j]=dp[i+(1<<(j-1))][j-1];  
+            else  
+                dp[i][j]=dp[i][j-1];  
+        }  
+}  
+int RMQ_MIN(int i,int j){  
+    int tem;  
+    if(i>j){  
+        tem=i;  
+        i=j;  
+        j=tem;  
+    }  
+    i++;           
+    int k=mm[(j-i+1)];  
+    return min(height[dp[i][k]],height[dp[j-(1<<k)+1][k]]);  
+}  
+void solve(int n){  
+    int i,j,ans=0,pre1=0,pre2=0;  
+    st(n);  
+    for(i=2;i<=n;i++){  
+        pre1=min(pre1,height[i]);  
+        j=RMQ_MIN(i,rk[n-1-sa[i]]);  
+        if(j>pre1){  
+            ans+=j-pre1;  
+            pre1=j;  
+        }  
+        pre2=min(pre2,height[i]);  
+        j=RMQ_MIN(i,rk[n-sa[i]]);  
+        if(j>pre2){  
+            ans+=j-pre2;  
+            pre2=j;  
+        }  
+    }  
+    printf("Case #%d: %d\n",cas,ans);  
+}  
+int main(){  
+    int i,j,n,t,T;  
+    mm[0]=-1;  
+    for(i=1;i<MAXN;i++)  
+        mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];           
+    scanf("%d",&T);  
+    cas=0;  
+    for(t=1;t<=T;t++){  
+        scanf("%s",r);  
+        n=init();  
+        SA(n+1,130);  
+        Height(n);  
+        cas++;  
+        solve(n);  
+    }  
+}
diff --git a/HDOJ/3949_autoAC.cpp b/HDOJ/3949_autoAC.cpp
new file mode 100644
index 0000000..be07a4f
--- /dev/null
+++ b/HDOJ/3949_autoAC.cpp
@@ -0,0 +1,64 @@
+#include<cstdio>
+#include<algorithm>
+#define MAXN 10010
+typedef long long LL;
+using namespace std;
+int n;
+LL a[MAXN];
+void Gauss() {
+    int i, j, k, t;
+    k = 0;
+    for (i = 60; i >= 0; i--) {
+        for (j = k; j < n; j++) {
+            if ((a[j] >> i) & 1)
+                break;
+        }
+        if (j < n) {
+            swap(a[j], a[k]);
+            for (t = 0; t < n; t++) {
+                if (t != k && ((a[t] >> i) & 1))
+                    a[t] ^= a[k];
+            }
+            k++;
+        }
+    }
+    sort(a, a + n);
+    n = unique(a, a + n) - a;
+}
+LL Cal(int k) {
+    LL ans;
+    int i;
+    ans = i = 0;
+    if (a[0] == 0) {
+        if (k == 1)
+            return 0;
+        k--;
+        i++;
+    }
+    for (; i < n && k; k >>= 1, i++) {
+        if (k & 1)
+            ans ^= a[i];
+    }
+    if (i == n && k)
+        return -1;
+    return ans;
+}
+int main() {
+    int c, ca = 1;
+    int i, q;
+    LL k;
+    scanf("%d", &c);
+    while (c--) {
+        scanf("%d", &n);
+        for (i = 0; i < n; i++)
+            scanf("%I64d", &a[i]);
+        Gauss();
+        scanf("%d", &q);
+        printf("Case #%d:\n", ca++);
+        while (q--) {
+            scanf("%I64d", &k);
+            printf("%I64d\n", Cal(k));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3950_autoAC.cpp b/HDOJ/3950_autoAC.cpp
new file mode 100644
index 0000000..0a0223d
--- /dev/null
+++ b/HDOJ/3950_autoAC.cpp
@@ -0,0 +1,195 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <set>
+using namespace std;
+#define LL(x) (x<<1)
+#define RR(x) (x<<1|1)
+#define MID(a,b) (a+((b-a)>>1))
+#define INF (1<<30)
+const int N=50005;
+int n,q,ed[N];
+int st_len,ed_len;
+struct Segtree
+{
+    set<int> T[N];
+    int st[N*4],len[N*4];
+    void PushUp(int ind)
+    {
+        if(st[LL(ind)]<st[RR(ind)])
+        {
+            st[ind]=st[LL(ind)];
+            len[ind]=len[LL(ind)];
+        }
+        else
+        {
+            st[ind]=st[RR(ind)];
+            len[ind]=len[RR(ind)];
+        }
+    }
+    void build(int lft,int rht,int ind)
+    {
+        st[ind]=INF;
+        if(lft==rht) T[lft].clear();
+        else
+        {
+            int mid=MID(lft,rht);
+            build(lft,mid,LL(ind));
+            build(mid+1,rht,RR(ind));
+        }
+    }
+    void updata(int pos,int ist,bool add,int ind,int lft,int rht)
+    {
+        if(lft==rht)
+        {
+            if(add) T[lft].insert(ist);
+            else T[lft].erase(ist);
+            if(T[lft].size()==0) st[ind]=INF;
+            else
+            {
+                len[ind]=lft;    st[ind]=*(T[lft].begin());
+            }
+        }
+        else
+        {
+            int mid=MID(lft,rht);
+            if(pos<=mid) updata(pos,ist,add,LL(ind),lft,mid);
+            else updata(pos,ist,add,RR(ind),mid+1,rht);
+            PushUp(ind);
+        }
+    }
+    pair<int,int> query(int ist,int ied,int ind,int lft,int rht)
+    {
+        if(ist<=lft&&rht<=ied) return make_pair(st[ind],len[ind]);
+        else
+        {
+            int mid=MID(lft,rht);
+            pair<int,int> tmp1,tmp2; tmp1.first=INF,tmp2.first=INF;
+            if(ist<=mid) tmp1=query(ist,ied,LL(ind),lft,mid);
+            if(ied> mid) tmp2=query(ist,ied,RR(ind),mid+1,rht);
+            if(tmp1.first<tmp2.first) return tmp1;
+            else return tmp2;
+        }
+    }
+}seg;
+struct BIT
+{
+    int T[N],sum;
+    void init(){memset(T,0,sizeof(T));sum=0;}
+    int lowbit(int x){return x&-x;}
+    void insert(int x,int add)
+    {
+        sum+=add;
+        while(x<N)
+        {
+            T[x]+=add; x+=lowbit(x);
+        }
+    }
+    int query(int k)
+    {
+        int ind=0;
+        for(int i=20;i>=0;i--)
+        {
+            ind^=(1<<i);
+            if(ind<N&&k>T[ind]) k-=T[ind];
+            else ind^=(1<<i);
+        }
+        return ind+1;
+    }
+    int getsum()
+    {
+        return sum;
+    }
+}bit;
+int calu(int st,int len,int m,int a,int b)    
+{
+    int ed=st+len-1;
+    return max(ed-m-b+1,st);
+}
+bool judge(int st1,int st2,int &ilen,int &ist) 
+{
+    ist=st1;
+    if(st1>st2) return false;
+    ilen=st2-st1+1;
+    return true;
+}
+int main()
+{
+    int t,t_cnt=0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&q);
+        seg.build(1,n,1);   bit.init();
+        st_len=n,ed_len=n;
+        printf("Case #%d:\n",++t_cnt);
+        while(q--)
+        {
+            char cmd[5];     scanf("%s",cmd);
+            if(cmd[0]=='A')
+            {
+                int m,a,b;     scanf("%d%d%d",&m,&a,&b);
+                if(st_len>=m)     
+                {
+                    if(st_len==n)  
+                    {
+                        ed[1]=m; bit.insert(1,1); st_len=0; ed_len-=m;
+                        printf("%d\n",1);
+                    }
+                    else            
+                    {
+                        int tmp=calu(1,st_len,m,a,b);     
+                        ed[tmp]=tmp+m-1; bit.insert(tmp,1); 
+                        printf("%d\n",tmp);
+                        int len,st;
+                        if(judge(ed[tmp]+1,st_len,len,st)) seg.updata(len,st,1,1,1,n);    
+                        st_len=tmp-1;                     
+                    }
+                }
+                else
+                {
+                    pair<int,int> res=seg.query(m,m+a+b,1,1,n);
+                    if(res.first!=INF)
+                    {
+                        seg.updata(res.second,res.first,0,1,1,n); 
+                        int tmp=calu(res.first,res.second,m,a,b);  
+                        ed[tmp]=tmp+m-1;  bit.insert(tmp,1);        
+                        printf("%d\n",tmp);
+                        int len,st;
+                        if(judge(res.first,tmp-1,len,st))     seg.updata(len,st,1,1,1,n);        
+                        if(judge(ed[tmp]+1,res.first+res.second-1,len,st))     seg.updata(len,st,1,1,1,n);
+                    }
+                    else
+                    {
+                        if(ed_len<m) puts("-1");
+                        else
+                        {
+                            int tmp=n-ed_len+1;
+                            ed[tmp]=tmp+m-1; ed_len=n-ed[tmp];    bit.insert(tmp,1);
+                            printf("%d\n",tmp);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                int k; scanf("%d",&k);
+                if(k>bit.getsum()||k<=0) continue;  
+                int st=bit.query(k);                 
+                int st1=1;
+                if(k>1) st1=ed[bit.query(k-1)]+1;    
+                int len1=st-st1;                    
+                if(len1>0&&st1!=1) seg.updata(len1,st1,0,1,1,n);    
+                int st2=bit.query(k+1)-1,len2;        
+                if(st2>n) len2=0,st2=n;
+                else len2=st2-ed[st];
+                if(len2>0&&!(st2==n)) seg.updata(len2,ed[st]+1,0,1,1,n);
+                if(st1!=1&&st2!=n) seg.updata(st2-st1+1,st1,1,1,1,n);
+                if(st1==1) st_len=st2-st1+1;
+                if(st2==n) ed_len=st2-st1+1;            
+                bit.insert(st,-1);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3951_autoAC.cpp b/HDOJ/3951_autoAC.cpp
new file mode 100644
index 0000000..16d2f43
--- /dev/null
+++ b/HDOJ/3951_autoAC.cpp
@@ -0,0 +1,18 @@
+#include<iostream>
+#include<cstdlib>
+#include<stdio.h>
+using namespace std;
+int main()
+{
+    int t,n,k;
+    int count=1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&k);
+        printf("Case %d: ",count++);
+        if(k==1&&(n%2==1)) puts("first");
+        else if(n<=k) puts("first");
+        else puts("second");
+    }
+}
diff --git a/HDOJ/3952_autoAC.cpp b/HDOJ/3952_autoAC.cpp
new file mode 100644
index 0000000..3610136
--- /dev/null
+++ b/HDOJ/3952_autoAC.cpp
@@ -0,0 +1,104 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-8;
+const double pi = acos(-1.0);
+struct Point {
+    double x, y;
+    Point operator - (const Point& t) const {
+        Point tmp;
+        tmp.x = x - t.x;
+        tmp.y = y - t.y;
+        return tmp;
+    }
+    Point operator + (const Point& t) const {
+        Point tmp;
+        tmp.x = x + t.x;
+        tmp.y = y + t.y;
+        return tmp;
+    }
+    bool operator == (const Point& t) const {
+        return fabs(x-t.x) < eps && fabs(y-t.y) < eps;
+    }
+}; 
+struct pol{
+    Point node[11];
+    int num;
+}P[11];
+inline double Cross(Point a, Point b, Point c) {                   
+    return (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y); 
+}
+bool dotOnSeg(Point p, Point s, Point e) {                            
+    if ( p == s || p == e )        // 蜂电规娉
+        return true;
+    return Cross(p,s,e) < eps && 
+        (p.x-s.x)*(p.x-e.x)<eps && (p.y-s.y)*(p.y-e.y)<eps;
+}
+struct Line {
+    double a, b, c;
+};
+Line Turn(Point s, Point e) {                                       
+    Line ln;
+    ln.a = s.y - e.y;
+    ln.b = e.x - s.x;
+    ln.c = s.x*e.y - e.x*s.y;
+    return ln;
+}
+bool Line_Inst(Line l1, Line l2, Point &p) {                        
+    double d = l1.a*l2.b - l2.a*l1.b;
+    if ( fabs(d) < eps )    return false;
+    p.x = (-l1.c*l2.b + l2.c*l1.b) / d;
+    p.y = (-l1.a*l2.c + l2.a*l1.c) / d;
+    return true; 
+}
+int main()
+{
+    int t,i,j,k,cases=1;
+    scanf("%d",&t);
+    int x,y,m,n,ans;
+    while(t--)
+    {
+         scanf("%d",&n);
+         for(i=1;i<=n;i++)
+         {
+             scanf("%d",&P[i].num);
+             for(j=1;j<=P[i].num;j++)
+                  scanf("%lf%lf",&P[i].node[j].x,&P[i].node[j].y);
+         }
+     if(n<=2){ printf("Case %d: %d\n",cases++,n);continue;}
+     Point p;
+     int max=0;
+         for(i=1;i<=n;i++)
+         {
+             for(j=i+1;j<=n;j++)
+             {
+                 for(k=1;k<=P[i].num;k++)
+                 {
+                     for(m=1;m<=P[j].num;m++)
+                     {   
+                         ans=2;                   
+                         Line a=Turn(P[i].node[k],P[j].node[m]) ;
+                         for(x=1;x<=n;x++)
+                         {
+                             if(x==i||x==j) continue;
+                             for(y=1;y<P[x].num;y++)
+                             {
+                                 Line b=Turn(P[x].node[y],P[x].node[y+1]);
+                                 if(Line_Inst(a,b,p)&&dotOnSeg(p,P[x].node[y],P[x].node[y+1]))    
+                                 {
+                                     ans++;
+                                     break;
+                                 }
+                             }
+                         }
+                         if(ans>max) max=ans;
+                     }
+                 }
+             }
+         }
+         printf("Case %d: %d\n",cases++,max);
+    }
+    return 0;
+}
diff --git a/HDOJ/3954_autoAC.cpp b/HDOJ/3954_autoAC.cpp
new file mode 100644
index 0000000..a3e6fde
--- /dev/null
+++ b/HDOJ/3954_autoAC.cpp
@@ -0,0 +1,139 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+#define LL(x) (x<<1)
+#define RR(x) (x<<1|1)
+#define MID(a,b) (a+((b-a)>>1))
+#define INF (1<<30)
+const int N=10000+5;
+typedef long long LL;
+struct node
+{
+    int lft,rht;
+    LL level,mx,flag,need;
+    int mid(){return MID(lft,rht);}
+    void init(){level=1;mx=0;flag=0;}
+    void fun(LL valu)
+    {
+        mx+=level*valu;
+        need-=valu;
+        flag+=valu;
+    }
+};
+int n,m,k;
+LL ned[12];
+struct Segtree
+{
+    node tree[N*4];
+    void down(int ind)
+    {
+        if(tree[ind].flag)
+        {
+            tree[LL(ind)].fun(tree[ind].flag);
+            tree[RR(ind)].fun(tree[ind].flag);
+            tree[ind].flag=0;
+        }
+    }
+    void up(int ind)
+    {
+        tree[ind].mx=max(tree[LL(ind)].mx,tree[RR(ind)].mx);
+        tree[ind].level=max(tree[LL(ind)].level,tree[RR(ind)].level);
+        tree[ind].need=min(tree[LL(ind)].need,tree[RR(ind)].need);
+    }
+    void build(int lft,int rht,int ind)
+    {
+        tree[ind].lft=lft;    tree[ind].rht=rht;
+        tree[ind].init();     tree[ind].need=ned[2];
+        if(lft!=rht)
+        {
+            int mid=tree[ind].mid();
+            build(lft,mid,LL(ind));
+            build(mid+1,rht,RR(ind));
+        }
+    }
+    void updata(int st,int ed,int ind,int valu)
+    {
+        int lft=tree[ind].lft,rht=tree[ind].rht;
+        if(st<=lft&&rht<=ed)
+        {
+            if(valu>=tree[ind].need)
+            {
+                if(lft==rht)
+                {
+                    LL &now=tree[ind].level;
+                    tree[ind].mx+=now*valu;
+                    while(tree[ind].mx>=ned[now+1]) now++;
+                    LL tmp=ned[now+1]-tree[ind].mx;
+                    tree[ind].need=tmp/now+(tmp%now!=0);
+                }
+                else 
+                {
+                    down(ind);
+                    int mid=tree[ind].mid();
+                    if(st<=mid) updata(st,ed,LL(ind),valu);
+                    if(ed> mid) updata(st,ed,RR(ind),valu);
+                    up(ind);
+                }
+            }
+            else 
+            {
+                tree[ind].fun(valu);
+            }
+        }
+        else 
+        {
+            down(ind);
+            int mid=tree[ind].mid();
+            if(st<=mid) updata(st,ed,LL(ind),valu);
+            if(ed> mid) updata(st,ed,RR(ind),valu);
+            up(ind);
+        }
+    }
+    LL query(int st,int ed,int ind)
+    {
+        int lft=tree[ind].lft,rht=tree[ind].rht;
+        if(st<=lft&&rht<=ed) return tree[ind].mx;
+        else 
+        {
+            down(ind);
+            int mid=tree[ind].mid();
+            LL mx1=0,mx2=0;
+            if(st<=mid) mx1=query(st,ed,LL(ind));
+            if(ed> mid) mx2=query(st,ed,RR(ind));
+            up(ind);
+            return max(mx1,mx2);
+        }
+    }
+}seg;
+int main()
+{
+    int t,t_cnt=0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d%d",&n,&k,&m);
+        ned[1]=0; ned[k+1]=((LL)1<<60);
+        for(int i=2;i<=k;i++) scanf("%I64d",&ned[i]);
+        printf("Case %d:\n",++t_cnt);
+        seg.build(1,n,1);
+        while(m--)
+        {
+            char cmd[5];
+            int a,b,c;
+            scanf("%s",cmd);
+            if(cmd[0]=='W')
+            {
+                scanf("%d%d%d",&a,&b,&c);
+                seg.updata(a,b,1,c);
+            }
+            else 
+            {
+                scanf("%d%d",&a,&b);
+                printf("%I64d\n",seg.query(a,b,1));
+            }
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/3955_autoAC.cpp b/HDOJ/3955_autoAC.cpp
new file mode 100644
index 0000000..e1d4ba7
--- /dev/null
+++ b/HDOJ/3955_autoAC.cpp
@@ -0,0 +1,145 @@
+# include<stdio.h>
+# include<string.h>
+# include<stdlib.h>
+# include<queue>
+# define N 105 
+using namespace std; 
+int n,m,MP; 
+bool map[N][N][10]; 
+bool visit[N][N]; 
+int x0,y0,endx,endy; 
+int dir1[6][2]={-1,1, 0,1, 1,1, 1,0, 0,-1, -1,0};
+int dir2[6][2]={-1,0, 0,1, 1,0, 1,-1, 0,-1, -1,-1};
+struct node{
+    int x,y;
+    int sum;
+    bool operator<(const node &b) const
+    {
+        return b.sum <  sum; 
+    } 
+};
+int MIN(int a,int b)
+{
+    return a<b?a:b;
+}
+bool is(int xx,int yy)
+{
+    if(xx<0 || xx>=n || yy<0 || yy>=m) return 0;
+    return 1; 
+} 
+bool is1(int xx,int yy)
+{
+    int i,x1,y1; 
+    if(xx%2==1)
+    {
+        for(i=0;i<6;i++)
+        {
+            x1=xx+dir1[i][0];
+            y1=yy+dir1[i][1];
+            if(is(x1,y1) && map[x1][y1][3]) return 1; 
+        } 
+        return 0; 
+    } 
+    else
+    {
+        for(i=0;i<6;i++)
+        {
+            x1=xx+dir2[i][0];
+            y1=yy+dir2[i][1];
+            if(is(x1,y1) && map[x1][y1][3]) return 1; 
+        } 
+        return 0;
+    } 
+} 
+int bfs()
+{
+    priority_queue<node>q;
+    node cur,next;
+    int i,cost,remain;
+    cur.x=x0;
+    cur.y=y0;
+    cur.sum=0;
+    while(!q.empty()) q.pop(); 
+    q.push(cur); 
+    while(!q.empty())
+    {
+        cur=q.top();
+        q.pop();
+        remain=MP-cur.sum%MP;
+        if(cur.x==endx && cur.y==endy) 
+        {
+            if(remain==MP) return cur.sum/MP;
+            else return cur.sum/MP+1; 
+        } 
+        if(visit[cur.x][cur.y]) continue;
+        visit[cur.x][cur.y]=1; 
+        for(i=0;i<6;i++)
+        {
+            if(cur.x%2==1)
+            {
+                next.x=cur.x+dir1[i][0];
+                next.y=cur.y+dir1[i][1]; 
+            } 
+            else
+            {
+                next.x=cur.x+dir2[i][0];
+                next.y=cur.y+dir2[i][1]; 
+            } 
+            if(!(is(next.x,next.y)) || map[next.x][next.y][3]) continue;
+            if(is1(cur.x,cur.y) && is1(next.x,next.y)) 
+            {
+                next.sum=cur.sum+remain;
+                q.push(next);
+            }
+            else if(map[cur.x][cur.y][2] && map[next.x][next.y][2])
+            {
+                next.sum=cur.sum+1;
+                q.push(next);
+            }
+            else if(map[cur.x][cur.y][i+4])
+            {
+                next.sum=cur.sum+remain;
+                q.push(next);
+            }
+            else 
+            {
+                if(map[next.x][next.y][0]) cost=1;
+                else cost=2;
+                cost *=4;
+                next.sum=cur.sum+MIN(cost,remain);
+                q.push(next);
+            }
+        } 
+    } 
+    return -1;
+} 
+int main()
+{
+    int i,j,ncase,t,k;
+    int a[10],ans;
+    a[0]=1;
+    for(i=1;i<10;i++)
+    a[i]=a[i-1]*2; 
+    scanf("%d",&ncase);
+    for(t=1;t<=ncase;t++)
+    {
+        scanf("%d%d%d",&n,&m,&MP);
+        MP*=4;
+        memset(map,0,sizeof(map)); 
+        for(i=0;i<n;i++)
+        for(j=0;j<m;j++)
+        { 
+            scanf("%d",&ans); 
+            for(k=9;k>=0;k--)
+            if(ans>=a[k])
+            {
+                map[i][j][k]=1;
+                ans-=a[k]; 
+            }  
+        } 
+        scanf("%d%d%d%d",&x0,&y0,&endx,&endy); 
+        memset(visit,0,sizeof(visit)); 
+        printf("Case %d: %d\n",t,bfs()); 
+    } 
+    return 0; 
+}
diff --git a/HDOJ/3957_autoAC.cpp b/HDOJ/3957_autoAC.cpp
new file mode 100644
index 0000000..2574ba4
--- /dev/null
+++ b/HDOJ/3957_autoAC.cpp
@@ -0,0 +1,151 @@
+# include<stdio.h>
+# include<string.h>
+# define cc 100
+# define rr 60
+# define V 6000
+int U[V],D[V];
+int L[V],R[V];
+int C[V],ROW[V];
+int H[rr],S[cc];
+int mark[rr],visit[27],size,ak;
+struct node{
+    int m;
+    int num1,num2;
+    int a[11][2],b[11][2];
+}s[27];
+void Link(int r,int c)
+{
+    S[c]++;
+    C[size]=c;
+    ROW[size]=r;
+    U[size]=U[c];D[U[c]]=size;
+    D[size]=c;U[c]=size;
+    if(H[r]==-1) H[r]=L[size]=R[size]=size;
+    else
+    {
+        L[size]=L[H[r]];R[L[H[r]]]=size;
+        R[size]=H[r];L[H[r]]=size;
+    }
+    size++;
+}
+void remove(int c)
+{
+    int i;
+    for(i=D[c];i!=c;i=D[i])
+    {
+        L[R[i]]=L[i];
+        R[L[i]]=R[i];
+    }
+}
+void resume(int c)
+{
+    int i;
+    for(i=U[c];i!=c;i=U[i])
+        L[R[i]]=R[L[i]]=i;
+}
+int h()
+{
+    int i,j,k,count=0;
+    bool hash[cc];
+    memset(hash,0,sizeof(hash));
+    for(i=R[0];i;i=R[i])
+    {
+        if(hash[i]) continue;
+        hash[i]=1;
+        count++;
+        for(j=D[i];j!=i;j=D[j])
+            for(k=R[j];k!=j;k=R[k])
+                hash[C[k]]=1;
+    }
+    return count;
+}
+void Dance(int k)
+{
+    int j,i,c,Min;
+    if(k+h()>=ak) return;
+    if(!R[0]) 
+    {
+        if(k<ak) ak=k;
+        return;
+    }
+    for(Min=rr,i=R[0];i;i=R[i])
+        if(Min>S[i]) Min=S[i],c=i;
+    for(i=D[c];i!=c;i=D[i])
+    {
+        if(visit[mark[ROW[i]]]) continue;
+        visit[mark[ROW[i]]]=1;
+        remove(i);
+        for(j=R[i];j!=i;j=R[j])
+            remove(j);
+        Dance(k+1);
+        for(j=L[i];j!=i;j=L[j])
+            resume(j);
+        resume(i);
+        visit[mark[ROW[i]]]=0;
+    }
+}
+int main()
+{
+    int i,j,ncase,t,n,sum[26],number,mob,k,c,r;
+    scanf("%d",&ncase);
+    for(t=1;t<=ncase;t++)
+    {
+        scanf("%d",&n);
+        sum[0]=1;
+        for(i=0;i<n;i++)
+        {
+            scanf("%d",&s[i].m);
+            scanf("%d",&s[i].num1);
+            for(k=0;k<s[i].num1;k++)
+                scanf("%d%d",&s[i].a[k][0],&s[i].a[k][1]);
+            if(s[i].m==2)
+            {
+                scanf("%d",&s[i].num2);
+                for(k=0;k<s[i].num2;k++)
+                    scanf("%d%d",&s[i].b[k][0],&s[i].b[k][1]);
+            }
+            sum[i+1]=sum[i]+s[i].m;
+        }
+        c=sum[n]-1;
+        for(i=0;i<=c;i++)
+        {
+            S[i]=0;
+            U[i]=D[i]=i;
+            L[i+1]=i;R[i]=i+1;
+        }R[c]=0;
+        size=c+1;
+        r=0;
+        memset(H,-1,sizeof(H));
+        for(i=0;i<n;i++)
+        {
+            r++;
+            mark[r]=i;
+            for(j=0;j<s[i].num1;j++)
+            {
+                number=s[i].a[j][0];
+                mob=s[i].a[j][1];
+                Link(r,sum[number]+mob);
+            }
+            for(j=0;j<s[i].m;j++)
+                Link(r,sum[i]+j);
+            if(s[i].m==2)
+            {
+                r++;
+                mark[r]=i;
+                for(j=0;j<s[i].num2;j++)
+                {
+                    number=s[i].b[j][0];
+                    mob=s[i].b[j][1];
+                    Link(r,sum[number]+mob);
+                }
+                for(j=0;j<s[i].m;j++)
+                    Link(r,sum[i]+j);
+            }
+        }
+        memset(visit,0,sizeof(visit));
+        ak=n;
+        Dance(0);
+        printf("Case %d: %d\n",t,ak);
+    }
+    return 0;
+}
diff --git a/HDOJ/3958_autoAC.cpp b/HDOJ/3958_autoAC.cpp
new file mode 100644
index 0000000..4fcea04
--- /dev/null
+++ b/HDOJ/3958_autoAC.cpp
@@ -0,0 +1,315 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <queue>
+#include <algorithm>
+#include <vector>
+#include <cstring>
+#include <stack>
+#include <cctype>
+#include <utility>   
+#include <map>
+#include <string>  
+#include <climits> 
+#include <set>
+#include <string>    
+#include <sstream>
+#include <utility>   
+#include <ctime>
+using std::priority_queue;
+using std::vector;
+using std::swap;
+using std::stack;
+using std::sort;
+using std::max;
+using std::min;
+using std::pair;
+using std::map;
+using std::string;
+using std::cin;
+using std::cout;
+using std::set;
+using std::queue;
+using std::string;
+using std::stringstream;
+using std::make_pair;
+using std::getline;
+using std::greater;
+using std::endl;
+using std::multimap;
+using std::deque;
+using std::random_shuffle;
+typedef long long LL;
+typedef unsigned long long ULL;
+typedef pair<int, int> PAIR;
+typedef multimap<int, int> MMAP;
+typedef LL TY;
+const int MAXN(10010);
+const int MAXM(5010);
+const int MAXE(10010);
+const int MAXK(6);
+const int HSIZE(13131);
+const int SIGMA_SIZE(26);
+const int MAXH(19);
+const int INFI((INT_MAX-1) >> 1);
+const ULL BASE(31);
+const LL LIM(10000000);
+const int INV(-10000);
+const int MOD(65521);
+template<typename T> void checkmax(T &a, T b){if(b > a) a = b;}
+template<typename T> void checkmin(T &a, T b){if(b < a) a = b;}
+template<typename T> T ABS(const T &a){return a < 0? -a: a;}
+int pre[21][10][MAXN], opt[21][10][MAXN];
+int MM;
+struct HASH_MAP
+{
+    int first[HSIZE], value[MAXN], next[MAXN];
+    LL state[MAXN];
+    int size;
+    void init()
+    {
+        memset(first, -1, sizeof(first));
+        size = 0;
+    }
+    void insert(LL ts, int tv, int x, int y, int pid, int op)
+    {
+        int h = ts%HSIZE;
+        for(int i = first[h]; ~i; i = next[i])
+            if(state[i] == ts)
+            {
+                if(tv > value[i])
+                {
+                    pre[x][y][i] = pid;
+                    opt[x][y][i] = op;
+                    value[i] = tv;
+                }
+                return ;
+            }
+        checkmax(MM, size);
+        pre[x][y][size] = pid;
+        opt[x][y][size] = op;
+        state[size] = ts;
+        value[size] = tv;
+        next[size] = first[h];
+        first[h] = size++;
+    }
+} hm[2];
+HASH_MAP *cur, *last;
+int N, M;
+int code[11], path[11];  
+int Num[8];
+char mp[21][15];
+void decode(LL ts)
+{
+    for(int i = 0; i <= M; ++i)
+    {
+        code[i] = ts&7;
+        path[i] = ts&8;
+        ts >>= 4;
+    }
+}
+LL encode()
+{
+    LL ret = 0;
+    memset(Num, -1, sizeof(Num));
+    int cnt = 0;
+    for(int i = M; i >= 0; --i)
+        if(code[i] == 0)
+            ret = (ret << 4)|path[i];
+        else
+        {
+            if(Num[code[i]] == -1) Num[code[i]] = ++cnt;
+            ret = (ret << 4)|Num[code[i]]|path[i];
+        }
+    return ret;
+}
+void updata(int x, int y, int tv, int pid)
+{
+    int lc = (y == 0)? 0: code[y];
+    int uc = (x == 0)? 0: code[y+1];
+    int lp = (y == 0)? 0: path[y-1];
+    int up = (x == 0)? 0: path[y+1];
+    if(mp[x][y] == 'S' || mp[x][y] == 'T')
+    {
+        if(lc == 0 && uc == 0)
+        {
+            if(lp || up) return;
+            if(x < N-1)
+            {
+                path[y] = 8;
+                code[y] = 7;
+                code[y+1] = 0;
+                cur->insert(encode(), tv+1, x, y, pid, 1);
+            }
+            if(y < M-1)
+            {
+                path[y] = 8;
+                code[y] = 0;
+                code[y+1] = 7;
+                cur->insert(encode(), tv+1, x, y, pid, 1);
+            }
+        }
+        else
+            if(lc == 0 || uc == 0)
+            {
+                if(lc)
+                {
+                    if(up) return;
+                    path[y] = 8;
+                    code[y] = code[y+1] = 0;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+                else
+                {
+                    if(lp) return;
+                    path[y] = 8;
+                    code[y] = code[y+1] = 0;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+            }
+        return;
+    }
+    if(mp[x][y] == 'B')
+    {
+        if(lc == 0 && uc == 0)
+        {
+            path[y] = 0;
+            code[y] = code[y+1] = 0;
+            cur->insert(encode(), tv, x, y, pid, 0);
+        }
+        return;
+    }
+    if(lc == 0 && uc == 0)
+    {
+        path[y] = 0;
+        code[y] = code[y+1] = 0;
+        cur->insert(encode(), tv, x, y, pid, 0);
+        if(x == N-1 || y == M-1) return;
+        if(lp || up) return;
+        path[y] = 8;
+        code[y] = code[y+1] = 7;
+        cur->insert(encode(), tv+1, x, y, pid, 1);
+    }
+    else
+        if(lc == 0 || uc == 0)
+        {
+            if(lc)
+            {
+                if(up) return;
+                if(x < N-1)
+                {
+                    path[y] = 8;
+                    code[y] = lc;
+                    code[y+1] = 0;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+                if(y < M-1)
+                {
+                    path[y] = 8;
+                    code[y] = 0;
+                    code[y+1] = lc;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+            }
+            else
+            {
+                if(lp) return;
+                if(x < N-1)
+                {
+                    path[y] = 8;
+                    code[y] = uc;
+                    code[y+1] = 0;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+                if(y < M-1)
+                {
+                    path[y] = 8;
+                    code[y] = 0;
+                    code[y+1] = uc;
+                    cur->insert(encode(), tv+1, x, y, pid, 1);
+                }
+            }
+        }
+        else
+            if(lc != uc)
+            {
+                path[y] = 8;
+                for(int i = 0; i <= M; ++i)
+                    if(code[i] == uc) code[i] = lc;
+                code[y] = code[y+1] = 0;
+                cur->insert(encode(), tv+1, x, y, pid, 1);
+            }
+}
+void solve()
+{
+    cur = hm;
+    last = hm+1;
+    last->init();
+    last->insert(0, 0, 0, 0, 0, 0);
+    for(int i = 0; i < N; ++i)
+    {
+        int sz = last->size;
+        for(int j = 0; j < sz; ++j)
+            last->state[j] <<= 4;
+        for(int j = 0; j < M; ++j)
+        {
+            cur->init();
+            sz = last->size;
+            for(int k = 0; k < sz; ++k)
+            {
+                decode(last->state[k]);
+                updata(i, j, last->value[k], k);
+            }
+            swap(cur, last);
+        }
+    }
+    int ans = 0, id;
+    for(int i = 0; i < last->size; ++i)
+    {
+        decode(last->state[i]);
+        bool flag(true);
+        for(int j = 0; j <= M; ++j)
+            if(code[j])
+            {
+                flag = false;
+                break;
+            }
+        if(flag)
+        {
+            if(last->value[i] > ans)
+            {
+                ans = last->value[i];
+                id = i;
+            }
+        }
+    }
+    for(int i = 0; i < N; ++i)
+        for(int j = 0; j < M; ++j)
+            if(mp[i][j] == '.')
+                mp[i][j] = 'W';
+    for(int i = N-1; i >= 0; --i)
+        for(int j = M-1; j >= 0; --j)
+        {
+            if(mp[i][j] == 'W' && opt[i][j][id]) mp[i][j] = '.';
+            id = pre[i][j][id];
+        }
+    printf("%d\n", ans);
+    for(int i = 0; i < N; ++i)
+        printf("%s\n", mp[i]);
+    printf("\n");
+}
+int main()
+{
+    int TC, n_case(0);
+    scanf("%d", &TC);
+    while(TC--)
+    {
+        scanf("%d%d", &N, &M);
+        for(int i = 0; i < N; ++i)
+            scanf("%s", mp[i]);
+        printf("Case %d: ", ++n_case);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3959_autoAC.cpp b/HDOJ/3959_autoAC.cpp
new file mode 100644
index 0000000..74354fc
--- /dev/null
+++ b/HDOJ/3959_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<stdio.h>
+long long gcd(long long a,long long b)
+{
+    if(b==0) return a;
+    return gcd(b,a%b);
+}
+int main()
+{
+    int s,m,n,i,j,count=1;
+    long long sum,t;
+    scanf("%d",&s);
+    while(s--)
+    {
+        sum=1;
+        scanf("%d %d",&n,&m);
+        for(i=1;i<=110;i++)
+        {
+            sum=sum*m;
+            if(sum>=n) break;
+        }
+        sum=sum*i;
+        t=gcd(sum,n);
+        sum=sum/t;n=n/t;
+        printf("Case %d: %lld/%d\n",count++,sum,n);
+    }
+    return 0;
+}
diff --git a/HDOJ/3961_autoAC.cpp b/HDOJ/3961_autoAC.cpp
new file mode 100644
index 0000000..1db4a6e
--- /dev/null
+++ b/HDOJ/3961_autoAC.cpp
@@ -0,0 +1,125 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+#define sqr(x) ((x)*(x))
+using namespace std;
+typedef long long ll;
+const double eps=1e-9;
+const double pi=acos(-1.0);
+struct point
+{
+    double x, y;
+    point() {}
+    point(double xx, double yy):x(xx), y(yy) {}
+    point operator + (const point &a) const
+    {
+        return point(x+a.x, y+a.y);
+    }
+    point operator - (const point &a) const
+    {
+        return point(x-a.x, y-a.y);
+    }
+} po[105], cen, s, e, tp[105];
+double r;
+int t1, t2, t;
+int n, pn;
+point cg()
+{
+    point p, s, re;
+    re.x=0.0;
+    re.y=0.0;
+    double area=0.0, ar;
+    p=po[0];
+    po[n]=po[0];
+    for(int i=1; i<=n; i++)
+    {
+        s=po[i];
+        ar=p.x*s.y-s.x*p.y;
+        area+=(ar/2);
+        re.x+=(p.x+s.x)*ar;
+        re.y+=(p.y+s.y)*ar;
+        p=s;
+    }
+    re.x/=(6*area);
+    re.y/=(6*area);
+    return re;
+}
+point pointrotate(point o, double ang, point p)
+{
+    point tp;
+    p.x-=o.x;
+    p.y-=o.y;
+    tp.x=p.x*cos(ang)-p.y*sin(ang)+o.x;
+    tp.y=p.y*cos(ang)+p.x*sin(ang)+o.y;
+    return tp;
+}
+double dis(point a, point b)
+{
+    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
+}
+double dot(point sp, point ep, point op)
+{
+    return (sp.x-op.x)*(ep.x-op.x)+(sp.y-op.y)*(ep.y-op.y);
+}
+double cross(point sp, point ep, point op)
+{
+    return (sp.x-op.x)*(ep.y-op.y)-(sp.y-op.y)*(ep.x-op.x);
+}
+double coverdeg(double ang, double d, double r)
+{
+    double neg=1;
+    if(ang<0)
+    {
+        ang=-ang;
+        neg=-1;
+    }
+    double sina=d*sin(ang)/r;
+    if(sina>1)sina=1;
+    return neg*(asin(sina)-ang);
+}
+int main ()
+{
+    int i;
+    while(~scanf("%lf%lf%lf%lf%lf%d%d%d%d", &s.x, &s.y, &e.x, &e.y, &r, &n, &t1, &t2, &t))
+    {
+        for(i=0; i<n; i++)scanf("%lf%lf", &po[i].x, &po[i].y);
+        cen=cg();
+        double a2=(double)(t%t2)/t2*2*pi;
+        for(i=0; i<n; i++)po[i]=pointrotate(cen, a2, po[i]);
+        double a1=(double)(t%t1)/t1*2*pi;
+        point newcen=pointrotate(e, a1, cen);
+        point mov=newcen-cen;
+        for(i=0; i<n; i++)po[i]=po[i]+mov;
+        double se=dis(s, e);
+        double maxang=acos(r/se);
+        double maxarc=2*maxang*r;
+        if(dot(s, newcen, e)<0)
+        {
+            printf("%.2lf\n", maxarc);
+            continue;
+        }
+        double supang=pi*0.5-maxang;
+        point up=po[0], lp=po[0];
+        for(int i=1; i<n; i++)
+        {
+            if(cross(up, po[i], s)>eps)up=po[i];
+            if(cross(lp, po[i], s)<-eps)lp=po[i];
+        }
+        double ua=acos(dot(up, e, s)/(se*dis(s, up)));
+        double la=acos(dot(lp, e, s)/(se*dis(s, lp)));
+        if(cross(e, up, s)<0)ua=-ua;
+        if(cross(e, lp, s)<0)la=-la;
+        double cvua=min(supang, ua), cvla=max(-supang, la);
+        if(cvua<cvla)
+        {
+            printf("%.2lf\n", maxarc);
+            continue;
+        }
+        double coverarc=r*(coverdeg(cvua, se, r)-coverdeg(cvla, se, r));
+        printf("%.2lf\n", maxarc-coverarc);
+    }
+    return 0;
+}
diff --git a/HDOJ/3962_autoAC.cpp b/HDOJ/3962_autoAC.cpp
new file mode 100644
index 0000000..541873e
--- /dev/null
+++ b/HDOJ/3962_autoAC.cpp
@@ -0,0 +1,135 @@
+#include <stdio.h>
+#include <string.h>
+#define MAX 40
+#define MOD 10007
+char dir[MAX];
+int hash[256],n,m,total;
+struct node {
+    int flag,in;
+    node *fail,*next[4];
+}*qu[MAX*MAX],arr[MAX*MAX],*root;
+node *CreateNode() {
+    node *p = &arr[total];
+    p->in = total++;
+    p->flag = 0;
+    p->fail = NULL;
+    for (int i = 0; i < 4; ++i)
+        p->next[i] = NULL;
+    return p;
+}
+void Insert(char *str) {
+    int i = 0,k;
+    node *p = root;
+    while (str[i]) {
+        k = hash[str[i++]];
+        if (p->next[k] == NULL)
+            p->next[k] = CreateNode();
+        p = p->next[k];
+    }
+    p->flag = 1;
+}
+void Build_AC() {
+    int head,tail,i;
+    head = tail = 0;
+    root->fail = root;
+    qu[++head] = root;
+    while (tail < head) {
+        node *p = qu[++tail];
+        for (i = 0; i < 4; ++i) {
+            if (p->next[i] != NULL) {
+                if (p == root) p->next[i]->fail = root;
+                else p->next[i]->fail = p->fail->next[i];
+                qu[++head] = p->next[i];
+                p->next[i]->flag |= p->fail->next[i]->flag;
+            }
+            else {
+                if (p == root) p->next[i] = root;
+                else p->next[i] = p->fail->next[i];
+            }//else
+        }//for
+    }//while
+}//void
+struct Mat{
+    int mat[MAX*2][MAX*2],size;
+    Mat(int n) {size = n,memset(mat,0,sizeof(mat));}
+    Mat(int arr[][MAX*2],int n) { size = n,memcpy(mat,arr,sizeof(arr));}
+    friend Mat operator *(Mat a,Mat b);
+    friend Mat operator +(Mat a,Mat b);
+    friend Mat operator ^(Mat a,int k);
+    friend Mat Sum(Mat a,int k);
+}A(MAX*2),E(MAX*2);
+Mat operator *(Mat a,Mat b) {
+    Mat c(total*2);
+    for (int i = 0; i < c.size; ++i)
+        for (int j = 0; j < c.size; ++j)
+            for (int k = 0; k < c.size; ++k)
+                if (a.mat[i][k] && b.mat[k][j]) {
+                    c.mat[i][j] += a.mat[i][k] * b.mat[k][j];
+                    c.mat[i][j] %= MOD;
+                }
+    return c;
+}
+Mat operator +(Mat a,Mat b) {
+    Mat c(total*2);
+    for (int i = 0; i < c.size; ++i)
+        for (int j = 0; j < c.size; ++j)
+            c.mat[i][j] = (a.mat[i][j] + b.mat[i][j]) % MOD;
+    return c;
+}
+Mat operator ^(Mat a,int k) {
+    Mat c = E;
+    while (k) {
+        if (k & 1) c = c * a;
+        a = a * a,k >>= 1;
+    }
+    return c;
+}
+Mat Sum(Mat A,int k) {
+    if (k == 1) return A;
+    else if (k & 1) return (A^k) * Sum(A,k-1);
+    else return Sum(A,k/2) * ((A^(k/2)) + E);
+}
+void GetMat() {
+    int i,j,k;
+    Mat c(total*2);
+    for (i = 0; i < total; ++i) {
+        for (k = 0; k < 4; ++k) {
+            j = arr[i].next[k]->in;    
+            if (arr[i].next[k]->flag)
+                c.mat[i][j+total]++;
+            else c.mat[i][j]++,c.mat[i+total][j+total]++;
+        }
+    }
+    E = A = c;
+    memset(E.mat,0,sizeof(E.mat));
+    for (i = 0; i < E.size; ++i)
+        E.mat[i][i] = 1;
+}
+int Solve_1A() {
+    int i,j,k,ans,sum;
+    ans = 1,k = n,sum = 4;
+    while (k) {
+        if (k & 1) ans = (ans * sum) % MOD;
+        sum = (sum * sum) % MOD,k >>= 1;
+    }
+    A = A^n;
+    for (i = 0; i < 2 * total; ++i)
+        ans = (ans - A.mat[0][i] + MOD) % MOD;
+    return ans;
+}
+int main()
+{
+    int i,j,k,ans;
+    hash['A'] = 0,hash['T'] = 1;
+    hash['C'] = 2,hash['G'] = 3;
+    while (scanf("%d%d",&m,&n) != EOF) {
+        total = 0;
+        root = CreateNode();
+        for (i = 0; i < m; ++i)
+            scanf("%s",dir),Insert(dir);
+        Build_AC();
+        GetMat();
+        ans = Solve_1A();
+        printf("%d\n",ans % MOD);
+    }
+}
diff --git a/HDOJ/3964_autoAC.cpp b/HDOJ/3964_autoAC.cpp
new file mode 100644
index 0000000..66d3dc4
--- /dev/null
+++ b/HDOJ/3964_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<iostream>
+using namespace std;
+bool map[15][15];
+bool mark[15];
+int val[15];
+int n;
+void dfs(int index,int num,int j)
+{
+    int i;
+    if(num>1&&map[index][j])
+    {
+        for(int k=0;k<num;k++)
+            printf("%d",val[k]);
+        printf("\n");
+    }
+    for(i=j+1;i<n;i++)
+    {
+        if(mark[i]==0&&map[index][i])
+        {
+            mark[i]=1;
+            val[num]=i;
+            dfs(i,num+1,j);
+            mark[i]=0;
+        }
+    }
+}
+int main()
+{
+    int i,j,a;
+    //freopen("a.txt","r",stdin);
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<n;j++)
+            {
+                scanf("%d",&a);
+                if(a==0)map[i][j]=0;
+                else map[i][j]=1;
+            }
+        }
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<n;j++)
+                mark[j]=0;
+            mark[i]=1;
+            val[0]=i;
+            dfs(i,1,i);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3966_autoAC.cpp b/HDOJ/3966_autoAC.cpp
new file mode 100644
index 0000000..05044b4
--- /dev/null
+++ b/HDOJ/3966_autoAC.cpp
@@ -0,0 +1,161 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int MAXN = 50010;
+struct Edge
+{
+    int to,next;
+}edge[MAXN*2];
+int head[MAXN],tot;
+int top[MAXN];
+int fa[MAXN];
+int deep[MAXN];
+int num[MAXN];
+int p[MAXN];
+int fp[MAXN];
+int son[MAXN];
+int pos;
+void init()
+{
+    tot = 0;
+    memset(head,-1,sizeof(head));
+    pos = 1;
+    memset(son,-1,sizeof(son));
+}
+void addedge(int u,int v)
+{
+    edge[tot].to = v; edge[tot].next = head[u]; head[u] = tot++;
+}
+void dfs1(int u,int pre,int d)
+{
+    deep[u] = d;
+    fa[u] = pre;
+    num[u] = 1;
+    for(int i = head[u];i != -1; i = edge[i].next)
+    {
+        int v = edge[i].to;
+        if(v != pre)
+        {
+            dfs1(v,u,d+1);
+            num[u] += num[v];
+            if(son[u] == -1 || num[v] > num[son[u]])
+                son[u] = v;
+        }
+    }
+}
+void getpos(int u,int sp)
+{
+    top[u] = sp;
+    p[u] = pos++;
+    fp[p[u]] = u;
+    if(son[u] == -1) return;
+    getpos(son[u],sp);
+    for(int i = head[u];i != -1;i = edge[i].next)
+    {
+        int v = edge[i].to;
+        if( v != son[u] && v != fa[u])
+            getpos(v,v);
+    }
+}
+int lowbit(int x)
+{
+    return x&(-x);
+}
+int c[MAXN];
+int n;
+int sum(int i)
+{
+    int s = 0;
+    while(i > 0)
+    {
+        s += c[i];
+        i -= lowbit(i);
+    }
+    return s;
+}
+void add(int i,int val)
+{
+    while(i <= n)
+    {
+        c[i] += val;
+        i += lowbit(i);
+    }
+}
+void Change(int u,int v,int val)
+{
+    int f1 = top[u], f2 = top[v];
+    int tmp = 0;
+    while(f1 != f2)
+    {
+        if(deep[f1] < deep[f2])
+        {
+            swap(f1,f2);
+            swap(u,v);
+        }
+        add(p[f1],val);
+        add(p[u]+1,-val);
+        u = fa[f1];
+        f1 = top[u];
+    }
+    if(deep[u] > deep[v]) swap(u,v);
+    add(p[u],val);
+    add(p[v]+1,-val);
+}
+int a[MAXN];
+int main()
+{
+     int M,P;
+    while(scanf("%d%d%d",&n,&M,&P) == 3)
+    {
+        int u,v;
+        int C1,C2,K;
+        char op[10];
+        init();
+        for(int i = 1;i <= n;i++)
+        {
+            scanf("%d",&a[i]);
+        }
+        while(M--)
+        {
+            scanf("%d%d",&u,&v);
+            addedge(u,v);
+            addedge(v,u);
+        }
+        dfs1(1,0,0);
+        getpos(1,1);
+        memset(c,0,sizeof(c));
+        for(int i = 1;i <= n;i++)
+        {
+            add(p[i],a[i]);
+            add(p[i]+1,-a[i]);
+        }
+        while(P--)
+        {
+            scanf("%s",op);
+            if(op[0] == 'Q')
+            {
+                scanf("%d",&u);
+                printf("%d\n",sum(p[u]));
+            }
+            else
+            {
+                scanf("%d%d%d",&C1,&C2,&K);
+                if(op[0] == 'D')
+                    K = -K;
+                Change(C1,C2,K);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3967_autoAC.cpp b/HDOJ/3967_autoAC.cpp
new file mode 100644
index 0000000..56754f6
--- /dev/null
+++ b/HDOJ/3967_autoAC.cpp
@@ -0,0 +1,73 @@
+#include<stdio.h>
+#include<math.h>
+#include<iostream>
+using namespace std;
+__int64 a,b,k,num,dp[20][25],d[20][25],C[20],r[20][25],A[20];
+__int64 dfs(__int64 now,__int64 left)
+{
+    if(now<0) return 0;
+    __int64 sum=0,i,j,ii;
+    for(i=0;i<A[now];i++)
+        r[now][(left*10+i)%k]++;
+    for(j=0;j<k;j++)
+    {
+        for(i=0;i<10;i++)
+            r[now][(j*10+i)%k]+=r[now+1][j];
+        ii=r[now+1][j];
+        if(!j&&ii>0) ii--;
+        sum+=ii*dp[now][((k-j)%k+k)%k];
+    }
+    if(now!=num)
+        sum+=d[now][((k-left)%k+k)%k];
+    sum+=dfs(now-1,(left*10+A[now])%k);
+    return sum;
+}
+void dfs2()
+{
+    __int64 i,j,now;
+    memset(C,0,sizeof(C));
+    C[0]=1%k;
+    for(i=1;i<18;i++)
+        C[i]=(C[i-1]*10)%k;
+    for(i=0;i<=A[0];i++)
+        d[0][i%k]++;
+    for(now=1;now<=num;now++)
+    {
+        for(j=0;j<k;j++)
+        {
+            d[now][(A[now]*C[now]+j)%k]+=d[now-1][j];
+            for(i=0;i<A[now];i++)
+                d[now][(i*C[now]+j)%k]+=dp[now-1][j];
+        }
+    }
+}
+__int64 Cal(__int64 a)
+{
+    __int64 i=0;
+    while(a)
+    {
+        A[i++]=a%10;
+        a/=10;
+    }
+    num=i-1;
+    memset(d,0,sizeof(d));
+    memset(r,0,sizeof(r));
+    dfs2();
+    return dfs(num,0);
+}
+int main()
+{
+    __int64 i,j,ii;
+    while(scanf("%I64d%I64d%I64d",&a,&b,&k)!=EOF)
+    {
+        memset(dp,0,sizeof(dp));
+        for(i=0;i<10;i++)
+            dp[0][i%k]++;
+        for(i=1;i<18;i++)
+            for(ii=0;ii<k;ii++)
+                for(j=0;j<=9;j++)
+                    dp[i][(ii*10+j)%k]+=dp[i-1][ii];
+        printf("%I64d\n",Cal(b)-Cal(a-1));
+    }
+    return 0;
+}
diff --git a/HDOJ/3968_autoAC.cpp b/HDOJ/3968_autoAC.cpp
new file mode 100644
index 0000000..7dd0feb
--- /dev/null
+++ b/HDOJ/3968_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <string>
+#include <cstring>
+#include <set>
+#include <map>
+#include <cstdio>
+#include <queue>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define forn(i, n) for(int i = 0; i < (int)(n); i++)
+#define clr(a, b) memset(a, b, sizeof(a))
+#define SZ(a) ((int)a.size())
+#define PB push_back
+#define MP make_pair
+#define inf 0x3f3f3f3f
+typedef vector<int> vi;
+typedef pair<int, int> pii;
+typedef long long ll;
+#ifdef ecust
+#define R "%lld"
+#else
+#define R "%I64d"
+#endif
+namespace acm {
+double x0, y0, x1, y1;
+double vx, vy;
+double t;
+double fun(double x){
+    return 1.0/9.8*(x/2*sqrt(x*x+vx*vx)+vx*vx/2*log(x+sqrt(x*x+vx*vx)));
+}
+void solve(){
+    scanf("%lf%lf%lf%lf%lf", &x0, &y0, &x1, &y1, &t);
+    if(fabs(t) <= 1e-8) {puts("Impossible."); return;}
+    vx = ((x1 - x0))/t;
+    vy = ((y1 - y0) + 0.5*9.8*t*t)/t;
+    printf("%.3lf\n", fun(vy)-fun(vy-9.8*t));
+}
+void icpc(){
+    int cas; scanf("%d", &cas);
+    while(cas--){
+        solve();
+    }
+}
+}
+int main() {
+    acm::icpc();
+    return 0;
+}
diff --git a/HDOJ/3969_autoAC.cpp b/HDOJ/3969_autoAC.cpp
new file mode 100644
index 0000000..d654912
--- /dev/null
+++ b/HDOJ/3969_autoAC.cpp
@@ -0,0 +1,277 @@
+#include <iostream>
+#include <map>
+#include <algorithm>
+#include <cstdio>
+#include <string>
+#include <cstring>
+using namespace std;
+int main()
+{
+    int i, j, t, n, k;
+    char team1[55], team2[55], tmp[122], tmp1[55][55], tmp2[55][55], fk[9];
+    bool chuchang[3][13];
+    int score[5], pts[5][55], off[5][55], def[5][55], reb[5][55], ast[5][55], pf[5][55], free[5][55][5], three[5][55][5], faqiu[55][55][5], stl[5][55], block[5][55];
+    scanf("%d", &t);
+    while(t--)
+    {
+        memset(chuchang, 0, sizeof(chuchang));
+        memset(score, 0, sizeof(score));
+        memset(pts, 0, sizeof(pts));
+        memset(off, 0, sizeof(off));
+        memset(def, 0, sizeof(def));
+        memset(reb, 0, sizeof(reb));
+        memset(ast, 0, sizeof(ast));
+        memset(pf, 0, sizeof(pf));
+        memset(free, 0, sizeof(free));
+        memset(three, 0, sizeof(three));
+        memset(faqiu, 0, sizeof(faqiu));
+        memset(stl, 0, sizeof(stl));
+        memset(block, 0, sizeof(block));
+        map<string, int>teamnum;
+        map<string, int>num;
+        scanf("%s %s %s", team1, tmp, team2);
+        for(i = 1; i <= 12; i++)
+        {
+            scanf("%s", tmp1[i]);
+            string tmpname = tmp1[i];
+            teamnum[tmpname] = 1;
+            num[tmpname] = i;
+        }
+        for(i = 1; i <= 12; i++)
+        {
+            scanf("%s", tmp2[i]);
+            string tmpname = tmp2[i];
+            teamnum[tmpname] = 2;
+            num[tmpname] = i;
+        }
+        scanf("%d", &n);
+        string pre = "", now = "";
+        bool ispass = 0,  twoout = 0, threeout = 0, fa = 0, fangui = 0;
+        getchar();
+        for(k = 0; k < n; k++)
+        {
+            gets(tmp);
+            if(k == 0 || k == n - 1) continue;
+            string str = tmp;
+            if(str.find("Hold Ball") != -1)
+            {
+                int len = str.length() - 10;
+                string tt = str.substr(0, len);
+                now = tt;
+                fangui = false;
+            }
+            else if(str.find("Pass to") != -1)
+            {
+                string tt = "";
+                int len = str.length();
+                for(i = 0; i < len; i++)
+                {
+                    if(str[i] == ' ') break;
+                    else tt += str[i];
+                }
+                pre = tt;
+                ispass = true;
+                now = str.substr(pre.length() + 9);
+            }
+            else if(str.find("Layup") != -1 || str.find("Slam Dunk") != -1 || str.find("Hook Shot") != -1  || str.find("Jump Shot") != -1 )
+            twoout = true;
+            else if(str.find("3pt Shot") != -1)
+            threeout = true;
+            else if(str.find("Missed") != -1)
+            {
+                if(fa == true)
+                {
+                    faqiu[teamnum[now]][num[now]][2]++;
+                    fa = false;
+                }
+                else if(twoout == true)
+                {
+                    if(!fangui) free[teamnum[now]][num[now]][2]++;
+                    else fangui = false;
+                    twoout = false;
+                }
+                else if(threeout == true)
+                {
+                    if(!fangui)
+                    {
+                        free[teamnum[now]][num[now]][2]++;
+                        three[teamnum[now]][num[now]][2]++;
+                    }
+                    else fangui = false;
+                    threeout = false;
+                }
+                ispass = false;
+            }
+            else if(str.find("Made") != -1)
+            {
+                if(fa == true)
+                {
+                    pts[teamnum[now]][num[now]]++;
+                    score[teamnum[now]]++;
+                    faqiu[teamnum[now]][num[now]][2]++;
+                    faqiu[teamnum[now]][num[now]][1]++;
+                    fa = false;
+                }
+                else if(twoout)
+                {
+                    pts[teamnum[now]][num[now]] += 2;
+                    score[teamnum[now]] += 2;
+                    free[teamnum[now]][num[now]][1]++;
+                    free[teamnum[now]][num[now]][2]++;
+                    if(ispass)
+                    {
+                        ast[teamnum[now]][num[pre]]++;
+                        ispass = false;
+                    }
+                    twoout = false;
+                }
+                else if(threeout)
+                {
+                    pts[teamnum[now]][num[now]] += 3;
+                    score[teamnum[now]] += 3;
+                    free[teamnum[now]][num[now]][1]++;
+                    free[teamnum[now]][num[now]][2]++;
+                    three[teamnum[now]][num[now]][2]++;
+                    three[teamnum[now]][num[now]][1]++;
+                    if(ispass)
+                    {
+                        ast[teamnum[now]][num[pre]]++;
+                        ispass = false;
+                    }
+                    threeout = false;
+                }
+                ispass = false;
+            }
+            else if(str.find("Rebound") != -1)
+            {
+                string tt = "";
+                int len = str.length();
+                for(i = 0; i < len; i++)
+                {
+                    if(str[i] == ' ') break;
+                    else tt += str[i];
+                }
+                if(teamnum[tt] != teamnum[now])
+                {
+                    def[teamnum[tt]][num[tt]]++;
+                    reb[teamnum[tt]][num[tt]]++;
+                }
+                else if(teamnum[tt] == teamnum[now])
+                {
+                    off[teamnum[tt]][num[tt]]++;
+                    reb[teamnum[tt]][num[tt]]++;
+                }
+                now = tt;
+                ispass = false;
+                twoout = false;
+                threeout = false;
+            }
+            else if(str.find("Blocked") != -1)
+            {
+                if(threeout)
+                {
+                    free[teamnum[now]][num[now]][2]++;
+                    three[teamnum[now]][num[now]][2]++;
+                    threeout = false;
+                }
+                else if(twoout)
+                {
+                    free[teamnum[now]][num[now]][2]++;
+                    twoout = false;
+                }
+                string tt = str.substr(11);
+                block[teamnum[tt]][num[tt]]++;
+                ispass = false;
+                twoout = false;
+                threeout = false;
+            }
+            else if(str.find("Foul") != -1)
+            {
+                string tt = "";
+                int len = str.length();
+                for(i = 0; i < len; i++)
+                {
+                    if(str[i] == ' ') break;
+                    else tt += str[i];
+                }
+                pf[teamnum[tt]][num[tt]]++;
+                if(twoout || threeout)
+                    fangui = true;
+            }
+            else if(str.find("Free Throw") != -1)
+            {
+                fa = true;
+                ispass = false;
+            }
+            else if(str.find("Substitution") != -1)
+            {
+                int len = str.find("Substitution") + 25;
+                string tt = str.substr(len);
+                chuchang[teamnum[tt]][num[tt]] = 1;
+                ispass = false;
+                twoout = false;
+                threeout = false;
+            }
+            else if(str.find("Timeout") != -1)
+            ispass = false;
+            else if(str.find("Jump Ball") != -1)
+            ispass = false;
+            else if(str.find("Steal") != -1)
+            {
+                string tt = "";
+                int len = str.length();
+                for(i = 0; i < len; i++)
+                {
+                    if(str[i] == ' ') break;
+                    else tt += str[i];
+                }
+                stl[teamnum[tt]][num[tt]]++;
+                now = tt;
+                ispass = false;
+            }
+        }
+        printf("%s %d-%d %s\n", team1, score[1], score[2], team2);
+        printf("%s\n", team1);
+        puts("              PLAYER PTS OFF DEF REB AST STL BLK PF FGM-A 3PM-A FTM-A");
+        for(i = 1; i <= 12; i++)
+        {
+            if(i <= 5 || chuchang[1][i] == 1)
+            {
+                printf("%20s%4d%4d%4d%4d%4d%4d%4d%3d", tmp1[i], pts[1][i], off[1][i], def[1][i], reb[1][i], ast[1][i], stl[1][i], block[1][i], pf[1][i]);
+                sprintf(fk, "%d-%d", free[1][i][1], free[1][i][2]);
+                printf("%6s", fk);
+                sprintf(fk, "%d-%d", three[1][i][1], three[1][i][2]);
+                printf("%6s", fk);
+                sprintf(fk, "%d-%d", faqiu[1][i][1], faqiu[1][i][2]);
+                printf("%6s\n", fk);
+            }
+            else
+            {
+                printf("%20s", tmp1[i]);
+                puts("          DNP - Coach's Decision");
+            }
+        }
+        printf("%s\n", team2);
+        puts("              PLAYER PTS OFF DEF REB AST STL BLK PF FGM-A 3PM-A FTM-A");
+        for(i = 1; i <= 12; i++)
+        {
+            if(i <= 5 || chuchang[2][i] == 1)
+            {
+                printf("%20s%4d%4d%4d%4d%4d%4d%4d%3d", tmp2[i], pts[2][i], off[2][i], def[2][i], reb[2][i], ast[2][i], stl[2][i], block[2][i], pf[2][i]);
+                sprintf(fk, "%d-%d", free[2][i][1], free[2][i][2]);
+                printf("%6s", fk);
+                sprintf(fk, "%d-%d", three[2][i][1], three[2][i][2]);
+                printf("%6s", fk);
+                sprintf(fk, "%d-%d", faqiu[2][i][1], faqiu[2][i][2]);
+                printf("%6s\n", fk);
+            }
+            else
+            {
+                printf("%20s", tmp2[i]);
+                puts("          DNP - Coach's Decision");
+            }
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/3971_autoAC.cpp b/HDOJ/3971_autoAC.cpp
new file mode 100644
index 0000000..9ecb202
--- /dev/null
+++ b/HDOJ/3971_autoAC.cpp
@@ -0,0 +1,110 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+namespace ST
+{
+    typedef long long LL;
+    const int maxn = 300010;
+    LL a[maxn];
+    LL Min[maxn<<2], Max[maxn<<2], add[maxn<<2];
+    inline void pushUp(int rt)
+    {
+        Max[rt] = max(Max[rt<<1], Max[rt<<1|1]);
+        Min[rt] = min(Min[rt<<1], Min[rt<<1|1]); 
+    }
+    inline void modify(int rt, LL c)
+    {
+        add[rt] += c;
+        Max[rt] += c;
+        Min[rt] += c;
+    }
+    inline void pushDown(int rt)
+    {
+        modify(rt << 1, add[rt]);
+        modify((rt << 1) | 1, add[rt]);
+        add[rt] = 0;
+    }
+    void build(int l, int r, int rt)
+    {
+        add[rt] = 0;
+        if (l == r) {
+            Max[rt] = Min[rt] = a[l];
+            return ;
+        }
+        int m = (l + r) >> 1;
+        build(l, m, rt << 1);
+        build(m + 1, r, (rt << 1) | 1);
+        pushUp(rt);
+    }
+    void update(int l, int r, int rt, LL L, LL R, LL D)
+    {
+        if (L > Max[rt] || R < Min[rt]) return ;
+        if (L <= Min[rt] && R >= Max[rt]) {
+            modify(rt, D);
+            return ;
+        }
+        if (l == r) return ;
+        int m = (l + r) >> 1;
+        pushDown(rt);
+        update(l, m, rt << 1, L, R, D); 
+        update(m + 1, r, (rt << 1) | 1, L, R, D); 
+        pushUp(rt);
+    }
+    int query(int l, int r, int rt, LL L, LL R)
+    {
+        if (L > Max[rt] || R < Min[rt]) {
+            return 0;
+        }
+        if (L <= Min[rt] && R >= Max[rt]) {
+            return r - l + 1;
+        }
+        if (l == r) return 0;
+        int m = (l + r) >> 1;
+        pushDown(rt);
+        return query(l, m, rt << 1, L, R) + query(m + 1, r, (rt << 1) | 1, L, R);
+    }
+    void getNewArr(int l, int r, int rt)
+    {
+        if (l == r) {
+            a[l] = Max[rt];
+            return ;
+        }
+        int m = (l + r) >> 1;
+        pushDown(rt);
+        getNewArr(l, m, rt << 1);
+        getNewArr(m + 1, r, (rt << 1) | 1);
+    }
+} 
+int main()
+{
+    using namespace ST;
+    int n, m;
+    char op[2];
+    long long L, R, D;
+    while (scanf("%d%d", &n, &m) != EOF) {
+        for (int i = 1; i <= n; ++i) {
+            scanf("%lld", &a[i]);
+        }
+        sort(a + 1, a + n + 1);
+        build(1, n, 1);
+        while (m--) {
+            scanf("%s", op);
+            if (op[0] == 'C') {
+                scanf("%lld%lld%lld", &L, &R, &D);
+                update(1, n, 1, L, R, D);
+            } else {
+                scanf("%lld%lld", &L, &R);
+                printf("%d\n", query(1, n, 1, L, R));
+            }
+            if (m % 4500 == 0) {
+                getNewArr(1, n, 1);
+                sort(a + 1, a + n + 1);
+                build(1, n, 1);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3973_autoAC.cpp b/HDOJ/3973_autoAC.cpp
new file mode 100644
index 0000000..941c438
--- /dev/null
+++ b/HDOJ/3973_autoAC.cpp
@@ -0,0 +1,88 @@
+#include<cstdio>  
+#include<cstring>  
+#include<map>  
+#define maxn 100010  
+#define p 33  
+using namespace std;  
+typedef unsigned long long ll;  
+struct Tree{  
+    int l,r;  
+    ll hashes;  
+}tree[300000];  
+char str[2000100];  
+ll hh[maxn];  
+void init(){  
+    int i;  
+    hh[0]=1;  
+    for(i=1;i<=maxn;i++)  
+        hh[i]=hh[i-1]*p;  
+}  
+ll calhash(){  
+    int i,len=strlen(str);  
+    ll sum=0;  
+    for(i=0;i<len;i++)  
+        sum=sum*p+str[i]-'a'+1;  
+    return sum;  
+}  
+void build(int s,int t,int id){  
+    tree[id].l=s;tree[id].r=t;  
+    if(s==t){  
+        tree[id].hashes=str[s]-'a'+1;  
+        return;  
+    }  
+    int mid=(s+t)>>1;  
+    build(s,mid,id<<1);  
+    build(mid+1,t,id<<1|1);  
+    tree[id].hashes=tree[id<<1].hashes*hh[t-mid]+tree[id<<1|1].hashes;  
+}  
+void update(int l,int id){  
+    if(tree[id].l==tree[id].r){  
+        tree[id].hashes=str[l]-'a'+1;  
+        return ;  
+    }  
+    int mid=(tree[id].l+tree[id].r)>>1;  
+    if(l<=mid) update(l,id<<1);  
+    else update(l,id<<1|1);  
+    tree[id].hashes=tree[id<<1].hashes*hh[tree[id].r-mid]+tree[id<<1|1].hashes;  
+}  
+ll query(int s,int t,int id){  
+    if(tree[id].l==s && tree[id].r==t)  
+        return tree[id].hashes;  
+    int mid=(tree[id].l+tree[id].r)>>1;  
+    if(t<=mid) return query(s,t,id<<1);  
+    else if(s>mid) return query(s,t,id<<1|1);  
+    return query(s,mid,id<<1)*hh[t-mid]+query(mid+1,t,id<<1|1);  
+}  
+int main(){  
+    int t,T,pos,l,r,i,q,n;  
+    char s1[10],s2[10];  
+    map<ll,int>mp;  
+    init();  
+    scanf("%d",&T);  
+    for(t=1;t<=T;t++){  
+        printf("Case #%d:\n",t);  
+        scanf("%d",&n);  
+        mp.clear();  
+        for(i=1;i<=n;i++){  
+            scanf("%s",str);  
+            mp.insert(make_pair(calhash(),1));  
+        }  
+        scanf("%s",str);  
+        int len=strlen(str);  
+        build(0,len-1,1);  
+        scanf("%d",&q);  
+        for(i=1;i<=q;i++){  
+            scanf("%s",s1);  
+            if(s1[0]=='C'){  
+                scanf("%d%s",&pos,s2);  
+                str[pos]=s2[0];  
+                update(pos,1);  
+            }  
+            else{  
+                scanf("%d %d",&l,&r);  
+                if(mp.find(query(l,r,1))!=mp.end()) printf("Yes\n");  
+                else printf("No\n");  
+            }  
+        }  
+    }  
+}
diff --git a/HDOJ/3974_autoAC.cpp b/HDOJ/3974_autoAC.cpp
new file mode 100644
index 0000000..19d0fb2
--- /dev/null
+++ b/HDOJ/3974_autoAC.cpp
@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <iostream>
+using namespace std;
+const int MAX = 50010;
+struct NODE
+{
+    int task,count;
+};
+NODE p[MAX];
+int parent[MAX];
+void init()
+{
+    memset(parent,-1,sizeof(parent));
+}
+int main()
+{
+    int ncases,n,u,v,m,x,task;
+    char s[5];    
+    scanf("%d",&ncases);    
+    int ind=1;
+    while(ncases--)
+    {
+        scanf("%d",&n);
+        init();
+        int i;
+        for(i=0;i<n-1;i++)
+        {
+            scanf("%d%d",&u,&v);
+            parent[u]=v;
+        }
+        for(i=1;i<=n;i++)
+        {
+            p[i].task=-1;
+            p[i].count=-1;
+        }        
+        scanf("%d",&m);        
+        printf("Case #%d:\n",ind++);
+        int count=0;
+        while(m--)
+        {
+            scanf("%s",s);
+            if(s[0]=='T')
+            {
+                scanf("%d%d",&x,&task);
+                p[x].task=task;
+                p[x].count=++count;
+            }
+            else
+            {
+                scanf("%d",&x);
+                task=p[x].task;
+                int count=p[x].count;
+                while(x!=-1)
+                {
+                    if(p[x].count>count)
+                    {
+                        task=p[x].task;
+                        count=p[x].count;
+                    }
+                    x=parent[x];
+                }
+                printf("%d\n",task);
+            }
+        }
+    }
+return 0;
+}
diff --git a/HDOJ/3975_autoAC.cpp b/HDOJ/3975_autoAC.cpp
new file mode 100644
index 0000000..174924c
--- /dev/null
+++ b/HDOJ/3975_autoAC.cpp
@@ -0,0 +1,40 @@
+#include<stdio.h>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+#define EPS 1e-8
+int main(){
+    int t,i,ca=1;
+    scanf("%d",&t);
+    double ti,g=10;
+    double x0[3],vx[3],vy[3],d[3],v[3];
+    double a,b,t1,c;
+    while(t--){
+        for(i=0;i<3;i++)scanf("%lf",x0+i);
+        for(i=0;i<3;i++)scanf("%lf",v+i);
+        for(i=0;i<3;i++)scanf("%lf",d+i);
+        for(i=0;i<3;i++){
+            vx[i]=v[i]*cos(d[i]);
+            vy[i]=v[i]*sin(d[i]);
+            if(i==0 || ti>2*vy[i]/g)
+                ti=2*vy[i]/g;
+        }
+        a=(vx[0]-vx[1])*(vy[1]-vy[2])-((vx[1]-vx[2])*(vy[0]-vy[1]));
+        b=(x0[0]-x0[1])*(vy[1]-vy[2])-(x0[1]-x0[2])*(vy[0]-vy[1]);
+        printf("Case #%d: ",ca++);
+        if(ti<EPS)
+            printf("-1\n");
+        else if(fabs(a)<EPS && fabs(b)<EPS)
+            printf("Multiply answer\n");
+        else if(fabs(a)<EPS)
+            printf("-1\n");
+        else{
+            t1=-b/a;
+            if(t1>EPS && ti-t1>-EPS )
+                printf("%.4lf\n",t1+EPS);
+            else
+                printf("-1\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3976_autoAC.cpp b/HDOJ/3976_autoAC.cpp
new file mode 100644
index 0000000..ca54707
--- /dev/null
+++ b/HDOJ/3976_autoAC.cpp
@@ -0,0 +1,79 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const double eps = 1e-9;
+const int MAXN = 100;
+double a[MAXN][MAXN],x[MAXN];
+int equ,var;
+int Gauss()
+{
+    int i,j,k,col,max_r;
+    for(k = 0,col = 0;k < equ && col < var;k++,col++)
+    {
+        max_r = k;
+        for(i = k+1;i < equ;i++)
+            if(fabs(a[i][col]) > fabs(a[max_r][col]))
+                max_r = i;
+        if(fabs(a[max_r][col]) < eps)return 0;
+        if(k != max_r)
+        {
+            for(j = col;j < var;j++)
+                swap(a[k][j],a[max_r][j]);
+            swap(x[k],x[max_r]);
+        }
+        x[k]/=a[k][col];
+        for(j = col+1;j < var;j++)a[k][j]/=a[k][col];
+        a[k][col] = 1;
+        for(int i = 0;i < equ;i++)
+            if(i != k)
+            {
+                x[i] -=  x[k]*a[i][k];
+                for(j = col+1;j < var;j++)a[i][j] -= a[k][j]*a[i][col];
+                a[i][col] = 0;
+            }
+    }
+    return 1;
+}
+int main()
+{
+    int n,m;
+    int T;
+    int iCase = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d",&n,&m);
+        equ = var = n;
+        memset(a,0,sizeof(a));
+        int u,v,w;
+        for(int i = 0;i < m;i++)
+        {
+            scanf("%d%d%d",&u,&v,&w);
+            a[u-1][v-1] += 1.0/w;
+            a[u-1][u-1] += -1.0/w;
+            a[v-1][u-1] += 1.0/w;
+            a[v-1][v-1] += -1.0/w;
+        }
+        for(int i = 0;i < n-1;i++)
+            x[i] = 0;
+        x[0] = 1;
+        for(int i = 0;i < n;i++)
+            a[n-1][i] = 0;
+        x[n-1] = 0;
+        a[n-1][0] = 1;
+        Gauss();
+        printf("Case #%d: %.2lf\n",iCase,x[n-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3977_autoAC.cpp b/HDOJ/3977_autoAC.cpp
new file mode 100644
index 0000000..7d8d4a8
--- /dev/null
+++ b/HDOJ/3977_autoAC.cpp
@@ -0,0 +1,207 @@
+#include <stdio.h>
+#include <algorithm>
+#include <math.h>
+#include <string.h>
+#include <vector>
+using namespace std;
+#define MAXN 1000005
+int prime[MAXN];
+int p[MAXN];
+int s[MAXN];
+vector <int> pmo[MAXN];
+int up;
+int tag[MAXN];
+int ttt[MAXN];
+int answer[MAXN];
+typedef struct
+{
+    long long m[2][2];
+}Matrix;
+void Prime()
+{
+    long long i,k;
+    up=0;
+    memset(prime,0,sizeof(prime));
+    for (i=2;i<=MAXN-3;i++)
+    {
+        if (prime[i]==1) continue;
+        k=i;
+        while(k*i<MAXN-2)
+        {
+            prime[i*k]=1;
+            k++;
+        }
+        p[up++]=i;
+        prime[i]=up-1;
+    }
+}
+Matrix Mul(Matrix a,Matrix b,int mod)
+{
+    Matrix c;
+    int i,j,k;
+    for (i=0;i<2;i++)
+    {
+        for (j=0;j<2;j++)
+        {
+            c.m[i][j]=0;
+            for (k=0;k<2;k++)
+            {
+                c.m[i][j]=(c.m[i][j]+a.m[i][k]*b.m[k][j])%mod;
+            }
+        }
+    }
+    return c;
+}
+long long CountFib(int t,int mod)
+{
+    Matrix a,b;
+    int k=t;
+    a.m[0][0]=a.m[0][1]=a.m[1][0]=b.m[0][0]=1;
+    a.m[1][1]=b.m[1][0]=b.m[0][1]=b.m[1][1]=0;
+    while(t)
+    {
+        if (t&1)
+        {
+            b=Mul(a,b,mod);
+        }
+        a=Mul(a,a,mod);
+        t>>=1;
+    }
+    return b.m[0][0];
+}
+int num[100][2];
+int ret;
+int now=0;
+int Multi(int t,int n)
+{
+    int ans=1;
+    while(n)
+    {
+        if (n&1) ans=ans*t;
+        t=t*t;
+        n>>=1;
+    }
+    return ans;
+}
+void DFS(int t,int mod,int mul)
+{
+    int j;
+    if (mul>=ret) return;
+    if (t==now)
+    {
+        if (CountFib(mul,mod)==1 && CountFib(mul+1,mod)==1) ret=mul;
+        return;
+    }
+    for (j=0;j<=num[t][1];j++)
+    {
+        if (num[t][0]==2 && j==0) continue;
+        int k=mul*Multi(num[t][0],j);
+        DFS(t+1,mod,k);
+    }
+}
+int DT(int t,int mod)
+{
+    int i;
+    ret=t;
+    now=0;
+    for (i=0;i<up;i++)
+    {
+        if (t%p[i]!=0) continue;
+        num[now][0]=p[i];
+        num[now][1]=0;
+        while(t%p[i]==0)
+        {
+            num[now][1]++;
+            t/=p[i];
+        }
+        now++;
+        if (t==1) break;
+    }
+    if (t!=1)
+    {
+        num[now][0]=t;
+        num[now++][1]=1;
+    }
+    DFS(0,mod,1);
+    return ret;
+}
+int Count(int t)
+{
+    int i,k,j;
+    if (t==2)
+    {
+        return 3;
+    }
+    else if (t==5)
+    {
+        return 20;
+    }
+    if (t%10==1 || t%10==9) k=t-1;
+    if (t%10==3 || t%10==7) k=t*2+2;
+    return DT(k,t);
+}
+int fj[50][2];
+int main()
+{
+    int i,j,m,T,cnt;
+    long long n;
+    Prime();
+    scanf("%d",&T);
+    cnt=1;
+    while(T--)
+    {
+        scanf("%I64d",&n);
+        m=0;
+        for (i=0;i<up;i++)
+        {
+            if (n%p[i]==0)
+            {
+                fj[m][0]=p[i];
+                fj[m][1]=0;
+                while(n%p[i]==0)
+                {
+                    fj[m][1]++;
+                    n/=p[i];
+                }
+                m++;
+            }
+            if (n==1) break;
+        }
+        memset(answer,0,sizeof(answer));
+        int mm=0;
+        for (i=0;i<m;i++)
+        {
+            memset(tag,0,sizeof(tag));
+            if (fj[i][1]>0)
+            {
+                mm=max(prime[fj[i][0]],mm);
+                tag[prime[fj[i][0]]]+=fj[i][1]-1;
+            }
+            int tt=Count(fj[i][0]);
+            for (j=0;j<up;j++)
+            {
+                while(tt%p[j]==0)
+                {
+                    tt/=p[j];
+                    tag[j]++;
+                    mm=max(mm,j);
+                }
+                if (tt==1) break;
+            }
+            for (j=0;j<=mm;j++)
+            {
+                answer[j]=max(tag[j],answer[j]);
+            }
+        }
+        long long pr=1;
+        for (i=0;i<=mm;i++)
+        {
+            for (j=0;j<answer[i];j++)
+            {
+                pr*=p[i];
+            }
+        }
+        printf("Case #%d: %I64d\n",cnt++,pr);
+    }
+    return 0;
+}
diff --git a/HDOJ/3978_autoAC.cpp b/HDOJ/3978_autoAC.cpp
new file mode 100644
index 0000000..5786c3a
--- /dev/null
+++ b/HDOJ/3978_autoAC.cpp
@@ -0,0 +1,197 @@
+#include <cstdio>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+#include <map>
+using namespace std;
+#define maxn 10010
+typedef long long LL;
+int prime[maxn];
+map<LL,LL>pika;
+void Prime(){
+    memset(prime,0,sizeof(prime));
+    for(int i=2;i<maxn;i++){
+        if(!prime[i]) prime[++prime[0]]=i;
+        for(int j=1;j<=prime[0]&&prime[j]<maxn/i;j++){
+            prime[prime[j]*i]=1;
+            if(i%prime[j]==0){
+                break;
+            }
+        }
+    }
+}
+LL factor[100][2];
+int fatcnt;
+int get_factors(LL n){
+    fatcnt=0;
+    LL tmp=n;
+    for(int i=1;prime[i]<=tmp/prime[i];i++){
+        factor[fatcnt][1]=0;
+        if(tmp%prime[i]==0){
+            factor[fatcnt][0]=prime[i];
+            while(tmp%prime[i]==0){
+                tmp/=prime[i];
+                factor[fatcnt][1]++;
+            }
+            fatcnt++;
+        }
+    }
+    if(tmp!=1){
+        factor[fatcnt][0]=tmp;
+        factor[fatcnt][1]=1;
+        fatcnt++;
+    }
+    return fatcnt;
+}
+LL gcd(LL a,LL b){
+    if(b==0){
+        return a;
+    }
+    else{
+        return gcd(b,a%b);
+    }
+}
+LL lcm(LL a,LL b){
+    return a/gcd(a,b)*b;
+}
+struct Matrix{
+    LL m[2][2];
+}E,D;
+Matrix Multi(Matrix A,Matrix B,LL mod){
+    Matrix ans;
+    for(int i=0;i<2;i++){
+        for(int j=0;j<2;j++){
+            ans.m[i][j]=0;
+            for(int k=0;k<2;k++){
+                ans.m[i][j]+=(A.m[i][k]*B.m[k][j])%mod;
+                if(ans.m[i][j]>=mod){
+                    ans.m[i][j]-=mod;
+                }
+            }
+        }
+    }
+    return ans;
+}
+void init(){
+    memset(E.m,0,sizeof(E.m));
+    memset(D.m,0,sizeof(D.m));
+    D.m[0][0]=D.m[0][1]=D.m[1][0]=1;
+    for(int i=0;i<2;i++){
+        E.m[i][i]=1;
+    }
+    Prime();
+}
+Matrix Pow(Matrix A,LL e,LL mod){
+    Matrix ans=E;
+    while(e){
+        if(e&1){
+            ans=Multi(ans,A,mod);
+        }
+        A=Multi(A,A,mod);
+        e>>=1;
+    }
+    return ans;
+}
+LL Pow(LL a,LL b,LL mod){
+    LL ans=1;
+    while(b){
+        if(b&1){
+            ans=(ans*a)%mod;
+        }
+        a=(a*a)%mod;
+        b>>=1;
+    }
+    return ans;
+}
+int legendre(LL a,LL p){
+    if(Pow(a,(p-1)>>1,p)==1){
+        return 1;
+    }
+    else{
+        return -1;
+    }
+}
+int f0=1,f1=1;
+LL get_fib(LL n,LL mod)
+{
+    if(mod==1) return 0;
+    return Pow(D,n,mod).m[0][0]%mod;
+}
+LL fac[maxn],GG[maxn];
+LL G(LL p)
+{
+    if(p<maxn && GG[p]!=-1) return GG[p];
+    LL num;
+    if(legendre(5,p)==1){
+        num=p-1;
+    }
+    else{
+        num=2*(p+1);
+    }
+    int cnt=0;
+    for(LL i=1;i*i<=num;i++){
+        if(num%i==0){
+            fac[cnt++]=i;
+            if(i*i!=num){
+                fac[cnt++]=num/i;
+            }
+        }
+    }
+    sort(fac,fac+cnt);
+    LL ans;
+    for(int i=0;i<cnt;i++){
+        if(get_fib(fac[i],p)==f0&&get_fib(fac[i]+1,p)==f1){
+            ans=fac[i];
+            break;
+        }
+    }
+    if(p<maxn) GG[p]=ans;
+    return ans;
+}
+LL find_loop(LL n)
+{
+    if(pika.count(n)){
+        return pika[n];
+    }
+    get_factors(n);
+    LL ans=1;
+    for(int i=0;i<fatcnt;i++)
+    {
+        LL record=1;
+        if(factor[i][0]==2) record=3;
+        else if(factor[i][0]==3) record=8;
+        else if(factor[i][0]==5) record=20;
+        else  record=G(factor[i][0]);
+        for(int j=1;j<factor[i][1];j++)
+            record*=factor[i][0];
+        ans=lcm(ans,record);
+    }
+    return pika[n]=ans;
+}
+LL loop[10010];
+void solve(LL p,LL k){
+    loop[0]=p;
+    for(int i=1;i<=k;i++){
+        loop[i]=find_loop(loop[i-1]);
+    }
+}
+int main()
+{
+    pika.clear();
+    init();
+    memset(GG,-1,sizeof(GG));
+    int T,cas=0;
+    scanf("%d",&T);
+    LL n,p,k;
+    while(T--)
+    {
+        scanf("%I64d%I64d%I64d",&n,&k,&p);
+        solve(p,k);
+        for(int i=k;i>=0;i--){
+            n=get_fib(n,loop[i]);
+        }
+        printf("Case #%d: %I64d\n",++cas,n);
+    }
+    return 0;
+}
diff --git a/HDOJ/3979_autoAC.cpp b/HDOJ/3979_autoAC.cpp
new file mode 100644
index 0000000..80c2de1
--- /dev/null
+++ b/HDOJ/3979_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+struct Node
+{
+    int h,g;
+}node[10010];
+int n,m;
+bool cmp(Node a,Node b)
+{
+    return a.h*b.g < b.h*a.g;
+}
+int main()
+{
+    int T;
+    int iCase = 0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        iCase ++;
+        scanf("%d%d",&n,&m);
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d%d",&node[i].h,&node[i].g);
+            node[i].h = (node[i].h + m - 1)/m;
+        }
+        sort(node,node+n,cmp);
+        long long ans = 0;
+        int cnt = 0;
+        for(int i = 0;i < n;i++)
+        {
+            cnt += node[i].h;
+            ans += (long long)cnt*node[i].g;
+        }
+        printf("Case #%d: %I64d\n",iCase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3980_autoAC.cpp b/HDOJ/3980_autoAC.cpp
new file mode 100644
index 0000000..31ce616
--- /dev/null
+++ b/HDOJ/3980_autoAC.cpp
@@ -0,0 +1,31 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <iostream>
+using namespace std;
+int t, n, m;
+int f[1005];
+bool emerge[1000];
+int get_sg(int len)
+{
+    if(len<m) return f[len]=0;
+    if(f[len]!=-1) return f[len];
+    bool vs[1001]={0};
+    for(int i=0; len-i-m>=0; i++)
+        vs[get_sg(i)^get_sg(len-i-m)]=1;
+    for(int i=0; i<1001; i++)
+        if(!vs[i]) return f[len]=i;
+}
+int main()
+{
+    scanf("%d", &t);
+    for(int ca=1; ca<=t; ca++)
+    {
+        scanf("%d%d", &n, &m);
+        memset(f, -1, sizeof(f));
+        printf("Case #%d: ", ca);
+        if(n<m || get_sg(n-m)) printf("abcdxyzk\n");
+        else printf("aekdycoin\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/3981_autoAC.cpp b/HDOJ/3981_autoAC.cpp
new file mode 100644
index 0000000..9a744a4
--- /dev/null
+++ b/HDOJ/3981_autoAC.cpp
@@ -0,0 +1,101 @@
+#include <iostream>
+#include <string>
+#include <cstring>
+#include <cstdio>
+#include <set>
+#include <map>
+#include <queue>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define forn(i, n) for(int i = 0; i < (int)(n); i++)
+#define clr(a, b) memset(a, b, sizeof(a))
+#define SZ(a) ((int)a.size())
+#define PB push_back
+#define MP make_pair
+#define inf 0x3f3f3f3f
+typedef vector<int> vi;
+typedef pair<int, int> pii;
+typedef long long ll;
+#ifdef ecust
+#define RR "%lld"
+#else
+#define RR "%I64d"
+#endif
+namespace acm {
+int dp[2][220][10][220];
+int T, HS, A, R, U, D, FI, P;
+int des[300];
+void update(int &a, int b) {
+    a = max(a, b);
+}
+void solve() {
+    scanf("%d%d%d%d", &T, &HS, &A, &R);
+    scanf("%d%d%d%d", &U, &D, &FI, &P);
+    forn(i, T)
+        scanf("%d", des + i + 1);
+    clr(dp, 0x3f);
+    forn(i, 2)
+        forn(j, 220)
+            forn(k, 10)
+                forn(l, 220)
+                    dp[i][j][k][l] = -inf;
+    int now = 0;
+    dp[0][HS][0][0] = 0;
+    for (int tt = 1; tt <= T; ++tt) {
+        int fang = des[tt];
+        for (int i = 1; i <= HS; ++i) {
+            for (int j = 0; j <= 6; ++j) {
+                for (int k = 0; k <= T; ++k) {
+                    if (dp[now][i][j][k] == -inf)
+                        continue;
+                    if (i > D) {
+                        int add = A + (HS - i) / R * U;
+                        if (add < fang)
+                            add = 0;
+                        else
+                            add -= fang;
+                        update(dp[now ^ 1][i - D][6][k + 1], dp[now][i][j][k]
+                                + add + FI * k);
+                    }
+                    int add = A + (HS - i) / R * U;
+                    if (add < fang)
+                        add = 0;
+                    else
+                        add -= fang;
+                    if (j - 1 == 0)
+                        update(dp[now ^ 1][i][j - 1][0], dp[now][i][j][k] + add
+                                + FI * k);
+                    else if (j)
+                        update(dp[now ^ 1][i][j - 1][k], dp[now][i][j][k] + add
+                                + FI * k);
+                    else if (j == 0)
+                        update(dp[now ^ 1][i][j][k], dp[now][i][j][k] + add);
+                }
+            }
+        }
+        now = now ^ 1;
+    }
+    int ans = -inf, ans2 = -inf;
+    forn(j, 220)
+        forn(k, 10)
+            forn(l, 220) {
+                if (dp[now ][j][k][l] != inf) {
+                    update(ans, dp[now ][j][k][l] - (HS - j) * P);
+                }
+            }
+    printf("%d\n", ans);
+}
+void icpc() {
+    int nc, nn = 1;
+    scanf("%d", &nc);
+    while (nc--) {
+        printf("Case #%d: ", nn++);
+        solve();
+    }
+}
+}
+int main() {
+    acm::icpc();
+    return 0;
+}
diff --git a/HDOJ/3982_autoAC.cpp b/HDOJ/3982_autoAC.cpp
new file mode 100644
index 0000000..d63a456
--- /dev/null
+++ b/HDOJ/3982_autoAC.cpp
@@ -0,0 +1,267 @@
+#include <set>
+#include <map>
+#include <queue>
+#include <stack>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <limits.h>
+#include <string.h>
+#include <string>
+#include <algorithm>
+#define MID(x,y) ( ( x + y ) >> 1 )
+#define L(x) ( x << 1 )
+#define R(x) ( x << 1 | 1 )
+#define FOR(i,s,t) for(int i=s; i<t; i++)
+#define BUG puts("here!!!")
+using namespace std;
+const int MAX = 2010;
+struct point { 
+    double x,y;
+    void P(double xx, double yy){ x = xx; y = yy;}
+    void get(){ scanf("%lf%lf",&x, &y);}
+};
+struct line { point a,b; double ang;};  
+point s[MAX*2], ch, p[MAX*2];  
+line l[MAX*2],deq[MAX*2];  
+const double eps = 1e-6;  
+const double pi = acos(-1.0);
+bool dy(double x,double y)  {   return x > y + eps;} 
+bool xy(double x,double y)  {   return x < y - eps;}  
+bool dyd(double x,double y) {   return x > y - eps;}   
+bool xyd(double x,double y) {   return x < y + eps;}     
+bool dd(double x,double y)  {   return fabs( x - y ) < eps;}   
+double crossProduct(point a,point b,point c)  
+{  
+    return (c.x - a.x)*(b.y - a.y) - (b.x - a.x)*(c.y - a.y);  
+}  
+double disp2p(point a,point b) 
+{
+    return sqrt( ( a.x - b.x ) * ( a.x - b.x ) + ( a.y - b.y ) * ( a.y - b.y ) );
+}
+bool parallel(line u,line v)  
+{  
+    return dd( (u.a.x - u.b.x)*(v.a.y - v.b.y) - (v.a.x - v.b.x)*(u.a.y - u.b.y) , 0.0 );  
+}  
+point l2l_inst_p(line l1,line l2)  
+{  
+    point ans = l1.a;  
+    double t = ((l1.a.x - l2.a.x)*(l2.a.y - l2.b.y) - (l1.a.y - l2.a.y)*(l2.a.x - l2.b.x))/  
+               ((l1.a.x - l1.b.x)*(l2.a.y - l2.b.y) - (l1.a.y - l1.b.y)*(l2.a.x - l2.b.x));  
+    ans.x += (l1.b.x - l1.a.x)*t;  
+    ans.y += (l1.b.y - l1.a.y)*t;  
+    return ans;  
+}  
+bool equal_ang(line a,line b)  
+{  
+    return dd(a.ang,b.ang);  
+}  
+bool cmphp(line a,line b)  
+{  
+    if( dd(a.ang,b.ang) ) return xy(crossProduct(b.a,b.b,a.a),0.0);  
+    return xy(a.ang,b.ang);  
+}  
+bool equal_p(point a,point b)
+{  
+    return dd(a.x,b.x) && dd(a.y,b.y);  
+}
+void makeline_hp(double x1,double y1,double x2,double y2,line &l)
+{
+    l.a.x = x1; l.a.y = y1; l.b.x = x2; l.b.y = y2;
+    l.ang = atan2(y2 - y1,x2 - x1);
+}
+void inst_hp_nlogn(line *ln,int n,point *s,int &len)  
+{  
+    len = 0;  
+    sort(ln,ln+n,cmphp);  
+    n = unique(ln,ln+n,equal_ang) - ln;  
+    int bot = 0,top = 1;  
+    deq[0] = ln[0]; deq[1] = ln[1];  
+    for(int i=2; i<n; i++)  
+    {  
+        if( parallel(deq[top],deq[top-1]) || parallel(deq[bot],deq[bot+1]) )  
+            return ;  
+        while( bot < top && dy(crossProduct(ln[i].a,ln[i].b,  
+            l2l_inst_p(deq[top],deq[top-1])),0.0) )  
+            top--;  
+        while( bot < top && dy(crossProduct(ln[i].a,ln[i].b,  
+            l2l_inst_p(deq[bot],deq[bot+1])),0.0) )  
+            bot++;  
+        deq[++top] = ln[i];  
+    }  
+    while( bot < top && dy(crossProduct(deq[bot].a,deq[bot].b,  
+        l2l_inst_p(deq[top],deq[top-1])),0.0) ) top--;  
+    while( bot < top && dy(crossProduct(deq[top].a,deq[top].b,  
+        l2l_inst_p(deq[bot],deq[bot+1])),0.0) ) bot++;  
+    if( top <= bot + 1 ) return ;  
+    for(int i=bot; i<top; i++)  
+        s[len++] = l2l_inst_p(deq[i],deq[i+1]);  
+    if( bot < top + 1 ) s[len++] = l2l_inst_p(deq[bot],deq[top]);  
+    len = unique(s,s+len,equal_p) - s;  
+}
+point l2l_inst_p(point u1,point u2,point v1,point v2)
+{
+    point ans = u1;
+    double t = ((u1.x - v1.x)*(v1.y - v2.y) - (u1.y - v1.y)*(v1.x - v2.x))/
+                ((u1.x - u2.x)*(v1.y - v2.y) - (u1.y - u2.y)*(v1.x - v2.x));
+    ans.x += (u2.x - u1.x)*t;
+    ans.y += (u2.y - u1.y)*t;
+    return ans;
+}
+void l2c_inst_p(point c,double r,point l1,point l2,point &p1,point &p2)
+{
+    point p = c;
+    double t;
+    p.x += l1.y - l2.y;
+    p.y += l2.x - l1.x;
+    p = l2l_inst_p(p,c,l1,l2);
+    t = sqrt(r*r - disp2p(p,c)*disp2p(p,c))/disp2p(l1,l2);
+    p1.x = p.x + (l2.x - l1.x)*t;
+    p1.y = p.y + (l2.y - l1.y)*t;
+    p2.x = p.x - (l2.x - l1.x)*t;
+    p2.y = p.y - (l2.y - l1.y)*t;
+}
+double disp2l(point a,point l1,point l2)
+{
+    return fabs( crossProduct(a,l1,l2) )/disp2p(l1,l2);
+}
+bool onSegment(point a, point b, point c)
+{
+    if( dd(crossProduct(a,b,c),0.0) && dyd(c.x,min(a.x,b.x)) && 
+        xyd(c.x,max(a.x,b.x)) && dyd(c.y,min(a.y,b.y)) && xyd(c.y,max(a.y,b.y)) )
+        return true;
+    return false;
+}
+bool cmp(point a,point b)
+{
+    double t1 = atan2(a.y - ch.y, a.x - ch.x);
+    double t2 = atan2(b.y - ch.y, b.x - ch.x);
+    return xy(t1, t2);
+}
+double area_triangle(point a,point b,point c)
+{
+    return fabs( crossProduct(a,b,c) )/2.0;
+}
+double gong_area(point c,point a,point b,double r)
+{
+    if( dd(crossProduct(c,a,b), 0.0) )
+        return r*r*pi/2;
+    double area = area_triangle(a, b, c);
+    double ang = acos(1-disp2p(a,b)*disp2p(a,b)/(r*r*2));
+    return ang*r*r/2 - area;
+}
+bool incircle(point a,point c, double r)
+{
+    return xy(disp2p(a, c), r);
+}
+bool pin_convexh(point *p,int n,point a)
+{
+    p[n] = p[0]; p[n+1] = p[1];
+    for(int i=0; i<n; i++)
+        if( xy(crossProduct(p[i],p[i+1],a)*
+            crossProduct(p[i+1],p[i+2],a),0.0) )
+            return false;
+    return true;
+}
+point foot_line(point a,point l1,point l2)
+{                                        
+    point c;
+    c.x = a.x - l2.y + l1.y;
+    c.y = a.y + l2.x - l1.x;
+    return c;    
+}
+double solve(point *s, int len, double r)
+{
+    point c; c.x = c.y = 0;
+    point a, b;
+    int cnt = 0;
+    s[len] = s[0];
+    FOR(i, 0, len)    
+    {    
+        if( xy(disp2l(c, s[i], s[i+1]), r) )
+        {
+            l2c_inst_p(c, r, s[i], s[i+1], a, b);
+            if( onSegment(s[i], s[i+1], a) )
+                p[cnt++] = a;
+            if( onSegment(s[i], s[i+1], b) )
+                p[cnt++] = b;
+        }
+        if( incircle(s[i], c, r) )
+            p[cnt++] = s[i];
+        if( incircle(s[i+1], c, r) )
+            p[cnt++] = s[i+1];
+    }
+    sort(p, p+cnt, cmp);
+    cnt = unique(p, p+cnt, equal_p) - p;
+    p[cnt] = p[0];
+    double area = 0.0;
+    if( cnt == 2 )     
+    {
+        if( xy(crossProduct(p[0],p[1],ch), 0.0) )
+            swap(p[0], p[1]);
+        cnt--;
+    }
+    FOR(i, 0, cnt)
+    {
+        area += area_triangle(p[0], p[i], p[i+1]);
+        if( !dd(disp2p(p[i], c), r) || !dd(disp2p(p[i+1], c), r) )
+            continue; 
+        point mid;
+        mid.P((p[i].x + p[i+1].x)/2, (p[i].y + p[i+1].y)/2);
+        point a, b, k;
+        k = foot_line(c, p[i], p[i+1]);
+        l2c_inst_p(c, r, k, c, a, b);
+        bool flag = false;
+        if( dyd(crossProduct(p[i], p[i+1], a), 0.0) && pin_convexh(s, len, a) )
+            flag = true; 
+        if( dyd(crossProduct(p[i], p[i+1], b), 0.0) && pin_convexh(s, len, b) )
+            flag = true; 
+        if( !flag ) continue;
+        double area_gong = gong_area(c, p[i], p[i+1], r);
+        if( dy(crossProduct(p[i], p[i+1], c), 0.0) )
+            area_gong = pi*r*r - area_gong;
+        area += area_gong;
+    }
+    return area/(pi*r*r);
+}
+int main()
+{
+    int ncases, ind = 1, n;
+    double r;
+    scanf("%d", &ncases);
+    while( ncases-- )
+    {
+        scanf("%lf%d",&r, &n);
+        FOR(i, 0, n)
+        {
+            l[i].a.get();
+            l[i].b.get();
+        }
+        ch.get();
+        bool f = false;
+        point c; c.P(0,0);
+        FOR(i, 0, n)
+        {
+            if( dy(crossProduct(l[i].a, l[i].b, ch), 0.0) )
+                swap(l[i].a, l[i].b);
+            l[i].ang = atan2(l[i].b.y - l[i].a.y, l[i].b.x - l[i].a.x);
+            if( xy(disp2l(c,l[i].a, l[i].b), r) )
+                f = true;         
+        }
+        if( !f )        
+        {
+            printf("Case %d: %.5lf%%\n",ind++, 100.0);
+            continue;
+        }
+        makeline_hp(-2*r, -2*r, 2*r, -2*r, l[n++]); 
+        makeline_hp(2*r, -2*r, 2*r, 2*r, l[n++]);
+        makeline_hp(2*r, 2*r, -2*r, 2*r, l[n++]);
+        makeline_hp(-2*r, 2*r, -2*r, -2*r, l[n++]);
+        int len;
+        inst_hp_nlogn(l, n, s, len); 
+        double ans = solve(s, len, r);
+        printf("Case %d: %.5lf%%\n",ind++, ans*100);
+    }
+return 0;
+}
diff --git a/HDOJ/3986_autoAC.cpp b/HDOJ/3986_autoAC.cpp
new file mode 100644
index 0000000..72fa383
--- /dev/null
+++ b/HDOJ/3986_autoAC.cpp
@@ -0,0 +1,88 @@
+#include<iostream>
+#include<cstdio>
+#include<queue>
+#include<vector>
+using namespace std;
+const int MAXN=1000+10;
+const int inf=1<<30;
+struct Node{
+    int v,w,id;
+};
+vector<Node>vet[MAXN];
+int path[MAXN];
+int dist[MAXN];
+bool visited[MAXN];
+bool mark[MAXN*50];
+int id[MAXN];
+int n,m;
+bool tag;
+void SPFA(int u){
+    for(int i=1;i<=n;i++)dist[i]=inf;
+    dist[u]=0;
+    memset(visited,false,sizeof(visited));
+    queue<int>Q;
+    Q.push(u);
+    while(!Q.empty()){
+        int u=Q.front();
+        Q.pop();
+        visited[u]=false;
+        for(int i=0;i<vet[u].size();i++){
+            int v=vet[u][i].v;
+            int w=vet[u][i].w;
+            int ID=vet[u][i].id;
+            if(mark[vet[u][i].id])continue;
+            if(dist[u]+w<dist[v]){
+                dist[v]=dist[u]+w;
+                if(tag)path[v]=u,id[v]=ID;
+                if(!visited[v]){
+                    Q.push(v);
+                    visited[v]=true;
+                }
+            }
+        }
+    }
+}
+int main(){
+    int _case;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        for(int i=1;i<=n;i++)vet[i].clear();
+        memset(path,-1,sizeof(path));
+        memset(mark,false,sizeof(mark));
+        for(int i=1;i<=m;i++){
+            int u,v,w;
+            scanf("%d%d%d",&u,&v,&w);
+            Node p1,p2;
+            p1.v=u,p2.v=v;
+            p1.w=p2.w=w;
+            p1.id=p2.id=i; 
+            vet[u].push_back(p2);
+            vet[v].push_back(p1);
+        }
+        tag=true;
+        SPFA(1);
+        tag=false;
+        if(dist[n]==inf){
+            printf("-1\n");
+            continue;
+        }
+        int ans=0;
+        bool flag=true;
+        for(int u=n;u!=-1;u=path[u]){
+            mark[id[u]]=true;
+            SPFA(1);
+            mark[id[u]]=false;
+            if(dist[n]==inf){
+                printf("-1\n");
+                flag=false;
+                break;
+            }
+            ans=max(ans,dist[n]);
+        }
+        if(flag){
+            printf("%d\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/3987_autoAC.cpp b/HDOJ/3987_autoAC.cpp
new file mode 100644
index 0000000..8fc344f
--- /dev/null
+++ b/HDOJ/3987_autoAC.cpp
@@ -0,0 +1,83 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+using namespace std;
+typedef long long ll;
+#define MAXN 2222
+#define MAXM 2222222
+struct Edge{
+    int v,next;
+    ll cap;
+}edge[MAXM];
+int head[MAXN];
+int pre[MAXN];
+int cur[MAXN];
+int level[MAXN];
+int gap[MAXN];
+int NV,NE,n,m,vs,vt;
+void Insert(int u,int v,ll cap,ll cc=0){
+    edge[NE].v=v;edge[NE].cap=cap;
+    edge[NE].next=head[u];head[u]=NE++;
+    edge[NE].v=u;edge[NE].cap=cc;
+    edge[NE].next=head[v];head[v]=NE++;
+}
+ll SAP(int vs,int vt){
+    memset(pre,-1,sizeof(pre));
+    memset(level,0,sizeof(level));
+    memset(gap,0,sizeof(gap));
+    for(int i=0;i<=NV;i++)cur[i]=head[i];
+    int u=pre[vs]=vs;
+    ll aug=-1,maxflow=0;
+    gap[0]=NV;
+    while(level[vs]<NV){
+loop:
+        for(int &i=cur[u];i!=-1;i=edge[i].next){
+            int v=edge[i].v;
+            if(edge[i].cap&&level[u]==level[v]+1){
+                aug==-1?aug=edge[i].cap:aug=min(aug,edge[i].cap);
+                pre[v]=u;
+                u=v;
+                if(v==vt){
+                    maxflow+=aug;
+                    for(u=pre[u];v!=vs;v=u,u=pre[u]){
+                        edge[cur[u]].cap-=aug;
+                        edge[cur[u]^1].cap+=aug;
+                    }
+                    aug=-1;
+                }
+                goto loop;
+            }
+        }
+        int minlevel=NV;
+        for(int i=head[u];i!=-1;i=edge[i].next){
+            int v=edge[i].v;
+            if(edge[i].cap&&minlevel>level[v]){
+                cur[u]=i;
+                minlevel=level[v];
+            }
+        }
+        if(--gap[level[u]]==0)break;
+        level[u]=minlevel+1;
+        gap[level[u]]++;
+        u=pre[u];
+    }
+    return maxflow;
+}
+int main(){
+    int _case,u,v,w,flag,t=1;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        vs=0,vt=n-1,NV=n,NE=0;
+        memset(head,-1,sizeof(head));
+        for(int i=1;i<=m;i++){
+            scanf("%d%d%d%d",&u,&v,&w,&flag);
+            Insert(u,v,(ll)w*MAXM+1);
+            if(flag)Insert(v,u,(ll)w*MAXM+1);
+        }
+        ll ans=SAP(vs,vt);
+        printf("Case %d: %d\n",t++,ans%MAXM);
+    }
+    return 0;
+}
diff --git a/HDOJ/3988_autoAC.cpp b/HDOJ/3988_autoAC.cpp
new file mode 100644
index 0000000..66c575d
--- /dev/null
+++ b/HDOJ/3988_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<iostream>
+#include<cstring>
+#include<queue>
+#include<cstdio>
+#include<cmath>
+#include<algorithm>
+#define N 100005
+#define MOD 9973
+#define LL unsigned long long
+#define eps 1e-7
+#define zero(a) fabs(a)<eps
+#define equal(a,b) zero(a-b)
+using namespace std;
+bool flag[10000005];
+int cnt=0,prime[10000005];
+void Init(){
+    for(int i=2;i<=sqrt(10000000.0)+1;i++){
+        if(flag[i])
+            continue;
+        for(int j=2;j*i<=10000000;j++)
+            flag[i*j]=true;
+    }
+    for(int i=2;i<=10000000;i++)
+        if(!flag[i])
+            prime[cnt++]=i;
+}
+LL get_sum(LL n,LL p){
+    LL ret=0;
+    while(n){
+        n/=p;
+        ret+=n;
+    }
+    return ret;
+}
+int main(){
+    int t,cas=0;
+    scanf("%d",&t);
+    Init();
+    while(t--){
+        LL n,k;
+        scanf("%I64u%I64u",&n,&k);
+        if(k==1){
+            printf("Case %d: inf\n",++cas);
+            continue;
+        }
+        LL mmax=-1;
+        for(int i=0;i<cnt&&prime[i]<=k;i++){
+            if(k%prime[i]==0){
+                int c=0;
+                while(k%prime[i]==0){
+                    c++;
+                    k/=prime[i];
+                }
+                LL tmp=get_sum(n,prime[i])/c;
+                if(mmax==-1)
+                    mmax=tmp;
+                else
+                    mmax=min(mmax,tmp);
+            }
+        }
+        if(k>1){
+            LL tmp=get_sum(n,k);
+            if(mmax==-1)
+                mmax=tmp;
+            else
+                mmax=min(mmax,tmp);
+        }
+        printf("Case %d: %I64u\n",++cas,mmax);
+    }
+    return 0;
+}
diff --git a/HDOJ/3991_autoAC.cpp b/HDOJ/3991_autoAC.cpp
new file mode 100644
index 0000000..f545102
--- /dev/null
+++ b/HDOJ/3991_autoAC.cpp
@@ -0,0 +1,110 @@
+#include <cstdio>
+#include <cstring>
+struct EDGE
+{
+    int v, next;
+}edge[2010010];
+struct NODE
+{
+    int p;
+    long long t;
+}node[1010];
+const long long inf = 1ll<<60;
+long long map[105][105];
+bool usedif[1005];
+int link[1005];
+int head[1010];
+int cnt, gx, gy;
+bool cmp(NODE a, NODE b)
+{
+    return a.t < b.t;
+}
+void addedge(int u, int v)
+{
+    edge[cnt].v = v;
+    edge[cnt].next = head[u];
+    head[u] = cnt++;
+}
+bool can(int t)
+{
+    for(int p = head[t]; p != -1; p = edge[p].next)
+    {
+        int i = edge[p].v;
+        if(usedif[i]==0)
+        {
+            usedif[i]=1;
+            if(link[i]==-1||can(link[i]))
+            {
+                link[i]=t;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int MaxMatch()
+{
+    int num=0;
+    memset(link,-1,sizeof(link));
+    for(int i=0; i< gx; i++)
+    {
+        memset(usedif,0,sizeof(usedif));
+        if(can(i))  num++;
+    }
+    return num;
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    int cas = 1;
+    while(T--)
+    {
+        int n, m, q;
+        scanf("%d%d%d", &n, &m, &q);
+        int d = 1<< 30;
+        for(int i = 0; i < n; i++)
+          for(int j = 0; j < n; j++)
+          if(i != j)  map[i][j] = inf;
+         else map[i][j] = 0;
+        while(m--)
+        {
+            int a, b;
+            long long c;
+            scanf("%d%d%I64d", &a, &b, &c);
+            if(map[a][b] > c)
+            {
+                map[a][b] = map[b][a] = c;
+            }
+        }
+        for(int k = 0; k < n; k++)
+          for(int i = 0; i < n; i++)
+          {
+            if(i == k) continue;
+            if(map[i][k] == inf)  continue;
+            for(int j = 0; j < n; j++)
+            if(map[k][j] != inf && map[i][k] + map[k][j] < map[i][j])
+            {
+                map[i][j] = map[i][k] + map[k][j];
+            }
+          }
+        for(int i = 0; i < q; i++)
+        {
+            scanf("%d%d", &node[i].p, &node[i].t);
+        }
+        gx = q;
+        cnt = 0;
+        memset(head, -1, sizeof(head));
+        for(int i = 0; i < q; i++)
+        {
+            for(int j = 0; j < q; j++)
+            if(i != j && node[j].t - node[i].t >= map[node[i].p][node[j].p])
+            {
+                addedge(i, j);
+            }
+        }
+        int ans = gx - MaxMatch();
+        printf("Case %d: %d\n", cas++, ans - 1);
+    }
+    return 0;
+}
diff --git a/HDOJ/3992_autoAC.cpp b/HDOJ/3992_autoAC.cpp
new file mode 100644
index 0000000..016fd49
--- /dev/null
+++ b/HDOJ/3992_autoAC.cpp
@@ -0,0 +1,190 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+const int maxn=100000;
+struct Node
+{
+    int flag;
+    int id;
+    Node* next[26];
+    Node* fail;
+};
+Node* root;
+Node temp[maxn];
+int tp;
+void reset(Node* p)
+{
+    p->flag=0;p->id=tp-1;
+    for(int i=0;i<26;i++) p->next[i]=NULL;
+    p->fail=root;
+    if(p==root) p->fail=NULL;
+}
+void init()
+{
+    tp=0;
+    root=&temp[tp++];
+    reset(root);
+}
+void insert(char* str)
+{
+    Node* p=root;
+    for(int i=0;str[i];i++)
+    {
+        int x=str[i]-'a';
+        if(p->next[x]==NULL)
+        {
+            p->next[x]=&temp[tp++];
+            reset(p->next[x]);
+        }
+        p=p->next[x];
+    }
+    p->flag=1;
+}
+Node* que[maxn];
+int front,rear;
+void DFA()
+{
+    front=rear=0;
+    que[rear++]=root;
+    while(front<rear)
+    {
+        Node* t=que[front++];
+        for(int i=0;i<26;i++)
+        {
+            Node* cnt=t->next[i];
+            if(cnt!=NULL)
+            {
+                Node* fath=t->fail;
+                while(fath!=NULL&&fath->next[i]==NULL)
+                {
+                    fath=fath->fail;
+                }
+                if(fath==NULL)
+                {
+                    cnt->fail=root;
+                }
+                else cnt->fail=fath->next[i];
+                cnt->flag|=cnt->fail->flag;
+                que[rear++]=cnt;
+            }
+        }
+    }
+}
+double pet[26];
+int n;
+char str[maxn];
+double a[1000][1000];
+int equ,var;//浠0寮濮
+void toMatrix()
+{
+    var=rear;
+    equ=0;
+    memset(a,0,sizeof(a));
+    for(int i=0;i<rear;i++)
+    {
+        Node* p=&temp[i];
+        if(p->flag)
+        {
+            a[equ][p->id]=1;
+            a[equ++][var]=0;
+            continue;
+        }
+        a[equ][p->id]=-1;
+        a[equ][var]=-1;
+        for(int j=0;j<26;j++)
+        {
+            Node* cnt=p->next[j];
+            int k;
+            if(cnt!=NULL)
+            {
+                k=cnt->id;
+                a[equ][k]+=pet[j];
+            }
+            else
+            {
+                Node* fath=p->fail;
+                while(fath!=NULL&&fath->next[j]==NULL)
+                {
+                    fath=fath->fail;
+                }
+                if(fath!=NULL)
+                {
+                    k=fath->next[j]->id;
+                    a[equ][k]+=pet[j];
+                }
+                else
+                {
+                    k=0;
+                    a[equ][0]+=pet[j];
+                }
+            }
+        }
+        equ++;
+    }
+}
+const double eps=1e-10;
+double x[1000];
+void Gauss()
+{
+    for(int i=0;i<equ;i++)
+    {
+        int j;
+        for(j=i;j<equ;j++)
+        {
+            if(fabs(a[j][i])>eps) break;
+        }
+        for(int k=i;k<=var;k++) swap(a[i][k],a[j][k]);
+        for(j=i+1;j<equ;j++)
+        {
+            double p=-a[j][i]/a[i][i];
+            for(int k=i;k<=var;k++) a[j][k]+=a[i][k]*p;
+        }
+    }
+    for(int i=equ-1;i>=0;i--)
+    {
+        x[i]=a[i][var]/a[i][i];
+        a[i][var]/=a[i][i];a[i][i]=1;
+        for(int j=i-1;j>=0;j--)
+        {
+            a[j][var]+=-a[j][i]*a[i][var];
+            a[j][i]=0;
+        }
+    }
+}
+int main()
+{
+    while(scanf("%d",&n)==1)
+    {
+        init();
+        for(int i=0;i<26;i++) scanf("%lf",&pet[i]);
+        int flag=0;
+        for(int i=0;i<n;i++)
+        {
+            scanf("%s",str);
+            insert(str);
+            int f=1;
+            for(int j=0;str[j];j++)
+            {
+                int x=str[j]-'a';
+                if(fabs(pet[x])<eps)
+                {
+                    f=0;break;
+                }
+            }
+            if(f) flag=1;
+        }
+        if(!flag)
+        {
+            printf("Infinity\n");
+            continue;
+        }
+        DFA();
+        toMatrix();
+        Gauss();
+        printf("%.6lf\n",x[0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/3993_autoAC.cpp b/HDOJ/3993_autoAC.cpp
new file mode 100644
index 0000000..eb220e4
--- /dev/null
+++ b/HDOJ/3993_autoAC.cpp
@@ -0,0 +1,24 @@
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+int a[20];
+int b[20];
+int main(){
+ int test,n;
+ scanf("%d",&test);
+ while (test--){
+ scanf("%d",&n);
+ for (int i=0;i<n;i++)
+ scanf("%d",&a[i]);
+ for (int j=0;j<n;j++)
+ scanf("%d",&b[j]);
+ int ans=0;
+ for (int i=0;i<n;i++)
+ for (int j=0;j<n;j++)
+ if (b[i]>a[j]) ans+=3;
+ printf("%.6lf\n",ans*1.0/n);
+ }
+ return 0;
+}
diff --git a/HDOJ/3994_autoAC.cpp b/HDOJ/3994_autoAC.cpp
new file mode 100644
index 0000000..bfbf144
--- /dev/null
+++ b/HDOJ/3994_autoAC.cpp
@@ -0,0 +1,97 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+#define MaxN 200
+#define eps 1e-8
+double dp[MaxN+5][MaxN+5];
+double tmp[MaxN+5][MaxN+5];
+int n;
+int c;
+int m;
+int lst[MaxN+5];
+void floyd(bool flag){
+    int i,j,k;
+    if (flag){
+        for (k=0;k<n;k++){
+            for (i=0;i<n;i++){
+                for (j=0;j<n;j++){
+                    if ((i==j) || (j==k) || (i==k)) continue;
+                    if (dp[i][j]<dp[i][k]*dp[k][j]){
+                        dp[i][j]=dp[i][k]*dp[k][j];
+                    }
+                }
+            }
+        }
+        return;
+    }
+    for (k=0;k<n;k++){
+        for (i=0;i<n;i++){
+            for (j=0;j<n;j++){
+                if ((i==j) || (j==k) || (i==k)) continue;
+                if (dp[i][k]>=0 && dp[k][j]>=0 && (dp[i][j]<0 || dp[i][j]>dp[i][k]+dp[k][j])){
+                    dp[i][j]=dp[i][k]+dp[k][j];
+                }
+            }
+        }
+    }
+}
+bool iszero(double a)
+{
+        return a<eps;
+}
+void init(){
+    int i,j;
+    scanf("%d",&n);    
+    for (i=0;i<n;i++){
+        for (j=0;j<n;j++){
+            scanf("%lf",&dp[i][j]);
+            dp[i][j]=dp[i][j]/100.0;
+        }
+    }
+    floyd(1);
+    scanf("%d",&m);
+    for (i=0;i<m;i++){
+        scanf("%d",&lst[i]);
+    }
+    for (i=0;i<m;i++){
+        if (lst[i]==1) break;
+    }
+    if (i==m) lst[m++]=1;
+    for (i=0;i<m;i++){
+        if (lst[i]==2) break;
+    }
+    if (i==m) lst[m++]=2;
+    sort(lst,lst+m);
+    for (i=0;i<m;i++){
+        for (j=i+1;j<m;j++){
+            tmp[i][j]=dp[lst[i]-1][lst[j]-1];
+            tmp[j][i]=dp[lst[j]-1][lst[i]-1];
+        }
+    }
+    for (i=0;i<m;i++){
+        for (j=0;j<m;j++){
+            if (iszero(tmp[i][j]))dp[i][j]=-1;
+            else dp[i][j]=1.0/tmp[i][j];
+            if (iszero(tmp[j][i]))dp[j][i]=-1;
+            else dp[j][i]=1.0/tmp[j][i];
+        }
+    }
+    n=m;
+    scanf("%d",&c);
+    floyd(0);
+}
+void solve(){
+    printf("%.6lf\n",dp[0][1]*c);
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while (t--){
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/3995_autoAC.cpp b/HDOJ/3995_autoAC.cpp
new file mode 100644
index 0000000..b3a24f0
--- /dev/null
+++ b/HDOJ/3995_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+#define sqr(a) ((a)*(a))
+#define trarea(p) fabs ((vdet(p[0],p[1],p[2])/2.0))
+double const EPS = 1e-12;
+int const maxn = 20011;
+struct point{double x,y;int flag;};
+struct circle{
+        point c;
+        double r;
+};
+inline double vdet(point op,point p1,point p2){
+        return (p1.x-op.x)*(p2.y-op.y)-(p2.x-op.x)*(p1.y-op.y);
+}
+inline double dis(point a,point b){
+        return sqr(a.x-b.x)+sqr(a.y-b.y);
+}
+inline point get_out_circle(point p[]){  
+        double c1,c2,xa,xb,xc,ya,yb,yc;
+        point o;
+        xa=p[0].x,xb=p[1].x,xc=p[2].x;
+        ya = p[0].y,yb = p[1].y,yc = p[2].y;
+        c1 = (sqr(xa) + sqr(ya) - sqr(xb) - sqr(yb))/2.0;
+        c2 = (sqr(xa) + sqr(ya) - sqr(xc) - sqr(yc))/2.0;
+        o.x = (c1*(ya-yc)-c2*(ya-yb))/((xa-xb)*(ya-yc)-(xa-xc)*(ya-yb));
+        o.y = (c1*(xa-xc)-c2*(xa-xb))/((ya-yb)*(xa-xc)-(ya-yc)*(xa-xb));
+        return o;
+}
+inline double get_out_r(point p[]){  
+        double a = dis(p[0],p[1]),b = dis(p[1],p[2]),c = dis(p[2],p[0]),s = trarea(p);
+        return a*b*c/sqr(4*s);
+}
+point must_on[3],p[maxn];
+circle mc;
+inline void get_circle(int tm){  
+        switch(tm){
+                case 0:mc.r = -1;
+                       break;
+                case 1:mc.r = 0,mc.c = must_on[0];
+                       break;
+                case 2:{
+                               mc.r = dis(must_on[0],must_on[1])/4.0;
+                               mc.c.x = (must_on[0].x+must_on[1].x)/2.0;
+                               mc.c.y = (must_on[0].y + must_on[1].y)/2.0;
+                       }break;
+                case 3:{
+                               mc.r = get_out_r(must_on);
+                               mc.c = get_out_circle(must_on);
+                       }break;
+        }
+}
+inline void min_circle(int t,int ton){
+        get_circle(ton);
+        if(ton >= 3)return;
+        for(int i = 0; i < t; ++i){
+                if(p[i].flag == 1){
+                    if(dis(mc.c,p[i]) > mc.r + EPS){ 
+                        must_on[ton] = p[i];
+                        min_circle(i,ton+1);
+                    }
+                }
+                else {
+                    if(dis(mc.c,p[i]) + EPS < mc.r){ 
+                        must_on[ton] = p[i];
+                        min_circle(i,ton+1);
+                    }
+                }
+        }
+}
+int main(){
+        int n,m;
+        while (scanf("%d%d",&n,&m) != EOF){
+                for(int i = 0; i < n; ++i){
+                        scanf("%lf%lf",&p[i].x,&p[i].y);
+                        p[i].flag = 1;
+                }
+                for(int i = n; i < m + n; ++i){
+                        scanf("%lf%lf",&p[i].x,&p[i].y);
+                        p[i].flag = 2;
+                }
+                n = n + m;
+                random_shuffle(p,p+n); 
+                min_circle(n,0);
+                printf("%.3lf %.3lf\n%.3lf\n",mc.c.x,mc.c.y,sqrt(mc.r));
+        }
+        return 0;
+}
diff --git a/HDOJ/3996_autoAC.cpp b/HDOJ/3996_autoAC.cpp
new file mode 100644
index 0000000..cba63a3
--- /dev/null
+++ b/HDOJ/3996_autoAC.cpp
@@ -0,0 +1,111 @@
+#include<iostream>
+#include<algorithm>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int N=62002;
+const int M=62002;
+const __int64 INF=1LL<<60;
+int t,n,m,tot,cas=1;
+int gap[M],dis[M],pre[M],head[N],cur[N],vis[N];
+int NE,NV,sink,source;
+struct Node
+{
+    __int64 c;
+    int pos,next;
+} E[9999999];
+#define FF(i,NV) for(int i=0;i<NV;i++)
+__int64 sap(int s,int t)
+{
+    memset(dis,0,sizeof(int)*(NV+1));
+    memset(gap,0,sizeof(int)*(NV+1));
+    FF(i,NV) cur[i] = head[i];
+    int u = pre[s] = s;
+    __int64 maxflow = 0,aug =INF;
+    gap[0] = NV;
+    while(dis[s] < NV)
+    {
+loop:
+        for(int &i = cur[u]; i != -1; i = E[i].next)
+        {
+            int v = E[i].pos;
+            if(E[i].c && dis[u] == dis[v] + 1)
+            {
+                if(aug>E[i].c) aug=E[i].c;
+                pre[v] = u;
+                u = v;
+                if(v == t)
+                {
+                    maxflow += aug;
+                    for(u = pre[u]; v != s; v = u,u = pre[u])
+                    {
+                        E[cur[u]].c -= aug;
+                        E[cur[u]^1].c += aug;
+                    }
+                    aug =INF;
+                }
+                goto loop;
+            }
+        }
+        if( (--gap[dis[u]]) == 0)   break;
+        int mindis = NV;
+        for(int i = head[u]; i != -1 ; i = E[i].next)
+        {
+            int v = E[i].pos;
+            if(E[i].c >0&& mindis > dis[v])
+            {
+                cur[u] = i;
+                mindis = dis[v];
+            }
+        }
+        gap[ dis[u] = mindis+1 ] ++;
+        u = pre[u];
+    }
+    return maxflow;
+}
+void addEdge(int u,int v,__int64 c )
+{
+    E[NE].c = c;
+    E[NE].pos = v;
+    E[NE].next = head[u];
+    head[u] = NE++;
+    E[NE].c = 0;
+    E[NE].pos = u;
+    E[NE].next = head[v];
+    head[v] = NE++;
+}
+int main()
+{
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        int i,j,a,b,w,cost,val;
+        __int64 sum=0;
+        source=0,sink=3000,NE=0,NV=sink+1;
+        memset(head,-1,sizeof(int)*(NV));
+        for(int i=1; i<=n; i++)
+        {
+            scanf("%d",&m);
+            for(int j=1; j<=m; j++)
+            {
+                scanf("%d%d%d",&cost,&val,&w);
+                val-=cost;
+                if(val>0)
+                {
+                    addEdge(source,i*26+j,val);
+                    sum+=val;
+                }
+                else    addEdge(i*26+j,sink,-val);
+                while(w--)
+                {
+                    scanf("%d%d",&a,&b);
+                    addEdge(i*26+j,a*26+b,INF);
+                }
+            }
+        }
+        __int64 ans=sap(source,sink);
+        printf("Case #%d: %I64d\n",cas++,sum-ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/3998_autoAC.cpp b/HDOJ/3998_autoAC.cpp
new file mode 100644
index 0000000..420748a
--- /dev/null
+++ b/HDOJ/3998_autoAC.cpp
@@ -0,0 +1,100 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring> 
+using namespace std ; 
+const int INF=0xfffffff ;
+struct node
+{
+    int s,t,cap,nxt ;
+}e[400005] ;
+int m,n,cnt,head[100005],level[100005],q[100005] ;
+void add(int s,int t,int cap)
+{
+    e[cnt].s=s ;e[cnt].t=t ;e[cnt].cap=cap ;e[cnt].nxt=head[s] ;head[s]=cnt++ ;
+    e[cnt].s=t ;e[cnt].t=s ;e[cnt].cap=0 ;e[cnt].nxt=head[t] ;head[t]=cnt++ ;
+}
+bool build(int s,int t)
+{
+    int front=0,rear=0 ;
+    memset(level,-1,sizeof(level)) ;
+    q[rear++]=s ;
+    level[s]=1 ;
+    while(front<rear)
+    {
+        int u=q[front++] ;
+        for(int i=head[u] ;i!=-1 ;i=e[i].nxt)
+        {
+            int tt=e[i].t ;
+            if(level[tt]==-1 && e[i].cap>0)
+            {
+                level[tt]=level[u]+1 ;
+                if(tt==t)return true ;
+                q[rear++]=tt ;
+            }
+        }
+    }
+    return false ;
+}
+int find(int s,int t,int flow)
+{
+    if(s==t)return flow ;
+    int ret=0,a ;
+    for(int i=head[s] ;i!=-1 ;i=e[i].nxt)
+    {
+        int tt=e[i].t ;
+        if(level[tt]==level[s]+1 && e[i].cap>0)
+        {
+            a=find(tt,t,min(e[i].cap,flow-ret)) ;
+            e[i].cap-=a ;
+            e[i^1].cap+=a ;
+            ret+=a ;
+            if(ret==flow)
+                return ret ;
+        }
+    }
+    if(!ret)level[s]=-1 ;
+    return ret ;
+}
+int dinic(int s,int t)
+{
+    int flow,ret=0 ;
+    while(build(s,t))
+        while(flow=find(s,t,INF))
+            ret+=flow ;
+    return ret ;
+}
+int a[1005],dp[1005] ;
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        for(int i=1 ;i<=n ;i++)
+            scanf("%d",&a[i]) ;
+        int ans=0 ;
+        for(int i=1 ;i<=n ;i++)
+        {
+            dp[i]=1 ;
+            for(int j=1 ;j<i ;j++)
+                if(a[j]<a[i] && dp[j]+1>dp[i])
+                    dp[i]=dp[j]+1 ;
+            ans=max(ans,dp[i]) ;
+        }
+        int S,T ;
+        S=0 ;T=2*n+1 ;
+        cnt=0 ;
+        memset(head,-1,sizeof(head)) ;
+        for(int i=1 ;i<=n ;i++)
+        {
+            add(i,i+n,1) ;
+            if(dp[i]==1)add(S,i,1) ;
+            if(dp[i]==ans)add(i+n,T,1) ;
+            for(int j=i+1 ;j<=n ;j++)
+            {
+                if(dp[j]==dp[i]+1)
+                    add(i+n,j,1) ;
+            }
+        }
+        printf("%d\n%d\n",ans,dinic(S,T)) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/3999_autoAC.cpp b/HDOJ/3999_autoAC.cpp
new file mode 100644
index 0000000..09346f4
--- /dev/null
+++ b/HDOJ/3999_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+struct node{
+    int num;
+    struct node *left;
+    struct node *right;
+}*tree;
+int tot=0;
+node *build(node *root,int num)
+{
+    if(root==NULL)
+    {
+        root=new node;
+        root->left=NULL;
+        root->right=NULL;
+        root->num=num;
+        return root;
+    }
+    else 
+    {
+        int t=root->num-num;;
+        if(t>0)
+            root->left=build(root->left,num);
+        else 
+            root->right=build(root->right,num);
+        return root;
+    }
+}
+bool first;
+void visit(node *root)
+{
+    if(root!=NULL&&!first)
+         printf(" %d",root->num);
+    else 
+    {
+        first=false;
+        printf("%d",root->num);
+    }
+}
+void preorder(node *root)
+{
+    if(root!=NULL)
+    {  
+        visit(root);
+        preorder(root->left);
+        preorder(root->right);
+    }
+}
+int main()
+{
+    int n,num;
+    while(scanf("%d",&n)!=EOF)
+    {
+        first=true;
+        int num;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&num);
+            tree=build(tree,num);
+        }
+        preorder(tree);
+        puts("");
+    }
+    return 0;
+}