diff --git a/HDOJ/5200_autoAC.cpp b/HDOJ/5200_autoAC.cpp
new file mode 100644
index 0000000..553d138
--- /dev/null
+++ b/HDOJ/5200_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+#define M 500005
+struct point{
+    int i, v;
+}p[M];
+struct node
+{
+    int v;
+    int cur;
+}s[M];
+int has[M],  res[M];
+bool cmp (point a, point b)
+{
+    return a.v > b.v;
+}
+int S()
+{
+    int ret=0,ok=0;
+    char c;
+    while((c=getchar()))
+    {
+        if(c>='0'&&c<='9')
+        ret=(ret<<3)+ret+ret+c-'0',ok=1;
+        else if(ok)
+        return ret;
+    }
+    return ret;
+}
+bool cmp2(node a,node b)
+{
+    return a.v<b.v;
+}
+int main()
+{
+    int  n, d, i, j, ans;
+    while (~scanf("%d%d",&n,&d))
+    {
+        for (i = 0; i < n; i++)
+        {
+            p[i].v=S();
+            p[i].i = i+1;
+        }
+        sort(p, p+n, cmp);
+        for (j = 0; j < d; j++)
+        {
+            s[j].v=S();
+            s[j].cur=j;
+        }
+        sort(s,s+d,cmp2);
+        memset(has, 0, sizeof(has));
+        ans = 0;
+        for (i = 0, j = d - 1; j >= 0; j--)
+        {
+            for ( ; i < n; i++) 
+            {
+                if (p[i].v <= s[j].v)
+                    break;
+                int id = p[i].i;
+                has[id] = 1;
+                if (!has[id-1] && !has[id+1]) ++ans;
+                else if (has[id-1] && has[id+1]) --ans;
+            }
+            res[s[j].cur] = ans;
+        }
+        for (i = 0; i < d; i++)
+        {
+            printf ("%d\n", res[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5201_autoAC.cpp b/HDOJ/5201_autoAC.cpp
new file mode 100644
index 0000000..6286a34
--- /dev/null
+++ b/HDOJ/5201_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<stdio.h>
+typedef long long LL;
+#define mod 1000000007
+LL pow(LL a, LL b) {
+    LL s = 1;
+    while(b) {
+        if(b&1) s = (s * a) % mod;
+        a = (a*a) % mod;
+        b >>= 1;
+    }
+    return s;
+}
+LL f[200005],inv[200005];
+void init()
+{
+    f[0]=f[1]=inv[0]=inv[1]=1;
+    for(LL i=2;i<=200000;++i){
+        f[i]=f[i-1]*i%mod;
+        inv[i]=pow(f[i],mod-2);
+    }
+}
+LL C(int n,int m)
+{
+    if(m>n||m<0) return 0;
+    return f[n]*inv[m]%mod*inv[n-m]%mod;
+}
+LL n,m;
+LL cal(int x)
+{
+    LL ans=0;
+    for(LL i=0,s=x;i<m&&s<=n;++i,s+=x)    
+    {
+        LL t=C(m-1,i)*C(n-s+m-2,n-s)%mod;
+        if(i&1) ans=((ans-t)%mod+mod)%mod;
+        else ans=(ans+t)%mod;
+    }
+    return ans;
+}
+int main() {
+    int t;
+    scanf("%d",&t);
+    init();
+    while(t--)
+    {
+        scanf("%lld%lld", &n,&m);
+        if(m==1) puts("1");
+        else
+        {
+            LL ans=0;
+            for(LL i=1;i<=n;++i) ans=(ans+cal(i))%mod;
+            printf("%lld\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5202_autoAC.cpp b/HDOJ/5202_autoAC.cpp
new file mode 100644
index 0000000..b9a92a2
--- /dev/null
+++ b/HDOJ/5202_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <string.h>
+const int N = 1005;
+char str[N];
+int n, pos[N], num, len, cnt;
+bool judge() {
+    for (int i = 0, j = len - 1; i < len; i++, j--)
+        if (str[i] != str[j])
+            return false;
+    return true;
+}
+int main() {
+    while (scanf("%d", &n) == 1) {
+        scanf("%s", str);
+        num = 0;
+        len = strlen(str);
+        for (int i = 0; i < len; i++) {
+            if (str[i] == '?') {
+                str[i] = 'a';
+                pos[num++] = i;
+            }
+        }
+        if (num == 0 && !judge()) {
+            printf("%s\n", str);
+            continue;
+        }
+        if (num == 0 && judge() || len == 1) {
+            printf("QwQ\n");
+            continue;
+        }
+        if (len & 1) {
+            if (!judge()) {
+                printf("%s\n", str);
+                continue;
+            }
+            bool flag = judge();
+            if (flag && pos[num - 1] != len / 2) {
+                str[pos[num - 1]] = 'b';
+                printf("%s\n", str);
+            }
+            else if (flag && pos[num - 1] == len / 2 && num == 1)
+                printf("QwQ\n");
+            else if (flag && pos[num - 1] == len / 2 && num > 1) {
+                str[pos[num - 2]] = 'b';
+                printf("%s\n", str);
+            }
+        }
+        else {
+            if (judge())
+                str[pos[num - 1]] = 'b';
+            printf("%s\n", str);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5203_autoAC.cpp b/HDOJ/5203_autoAC.cpp
new file mode 100644
index 0000000..0d14c1e
--- /dev/null
+++ b/HDOJ/5203_autoAC.cpp
@@ -0,0 +1,49 @@
+#include<cstdio>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+using namespace std;
+int l,r,x,n,m;
+int ok(int a,int b,int c) 
+{
+    if(a<b) swap(a,b);
+    if(a<c) swap(a,c);
+    if(b+c>a) return true;
+    else return false;
+}
+long long calc2(int x,int y) 
+{
+    long long tot=0;
+    for(int i=1;i<x;i++)
+        if(ok(i,x-i,y)) tot++;
+    for(int i=1;i<y;i++)
+        if(ok(i,y-i,x)) tot++;
+    return tot;
+}
+long long calc1(int n) 
+{
+    long long tot=0;
+    for(int i=1;i<=n-2;i++) 
+        if(2*i<n) 
+        {
+            tot+=(n-1)/2-(n/2-i);
+        }
+    return tot;
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        l=n,r=1;
+        for(int i=1;i<=m;i++)
+        {
+            scanf("%d",&x);
+            l=min(l,x);
+            r=max(r,x);
+        }
+        if(r==n) printf("%lld\n",calc1(l-1));
+        else if(l==1)  printf("%lld\n",calc1(n-r));
+        else printf("%lld\n",calc2(l-1,n-r));
+    }
+    return 0;
+}
diff --git a/HDOJ/5204_autoAC.cpp b/HDOJ/5204_autoAC.cpp
new file mode 100644
index 0000000..3306704
--- /dev/null
+++ b/HDOJ/5204_autoAC.cpp
@@ -0,0 +1,122 @@
+#pragma comment(linker, "/STACK:10240000,10240000")
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <map>
+#include <queue>
+#include <deque>
+#include <cmath>
+#include <vector>
+#include <ctime>
+#include <cctype>
+#include <set>
+#include <bitset>
+#include <functional>
+#include <numeric>
+#include <stdexcept>
+#include <utility>
+using namespace std;
+#define mem0(a) memset(a, 0, sizeof(a))
+#define lson l, m, rt << 1
+#define rson m + 1, r, rt << 1 | 1
+#define define_m int m = (l + r) >> 1
+#define rep0(a, b) for (int a = 0; a < (b); a++)
+#define rep1(a, b) for (int a = 1; a <= (b); a++)
+#define all(a) (a).begin(), (a).end()
+#define lowbit(x) ((x) & (-(x)))
+#define constructInt4(name, a, b, c, d) name(int a = 0, int b = 0, int c = 0, int d = 0): a(a), b(b), c(c), d(d) {}
+#define constructInt3(name, a, b, c) name(int a = 0, int b = 0, int c = 0): a(a), b(b), c(c) {}
+#define constructInt2(name, a, b) name(int a = 0, int b = 0): a(a), b(b) {}
+#define pchr(a) putchar(a)
+#define pstr(a) printf("%s", a)
+#define sint(a) ReadInt(a)
+#define sint2(a, b) ReadInt(a);ReadInt(b)
+#define sint3(a, b, c) ReadInt(a);ReadInt(b);ReadInt(c)
+#define pint(a) WriteInt(a)
+typedef double db;
+typedef long long LL;
+typedef pair<int, int> pii;
+typedef multiset<int> msi;
+typedef set<int> si;
+typedef vector<int> vi;
+typedef map<int, int> mii;
+const int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
+const int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
+const int maxn = 1e3 + 7;
+const int maxm = 1e5 + 7;
+const int maxv = 1e7 + 7;
+const int max_val = 1e6 + 7;
+const int MD = 1e9 +7;
+const int INF = 1e9 + 7;
+const double PI = acos(-1.0);
+const double eps = 1e-10;
+template<class T>T gcd(T a, T b){return b==0?a:gcd(b,a%b);}
+template<class T>void ReadInt(T &x){char c=getchar();while(!isdigit(c))c=getchar();x=0;while(isdigit(c)){x=x*10+c-'0';c=getchar();}}
+template<class T>void WriteInt(T i) {int p=0;static int b[20];if(i == 0) b[p++] = 0;else while(i){b[p++]=i%10;i/=10;}for(int j=p-1;j>=0;j--)pchr('0'+b[j]);}
+struct abc {
+    pii a[100007];
+    int l, r;
+    void Init() { l = r = 0; }
+    void push_back(int x) {
+        a[r++] = make_pair(x, 0);
+        for(int i = l; i < r - 1; i++) a[i].second++;
+        if (r - l >= 62) {
+            int pos;
+            for (int i = l; i < r; i++) {
+                if (a[i].second == 61) {
+                    pos = i;
+                    break;
+                }
+            }
+            for (int i = pos; i > l; i--) a[i] = a[i - 1];
+            l++;
+        }
+        int p = r - 1;
+        while (p > l && a[p].first < a[p - 1].first) {
+            swap(a[p], a[p - 1]);
+            p--;
+        }
+    }
+    pii &operator [] (int i) {
+        return a[l + i];
+    }
+    int size() {
+        return r - l;
+    }
+};
+abc g;
+LL calc(LL x, LL pos) {
+    if (x < pos) return 0;
+    return (x - pos) / pos / 2 + 1;
+}
+int main() {
+    int n;
+    while (cin >> n) {
+        g.Init();
+        rep0(i, n) {
+            int id, w;
+            sint(id);
+            if (id == 1) {
+                sint(w);
+                g.push_back(w);
+            }
+            else {
+                LL L, R, k;
+                sint3(L, R, k);
+                int sz = g.size();
+                rep0(i, sz) {
+                    LL pos = 1LL << g[i].second, c = calc(R, pos) - calc(L - 1, pos);
+                    if (k <= c) {
+                        pint(g[i].first);
+                        pchr('\n');
+                        break;
+                    }
+                    k -= c;
+                }
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5206_autoAC.cpp b/HDOJ/5206_autoAC.cpp
new file mode 100644
index 0000000..76d613d
--- /dev/null
+++ b/HDOJ/5206_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<iostream>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+#include<vector>
+#include<queue>
+#define inf 0x7fffffff
+using namespace std;
+typedef long long LL;
+const LL maxn=10000+10;
+LL n,m;
+struct Point
+{
+    LL x,y,z;
+    Point (LL x=0,LL y=0,LL z=0):x(x),y(y),z(z){}
+}a,b,c,d;
+typedef Point Vector;
+double Dot(Vector A,Vector B) {return A.x*B.x + A.y*B.y; }
+double Length(Vector A) {return sqrt(Dot(A,A)); }
+double angle(Vector A,Vector B) {return acos(Dot(A,B)/Length(A)/Length(B)); }
+LL dis(Point A,Point B)
+{
+    LL xx=(A.x-B.x)*(A.x-B.x);
+    LL yy=(A.y-B.y)*(A.y-B.y);
+    LL zz=(A.z-B.z)*(A.z-B.z);
+    return xx+yy+zz;
+}
+int main()
+{
+    int t,ncase=1;
+    scanf("%d",&t);
+    while (t--)
+    {
+        scanf("%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d",
+            &a.x,&a.y,&a.z,&b.x,&b.y,&b.z,&c.x,&c.y,&c.z,&d.x,&d.y,&d.z);
+             int flag=0;
+        LL len,len2,len3;
+        len=dis(a,b) ;len2=dis(a,c) ;len3=dis(a,d) ;
+        if ((len==len2&&len3==len+len2)||(len==len3&&len2==len+len3)||(len2==len3&&len==len2+len3))
+            flag++;
+        len=dis(b,a) ;len2=dis(b,c) ;len3=dis(b,d) ;
+        if ((len==len2&&len3==len+len2)||(len==len3&&len2==len+len3)||(len2==len3&&len==len2+len3))
+            flag++;
+            len=dis(c,a) ;len2=dis(c,b) ;len3=dis(c,d) ;
+        if ((len==len2&&len3==len+len2)||(len==len3&&len2==len+len3)||(len2==len3&&len==len2+len3))
+            flag++;
+            len=dis(d,a) ;len2=dis(d,b) ;len3=dis(d,c) ;
+        if ((len==len2&&len3==len+len2)||(len==len3&&len2==len+len3)||(len2==len3&&len==len2+len3))
+            flag++;
+        if (flag==4) printf("Case #%d: Yes\n",ncase++);
+        else printf("Case #%d: No\n",ncase++);
+    }
+    return 0;
+}
diff --git a/HDOJ/5207_autoAC.cpp b/HDOJ/5207_autoAC.cpp
new file mode 100644
index 0000000..34d53a3
--- /dev/null
+++ b/HDOJ/5207_autoAC.cpp
@@ -0,0 +1,34 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#define maxn 100000+5
+using namespace std;
+int mapp[maxn],head[maxn];
+int n;
+int main()
+{
+    cin.sync_with_stdio(false);
+    int t,casee=1;
+    cin>>t;
+    while(t--)
+    {
+        cin>>n;
+        memset(mapp,0,sizeof(mapp));
+        memset(head,0,sizeof(head));
+        int maxx=-1;
+        for(int i=0;i<n;i++){int x;cin>>x;mapp[x]++;maxx=max(maxx,x);}
+        for(int i=2;i<=maxx;i++)
+        {
+            for(int j=i;j<=maxx;j+=i)
+            {
+                if(mapp[j]) head[i]+=mapp[j];
+            }
+        }    
+        cout<<"Case #"<<casee++<<": ";
+        for(int i=maxx;i>=1;i--)
+        {
+            if(head[i]>=2) {cout<<i<<endl;break;}
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5208_autoAC.cpp b/HDOJ/5208_autoAC.cpp
new file mode 100644
index 0000000..1e4f322
--- /dev/null
+++ b/HDOJ/5208_autoAC.cpp
@@ -0,0 +1,61 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+typedef long long LL;
+int _,ans;
+int state(int i,int l,int r)
+{
+    if((1 << i) <= l)return 1;
+    else if((1 << i) > r)return 0;
+    else return -1;
+}
+void deal(int & l,int & r,int v,int i)
+{
+    l = max(l - v,0);
+    r = min(max(r - v,0),(1 << i) - 1);
+}
+void dfs(int l1,int r1,int l2,int r2,int i,int cur)
+{
+    if(l2 <= l1 && r1 <= r2 || i == -1)return;
+    if(cur + ((LL)1 << (i + 1)) - 1 < ans)return;
+    int st1 = state(i,l1,r1),st2 = state(i,l2,r2);
+    if(st1 >= 0 && st2 >= 0)
+    {
+        cur |= ((st1 ^ st2) << i);
+        ans = max(cur,ans);
+        deal(l1,r1,st1 << i,i) , deal(l2,r2,st2 << i,i);
+        dfs(l1,r1,l2,r2,i - 1,cur);
+    }
+    else if(st1 == -1 && st2 == -1)
+    {
+        dfs(l1,min(r1,(1 << i) - 1),l2,min(r2,(1 << i) - 1),i - 1,cur);
+        deal(l1,r1,1 << i,i) , deal(l2,r2,1 << i,i);
+        dfs(l1,r1,l2,r2,i - 1,cur);
+    }
+    else if(st1 >= 0 && st2 == -1)
+    {
+        deal(l1,r1,st1 << i,i) , deal(l2,r2,st1 << i,i);
+        dfs(l1,r1,l2,r2,i - 1,cur);
+    }
+    else// if(st1 == -1 && st2 >= 0)
+    {
+        cur |= (1 << i);
+        ans = max(cur,ans);
+        deal(l1,r1,!st2 << i,i) , deal(l2,r2,st2 << i,i);
+        dfs(l1,r1,l2,r2,i - 1,cur);
+    }
+}
+int main()
+{
+    scanf("%d",&_);
+    for(int kcas = 1;kcas <= _;kcas++)
+    {
+        int l1,l2,r1,r2;
+        scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
+        ans = 0;
+        dfs(l1,r1,l2,r2,30,0);
+        printf("Case #%d: %d\n",kcas,ans);
+    }
+}
diff --git a/HDOJ/5209_autoAC.cpp b/HDOJ/5209_autoAC.cpp
new file mode 100644
index 0000000..b88c2d1
--- /dev/null
+++ b/HDOJ/5209_autoAC.cpp
@@ -0,0 +1,61 @@
+#include<cstdio>  
+#include<cstring>  
+#include<cmath>  
+#include<algorithm>  
+#include<iostream>  
+using namespace std;  
+const int mod=1000000007;  
+const int maxn=110005;  
+typedef long long LL;  
+LL jie[maxn],jie2[maxn];  
+int mm(int n,int m){  
+    LL s=1,k=n;  
+    while(m>0){  
+        if(m&1){  
+            s=s*k;  
+            s%=mod;  
+        }  
+        k=k*k;  
+        k%=mod;  
+        m>>=1;  
+    }  
+    return s;  
+}  
+int zuhe(int n,int m){  
+    LL s;  
+    s=jie[n];  
+    s=s*jie2[m];  
+    s%=mod;  
+    s=s*jie2[n-m];  
+    s%=mod;  
+    return s;  
+}  
+void init(void){  
+    int i;  
+    jie[0]=1;  
+    jie2[0]=1;  
+    for(i=1;i<=110000;i++){  
+        jie[i]=jie[i-1]*i;  
+        jie[i]%=mod;  
+        jie2[i]=mm(jie[i],mod-2);  
+    }  
+}  
+LL dp[1005];  
+int main()  
+{  
+    int i,j,n,m,t,N=0;  
+    cin>>t;  
+    init();  
+    while(t--){  
+        cin>>n>>m;  
+        memset(dp,0,sizeof(dp));  
+        dp[0]=1;  
+        for(i=1;i<=n;i++){  
+            for(j=1;j<=i;j++){  
+                dp[i]+=zuhe(i-1,j-1)*((dp[i-j]*zuhe(j+m-1,m-1))%mod);  
+                dp[i]%=mod;  
+            }  
+        }  
+        printf("Case #%d: %d\n",++N,dp[n]);  
+    }  
+}
diff --git a/HDOJ/5210_autoAC.cpp b/HDOJ/5210_autoAC.cpp
new file mode 100644
index 0000000..11d4c4c
--- /dev/null
+++ b/HDOJ/5210_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<iostream>
+#include<cstring>
+#define maxn 100+5
+using namespace std;
+int mapp[maxn];
+int main()
+{
+    int n;
+    while(cin>>n)
+    {
+        int sum=0;
+        memset(mapp,0,sizeof(mapp));
+        for(int i=0;i<n;i++)
+        {
+            int x;
+            cin>>x;
+            if(!mapp[x]) sum++;
+            mapp[x]++; 
+        }
+        int k;
+        cin>>k;
+        k-=(n-sum);
+        if(k<=0) cout<<sum<<endl;
+        else cout<<sum-k<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5211_autoAC.cpp b/HDOJ/5211_autoAC.cpp
new file mode 100644
index 0000000..e032b30
--- /dev/null
+++ b/HDOJ/5211_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<cmath>
+using namespace std;
+#define MAXN 10005
+int num[MAXN],n,f[MAXN];
+int main()
+{
+    while(scanf("%d",&n) != EOF)
+    {
+        int ans = 0;
+        memset(f,0,sizeof(f));
+        for(int i = 0;i < n;i++)
+            scanf("%d",&num[i]);
+        for(int i = n - 1;i >= 0;i--)
+        {
+            ans += f[num[i]];
+            int q = sqrt(num[i] + 1) + 1;
+            for(int j = 1;j <= q && j <= num[i];j++)
+                if(num[i] % j == 0)
+                    f[j] = i + 1,
+                    f[num[i] / j] = i + 1;
+        }
+        printf("%d\n",ans);
+    }
+}
diff --git a/HDOJ/5212_autoAC.cpp b/HDOJ/5212_autoAC.cpp
new file mode 100644
index 0000000..e9aea60
--- /dev/null
+++ b/HDOJ/5212_autoAC.cpp
@@ -0,0 +1,39 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+typedef long long LL;
+int dp[11111];
+int num[11111];
+int sum[11111];
+int n;
+int main()
+{
+    while(scanf("%d", &n) != EOF)
+    {
+        int maxnum = 0, ans = 0;
+        memset(sum, 0, sizeof(sum));
+        for(int i = 0; i < n; i ++)
+        {
+            scanf("%d", &num[i]);
+            sum[num[i]] ++;
+            maxnum = maxnum < num[i] ? num[i] : maxnum;
+        }
+        memset(dp, 0, sizeof(dp));
+        for(int i = 2; i <= maxnum; i ++)
+        {
+            for(int j = i; j <= maxnum; j += i)
+            {
+                dp[i] += sum[j];
+            }
+            dp[i] *= dp[i];
+        }
+        for(int i = maxnum; i >= 2; i --)
+        {
+            for(int j = i + i; j <= maxnum; j += i)
+                dp[i] -= dp[j];
+            ans = (ans + (LL)i * (i - 1) * dp[i]) % 10007;
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5213_autoAC.cpp b/HDOJ/5213_autoAC.cpp
new file mode 100644
index 0000000..5bc53f4
--- /dev/null
+++ b/HDOJ/5213_autoAC.cpp
@@ -0,0 +1,83 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<math.h>
+#include<map>
+#include<vector>
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+using namespace std;
+#define N 30005
+int a[N];
+int n,k,m;
+int len,tot;
+int l1,l2,r1,r2;
+int ans[N],c[N*2];
+struct node{
+    int l,r,id,p;
+    void set(int i,int ll,int rr,int pp){
+        id=i;l=ll;r=rr;p=pp;
+    }
+}f[N*4];
+bool cmp(node a,node b){
+    if(a.l/len!=b.l/len) return a.l/len<b.l/len;
+    return a.r<b.r;
+}
+void solve(){
+    int nl=1;
+    int nr=0;
+    int res=0;
+    for(int i=0;i<tot;i++)
+    {
+        while(nl>f[i].l){
+            nl--;
+            if(k>a[nl]) res+=c[k-a[nl]];
+            c[a[nl]]++;
+        }
+        while(nr<f[i].r){
+            nr++;
+            if(k>a[nr]) res+=c[k-a[nr]];
+            c[a[nr]]++;
+        }
+        while(nl<f[i].l){
+            if(k>a[nl]) res-=c[k-a[nl]];
+            c[a[nl]]--;
+            nl++;
+        }
+        while(nr>f[i].r){
+            if(k>a[nr]) res-=c[k-a[nr]];
+            c[a[nr]]--;
+            nr--;
+        }
+        ans[f[i].id]+=res*f[i].p;
+    }
+}
+int main()
+{
+    while(~scanf("%d",&n)){
+        scanf("%d",&k);
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&a[i]);
+        }
+        memset(c,0,sizeof(c));
+        scanf("%d",&m);
+        tot=0;
+        for(int i=1;i<=m;i++)
+        {
+            ans[i]=0;
+            scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
+            f[tot++].set(i,l1,r2,1);
+            f[tot++].set(i,l1,l2-1,-1);
+            f[tot++].set(i,r1+1,r2,-1);
+            if(r1+1<=l2-1) f[tot++].set(i,r1+1,l2-1,1);
+        }
+        len=sqrt(n);
+        sort(f,f+tot,cmp);
+        solve();
+        for(int i=1;i<=m;i++)
+        printf("%d\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5214_autoAC.cpp b/HDOJ/5214_autoAC.cpp
new file mode 100644
index 0000000..f6e6d25
--- /dev/null
+++ b/HDOJ/5214_autoAC.cpp
@@ -0,0 +1,45 @@
+#include<iostream>  
+#include<cstdio>  
+#include<cstring> 
+#include <cmath> 
+#include<stack>
+#include<vector>
+#include<map> 
+#include<set>
+#include<queue> 
+#include<algorithm>  
+using namespace std;
+typedef long long LL;
+const int INF = (1<<30)-1;
+const int mod=4294967296;
+const int maxn=10000005;
+unsigned int  l[maxn],r[maxn];
+int main(){
+    int T;
+    scanf("%d",&T);
+    while(T--){
+        memset(l,0,sizeof(l));
+        memset(r,0,sizeof(r));
+        unsigned int n,a,b,c,d;
+        cin>>n>>l[1]>>r[1]>>a>>b>>c>>d;
+        for(int i=2;i<=n;i++) l[i]=l[i-1]*a+b;
+        for(int i=2;i<=n;i++) r[i]=r[i-1]*c+d;
+        for(int i=1;i<=n;i++)
+        if(l[i]>r[i]) swap(l[i],r[i]);
+        int minn=r[1],maxx=l[1];
+        for(int i=1;i<=n;i++){
+            if(l[i]>maxx) maxx=l[i];
+            if(r[i]<minn) minn=r[i];
+        }
+        int flag=0;
+        for(int i=1;i<=n;i++){
+            if(l[i]>minn&&r[i]<maxx){
+                flag=1;
+                break;
+            }
+        }
+        if(flag) printf("YES\n");
+        else printf("NO\n");                
+    }
+    return 0;
+}
diff --git a/HDOJ/5215_autoAC.cpp b/HDOJ/5215_autoAC.cpp
new file mode 100644
index 0000000..b357c60
--- /dev/null
+++ b/HDOJ/5215_autoAC.cpp
@@ -0,0 +1,86 @@
+#pragma comment(linker, "/STACK:102400000,102400000")
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+const int maxn=200000+100;
+struct Edge
+{
+    int v, nxt;
+    Edge(int v=0, int nxt=0):v(v), nxt(nxt) {}
+} edge[600010];
+bool even, odd;
+int n, m, head[maxn], color[maxn], tot, cnt, pre[maxn], bel[maxn];
+void init()
+{
+    tot=even=odd=0;
+    cnt=0;
+    memset(color, 0, sizeof color);
+    memset(head, -1, sizeof head);
+    memset(bel, -1, sizeof bel);
+}
+void AddEdge(int u, int v)
+{
+    edge[tot]=Edge(v, head[u]);
+    head[u]=tot++;
+}
+void dfs(int u, int fa)
+{
+    for(int i=head[u]; ~i; i=edge[i].nxt)
+    {
+        if((i^1)==fa)continue ;
+        int v=edge[i].v;
+        if(color[v]==color[u])    
+        {
+            odd=1;
+            ++cnt;
+            int x=v;
+            while(!even)    
+            {
+                if(~bel[x])
+                {
+                    even=true;
+                    break;
+                }
+                bel[x]=cnt;
+                x=pre[x];
+                if(x==u || x==-1)break;
+            }
+        }
+        if(color[v]==3-color[u])    
+            even=1;
+        if(!color[v])
+        {
+            color[v]=3-color[u];
+            pre[v]=u;
+            dfs(v, i);
+        }
+    }
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%d%d", &n, &m);
+        init();
+        while(m--)
+        {
+            int u, v;
+            scanf("%d%d", &u, &v);
+            AddEdge(u, v);
+            AddEdge(v, u);
+        }
+        for(int i=1; i<=n; i++)
+            if(!color[i])
+            {
+                color[i]=1;
+                pre[i]=-1;
+                dfs(i, -1);
+            }
+        puts(odd?"YES":"NO");
+        puts(even?"YES":"NO");
+    }
+    return 0;
+}
diff --git a/HDOJ/5216_autoAC.cpp b/HDOJ/5216_autoAC.cpp
new file mode 100644
index 0000000..e7a8e05
--- /dev/null
+++ b/HDOJ/5216_autoAC.cpp
@@ -0,0 +1,40 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int maxn=100010;
+int N,M;
+int A[maxn],B[maxn];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&N,&M);
+        for(int i=1;i<=M;i++)scanf("%d",&A[i]);
+        for(int i=1;i<=M;i++)scanf("%d",&B[i]);
+        sort(A+1,A+1+M);
+        sort(B+1,B+1+M);
+        bool flag=true;
+        for(int i=1;i<=M;i++)
+            if(A[i]>B[i]){flag=false;break;}
+        if(!flag){printf("Stupid BrotherK!\n");}
+        else
+        {
+            int ans=max(A[1]-1,N-B[M]);
+            int last=0;
+            for(int i=1;i<=M;i++)
+            {
+                if(A[i]>last)
+                {
+                    ans=max(ans,A[i]-last-1);
+                }
+                last=B[i];
+            }
+            printf("%.6lf\n",double(ans));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5217_autoAC.cpp b/HDOJ/5217_autoAC.cpp
new file mode 100644
index 0000000..eb0227f
--- /dev/null
+++ b/HDOJ/5217_autoAC.cpp
@@ -0,0 +1,178 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+#define N 200010
+char str[N];
+struct Node
+{
+    Node(int l=0,int r=0){lnum=l;rnum=r;}
+    int lnum,rnum;
+}node[N<<2];
+void pushup(int rt)
+{
+    int matched=min(node[rt<<1].lnum,node[rt<<1|1].rnum);
+    node[rt].lnum=node[rt<<1].lnum+node[rt<<1|1].lnum-matched;
+    node[rt].rnum=node[rt<<1].rnum+node[rt<<1|1].rnum-matched;
+}
+void build(int l,int r,int rt)
+{
+    if(l==r)
+    {
+        node[rt].lnum=node[rt].rnum=0;
+        if(str[l]=='(')node[rt].lnum=1;
+        else node[rt].rnum=1;
+        return ;
+    }
+    int mid=(l+r)/2;
+    build(l,mid,rt<<1);
+    build(mid+1,r,rt<<1|1);
+    pushup(rt);
+}
+Node query(int L,int R,int l,int r,int rt)
+{
+    if(L<=l&&r<=R)
+        return node[rt];
+    int mid=(l+r)/2;
+    Node ret;
+    if(L<=mid)ret=query(L,R,l,mid,rt<<1);
+    if(R>mid)
+    {
+        Node tmp=query(L,R,mid+1,r,rt<<1|1);
+        int matched=min(ret.lnum,tmp.rnum);
+        ret.lnum+=tmp.lnum-matched;
+        ret.rnum+=tmp.rnum-matched;
+    }
+    return ret;
+}
+void change(int x,int l,int r,int rt)
+{
+    if(l==r&&r==x)
+    {
+        swap(node[rt].lnum,node[rt].rnum);
+        return;
+    }
+    int mid=(l+r)/2;
+    if(x<=mid)change(x,l,mid,rt<<1);
+    else change(x,mid+1,r,rt<<1|1);
+    pushup(rt);
+    return;
+}
+int lsearch(int L,int R,int K,Node &Val,int l,int r,int rt)
+{
+    if(L<=l&&r<=R)
+    {
+        int mid=(l+r)/2;
+        if(l==r)
+        {
+            int matched=min(Val.lnum,node[rt].rnum);
+            int lnum=Val.lnum+node[rt].lnum-matched;
+            int rnum=Val.rnum+node[rt].rnum-matched;
+            if(rnum==K)return l;
+            else
+            {
+                Val.lnum=lnum;
+                Val.rnum=rnum;
+                return 0;
+            }
+        }
+        int matched=min(Val.lnum,node[rt<<1].rnum);
+        int lnum=Val.lnum+node[rt<<1].lnum-matched;
+        int rnum=Val.rnum+node[rt<<1].rnum-matched;
+        if(K<=rnum)
+        {
+            return lsearch(L,R,K,Val,l,mid,rt<<1);
+        }
+        else
+        {
+            Val.lnum=lnum;
+            Val.rnum=rnum;
+            return lsearch(L,R,K,Val,mid+1,r,rt<<1|1);
+        }
+    }
+    int mid=(l+r)/2;
+    if(R<=mid)return lsearch(L,R,K,Val,l,mid,rt<<1);
+    if(L>mid)return lsearch(L,R,K,Val,mid+1,r,rt<<1|1);
+    int ret=lsearch(L,R,K,Val,l,mid,rt<<1);
+    if(ret)return ret;
+    else return lsearch(L,R,K,Val,mid+1,r,rt<<1|1);
+}
+int rsearch(int L,int R,int K,Node &Val,int l,int r,int rt)
+{
+     if(L<=l&&r<=R)
+    {
+        int mid=(l+r)/2;
+        if(l==r)
+        {
+             int matched=min(Val.rnum,node[rt].lnum);
+             int lnum=Val.lnum+node[rt].lnum-matched;
+             int rnum=Val.rnum+node[rt].rnum-matched;
+             if(lnum==K)return l;
+            else
+            {
+                Val.lnum=lnum;
+                Val.rnum=rnum;
+                return 0;
+            }
+        }
+        int matched=min(Val.rnum,node[rt<<1|1].lnum);
+        int lnum=Val.lnum+node[rt<<1|1].lnum-matched;
+        int rnum=Val.rnum+node[rt<<1|1].rnum-matched;
+        if(K<=lnum)
+        {
+            return rsearch(L,R,K,Val,mid+1,r,rt<<1|1);
+        }
+        else
+        {
+            Val.lnum=lnum;
+            Val.rnum=rnum;
+            return rsearch(L,R,K,Val,l,mid,rt<<1);
+        }
+    }
+    int mid=(l+r)/2;
+    if(R<=mid)return rsearch(L,R,K,Val,l,mid,rt<<1);
+    if(L>mid)return rsearch(L,R,K,Val,mid+1,r,rt<<1|1);
+    int ret=rsearch(L,R,K,Val,mid+1,r,rt<<1|1);
+    if(ret)return ret;
+    else return rsearch(L,R,K,Val,l,mid,rt<<1);
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int n,q;
+        scanf("%d%d",&n,&q);
+        scanf(" %s",&str[1]);
+        int len=strlen(&str[1]);
+        build(1,len,1);
+        for(int i=0;i<q;i++)
+        {
+            int type;
+            scanf("%d",&type);
+            if(type==1)
+            {
+                int x;
+                scanf("%d",&x);
+                change(x,1,len,1);
+            }
+            else
+            {
+                int a,b,k;
+                scanf("%d%d%d",&a,&b,&k);
+                Node tp(0,0),qry=query(a,b,1,len,1);
+                int cnt=qry.lnum+qry.rnum;
+                if(cnt<k){printf("-1\n");continue;}
+                if(k<=qry.rnum)
+                {
+                    printf("%d\n",lsearch(a,b,k,tp,1,len,1));
+                }
+                else
+                {
+                    printf("%d\n",rsearch(a,b,cnt-k+1,tp,1,len,1));
+                }
+            }
+        }
+    }
+}
diff --git a/HDOJ/5218_autoAC.cpp b/HDOJ/5218_autoAC.cpp
new file mode 100644
index 0000000..4916567
--- /dev/null
+++ b/HDOJ/5218_autoAC.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+#include<string.h>
+#include<stdio.h>
+#include<algorithm>
+using namespace std;
+int arr[300];
+int n,m;
+int dp[300][300];
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&m);
+        for(int i=0;i<m;i++)scanf("%d",&arr[i]);
+        memset(dp,0,sizeof(dp));
+        dp[1][0]=1;
+        for(int i=2;i<=n;i++)
+        {
+            for(int j=0;j<i;j++)
+            {
+                for(int k=0;k<m;k++)
+                {
+                    if((arr[k]-1)%i==j)continue;
+                    if((arr[k]-1)%i<j)dp[i][j]=dp[i-1][j-(arr[k]-1)%i-1];
+                    if((arr[k]-1)%i>j)dp[i][j]=dp[i-1][i-1-((arr[k]-1)%i-j)];
+                    if(dp[i][j])break;
+                }
+            }
+        }
+        int ok=1,ans=0;
+        for(int i=0;i<n;i++)if(dp[n][i])ans++;
+        printf("%d\n",ans);
+        for(int i=0;i<n;i++)
+            if(dp[n][i])
+            {
+                if(ok)ok=0;
+                else printf(" ");
+                printf("%d",i+1);
+            }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5219_autoAC.cpp b/HDOJ/5219_autoAC.cpp
new file mode 100644
index 0000000..e2cf476
--- /dev/null
+++ b/HDOJ/5219_autoAC.cpp
@@ -0,0 +1,183 @@
+#include<iostream>
+#include<sstream>
+#include<fstream>
+#include<vector>
+#include<list>
+#include<deque>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<bitset>
+#include<algorithm>
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cctype>
+#include<cmath>
+#include<ctime>
+#include<iomanip>
+using namespace std;
+const double eps(1e-8);
+typedef long long lint;
+#define ws Ws
+#define rank rrrank
+const int maxn = 100200 + 1;
+int prime[maxn], vis[maxn], mu[maxn];
+int tot;
+void Mobius(){
+    mu[1] = 1;
+    for( int i = 2 ; i < maxn ; i ++ ){
+        if( !vis[i] )
+            prime[++tot] = i, mu[i] = -1;
+        for( int j = 1 ; j <= tot && i * prime[j] < maxn ; j ++ ){
+            vis[i*prime[j]] = 1;
+            if( i % prime[j] == 0 ){
+                mu[i*prime[j]] = 0;
+                break;
+            }
+            else
+                mu[i*prime[j]] = - mu[i];
+        }
+    }
+    return;
+}
+int wa[maxn], wb[maxn], wv[maxn], ws[maxn];
+int cmp(int *r, int a, int b, int l)
+{
+    return r[a] == r[b] && r[a + l] == r[b + l];
+}
+void da(int *r, int *sa, int n, int m)
+{
+    int *x = wa, *y = wb, *t, i, j, p;
+    for(i = 0; i < m; i++) ws[i] = 0;
+    for(i = 0; i < n; i++) ws[x[i] = r[i]]++;
+    for(i = 1; i < m; i++) ws[i] += ws[i - 1];
+    for(i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;
+    for(j = 1, p = 1; p < n; j <<= 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 < n; i++) wv[i] = x[y[i]];
+        for(i = 0; i < m; i++) ws[i] = 0;
+        for(i = 0; i < n; i++) ws[wv[i]]++;
+        for(i = 1; i < m; i++) ws[i] += ws[i - 1];
+        for(i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];
+        for(t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
+            x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
+    }
+    return;
+}
+int rank[maxn], height[maxn];
+void calheight(int *r, int *sa, int n)
+{
+    int i, j, k = 0;
+    for(i = 1; i <= n; i++) rank[sa[i]] = i;
+    for(i = 0; i < n; height[rank[i++]] = k)
+        for(k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; k++);
+    return;
+}
+int rank2[maxn], height2[maxn];
+void calheight2(int *r, int *sa, int n)
+{
+    int i, j, k = 0;
+    for(i = 1; i <= n; i++) rank2[sa[i]] = i;
+    for(i = 0; i < n; height2[rank2[i++]] = k)
+        for(k ? k-- : 0, j = sa[rank2[i] - 1]; r[i + k] == r[j + k]; k++);
+    return;
+}
+int dp[maxn][20];
+void initRMQ(int n)
+{
+    for(int i = 1; i <= n; i++) dp[i][0] = height[i];
+    for(int j = 1; (1 << j) <= n; j++)
+        for(int i = 1; i + (1 << j) - 1 <= n; i++)
+            dp[i][j] = min(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
+    return;
+}
+int dp2[maxn][20];
+void initRMQ2(int n)
+{
+    for(int i = 1; i <= n; i++) dp2[i][0] = height2[i];
+    for(int j = 1; (1 << j) <= n; j++)
+        for(int i = 1; i + (1 << j) - 1 <= n; i++)
+            dp2[i][j] = min(dp2[i][j - 1], dp2[i + (1 << (j - 1))][j - 1]);
+    return;
+}
+int askRMQ(int a, int b)
+{
+    int ra = rank[a], rb = rank[b];
+    if(ra > rb) swap(ra, rb);
+    int k = 0;
+    while((1 << (k + 1)) <= rb - ra) k++;
+    return min(dp[ra + 1][k], dp[rb - (1 << k) + 1][k]);
+}
+int len;
+int askRMQ2(int a, int b)
+{
+    a = len - a - 1;
+    b = len - b - 1;
+    int ra = rank2[a], rb = rank2[b];
+    if(ra > rb) swap(ra, rb);
+    int k = 0;
+    while((1 << (k + 1)) <= rb - ra) k++;
+    return min(dp2[ra + 1][k], dp2[rb - (1 << k) + 1][k]);
+}
+char in[maxn];
+int s[maxn], sa[maxn];
+int main()
+{
+    Mobius();
+    int T;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%s", in);
+        len = strlen(in);
+        for(int i = 0; i < len; i++)
+            s[i] = in[i] - 'a' + 1;
+        s[len] = 0;
+        da(s, sa, len + 1, 28);
+        calheight(s, sa, len);
+        initRMQ(len);
+        for(int i = 0; i < len; i++)
+            s[i] = in[len - 1 - i] - 'a' + 1;
+        s[len] = 0;
+        da(s, sa, len + 1, 28);
+        calheight2(s, sa, len);
+        initRMQ2(len);
+        lint ans = 0;
+        for(int L = 1; L <= (len >> 1); L++)
+        {
+            int n = len;
+            int blocks = n / L + (n % L != 0);
+            int now = 1;
+            while(now < blocks)
+            {
+                if(now + 1 < blocks)
+                {
+                    int len2 = askRMQ2((now + 1)*L - 1, now*L - 1);
+                    int len1 = askRMQ(now*L, (now + 1)*L);
+                    int totlen = L + len2 + len1;
+                    int cnt = totlen / L;
+                    for(int i = 2; i <= cnt; i++)
+                    {
+                        ans += mu[i]*(totlen - L*i + 1);
+                    }
+                    now = now + (len1 / L) + 1;
+                }
+                else
+                {
+                    if(n % L != 0) break;
+                    int totlen = (len - now*L) + askRMQ2(len - 1, now*L - 1);
+                    int cnt = totlen / L;
+                    for(int i = 2; i <= cnt; i++)
+                        ans += mu[i]*(totlen - L*i + 1);
+                    now = blocks;
+                }
+            }
+        }
+        printf("%I64d\n", (lint)len*(len + 1LL) / 2LL + ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5220_autoAC.cpp b/HDOJ/5220_autoAC.cpp
new file mode 100644
index 0000000..7f0dc9d
--- /dev/null
+++ b/HDOJ/5220_autoAC.cpp
@@ -0,0 +1,66 @@
+#include <cstdio>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+#include <vector>
+#include <map>
+using namespace std;
+typedef long long LL;
+#pragma comment(linker, "/STACK:102400000,102400000") 
+#define pb push_back
+#define mp make_pair
+#define F first
+#define S second
+const int N = 33;
+int f[N], c[N], m[N], d[N], w[N];
+vector<int> a[N], b[N];
+typedef pair<int, int> pii;
+map<pii, LL> g[2];
+map<pii, LL>:: iterator it;
+int main() {
+	int n, T;
+	scanf("%d", &T);
+	while (T--) {
+		scanf("%d", &n);
+		for (int i = 1; i <= 32; ++i)	a[i].clear(), b[i].clear();
+		memset(w, 0, sizeof(w));
+		memset(d, 0, sizeof(d));
+		g[0].clear(), g[1].clear();
+		for (int i = 0; i < n; ++i) {
+			scanf("%d%d%d", &f[i], &c[i], &m[i]);
+			a[f[i]].pb(i), b[c[i]].pb(i);
+		}
+		bool ok = 1;
+		int mask = 0, cnt = 0;
+		for (int i = 1; i <= 32; ++i) {
+			if (b[i].size() == 1) {
+				if (d[f[b[i][0]]])	ok = 0;
+				mask ^= m[b[i][0]];
+				d[f[b[i][0]]] = 1;
+			}
+			else if (b[i].size() > 1) w[i] = cnt++; 
+		}	
+		if (!ok) {
+			puts("0");
+			continue;
+		}
+		int now = 0;
+		g[now].insert(mp(mp(0, 0), 1));
+		for (int i = 1; i <= 32; ++i) {
+			if (!a[i].size() || d[i])	continue;
+			g[now ^ 1] = g[now];
+			for (it = g[now].begin(); it != g[now].end(); it++) {
+				pii st = it -> F;
+				LL d = it -> S;
+				for (int j = 0; j < a[i].size(); ++j) {
+					int t = a[i][j];
+					pii tmp = mp(st.F ^ m[t], st.S | (1 << w[c[t]]));
+					g[now ^ 1][tmp] += d;
+				}
+			}
+			now ^= 1;
+		}
+		printf("%I64d\n", g[now][mp(mask, (1 << cnt) - 1)]);
+	}
+	return 0;
+}
diff --git a/HDOJ/5221_autoAC.cpp b/HDOJ/5221_autoAC.cpp
new file mode 100644
index 0000000..0bc91d2
--- /dev/null
+++ b/HDOJ/5221_autoAC.cpp
@@ -0,0 +1,222 @@
+#pragma comment(linker, "/STACK:102400000,102400000")
+#include <iostream>
+#include <string.h>
+#include <math.h>
+#include <queue>
+#include <algorithm>
+#include <stdlib.h>
+#include <map>
+#include <set>
+#include <stdio.h>
+#include <vector>
+#define L(x) (x*2)
+#define R(x) (x*2 + 1)
+using namespace std;
+const int INF = 0x3f3f3f3f ;
+const int MX = 100000 + 5 ;
+int n ,m ,num ,idx ,sum ;
+int dep[MX] ,top[MX] ,V[MX] ,ti[MX] ,to[MX] ,head[MX] ,father[MX] ,siz[MX] ,son[MX] ;
+struct Edge
+{
+    int v ,next ;
+}E[MX*2] ;
+void add_edge(int u ,int v)
+{
+    E[num].v = v ; E[num].next = head[u] ; head[u] = num++ ;
+    E[num].v = u ; E[num].next = head[v] ; head[v] = num++ ;
+}
+void dfs_find(int u ,int fa)
+{
+    dep[u] = dep[fa] + 1 ;
+    father[u] = fa ;
+    siz[u] = 1 ;
+    son[u] = 0 ;
+    for(int i = head[u] ;i != -1 ; i = E[i].next)
+    {
+        int v = E[i].v ;
+        if(v == fa)  continue ;
+        dfs_find(v ,u) ;
+        siz[u] += siz[v] ;
+        if(siz[son[u]] < siz[v])   son[u] = v ;
+    }
+}
+void dfs_time(int u ,int fa)
+{
+    ti[u] = idx++ ;
+    top[u] = fa ;
+    if(son[u])  dfs_time(son[u] ,top[u]) ;
+    for(int i = head[u] ;i != -1 ;i = E[i].next)
+    {
+        int v = E[i].v ;
+        if(v == father[u] || v == son[u])  continue ;
+        dfs_time(v ,v) ;
+    }
+    to[u] = idx-1 ;
+}
+void init()
+{
+    sum = 0 ;
+    num = 0 ;
+    memset(head ,-1 ,sizeof(head)) ;
+}
+struct node
+{
+    int le ,rt ,sum ,flag ;
+}T[MX*4] ;
+void build(int x ,int le ,int rt)
+{
+    T[x].sum = 0 ;
+    T[x].flag = true ;
+    T[x].le = le ; T[x].rt = rt ;
+    if(le == rt)
+               return ;
+    int Mid = (le + rt)>>1 ;
+    build(L(x) ,le ,Mid) ;
+    build(R(x),Mid+1 ,rt) ;
+}
+void push_up(int x)
+{
+    T[x].sum = T[L(x)].sum + T[R(x)].sum  ;
+    T[x].flag = true ;
+}
+void push_down(int x)
+{
+    if(!T[x].flag)
+    {
+        T[L(x)].sum = T[R(x)].sum = 0 ;
+        T[L(x)].flag = T[R(x)].flag = false ;
+        T[x].sum = 0 ;
+    }
+}
+bool Findpos(int x ,int pos)
+{
+    if(T[x].le == T[x].rt && T[x].le == pos)
+    {
+        if(!T[x].flag)  T[x].sum = 0 ;
+        return T[x].flag ;
+    }
+    push_down(x) ;
+    int Mid = (T[x].le + T[x].rt)>>1 ;
+    if(pos <= Mid)   return Findpos(L(x) ,pos) ;
+    else    return Findpos(R(x) ,pos) ;
+    push_up(x) ;
+}
+void insert(int x ,int pos ,int w)  
+{
+     if(T[x].le == T[x].rt && T[x].le == pos)
+     {
+         T[x].sum = w ;
+         T[x].flag = true ;
+         return ;
+     }
+     push_down(x) ;
+     int Mid = (T[x].le + T[x].rt)>>1 ;
+     if(pos <= Mid)  insert(L(x) ,pos ,w) ;
+     else    insert(R(x) ,pos ,w) ;
+     push_up(x) ;
+}
+void update(int x ,int Le ,int Rt) 
+{
+    if(T[x].le == Le && T[x].rt == Rt)
+    {
+        T[x].flag = false ;
+        T[x].sum = 0 ;
+        return ;
+    }
+    push_down(x) ;
+    int Mid = (T[x].le + T[x].rt)>>1 ;
+    if(Le > Mid)   update(R(x) ,Le ,Rt) ;
+    else if(Rt <= Mid)  update(L(x) ,Le ,Rt) ;
+    else
+    {
+        update(L(x) ,Le ,Mid) ;
+        update(R(x) ,Mid+1 ,Rt) ;
+    }
+    push_up(x) ;
+}
+int Query(int x ,int Le ,int Rt) 
+{
+   if(T[x].le == Le && T[x].rt == Rt)
+    {
+        if(!T[x].flag)  T[x].sum = 0 ;
+        int temp = T[x].sum ;
+        T[x].sum = 0 ;
+        T[x].flag = false ;
+        return temp ;
+    }
+    push_down(x) ;
+    int Mid = (T[x].le + T[x].rt)>>1 ;
+    if(Le > Mid)   return Query(R(x) ,Le ,Rt) ;
+    else if(Rt <= Mid)  return Query(L(x) ,Le ,Rt) ;
+    else
+        return Query(L(x) ,Le ,Mid) + Query(R(x) ,Mid+1 ,Rt) ;
+}
+void LCA(int u ,int v)
+{
+    int temp ;
+    while(top[u] != top[v])
+    {
+        if(dep[top[u]] < dep[top[v]])
+             swap(u ,v) ;
+        temp = Query(1 ,ti[top[u]] ,ti[u]) ;
+        update(1 ,ti[top[u]] ,ti[u]) ;
+        sum += temp ;
+        u = father[top[u]] ;
+    }
+    if(dep[u] > dep[v])
+         swap(u ,v) ;
+    temp = Query(1 ,ti[u] ,ti[v]) ;
+    update(1 ,ti[u] ,ti[v]) ;
+    sum += temp ;
+}
+int main()
+{
+    int Tx ,u ,v ;
+    scanf("%d" ,&Tx) ;
+    while(Tx--)
+    {
+        init() ;
+        scanf("%d" ,&n) ;
+        for(int i = 1 ;i <= n ; ++i)
+            scanf("%d" ,&V[i]) ;
+        for(int i = 1 ;i < n ; ++i)
+        {
+            scanf("%d%d" ,&u ,&v) ;
+            add_edge(u ,v) ;
+        }
+        dep[1] = siz[0] = 0 ;
+        dfs_find(1 ,1) ;
+        idx = 1 ;
+        dfs_time(1 ,1) ;
+        build(1 ,1 ,n) ;
+        for(int i = 1 ;i <= n ; ++i)
+            insert(1 ,ti[i] ,V[i]) ;
+        scanf("%d" ,&m) ;
+        int type ;
+        for(int i = 0 ;i < m ; ++i)
+        {
+            scanf("%d%d" ,&type ,&u) ;
+            if(type == 1)
+            {
+                scanf("%d" ,&v) ;
+                LCA(u ,v) ;
+            }
+            else if(type == 2)
+            {
+                bool flag = Findpos(1 ,ti[u]) ;
+                if(!flag)
+                {
+                    insert(1 ,ti[u] ,V[u]) ;
+                    sum -= V[u] ;
+                }
+            }
+            else if(type == 3)
+            {
+                sum += Query(1 ,ti[u] ,to[u]) ;
+                update(1 ,ti[u] ,to[u]) ;
+            }
+            cout<<sum<<endl ;
+        }
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5222_autoAC.cpp b/HDOJ/5222_autoAC.cpp
new file mode 100644
index 0000000..9111624
--- /dev/null
+++ b/HDOJ/5222_autoAC.cpp
@@ -0,0 +1,74 @@
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<algorithm>
+using namespace std;
+#pragma comment(linker, "/STACK:102400000,102400000")
+const int maxn = 1000005;
+int N,M1,M2,cnt;
+int fa[maxn],vis[maxn];
+vector<int>G[maxn];
+int find_father(int u){
+    return u == fa[u] ? u : fa[u] = find_father(fa[u]);
+}
+void init(){
+    for(int i = 1; i <= N; i++) fa[i] = i;
+    for(int i = 1; i <= N; i++) G[i].clear();
+}
+bool dfs(int v){
+    vis[v] = -1;
+    for(int i = 0; i < G[v].size(); i++){
+        int e = G[v][i];
+        if(vis[e] < 0) return false;
+        if(!vis[e] && !dfs(e)) return false;
+    }
+    vis[v] = 1;
+    return true;
+}
+int solve(){
+    memset(vis,0,sizeof(vis));
+    for(int i = 1; i <= N; i++){
+        int e = find_father(i);
+        if(!vis[e]){
+            if(!dfs(e)) return true;
+        }
+    }
+    return false;
+}
+int main(){
+    int T;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d%d%d",&N,&M1,&M2);
+        int u,v,ok = 0;
+        init();
+        getchar();
+        for(int i = 0; i < M1; i++){
+            scanf("%d%d",&u,&v);
+            int f1 = find_father(u);
+            int f2 = find_father(v);
+            if(f1 == f2)
+                ok = 1;
+            else
+                fa[f1] = f2;
+        }
+        for(int i = 0; i < M2; i++){
+            scanf("%d%d",&u,&v);
+            if(!ok){
+                int f1 = find_father(u);
+                int f2 = find_father(v);
+                G[f1].push_back(f2);
+            }
+        }
+        if(ok)
+            printf("YES\n");
+        else{
+            ok = solve();
+            if(ok)
+                printf("YES\n");
+            else
+                printf("NO\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5223_autoAC.cpp b/HDOJ/5223_autoAC.cpp
new file mode 100644
index 0000000..7eaffdc
--- /dev/null
+++ b/HDOJ/5223_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<cstdio>
+#include<string>
+#include<queue>
+#include<cstring>
+#include<iostream>
+#include<map>
+#include<stack>
+#include<malloc.h>
+#include<algorithm>
+using namespace std;
+const int maxn = 1005;
+int T, n, m, l[maxn], r[maxn], ans[maxn], x[maxn];
+int gcd(int x, int y)
+{
+    if (x%y) return gcd(y, x%y);
+    return y;
+}
+int main()
+{
+    scanf("%d", &T);
+    while (T--)
+    {
+        scanf("%d%d", &n, &m);
+        for (int i = 1; i <= n; i++) x[i] = 1;
+        int F = 1;
+        for (int i = 1; i <= m; i++)
+        {
+            scanf("%d%d%d", &l[i], &r[i], &ans[i]);
+            for (int j = l[i]; j <= r[i]; j++)
+            {
+                x[j] = x[j] / gcd(ans[i], x[j]);
+                if ((double)x[j] * ans[i] > 1e9) F = 0;
+                x[j] = x[j] * ans[i];
+            }
+        }
+        if (F)
+        for (int i = 1, u; i <= m; i++)
+        {
+            u = x[l[i]];
+            for (int j = l[i]; j <= r[i]; j++) u = gcd(u, x[j]);
+            if (u != ans[i]) { F = 0; break; }
+        }
+        if (F)
+        {
+            for (int i = 1; i < n; i++) printf("%d ", x[i]);
+            printf("%d\n", x[n]);
+        }
+        else printf("Stupid BrotherK!\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5224_autoAC.cpp b/HDOJ/5224_autoAC.cpp
new file mode 100644
index 0000000..3f5e303
--- /dev/null
+++ b/HDOJ/5224_autoAC.cpp
@@ -0,0 +1,23 @@
+#include<cstdio>
+#include<cmath>
+#include<queue>
+#include<map>
+#include<string>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+int T, n;
+int main()
+{
+    scanf("%d", &T);
+    while (T--)
+    {
+        scanf("%d", &n);
+        int k = sqrt(1.0*n), ans = 0x7FFFFFFF;
+        for (int i = 1; i <= k; i++)
+            if (n%i == 0) ans = min(ans, 2 * (i + n / i));
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5225_autoAC.cpp b/HDOJ/5225_autoAC.cpp
new file mode 100644
index 0000000..6f27798
--- /dev/null
+++ b/HDOJ/5225_autoAC.cpp
@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <iostream>
+using namespace std;
+#define mod 1000000007
+#define llt long long
+llt cal[110],a[110],A[110];
+llt tree[330];
+template<class T>
+inline char read(T &n){
+    T x = 0, tmp = 1; char c = getchar();
+    while((c < '0' | c > '9') && c != '-' && c != EOF) c = getchar();
+    if(c == '-') c = getchar(), tmp = -1;
+    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
+    n = x*tmp;
+    return c;
+}
+template <class T>
+inline void write(T n) {
+    if(n < 0) {
+        putchar('-');
+        n = -n;
+    }
+    int len = 0,data[20];
+    while(n) {
+        data[len++] = n%10;
+        n /= 10;
+    }
+    if(!len) data[len++] = 0;
+    while(len--) putchar(data[len]+48);
+}
+void create(llt l,llt r,llt rt)
+{
+    tree[rt]=0;
+    if(l==r) return;
+    llt mid=(l+r)>>1;
+    create(l,mid,rt<<1);
+    create(mid+1,r,rt<<1|1);
+}
+llt query(llt ll,llt rr,llt l,llt r,llt rt)
+{
+    if(l==ll&&r==rr) return tree[rt];
+    llt mid=(l+r)>>1;
+    if(rr<=mid) return query(ll,rr,l,mid,rt<<1);
+    else if(ll>mid) return query(ll,rr,mid+1,r,rt<<1|1);
+    else
+    {
+        llt ans=query(ll,mid,l,mid,rt<<1);
+        ans+=query(mid+1,rr,mid+1,r,rt<<1|1);
+        return ans;
+    }
+}
+void update(llt l,llt r,llt rt,llt x)
+{
+    if(l==x&&r==x)
+    {
+        tree[rt]++;
+        return;
+    }
+    llt mid=(l+r)>>1;
+    if(x<=mid) update(l,mid,rt<<1,x);
+    else update(mid+1,r,rt<<1|1,x);
+    tree[rt]=tree[rt<<1]+tree[rt<<1|1];
+}
+void init()
+{
+    cal[0]=0,cal[1]=0,cal[2]=1;
+    A[1]=1;A[0]=1;
+    for(int i=2;i<=100;i++)
+    {A[i]=(A[i-1]*i)%mod;
+    }
+    for(int i=3;i<=100;i++)
+    {
+        cal[i]=((i*cal[i-1])%mod+(i*(i-1)*A[i-1]/2)%mod)%mod;
+    }
+}
+llt sum(llt x)
+{
+    return ((x-1)*x)/2;
+}
+int main()
+{
+    init();llt n;
+    while(scanf("%I64d",&n)!=EOF)
+    {
+        llt ans=0;
+        llt i,j,pre=0,tmp=0;
+        llt k;
+        create(1,100,1);
+        for(i=1;i<=n;i++)
+        {
+            read(a[i]);
+            tmp=query(a[i]+1>100?100:a[i]+1,100,1,100,1);
+            j=n-i-(n-a[i]-tmp);  
+            if(j<=0) continue;
+            k=A[n-i];llt p=cal[n-i];
+            ans=(ans+((p*j)%mod+(pre*k*j)%mod+(sum(j)*k)%mod)%mod)%mod;
+            update(1,100,1,a[i]);
+            pre+=j;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5226_autoAC.cpp b/HDOJ/5226_autoAC.cpp
new file mode 100644
index 0000000..d6d5f4e
--- /dev/null
+++ b/HDOJ/5226_autoAC.cpp
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <iostream>
+using namespace std;
+#define maxn 101000
+#define ll long long
+ll A[maxn],inv[maxn];
+ll mod;
+ll Pow(ll a,ll b)
+{
+    ll ret=1;
+    a%=mod;
+    while(b)
+    {
+        if(b&1) ret=ret*a%mod;
+        a=a*a%mod;
+        b>>=1;
+    }
+    return ret%mod;
+}
+void init()
+{
+    A[0]=1,A[1]=1;
+    inv[1]=1;inv[0]=1;
+    for(int i=2;i<maxn;i++)
+    {A[i]=A[i-1]*(ll)i%mod;inv[i]=Pow(A[i],mod-2);}
+}
+ll C(ll a,ll b)
+{
+    if(a<b) return 0;
+    if(a<mod&&b<mod) return (A[a]*inv[b]%mod)*inv[a-b]%mod;
+    return C(a/mod,b/mod)*C(a%mod,b%mod)%mod;
+}
+int main()
+{
+    ll x,xx,y,yy;
+    while(scanf("%lld%lld%lld%lld%lld",&x,&y,&xx,&yy,&mod)!=EOF)
+    {
+        init();
+        ll ans=0;
+        if(y>x&&yy>xx&&y>xx) {printf("0\n");continue;}
+        if(y>x) x=y;
+        if(yy>xx) yy=xx;
+        ll st=x,en=xx,h=y;
+        while(h<=yy&&st<=en)
+        {
+            if(st<h) st=h;
+            ans=(ans+C(en+1,h+1)-C(st,h+1)+mod)%mod;
+            h++;
+        }
+        printf("%lld\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5227_autoAC.cpp b/HDOJ/5227_autoAC.cpp
new file mode 100644
index 0000000..11aa7f3
--- /dev/null
+++ b/HDOJ/5227_autoAC.cpp
@@ -0,0 +1,154 @@
+#include <stdio.h>
+#include <string.h>
+#include <map>
+#include <algorithm>
+using namespace std ;
+typedef long long LL ;
+#define clr( a , x ) memset ( a , x , sizeof a )
+#define cpy( a , x ) memcpy ( a , x , sizeof a )
+const int MAXN = 10005 ;
+const int MAXE = 20005 ;
+struct Edge {
+    int v , n ;
+    Edge () {}
+    Edge ( int v , int n ) : v ( v ) , n ( n ) {}
+} ;
+Edge E[MAXE] ;
+int H[MAXN] , cntE ;
+int phi[MAXN] ;
+LL val[MAXN] ;
+LL S[MAXN] , top ;
+LL ct[MAXN] ;
+int ans ;
+int n ;
+int Q[MAXN] , head , tail ;
+map < LL , int > mp ;
+int vis[MAXN] ;
+int siz[MAXN] ;
+int pre[MAXN] ;
+int gcd ( int a , int b ) {
+    return b ? gcd ( b , a % b ) : a ;
+}
+void init () {
+    ans = 0 ;
+    cntE = 0 ;
+    clr ( H , -1 ) ;
+    clr ( vis , 0 ) ;
+}
+void addedge ( int u , int v ) {
+    E[cntE] = Edge ( v , H[u] ) ;
+    H[u] = cntE ++ ;
+}
+LL get ( int n , int m ) {
+    LL res = 0 ;
+    if ( n > m ) swap ( n , m ) ;
+    for ( int i = 1 , j ; i <= n ; i = j + 1 ) {
+        j = min ( n / ( n / i ) , m / ( m / i ) ) ;
+        res += ( LL ) ( phi[j] - phi[i - 1] ) * ( n / i ) * ( m / i ) ;
+    }
+    return res ;
+}
+void preprocess () {
+    for ( int i = 0 ; i <= 10000 ; ++ i ) {
+        phi[i] = i ;
+    }
+    for ( int i = 2 ; i <= 10000 ; ++ i ) if ( phi[i] == i ) {
+        for ( int j = i ; j <= 10000 ; j += i ) {
+            phi[j] = phi[j] / i * ( i - 1 ) ;
+        }
+    }
+    for ( int i = 2 ; i <= 10000 ; ++ i ) {
+        phi[i] += phi[i - 1] ;
+    }
+    for ( int t = 1 ; t <= 10000 ; ++ t ) {
+        ct[t] = get ( t , t ) + ct[t - 1] ;
+    }
+}
+int get_root ( int s ) {
+    head = tail = 0 ;
+    Q[tail ++] = s ;
+    pre[s] = 0 ;
+    while ( head != tail ) {
+        int u = Q[head ++] ;
+        for ( int i = H[u] ; ~i ; i = E[i].n ) {
+            int v = E[i].v ;
+            if ( vis[v] || v == pre[u] ) continue ;
+            pre[v] = u ;
+            Q[tail ++] = v ;
+        }
+    }
+    int root_siz = tail , root = s ;
+    while ( head ) {
+        int u = Q[-- head] , cnt = 1 ;
+        siz[u] = 1 ;
+        for ( int i = H[u] ; ~i ; i = E[i].n ) {
+            int v = E[i].v ;
+            if ( vis[v] || v == pre[u] ) continue ;
+            siz[u] += siz[v] ;
+            if ( siz[v] > cnt ) cnt = siz[v] ;
+        }
+        cnt = max ( cnt , tail - siz[u] ) ;
+        if ( cnt < root_ ) {
+            root_siz = cnt ;
+            root = u ;
+        }
+    }
+    return root ;
+}
+void get_val ( int u , int f , LL value ) {
+    S[top ++] = value ;
+    for ( int i = H[u] ; ~i ; i = E[i].n ) {
+        int v = E[i].v ;
+        if ( vis[v] || v == f ) continue ;
+        get_val ( v , u , value ^ val[v] ) ;
+    }
+}
+void dfs ( int u ) {
+    int root = get_root ( u ) ;
+    vis[root] = 1 ;
+    mp.clear () ;
+    if ( !val[root] ) ++ ans ;
+    for ( int i = H[root] ; ~i ; i = E[i].n ) {
+        int v = E[i].v ;
+        if ( vis[v] ) continue ;
+        top = 0 ;
+        get_val ( v , root , val[v] ) ;
+        for ( int j = 0 ; j < top ; ++ j ) {
+            map < LL , int > :: iterator it = mp.find ( S[j] ^ val[root] ) ;
+            if ( it != mp.end () ) ans += it->second * 2 ;
+            if ( !( S[j] ^ val[root] ) ) ans += 2 ;
+        }
+        for ( int j = 0 ; j < top ; ++ j ) {
+            mp[S[j]] ++ ;
+        }
+    }
+    for ( int i = H[root] ; ~i ; i = E[i].n ) {
+        int v = E[i].v ;
+        if ( vis[v] ) continue ;
+        dfs ( v ) ;
+    }
+}
+void solve () {
+    int t , a , b , c ;
+    init () ;
+    for ( int i = 1 ; i < n ; ++ i ) {
+        scanf ( "%d%d" , &a , &b ) ;
+        addedge ( a , b ) ;
+        addedge ( b , a ) ;
+    }
+    for ( int i = 1 ; i <= n ; ++ i ) {
+        scanf ( "%d%d%d%d" , &t , &a , &b , &c ) ;
+        val[i] = ct[t - 1] + c - 1 ;
+        val[i] += get ( a - 1 , t ) ;
+        val[i] += get ( a , b - 1 ) - get ( a - 1 , b - 1 ) ;
+    }
+    dfs ( 1 ) ;
+    ans = n * n - ans ;
+    int x = gcd ( n * n , ans ) ;
+    printf ( "%d/%d\n" , ans / x , n * n / x  ) ;
+}
+int main () {
+    preprocess () ;
+    while ( ~scanf ( "%d" , &n ) ) solve () ;
+    return 0 ;
+}
diff --git a/HDOJ/5228_autoAC.cpp b/HDOJ/5228_autoAC.cpp
new file mode 100644
index 0000000..93f266f
--- /dev/null
+++ b/HDOJ/5228_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+int has[13*4];
+char s[5];
+int main()
+{
+     int t;
+     cin>>t;
+     while(t--)
+     {
+         memset(has,0,sizeof(has));
+         for(int i=0;i<5;i++)
+         {
+             scanf("%s",s);
+             int cur;
+             if(strlen(s)==3)
+             {
+                 cur=(s[1]-'0')*10+s[2]-'0';
+             }
+             else
+             {
+                 cur=s[1]-'0';
+             }
+             cur--;
+             has[cur*4+s[0]-'A']++;
+         }
+         int ans=5;
+         for(int i=0;i<10;i++)
+         {
+             for(int j=0;j<4;j++)
+             {
+                 int cnt=5;
+                 for(int k=0;k<5;k++)
+                 {
+                     int num=(i+k)*4+j;
+                     if(has[num%(52)]) cnt--;
+                 }
+                 ans=min(ans,cnt);
+             }
+         }
+         printf("%d\n",ans);
+     }
+}
diff --git a/HDOJ/5229_autoAC.cpp b/HDOJ/5229_autoAC.cpp
new file mode 100644
index 0000000..4356c4d
--- /dev/null
+++ b/HDOJ/5229_autoAC.cpp
@@ -0,0 +1,47 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<map>
+#include<string>
+using namespace std;
+typedef long long ll;
+ll gcd(ll a,ll b){
+    for(;a>0&&b>0;a>b?a%=b:b%=a);
+    return a+b;
+}
+int main(){
+    int T;
+    while(scanf("%d",&T)!=EOF){
+        while(T--){
+            int n;
+            scanf("%d",&n);
+            map<string,int>m;
+            ll ji=0,ou=0;
+            m.clear();
+            int i;
+            for(i=1;i<=n;i++){
+                string a;
+                cin>>a;
+                m[a]++;
+                if(a.length()%2){
+                    ji++;
+                }
+                else ou++;
+            }
+            ll cnt=0;
+            cnt=ji*ou;
+            for(map<string,int>::iterator it=m.begin();it!=m.end();it++){
+                if(it->second>1){
+                    cnt+=((it->second)*((it->second)-1)/2);
+                }
+            }
+            ll sum=n*(n-1)/2;
+            if(cnt==0)printf("0/1\n");
+            else{
+                ll g=gcd(cnt,sum);
+                printf("%lld/%lld\n",cnt/g,sum/g);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5230_autoAC.cpp b/HDOJ/5230_autoAC.cpp
new file mode 100644
index 0000000..a7c4cf6
--- /dev/null
+++ b/HDOJ/5230_autoAC.cpp
@@ -0,0 +1,44 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#define MOD 998244353
+using namespace std;
+int Now[101005][2],Next[101005][2],s[101005];
+void add(int &x,int y)
+{
+  if (y>MOD) y-=MOD;
+  x+=y;
+  if (x>MOD) x-=MOD;
+} 
+int main()
+{
+  int i,j,T,c,n,l,r;
+  memset(s,0,sizeof(s));
+  Next[1][1]=1;
+  for (i=1;i<=450;i++)
+  {
+    for (j=1;j<=100000;j++) 
+    {
+      Now[j][0]=Next[j][0]; Next[j][0]=0;
+      Now[j][1]=Next[j][1]; Next[j][1]=0;
+    }
+    for (j=i;j<=100000;j++)
+    {
+      add(Now[j+i][0],Now[j][0]+Now[j][1]);
+      add(Next[j+1][1],Now[j][0]);
+    }
+    for (j=1;j<=100000;j++) add(s[j],Now[j][0]+Now[j][1]);
+  }
+  s[0]=1;
+  for (i=1;i<=100000;i++) add(s[i],s[i-1]);
+  scanf("%d",&T);
+  while (T--)
+  {
+    scanf("%d%d%d%d",&n,&c,&l,&r);
+    l-=c; r-=c; c=s[r];
+    if (l!=0) c=s[r]-s[l-1];
+    if (c<0) c+=MOD;
+    printf("%d\n",c);
+  }
+  return 0;
+}
diff --git a/HDOJ/5232_autoAC.cpp b/HDOJ/5232_autoAC.cpp
new file mode 100644
index 0000000..1a7b6b4
--- /dev/null
+++ b/HDOJ/5232_autoAC.cpp
@@ -0,0 +1,63 @@
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <algorithm>
+#include <set>
+#include <vector>
+#include <sstream>
+#include <queue>
+#include <typeinfo>
+#include <fstream>
+#include <map>
+#include <stack>
+typedef long long ll;
+using namespace std;
+#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
+#define maxn 200001
+#define mod 10007
+#define eps 1e-9
+int Num;
+char CH[20];
+const int inf=0x3f3f3f3f;
+inline ll read()
+{
+    ll x=0,f=1;char ch=getchar();
+    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
+    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
+    return x*f;
+}
+inline void P(int x)
+{
+    Num=0;if(!x){putchar('0');puts("");return;}
+    while(x>0)CH[++Num]=x%10,x/=10;
+    while(Num)putchar(CH[Num--]+48);
+    puts("");
+}
+int g[300][300];
+int main()
+{
+    int n;
+    while(scanf("%d",&n)!=EOF)
+    {
+        memset(g,0,sizeof(g));
+        for(int i=0;i<n;i++)
+            for(int j=0;j<n;j++)
+                g[i][j]=read();
+        int ans=0;
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<n;j++)
+            {
+                if(g[i][j])
+                {
+                    ans++;
+                    g[i][j]=0;
+                    g[j][i]=0;
+                }
+            }
+        }
+        cout<<(ans+n)*2<<endl;
+    }
+}
diff --git a/HDOJ/5234_autoAC.cpp b/HDOJ/5234_autoAC.cpp
new file mode 100644
index 0000000..743a2a3
--- /dev/null
+++ b/HDOJ/5234_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <string>
+#include <sstream>
+#include <algorithm>
+#define Max 2147483647
+#define INF 0x7fffffff
+#define N 110
+#define ll long long
+#define mem(a,b) memset(a,b,sizeof(a))
+#define repu(i, a, b) for(int i = (a); i < (b); i++)
+const double PI=-acos(-1.0);
+using namespace std;
+int dp[N][N][N];
+int w[N][N];
+int main()
+{
+    int n,m,k;
+    while(~scanf("%d%d%d",&n,&m,&k))
+    {
+        repu(i,0,1+n)
+        repu(j,0,m+1)
+        repu(p,0,k+1)
+        dp[i][j][p] = 0;
+        repu(i,1,1+n)
+        repu(j,1,1+m)
+        scanf("%d",&w[i][j]);
+        repu(i,1,n+1)
+        {
+            repu(j,1,m+1)
+            {
+                for(int p = w[i][j]; p<=k; p++)
+                {
+                    int t = max(dp[i-1][j][p],dp[i][j-1][p]);
+                    int s = max(dp[i-1][j][p-w[i][j]]+w[i][j],dp[i][j-1][p-w[i][j]]+w[i][j]);
+                    dp[i][j][p] = max(t,s);
+                }
+            }
+        }
+        int maxn = 0;
+        repu(p,0,k+1)
+        maxn = max(dp[n][m][p],maxn);
+        printf("%d\n",maxn);
+    }
+    return 0;
+}
diff --git a/HDOJ/5236_autoAC.cpp b/HDOJ/5236_autoAC.cpp
new file mode 100644
index 0000000..3207330
--- /dev/null
+++ b/HDOJ/5236_autoAC.cpp
@@ -0,0 +1,67 @@
+#include <cstdio>
+#include <limits>
+#include <algorithm>
+using namespace std;
+const int MAXN = 100005;
+const int MAXS = 30;  
+int N, X, S;
+double P, F[MAXS];
+void CalcF(){
+    int i;
+    double a = 1, b = 1. / (P - 1.);
+    S = numeric_limits<int>::max();
+    F[0] = 0.;
+    F[1] = - b / a;
+    for(i = 2; i <= N && i <= S; i ++){
+        a = (a - P) / (1 - P);
+        b = (b - 1) / (1 - P);
+        F[i] = - b / a;
+        if(F[i] > F[i >> 1] + F[i - (i >> 1)] + X){
+            F[i] = F[i >> 1] + F[i - (i >> 1)] + X;
+            S = i;
+        }
+    }
+}
+double BFSolve(){
+    static double dp[MAXN];
+    int i, j;
+    dp[0] = 0;
+    for(i = 1; i <= N; i ++){
+        if(i <= S){
+            dp[i] = F[i] + X;
+        }else{
+            dp[i] = numeric_limits<double>::max();
+        }
+        for(j = 1; j <= S && j < i; j ++){
+            dp[i] = min(dp[i], dp[i - j] + dp[j]);
+        }
+    }
+    return dp[N];
+}
+double Solve(){
+    int i, a, b;
+    double ans = numeric_limits<double>::max();
+    if(N < S)
+        return F[N] + X;
+    for(i = 1; i <= S; i ++){
+        a = N / i;
+        b = N % i;
+        if(a >= b && i < S){
+            ans = min(ans, (a - b) * F[i] + b * F[i + 1] + a * X);
+        }
+        if(a + b + 1 >= i){
+            ans = min(ans, (a + 1 - i + b) * F[i] + (i - b) * F[i - 1] + (a + 1) * X);
+        }
+    }
+    return ans;
+}
+int main(){
+    int T, i;
+    scanf("%d", &T);
+    for(i = 1; i <= T; i ++){
+        scanf("%d%lf%d", &N, &P, &X);
+        CalcF();
+        printf("Case #%d: %.6lf\n", i, Solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/5237_autoAC.cpp b/HDOJ/5237_autoAC.cpp
new file mode 100644
index 0000000..065f98d
--- /dev/null
+++ b/HDOJ/5237_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<iostream>
+#include<cstdio>
+#include<string.h>
+using namespace std;
+char S[1000],Q[1000];
+char Std[65]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+void Make(int x)
+{
+    Q[strlen(Q)]=Std[x];
+}
+void f(int n) 
+{ 
+    if(n) f(n/2); 
+    else return; 
+    printf("%d",n%2); 
+} 
+int main()
+{
+    int t,tm;
+    scanf("%d",&tm);t=tm;
+    while(t--)
+    {
+        int k,i,n;
+        scanf("%d %s",&n,S);
+        while(n--)
+        {
+            memset(Q,0,sizeof(Q));
+            int l=strlen(S);
+            for(i=0;i<l;i++)
+            {
+                if(i%3==0)
+                    Make(S[i]/4);
+                if(i%3==1)
+                    Make((S[i-1]%4)*16+S[i]/16);
+                if(i%3==2)
+                {
+                    Make((S[i-1]%16)*4+S[i]/64);
+                    Make(S[i]%64);
+                }
+            }
+            if(l%3)
+            {
+                int key=(S[l-1]%4)*16;
+                if(l%3==2) key=(S[l-1]%16)*4;
+                Make(key);
+                strcat(Q,"=");
+                if(l%3==1) strcat(Q,"=");    
+            }
+            Q[strlen(Q)]='\0';
+            strcpy(S,Q);
+        }
+        printf("Case #%d: %s\n",tm-t,S);
+    }
+    return 0;
+}
diff --git a/HDOJ/5238_autoAC.cpp b/HDOJ/5238_autoAC.cpp
new file mode 100644
index 0000000..59c889f
--- /dev/null
+++ b/HDOJ/5238_autoAC.cpp
@@ -0,0 +1,111 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std ;
+typedef long long LL ;
+#define clr( a , x ) memset ( a , x , sizeof a )
+#define ls ( o << 1 )
+#define rs ( o << 1 | 1 )
+#define lson ls , l , m
+#define rson rs , m + 1 , r
+#define mid ( ( l + r ) >> 1 )
+#define root 1 , 1 , n
+const int MAXN = 50005 ;
+const int MOD = 29393 ;
+int mod[4] = { 7 , 13 , 17 , 19 } ;
+int p[4][20][MOD] ;
+int f[MAXN << 2][4][20] ;
+int n , m ;
+void preprocess () {
+    for ( int i = 0 ; i < 4 ; ++ i ) {
+        for ( int j = 0 , m = mod[i] ; j < m ; ++ j ) {
+            p[i][j][0] = 1 ;
+            for ( int k = 1 ; k < MOD ; ++ k ) {
+                p[i][j][k] = p[i][j][k - 1] * j % m ;
+            }
+        }
+    }
+}
+void upd ( int o , char op , int x ) {
+    for ( int i = 0 ; i < 4 ; ++ i ) {
+        for ( int j = 0 , m = mod[i] ; j < m ; ++ j ) {
+            if ( op == '+' ) f[o][i][j] = ( j + x ) % m ;
+            else if ( op == '*' ) f[o][i][j] = ( j * x ) % m ;
+            else f[o][i][j] = p[i][j][x] ;
+        }
+    }
+}
+void push_up ( int o ) {
+    for ( int i = 0 ; i < 4 ; ++ i ) {
+        for ( int j = 0 , m = mod[i] ; j < m ; ++ j ) {
+            f[o][i][j] = f[rs][i][f[ls][i][j]] ;
+        }
+    }
+}
+void build ( int o , int l , int r ) {
+    if ( l == r ) {
+        char c ;
+        int x ;
+        scanf ( " %c%d" , &c , &x ) ;
+        upd ( o , c , x ) ;
+        return ;
+    }
+    int m = mid ;
+    build ( lson ) ;
+    build ( rson ) ;
+    push_up ( o ) ;
+}
+void update ( int x , char c , int v , int o , int l , int r ) {
+    if ( l == r ) {
+        upd ( o , c , v ) ;
+        return ;
+    }
+    int m = mid ;
+    if ( x <= m ) update ( x , c , v , lson ) ;
+    else update ( x , c , v , rson ) ;
+    push_up ( o ) ;
+}
+int exgcd ( int a , int b , int &x , int &y ) {
+    if ( !b ) {
+        x = 1 ;
+        y = 0 ;
+        return a ;
+    }
+    int ans = exgcd ( b , a % b , y , x ) ;
+    y -= a / b * x ;
+    return ans ;
+}
+int crt ( int v ) {
+    int ans = 0 ;
+    for ( int i = 0 ; i < 4 ; ++ i ) {
+        int t = MOD / mod[i] , x , y ;
+        exgcd ( t , mod[i] , x , y ) ;
+        ans = ( ans + f[1][i][v % mod[i]] * t * ( x % mod[i] ) ) % MOD ;
+    }
+    return ( ans + MOD ) % MOD ;
+}
+void solve () {
+    int op , x , v ;
+    char c ;
+    scanf ( "%d%d" , &n , &m ) ;
+    build ( root ) ;
+    while ( m -- ) {
+        scanf ( "%d%d" , &op , &x ) ;
+        if ( op == 1 ) {
+            printf ( "%d\n" , crt ( x ) ) ;
+        } else {
+            scanf ( " %c%d" , &c , &v ) ;
+            update ( x , c , v , root ) ;
+        }
+    }
+}
+int main () {
+    int T ;
+    preprocess () ;
+    scanf ( "%d" , &T ) ;
+    for ( int i = 1 ; i <= T ; ++ i ) {
+        printf ( "Case #%d:\n" , i ) ;
+        solve () ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5239_autoAC.cpp b/HDOJ/5239_autoAC.cpp
new file mode 100644
index 0000000..1c0746c
--- /dev/null
+++ b/HDOJ/5239_autoAC.cpp
@@ -0,0 +1,125 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+typedef unsigned long long ull;
+struct uint64{
+    static const ull MODN = 9223372034707292160;
+    ull n;
+    uint64(ull n = 0):n(n){}
+    static uint64 ass(ull n){
+        if(n >= MODN)
+            return uint64(n - MODN);
+        else
+            return uint64(n);
+    }
+    inline uint64 operator-() const{
+        return uint64(MODN - n);
+    };
+    friend inline uint64 operator*(const uint64& a, const uint64& b){
+        uint64 tmp;
+        ull a1 = (a.n >> 32), a0 = (a.n & 0xffffffff);
+        ull b1 = (b.n >> 32), b0 = (b.n & 0xffffffff);
+        tmp = ass(a1 * b1);
+        tmp = tmp + ass(a1 * b0);
+        tmp = tmp + ass(a0 * b1);
+        for(int i = 0; i < 32; i ++)
+            tmp = tmp + tmp;
+        tmp = tmp + ass(a0 * b0);
+        return tmp;
+    }
+    friend inline uint64 operator+(const uint64& a, const uint64& b){
+        ull n = a.n + b.n;
+        return uint64((n < a.n || n >= MODN) ? (n - MODN) : n);
+    }
+    friend inline uint64 operator-(const uint64& a, const uint64& b){
+        return (a.n < b.n) ? (a.n + MODN - b.n) : (a.n - b.n);
+    }
+    inline uint64 sqr(){
+        return (*this) * (*this);
+    }
+};
+const int MAXN = 131072;
+ull arr[MAXN];
+int N, M;
+class Segtree{
+public:
+    static const int MAXK = 30;
+    struct NODE{
+        int flg;  
+        uint64 d[MAXK];
+    }node[MAXN<<1];
+    inline void popup(int id){
+        int j;
+        for(j = 0; j < MAXK; j ++)
+            node[id].d[j] = node[id<<1].d[j] + node[id<<1|1].d[j];
+    }
+    inline void shift(int id, int k){
+        node[id].flg += k;
+        for(int j = 0; j <= MAXK - 2; j ++){
+            node[id].d[j] = node[id].d[min(j + k, MAXK - 1)];
+        }
+    }
+    inline void pushdown(int id){
+        int flg = node[id].flg;
+        if(flg > 0){
+            shift(id<<1, flg);
+            shift(id<<1|1, flg);
+            node[id].flg = 0;
+        }
+    }
+    void build(int id, int l, int r){
+        int mid = (l + r) >> 1;
+        if(l == r){
+            node[id].d[0] = uint64::ass(arr[l]);
+            node[id].flg = 0;
+            for(int j = 1; j < MAXK; j ++)
+                node[id].d[j] = node[id].d[j - 1].sqr();
+        }else{
+            node[id].flg = 0;
+            build(id<<1, l, mid);
+            build(id<<1|1, mid+1, r);
+            popup(id);
+        }
+    }
+    uint64 query(int id, int l, int r, int L, int R){
+        uint64 ret;
+        if(l == L && r == R){
+            ret = node[id].d[0];
+            shift(id, 1); 
+            return ret;
+        }
+        int mid = (L + R) >> 1;
+        pushdown(id);
+        if(l > mid){
+            ret = query(id<<1|1, l, r, mid + 1, R);
+        }else if(r <= mid){
+            ret = query(id<<1, l, r, L, mid);
+        }else{
+            ret = query(id<<1, l, mid, L, mid) + query(id<<1|1, mid + 1, r, mid + 1, R);
+        }
+        popup(id);
+        return ret;
+    }
+}tree;
+int main(){
+    int i, T, l, r;
+    uint64 ans;
+    scanf("%d", &T);
+    for(i = 1; i <= T; i ++){
+        printf("Case #%d:\n", i);
+        scanf("%d%d", &N, &M);
+        for(l = 1; l <= N; l ++){
+            scanf("%I64u", &arr[l]);
+        }
+        tree.build(1, 1, N);
+        ans = 0;
+        while(M --){
+            scanf("%d%d", &l, &r);
+            ans = ans + tree.query(1, l, r, 1, N);
+            printf("%I64u\n", ans.n);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5240_autoAC.cpp b/HDOJ/5240_autoAC.cpp
new file mode 100644
index 0000000..1a51771
--- /dev/null
+++ b/HDOJ/5240_autoAC.cpp
@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <stack>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int INF = 0x3f3f3f3f;
+const double eps = 1e-4;
+struct node
+{
+    long long r,s,l;
+}exam[111111];
+bool cmp(node a,node b)
+{
+    return a.s<b.s;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    for(int ncase=1;ncase<=T;ncase++)
+    {
+        int n;
+        scanf("%d",&n);
+        for(int i=0;i<n;i++)
+            scanf("%I64d%I64d%I64d",&exam[i].r,&exam[i].s,&exam[i].l);
+        sort(exam,exam+n,cmp);
+        for(int i=n-1;i>0;i--)
+            exam[i].s-=(exam[i-1].s+exam[i-1].l);
+        int flag=1,i=0,j=0;
+        while(i<n)
+        {
+            if(exam[i].s<exam[j].r)
+            {
+                if(i==j)
+                {
+                    flag=0;
+                    break;
+                }
+                exam[j].r-=exam[i].s;
+                i++;
+            }
+            else
+            {
+                exam[i].s-=exam[j].r;
+                j++;
+            }
+        }
+        if(flag)
+            printf("Case #%d: YES\n",ncase);
+        else
+            printf("Case #%d: NO\n",ncase);
+    }
+    return 0;
+}
diff --git a/HDOJ/5241_autoAC.cpp b/HDOJ/5241_autoAC.cpp
new file mode 100644
index 0000000..7d7645a
--- /dev/null
+++ b/HDOJ/5241_autoAC.cpp
@@ -0,0 +1,65 @@
+#include<iostream>
+#include<cstdio>
+#include<string.h>
+using namespace std;
+int a[10000],b[10000],c[10000];
+void SP()
+{
+    memset(c,0,sizeof(c));
+    int i,j;
+    for(i=1;i<=a[0];i++)
+        for(j=1;j<=b[0];j++)
+            c[i+j-1]+=a[i]*b[j];
+    i=1;
+    for(i=1;i<9999;i++)
+    {
+        c[i+1]+=c[i]/10;
+        a[i]=c[i]%10;
+        if(a[i]) a[0]=i;
+    }
+}
+void PP()
+{
+    memset(c,0,sizeof(c));
+    int i,j;
+    for(i=1;i<=b[0];i++)
+        for(j=1;j<=b[0];j++)
+            c[i+j-1]+=b[i]*b[j];
+    i=1;
+    for(i=1;i<9999;i++)
+    {
+        c[i+1]+=c[i]/10;
+        b[i]=c[i]%10;
+        if(b[i]) b[0]=i;
+    }
+}
+int main()
+{
+    int t,tm;
+    scanf("%d",&t);tm=t;
+    while(t--)
+    {
+        int n;
+        scanf("%d",&n);
+        printf("Case #%d: ",tm-t);
+        if(!n) printf("1\n");
+        else
+        {
+            n*=5;
+            memset(a,0,sizeof(a));
+            memset(b,0,sizeof(b));
+            a[0]=1;a[1]=1;
+            b[0]=1;b[1]=2;
+            while(n)
+            {
+                if(n%2)
+                    SP();
+                PP();
+                n/=2;
+            }
+            for(int i=a[0];i;i--) printf("%d",a[i]);
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5242_autoAC.cpp b/HDOJ/5242_autoAC.cpp
new file mode 100644
index 0000000..8be8dd3
--- /dev/null
+++ b/HDOJ/5242_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<vector>
+#include<queue>
+using namespace std;
+#define LL __int64
+const int maxn=1e5+100;
+vector<LL>V[maxn];
+priority_queue<LL>Q;
+LL a[maxn];
+LL dp[maxn];
+LL dfs(int cur){
+    int i,v;
+    LL tmp;
+    dp[cur]=a[cur];
+    for(i=0;i<V[cur].size();i++){
+        v=V[cur][i];
+        tmp=dfs(v);
+        if(dp[cur]>tmp+a[cur]){ 
+            Q.push(tmp);
+        }else{    
+            Q.push(dp[cur]-a[cur]);
+            dp[cur]=tmp+a[cur];
+        }
+    }
+    return dp[cur];
+}
+int main(){
+    int t ,n,m,i,j,k,u,v,cnt=0;
+    LL ans;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&k);
+        for(i=1;i<=n;i++)
+            scanf("%lld",&a[i]);
+        for(i=1;i<n;i++){
+            scanf("%d%d",&u,&v);
+            V[u].push_back(v);
+        }
+        dfs(1);
+        ans=dp[1];
+        for(i=1;i<k;i++){
+            ans+=Q.top();
+            Q.pop();
+        }
+        printf("Case #%d: %lld\n",++cnt,ans);
+        while(!Q.empty())
+            Q.pop();
+        for(i=0;i<=n;i++){
+            V[i].clear();
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5243_autoAC.cpp b/HDOJ/5243_autoAC.cpp
new file mode 100644
index 0000000..dea3c82
--- /dev/null
+++ b/HDOJ/5243_autoAC.cpp
@@ -0,0 +1,198 @@
+#include <cstdio>
+#include <iostream>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define V P
+const double eps = 1e-6;
+inline int dcmp (double x) {
+    return x < -eps ? -1 : x > eps;
+}
+struct P {
+    double x, y;
+    void scan() {
+        scanf("%lf%lf", &x, &y);
+    }
+    P(double _x = 0, double _y = 0) : x(_x), y(_y) { }
+    V operator + (V a) const {
+        return V(x + a.x, y + a.y);
+    }
+    V operator - (V a) const {
+        return V(x - a.x, y - a.y);
+    }
+    V operator * (double p) const {
+        return V(p * x, p * y);
+    }
+    V operator / (double p) const {
+        return V(x / p, y / p);
+    }
+    bool operator < (P a) const {
+        return x < a.x || (dcmp(x - a.x) == 0 && y < a.y);
+    }
+    bool operator == (P a) const {
+        return dcmp(x - a.x) == 0 && dcmp(y - a.y) == 0;
+    }
+};
+inline double dot(V a, V b) {
+    return a.x * b.x + a.y * b.y;
+}
+inline double len(V a) {
+    return sqrt(dot(a, a));
+}
+inline double dis(P a, P b) {
+    return len(b - a);
+}
+inline double ang(V a, V b) {
+    return acos(dot(a, b) / len(a) / len(b));
+}
+inline double cross(V a, V b) {
+    return a.x * b.y - a.y * b.x;
+}
+inline double area(P a, P b, P c) {
+    return cross(b - a, c - a);
+}
+V rot(V a, double p) {
+    return V(a.x * cos(p) - a.y * sin(p), a.x * sin(p) + a.y * cos(p));
+}
+V normal(V a) {
+    double L = len(a);
+    return V(-a.y / L, a.x / L);
+}
+P inter(P p, V v, P q, V w) {
+    V u = p - q;
+    double t = cross(w, u) / cross(v, w);
+    return p + v * t;
+}
+double dis(P p, P a, P b) {
+    V v1 = b - a, v2 = p - a;
+    return fabs(cross(v1, v2)) / len(v1);
+}
+double dis2(P p, P a, P b) {
+    if (a == b) return len(p - a);
+    V v1 = b - a, v2 = p - a, v3 = p - b;
+    if (dcmp(dot(v1, v2)) < 0) return len(v2);
+    else if (dcmp(dot(v1, v3)) > 0) return len(v3);
+    else return fabs(cross(v1, v2)) / len(v1);
+}
+P proj(P p, P a, P b) {
+    V v = b - a;
+    return a + v * (dot(v, p - a) / dot(v, v));
+}
+bool isInter(P a1, P a2, P b1, P b2) {
+    double c1 = cross(a2 - a1, b1 - a1), c2 = cross(a2 - a1, b2 - a1),
+           c3 = cross(b2 - b1, a1 - b1), c4 = cross(b2 - b1, a2 - b1);
+    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
+}
+bool onSeg(P p, P a1, P a2) {
+    return dcmp(cross(a1 - p, a2 - p)) == 0 && dcmp(dot(a1 - p, a2 - p)) < 0;
+}
+double area(P* p, int n) {
+    double s = 0;
+    p[n] = p[0];
+    for (int i = 1; i < n; i ++)
+        s += cross(p[i] - p[0], p[i + 1] - p[0]);
+    return s / 2;
+}
+int graham(P* p, int n, P* ch) {
+    sort(p, p + n);
+    int m = 0;
+    for (int i = 0; i < n; i ++) {
+        while (m > 1 && cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m --;
+        ch[m ++] = p[i];
+    }
+    int k = m;
+    for (int i = n - 2; i >= 0; i --) {
+        while (m > k && cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0) m --;
+        ch[m ++] = p[i];
+    }
+    if (n > 1) m --;
+    return m;
+}
+struct L {
+    P p;
+    V v;
+    double ang;
+    L() {}
+    L(P _p, V _v) : p(_p), v(_v) { ang = atan2(v.y, v.y); }
+    bool operator < (const L& L) const {
+        return ang < L.ang;
+    }
+};
+inline int get(P a) {
+    if( a.x > 0 && a.y >= 0) return 1;
+    if( a.x <= 0 && a.y > 0) return 2;
+    if( a.x < 0 && a.y <= 0) return 3;
+    if( a.x >= 0 && a.y < 0) return 4;
+    return 0;
+}
+inline bool cmp2 (L a, L b) {
+    return get(a.v) < get(b.v) || (get(a.v) == get(b.v) && dcmp( cross(a.v, b.v) ) >0);
+}
+bool onLeft(L l, P p) {
+    return cross(l.v, p - l.p) > 0;
+}
+P inter(L a, L b) {
+    return inter(a.p, a.v, b.p, b.v);
+}
+int half(L* l, int n, P* po) {
+    sort(l, l + n, cmp2);
+    int h, t;
+    P *p = new P[n];
+    L *q = new L[n];
+    q[h = t = 0] = l[0];
+    for (int i = 1; i < n; i ++) {
+        while (h < t && !onLeft(l[i], p[t - 1])) t --;
+        while (h < t && !onLeft(l[i], p[h])) h ++;
+        q[++ t] = l[i];
+        if (dcmp(cross(q[t].v, q[t - 1].v)) == 0) {
+            t --;
+            if (onLeft(q[t], l[i].p)) q[t] = l[i];
+        }
+        if (h < t) p[t - 1] = inter(q[t - 1], q[t]);
+    }
+    while (h < t && !onLeft(q[h], p[t - 1])) t --;
+    if (t - h <= 1) return 0;
+    p[t] = inter(q[t], q[h]);
+    int m = 0;
+    for (int i = h; i <= t; i ++) po[m ++] = p[i];
+    return m;
+}
+inline bool cmp (V a, V b) {
+    return get(a) < get(b) || (get(a) == get(b) && dcmp( cross(a, b) ) >0);
+}
+const int N = 101000;
+int n;
+P a[N], b[N], res[N];
+L l[N];
+int main() {
+    int T;
+    scanf("%d", &T);
+    for (int cas = 1; cas <= T; cas ++) {
+        scanf("%d", &n);
+        for (int i = 0; i < n; i ++)
+            a[i].scan();
+        int bound = n / 3 - 1, l_c = 0;
+        for (int i = 0; i < n; i ++) {
+            int cnt = 0;
+            for (int j = 0; j < n; j ++)
+                if (j != i)
+                    b[cnt ++] = a[j] - a[i];
+            sort(b, b + cnt, cmp);
+            int t = 0, sum = 0;
+            for (int j = 0; j < cnt; j ++) {
+                while ((dcmp(cross(b[j], b[(t + 1) % cnt])) == 1) ||
+                        (dcmp(cross(b[j], b[(t + 1) % cnt])) == 0 &&
+                         dcmp(dot(b[j], b[(t + 1) % cnt])) == -1)) t = (t + 1) % cnt, sum ++;
+                if (cnt - (sum + 1) == bound) l[l_c ++] = L(a[i], b[j]);
+                if (t == j) t ++;
+                else {
+                    while (dcmp(cross(b[j], b[(j + 1) % cnt])) == 0) j ++, sum --;
+                    sum --;
+                }
+            }
+        }
+        int ans = half(l, l_c, res);
+        printf("Case #%d: %.6lf\n", cas, area(res, ans));
+    }
+    return 0;
+}
diff --git a/HDOJ/5244_autoAC.cpp b/HDOJ/5244_autoAC.cpp
new file mode 100644
index 0000000..77a0b9f
--- /dev/null
+++ b/HDOJ/5244_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <cstdio>
+using namespace std;
+const int MAXK = 20;
+const int MAXN = (1 << MAXK);
+typedef long long ll;
+typedef unsigned long ul;
+struct BI{
+    ul d[4];
+    BI(const ll& a = 0){
+        d[0] = a & 0xffffffff;
+        d[1] = a >> 32;
+        d[2] = a >> 64;
+        d[3] = d[2];
+    }
+    BI operator+(const BI& B)const{
+        BI ret(*this);
+        int flg = 0;
+        ll tmp;
+        for(int i = 0; i < 4; i ++){
+            tmp = ll(ret.d[i]) + ll(B.d[i]) + ll(flg);
+            ret.d[i] = tmp & 0xffffffff;
+            flg = (tmp >> 32) & 1;
+        }
+        return ret;
+    }
+    BI operator-()const{
+        BI ret(*this);
+        int flg = 1;
+        ll tmp;
+        for(int i = 0; i < 4; i ++){
+            tmp = ll(~ret.d[i]) + ll(flg);
+            ret.d[i] = tmp & 0xffffffff;
+            flg = (tmp >> 32) & 1;
+        }
+        return ret;
+    }
+    inline BI operator-(const BI& rhs)const{
+        return (*this) + (- rhs);
+    }
+    void operator>>=(int k){
+        int i;
+        for(i = 0; i < 3; i ++)
+            d[i] = (d[i] >> k) | (d[i+1] << (32 - k));
+        d[3] = d[3] >> k;
+    };
+    ll val(){
+        return (ll(d[1]) << 32) + ll(d[0]);
+    }
+};
+ll B[MAXN];
+BI A[MAXN];
+int N, K;
+void CalcA(){
+    int i, j, b;
+    for(j = 0; j < N; j ++)
+        A[j] = B[j];
+    for(i = 1; i <= K; i ++){
+        for(b = 0; b < N; b += (1 << i)){
+            int step = (1 << (i - 1));
+            for(j = b; j < b + step; j ++){
+                BI t1, t2;
+                t1 = A[j + step] + A[j];
+                t2 = A[j + step] - A[j];
+                A[j] = t1;
+                A[j + step] = t2;
+            }
+        }
+    }
+    if(K > 0){
+        for(j = 0; j < N; j ++){
+            A[j] >>= (K - 1);
+        }
+        A[0] = A[0] - B[N - 1];
+    }
+}
+int main(){
+    int i, j, T;
+    scanf("%d", &T);
+    for(i = 1; i <= T; i ++){
+        scanf("%d", &K);
+        N = 1 << K;
+        for(j = 0; j < N; j ++){
+            scanf("%I64d", &B[j]);
+        }
+        CalcA();
+        printf("Case #%d:", i);
+        for(j = 0; j < N; j ++)
+            printf(" %I64d", A[j].val());
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5245_autoAC.cpp b/HDOJ/5245_autoAC.cpp
new file mode 100644
index 0000000..fcf6b72
--- /dev/null
+++ b/HDOJ/5245_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+using namespace std;
+int main()
+{
+    int t,tm,k;
+    double n,m;
+    scanf("%d",&t);tm=t;
+    while(t--)
+    {
+        scanf("%lf%lf%d",&n,&m,&k);
+        double ans=0;
+        for(double i=1;i<=n;i++)
+            for(double j=1;j<=m;j++)
+            {
+                double p=m*n;
+                p+=(i-1)*(j-1)*(n-i+1)*(m-j+1);
+                p+=(i-1)*(m-j)*(n-i+1)*j;
+                p+=(j-1)*(n-i)*(m-j+1)*i;
+                p+=(n-i)*(m-j)*i*j;
+                p+=(i-1)*m*(n-i+1);
+                p+=(m-j)*n*j;
+                p+=(n-i)*m*i;
+                p+=(j-1)*n*(m-j+1);
+                p=p/n/n/m/m;
+                ans+=1-(pow(1-p,k));
+            }
+            printf("Case #%d: %d\n",tm-t,int(ans+0.5));
+    }
+    return 0;
+}
diff --git a/HDOJ/5246_autoAC.cpp b/HDOJ/5246_autoAC.cpp
new file mode 100644
index 0000000..3d3d1e0
--- /dev/null
+++ b/HDOJ/5246_autoAC.cpp
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+const int N = 10005;
+long long n, m, k;
+long long s[N];
+int main() {
+    int t, cas = 1;
+    scanf("%d", &t);
+    while (t--) {
+        scanf("%lld%lld%lld", &n, &m, &k);
+        for (int i = 0; i < n; i++)
+            scanf("%lld", &s[i]);
+        sort(s, s + n);
+        if (s[0] > m) {
+            printf("Case #%d:\nmadan!\n", cas++);
+            continue;
+        }
+        if (s[n - 1] <= m) {
+            printf("Case #%d:\nwhy am I so diao?\n", cas++);
+            continue;
+        }
+        for (int i = 0; i < n; i++) {
+            if (s[i] > m) {
+                int flag = 1, flag2 = 0;
+                m = s[i - 1];
+                for (int j = i; j < n; j++) {
+                    if (m + k >= s[j])
+                        continue;
+                    else {
+                        m = s[j - 1];
+                        if (k > 0)
+                            k--;
+                        if (m + k < s[j]) {
+                            flag = 0;
+                            break;
+                        }
+                        j--;
+                    }
+                }
+                if (!flag)
+                    printf("Case #%d:\nmadan!\n", cas++);
+                else
+                    printf("Case #%d:\nwhy am I so diao?\n", cas++);
+                break;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5247_autoAC.cpp b/HDOJ/5247_autoAC.cpp
new file mode 100644
index 0000000..e81214c
--- /dev/null
+++ b/HDOJ/5247_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<cstdio>
+#include<set>
+#include<algorithm>
+using namespace std;
+typedef long long LL;
+const int maxn = 10005;
+set<LL>s;
+set<LL>::iterator it1,it2;
+int n,m;
+int num[maxn] = {0};
+LL arr[maxn];
+int main(){
+    scanf("%d%d",&n,&m);
+    for(int i = 0; i < n; i++)
+        scanf("%I64d",&arr[i]);
+    for(int i = 0; i < n; i++){
+        s.clear();
+        s.insert(arr[i]);
+        num[1] ++;
+        for(int j = i + 1; j < n; j++){
+            if(!s.count(arr[j]))
+                s.insert(arr[j]);
+            else
+                break;
+            it1 = s.begin();
+            it2 = s.end();
+            it2 --;
+            LL e1 = *it1,e2 = *it2;
+            if(e2 - e1 == s.size() - 1){
+                num[s.size()] ++;
+            }
+        }
+    }
+    printf("Case #1:\n");
+    while(m--){
+        int k;
+        scanf("%d",&k);
+        printf("%d\n",num[k]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5248_autoAC.cpp b/HDOJ/5248_autoAC.cpp
new file mode 100644
index 0000000..9839965
--- /dev/null
+++ b/HDOJ/5248_autoAC.cpp
@@ -0,0 +1,77 @@
+#include<cstdio>
+#include<iostream>
+#include<algorithm>
+#include<cstring>
+#include<cmath>
+#include<queue>
+#include<map>
+using namespace std;
+#define MOD 1000000007
+const int INF=0x3f3f3f3f;
+const double eps=1e-5;
+typedef long long ll;
+#define cl(a) memset(a,0,sizeof(a))
+#define ts printf("*****\n");
+const int MAXN=100005;
+int n,m,tt;
+int a[MAXN],b[MAXN];
+bool check(int mid)
+{
+    for(int i=1;i<=n;i++)
+    {
+        b[i]=a[i];
+    }
+    for(int i=1;i<=n;i++)
+    {
+        if(i==1)
+        {
+            b[i]-=mid;
+            continue;
+        }
+        if(b[i]<=b[i-1])
+        {
+            if((b[i-1]+1)-b[i]<=mid)
+                b[i]=b[i-1]+1;
+            else
+            {
+                return 0;
+            }
+        }
+        if(b[i]-mid>b[i-1])
+        {
+            b[i]=b[i]-mid;
+        }
+        else
+        {
+            b[i]=b[i-1]+1;
+        }
+    }
+    return 1;
+}
+int main()
+{
+    int i,j,k;
+    int ca=1;
+    scanf("%d",&tt);
+    while(tt--)
+    {
+        printf("Case #%d:\n",ca++);
+        scanf("%d",&n);
+        for(i=1;i<=n;i++)   scanf("%d",a+i);
+        int l=0;
+        int r=1000005;
+        int ans=0;
+        while(l<=r)
+        {
+            int mid=(l+r)>>1;
+            if(check(mid))
+            {
+                ans=mid;
+                r=mid-1;
+            }
+            else
+                l=mid+1;
+        }
+        printf("%d\n",ans);
+    }
+}
diff --git a/HDOJ/5249_autoAC.cpp b/HDOJ/5249_autoAC.cpp
new file mode 100644
index 0000000..2090b14
--- /dev/null
+++ b/HDOJ/5249_autoAC.cpp
@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <string.h>
+#include <set>
+#include <queue>
+#include <algorithm>
+using namespace std;
+set<int> A, B;
+queue<int> q;
+int n, cas = 1;
+int main() {
+    while (scanf("%d", &n) == 1) {
+        printf("Case #%d:\n", cas++);
+        while (!q.empty())
+            q.pop();
+        A.clear();
+        B.clear();
+        char str[10];
+        int m = 0, d;
+        while (n--) {
+            scanf("%s", str);
+            if (str[0] == 'i') {
+                scanf("%d", &d);
+                q.push(d);
+                if (A.size() == 0 || d <= *A.rbegin())
+                    A.insert(d);    
+                else
+                    B.insert(d);
+                m++;
+            }
+            else if (str[0] == 'o') {
+                int temp = q.front();
+                q.pop();
+                if (A.find(temp) == A.end())
+                    B.erase(temp);
+                else
+                    A.erase(temp);
+                m--;
+            }
+            else
+                printf("%d\n", *A.rbegin());
+            while (m > 0 && A.size() < m / 2 + 1) {
+                int temp = *B.begin();
+                A.insert(temp);
+                B.erase(temp);
+            }
+            while (m > 0 && A.size() > m / 2 + 1) {
+                int temp = *A.rbegin();
+                B.insert(temp);
+                A.erase(temp);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5251_autoAC.cpp b/HDOJ/5251_autoAC.cpp
new file mode 100644
index 0000000..87fea91
--- /dev/null
+++ b/HDOJ/5251_autoAC.cpp
@@ -0,0 +1,173 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<math.h>
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+typedef double typev;
+const double eps = 1e-8;
+const int N = 50005;
+int sign(double d){
+    return d < -eps ? -1 : (d > eps);
+}
+struct point{
+    typev x, y;
+    point operator-(point d){
+        point dd;
+        dd.x = this->x - d.x;
+        dd.y = this->y - d.y;
+        return dd;
+    }
+    point operator+(point d){
+        point dd;
+        dd.x = this->x + d.x;
+        dd.y = this->y + d.y;
+        return dd;
+    }
+}ps[N];
+//int n, cn;
+double dist(point d1, point d2){
+    return sqrt(pow(d1.x - d2.x, 2.0) + pow(d1.y - d2.y, 2.0));
+}
+double dist2(point d1, point d2){
+    return pow(d1.x - d2.x, 2.0) + pow(d1.y - d2.y, 2.0);
+}
+bool cmp(point d1, point d2){
+    return d1.y < d2.y || (d1.y == d2.y && d1.x < d2.x);
+}
+typev xmul(point st1, point ed1, point st2, point ed2){
+    return (ed1.x - st1.x) * (ed2.y - st2.y) - (ed1.y - st1.y) * (ed2.x - st2.x);
+}
+typev dmul(point st1, point ed1, point st2, point ed2){
+    return (ed1.x - st1.x) * (ed2.x - st2.x) + (ed1.y - st1.y) * (ed2.y - st2.y);
+}
+struct poly{
+    static const int N = 50005; 
+    point ps[N+5]; 
+    int pn;  
+    poly() { pn = 0; }
+    void push(point tp){
+        ps[pn++] = tp;
+    }
+    int trim(int k){
+        return (k+pn)%pn;
+    }
+    void clear(){ pn = 0; }
+};
+poly graham(point* ps, int n){
+    sort(ps, ps + n, cmp);
+    poly ans;
+    if(n <= 2){
+        for(int i = 0; i < n; i++){
+            ans.push(ps[i]);
+        }
+        return ans;
+    }
+    ans.push(ps[0]);
+    ans.push(ps[1]);
+    point* tps = ans.ps;
+    int top = -1;
+    tps[++top] = ps[0];
+    tps[++top] = ps[1];
+    for(int i = 2; i < n; i++){
+        while(top > 0 && xmul(tps[top - 1], tps[top], tps[top - 1], ps[i]) <= 0) top--;
+        tps[++top] = ps[i];
+    }
+    int tmp = top;  
+    for(int i = n - 2; i >= 0; i--){
+        while(top > tmp && xmul(tps[top - 1], tps[top], tps[top - 1], ps[i]) <= 0) top--;
+        tps[++top] = ps[i];
+    }
+    ans.pn = top;
+    return ans;
+}
+point getRoot(point p, point st, point ed){
+    point ans;
+    double u=((ed.x-st.x)*(ed.x-st.x)+(ed.y-st.y)*(ed.y-st.y));
+    u = ((ed.x-st.x)*(ed.x-p.x)+(ed.y-st.y)*(ed.y-p.y))/u;
+    ans.x = u*st.x+(1-u)*ed.x;
+    ans.y = u*st.y+(1-u)*ed.y;
+    return ans;
+}
+point change(point st, point ed, point next, double l){
+    point dd;
+    dd.x = -(ed - st).y;
+    dd.y = (ed - st).x;
+    double len = sqrt(dd.x * dd.x + dd.y * dd.y);
+    dd.x /= len, dd.y /= len;
+    dd.x *= l, dd.y *= l;
+    dd = dd + next;
+    return dd;
+}
+double getMinAreaRect(point* ps, int n, point* ds){
+    int cn, i;
+    double ans;
+    point* con;
+    poly tpoly = graham(ps, n);
+    con = tpoly.ps;
+    cn = tpoly.pn;
+    if(cn <= 2){
+        ds[0] = con[0]; ds[1] = con[1];
+        ds[2] = con[1]; ds[3] = con[0];
+        ans=0;
+    }else{
+        int  l, r, u;
+        double tmp, len;
+        con[cn] = con[0];
+        ans = 1e40;
+        l = i = 0;
+        while(dmul(con[i], con[i+1], con[i], con[l])
+            >= dmul(con[i], con[i+1], con[i], con[(l-1+cn)%cn])){
+                l = (l-1+cn)%cn;
+        }
+        for(r=u=i = 0; i < cn; i++){
+            while(xmul(con[i], con[i+1], con[i], con[u])
+                <= xmul(con[i], con[i+1], con[i], con[(u+1)%cn])){
+                    u = (u+1)%cn;
+            }
+            while(dmul(con[i], con[i+1], con[i], con[r])
+                <= dmul(con[i], con[i+1], con[i], con[(r+1)%cn])){
+                    r = (r+1)%cn;
+            }
+            while(dmul(con[i], con[i+1], con[i], con[l])
+                >= dmul(con[i], con[i+1], con[i], con[(l+1)%cn])){
+                    l = (l+1)%cn;
+            }
+            tmp = dmul(con[i], con[i+1], con[i], con[r]) - dmul(con[i], con[i+1], con[i], con[l]);
+            tmp *= xmul(con[i], con[i+1], con[i], con[u]);
+            tmp /= dist2(con[i], con[i+1]);
+            len = xmul(con[i], con[i+1], con[i], con[u])/dist(con[i], con[i+1]);
+            if(sign(tmp - ans) < 0){
+                ans = tmp;
+                ds[0] = getRoot(con[l], con[i], con[i+1]);
+                ds[1] = getRoot(con[r], con[i+1], con[i]);
+                ds[2] = change(con[i], con[i+1], ds[1], len);
+                ds[3] = change(con[i], con[i+1], ds[0], len);
+            }
+        }
+    }
+    return ans+eps;
+}
+int main ()
+{
+   int t ,n ,i ,NN ,cas = 1;
+   point ds[10];
+   scanf("%d" ,&t);
+   while(t--)
+   {
+      scanf("%d" ,&NN);
+      int n = 0;
+      for(i = 1 ;i <= NN ;i ++)
+      {
+          for(int j = 1 ;j <= 4 ;j ++)
+          {
+              scanf("%lf %lf" ,&ps[n].x ,&ps[n].y);
+              n++;
+          }
+      }
+      double ans = getMinAreaRect(ps ,n ,ds);
+      printf("Case #%d:\n" ,cas ++);
+      printf("%.0lf\n" ,ans);
+   }
+   return 0;
+}
diff --git a/HDOJ/5253_autoAC.cpp b/HDOJ/5253_autoAC.cpp
new file mode 100644
index 0000000..9f6f070
--- /dev/null
+++ b/HDOJ/5253_autoAC.cpp
@@ -0,0 +1,78 @@
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+using namespace std;
+#define N 1005
+int father[N*N];
+struct EDGE
+{
+    int u,v;
+    int len;
+    bool operator<(const EDGE& a)const  
+    {
+        return len<a.len;
+    }
+};
+EDGE edge[N*N*4];
+int map[N][N],m,n,k;
+int Find(int x)
+{
+    return x==father[x]?x:father[x]=Find(father[x]);
+}
+bool Union(int x,int y)
+{
+    int a,b;
+    a=Find(x);
+    b=Find(y);
+    if(a!=b)
+    {
+        father[a]=b;
+        return true;
+    }
+    return false;
+}
+int process()
+{
+    int i;
+    int sum=0;
+    for(i=0;i<k;i++)
+        if(Union(edge[i].u,edge[i].v))
+            sum+=edge[i].len;
+    return sum;
+}
+int main()      
+{
+    int T,t=0,i,j;
+    EDGE e;
+    scanf("%d",&T);
+    t=0;
+    while(T--)
+    {
+        k=0;
+        scanf("%d%d",&m,&n);
+        for(i=0;i<m;i++)
+            for(j=0;j<n;j++)
+            {
+                father[i*n+j]=i*n+j;
+                scanf("%d",&map[i][j]);
+                if(j>0)
+                {
+                    e.u=i*n+j;
+                    e.v=i*n+j-1;
+                    e.len=abs(map[i][j]-map[i][j-1]);
+                    edge[k++]=e;
+                }
+                if(i>0)
+                {
+                    e.u=i*n+j;
+                    e.v=i*n+j-n;
+                    e.len=abs(map[i][j]-map[i-1][j]);
+                    edge[k++]=e;
+                }
+            }
+        sort(edge,edge+k);
+        printf ("Case #%d:\n", ++t);
+        printf ("%d\n", process());
+    }
+    return 0;      
+}
diff --git a/HDOJ/5254_autoAC.cpp b/HDOJ/5254_autoAC.cpp
new file mode 100644
index 0000000..bcee967
--- /dev/null
+++ b/HDOJ/5254_autoAC.cpp
@@ -0,0 +1,2 @@
+10
+&amp;#8232;01&amp;#8232;
diff --git a/HDOJ/5255_autoAC.cpp b/HDOJ/5255_autoAC.cpp
new file mode 100644
index 0000000..2cd67b5
--- /dev/null
+++ b/HDOJ/5255_autoAC.cpp
@@ -0,0 +1,85 @@
+#include<cstdio>
+#include<algorithm>
+#include<map>
+#include<cstring>
+#include<vector>
+#include<cmath>
+#include<string>
+#define N 2000010
+#define M 1000
+using namespace std;
+double n;
+long long a,b,z,pp,qq,ans[N],P,p,q,o,k,tot,i,j,l;
+long long gcd(long long a,long long b)
+{
+    if (b==0) return a;
+    return gcd(b,a%b);
+}
+int check(long long p,long long q)
+{
+    if (p==0) return 0;
+    if (p>=P) return 0;
+    long long a,b,c=1,pp;
+    a=p%10;
+    pp=p;
+    while (pp)
+    {
+        b=pp%10;
+        pp=pp/10;
+        c=c*10;
+    }
+    c=c/10;
+    p=p-a+b-b*c+a*c;
+    if (p==q) return 1;return 0;
+}
+int main()
+{
+    int test,ii;
+    P=1000000;
+    P=P*10000;
+    scanf("%d",&test);
+    for (ii=1;ii<=test;ii++)
+    {
+    tot=0;
+    scanf("%lf",&n);
+    p=(n+0.0000005)*1000000;
+    q=p/gcd(p,1000000);
+    p=1000000/gcd(p,1000000);
+    o=abs(p-q);
+    b=10;a=0;
+    for (k=0;k<=8;k++)
+    {
+    for (i=0;i<=9;i++)
+    for (j=0;j<=9;j++)
+    {
+        z=b*i+a*10+j;
+        if (z%o==0) 
+        {
+            z=z/o;
+            pp=p*z;qq=q*z;
+            if (check(pp,qq))
+            {
+                tot++;
+                ans[tot]=pp;
+            }
+        }
+    }
+    a=a*10+9;
+    b=b*10;
+    }
+    sort(ans+1,ans+1+tot);
+    j=0;ans[0]=-1;
+    for (i=1;i<=tot;i++)
+    if (ans[i]!=ans[i-1])
+    {
+        j++;ans[j]=ans[i];
+    }
+    tot=j;
+    printf("Case #%d:\n",ii);
+    printf("%I64d\n",tot);
+    for (i=1;i<=tot-1;i++)
+    printf("%I64d ",ans[i]);
+    if (tot)
+    printf("%I64d\n",ans[tot]);
+    }
+}
diff --git a/HDOJ/5256_autoAC.cpp b/HDOJ/5256_autoAC.cpp
new file mode 100644
index 0000000..e380903
--- /dev/null
+++ b/HDOJ/5256_autoAC.cpp
@@ -0,0 +1,29 @@
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+const int N = 100005;
+int n, s[N], f[N];
+int main() {
+    int t, cas = 1;
+    scanf("%d", &t);
+    while (t--) {
+        scanf("%d", &n);
+        int a;
+        for (int i = 0; i < n; i++) {
+            scanf("%d", &a);
+            s[i] = a - i;
+        }
+        int k = 0;
+        f[k++] = s[0];
+        for (int i = 1; i < n; i++) {
+            if (s[i] >= f[k - 1])
+                f[k++] = s[i];
+            else {
+                int pos = upper_bound(f, f + k, s[i]) - f;
+                f[pos] = s[i];
+            }
+        }
+        printf("Case #%d:\n%d\n", cas++, n - k);
+    }
+    return 0;
+}
diff --git a/HDOJ/5258_autoAC.cpp b/HDOJ/5258_autoAC.cpp
new file mode 100644
index 0000000..1f27916
--- /dev/null
+++ b/HDOJ/5258_autoAC.cpp
@@ -0,0 +1,122 @@
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <algorithm>
+#include <set>
+#include <vector>
+#include <sstream>
+#include <queue>
+#include <typeinfo>
+#include <fstream>
+#include <map>
+#include <stack>
+typedef long long ll;
+using namespace std;
+#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
+#define maxn 2000001
+#define mod 10007
+#define eps 1e-9
+int Num;
+char CH[20];
+const int inf=0x3f3f3f3f;
+const ll infll = 0x3f3f3f3f3f3f3f3fLL;
+inline ll read()
+{
+    ll x=0,f=1;char ch=getchar();
+    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
+    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
+    return x*f;
+}
+inline void P(int x)
+{
+    Num=0;if(!x){putchar('0');puts("");return;}
+    while(x>0)CH[++Num]=x%10,x/=10;
+    while(Num)putchar(CH[Num--]+48);
+    puts("");
+}
+int g[50][50];
+map<int,int> H1;
+map<int,int> H2;
+vector<int> x;
+vector<int> y;
+vector<int> kiss[50];
+struct node
+{
+    int x1,x2,y1,y2;
+}a[100];
+int main()
+{
+    int t=read();
+    for(int cas=1;cas<=t;cas++)
+    {
+        memset(g,0,sizeof(g));
+        memset(a,0,sizeof(a));
+        H1.clear();
+        H2.clear();
+        x.clear();
+        y.clear();
+        for(int i=0;i<50;i++)
+            kiss[i].clear();
+        int n=read();
+        for(int i=0;i<n;i++)
+        {
+            a[i].x1=read(),a[i].y1=read(),a[i].x2=read(),a[i].y2=read();
+            if(a[i].x1>a[i].x2)
+                swap(a[i].x1,a[i].x2);
+            if(a[i].y1>a[i].y2)
+                swap(a[i].y1,a[i].y2);
+            x.push_back(a[i].x1);
+            x.push_back(a[i].x2);
+            y.push_back(a[i].y1);
+            y.push_back(a[i].y2);
+        }
+        sort(x.begin(),x.end());
+        sort(y.begin(),y.end());
+        x.erase(unique(x.begin(),x.end()),x.end());
+        y.erase(unique(y.begin(),y.end()),y.end());
+        for(int i=0;i<x.size();i++)
+            H1[x[i]]=i;
+        for(int i=0;i<y.size();i++)
+            H2[y[i]]=i;
+        for(int i=0;i<n;i++)
+        {
+            a[i].x1=H1[a[i].x1];
+            a[i].x2=H1[a[i].x2];
+            a[i].y1=H2[a[i].y1];
+            a[i].y2=H2[a[i].y2];
+        }
+        for(int i=0;i<n;i++)
+            if(a[i].x1==a[i].x2)
+                for(int j=a[i].y1;j<=a[i].y2;j++)
+                    g[a[i].x1][j]=i+1;
+        for(int i=0;i<n;i++)
+            if(a[i].y1==a[i].y2)
+                for(int j=a[i].x1;j<=a[i].x2;j++)
+                    if(g[j][a[i].y1]!=0)
+                        kiss[g[j][a[i].y1]].push_back(i+1);
+        ll ans=0;
+        for(int i=0;i<=n;i++)
+        {
+            for(int j=i+1;j<=n;j++)
+            {
+                int flag=0;
+                for(int k=0;k<kiss[i].size();k++)
+                {
+                    for(int m=0;m<kiss[j].size();m++)
+                    {
+                        if(kiss[i][k]==kiss[j][m])
+                        {
+                            flag++;
+                            break;
+                        }
+                    }
+                }
+                ans+=flag*(flag-1)/2;
+            }
+        }
+        printf("Case #%d:\n",cas);
+        cout<<ans<<endl;
+    }
+}
diff --git a/HDOJ/5259_autoAC.cpp b/HDOJ/5259_autoAC.cpp
new file mode 100644
index 0000000..44cc2d9
--- /dev/null
+++ b/HDOJ/5259_autoAC.cpp
@@ -0,0 +1,76 @@
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <cstdlib>
+using namespace std;
+typedef long long LL;
+const int MOD = 1e9 + 7;
+const int INF = 10000000;
+const int N = 5000 + 10;
+struct State {
+    int a[4], b[4]; 
+    void read() {
+        for(int i = 0; i < 4; i++) {
+            scanf("%d%d", &a[i], &b[i]);
+        }
+    }
+} s[N];
+int seq[30][4], dp[N][30];
+bool check(int b[], int q[]) { 
+    for(int i = 1; i < 4; i++) {
+        if(b[q[i]] < b[q[i - 1]]) return false;
+    }
+    return true;
+}
+int calc(State& A, State& B, int q0[], int q1[]) {
+    int dis = 0;
+    for(int i = 0; i < 4; i++) {
+        dis += abs(A.a[q0[i]] - B.a[q1[i]]);
+        dis += abs(A.b[q0[i]] - B.b[q1[i]]);
+    }
+    return dis;
+}
+int main() {
+    int T, C = 1, n;
+    int A[4] = {0, 1, 2, 3};
+    int nq = 0;
+    do {
+        for(int i = 0; i < 4; i++) seq[nq][i] = A[i];
+        nq ++;
+    } while(next_permutation(A, A + 4));
+    scanf("%d", &T);
+    while(T--) {
+        printf("Case #%d:\n", C++);
+        scanf("%d" , &n);
+        for(int i = 1; i <= n; i++) {
+            s[i].read();
+        }
+        for(int i = 0; i < 4; i++)
+            s[0].b[i] = i + 1, s[0].a[i] = 0;
+        for(int i = 0; i < 24; i++) {
+            if(check(s[1].b, seq[i])) {
+                dp[1][i] = calc(s[0], s[1], seq[0], seq[i]);
+            } else {
+                dp[1][i] = INF;
+            }
+        }
+        for(int i = 2; i <= n; i++) {
+            for(int j = 0; j < 24; j++) {
+                dp[i][j] = INF;
+                if(!check(s[i].b, seq[j])) continue;
+                for(int k = 0; k < 24; k++) {
+                    if(dp[i - 1][k] == INF) continue;
+                    dp[i][j] = min(dp[i][j], dp[i - 1][k] + calc(s[i - 1], s[i], seq[k], seq[j]));
+                }
+            }
+        }
+        int ans = INF;
+        for(int i = 0; i < 24; i++) {
+            ans = min(ans, dp[n][i]);
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5260_autoAC.cpp b/HDOJ/5260_autoAC.cpp
new file mode 100644
index 0000000..06e998d
--- /dev/null
+++ b/HDOJ/5260_autoAC.cpp
@@ -0,0 +1,79 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <cctype>
+#include <climits>
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <algorithm>
+#include <bitset>
+#include <complex>
+#include <string>
+#include <utility>
+using namespace std;
+typedef long long LL;
+typedef pair<int, int> Pii;
+typedef pair<LL, LL> Pll;
+#define foreach(it,s) for(__typeof(s.begin()) it=s.begin();it!=s.end();it++)
+const int maxn = 50 + 5;
+const int maxe = 500 + 5;
+int n, m, s, t;
+struct Tedge {
+    int u, v;
+    string w;
+    Tedge(int u = 0, int v = 0, string w = ""):u(u), v(v), w(w){};
+};
+vector<Tedge> edge[maxn];
+string dis[maxn];
+bool vis[maxn];
+string bf()
+{
+    int clk = 0;
+    memset(vis, false, sizeof(vis));
+    dis[t] = ""; vis[t] = true;
+    while (1) {
+        bool update = false;
+        for (int ii=0;ii<n;ii++) {
+            foreach(i, edge[ii]) 
+                if (vis[i->v]) {
+                    int u = i->u, v = i->v;
+                    string tmp = i->w + dis[v];
+                    if (!vis[u] || tmp < dis[u]) {
+                        dis[u] = tmp;
+                        update = vis[u] = true;
+                        if (clk >= n - 1 && u == s) return "Tough way!";
+                    }
+                }
+        }
+        if (!update || ++clk > n * 6) break;
+    }
+    return vis[s] ? dis[s]: "Tough way!";
+}
+int main()
+{
+    int cas = 0;
+    int T;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d%d%d%d", &n, &m, &s, &t);
+        for (int i=0;i<n;i++) edge[i].clear();
+        printf("Case #%d:\n", ++cas);
+        for (int i=0;i<m;i++) {
+            int u, v;
+            char st[8];
+            scanf("%d%d%s", &u, &v, st);
+            edge[u].push_back(Tedge(u, v, st));
+        }
+        puts(bf().c_str());
+    }
+    return 0;
+}
diff --git a/HDOJ/5261_autoAC.cpp b/HDOJ/5261_autoAC.cpp
new file mode 100644
index 0000000..ffdd698
--- /dev/null
+++ b/HDOJ/5261_autoAC.cpp
@@ -0,0 +1,129 @@
+#include<iostream>
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<vector>
+#include<cmath>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<algorithm>
+using namespace std;
+typedef long long LL;
+const int maxn=200010;
+int N;
+int maxvid,maxvsum;
+LL R;
+int height[maxn];
+struct IntervalTree
+{
+    LL sum[maxn<<2];
+    int id[maxn<<2];
+    void build(int o,int l,int r)
+    {
+        if(l==r)
+        {
+            sum[o]=R*(l-1)+height[l];
+            id[o]=l;
+            return ;
+        }
+        int mid=(l+r)>>1;
+        build(o<<1,l,mid);
+        build(o<<1|1,mid+1,r);
+        pushup(o);
+    }
+    void pushup(int o)
+    {
+        if(sum[o<<1]<sum[o<<1|1])
+        {
+            sum[o]=sum[o<<1|1];
+            id[o]=id[o<<1|1];
+        }
+        else
+        {
+            sum[o]=sum[o<<1];
+            id[o]=id[o<<1];
+        }
+    }
+    void query(int o,int l,int r,int q1,int q2)
+    {
+        if(q1<=l&&r<=q2)
+        {
+            if(sum[o]>maxvsum)
+            {
+                maxvsum=sum[o];
+                maxvid=id[o];
+            }
+            return ;
+        }
+        int mid=(l+r)>>1;
+        if(q1<=mid)query(o<<1,l,mid,q1,q2);
+        if(q2>mid)query(o<<1|1,mid+1,r,q1,q2);
+    }
+}tree;
+int main()
+{
+    int T,cas=1;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%I64d",&N,&R);
+        for(int i=1;i<=N;i++)
+            scanf("%d",&height[i]);
+        for(int i=1;i<=N;i++)
+            height[i+N]=height[i];
+        tree.build(1,1,N*2);
+        LL anssum=0;
+        int x,y,p;
+        pair<int,int> ans=make_pair(N,N),tmp;
+        for(int i=1;i<=N*2;i++)
+        {
+            int r=i+N/2,l=i-N/2;
+            if(r>N*2||l<1)continue;
+            maxvid=maxvsum=0;
+            tree.query(1,1,N*2,i+1,r);
+            x=maxvid;
+            maxvid=maxvsum=0;
+            tree.query(1,1,N*2,l,i-1);
+            y=maxvid;
+            if((i-y)*R+height[i]+height[y]>anssum)
+            {
+                anssum=(i-y)*R+height[i]+height[y];
+                if(y>N)y-=N;
+                p=i;
+                if(p>N)p-=N;
+                tmp=make_pair(min(y,p),max(y,p));
+                ans=tmp;
+            }
+            else if((i-y)*R+height[i]+height[y]==anssum)
+            {
+                if(y>N)y-=N;
+                p=i;
+                if(p>N)p-=N;
+                tmp=make_pair(min(y,p),max(y,p));
+                if(tmp<ans)ans=tmp;
+            }
+            if((x-i)*R+height[x]+height[i]>anssum)
+            {
+                anssum=(x-i)*R+height[x]+height[i];
+                if(x>N)x-=N;
+                p=i;
+                if(p>N)p-=N;
+                tmp=make_pair(min(x,p),max(x,p));
+                ans=tmp;
+            }
+            else if((x-i)*R+height[x]+height[i]==anssum)
+            {
+                if(x>N)x-=N;
+                p=i;
+                if(p>N)p-=N;
+                tmp=make_pair(min(x,p),max(x,p));
+                if(tmp<ans)ans=tmp;
+            }
+        }
+        printf("Case #%d:\n",cas++);
+        printf("%d %d\n",ans.first,ans.second);
+    }
+    return 0;
+}
diff --git a/HDOJ/5262_autoAC.cpp b/HDOJ/5262_autoAC.cpp
new file mode 100644
index 0000000..5f8cc1a
--- /dev/null
+++ b/HDOJ/5262_autoAC.cpp
@@ -0,0 +1,59 @@
+#include<iostream>
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<vector>
+#include<cmath>
+#include<queue>
+#include<stack>
+#include<map>
+#include<set>
+#include<algorithm>
+using namespace std;
+using namespace std;
+typedef long long LL;
+const int maxn=100010;
+const int MOD=1e9+7;
+char str[maxn];
+int dp[maxn];
+int pos[30];
+int nxt[maxn][30];
+LL cnt[maxn];
+int main()
+{
+    int T,cas=1;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%s",str);
+        int N=strlen(str);
+        for(int i=0;i<26;i++)pos[i]=N+1;
+        for(int i=N-1;i>=0;i--)
+        {
+            pos[str[i]-'a']=i+1;
+            for(int j=0;j<26;j++)
+                nxt[i][j]=pos[j];
+        }
+        dp[N+1]=0,dp[N]=1;
+        for(int i=N-1;i>=0;i--)
+        {
+            int minv=N+1;
+            for(int j=0;j<26;j++)
+                minv=min(minv,dp[nxt[i][j]]+1);
+            dp[i]=minv;
+        }
+        memset(cnt,0,sizeof(cnt));
+        cnt[N]=26,cnt[N+1]=1;
+        for(int i=N-1;i>=0;i--)
+        {
+            for(int j=0;j<26;j++)
+                if(dp[i]==dp[nxt[i][j]]+1)
+                {
+                    cnt[i]+=cnt[nxt[i][j]];
+                    if(cnt[i]>=MOD)cnt[i]-=MOD;
+                }
+        }
+        printf("Case #%d:\n%d %I64d\n",cas++,dp[0],cnt[0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5264_autoAC.cpp b/HDOJ/5264_autoAC.cpp
new file mode 100644
index 0000000..f1b9858
--- /dev/null
+++ b/HDOJ/5264_autoAC.cpp
@@ -0,0 +1,28 @@
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<iostream>
+#include<queue>
+#include<algorithm>
+#include<cmath>
+#include<string>
+using namespace std;
+const int maxn = 1005;
+int T, n, m; 
+string a, b, s;
+int main()
+{
+    scanf("%d", &T);
+    while (T--)
+    {
+        cin >> s;
+        b = a = "";
+        for (int i = 0; s[i]; i++)
+        {
+            if (i & 1) b = s[i] + b;
+            else a = a + s[i];
+        }
+        cout << a << endl;
+        cout << b << endl;
+    }
+}
diff --git a/HDOJ/5265_autoAC.cpp b/HDOJ/5265_autoAC.cpp
new file mode 100644
index 0000000..9ea92bf
--- /dev/null
+++ b/HDOJ/5265_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+using namespace std;
+const int maxn=100000+5;
+int data[maxn];
+int main()
+{
+    int m,p;
+    while(scanf("%d%d",&m,&p)!=-1)
+    {
+        for(int i=0; i<m; i++)
+          {
+              scanf("%d",&data[i]);
+                data[i]%=p;
+          }
+        sort(data,data+m);
+        if(p-data[m-1]>data[m-2])
+            printf("%d\n",data[m-1]+data[m-2]);
+        else
+        {
+            int now=0;
+            int ans=data[m-1]+data[m-2]-p;
+            for(int i=m-1; i>=1; i--)
+            {
+                for(int j=now; j<i; j++)
+                {
+                    if(p-data[i]>data[j])
+                    ans=max(data[i]+data[j],ans);
+                    else
+                    {
+                        if(j>0)
+                        now=j-1;
+                        break;
+                    }
+                    if(ans==p-1)
+                        break;
+                }
+                if(ans==p-1)
+                        break;
+            }
+            printf("%d\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5268_autoAC.cpp b/HDOJ/5268_autoAC.cpp
new file mode 100644
index 0000000..38da8f9
--- /dev/null
+++ b/HDOJ/5268_autoAC.cpp
@@ -0,0 +1,20 @@
+#include <iostream>
+#include <algorithm>
+using namespace std;
+int main()
+{
+    int T,a,b;
+    cin>>T;
+    for(int k=1; k<=T; k++)
+    {
+        int sum,ans=0;
+        for(int i=2; i<=5; i++)
+        {
+            cin>>a>>b;
+            sum=2*i*(250-a)-50*b;
+            ans+=max(sum,(int)(0.4*i*500));
+        }
+        cout<<"Case #"<<k<<": "<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5269_autoAC.cpp b/HDOJ/5269_autoAC.cpp
new file mode 100644
index 0000000..0370eef
--- /dev/null
+++ b/HDOJ/5269_autoAC.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <map>
+#include <stack>
+#include <sstream>
+#include <cmath>
+#include <queue>
+#include <string>
+#include <vector>
+#define zeros(a) memset(a,0,sizeof(a))
+#define ones(a) memset(a,-1,sizeof(a))
+#define sc(a) scanf("%d",&a)
+#define sc2(a,b) scanf("%d%d",&a,&b)
+#define rep(i,n) for(int i=0;i<n;i++)
+#define lson (step<<1)
+#define rson (lson+1)
+#define esp 1e-6
+#define oo 0x3fffffff
+using namespace std;
+typedef long long ll;
+int n;
+const int mod=998244353;
+const int maxn=50000+10;
+int bit[31];
+ll ans;
+struct trie
+{
+    int next[30*maxn][2];
+    int tot[maxn*30];
+    int cnt,root;
+    int newNode()
+    {
+        tot[cnt]=0;
+        next[cnt][0]=next[cnt][1]=-1;
+        cnt++;
+        return cnt-1;
+    }
+    void init()
+    {
+        cnt=0;
+        root=newNode();
+    }
+    void Insert(int val)
+    {
+        int temp=root;
+        int id;
+        for(int i=0;i<30;i++)
+        {
+            if(val&bit[i])
+                id=1;
+            else
+                id=0;
+            if(next[temp][id^1]!=-1)
+                ans=(ans+((ll)bit[i]*tot[next[temp][id^1]])%mod)%mod;
+            if(next[temp][id]==-1)
+                next[temp][id]=newNode();
+            temp=next[temp][id];
+            tot[temp]++;
+        }
+    }
+}tree;
+int main()
+{
+    int T_T;
+    scanf("%d",&T_T);
+    bit[0]=1;
+    for(int i=1;i<=30;i++)
+    {
+        bit[i]=bit[i-1]<<1;
+    }
+    for(int kase=1;kase<=T_T;kase++)
+    {
+        scanf("%d",&n);
+        int val;
+        ans=0;
+        tree.init();
+        for(int i=1;i<=n;i++)
+        {
+            sc(val);
+            tree.Insert(val);
+        }
+        ans=(ans<<1)%mod;
+        printf("Case #%d: %I64d\n",kase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5270_autoAC.cpp b/HDOJ/5270_autoAC.cpp
new file mode 100644
index 0000000..13206f2
--- /dev/null
+++ b/HDOJ/5270_autoAC.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <cstdio>
+#include <string.h>
+#include <algorithm>
+#define cl(a,b) memset(a,b,sizeof(a))
+#define ll long long
+#define ull unsigned long long
+using namespace std;
+#define maxn 200005
+ull aa[maxn],bb[maxn];
+ull taa[maxn],tbb[maxn];
+ull cc[64],be[64],en[64];
+int n;
+void initcc()
+{
+    cl(cc,0);
+    cc[0]=1;
+    be[0]=1;
+    en[0]=2;
+    for(int i=1;i<=62;i++)
+    {
+        cc[i]=cc[i-1]*2+1;
+        be[i]=be[i-1]*2;
+        en[i]=en[i-1]*2;
+    }
+}
+int main()
+{
+    initcc();
+    int tt,ii;
+    cin>>tt;
+    ii=0;
+    while(tt--)
+    {
+        scanf("%d",&n);
+        int i,j,k;
+        for(i=0;i<n;i++)scanf("%llu",&aa[i]);
+        for(i=0;i<n;i++)scanf("%llu",&bb[i]);
+        ull res=0,bitc;
+        int s1,s2,e1,e2;
+        for(k=0;k<62;k++)
+        {
+            for(i=0;i<n;i++)
+            {
+                taa[i]=aa[i]&cc[k];
+                tbb[i]=bb[i]&cc[k];
+            }
+            sort(taa,taa+n);
+            sort(tbb,tbb+n);
+            s1=n-1;e1=n-1;bitc=0;
+            s2=n-1;e2=n-1;
+            for(i=0;i<n;i++)
+            {
+                while(s1>=0&&tbb[s1]+taa[i]>=be[k])s1--;
+                while(e1>=0&&tbb[e1]+taa[i]>=en[k])e1--;
+                while(s2>=0&&tbb[s2]+taa[i]>=be[k]+en[k])s2--;
+                while(e2>=0&&tbb[e2]+taa[i]>=en[k+1])e2--;
+                bitc+=e1-s1;
+                bitc+=e2-s2;
+            }
+            res+=be[k]*(bitc%2);
+        }
+        printf("Case #%d: %llu\n",++ii,res);
+    }
+    return 0;
+}
diff --git a/HDOJ/5272_autoAC.cpp b/HDOJ/5272_autoAC.cpp
new file mode 100644
index 0000000..d155621
--- /dev/null
+++ b/HDOJ/5272_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <algorithm>
+#include <set>
+#include <vector>
+#include <sstream>
+#include <queue>
+#include <typeinfo>
+#include <fstream>
+#include <map>
+#include <stack>
+typedef long long ll;
+using namespace std;
+#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
+#define maxn 2000001
+#define mod 10007
+#define eps 1e-5
+const int inf=0x3f3f3f3f;
+const ll infll = 0x3f3f3f3f3f3f3f3fLL;
+inline ll read()
+{
+    ll x=0,f=1;char ch=getchar();
+    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
+    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
+    return x*f;
+}
+int main()
+{
+    int t=read();
+    while(t--){
+        ll n=read();
+        int ans=0;
+        int flag=1;
+        while(n)
+        {
+            if(flag)
+            {
+                if(n&1)
+                {
+                    ans++;
+                    flag=0;
+                }
+            }
+            else if(!(n&1))
+            {
+                flag=1;
+            }
+            n>>=1;
+        }
+        cout<<ans<<endl;
+    }
+}
diff --git a/HDOJ/5273_autoAC.cpp b/HDOJ/5273_autoAC.cpp
new file mode 100644
index 0000000..42cd2a9
--- /dev/null
+++ b/HDOJ/5273_autoAC.cpp
@@ -0,0 +1,28 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<math.h>
+using namespace std;
+const int N = 1005;
+#define LL __int64
+int n,q,a[N],l,r,dp[N][N];
+int main()
+{
+    while(scanf("%d%d",&n,&q)>0){
+        for(int i=1; i<=n; i++)
+            scanf("%d",&a[i]);
+        memset(dp,0,sizeof(dp));
+        for(int k=1; k<n; k++)
+        for(int i=1; i+k<=n; i++){
+            int j=i+k;
+            dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];
+            if(a[i]>a[j])
+                dp[i][j]++;
+        }
+        while(q--){
+            scanf("%d%d",&l,&r);
+            printf("%d\n",dp[l][r]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5274_autoAC.cpp b/HDOJ/5274_autoAC.cpp
new file mode 100644
index 0000000..7fdd98f
--- /dev/null
+++ b/HDOJ/5274_autoAC.cpp
@@ -0,0 +1,130 @@
+#pragma comment(linker,"/STACK:1024000000,1024000000")
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<map>
+using namespace std;
+const int N = 100005;
+#define LL __int64
+struct EDG{
+    int to,next;
+}edg[N*2];
+int eid,head[N];
+int fath[N],deep[N],top[N],num[N],son[N],p[N],pos;
+void init(){
+    pos=0; eid=0;
+    memset(head,-1,sizeof(head));
+}
+void addEdg(int u,int v){
+    edg[eid].to=v; edg[eid].next=head[u]; head[u]=eid++;
+    edg[eid].to=u; edg[eid].next=head[v]; head[v]=eid++;
+}
+void dfs(int u,int pre,int d){
+    fath[u]=pre; num[u]=1; deep[u]=d; son[u]=-1;
+    for(int i=head[u]; i!=-1; i=edg[i].next){
+        int v=edg[i].to;
+        if(v==pre)continue;
+        dfs(v,u,d+1);
+        num[u]+=num[v];
+        if(son[u]==-1||num[son[u]]<num[v])
+            son[u]=v;
+    }
+}
+void getpos(int u,int root){
+    top[u]=root;
+    p[u]=++pos;
+    if(son[u]==-1)
+        return ;
+    getpos(son[u],root);
+    for(int i=head[u]; i!=-1; i=edg[i].next){
+        int v=edg[i].to;
+        if(son[u]==v||v==fath[u])
+            continue;
+        getpos(v,v);
+    }
+}
+int root[N*3]; 
+int a[N];
+void build(int l,int r,int k){
+    if(l==r){
+       root[k]=a[l];
+       return ;
+    }
+    int m=(l+r)>>1;
+    build(l,m,k<<1);
+    build(m+1,r,k<<1|1);
+    root[k]=root[k<<1]^root[k<<1|1];
+}
+void updata(int l,int r,int k,int id,int vule){
+    if(l==r){
+        root[k]=vule;
+        return ;
+    }
+    int m=(l+r)>>1;
+    if(id<=m)
+        updata(l,m,k<<1,id,vule);
+    else
+        updata(m+1,r,k<<1|1,id,vule);
+    root[k]=root[k<<1]^root[k<<1|1];
+}
+int query(int l,int r,int k,int L,int R){
+    if(L<=l&&r<=R){
+        return root[k];
+    }
+    int m=(l+r)>>1 , ans=0;
+    if(L<=m)
+       ans^= query(l,m,k<<1,L,R);
+    if(m<R)
+        ans^=query(m+1,r,k<<1|1,L,R);
+    return ans;
+}
+void swp(int &aa,int &bb){
+    int tt=aa; aa=bb; bb=tt;
+}
+int Operat(int u,int v){
+    int fu=top[u] , fv=top[v],ans=0;
+    while(fu!=fv){
+        if(deep[fu]<deep[fv]){
+            swp(fu,fv); swp(u,v);
+        }
+       ans^= query(1,pos,1,p[fu],p[u]);
+       u=fath[fu]; fu=top[u];
+    }
+    if(deep[u]>deep[v])
+        swp(u,v);
+    ans^=query(1,pos,1,p[u],p[v]);
+    return ans;
+}
+int main()
+{
+   int T,n,q,val[N],u,v;
+   scanf("%d",&T);
+   while(T--){
+    scanf("%d%d",&n,&q);
+    init();
+    for(int i=1; i<n; i++)
+    {
+        scanf("%d%d",&u,&v);
+        addEdg(u,v);
+    }
+    for(int i=1; i<=n; i++){
+        scanf("%d",&val[i]);
+        val[i]++;
+    }
+    dfs(1,1,1);
+    getpos(1,1);
+    for(int i=1; i<=n; i++)
+        a[p[i]]=val[i];
+    build(1,pos,1);
+    while(q--){
+        int op,x,y;
+        scanf("%d%d%d",&op,&x,&y);
+        if(op==0)
+            updata(1,pos,1,p[x],y+1);
+        else{
+            printf("%d\n",Operat(x,y)-1);
+        }
+    }
+   }
+    return 0;
+}
diff --git a/HDOJ/5275_autoAC.cpp b/HDOJ/5275_autoAC.cpp
new file mode 100644
index 0000000..021140a
--- /dev/null
+++ b/HDOJ/5275_autoAC.cpp
@@ -0,0 +1,54 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <cctype>
+#include <climits>
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <algorithm>
+#include <bitset>
+#include <complex>
+#include <string>
+#include <utility>
+using namespace std;
+typedef long long Int;
+const int M=1e9+7;
+int rev[250002];
+int dp[3002][3002];
+int x[3002],y[3002];
+inline int getrev(int x){return x<0?-rev[-x]:rev[x];}
+int main()
+{
+    rev[1]=1;
+    for(int i=2;i<=250000;i++)rev[i]=(M-M/i)*(Int)rev[M%i]%M;
+    int n;
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(int i=1;i<=n;i++)scanf("%d%d",x+i,y+i);
+        for(int i=1;i<=n;i++)dp[0][i]=y[i];
+        for(int i=1;i<=n;i++)
+            for(int j=1;j+i<=n;j++)
+                dp[i][j]=((dp[i-1][j+1]-dp[i-1][j])*(Int)getrev(x[i+j]-x[j])%M+M)%M;
+        int m;scanf("%d",&m);
+        while(m--)
+        {
+            int l,r,q;scanf("%d%d%d",&l,&r,&q);
+            int ans=0,cur=1;
+            for(int i=0;i<=r-l;i++)
+            {
+                ans+=dp[i][l]*(Int)cur%M;
+                if(ans>=M)ans-=M;
+                cur=(cur*(Int)(q-x[l+i])%M+M)%M;
+            }printf("%d\n",ans);
+        }
+    }
+}
diff --git a/HDOJ/5276_autoAC.cpp b/HDOJ/5276_autoAC.cpp
new file mode 100644
index 0000000..e0b6b93
--- /dev/null
+++ b/HDOJ/5276_autoAC.cpp
@@ -0,0 +1,32 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+int main()
+{
+    int n;
+    while(scanf("%d", &n) != EOF)
+    {
+        int h=0,m=0,s=0;
+        for (int i = 0; i < 12 * 60 * 60; i = i + 10)
+        {
+            int time1 = (i * 1200) % 4320000;
+            int time2 = (i * 100) % 4320000;
+            int time;
+            if (time1 > time2)
+                time = time1 - time2;
+            else
+                time = time2 - time1;
+            if (time > 2160000)
+                time = 4320000 - time;
+            if (time == n)
+            {
+                int h = i / (60 * 60);
+                int m = (i - h * (60 * 60)) / 60;
+                int s = (i % 60) - (i % 60) % 10;
+                printf("%02d:%02d:%02d\n", h, m, s);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5277_autoAC.cpp b/HDOJ/5277_autoAC.cpp
new file mode 100644
index 0000000..35b5eac
--- /dev/null
+++ b/HDOJ/5277_autoAC.cpp
@@ -0,0 +1,91 @@
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <algorithm>
+#include <set>
+#include <vector>
+#include <sstream>
+#include <queue>
+#include <typeinfo>
+#include <fstream>
+#include <map>
+#include <stack>
+typedef long long ll;
+using namespace std;
+#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
+#define maxn 1005
+#define mod 10007
+#define eps 1e-9
+const int inf=0x3f3f3f3f;
+const ll infll = 0x3f3f3f3f3f3f3f3fLL;
+inline ll read()
+{
+    ll x=0,f=1;char ch=getchar();
+    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
+    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
+    return x*f;
+}
+struct node
+{
+    int x,y;
+};
+node a[maxn];
+int g[maxn][maxn];
+vector<int> G[maxn];
+int one,two,three,four;
+int n,m;
+void init()
+{
+    one=two=three=four=0;
+    memset(a,0,sizeof(a));
+    memset(g,0,sizeof(g));
+    for(int i=0;i<n;i++)
+        G[i].clear();
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        init();
+        for(int i=0;i<n;i++)
+            a[i].x=read(),a[i].y=read();
+        for(int i=1;i<=m;i++)
+        {
+            int x=read(),y=read();
+            x--,y--;
+            g[x][y]=g[y][x]=1;
+            G[x].push_back(y);
+            G[y].push_back(x);
+        }
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<G[i].size();j++)
+            {
+                for(int k=0;k<G[i].size();k++)
+                {
+                    if(G[i][j]!=G[i][k]&&g[G[i][j]][G[i][k]])
+                    {
+                        three++;
+                        for(int t=0;t<G[i].size();t++)
+                        {
+                            if(G[i][j]!=G[i][k]&&G[i][j]!=G[i][t]&&G[i][k]!=G[i][t]&&g[G[i][j]][G[i][k]]&&g[G[i][j]][G[i][t]]&&g[G[i][k]][G[i][t]])
+                            {
+                                four++;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if(four)
+            cout<<"4 "<<four/24<<endl;
+        else if(three)
+            cout<<"3 "<<three/6<<endl;
+        else if(m)
+            cout<<"2 "<<m<<endl;
+        else
+            cout<<"1 "<<n<<endl;
+    }
+}
diff --git a/HDOJ/5278_autoAC.cpp b/HDOJ/5278_autoAC.cpp
new file mode 100644
index 0000000..aaed5af
--- /dev/null
+++ b/HDOJ/5278_autoAC.cpp
@@ -0,0 +1,82 @@
+#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>
+#include <iomanip>
+using namespace std;
+typedef long long ll;
+const ll mod=998244353;
+bool a[1000][1000];
+int n,m,au[1000][9],p[1000][1000],ee,fa[900],num[900];
+ll two[1000];
+struct edge {
+    int x,y,next;
+}e[8888888];
+void addedge(int x,int y,int u,int v) {
+    if(x==y) return;
+    if(x>y) {x=x^y;y=x^y;x=x^y;}
+    e[ee].x=u;e[ee].y=v;e[ee].next=p[x][y];p[x][y]=ee++;
+}
+void init() {
+    int i,j,k,x,y;
+    queue<int> qx,qy;ee=0;
+    for(i=1;i<=n;i++) {fa[i]=i;num[i]=1;}
+    for(i=1;i<n;i++)
+        for(j=i+1;j<=n;j++)
+            for(k=1;k<=m;k++)
+                addedge(au[i][k],au[j][k],i,j);
+    for(i=1;i<=n;i++) {
+        a[0][i]=true;qx.push(0);qy.push(i);
+    }
+    while (!qx.empty()) {
+        i=qx.front();j=qy.front();qx.pop();qy.pop();
+        k=p[i][j];
+        while(k!=-1) {
+            x=e[k].x;y=e[k].y;
+            if(a[x][y]) {k=e[k].next;continue;}
+            else {
+                a[x][y]=true;
+                qx.push(e[k].x);qy.push(e[k].y);
+            }
+        }
+    }
+}
+int find_fa(int u) {
+    if(u==fa[u]) return u;
+    return fa[u]=find_fa(fa[u]);
+}
+ll cal () {
+    int i,j;ll ans=two[n]-1;
+    for(i=1;i<n;i++) for(j=i+1;j<=n;j++) {
+        if(!a[i][j]&&find_fa(i)!=find_fa(j)) {
+            num[find_fa(i)]+=num[find_fa(j)];
+            fa[fa[j]]=fa[i];
+        }
+    }
+    for(i=1;i<=n;i++) {
+        if(i==fa[i]) {
+            ans=(ans+mod-two[num[i]]+1)%mod;
+        }
+    }
+    return ans;
+}
+int main () 
+{
+    int i,j;
+    two[0]=1;for(i=1;i<=900;i++) two[i]=2*two[i-1]%mod;
+    while(~scanf("%d%d",&n,&m)) {
+        for(i=1;i<=n;i++) for(j=1;j<=m;j++) scanf("%d",&au[i][j]);
+        memset(a,false,sizeof(a));
+        for(i=0;i<n;i++) for(j=i+1;j<=n;j++) p[i][j]=-1;
+        init();
+        printf("%I64d\n",cal());
+    }
+}
diff --git a/HDOJ/5279_autoAC.cpp b/HDOJ/5279_autoAC.cpp
new file mode 100644
index 0000000..4c17a61
--- /dev/null
+++ b/HDOJ/5279_autoAC.cpp
@@ -0,0 +1,108 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std ;
+typedef long long LL ;
+#define clr(a,x); memset ( a , x , sizeof a ) ;
+const int MAXN = 1 << 17 ;
+const int mod = 998244353 ;
+const int g = 3 ;
+LL f[MAXN] , invf[MAXN] ;
+LL tcnt[MAXN] ;
+LL dp[MAXN] , dp2[MAXN] ;
+LL x1[MAXN] , x2[MAXN] , x3[MAXN] ;
+int n ;
+LL power ( LL a , int b ) {
+    LL res = 1 , tmp = a ;
+    while ( b ) {
+        if ( b & 1 ) res = res * tmp % mod ;
+        tmp = tmp * tmp % mod ;
+        b >>= 1 ;
+    }
+    return res ;
+}
+void NTT ( LL y[] , int n , int rev ) {
+    for ( int i = 1 , j , k , t ; i < n ; ++ i ) {
+        for ( j = 0 , k = n >> 1 , t = i ; k ; k >>= 1 , t >>= 1 ) {
+            j = j << 1 | ( t & 1 ) ;
+        }
+        if ( i < j ) swap ( y[i] , y[j] ) ;
+    }
+    for ( int s = 2 , ds = 1 ; s <= n ; ds = s , s <<= 1 ) {
+        LL wn = power ( g , ( mod - 1 ) / s ) ;
+        if ( !rev ) wn = power ( wn , mod - 2 ) ;
+        for ( int k = 0 ; k < n ; k += s ) {
+            LL w = 1 , t ;
+            for ( int i = k ; i < k + ds ; ++ i , w = w * wn % mod ) {
+                y[i + ds] = ( y[i] - ( t = y[i + ds] * w % mod ) + mod ) % mod ;
+                y[i] = ( y[i] + t ) % mod ;
+            }
+        }
+    }
+    if ( !rev ) {
+        LL invn = power ( n , mod - 2 ) ;
+        for ( int i = 0 ; i < n ; ++ i ) {
+            y[i] = y[i] * invn % mod ;
+        }
+    }
+}
+void cdq_fz ( int l , int r ) {
+    if ( l == r ) return ;
+    if ( l + 1 == r ) {
+        dp[r] = ( dp[r] + dp[l] ) % mod ;
+        return ;
+    }
+    int m = ( l + r ) >> 1 , n1 = 1 ;
+    cdq_fz ( l , m ) ;
+    while ( n1 <= r - l + 1 ) n1 <<= 1 ;
+    for ( int i = 0 ; i < n1 ; ++ i ) {
+        x1[i] = l + i <= m ? dp[l + i] * invf[l + i] % mod : 0 ;
+        x2[i] = l + i <= r ? tcnt[i + 1] * invf[i] % mod : 0 ;
+        x3[i] = l + i <= r ? tcnt[i + 2] * invf[i] % mod : 0 ;
+    }
+    NTT ( x1 , n1 , 1 ) ;
+    NTT ( x2 , n1 , 1 ) ;
+    NTT ( x3 , n1 , 1 ) ;
+    for ( int i = 0 ; i < n1 ; ++ i ) {
+        x3[i] = x1[i] * x3[i] % mod ;
+        x2[i] = x1[i] * x2[i] % mod ;
+    }
+    NTT ( x2 , n1 , 0 ) ;
+    NTT ( x3 , n1 , 0 ) ;
+    for ( int i = m + 1 ; i <= r ; ++ i ) {
+        dp[i] = ( dp[i] + f[i - 1] * x2[i - l - 1] % mod ) % mod ;
+        dp2[i] = ( dp2[i] + f[i - 2] * x3[i - l - 2] % mod ) % mod ;
+    }
+    cdq_fz ( m + 1 , r ) ;
+}
+void preprocess () {
+    f[0] = invf[0] = 1 ;
+    dp[0] = dp2[0] = dp2[1] = 1 ;
+    for ( int i = 1 ; i <= 100000 ; ++ i ) {
+        f[i] = f[i - 1] * i % mod ;
+        invf[i] = power ( f[i] , mod - 2 ) ;
+        if ( i >= 2 ) tcnt[i] = power ( i , i - 2 ) ;
+    }
+    tcnt[1] = 1 ;
+    cdq_fz ( 0 , 100000 ) ;
+}
+void solve () {
+    int x ;
+    scanf ( "%d" , &n ) ;
+    int ans1 = power ( 2 , n ) , ans2 = 1 ;
+    for ( int i = 1 ; i <= n ; ++ i ) {
+        scanf ( "%d" , &x ) ;
+        ans1 = ans1 * dp[x] % mod ;
+        if ( n > 2 ) ans2 = ans2 * dp2[x] % mod ;
+    }
+    printf ( "%d\n" , ( ans1 - ans2 + mod ) % mod ) ;
+}
+int main () {
+    int T ;
+    preprocess () ;
+    scanf ( "%d" , &T ) ;
+    for ( int i = 1 ; i <= T ; ++ i ) {
+        solve () ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5280_autoAC.cpp b/HDOJ/5280_autoAC.cpp
new file mode 100644
index 0000000..017c2b1
--- /dev/null
+++ b/HDOJ/5280_autoAC.cpp
@@ -0,0 +1,50 @@
+#include <set>
+#include <map>
+#include <queue>
+#include <deque>
+#include <cmath>
+#include <vector>
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cassert>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+typedef long long LL;
+typedef pair <int, int> PII;
+const int N = 1e5 + 7;
+const int INF = 0x3f3f3f3f;
+const int MOD = 1e9 + 7;
+const double EPS = 1e-6;
+const double PI = acos(-1.0);
+int a[N];
+LL l[N], r[N];
+int main(void){
+    int T;
+    scanf("%d", &T);
+    while (T--) {
+        int n, p;
+        scanf("%d%d", &n, &p);
+        for (int i = 1; i <= n; ++i)
+            scanf("%d", &a[i]);
+        l[0] = r[0] = l[n + 1] = r[n + 1] = 0;
+        for (int i = 1; i <= n; ++i)
+            l[i] = max(l[i - 1] + a[i], (LL)a[i]);
+        for (int i = n; i; --i)
+            r[i] = max(r[i + 1] + a[i], (LL)a[i]);
+        LL ans = -INF;
+        for (int i = 1; i <= n; ++i) {
+            ans = max(ans, max(l[i - 1], 0LL) + max(r[i + 1], 0LL) + p);
+        }
+        for (int i = 1; i < n; ++i) {
+            ans = max(ans, l[i]);
+        }
+        for (int i = n; i > 1; --i) {
+            ans = max(ans, r[i]);
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5281_autoAC.cpp b/HDOJ/5281_autoAC.cpp
new file mode 100644
index 0000000..10748fd
--- /dev/null
+++ b/HDOJ/5281_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+#define maxn 100000 + 10
+#define INF 0x7fffffff
+long long  mmap[maxn];
+long long  temp[maxn];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int n,m;
+        scanf("%d %d",&n,&m);
+        for(int i=0;i<n;i++)
+        {
+            scanf("%lld",&mmap[i]);
+        }
+        for(int i=0;i<m;i++)
+        {
+            scanf("%lld",&temp[i]);
+        }
+        sort(mmap,mmap+n);
+        sort(temp,temp+m);
+        long long sum = 0;
+        long long ans = 0;
+        int p = 0;
+        for(int i=n-1;i>=0;i--)
+        {
+            if(p>=m) break;
+            if(mmap[i] >= temp[p])
+            {
+               ans += mmap[i] - temp[p];
+               sum = max(sum,ans);
+               p++;
+            }
+            else
+            {
+                p++;
+                i++;
+            }
+        }
+        printf("%lld\n",sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/5282_autoAC.cpp b/HDOJ/5282_autoAC.cpp
new file mode 100644
index 0000000..a1bf475
--- /dev/null
+++ b/HDOJ/5282_autoAC.cpp
@@ -0,0 +1,62 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+#define MAX_N 1100
+char a[MAX_N],b[MAX_N];
+int dp[MAX_N+1][MAX_N+1];
+int dd[MAX_N+1][MAX_N+1];
+int wei[MAX_N+1][26];
+__int64 f[MAX_N+1][MAX_N+1];
+int mod=1e9+7;
+int main()
+{
+    int n,m,tem,t;
+    scanf("%d",&t);
+    while(t--) 
+    {
+        scanf("%s%s",a,b);
+        memset(dp,0,sizeof(dp)); 
+        n=strlen(a);
+        m=strlen(b);
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {
+                if(a[i]==b[j]) 
+                    dp[i+1][j+1]=max(dp[i][j]+1,max(dp[i+1][j],dp[i][j+1])); 
+                else 
+                    dp[i+1][j+1]=max(dp[i+1][j],dp[i][j+1]); 
+            }
+        }  
+        memset(wei,0,sizeof wei); 
+        for(int i=1;i<=m;i++)
+        {
+            for(int j=0;j<26;j++)
+                wei[i][j]=wei[i-1][j];
+            wei[i][b[i-1]-'a']=i;
+        } 
+        memset(f,0,sizeof f);
+        for(int i=0;i<=n;i++)
+        {
+            for(int j=0;j<=m;j++)
+            {
+                if(dp[i][j]==0)
+                {
+                    f[i][j]=1;
+                    continue;
+                }
+                if(dp[i-1][j]==dp[i][j]) 
+                    f[i][j]=(f[i][j]+f[i-1][j])%mod;
+                int p=wei[j][a[i-1]-'a'];
+                if(p)
+                {
+                    if(dp[i-1][p-1]+1==dp[i][j])
+                        f[i][j]=(f[i][j]+f[i-1][p-1])%mod;
+                }
+            }
+        }
+        printf("%I64d\n",f[n][m]%mod);
+    }
+    return 0;
+}
diff --git a/HDOJ/5283_autoAC.cpp b/HDOJ/5283_autoAC.cpp
new file mode 100644
index 0000000..bd0c398
--- /dev/null
+++ b/HDOJ/5283_autoAC.cpp
@@ -0,0 +1,144 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <set>
+#include <vector>
+#include <map>
+#include <queue>
+#include <set>
+#include <algorithm>
+#include <limits>
+using namespace std;
+typedef long long LL;
+const int MAXN=100000+100;
+const LL LL_INF=numeric_limits<LL>::max();
+#define lson L,mid,rt<<1
+#define rson mid+1,R,rt<<1|1
+long long X[4],Y[4];
+long long tx[MAXN],ty[MAXN];
+struct Tree {
+    long long maX[4],maY[4],addx,addy,sum[4];
+}tr[MAXN<<2];
+void pushup(int rt){
+    for(int i=0;i<4;i++){
+        tr[rt].maX[i]=max(tr[rt<<1].maX[i],tr[rt<<1|1].maX[i]);
+        tr[rt].maY[i]=max(tr[rt<<1].maY[i],tr[rt<<1|1].maY[i]);
+        tr[rt].sum[i]=tr[rt<<1].sum[i]+tr[rt<<1|1].sum[i];
+    }
+}
+void pushdown(int rt){
+    if(tr[rt].addx){
+        tr[rt<<1].addx+=tr[rt].addx;
+        tr[rt<<1|1].addx+=tr[rt].addx;
+        for(int i=0;i<4;i++){
+            tr[rt<<1].maX[i]+=tr[rt].addx;
+            tr[rt<<1|1].maX[i]+=tr[rt].addx;
+        }
+        tr[rt].addx=0;
+    }
+    if(tr[rt].addy){
+        tr[rt<<1].addy+=tr[rt].addy;
+        tr[rt<<1|1].addy+=tr[rt].addy;
+        for(int i=0;i<4;i++){
+            tr[rt<<1].maY[i]+=tr[rt].addy;
+            tr[rt<<1|1].maY[i]+=tr[rt].addy;
+        }
+        tr[rt].addy=0;
+    }
+}
+void build(int L,int R,int rt){
+    tr[rt].addy=tr[rt].addx=0;
+    if(L==R){
+        for(int i=0;i<4;i++){
+            tr[rt].maX[i]=tx[L];
+            tr[rt].maY[i]=ty[L];
+            tr[rt].sum[i]=1;
+        }
+        return ;
+    }
+    int mid=(L+R)>>1;
+    build(lson);
+    build(rson);
+    pushup(rt);
+}
+void update(int L,int R,int rt,int l,int r,long long v,int flag){
+    if(l<=L&&R<=r){
+        if(flag==0){
+            for(int i=0;i<4;i++) tr[rt].maX[i]+=v;
+            tr[rt].addx+=v;
+        }
+        else {
+            for(int i=0;i<4;i++) tr[rt].maY[i]+=v;
+            tr[rt].addy+=v;
+        }
+        return ;
+    }
+    pushdown(rt);
+    int mid=(L+R)>>1;
+    if(l<=mid)update(lson,l,r,v,flag);
+    if(r>mid)update(rson,l,r,v,flag);
+    pushup(rt);
+}
+void adjust(int L,int R,int rt){
+    int mid=(L+R)>>1;
+    for(int i=0;i<4;i++){
+        if(tr[rt].maX[i]>X[i]||tr[rt].maY[i]>Y[i]){
+            if(L==R){
+                tr[rt].maX[i]=LL_INF+1;
+                tr[rt].maY[i]=LL_INF+1;
+                tr[rt].sum[i]=0;
+                continue;
+            }
+            pushdown(rt);
+            adjust(lson);adjust(rson);
+            pushup(rt);
+        }
+    }
+}
+LL query(int L,int R,int rt,int l,int r,int f){
+    if(l<=L&&R<=r)return tr[rt].sum[f];
+    int mid=(L+R)>>1;
+    LL ans=0;
+    if(l<=mid)ans+=query(lson,l,r,f);
+    if(r>mid)ans+=query(rson,l,r,f);
+    return ans;
+}
+int main()
+{
+    int n,m,t;
+    int xx1,xx2,yy1,yy2;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        scanf("%d%d%d%d",&xx1,&yy1,&xx2,&yy2);
+        X[0]=xx2;Y[0]=yy2;
+        X[1]=xx1-1;Y[1]=yy2;
+        X[2]=xx2;Y[2]=yy1-1;
+        X[3]=xx1-1;Y[3]=yy1-1;
+        for(int i=1;i<=n;i++){
+            scanf("%I64d%I64d",&tx[i],&ty[i]);
+        }
+        build(1,n,1);
+        int type,d,tl,tr;
+        scanf("%d",&m);
+        while(m--){
+            scanf("%d",&type);
+            if(type==1){
+                scanf("%d%d%d",&tl,&tr,&d);
+                update(1,n,1,tl,tr,(LL)d,0);
+            }
+            if(type==2){
+                scanf("%d%d%d",&tl,&tr,&d);
+                update(1,n,1,tl,tr,(LL)d,1);
+            }
+            if(type==3){
+                adjust(1,n,1);
+                scanf("%d%d",&tl,&tr);
+                LL ans=query(1,n,1,tl,tr,0)-query(1,n,1,tl,tr,1)-query(1,n,1,tl,tr,2)+query(1,n,1,tl,tr,3);
+                printf("%I64d\n",ans);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5284_autoAC.cpp b/HDOJ/5284_autoAC.cpp
new file mode 100644
index 0000000..7a24e34
--- /dev/null
+++ b/HDOJ/5284_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<queue>
+#include<math.h>
+#include<vector>
+#include<map>
+#include<set>
+#include<stdlib.h>
+#include<cmath>
+#include<string>
+#include<algorithm>
+#include<iostream>
+#define exp 1e-10
+using namespace std;
+const int N = 3145750;
+const int inf = 1000000000;
+char s[N];
+int main()
+{
+    int t,i;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%s",s);
+        for(i=0;s[i+1]!='\0';i++)
+            if(s[i]=='w'||s[i]=='v'&&s[i+1]=='v')
+                break;
+        if(s[i+1]=='\0')
+        {
+            puts("No");
+            continue;
+        }
+        for(;s[i]!='\0';i++)
+            if(s[i]=='y')
+                break;
+        if(s[i]=='\0')
+        {
+            puts("No");
+            continue;
+        }
+        for(;s[i]!='\0';i++)
+            if(s[i]=='h')
+                break;
+        if(s[i]=='\0')
+            puts("No");
+        else
+            puts("Yes");
+    }
+    return 0;
+}
diff --git a/HDOJ/5285_autoAC.cpp b/HDOJ/5285_autoAC.cpp
new file mode 100644
index 0000000..c8b41a2
--- /dev/null
+++ b/HDOJ/5285_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<string>
+#include<string.h>
+#include<math.h>
+#include<limits.h>
+#include<time.h>
+#include<stdlib.h>
+#include<map>
+#include<queue>
+#include<set>
+#include<stack>
+#include<vector>
+#define LL long long
+using namespace std;
+int vis[100005];
+vector <int> v[100005];
+int bfs(int u)
+{
+    queue <int> q;
+    q.push(u);
+    vis[u] = 0;
+    int res[2] = {1, 0};
+    while(!q.empty())
+    {
+        int tmp = q.front();
+        q.pop();
+        int len = v[tmp].size();
+        for(int i = 0; i < len; i++)
+        {
+            if(vis[v[tmp][i]] == -1)
+            {
+                vis[v[tmp][i]] = !vis[tmp];
+                q.push(v[tmp][i]);
+                res[vis[v[tmp][i]]]++;
+            }
+            else if(vis[v[tmp][i]] == vis[tmp])
+                return -1;
+        }
+    }
+    return max(res[0], res[1]);
+}
+int main()
+{
+    int T;
+    while(~scanf("%d", &T))
+    {
+        while(T--)
+        {
+            int n, m;
+            for(int i = 0; i < 100005; i++)
+                v[i].clear();
+            memset(vis, -1, sizeof vis);
+            scanf("%d%d", &n, &m);
+            for(int i = 0; i < m; i++)
+            {
+                int a, b;
+                scanf("%d%d", &a, &b);
+                v[a].push_back(b);
+                v[b].push_back(a);
+            }
+            int ans = 0;
+            for(int j = 1; j <= n; j++)
+            {
+                if(vis[j] == -1)
+                {
+                    int tmp = bfs(j);
+                    if(tmp == -1)
+                    {
+                        ans = -1;
+                        break;
+                    }
+                    else
+                    {
+                        ans += tmp;
+                    }
+                }
+            }
+            if(ans == -1 || (ans == n && n < 2))
+            {
+                puts("Poor wyh");
+            }
+            else if(ans != n)
+                printf("%d %d\n", ans, n - ans);
+            else
+                printf("%d %d\n", ans - 1, n - ans + 1);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5286_autoAC.cpp b/HDOJ/5286_autoAC.cpp
new file mode 100644
index 0000000..9ab7233
--- /dev/null
+++ b/HDOJ/5286_autoAC.cpp
@@ -0,0 +1,176 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<iostream>
+#include<cmath>
+#include<vector>
+#include<map>
+using namespace std;
+const int maxn=51005;
+const int mod=1000000007;
+struct pi{
+    int sum;
+    int lson;
+    int rson;
+}pp[maxn*17];
+int root[maxn],tot;
+void build(int cnt,int l,int r){
+    pp[cnt].sum=0;
+    if(l==r) return;
+    pp[cnt].lson=tot+1;
+    tot++;
+    build(tot,l,(l+r)/2);
+    pp[cnt].rson=tot+1;
+    tot++;
+    build(tot,(l+r)/2+1,r);
+}
+void merg(int qq,int cnt,int n,int p,int k){
+    int le,ri,mid;
+    le=1;
+    ri=n;
+    while(le<=ri){
+        mid=(le+ri)/2;
+        pp[cnt]=pp[qq];
+        pp[cnt].sum+=k;
+        if (le==ri) break;
+        if(p<=mid){
+            pp[cnt].lson=tot+1;
+            tot++;
+            ri=mid;
+            cnt=tot;
+            qq=pp[qq].lson;
+        }
+        else{
+            pp[cnt].rson=tot+1;
+            tot++;
+            le=mid+1;
+            cnt=tot;
+            qq=pp[qq].rson;
+        }
+    }
+}
+int query(int cnt,int le,int ri,int l,int r){
+    int s=0;
+    int mid;
+    if(le>=l&&ri<=r){
+        return pp[cnt].sum;
+    }
+    mid=(le+ri)/2;
+    if(l<=mid) s+=query(pp[cnt].lson,le,mid,l,r);
+    if(r>mid) s+=query(pp[cnt].rson,mid+1,ri,l,r);
+    return s;
+}
+int a[maxn],b[maxn],c[maxn];
+int l[maxn],vis[maxn],r[505],le[505];
+int g[315][315];
+vector<int>gg[maxn],g1;
+int d[maxn][300];
+int main()
+{
+    int i,j,n,m,t;
+    cin>>t;
+    while(t--){
+        scanf("%d%d",&n,&m);
+        memset(vis,0,sizeof(vis));
+        for(i=1;i<=n;i++){
+            scanf("%d",&a[i]);
+            b[i]=a[i];
+            gg[i].clear();
+        }
+        sort(b+1,b+1+n);
+        memset(d,0,sizeof(d));
+        for(i=1;i<=n;i++){ a[i]=lower_bound(b+1,b+1+n,a[i])-b;
+            vis[a[i]]++;
+        }
+        for(i=1;i<=n;i++){
+            long long q=1;
+            gg[i].push_back(0);
+            for(j=1;j<=vis[i];j++){
+                q=q*b[i];
+                q%=mod;
+                gg[i].push_back(q);
+            }
+        }
+        int p=sqrt(n),f=0;
+        for(i=1;i<=n;i++){
+            f++;
+            int q=min(i+p-1,n);
+            r[f]=q;
+            le[f]=i;
+            for(j=1;j<=n;j++){
+                d[j][f]=d[j][f-1];
+            }
+            for(j=i;j<=q;j++){
+                l[j]=f;
+                d[a[j]][f]++;
+            }
+            i=q;
+        }
+        memset(g,0,sizeof(g));
+        for(i=1;i<=n;i++){
+            memset(vis,0,sizeof(vis));
+            for(j=i;j<=n;j++){
+                vis[a[j]]++;
+                if(j==i||l[j]!=l[j-1]){
+                    g[l[i]][l[j]]=(g[l[i]][l[j]-1]+gg[a[j]][vis[a[j]]])%mod-gg[a[j]][vis[a[j]]-1];
+                    g[l[i]][l[j]]%=mod;
+                }
+                else{
+                    g[l[i]][l[j]]+=(gg[a[j]][vis[a[j]]]-gg[a[j]][vis[a[j]]-1])%mod;
+                    g[l[i]][l[j]]%=mod;
+                }
+            }
+            i+=p-1;
+        }
+        memset(vis,0,sizeof(vis));
+        int la=0;
+        for(i=0;i<m;i++){
+            int x,y,ll,rr;
+            scanf("%d%d",&x,&y);
+            ll=x;
+            rr=y;
+            x=min((ll^la)%n+1,(rr^la)%n+1);
+            y=max((ll^la)%n+1,(rr^la)%n+1);
+            g1.clear();
+            if(l[y]-l[x]<=1){
+                for(j=x;j<=y;j++){
+                    if(vis[a[j]]==0) g1.push_back(a[j]);
+                    vis[a[j]]++;
+                }
+                int s=0;
+                int p=g1.size();
+                for(j=0;j<p;j++){
+                    s+=gg[g1[j]][vis[g1[j]]];
+                    vis[g1[j]]=0;
+                    s%=mod;
+                }
+                s=(s+mod)%mod;
+                printf("%d\n",s);
+                la=s;
+            }
+            else{
+                int s=0;
+                s=g[l[x]+1][l[y]-1];
+                for(j=x;j<=r[l[x]];j++){
+                    if(!vis[a[j]]) g1.push_back(a[j]);
+                    vis[a[j]]++;
+                }
+                for(j=le[l[y]];j<=y;j++){
+                    if(!vis[a[j]]) g1.push_back(a[j]);
+                    vis[a[j]]++;
+                }
+                int p=g1.size();
+                for(j=0;j<p;j++){
+                    int v=g1[j];
+                    int q=d[v][l[y]-1]-d[v][l[x]];
+                    s+=(gg[v][q+vis[v]]-gg[v][q])%mod;
+                    s%=mod;
+                    vis[v]=0;
+                }
+                s=(s%mod+mod)%mod;
+                printf("%d\n",s);
+                la=s;
+            }
+        }
+    }
+}
diff --git a/HDOJ/5288_autoAC.cpp b/HDOJ/5288_autoAC.cpp
new file mode 100644
index 0000000..4a542fb
--- /dev/null
+++ b/HDOJ/5288_autoAC.cpp
@@ -0,0 +1,124 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <malloc.h>
+#include <ctype.h>
+#include <math.h>
+#include <string>
+#include <iostream>
+#include <algorithm>
+#include <map>
+#include <vector>
+#include <set>
+using namespace std;
+int num[100010];
+int zuo[100010];
+int you[100010];
+int has[10010];
+int Scan()
+{
+    int res = 0, ch, flag = 0;
+    if((ch = getchar()) == '-')               
+        flag = 1;
+    else if(ch >= '0' && ch <= '9')            
+        res = ch - '0';
+    while((ch = getchar()) >= '0' && ch <= '9' )
+        res = res * 10 + ch - '0';
+    return flag ? -res : res;
+}
+vector<int>my[10010];
+int main()
+{
+    int n;
+    for(int i=1;i<=10000;i++)
+    {
+        for(int j=1;j<=i;j++)
+        {
+            if(i%j==0)
+            {
+                my[i].push_back(j); 
+            } 
+        } 
+    }
+    while(scanf("%d",&n)!=EOF)
+    {
+        for(int i=1;i<=n;i++)
+        {
+            num[i]=Scan();
+        }
+        memset(zuo,-1,sizeof zuo);
+        memset(you,-1,sizeof you);
+        /*
+        memset(has,0,sizeof has);
+        for(int i=1;i<=n;i++)
+        {
+            if(has[num[i]]!=0) 
+                zuo[i]=has[num[i]]+1;
+            has[num[i]]=i;
+        }
+        memset(has,0,sizeof has);
+        for(int i=n;i>=1;i--)
+        {
+            if(has[num[i]]!=0) 
+                you[i]=has[num[i]]-1;
+            has[num[i]]=i;
+        }
+        */
+        memset(has,0,sizeof has);
+        for(int i=1;i<=n;i++)
+        {
+            for(int j=0;j<my[num[i]].size();j++)
+            {
+                int tt=my[num[i]][j];
+                if(has[tt])
+                {
+                    if(num[i]%tt==0)
+                    {
+                        if(zuo[i]!=-1)
+                            zuo[i]=max(zuo[i],has[tt]+1);
+                        else
+                            zuo[i]=has[tt]+1;
+                    }
+                }
+            }
+            has[num[i]]=i; 
+        }
+        memset(has,0,sizeof has);
+        for(int i=n;i>=1;i--)
+        {
+            for(int j=0;j<my[num[i]].size();j++)
+            {
+                int tt=my[num[i]][j];
+                if(has[tt])
+                {
+                    if(num[i]%tt==0)
+                    {
+                        if(you[i]!=-1)
+                            you[i]=min(you[i],has[tt]-1);
+                        else
+                            you[i]=has[tt]-1;
+                    }
+                }
+            }
+            has[num[i]]=i; 
+        }
+        for(int i=1;i<=n;i++)
+        {
+            if(zuo[i]==-1)
+                zuo[i]=1;
+            if(you[i]==-1)
+                you[i]=n;
+        }
+        __int64 ans=0;
+        for(int i=1;i<=n;i++)
+        {
+            __int64 l,r;
+            l=(__int64)(i-zuo[i]+1);
+            r=(__int64)(you[i]-i+1);
+            ans=(ans+l*r)%1000000007;
+        }
+        printf("%I64d\n",ans);
+    } 
+    return 0;
+}
diff --git a/HDOJ/5289_autoAC.cpp b/HDOJ/5289_autoAC.cpp
new file mode 100644
index 0000000..e90bb00
--- /dev/null
+++ b/HDOJ/5289_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <set>
+using namespace std;
+int a[100005];
+multiset<int> s;
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    int n, k;
+    while(T--) {
+        s.clear();
+        scanf("%d %d", &n, &k);
+        for(int i = 0; i < n; ++i) {
+            scanf("%d", &a[i]);
+        }
+        if(k == 0) {
+            printf("0\n");
+            continue;
+        }
+        s.insert(a[0]);
+        int l = 0, r = 1;
+        int cnt = 1;
+        long long ans = 0;
+        int minn, maxn;
+        while(1) {
+            if(s.size()) {
+                minn = *s.begin();
+                maxn = *s.rbegin();
+                if(abs(a[r]-minn) < k && abs(a[r]-maxn) < k) {
+                    ans += (long long)s.size();
+                    s.insert(a[r]);
+                    r++;
+                    if(r == n) break;
+                }
+                else {
+                    if(s.size()) {
+                        s.erase(s.find(a[l]));
+                    }
+                    l++;
+                }
+            }
+            else {
+                l = r;
+                s.insert(a[r]);
+                r++;
+                if(r == n) break;
+            }
+        }
+        printf("%I64d\n", ans+n);
+    }
+    return 0;
+}
diff --git a/HDOJ/5290_autoAC.cpp b/HDOJ/5290_autoAC.cpp
new file mode 100644
index 0000000..fb45234
--- /dev/null
+++ b/HDOJ/5290_autoAC.cpp
@@ -0,0 +1,172 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <cctype>
+#include <climits>
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <algorithm>
+#include <bitset>
+#include <complex>
+#include <string>
+#include <utility>
+#include <assert.h> 
+using namespace std;
+typedef long long ll;
+#define prt(k) cout<<#k" = "<<k<<endl;
+const int N = 100007;
+const int W = 107;
+int f[N][107], g[N][107];
+int father[N];
+int n;
+int w[N];
+int F[N][107], G[N][107];
+int maxw;
+struct edge
+{
+        int v, next;
+}e[N<<1];
+int head[N], mm;
+void add(int u,  int v)
+{
+        e[mm].v = v;
+        e[mm].next = head[u];
+        head[u] = mm++;
+}
+struct P
+{
+        int d, id;
+        P() {}
+        P(int _id, int _d=0) { d=_d, id=_id; }
+        bool operator < (P b) const
+        {
+                return d > b.d;
+        }
+}p[N];
+bool vis[N];
+void bfs()
+{
+        queue<P> q;
+        q.push(P(1,0));
+        memset(vis,0,sizeof vis);
+        vis[1] = true;
+        father[1] = 1;
+        while (!q.empty()) {
+                P u = q.front(); q.pop();
+                int now = u.id;
+                p[now].id = now;
+                p[now].d = u.d + 1;
+                for (int i=head[now];~i;i=e[i].next) {
+                        int v = e[i].v;
+                        if (!vis[v]) {
+                                q.push(P(v, u.d + 1));
+                                vis[v] = true;
+                                father[v] = now;
+                        }
+                }
+        }
+}
+void gao(int u, int fa)
+{
+        assert(!vis[u]);
+        vis[u] = true;
+        bool flag = false;
+        g[u][0] = 0;
+        for (int i=head[u];~i;i=e[i].next) {
+                int v = e[i].v;
+                if (v==fa) continue;
+                flag = true;
+                g[u][0] += f[v][0];
+                assert(vis[v]);
+        }
+        if (!flag) {
+                g[u][0] = 0;
+                f[u][w[u]] = 1;
+        }
+        for (int j=0;j<=maxw;j++) {
+                ll sum=0;
+                for (int i=head[u];~i;i=e[i].next) {
+                        int v = e[i].v;
+                        if (v==fa) continue;
+                        int t = F[v][j+1];
+                        if (j > 0)
+                                t = min(t, G[v][j-1]);
+                        sum += t;
+                        if (sum >= n) { sum = n; break; }
+                }
+                if (sum < n ) for (int i=head[u];~i;i=e[i].next) {
+                        int v = e[i].v;
+                        if (v==fa) continue;
+                        int t = F[v][j+1];
+                        if (j > 0) t = min(t, G[v][j-1]);
+                        if (0<=sum && sum < n) f[u][j] = min(f[u][j], (int)(f[v][j+1] + sum - t ) ) ;
+                }
+                sum = 0;
+                int t;
+                for (int i=head[u];~i;i=e[i].next) {
+                        int v = e[i].v;
+                        if (v==fa) continue;
+                        int t = F[v][j];
+                        if (j > 0) t = min(t, G[v][j-1]);
+                        sum += t;
+                        if (sum >= n)  { sum = n; break; }
+                }
+                if (j>0 && sum < n) for (int i=head[u];~i;i=e[i].next) {
+                        int v = e[i].v;
+                        if (v==fa) continue;
+                        int t = F[v][j];
+                        if (j > 0) t = min(t, G[v][j-1]);
+                        if (0<=sum && sum < n) g[u][j]=min(g[u][j], (int)(g[v][j-1] + sum -  t ) );
+                }
+        }
+        ll sum = 0;
+        for (int i=head[u];~i;i=e[i].next) {
+                int v = e[i].v;
+                if (v==fa) continue;
+                sum += min(F[v][w[u]+1], w[u]>0 ? G[v][w[u]-1] : n);
+        }
+        if (0<=sum && sum<n) f[u][w[u]]=min(f[u][w[u]], int(1 +  sum ));
+        for (int i=100;i>=0;i--) f[u][i] = min(f[u][i], f[u][i+1]);
+        for (int i=1;i<=100;i++) g[u][i] =  min(g[u][i], g[u][i-1]);
+        F[u][0] = f[u][0];
+        G[u][0] = g[u][0];
+        for (int j=1;j<=maxw+1;j++) {
+                F[u][j] = min(F[u][j-1], f[u][j]);
+                G[u][j] = min(G[u][j-1], g[u][j]);
+        }
+}
+int main()
+{
+        while (scanf("%d", &n)==1) {
+                maxw = 0;
+                for (int i=1;i<=n;i++) scanf("%d", w+i), maxw=max(maxw, w[i]);
+                mm=0; memset(head,-1,sizeof head);
+                for (int i=1;i<=n-1;i++)
+                {
+                        int u, v; scanf("%d%d", &u, &v);
+                        add(u, v);
+                        add(v, u);
+                }
+                memset(f, 63, sizeof f);
+                memset(g, 63, sizeof g);
+                bfs();
+                sort(p+1, p+n+1);
+                memset(vis, 0, sizeof vis);
+                for (int i=1;i<=n;i++) {
+                        gao(p[i].id, father[p[i].id]);
+                }
+                int ans = n;
+                for (int i=0;i<=maxw;i++)
+                        ans =  min(ans, f[1][i]);
+                printf("%d\n", ans);
+        }
+}
diff --git a/HDOJ/5291_autoAC.cpp b/HDOJ/5291_autoAC.cpp
new file mode 100644
index 0000000..be1d4ef
--- /dev/null
+++ b/HDOJ/5291_autoAC.cpp
@@ -0,0 +1,59 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#include<cstdio>
+using namespace std;
+#define ll long long
+int dp[90000],sum[2][90000];
+int mod = 1000000007;
+int modx = -mod;
+int num[300];
+int main(){
+    int t,n;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        int total = 0;
+        for(int i = 1; i <= n; i++){
+            scanf("%d",&num[i]);
+            total += num[i];
+        }
+        if(total & 1) total++;
+        memset(dp,0,sizeof(dp));
+        memset(sum,0,sizeof(sum));
+        dp[total] = 1;
+        int tt = total*2;
+        for(int i = 1; i <= n; i++){
+            sum[0][0] = dp[0];
+            sum[1][0] = 0;
+            for(int j = 1;j <= tt; j++){
+                sum[0][j] = sum[0][j-1];
+                sum[1][j] = sum[1][j-1];
+                sum[j&1][j] += dp[j];
+                sum[j&1][j] %= modx;
+            }
+            ll ans = 0;
+            for(int j = 0;j <= num[i]; j++){
+                ans += (ll)dp[j]*((num[i]-j)/2+1);
+                ans %= mod;
+            }
+            int p = (num[i]&1)^1;
+            int res = ans;
+            for(int j = 0;j <= tt; j++){
+                dp[j] = res;
+                int u = j-num[i]-1;
+                u = max(u,0);
+                res += (sum[p][j+1+num[i]] - sum[p][j])%mod;
+                res %= mod;
+                p ^= 1;
+                res -= (sum[p][j] - sum[p][u])%mod;
+                res %= mod;
+            }
+        }
+        int res = dp[total];
+        res %= mod;
+        res = (res+mod)%mod;
+        cout<<res<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5292_autoAC.cpp b/HDOJ/5292_autoAC.cpp
new file mode 100644
index 0000000..602ee60
--- /dev/null
+++ b/HDOJ/5292_autoAC.cpp
@@ -0,0 +1,53 @@
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <set>
+#include <algorithm>
+using namespace std;
+#define ll long long
+int main(){
+    int t;
+    cin>>t;
+    int cas=0;
+    while(t--){
+        cas++;
+        int ans=0;
+        for(int i=1;i<=24;i++){
+            char color[2];
+            scanf("%s",color);
+            if(color[0]=='w'||color[0]=='y'){
+                switch(i){
+                    case 5:
+                    case 7:
+                    case 9:
+                    case 12:
+                    case 14:
+                    case 16:
+                    case 21:
+                    case 24:
+                        ans++;
+                        break;
+                    case 6:
+                    case 8:
+                    case 10:
+                    case 11:
+                    case 13:
+                    case 15:
+                    case 22:
+                    case 23:
+                        ans+=2;
+                        break;
+                }
+            }
+        }
+        printf("Case #%d: ",cas);
+        if(ans%3==0){
+            printf("YES\n");
+        }else{
+            printf("NO\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5293_autoAC.cpp b/HDOJ/5293_autoAC.cpp
new file mode 100644
index 0000000..c863947
--- /dev/null
+++ b/HDOJ/5293_autoAC.cpp
@@ -0,0 +1,74 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include<stdio.h>
+#include<string.h>
+#include<iostream>
+#include<vector>
+#include<math.h>
+#include<algorithm>
+#define ll int
+using namespace std;
+const int maxn = 100000+10;
+int t,n,m;
+vector<int> g[maxn];
+int fa[maxn][25],deep[maxn];
+int cnt,l[maxn],r[maxn];
+vector<int> lis[maxn];
+void dfs(int u,int f,int d){
+    l[u]=++cnt,deep[u]=d,fa[u][0]=f;
+    for(int i=0;i<g[u].size();i++){
+        int v=g[u][i];
+        if(v==f) continue;
+        dfs(v,u,d+1);
+    }
+    r[u]=++cnt;
+}
+void init(){
+    cnt=0; dfs(1,0,1);
+    for(int i=1;i<=20;i++) for(int j=1;j<=n;j++) fa[j][i]=fa[fa[j][i-1]][i-1];
+    for(int i=1;i<=n;i++) lis[i].clear();
+}
+int lca(int x, int y) {
+    if (deep[x] < deep[y]) swap(x, y);
+    int delta = deep[x] - deep[y];
+    for(int j=0;j<=20;j++) if ((1<<j) & delta) x = fa[x][j];
+    if (x == y) return x;
+    for(int j=20;j>=0;j--) if (fa[x][j] != fa[y][j]) x = fa[x][j], y = fa[y][j];
+    return fa[x][0];
+}
+int st[maxn],en[maxn],quan[maxn];
+int dp[maxn],sum[maxn],sd[maxn<<1],ss[maxn<<1];
+int lowbit(int x) { return x&(-x); }
+void Add(int id,int x,int c[]) { for(int i=id;i<=2*n;i+=lowbit(i)) c[i]+=x; }
+int Sum(int id,int c[]) { int tmp=0; for(int i=id;i>0;i-=lowbit(i)) tmp+=c[i]; return tmp; }
+void dfs2(int u,int f){
+    for(int i=0;i<g[u].size();i++){
+        int v=g[u][i];
+        if(v==f) continue;
+        dfs2(v,u);
+        sum[u]+=dp[v];
+    }
+    dp[u]=sum[u];
+    for(int i=0;i<lis[u].size();i++){
+        int id=lis[u][i],s=st[id],t=en[id],w=quan[id];
+        int tmp=Sum(l[s],ss)+Sum(l[t],ss)-Sum(l[s],sd)-Sum(l[t],sd)+sum[u];
+        dp[u]=max(dp[u],tmp+w);
+    }
+    Add(l[u],dp[u],sd),Add(r[u],-dp[u],sd),Add(l[u],sum[u],ss),Add(r[u],-sum[u],ss);
+}
+int main(){
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&m);
+        for(int i=1;i<=n;i++) g[i].clear();
+        for(int i=1;i<n;i++) { int u,v; scanf("%d%d",&u,&v); g[u].push_back(v); g[v].push_back(u); }
+        init();
+        for(int i=1;i<=m;i++){
+            scanf("%d%d%d",&st[i],&en[i],&quan[i]);
+            int tmp=lca(st[i],en[i]); lis[tmp].push_back(i);
+        }
+        memset(dp,0,sizeof(dp)); memset(sum,0,sizeof(sum)); memset(sd,0,sizeof(sd)); memset(ss,0,sizeof(ss));
+        dfs2(1,0);
+        printf("%d\n",dp[1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5294_autoAC.cpp b/HDOJ/5294_autoAC.cpp
new file mode 100644
index 0000000..7449f72
--- /dev/null
+++ b/HDOJ/5294_autoAC.cpp
@@ -0,0 +1,187 @@
+#include<iostream>
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<queue>
+using namespace std;
+typedef long long LL;
+const int INF=0x3f3f3f3f;
+const int MAXN=2010;
+int N,M;
+struct Edge{
+    int from,to,cap,flow;
+};
+struct Dinic{
+    int n,m,s,t;            
+    vector<Edge> edges;   
+    vector<int> G[MAXN];    
+    bool vis[MAXN];         
+    int d[MAXN];            
+    int cur[MAXN];          
+    void clear_all(int n){
+        for(int i=0;i<n;i++) G[i].clear();
+        edges.clear();
+    }
+    void clear_flow(){
+        int len=edges.size();
+        for(int i=0;i<len;i++) edges[i].flow=0;
+    }
+    void add_edge(int from,int to,int cap){
+        edges.push_back((Edge){from,to,cap,0});
+        edges.push_back((Edge){to,from,0,0});
+        m=edges.size();
+        G[from].push_back(m-2);
+        G[to].push_back(m-1);
+    }
+    bool BFS(){
+        memset(vis,0,sizeof(vis));
+        queue<int> q;
+        q.push(s);
+        d[s]=0;
+        vis[s]=1;
+        while(!q.empty()){
+            int x=q.front();
+            q.pop();
+            int len=G[x].size();
+            for(int i=0;i<len;i++){
+                Edge& e=edges[G[x][i]];
+                if(!vis[e.to]&&e.cap>e.flow){
+                    vis[e.to]=1;
+                    d[e.to]=d[x]+1;
+                    q.push(e.to);
+                }
+            }
+        }
+        return vis[t];
+    }
+    int DFS(int x,int a){
+        if(x==t||a==0) return a;
+        int flow=0,f,len=G[x].size();
+        for(int& i=cur[x];i<len;i++){
+            Edge& e=edges[G[x][i]];
+            if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
+                e.flow+=f;
+                edges[G[x][i]^1].flow-=f;
+                flow+=f;
+                a-=f;
+                if(a==0) break;
+            }
+        }
+        return flow;
+    }
+    int maxflow(int s,int t){
+        this->s=s;
+        this->t=t;
+        int flow=0;
+        while(BFS()){
+            memset(cur,0,sizeof(cur));
+            flow+=DFS(s,INF);
+        }
+        return flow;
+    }
+    int mincut(){   
+        int ans=0;
+        int len=edges.size();
+        for(int i=0;i<len;i++){
+            Edge& e=edges[i];
+            if(vis[e.from]&&!vis[e.to]&&e.cap>0) ans++;
+        }
+        return ans;
+    }
+    void reduce(){
+        int len=edges.size();
+        for(int i=0;i<len;i++) edges[i].cap-=edges[i].flow;
+    }
+}solver;
+int d[MAXN];
+vector<int> p[MAXN];
+struct HeapNode{
+    int u,d;
+    bool operator < (const HeapNode& rhs) const{
+        return d>rhs.d;
+    }
+};
+struct Edge2{
+    int u,v,dist;
+};
+struct Dijkstra{
+    int n,m;
+    vector<Edge2> edges;
+    vector<int> G[MAXN];
+    bool done[MAXN];
+    void init(int n){
+        this->n=n;
+        for(int i=0;i<n;i++) G[i].clear();
+        edges.clear();
+    }
+    void add_edge(int u,int v,int dist){
+        edges.push_back((Edge2){u,v,dist});
+        m=edges.size();
+        G[u].push_back(m-1);
+    }
+    void dijkstra(int s){
+        priority_queue<HeapNode> q;
+        for(int i=0;i<n;i++) p[i].clear();
+        for(int i=0;i<n;i++) d[i]=INF;
+        d[s]=0;
+        memset(done,0,sizeof(done));
+        q.push((HeapNode){s,0});
+        while(!q.empty()){
+            HeapNode x=q.top();
+            q.pop();
+            int u=x.u;
+            if(done[u]) continue;
+            done[u]=true;
+            int L=G[u].size();
+            for(int i=0;i<L;i++){
+                Edge2& e=edges[G[u][i]];
+                if(d[e.v]>d[u]+e.dist){
+                    d[e.v]=d[u]+e.dist;
+                    p[e.v].clear();
+                    p[e.v].push_back(u);
+                    q.push((HeapNode){e.v,d[e.v]});
+                }
+                else if(d[e.v]==d[u]+e.dist){
+                    p[e.v].push_back(u);
+                    q.push((HeapNode){e.v,d[e.v]});
+                }
+            }
+        }
+    }
+}solver2;
+int num[MAXN];
+int dfs(int u){
+    if(u==0) return 0;
+    if(num[u]!=INF) return num[u];
+    int len=p[u].size();
+    for(int i=0;i<len;i++){
+        int fa=p[u][i];
+        solver.add_edge(fa,u,1);
+        solver.add_edge(u,fa,1);
+        num[u]=min(num[u],dfs(fa)+1);
+    }
+    return num[u];
+}
+int main(){
+    while(scanf("%d%d",&N,&M)!=EOF){
+        solver2.init(N+1);
+        int u,v,t;
+        for(int i=0;i<M;i++){
+            scanf("%d%d%d",&u,&v,&t);
+            u--;
+            v--;
+            solver2.add_edge(u,v,t);
+            solver2.add_edge(v,u,t);
+        }
+        solver2.dijkstra(0);
+        memset(num,INF,sizeof(num));
+        solver.clear_all(N+1);
+        int n=dfs(N-1);
+        solver.maxflow(0,N-1);
+        int ans1=solver.mincut(),ans2=M-num[N-1];
+        printf("%d %d\n",ans1,ans2);
+    }
+    return 0;
+}
diff --git a/HDOJ/5295_autoAC.cpp b/HDOJ/5295_autoAC.cpp
new file mode 100644
index 0000000..31071db
--- /dev/null
+++ b/HDOJ/5295_autoAC.cpp
@@ -0,0 +1,130 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-6;
+int sgn(double x){
+if(fabs(x) <= eps) return 0;
+return x > 0 ? 1 : -1;
+}
+struct P{
+double x , y;
+P(double _x = 0,double _y = 0){
+x = _x , y =  _y;
+}
+void set(double _x,double _y){
+x = _x , y = _y;
+}
+void out(){
+printf("%.6lf %.6lf\n",x,y);
+}
+P operator + (P b){
+return P(x+b.x,y+b.y);
+}
+P operator - (P b){
+return P(x-b.x,y-b.y);
+}
+P operator / (double k){
+return P(x/k , y/k);
+}
+bool operator == (const P&b) const{
+return sgn(x - b.x) == 0 && sgn(y - b.y) == 0;
+}
+double lenq(){
+return x*x + y*y;
+}
+double len(){
+return sqrt(lenq());
+}
+};
+double dis(P a,P b){
+return (a-b).len();
+}
+struct Cir{
+P o;
+double r;
+Cir(P _o,double _r = 0){
+o = _o , r = _r;
+}
+void set(P _o,double _r){
+o = _o , r = _r;
+}
+bool operator == (const Cir&b) const{
+return o == b.o && sgn(r - b.r) == 0;
+}
+};
+void c2point(Cir c1,Cir c2,P &rp1,P &rp2){
+if(c1 == c2){
+rp1 = c1.o + P(0,c1.r);
+rp2 = c1.o - P(0,c1.r);
+return;
+}
+P p1 = c1.o , p2 = c2.o;
+double r1 = c1.r , r2 = c2.r;
+double a = p2.x - p1.x , b = p2.y - p1.y , r = (a*a + b*b + r1*r1 - r2*r2) / 2;
+double tmp;
+if(a == 0 && b != 0){
+rp1.y = rp2.y = r / b;
+tmp = r1 * r1 - rp1.y * rp1.y;
+if(sgn(tmp) <= 0) tmp = 0;
+rp1.x = sqrt(tmp);
+rp2.x = -rp1.x;
+}
+else if(a != 0 && b == 0){
+rp1.x = rp2.x = r / a;
+tmp = r1 * r1 - rp1.x * rp1.x;
+if(sgn(tmp) <= 0) tmp = 0;
+rp1.y = sqrt(tmp);
+rp2.y = -rp1.y;
+}
+else if(a != 0 && b != 0){
+double delta = b*b*r*r - (a*a + b*b) * (r*r - r1*r1*a*a);
+if(sgn(delta) <= 0) delta = 0;
+rp1.y = (b*r + sqrt(delta)) / (a*a + b*b);
+rp2.y = (b*r - sqrt(delta)) / (a*a + b*b);
+rp1.x = (r - b*rp1.y) / a;
+rp2.x = (r - b*rp2.y) / a;
+}
+rp1.x += p1.x , rp1.y += p1.y;
+rp1.x += p1.x , rp2.y += p1.y;
+}
+int T;
+double AB , BC , CD , DA , EF;
+P A , B , C , D , A2 , G;
+void graph_construct(){
+C.set(0,0);
+B.set(BC,0);
+Cir O1(C,DA) , O2(B,2 * EF);
+P discard;
+c2point(O1,O2,A2,discard);
+G = A2 + (B - C);
+O1.set(C,CD);O2.set(G,AB);
+c2point(O1,O2,D,discard);
+A = D + (C - A2);
+}
+const double eps2 = 1e-4;
+int sgn2(double x){
+if(fabs(x) <= eps2) return 0;
+return 1;
+}
+void spj(){
+bool ff = true;
+if(sgn2(AB - dis(A,B)) != 0) ff = false;
+if(sgn2(BC - dis(B,C)) != 0) ff = false;
+if(sgn2(CD - dis(C,D)) != 0) ff = false;
+if(sgn2(DA - dis(D,A)) != 0) ff = false;
+if(sgn2(EF - dis((A+B)/2,(C+D)/2)) != 0) ff = false;
+}
+int main(){
+scanf("%d",&T);
+for(int _=1;_<=T;++_){
+scanf("%lf%lf%lf%lf%lf",&AB,&BC,&CD,&DA,&EF);
+graph_construct();
+printf("Case #%d:\n",_);
+A.out();B.out();C.out();D.out();
+spj();
+}
+return 0;
+}
diff --git a/HDOJ/5296_autoAC.cpp b/HDOJ/5296_autoAC.cpp
new file mode 100644
index 0000000..1027fb1
--- /dev/null
+++ b/HDOJ/5296_autoAC.cpp
@@ -0,0 +1,156 @@
+#include <map>
+#include <set>
+#include <stack>
+#include <queue>
+#include <cmath>
+#include <ctime>
+#include <vector>
+#include <cstdio>
+#include <cctype>
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define INF 0x3f3f3f3f
+#define inf (-((LL)1<<40))
+#define lson k<<1, L, (L + R)>>1
+#define rson k<<1|1,  ((L + R)>>1) + 1, R
+#define mem0(a) memset(a,0,sizeof(a))
+#define mem1(a) memset(a,-1,sizeof(a))
+#define mem(a, b) memset(a, b, sizeof(a))
+#define rep(i, a, b) for(int i = (a); i <= (b); i ++)
+#define dec(i, a, b) for(int i = (a); i >= (b); i --)
+template<class T> T MAX(T a, T b) { return a > b ? a : b; }
+template<class T> T MIN(T a, T b) { return a < b ? a : b; }
+template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
+template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }
+typedef long long LL;
+const int MAXN = 100000 + 100;
+const int MAXM = 2000000 + 100;
+const double eps = 1e-8;
+LL MOD = 1000000007;
+struct Edge {
+    int v, w;
+    Edge(int _v = 0, int _w = 0) {
+        v = _v; w = _w;
+    }
+};
+struct LCA {
+    int idx[MAXN << 1];
+    int dep[MAXN << 1];
+    int dp[MAXN << 1][20];
+    int K[MAXN << 1];
+    int node_cnt;
+    vector<Edge>G[MAXN];
+    int P[MAXN];
+    int dis[MAXN];
+    void init(int n) {
+        mem0(dep); mem0(K);
+        node_cnt = 0;
+        rep (i, 0, n) G[i].clear();
+    }
+    void add_edge(int u, int v, int w) {
+        G[u].push_back(Edge(v, w));
+        G[v].push_back(Edge(u, w));
+    }
+    void dfs(int u, int fa, int height, int dist) {
+        idx[++node_cnt] = u;
+        dep[node_cnt] = height;
+        P[u] = node_cnt;
+        dis[u] = dist;
+        int sz = G[u].size();
+        rep (i, 0, sz - 1) {
+            int v = G[u][i].v;
+            if(v == fa) continue;
+            dfs(v, u, height + 1, dist + G[u][i].w);
+            idx[++node_cnt] = u;
+            dep[node_cnt] = height;
+        }
+    }
+    void init_st_table() {
+        dfs(1, -1, 0, 0);
+        int n = node_cnt;
+        rep (i, 1, n) {
+            dp[i][0] = i;
+            while((1 << (K[i] + 1)) <= i) K[i] ++;
+        }
+        for(int j = 1; (1 << j) <= n; j ++) {
+            for(int i = 1; i + (1 << j) - 1 <= n; i ++) {
+                int l_pos = dp[i][j - 1], r_pos = dp[i + (1 << (j - 1))][j - 1];
+                dp[i][j] = dep[l_pos] < dep[r_pos] ? l_pos : r_pos;
+            }
+        }
+    }
+    int rmq_query(int L, int R) {
+        if(L > R) swap(L, R);
+        int len = R - L + 1, k = K[len];
+        return dep[dp[L][k]] < dep[dp[R - (1 << k) + 1][k]] ? dp[L][k] : dp[R - (1 << k) + 1][k];
+    }
+    int lca_query(int u, int v) {
+        int id = rmq_query(P[u], P[v]);
+        return idx[id];
+    }
+}lca;
+struct SegTree  {
+    int s[MAXN << 3];
+    void update(int k, int L, int R, int p, int v) {
+        if(L == R) { s[k] = v; return ; }
+        if(((L + R) >> 1) >= p)  update(lson, p, v);
+        else update(rson, p, v);
+        s[k] = s[k << 1] + s[k << 1 | 1];
+    }
+    int query_sum(int k, int L, int R, int p) {
+        if(R <= p) return s[k];
+        if( ((L + R) >> 1) >= p ) return query_sum(lson, p);
+        return s[k << 1] + query_sum(rson, p);
+    }
+    int query_pos(int k, int L, int R, int x) {
+        if(L == R) return L;
+        if(s[k << 1] >= x) return query_pos(lson, x);
+        return query_pos(rson, x - s[k << 1]);
+    }
+}st;
+int t, n, m, cas = 0;
+int u, v, w;
+bool vis[MAXN << 1];
+int main()
+{
+    cin >> t;
+    while(t--) {
+        scanf("%d %d", &n, &m);
+        lca.init(n);
+        rep (i, 2, n) {
+            scanf("%d %d %d", &u, &v, &w);
+            lca.add_edge(u, v, w);
+        }
+        lca.init_st_table();
+        mem0(st.s);
+        mem0(vis);
+        int ans = 0;
+        printf("Case #%d:\n", ++cas);
+        while(m --) {
+            scanf("%d %d", &u, &v);
+            if( (u == 1 && !vis[v]) || (u == 2 && vis[v]) ) {
+                vis[v] = !vis[v];
+                if(u == 2) st.update(1, 1, lca.node_cnt, lca.P[v], 0);
+                if( st.s[1] ) {
+                    int x, y;
+                    int sum = st.query_sum(1, 1, lca.node_cnt, lca.P[v]);
+                    if( !sum || sum == st.s[1] ) x = 1, y = st.s[1];
+                    else x = sum, y = sum + 1;
+                    x = lca.idx[st.query_pos(1, 1, lca.node_cnt, x)];
+                    y = lca.idx[st.query_pos(1, 1, lca.node_cnt, y)];
+                    int xv = lca.lca_query(x, v);
+                    int yv = lca.lca_query(y, v);
+                    int xy = lca.lca_query(x, y);
+                    ans += (u == 1 ? 1 : -1) * (lca.dis[v] - lca.dis[xv] - lca.dis[yv] + lca.dis[xy]);
+                }
+                else ans = 0;
+                if(u == 1) st.update(1, 1, lca.node_cnt, lca.P[v], 1);
+            }
+            printf("%d\n", ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5297_autoAC.cpp b/HDOJ/5297_autoAC.cpp
new file mode 100644
index 0000000..168c547
--- /dev/null
+++ b/HDOJ/5297_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+using namespace std;
+int prime[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67};
+int cnt[100]={19,0,1,1,1,1,2,1,1,1,2,1,2,1,2,2,1,1,2,1,2,2,2,1,2,1,2,1,2,1,3,1,1,2,2,2,2,1,2,2
+,2,1,3,1,2,2,2,1,2,1,2,2,2,1,2,2,2,2,2,1,3,1,2,2,1};
+long long considrt[6000000],nconsidrt;
+void GetConsider(int r)
+{
+    nconsidrt=0;
+    int i,j,sz;
+    for(i=0;prime[i]<=r;i++)
+    {
+        sz=nconsidrt;
+        for(j=0;j<sz;j++)
+        {
+            if(considrt[j]*prime[i]<=63)
+                considrt[nconsidrt++]=considrt[j]*prime[i];
+        }
+        considrt[nconsidrt++]=prime[i];
+    }
+}
+long long cal(long long x)
+{
+    long long ret(0);
+    for(int i=0;i<nconsidrt;i++)
+    {
+        if(cnt[considrt[i]]&1)
+            ret+=(long long)pow(x+0.5,1.0/considrt[i])-1;
+        else
+            ret-=(long long)pow(x+0.5,1.0/considrt[i])-1;
+    }
+    return x-ret-1;
+}
+long long solve(long long n,int r)
+{
+    GetConsider(r);
+    long long ans = n;
+    while(1)
+    {
+        long long temp = cal(ans);
+        if(temp == n)
+            break;
+        ans += n - temp; 
+    }
+    return ans;
+}
+int main()
+{
+    int ncase,r;
+    long long n;
+    scanf("%d",&ncase);
+    while(ncase--)
+    {
+        scanf("%I64d%d",&n,&r);
+        printf("%I64d\n",solve(n,r));
+    }
+    return 0;
+}
diff --git a/HDOJ/5298_autoAC.cpp b/HDOJ/5298_autoAC.cpp
new file mode 100644
index 0000000..1f3db43
--- /dev/null
+++ b/HDOJ/5298_autoAC.cpp
@@ -0,0 +1,45 @@
+#include <stdio.h>
+typedef long long LL ;
+struct Node {
+    LL x , y , z , d ;
+} a[100] , b[10] ;
+int n , m , p , q ;
+LL f ( LL x ) {
+    return ( LL ) x * x ;
+}
+bool calc ( int x , int y , int z ) {
+    bool t = 0 ;
+    for ( int i = 0 ; i < n ; ++ i ) if ( a[i].x * x + a[i].y * y + a[i].z * z + a[i].d > 0 ) t ^= 1 ;
+    for ( int i = 0 ; i < m ; ++ i ) if ( f ( b[i].d ) > f ( b[i].x - x ) + f ( b[i].y - y ) + f ( b[i].z - z ) ) t ^= 1 ;
+    return t ;
+}
+void solve () {
+    int x , y , z , ok = 1 , mark = -1 ;
+    scanf ( "%d%d%d%d" , &n , &m , &p , &q ) ;
+    for ( int i = 0 ; i < n ; ++ i ) scanf ( "%lld%lld%lld%lld" , &a[i].x , &a[i].y , &a[i].z , &a[i].d ) ;
+    for ( int i = 0 ; i < m ; ++ i ) scanf ( "%lld%lld%lld%lld" , &b[i].x , &b[i].y , &b[i].z , &b[i].d ) ;
+    for ( int i = 0 ; i < p ; ++ i ) {
+        scanf ( "%d%d%d" , &x , &y , &z ) ;
+        if ( !ok ) continue ;
+        bool tmp = calc ( x , y , z ) ;
+        if ( mark == -1 ) mark = tmp ;
+        else if ( mark != tmp ) ok = 0 ;
+    }
+    if ( !ok ) puts ( "Impossible" ) ;
+    for ( int i = 0 ; i < q ; ++ i ) {
+        scanf ( "%d%d%d" , &x , &y , &z ) ;
+        if ( !ok ) continue ;
+        bool tmp = calc ( x , y , z ) ;
+        if ( mark == -1 ) puts ( "Both" ) ;
+        else puts ( mark == tmp ? "Y" : "R" ) ;
+    }
+}
+int main () {
+    int T ;
+    scanf ( "%d" , &T ) ;
+    for ( int i = 1 ; i <= T ; ++ i ) {
+        if ( i > 1 ) puts ( "" ) ;
+        solve () ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5299_autoAC.cpp b/HDOJ/5299_autoAC.cpp
new file mode 100644
index 0000000..5f5c7f7
--- /dev/null
+++ b/HDOJ/5299_autoAC.cpp
@@ -0,0 +1,76 @@
+#include<map>
+#include<string>
+#include<cstring>
+#include<cstdio>
+#include<cstdlib>
+#include<cmath>
+#include<queue>
+#include<vector>
+#include<iostream>
+#include<algorithm>
+#include<bitset>
+#include<climits>
+#include<list>
+#include<iomanip>
+#include<stack>
+#include<set>
+using namespace std;
+typedef long long ll;
+struct Point
+{
+    int x,y,r;
+}point[20010];
+bool cmp(Point a,Point b)
+{
+    return a.r<b.r;
+}
+struct Edge
+{
+    int to,next;
+}edge[20010];
+int head[20010],tail;
+void add(int from,int to)
+{
+    edge[tail].to=to;
+    edge[tail].next=head[from];
+    head[from]=tail++;
+}
+int dfs(int from)
+{
+    int ans=0;
+    for(int i=head[from];i!=-1;i=edge[i].next)
+        ans^=dfs(edge[i].to)+1;
+    return ans;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int n;
+        scanf("%d",&n);
+        for(int i=0;i<n;i++)
+            scanf("%d%d%d",&point[i].x,&point[i].y,&point[i].r);
+        sort(point,point+n,cmp);
+        tail=0;
+        memset(head,-1,sizeof(head));
+        for(int i=0;i<n;i++)
+        {
+            bool flag=0;
+            for(int j=i+1;j<n;j++)
+                if(ll(point[j].r*point[j].r)>ll(point[i].x-point[j].x)*(point[i].x-point[j].x)+(point[i].y-point[j].y)*(point[i].y-point[j].y))
+                {
+                    flag=1;
+                    add(j,i);
+                    break;
+                }
+            if(!flag)
+                add(n,i);
+        }
+        if(dfs(n)!=0)
+            puts("Alice");
+        else
+            puts("Bob");
+    }
+}
diff --git a/HDOJ/5301_autoAC.cpp b/HDOJ/5301_autoAC.cpp
new file mode 100644
index 0000000..5072807
--- /dev/null
+++ b/HDOJ/5301_autoAC.cpp
@@ -0,0 +1,33 @@
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+using namespace std;
+typedef long long ll;
+int main(void)  {      
+    ll n, m, x, y;
+    while (scanf ("%I64d%I64d%I64d%I64d", &n, &m, &x, &y) == 4) {
+        if (n > m)  {
+            swap (n, m);    swap (x, y);
+        }
+        if (x > n - x + 1)  {
+            x = n - x + 1;
+        }
+        if (y > m - y + 1)  {
+            y = m - y + 1;
+        }
+        ll hm = (m + 1) / 2, hn = (n + 1) / 2;
+        ll ans = min (hm, hn);
+        if (m == n) {
+            if (m % 2 == 1) {
+                if (x == hn && y == hm) ans--;
+            }
+        }
+        else    {
+            ll t = min (y, n - x);
+            ans = max (ans, t);
+            ans = min (ans, hm);
+        }
+        printf ("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5302_autoAC.cpp b/HDOJ/5302_autoAC.cpp
new file mode 100644
index 0000000..a15511e
--- /dev/null
+++ b/HDOJ/5302_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+#include<algorithm>
+#include<cstring>
+using namespace std;
+#define sf scanf
+int T;
+int a[5],b[5];
+int d[1000005];
+int main()
+{
+    sf("%d",&T);
+    while(T--)
+    {
+        for(int i = 0;i<3;i++)sf("%d",a+i);
+        for(int i = 0;i<3;i++)sf("%d",b+i);
+        int sum = 0;
+        for(int i = 0;i<3;i++)sum+=a[i];
+        if( (a[1]&1) || (b[1]&1) )
+        {
+            puts("-1");
+            continue;
+        }
+        if(sum==4)
+        {
+            puts("4\n1 2 0\n1 3 0\n2 3 1\n3 4 1");
+            continue;
+        }
+        printf("%d\n",a[1]/2+a[2]+b[1]/2+b[2]);
+        int t = 1;
+        while(a[2]!=-1){printf("%d %d 0\n",t,t+1);t++;a[2]--;}t++;
+        while(a[1]!=2){printf("%d %d 0\n",t,t+1);t+=2;a[1]-=2;}
+            int tt = 0;
+            for(int i = 1;i<=sum;i+=2) d[tt++] = i;
+            for(int i = 2;i<=sum;i+=2)d[tt++] = i;
+        t = 0;
+        while(b[2]!=-1){printf("%d %d 1\n",min(d[t],d[t+1]),max(d[t],d[t+1]));t++;b[2]--;}t++;
+        while(b[1]!=2){printf("%d %d 1\n",min(d[t],d[t+1]),max(d[t],d[t+1]));t+=2;b[1]-=2;}
+    }
+}
diff --git a/HDOJ/5303_autoAC.cpp b/HDOJ/5303_autoAC.cpp
new file mode 100644
index 0000000..e22265d
--- /dev/null
+++ b/HDOJ/5303_autoAC.cpp
@@ -0,0 +1,54 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+int t,n,m,l,num1,num2,cnt;
+long long left[500010],right[500010];
+long long sum1[500010],sum2[500010];
+long long apple[500010];
+long long ans;
+int main()
+{
+    int i,j,k,a,b;
+    scanf("%d",&t);
+    while(t--)
+    {
+        cnt=0;num1=num2=0;
+        memset(apple,0,sizeof(apple));
+        memset(sum1,0,sizeof(sum1));
+        memset(sum2,0,sizeof(sum2));
+        scanf("%d%d%d",&l,&n,&k);
+        for(i=0;i<n;i++)
+        {
+            scanf("%d%d",&a,&b);
+            for(j=1;j<=b;j++){
+                apple[++cnt]=a;  
+            }
+        }
+        k=min(k,cnt);
+        for(i=1;i<=cnt;i++){
+            if(apple[i]*2<=l){
+               left[++num1]=apple[i]; 
+            }
+            else{
+                right[++num2]=l-apple[i];
+            }
+        }
+        sort(left+1,left+num1+1); 
+        sort(right+1,right+num2+1);
+        for(i=1;i<=num1;i++){
+            if(i<=k) sum1[i]=left[i];   
+            else sum1[i]=sum1[i-k]+left[i]; 
+        }
+        for(i=1;i<=num2;i++){
+            if(i<=k) sum2[i]=right[i];
+            else sum2[i]=sum2[i-k]+right[i];
+        }
+        ans=(long long)(sum1[num1]+sum2[num2])*2; 
+        for(i=0;i<=num1&&i<=k;i++){
+            ans=min(ans,(long long)(l+2*sum1[num1-i]+2*sum2[num2-(k-i)])); 
+        }
+        printf("%lld\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5304_autoAC.cpp b/HDOJ/5304_autoAC.cpp
new file mode 100644
index 0000000..b8975a5
--- /dev/null
+++ b/HDOJ/5304_autoAC.cpp
@@ -0,0 +1,88 @@
+#include<iostream>
+#include<cmath>
+#include<cstring>
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+const int mo=998244353;
+struct atom{
+    int x,y;
+};
+atom operator - (const atom k1,const atom k2){
+    return (atom){(k1.x-k2.x+mo)%mo,(k1.y-k2.y+mo)%mo};
+}
+atom operator * (const atom k1,const int k2){
+    return (atom){1ll*k1.x*k2%mo,1ll*k1.y*k2%mo};
+}
+int x[20][20],n,m,A[20][20],dp[1<<16][17],f[1<<16],pd[20];
+int gauss(int n){
+    int pd=1; n--;
+    for (int i=1;i<=n;i++)
+        for (int j=1;j<=n;j++) x[i][j]=(x[i][j]+mo)%mo;
+    for (int i=1;i<=n;i++){
+        int r=0;
+        for (int j=i;j<=n;j++) if (x[j][i]){r=j; break;}
+        for (int j=1;j<=n;j++) swap(x[i][j],x[r][j]);
+        if (r!=i) pd=-pd;
+        for (int j=i+1;j<=n;j++){
+            int k1=x[i][i],k2=x[j][i];
+            atom xx=(atom){1,0},y=(atom){0,1};
+            while (k2){
+                int k4=k1/k2;
+                atom z=y; y=xx-y*k4; xx=z;
+                k4=k2; k2=k1%k2; k1=k4; pd=-pd;
+            }
+            for (int k=1;k<=n;k++){
+                int k3=x[i][k],k4=x[j][k];
+                x[i][k]=(1ll*xx.x*k3+1ll*xx.y*k4)%mo;
+                x[j][k]=(1ll*y.x*k3+1ll*y.y*k4)%mo;
+            }
+        }
+    }
+    for (int i=1;i<=n;i++) pd=1ll*pd*x[i][i]%mo;
+    return (pd+mo)%mo;
+}
+int solve(){
+    memset(A,0x00,sizeof A);
+    for (;m;m--){
+        int k1,k2; scanf("%d%d",&k1,&k2); A[k1][k2]=1; A[k2][k1]=1;
+    }
+    memset(f,0x00,sizeof f);
+    for (int s=1;s<=n;s++){
+        memset(dp,0x00,sizeof dp);
+        dp[(1<<s-1)][s]=1;
+        for (int i=1;i<(1<<n);i++)
+            for (int j=1;j<=n;j++)
+                if (dp[i][j]){
+                    for (int k=s+1;k<=n;k++)
+                        if ((i&(1<<k-1))==0&&A[j][k])
+                            dp[i|(1<<k-1)][k]=(dp[i|(1<<k-1)][k]+dp[i][j])%mo;
+                    if (A[j][s]) f[i]=(f[i]+dp[i][j])%mo;
+                }
+    }
+    int ans=0;
+    for (int i=1;i<=n;i++)
+        for (int j=i+1;j<=n;j++)
+            if (A[i][j]) f[(1<<i-1)|(1<<j-1)]=(f[(1<<i-1)|(1<<j-1)]-1+mo)%mo;
+    int inv2=(mo+1)/2;
+    for (int i=0;i<(1<<n);i++) f[i]=1ll*f[i]*inv2%mo;
+    for (int now=0;now<(1<<n);now++) if (f[now]){
+        for (int i=1;i<=n;i++) pd[i]=0;
+        for (int i=1;i<=n;i++) if (now&(1<<i-1)) pd[i]=1;
+        int sign=1;
+        for (int i=1;i<=n;i++) if (pd[i]==0) pd[i]=++sign;
+        for (int i=1;i<=n;i++)
+            for (int j=1;j<=n;j++) x[i][j]=0;
+        for (int i=1;i<=n;i++)
+            for (int j=1;j<=n;j++)
+                if (A[i][j]&&pd[i]!=pd[j]){
+                    x[pd[i]][pd[j]]--; x[pd[i]][pd[i]]++;
+                }
+        ans=(ans+1ll*f[now]*gauss(sign))%mo;
+    }
+    return ans;
+}
+int main(){
+    while (scanf("%d%d",&n,&m)!=EOF) printf("%d\n",solve());
+    return 0;
+}
diff --git a/HDOJ/5305_autoAC.cpp b/HDOJ/5305_autoAC.cpp
new file mode 100644
index 0000000..a8f13a9
--- /dev/null
+++ b/HDOJ/5305_autoAC.cpp
@@ -0,0 +1,70 @@
+#include<iostream>
+#include<algorithm>
+#include<cstdio>
+#include<cstring>
+#include<string>
+using namespace std;
+int ans;
+int n,m;
+int cnt[10];
+struct node{
+    int x,y;
+    void in(){
+        scanf("%d%d",&x,&y);
+        if(x>y)swap(x,y);
+        cnt[x]++;
+        cnt[y]++;
+    }
+    friend bool operator < (node a,node b){
+        if(a.x==b.x)return a.y<b.y;
+        return a.x<b.x;
+    }
+}p[30];
+void dfs(int t,int on[],int off[]){
+    if(t==m){
+        ans++;
+        return ;
+    }
+    int x=p[t].x;
+    int y=p[t].y;
+    on[x]++ , on[y]++;
+    if(on[x]<=cnt[x]/2 && off[x]<=cnt[x]/2 && on[y]<=cnt[y]/2 && off[y]<=cnt[y]/2 ){
+        dfs(t+1,on,off);
+    }
+    on[x]-- , on[y]--;
+    off[x]++ , off[y]++;
+    if(on[x]<=cnt[x]/2 && off[x]<=cnt[x]/2 && on[y]<=cnt[y]/2 && off[y]<=cnt[y]/2 ){
+        dfs(t+1,on,off);
+    }
+    off[x]-- , off[y]-- ;
+}
+int main(){
+    int T;scanf("%d",&T);
+    while(T--){
+        scanf("%d%d",&n,&m);
+        int on[10];
+        int off[10];
+        memset(cnt,0,sizeof cnt);
+        memset(on,0,sizeof on);
+        memset(off,0,sizeof off);
+        for(int i=0;i<m;i++){
+            p[i].in();
+        }
+        bool ok=false;
+        for(int i=1;i<=n;i++){
+            if(cnt[i]&1){
+                ok=true;
+                break;
+            }
+        }
+        if(ok){
+            printf("0\n");
+            continue;
+        }
+        sort(p,p+m);
+        ans=0;
+        dfs(0,on,off);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5306_autoAC.cpp b/HDOJ/5306_autoAC.cpp
new file mode 100644
index 0000000..e448be1
--- /dev/null
+++ b/HDOJ/5306_autoAC.cpp
@@ -0,0 +1,175 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <string>
+#include <cmath>
+#include <cstdlib>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+using namespace std;
+typedef long long int LL;
+const int maxn=1000030;
+int n,m;
+int a[maxn];
+struct Node
+{
+    LL ss;
+    int mx,tag,cv;
+    void toString() {
+        printf("ss: %lld mx: %d tag: %d cv: %d\n",ss,mx,tag,cv);
+    }
+}T[maxn<<2];
+#define lrt (rt<<1)
+#define rrt (rt<<1|1)
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1|1
+void push_up(int rt)
+{
+    T[rt].ss=T[lrt].ss+T[rrt].ss;
+    T[rt].mx=max(T[lrt].mx,T[rrt].mx);
+    T[rt].cv=T[lrt].cv+T[rrt].cv;
+}
+void pnc(int t,int l,int r,int rt)
+{
+    if(T[rt].tag!=0&&T[rt].tag<=t) return ;
+    int all=r-l+1;
+    if(T[rt].cv!=all)
+    {
+        T[rt].ss+=(LL)t*(all-T[rt].cv);
+        T[rt].tag=T[rt].mx=t;
+        T[rt].cv=all;
+    }
+}
+void push_down(int l,int r,int rt)
+{
+    if(T[rt].tag)
+    {
+        int m=(l+r)/2;
+        pnc(T[rt].tag,lson); pnc(T[rt].tag,rson);
+    }
+}
+void fix(int t,int l,int r,int rt)
+{
+    if(T[rt].mx<t) return ;
+    if(T[rt].tag>=t) T[rt].tag=0;
+    if(l==r)
+    {
+        T[rt].ss=T[rt].mx=T[rt].tag;
+        T[rt].cv=T[rt].tag!=0;
+    }
+    else
+    {
+        push_down(l,r,rt);
+        int m=(l+r)/2;
+        fix(t,lson); fix(t,rson);
+        push_up(rt);
+    }
+}
+void build(int l,int r,int rt)
+{
+    if(l==r)
+    {
+        T[rt].ss=T[rt].mx=T[rt].tag=a[l];
+        T[rt].cv=1;
+        return ;
+    }
+    T[rt].tag=0;
+    int m=(l+r)/2;
+    build(lson); build(rson);
+    push_up(rt);
+}
+void update(int L,int R,int t,int l,int r,int rt)
+{
+    if(T[rt].mx<=t) return ;
+    if(L<=l&&r<=R)
+    {
+        fix(t,l,r,rt);
+        if(l==r)
+        {
+            T[rt].ss=T[rt].mx=T[rt].tag=t; 
+            T[rt].cv=1;
+        }
+        else push_up(rt);
+        pnc(t,l,r,rt);
+    }
+    else 
+    {
+        push_down(l,r,rt);
+        int m=(l+r)/2;
+        if(L<=m) update(L,R,t,lson); 
+        if(R>m) update(L,R,t,rson);
+        push_up(rt);
+    }
+}
+int query_max(int L,int R,int l,int r,int rt)
+{
+    if(L<=l&&r<=R) return T[rt].mx;
+    push_down(l,r,rt);
+    int m=(l+r)/2;
+    int ret=0;
+    if(L<=m) ret=max(ret,query_max(L,R,lson));
+    if(R>m) ret=max(ret,query_max(L,R,rson));
+    return ret;
+}
+LL query_sum(int L,int R,int l,int r,int rt)
+{
+    if(L<=l&&r<=R) return T[rt].ss;
+    push_down(l,r,rt);
+    int m=(l+r)/2;
+    LL ret=0;
+    if(L<=m) ret+=query_sum(L,R,lson);
+    if(R>m) ret+=query_sum(L,R,rson);
+    return ret;
+}
+void show(int l,int r,int rt)
+{
+    printf("rt: %d %d <---> %d\n   ",rt,l,r);
+    T[rt].toString();
+    if(l==r) return ;
+    int m=(l+r)/2;
+    show(lson); show(rson);
+}
+char *ch,buf[40*1024000+5];
+void nextInt(int& x)
+{
+    x=0;
+    for(++ch;*ch<=32;++ch);
+    for(x=0;'0'<=*ch;ch++) x=x*10+*ch-'0';
+}
+int main()
+{
+    ch=buf-1;
+    fread(buf,1,1000*35*1024,stdin);
+    int T_T;
+    nextInt(T_T);
+    while(T_T--)
+    {
+        nextInt(n); nextInt(m);
+        for(int i=1;i<=n;i++) nextInt(a[i]);
+        build(1,n,1);
+        int k,l,r,t;
+        while(m--)
+        {
+            nextInt(k);
+            if(k==0)
+            {
+                nextInt(l); nextInt(r); nextInt(t);
+                update(l,r,t,1,n,1);
+            }
+            else if(k==1)
+            {
+                nextInt(l); nextInt(r);
+                printf("%d\n",query_max(l,r,1,n,1));
+            }
+            else if(k==2)
+            {
+                nextInt(l); nextInt(r);
+                printf("%I64d\n",query_sum(l,r,1,n,1));
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5307_autoAC.cpp b/HDOJ/5307_autoAC.cpp
new file mode 100644
index 0000000..55ae3ae
--- /dev/null
+++ b/HDOJ/5307_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <cstdio>
+#include <string.h>
+using namespace std;
+#define P 50000000001507329LL
+#define G 3
+int T;
+int n, s[110000];
+long long ans[140000], a[140000], b[140000], c[140000], x[140000], w[140000];
+long long pu[110000];
+int nn;
+long long Mul(long long x, long long y) {
+    return (x*y-(long long)(x/(long double)P*y+1e-3)*P+P)%P;
+}
+long long Pow(long long x, long long y) {
+    long long i, ans = 1;
+    for (i = 1; i <= y; i *= 2, x = Mul(x, x)) if (y & i)  ans = Mul(ans, x);
+    return ans;
+}
+void DFT(long long *a, int n) {
+    int m, i, d, p, q;
+    for (m = 1; (1 << m) <= n; m++){
+        for (i = 0; i < (n >> m); i++)
+        for (q = 0, d = p = i; d < n; q += (n >> m), d += (n >> (m - 1)), p += (n >> m)){
+            x[p] = (Mul(a[d + (n >> m)], w[q]) + a[d]) % P;
+            x[p + n / 2] = (Mul(a[d + (n >> m)], w[q + n / 2]) + a[d]) % P;
+        }
+        for (i = 0; i < n; i++) a[i] = x[i];
+    }
+}
+void DFT1(long long *a, int n){
+    int m, i, d, p, q;
+    for (m = 1; (1 << m) <= n; m++) {
+        for (i = 0; i < (n >> m); i++)
+        for (q = 0, d = p = i; d < n; q += (n >> m), d += (n >> (m - 1)), p += (n >> m)){
+            x[p] = (Mul(a[d + (n >> m)], w[n - q]) + a[d]) % P;
+            x[p + n / 2] = (Mul(a[d + (n >> m)], w[n / 2 - q]) + a[d]) % P;
+        }
+        for (i = 0; i < n; i++) a[i] = x[i];
+    }
+}
+void doit() {
+    long long S = Pow(n, P - 2);
+    DFT(a, n);
+    DFT(b, n);
+    for (int i = 0; i < n; i++)
+        c[i] = Mul(a[i], b[i]);
+    DFT1(c, n);
+    for (int i = 0; i < n; i++)
+        c[i] = Mul(c[i], S);
+    for (int i = 0; i < n; i++)
+        ans[i] = (ans[i] + c[i]) % P;
+}
+int main() {
+    scanf("%d", &T);
+    n = 131072;
+    for (int i = 0; i <= n; i++)
+        w[i] = Pow(G, (P - 1) / n * i);
+    s[0] = 0;
+    while (T--) {
+        scanf("%d", &nn);
+        for (int i = 1; i <= nn; i++)
+            scanf("%d", &s[i]), s[i] += s[i - 1];
+        memset(ans, 0, sizeof ans);
+        memset(a, 0, sizeof a);
+        memset(b, 0, sizeof b);
+        for (int i = 1; i <= nn; i++)
+            a[s[i]] += i;
+        for (int i = 1; i <= nn; i++)
+            b[s[nn] - s[i - 1]]++;
+        doit();
+        memset(a, 0, sizeof a);
+        memset(b, 0, sizeof b);
+        for (int i = 0; i <= 50000; i++)
+            a[i] = b[i] = 0;
+        for (int i = 1; i <= nn; i++)
+            a[s[i]] = (a[s[i]] + P - 1) % P;
+        for (int i = 1; i <= nn; i++)
+            b[s[nn] - s[i - 1]] += i - 1;
+        doit();
+        long long ans0 = 0;
+        int q, h;
+        for (int i = 1; i <= nn; i++)
+            pu[i] = pu[i - 1] + 1LL * i * (i + 1) / 2;
+        for (q = 1; q <= nn; q = h + 1)
+            if (s[q] != s[q - 1]) h = q;
+            else {
+                for (h = q; h < nn && s[h + 1] == s[q]; h++);
+                ans0 += pu[h - q + 1];
+            }
+        printf("%lld\n", ans0);
+        for (int i = 1; i <= s[nn]; i++)
+            printf("%lld\n", ans[i + s[nn]]);
+    }
+}
diff --git a/HDOJ/5308_autoAC.cpp b/HDOJ/5308_autoAC.cpp
new file mode 100644
index 0000000..24be1ea
--- /dev/null
+++ b/HDOJ/5308_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<iostream>
+#include<cstdio>
+using namespace std;
+int main(){
+    int n;
+    while(~scanf("%d",&n)){
+        if(n<=3){puts("-1");continue;}
+        if(n==4){puts("1 * 2");puts("5 + 3");puts("6 + 4");continue; }
+        if(n==5){puts("2 / 3");puts("6 / 4");puts("1 - 7");puts("8 * 5");continue; }
+        if(n==6){puts("1 + 2");puts("7 + 3");puts("8 + 4");puts("9 + 5");puts("10 - 6");continue; }
+        if(n==7){puts("1 + 2");puts("8 + 3");puts("9 / 4");puts("10 + 5");puts("11 + 6");puts("12 + 7");continue; }
+        if(n==8){puts("1 + 2");puts("9 + 3");puts("10 + 4");puts("5 + 6");puts("11 / 12");puts("13 * 7");puts("14 + 8");continue; }
+        if(n==9){puts("1 + 2");puts("10 + 3");puts("4 + 5");puts("12 + 6");puts("13 / 7");
+                 puts("11 - 14");puts("15 * 8");puts("16 / 9");continue;}
+        if(n==10){puts("1 + 2");puts("11 / 3");puts("12 + 4");puts("5 / 6");puts("7 / 8");
+                 puts("14 + 15");puts("13 * 16");puts("17 * 9");puts("18 / 10");continue;   }
+        if(n==11){puts("1 / 2");puts("12 + 3");puts("4 / 5");puts("6 / 7");puts("14 + 15");puts("13 * 16");
+                 puts("17 * 8");puts("18 * 9");puts("19 / 10");puts("20 / 11");continue;  }
+        if(n&1){
+            puts("1 + 2");printf("%d / 3\n",n+1);
+            puts("4 + 5");printf("%d / 6\n",n+3);
+            puts("7 + 8");printf("%d / 9\n",n+5);
+            puts("10 + 11");printf("%d + 12\n",n+7);printf("%d / 13\n",n+8);
+            printf("%d * %d\n",n+2,n+4);printf("%d * %d\n",n+10,n+6);
+            printf("%d * %d\n",n+11,n+9);
+            int x=n+12,y=14;
+            for(int i=1;i<=(n-13)/2;i++){
+                printf("%d * %d\n",x++,y++);
+                printf("%d / %d\n",x++,y++);
+            }
+        }else{
+            puts("1 + 2");printf("%d + 3\n",n+1);printf("%d + 4\n",n+2);printf("%d / 5\n",n+3);
+            puts("6 + 7");
+            for(int i=5;i<=8;i++)
+                printf("%d + %d\n",n+i,i+3);
+            printf("%d / 12\n",n+9);
+            printf("%d * %d\n",n+4,n+10);
+            int x=n+11,y=13;
+            for(int i=1;i<=(n-12)/2;i++){
+                printf("%d * %d\n",x++,y++);
+                printf("%d / %d\n",x++,y++);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5309_autoAC.cpp b/HDOJ/5309_autoAC.cpp
new file mode 100644
index 0000000..4705917
--- /dev/null
+++ b/HDOJ/5309_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+#include<queue>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define sf scanf
+#define mx 100000000
+struct node{
+int id,v;
+//friend bool operator<(node a,node b){return (a.v==b.v)?(a.id>b.id):(a.v>b.v);}
+bool operator < (const node &a)const {
+    if(a.v==v)return id>a.id;
+    return v<a.v;
+}
+};
+priority_queue<node> que1,que2;
+queue<int> que;
+int n,m,k;
+int g[1000000],sum[1000000],a[1000000],r[1000000];
+int main()
+{
+    while(~scanf("%d%d%d",&n,&m,&k))
+    {
+        while(!que1.empty()) que1.pop();
+        while(!que2.empty())que2.pop();
+        for(int i = 1;i<=n;i++) {sf("%d",a+i);sum[i]=sum[i-1]+a[i];}
+        int t = 0;
+        for(int i = 0;i<=n;i++){while(t<=n&&sum[t]<i*k + m) t++;r[i] = t-1;}
+        for(int i = n;i>0;i--)
+        {
+            g[i] = 0;
+            if(r[i] == n) g[i] = mx + i;
+            else
+            {
+                while(!que1.empty()){
+                        node tmp = que1.top();
+                        if(tmp.id>r[i])que1.pop();
+                        else if(tmp.v*2>=g[tmp.id] + i)
+                            {
+                                que2.push(node{tmp.id,g[tmp.id]-tmp.id});
+                                que1.pop();
+                            }
+                        else break;
+                }
+                while(!que2.empty())
+                    {
+                        node tmp = que2.top();
+                        if(tmp.id>r[i])que2.pop();
+                        else break;
+                    }
+                if(!que1.empty())g[i] = max(g[i],que1.top().v);
+                if(!que2.empty())g[i] = max(g[i],que2.top().v+i);
+            }
+            if(g[i]>i) que1.push((node){i,i});
+            else que2.push((node){i,g[i]-i});
+        }
+        for(int i = 1;i<=n;i++)g[i]-=i;
+        g[0] = 0;
+        for(int i = 1;i<=r[0];i++) g[0] = max(g[0],g[i]);
+        if(g[0] > n) puts("Poor JRY!");
+        else if(!g[0]) puts("Poor Hero!");
+        else
+        {
+            printf("%d\n",g[0]);
+            int i = 1;
+            while(g[i]!=g[0]) i++;
+            que.push(i);
+            while(g[i]!=mx)
+            {
+                int j=i+g[0];
+                while(g[j]<g[0]) {
+                        j++;
+                }
+                i = j;
+                que.push(i);
+            }
+            printf("%d\n",que.size());
+            while(!que.empty())
+            {
+                int tmp = que.front();
+                printf("%d",tmp);
+                que.pop();
+                if(que.size())printf(" ");
+                else printf("\n");
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5310_autoAC.cpp b/HDOJ/5310_autoAC.cpp
new file mode 100644
index 0000000..b9caeae
--- /dev/null
+++ b/HDOJ/5310_autoAC.cpp
@@ -0,0 +1,25 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+int main()
+{
+    int m,n,q,t,p;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d%d%d",&n,&m  ,&p,&q);
+        int sum=0;
+        double op=q/m;
+        if(op<p)
+        {
+            sum+=(n/m)*q;
+            int pl=n%m;
+            sum+=min(p*pl,q);
+            cout<<sum<<endl;
+        }
+        else
+            cout<<p*n<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5311_autoAC.cpp b/HDOJ/5311_autoAC.cpp
new file mode 100644
index 0000000..b116246
--- /dev/null
+++ b/HDOJ/5311_autoAC.cpp
@@ -0,0 +1,104 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+using namespace std;
+const int MAX_N = 200 + 10;
+int Next[MAX_N];
+const char *str = "anniversary";
+char pat[MAX_N], pat_sub[MAX_N];
+char sub_1[MAX_N], sub_2[MAX_N], sub_3[MAX_N];
+void get_nextval(char *W, int Next[])
+{
+    int i = 0, j = -1;
+    int Len_W = strlen(W);
+    Next[0] = -1;
+    if (W[0] == '\0')
+        return;
+    while (i < Len_W)
+    {
+        if (j == -1 || W[i] == W[j])
+        {
+            ++i;
+            ++j;
+            Next[i] = j;
+        } else
+            j = Next[j];
+    }
+}
+int KMP_Matcher(char T[], char P[], int Next[])
+{
+    int i = 0, j = 0;
+    int TLen = strlen(T);
+    int PLen = strlen(P);
+    if (TLen == 0)
+        return -2;
+    while (i < TLen && j < PLen)
+    {
+        if (j == -1 || T[i] == P[j])
+        {
+            i++;
+            j++;
+        } else
+            j = Next[j];
+    }
+    if (j == PLen)
+        return i - j;
+    else
+        return -1;
+}
+int main()
+{
+    int case_times, len;
+    scanf("%d", &case_times);
+    len = strlen(str);
+    while (case_times--)
+    {
+        int len_s;
+        bool ans = false;
+        scanf("%s", pat);
+        strcpy(pat_sub, pat);
+        len_s = strlen(pat);
+        for (int i = 1; i < len; ++i)
+        {
+            if (ans)
+                break;
+            for (int j = i + 1; j < len; ++j)
+            {
+                int m_1, m_2, m_3;
+                strncpy(sub_1, str, i);
+                sub_1[i] = '\0';
+                strncpy(sub_2, str + i, j - i);
+                sub_2[j - i] = '\0';
+                strncpy(sub_3, str + j, len - j);
+                sub_3[len - j] = '\0';
+                strcpy(pat_sub, pat);
+                get_nextval(sub_1, Next);
+                m_1 = KMP_Matcher(pat_sub, sub_1, Next);
+                if (m_1 >= 0)
+                {
+                    for (int k = 0; k <= len_s - i; ++k)
+                        pat_sub[k] = pat[m_1 + i + k];
+                }
+                get_nextval(sub_2, Next);
+                m_2 = KMP_Matcher(pat_sub, sub_2, Next);
+                if (m_2 >= 0)
+                {
+                    for (int k = 0; k <= len_s - j; ++k)
+                        pat_sub[k] = pat_sub[m_2 + j - i + k];
+                }
+                get_nextval(sub_3, Next);                
+                m_3 = KMP_Matcher(pat_sub, sub_3, Next);
+                if (m_1 >= 0 && m_2 >= 0 && m_3 >= 0)
+                {
+                    ans = true;
+                    break;
+                }
+            }
+        }
+        if (ans)
+            printf("YES\n");
+        else
+            printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5312_autoAC.cpp b/HDOJ/5312_autoAC.cpp
new file mode 100644
index 0000000..ad8548c
--- /dev/null
+++ b/HDOJ/5312_autoAC.cpp
@@ -0,0 +1,63 @@
+#include <map>
+#include <set>
+#include <stack>
+#include <queue>
+#include <cmath>
+#include <ctime>
+#include <vector>
+#include <cstdio>
+#include <cctype>
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define INF 0x3f3f3f3f
+#define inf -0x3f3f3f3f
+#define lson k<<1, L, mid
+#define rson k<<1|1, mid+1, R
+#define mem0(a) memset(a,0,sizeof(a))
+#define mem1(a) memset(a,-1,sizeof(a))
+#define mem(a, b) memset(a, b, sizeof(a))
+typedef long long ll;
+ll a[1000000];
+int count1;
+int main(){
+    mem0(a);
+    int m;
+    for(int i=1;(ll)3*i*(i-1)+1<=1000010000;i++){
+        a[i]=3*i*(i-1)+1;
+        m=i;
+    }
+    int t;
+    int n;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        if(*lower_bound(a+1,a+m+1,n)==n){
+            printf("1\n");
+            continue;
+        }
+        int p=1;
+        int flag=0;
+        if((n-2)%6==0){                            
+            while(2*a[p]<=n){
+                if(*lower_bound(a+1,a+m+1,n-a[p])==n-a[p]){
+                    printf("2\n");
+                    flag=1;
+                    break;
+                }
+                p++;
+            }
+        }
+        if(flag==1)
+            continue;
+        for(int i=3;;i++){
+            if((n-i)%6==0){
+                printf("%d\n",i);
+                break;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5313_autoAC.cpp b/HDOJ/5313_autoAC.cpp
new file mode 100644
index 0000000..e5967d9
--- /dev/null
+++ b/HDOJ/5313_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<stdio.h>
+#include<math.h>
+#include<string.h>
+#include<algorithm>
+#include<vector>
+#include<queue>
+#include<set>
+using namespace std;
+int x,y;
+vector<int>v[10004];
+set<int>s[2];
+int dfs(int p,int b)
+{
+    s[b].insert(p);
+    int l=v[p].size();
+    for(int i=0;i<l;i++)
+        if(!s[!b].count(v[p][i]))
+            dfs(v[p][i],!b);
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&x,&y);
+        for(int i=0;i<y;i++)
+        {
+            int tx,ty;
+            scanf("%d%d",&tx,&ty);
+            v[tx].push_back(ty);
+            v[ty].push_back(tx);
+        }
+        s[0].clear();
+        s[1].clear();
+        for(int i=0;i<x;i++)
+            if(v[i].size())
+        {
+            dfs(i,0);
+            break;
+        }
+        long long  line;
+        long long  mmax=(s[0].size(),s[1].size());
+        if(mmax<(x/2))
+        {
+            line=(x/2)*(x-x/2)-y;
+        }
+        else
+            line=(x-mmax)*(x-(x-mmax))-y;
+        printf("%I64d\n",line);
+        for(int i=0;i<=x;i++)
+            v[i].clear();
+    }
+    return 0;
+}
diff --git a/HDOJ/5314_autoAC.cpp b/HDOJ/5314_autoAC.cpp
new file mode 100644
index 0000000..b38f2a3
--- /dev/null
+++ b/HDOJ/5314_autoAC.cpp
@@ -0,0 +1,85 @@
+#pragma comment(linker, "/STACK:102400000,102400000")
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <map>
+#include <set>
+#include <cmath>
+using namespace std;
+const int size=200111;
+typedef long long ll;
+ll inf=-1000111000ll;
+typedef pair<int,int> P;
+ll mod=1000000007;
+int t,n,m,a[size],K;
+vector<int>V[size];
+int vis[size],sum[size],id,tmp;
+void find(int u,int fa,int num){
+    sum[u]=1;int K=0;
+    for(int i=0;i<V[u].size();i++){
+        int to=V[u][i];
+        if(vis[to]||to==fa)continue;
+        find(to,u,num);
+        K=max(K,sum[to]);
+        sum[u]+=sum[to];
+    }
+    K=max(K,num-sum[u]);
+    if(K<tmp)tmp=K,id=u;
+}
+P b[size];
+int tot;
+void dfs(int u,int fa,int mi,int ma){
+    sum[u]=1;
+    mi=min(mi,a[u]);
+    ma=max(ma,a[u]);
+    if(ma<=mi+K)b[tot++]=P(mi,ma);
+    for(int i=0;i<V[u].size();i++){
+        int to=V[u][i];
+        if(vis[to]||to==fa)continue;
+        dfs(to,u,mi,ma);
+        sum[u]+=sum[to];
+    }
+}
+ll gao(int u,int mi,int ma){
+    tot=0;
+    dfs(u,0,mi,ma);
+    sort(b,b+tot);
+    ll ans=0;
+    for(int i=0;i<tot;i++){
+        int p=lower_bound(b,b+i,P(b[i].second-K,0))-b;
+        ans+=i-p;
+    }
+    return ans;
+}
+ll work(int u,int num){
+    tmp=n;
+    find(u,0,num);
+    u=id;
+    ll ans=gao(u,a[u],a[u]);
+    vis[u]=1;
+    for(int i=0;i<V[u].size();i++){
+        int to=V[u][i];
+        if(!vis[to])ans-=gao(to,a[u],a[u]);
+    }
+    for(int i=0;i<V[u].size();i++){
+        int to=V[u][i];
+        if(!vis[to])ans+=work(to,sum[to]);
+    }
+    return ans;
+}
+int main(){
+    cin>>t;
+    while(t--){
+        cin>>n>>K;
+        for(int i=1;i<=n;i++)V[i].clear(),scanf("%d",&a[i]),vis[i]=0;
+        for(int i=1;i<n;i++){
+            int x,y;
+            scanf("%d%d",&x,&y);
+            V[x].push_back(y);
+            V[y].push_back(x);
+        }
+        cout<<work(1,n)*2<<endl;
+    }
+}
diff --git a/HDOJ/5316_autoAC.cpp b/HDOJ/5316_autoAC.cpp
new file mode 100644
index 0000000..40ee7b6
--- /dev/null
+++ b/HDOJ/5316_autoAC.cpp
@@ -0,0 +1,109 @@
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#define LL long long
+#define INF 0x3f3f3f3f
+#define msz 405000
+#define Max 50000000000000
+using namespace std;
+typedef struct LinkTree
+{
+    LL sum[2][2];
+}LinkTree;
+LinkTree tr[405005];
+int n,m;
+LinkTree Joint(LinkTree a,LinkTree b)
+{
+    int i,j;
+    LL t;
+    LinkTree tmp;
+    for(i = 0; i < 2; ++i)
+    {
+        for(j = 0; j < 2; ++j)
+        {
+            tmp.sum[i][j] = max(a.sum[i][j],b.sum[i][j]);
+            t = max(a.sum[i][0]+b.sum[1][j],a.sum[i][1]+b.sum[0][j]);
+            tmp.sum[i][j] = max(tmp.sum[i][j],t);
+        }
+    }
+    return tmp;
+}
+void SetTree(int site,int l,int r)
+{
+    int i,j,x;
+    if(l == r)
+    {
+        scanf("%d",&x);
+        for(i = 0; i < 2; ++i)
+            for(j = 0; j < 2; ++j)
+                tr[site].sum[i][j] = -Max;
+        tr[site].sum[l&1][r&1] = x;
+        return;
+    }
+    int m = (l+r)>>1;
+    SetTree(site<<1,l,m);
+    SetTree(site<<1|1,m+1,r);
+    tr[site] = Joint(tr[site<<1],tr[site<<1|1]);
+}
+void Change(int site,int l,int r,int k,int data)
+{
+    if(l == k && r == k)
+    {
+        tr[site].sum[l&1][l&1] = data;
+        return;
+    }
+    int m = (l+r)>>1;
+    if(m >= k)
+        Change(site<<1,l,m,k,data);
+    else
+        Change(site<<1|1,m+1,r,k,data);
+    tr[site] = Joint(tr[site<<1],tr[site<<1|1]);
+}
+LinkTree MAX(int site,int l,int r,int ll,int rr)
+{
+    int i,j;
+    LinkTree tmp;
+    if(l == ll && r == rr)
+    {
+        return tr[site];
+    }
+    int m = (l+r)>>1;
+    if(m >= rr) return MAX(site<<1,l,m,ll,rr);
+    else if(m < ll) return MAX(site<<1|1,m+1,r,ll,rr);
+    else
+    {
+        return Joint(MAX(site<<1,l,m,ll,m),MAX(site<<1|1,m+1,r,m+1,rr));
+    }
+}
+int main()
+{
+    int i,j,t,x,b,a;
+    LL mm;
+    LinkTree tmp;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d %d",&n,&m);
+        SetTree(1,1,n);
+        while(m--)
+        {
+            scanf("%d %d %d",&x,&a,&b);
+            if(x) Change(1,1,n,a,b);
+            else
+            {
+                tmp = MAX(1,1,n,a,b);
+                mm = -Max;
+                for(i = 0; i  < 2; ++i)
+                {
+                    for(j = 0; j < 2; ++j)
+                    {
+                        mm = max(mm,tmp.sum[i][j]);
+                    }
+                }
+                printf("%lld\n",mm);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5317_autoAC.cpp b/HDOJ/5317_autoAC.cpp
new file mode 100644
index 0000000..16da789
--- /dev/null
+++ b/HDOJ/5317_autoAC.cpp
@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <iostream>
+using namespace std;
+const int MAX = 1000000+50;
+int arr[MAX],prime[MAX];
+int dp[MAX][9];
+void init()
+{
+    int n=1000000;
+    int flag = 0;
+    prime[2]=1;
+    for(int i=3;i<=n;i++)
+    {
+        if(i%2==0)
+        {
+            flag=1;
+        }
+        else
+        {
+            for(int j=3;j*j<=i;j=j+2)
+            {
+                if(i%j==0)
+                {
+                    flag = 1;
+                    break;
+                }
+            }
+        }
+        if(flag==0)
+        {
+            prime[i]=1;
+        }
+        flag=0;
+    }
+    for(int i = 2;i<=n;i++)
+    {
+        if(prime[i])
+        {
+            for(int j=i;j<=n;j+=i)
+            {
+                arr[j]++;
+            }
+        }
+    }
+    for(int i=2;i<=n;i++)
+    {
+        dp[i][arr[i]]++;
+    }
+    for(int i=2;i<=n;i++)
+    {
+        for(int j=1;j<8;j++)
+        {
+            dp[i][j]+=dp[i-1][j];
+        }
+    }
+}
+int main()
+{
+    init();
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int L,R;
+        scanf("%d %d",&L,&R);
+        int ans=1;
+        for(int j=2;j<8;j++)
+        {
+            if(dp[R][j]-dp[L-1][j]>=2)
+            {
+                ans=max(ans,j);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5318_autoAC.cpp b/HDOJ/5318_autoAC.cpp
new file mode 100644
index 0000000..ba84ba7
--- /dev/null
+++ b/HDOJ/5318_autoAC.cpp
@@ -0,0 +1,101 @@
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#include <vector>
+#include <cmath>
+#include <string>
+#include <set>
+using namespace std;
+typedef long long ll;
+const int MAXN = 55;
+const int INF = 0x3f3f3f3f;
+const int MOD = 1e9 + 7;
+struct Mat  {
+    int m[MAXN][MAXN];
+    Mat () {
+        memset (m, 0, sizeof (m));
+    }
+    void init(void) {
+        for (int i=0; i<MAXN; ++i)  m[i][i] = 1;
+    }
+};
+int n, m;
+int a[MAXN];
+int dp[MAXN][MAXN];
+bool judge(int x, int y)    {
+    char p[15], q[15];
+    sprintf (p, "%d", x);
+    sprintf (q, "%d", y);
+    int lenp =  strlen (p), lenq = strlen (q);
+    for (int i=0; i<lenp; ++i)  {
+        int k = 0;
+        while (i + k < lenp && k < lenq && p[i+k] == q[k])  k++;
+        if (i + k == lenp && k >= 2)    return true;
+    }
+    return false;
+}
+Mat operator * (Mat &a, Mat &b) {
+    Mat ret;
+    for (int k=1; k<=n; ++k)    {
+        for (int i=1; i<=n; ++i)    {
+            for (int j=1; j<=n; ++j)    {
+                ret.m[i][j] = (ret.m[i][j] + 1LL * a.m[i][k] * b.m[k][j] % MOD) % MOD;
+            }
+        }
+    }
+    return ret;
+}
+Mat operator ^ (Mat x, int n)   {
+    Mat ret;    ret.init ();
+    while (n)   {
+        if (n & 1)  ret = ret * x;
+        x = x * x;
+        n >>= 1;
+    }
+    return ret;
+}
+Mat work(void)  {
+    Mat ret;
+    for (int i=1; i<=n; ++i)    {
+        for (int j=1; j<=n; ++j)    {
+            if (judge (a[i], a[j]))   ret.m[i][j] = 1;
+        }
+    }
+    return ret;
+}
+void brute_force(void)  {
+    memset (dp, 0, sizeof (dp));
+    for (int i=1; i<=n; ++i)    dp[1][i] = 1;
+    for (int i=2; i<=m; ++i)    {
+        for (int j=1; j<=n; ++j)    {
+            for (int k=1; k<=n; ++k)    if (judge (a[j], a[k])) {
+                dp[i][k] += dp[i-1][j];
+                dp[i][k] %= MOD;
+            }
+        } 
+    }
+    int res = 0;
+    for (int i=1; i<=n; ++i)    {
+        res += dp[m][i];    res %= MOD;
+    }
+    printf ("%d\n", res);
+}
+int main(void)  {       
+    int T;  scanf ("%d", &T);
+    while (T--) {
+        scanf ("%d%d", &n, &m);
+        for (int i=1; i<=n; ++i)    {
+            scanf ("%d", &a[i]);
+        }
+        sort (a+1, a+1+n);  n = unique (a+1, a+1+n) - (a + 1);       
+        Mat x = work ();
+        Mat res = x ^ (m - 1);  int ans = 0;
+        for (int i=1; i<=n; ++i)    {
+            for (int j=1; j<=n; ++j)    {
+                ans = (ans + res.m[i][j]) % MOD;
+            }
+        }
+        printf ("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5319_autoAC.cpp b/HDOJ/5319_autoAC.cpp
new file mode 100644
index 0000000..43ec8e4
--- /dev/null
+++ b/HDOJ/5319_autoAC.cpp
@@ -0,0 +1,35 @@
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#include <cmath>
+using namespace std;
+const int MAXN = 55;
+const int INF = 0x3f3f3f3f;
+char s[MAXN][MAXN];
+bool vis[MAXN][MAXN];
+int n, m;
+int main(void)    {      
+    int T;  scanf ("%d", &T);
+    while (T--) {
+        scanf ("%d", &n);
+        for (int i=1; i<=n; ++i)    scanf ("%s", s[i] + 1);
+        memset (vis, false, sizeof (vis));  m = strlen (s[1] + 1);
+        int ans = 0;
+        for (int i=1; i<=n; ++i)    {
+            for (int j=1; j<=m; ++j)  {
+                if (s[i][j] == 'R' || s[i][j] == 'G')   {
+                    if (!(s[i-1][j-1] == 'R' || s[i-1][j-1] == 'G'))    ans++; 
+                }
+            }
+        }
+        for (int i=1; i<=n; ++i)    {
+            for (int j=1; j<=m; ++j)    {
+                if (s[i][j] == 'B' || s[i][j] == 'G')   {
+                    if (!(s[i-1][j+1] == 'B' || s[i-1][j+1] == 'G'))    ans++;
+                }
+            }
+        }
+        printf ("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5320_autoAC.cpp b/HDOJ/5320_autoAC.cpp
new file mode 100644
index 0000000..886967c
--- /dev/null
+++ b/HDOJ/5320_autoAC.cpp
@@ -0,0 +1,160 @@
+#include <stdio.h>
+#include <string.h>
+#include <vector>
+#include <algorithm>
+using namespace std ;
+typedef long long LL ;
+#define clr( a , x ) memset ( a , x , sizeof a )
+#define ls ( o << 1 )
+#define rs ( o << 1 | 1 )
+#define lson ls , l , m
+#define rson rs , m + 1 , r
+#define root 1 , 1 , n
+#define rt o , l , r
+#define mid ( ( l + r ) >> 1 )
+const int MAXN = 100005 ;
+const int mod = 998244353 ;
+struct Node {
+    int g , idx , L , R ;
+    Node () {}
+    Node ( int g , int idx , int L , int R ) : g ( g ) , idx ( idx ) , L ( L ) , R ( R ) {}
+    bool operator < ( const Node& a ) const {
+        return g != a.g ? g < a.g : idx < a.idx ;
+    }
+} ;
+int a[MAXN] ;
+vector < pair < int , int > > G[2] ;
+Node node[MAXN * 25] ;
+int cnt ;
+int vis[MAXN << 2] , Time ;
+int maxv[MAXN << 2] ;
+int sum[MAXN << 2] ;
+int add[MAXN << 2] ;
+int query_ , query_ ;
+int ans_ , ans_ ;
+int n ;
+int gcd ( int a , int b ) {
+    return b ? gcd ( b , a % b ) : a ;
+}
+void check ( int o ) {
+    if ( vis[o] < Time ) {
+        vis[o] = Time ;
+        maxv[o] = sum[o] = add[o] = 0 ;
+    }
+}
+void upd ( int Max , int Add , int o , int len ) {
+    check ( o ) ;
+    if ( Max > maxv[o] ) {
+        maxv[o] = Max ;
+        add[o] = Add ;
+        sum[o] = ( LL ) len * Add % mod ;
+    } else if ( Max == maxv[o] ) {
+        add[o] = ( add[o] + Add ) % mod ;
+        sum[o] = ( sum[o] + ( LL ) len * Add ) % mod ;
+    }
+}
+void pushdown ( int o , int l , int r ) {
+    int m = mid ;
+    if ( add[o] ) {
+        upd ( maxv[o] , add[o] , ls , m - l + 1 ) ;
+        upd ( maxv[o] , add[o] , rs , r - m ) ;
+        add[o] = 0 ;
+    }
+}
+void pushup ( int o ) {
+    check ( ls ) ;
+    check ( rs ) ;
+    if ( maxv[ls] == maxv[rs] ) {
+        sum[o] = ( sum[ls] + sum[rs] ) % mod ;
+        maxv[o] = maxv[ls] ;
+    } else if ( maxv[ls] > maxv[rs] ) {
+        maxv[o] = maxv[ls] ;
+        sum[o] = sum[ls] ;
+    } else {
+        maxv[o] = maxv[rs] ;
+        sum[o] = sum[rs] ;
+    }
+}
+void update ( int L , int R , int x , int v , int o , int l , int r ) {
+    check ( o ) ;
+    if ( L <= l && r <= R ) {
+        upd ( x , v , o , r - l + 1 ) ;
+        return ;
+    }
+    int m = mid ;
+    pushdown ( rt ) ;
+    if ( L <= m ) update ( L , R , x , v , lson ) ;
+    if ( m <  R ) update ( L , R , x , v , rson ) ;
+    pushup ( o ) ;
+}
+void query ( int L , int R , int o , int l , int r ) {
+    if ( R < L ) return ;
+    check ( o ) ;
+    if ( L <= l && r <= R ) {
+        if ( query_max < maxv[o] ) {
+            query_max = maxv[o] ;
+            query_sum = sum[o] ;
+        } else if ( query_max == maxv[o] ) query_sum = ( query_sum + sum[o] ) % mod ;
+        return ;
+    }
+    int m = mid ;
+    pushdown ( rt ) ;
+    if ( L <= m ) query ( L , R , lson ) ;
+    if ( m <  R ) query ( L , R , rson ) ;
+}
+void solve () {
+    cnt = 0 ;
+    for ( int i = 1 ; i <= n ; ++ i ) {
+        scanf ( "%d" , &a[i] ) ;
+    }
+    int cur = 0 ;
+    G[cur].clear () ;
+    G[cur].push_back ( make_pair ( a[n] , n ) ) ;
+    node[cnt ++] = Node ( a[n] , n , n , n ) ;
+    for ( int i = n - 1 ; i >= 1 ; -- i ) {
+        cur ^= 1 ;
+        G[cur].clear () ;
+        G[cur].push_back ( make_pair ( a[i] , i ) ) ;
+        int pre = a[i] ;
+        int m = 1 ;
+        for ( int j = 0 ; j < G[cur ^ 1].size () ; ++ j ) {
+            int v = G[cur ^ 1][j].first ;
+            int g = gcd ( pre , v ) ;
+            if ( g != pre ) {
+                G[cur].push_back ( make_pair ( g , G[cur ^ 1][j].second ) ) ;
+                node[cnt ++] = Node ( pre , i , G[cur][m - 1].second , G[cur][m].second - 1 ) ;
+                ++ m ;
+            }
+            pre = g ;
+        }
+        node[cnt ++] = Node ( pre , i , G[cur][m - 1].second , n ) ;
+    }
+    ans_sum = ans_max = 0 ;
+    sort ( node , node + cnt ) ;
+    for ( int i = 0 , j = 0 ; i < cnt ; i = j ) {
+        while ( j < cnt && node[j].g == node[i].g ) ++ j ;
+        {
+            ++ Time ;
+            update ( node[i].L , node[i].R , 1 , 1 , root ) ;
+            for ( int l = i + 1 ; l < j ; ++ l ) {
+                int idx = node[l].idx ;
+                query_max = query_sum = 0 ;
+                query ( 1 , idx - 1 , root ) ;
+                if ( query_max == 0 ) query_sum = 1 ;
+                update ( node[l].L , node[l].R , query_max + 1 , query_ , root ) ;
+            }
+            if ( ans_max < maxv[1] ) {
+                ans_max = maxv[1] ;
+                ans_sum = sum[1] ;
+            } else if ( ans_max == maxv[1] ) {
+                ans_sum = ( ans_sum + sum[1] ) % mod ;
+            }
+        }
+    }
+    printf ( "%d %d\n" , ans_ , ans_ ) ;
+}
+int main () {
+    clr ( vis , 0 ) ;
+    Time = 0 ;
+    while ( ~scanf ( "%d" , &n ) ) solve () ;
+}
diff --git a/HDOJ/5321_autoAC.cpp b/HDOJ/5321_autoAC.cpp
new file mode 100644
index 0000000..8c3da0f
--- /dev/null
+++ b/HDOJ/5321_autoAC.cpp
@@ -0,0 +1,96 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+#define maxn 1000000
+#define MOD 258280327
+#define LL long long
+int notprime[maxn+10];
+int prime[maxn+10],tot;
+int mu[maxn+10]={0,1};
+LL jie[maxn+10];
+LL inv[maxn+10];
+LL power(LL x,LL k){
+    LL res=1,t=x;
+    while(k){
+        if(k&1)res=res*t%MOD;
+        t=t*t%MOD;
+        k>>=1;
+    }
+    return res%MOD;
+}
+void init(){
+    jie[0]=jie[1]=1;
+    tot=0;
+    mu[1]=1;
+    inv[0]=inv[1]=1;
+    for(int i=2;i<=maxn;i++){
+        jie[i]=i*jie[i-1]%MOD;
+        inv[i]=power(jie[i],MOD-2);
+        if(!notprime[i]){
+            prime[tot++]=i;
+            mu[i]=-1;
+        }
+        for(int j=0;j<tot&&i*prime[j]<=maxn;j++){
+            notprime[i*prime[j]]=1;
+            if(i%prime[j]==0){
+                mu[i*prime[j]]=0;
+                break;
+            }
+            mu[i*prime[j]]=-mu[i];
+        }
+    }
+}
+int n;
+int ma;
+int cnt[maxn+10];
+LL F1[maxn+10],F2[maxn+10];
+LL ans1,ans2;
+void calc(){
+    for(int i=1;i<=ma;i++){
+        LL tmp=0;
+        for(int j=1;j<=cnt[i];j++){
+            LL a=jie[cnt[i]];
+            LL b=inv[cnt[i]-j];
+            tmp=(tmp+a*b%MOD*jie[n-j+1]%MOD)%MOD;
+        }
+        F1[i]=tmp;
+        if(cnt[i]>0)
+            F2[i]=cnt[i]*power(2,cnt[i]-1);
+        else F2[i]=0;
+    }
+    LL tmp1,tmp2;
+    ans1=ans2=0;
+    for(int i=1;i<=ma;i++){
+        tmp1=tmp2=0;
+        for(int j=i;j<=ma;j+=i){
+            tmp1=(tmp1+mu[j/i]*F1[j]%MOD)%MOD;
+            tmp2=(tmp2+mu[j/i]*F2[j]%MOD)%MOD;
+        }
+        ans1=(ans1+i*tmp1%MOD)%MOD;
+        ans2=(ans2+i*tmp2%MOD)%MOD;
+    }
+}
+int main(){
+    init();
+    while(~scanf("%d",&n)){
+        for(int i=1;i<=maxn;i++)cnt[i]=0;
+        ma=0;
+        for(int i=0;i<n;i++){
+            int x;scanf("%d",&x);
+            if(ma<x)ma=x;
+            for(int j=1;j*j<=x;j++){
+                if(j*j==x)cnt[j]++;
+                else if(x%j==0){
+                    cnt[j]++;
+                    cnt[x/j]++;
+                }
+            }
+        }
+        calc();
+        if(ans1==ans2)printf("Equal %lld\n",ans1);
+        else if(ans1>ans2)printf("Mr. Zstu %lld\n",ans1);
+        else printf("Mr. Hdu %lld\n",ans2);
+    }
+    return 0;
+}
diff --git a/HDOJ/5322_autoAC.cpp b/HDOJ/5322_autoAC.cpp
new file mode 100644
index 0000000..a053a29
--- /dev/null
+++ b/HDOJ/5322_autoAC.cpp
@@ -0,0 +1,103 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<cmath>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const ll Mod=998244353;
+const ll g=3;
+ll fp(ll a,ll k)
+{
+    ll res=1LL;
+    while(k>0)
+    {
+        if(k&1)res=res*a%Mod;
+        a=a*a%Mod;
+        k>>=1;
+    }
+    return res;
+}
+ll f[100005],inv[100005];
+void change(ll y[],int len)
+{
+    for(int i=1,j=len/2;i<len-1;i++)
+    {
+        if(i<j)swap(y[i],y[j]);
+        int k=len/2;
+        while(j>=k)
+        {
+            j-=k;
+            k/=2;
+        }
+        if(j<k)j+=k;
+    }
+}
+void ntt(ll y[],int len,int on)
+{
+    change(y,len);
+    for(int h=2;h<=len;h<<=1)
+    {
+        ll wn=fp(g,(Mod-1)/h);
+        if(on==-1)wn=fp(wn,Mod-2);
+        for(int j=0;j<len;j+=h)
+        {
+            ll w=1LL;
+            for(int k=j;k<j+h/2;k++)
+            {
+                ll u=y[k];
+                ll t=w*y[k+h/2]%Mod;
+                y[k]=(u+t)%Mod;
+                y[k+h/2]=(u-t+Mod)%Mod;
+                w=w*wn%Mod;
+            }
+        }
+    }
+    if(on==-1)
+    {
+        ll t=fp(len,Mod-2);
+        for(int i=0;i<len;i++)
+            y[i]=y[i]*t%Mod;
+    }
+}
+ll dp[100005];
+ll x1[200005],x2[200005];
+void cdq(int l,int r)
+{
+    if(l==r)return;
+    int m=(l+r)>>1;
+    cdq(l,m);
+    int len=1;
+    while(len<=r-l+1)len<<=1;
+    for(int i=0;i<len;i++)
+    {
+        x1[i]=(l+i<=m ? dp[l+i]*inv[l+i]%Mod : 0);
+        x2[i]=(l+i<r ? 1LL*(i+1)*(i+1)%Mod : 0);
+    }
+    ntt(x1,len,1);
+    ntt(x2,len,1);
+    for(int i=0;i<len;i++)
+        x1[i]=x1[i]*x2[i]%Mod;
+    ntt(x1,len,-1);
+    for(int i=m+1;i<=r;i++)
+        dp[i]=(dp[i]+f[i-1]*x1[i-l-1]%Mod)%Mod;
+    cdq(m+1,r);
+}
+void prepare()
+{
+    f[0]=1LL;
+    for(int i=1;i<=100000;i++)
+        f[i]=i*f[i-1]%Mod;
+    for(int i=0;i<=100000;i++)
+        inv[i]=fp(f[i],Mod-2)%Mod;
+    dp[0]=1LL;
+    cdq(0,100000);
+}
+int main()
+{
+    prepare();
+    int n;
+    while(scanf("%d",&n)!=EOF)printf("%I64d\n",dp[n]);
+    return 0;
+}
diff --git a/HDOJ/5323_autoAC.cpp b/HDOJ/5323_autoAC.cpp
new file mode 100644
index 0000000..38e331e
--- /dev/null
+++ b/HDOJ/5323_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <stdio.h>
+using namespace std;
+long long ans=0x3f3f3f3f3f3f3f;
+void dfs(long long L,long long R,long long RR)
+{
+    if(L<0||R>2*RR)
+        return;
+    if(ans&&ans<=R)
+        return;
+    if(L==0)
+    {
+        ans=min(ans,R);
+        return;
+    }
+    if (2*L<R+1)
+        return;
+    dfs(2*L-R-1,R,RR);
+    dfs(2*L-R-2,R,RR);
+    dfs(L,2*R-L+1,RR);
+    dfs(L,2*R-L,RR);
+}
+int main()
+{
+    long long L,R;
+    while(~scanf("%I64d %I64d",&L,&R))
+    {
+        dfs(L,R,R);
+        if(ans==0x3f3f3f3f3f3f3f)
+        {
+            printf("-1\n");
+        }
+        else
+        {
+            printf("%I64d\n",ans);
+        }
+        ans=0x3f3f3f3f3f3f3f;
+    }
+    return 0;
+}
diff --git a/HDOJ/5324_autoAC.cpp b/HDOJ/5324_autoAC.cpp
new file mode 100644
index 0000000..4811c8e
--- /dev/null
+++ b/HDOJ/5324_autoAC.cpp
@@ -0,0 +1,191 @@
+#include <iostream>
+    #include <cstdio>
+    #include <cstdlib>
+    #include <cstring>
+    #include <algorithm>
+    using namespace std;
+    const int maxn = 50010;
+    struct Node{
+        Node *ch[2];
+        int r;
+        int v; 
+        int len; 
+        int idx; 
+        int mlen; 
+        int midx; 
+        Node() {}
+        Node(int v, int len, int idx):v(v),len(len),idx(idx),mlen(len),midx(idx) {ch[0] = ch[1] = NULL; r = rand();}
+        int cmp(int x) const {
+            if (x == v) return -1;
+            return x < v ? 0 : 1;
+        }
+        void maintain(){
+            mlen = len;
+            midx = idx;
+            if (ch[0] != NULL && (ch[0]->mlen > mlen || (ch[0]->mlen == mlen && ch[0]->midx < midx))){
+                mlen = ch[0]->mlen;
+                midx = ch[0]->midx;
+            }
+            if (ch[1] != NULL && (ch[1]->mlen > mlen || (ch[1]->mlen == mlen && ch[1]->midx < midx))){
+                mlen = ch[1]->mlen;
+                midx = ch[1]->midx;
+            }
+        }
+    };
+    bool findMax(Node* a, Node* b){
+        if (a->mlen < b->mlen || (a->mlen == b->mlen && a->midx > b->midx)){
+            *a = *b;
+            return true;
+        }
+        return false;
+    }
+    namespace Treap{
+        int cntnode;
+        Node node[maxn*10];
+        void init(){
+            cntnode = 0;
+        }
+        Node* newNode(int v, int len, int idx){
+            node[++cntnode] = Node(v, len, idx);
+            return &node[cntnode];
+        }
+        void rotate(Node* &o, int d){
+            Node* k = o->ch[d^1]; o->ch[d^1] = k->ch[d]; k->ch[d] = o;
+            o->maintain(); k->maintain(); o = k;
+        }
+        void insert(Node* &o, int v, int len, int idx){
+            if (o == NULL) o = newNode(v, len, idx);
+            else {
+                int d = o->cmp(v);
+                if (d != -1){
+                    insert(o->ch[d], v, len, idx);
+                    if (o->r < o->ch[d]->r) rotate(o, d^1);
+                }
+                else
+                {
+                    if (len >= o->len){
+                        o->len = len;
+                        o->idx = idx;
+                    }
+                }
+            }
+            o->maintain();
+        }
+        Node search(Node *o, int v){
+            if (o == NULL){
+                return Node(-1, 0, -1);
+            }
+            else{
+                Node re, tmp;
+                if (o->v == v) {
+                    re = Node(o->v, o->len, o->idx);
+                    if (o->ch[1]){
+                        findMax(&re, o->ch[1]);
+                    }
+                }
+                else if (o->v > v){
+                    re = Node(o->v, o->len, o->idx);
+                    if (o->ch[1]){
+                        findMax(&re, o->ch[1]);
+                    }
+                    if (o->ch[0]){
+                        tmp = search(o->ch[0], v);
+                        findMax(&re, &tmp);
+                    }
+                }
+                else{
+                    re = search(o->ch[1], v);
+                }
+                return re;
+            }
+        }
+    }
+    namespace BIT{
+        Node* fwt[maxn];
+        int N;
+        void init(int n){
+            N = n;
+            memset(fwt, 0, sizeof fwt);
+        }
+        void add(int v1, int v2, int len, int idx){
+            while(v1 < N){
+                Treap::insert(fwt[v1], v2, len, idx);
+                v1 += (-v1)&v1;
+            }
+        }
+        Node query(int v1, int v2){
+            Node re, tmp;
+            re = Node(-1, 0, -1);
+            while(v1 > 0){
+                tmp = Treap::search(fwt[v1], v2);
+                findMax(&re, &tmp);
+                v1 -= (-v1)&v1;
+            }
+            return re;
+        }
+    }
+    struct Pe{
+        int L,R;
+        int i;
+        bool operator < (const Pe& rhs)const{
+            return L < rhs.L;
+        }
+    };
+    bool cmp(Pe a, Pe b){
+        return a.i < b.i;
+    }
+    int solo[maxn];
+    Pe pe[maxn];int pre[maxn];
+    void print(Node& a){
+        int id = a.midx;
+        printf("%d\n", a.mlen);
+        while(1){
+            printf("%d", id+1);
+            if (pre[id] == -1){
+                break;
+            }
+            printf(" ");
+            id = pre[id];
+        }
+        printf("\n");
+    }
+    int main(){
+        int n;
+        while(scanf("%d", &n) != EOF){
+            for(int i=0;i<n;i++){
+                pe[i].i = i;
+                scanf("%d", &pe[i].L);
+            }
+            for(int i=0;i<n;i++){
+                scanf("%d", &pe[i].R);
+            }
+            sort(pe, pe+n);
+            int m = 0;
+            solo[0] = ++m;
+            for(int i=1;i<n;i++){
+                if (pe[i].L != pe[i-1].L){
+                    solo[i] = ++m;
+                }
+                else{
+                    solo[i] = solo[i-1];
+                }
+            }
+            for(int i=0;i<n;i++){
+                pe[i].L = solo[i];
+            }
+            sort(pe, pe+n, cmp);
+            BIT::init(m+1);
+            Treap::init();
+            Node ans = Node(-1, 0, -1), tmp;
+            for(int i=n-1;i>=0;i--){
+                tmp = BIT::query(pe[i].L, pe[i].R);
+                pre[i] = tmp.midx;
+                tmp.mlen = tmp.mlen + 1;
+                tmp.midx = i;
+                BIT::add(pe[i].L, pe[i].R, tmp.mlen, tmp.midx);
+                findMax(&ans, &tmp);
+            }
+            print(ans);
+        }
+        return 0;
+    }
diff --git a/HDOJ/5325_autoAC.cpp b/HDOJ/5325_autoAC.cpp
new file mode 100644
index 0000000..b939b24
--- /dev/null
+++ b/HDOJ/5325_autoAC.cpp
@@ -0,0 +1,44 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <vector>
+#include <queue>
+using namespace std;
+const int MAXN = 5e5 + 10;
+const int INF = 0x3f3f3f3f;
+int w[MAXN];
+int cnt[MAXN];
+int deg[MAXN];
+vector<int> G[MAXN];
+int n;
+int BFS(void)   {
+    queue<int> Q;   int ret = 0;
+    for (int i=1; i<=n; ++i)    cnt[i] = 1;
+    for (int i=1; i<=n; ++i)    {
+        if (!deg[i])    Q.push (i);
+    }
+    while (!Q.empty ()) {
+        int u = Q.front (); Q.pop ();
+        ret = max (ret, cnt[u]);
+        for (int i=0; i<G[u].size (); ++i)   {
+            int v = G[u][i];
+            cnt[v] += cnt[u];
+            if (!(--deg[v]))    Q.push (v);
+        }
+    }
+    return ret;
+}
+int main(void)  {
+    while (scanf ("%d", &n) == 1)   {
+        for (int i=1; i<=n; ++i)    scanf ("%d", &w[i]);
+        for (int i=1; i<=n; ++i)    G[i].clear ();
+        memset (deg, 0, sizeof (deg));
+        for (int i=1; i<=n-1; ++i)  {
+            int u, v;   scanf ("%d%d", &u, &v);
+            if (w[u] < w[v])    swap (u, v);    
+            G[u].push_back (v); deg[v]++;
+        }
+        printf ("%d\n", BFS ());
+    }
+    return 0;
+}
diff --git a/HDOJ/5326_autoAC.cpp b/HDOJ/5326_autoAC.cpp
new file mode 100644
index 0000000..be99c3a
--- /dev/null
+++ b/HDOJ/5326_autoAC.cpp
@@ -0,0 +1,54 @@
+#include <iostream>
+#include <stdio.h>
+#include <memory.h>
+using namespace std;
+const int MAX=100+5;
+int a[MAX][MAX];
+int b[MAX];
+void dfs(int j,int jj,int num,int n)
+{
+    for(int k=jj;k<=n;k++)
+    {
+        if(a[j][ k ])
+        {
+            b[num]++;
+            dfs(k,1,num,n);
+        }
+    }
+}
+int main()
+{
+    int n,k;
+    while(~scanf("%d %d",&n,&k))
+    {
+        int ans=0;
+        int A,B;
+        memset(a,0,sizeof(a));
+        memset(b,0,sizeof(b));
+        for(int i=1;i<n;i++)
+        {
+            scanf("%d %d",&A,&B);
+            a[A][B]=1;
+        }
+        for(int i=1;i<=n;i++)
+        {
+            for(int j=1;j<=n;j++)
+            {
+                if(a[i][j])
+                {
+            b[i]++;
+                    dfs(j,1,i,n);
+                }
+            }
+        }
+        for(int i=1;i<=n;i++)
+        {
+            if(b[i]==k)
+            {
+                ans++;
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5327_autoAC.cpp b/HDOJ/5327_autoAC.cpp
new file mode 100644
index 0000000..b36b08a
--- /dev/null
+++ b/HDOJ/5327_autoAC.cpp
@@ -0,0 +1,31 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+using namespace std;
+int num[111111];
+bool vis[10];
+int main()
+{
+    int i,j = 10,t,l,r;
+    num[0] = 0;
+    for(i = 1; i <= 100000; ++i)
+    {
+        memset(vis,0,sizeof(vis));
+        j = i;
+        while(j)
+        {
+            if(!vis[j%10]) vis[j%10] = 1;
+            else break;
+            j /= 10;
+        }
+        num[i] = num[i-1];
+        if(!j) num[i]++;
+    }
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d %d",&l,&r);
+        printf("%d\n",num[r]-num[l-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5328_autoAC.cpp b/HDOJ/5328_autoAC.cpp
new file mode 100644
index 0000000..0baa51d
--- /dev/null
+++ b/HDOJ/5328_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+using namespace std;
+int main(){
+            int T,n;
+            double a,b;
+            double ap,gp;
+            int sumap,sumgp,ans;
+            scanf("%d",&T);
+            while(T--){
+                        scanf("%d",&n);
+                        sumap = 2,sumgp = 2,ans = 2;
+                        scanf("%lf",&a);
+                        if(n==1)    {
+                                    printf("1\n");
+                                    continue;
+                        }
+                        scanf("%lf",&b);
+                        ap = b-a;
+                        gp = b/a;
+                        a = b;
+                        double tmap,tmgp;
+                        for(int i=2;i<n;i++){
+                                    scanf("%lf",&b);
+                                    tmap = b-a;
+                                    tmgp = b/a;
+                                    if(ap == tmap)          sumap++;
+                                    else{
+                                                ans = max(ans,sumap);
+                                                sumap = 2;
+                                                ap = tmap;
+                                    }
+                                    if(gp == tmgp)          sumgp++;
+                                    else{
+                                                ans = max(ans,sumgp);
+                                                sumgp = 2;
+                                                gp = tmgp;
+                                    }
+                                    a = b;
+                        }
+                        ans = max(ans,sumap);
+                        ans = max(ans,sumgp);
+                        printf("%d\n",ans);
+            }
+            return 0;
+}
diff --git a/HDOJ/5329_autoAC.cpp b/HDOJ/5329_autoAC.cpp
new file mode 100644
index 0000000..9392edd
--- /dev/null
+++ b/HDOJ/5329_autoAC.cpp
@@ -0,0 +1,126 @@
+#pragma comment(linker, "/STACK:16777216")
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<ctype.h>
+#include<math.h>
+#include<map>
+#include<set>
+#include<vector>
+#include<queue>
+#include<functional>
+#include<string>
+#include<algorithm>
+#include<time.h>
+#include<bitset>
+using namespace std;
+const int maxn = 200005;
+const int maxm = 400005;
+struct Edge
+{
+    int v;
+    Edge *next;
+}E[maxm], *edges, *H[maxn];
+int tsum[maxn];
+int size[maxn];
+int sum[maxn];
+int dfn[maxn];
+int low[maxn];
+int bcc[maxn];
+int cnt[maxn];
+int fa[maxn];
+int a[maxn];
+int c[maxn];
+int n, m, tcnt, K, dfs_clock, ok;
+void addedges(int u, int v)
+{
+    edges->v = v;
+    edges->next = H[u];
+    H[u] = edges++;
+}
+void init()
+{
+    dfs_clock = 0;
+    tcnt = 0;
+    edges = E;
+    for(int i = 0; i <= n; i++) {
+        H[i] = 0;
+        dfn[i] = low[i] = bcc[i] = cnt[i] = 0;
+    }
+}
+void dfs(int u)
+{
+    dfn[u] = low[u] = ++dfs_clock;
+    for(Edge *e = H[u]; e; e = e->next) if(e->v != fa[u]) {
+        int v = e->v;
+        if(!dfn[v]) {
+            fa[v] = u;
+            dfs(v);
+            low[u] = min(low[u], low[v]);
+        }
+        else low[u] = min(low[u], dfn[v]);
+        if(fa[v] != u && dfn[u] < dfn[v]) {
+            int vn = v;
+            bcc[u] = true;
+            a[++tcnt] = u;
+            do {
+                a[++tcnt] = vn;
+                bcc[vn] = true;
+                vn = fa[vn];
+            }while(vn != u);
+        }
+    }
+}
+void DFS(int u, int f)
+{
+    size[u] = 1;
+    for(Edge *e = H[u]; e; e = e->next) if(!bcc[e->v] && e->v != f) {
+        int v = e->v;
+        DFS(v, u);
+        size[u] += size[v];
+    }
+}
+void work()
+{
+    int u, v;
+    for(int i = 1; i <= n; i++) {
+        scanf("%d", &v);
+        addedges(i, v);
+        addedges(v, i);
+    }
+    dfs(1);
+    int ans = 0;
+    for(int i = tcnt+1; i <= 2 * tcnt; i++) a[i] = a[i - tcnt];
+    for(int i = 1; i <= n; i++) if(bcc[i]) DFS(i, i); 
+    for(int i = 1; i <= n; i++) if(!bcc[i]) cnt[size[i]]++;
+    for(int i = 1; i <= n; i++)
+        for(int j = i + i; j <= n; j += i) 
+            cnt[i] += cnt[j];
+    for(int i = 1; i <= n; i++) if(n % i == 0) {
+        K = i;
+        int tt = n / K - cnt[K];
+        for(int i = 1; i <= tcnt; i++) sum[i] = size[a[i]] % K;
+        for(int i = tcnt + 1; i <= 2 * tcnt; i++) sum[i] = sum[i - tcnt];
+        for(int i = 1; i <= 2 * tcnt; i++) sum[i] = (sum[i] + sum[i-1]) % K;
+        for(int i = 0; i <= K; i++) c[i] = -1;
+        for(int i = 0; i <= 2 * tcnt; i++) {
+            if(c[sum[i]] != -1) tsum[i] = tsum[c[sum[i]]] + 1;
+            c[sum[i]] = i;
+        }
+        for(int i = tcnt+1; i <= 2 * tcnt; i++) {
+            if(tsum[i] - tsum[i-tcnt] >= tt) {
+                ans++;
+                break;
+            }
+        }
+    }
+    printf("%d\n", ans);
+}
+int main()
+{
+    while(scanf("%d", &n) != EOF) {
+        init();
+        work();
+    }
+    return 0;
+}
diff --git a/HDOJ/5330_autoAC.cpp b/HDOJ/5330_autoAC.cpp
new file mode 100644
index 0000000..47895ad
--- /dev/null
+++ b/HDOJ/5330_autoAC.cpp
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#include<cstdio>
+#include<vector>
+using namespace std;
+int pow3[20];
+int dp[2][200000][24];
+char w[12];
+long long ans[100];
+int num[200000];
+int main(){
+    pow3[0] = 1;
+    for(int i = 1;i <= 11; i++)
+        pow3[i] = pow3[i-1]*3;
+    int t,m,n;
+    scanf("%d",&t);
+    for(int tt = 1; tt <= t; tt++){
+        memset(dp,0,sizeof(dp));
+        memset(num,0,sizeof(num));
+        scanf("%d%d",&n,&m);
+        for(int i = 0;i < n; i++){
+            scanf("%s",w);
+            int u = 0;
+            for(int j = 0;j < m; j++){
+                u = u*3+w[j]-'0';
+            }
+            dp[0][u][0]++;
+            num[u]++;
+        }
+        int p = 0, q = 1,s0,s1,s2;
+        for(int mm=1;mm<=m;mm++){
+            memset(dp[q],0,sizeof(dp[q]));
+            for(int i = 0;i < pow3[mm-1];i++){
+                for(int j = 0;j < pow3[m-mm];j++){
+                    for(int d = 0; d <= 2*m;d++){
+                        s0 = i+j*pow3[mm];
+                        s1 = s0 + pow3[mm-1];
+                        s2 = s1 + pow3[mm-1];
+                        dp[q][s0][d] += dp[p][s0][d];
+                        dp[q][s1][d] += dp[p][s1][d];
+                        dp[q][s2][d] += dp[p][s2][d];
+                        if(d > 0){
+                            dp[q][s0][d] += dp[p][s1][d-1];
+                            dp[q][s1][d] += dp[p][s0][d-1];
+                            dp[q][s1][d] += dp[p][s2][d-1];
+                            dp[q][s2][d] += dp[p][s1][d-1];
+                        }
+                        if(d > 1){
+                            dp[q][s0][d] += dp[p][s2][d-2];
+                            dp[q][s2][d] += dp[p][s0][d-2];
+                        }
+                    }
+                }
+            }
+            swap(p,q);
+        }
+        memset(ans,0,sizeof(ans));
+        for(int i = 0;i < pow3[m]; i++){
+            ans[0] += 1ll*num[i]*(num[i]-1);
+            for(int j = 1 ;j <= 2*m; j++)
+                ans[j] += 1ll*num[i]*dp[p][i][j];
+        }
+        for(int i = 0;i <= 2*m; i++)
+            printf("%I64d\n",ans[i]/2);
+    }
+    return 0;
+}
diff --git a/HDOJ/5332_autoAC.cpp b/HDOJ/5332_autoAC.cpp
new file mode 100644
index 0000000..6b994fc
--- /dev/null
+++ b/HDOJ/5332_autoAC.cpp
@@ -0,0 +1,43 @@
+#include <iostream>
+using namespace std;
+long long a[35][35];
+long long b[35][35];
+long long c[35][35];
+int main() {
+  int cas;
+  std::cin >> cas;
+  while (cas --) {
+    long long k;
+    std::cin >> k;
+    std::cout << 30 << ' ' << 20 << "\n";
+    for (int i = 0; i <= 30; i ++) {
+      for (int j = 0; j <= 30; j ++) {
+        a[i][j] = 0;
+      }
+    }
+    for (int i = 1; i <= 10; i ++) {
+      a[0][i] = 1;
+      for (int j = 1; j <= 10; j ++) {
+        a[i][j] = 1;
+      }
+    }
+    for (int i = 11; i <= 28;  i++) {
+      a[i][i + 1] = 1;
+    }
+    int cur = 11;
+    while (k) {
+      int m = k % 10;
+      k /= 10;
+      for (int i = 1; i <= m; i++) {
+        a[i][cur] = 1;
+      }
+      cur ++;
+    }
+    for (int i = 0; i <= 29; i ++) {
+      for (int j = 0; j <= 29; j ++)
+        std::cout << a[i][j];
+      std::cout << "\n";
+    }
+  }
+  return 0;
+}
diff --git a/HDOJ/5333_autoAC.cpp b/HDOJ/5333_autoAC.cpp
new file mode 100644
index 0000000..d5ee045
--- /dev/null
+++ b/HDOJ/5333_autoAC.cpp
@@ -0,0 +1,229 @@
+#pragma comment(linker, "/STACK:1024000000")
+#include <stdio.h>
+#include <string.h>
+#include <map>
+#include <algorithm>
+using namespace std ;
+typedef long long LL ;
+#define clr( a , x ) memset ( a , x , sizeof a )
+#define ls ( o << 1 )
+#define rs ( o << 1 | 1 )
+#define lson ls , l , m
+#define rson rs , m + 1 , r
+#define root 1 , 1 , n
+#define mid ( ( l + r ) >> 1 )
+const int MAXN = 100005 ;
+const int MAXE = 200005 ;
+const int INF = 0x3f3f3f3f ;
+struct Edge {
+    int v , idx , n ;
+    Edge () {}
+    Edge ( int v , int idx , int n ) : v ( v ) , idx ( idx ) , n ( n ) {}
+} ;
+struct Node* null ;
+struct Node {
+    Node* c[2] ;
+    Node* f ;
+    bool flip ;
+    int minv , val ;
+    int eidx , idx ;
+    void newnode ( int v , int i ) {
+        c[0] = c[1] = f = null ;
+        minv = val = v ;
+        eidx = idx = i ;
+        flip = 0 ;
+    }
+    void rev () {
+        if ( this == null ) return ;
+        swap ( c[0] , c[1] ) ;
+        flip ^= 1 ;
+    }
+    void up () {
+        if ( this == null ) return ;
+        if ( val <= c[0]->minv && val <= c[1]->minv ) {
+            minv = val ;
+            eidx = idx ;
+        } else if ( c[0]->minv <= c[1]->minv && c[0]->minv <= val ) {
+            minv = c[0]->minv ;
+            eidx = c[0]->eidx ;
+        } else {
+            minv = c[1]->minv ;
+            eidx = c[1]->eidx ;
+        }
+    }
+    void down () {
+        if ( this == null ) return ;
+        if ( flip ) {
+            c[0]->rev () ;
+            c[1]->rev () ;
+            flip = 0 ;
+        }
+    }
+    bool is_root () {
+        return f == null || f->c[0] != this && f->c[1] != this ;
+    }
+    void sign_down () {
+        if ( !is_root () ) f->sign_down () ;
+        down () ;
+    }
+    void setc ( Node* o , int d ) {
+        c[d] = o ;
+        o->f = this ;
+    }
+    void rot ( int d ) {
+        Node* p = f ;
+        Node* g = f->f ;
+        p->setc ( c[d] , !d ) ;
+        if ( !p->is_root () ) g->setc ( this , f == g->c[1] ) ;
+        else f = g ;
+        setc ( p , d ) ;
+        p->up () ;
+    }
+    void splay () {
+        sign_down () ;
+        while ( !is_root () ) {
+            if ( f->is_root () ) rot ( this == f->c[0] ) ;
+            else {
+                if ( f == f->f->c[0] ) {
+                    if ( this == f->c[0] ) f->rot ( 1 ) , rot ( 1 ) ;
+                    else rot ( 0 ) , rot ( 1 ) ;
+                } else {
+                    if ( this == f->c[1] ) f->rot ( 0 ) , rot ( 0 ) ;
+                    else rot ( 1 ) , rot ( 0 ) ;
+                }
+            }
+        }
+        up () ;
+    }
+    void access () {
+        Node* o = this ;
+        for ( Node* x = null ; o != null ; x = o , o = o->f ) {
+            o->splay () ;
+            o->setc ( x , 1 ) ;
+            o->up () ;
+        }
+        splay () ;
+    }
+    void make_root () {
+        access () ;
+        rev () ;
+    }
+    void link ( Node* o ) {
+        make_root () ;
+        f = o ;
+    }
+    void cut () {
+        access () ;
+        c[0] = c[0]->f = null ;
+        up () ;
+    }
+    void cut ( Node* o ) {
+        make_root () ;
+        o->cut () ;
+    }
+    int get_min ( Node* o ) {
+        make_root () ;
+        o->access () ;
+        return o->eidx ;
+    } 
+} ;
+Node pool[MAXN + MAXE] ;
+Node* cur ;
+Node* node[MAXN] ;
+Node* edge[MAXE] ;
+Edge E[MAXE + MAXN] ;
+int H[MAXN] , Q[MAXN] , cntE ;
+int U[MAXE] , V[MAXE] ;
+int ans[MAXN] ;
+int p[MAXN] ;
+int c[MAXN] ;
+int n , m , q ;
+int find ( int x ) {
+    return p[x] == x ? x : ( p[x] = find ( p[x] ) ) ;
+}
+void init ( int n ) {
+    cntE = 0 ;
+    cur = pool ;
+    cur->newnode ( INF , -1 ) ;
+    null = cur ++ ;
+    for ( int i = 1 ; i <= n ; ++ i ) {
+        p[i] = i ;
+        H[i] = -1 ;
+        Q[i] = -1 ;
+        c[i] = 0 ;
+        cur->newnode ( INF , -1 ) ;
+        node[i] = cur ++ ;
+    }
+}
+void addedge ( int u , int v , int idx , int H[] ) {
+    E[cntE] = Edge ( v , idx , H[u] ) ;
+    H[u] = cntE ++ ;
+}
+void add ( int x , int v ) {
+    for ( ; x <= n ; x += x & -x ) c[x] += v ;
+}
+int sum ( int x , int ans = 0 ) {
+    for ( ; x > 0 ; x -= x & -x ) ans += c[x] ;
+    return ans ;
+}
+void scanf ( int& x , char c = 0 ) {
+    while ( ( c = getchar () ) < '0' ) ;
+    x = c - '0' ;
+    while ( ( c = getchar () ) >= '0' ) x = x * 10 + c - '0' ;
+}
+void solve () {
+    int cnt = 0 ;
+    int u , v ;
+    init ( n ) ;
+    for ( int i = 1 ; i <= n ; ++ i ) add ( i , -1 ) ;
+    for ( int i = 0 ; i < m ; ++ i ) {
+        scanf ( "%d%d" , &u , &v ) ;
+        if ( u == v ) continue ;
+        if ( u < v ) swap ( u , v ) ;
+        addedge ( u , v , i , H ) ;
+        U[i] = u ;
+        V[i] = v ;
+        cur->newnode ( v , i ) ;
+        edge[i] = cur ++ ;
+    }
+    for ( int i = 0 ; i < q ; ++ i ) {
+        scanf ( "%d%d" , &u , &v ) ;
+        addedge ( v , u , i , Q ) ;
+    }
+    for ( int i = 1 ; i <= n ; ++ i ) {
+        ++ cnt ;
+        for ( int j = H[i] ; ~j ; j = E[j].n ) {
+            int v = E[j].v , idx = E[j].idx ;
+            if ( v == i ) continue ;
+            int x = find ( i ) ;
+            int y = find ( v ) ;
+            if ( x != y ) {
+                -- cnt ;
+                p[x] = y ;
+                edge[idx]->link ( node[i] ) ;
+                edge[idx]->link ( node[v] ) ;
+                add ( v , 1 ) ;
+            } else {
+                int eidx = node[i]->get_min ( node[v] ) ;
+                if ( V[eidx] >= v ) continue ;
+                edge[eidx]->cut ( node[U[eidx]] ) ;
+                edge[eidx]->cut ( node[V[eidx]] ) ;
+                add ( V[eidx] , -1 ) ;
+                edge[idx]->link ( node[i] ) ;
+                edge[idx]->link ( node[v] ) ;
+                add ( v , 1 ) ;
+            }
+        }
+        for ( int j = Q[i] ; ~j ; j = E[j].n ) {
+            int v = E[j].v , idx = E[j].idx ;
+            ans[idx] = cnt + sum ( v - 1 ) + n - i + v - 1 ;
+        }
+    }
+    for ( int i = 0 ; i < q ; ++ i ) {
+        printf ( "%d\n" , ans[i] ) ;
+    }
+}
+int main () {
+    while ( ~scanf ( "%d%d%d" , &n , &m , &q ) ) solve () ;
+    return 0 ;
+}
diff --git a/HDOJ/5334_autoAC.cpp b/HDOJ/5334_autoAC.cpp
new file mode 100644
index 0000000..b555321
--- /dev/null
+++ b/HDOJ/5334_autoAC.cpp
@@ -0,0 +1,79 @@
+#include<stdio.h>
+#include<string.h>
+int a[1000000],ans[1000000];
+int cnt;
+int f(int x){
+    int l=1,r=cnt;
+    int mid;
+    while(l<r){
+        mid=(l+r)/2;
+        if(x>a[mid]) l=mid+1;
+        else r=mid;
+    }
+    return r;
+}
+int main(){
+    int k,l,r;
+    cnt=1;
+    a[0]=0;
+    for(cnt=1;;cnt++){
+        if(cnt+a[cnt-1]>1000000000) {a[cnt]=cnt+a[cnt-1]; break;}
+        else a[cnt]=cnt+a[cnt-1];
+    }
+    while(scanf("%d",&k)!=EOF){
+        if(k<=100000){
+            printf("%d\n",k);
+            for(int i=1;i<k;i++)
+            printf("1 ");
+            printf("1\n");
+        }
+        else {
+            int tmp=f(k);
+            while(k>a[tmp]) tmp++;
+            if(k==a[tmp]){
+                printf("%d\n",tmp);
+                for(int i=1;i<tmp;i++){
+                    printf("%d ",i);
+                }
+                printf("%d\n",tmp);
+            }
+            else {
+                l=tmp-1;
+                r=tmp;
+                int x=a[tmp]-k,c=1,d;
+                while(x){
+                    d=f(x);
+                    if(x==a[d]){
+                        ans[c++]=d+1;
+                        break;
+                    }
+                    else {
+                        ans[c++]=d;
+                        x-=a[d-1];
+                    }
+                }
+                int t=1,sum=0;
+                printf("%d\n",tmp);
+                for(int i=1;i<c;i++){
+                    sum+=ans[i];
+                    for(int j=1;j<=ans[i];j++)
+                    {
+                    printf("%d",t);
+                    if(sum!=tmp) printf(" ");
+                    else {
+                        if(j==ans[i]) printf("\n");
+                        else printf(" ");
+                    }
+                    }
+                    t++;
+                }
+                if(sum<tmp)
+                {for(int i=sum+1;i<tmp;i++){
+                    printf("%d ",t);t++;
+                }
+                printf("%d\n",t);}
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5335_autoAC.cpp b/HDOJ/5335_autoAC.cpp
new file mode 100644
index 0000000..8ed5cda
--- /dev/null
+++ b/HDOJ/5335_autoAC.cpp
@@ -0,0 +1,141 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<vector>
+#include<queue>
+using namespace std;
+const int maxn=1008;
+const int INF=0x7f7f7f7f;
+char mp[maxn][maxn];
+int dir[2][2]={1,0,0,1};
+int di[4][2]={1,0,0,1,-1,0,0,-1};
+int n,m;
+struct poi{
+    int x,y,t;
+}f[maxn*maxn];
+struct fuck{
+    int x,y;
+};
+fuck pa[maxn][maxn],papa[maxn<<4];
+bool flag[maxn<<4],done[maxn][maxn];
+int idx=0;
+int cmp(poi a,poi b)
+{
+    return a.t>b.t;
+}
+void rigou()
+{
+    int i,nx,ny,x,y,t;
+    sort(f+1,f+1+idx,cmp);
+    queue<poi> q;
+    q.push((poi){f[1].x,f[1].y,1});
+    done[f[1].x][f[1].y]=true;
+    for(i=2;i<=idx;i++)
+    {
+        if(f[i].t==f[i-1].t)
+        {
+                q.push((poi){f[i].x,f[i].y,1});
+                done[f[i].x][f[i].y]=true;
+            }
+        else
+            break;
+        }
+    memset(done,false,sizeof(done));
+    memset(flag,false,sizeof(flag));
+    memset(pa,-1,sizeof(pa));
+    poi pp;
+    while(!q.empty())
+    {
+        pp=q.front();q.pop();
+        x=pp.x;y=pp.y;t=pp.t;
+        if(flag[t]==true&&mp[x][y]=='1')    continue;
+        for(i=0;i<2;i++)
+        {
+            nx=x+dir[i][0];
+            ny=y+dir[i][1];
+            if(mp[nx][ny]!='\0'&&!done[nx][ny])
+            {
+                q.push((poi){nx,ny,t+1});
+                if(mp[nx][ny]=='0')
+                    flag[t+1]=true;
+                pa[nx][ny].x=x;pa[nx][ny].y=y;
+                done[nx][ny]=true;
+            }
+        }
+    }
+}
+bool bfs(int x,int y)
+{
+    int nx,ny,i;
+    queue<fuck> q;
+    if(mp[x][y]=='0')
+    {
+        q.push((fuck){x,y});
+        fuck pp;
+        memset(done,false,sizeof(done));
+        while(!q.empty())
+        {
+            pp=q.front();q.pop();
+            x=pp.x;y=pp.y;
+            for(i=0;i<4;i++)
+            {
+                nx=x+di[i][0];
+                ny=y+di[i][1];
+                if(mp[nx][ny]=='1'){
+                    f[++idx].x=nx;
+                    f[idx].y=ny;
+                    f[idx].t=nx+ny;
+                }
+                if(mp[nx][ny]=='0'&&!done[nx][ny])
+                {
+                    done[nx][ny]=true;
+                    if(nx==n&&ny==m)
+                        return false;
+                    q.push((fuck){nx,ny});
+                }
+            }
+        }
+    }
+    else
+    {
+        f[++idx].x=1;f[idx].y=1;f[idx].t=2;
+    }
+    return true;
+}
+int main()
+{
+    int i,j,t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&m);
+        idx=0;
+        memset(mp,'\0',sizeof(mp));
+        for(i=1;i<=n;i++)
+            scanf("%s",mp[i]+1);
+        if(bfs(1,1))
+        {
+           rigou();
+           int x=n,y=m,id=0,nx,ny;
+           papa[id].x=n;papa[id].y=m;
+        while(pa[x][y].x!=-1)
+        {
+            papa[++id].x=pa[x][y].x;
+            papa[id].y=pa[x][y].y;
+            nx=pa[x][y].x;
+            ny=pa[x][y].y;
+            x=nx;y=ny;
+        }
+        for(i=id;i>=0;i--)
+        {
+            x=papa[i].x;
+            y=papa[i].y;
+            printf("%c",mp[x][y]);
+        }
+        }
+        else    
+          printf("0");
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5336_autoAC.cpp b/HDOJ/5336_autoAC.cpp
new file mode 100644
index 0000000..75adf9c
--- /dev/null
+++ b/HDOJ/5336_autoAC.cpp
@@ -0,0 +1,126 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <string>
+#include <cmath>
+#include <cstdlib>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+using namespace std;
+const int dir_x[4]={0,0,-1,1};
+const int dir_y[4]={1,-1,0,0};
+int r,c,n,T;
+int mid[111][111];
+int SZ[111],Time[111];
+int X[111],Y[111];
+void init()
+{
+    memset(SZ,0,sizeof(SZ));
+    memset(mid,0,sizeof(mid));
+    memset(Time,0,sizeof(Time));
+}
+struct Node
+{
+    int x,y,d,t;
+    void toString()
+    {
+        printf("(%d,%d) d: %d t: %d\n",x,y,d,t);
+    }
+};
+bool isInside(int x,int y)
+{
+    if((x>=1&&x<=r)&&(y>=1&&y<=c)) return true;
+    return false;
+}
+void solve(int _x,int _y)
+{
+    queue<Node> q;
+    for(int i=0;i<4;i++)
+    {
+        Node nd;
+        nd.x=_x; nd.y=_y; nd.d=i; nd.t=0;
+        q.push(nd);
+    }
+    while(!q.empty())
+    {
+        Node u=q.front(); q.pop();
+        int bbb=-1;
+        int d=u.d;
+        Node v;
+        v.x=u.x+dir_x[d];
+        v.y=u.y+dir_y[d];
+        v.d=u.d;
+        v.t=u.t+1;
+        if(isInside(v.x,v.y)==false) continue;
+        int id=mid[v.x][v.y];
+        if(id==0)
+        {
+            if(v.t<T)
+            {
+                q.push(v);
+            }
+        }
+        else
+        {
+            if(Time[id]!=0)
+            {
+                if(Time[id]>=v.t) continue;
+                else
+                {
+                    if(v.t<T)
+                    {
+                        q.push(v);
+                    }
+                }
+            }
+            else if(Time[id]==0)
+            {
+                SZ[id]++;
+                if(SZ[id]>4)
+                {
+                    Time[id]=v.t;
+                    bbb=id;
+                }
+            }
+        }
+        if(bbb!=-1)
+        {
+            for(int j=0;j<4;j++)
+            {
+                Node n1;
+                n1.x=X[bbb]; n1.y=Y[bbb];
+                n1.d=j; n1.t=v.t;
+                if(n1.t<T) 
+                {
+                    q.push(n1);
+                }
+            }
+        }
+    }
+}
+int main()
+{
+    while(scanf("%d%d%d%d",&r,&c,&n,&T)!=EOF)
+    {
+        init();
+        for(int i=1,s;i<=n;i++)
+        {
+            scanf("%d%d%d",X+i,Y+i,&s);
+            int x=X[i],y=Y[i];
+            mid[x][y]=i;
+            SZ[i]=s;
+        }
+        int x,y;
+        scanf("%d%d",&x,&y);
+        solve(x,y);
+        for(int i=1;i<=n;i++)
+        {
+            if(Time[i]!=0) printf("%d %d\n",0,Time[i]);
+            else printf("%d %d\n",1,SZ[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5338_autoAC.cpp b/HDOJ/5338_autoAC.cpp
new file mode 100644
index 0000000..b588406
--- /dev/null
+++ b/HDOJ/5338_autoAC.cpp
@@ -0,0 +1,155 @@
+ #include <iostream>
+    #include <cstdio>
+    #include <cstdlib>
+    #include <cstring>
+    #include <algorithm>
+    #include <map>
+    using namespace std;
+    const int maxn = 100010;
+    typedef long long LL;
+    int a[maxn], vidx[maxn];
+    int vis[maxn], flg[maxn];
+    namespace SegmentTree{
+        int maxv[maxn<<2]; int setv[maxn<<2];
+        #define Lson o<<1
+        #define Rson o<<1|1
+        void pushup(int o){
+            maxv[o] = max(maxv[Lson], maxv[Rson]);
+        }
+        void build(int o, int l, int r){
+            int m = (l+r)>>1;
+            if(l == r){
+                maxv[o] = a[l];
+                setv[o] = -1;
+            }
+            else {
+                build(Lson, l, m);
+                build(Rson, m+1, r);
+                setv[o] = -1;
+                pushup(o);
+            }
+        }
+        void pushdown(int o){
+            if (setv[o] >= 0){
+                setv[Lson] = setv[Rson] = setv[o];
+                maxv[Lson] = maxv[Rson] = setv[o];
+                setv[o] = -1;
+            }
+        }
+        int v, ul, ur;
+        void update(int o, int l, int r){
+            if(l > r) return ;
+            if (ul <= l && r <= ur){
+                setv[o] = v;
+                maxv[o] = v;
+            }
+            else{
+                pushdown(o);
+                int m = (l+r)>>1;
+                if (ul <= m) update(Lson, l, m);
+                if (ur > m) update(Rson, m+1, r);
+                pushup(o);
+            }
+        }
+        int _max, ql, qr;
+        void query(int o, int l, int r){
+            if(l>r) return ;
+            if (setv[o] >= 0){
+                _max = max(_max, setv[o]);
+            }
+            else if (ql <= l && r <= qr){
+                _max = max(_max, maxv[o]);
+            }
+            else {
+                int m = (l+r)>>1;
+                pushdown(o);
+                if(ql <= m) query(Lson, l, m);
+                if(qr > m) query(Rson, m+1, r);
+            }
+        }
+    }
+    namespace BS{
+        typedef pair<int,int> seg;
+        #define l first
+        #define r second
+        #define MP make_pair
+        int n;
+        map<int,int> mp;
+        void init(){
+            mp.clear();
+        }
+        void add(int l, int r){
+            seg line = MP(l, r);
+            mp.insert(line);
+        }
+        int search(int v){
+            map<int,int>::iterator it = mp.upper_bound(v);
+            if (it == mp.begin()){
+                return 0;
+            }
+            else{
+                --it;
+                return it->r;
+            }
+        }
+    }
+    int ans[maxn];
+    void link(int l, int r){
+        for(int i=l; i<r; i++){
+            ans[a[i]] = a[i+1];
+        }
+        ans[a[r]] = a[l];
+    }
+    int main(){
+        int T, n;
+        scanf("%d",&T);
+        while(T--){
+            scanf("%d", &n);
+            for(int i=1;i<=n;i++){
+                scanf("%d",&a[i]);
+                vidx[a[i]] = i;
+            }
+            memset(vis, 0, sizeof vis);
+            memset(flg, 0, sizeof flg);
+            SegmentTree::build(1,1,n);
+            BS::init();
+            for(int _i=1;_i<=n;_i++){
+                int i = vidx[_i];
+                if (vis[i]) continue;
+                int id = i, mx=0;
+                if(!flg[_i]) mx = _i;
+                SegmentTree::ql = BS::search(i) + 1;
+                SegmentTree::qr = id-1;
+                SegmentTree::_max = 0;
+                SegmentTree::query(1,1,n);
+                mx = max(mx, SegmentTree::_max);
+                if (!vis[i+1] && i < n){
+                    mx = max(mx, a[i+1]);
+                    if (mx == a[i+1]){
+                        ans[_i] = a[i+1];
+                        flg[a[i+1]] = 1;
+                        SegmentTree::ul = i+1;
+                        SegmentTree::ur = i+1;
+                        SegmentTree::v = 0;
+                        SegmentTree::update(1,1,n);
+                        continue;
+                    }
+                }
+                int l = min(vidx[mx], i),r = max(vidx[mx], i);
+                link(l, r);
+                for(int j = l; j <= r; j++){
+                    vis[j] = 1;
+                    flg[a[j]] = 1;
+                }
+                BS::add(l, r);
+                SegmentTree::ul = l;
+                SegmentTree::ur = r;
+                SegmentTree::v = 0;
+                SegmentTree::update(1,1,n);
+            }
+            for(int i=1; i <= n; i++){
+                printf("%d%c", ans[i], i<n?' ':'\n');
+            }
+        }
+        return 0;
+    }
diff --git a/HDOJ/5339_autoAC.cpp b/HDOJ/5339_autoAC.cpp
new file mode 100644
index 0000000..2d5425b
--- /dev/null
+++ b/HDOJ/5339_autoAC.cpp
@@ -0,0 +1,41 @@
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+using namespace std;
+int b[50],temp[50];
+int cmp(int a,int b){
+    return a>b;
+}
+int main(){
+    int n,a,t,i,j,k,cur,num,sum,minn,sign;
+    scanf("%d",&t);
+    while(t--){
+    scanf("%d%d",&n,&a);
+    sign=0;
+    for(i=0;i<n;i++)
+    scanf("%d",&b[i]);
+    minn=99999999;
+    sum=1<<n;
+    sort(b,b+n,cmp);           
+    for(i=1;i<sum;i++){        
+       j=i;k=cur=0;num=a;
+       while(j){                
+       if(j&1)temp[cur++]=b[k]; 
+       j>>=1;k++;
+       }
+       if(cur>=minn)           
+       continue;
+       for(j=0;j<cur;j++)
+       num%=temp[j];
+       if(num==0){
+       minn=cur;
+       sign=1;
+       }
+    }
+    if(sign)
+    printf("%d\n",minn);
+    else
+    printf("-1\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5340_autoAC.cpp b/HDOJ/5340_autoAC.cpp
new file mode 100644
index 0000000..a9ee48b
--- /dev/null
+++ b/HDOJ/5340_autoAC.cpp
@@ -0,0 +1,227 @@
+#include <iostream>                                                                
+#include <cstdio>                                                                 
+#include <cmath>                                                                    
+#include <cstdlib>                                                                  
+#include <cstring>                                                                  
+#include <vector>                                                                   
+#include <ctime>                                                                    
+#include <deque>                                                                    
+#include <queue>                                                                    
+#include <algorithm>                                                               
+#include <map>                                                                     
+#include <cmath>                                                                   
+using namespace std;                                                               
+#define pb push_back                                                               
+#define mp make_pair                                                             
+#define X first                                                                     
+#define Y second                                                                    
+#define all(a) (a).begin(), (a).end()                                               
+#define fillchar(a, x) memset(a, x, sizeof(a))                                      
+typedef pair<int, int> pii;                                                         
+typedef long long ll;                                                               
+typedef unsigned long long ull;                                                     
+#ifndef ONLINE_JUDGE                                                                
+void RI(vector<int>&a,int n){a.resize(n);for(int i=0;i<n;i++)scanf("%d",&a[i]);}    
+void RI(){}void RI(int&X){scanf("%d",&X);}template<typename...R>                    
+void RI(int&f,R&...r){RI(f);RI(r...);}void RI(int*p,int*q){int d=p<q?1:-1;          
+while(p!=q){scanf("%d",p);p+=d;}}void print(){cout<<endl;}template<typename T>      
+void print(const T t){cout<<t<<endl;}template<typename F,typename...R>              
+void print(const F f,const R...r){cout<<f<<", ";print(r...);}template<typename T>   
+void print(T*p, T*q){int d=p<q?1:-1;while(p!=q){cout<<*p<<", ";p+=d;}cout<<endl;}   
+#endif // ONLINE_JUDGE                                                              
+template<typename T>bool umax(T&a, const T&b){return b<=a?false:(a=b,true);}        
+template<typename T>bool umin(T&a, const T&b){return b>=a?false:(a=b,true);}        
+template<typename T>                                                                
+void V2A(T a[],const vector<T>&b){for(int i=0;i<b.size();i++)a[i]=b[i];}            
+template<typename T>                                                                
+void A2V(vector<T>&a,const T b[]){for(int i=0;i<a.size();i++)a[i]=b[i];}            
+const double PI = acos(-1.0);                                                       
+const int INF = 1e9 + 7;                                                            
+unsigned long long Pre[64], Suf[64];
+struct BitSet {
+    vector<unsigned long long> s;
+    static void init() {
+        Pre[0] = 1;
+        Suf[63] = (unsigned long long)1 << 63;
+        for (int i = 1; i < 64; i ++) {
+            Pre[i] = (unsigned long long)1 << i | Pre[i - 1];
+        }
+        for (int i = 62; i >= 0; i --) {
+            Suf[i] = (unsigned long long)1 << i | Suf[i + 1];
+        }
+    }
+    void resize(int n) {
+        int p = s.size(), t = (n - 1) / 64 + 1;
+        s.resize(t);
+    }
+    BitSet(int n) {
+        resize(n);
+    }
+    BitSet() {}
+    BitSet operator & (BitSet &that) {
+        int sz = that.s.size(), n = this->s.size(), len = max(sz, n);
+        if (sz < len) that.resize(len);
+        if (n < len) this->resize(len);
+        BitSet ans(len * 64);
+        for (int i = len - 1; i >= 0; i --) {
+            ans.s[i] = this->s[i] & that.s[i];
+        }
+        return ans;
+    }
+    BitSet operator | (BitSet &that) {
+        int sz = that.s.size(), n = this->s.size(), len = max(sz, n);
+        if (sz < len) that.resize(len);
+        if (n < len) this->resize(len);
+        BitSet ans(len * 64);
+        for (int i = len - 1; i >= 0; i --) {
+            ans.s[i] = this->s[i] | that.s[i];
+        }
+        return ans;
+    }
+    BitSet operator ^ (BitSet &that) {
+        int sz = that.s.size(), n = this->s.size(), len = max(sz, n);
+        if (sz < len) that.resize(len);
+        if (n < len) this->resize(len);
+        BitSet ans(len * 64);
+        for (int i = len - 1; i >= 0; i --) {
+            ans.s[i] = this->s[i] ^ that.s[i];
+        }
+        return ans;
+    }
+    BitSet operator << (int x) {
+        int sz = s.size(), c = x / 64, r = x % 64;
+        BitSet ans(64 * sz);
+        for (int i = sz - 1; i - c >= 0; i --) {
+            ans.s[i] = (s[i - c] & Pre[63 - r]) << r;
+            if (r && i - c - 1 >= 0) ans.s[i] |= (s[i - c - 1 ] & Suf[64 - r]) >> (64 - r);
+        }
+        return ans;
+    }
+    BitSet operator >> (int x) {
+        int sz = s.size(), c = x / 64, r = x % 64;
+        BitSet ans(64 * sz);
+        for (int i = 0; i + c < sz; i ++) {
+            ans.s[i] = (s[i + c] & Suf[r]) >> r;
+            if (r && i + c + 1 < sz) ans.s[i] |= (s[i + c + 1] & Pre[r - 1]) << (64 - r);
+        }
+        return ans;
+    }
+    bool get(int p) {
+        int c = p / 64, r = p % 64;
+        return s[c] & ((unsigned long long)1 << r);
+    }
+    bool zero() {
+        int n = s.size();
+        for (int i = 0; i < n; i ++) {
+            if (s[i]) return false;
+        }
+        return true;
+    }
+    void setval(int L, int R, bool val) {
+        int p = L / 64, tp = L % 64, q = R / 64, tq = R % 64;
+        for (int i = p + 1; i < q; i ++) {
+            s[i] = val? ((unsigned long long)-1) : 0;
+        }
+        if (p == q) {
+            unsigned long long buf = Suf[tp] & Pre[tq];
+            s[p] = val? s[p] | buf : s[p] & ~buf;
+            return ;
+        }
+        s[p] = val? s[p] | Suf[tp] : s[p] & ~Suf[tp];
+        s[q] = val? s[q] | Pre[tq] : s[q] & ~Pre[tq];
+    }
+    void print() {
+        int n = s.size();
+        for (int i = n - 1; i >= 0; i --) {
+            unsigned long long x = s[i];
+            for (int i = 63; i >= 0; i --) {
+                if (((unsigned long long)1 << i) & x)
+                    putchar('1');
+                else
+                    putchar('0');
+            }
+        }
+        putchar('\n');
+    }
+};
+struct StringHash {
+    const static unsigned int hack = 1301;
+    const static int maxn = 1e5 + 7;
+    unsigned long long H[maxn], C[maxn];
+    void init(char s[], int n) {
+        for (int i = 0; s[i]; i ++) {
+            H[i] = (i? H[i - 1] * hack : 0) + s[i];
+        }
+        C[0] = 1;
+        for (int i = 1; i <= n; i ++) C[i] = C[i - 1] * hack;
+    }
+    unsigned long long get(int L, int R) {
+        return H[R] - (L? H[L - 1] * C[R - L + 1] : 0);
+    }
+} ;
+StringHash hsh, hshrev;
+const int maxn = 1e5 + 7;
+bool pre[maxn], suf[maxn];
+char s[maxn], revs[maxn];
+int F[maxn];
+int main() {
+    BitSet::init();
+    int T;
+    cin >> T;
+    while (T --) {
+        scanf("%s", s);
+        int n = strlen(s), total = n * 2 - 1;
+        hsh.init(s, n);
+        for (int i = 0; i < n; i ++) revs[i] = s[n - i - 1];
+        hshrev.init(revs, n);
+        for (int i = 0; i < total; i ++) {
+            int L = i / 2, R = (i + 1) / 2;
+            int minlen = 0, maxlen = min(L + 1, n - R);
+            while (minlen < maxlen) {
+                int midlen = (minlen + maxlen + 1) >> 1;
+                int lpos = L - midlen + 1, rpos = R + midlen - 1;
+                if (hsh.get(lpos, L) == hshrev.get(n - rpos - 1, n - R - 1)) minlen = midlen;
+                else maxlen = midlen - 1;
+            }
+            F[i] = minlen;
+        }
+        fillchar(pre, 0);
+        fillchar(suf, 0);
+        pre[0] = suf[n - 1] = true;
+        BitSet bs1(n), bs2(n);
+        bs1.setval(0, 0, 1);
+        bs2.setval(0, 0, 1);
+        for (int i = 1; i < n; i ++) {
+            pre[i] = F[i] == i / 2 + 1;
+            if (pre[i]) bs1.setval(i, i, 1);
+        }
+        for (int i = n - 2; i >= 0; i --) {
+            suf[i] = F[i + n - 1] == (n - i + 1) / 2;
+            if (suf[i]) bs2.setval(n - i - 1, n - i - 1, 1);
+        }
+        bool ok = false;
+        for (int i = 0; i < total; i ++) {
+            int L = i / 2, R = (i + 1) / 2;
+            int len = F[i], lpos = L - len + 1, rpos = R + len - 1;
+            if (len == 0) continue;
+            BitSet buf, result, newbuf(n);
+            if (n - R >= L + 1) {
+                buf = bs2 >> (n - R - L - 1);
+                result = bs1 & buf;
+                newbuf.setval(max(0, lpos - 1), L - 1, 1);
+            }
+            if (L + 1 > n - R) {
+                buf = bs1 >> (L + 1 - n + R);
+                result = buf & bs2;
+                newbuf.setval(max(0, n - rpos - 2), n - R - 2, 1);
+            }
+            newbuf = newbuf & result;
+            if (!newbuf.zero()) {
+                ok = true;
+                break;
+            }
+        }
+        puts(ok? "Yes" : "No");
+    }
+    return 0;
+}
diff --git a/HDOJ/5341_autoAC.cpp b/HDOJ/5341_autoAC.cpp
new file mode 100644
index 0000000..7081402
--- /dev/null
+++ b/HDOJ/5341_autoAC.cpp
@@ -0,0 +1,62 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<vector>
+#include<cmath>
+#include<string.h>
+#define ll long long
+using namespace std;
+const ll maxn = 10000000+10;
+const ll mod = (1ll<<32);
+ll t,n,ans;
+ll f0[maxn],g0[maxn];
+ll sumhe[maxn],sumu[maxn],sumu0[maxn];
+bool not_prime[maxn];
+ll pri[maxn],cnt;
+ll ans0,ans1;
+void mobius(){
+    sumu[1]=1,sumu0[1]=1,sumu[0]=0,sumhe[0]=0,sumu0[0]=0,cnt=0;
+    for(ll i=2;i<=maxn-5;i++){
+        if(!not_prime[i]) pri[cnt++]=i,sumu[i]=((-1)%mod+mod)%mod,sumu0[i]=((1-i)%mod+mod)%mod;
+        for(ll j=0;j<cnt&&i*pri[j]<=maxn-5;j++){
+            not_prime[i*pri[j]]=1;
+            if(i%pri[j]==0) { sumu[i*pri[j]]=0,sumu0[i*pri[j]]=sumu0[i]%mod;break; }
+            else sumu[i*pri[j]]=((-sumu[i])%mod+mod)%mod,sumu0[i*pri[j]]=(sumu0[pri[j]]*sumu0[i])%mod;
+        }
+    }
+    for(ll i=1;i<=maxn-5;i++) sumu[i]=(sumu[i-1]+sumu[i])%mod,f0[i]=g0[i]=mod+1,sumhe[i]=(sumhe[i-1]+i)%mod,sumu0[i]=(sumu0[i-1]+i*sumu0[i]%mod)%mod;
+}
+ll calf(ll n){
+    if(f0[n]!=mod+1) return f0[n];
+    ll ans=0,tmp;
+    for(ll i=1;i<=n;i=tmp+1){
+        tmp=n/(n/i);
+        ans=(ans+((sumu[tmp]-sumu[i-1])%mod+mod)%mod*(n/i)%mod*(n/i)%mod)%mod;
+    }
+    return f0[n]=ans;
+}
+ll calg(ll n){
+    if(g0[n]!=mod+1) return g0[n];
+    ll ans=0,tmp;
+    for(ll i=1;i<=n;i=tmp+1){
+        tmp=n/(n/i);
+        ans=(ans+((sumhe[tmp]-sumhe[i-1])%mod+mod)%mod*calf(n/i)%mod)%mod;
+    }
+    return g0[n]=ans;
+}
+int main(){
+    mobius();
+    scanf("%lld",&t);
+    while(t--){
+        scanf("%lld",&n);
+        ans=0;
+        ll tmp=0;
+        for(ll i=1;i<=n;i=tmp+1){
+            tmp=n/(n/i);
+            ll x=calg(n/i);
+            ans=(ans+((sumu0[tmp]-sumu0[i-1])%mod+mod)%mod*x%mod*x%mod)%mod;
+        }
+        printf("%lld\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5343_autoAC.cpp b/HDOJ/5343_autoAC.cpp
new file mode 100644
index 0000000..6bfa250
--- /dev/null
+++ b/HDOJ/5343_autoAC.cpp
@@ -0,0 +1,71 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int MAX_N = 200007;
+typedef unsigned long long ll;
+struct SAM {
+    int val[MAX_N], fa[MAX_N], c[26][MAX_N];
+    int tot, last;
+    int which[MAX_N];
+    inline int newNode(int step) {
+        val[++tot] = step;
+        fa[tot] = 0;
+        for (int i = 0; i < 26; ++i) c[i][tot] = 0;
+        return tot;
+    }
+    inline void extend(int k) {
+        int p = last;
+        int np = newNode(val[last] + 1);
+        which[np] = k;
+        while (p && !c[k][p]) c[k][p] = np, p = fa[p];
+        if (!p) fa[np] = 1;
+        else {
+            int q = c[k][p];
+            if (val[q] == val[p] + 1) fa[np] = q;
+            else {
+                int nq = newNode(val[p] + 1);
+                which[nq] = k;
+                for (int i = 0; i < 26; ++i) c[i][nq] = c[i][q];
+                fa[nq] = fa[q]; 
+                fa[q] = fa[np] = nq;
+                while (p && c[k][p] == q) c[k][p] = nq, p = fa[p];
+            }
+        }
+        last = np;
+    }
+    inline int add(int k) {
+        extend(k);
+    }
+    inline void init() {
+        tot = 0;
+        last = newNode(0);
+    }
+} suf;
+char A[MAX_N>>1], B[MAX_N>>1];
+ll dp[26];
+int main() {
+    int T;
+    scanf("%d", &T);
+    while (T-- > 0) {
+        suf.init();
+        scanf("%s%s", A, B);
+        int n = strlen(B);
+        reverse(B, B + n);
+        for (int i = 0; B[i]; ++i) suf.add(B[i] - 'a');
+        memset(dp, 0, sizeof dp);
+        for (int i = 1; i <= suf.tot; ++i) 
+            dp[suf.which[i]] += suf.val[i] - suf.val[suf.fa[i]];
+        suf.init(); 
+        for (int i = 0; A[i]; ++i) suf.add(A[i] - 'a');
+        ll ans = 0;
+        for (int i = 1; i <= suf.tot; ++i) {
+            for (int j = 0; j < 26; ++j) if (!suf.c[j][i]) {
+                ans += dp[j] * (suf.val[i] - suf.val[suf.fa[i]]);
+            }
+            if (suf.fa[i]) ans += suf.val[i] - suf.val[suf.fa[i]];
+        }
+        printf("%I64u\n", ans + 1);
+    }
+    return 0;
+}
diff --git a/HDOJ/5344_autoAC.cpp b/HDOJ/5344_autoAC.cpp
new file mode 100644
index 0000000..cb9a972
--- /dev/null
+++ b/HDOJ/5344_autoAC.cpp
@@ -0,0 +1,25 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std ;
+typedef __int64 ll ;
+int main()
+{
+    ll n , m , l , z ;
+    int t ;
+    scanf("%d" , &t) ;
+    while(t--)
+    {
+        scanf("%I64d%I64d%I64d%I64d" , &n , &m , &z, &l) ;
+        ll ans = 0 ;
+        ll pre = 0 ;
+        ll now ;
+        for(int i = 2;i <= n;i++)
+        {
+           now = (pre*m + z)%l ;
+           ans = ans^(2*now) ;
+           pre = now ;
+        }
+       printf("%I64d\n" , ans) ;
+    }
+}
diff --git a/HDOJ/5346_autoAC.cpp b/HDOJ/5346_autoAC.cpp
new file mode 100644
index 0000000..0773b5d
--- /dev/null
+++ b/HDOJ/5346_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<stdio.h>
+#include<string.h>
+using namespace std;
+const long long PIVOT = 258280327;
+long long P;
+long long inv(long long x)
+{
+    if(x <= 1)
+        return 1;
+    return (PIVOT - PIVOT/x)*inv(PIVOT%x)%PIVOT;
+}
+long long n, x, y;
+long long alive_K[2010];
+long long dp[2010][2010];
+int main()
+{
+    int T, i, j;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%lld%lld%lld", &n, &x, &y);
+        P = x * inv(y) % PIVOT;
+        alive_K[0] = 1;
+        for (i = 1; i <= n; ++i) {
+            alive_K[i] = alive_K[i - 1] * (1 - P + PIVOT) % PIVOT;
+        }
+        dp[1][0] = 1;
+        for (i = 2; i <= n; ++i) {
+            for (j = 1; j < i; ++j) {
+                dp[i][j] = dp[i - 1][j - 1] * alive_K[j - 1] % PIVOT + dp[i - 1][j] * (1 - alive_K[j] + PIVOT) % PIVOT;
+                dp[i][j] %= PIVOT;
+            }
+        }
+        long long res;
+        int k;
+        printf("%lld", inv(n));
+        for (k = 1; k <= n - 1; ++k) {
+            res = 0;
+            for (i = 1; i <= n; ++i) {
+                res += dp[i][k];
+                res %= PIVOT;
+            }
+            res = res * alive_K[k] % PIVOT * inv(n) % PIVOT;
+            printf(" %lld", res);
+        }
+        printf("\n");
+    }
+}
diff --git a/HDOJ/5348_autoAC.cpp b/HDOJ/5348_autoAC.cpp
new file mode 100644
index 0000000..b7dc044
--- /dev/null
+++ b/HDOJ/5348_autoAC.cpp
@@ -0,0 +1,102 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <queue>
+#include <algorithm>
+#include <stdlib.h>
+#include <math.h>
+#include <stack>
+using namespace std;
+const int MAXM=300010;
+const int MAXN=200010;
+struct edge{
+    int u,v;
+}edges[MAXM*2];
+int head[MAXN];
+int pre[MAXM*2];
+int Next[MAXM*2];
+int deg[MAXN];
+int ans[MAXM];
+int ecnt;
+int n,m;
+int init(){
+    memset(head,-1,sizeof(head));
+    memset(Next,-1,sizeof(Next));
+    memset(deg,0,sizeof(deg));
+    ecnt=0;
+}
+void addedge(int u,int v){
+    edges[ecnt].u=u;    edges[ecnt].v=v;
+    pre[ecnt]=head[u];
+    head[u]=ecnt;
+    ecnt++;
+    edges[ecnt].u=v;    edges[ecnt].v=u;
+    pre[ecnt]=head[v];
+    head[v]=ecnt;
+    ecnt++;
+}
+void dfs(int u){
+    while(head[u]!=-1){
+        deg[u]--;
+        int i=head[u];
+        int v=edges[i].v;
+        if(i&1){
+            ans[(i>>1)+1]=0;
+        }else{
+            ans[(i>>1)+1]=1;
+        }
+        int pp,nn;
+        if(head[u]==i){
+            head[u]=pre[i];
+        }
+        pp=pre[i];
+        nn=Next[i];
+        if(pp!=-1)Next[pp]=nn;
+        if(nn!=-1)pre[nn]=pp;
+        int _i=i^1;
+        if(head[v]==_i){
+            head[v]=pre[_i];
+        }
+        pp=pre[_i];
+        nn=Next[_i];
+        if(pp!=-1)Next[pp]=nn;
+        if(nn!=-1)pre[nn]=pp;
+        u=v;
+        if(deg[v])deg[v]--;
+    }
+}
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        init();
+        cin>>n>>m;
+        for(int i=1;i<=m;i++){
+            int u,v;
+            scanf("%d%d",&u,&v);
+            addedge(u,v);
+            deg[u]++;
+            deg[v]++;
+        }
+        for(int i=0;i<ecnt;i++){
+            if(pre[i]!=-1)Next[pre[i]]=i;
+        }
+        for(int i=1;i<=n;i++){
+            Next[head[i]]=-1;
+        }
+        for(int i=1;i<=n;i++){
+            if(deg[i]&1){
+                dfs(i);
+            }
+        }
+        for(int i=1;i<=n;i++){
+            if(deg[i]){
+                dfs(i);
+            }
+        }
+        for(int i=1;i<=m;i++){
+            printf("%d\n",ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5349_autoAC.cpp b/HDOJ/5349_autoAC.cpp
new file mode 100644
index 0000000..a9422f4
--- /dev/null
+++ b/HDOJ/5349_autoAC.cpp
@@ -0,0 +1,38 @@
+#include<iostream>
+#include<set>
+#include<cstdio>
+#include<cstring>
+#include<cstdio>
+using namespace std;
+multiset<int> haha;
+multiset<int>::iterator it;
+int main(){
+    int n;
+    while(scanf("%d",&n)!=EOF){
+        int p,u;
+        haha.clear();
+        int ans ;
+        while(n--){
+            scanf("%d",&p);
+            if(p == 1) {
+                scanf("%d",&u);
+                haha.insert(u);
+            }
+            else if(p == 2){
+                if(haha.size() > 0){
+                    haha.erase(haha.begin());
+                }
+            }
+            else if(p==3){
+                ans = 0;
+                if(haha.size() > 0){
+                    it = haha.end();
+                    it--;
+                    ans = *it;
+                }
+                printf("%d\n",ans);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5350_autoAC.cpp b/HDOJ/5350_autoAC.cpp
new file mode 100644
index 0000000..dd160fa
--- /dev/null
+++ b/HDOJ/5350_autoAC.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <cstdio>
+#include<algorithm>
+#include<cstring>
+#include<functional>
+#include<queue>
+typedef long long ll;
+using namespace std;
+int main()
+{
+    int T;
+    int n,a;
+    priority_queue<ll, vector<ll>, greater<ll> >q;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        while(!q.empty())
+        {
+            q.pop();
+        }
+        for(int i=1; i<=n; i++)
+        {
+            scanf("%d",&a);
+            q.push(a);
+        }
+        ll sum = 0;
+        while(!q.empty())
+        {
+            ll x = q.top();
+            q.pop();
+            if(q.empty())
+            {
+                continue;
+            }
+            ll y = q.top();
+            q.pop();
+            ll tmp= x + y;
+            sum+=tmp;
+            q.push(tmp);
+        }
+        printf("%I64d\n",sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/5351_autoAC.cpp b/HDOJ/5351_autoAC.cpp
new file mode 100644
index 0000000..5398cb9
--- /dev/null
+++ b/HDOJ/5351_autoAC.cpp
@@ -0,0 +1,124 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+#define MOD 258280327
+int n;
+struct s
+{
+    int a[1050];
+    void set()
+    {
+        memset(a,0,sizeof(a));
+    }
+}f[1050];
+s ss;
+s operator +(s const &m,s const &n)
+{
+    s temp;
+    temp.set();
+    for(int i=0;i<1050;i++)
+    {
+        temp.a[i]+=m.a[i]+n.a[i];
+        if(temp.a[i]>9)
+        {
+            temp.a[i+1]++;
+            temp.a[i]-=10;
+        }
+    }
+    return temp;
+}
+s operator -(s const &m,s const &n)
+{
+    s tem;
+    tem.set();
+    for(int i=0;i<1050;i++)
+    {
+        tem.a[i]=m.a[i];
+    }
+    for(int i=0;i<1050;i++)
+    {
+        tem.a[i]-=n.a[i];
+        if(tem.a[i]<0)
+        {
+            tem.a[i]=10+tem.a[i];
+            tem.a[i+1]--;
+        }
+    }
+    return tem;
+}
+bool operator >(s const &m,s const &n)
+{
+    int lm,ln;
+    for(lm=1000;m.a[lm]==0;lm--);
+    for(ln=1000;n.a[ln]==0;ln--);
+    if(lm>ln)
+        return true;
+    else if(lm<ln)
+        return false;
+    for(int i=lm;i>=0;i--)
+    {
+        if(m.a[i]>n.a[i])
+            return true;
+        else if(m.a[i]<n.a[i])
+            return false;
+    }
+    return false;
+}
+void init(int n)
+{
+    for(int i=1;i<=n;i++)
+        f[i].set();
+    f[1].a[0]=1;
+    f[2].a[0]=1;
+    for(int i=3;i<=n;i++)
+        f[i]=f[i-1]+f[i-2];
+}
+void change(string m)
+{
+    ss.set();
+    for(int i=0;i<m.length();i++)
+    {
+        ss.a[m.length()-1-i]=m[i]-'0';
+    }
+    s k;
+    k.set();
+    k.a[0]=1;
+    while(f[n]>ss+k)
+    {
+        n--;
+    }
+}
+long long g()
+{
+    long long ans=0;
+    int i;
+    s temp=ss-f[n-1];
+    for(i=1000;temp.a[i]==0;i--);
+    for(int j=i;j>=0;j--)
+        ans=((ans*10)%MOD+temp.a[j]%MOD)%MOD;
+    return ans;
+}
+int main()
+{
+    int t;
+    string m;
+    long long ans;
+    init(1001);
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        cin >> m;
+        if(m.length()==1&&(m[0]=='1'))
+        {
+            puts("1");
+            continue;
+        }
+        int i;
+        change(m);
+        ans=g();
+        printf("%lld\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5352_autoAC.cpp b/HDOJ/5352_autoAC.cpp
new file mode 100644
index 0000000..d33d4fb
--- /dev/null
+++ b/HDOJ/5352_autoAC.cpp
@@ -0,0 +1,132 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<vector>
+#include<iostream>
+#define maxn 1000
+#define maxm 200000
+#define inf 10000000
+using namespace std;
+int head[maxn],tail;
+int queue[maxn],pre[maxn],flag[maxn];
+int dist[maxn],maxFlow[maxn];
+struct Edge{
+    int v,u,next,cost,w;
+    Edge(){}
+    Edge(int u,int v,int next,int cost,int w):u(u),v(v),next(next),cost(cost),w(w){}
+} edge[maxm];
+void add_edge(int u,int v,int cost,int w){
+    edge[tail] = Edge(u,v,head[u],cost,w);
+    head[u] = tail++;
+    edge[tail] = Edge(v,u,head[v],-cost,0);
+    head[v] = tail++;
+}
+void init(){
+    memset(head,-1,sizeof(head));
+    tail=0;
+}
+int SPFA(int start,int end){
+    int i,u,v,front,rear;
+    front = rear = 0;
+    memset(flag,0,sizeof(flag));
+    memset(dist,0x1f,sizeof(dist));
+    memset(pre,-1,sizeof(pre));
+    dist[start] = 0, dist[end] = inf ,flag[start]=1;
+    maxFlow[start] = inf, queue[rear++] = start;
+    while(front != rear){
+        u = queue[front++];
+        if(front >= maxn) front = 0;
+        flag[u] = 0;
+        for(i = head[u]; i!=-1;i=edge[i].next){
+            v=edge[i].v;
+      if(edge[i].w&&dist[v]>dist[u]+edge[i].cost){
+                dist[v]=dist[u]+edge[i].cost;
+        maxFlow[v]=min(edge[i].w,maxFlow[u]);
+                pre[v]=i;
+                if(!flag[v]){
+                    queue[rear++]=v;
+                    if(rear>=maxn)rear=0;
+                    flag[v] =1;
+                }
+            }
+        }
+    }
+    return dist[end] != inf;
+}
+int MFMC(int start,int end){
+    int min_cost = 0,v;
+    while(SPFA(start,end)){
+        v = end;
+        while(pre[v]>=0){
+            edge[pre[v]].w-=maxFlow[end];
+            edge[pre[v]^1].w+=maxFlow[end];
+            v=edge[pre[v]].u;
+        }
+        min_cost+=dist[end]*maxFlow[end];
+    }
+    return min_cost;
+}
+int map[207][207];
+vector<int> stack;
+int check[207];
+int n;
+void dfs(int u){
+    if(check[u]) return;
+    check[u] = 1;
+    stack.push_back(u);
+    for(int i = 1;i <= n; i++){
+        if(map[u][i] == 1 && check[i] == 0){
+            dfs(i);
+        }
+    }
+}
+int main(){
+    int m,t,k;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d%d",&n,&m,&k);
+        init();
+        memset(map,0,sizeof(map));
+        for(int i = 1;i <= n; i++)
+            add_edge(i,n+1,1,1);
+        int q,u,v,t,cost = n+2;
+        for(int i = 0;i < m; i++){
+            scanf("%d",&t);
+            if(t == 1){
+                scanf("%d",&u);
+                memset(check,0,sizeof(check));
+                stack.clear();
+                dfs(u);
+                add_edge(0,cost,500000-cost*500,k);
+                for(int j = 0;j < stack.size() ;j++){
+                   add_edge(cost,stack[j],0,1);
+                }
+                cost++;
+            }
+            else if(t == 2){
+                scanf("%d%d",&u,&v);
+                map[v][u] = map[u][v] = 1;
+            }
+            else {
+                scanf("%d",&q);
+                while(q--){
+                    scanf("%d%d",&u,&v);
+                    map[u][v] = map[v][u] = 0;
+                }
+            }
+        }
+        int ans = MFMC(0,n+1);
+        stack.clear();
+        for(int i = head[0];i != -1; i=edge[i].next){
+            stack.push_back(k-edge[i].w);
+        }
+        printf("%d\n",ans%500);
+        int flag = 0;
+        for(int i = stack.size() - 1;i >= 0; i--){
+            if(i != stack.size()-1) printf(" ");
+            printf("%d",stack[i]);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5353_autoAC.cpp b/HDOJ/5353_autoAC.cpp
new file mode 100644
index 0000000..bb3ff60
--- /dev/null
+++ b/HDOJ/5353_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<cstdio>
+#include<cmath>
+#include<iostream>
+#include<queue>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const ll maxn=100005;
+ll T,n,m,a[maxn],sum,tot;
+bool flag;
+int f[maxn][2];
+int main()
+{
+    scanf("%lld",&T);
+    while (T--)
+    {
+        scanf("%lld",&n);
+        sum=0;    flag=true;
+        for (int i=0;i<n;i++) 
+        {
+            scanf("%lld",&a[i]);
+            sum+=a[i];
+        }
+        if (sum%n) flag=false;
+        else 
+        {
+            sum=sum/n;
+            tot=0;
+            for (int i=0;i<n;i++) a[i]-=sum;
+            memset(f,0,sizeof(f));
+            for (int i=0,j,k;i<n+n;i++)
+            {
+                j=i%n;    k=(i+1)%n;
+                if (a[j]>0&&a[k]<=0&&!f[j][1]) { 
+                    a[k]++;
+                    a[j]--;
+                    if (!f[k][0]) f[j][1]=1;
+                      else f[k][0]=f[j][1]=0; 
+                }
+                else if (a[j]<0&&a[k]>=0&&!f[k][0]) {  
+                    a[k]--;
+                    a[j]++;
+                    if (!f[j][1]) f[k][0]=1;
+                      else f[j][1]=f[k][0]=0; 
+                }
+            }
+            for (int i=0;i<n;i++) if (a[i]) {flag=false; break;}
+             for (int i=0;i<n;i++) tot+=f[i][0]+f[i][1];
+            if (n==2&&tot==2) flag=false;
+        }
+        if (flag)
+        {
+            printf("YES\n%d\n",tot);
+            for (int i=1,j,k;i<=n;i++)
+             {
+                j=i-1;    if (j==0) j=n;
+                k=i+1;  if (k>n) k=1;
+                if (f[i-1][0]) printf("%d %d\n",i,j);
+                if (f[i-1][1]) printf("%d %d\n",i,k);
+             }
+        }
+        else printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5354_autoAC.cpp b/HDOJ/5354_autoAC.cpp
new file mode 100644
index 0000000..0842def
--- /dev/null
+++ b/HDOJ/5354_autoAC.cpp
@@ -0,0 +1,197 @@
+#include <algorithm>
+#include <iostream>
+#include <iomanip>
+#include <cstring>
+#include <climits>
+#include <complex>
+#include <cstdio>
+#include <bitset>
+#include <vector>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <ctime>
+#include <set>
+#include <map>
+#include <cmath>
+#include <functional>
+#include <numeric>
+using namespace std;
+#define eps 1e-9
+#define PI acos(-1.0)
+#define INF 0x3f3f3f3f
+#define LLINF 1LL<<62
+#define speed std::ios::sync_with_stdio(false);
+typedef long long ll;
+typedef unsigned long long ull;
+typedef long double ld;
+typedef pair<ll, ll> pll;
+typedef complex<ld> point;
+typedef pair<int, int> pii;
+typedef pair<pii, int> piii;
+typedef vector<int> vi;
+#define CLR(x,y) memset(x,y,sizeof(x))
+#define CPY(x,y) memcpy(x,y,sizeof(x))
+#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
+#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))
+#define mp(x,y) make_pair(x,y)
+#define pb(x) push_back(x)
+#define lowbit(x) (x&(-x))
+#define MID(x,y) (x+((y-x)>>1))
+template<class T>
+inline bool read(T &n)
+{
+    T x = 0, tmp = 1;
+    char c = getchar();
+    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
+    if(c == EOF) return false;
+    if(c == '-') c = getchar(), tmp = -1;
+    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
+    n = x*tmp;
+    return true;
+}
+template <class T>
+inline void write(T n)
+{
+    if(n < 0)
+    {
+        putchar('-');
+        n = -n;
+    }
+    int len = 0,data[20];
+    while(n)
+    {
+        data[len++] = n%10;
+        n /= 10;
+    }
+    if(!len) data[len++] = 0;
+    while(len--) putchar(data[len]+48);
+}
+const int MAXN=100010;
+int n,m;
+int fa[MAXN];
+struct Edge
+{
+    int u,v,next;
+}e[MAXN<<1];
+struct Node
+{
+    int u,v,colu,colv,rku,rkv,fau,fav;
+    Node(){}
+    Node(int u,int v,int colu,int colv,int rku,int rkv,int fau,int fav):u(u),v(v),colu(colu),colv(colv),rku(rku),rkv(rkv),fau(fau),fav(fav){}
+}s[MAXN];
+int col[MAXN];
+int head[MAXN],tot;
+int rk[MAXN],top;
+int ans[MAXN];
+void init(int n)
+{
+    CLR(head,-1);
+    tot=0;top=0;
+    for(int i=0;i<n+10;i++)
+        fa[i]=i,col[i]=1,rk[i]=1;
+}
+void addedge(int u,int v)
+{
+    e[tot].u=u;
+    e[tot].v=v;
+    e[tot].next=head[u];
+    head[u]=tot++;
+}
+int find_fa(int x)
+{
+    int o=x;
+    while(fa[o]!=o) o=fa[o];
+    return o;
+}
+int find_col(int x)
+{
+    if(fa[x]==x)    return col[x];
+    if(!col[x])        return !find_col(fa[x]);
+    return find_col(fa[x]);
+}
+bool merge(int u,int v)
+{
+    int a=find_fa(u),b=find_fa(v);
+    int x=find_col(u),y=find_col(v);
+    int root,next;
+    if(a==b)
+    {
+        if(x==y)    return false;
+        return true;
+    }
+    if(rk[a]>rk[b])
+        root=a,next=b;
+    else
+        root=b,next=a;
+    s[top++]=Node(a,b,col[a],col[b],rk[a],rk[b],fa[a],fa[b]);
+    if(x==y && col[root]==1)
+        col[next]^=1;
+    fa[next]=root;
+    rk[root]+=rk[next];
+    return true;
+}
+bool unite(int l,int r,int a,int b)
+{
+    bool flag=true;
+    int u,v;
+    for(int t=l;t<=r;t++)
+        for(int i=head[t];~i;i=e[i].next)
+        {
+            u=e[i].u;v=e[i].v;
+            if(a<=v && v<=b)  continue;
+            if(!merge(u,v))
+                flag=false;
+        }
+    return flag;
+}
+void back(int x)
+{
+    Node tmp;
+    while(top>x)
+    {
+        --top;
+        tmp=s[top];
+        int u=tmp.u,v=tmp.v;
+        rk[u]=tmp.rku;rk[v]=tmp.rkv;
+        fa[u]=tmp.fau;fa[v]=tmp.fav;
+        col[u]=tmp.colu;col[v]=tmp.colv;
+    }
+}
+void cdq(int l,int r,bool flag)
+{
+    if(l==r)
+    {
+        ans[l]=flag;
+        return;
+    }
+    int mid=MID(l,r);
+    int pre=top;
+    bool now=flag&&unite(mid+1,r,l,mid);
+    cdq(l,mid,now);
+    back(pre);
+    now=flag&&unite(l,mid,mid+1,r);
+    cdq(mid+1,r,now);
+    back(pre);
+}
+int main()
+{
+    int T;
+    read(T);
+    while(T--)
+    {
+        read(n),read(m);
+        init(n);
+        for(int i=0,u,v;i<m;i++)
+        {
+            read(u);read(v);
+            addedge(u,v);
+            addedge(v,u);
+        }
+        cdq(1,n,true);
+        for(int i=1;i<=n;i++)
+            write(ans[i]);
+        putchar('\n');
+    }
+    return 0;
+}
diff --git a/HDOJ/5355_autoAC.cpp b/HDOJ/5355_autoAC.cpp
new file mode 100644
index 0000000..bb3ff60
--- /dev/null
+++ b/HDOJ/5355_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<cstdio>
+#include<cmath>
+#include<iostream>
+#include<queue>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const ll maxn=100005;
+ll T,n,m,a[maxn],sum,tot;
+bool flag;
+int f[maxn][2];
+int main()
+{
+    scanf("%lld",&T);
+    while (T--)
+    {
+        scanf("%lld",&n);
+        sum=0;    flag=true;
+        for (int i=0;i<n;i++) 
+        {
+            scanf("%lld",&a[i]);
+            sum+=a[i];
+        }
+        if (sum%n) flag=false;
+        else 
+        {
+            sum=sum/n;
+            tot=0;
+            for (int i=0;i<n;i++) a[i]-=sum;
+            memset(f,0,sizeof(f));
+            for (int i=0,j,k;i<n+n;i++)
+            {
+                j=i%n;    k=(i+1)%n;
+                if (a[j]>0&&a[k]<=0&&!f[j][1]) { 
+                    a[k]++;
+                    a[j]--;
+                    if (!f[k][0]) f[j][1]=1;
+                      else f[k][0]=f[j][1]=0; 
+                }
+                else if (a[j]<0&&a[k]>=0&&!f[k][0]) {  
+                    a[k]--;
+                    a[j]++;
+                    if (!f[j][1]) f[k][0]=1;
+                      else f[j][1]=f[k][0]=0; 
+                }
+            }
+            for (int i=0;i<n;i++) if (a[i]) {flag=false; break;}
+             for (int i=0;i<n;i++) tot+=f[i][0]+f[i][1];
+            if (n==2&&tot==2) flag=false;
+        }
+        if (flag)
+        {
+            printf("YES\n%d\n",tot);
+            for (int i=1,j,k;i<=n;i++)
+             {
+                j=i-1;    if (j==0) j=n;
+                k=i+1;  if (k>n) k=1;
+                if (f[i-1][0]) printf("%d %d\n",i,j);
+                if (f[i-1][1]) printf("%d %d\n",i,k);
+             }
+        }
+        else printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5357_autoAC.cpp b/HDOJ/5357_autoAC.cpp
new file mode 100644
index 0000000..54a9ea4
--- /dev/null
+++ b/HDOJ/5357_autoAC.cpp
@@ -0,0 +1,87 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <ctime>
+#include <string>
+#include <map>
+#include <vector>
+#include <stack>
+#include <queue>
+#include <utility>
+#include <iostream>
+#include <algorithm>
+template<class Num>void read(Num &x)
+{
+    char c; int flag = 1;
+    while((c = getchar()) < '0' || c > '9')
+        if(c == '-') flag *= -1;
+    x = c - '0';
+    while((c = getchar()) >= '0' && c <= '9')
+        x = (x<<3) + (x<<1) + (c-'0');
+    x *= flag;
+    return;
+}
+template<class Num>void write(Num x)
+{
+    if(x < 0) putchar('-'), x = -x;
+    static char s[20];int sl = 0;
+    while(x) s[sl++] = x%10 + '0',x /= 10;
+    if(!sl) {putchar('0');return;}
+    while(sl) putchar(s[--sl]);
+}
+const int maxn = 1e6 + 50, Mod = 1e9+7;
+char str[maxn];
+int T, n, a[maxn], b[maxn];
+int pre[maxn], match[maxn];
+long long ans[maxn];
+int stack[maxn], top;
+void prework()
+{
+    top = 0;
+    for(int i = 1; i <= n; i++)
+    {
+        match[i] = pre[i] = 0;
+        if(str[i] == '(')
+            stack[++top] = i;
+        else
+        {
+            if(top)
+            {
+                match[stack[top]] = i;
+                match[i] = stack[top];
+                if(top > 1) pre[match[i]] = stack[top - 1];
+                stack[top--] = 0;
+            }
+        }
+    }
+}
+void solve()
+{
+    a[0] = b[n + 1] = ans[0] = 0;
+    for(int i = 1; i <= n; i++)
+        a[i] = (str[i] == ')' && match[i])?(a[match[i] - 1] + 1):0;
+    for(int i = n; i >= 1; i--)
+        b[i] = (str[i] == '(' && match[i])?(b[i] = b[match[i] + 1] + 1):0;
+    for(int i = 1; i <= n; i++)
+         ans[i] = (str[i] == '(')?(ans[pre[i]] + ((long long)b[i]*a[match[i]] % Mod) % Mod):ans[match[i]];  
+}
+long long calcu()
+{
+    long long tot = 0;
+    for(int i = 1; i <= n; i++)
+        tot = tot + ans[i]*i % Mod;
+    return tot; 
+}
+int main()
+{
+    read(T);
+    while(T--)
+    {
+        scanf("%s", str + 1);
+        n = strlen(str + 1);
+        prework(), solve();
+        write(calcu()), puts("");
+    }
+    return 0;            
+}
diff --git a/HDOJ/5358_autoAC.cpp b/HDOJ/5358_autoAC.cpp
new file mode 100644
index 0000000..ca37872
--- /dev/null
+++ b/HDOJ/5358_autoAC.cpp
@@ -0,0 +1,57 @@
+#pragma comment(linker, "/STACK:102400000,102400000")
+#include <iostream>
+#include<stdio.h>
+#include<string.h>
+#include<vector>
+#include<algorithm>
+#include<cmath>
+#include<map>
+#include<queue>
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1 | 1
+#define lowbit(x) x&(-x)
+using namespace std;
+typedef long long LL;
+const int N=1e5+10;
+long long inf=1e15;
+const int MOD=1e9+7;
+int T,n,m,k,x,y,z,l,tot;
+long long cnt;
+int a[N];
+long long sum[N];
+long long solve(long long L,long long R){    
+    long long ans=0;
+    int l,r;
+    r=0;l=1;
+    for(int i=1;i<=n;i++){
+        if(l<i) l=i;
+        if(r<i-1) r=i-1;
+        while(l<=n && sum[l]-sum[i-1]<L) l++;
+        while(r+1<=n && sum[r+1]-sum[i-1]<R) r++;
+        if(l>r) continue;
+        if(sum[r]-sum[i-1]<L || sum[r]-sum[i-1]>=R) continue;
+        if(sum[l]-sum[i-1]<L || sum[l]-sum[i-1]>=R) continue;
+        ans+=(long long)(r-l+1)*i+(long long)(l+r)*(r-l+1)/2;
+    }
+    return ans;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d",&n);
+        sum[0]=0;
+        for(int i=1;i<=n;i++) {
+            scanf("%d",&a[i]);
+            sum[i]=sum[i-1]+a[i];
+        }
+        long long ans=0;
+        for(int k=1;k<=34;k++){
+            ans+=(long long)k*solve(pow(2,k-1),pow(2,k));
+        }
+         ans+=solve(0,1);
+         printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5360_autoAC.cpp b/HDOJ/5360_autoAC.cpp
new file mode 100644
index 0000000..e0d2e7c
--- /dev/null
+++ b/HDOJ/5360_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<cstdio>
+#include<cmath>
+#include<iostream>
+#include<queue>
+#include<vector>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const ll maxn=100005;
+int T,n,m,l[maxn],r[maxn],ans[maxn],tot,f[maxn];
+struct lr
+{
+    int l,r,id;
+    lr(int l,int r,int id):l(l),r(r),id(id){};
+    bool operator <(const lr& a)const
+    {
+        if (r==a.r) return l>a.l;
+        return r>a.r;
+    }
+};
+vector<lr> p[maxn];
+int main()
+{
+    scanf("%d",&T);
+    while (T--)
+    {
+        scanf("%d",&n);    tot=0;
+        for (int i=1;i<=n;i++) scanf("%d",&l[i]);
+        for (int i=1;i<=n;i++) scanf("%d",&r[i]);
+        for (int i=0;i<=n;i++) p[i].clear();
+        for (int i=1;i<=n;i++) p[l[i]].push_back(lr(l[i],r[i],i));
+        priority_queue<lr> que;
+        for (int i=0;i<=n;)
+        {
+            for (int j=0;j<p[i].size();j++) que.push(lr(p[i][j]));
+            while (!que.empty()&&que.top().r<i) que.pop();
+            if (!que.empty()) {ans[tot++]=que.top().id; que.pop(); i++;}
+            else break;
+        }
+        printf("%d\n",tot);
+        if (tot) 
+        {
+            memset(f,0,sizeof(f));
+            printf("%d",ans[0]);
+            for (int i=1;i<tot;i++) printf(" %d",ans[i]);
+            for (int i=0;i<tot;i++) f[ans[i]]=1;
+            for (int i=1;i<=n;i++) if (!f[i]) printf(" %d",i);
+        }
+        else for (int i=1;i<=n;i++) 
+        {
+            if (i>1) printf(" ");
+            printf("%d",i);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5361_autoAC.cpp b/HDOJ/5361_autoAC.cpp
new file mode 100644
index 0000000..3cd6d9d
--- /dev/null
+++ b/HDOJ/5361_autoAC.cpp
@@ -0,0 +1,73 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+#include<set>
+using namespace std;
+#define maxn 200007
+#define ll long long
+int lp[maxn],rp[maxn];
+ll cosw[maxn];
+ll dist[maxn];
+set<int> haha;
+struct Node{
+    int id;
+    ll cost;
+};
+bool operator < (Node a,Node b){
+    if(a.cost == b.cost) return a.id < b.id;
+    return a.cost < b.cost;
+}
+set<Node> mind;
+int main(){
+    int t,n;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(int i = 0;i < n; i++)
+            scanf("%d",&lp[i]);
+        for(int i = 0;i < n; i++)
+            scanf("%d",&rp[i]);
+        for(int i = 0;i < n; i++)
+            scanf("%d",&cosw[i]);
+        haha.clear();
+        mind.clear();
+        memset(dist,-1,sizeof(dist));
+        dist[0] = 0;
+        Node x,y;
+        x.id = 0;
+        x.cost = cosw[0];
+        mind.insert(x);
+        for(int i = 1;i < n; i++)
+            haha.insert(i);
+        set<int>::iterator it,it2;
+        while(mind.size() > 0){
+            x = *mind.begin();
+            mind.erase(mind.begin());
+            it = haha.lower_bound(x.id - rp[x.id]);
+            while(it != haha.end()  && *it <= x.id - lp[x.id]){
+                y.id = *it;
+                y.cost = x.cost + cosw[y.id];
+                dist[y.id] = x.cost;
+                mind.insert(y);
+                it2 = it++;
+                haha.erase(it2);
+            }
+            it = haha.lower_bound(x.id + lp[x.id]);
+            while(it != haha.end()  && *it <= x.id + rp[x.id]){
+                y.id = *it;
+                y.cost = x.cost + cosw[y.id];
+                dist[y.id] = x.cost;
+                mind.insert(y);
+                it2 = it++;
+                haha.erase(it2);
+            }
+        }
+        for(int  i = 0;i < n; i++){
+            if(i) printf(" ");
+            printf("%I64d",dist[i]);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5363_autoAC.cpp b/HDOJ/5363_autoAC.cpp
new file mode 100644
index 0000000..9154093
--- /dev/null
+++ b/HDOJ/5363_autoAC.cpp
@@ -0,0 +1,27 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+const int m=1000000007;
+int pow_mod(__int64 a,__int64 n,int m)
+{
+    if(n==0) return 1;
+    __int64 x=pow_mod(a,n/2,m);
+    __int64 ans=(x%m)*(x%m);
+    ans%=m;
+    if(n%2==1) ans=ans*a%m;
+    return (int)ans;
+}
+int main()
+{
+    int _;
+    __int64 n;
+    scanf("%d",&_);
+    while(_--)
+    {
+        scanf("%I64d",&n);
+        int ans=pow_mod(2,n-1,m);
+        printf("%d\n",(ans-1)%m);
+    }
+    return 0;
+}
diff --git a/HDOJ/5364_autoAC.cpp b/HDOJ/5364_autoAC.cpp
new file mode 100644
index 0000000..0498789
--- /dev/null
+++ b/HDOJ/5364_autoAC.cpp
@@ -0,0 +1,35 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+using namespace std;
+const int maxn=1e4+5;
+int a;
+int b[maxn];
+int main()
+{
+    int m;
+    while(scanf("%d",&m)!=EOF)
+    {
+        memset(b,0,sizeof(b));
+        for(int i=0; i<m; i++)
+        {
+            scanf("%d",&a);
+            b[a]++;
+        }
+        int maxx=-99;
+        int flag=0;
+        for(int i=0; i<maxn; i++)
+        {
+            if(maxx<b[i])
+            {
+                maxx=b[i];
+                flag=i;
+            }
+        }
+        if(maxx<=m/2)
+            printf("-1\n");
+        else
+            printf("%d\n",flag);
+    }
+    return 0;
+}
diff --git a/HDOJ/5365_autoAC.cpp b/HDOJ/5365_autoAC.cpp
new file mode 100644
index 0000000..7054f57
--- /dev/null
+++ b/HDOJ/5365_autoAC.cpp
@@ -0,0 +1,55 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<queue>
+#include<math.h>
+#include<vector>
+#include<map>
+#include<set>
+#include<cmath>
+#include<string>
+#include<algorithm>
+#include<iostream>
+#define exp 1e-10
+#define ll __int64
+using namespace std;
+const int N = 25;
+const int inf = 1000000000;
+const int mod = 1000000007;
+int x[N],y[N],s[6];
+int sqare(int x1,int y1,int x2,int y2)
+{
+    return (x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);
+}
+bool judge(int i,int j,int k,int l)
+{
+    int t=0;
+    s[t++]=sqare(x[i],y[i],x[j],y[j]);
+    s[t++]=sqare(x[j],y[j],x[k],y[k]);
+    s[t++]=sqare(x[k],y[k],x[l],y[l]);
+    s[t++]=sqare(x[l],y[l],x[i],y[i]);
+    s[t++]=sqare(x[i],y[i],x[k],y[k]);
+    s[t++]=sqare(x[l],y[l],x[j],y[j]);
+    sort(s,s+6);
+    if(s[0]==s[1]&&s[2]==s[3]&&s[1]==s[2]&&s[4]==2*s[0]&&s[5]==s[4])
+        return true;
+    return false;
+}
+int main()
+{
+    int n,i,j,k,l,t;
+    while(~scanf("%d",&n))
+    {
+        t=0;
+        for(i=1;i<=n;i++)
+            scanf("%d%d",&x[i],&y[i]);
+        for(i=1;i<=n;i++)
+            for(j=i+1;j<=n;j++)
+                for(k=j+1;k<=n;k++)
+                    for(l=k+1;l<=n;l++)
+                        if(judge(i,j,k,l))
+                            t++;
+        printf("%d\n",t);
+    }
+    return 0;
+}
diff --git a/HDOJ/5366_autoAC.cpp b/HDOJ/5366_autoAC.cpp
new file mode 100644
index 0000000..6d0f6fc
--- /dev/null
+++ b/HDOJ/5366_autoAC.cpp
@@ -0,0 +1,18 @@
+#include <iostream>
+#include <cstdio>
+using namespace std;
+__int64 dp[62];
+int main()
+{
+    int m;
+    dp[1]=1;
+    dp[2]=2;
+    dp[3]=3;
+    for(int i=4; i<61; i++)
+        dp[i] = dp[i-1]+dp[i-3]+1;
+    while(~scanf("%d",&m))
+    {
+        printf("%I64d\n",dp[m]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5367_autoAC.cpp b/HDOJ/5367_autoAC.cpp
new file mode 100644
index 0000000..a5245f5
--- /dev/null
+++ b/HDOJ/5367_autoAC.cpp
@@ -0,0 +1,137 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std ;
+typedef long long LL ;
+#define clr( a , x ) memset ( a , x , sizeof a )
+const int MAXN = 50005 ;
+const int INF = 0x3f3f3f3f ;
+struct Node {
+    int sum , lsum , rsum ;
+    int lnum , rnum ;
+    int lf , rf ;
+    int ls , rs ;
+    int l , r , len ;
+    int add ;
+    void init ( int _l , int _r ) {
+        add = sum = lnum = rnum = lf = rf = ls = rs = 0 ;
+        l = _l ;
+        r = _r ;
+        lsum = rsum = len = r - l + 1 ;
+    }
+} ;
+Node T[MAXN * 60] ;
+int root , cur ;
+int n , m ;
+void check ( int& o , int l , int r ) {
+    if ( o ) return ;
+    o = ++ cur ;
+    T[o].init ( l , r ) ;
+    if ( l == 1 ) T[o].lf = INF ;
+    if ( r == n ) T[o].rf = INF ;
+}
+void pushup ( int o ) {
+    int m = ( T[o].l + T[o].r ) >> 1 ;
+    check ( T[o].ls , T[o].l , m ) ;
+    check ( T[o].rs , m + 1 , T[o].r ) ;
+    int ls = T[o].ls , rs = T[o].rs ;
+    T[o].sum = T[ls].sum + T[rs].sum ;
+    T[o].lnum = T[ls].lnum ;
+    T[o].rnum = T[rs].rnum ;
+    T[o].lsum = T[ls].lsum ;
+    T[o].rsum = T[rs].rsum ;
+    T[o].lf = T[ls].lf ;
+    T[o].rf = T[rs].rf ;
+    if ( T[ls].rnum == T[rs].lnum ) {
+        if ( T[ls].rf < T[ls].rnum && T[rs].lf < T[rs].lnum ) {
+            T[o].sum += T[ls].rsum + T[rs].lsum ;
+        }
+        if ( T[ls].rsum == T[ls].len ) {
+            T[o].lf = T[rs].lf ;
+            T[o].lsum += T[rs].lsum ;
+        }
+        if ( T[rs].lsum == T[rs].len ) {
+            T[o].rf = T[ls].rf ;
+            T[o].rsum += T[ls].rsum ;
+        }
+    } else {
+        if ( T[ls].lsum == T[ls].len ) {
+            T[o].lf = T[rs].lnum ;
+        }
+        if ( T[ls].rnum > T[ls].rf && T[ls].rnum > T[rs].lnum ) {
+            T[o].sum += T[ls].rsum ;
+        }
+        if ( T[rs].rsum == T[rs].len ) {
+            T[o].rf = T[ls].rnum ;
+        }
+        if ( T[rs].lnum > T[rs].lf && T[rs].lnum > T[ls].rnum ) {
+            T[o].sum += T[rs].lsum ;
+        }
+    }
+}
+void upd ( int o , int addv ) {
+    T[o].add += addv ;
+    T[o].lnum += addv ;
+    T[o].rnum += addv ;
+    T[o].lf += addv ;
+    T[o].rf += addv ;
+}
+void pushdown ( int o ) {
+    int m = ( T[o].l + T[o].r ) >> 1 ;
+    if ( T[o].add ) {
+        check ( T[o].ls , T[o].l , m ) ;
+        check ( T[o].rs , m + 1 , T[o].r ) ;
+        upd ( T[o].ls , T[o].add ) ;
+        upd ( T[o].rs , T[o].add ) ;
+        T[o].add = 0 ;
+    }
+}
+void update ( int L , int R , int v , int& o , int l , int r ) {
+    check ( o , l , r ) ;
+    if ( L <= l && r <= R ) {
+        upd ( o , v ) ;
+        return ;
+    }
+    pushdown ( o ) ;
+    int m = ( l + r ) >> 1 ;
+    if ( L <= m ) update ( L , R , v , T[o].ls , l , m ) ;
+    if ( m <  R ) update ( L , R , v , T[o].rs , m + 1 , r ) ;
+    pushup ( o ) ;
+}
+void show ( int o , int l , int r ) {
+    if ( o == 0 ) {
+        for ( int i = l ; i <= r ; ++ i ) {
+            printf ( "%d " , 0 ) ;
+        }
+        return ;
+    } else if ( !T[o].ls && !T[o].rs ) {
+        for ( int i = l ; i <= r ; ++ i ) {
+            printf ( "%d " , T[o].lnum ) ;
+        }
+        return ;
+    }
+    pushdown ( o ) ;
+    int m = ( l + r ) >> 1 ;
+    show ( T[o].ls , l , m ) ;
+    show ( T[o].rs , m + 1 , r ) ;
+    pushup ( o ) ;
+}
+void solve () {
+    int l , r , v ;
+    root = cur = 0 ;
+    int ans = 0 ;
+    for ( int i = 0 ; i < m ; ++ i ) {
+        scanf ( "%d%d%d" , &l , &r , &v ) ;
+        l ^= ans ;
+        r ^= ans ;
+        v ^= ans ;
+        if ( l > r ) swap ( l , r ) ;
+        update ( l , r , v , root , 1 , n ) ;
+        ans = T[1].sum ;
+        printf ( "%d\n" , T[1].sum ) ;
+    }
+}
+int main () {
+    while ( ~scanf ( "%d%d%*d" , &n , &m ) ) solve () ;
+    return 0 ;
+}
diff --git a/HDOJ/5370_autoAC.cpp b/HDOJ/5370_autoAC.cpp
new file mode 100644
index 0000000..dd3456c
--- /dev/null
+++ b/HDOJ/5370_autoAC.cpp
@@ -0,0 +1,129 @@
+#include<iostream>
+#include<stdio.h>
+#include<string.h> 
+using namespace std ;
+typedef long long LL ;
+#define clr( a , x ) memset ( a , x , sizeof a )
+const int MAXN = 505 ;
+const int mod = 1e9 + 7 ;
+int G[MAXN][2] , cnt ;
+int f[MAXN] ;
+int root[MAXN] , idx ;
+int is[MAXN] ;
+int num[MAXN] ;
+int dp[MAXN] , dp2[MAXN][MAXN] ;
+int n , cur ;
+void upd ( int& x , int y ) {
+    x += y ;
+    if ( x >= mod ) x -= mod ;
+}
+void preprocess () {
+    dp[0] = dp[1] = 1 ;
+    for ( int i = 2 ; i < MAXN ; ++ i ) {
+        for ( int j = 0 ; j < i ; ++ j ) {
+            upd ( dp[i] , ( LL ) dp[j] * dp[i - 1 - j] % mod ) ;
+        }
+    }
+}
+void dfs ( int u , int x ) {
+    int l = G[u][0] , r = G[u][1] ;
+    if ( is[u] == is[l] ) dfs ( l , x ) ;
+    if ( is[u] == is[r] ) dfs ( r , x ) ;
+    if ( is[l] != is[u] && is[r] != is[u] ) {
+        if ( !l && !r ) {
+            for ( int i = 0 ; i <= x ; ++ i ) {
+                dp2[u][i] = dp[i + 1] ;
+            }
+        } else if ( !l ) {
+            for ( int i = 0 ; i <= x ; ++ i ) {
+                dp2[u][i] = dp[i] ;
+            }
+        } else if ( !r ) {
+            for ( int i = 0 ; i <= x ; ++ i ) {
+                dp2[u][i] = dp[i] ;
+            }
+        } else {
+            dp2[u][0] = 1 ;
+            for ( int i = 1 ; i <= x ; ++ i ) {
+                dp2[u][i] = 0 ;
+            }
+        }
+    } else if ( is[u] != is[l] ) {
+        if ( !l ) {
+            for ( int i = 0 ; i <= x ; ++ i ) {
+                dp2[u][i] = 0 ;
+                for ( int j = 0 ; j <= i ; ++ j ) {
+                    upd ( dp2[u][i] , ( LL ) dp[j] * dp2[r][i - j] % mod ) ;
+                }
+            }
+        } else {
+            for ( int i = 0 ; i <= x ; ++ i ) {
+                dp2[u][i] = dp2[r][i] ;
+            }
+        }
+    } else if ( is[u] != is[r] ) {
+        if ( !r ) {
+            for ( int i = 0 ; i <= x ; ++ i ) {
+                dp2[u][i] = 0 ;
+                for ( int j = 0 ; j <= i ; ++ j ) {
+                    upd ( dp2[u][i] , ( LL ) dp[j] * dp2[l][i - j] % mod ) ;
+                }
+            }
+        } else {
+            for ( int i = 0 ; i <= x ; ++ i ) {
+                dp2[u][i] = dp2[l][i] ;
+            }
+        }
+    } else {
+        for ( int i = 0 ; i <= x ; ++ i ) {
+            dp2[u][i] = 0 ;
+            for ( int j = 0 ; j <= i ; ++ j ) {
+                upd ( dp2[u][i] , ( LL ) dp2[l][j] * dp2[r][i - j] % mod ) ;
+            }
+        }
+    }
+}
+int newnode ( int x ) {
+    ++ cnt ;
+    G[cnt][0] = G[cnt][1] = 0 ;
+    f[cnt] = cur ;
+    is[cnt] = x ;
+    return cnt ;
+}
+void solve () {
+    int op , x ;
+    idx = cnt = 0 ;
+    cur = 1 ;
+    newnode ( 0 ) ;
+    for ( int i = 1 ; i <= n ; ++ i ) {
+        scanf ( "%d" , &op ) ;
+        if ( op == 0 ) cur = f[cur] ;
+        else if ( op <= 2 ) {
+            if ( !G[cur][op - 1] ) {
+                G[cur][op - 1] = newnode ( is[cur] ) ;
+                num[is[cur]] -- ;
+            }
+            cur = G[cur][op - 1] ;
+        } else {
+            scanf ( "%d" , &x ) ;
+            G[cur][op - 3] = newnode ( ++ idx ) ;
+            root[idx] = cnt ;
+            num[idx] = x - 1 ;
+        }
+    }
+    int ans = 1 ;
+    for ( int i = 1 ; i <= idx ; ++ i ) if ( num[i] ) {
+        dfs ( root[i] , num[i] ) ;
+        ans = ( LL ) ans * dp2[root[i]][num[i]] % mod ;
+    }
+    printf ( "%d\n" , ans ) ;
+}
+int main () {
+    int cas = 0 ;
+    preprocess () ;
+    while ( ~scanf ( "%d" , &n ) ) {
+        printf ( "Case #%d: " , ++ cas ) ;
+        solve () ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5371_autoAC.cpp b/HDOJ/5371_autoAC.cpp
new file mode 100644
index 0000000..2a94689
--- /dev/null
+++ b/HDOJ/5371_autoAC.cpp
@@ -0,0 +1,57 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<iostream>
+using namespace std ;
+const int maxn = 2e5 + 10 ;
+int str[maxn] ;
+int p[maxn] ;
+void pk(int n)
+{
+    int i;
+    int mx = 0;
+    int id=0;
+    for(i=0; i<n; i++)
+    {
+        if( mx > i )
+            p[i] = min( p[2*id-i], mx-i );
+        else
+            p[i] = 1;
+        for(; str[i+p[i]] == str[i-p[i]] && i - p[i] >= 0 && i + p[i] < n; p[i]++);
+        if( p[i] + i > mx )
+        {
+            mx = p[i] + i;
+            id = i;
+        }
+    }
+}
+int main()
+{
+    int t  ;
+    int cas = 0 ;
+    int  n ;
+    scanf("%d" , &t) ;
+    while(t--)
+    {
+        scanf("%d" , &n) ;
+        for(int i = 0;i <= 2*n+1;i++)
+        p[i] = 0 ;
+        int len = 0 ;
+        str[len++] = -1 ;
+        for(int i = 1;i <= n;i++)
+        {
+            scanf("%d" , &str[len++]) ;
+            str[len++] = -1 ;
+        }
+        int ans = 1 ;
+        pk(len) ;
+        for(int i = 2;i < len-1 ;i += 2)
+          for(int j = ans;j <= p[i] ;j += 2)
+            if(p[i + j -1]>= j)
+              ans = j;
+        ans = ans/2*3 ;
+        printf("Case #%d: ",++cas) ;
+        cout<<ans<<endl;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5372_autoAC.cpp b/HDOJ/5372_autoAC.cpp
new file mode 100644
index 0000000..89d928f
--- /dev/null
+++ b/HDOJ/5372_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<cstdio>
+#include<cmath>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int low(int x) { return x&-x; }
+const int maxn = 400005;
+int n, m, x[maxn], y[maxn], z[maxn], a[maxn], tot, f[2][maxn], tt = 0, u, v;
+void add(int x, int y, int z)
+{
+    for (int i = y; i <= m; i += low(i)) f[x][i] += z;
+}
+int get(int x, int y)
+{
+    int ans = 0;
+    for (int i = y; i; i -= low(i)) ans += f[x][i];
+    return ans;
+}
+int main()
+{
+    while (scanf("%d", &n) != EOF)
+    {
+        tot = 0;
+        memset(f, 0, sizeof(f));
+        for (int i = 1; i <= n; i++)
+        {
+            scanf("%d%d", &z[i], &x[i]);
+            if (!z[i]) {
+                a[++tot] = x[i];
+                y[i] = x[i] + (++tot) / 2;
+                a[tot] = y[i];
+            }
+            else
+            {
+                y[i] = a[x[i] + x[i]];
+                x[i] = a[x[i] + x[i] - 1];
+            }
+        }
+        sort(a + 1, a + tot + 1);
+        m = unique(a + 1, a + tot + 1) - a;
+        printf("Case #%d:\n", ++tt);
+        for (int i = 1; i <= n; i++)
+        {
+            u = lower_bound(a + 1, a + m, x[i]) - a;
+            v = lower_bound(a + 1, a + m, y[i]) - a;    
+            if (!z[i]) printf("%d\n", get(1, v) - get(0, u - 1));
+            add(0, u, z[i] ? -1 : 1);
+            add(1, v, z[i] ? -1 : 1);
+        }
+    } 
+    return 0;
+}
diff --git a/HDOJ/5373_autoAC.cpp b/HDOJ/5373_autoAC.cpp
new file mode 100644
index 0000000..2c6bcb7
--- /dev/null
+++ b/HDOJ/5373_autoAC.cpp
@@ -0,0 +1,53 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <queue>
+#include <vector>
+#include <malloc.h>
+#define Max(a,b) (a>b?a:b)
+#define Min(a,b) (a<b?a:b)
+#define MAX 999999999
+#define LL long long
+#define M 6666666
+using namespace std;
+int main()
+{
+    int n,m,i,j,k,l,cas=1;
+    while(~scanf("%d%d",&n,&m))
+    {
+        if(n==-1&&m==-1)break;
+         if(m==0)
+         {
+              if(n%11==0)printf("Case #%d: Yes\n",cas++);
+            else printf("Case #%d: No\n",cas++);
+            continue;
+         }
+        k=n;
+        l=0;
+        while(k>0)
+        {
+            l+=k%10;
+            k/=10;
+        }
+        while(m--)
+        {
+            k=l;
+            while(k>0)
+            {
+                k/=10;
+                n*=10;
+            }
+            n=(n+l)%11;
+            k=l;
+            while(k>0)
+            {
+                l+=k%10;
+                k/=10;
+            }
+        }
+        if(n==0)printf("Case #%d: Yes\n",cas++);
+        else printf("Case #%d: No\n",cas++);
+    }
+    return 0;
+}
diff --git a/HDOJ/5374_autoAC.cpp b/HDOJ/5374_autoAC.cpp
new file mode 100644
index 0000000..ecbefec
--- /dev/null
+++ b/HDOJ/5374_autoAC.cpp
@@ -0,0 +1,581 @@
+#include <map>
+#include <cmath>
+#include <queue>
+#include <cstdio>
+#include <vector>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+char seq[1010];
+int type[1010];
+int maz[20][20];
+int LS;
+int now;
+int ans;
+int N;
+void init()
+{
+    memset(maz, 0, sizeof(maz));
+}
+void out(){
+    return;
+    getchar();
+    system( "cls" );
+    cout << now << " " << seq[now] <<  endl;
+    for( int i = 12 ; i ; i -- )
+    {
+        for( int j = 1 ; j <= 9 ; j ++ )
+            printf("%d ",maz[j][i] );
+        puts("");
+    }
+}
+int tmp[20][20];
+void disappear()
+{
+out();
+    memset(tmp, 0, sizeof(tmp));
+    int nx = 1;
+    for(int y = 1; y <= 12; y++)
+    {
+        int cnt = 0;
+        for(int x = 1; x <= 9; x++)
+            if(maz[x][y]) cnt++;
+        if(cnt == 9)
+        {
+            ans++;
+        }
+        else
+        {
+            for(int i = 1; i <= 9; i++)
+                tmp[i][nx] = maz[i][y];
+            nx++;
+        }
+    }
+    memset(maz, 0, sizeof(maz));
+    for(int j = 1; j <= 9; j++)
+        for(int i = 1; i < nx; i++)
+            maz[j][i] = tmp[j][i];
+out();
+    return;
+}
+void OO()
+{
+    int midx = 4, midy = 9;
+    maz[midx][midy] = maz[midx][midy + 1] = maz[midx + 1][midy] = maz[midx + 1][midy + 1] = 1;
+    while(now < LS)
+    {
+out();
+        if(seq[now] == 'w')
+        {
+            ;
+        }
+        else if(seq[now] == 'a')
+        {
+            if(midx - 1 >= 1 && !maz[midx - 1][midy] && !maz[midx - 1][midy + 1])
+            {
+                maz[midx - 1][midy] = maz[midx - 1][midy + 1] = 1;
+                maz[midx + 1][midy] = maz[midx + 1][midy + 1] = 0;
+                midx--;
+            }
+            else ;
+        }
+        else if(seq[now] == 'd')
+        {
+            if(midx + 1 + 1 <= 9 && !maz[midx + 2][midy] && !maz[midx + 2][midy + 1])
+            {
+                maz[midx + 2][midy] = maz[midx + 2][midy + 1] = 1;
+                maz[midx][midy] = maz[midx][midy + 1] = 0;
+                midx++;
+            }
+            else ;
+        }
+        else if(seq[now] == 's')
+        {
+            if(midy - 1 >= 1 && maz[midx][midy - 1] == 0 && maz[midx + 1][midy - 1] == 0)
+            {
+                maz[midx][midy - 1] = maz[midx + 1][midy - 1] = 1;
+                maz[midx][midy + 1] = maz[midx + 1][midy + 1] = 0;
+                midy--;
+            }
+            else ;
+        }
+        now++;
+        if(midy - 1 >= 1 && maz[midx][midy - 1] == 0 && maz[midx + 1][midy - 1] == 0)
+        {
+            maz[midx][midy - 1] = maz[midx + 1][midy - 1] = 1;
+            maz[midx][midy + 1] = maz[midx + 1][midy + 1] = 0;
+            midy--;
+        }
+        else
+        {
+            break;
+        }
+    }
+    disappear();
+    return;
+}
+void II()
+{
+    int midx = 4, midy = 9;
+    for(int i = 0; i < 4; i++)
+        maz[midx][midy + i] = 1;
+    int cas = 0;
+    while(now < LS)
+    {
+out();
+        if(seq[now] == 'w')
+        {
+            if(cas == 0)
+            {
+                bool ok = 1;
+                for(int i = 1; i <= 3; i++)
+                {
+                    if(midx + i > 9 || maz[midx + i][midy] == 1)
+                    {
+                        ok = 0;
+                        break;
+                    }
+                }
+                if(!ok) ;
+                else
+                {
+                    for(int i = 1; i <= 3; i++)
+                        maz[midx][midy + i] = 0;
+                    for(int i = 1; i <= 3; i++)
+                        maz[midx + i][midy] = 1;
+                    cas = 1;
+                }
+            }
+            else
+            {
+                bool ok = 1;
+                for(int i = 1; i <= 3; i++)
+                {
+                    if(maz[midx][midy + i] == 1)
+                    {
+                        ok = 0;
+                        break;
+                    }
+                }
+                if(!ok);
+                else
+                {
+                    for(int i = 1; i <= 3; i++)
+                        maz[midx][midy + i] = 1;
+                    for(int i = 1; i <= 3; i++)
+                        maz[midx + i][midy] = 0;
+                    cas = 0;
+                }
+            }
+        }
+        else if(seq[now] == 'a')
+        {
+            if(cas == 0)
+            {
+                bool ok = 1;
+                for(int i = 0; i < 4; i++)
+                    if(midx - 1 < 1 || maz[midx - 1][midy + i] == 1)
+                    {
+                        ok = 0;
+                        break;
+                    }
+                if(!ok);
+                else
+                {
+                    for(int i = 0; i < 4; i++)
+                    {
+                        maz[midx - 1][midy + i] = 1;
+                        maz[midx][midy + i] = 0;
+                    }
+                    midx--;
+                }
+            }
+            else
+            {
+                if(midx - 1 < 1 || maz[midx - 1][midy] == 1);
+                else
+                {
+                    maz[midx - 1][midy] = 1;
+                    maz[midx + 3][midy] = 0;
+                    midx--;
+                }
+            }
+        }
+        else if(seq[now] == 'd')
+        {
+            if(cas == 0)
+            {
+                bool ok = 1;
+                for(int i = 0; i < 4; i++)
+                    if(midx + 1 > 9 || maz[midx + 1][midy + i] == 1)
+                    {
+                        ok = 0;
+                        break;
+                    }
+                if(!ok);
+                else
+                {
+                    for(int i = 0; i < 4; i++)
+                    {
+                        maz[midx + 1][midy + i] = 1;
+                        maz[midx][midy + i] = 0;
+                    }
+                    midx++;
+                }
+            }
+            else
+            {
+                if(midx + 4 > 9 || maz[midx + 4][midy] == 1);
+                else
+                {
+                    maz[midx + 4][midy] = 1;
+                    maz[midx][midy] = 0;
+                    midx++;
+                }
+            }
+        }
+        else if(seq[now] == 's')
+        {
+            if(cas == 0)
+            {
+                if(midy - 1 < 1 || maz[midx][midy - 1] == 1);
+                else
+                {
+                    maz[midx][midy + 3] = 0;
+                    maz[midx][midy - 1] = 1;
+                    midy--;
+                }
+            }
+            else
+            {
+                int ok = 1;
+                for(int i = 0; i < 4; i++)
+                    if(midy - 1 < 1 || maz[midx + i][midy - 1] == 1)
+                    {
+                        ok = 0;
+                        break;
+                    }
+                if(!ok);
+                else
+                {
+                    for(int i = 0; i < 4; i++)
+                        maz[midx + i][midy - 1] = 1;
+                    for(int i = 0; i < 4; i++)
+                        maz[midx + i][midy] = 0;
+                    midy--;
+                }
+            }
+        }
+        now++;
+        if(cas == 0)
+        {
+            if(midy - 1 < 1 || maz[midx][midy - 1] == 1)
+                break;
+            else
+            {
+                maz[midx][midy + 3] = 0;
+                maz[midx][midy - 1] = 1;
+                midy--;
+            }
+        }
+        else
+        {
+            int ok = 1;
+            for(int i = 0; i < 4; i++)
+                if(midy - 1 < 1 || maz[midx + i][midy - 1] == 1)
+                {
+                    ok = 0;
+                    break;
+                }
+            if(!ok)
+                break;
+            else
+            {
+                for(int i = 0; i < 4; i++)
+                    maz[midx + i][midy - 1] = 1;
+                for(int i = 0; i < 4; i++)
+                    maz[midx + i][midy] = 0;
+                midy--;
+            }
+        }
+    }
+    disappear();
+}
+void JJ()
+{
+    int midx = 4, midy = 9;
+    int cas = 0;
+    maz[midx][midy] = maz[midx + 1][midy] = maz[midx + 2][midy] = maz[midx][midy + 1] = 1;
+    while(now < LS)
+    {
+out();
+        if(seq[now] == 'w')
+        {
+            if(cas == 0)
+            {
+                if(maz[midx][midy + 2] == 1 || maz[midx + 1][midy + 2] == 1);
+                else
+                {
+                    maz[midx + 1][midy] = maz[midx + 2][midy] = 0;
+                    maz[midx][midy + 2] = maz[midx + 1][midy + 2] = 1;
+                    cas = 1;
+                }
+            }
+            else if(cas == 1)
+            {
+                if(maz[midx + 1][midy + 1] == 1 || maz[midx + 2][midy + 1] == 1 || maz[midx + 2][midy] == 1);
+                else
+                {
+                    maz[midx][midy] = maz[midx][midy + 2] = maz[midx + 1][midy + 2] = 0;
+                    maz[midx + 1][midy + 1] = maz[midx + 2][midy] = maz[midx + 2][midy + 1] = 1;
+                    cas = 2;
+                }
+            }
+            else if(cas == 2)
+            {
+                if(maz[midx][midy] == 1 || maz[midx + 1][midy] == 1 || maz[midx + 1][midy + 2] == 1);
+                else
+                {
+                    maz[midx][midy] = maz[midx + 1][midy] = maz[midx + 1][midy + 2] = 1;
+                    maz[midx][midy + 1] = maz[midx + 2][midy] = maz[midx + 2][midy + 1] = 0;
+                    cas = 3;
+                }
+            }
+            else if(cas == 3)
+            {
+                if(maz[midx][midy + 1] == 1 || maz[midx + 2][midy] == 1);
+                else
+                {
+                    maz[midx][midy + 1] = maz[midx + 2][midy] = 1;
+                    maz[midx + 1][midy + 1] = maz[midx + 1][midy + 2] = 0;
+                    cas = 0;
+                }
+            }
+        }else if(seq[now] == 'a') 
+        {
+            if(cas == 0)
+            {
+                if(midx - 1 < 1 || maz[midx - 1][midy] == 1 || maz[midx - 1][midy + 1] == 1);
+                else
+                {
+                    maz[midx - 1][midy] = maz[midx - 1][midy + 1] = 1;
+                    maz[midx][midy + 1] = maz[midx + 2][midy] = 0;
+                    midx--;
+                }
+            }
+            else if(cas == 1)
+            {
+                if(midx - 1 < 1 || maz[midx - 1][midy] || maz[midx - 1][midy + 1] || maz[midx - 1][midy + 2]);
+                else
+                {
+                    maz[midx - 1][midy] = maz[midx - 1][midy + 1] = maz[midx - 1][midy + 2] = 1;
+                    maz[midx][midy] = maz[midx][midy + 1] = maz[midx + 1][midy + 2] = 0;
+                    midx--;
+                }
+            }
+            else if(cas == 2)
+            {
+                if(midx - 1 < 1 || maz[midx - 1][midy + 1] || maz[midx + 1][midy]);
+                else
+                {
+                    maz[midx - 1][midy + 1] = maz[midx + 1][midy] = 1;
+                    maz[midx + 2][midy] = maz[midx + 2][midy + 1] = 0;
+                    midx--;
+                }
+            }
+            else if(cas == 3)
+            {
+                if(midx - 1 < 1 || maz[midx - 1][midy] || maz[midx][midy + 1] || maz[midx][midy + 2]);
+                else
+                {
+                    maz[midx - 1][midy] = maz[midx][midy + 1] = maz[midx][midy + 2] = 1;
+                    maz[midx + 1][midy] = maz[midx + 1][midy + 1] = maz[midx + 1][midy + 2] = 0;
+                    midx--;
+                }
+            }
+        }
+        else if(seq[now] == 'd') 
+        {
+            if(cas == 0)
+            {
+                if(midx + 3 > 9 || maz[midx + 3][midy] || maz[midx + 1][midy + 1]);
+                else
+                {
+                    maz[midx + 3][midy] = maz[midx + 1][midy + 1] = 1;
+                    maz[midx][midy] = maz[midx][midy + 1] = 0;
+                    midx++;
+                }
+            }
+            else if(cas == 1)
+            {
+                if(midx + 2 > 9 || maz[midx + 2][midy + 2] || maz[midx + 1][midy] || maz[midx + 1][midy + 1]);
+                else
+                {
+                    maz[midx + 2][midy + 2] = maz[midx + 1][midy] = maz[midx + 1][midy + 1] = 1;
+                    maz[midx][midy] = maz[midx][midy + 1] = maz[midx][midy + 2] = 0;
+                    midx++;
+                }
+            }
+            else if(cas == 2)
+            {
+                if(midx + 3 > 9 || maz[midx + 3][midy] || maz[midx + 3][midy + 1]);
+                else
+                {
+                    maz[midx + 3][midy] = maz[midx + 3][midy + 1] = 1;
+                    maz[midx][midy + 1] = maz[midx + 2][midy] = 0;
+                    midx++;
+                }
+            }
+            else if(cas == 3)
+            {
+                if(midx + 2 > 9 || maz[midx + 2][midy] || maz[midx + 2][midy + 1] || maz[midx + 2][midy + 2]);
+                else
+                {
+                    maz[midx + 2][midy] = maz[midx + 2][midy +1] = maz[midx + 2][midy + 2] = 1;
+                    maz[midx][midy] = maz[midx + 1][midy + 1] = maz[midx +1][midy + 2] = 0;
+                    midx++;
+                }
+            }
+        }
+        else if(seq[now] == 's') 
+        {
+            if(cas == 0)
+            {
+                bool ok = 1;
+                for(int i = 0; i < 3; i++)
+                    if(midy - 1 < 1 || maz[midx + i][midy - 1])
+                    {
+                        ok = 0;
+                        break;
+                    }
+                if(!ok);
+                else
+                {
+                    for(int i = 0; i < 3; i++)
+                        maz[midx + i][midy - 1] = 1;
+                    maz[midx + 1][midy] = maz[midx + 2][midy] = maz[midx][midy + 1] = 0;
+                    midy--;
+                }
+            }
+            else if(cas == 1)
+            {
+                if(midy - 1 < 1 || maz[midx][midy - 1] || maz[midx + 1][midy + 1]);
+                else
+                {
+                    maz[midx][midy - 1] = maz[midx + 1][midy + 1] = 1;
+                    maz[midx][midy + 2] = maz[midx + 1][midy + 2] = 0;
+                    midy--;
+                }
+            }
+            else if(cas == 2)
+            {
+                if(midy - 1 < 1 || maz[midx + 2][midy - 1] || maz[midx][midy] || maz[midx + 1][midy]);
+                else
+                {
+                    maz[midx + 2][midy - 1] = maz[midx][midy] = maz[midx + 1][midy] = 1;
+                    maz[midx][midy + 1] = maz[midx + 1][midy + 1] = maz[midx + 2][midy + 1] = 0;
+                    midy--;
+                }
+            }
+            else if(cas == 3)
+            {
+                if(midy - 1 < 1 || maz[midx][midy - 1] || maz[midx + 1][midy - 1]);
+                else
+                {
+                    maz[midx][midy - 1] = maz[midx + 1][midy - 1] = 1;
+                    maz[midx][midy] = maz[midx + 1][midy + 2] = 0;
+                    midy--;
+                }
+            }
+        }
+        now++;
+        if(4)
+        {
+            if(cas == 0)
+            {
+                bool ok = 1;
+                for(int i = 0; i < 3; i++)
+                    if(midy - 1 < 1 || maz[midx + i][midy - 1])
+                    {
+                        ok = 0;
+                        break;
+                    }
+                if(!ok)
+                    break;
+                else
+                {
+                    for(int i = 0; i < 3; i++)
+                        maz[midx + i][midy - 1] = 1;
+                    maz[midx + 1][midy] = maz[midx + 2][midy] = maz[midx][midy + 1] = 0;
+                    midy--;
+                }
+            }
+            else if(cas == 1)
+            {
+                if(midy - 1 < 1 || maz[midx][midy - 1] || maz[midx + 1][midy + 1])
+                    break;
+                else
+                {
+                    maz[midx][midy - 1] = maz[midx + 1][midy + 1] = 1;
+                    maz[midx][midy + 2] = maz[midx + 1][midy + 2] = 0;
+                    midy--;
+                }
+            }
+            else if(cas == 2)
+            {
+                if(midy - 1 < 1 || maz[midx + 2][midy - 1] || maz[midx][midy] || maz[midx + 1][midy])
+                    break;
+                else
+                {
+                    maz[midx + 2][midy - 1] = maz[midx][midy] = maz[midx + 1][midy] = 1;
+                    maz[midx][midy + 1] = maz[midx + 1][midy + 1] = maz[midx + 2][midy + 1] = 0;
+                    midy--;
+                }
+            }
+            else if(cas == 3)
+            {
+                if(midy - 1 < 1 || maz[midx][midy - 1] || maz[midx + 1][midy - 1])
+                    break;
+                else
+                {
+                    maz[midx][midy - 1] = maz[midx + 1][midy - 1] = 1;
+                    maz[midx][midy] = maz[midx + 1][midy + 2] = 0;
+                    midy--;
+                }
+            }
+        }
+    }
+    disappear();
+}
+void start()
+{
+    init();
+    for(int i = 1; i <= N; i++)
+    {
+        switch(type[i])
+        {
+            case 0: OO(); break;
+            case 1: II(); break;
+            case 2: JJ(); break;
+        }
+    }
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    for(int cas = 1; cas <= T; cas++)
+    {
+        scanf("%d", &N);
+        scanf("%s", seq);
+        for(int i = 1; i <= N; i++)
+            scanf("%d", &type[i]);
+        LS = strlen(seq);
+        now = 0;
+        ans = 0;
+        start();
+        printf("Case %d: %d\n", cas,  ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5375_autoAC.cpp b/HDOJ/5375_autoAC.cpp
new file mode 100644
index 0000000..c5252a4
--- /dev/null
+++ b/HDOJ/5375_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std ;
+const int maxn = 2e5+10 ;
+const int inf = 0x3f3f3f3f ;
+int dp[maxn][2] ;
+char str[maxn] ;
+int a[maxn] ;
+int main()
+{
+    int t  ;int cas = 0 ;
+    scanf("%d" , &t) ;
+    while(t--)
+    {
+        scanf("%s" , str) ;
+        int n = strlen(str) ;
+        for(int i = 0 ;i < n;i++)
+        scanf("%d" , &a[i]) ;
+        dp[0][1] = dp[0][0] = -inf ;
+        if(str[0] == '1' || str[0] == '?')
+            dp[0][1] = a[0] ;
+        if(str[0] == '0' || str[0] == '?')
+            dp[0][0] = 0 ;
+        for(int i = 1;i < n;i++)
+        {
+            dp[i][0] = dp[i][1] = -inf ;
+            if(str[i] == '0' || str[i] == '?')
+            dp[i][0] = max(dp[i-1][0] , dp[i-1][1] + a[i]) ;
+            if(str[i] == '1' || str[i] == '?')
+            dp[i][1] = max(dp[i-1][1] , dp[i-1][0] + a[i]) ;
+        }
+        printf("Case #%d: " , ++cas) ;
+        cout<<max(dp[n-1][0] , dp[n-1][1])<<endl;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5377_autoAC.cpp b/HDOJ/5377_autoAC.cpp
new file mode 100644
index 0000000..785bd51
--- /dev/null
+++ b/HDOJ/5377_autoAC.cpp
@@ -0,0 +1,212 @@
+#include <cstdio>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+#include <string>
+#include <cmath>
+#include <vector>
+#include <map>
+#include <tr1/unordered_map>
+#define clr(x, y) memset(x, y, sizeof x)
+using namespace std;
+typedef long long LL;
+const double eps=1e-8;
+const int maxn=100100;
+const int mod=1e6+10;
+LL prime[maxn];
+LL X[maxn],Y[maxn];
+LL A[maxn],B[maxn];
+LL ans[maxn];
+LL M;
+LL get_prime(LL n)
+{
+    LL cnt=0;
+    for(LL i=2;i*i<=n;i++)
+    {
+        if(n%i==0)
+        {
+            prime[cnt++]=i;
+            while(n%i==0)
+                n/=i;
+        }
+    }
+    if(n!=1)
+        prime[cnt++]=n;
+    return cnt;
+}
+LL pow_mod(LL a,LL p,LL n)
+{
+    LL ans=1;
+    while(p)
+    {
+        if(p&1)
+            ans=(ans*a)%n;
+        p>>=1;
+        a=(a*a)%n;
+    }
+    return ans;
+}
+vector<LL>a;
+bool g_test(LL g,LL p)
+{
+    for(LL i=0;i<a.size();i++)
+    {
+        if(pow_mod(g,(p-1)/a[i],p)==1)
+            return 0;
+    }
+    return 1;
+}
+LL primitive_root(LL p)
+{
+    LL tmp=p-1;
+    a.clear();
+    for(LL i=2;i<=tmp/i;i++)
+    {
+        if(tmp%i==0)
+        {
+            a.push_back(i);
+            while(tmp%i==0)
+                tmp/=i;
+        }
+    }
+    if(tmp!=1)
+        a.push_back(tmp);
+    LL g=1;
+    while(true)
+    {
+        if(g_test(g,p))
+            return g;
+        g++;
+    }
+}
+void gcd(LL a,LL b,LL &d,LL &x,LL &y)
+{
+    if(!b) {  d=a;  x=1;  y=0;}
+    else
+    {
+        gcd(b,a%b,d,y,x);
+        y-=x*(a/b);
+    }
+}
+LL inv(LL a,LL n)
+{
+    LL d,x,y;
+    gcd(a,n,d,x,y);
+    return d==1 ? (x+n)%n : -1;
+}
+struct HashTable
+{
+    int top,head[mod];
+    struct Node
+    {
+        int x,y,next;
+    }node[mod];
+    void init()
+    {
+        top=0;
+        memset(head,0,sizeof(head));
+    }
+    void insert(LL x,LL y)
+    {
+        node[top].x=x;
+        node[top].y=y;
+        node[top].next=head[x%mod];
+        head[x%mod]=top++;
+    }
+    LL query(LL x)
+    {
+        for(int tx=head[x%mod];tx;tx=node[tx].next)
+        {
+            if(node[tx].x==x)
+                return node[tx].y;
+        }
+        return -1;
+    }
+}hs;
+void log_mod(LL a,LL n)
+{
+    LL m,v,e=1;
+    m=mod;
+    v=inv(pow_mod(a,m,n),n);
+    hs.init();
+    for(int i=0;i<m;i++)
+    {
+        hs.insert(e,i);
+        e=e*a%n;
+    }
+    for(int j=0;j<M;j++)
+    {
+        LL b=X[j]%n;
+        for(int i=0;i<m;i++)
+        {
+            LL s=hs.query(b);
+            if(s!=-1)
+            {
+                A[j]=i*m+s;
+                break;
+            }
+            b=b*v%n;
+        }
+        b=Y[j]%n;
+        for(int i=0;i<=n/m;i++)
+        {
+            LL s=hs.query(b);
+            if(s!=-1)
+            {
+                B[j]=i*m+s;
+                break;
+            }
+            b=b*v%n;
+        }
+    }
+}
+LL get_K(LL a,LL b,LL c)
+{
+    LL d,x,y;
+    gcd(a,b,d,x,y);
+    if(c%d!=0)
+        return -1;
+    x=x*c/d;
+    b=b/d;
+    x=x-(x/b*b);
+    if(x<0)
+        x+=b;
+    return x;
+}
+int main()
+{
+    int T;
+    LL sum;
+    scanf("%d",&T);
+    for(int t=1;t<=T;t++)
+    {
+        memset(ans,-1,sizeof(ans));
+        scanf("%I64d %I64d",&sum,&M);
+        printf("Case #%d:\n",t);
+        for(int i=0;i<M;i++)
+        {
+            scanf("%I64d %I64d",&X[i],&Y[i]);
+        }
+        LL cnt=get_prime(sum);
+        LL temp;
+        for(int j=0;j<cnt;j++)
+        {
+            LL d=primitive_root(prime[j]);
+            log_mod(d,prime[j]);
+            for(int i=0;i<M;i++)
+            {
+                temp=get_K(A[i],prime[j]-1,B[i]);
+                if(temp!=-1)
+                {
+                    if(ans[i]==-1)
+                        ans[i]=temp;
+                    else
+                        ans[i]=min(temp,ans[i]);
+                }
+            }
+        }
+        for(int i=0;i<M;i++)
+            printf("%I64d\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5378_autoAC.cpp b/HDOJ/5378_autoAC.cpp
new file mode 100644
index 0000000..d31db3e
--- /dev/null
+++ b/HDOJ/5378_autoAC.cpp
@@ -0,0 +1,121 @@
+#pragma comment(linker, "/STACK:102400000,102400000")
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <string>
+#include <cmath>
+#include <cstring>
+#include <queue>
+#include <set>
+#include <map>
+#include <vector>
+using namespace std;
+template <class T>
+inline bool rd(T &ret) {
+    char c; int sgn;
+    if (c = getchar(), c == EOF) return 0;
+    while (c != '-' && (c<'0' || c>'9')) c = getchar();
+    sgn = (c == '-') ? -1 : 1;
+    ret = (c == '-') ? 0 : (c - '0');
+    while (c = getchar(), c >= '0'&&c <= '9') ret = ret * 10 + (c - '0');
+    ret *= sgn;
+    return 1;
+}
+template <class T>
+inline void pt(T x) {
+    if (x < 0) {
+        putchar('-');
+        x = -x;
+    }
+    if (x > 9) pt(x / 10);
+    putchar(x % 10 + '0');
+}
+typedef pair<int, int> pii;
+typedef long long ll;
+const int N = 1005;
+const int mod = 1e9 + 7;
+const int inf = 1e9;
+int Pow(int x, int y) {
+    int ans = 1;
+    while (y) {
+        if (y & 1)ans = (ll)ans*x%mod;
+        y >>= 1;
+        x = (ll)x*x%mod;
+    }return ans;
+}
+vector<int>G[N];
+int n, k;
+int dp[N][N], siz[N], lef[N];
+int A[N];
+int mul(int x, int y) {
+    x = (ll)x*y%mod;
+    return x;
+}
+inline void add(int &x, int y) {
+    x += y; if (x >= mod)x -= mod;
+}
+inline void sub(int &x, int y) {
+    x -= y; if (x < 0)x += mod;
+}
+inline void dv(int &x, int y) {
+    x = (ll)x*Pow(y, mod - 2) % mod;
+}
+int g[N];
+void dfs(int u, int fa) {
+    siz[u] = 1; lef[u] = 0;
+    for (auto v : G[u]) {
+        if (v == fa)continue;
+        dfs(v, u);
+        siz[u] += siz[v];
+    }
+    if (siz[u] == 1) {
+        dp[u][0] = 0; dp[u][1] = 1;
+        lef[u] = 1;
+        return;
+    }
+    dp[u][0] = 1;
+    int x1 = A[siz[u] - 1], x2 = A[siz[u]];
+    siz[u] = 0;
+    for (auto v : G[u]) {
+        if (v == fa)continue;
+        for (int i = lef[u] + lef[v]; i <= min(k, siz[u] + siz[v]); i++)g[i] = 0;
+        for (int i = lef[u]; i <= min(k, siz[u]); i++)
+        {
+            for (int j = lef[v]; j <= min(k, siz[v]) && i + j <= k; j++)
+            {
+                add(g[i + j], mul(dp[v][j], dp[u][i]));
+            }
+        }
+        for (int i = lef[u] + lef[v]; i <= min(k, siz[u] + siz[v]); i++)dp[u][i] = g[i];
+        siz[u] += siz[v];
+        lef[u] += lef[v];
+        dv(x1, A[siz[v]]);
+        dv(x2, A[siz[v]]);
+    }
+    siz[u]++;
+    sub(x2, x1);
+    for (int i = min(siz[u], k); i >= lef[u]; i--) {
+        int tmp = 0;
+        add(tmp, mul(dp[u][i], x2));
+        if (i - 1 >= lef[u])
+        add(tmp, mul(dp[u][i - 1], x1));
+        dp[u][i] = tmp;
+    }
+}
+int main() {
+    A[0] = 1;
+    for (int i = 1; i < N; i++)A[i] = (ll)A[i - 1] * i%mod;
+    int T, Cas = 1; rd(T);
+    while (T--) {
+        rd(n); rd(k);
+        for (int i = 1; i <= n; i++)G[i].clear(), memset(dp[i], 0, sizeof dp[i]);
+        for (int i = 1, u, v; i < n; i++) {
+            rd(u); rd(v);
+            G[u].push_back(v); G[v].push_back(u);
+        }
+        dfs(1, 1);
+        printf("Case #%d: ", Cas++);
+        pt(dp[1][k]); puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/5379_autoAC.cpp b/HDOJ/5379_autoAC.cpp
new file mode 100644
index 0000000..e3047ca
--- /dev/null
+++ b/HDOJ/5379_autoAC.cpp
@@ -0,0 +1,72 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <iostream>
+#include <stdio.h>
+#include <algorithm>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <vector>
+#include <queue>
+#include <stack>
+#include <map>
+#include <set>
+using namespace std;
+#define Max 100010
+const int  MOD = 1e9+7;
+vector <int > q[Max];
+int vis[Max];
+long long res=1;
+int flag=1;
+int n;
+void dfs(int a)
+{
+    int k=q[a].size();
+    int cnt=0;
+    vis[a]=1;
+    for(int i=0;i<k;i++)
+    {
+        if(vis[q[a][i]]) continue;
+        if(q[q[a][i]].size()==1&&vis[q[a][i]]==0) cnt++;
+        else dfs(q[a][i]);
+    }
+    if(a!=1)k--;
+    if(k-cnt>2){flag=0;return ;}
+    if(cnt!=k)
+    {
+        res*=2;
+        res%=MOD;
+    }
+    while(cnt>0)
+    {
+        res*=cnt;res%=MOD;cnt--;
+    }
+    //cout<<a<<" "<<res<<endl;
+    //cout<<res<<endl;
+}
+int main()
+{
+    int T;
+    cin>>T;
+    int _case=0;
+    while(T--)
+    {
+        cin>>n;
+        flag=1;
+        for(int i=1;i<=n;i++) q[i].clear();
+        memset(vis,0,sizeof(vis));
+        int a,b;
+        for(int i=1;i<n;i++)
+        {
+            scanf("%d %d",&a,&b);
+            q[b].push_back(a);
+            q[a].push_back(b);
+        }
+        res=2;
+        if(n!=1)
+        dfs(1);
+        else res=1;
+        if(!flag) res=0;
+        cout<<"Case #"<<++_case<<": "<<res%MOD<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5380_autoAC.cpp b/HDOJ/5380_autoAC.cpp
new file mode 100644
index 0000000..c4bc4ad
--- /dev/null
+++ b/HDOJ/5380_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <cstring>
+#include <algorithm>
+#include <cstdio>
+#include <cmath>
+#include <iostream>
+#include <queue>
+#define mp make_pair
+#define INF 1000000000
+#define MAXN 200050
+#define max(x,y) ((x)>(y)?(x):(y))
+#define min(x,y) ((x)<(y)?(x):(y))
+#define P pair<int,int>
+#define LL long long
+using namespace std;
+int a[MAXN];
+LL buy[MAXN],sell[MAXN];
+int len[MAXN];
+LL now[MAXN];
+int q[MAXN];
+void work(){
+    int st=0,ed=0;
+    int n,c;
+    scanf("%d%d",&n,&c);
+    for(int i=1;i<=n;++i)scanf("%d",&a[i]);
+    for(int i=0;i<=n;++i)scanf("%I64d%I64d",&buy[i],&sell[i]);
+    now[0]=c;
+    q[ed++]=0;
+    LL ans=c*buy[0];
+    for(int i=1;i<=n;++i){
+        int dis=a[i]-a[i-1];
+        LL sum=c-dis;
+        while(dis){
+            int x=q[st];
+            if(now[x]>dis){
+                now[x]-=dis;
+                dis=0;
+            }else{
+                dis-=now[x];
+                now[x]=0;
+                st++;
+            }
+        }
+        int era=0;
+        while(st<ed){
+            int x=q[st];
+            if(buy[x]<sell[i]){
+                era+=now[x];
+                st++;
+            }else
+                break;
+        }
+        if(era!=0){
+            st--;
+            now[q[st]]=era;
+            buy[q[st]]=sell[i];
+        }
+        bool flag=true;
+        while(flag&&st<ed){
+            flag=false;
+            int x=q[ed-1];
+            if(buy[x]>=buy[i]){
+                flag=true;
+                ans-=now[x]*buy[x];
+                sum-=now[x];
+                now[x]=0;
+                ed--;
+            }
+        }
+        q[ed++]=i;
+        now[i]=c-sum;
+        ans+=(c-sum)*buy[i];
+    }
+    while(st<ed){
+        int x=q[st++];
+           ans-=now[x]*buy[x];
+    }
+    printf("%I64d\n",ans);
+}
+int main()
+{
+    len[0]=len[1]=0;
+    for(int i=2;i<MAXN;++i){
+        int k=0;
+        while((1<<k)<=i)k++;
+        len[i]=k-1;
+    }
+    int tt;
+    scanf("%d",&tt);
+    while(tt--){
+        work();
+    }
+}
diff --git a/HDOJ/5381_autoAC.cpp b/HDOJ/5381_autoAC.cpp
new file mode 100644
index 0000000..0dc2aab
--- /dev/null
+++ b/HDOJ/5381_autoAC.cpp
@@ -0,0 +1,136 @@
+#include <stdio.h>
+#include <algorithm>
+#include <math.h>
+const int N = (int)(1e4)+5;
+int t,n,m,a[N],ppos[N];
+long long ans[N];
+int v1[N][35], v2[N][35], v3[N][35], v4[N][35];
+int size1[N], size2[N];
+struct Q{
+    int l,r,id;
+    bool operator < (const Q &a ) const{
+        if(ppos[l] == ppos[a.l]) return r<a.r;
+        return ppos[l] < ppos[a.l];
+    }
+}q[N];
+int gcd(int a, int b){
+    return !b?a:gcd(b, a%b);
+}
+int pool[50], pos[50], cnt;
+void unique(int &cnt){
+    int id = 0, p = pos[0];
+    for(int i=0; i<cnt; i++){
+        if(pool[i] != pool[id]){
+            pos[id] = p; id++;
+            p = pos[i]; pool[id] = pool[i];
+        }
+    }
+    pos[id] = p;
+    cnt = id+1;
+}
+void init(){
+    cnt = 0;
+    for(int i=n; i>=1; i--){
+        for(int j=0; j<cnt; j++) pool[j] = gcd(pool[j], a[i]);
+        pool[cnt] = a[i]; pos[cnt++]=i;
+        unique(cnt);
+        for(int j=cnt-1; j>=0; j--){
+            v1[i][cnt-1-j] = pool[j];
+            v2[i][cnt-1-j] = pos[j];
+        }
+        size1[i] = cnt;
+    }
+    cnt = 0;
+    for(int i=1; i<=n; i++){
+        for(int j=0; j<cnt; j++) pool[j] = gcd(pool[j], a[i]);
+        pool[cnt] = a[i]; pos[cnt++] = i;
+        unique(cnt);
+        for(int j=cnt-1; j>=0; j--){
+            v3[i][cnt-1-j] = pool[j];
+            v4[i][cnt-1-j] = pos[j];
+        }
+        size2[i] = cnt;
+    }
+}
+int l,r;
+long long sum;
+void add_l(int v){
+    int s = l, t = r;
+    long long tmp = 0;
+    int last = s;
+    for(int i=0; i<size1[l]; i++){
+        if(v2[l][i] < s) continue;
+        else if(v2[l][i] > t){
+            tmp += (t - last + 1) *1LL *v1[l][i];
+        }
+        else{
+            tmp +=  (v2[l][i] - last + 1) *1LL* v1[l][i];
+            last = v2[l][i] + 1;
+        }
+        if(v2[l][i] >= t) break;
+    }
+    sum += v*tmp;
+}
+void add_r(int v){
+    int s = l, t = r;
+    long long tmp = 0;
+    int last = t;
+    for(int i=0; i<size2[r]; i++){
+        if(v4[r][i] > t) continue;
+        else if(v4[r][i] < s){
+            tmp += (last - s + 1) * 1LL * v3[r][i];
+        }else{
+            tmp += (last - v4[r][i] + 1) *1LL * v3[r][i];
+            last = v4[r][i]-1;
+        }
+        if(v4[t][i] <= s) break;
+    }
+    sum += v*tmp;
+}
+int main(){
+    scanf("%d", &t);
+    for(int ca=1; ca<=t; ca++){
+        scanf("%d", &n);
+        int S = (int)(sqrt(n*1.0) + 0,5);
+        for(int i=1; i<=n; i++){
+            ppos[i] = (i-1)/100;
+        }
+        for(int i=1; i<=n; i++) scanf("%d", &a[i]);;
+        init(); scanf("%d", &m);
+        for(int i=0; i<m; i++){
+            scanf("%d%d", &q[i].l, &q[i].r);
+            q[i].id = i;
+        }
+        std::sort(q, q+m);
+        sum = 0, l = 1, r = 0;
+        for(int i=0; i<m; i++){
+            if(r<q[i].r){
+                for(r=r+1; r<=q[i].r; r++){
+                    add_r(1);
+                }
+                r--;
+            }
+            if(r>q[i].r){
+                for(;r>q[i].r; r--){
+                    add_r(-1);
+                }
+            }
+            if(l>q[i].l){
+                for(l=l-1; l>=q[i].l; l--){
+                    add_l(1);
+                }
+                l++;
+            }
+            if(l<q[i].l){
+                for(; l<q[i].l; l++){
+                    add_l(-1);
+                }
+            }
+            ans[q[i].id] = sum;
+        }
+        for(int i=0; i<m; i++){
+            printf("%I64d\n", ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5382_autoAC.cpp b/HDOJ/5382_autoAC.cpp
new file mode 100644
index 0000000..fd8e123
--- /dev/null
+++ b/HDOJ/5382_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <cstdio>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+#include <string>
+#include <cmath>
+#include <vector>
+#include <map>
+#include <tr1/unordered_map>
+#define clr(x, y) memset(x, y, sizeof x)
+using namespace std;
+typedef long long LL;
+const double eps=1e-8;
+const int maxn=1000100;
+const int mod=258280327;
+int valid[maxn];
+LL G[maxn],T[maxn],F[maxn],S[maxn];
+void init()
+{
+    for(int i=0;i<maxn;i++)
+    {
+        G[i]=valid[i]=1;
+        T[i]=0;
+    }
+    G[0]=0;
+    for(int i=2;i<maxn;i++)
+    {
+        if(valid[i])
+        {
+            for(int j=i;j<maxn;j+=i)
+            {
+                G[j]=G[j]*2%mod;
+                valid[j]=0;
+            }
+        }
+    }
+    for(int i=1;i<maxn;i++)
+    {
+        for(int j=i;j<maxn;j+=i)
+        {
+            T[j]=(T[j]+G[j/i-1])%mod;
+        }
+    }
+    F[1]=S[1]=1;
+    for(int i=2;i<maxn;i++)
+    {
+        F[i]=(((F[i-1]+2*i-1)%mod-T[i-1])%mod+mod)%mod;
+        S[i]=(S[i-1]+F[i])%mod;
+    }
+}
+int main()
+{
+    init();
+    int t,n;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        printf("%I64d\n",S[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5383_autoAC.cpp b/HDOJ/5383_autoAC.cpp
new file mode 100644
index 0000000..fbbe8d0
--- /dev/null
+++ b/HDOJ/5383_autoAC.cpp
@@ -0,0 +1,127 @@
+#include<iostream>
+#include<queue>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#define MAXN 805
+typedef long long LL;
+const LL INF = 1000000007;
+struct edge{
+    int to,next,cost,cap;
+}E[2000000];
+struct node{
+    int lev,tun,atk;
+}A[MAXN];
+int head[MAXN],si,prevv[MAXN],preve[MAXN],que[200000],n,m,used[MAXN],C[400][400];
+LL dist[MAXN];
+void add_edge(int u,int v,int c,int cap)
+{
+    //printf("%d->%d(cap:%d,cost:%d)\n",u,v,cap,c);
+    E[si].to=v;
+    E[si].cost=c;
+    E[si].cap=cap;
+    E[si].next=head[u];
+    head[u]=si++;
+    E[si].to=u;
+    E[si].cost=-c;
+    E[si].cap=0;
+    E[si].next=head[v];
+    head[v]=si++;
+}
+bool SPFA(int s,int t)
+{
+    for(int i=0;i<=2*n+1;i++)dist[i]=INF,used[i]=false;
+    dist[s]=0;
+    int h=0,tail=0;
+    for(que[tail++]=s,used[s]=true;h<tail;h++){
+        int v=que[h];used[v]=false;
+        for(int i=head[v];~i;i=E[i].next){
+            if(E[i].cap>0){
+                int u=E[i].to;
+                if(dist[u]>dist[v]+E[i].cost){
+                   // printf("dist[%d]=%I64d___dist[%d]=%I64d___cost:%d\n",u,dist[u],v,dist[v],E[i].cost);
+                    dist[u]=dist[v]+E[i].cost;
+                    prevv[u]=v;
+                    preve[u]=i;
+                    if(!used[u]){
+                        que[tail++]=u;
+                        used[u]=true;
+                    }
+                }
+            }
+        }
+    }
+  //  printf("dist:%I64d\n",dist[t]);
+    if(dist[t]<0)return true;
+    return false;
+}
+int min_cost_flow(int s,int t)
+{
+    LL ans=0;
+    while(SPFA(s,t)){
+        int d=INF;
+        for(int v=t;s!=v;v=prevv[v]){
+            d=std::min(d,E[preve[v]].cap);
+        }
+        ans+=d*dist[t];
+        for(int v=t;v!=s;v=prevv[v]){
+            E[preve[v]].cap-=d;
+            E[preve[v]^1].cap+=d;
+        }
+    }
+    return ans;
+}
+int main()
+{
+    int T;scanf("%d",&T);
+    while(T--){
+        scanf("%d%d",&n,&m);
+        memset(head,-1,sizeof head);si=0;
+        memset(C,0,sizeof C);
+        for(int i=1;i<=n;i++){
+            scanf("%d%d%d",&A[i].tun,&A[i].lev,&A[i].atk);
+            add_edge(0,i,0,1);
+            add_edge(i,i+n,-A[i].atk,1);
+            add_edge(i+n,n*2+1,0,1);
+        }
+        for(int i=1,lev,atk,r,u,v;i<=m;i++){
+            scanf("%d%d%d",&lev,&atk,&r);
+            if(r==0){
+                for(int j=1;j<=n;j++){
+                    if(!A[j].tun)
+                    for(int k=1;k<=n;k++)if(A[k].tun&&A[j].lev+A[k].lev==lev){
+                        C[j][k]=std::min(C[j][k],-atk);
+                    }
+                }
+            }
+            else if(r==1){
+                scanf("%d",&v);
+                if(A[v].tun){
+                    for(int j=1;j<=n;j++)if(!A[j].tun&&A[j].lev+A[v].lev==lev){
+                      //  add_edge(j,v+n,-atk,1);
+                        C[j][v]=std::min(C[j][v],-atk);
+                    }
+                }
+                else{
+                    for(int j=1;j<=n;j++)if(A[j].tun&&A[j].lev+A[v].lev==lev){
+                        add_edge(v,j+n,-atk,1);
+                        C[v][j]=std::min(C[v][j],-atk);
+                    }
+                }
+            }
+            else{
+                scanf("%d%d",&u,&v);
+                if(A[u].tun)std::swap(u,v);
+                C[u][v]=std::min(C[u][v],-atk);
+            }
+        }
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=n;j++)if(C[i][j]<0&&C[i][j]<-A[i].atk-A[j].atk){
+                add_edge(i,j+n,C[i][j],1);
+            }
+        }
+        LL ans=-min_cost_flow(0,n*2+1);
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5384_autoAC.cpp b/HDOJ/5384_autoAC.cpp
new file mode 100644
index 0000000..370efc3
--- /dev/null
+++ b/HDOJ/5384_autoAC.cpp
@@ -0,0 +1,69 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <string>
+using namespace std;
+typedef long long ll;
+const int MAXN = (int)1e5 + 10;
+const int maxnode = (int)6e5 + 10;
+const int sigma_size = 26;
+struct Trie {
+    int ch[maxnode][sigma_size];
+    int val[maxnode];
+    int sz;
+    void clear() { sz = 1; memset(ch[0], 0, sizeof(ch[0]));}
+    Trie() {clear();}
+    int idx(char c) { return c - 'a';}
+    void insert(char *s, int v = 1) {
+        int u = 0, n = strlen(s);
+        for(int i = 0; i < n; i++) {
+            int c = idx(s[i]);
+            if(!ch[u][c]) {
+                memset(ch[sz], 0, sizeof(ch[u]));
+                val[sz] = 0;
+                ch[u][c] = sz++;
+            }
+            u = ch[u][c];
+        }
+        val[u] += v;
+    }
+    ll find(const char* s) {
+        int u = 0, n = strlen(s);
+        ll ret = 0;
+        for(int i = 0; i < n; i++) {
+            int c = idx(s[i]);
+            if(!ch[u][c]) return ret;
+            u = ch[u][c];
+            ret += val[u];
+        }
+        return ret;
+    }
+} trie;
+int n, m;
+string A[MAXN];
+char B[MAXN];
+int main() {
+    int T;
+    scanf("%d", &T);
+    while(T--) {
+        scanf("%d%d", &n, &m);
+        trie.clear();
+        for(int i = 0; i < n; i++) {
+            cin >> A[i];
+        }
+        for(int i = 0; i < m; i++) {
+            scanf("%s", B);
+            trie.insert(B);
+        }
+        ll ans = 0;
+        for(int i = 0; i < n; i++) {
+            ans = 0;
+            for(int j = 0; j < A[i].size(); j++) {
+                ans += trie.find(A[i].c_str()+j);
+            }
+            printf("%lld\n", ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5385_autoAC.cpp b/HDOJ/5385_autoAC.cpp
new file mode 100644
index 0000000..0f7a0eb
--- /dev/null
+++ b/HDOJ/5385_autoAC.cpp
@@ -0,0 +1,71 @@
+#pragma comment(linker, "/STACK:102400000,102400000")
+#include <iostream>
+#include<stdio.h>
+#include<string.h>
+#include<vector>
+#include<algorithm>
+#include<cmath>
+#include<map>
+#include<set>
+#include<queue>
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1 | 1
+#define lowbit(x) x&(-x)
+using namespace std;
+const int N=1e5+10;
+long long inf=1e15;
+const int MOD=258280327;
+int T,n,m,k,x,y,z,l,tot,t,A,B,q;
+int cas=1;
+int u[N],v[N];
+vector<int> vec[N];
+bool vis[N];
+int dis[N];
+int fa[N];
+void relax(int x){
+    for(int i=0;i<vec[x].size();i++){
+        int v1=vec[x][i];
+        if(!vis[v1] && !fa[v1]) fa[v1]=x;
+    }
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+   while(T--){
+        scanf("%d%d",&n,&m);
+        for(int i=1;i<=n;i++) vec[i].clear();
+        for(int i=1;i<=n;i++) vis[i]=false,fa[i]=0;
+        for(int i=1;i<=m;i++){
+            scanf("%d%d",u+i,v+i);
+            vec[u[i]].push_back(v[i]);
+        }
+        vis[1]=true;
+        dis[1]=0;
+        fa[1]=-1;
+        int now=1;
+        int pre=2,last=n;
+        relax(1);
+        while(pre<=last){
+            if(fa[pre]){
+                dis[pre]=now++;
+                vis[pre]=true;
+                relax(pre);
+                pre++;
+                continue;
+            }
+            if(fa[last]){
+                dis[last]=now++;
+                vis[last]=true;
+                relax(last);
+                last--;
+                continue;
+            }
+        }
+        for(int i=1;i<=m;i++){
+            if(fa[v[i]]!=u[i]) printf("%d\n",n);
+            else printf("%d\n",dis[v[i]]-dis[u[i]]);
+        }
+   }
+    return 0;
+}
diff --git a/HDOJ/5386_autoAC.cpp b/HDOJ/5386_autoAC.cpp
new file mode 100644
index 0000000..abfe222
--- /dev/null
+++ b/HDOJ/5386_autoAC.cpp
@@ -0,0 +1,66 @@
+#include "stdio.h"
+#include "string.h"
+struct Mark
+{
+    int x,y;
+    char op;
+}mark[510];
+int a[110][110],ans[510];
+int main()
+{
+    int t,n,m,i,cnt,j,k;
+    char str[2];
+    scanf("%d",&t);
+    while (t--)
+    {
+        scanf("%d%d",&n,&m);
+        for (i=1;i<=n;i++)
+            for (j=1;j<=n;j++)
+            scanf("%d",&a[i][j]);
+        for (i=1;i<=n;i++)
+            for (j=1;j<=n;j++)
+            scanf("%d",&a[i][j]);
+        for (i=1;i<=m;i++)
+        {
+            scanf("%s%d%d",str,&mark[i].x,&mark[i].y);
+            mark[i].op=str[0];
+        }
+        cnt=m;
+        while (cnt!=0)
+        {
+            for (i=1;i<=m;i++)
+                if (mark[i].x!=0)
+                {
+                    k=mark[i].x;
+                    if (mark[i].op=='H')
+                    {
+                        for (j=1;j<=n;j++)
+                            if (a[k][j]!=0 && a[k][j]!=mark[i].y) break;
+                        if (j==n+1)
+                        {
+                            for (j=1;j<=n;j++)
+                                a[k][j]=0;
+                            mark[i].x=0;
+                            ans[cnt--]=i;
+                        }
+                    }
+                    else
+                    {
+                        for (j=1;j<=n;j++)
+                            if (a[j][k]!=0 && a[j][k]!=mark[i].y) break;
+                        if (j==n+1)
+                        {
+                            for (j=1;j<=n;j++)
+                                a[j][k]=0;
+                            mark[i].x=0;
+                            ans[cnt--]=i;
+                        }
+                    }
+                }
+        }
+        for (i=1;i<=m;i++)
+            printf("%d ",ans[i]);
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5387_autoAC.cpp b/HDOJ/5387_autoAC.cpp
new file mode 100644
index 0000000..bac750e
--- /dev/null
+++ b/HDOJ/5387_autoAC.cpp
@@ -0,0 +1,50 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <string>
+#include <algorithm>
+using namespace std;
+int gcd(int u,int v)
+{
+    if(u<v) swap(u,v);
+    return v==0?u:gcd(v,u%v);
+}
+int abs(int x)
+{
+    if(x<0) return -x;
+    else return x;
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int hh,mm,ss;
+        scanf("%d:%d:%d",&hh,&mm,&ss);
+        int ts,tm,th;
+        ts=6*ss;
+        tm=60*mm+ss;
+        th=3600*(hh%12)+60*mm+ss;
+        int difms=abs(10*ts-tm);
+        int difhm=abs(12*tm-th);
+        int difhs=abs(120*ts-th);
+        if(difms>10*180) difms=10*360-difms;
+        if(difhm>120*180) difhm=120*360-difhm;
+        if(difhs>120*180) difhs=120*360-difhs;
+        if(difhm%120==0)
+            printf("%d ",difhm/120);
+        else
+            printf("%d/%d ",difhm/gcd(difhm,120),120/gcd(difhm,120));
+        if(difhs%120==0)
+            printf("%d ",difhs/120);
+        else
+            printf("%d/%d ",difhs/gcd(difhs,120),120/gcd(difhs,120));
+        if(difms%10==0)
+            printf("%d \n",difms/10);
+        else
+            printf("%d/%d \n",difms/gcd(difms,10),10/gcd(difms,10));
+    }
+    return 0;
+}
diff --git a/HDOJ/5389_autoAC.cpp b/HDOJ/5389_autoAC.cpp
new file mode 100644
index 0000000..2e3df71
--- /dev/null
+++ b/HDOJ/5389_autoAC.cpp
@@ -0,0 +1,67 @@
+#include <cstdio>
+#include <algorithm>
+#include <iostream>
+#include <sstream>
+#include <cstring>
+#include <cmath>
+#include <string>
+#include <vector>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <list>
+#include <map>
+#include <set>
+#include <bitset>
+#include <cstdlib>
+#include <ctime>
+using namespace std;
+#define lson l, mid, rt << 1
+#define rson mid + 1, r, rt << 1 | 1
+typedef long long ll;
+const int MAXN = 1e5 + 10;
+const int INF = 0x3f3f3f3f;
+const int MOD = 258280327;
+int cal(int x, int y)
+{
+    int ret = x + y;
+    ret %= 9;
+    if(ret == 0) return 9;
+    return ret;
+}
+int dp[MAXN][10];
+int a[MAXN];
+int main(){
+    int T;
+    int n, s1, s2;
+    scanf("%d", &T);
+    while(T--){
+        scanf("%d%d%d", &n, &s1, &s2);
+        int sum = 0;
+        for(int i = 1; i <= n; i++){
+            scanf("%d", &a[i]);
+            sum = cal(sum, a[i]);
+        }
+        int ret = cal(s1, s2);
+        memset(dp, 0, sizeof(dp));
+        for(int i = 1; i <= n; i++){
+            dp[i][a[i]] = 1;
+        }
+        for(int i = 1; i <= n; i++){
+            for(int j = 0; j <= 9; j++){
+                dp[i][j] = (dp[i][j] + dp[i-1][j]) % MOD;
+                    int x = cal(a[i], j);
+                    dp[i][x] = (dp[i][x] + dp[i-1][j]) % MOD;
+                }
+        }
+        int ans = 0;
+        if(ret == sum) {
+            ans += dp[n][s1];
+            if(s1 == sum) ans--;
+        }
+        if(s1 == sum) ans++;
+        if(s2 == sum) ans++;
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5390_autoAC.cpp b/HDOJ/5390_autoAC.cpp
new file mode 100644
index 0000000..d3e68d8
--- /dev/null
+++ b/HDOJ/5390_autoAC.cpp
@@ -0,0 +1,203 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<algorithm>
+#define maxn 100005
+using namespace std;
+struct OP
+{
+    int op, id, x;
+}op[maxn];
+struct Seg
+{
+    int l, r;
+    int root;
+    Seg() {}
+    Seg(int _l, int _r, int _ro)
+    {
+        l = _l;
+        r = _r;
+        root = _ro;
+    }
+};
+vector<Seg> T[20];
+void build(int L, int R, int dep)
+{
+    T[dep].push_back(Seg(L, R, 0));
+    if (L != R)
+    {
+        int mid = L + R >> 1;
+        build(L, mid, dep + 1);
+        build(mid + 1, R, dep + 1);
+    }
+}
+int ch[4000000][2];
+int num[4000000];
+int cnt;
+void insert_Dic(int root, int x)
+{
+    num[root]++;
+    for (int i = 30; i >= 0; i--)
+    {
+        int c = (x&(1 << i)) ? 1 : 0;
+        if (!ch[root][c]) ch[root][c] = ++cnt;
+        root = ch[root][c];
+        num[root]++;
+    }
+}
+void erase_Dic(int root, int x)
+{
+    num[root]--;
+    for (int i = 30; i >= 0; i--)
+    {
+        int c = (x&(1 << i)) ? 1 : 0;
+        root = ch[root][c];
+        num[root]--;
+    }
+}
+int find_Dic(int root, int x)
+{
+    int res = 0;
+    for (int i = 30; i >= 0; i--)
+    {
+        int c = (x&(1 << i)) ? 1 : 0;
+        if (ch[root][c ^ 1] && num[ch[root][c ^ 1]])
+        {
+            res |= 1 << i;
+            root = ch[root][c ^ 1];
+        }
+        else root = ch[root][c];
+    }
+    return res;
+}
+vector<Seg> Q;
+void Select(int L, int R, int l, int r, int dep, int deep)
+{
+    if (dep > deep) return;
+    if (l <= L&&R <= r)
+    {
+        if(dep==deep)
+            Q.push_back(Seg(L, R, 0));
+    }
+    else
+    {
+        int mid = L + R >> 1;
+        if (l <= mid) Select(L, mid, l, r, dep + 1, deep);
+        if (mid < r) Select(mid + 1, R, l, r, dep + 1, deep);
+    }
+}
+struct EDGE
+{
+    int to, next;
+    EDGE() {}
+    EDGE(int _t, int _n) { to = _t, next = _n; }
+}edge[maxn];
+int head[maxn], edgecnt;
+void init_edge()
+{
+    memset(head, -1, sizeof(head));
+    edgecnt = 0;
+}
+void add(int s, int t)
+{
+    edge[edgecnt] = EDGE(t, head[s]);
+    head[s] = edgecnt++;
+}
+int dfs_clk;
+int Left[maxn], Right[maxn];
+void dfs(int u)
+{
+    Left[u] = ++dfs_clk;
+    for (int i = head[u]; ~i; i = edge[i].next)
+        dfs(edge[i].to);
+    Right[u] = dfs_clk;
+}
+int val[maxn], _val[maxn];
+int ans[maxn];
+int bin(int idx, int x)
+{
+    int L = 0, R = T[idx].size();
+    while (L < R)
+    {
+        int mid = (L + R) >> 1;
+        if (T[idx][mid].l <= x) L = mid + 1;
+        else R = mid;
+    }
+    return L - 1;
+}
+int main()
+{
+    int Ts;
+    scanf("%d", &Ts);
+    while (Ts--)
+    {
+        init_edge();
+        int n, m;
+        scanf("%d %d", &n, &m);
+        for (int i = 2; i <= n; i++)
+        {
+            int fa;
+            scanf("%d", &fa);
+            add(fa, i);
+        }
+        dfs_clk = 0;
+        dfs(1);
+        for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
+        int Qc = 0;
+        for (int i = 1; i <= m; i++)
+        {
+            scanf("%d %d", &op[i].op, &op[i].id);
+            if (op[i].op == 0) scanf("%d", &op[i].x);
+            else Qc++;
+        }
+        for (int i = 0; i < 20; i++) T[i].clear();
+        build(1, dfs_clk, 0);
+        memset(ans, 0, sizeof(ans));
+        for (int i = 19; i >= 0; i--)
+            if (T[i].size())
+            {
+                int Tsize = T[i].size();
+                memcpy(_val, val, sizeof(_val));
+                memset(ch, 0, sizeof(ch));
+                memset(num, 0, sizeof(num));
+                cnt = 0;
+                for (int j = 0; j < Tsize; j++) T[i][j].root = ++cnt;
+                for (int j = 1; j <= n; j++)
+                {
+                    Q.clear();
+                    Select(1, dfs_clk, Left[j], Right[j], 0, i);
+                    for (int k = 0; k < Q.size(); k++)
+                    {
+                        int pos = bin(i, Q[k].l);
+                        insert_Dic(T[i][pos].root, _val[j]);
+                    }
+                }
+                int quecnt = 0;
+                for (int j = 1; j <= m;j++)
+                    if (op[j].op == 0)
+                    {
+                        Q.clear();
+                        Select(1, dfs_clk, Left[op[j].id], Right[op[j].id], 0, i);
+                        for (int k = 0; k < Q.size(); k++)
+                        {
+                            int pos = bin(i, Q[k].l);
+                            erase_Dic(T[i][pos].root, _val[op[j].id]);
+                            insert_Dic(T[i][pos].root, op[j].x);
+                        }
+                        _val[op[j].id] = op[j].x;
+                    }
+                    else
+                    {
+                        quecnt++;
+                        int pos = bin(i, Left[op[j].id]);
+                        if (pos >= 0 && T[i][pos].l <= Left[op[j].id] && Left[op[j].id] <= T[i][pos].r)
+                        {
+                            ans[quecnt] = max(ans[quecnt], find_Dic(T[i][pos].root, _val[op[j].id]));
+                        }
+                    }
+            }
+        for (int i = 1; i <= Qc; i++) printf("%d\n", ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5391_autoAC.cpp b/HDOJ/5391_autoAC.cpp
new file mode 100644
index 0000000..1b84663
--- /dev/null
+++ b/HDOJ/5391_autoAC.cpp
@@ -0,0 +1,40 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+bool isPrimeNum(int num)
+{
+     if (num <= 2)
+     {
+         return num == 2;
+     }
+     if (num % 2 == 0)
+     {
+         return false;
+     }
+     int iSqrt = sqrt(num);
+     for (int i = 3; i <= iSqrt; i+=2)
+     {
+         if (num % i == 0)
+         {
+             return false;
+         }
+     }
+     return true;
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int n;
+        scanf("%d",&n);
+        if(n==4) printf("2\n");
+        else if(isPrimeNum(n)) printf("%d\n",n-1);
+        else printf("0\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5392_autoAC.cpp b/HDOJ/5392_autoAC.cpp
new file mode 100644
index 0000000..51d424c
--- /dev/null
+++ b/HDOJ/5392_autoAC.cpp
@@ -0,0 +1,96 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<map>
+using namespace std;
+#define ll unsigned long long
+#define maxn 3000007
+int check[maxn];
+vector<int> pri;
+void init(){
+    memset(check,0,sizeof(check));
+    pri.clear();
+    for(int i = 2;i < maxn; i++){
+        if(check[i] == 0) {
+            pri.push_back(i);
+        }
+        for(int j = 0;j < pri.size() ; j++){
+            if(i*pri[j] >= maxn) break;
+            check[i*pri[j]] = 1;
+            if(i%pri[j] == 0) break;
+        }
+    }
+}
+int getn(){
+    int a = 0;
+    char x;
+    do{
+        x = getchar();
+        if(x == ' ' || x == '\n') return a;
+        a = a*10+x-'0';
+    }while(1);
+    return 1;
+}
+int num[maxn];
+int ok[maxn];
+vector<int> hehe;
+ll mod = 3221225473ll;
+int pnum[maxn];
+ll cal(int u,int p){
+    ll ans = 1;
+    ll v = u;
+    while(p){
+        if(p & 1) ans = ans*v % mod;
+        p/=2;
+        v = v*v%mod;
+    }
+    return ans;
+}
+int main(){
+    init();
+    int t,n;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        getchar();
+        for(int i = 1;i <= n; i++)
+            num[i] = getn();
+        for(int i = 1;i <= n; i++)
+            ok[i] = pnum[i] = 0;
+        hehe.clear();
+        int mu = 1;
+        for(int i = 1;i <= n; i++){
+            if(ok[i] != 1){
+                int u = i;
+                int x = 0;
+                while(ok[u] == 0){
+                    x++;
+                    ok[u] = 1;
+                    u = num[u];
+                }
+                hehe.push_back(x);
+            }
+        }
+        for(int i = 0;i < hehe.size(); i++){
+            for(int j = 0;j < pri.size() && pri[j] <= hehe[i]; j++){
+                if(hehe[i] % pri[j] == 0){
+                    int x = 0;
+                    while(hehe[i] % pri[j] == 0){
+                        hehe[i] /= pri[j];
+                        x++;
+                    }
+                    pnum[pri[j]] = max(pnum[pri[j]],x);
+                    mu = max(mu,pri[j]);
+                }
+            }
+        }
+        ll ans = 1;
+        for(int i = 1;i <= mu; i++){
+            if(pnum[i] != 0)
+            ans = ans*cal(i,pnum[i])%mod;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5393_autoAC.cpp b/HDOJ/5393_autoAC.cpp
new file mode 100644
index 0000000..ef7743a
--- /dev/null
+++ b/HDOJ/5393_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<iostream>
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<queue>
+#include<algorithm> 
+using namespace std;
+typedef long long Int;
+int getphi(int x)
+{
+    int ret=1;
+    for(int i=2;i*(Int)i<=x;i++)
+        if(x%i==0)
+        {
+            ret=ret*(i-1);
+            x/=i;
+            while(x%i==0)x/=i,ret*=i;
+        }
+    if(x>1)ret=ret*(x-1);
+    return ret;
+}
+int powmod(int x,int y,int mod)
+{
+    int ret=1;
+    while(y){if(y&1)ret=ret*(Int)x%mod;y>>=1;x=x*(Int)x%mod;}
+    return ret;
+}
+int check(int x,int y,int mod)
+{
+    vector<int>V;
+    while(y){V.push_back(y&1);y>>=1;}
+    reverse(V.begin(),V.end());
+    int ret=0,tp=1;
+    for(int i=0;i<V.size();i++)
+    {
+        ret=(ret+ret*(Int)tp%mod)%mod;
+        tp=tp*(Int)tp%mod;
+        if(V[i])
+        {
+            tp=tp*(Int)x%mod;
+            ret=(ret+tp)%mod;
+        }
+    }
+    return (ret+1)%mod;
+}
+int main()
+{
+    int _;scanf("%d",&_);
+    while(_--)
+    {
+        int k,b,x,p;
+        scanf("%d%d%d%d",&k,&b,&x,&p);
+        if(!k){puts(b==x?"1":"-1");continue;}
+        if(k==1)
+        {
+            if(!b)puts("1");
+            else
+            {
+                printf("%d\n",p/__gcd(b,p));
+            }
+            continue;
+        }
+        int q=p/__gcd((Int)p,(Int)(k-1)*x+b);
+        if(q==1){puts("1");continue;}
+        if(__gcd(k,q)!=1){puts("-1");continue;}
+        int t=getphi(q);
+        int rep=t;
+        for(int i=2;i*(Int)i<=t;i++)
+        {
+            if(t%i==0)
+            {
+                if(powmod(k,i,q)==1){rep=i;break;}
+                if(powmod(k,t/i,q)==1)rep=t/i;
+            }
+        }
+        int ans=check(k,rep-1,q);
+        if(!ans){printf("%d\n",rep);continue;}
+        printf("%lld\n",q/__gcd(ans,q)*(Int)rep);
+    }
+}
diff --git a/HDOJ/5396_autoAC.cpp b/HDOJ/5396_autoAC.cpp
new file mode 100644
index 0000000..360a590
--- /dev/null
+++ b/HDOJ/5396_autoAC.cpp
@@ -0,0 +1,45 @@
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <algorithm>
+using namespace std;
+typedef long long LL;
+const int maxn = 110;
+const LL mod = 1000000007;
+LL dp[maxn][maxn],c[maxn][maxn] = {1},f[maxn] = {1};
+void init() {
+    for(int i = 1; i < maxn; ++i) {
+        c[i][0] = c[i][i] = 1;
+        f[i] = f[i-1]*i%mod;
+        for(int j = 1; j < i; ++j)
+            c[i][j] = (c[i-1][j-1] + c[i-1][j])%mod;
+    }
+}
+char op[maxn];
+int main() {
+    init();
+    int n;
+    while(~scanf("%d",&n)) {
+        memset(dp,0,sizeof dp);
+        for(int i = 0; i < n; ++i)
+            scanf("%I64d",&dp[i][i]);
+        scanf("%s",op);
+        for(int i = 2; i <= n; ++i) {
+            for(int j = 0; j + i <= n; ++j) {
+                for(int k = j,t = j + i -1; k < t; ++k) {
+                    LL tmp;
+                    if(op[k] == '+')
+                        tmp = (f[t-k-1]*dp[j][k] + f[k-j]*dp[k+1][t])%mod;
+                    else if(op[k] == '-') {
+                        tmp = (f[t-k-1]*dp[j][k] - f[k-j]*dp[k+1][t])%mod;
+                        tmp = (tmp + mod)%mod;
+                    } else if(op[k] == '*') tmp = dp[j][k]*dp[k+1][t]%mod;
+                    tmp = tmp*c[t-j-1][k-j]%mod;
+                    dp[j][t] = (dp[j][t] + tmp + mod)%mod;
+                }
+            }
+        }
+        printf("%I64d\n",dp[0][n-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5398_autoAC.cpp b/HDOJ/5398_autoAC.cpp
new file mode 100644
index 0000000..8ea4e1c
--- /dev/null
+++ b/HDOJ/5398_autoAC.cpp
@@ -0,0 +1,123 @@
+#include <cstdlib>
+#include <cctype>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#include <iostream>
+#include <map>
+#include <set>
+#include <queue>
+#include <stack>
+#include <numeric>
+#include <iomanip>
+#include <bitset>
+#include <ctime>
+#include <cassert>
+#include <complex>
+using namespace std;
+#define rep(i,a,n) for (int i=a;i<n;i++)
+#define per(i,a,n) for (int i=n-1;i>=a;i--)
+#define pb push_back
+#define mp make_pair
+#define all(x) (x).begin(),(x).end()
+#define fi first
+#define se second
+#define SZ(x) ((int)(x).size())
+#define ACCU accumulate
+#define TWO(x) (1<<(x))
+#define TWOL(x) (1ll<<(x))
+#define clr(a) memset(a,0,sizeof(a))
+#define POSIN(x,y) (0<=(x)&&(x)<n&&0<=(y)&&(y)<m)
+#define PRINTC(x) cout<<"Case #"<<++__<<": "<<x<<endl 
+#define POP(x) (__builtin_popcount(x))
+#define POPL(x) (__builtin_popcountll(x))
+typedef vector<int> VI;
+typedef vector<string> VS;
+typedef vector<double> VD;
+typedef long long ll;
+typedef long double LD;
+typedef pair<int,int> PII;
+typedef pair<ll,ll> PLL;
+typedef vector<ll> VL;
+typedef vector<PII> VPII;
+typedef complex<double> CD;
+const int inf=0x20202020;
+const ll mod=1000000007;
+const double eps=1e-9;
+const double pi=3.1415926535897932384626;
+const int DX[]={1,0,-1,0},DY[]={0,1,0,-1};
+ll powmod(ll a,ll b) {ll res=1;a%=mod;for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
+ll powmod(ll a,ll b,ll mod) {ll res=1;a%=mod;for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
+ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
+const int N=101000;
+struct node {
+    node *s[2],*f;
+    int val,d;
+    bool rev;
+    bool isr() { return !f||(f->s[0]!=this && f->s[1]!=this);}
+    bool dir() { return f->s[1]==this;}
+    void setc(node *c,int d) { s[d]=c;if (c) c->f=this;}
+    void push() {
+        if (rev) { swap(s[0],s[1]); rep(i,0,2) if (s[i]) s[i]->rev^=1;} rev=0;
+    }
+    void upd() {
+        val=d;
+        rep(i,0,2) if (s[i]&&s[i]->val<val) val=s[i]->val;
+    }
+}pool[N],*cur;
+stack<node*> sta;
+void rot(node *x) {
+    node *p=x->f;bool d=x->dir();
+    if (!p->isr()) p->f->setc(x,p->dir()); else x->f=p->f;
+    p->setc(x->s[!d],d);x->setc(p,!d);
+    p->upd();
+}
+void splay(node *x) {
+    node *q=x;
+    while (1) { sta.push(q);if (q->isr()) break; q=q->f; }
+    while (!sta.empty()) sta.top()->push(),sta.pop();
+    while (!x->isr()) {
+        if (x->f->isr()) rot(x);
+        else if (x->isr()==x->f->isr()) rot(x->f),rot(x);
+        else rot(x),rot(x);
+    }
+    x->upd();
+}
+node *expose(node *x) {
+    node *q=NULL;
+    for (;x;x=x->f) splay(x),x->s[1]=q,(q=x)->upd();
+    return q;
+}
+void evert(node *x) { expose(x); splay(x); x->rev^=1; x->push();}
+void expose(node *x,node *y) { evert(x); expose(y); splay(x);}
+void link(node *x,node *y) { evert(x); evert(y); x->setc(y,1);}
+void cut(node *x,node *y) { expose(x,y); x->s[1]=y->f=NULL;}
+const int R=100000;
+int ans,ret[N],n;
+VI d[N];
+int main() {
+    for (int i=2;i<=R;i++) for (int j=i+i;j<=R;j+=i) d[j].pb(i);
+    for (int i=1;i<=R;i++) {
+        pool[i].d=pool[i].val=i;
+    }
+    for (int i=2;i<=R;i++) {
+        link(pool+i,pool+1); ans+=1;
+        per(j,0,SZ(d[i])) {
+            int v=d[i][j];
+            expose(pool+i,pool+v);
+            int u=pool[i].val;
+            if (u>=v) continue;
+            ans=ans-u+v;
+            splay(pool+u);
+            if (pool[u].s[0]) pool[u].s[0]->f=NULL,pool[u].s[0]=NULL;
+            else if (pool[u].s[1]) pool[u].s[1]->f=NULL,pool[u].s[1]=NULL;
+            else assert(0);
+            link(pool+i,pool+v);
+        }
+        ret[i]=ans;
+    }
+    while (scanf("%d",&n)!=EOF) {
+        printf("%d\n",ret[n]);
+    }
+}
diff --git a/HDOJ/5399_autoAC.cpp b/HDOJ/5399_autoAC.cpp
new file mode 100644
index 0000000..cde96cf
--- /dev/null
+++ b/HDOJ/5399_autoAC.cpp
@@ -0,0 +1,46 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000") 
+#include<cmath>
+#include<cstdio>
+#include<string>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+typedef long long LL;
+const LL base = 1e9 + 7;
+const int maxn = 105;
+LL T, n, m, f[maxn], a[maxn][maxn];
+inline void read(int &x)
+{
+    char ch;
+    while ((ch = getchar())<'0' || ch>'9');
+    x = ch - '0';
+    while ((ch = getchar()) >= '0' && ch <= '9') x = x * 10 + ch - '0';
+}
+int main()
+{
+    for (int i = f[0] = 1; i <= 100; i++) f[i] = f[i - 1] * i % base;
+    while (scanf("%I64d%I64d", &n, &m) != EOF)
+    {
+        LL tot = 0, ans = 1;
+        for (int i = 1; i <= m; i++)
+        {
+            scanf("%I64d", &a[i][1]);
+            if (a[i][1] == -1) tot++;
+            else for (int j = 2; j <= n; j++)
+            {
+                scanf("%I64d", &a[i][j]);
+                for (int k = j - 1; k; k--) if (a[i][j] == a[i][k]) ans = 0;
+            }
+        }
+        for (int i = 1; i < tot; i++) ans = ans * f[n] % base;
+        if (tot == 0)
+        {
+            for (int i = 1; i <= n; i++) a[0][i] = i;
+            for (int i = m; i; i--)
+                for (int j = 1; j <= n; j++) a[0][j] = a[i][a[0][j]];
+            for (int i = 1; i <= n; i++) if (a[0][i] != i) ans = 0;
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5400_autoAC.cpp b/HDOJ/5400_autoAC.cpp
new file mode 100644
index 0000000..91026a2
--- /dev/null
+++ b/HDOJ/5400_autoAC.cpp
@@ -0,0 +1,61 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const int MAXN= 100002;
+int a[MAXN], m, n, b1, b2, len[MAXN], ch[MAXN];
+long long ans;
+int main()
+{
+    int i;
+    while(scanf("%d%d%d", &n, &b1, &b2) != -1)
+    {
+        for(i = 1; i <= n; i++)
+        {
+            scanf("%d", &a[i]);
+        }
+        ans = 0;
+        len[1] = 1;
+        for(i = 2; i <= n; i++)
+        {
+            ch[i] = a[i] - a[i-1];
+            if(i == 2)
+            {
+                if(a[2]-a[1] == b1 || a[2] - a[1] == b2)
+                    len[i] = 2;
+                else len[i] = 1;
+            }
+            else
+            {
+                if(ch[i] == ch[i-1])
+                {
+                    if(ch[i] == b1 || ch[i] == b2)
+                        len[i] = len[i-1] + 1;
+                    else
+                        len[i]  = 1;
+                }
+                else if(ch[i] == b2 && ch[i-1] == b1)
+                {
+                    len[i] = len[i-1] + 1;
+                }
+                else if(ch[i] == b1 || ch[i] == b2)
+                {
+                    len[i]  = 2;
+                }
+                else
+                {
+                    len[i] = 1;
+                }
+            }
+        }
+        for(i = 1; i<= n; i++)
+        {
+            ans += len[i];
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5401_autoAC.cpp b/HDOJ/5401_autoAC.cpp
new file mode 100644
index 0000000..e3815b9
--- /dev/null
+++ b/HDOJ/5401_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<vector>
+#include<cmath>
+#include<string.h>
+#include<set>
+#include<map>
+#include<queue>
+#include<math.h>
+#define ll long long
+#define pi acos(-1)
+#define PLL pair<ll,ll>
+#define PLLL pair<PLL,ll>
+#define MP make_pair
+using namespace std;
+const ll mod = 1e9+7;
+const ll maxn= 1000+10;
+ll m,a[maxn],b[maxn],c[maxn],d[maxn],l[maxn],ans[maxn],s[maxn],cc[maxn],dd[maxn];
+map<PLLL,ll> ma;
+ll calc(ll p,ll x,ll y){
+    if(p==0) return 0;
+    PLLL r=MP(MP(p,x),y);
+    if(ma.find(r)!=ma.end()) return ma[r];
+    if(x<s[a[p]]&&y<s[a[p]]) return ma[r]=(calc(a[p],x,y)%mod);
+    else if(x<s[a[p]]&&y>=s[a[p]]) return  ma[r]=(calc(a[p],x,c[p])+calc(b[p],y-s[a[p]],d[p])+l[p])%mod;
+    else if(x>=s[a[p]]&&y<s[a[p]]) return  ma[r]=(calc(a[p],y,c[p])+calc(b[p],x-s[a[p]],d[p])+l[p])%mod;
+    else return  ma[r]=(calc(b[p],x-s[a[p]],y-s[a[p]])%mod);
+}
+ll solve(ll p,ll id){
+    if(p==0) return 0;
+    if(id<s[a[p]])
+        return ((calc(a[p],id,c[p])+l[p])%mod*(s[b[p]]%mod)%mod+(dd[p]+solve(a[p],id))%mod)%mod;
+    else{
+        id=(id-s[a[p]]);
+        return ((calc(b[p],id,d[p])+l[p])%mod*(s[a[p]]%mod)%mod+(cc[p]+solve(b[p],id))%mod)%mod;
+    }
+}
+int main(){
+    while(scanf("%lld",&m)!=EOF){
+        s[0]=1; a[0]=b[0]=c[0]=d[0]=cc[0]=dd[0]=l[0]=0; ma.clear();
+        for(ll i=1;i<=m;i++) s[i]=ans[i]=0;
+        for(ll i=1;i<=m;i++){
+            scanf("%lld%lld%lld%lld%lld",&a[i],&b[i],&c[i],&d[i],&l[i]); s[i]=s[a[i]]+s[b[i]];
+            cc[i]=solve(a[i],c[i])%mod,dd[i]=solve(b[i],d[i])%mod;
+            ans[i]=((cc[i]*(s[b[i]]%mod)%mod)+(dd[i]*(s[a[i]]%mod)%mod)+l[i]%mod*(s[a[i]]%mod)%mod*(s[b[i]]%mod)%mod+(ans[a[i]]+ans[b[i]])%mod)%mod;
+            printf("%lld\n",ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5402_autoAC.cpp b/HDOJ/5402_autoAC.cpp
new file mode 100644
index 0000000..903c420
--- /dev/null
+++ b/HDOJ/5402_autoAC.cpp
@@ -0,0 +1,105 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000") 
+#include<set>
+#include<map>
+#include<queue>
+#include<stack>
+#include<cmath>
+#include<cstdio>
+#include<vector>
+#include<string>
+#include<cstring>
+#include<algorithm>
+#include<functional>
+using namespace std;
+typedef long long LL;
+const LL base = 1e9 + 7;
+const int maxn = 105;
+LL T, n, m, a[maxn][maxn], sum, x, y;
+inline void read(int &x)
+{
+    char ch;
+    while ((ch = getchar())<'0' || ch>'9');
+    x = ch - '0';
+    while ((ch = getchar()) >= '0' && ch <= '9') x = x * 10 + ch - '0';
+}
+void get()
+{
+    x = 1;    y = 2;
+    for (int i = 1; i <= n;i++)
+        for (int j = 1; j <= m; j++) 
+            if (((i + j) & 1) && a[x][y] > a[i][j]) x = i, y = j;
+}
+int main()
+{
+    while (scanf("%lld%lld", &n, &m) !=EOF)
+    {
+        sum = 0;
+        for (int i = 1; i <= n;i++)
+            for (int j = 1; j <= m; j++)
+            {
+                scanf("%lld", &a[i][j]);
+                sum += a[i][j];
+            }
+        if (n & 1 || m & 1)
+        {
+            printf("%lld\n", sum);
+            if (n & 1)
+            {
+                for (int i = 1; i <= n; i++)
+                {
+                    for (int j = 1; j < m; j++) 
+                        if (i & 1) printf("R"); else printf("L");
+                    if (i < n) printf("D"); else printf("\n");
+                }
+            }
+            else
+            {
+                for (int i = 1; i <= m; i++)
+                {
+                    for (int j = 1; j < n; j++)
+                        if (i & 1) printf("D"); else printf("U");
+                    if (i < m) printf("R"); else printf("\n");
+                }
+            }
+        }
+        else
+        {
+            get();
+            printf("%lld\n", sum - a[x][y]);
+            for (int i = 1; i <= n; i += 2)
+            {
+                if (x == i || x == i + 1)
+                {
+                    for (int j = 1; j < y; j++)
+                    {
+                        if (j & 1) printf("D"); else printf("U");
+                        printf("R");
+                    }
+                    if (y < m) printf("R");
+                    for (int j = y + 1; j <= m; j++)
+                    {
+                        if (j & 1) printf("U"); else printf("D");
+                        if (j < m) printf("R");
+                    }
+                    if (i < n - 1) printf("D");
+                }
+                else if (i < x)
+                {
+                    for (int j = 1; j < m; j++) printf("R");
+                    printf("D");
+                    for (int j = 1; j < m; j++) printf("L");
+                    printf("D");
+                }
+                else
+                {
+                    for (int j = 1; j < m; j++) printf("L");
+                    printf("D");
+                    for (int j = 1; j < m; j++) printf("R");
+                    if (i < n - 1) printf("D");
+                }
+            }
+            printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5405_autoAC.cpp b/HDOJ/5405_autoAC.cpp
new file mode 100644
index 0000000..24d204c
--- /dev/null
+++ b/HDOJ/5405_autoAC.cpp
@@ -0,0 +1,182 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<iostream>
+#include<vector>
+using namespace std;
+#define maxn 200007
+#define inf  1000000000
+#define ll long long
+ll mod = 1000000007;
+struct Node{
+    Node *fa,*ch[2];
+    bool rev,root;
+    ll val,s1,s2,s3,s4;
+};
+Node pool[maxn];
+Node *nil,*tree[maxn];
+int cnt = 0;
+void init(){
+    cnt = 1;
+    nil = tree[0] = pool;
+    nil->ch[0] = nil->ch[1] = nil;
+    nil->s1 = nil->s2 = nil->val = nil->s3 = nil->s4 = 0;
+}
+Node *newnode(ll val,Node *f){ 
+    pool[cnt].fa = f;
+    pool[cnt].ch[0]=pool[cnt].ch[1]=nil;
+    pool[cnt].rev = false;
+    pool[cnt].root = true;
+    pool[cnt].val = val;
+    pool[cnt].s1 = 0;
+    pool[cnt].s2 = 0;
+    pool[cnt].s3 = 0;
+    pool[cnt].s4 = 0;
+    return &pool[cnt++];
+}
+void update_rev(Node *x){
+    if(x == nil) return ;
+    x->rev = !x->rev;
+    swap(x->ch[0],x->ch[1]);
+}
+void update(Node *x){
+    if(x == nil) return ;
+    x->s2 = x->s1 + x->val;
+    x->s4 = x->s3;
+    if(x->ch[0] != nil){
+        x->s2 += x->ch[0]->s2;
+        if(x->s2 >= mod)
+            x->s2 -= mod;
+        x->s4 += x->ch[0]->s4;
+        x->s4 %= mod;
+    }
+    if(x->ch[1] != nil){
+        x->s2 += x->ch[1]->s2;
+        if(x->s2 >= mod)
+            x->s2 -= mod;
+        x->s4 += x->ch[1]->s4;
+        x->s4 %= mod;
+    }
+}
+void pushdown(Node *x){
+    if(x->rev != false){
+        update_rev(x->ch[0]);
+        update_rev(x->ch[1]);
+        x->rev = false;
+    }
+}
+void push(Node *x){
+    if(!x->root) push(x->fa);
+    pushdown(x);
+}
+void rotate(Node *x){
+    Node *f = x->fa, *ff = f->fa;
+    int t = (f->ch[1] == x);
+    if(f->root)
+        x->root = true, f->root = false;
+    else ff->ch[ff->ch[1] == f] = x;
+    x->fa = ff;
+    f->ch[t] = x->ch[t^1];
+    x->ch[t^1]->fa = f;
+    x->ch[t^1] = f;
+    f->fa = x;
+    update(f);
+}
+void splay(Node *x){
+    push(x);
+    Node *f, *ff;
+    while(!x->root){
+        f = x->fa,ff = f->fa;
+        if(!f->root)
+            if((ff->ch[1]==f)&&(f->ch[1] == x)) rotate(f);
+            else rotate(x);
+        rotate(x);
+    }
+    update(x);
+}
+Node *access(Node *x){
+    Node *y = nil,*z;
+    while(x != nil){
+        splay(x);
+        z = x->ch[1];
+        x->ch[1]->root = true;
+        (x->ch[1] = y)->root = false;
+        update(z);
+        x->s1 += z->s2;
+        x->s3 += (z->s2*z->s2);
+        x->s1 %= mod;
+        x->s3 %= mod;
+        x->s1 -= y->s2;
+        x->s3 -= y->s2*y->s2;
+        x->s1 %= mod;
+        x->s3 %= mod;
+        update(x);
+        y = x;
+        x = x->fa;
+    }
+    return y;
+}
+void be_root(Node *x){
+    access(x);
+    splay(x);
+    update_rev(x);
+}
+int value[maxn];
+vector<int> head[maxn];
+void dfs(int u,int f){
+    tree[u]->fa = tree[f];
+    for(int i = 0;i < head[u].size() ;i++){
+        int v = head[u][i];
+        if(v == f) continue;
+        dfs(v,u);
+        tree[u]->s1 += tree[v]->s2;
+        tree[u]->s1 %= mod;
+        tree[u]->s3 += tree[v]->s2*tree[v]->s2;
+        tree[u]->s3 %= mod;
+    }
+    update(tree[u]);
+}
+int main(){
+    int n,m;
+    while(scanf("%d%d",&n,&m)!=EOF){
+        for(int i = 1;i <= n; i++)
+            scanf("%d",&value[i]);
+        for(int i = 0;i <= n; i++)
+            head[i].clear();
+        int u,v;
+        for(int i = 1;i < n; i++){
+            scanf("%d%d",&v,&u);
+            head[v].push_back(u);
+            head[u].push_back(v);
+        }
+        init();
+        for(int i=1;i <= n;i++)
+            tree[i] = newnode(value[i],nil);
+        dfs(1,0);
+        ll total = 0;
+        for(int i = 1;i <= n; i++)
+            total += value[i];
+        total %= mod;
+        int t;
+        for(int i = 0;i < m; i++){
+            scanf("%d%d%d",&t,&u,&v);
+            if(t == 1){
+                be_root(tree[u]);
+                access(tree[u]);
+                total = total + v - tree[u]->val;
+                total %= mod;
+                tree[u]->val = v;
+                update(tree[u]);
+            }
+            else {
+                be_root(tree[u]);
+                access(tree[v]);
+                splay(tree[v]);
+                ll ans = total*total%mod-tree[v]->s4;
+                ans = (ans%mod+mod)%mod;
+                printf("%I64d\n",ans);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5406_autoAC.cpp b/HDOJ/5406_autoAC.cpp
new file mode 100644
index 0000000..8fe5283
--- /dev/null
+++ b/HDOJ/5406_autoAC.cpp
@@ -0,0 +1,457 @@
+#include <cstdio>
+#include <algorithm>
+#include <iostream>
+#include <cmath>
+#include <vector>
+#include <cstring>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <queue>
+#include <sstream>
+using namespace std;
+const int MAXN = 1005;
+struct A{
+    int H, D;
+    bool operator<(const A rhs)const{
+        if(H != rhs.H)
+            return H > rhs.H;
+        else
+            return D < rhs.D;
+    }
+}arr[MAXN];
+int N;
+int dval[MAXN], dvn;
+#define MAXP 2010
+#define MAXQ 1000005
+#define MAXI 0x7fffffff
+#define MAXC 0x0fffffff
+#define BIGM MAXC
+struct EDGE{
+    int st, ed; 
+    int flow;   
+    int low;    
+    int upf;    
+    int cost;   
+    int hnext;  
+    int tnext; 
+    int hprev;  
+    int tprev; 
+    char set;   
+}edge[MAXQ+MAXP];
+int ecnt; 
+int ecnt2;  
+int sece; 
+bool search_method;  
+struct NODE{
+    int head;  
+    int tail;  
+    int d;     
+    int pi;    
+    int pred;  
+    int depth; 
+}node[MAXP];
+int ncnt;    
+struct LOOP{
+    int e;
+    int prev;
+    int next;
+}loop[MAXP+3];
+int lcnt;
+int addedge(int a, int b, int low, int upf, int cost, int &cnt)
+{
+    edge[cnt].st = a;
+    edge[cnt].ed = b;
+    edge[cnt].low = low;
+    edge[cnt].upf = upf;
+    edge[cnt].cost = cost;
+    edge[cnt].hnext = -1;
+    edge[cnt].tnext = -1;
+    edge[cnt].hprev = -1;
+    edge[cnt].tprev = -1;
+    cnt++;
+    return (cnt - 1);
+}
+void insert_tree(int j)
+{
+    int a, b;
+    a = edge[j].st;
+    b = edge[j].ed;
+    edge[j].hprev = -1;
+    edge[j].hnext = node[a].head;
+    if(node[a].head >= 0)
+        edge[node[a].head].hprev = j;
+    node[a].head = j;
+    edge[j].tprev = -1;
+    edge[j].tnext = node[b].tail;
+    if(node[b].tail >= 0)
+        edge[node[b].tail].tprev = j;
+    node[b].tail = j;
+}
+void delete_tree(int j)
+{
+    int a, b;
+    a = edge[j].st;
+    b = edge[j].ed;
+    if(edge[j].hprev >= 0)
+    {
+        edge[edge[j].hprev].hnext = edge[j].hnext;
+    }else{
+        node[a].head = edge[j].hnext;
+    }
+    if(edge[j].hnext >= 0)
+    {
+        edge[edge[j].hnext].hprev = edge[j].hprev;
+    }
+    edge[j].hprev = -1;
+    edge[j].hnext = -1;
+    if(edge[j].tprev >= 0)
+    {
+        edge[edge[j].tprev].tnext = edge[j].tnext;
+    }else{
+        node[b].tail = edge[j].tnext;
+    }
+    if(edge[j].tnext >= 0)
+    {
+        edge[edge[j].tnext].tprev = edge[j].tprev;
+    }
+    edge[j].tprev = -1;
+    edge[j].tnext = -1;
+}
+void M_init()   
+{
+    int i, j;
+    node[0].d = 0;
+    node[0].head = -1;
+    node[0].tail = -1;
+    for(i=0;i<ecnt;i++)
+    {
+        edge[i].flow = edge[i].low;
+        edge[i].set = 'L';
+        node[edge[i].st].d -= edge[i].low;
+        node[edge[i].ed].d += edge[i].low;
+    }
+    ecnt2 = ecnt;
+    for(i=1;i<=ncnt;i++)
+    {
+        if(node[i].d > 0)
+        {
+            j = addedge(i, 0, 0, MAXC, BIGM, ecnt2); 
+            edge[j].flow = node[i].d;
+        }else{
+            j = addedge(0, i, 0, MAXC, BIGM, ecnt2);
+            edge[j].flow = -node[i].d;
+        }
+        edge[j].set = 'T';
+        insert_tree(j);
+    }
+}
+void calc_pi(int root, int val, int dep, int pred)
+{
+    int j;
+    node[root].pi = val;
+    node[root].depth = dep;
+    node[root].pred = pred;
+    for(j=node[root].head;j!=-1;j=edge[j].hnext)
+    {
+        if(j != pred)
+        {
+            calc_pi(edge[j].ed, val - edge[j].cost, dep + 1, j);
+        }
+    }
+    for(j=node[root].tail;j!=-1;j=edge[j].tnext)
+    {
+        if(j != pred)
+        {
+            calc_pi(edge[j].st, val + edge[j].cost, dep + 1, j);
+        }
+    }
+}
+int calc_dual1()   
+{
+    int i, ret = -1, dual0 = -1, dual;
+    for(i=0;i<ecnt2;i++)
+    {
+        dual = edge[i].cost - node[edge[i].st].pi + node[edge[i].ed].pi;
+        if((edge[i].set == 'L' && dual < 0)||(edge[i].set == 'U' && dual > 0))
+        {
+            dual = labs(dual);
+            if(dual > dual0)  
+            {
+                ret = i;
+                dual0 = dual;
+            }
+        }
+    }
+    return ret;
+}
+int calc_dual2()   
+{
+    int i, dual;
+    for(i=sece;i<ecnt2;i++)
+    {
+        dual = edge[i].cost - node[edge[i].st].pi + node[edge[i].ed].pi;
+        if((edge[i].set == 'L' && dual < 0)||(edge[i].set == 'U' && dual > 0))
+        {
+            sece = i + 1;
+            return i;
+        }
+    }
+    for(i=0;i<sece;i++)
+    {
+        dual = edge[i].cost - node[edge[i].st].pi + node[edge[i].ed].pi;
+        if((edge[i].set == 'L' && dual < 0)||(edge[i].set == 'U' && dual > 0))
+        {
+            sece = i + 1;
+            return i;
+        }
+    }
+    return -1;
+}
+bool augment(int rda)  
+{
+    int p, q;
+    int pl, ql, pp, qp, maxflow;
+    bool flagp, flagq, flag, ret;
+    lcnt = 0;
+    if(edge[rda].set == 'L')
+    {
+        p = edge[rda].st;
+        q = edge[rda].ed;
+    }else{
+        q = edge[rda].st;
+        p = edge[rda].ed;
+    }
+    loop[lcnt].e = rda;
+    loop[lcnt].prev = 1;
+    loop[lcnt].next = 2;
+    pl = 1;
+    ql = 2;
+    loop[pl].e = -1;
+    loop[pl].next = 0;
+    loop[pl].prev = -1;
+    loop[ql].e = -1;
+    loop[ql].next = -1;
+    loop[ql].prev = 0;
+    lcnt = 3;
+    maxflow = edge[rda].upf - edge[rda].low;
+    while(p != q)
+    {
+        if(node[p].depth > node[q].depth)
+        {
+            flagp = true;
+            flagq = false;
+        }else if(node[p].depth < node[q].depth)
+        {
+            flagp = false;
+            flagq = true;
+        }else{
+            flagp = true;
+            flagq = true;
+        }
+        if(flagp)
+        {
+            pp = node[p].pred;
+            if(edge[pp].ed == p)  
+            {
+                maxflow = min(maxflow, edge[pp].upf - edge[pp].flow);
+                p = edge[pp].st;
+            }else{                
+                maxflow = min(maxflow, edge[pp].flow - edge[pp].low);
+                p = edge[pp].ed;
+            }
+            loop[pl].e = pp;
+            loop[pl].prev = lcnt;
+            loop[lcnt].e = -1;
+            loop[lcnt].next = pl;
+            loop[lcnt].prev = -1;
+            pl = lcnt;
+            lcnt++;
+        }
+        if(flagq)
+        {
+            qp = node[q].pred;
+            if(edge[qp].st == q)  
+            {
+                maxflow = min(maxflow, edge[qp].upf - edge[qp].flow);
+                q = edge[qp].ed;
+            }else{               
+                maxflow = min(maxflow, edge[qp].flow - edge[qp].low);
+                q = edge[qp].st;
+            }
+            loop[ql].e = qp;
+            loop[ql].next = lcnt;
+            loop[lcnt].e = -1;
+            loop[lcnt].next = -1;
+            loop[lcnt].prev = ql;
+            ql = lcnt;
+            lcnt++;
+        }
+    }
+    flag = false;
+    while(loop[pl].next >= 0)
+    {
+        pl = loop[pl].next;
+        ql = loop[pl].e;
+        if(ql == -1)
+            break;
+        if(ql == rda)
+        {
+            ret = (flag == (edge[rda].set == 'L'));
+        }
+        if(edge[ql].st == p)  
+        {
+            edge[ql].flow += maxflow;
+            if(!flag && (edge[ql].flow == edge[ql].upf))
+            {
+                edge[ql].set = 'U';
+                flag = true;
+                delete_tree(ql);
+            }else{
+                edge[ql].set = 'T';
+            }
+            p = edge[ql].ed;
+        }else{                
+            edge[ql].flow -= maxflow;
+            if(!flag && (edge[ql].flow == edge[ql].low))
+            {
+                edge[ql].set = 'L';
+                flag = true;
+                delete_tree(ql);
+            }else{
+                edge[ql].set = 'T';
+            }
+            p = edge[ql].st;
+        }
+    }
+    return ret;
+}
+bool NSMCalc(int &cost)
+{
+    int rda, i;
+    M_init();
+    calc_pi(0, 0, 0, -1);
+    rda = (search_ ? calc_dual1() : calc_dual2());
+    while(rda >= 0)
+    {
+        int j;
+        insert_tree(rda);
+        if(augment(rda))
+        {
+            i = edge[rda].st;
+            j = edge[rda].ed;
+            calc_pi(i, node[j].pi + edge[rda].cost, node[j].depth + 1, rda);
+        }else{
+            i = edge[rda].ed;
+            j = edge[rda].st;
+            calc_pi(i, node[j].pi - edge[rda].cost, node[j].depth + 1, rda);
+        }
+        rda = (search_ ? calc_dual1() : calc_dual2());
+    }
+    for(i=ecnt;i<ecnt2;i++)
+    {
+        if(edge[i].flow > 0)
+            return false;
+    }
+    cost = 0;
+    for(i=0;i<ecnt;i++)
+    {
+        cost += edge[i].flow * edge[i].cost;
+    }
+    return true;
+}
+void init_graph(int pointnum, bool method)
+{
+    int i;
+    ncnt = pointnum;
+    ecnt = 0;
+    sece = 0;
+    for(i=0;i<=ncnt;i++)
+    {
+        node[i].d = 0;
+        node[i].head = -1;
+        node[i].tail = -1;
+        node[i].pred = -1;
+        node[i].pi = 0;
+        node[i].depth = 0;
+    }
+    search_method = method;
+}
+inline char getc(){  
+    static const int BUFLEN = 1 << 15;  
+    static char B[BUFLEN], *S = B, *T = B;  
+    if(S == T){  
+        S = B;  
+        T = S + fread(B, 1, BUFLEN, stdin);  
+    }  
+    return (S == T) ? 0 : *(S ++);  
+}  
+int ReadInt(){  
+    char ch;  
+    do ch = getc(); while(!isdigit(ch));  
+    int aa = ch - '0';  
+    for(ch = getc(); isdigit(ch); ch = getc())  
+        aa = aa * 10 + ch - '0';  
+    return aa;  
+}  
+int calc(){
+    int i, j;
+    int ret, mxv;
+    init_graph(N * 2 + 3, false);
+    addedge(0, 1, 0, 2, 0, ecnt);
+    for(i = 1; i <= N; i ++){
+        addedge(1, i + 1, 0, 1, 0, ecnt);
+        addedge(i + N + 1, N * 2 + 2, 0, 1, 0, ecnt);
+        addedge(i + 1, i + N + 1, 0, 1, -1, ecnt);
+    }
+    for(i = 1; i <= N; i ++){
+        mxv = 0x3fffffff;
+        for(j = i + 1; j <= N; j ++){
+            if(arr[j].D < arr[i].D || arr[j].D >= mxv)
+                continue;
+            addedge(i + N + 1, j + 1, 0, 1, 0, ecnt);
+            addedge(i + 1, j + 1, 0, 1, 0, ecnt);
+            mxv = arr[j].D;
+        }
+    }
+    node[0].d = 2;
+    node[N * 2 + 2].d = -2;
+    NSMCalc(ret);
+    return - ret;
+}
+bool deal1(){
+    int i;
+    for(i = 1; i <= N; i ++){
+        if(arr[i + 1].D < arr[i].D)
+            return false;
+    }
+    printf("%d\n", N);
+    return true;
+}
+void domain(){
+    int i, ans = 0;
+    N = ReadInt();
+    for(i = 1; i <= N; i ++){
+        arr[i].H = ReadInt();
+        arr[i].D = ReadInt();
+    }
+    sort(arr + 1, arr + N + 1);
+    dvn = 0;
+    for(i = 1; i <= N; i ++){
+        dval[dvn ++] = arr[i].D;
+    }
+    sort(dval, dval + dvn);
+    dvn = unique(dval, dval + dvn) - dval;
+    for(i = 1; i <= N; i ++){
+        arr[i].D = lower_bound(dval, dval + dvn, arr[i].D) - dval + 1;
+    }
+    ans = calc();
+    printf("%d\n", ans);
+}
+int main(){
+    int T = ReadInt();
+    while(T --){
+        domain();
+    }
+    return 0;
+}
diff --git a/HDOJ/5407_autoAC.cpp b/HDOJ/5407_autoAC.cpp
new file mode 100644
index 0000000..37c188c
--- /dev/null
+++ b/HDOJ/5407_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <iostream>
+using namespace std;
+#define prt(k) cerr<<#k" = "<<k<<endl
+typedef long long ll;
+const int inf = 0x3f3f3f3f;
+const ll mod = 1e9 + 7;
+const int N = 1000100;
+ll p[N];
+ll a[N];
+bool ok(ll n)
+{
+    int t = p[n];
+    while (n % t==0 && n > 1) n /= t;
+    return n==1;
+}
+ll pmod(ll a, ll n)
+{
+    ll ret = 1;
+    for (; n; n>>=1, a=a*a%mod) if (n & 1)
+        ret = ret * a % mod;
+    return ret;
+}
+ll inv(ll a)
+{
+    return pmod(a, mod - 2);
+}
+int main()
+{
+    for (int i=1;i<N;i++) p[i]=i;
+    for (int i=2;i<N;i++) if (p[i]==i) {
+        for (int j=i+i;j<N;j+=i) p[j] = i;
+    }
+    a[0] = 1;
+    for (int i=1;i<N;i++) {
+        if (ok(i))
+            a[i] = a[i-1] * p[i] % mod;
+        else
+            a[i] = a[i-1];
+    }
+    int n; int re; cin>>re;
+    while (re--) {
+        scanf("%d", &n);
+        n++;
+        ll ans = a[n] * inv(n) % mod;
+        printf("%I64d\n", ans);
+    }
+}
diff --git a/HDOJ/5409_autoAC.cpp b/HDOJ/5409_autoAC.cpp
new file mode 100644
index 0000000..84c2db9
--- /dev/null
+++ b/HDOJ/5409_autoAC.cpp
@@ -0,0 +1,77 @@
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+const int MAXN = 100005;
+struct NODE;
+struct EDGE{
+    NODE *a, *b;
+       EDGE *next;
+    int u;    
+    bool bridge;  
+}edge[MAXN << 1];
+struct NODE{
+  EDGE *head;
+  NODE *par;
+  int DFN, low;
+  int mv;    
+}node[MAXN];
+int ecnt, dep, n, m;
+void Tarjan(NODE *x){
+    x->DFN = x->low = ++ dep;
+      for(EDGE *j = x->head; j; j = j->next){
+       NODE *p = j->b;
+          if(p == x->par)
+              continue;
+     if(!p->DFN){
+        p->par = x;
+          Tarjan(p);
+        }
+      j->bridge = p->low > x->DFN;
+      x->low = min(x->low, p->low);
+      x->mv = max(x->mv, p->mv);
+    j->u = j->b->mv;
+    }
+}
+void addedge(NODE *a, NODE *b, int& ecnt){
+ EDGE *j = &edge[ecnt ++];
+  j->a = a;
+  j->b = b;
+   j->next = a->head;
+  a->head = j;
+  j->bridge = false;
+}
+void domain(){
+  int i, u, v;
+   scanf("%d%d", &n, &m);
+   ecnt = 0;
+ for(i = 0; i <= n; i ++){
+     node[i].mv = i;
+      node[i].par = nullptr;
+      node[i].DFN = 0;
+      node[i].head = nullptr;
+    }
+  for(i = 0; i < m; i ++){
+      scanf("%d%d", &u, &v);
+       addedge(node + u, node + v, ecnt);
+      addedge(node + v, node + u, ecnt);
+    }
+  dep = 0;
+  Tarjan(node + n);
+   for(i = 0; i < ecnt; ){
+     u = 0;
+      if(edge[i].bridge)
+         u = edge[i].u;
+     i ++;
+       if(edge[i].bridge)
+          u = edge[i].u;
+      i ++;
+      printf("%d %d\n", u, u > 0 ? u + 1 : 0);
+    }
+}
+int main(){
+  int T;
+  scanf("%d", &T);
+   while(T --)
+       domain();
+  return 0;
+}
diff --git a/HDOJ/5410_autoAC.cpp b/HDOJ/5410_autoAC.cpp
new file mode 100644
index 0000000..64f1d7e
--- /dev/null
+++ b/HDOJ/5410_autoAC.cpp
@@ -0,0 +1,30 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int N = 1005;
+int w[N], a[N], b[N];
+int dp[N][2005][2];
+int main(){
+    int t; scanf("%d", &t);
+    while (t--){
+        int m, n; scanf("%d %d", &m, &n);
+        for (int i = 1; i <= n; i++){
+            scanf("%d %d %d", w + i, a + i, b + i);
+        }
+        memset(dp, 0, sizeof dp);
+        for (int i = 1; i <= n; i++){
+            for (int j = 0; j < w[i]; j++){
+                dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1]);
+                dp[i][j][1] = 0;
+            }
+            for (int j = w[i]; j <= m; j++){
+                dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1]);
+                dp[i][j][1] = max(dp[i][j - w[i]][0] + a[i] + b[i], dp[i][j - w[i]][1] + a[i]);
+            }
+        }
+        int ans = max(dp[n][m][0], dp[n][m][1]);
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5411_autoAC.cpp b/HDOJ/5411_autoAC.cpp
new file mode 100644
index 0000000..31c5cc9
--- /dev/null
+++ b/HDOJ/5411_autoAC.cpp
@@ -0,0 +1,62 @@
+#include<iostream>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<cstdio>
+#include<ctime>
+#include<vector>
+using namespace std;
+const int base = 2015;
+const int maxn = 100005;
+int T, n, m, k, kk;
+struct Matrix
+{
+    #define size 55
+    int m[size][size];
+    Matrix() { memset(m, 0, sizeof(m)); }
+    void operator =(const Matrix&b) { memcpy(m, b.m, sizeof(m)); }
+    Matrix operator *(const Matrix&b) {
+        Matrix c;
+        for (int i = 0; i < size; i++)
+        for (int j = 0; j < size; j++)
+        for (int k = 0; k < size; k++)
+            c.m[i][k] = (c.m[i][k] + m[i][j] * b.m[j][k]) % base;
+        return c;
+    }
+    Matrix get(int x)
+    {
+        Matrix a, b = *this;
+        for (int f = 0; x; x >>= 1)
+        {
+            if (x & 1)
+            if (f) a = a * b; else a = b, f = 1;
+            b = b * b;
+        }
+        return a;
+    }
+};
+int main()
+{
+    scanf("%d", &T);
+    while (T--)
+    {
+        scanf("%d%d", &n, &m);
+        Matrix a, b;
+        for (int i = 1; i <= n + 1; i++) a.m[i][n + 1] = 1;
+        for (int i = 1; i <= n; i++)
+        {
+            scanf("%d", &k);
+            for (int j = 1; j <= k; j++)
+            {
+                scanf("%d", &kk);
+                a.m[i][kk] = 1;
+            }
+        }
+        for (int i = 1; i <= n + 1; i++) b.m[1][i] = 1;
+        a = a.get(m);    
+        b = b * a;
+        if (m == 1) printf("%d\n", n + 1);
+        else printf("%d\n", b.m[1][n + 1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5412_autoAC.cpp b/HDOJ/5412_autoAC.cpp
new file mode 100644
index 0000000..28fc580
--- /dev/null
+++ b/HDOJ/5412_autoAC.cpp
@@ -0,0 +1,192 @@
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <string>
+#include <cstdlib>
+#include <climits>
+#include <ctype.h>
+#include <queue>
+#include <stack>
+#include <vector>
+#include <utility>
+#include <deque>
+#include <set>
+#include <map>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-9;
+const double PI = acos(-1.00);
+const double e = exp(1.0);
+#define INF 0x3f3f3f3f
+#define N 600010
+#define M 100010
+struct treap
+{
+    int key,wht,count,sz,ch[2];
+} tp[N*15];
+int tree[N<<1];
+int nodecount,root;
+int IDX(int l,int r)
+{
+    return l+r | l!=r;
+}
+void init()
+{
+    tp[0].sz=0;
+    tp[0].wht=-INF;
+    nodecount=0;
+    root=0;
+}
+void update(int x)
+{
+    tp[x].sz=tp[tp[x].ch[0]].sz+tp[x].count+tp[tp[x].ch[1]].sz;
+}
+void rotate(int &x,int t)
+{
+    int y=tp[x].ch[t];
+    tp[x].ch[t]=tp[y].ch[!t];
+    tp[y].ch[!t]=x;
+    update(x);
+    update(y);
+    x=y;
+}
+void insert(int &x,int t)
+{
+    if(! x)
+    {
+        x=++nodecount;
+        tp[x].key=t;
+        tp[x].wht=rand();
+        tp[x].count=1;
+        tp[x].ch[0]=tp[x].ch[1]=0;
+    }
+    else if(tp[x].key==t)  tp[x].count++;
+    else
+    {
+        int k=tp[x].key<t;
+        insert(tp[x].ch[k],t);
+        if(tp[x].wht<tp[tp[x].ch[k]].wht) rotate(x,k);
+    }
+    update(x);
+}
+void erase(int &x,int t)
+{
+    if(tp[x].key==t)
+    {
+        if(tp[x].count==1)
+        {
+            if(! tp[x].ch[0] && ! tp[x].ch[1])
+            {
+                x=0;
+                return;
+            }
+            rotate(x,tp[tp[x].ch[0]].wht<tp[tp[x].ch[1]].wht);
+            erase(x,t);
+        }
+        else tp[x].count--;
+    }
+    else erase(tp[x].ch[tp[x].key<t],t);
+    update(x);
+}
+int select(int x,int t)
+{
+    if(! x) return 0;
+    if(tp[x].key>t) return select(tp[x].ch[0],t);
+    return tp[x].count+tp[tp[x].ch[0]].sz+select(tp[x].ch[1],t);
+}
+int a[N],b[N],ord[M][5],lb;
+int n,m,tt;
+int search(int x)
+{
+    int l=1,r=b[0],mid;
+    while (l<=r)
+    {
+        mid=(l+r)>>1;
+        if(b[mid]==x) return mid;
+        if(b[mid]<x) l=mid+1;
+        else r=mid-1;
+    }
+}
+void treeinsert(int l,int r,int i,int x)
+{
+    insert(tree[IDX(l,r)],x);
+    if(l==r) return;
+    int m=(l+r)>>1;
+    if(i<=m) treeinsert(l,m,i,x);
+    else treeinsert(m+1,r,i,x);
+}
+void treedel(int l,int r,int i,int x)
+{
+    erase(tree[IDX(l,r)],x);
+    if(l==r) return;
+    int m=(l+r)>>1;
+    if(i<=m) treedel(l,m,i,x);
+    else treedel(m+1,r,i,x);
+}
+int query(int l,int r,int x,int y,int k)
+{
+    if(l==r) return l;
+    int m=(l+r)>>1;
+    int ans=select(tree[IDX(l,m)],y)-select(tree[IDX(l,m)],x);
+    if(ans>=k) return query(l,m,x,y,k);
+    return query(m+1,r,x,y,k-ans);
+}
+int main ()
+{
+    while (~scanf("%d",&n))
+    {
+        b[0]=1;
+        lb=0;
+        memset(tree,0,sizeof(tree));
+        init();
+        for(int i=1; i<=n; i++)
+        {
+            scanf("%d",&a[i]);
+            b[++lb]=a[i];
+        }
+        scanf("%d",&m);
+        for(int i=1; i<=m; i++)
+        {
+            int op;
+            int x,y,c;
+            scanf("%d",&op);
+            if(op == 2)
+            {
+                scanf("%d %d %d",&x,&y,&c);
+                ord[i][1]=1;
+                ord[i][2]=x;
+                ord[i][3]=y;
+                ord[i][4]=c;
+            }
+            else
+            {
+                scanf("%d %d",&x,&y);
+                ord[i][1]=2;
+                ord[i][2]=x;
+                ord[i][3]=y;
+                b[++lb]=y;
+            }
+        }
+        sort(b+1,b+1+lb);
+        for(int i=1; i<=lb; i++)
+            if(b[i]!=b[b[0]]) b[++b[0]]=b[i];
+        for(int i=1; i<=n; i++)
+        {
+            a[i]=search(a[i]);
+            treeinsert(1,b[0],a[i],i);
+        }
+        for(int i=1; i<=m; i++)
+        {
+            if(ord[i][1]==1)
+                printf("%d\n",b[query(1,b[0],ord[i][2]-1,ord[i][3],ord[i][4])]);
+            else
+            {
+                treedel(1,b[0],a[ord[i][2]],ord[i][2]);
+                a[ord[i][2]]=search(ord[i][3]);
+                treeinsert(1,b[0],a[ord[i][2]],ord[i][2]);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5413_autoAC.cpp b/HDOJ/5413_autoAC.cpp
new file mode 100644
index 0000000..131a851
--- /dev/null
+++ b/HDOJ/5413_autoAC.cpp
@@ -0,0 +1,97 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <set>
+#include <vector>
+#include <map>
+#include <queue>
+#include <set>
+#include <algorithm>
+#include <limits>
+using namespace std;
+typedef long long LL;
+const int MAXN=20000 + 10;
+const int INF = numeric_limits<int>::max();
+const LL LL_INF= numeric_limits<LL>::max();
+int bit[MAXN][MAXN/32+100];
+struct Edge {
+    int to,next;
+    Edge(){}
+    Edge(int _to,int _next):to(_to),next(_next){}
+}e[MAXN*10],e2[MAXN*10];
+int head[MAXN],tot,du[MAXN];
+int head2[MAXN],tot2;
+int n,m;
+void init(){
+    for(int i=1;i<=n;i++)head2[i]=head[i]=-1,du[i]=0;
+    tot2=0;
+    tot=0;
+}
+void AddEdge(int u,int v){
+    e[tot]=Edge(v,head[u]);
+    head[u]=tot++;
+}
+void AddEdge1(int u,int v){
+    e2[tot2]=Edge(v,head2[u]);
+    head2[u]=tot2++;
+}
+int que[MAXN],front,rear;
+void _or(int posi,int posj){
+    for(int i=0;i<=n/32;i++)bit[posi][i]|=bit[posj][i];
+}
+void top_bfs(){
+    front=rear=0;
+    memset(bit,0,sizeof(bit));
+    for(int i=1;i<=n;i++){
+        bit[i][i/32]=(1<<(i%32));
+        if(du[i]==0){
+            que[front++]=i;
+            --du[i];
+        }
+    }
+    while(front!=rear){
+        int u=que[rear++];
+        for(int i=head[u];~i;i=e[i].next){
+            int v=e[i].to;
+            AddEdge1(v,u);
+            if(--du[v]==0)que[front++]=v;
+        }
+    }
+}
+template <class T>
+void Rd(T &tmp){
+    char ch;
+    while((ch=getchar())&&!isdigit(ch));
+    tmp=0;
+    do {
+        tmp=(tmp<<3)+(tmp<<1)+(ch^48);
+    }while((ch=getchar())&&isdigit(ch));
+    return ;
+}
+int main()
+{
+    int T;
+    Rd(T);
+    while(T--){
+        Rd(n),Rd(m);
+        init();
+        for(int i=0,x,y;i<m;i++){
+            Rd(x),Rd(y);
+            AddEdge(x,y);
+            ++du[y];
+        }
+        top_bfs();
+        int ans=0;
+        for(int i=0;i<front;i++){
+            int u=que[i];
+            for(int j=head2[u];~j;j=e2[j].next){
+                int v=e2[j].to;
+                if(bit[u][v/32]&(1<<(v%32)))++ans;
+                _or(u,v);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5414_autoAC.cpp b/HDOJ/5414_autoAC.cpp
new file mode 100644
index 0000000..bc2b760
--- /dev/null
+++ b/HDOJ/5414_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <cstring>
+#include <algorithm>
+#include <cstdio>
+using namespace std;
+const int maxn=100000+100;
+char s[maxn];
+char ts[maxn];
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%s%s",s,ts);
+        int n1=strlen(s);
+        int n2=strlen(ts);
+        int cur=0;
+        for(int i=0;i<n2;i++)
+        {
+            if(ts[i]==s[cur])
+            cur++;
+            if(cur==n1)
+            break;
+        }
+        if(cur==n1)
+        {
+            int a1=1,a2=1;
+            for(int j=1;j<n1;j++)
+            {
+                if(s[j]==s[0])
+                a1++;
+                else
+                break;
+            }
+            for(int j=1;j<n2;j++)
+            {
+                if(ts[j]==ts[0])
+                a2++;
+                else
+                break;
+            }
+            if(a2>a1||s[0]!=ts[0])
+            printf("No\n");
+            else
+            printf("Yes\n");
+        }
+        else
+        printf("No\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5416_autoAC.cpp b/HDOJ/5416_autoAC.cpp
new file mode 100644
index 0000000..d21c7bf
--- /dev/null
+++ b/HDOJ/5416_autoAC.cpp
@@ -0,0 +1,70 @@
+#include <iostream>
+#include <cstring>
+#include <algorithm>
+#include <cstdio>
+using namespace std;
+const int maxn = 1e6+10;
+typedef long long LL;
+int dp[maxn];
+int head[maxn],ip;
+LL cnt[maxn];
+int n;
+struct nod{
+    int to,next,w;
+}edge[maxn];
+bool vis[maxn];
+void init(){
+    ip=0;
+    memset(head,-1,sizeof(head));
+    memset(cnt,0,sizeof(cnt));
+    memset(vis,0,sizeof(vis));
+}
+void add(int u,int v,int w){
+    edge[ip].to=v;
+    edge[ip].w=w;
+    edge[ip].next=head[u];
+    head[u]=ip++;
+}
+int mmax;
+void dfs(int u,int pre,int val){
+    for(int i=head[u];i!=-1;i=edge[i].next){
+        int v= edge[i].to;
+        if(v==pre) continue;
+        if(edge[i].w^val>mmax)
+            mmax = edge[i].w^val;
+        cnt[edge[i].w^val]++;
+        dfs(v,u,val^edge[i].w);
+    }
+}
+int main()
+{
+    int t,m;
+    scanf("%d",&t);
+    while(t--){
+        init();
+        scanf("%d",&n);
+        for(int i=0;i<n-1;i++){
+            int u,v,w;
+            scanf("%d%d%d",&u,&v,&w);
+            add(u,v,w);
+            add(v,u,w);
+        }
+        mmax = 0;
+        dfs(1,1,0);
+        scanf("%d",&m);
+        cnt[0]++;
+        for(int i=0;i<m;i++){
+            int s;
+            scanf("%d",&s);
+            LL ans = 0;
+            for(int j=0;j<maxn;j++){
+                if((s^j)==j) ans=ans+(cnt[j]*(cnt[j]-1));
+                else ans = ans=ans+cnt[j]*cnt[s^j];
+            }
+            ans=ans/2;
+            if(s==0) ans=ans+n;
+            printf("%I64d\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5417_autoAC.cpp b/HDOJ/5417_autoAC.cpp
new file mode 100644
index 0000000..2c769dd
--- /dev/null
+++ b/HDOJ/5417_autoAC.cpp
@@ -0,0 +1,21 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+    int x, y, w, n;
+    while(cin>>x>>y>>w>>n)
+    {
+        n -= 1;
+        int ans, tmp1, tmp2;
+        if(w > x)
+            ans = (x+y)*n;
+        else
+        {
+            tmp1 = n % ((int)(x/w)+1);
+            tmp2 = n / (x/w+1);
+            ans = tmp2*(x+y)+w*tmp1;
+        }
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5418_autoAC.cpp b/HDOJ/5418_autoAC.cpp
new file mode 100644
index 0000000..54c3037
--- /dev/null
+++ b/HDOJ/5418_autoAC.cpp
@@ -0,0 +1,63 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <set>
+#include <vector>
+#include <map>
+#include <queue>
+#include <set>
+#include <algorithm>
+#include <limits>
+using namespace std;
+typedef long long LL;
+const int MAXN=20;
+const int INF = numeric_limits<int>::max();
+int dp[1<<MAXN][MAXN];
+int dis[MAXN][MAXN];
+int main()
+{
+    int T,n,m;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d%d",&n,&m);
+        for(int i=0;i<=n;i++)
+            for(int j=0;j<=n;j++)dis[i][j]=INF;
+        for(int i=0,x,y,w;i<m;i++){
+            scanf("%d%d%d",&x,&y,&w);
+            --x;--y;
+            dis[x][y]=dis[y][x]=min(dis[x][y],w);
+        }
+        if(n==1){
+            puts("0");
+            continue;
+        }
+        for(int k=0;k<n;k++)
+            for(int i=0;i<n;i++)
+                for(int j=0;j<n;j++)
+                {
+                    if(dis[i][k]!=INF&&dis[k][j]!=INF)dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
+                }
+        --n;
+        int tot=(1<<n);
+        for(int s=0;s<tot;s++){
+            for(int i=0;i<n;i++){
+                if(s&(1<<i)){
+                    if(s==(1<<i))dp[s][i]=dis[0][i+1];
+                    else {
+                        dp[s][i]=INF;
+                        for(int j=0;j<n;j++){
+                            if(i!=j&&(s&(1<<j))){
+                                dp[s][i]=min(dp[s][i],dp[s^(1<<i)][j]+dis[i+1][j+1]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        int ans=INF;
+        for(int i=0;i<n;i++)ans=min(ans,dp[tot-1][i]+dis[0][i+1]);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5419_autoAC.cpp b/HDOJ/5419_autoAC.cpp
new file mode 100644
index 0000000..9361bed
--- /dev/null
+++ b/HDOJ/5419_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std ;
+#define LL __int64
+LL dp[50100] ;
+int a[50100] ;
+LL gcd(LL a,LL b) {
+    return b == 0 ? a : gcd(b,a%b) ;
+}
+int main() {
+    int t , n , m ;
+    int i , l , r ;
+    LL x , y , temp ;
+    scanf("%d", &t) ;
+    while( t-- ) {
+        scanf("%d %d", &n, &m) ;
+        memset(dp,0,sizeof(dp)) ;
+        for(i = 1 ; i <= n ; i++)
+            scanf("%d", &a[i]) ;
+        while( m-- ) {
+            scanf("%d %d", &l, &r) ;
+            dp[l]++ ;
+            dp[r+1]-- ;
+        }
+        x = 0 ;
+        y = (LL)n*(n-1)*(n-2)/6 ;
+        for(i = 1 ; i <= n ; i++) {
+            dp[i] += dp[i-1] ;
+            if( dp[i] > 2 )
+                x += dp[i]*(dp[i]-1)*(dp[i]-2)/6*a[i] ;
+        }
+        if( x == 0 || y == 0 ) {
+            printf("0\n") ;
+            continue ;
+        }
+        temp = gcd(x,y) ;
+        x /= temp ;
+        y /= temp ;
+        if( y == 1 )
+            printf("%I64d\n", x ) ;
+        else
+            printf("%I64d/%I64d\n", x, y) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5420_autoAC.cpp b/HDOJ/5420_autoAC.cpp
new file mode 100644
index 0000000..e690eb0
--- /dev/null
+++ b/HDOJ/5420_autoAC.cpp
@@ -0,0 +1,124 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <set>
+#include <vector>
+#include <map>
+#include <queue>
+#include <set>
+#include <algorithm>
+#include <limits>
+using namespace std;
+typedef long long LL;
+const int MAXN=100000+1000;
+const int MAXM=MAXN*20;
+const int INF = numeric_limits<int>::max();
+const LL LL_INF= numeric_limits<LL>::max();
+struct Edge {
+    int to,next;
+    Edge(){}
+    Edge(int _to,int _next):to(_to),next(_next){}
+}e[MAXM<<3];
+int head[MAXM],tot;
+void init(){
+    memset(head,-1,sizeof(head));
+    tot=0;
+}
+void AddEdge(int u,int v){
+    e[tot]=Edge(v,head[u]);
+    head[u]=tot++;
+}
+typedef pair<int,int> ii;
+vector <ii> t[MAXN<<2];
+int d[MAXN],L[MAXN],R[MAXN],dep[MAXN],ncnt,rid[MAXN],n,Begin[MAXN<<2];
+void dfs(int u,int d){
+    L[u]=++ncnt;
+    rid[ncnt]=u;
+    dep[u]=d;
+    for(int i=head[u];~i;i=e[i].next)
+        dfs(e[i].to,d+1);
+    R[u]=ncnt;
+}
+#define lson L,mid,rt<<1
+#define rson mid+1,R,rt<<1|1
+void build(int L,int R,int rt){
+    t[rt].resize(R-L+1);
+    if(L==R){
+        Begin[rt]=n+1;
+        t[rt][0]=make_pair(dep[rid[L]],rid[L]);
+        ++n;
+        AddEdge(n,rid[L]);
+        return ;
+    }
+    int mid=(L+R)>>1;
+    build(lson);build(rson);
+    merge(t[rt<<1].begin(),t[rt<<1].end(),t[rt<<1|1].begin(),t[rt<<1|1].end(),t[rt].begin());
+    Begin[rt]=n+1;
+    for(int i=1;i<R-L+1;i++)AddEdge(n+1+i,n+i);
+    for(int i=0;i<R-L+1;i++)AddEdge(n+1+i,t[rt][i].second);
+    n+=R-L+1;
+}
+void connect(int L,int R,int rt,int l,int r,int x,int d){
+    if(l<=L&&R<=r){
+        int pos=lower_bound(t[rt].begin(),t[rt].end(),make_pair(d,1<<30))-t[rt].begin()-1;
+        if(~pos)AddEdge(x,Begin[rt]+pos);
+        return ;
+    }
+    int mid=(L+R)>>1;
+    if(l<=mid)connect(lson,l,r,x,d);
+    if(r>mid)connect(rson,l,r,x,d);
+}
+int dfn[MAXM],low[MAXM],sta[MAXM],top,times,bleg[MAXM],cnt[MAXM];
+void tarjan(int u){
+    low[u]=dfn[u]=++times;
+    sta[++top]=u;
+    for(int i=head[u];~i;i=e[i].next){
+        int v=e[i].to;
+        if(!dfn[v]){
+            tarjan(v);
+            low[u]=min(low[u],low[v]);
+        }
+        else if(!bleg[v])
+            low[u]=min(low[u],dfn[v]);
+    }
+    if(dfn[u]==low[u]){
+        bleg[0]++;
+        cnt[bleg[0]]=0;
+        do{
+            bleg[sta[top]]=bleg[0];
+            cnt[bleg[0]]+=(sta[top]<=ncnt);
+        }while(sta[top--]!=u);
+    }
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d",&n);
+        init();
+        for(int i=2,x;i<=n;i++){
+            scanf("%d",&x);
+            AddEdge(x,i);
+        }
+        ncnt=0;
+        dfs(1,0);
+        init();
+        build(1,ncnt,1);
+        for(int i=1,x,y;i<=ncnt;i++){
+            scanf("%d%d",&x,&y);
+            connect(1,ncnt,1,L[x],R[x],i,dep[x]+y);
+        }
+        memset(dfn,0,sizeof(dfn));
+        memset(bleg,0,sizeof(bleg));
+        top=times=0;
+        for(int i=1;i<=n;i++)if(!dfn[i])tarjan(i);
+        LL ans=0;
+        for(int i=1;i<=bleg[0];i++){
+            ans+=(LL)cnt[i]*(cnt[i]-1)/2;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5421_autoAC.cpp b/HDOJ/5421_autoAC.cpp
new file mode 100644
index 0000000..d03c105
--- /dev/null
+++ b/HDOJ/5421_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std ;
+typedef long long LL ;
+#define clr( a , x ) memset ( a , x , sizeof a )
+const int MAXN = 200005 ;
+struct Palindromic_Tree {
+    int nxt[MAXN][26] ;
+    int fail[MAXN] ;
+    int len[MAXN] ;
+    int S[MAXN] , L , R ;
+    int num[MAXN] ;
+    int last[2] ;
+    int p ;
+    LL tot ;
+    int newnode ( int l ) {
+        for ( int i = 0 ; i < 26 ; ++ i ) nxt[p][i] = 0 ;
+        num[p] = 0 ;
+        len[p] = l ;
+        return p ++ ;
+    }
+    void init ( int n ) {
+        p = 0 ;
+        newnode ( 0 ) ;
+        newnode ( -1 ) ;
+        clr ( S , -1 ) ;
+        L = n ;
+        R = n - 1 ;
+        last[0] = last[1] = 1 ;
+        fail[0] = 1 ;
+        tot = 0 ;
+    }
+    int get_fail ( int v , bool d ) {
+        if ( d ) while ( S[R - len[v] - 1] != S[R] ) v = fail[v] ;
+        else while ( S[L + len[v] + 1] != S[L] ) v = fail[v] ;
+        return v ;
+    }
+    void add ( int c , bool d ) {
+        if ( d ) S[++ R] = c ;
+        else S[-- L] = c ;
+        int cur = get_fail ( last[d] , d ) ;
+        if ( !nxt[cur][c] ) {
+            int now = newnode ( len[cur] + 2 ) ;
+            fail[now] = nxt[get_fail ( fail[cur] , d )][c] ;
+            nxt[cur][c] = now ;
+            num[now] = num[fail[now]] + 1 ;
+        }
+        last[d] = nxt[cur][c] ;
+        if ( len[last[d]] == R - L + 1 ) last[d ^ 1] = last[d] ;
+        tot += num[last[d]] ;
+    }
+} ;
+Palindromic_ T ;
+int n ;
+void solve () {
+    int op ;
+    char c ;
+    T.init ( n ) ;
+    for ( int i = 0 ; i < n ; ++ i ) {
+        scanf ( "%d" , &op ) ;
+        if ( op <= 2 ) {
+            scanf ( " %c" , &c ) ;
+            T.add ( c - 'a' , op - 1 ) ;
+        }
+        if ( op == 3 ) printf ( "%d\n" , T.p - 2 ) ;
+        if ( op == 4 ) printf ( "%I64d\n" , T.tot ) ;
+    }
+}
+int main () {
+    while ( ~scanf ( "%d" , &n ) ) solve () ;
+    return 0 ;
+}
diff --git a/HDOJ/5422_autoAC.cpp b/HDOJ/5422_autoAC.cpp
new file mode 100644
index 0000000..d77fc10
--- /dev/null
+++ b/HDOJ/5422_autoAC.cpp
@@ -0,0 +1,19 @@
+#include <iostream>
+using namespace std;
+int main(){             
+    int n,m,a,b,sign;   
+    while(cin>>n>>m){   
+        sign=0;       
+        while(m--){     
+            cin>>a>>b;
+            if((a==1&&b==n)||(b==1&&a==n))
+            sign=1;     
+        }
+        n=n*(n-1)/2;
+        if(sign)
+        cout<<"1 "<<n<<endl;
+        else
+        cout<<"1 1"<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5423_autoAC.cpp b/HDOJ/5423_autoAC.cpp
new file mode 100644
index 0000000..ffd69c9
--- /dev/null
+++ b/HDOJ/5423_autoAC.cpp
@@ -0,0 +1,44 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+int s[1005][1005],sum[1005],dis[1005];
+int n;
+void dfs(int x,int num){
+    int i;
+    dis[x]=num;
+    for(i=1;i<=n;i++)
+    if(s[x][i]&&!dis[i])
+    dfs(i,num+1);
+}                                       
+int main(){
+    int i,a,b,ans;
+    while(scanf("%d",&n)!=EOF){
+        memset(s,0,sizeof(s));
+        memset(sum,0,sizeof(sum));
+        memset(dis,0,sizeof(dis));
+        for(i=1;i<=n-1;i++){
+            scanf("%d%d",&a,&b);
+            s[a][b]=s[b][a]=1;
+        }
+        dfs(1,1);
+        for(i=1;i<=n;i++)
+        sum[dis[i]]++;
+        ans=0;
+        for(i=1;i<=n;i++){
+            if(sum[i]==1)
+            ans++;
+            else{
+              if(sum[i+1]==0)
+              ans=n;
+              break;
+            }                               
+        }                                   
+        if(ans==n)                         
+        printf("YES\n");
+        else
+        printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5424_autoAC.cpp b/HDOJ/5424_autoAC.cpp
new file mode 100644
index 0000000..4bce6bc
--- /dev/null
+++ b/HDOJ/5424_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <iostream>
+#include<cstring>
+#include<cstdio>
+using namespace std;
+int n,cnt,x,y,deg[1001];
+bool flag,vis[1001],Map[1001][1001];
+void dfs(int u)
+{
+    if(cnt==n) {flag=1;return;}
+    for(int i=1;i<=n&&!flag;++i)
+        if(!vis[i]&&Map[u][i])
+        {
+            vis[i]=1;
+            ++cnt;
+            dfs(i);
+            --cnt;
+            vis[i]=0;
+        }
+}
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        flag=0;
+        cnt=1;
+        memset(deg,0,sizeof(deg));
+        memset(vis,0,sizeof(vis));
+        memset(Map,0,sizeof(Map));
+        for(int i=0;i<n;++i){
+            scanf("%d%d",&x,&y);
+            if(x!=y&&!Map[x][y])
+            {
+                Map[x][y]=Map[y][x]=1;
+                ++deg[x],++deg[y];
+            }
+        }
+        int s=1,tot=0;
+        for(int i=1;i<=n;++i)
+            if(deg[i]==1) {s=i;++tot;}
+        if(tot>2) {puts("NO");continue;}
+        vis[s]=1;
+        dfs(s);
+        if(flag) puts("YES");
+        else puts("NO");
+    }
+    return 0;
+}
diff --git a/HDOJ/5425_autoAC.cpp b/HDOJ/5425_autoAC.cpp
new file mode 100644
index 0000000..aace4e5
--- /dev/null
+++ b/HDOJ/5425_autoAC.cpp
@@ -0,0 +1,53 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<vector>
+#include<algorithm>
+#include<cmath>
+#include<queue>
+using namespace std;
+#define MAXN 100005
+vector<int>vec[MAXN];
+queue<int>q;
+int n,d[MAXN];
+inline double f(double a,double b)
+{
+    return a * b / (a + b);
+}
+double solve()
+{
+    double ans = 0;
+    for(int i = n - 1;i >= max(n - 100,0);i--)
+        for(int j = n - 1;j > i;j--)
+            ans += f(d[i],d[j]) / (pow(2.0,n - i) - (n + 1) / pow(2.0,i));
+    return ans;
+}
+int main()
+{
+    while(scanf("%d",&n) != EOF)
+    {
+        for(int i = 0;i <= n;i++)vec[i].clear();
+        for(int i = 1;i < n;i++)
+        {
+            int u;
+            scanf("%d",&u);
+            vec[u - 1].push_back(i);
+        }
+        d[0] = 1;
+        q.push(0);
+        while(!q.empty())
+        {
+            int u = q.front();
+            q.pop();
+            for(int i = 0;i < vec[u].size();i++)
+            {
+                int v = vec[u][i];
+                d[v] = d[u] + 1;
+                q.push(v);
+            }
+        }
+        sort(d,d + n);
+        double ans = solve();
+        printf("%.6f\n",ans);
+    }
+}
diff --git a/HDOJ/5427_autoAC.cpp b/HDOJ/5427_autoAC.cpp
new file mode 100644
index 0000000..1d0bab0
--- /dev/null
+++ b/HDOJ/5427_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+using namespace std;
+struct node
+{
+    char s[110];
+    int a;
+}p[1000],t;
+int T,n;
+int main()
+{
+    while(~scanf("%d",&T))
+    {
+        while(T--)
+        {
+            scanf("%d",&n);
+            getchar();
+            for(int i=0;i<n;i++)
+            {
+                gets(p[i].s);
+            }
+            for(int i=0;i<n;i++)
+            {
+                int sum=0;
+                int len=strlen(p[i].s);
+                for(int j=len-4;j<len;j++)
+                {
+                    sum*=10;
+                    sum+=p[i].s[j]-'0';
+                }
+                p[i].s[len-5]='\0';   
+                p[i].a=sum;
+            }
+            for(int i=0;i<n-1;i++)
+            {
+                for(int j=0;j<n-1-i;j++)
+                {
+                    if(p[j].a<p[j+1].a)
+                    {
+                        t=p[j];
+                        p[j]=p[j+1];
+                        p[j+1]=t;
+                    }
+                }
+            }
+            for(int i=0;i<n;i++)
+            printf("%s\n",p[i].s);
+        }
+    }
+}
diff --git a/HDOJ/5428_autoAC.cpp b/HDOJ/5428_autoAC.cpp
new file mode 100644
index 0000000..a7b34f1
--- /dev/null
+++ b/HDOJ/5428_autoAC.cpp
@@ -0,0 +1,37 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int maxn=40000;
+int T;
+int n;
+long long a[100],x,cnt;
+long long vis[maxn];
+int main()
+{
+    scanf("%d",&T);
+    while(T--){
+        memset(vis,0,sizeof(vis));
+        scanf("%d",&n);
+        for(int i=0;i<n;i++)
+            scanf("%I64d",&a[i]);
+        cnt=0;
+        for(int i=0;i<n;i++){
+            x=a[i];
+            for(long long j=2;j*j<=x;j++){
+                while(x%j==0){
+                    x/=j;
+                    vis[cnt++]=j;
+                }
+            }
+            if(x>1)
+                vis[cnt++]=x;
+        }
+        sort(vis,vis+cnt);
+        if(cnt<2)
+            printf("-1\n");
+        else
+            printf("%I64d\n",vis[0]*vis[1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5429_autoAC.cpp b/HDOJ/5429_autoAC.cpp
new file mode 100644
index 0000000..ff34e75
--- /dev/null
+++ b/HDOJ/5429_autoAC.cpp
@@ -0,0 +1,309 @@
+#include <iostream>
+#include <string.h>
+#include<stdio.h>
+#include<iostream>
+using namespace std;
+#define DIGIT    4
+#define DEPTH    10000
+#define MAX     100
+typedef int bignum_t[MAX+1];
+int read(bignum_ a,istream& is=cin){
+    char buf[MAX*DIGIT+1],ch;
+    int i,j;
+    memset((void*)a,0,sizeof(bignum_t));
+    if (!(is>>buf))    return 0;
+    for (a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
+        ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch;
+    for (a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
+    for (i=1;i<=a[0];i++)
+        for (a[i]=0,j=0;j<DIGIT;j++)
+            a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0';
+    for (;!a[a[0]]&&a[0]>1;a[0]--);
+    return 1;
+}
+void write(const bignum_ a,ostream& os=cout){
+    int i,j;
+    for (os<<a[i=a[0]],i--;i;i--)
+        for (j=DEPTH/10;j;j/=10)
+            os<<a[i]/j%10;
+}
+int comp(const bignum_ a,const bignum_ b){
+    int i;
+    if (a[0]!=b[0])
+        return a[0]-b[0];
+    for (i=a[0];i;i--)
+        if (a[i]!=b[i])
+            return a[i]-b[i];
+    return 0;
+}
+int comp(const bignum_ a,const int b){
+    int c[12]={1};
+    for (c[1]=b;c[c[0]]>=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++);
+    return comp(a,c);
+}
+int comp(const bignum_ a,const int c,const int d,const bignum_ b){
+    int i,t=0,O=-DEPTH*2;
+    if (b[0]-a[0]<d&&c)
+        return 1;
+    for (i=b[0];i>d;i--){
+        t=t*DEPTH+a[i-d]*c-b[i];
+        if (t>0) return 1;
+        if (t<O) return 0;
+    }
+    for (i=d;i;i--){
+        t=t*DEPTH-b[i];
+        if (t>0) return 1;
+        if (t<O) return 0;
+    }
+    return t>0;
+}
+void add(bignum_ a,const bignum_ b){
+    int i;
+    for (i=1;i<=b[0];i++)
+        if ((a[i]+=b[i])>=DEPTH)
+            a[i]-=DEPTH,a[i+1]++;
+    if (b[0]>=a[0])
+        a[0]=b[0];
+    else
+        for (;a[i]>=DEPTH&&i<a[0];a[i]-=DEPTH,i++,a[i]++);
+    a[0]+=(a[a[0]+1]>0);
+}
+void add(bignum_ a,const int b){
+    int i=1;
+    for (a[1]+=b;a[i]>=DEPTH&&i<a[0];a[i+1]+=a[i]/DEPTH,a[i]%=DEPTH,i++);
+    for (;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
+}
+void sub(bignum_ a,const bignum_ b){
+    int i;
+    for (i=1;i<=b[0];i++)
+        if ((a[i]-=b[i])<0)
+            a[i+1]--,a[i]+=DEPTH;
+    for (;a[i]<0;a[i]+=DEPTH,i++,a[i]--);
+    for (;!a[a[0]]&&a[0]>1;a[0]--);
+}
+void sub(bignum_ a,const int b){
+    int i=1;
+    for (a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
+    for (;!a[a[0]]&&a[0]>1;a[0]--);
+}
+void sub(bignum_ a,const bignum_ b,const int c,const int d){
+    int i,O=b[0]+d;
+    for (i=1+d;i<=O;i++)
+        if ((a[i]-=b[i-d]*c)<0)
+            a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH;
+    for (;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
+    for (;!a[a[0]]&&a[0]>1;a[0]--);
+}
+void mul(bignum_ c,const bignum_ a,const bignum_ b){
+    int i,j;
+    memset((void*)c,0,sizeof(bignum_t));
+    for (c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++)
+        for (j=1;j<=b[0];j++)
+            if ((c[i+j-1]+=a[i]*b[j])>=DEPTH)
+                c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH;
+    for (c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--);
+}
+void mul(bignum_ a,const int b){
+    int i;
+    for (a[1]*=b,i=2;i<=a[0];i++){
+        a[i]*=b;
+        if (a[i-1]>=DEPTH)
+            a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH;
+    }
+    for (;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
+    for (;!a[a[0]]&&a[0]>1;a[0]--);
+}
+void mul(bignum_ b,const bignum_ a,const int c,const int d){
+    int i;
+    memset((void*)b,0,sizeof(bignum_t));
+    for (b[0]=a[0]+d,i=d+1;i<=b[0];i++)
+        if ((b[i]+=a[i-d]*c)>=DEPTH)
+            b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH;
+    for (;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH);
+    for (;!b[b[0]]&&b[0]>1;b[0]--);
+}
+void div(bignum_ c,bignum_ a,const bignum_ b){
+    int h,l,m,i;
+    memset((void*)c,0,sizeof(bignum_t));
+    c[0]=(b[0]<a[0]+1)?(a[0]-b[0]+2):1;
+    for (i=c[0];i;sub(a,b,c[i]=m,i-1),i--)
+        for (h=DEPTH-1,l=0,m=(h+l+1)>>1;h>l;m=(h+l+1)>>1)
+            if (comp(b,m,i-1,a)) h=m-1;
+            else l=m;
+    for (;!c[c[0]]&&c[0]>1;c[0]--);
+    c[0]=c[0]>1?c[0]:1;
+}
+void div(bignum_ a,const int b,int& c){
+    int i;
+    for (c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--);
+    for (;!a[a[0]]&&a[0]>1;a[0]--);
+}
+void sqrt(bignum_ b,bignum_ a){
+    int h,l,m,i;
+    memset((void*)b,0,sizeof(bignum_t));
+    for (i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--)
+        for (h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1)
+            if (comp(b,m,i-1,a)) h=m-1;
+            else l=m;
+    for (;!b[b[0]]&&b[0]>1;b[0]--);
+    for (i=1;i<=b[0];b[i++]>>=1);
+}
+int length(const bignum_ a){
+    int t,ret;
+    for (ret=(a[0]-1)*DIGIT,t=a[a[0]];t;t/=10,ret++);
+    return ret>0?ret:1;
+}
+int digit(const bignum_ a,const int b){
+    int i,ret;
+    for (ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--);
+    return ret%10;
+}
+int zeronum(const bignum_ a){
+    int ret,t;
+    for (ret=0;!a[ret+1];ret++);
+    for (t=a[ret+1],ret*=DIGIT;!(t%10);t/=10,ret++);
+    return ret;
+}
+void comp(int* a,const int l,const int h,const int d){
+    int i,j,t;
+    for (i=l;i<=h;i++)
+        for (t=i,j=2;t>1;j++)
+            while (!(t%j))
+                a[j]+=d,t/=j;
+}
+void convert(int* a,const int h,bignum_ b){
+    int i,j,t=1;
+    memset(b,0,sizeof(bignum_t));
+    for (b[0]=b[1]=1,i=2;i<=h;i++)
+        if (a[i])
+            for (j=a[i];j;t*=i,j--)
+                if (t*i>DEPTH)
+                    mul(b,t),t=1;
+    mul(b,t);
+}
+void combination(bignum_ a,int m,int n){
+    int* t=new int[m+1];
+    memset((void*)t,0,sizeof(int)*(m+1));
+    comp(t,n+1,m,1);
+    comp(t,2,m-n,-1);
+    convert(t,m,a);
+    delete []t;
+}
+void permutation(bignum_ a,int m,int n){
+    int i,t=1;
+    memset(a,0,sizeof(bignum_t));
+    a[0]=a[1]=1;
+    for (i=m-n+1;i<=m;t*=i++)
+        if (t*i>DEPTH)
+            mul(a,t),t=1;
+    mul(a,t);
+}
+#define SGN(x) ((x)>0?1:((x)<0?-1:0))
+#define ABS(x) ((x)>0?(x):-(x))
+int read(bignum_ a,int &sgn,istream& is=cin){
+    char str[MAX*DIGIT+2],ch,*buf;
+    int i,j;
+    memset((void*)a,0,sizeof(bignum_t));
+    if (!(is>>str)) return 0;
+    buf=str,sgn=1;
+    if (*buf=='-') sgn=-1,buf++;
+    for (a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
+        ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch;
+    for (a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
+    for (i=1;i<=a[0];i++)
+        for (a[i]=0,j=0;j<DIGIT;j++)
+            a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0';
+    for (;!a[a[0]]&&a[0]>1;a[0]--);
+    if (a[0]==1&&!a[1]) sgn=0;
+    return 1;
+}
+struct bignum{
+    bignum_t num;
+    int sgn;
+public:
+inline bignum(){memset(num,0,sizeof(bignum_t));num[0]=1;sgn=0;}
+inline bignum& operator=(const bignum& a){memcpy(num,a.num,sizeof(bignum_t));sgn=a.sgn;return *this;}
+inline bignum& operator=(const int a){memset(num,0,sizeof(bignum_t));num[0]=1;sgn=SGN(a);add(num,sgn*a);return *this;};
+inline bignum& operator+=(const bignum& a){if(sgn==a.sgn)add(num,a.num);else if(sgn&&a.sgn){int ret=comp(num,a.num);if(ret>0)sub(num,a.num);else if(ret<0){bignum_ t;
+    memcpy(t,num,sizeof(bignum_t));memcpy(num,a.num,sizeof(bignum_t));sub(num,t);sgn=a.sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn;return *this;}
+inline bignum& operator+=(const int a){if(sgn*a>0)add(num,ABS(a));else if(sgn&&a){int ret=comp(num,ABS(a));if(ret>0)sub(num,ABS(a));else if(ret<0){bignum_ t;
+    memcpy(t,num,sizeof(bignum_t));memset(num,0,sizeof(bignum_t));num[0]=1;add(num,ABS(a));sgn=-sgn;sub(num,t);}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)sgn=SGN(a),add(num,ABS(a));return *this;}
+inline bignum operator+(const bignum& a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret+=a;return ret;}
+inline bignum operator+(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret+=a;return ret;}
+inline bignum& operator-=(const bignum& a){if(sgn*a.sgn<0)add(num,a.num);else if(sgn&&a.sgn){int ret=comp(num,a.num);if(ret>0)sub(num,a.num);else if(ret<0){bignum_ t;
+    memcpy(t,num,sizeof(bignum_t));memcpy(num,a.num,sizeof(bignum_t));sub(num,t);sgn=-sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)add(num,a.num),sgn=-a.sgn;return *this;}
+inline bignum& operator-=(const int a){if(sgn*a<0)add(num,ABS(a));else if(sgn&&a){int ret=comp(num,ABS(a));if(ret>0)sub(num,ABS(a));else if(ret<0){bignum_ t;
+    memcpy(t,num,sizeof(bignum_t));memset(num,0,sizeof(bignum_t));num[0]=1;add(num,ABS(a));sub(num,t);sgn=-sgn;}else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0;}else if(!sgn)sgn=-SGN(a),add(num,ABS(a));return *this;}
+inline bignum operator-(const bignum& a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret-=a;return ret;}
+inline bignum operator-(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));ret.sgn=sgn;ret-=a;return ret;}
+inline bignum& operator*=(const bignum& a){bignum_ t;mul(t,num,a.num);memcpy(num,t,sizeof(bignum_t));sgn*=a.sgn;return *this;}
+inline bignum& operator*=(const int a){mul(num,ABS(a));sgn*=SGN(a);return *this;}
+inline bignum operator*(const bignum& a){bignum ret;mul(ret.num,num,a.num);ret.sgn=sgn*a.sgn;return ret;}
+inline bignum operator*(const int a){bignum ret;memcpy(ret.num,num,sizeof(bignum_t));mul(ret.num,ABS(a));ret.sgn=sgn*SGN(a);return ret;}
+inline bignum& operator/=(const bignum& a){bignum_ t;div(t,num,a.num);memcpy(num,t,sizeof(bignum_t));sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn;return *this;}
+inline bignum& operator/=(const int a){int t;div(num,ABS(a),t);sgn=(num[0]==1&&!num[1])?0:sgn*SGN(a);return *this;}
+inline bignum operator/(const bignum& a){bignum ret;bignum_ t;memcpy(t,num,sizeof(bignum_t));div(ret.num,t,a.num);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn;return ret;}
+inline bignum operator/(const int a){bignum ret;int t;memcpy(ret.num,num,sizeof(bignum_t));div(ret.num,ABS(a),t);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);return ret;}
+inline bignum& operator%=(const bignum& a){bignum_ t;div(t,num,a.num);if (num[0]==1&&!num[1])sgn=0;return *this;}
+inline int operator%=(const int a){int t;div(num,ABS(a),t);memset(num,0,sizeof(bignum_t));num[0]=1;add(num,t);return t;}
+inline bignum operator%(const bignum& a){bignum ret;bignum_ t;memcpy(ret.num,num,sizeof(bignum_t));div(t,ret.num,a.num);ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn;return ret;}
+inline int operator%(const int a){bignum ret;int t;memcpy(ret.num,num,sizeof(bignum_t));div(ret.num,ABS(a),t);memset(ret.num,0,sizeof(bignum_t));ret.num[0]=1;add(ret.num,t);return t;}
+inline bignum& operator++(){*this+=1;return *this;}
+inline bignum& operator--(){*this-=1;return *this;};
+inline int operator>(const bignum& a){return sgn>0?(a.sgn>0?comp(num,a.num)>0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<0:0):a.sgn<0);}
+inline int operator>(const int a){return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);}
+inline int operator>=(const bignum& a){return sgn>0?(a.sgn>0?comp(num,a.num)>=0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<=0:0):a.sgn<=0);}
+inline int operator>=(const int a){return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);}
+inline int operator<(const bignum& a){return sgn<0?(a.sgn<0?comp(num,a.num)>0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<0:0):a.sgn>0);}
+inline int operator<(const int a){return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);}
+inline int operator<=(const bignum& a){return sgn<0?(a.sgn<0?comp(num,a.num)>=0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<=0:0):a.sgn>=0);}
+inline int operator<=(const int a){return sgn<0?(a<0?comp(num,-a)>=0:1):(sgn>0?(a>0?comp(num,a)<=0:0):a>=0);}
+inline int operator==(const bignum& a){return (sgn==a.sgn)?!comp(num,a.num):0;}
+inline int operator==(const int a){return (sgn*a>=0)?!comp(num,ABS(a)):0;}
+inline int operator!=(const bignum& a){return (sgn==a.sgn)?comp(num,a.num):1;}
+inline int operator!=(const int a){return (sgn*a>=0)?comp(num,ABS(a)):1;}
+inline int operator[](const int a){return digit(num,a);}
+friend inline istream& operator>>(istream& is,bignum& a){read(a.num,a.sgn,is);return is;}
+friend inline ostream& operator<<(ostream& os,const bignum& a){if(a.sgn<0)os<<'-';write(a.num,os);return os;}
+friend inline bignum sqrt(const bignum& a){bignum ret;bignum_ t;memcpy(t,a.num,sizeof(bignum_t));sqrt(ret.num,t);ret.sgn=ret.num[0]!=1||ret.num[1];return ret;}
+friend inline bignum sqrt(const bignum& a,bignum& b){bignum ret;memcpy(b.num,a.num,sizeof(bignum_t));sqrt(ret.num,b.num);ret.sgn=ret.num[0]!=1||ret.num[1];b.sgn=b.num[0]!=1||ret.num[1];return ret;}
+inline int length(){return ::length(num);}
+inline int zeronum(){return ::zeronum(num);}
+inline bignum C(const int m,const int n){combination(num,m,n);sgn=1;return *this;}
+inline bignum P(const int m,const int n){permutation(num,m,n);sgn=1;return *this;}
+};
+#define N 105
+bignum s[N];
+int main()
+{
+    int t,n,i,k;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d",&n);
+        for(i=k=0;i<n;i++)
+        {
+            cin>>s[i];
+            if(s[i]==0)
+                k++;
+        }
+        if(k>0&&k<n)
+        {
+            puts("No");
+            continue;
+        }
+        if(n<3)
+        {
+            puts("Yes");
+            continue;
+        }
+        for(i=1;i<n-1;i++)
+            if(s[i-1]*s[i+1]!=s[i]*s[i])
+                break;
+        if(i<n-1)
+            puts("No");
+        else
+            puts("Yes");
+    }
+    return 0;
+}
diff --git a/HDOJ/5430_autoAC.cpp b/HDOJ/5430_autoAC.cpp
new file mode 100644
index 0000000..23712e7
--- /dev/null
+++ b/HDOJ/5430_autoAC.cpp
@@ -0,0 +1,31 @@
+#include<stdio.h>
+#define LL long long
+LL fun(LL m)
+{
+    LL res=m;
+    for(LL i=2;i*i<=m;i++)
+    {
+        if(m%i==0)
+        {
+            res=(res*(i-1))/i;
+            while(m%i==0)
+            {
+                m/=i;
+            }
+        }
+    }
+    if(m>1) res=(res*(m-1))/m;
+    return res;
+}
+int main()
+{
+    LL n;
+    int T;
+    scanf ("%d",&T);
+    while(T--)
+    {
+        scanf("%lld",&n);
+        printf("%lld\n",fun(n+1));
+    }
+    return 0;
+}
diff --git a/HDOJ/5431_autoAC.cpp b/HDOJ/5431_autoAC.cpp
new file mode 100644
index 0000000..f0681db
--- /dev/null
+++ b/HDOJ/5431_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+char str[20010];
+int bits[32];
+int save[32][20010];
+int tmp[32];
+int findindex(int i,int key){
+    int l=1,r=save[i][0];
+    int m,ans=0;
+    while(l<=r){
+        int m=(l+r)/2;
+        if(save[i][m]<=key){
+            ans=m;
+            l=m+1;
+        }      
+        else r=m-1;
+    }
+    return ans;
+}
+int main(){
+    int kase,now,T,K;
+    scanf("%d",&kase);
+    for(int i=1;i<32;i++) bits[i]=(1<<i);
+    while(kase--){
+        scanf("%s",str);
+        int len=strlen(str);
+        for(int i=0;i<31;i++) save[i][0]=0;
+        for(int i=0;i<len;i++){
+            now=0;
+            for(int j=i;j<=min(i+29,len-1);j++){
+                now=(now<<1)+(str[j]-'A');
+                save[j-i+1][++save[j-i+1][0]]=now;
+            }
+        }
+        for(int i=1;i<=30;i++) sort(save[i]+1,save[i]+save[i][0]+1);
+        for(int i=1;i<=30;i++) {
+            save[i][0]=unique(save[i]+1,save[i]+save[i][0]+1)-(save[i]+1);
+        }
+        scanf("%d",&T); int ans,ansbit;
+        while(T--){
+            scanf("%d",&K);
+            ans=-1;
+            for(int i=1;i<=30;i++){
+                if(K>bits[i]-save[i][0]){
+                    K-=(bits[i]-save[i][0]);
+                    continue;
+                }
+                int l=0,r=bits[i]-1;
+                while(l<=r){
+                    int m=(l+r)>>1;
+                    int pos=findindex(i,m);
+                    if(K>m+1-pos) l=m+1;
+                    else if(K<m+1-pos) r=m-1;
+                    else{
+                        ans=m;
+                        while(ans==save[i][pos]&&pos!=0){
+                            ans--; pos--;
+                        }
+                        break;
+                    }
+                }
+                if(ans!=-1){
+                    ansbit=i;
+                    break;
+                }
+            }
+            int cnt=0;
+            while(ansbit--){
+                tmp[cnt++]=ans%2;
+                ans/=2;
+            }
+            while(cnt--)
+                printf("%c",tmp[cnt]+'A');
+            puts("");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5432_autoAC.cpp b/HDOJ/5432_autoAC.cpp
new file mode 100644
index 0000000..1955f07
--- /dev/null
+++ b/HDOJ/5432_autoAC.cpp
@@ -0,0 +1,45 @@
+#include<map>
+#include<set>
+#include<cmath>
+#include<stack>
+#include<queue>
+#include<cstdio>
+#include<cctype>
+#include<vector>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+#include<functional>
+using namespace std;
+typedef long long LL;
+typedef pair<int, int> PII;
+const int MX = 1e5 + 5;
+double A[MX], B[MX];
+int main() {
+    int T, n; 
+    scanf("%d", &T);
+    while(T--) {
+        scanf("%d", &n);
+        for(int i = 1; i <= n; i++) {
+            scanf("%lf", &A[i]);
+        }
+        for(int i = 1; i <= n; i++) {
+            scanf("%lf", &B[i]);
+        }
+        double L = 0, R = 1000, m;
+        for(int i = 1; i <= 40; i++) {
+            m = (L + R) / 2;
+            double s, sum1 = 0, sum2 = 0;
+            for(int j = 1; j <= n; j++) {
+                if(A[j] <= m) s = 0;
+                else s = B[j] * B[j] * (A[j] - m) * (A[j] - m) * (A[j] - m) / (3.0 * A[j] * A[j]);
+                sum1 += s;
+                sum2 += B[j] * B[j] * A[j] / 3.0 - s;
+            }
+            if(sum1 < sum2) R = m;
+            else L = m;
+        }
+        printf("%d\n", (int)m);
+    }
+    return 0;
+}
diff --git a/HDOJ/5433_autoAC.cpp b/HDOJ/5433_autoAC.cpp
new file mode 100644
index 0000000..832ecb6
--- /dev/null
+++ b/HDOJ/5433_autoAC.cpp
@@ -0,0 +1,69 @@
+#include <cstdio>  
+#include <cstring>  
+#include <cmath>  
+#include <cstdlib>  
+#include <queue>  
+#include <algorithm>  
+using namespace std;  
+const int maxn = 55;  
+const double eps = 1e-6;  
+const double inf = 1e20;  
+const int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};  
+int N, M, K, Sx, Sy, Ex, Ey;  
+bool done[maxn][maxn][maxn];  
+char G[maxn][maxn];  
+double dp[maxn][maxn][maxn];  
+struct State {  
+    int x, y, k;  
+    double d;  
+    State(int x = 0, int y = 0, int k = 0, double d = 0): x(x), y(y), k(k), d(d) {}  
+    bool operator < (const State& u) const { return d > u.d; }  
+};  
+void init () {  
+    scanf("%d%d%d", &N, &M, &K);  
+    for (int i = 1; i <= N; i++)  
+        scanf("%s", G[i]+1);  
+    scanf("%d%d%d%d", &Sx, &Sy, &Ex, &Ey);  
+}  
+bool Dijkstra () {  
+    for (int i = 1; i <= N; i++)  
+        for (int j = 1; j <= M; j++)  
+            for (int k = 0; k <= K; k++) dp[i][j][k] = inf;  
+    memset(done, false, sizeof(done));  
+    dp[Sx][Sy][K] = 0;  
+    priority_queue<State> Q;  
+    Q.push(State(Sx, Sy, K, 0));  
+    while (!Q.empty()) {  
+        State u = Q.top();  
+        Q.pop();  
+        int x = u.x, y = u.y, k = u.k;  
+        if (done[x][y][k]) continue;  
+        done[x][y][k] = true;  
+        for (int i = 0; i < 4; i++) {  
+            int p = x + dir[i][0];  
+            int q = y + dir[i][1];  
+            int t = k - 1;  
+            if (p <= 0 || p > N || q <= 0 || q > M || t <= 0 || G[p][q] == '#') continue;  
+            double d = 1.0 * abs(G[x][y] - G[p][q]) / k;  
+            if (dp[p][q][t] > dp[x][y][k] + d) {  
+                dp[p][q][t] = dp[x][y][k] + d;  
+                Q.push(State(p, q, t, dp[p][q][t]));  
+            }  
+        }  
+    }  
+    double ans = inf;  
+    for (int i = 1; i <= K; i++)  
+        ans = min(ans, dp[Ex][Ey][i]);  
+    if (fabs(ans-inf) < eps) return false;  
+    printf("%.2lf\n", ans);  
+    return true;  
+}  
+int main () {  
+    int cas;  
+    scanf("%d", &cas);  
+    while (cas--) {  
+        init();  
+        if (!Dijkstra()) printf("No Answer\n");  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/5434_autoAC.cpp b/HDOJ/5434_autoAC.cpp
new file mode 100644
index 0000000..0a1e9b8
--- /dev/null
+++ b/HDOJ/5434_autoAC.cpp
@@ -0,0 +1,101 @@
+#include<map>
+#include<set>
+#include<cmath>
+#include<stack>
+#include<queue>
+#include<cstdio>
+#include<cctype>
+#include<vector>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+#include<functional>
+using namespace std;
+typedef long long LL;
+const int matMX = 128 + 5;
+const int INF = 0x3f3f3f3f;
+const LL mod = 1e9 + 7;
+struct Mat {
+    int m, n;
+    LL S[matMX][matMX];
+    Mat(int a, int b) {
+        m = a;
+        n = b;
+        memset(S, 0, sizeof(S));
+    }
+    Mat(int a, int b, LL w[][matMX]) {
+        m = a;
+        n = b;
+        for(int i = 0; i < m; i++) {
+            for(int j = 0; j < n; j++) {
+                S[i][j] = w[i][j];
+            }
+        }
+    }
+};
+Mat mat_mul(Mat A, Mat B) {
+    Mat C(A.m, B.n);
+    for(int i = 0; i < A.m; i++) {
+        for(int j = 0; j < B.n; j++) {
+            for(int k = 0; k < A.n; k++) {
+                C.S[i][j] = (C.S[i][j] + A.S[i][k] * B.S[k][j]) % mod;
+            }
+        }
+    }
+    return C;
+}
+Mat Blank(int m, int n) {
+    Mat ret(m, n);
+    for(int i = 0; i < m; i++) {
+        ret.S[i][i] = 1;
+    }
+    return ret;
+}
+Mat mat_pow(Mat A, LL b) {
+    Mat ret = Blank(A.m, A.n);
+    while(b) {
+        if(b & 1) ret = mat_mul(ret, A);
+        A = mat_mul(A, A);
+        b >>= 1;
+    }
+    return ret;
+}
+LL S[matMX][matMX];
+void DFS(int m, int cnt, int x, int y) {
+    if(cnt == m) {
+        S[x][y] = 1;
+        return;
+    }
+    DFS(m, cnt + 1, x << 1, y << 1);
+    DFS(m, cnt + 1, x << 1 | 1, y << 1 | 1);
+    if(cnt) {
+        if((x & 1) ^ (y & 1) == 0) {
+            DFS(m, cnt + 1, x << 1, y << 1 | 1);
+            DFS(m, cnt + 1, x << 1 | 1, y << 1);
+        } else if((x & 1) && !(y & 1)) {
+            DFS(m, cnt + 1, x << 1 | 1, y << 1);
+        } else {
+            DFS(m, cnt + 1, x << 1, y << 1 | 1);
+        }
+    } else {
+        DFS(m, cnt + 1, x << 1 | 1, y << 1);
+        DFS(m, cnt + 1, x << 1, y << 1 | 1);
+    }
+}
+int main() {
+    int m, n; 
+    while(~scanf("%d%d", &n, &m)) {
+        DFS(m, 0, 0, 0);
+        Mat A(1 << m, 1 << m, S), B(1 << m, 1);
+        memset(B.S, 0, sizeof(B.S));
+        B.S[0][0] = 1;
+        Mat ret = mat_mul(mat_pow(A, n), B);
+        LL ans = 0;
+        for(int i = 0; i < (1 << m); i++) {
+            ans += ret.S[i][0];
+            ans %= mod;
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5435_autoAC.cpp b/HDOJ/5435_autoAC.cpp
new file mode 100644
index 0000000..c482131
--- /dev/null
+++ b/HDOJ/5435_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <cstdio>
+#include <ctime>
+#include <cstring>
+#include <cstdlib>
+#include <cmath>
+#include <vector>
+#include <map>
+#include <set>
+#include <stack>
+#include <queue>
+#include <string>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define getmid(l,r) ((l) + ((r) - (l)) / 2)
+#define MEM(a,b) memset(a,b,sizeof(a))
+#define MP(a,b) make_pair(a,b)
+#define PB push_back
+typedef long long ll;
+typedef pair<int,int> pii;
+const double eps = 1e-8;
+const int INF = (1 << 30) - 1;
+const int MAXN = 100010;
+const ll mod = 1e9 + 7;
+int T,LA,LB;
+char A[MAXN],B[MAXN];
+int dp[100010][16];
+int Solve(char *s,int L,int p,int f,int xsum){
+    if(p > L) return xsum;
+    if(f){
+        int len = L - p + 1;
+        int res = 0;
+        for(int i = 0; i < 16; ++i)
+            res = (res + 1ll * (xsum ^ i) * dp[len][i]) % mod;
+        return res;
+    }
+    int top = s[p] - '0';
+    int res = 0;
+    for(int i = 0; i <= top; ++i)
+        res = (res + 1ll * Solve(s,L,p + 1,f | (i < top),xsum ^ i)) % mod;
+    return res;
+}
+void Pre(){
+    dp[0][0] = 1;
+    for(int i = 1; i < 100010; ++i)
+        for(int j = 0; j < 16; ++j)
+            for(int k = 0; k < 10; ++k)
+                dp[i][j] = (dp[i][j] + 1ll * dp[i - 1][j ^ k]) % mod;
+}
+int main(){
+    Pre();
+    scanf("%d",&T);
+    for(int tt = 1; tt <= T; ++tt){
+        scanf("%s%s",A + 1,B + 1);
+        LA = strlen(A + 1);
+        LB = strlen(B + 1);
+        int tmp = 0;
+        for(int i = 1; i <= LA; ++i) tmp ^= (A[i] - '0');
+        int ansA = Solve(A,LA,1,0,0);
+        int ansB = Solve(B,LB,1,0,0);
+        printf("Case #%d: %d\n",tt,(int)
+                (((1ll * ansB - ansA + tmp) % mod + mod) % mod));
+    }
+    return 0;
+}
diff --git a/HDOJ/5437_autoAC.cpp b/HDOJ/5437_autoAC.cpp
new file mode 100644
index 0000000..1ee4fc9
--- /dev/null
+++ b/HDOJ/5437_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>
+#define maxn 150005
+using namespace std;
+struct node
+{
+    char name[205];
+    int v, tp;
+    friend bool operator <(node a,node b)
+    {
+        if(a.v == b.v) return a.tp > b.tp;
+        return a.v < b.v;
+    }
+};
+node fri[maxn];
+struct node1
+{
+    int t, r;
+}ask[maxn];
+bool cmp(node1 a, node1 b)
+{
+    return a.t < b.t;
+}
+int put[maxn], wen[105];
+int main()
+{
+    int t, k, m, p, i, j, ok, now;
+    scanf("%d", &t);
+    while(t--)
+    {
+        scanf("%d %d %d", &k, &m, &p);
+        for(i = 0;i < k;i++)
+        {
+            scanf("%s %d",fri[i].name, &fri[i].v);
+            fri[i].tp = i;
+        }
+        ask[0].t = -1;
+        for(i = 0;i < m;i++)
+            scanf("%d %d", &ask[i].t, &ask[i].r);
+        for(i = 0;i < p;i++)
+            scanf("%d", &wen[i]);
+        priority_queue<node>q;
+        sort(ask, ask + m, cmp);
+        now = 0;
+        ok = 0;
+        for(i = 1;i <= k;i++)
+        {
+            q.push(fri[i - 1]);
+            if(i == ask[now].t)
+            {
+                for(j = 1;j <= ask[now].r&&(!q.empty());j++)
+                {
+                    node x = q.top();
+                    q.pop();
+                    put[ok++] = x.tp;
+                }
+                now++;
+            }
+        }
+        while(!q.empty())
+        {
+            node x = q.top();
+            q.pop();
+            put[ok++] = x.tp;
+        }
+        for(i = 0;i < p;i++)
+            printf("%s%c", fri[put[wen[i] - 1]].name, i==p-1?'\n':' ');
+    }
+}
diff --git a/HDOJ/5438_autoAC.cpp b/HDOJ/5438_autoAC.cpp
new file mode 100644
index 0000000..cfa6200
--- /dev/null
+++ b/HDOJ/5438_autoAC.cpp
@@ -0,0 +1,70 @@
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <queue>
+#include <set>
+#include <vector>
+using namespace std;
+#define pr(x) cout << #x << " = " << x << "  "
+#define prln(x) cout << #x << " = " << x << endl
+const int N = 1e4 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
+const int M = 1e5 + 10;
+int n, m;
+int deg[N], val[N];
+vector<int> G[N];
+bool vis[N];
+void dfs(int u, int &cnt, long long& sum) {
+    sum += val[u];
+    ++cnt;
+    vis[u] = true;
+    for(int i = 0; i < G[u].size(); ++i) {
+        int v = G[u][i];
+        if(vis[v]) continue;
+        dfs(v, cnt, sum);
+    }
+}
+int main() {
+    ios_base::sync_with_stdio(0);
+    int t; scanf("%d", &t);
+    while(t--) {
+        scanf("%d%d", &n, &m);
+        for(int i = 1; i <= n; ++i) {
+            scanf("%d", val + i);
+            G[i].clear();
+            vis[i] = false;
+            deg[i] = 0;
+        }
+        for(int i = 1; i <= m; ++i) {
+            int u, v; scanf("%d%d", &u, &v);
+            G[u].push_back(v);
+            G[v].push_back(u);
+            ++deg[u], ++deg[v];
+        }
+        queue<int> q;
+        for(int i = 1; i <= n; ++i)
+            if(deg[i] < 2) q.push(i);
+        while(q.size()) {
+            int u = q.front(); q.pop();
+            deg[u] = 0; vis[u] = true;
+            for(int i = 0; i < G[u].size(); ++i) {
+                int v = G[u][i];
+                if(--deg[v] < 2 && !vis[v]) q.push(v);
+            }
+        }
+        long long ans = 0;
+        for(int i = 1; i <= n; ++i) {
+            if(vis[i]) continue;
+            int cnt = 0; long long sum = 0;
+            dfs(i, cnt, sum);
+            if(cnt & 1) ans += sum;
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5439_autoAC.cpp b/HDOJ/5439_autoAC.cpp
new file mode 100644
index 0000000..224e2a2
--- /dev/null
+++ b/HDOJ/5439_autoAC.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <algorithm>
+#include <set>
+#include <cstring>
+#include <queue>
+using namespace std;
+typedef long long ll;
+const int MOD = (int)1e9+7;
+const int INF = (int)1e9;
+const int MAXN = 438744;
+int a[MAXN+5];
+int b[MAXN+5];
+int sum[MAXN+5];
+int dp[MAXN+5];
+int pre[MAXN+5];
+int sz,val;
+int add(int x,int y){
+    x+=y;
+    if(x>=MOD)x-=MOD;
+    return x;
+}
+int po(int x,int n){
+    int ans=1;
+    int temp=x;
+    while(n){
+        if(n&1)ans=(ll)ans*temp%MOD;
+        temp=(ll)temp*temp%MOD;
+        n>>=1;
+    }
+    return ans;
+}
+int main()
+{
+    val=po(2,MOD-2);
+    a[1]=1;
+    a[2]=2;
+    a[3]=2;
+    int sz=3;
+    for(int i=3;;i++){
+        int cnt=a[i];
+        while(cnt){
+        a[++sz]=i;
+        cnt--;
+        if(sz>=MAXN)break;
+        }
+        if(sz>=MAXN)break;
+    }
+    for(int i=1;i<=MAXN;i++){
+        sum[i]=sum[i-1]+a[i];
+        if(sum[i]>=INF)break;
+    }
+    for(int i=1;i<=MAXN;i++){
+        dp[i]=add(dp[i-1],(ll)( add(add(add(pre[i-1],1),pre[i-1]),a[i]) )*a[i]%MOD*i%MOD*val%MOD);
+        pre[i]=add(pre[i-1],a[i]);
+    }
+    int t;scanf("%d",&t);
+    while(t--){
+        int n;scanf("%d",&n);
+        int l=1,r=MAXN;
+        int pos;
+        while(l<=r){
+            int mid=l+r>>1;
+            if(n<=sum[mid]){
+                pos=mid;
+                r=mid-1;
+            }
+            else l=mid+1;
+        }
+        int x=n-sum[pos-1];
+        int ans=add(dp[pos-1],(ll)( add(add(add(pre[pos-1],1),pre[pos-1]),x) )*x%MOD*pos%MOD*val%MOD);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5440_autoAC.cpp b/HDOJ/5440_autoAC.cpp
new file mode 100644
index 0000000..cde09bb
--- /dev/null
+++ b/HDOJ/5440_autoAC.cpp
@@ -0,0 +1,145 @@
+#include <cstdio>
+#include <cstring>
+#include <set>
+#include <map>
+#include <vector>
+#include <queue>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+const int maxn = 1 * 1e5 + 5;
+ll S;
+int N, M, L[10], X[10], head, rear, ans;
+map<ll, int> C;
+set<ll> T;
+struct State {
+    ll s;
+    int f, c;
+    State(ll s = 0, int f = 0, int c = 0): s(s), f(f), c(c) {}
+}Q[maxn], cur;
+inline ll idx(int* c) {
+    ll ret = 0;
+    for (int i = 0; i < 12; i++)
+        ret = ret * (N+1) + c[i];
+    return ret;
+}
+inline void reidx(ll s, int* c) {
+    for (int i = 11; i >= 0; i--) {
+        c[i] = s % (N+1);
+        s /= (N+1);
+    }
+}
+void init () {
+    C.clear();
+    T.clear();
+    scanf("%d%d", &N, &M);
+    int x, cnt[15];
+    memset(cnt, 0, sizeof(cnt));
+    for (int i = 1; i <= N; i++) {
+        scanf("%d", &x);
+        if (x == 12) x = 0;
+        cnt[x]++;
+    }
+    S = idx(cnt);
+    for (int i = 0; i < M; i++)
+        scanf("%d%d", &L[i], &X[i]);
+}
+bool dfs1 (int d, int* c, int* t, int n, int m, int v) {
+    if (d > 12 || n > m) return false;
+    if (n == 0 && m == 0) {
+        ll tmp = idx(t);
+        if (tmp == S) {
+            ans = cur.c + 1;
+            return true;
+        }
+        if (!C.count(tmp)) {
+            C[tmp] = cur.c + 1;
+            if (cur.c < 4) Q[rear++] = State(tmp, v, cur.c+1);
+        }
+        return false;
+    }
+    for (int i = min(c[d], n); i >= 0; i--) {
+        if (n-i > m-c[d]) break;
+        t[(d-X[v]+12)%12] += i;
+        t[d] += (c[d] - i);
+        if (dfs1(d+1, c, t, n-i, m-c[d], v)) return true;
+        t[(d-X[v]+12)%12] -= i;
+        t[d] -= (c[d] - i);
+    }
+    return false;
+}
+bool dfs2 (int d, int* c, int* t, int n, int m, int v) {
+    if (d > 12 || n > m) return false;
+    if (n == 0 && m == 0) {
+        ll tmp = idx(t);
+        if (C.count(tmp)) {
+            ans = C[tmp] + cur.c + 1;
+            return true;
+        }
+        if (!T.count(tmp) && cur.c < 2) {
+            T.insert(tmp);
+            Q[rear++] = State(tmp, v, cur.c+1);
+        }
+        return false;
+    }
+    for (int i = min(c[d], n); i >= 0; i--) {
+        if (n-i > m-c[d]) break;
+        t[(d+X[v]+12)%12] += i;
+        t[d] += (c[d] - i);
+        if (dfs2(d+1, c, t, n-i, m-c[d], v)) return true;
+        t[(d+X[v]+12)%12] -= i;
+        t[d] -= (c[d] - i);
+    }
+    return false;
+}
+int bfs() {
+    int cnt[15], pos[15];
+    memset(cnt, 0, sizeof(cnt));
+    cnt[0] = N;
+    ll k = idx(cnt);
+    if (S == k) return 0;
+    C[k] = 0;
+    head = rear = 0;
+    for (int i = 0; i < M; i++) {
+        int x = (-X[i] + 12) % 12;
+        cnt[x] += L[i];
+        cnt[0] -= L[i];
+        ll tmp = idx(cnt);
+        if (!C.count(tmp)) {
+            if (tmp == S) return 1;
+            Q[rear++] = State(tmp, i, 1);
+            C[tmp] = 1;
+        }
+        cnt[x] -= L[i];
+        cnt[0] += L[i];
+    }
+    while (head < rear) {
+        cur = Q[head++];
+        reidx(cur.s, cnt);
+        for (int i = M-1; i >= cur.f; i--) {
+            memset(pos, 0, sizeof(pos));
+            if (dfs1(0, cnt, pos, L[i], N, i))
+                return ans;
+        }
+    }
+    head = rear = 0;
+    Q[rear++] = State(S, 0, 0);
+    while (head < rear) {
+        cur = Q[head++];
+        reidx(cur.s, cnt);
+        for (int i = M-1; i >= cur.f; i--) {
+            memset(pos, 0, sizeof(pos));
+            if (dfs2(0, cnt, pos, L[i], N, i)) return ans;
+        }
+    }
+    return -1;
+}
+int main () {
+    int cas;
+    scanf("%d", &cas);
+    while (cas--) {
+        init();
+        printf("%d\n", bfs());
+    }
+    return 0;
+}
diff --git a/HDOJ/5441_autoAC.cpp b/HDOJ/5441_autoAC.cpp
new file mode 100644
index 0000000..7b698e0
--- /dev/null
+++ b/HDOJ/5441_autoAC.cpp
@@ -0,0 +1,78 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#define MAX 20007
+using namespace std;
+int fa[MAX],num[MAX],t,n,m,q,pp[MAX];
+struct Query
+{
+    int x,id;
+    bool operator < ( const Query& a )const 
+    {
+        return x < a.x;
+    }
+}a[MAX];
+struct Edge
+{
+    int u,v,w;
+    bool operator < ( const Edge& a ) const 
+    {
+        return w < a.w;
+    }
+}e[MAX*5];
+void init ( )
+{
+    for ( int i = 1 ; i <= n ; i++ )
+    {
+        num[i] = 1;
+        fa[i] = i;
+    }
+}
+int _find ( int x )
+{
+    return fa[x] == x? x : fa[x] = _find ( fa[x] );
+}
+void _union ( int x , int y )
+{
+    x = _find ( x );
+    y = _find ( y );
+    if ( y < x ) swap ( x , y );
+    fa[y] = x;
+    num[x] += num[y];
+}
+int main ( )
+{
+    scanf ( "%d" ,&t );
+    while ( t-- )
+    {
+        int ans = 0;
+        scanf ( "%d%d%d" , &n , &m , &q );
+        init ( ); 
+        for ( int i = 0 ; i < m ; i++ )
+            scanf ( "%d%d%d" , &e[i].u , &e[i].v , &e[i].w );
+        sort ( e , e+m );
+        int j = 0;
+        for ( int i = 0 ; i < q ; i++ )
+        {
+            a[i].id = i;
+            scanf ( "%d" , &a[i].x );
+        }
+        sort ( a , a+q );
+        for ( int i = 0 ; i < q ; i++ )
+        {
+            while ( j < m && e[j].w <= a[i].x )
+            {
+                int u = _find ( e[j].u );
+                int v = _find ( e[j].v );
+                j++;
+                if ( u == v ) continue;
+                ans += (num[u]+num[v])*(num[u]+num[v]-1)-num[u]*(num[u]-1) - num[v]*(num[v]-1);
+                _union ( u , v );
+            }
+            pp[a[i].id] = ans;
+        }
+        for ( int i = 0 ; i < q ; i++ )
+            printf ( "%d\n" , pp[i] );
+    }
+}
diff --git a/HDOJ/5442_autoAC.cpp b/HDOJ/5442_autoAC.cpp
new file mode 100644
index 0000000..e9981c5
--- /dev/null
+++ b/HDOJ/5442_autoAC.cpp
@@ -0,0 +1,90 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#include<cstdio>
+using namespace std;
+#define maxn 200007
+int wwa[maxn],wwb[maxn],wwv[maxn],wws[maxn];
+int cmp(int *r,int a,int b,int l){
+    return r[a]==r[b]&&r[a+l]==r[b+l];
+}
+void da(int *r,int *sufix,int n,int m){
+    int i,j,p,*x=wwa,*y=wwb,*t;
+    for(i=0;i<m;i++)wws[i]=0;
+    for(i=0;i<n;i++)wws[x[i]=r[i]]++;
+    for(i=1;i<m;i++)wws[i]+=wws[i-1];
+    for(i=n-1;i>=0;i--)sufix[--wws[x[i]]]=i;
+    for(j=1,p=1;p<n;j*=2,m=p){
+        for(p=0,i=n-j;i<n;i++)y[p++]=i;
+        for(i=0;i<n;i++)
+            if(sufix[i]>=j)
+                y[p++]=sufix[i]-j;
+        for(i=0;i<n;i++)wwv[i]=x[y[i]];
+        for(i=0;i<m;i++)wws[i]=0;
+        for(i=0;i<n;i++)wws[wwv[i]]++;
+        for(i=1;i<m;i++)wws[i]+=wws[i-1];
+        for(i=n-1;i>=0;i--)
+            sufix[--wws[wwv[i]]]=y[i];
+        for(t=x,x=y,y=t,p=1,x[sufix[0]]=0,i=1;i<n;i++)
+            x[sufix[i]]=cmp(y,sufix[i-1],sufix[i],j)?p-1:p++;
+    }
+    return;
+}
+int r[maxn];
+int rank1[maxn],height[maxn],sufix[maxn];
+void calheight(int *r,int *sufix,int n){
+    int i,j,k=0;
+    for(i=0;i<=n;i++) rank1[sufix[i]]=i;
+    for(i=0;i<n;height[rank1[i++]]=k)
+        for(k?k--:0,j=sufix[rank1[i]-1];r[i+k]==r[j+k];k++);
+    return;
+}
+struct Node{
+    int p,c;
+};
+int comp(Node a,Node b){
+    if(a.p == b.p) return a.c < b.c;
+    return a.p < b.p;
+}
+Node ans[maxn];
+char word[maxn];
+int main(){
+    int t,n;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        scanf("%s",word);
+        for(int i = 0;i < n; i++){
+            r[i]=r[i+n] = word[i];
+        }
+        int len =n*4+1;
+        r[n*2] = '#';
+        for(int i = 0;i < n; i++){
+            r[i+n*2+1] = r[i+n*3+1] = word[n-i-1];
+        }
+        r[len] = 0;
+        da(r,sufix,len+1,328);
+        calheight(r,sufix,len);
+        int cnt = 0;
+        ans[cnt++].p = sufix[len];
+        for(int i = len-1;i > 1; i--){
+            if(height[i+1] < n) break;
+            if(sufix[i]>=n&&sufix[i]<=n*2) continue;
+            if(sufix[i]>=n*3+1)continue;
+            ans[cnt++].p = sufix[i];
+        }
+        for(int i = 0;i < cnt; i++){
+            if(ans[i].p > 2*n){
+                ans[i].c =1;
+                ans[i].p = n-(ans[i].p-2*n-1);
+            }
+            else {
+                ans[i].p++;
+                ans[i].c =  0;
+            }
+        }
+        sort(ans,ans+cnt,comp);
+        printf("%d %d\n",ans[0].p,ans[0].c);
+    }
+    return 0;
+}
diff --git a/HDOJ/5443_autoAC.cpp b/HDOJ/5443_autoAC.cpp
new file mode 100644
index 0000000..60bfa53
--- /dev/null
+++ b/HDOJ/5443_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <queue>
+#include <set>
+#include <vector>
+using namespace std;
+#define pr(x) cout << #x << " = " << x << "  "
+#define prln(x) cout << #x << " = " << x << endl
+const int N = 1e3 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
+int n, q, dp[2][N][20];
+int RMQ(int l, int r) {
+    int k = 31 - __builtin_clz(r - l + 1);
+    int Max = max(dp[1][l][k], dp[1][r - (1 << k) + 1][k]);
+    return Max;
+}
+int main() {
+    int t; scanf("%d", &t);
+    while(t--) {
+        scanf("%d", &n);
+        for(int i = 1; i <= n; ++i) {
+            scanf("%d", &dp[0][i][0]);
+            dp[1][i][0] = dp[0][i][0];
+        }
+        for(int j = 1; (1 << j) <= n; ++j) {
+            for(int i = 1; i + (1 << j) - 1 <= n; ++i) {
+                dp[0][i][j] = min(dp[0][i][j - 1],
+                                  dp[0][i + (1 << j - 1)][j - 1]);
+                dp[1][i][j] = max(dp[1][i][j - 1],
+                                  dp[1][i + (1 << j - 1)][j - 1]);
+            }
+        }
+        scanf("%d", &q);
+        while(q--) {
+            int x, y; scanf("%d%d", &x, &y);
+            printf("%d\n", RMQ(x, y));
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5444_autoAC.cpp b/HDOJ/5444_autoAC.cpp
new file mode 100644
index 0000000..58ec5fb
--- /dev/null
+++ b/HDOJ/5444_autoAC.cpp
@@ -0,0 +1,80 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int maxn = 1100;
+struct tree{
+    int v, l, r, f;
+    tree(){}
+    tree(int v, int l, int r, int f):v(v), l(l), r(r), f(f){}
+} t[maxn<<2];
+int T, n;
+int pt, sz;
+int st[maxn];
+int a[maxn];
+int ps[maxn];
+bool v[maxn];
+void work(int x){
+    int pos = 0, ed = ps[x];
+    while(1){
+        if (pt > ed) break;
+        v[a[pt]] = true;
+        if (t[pos].v > a[pt]){
+            if (t[pos].r == -1){
+                st[a[pt]] = sz;
+                t[sz] = tree(a[pt++], -1, -1, pos);
+                t[pos].r = sz;
+                pos = sz++;
+            }
+            else pos = t[pos].r;
+        }
+        else{
+            if (t[pos].l == -1){
+                st[a[pt]] = sz;
+                t[sz] = tree(a[pt++], -1, -1, pos);
+                t[pos].l = sz;
+                pos = sz++;
+            }
+            else pos = t[pos].l;
+        }
+    }
+}
+char s[1100];
+void output(int x){
+    int len = 0, px;
+    while(1){
+        px = x;
+        x = t[x].f;    
+        if (x == -1) break;
+        if (t[x].l == px) s[len++] = 'W';
+        else s[len++] = 'E';
+    }
+    for (int i = 0, j = len-1; i < j; i++, j--)
+        swap(s[i], s[j]);
+    s[len] = 0;
+    printf("%s\n", s);
+}
+int main()
+{
+    scanf("%d", &T);
+    while(T--){
+        scanf("%d", &n);
+        for (int i = 0; i < n; i++){
+            v[i+1] = false;
+            scanf("%d", &a[i]);
+            ps[a[i]] = i;
+        }
+        sz = 0, pt = 1;
+        t[sz++] = tree(a[0], -1, -1, -1);
+        v[a[0]] = true;
+        for (int i = 1; i <= n; i++)
+            if (!v[i]){ work(i); }
+        int q, qq;
+        scanf("%d", &q);
+        for (int i = 0; i < q; i++){
+            scanf("%d", &qq);
+            output(st[qq]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5445_autoAC.cpp b/HDOJ/5445_autoAC.cpp
new file mode 100644
index 0000000..0053e56
--- /dev/null
+++ b/HDOJ/5445_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <set>
+#include <map>
+#include <queue>
+#include <vector>
+#include <functional>
+#include <cassert>
+#include <bitset>
+using namespace std;
+typedef long long ll;
+typedef unsigned long long ull;
+#define ff(i, n) for(int i=0,END=(n);i<END;i++)
+#define fff(i, n, m) for(int i=(n),END=(m);i<=END;i++)
+#define dff(i, n, m) for(int i=(n),END=(m);i>=END;i--)
+#define travel(e, u) for(int e=first[u], v=vv[first[u]]; ~e; e=nxt[e])
+#define mid ((l+r)/2)
+#define bit(n) (1ll<<(n))
+#define clr(a, b) memset(a, b, sizeof(a))
+#define debug(x) cout << #x << " = " << x << endl;
+#define ls (rt << 1)
+#define rs (ls | 1)
+#define lson l, m, ls
+#define rson m + 1, r, rs
+void work();
+int main() {
+    work();
+    return 0;
+}
+const int maxn = 222;
+const int maxv = 5e4 + 5 + maxn;
+const int inf = 0x3f3f3f3f;
+int n, m, p;
+int dp[maxv];
+void zero_one_pack(int v, int c, int V) {
+    dff(i, V, v) {
+        dp[i] = min(dp[i], dp[i - v] + c);
+    }
+}
+void zero_one_pack2(int v, int c, int V) {
+    dff(i, V, v) {
+        dp[i] = max(dp[i], dp[i - v] + c);
+    }
+}
+void multi_pack(int v, int c, int num, int V, bool flag = true) {
+    int k = 1;
+    while (num) {
+        if (flag)
+            zero_one_pack(v * k, c * k, V);
+        else
+            zero_one_pack2(v * k, c * k, V);
+        num -= k;
+        k += k;
+        if (k > num) k = num;
+    }
+}
+void input() {
+    scanf("%d%d%d", &n, &m, &p);
+    clr(dp, inf); dp[0] = 0;
+    ff (i, n) {
+        int v, c, num;
+        scanf("%d%d%d", &v, &c, &num);
+        multi_pack(v, c, num, p + 100);
+    }
+    int V = *min_element(dp + p, dp + p + 100);
+    clr(dp, 0);
+    ff (i, m) {
+        int v, c, num;
+        scanf("%d%d%d", &v, &c, &num);
+        multi_pack(c, v, num, 50000, false);
+    }
+    int ans = inf;
+    dff(i, 50000, 0) if (dp[i] >= V) {
+        ans = min(ans, i);
+    }
+    if (ans == inf) {
+        puts("TAT");
+    } else {
+        printf("%d\n", ans);
+    }
+}
+void work() {
+    int T; scanf("%d", &T);
+    fff(cas, 1, T) {
+        input();
+    }
+}
diff --git a/HDOJ/5446_autoAC.cpp b/HDOJ/5446_autoAC.cpp
new file mode 100644
index 0000000..d432a73
--- /dev/null
+++ b/HDOJ/5446_autoAC.cpp
@@ -0,0 +1,81 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<cassert>
+using namespace std;
+#define debug 0
+const int maxn = 101000;
+typedef long long ll;
+ll A[maxn], inv[maxn];
+int res[20];
+int p[20];
+void gcd(ll a, ll b, ll d, ll& x, ll& y){
+    if (!b) { d = a; x = 1; y = 0; }
+    else{ gcd(b, a%b, d, y, x); y -= x*(a/b); }
+}
+int cal(long long n, long long m, int p){
+    A[0] = A[1] = 1;
+    inv[0] = inv[1] = 1;
+    for (int i = 2; i <= p; i++){
+        inv[i] = (long long)(p - p/i) * inv[p % i] % p;
+        A[i] = A[i-1] * i % p;
+    }
+    for (int i = 2; i < p; i++){
+        inv[i] = inv[i] * inv[i-1] % p;
+    }
+    if (debug){
+        for (int i = 0; i < p; i++){
+            assert(inv[i] * A[i] % p == 1);
+            printf("%lld %lld\n", inv[i], A[i]);
+        }
+    }
+    int ret = 1;
+    while(n&&m){
+        int a = n % p, b = m % p;    
+        if (a < b) return 0;
+        n /= p, m /= p;
+        ret = (long long)ret * A[a] % p * inv[b] % p * inv[a-b] % p;
+    }
+    return ret;
+}
+ll mul(ll a, ll b, ll p){
+    ll ret = 0;
+    for (; a; a>>=1){
+        if (a&1){
+            ret += b;
+            if (ret >= p) ret -= p;
+        }
+        b <<= 1;
+        if (b >= p) b -= p;
+    }
+    return ret;
+}
+ll crt(int n, int* a, int *m){
+    ll M = 1, d, y, x = 0;
+    for (int i = 0; i < n; i++) M *= m[i];
+    for (int i = 0; i < n; i++){
+        ll w = M / m[i];
+        gcd(m[i], w, d, d, y);
+        int sign;
+        if (y < 0) sign = -1;
+        else sign = 1;
+        x = (x + mul(y*sign, w*a[i]%M, M) * sign) % M;
+    }
+    return (x + M) % M;
+}
+int T;
+int main()
+{
+    scanf("%d", &T);
+    while(T--){
+        ll n, m; int k;
+        scanf("%I64d %I64d %d", &n, &m, &k);
+        for (int i = 0; i < k; i++){
+            scanf("%d", &p[i]);
+            res[i] = cal(n, m, p[i]);
+        }
+        long long ans = crt(k, res, p);
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5448_autoAC.cpp b/HDOJ/5448_autoAC.cpp
new file mode 100644
index 0000000..409793a
--- /dev/null
+++ b/HDOJ/5448_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <cstdio>
+typedef long long LL;
+const int maxn = 100010, mod = 1000000007, inv2 = 500000004;
+int t, n, pw1[maxn], pw2[maxn], x, y, pre1x, pre1y, pre2x, pre2y, ans;
+int mod_add(int x, int y)
+{
+    x += y;
+    if(x >= mod)
+        x -= mod;
+    return x;
+}
+int mod_sub(int x, int y)
+{
+    x -= y;
+    if(x < 0)
+        x += mod;
+    return x;
+}
+int det(int x1, int y1, int x2, int y2)
+{
+    return mod_sub((LL)x1 * y2 % mod, (LL)x2 * y1 % mod);
+}
+int main()
+{
+    scanf("%d", &t);
+    pw1[0] = 1;
+    for(int i = 1; i < maxn; ++i)
+        pw1[i] = (LL)pw1[i - 1] * 2 % mod; 
+    pw2[0] = 1;
+    for(int i = 1; i < maxn; ++i)
+        pw2[i] = (LL)pw2[i - 1] * inv2 % mod; 
+    while(t--)
+    {
+        scanf("%d", &n);
+        pre1x = pre1y = pre2x = pre2y = ans = 0;
+        for(int i = 1; i <= n; ++i)
+        {
+            scanf("%d%d", &x, &y);
+            ans = mod_add(ans, (LL)pw1[i - 1] * det(x, y, pre2x, pre2y) % mod);
+            ans = mod_add(ans, (LL)(i == n ? inv2 : pw1[n - i - 1]) * det(pre1x, pre1y, x, y) % mod);
+            pre1x = mod_add(pre1x, (LL)x * pw1[i] % mod); 
+            pre1y = mod_add(pre1y, (LL)y * pw1[i] % mod); 
+            pre2x = mod_add(pre2x, (LL)x * pw2[i] % mod); 
+            pre2y = mod_add(pre2y, (LL)y * pw2[i] % mod); 
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5449_autoAC.cpp b/HDOJ/5449_autoAC.cpp
new file mode 100644
index 0000000..a50e668
--- /dev/null
+++ b/HDOJ/5449_autoAC.cpp
@@ -0,0 +1,95 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+const int maxn = 50005;
+int N, E, first[maxn], jump[maxn<<1], linker[maxn<<1];
+ll sz[maxn], up[maxn], dn[maxn], f[20][maxn], dep[maxn];
+void addEdge(int u, int v) {
+    jump[E] = first[u];
+    linker[E] = v;
+    first[u] = E++;
+}
+void dfs (int u, int far, int d) {
+    sz[u] = 1;
+    dep[u] = d;
+    f[0][u] = far;
+    for (int i = first[u]; i + 1; i = jump[i]) {
+        int v = linker[i];
+        if (v == far) continue;
+        dfs(v, u, d + 1);
+        sz[u] += sz[v];
+    }
+}
+void dfs (int u) {
+    if (f[0][u] != -1) {
+        up[u] = up[f[0][u]] + 2 * sz[u] - 1;
+        dn[u] = dn[f[0][u]] + 2 * (N-sz[u]) - 1;
+    } else
+        up[u] = dn[u] = 0;
+    for (int i = first[u]; i + 1; i = jump[i]) {
+        int v = linker[i];
+        if (v == f[0][u]) continue;
+        dfs(v);
+    }
+}
+int lca(int u, int v) {
+    if (dep[u] < dep[v]) swap(u, v);
+    int d = dep[u] - dep[v];
+    for (int i = 0; i < 20; i++) if ((1<<i)&d)
+        u = f[i][u];
+    if (u == v) return u;
+    for (int i = 19; i >= 0; i--) {
+        if (f[i][u] != f[i][v]) {
+            u = f[i][u];
+            v = f[i][v];
+        }
+    }
+    return f[0][u];
+}
+void init () {
+    E = 0;
+    memset(first, -1, sizeof(first));
+    int u, v;
+    scanf("%d", &N);
+    for (int i = 1; i < N; i++) {
+        scanf("%d%d", &u, &v);
+        addEdge(u, v);
+        addEdge(v, u);
+    }
+    dfs(0, -1, 0);
+    dfs(0);
+    for (int k = 1; k < 20; k++) {
+        for (int i = 0; i < N; i++)
+            f[k][i] = f[k-1][f[k-1][i]];
+    }
+}
+ll get (int u, int v) {
+    int l = lca(u, v);
+    return up[u] - up[l] + dn[v] - dn[l];
+}
+void solve () {
+    int q, p, u, v;
+    scanf("%d", &q);
+    while (q--) {
+        ll ans = 0;
+        scanf("%d%d", &p, &u);
+        while (p--) {
+            scanf("%d", &v);
+            ans += get(u, v);
+            u = v;
+        }
+        printf("%lld.0000\n", ans);
+    }
+}
+int main () {
+    int cas;
+    scanf("%d", &cas);
+    while (cas--) {
+        init();
+        solve();
+        if (cas) printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5450_autoAC.cpp b/HDOJ/5450_autoAC.cpp
new file mode 100644
index 0000000..d7ac36c
--- /dev/null
+++ b/HDOJ/5450_autoAC.cpp
@@ -0,0 +1,91 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int maxn = 105;
+const int maxm = 15;
+const int maxs = 200000;
+const int mod = 10007;
+int N, P, dp[maxn][maxs];
+bool exist[maxn];
+int encode (int* c, int n) {
+    int ret = 0;
+    for (int i = 0; i < n; i++)
+        ret = ret * 3 + c[i];
+    return ret;
+}
+void decode(int* c, int n, int s) {
+    for (int i = n-1; i >= 0; i--) {
+        c[i] = s % 3;
+        s /= 3;
+    }
+}
+void move(int* c, int n) {
+    for (int i = n; i > 0; i--)
+        c[i] = c[i-1];
+    c[0] = 0;
+}
+void init () {
+    scanf("%d%d", &N, &P);
+    memset(exist, false, sizeof(exist));
+    int k, x;
+    scanf("%d", &k);
+    for (int i = 0; i < k; i++) {
+        scanf("%d", &x);
+        exist[x] = true;
+    }
+}
+void add(int& u, int v) { u = (u + v) % mod; }
+int solve () {
+    int n = P + 2, cur[maxm], nxt[maxm], idx[3];
+    idx[0] = 1, idx[1] = P, idx[2] = P + 2;
+    memset(dp, 0, sizeof(dp));
+    for (int i = 0; i < n; i++) cur[i] = 2;
+    int e = encode(cur, n);
+    dp[0][e] = 1;
+    for (int i = 0; i < N; i++) {
+        for (int s = 0; s <= e; s++) {
+            if (dp[i][s] == 0) continue;
+            decode(cur, n, s);
+            memcpy(nxt, cur, sizeof(cur));
+            move(nxt, n);
+            if (exist[i+1]) {
+                nxt[0] = 2;
+                if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]);
+                continue;
+            }
+            if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]);
+            nxt[0] = 1;
+            for (int j = 0; j < 3; j++) {
+                int& v = nxt[idx[j]];
+                if (v < 2) {
+                    v++;
+                    if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]);
+                    v--;
+                }
+            }
+            nxt[0] = 2;
+            for (int j = 0; j < 3; j++) {
+                for (int k = j+1; k < 3; k++) {
+                    int& u = nxt[idx[j]];
+                    int& v = nxt[idx[k]];
+                    if (u < 2 && v < 2) {
+                        u++, v++;
+                        if (nxt[n] == 2) add(dp[i+1][encode(nxt, n)], dp[i][s]);
+                        u--, v--;
+                    }
+                }
+            }
+        }
+    }
+    return dp[N][e];
+}
+int main () {
+    int cas;
+    scanf("%d", &cas);
+    for (int kcas = 1; kcas <= cas; kcas++) {
+        init();
+        printf("Case #%d: %d\n", kcas, solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/5451_autoAC.cpp b/HDOJ/5451_autoAC.cpp
new file mode 100644
index 0000000..d7d1c84
--- /dev/null
+++ b/HDOJ/5451_autoAC.cpp
@@ -0,0 +1,74 @@
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+#define LL long long
+#define FOR(i,x,y)  for(int i = x;i < y;i ++)
+#define IFOR(i,x,y) for(int i = x;i > y;i --)
+#define N 2
+int MOD;
+LL p;
+struct Matrix{
+    LL mat[N][N];
+    Matrix operator *(const Matrix& a) const{
+        Matrix c;
+        memset(c.mat,0,sizeof(c.mat));
+        for(int i=0;i<N;i++){
+            for(int j=0;j<N;j++){
+                for(int k=0;k<N;k++){
+                    LL ssss = ((mat[i][k]*a.mat[k][j])%MOD+MOD)%MOD;
+                    c.mat[i][j] = ((c.mat[i][j]+ssss)%MOD+MOD)%MOD;
+                }
+            }
+        }
+        return c;
+    }
+    Matrix operator ^(LL n) const{
+        Matrix c;
+        for(int i=0;i<N;i++){
+            for(int j=0;j<N;j++){
+                c.mat[i][j]=(i==j);
+            }
+        }
+        Matrix a = *this;
+        while(n)
+        {
+            if(n%2) c=c*a;
+            a=a*a;
+            n=n>>1;
+        }
+        return c;
+    }
+};
+Matrix ss;
+LL quickpow(LL a,LL n,int m){
+    LL ret = 1;
+    while(n){
+        if(n&1) ret = (ret*a)%m;
+        a = (a*a)%m;
+        n >>= 1;
+    }
+    return ret;
+}
+int main(){
+    int T,tCase = 0;
+    scanf("%d",&T);
+    ss.mat[0][0] = 10; ss.mat[0][1] = -1; ss.mat[1][0] = 1; ss.mat[1][1] = 0;
+    while(T--){
+        printf("Case #%d: ",++tCase);
+        LL x;
+        scanf("%I64d%d",&x,&MOD);
+        p = (MOD-1)*(MOD+1);
+        LL r = quickpow(2,x,p);
+        Matrix st;
+        st.mat[0][0] = 10; st.mat[0][1] = -1; st.mat[1][0] = 1; st.mat[1][1] = 0;
+        st = st^r;
+        LL aaaa = (((st.mat[0][0]*10)%MOD+MOD)%MOD + ((st.mat[0][1]*2)%MOD+MOD)%MOD)%MOD;
+        if(!aaaa){
+            printf("%d\n",MOD-1);
+        }
+        else
+            printf("%I64d\n",aaaa-1);
+    }
+    return 0;
+}
diff --git a/HDOJ/5452_autoAC.cpp b/HDOJ/5452_autoAC.cpp
new file mode 100644
index 0000000..74e6b90
--- /dev/null
+++ b/HDOJ/5452_autoAC.cpp
@@ -0,0 +1,123 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define INF 0x3f3f3f3f
+const int maxn = 80010;
+const int maxm = 26;
+int dp[2*maxn][maxm];  
+bool vis[maxn];
+struct edge
+{
+    int from, to;
+    int next;
+} e[2*maxn];
+int tot,head[maxn];
+int cnt;
+int num[maxn];
+void init()
+{
+    memset(head,-1,sizeof(head));
+    memset(vis,false,sizeof(vis));
+    memset(num,0,sizeof(num));
+    cnt = 0;
+}
+void addedge(int u, int v)
+{
+    e[cnt].from = u;
+    e[cnt].to = v;
+    e[cnt].next = head[u];
+    head[u] = cnt++;
+}
+int ver[2*maxn], R[2*maxn], first[maxn];
+void dfs(int u ,int dep)
+{
+    vis[u] = true;
+    ver[++tot] = u;
+    first[u] = tot;
+    R[tot] = dep;
+    for(int k=head[u]; k!=-1; k=e[k].next)
+        if( !vis[e[k].to] )
+        {
+            int v = e[k].to;
+            dfs(v, dep+1);
+            ver[++tot] = u;
+            R[tot] = dep;
+        }
+}
+void ST(int n)
+{
+    for(int i=1; i<=n; i++)
+        dp[i][0] = i;
+    for(int j=1; (1<<j)<=n; j++)
+    {
+        for(int i=1; i+(1<<j)-1<=n; i++)
+        {
+            int a = dp[i][j-1] , b = dp[i+(1<<(j-1))][j-1];
+            dp[i][j] = R[a]<R[b]?a:b;
+        }
+    }
+}
+int RMQ(int l,int r)
+{
+    int k=0;
+    while((1<<(k+1))<=r-l+1)
+        k++;
+    int a = dp[l][k], b = dp[r-(1<<k)+1][k]; 
+    return R[a]<R[b]?a:b;
+}
+int LCA(int u ,int v)
+{
+    int x = first[u] , y = first[v];
+    if(x > y) swap(x,y);
+    int res = RMQ(x,y);
+    return ver[res];
+}
+int DFS(int u,int fa)
+{
+    for(int i = head[u]; ~i; i = e[i].next)
+    {
+        int v = e[i].to;
+        if(v == fa)
+            continue;
+        DFS(v, u);
+        num[u]+=num[v];
+    }
+    return 0;
+}
+int main()
+{
+    int t;
+    int cas = 0;
+    int n, m;
+    scanf("%d",&t);
+    while(t--)
+    {
+        init();
+        scanf("%d%d",&n,&m);
+        int u, v;
+        for(int i = 0; i < n-1; i++)
+        {
+            scanf("%d%d",&u,&v);
+            addedge(u, v);
+            addedge(v, u);
+        }
+        for(int i = n; i <= m; i++)
+        {
+            scanf("%d%d",&u,&v);
+            int tt = LCA(u, v);
+            num[u]++;
+            num[v]++;
+            num[tt]-=2;
+        }
+        DFS(1, 1);
+        int ans = INF;
+        for(int i = 2; i <= n; i++)
+        {
+            ans = min(ans, num[i]+1);
+        }
+        printf("Case #%d: %d\n",++cas,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5454_autoAC.cpp b/HDOJ/5454_autoAC.cpp
new file mode 100644
index 0000000..31b7067
--- /dev/null
+++ b/HDOJ/5454_autoAC.cpp
@@ -0,0 +1,157 @@
+#include<cstdio>  
+#include<algorithm>  
+#include<cstring>  
+using namespace std;  
+typedef __int64 LL;  
+const int maxn = 300005;  
+struct tree  
+{  
+    LL suml[maxn << 2], sumr[maxn << 2], sum[maxn << 2];  
+    LL add[maxn << 2];  
+    inline void pushup(int id, int L, int R)  
+    {  
+        LL mid = L + R >> 1;  
+        sum[id] = sum[id << 1] + sum[id << 1 | 1];  
+        suml[id] = suml[id << 1] + (mid - L + 1)*sum[id << 1 | 1] + suml[id << 1 | 1];  
+        sumr[id] = sumr[id << 1 | 1] + sumr[id << 1] + (R - mid)*sum[id << 1];  
+    }  
+    inline void pushdown(int id, int L, int R)  
+    {  
+        int mid = L + R >> 1;  
+        if (add[id])  
+        {  
+            LL ln = mid - L + 1;  
+            LL rn = R - mid;  
+            add[id << 1] += add[id];  
+            add[id << 1 | 1] += add[id];  
+            sum[id << 1] += add[id] * ln;  
+            sum[id << 1 | 1] += add[id] * rn;  
+            suml[id << 1] += add[id] * (1 + ln)*ln >> 1;  
+            suml[id << 1 | 1] += add[id] * (1 + rn)*rn >> 1;  
+            sumr[id << 1] += add[id] * (1 + ln)*ln >> 1;  
+            sumr[id << 1 | 1] += add[id] * (1 + rn)*rn >> 1;  
+            add[id] = 0;  
+        }  
+    }  
+    void build()  
+    {  
+        memset(sum, 0, sizeof(sum));  
+        memset(suml, 0, sizeof(suml));  
+        memset(sumr, 0, sizeof(sumr));  
+        memset(add, 0, sizeof(add));  
+    }  
+    LL queL(int id, int L, int R, int l, int r)  
+    {  
+        if (l <= L&&R <= r) return (L - l)*sum[id] + suml[id];  
+        else  
+        {  
+            pushdown(id, L, R);  
+            int mid = L + R >> 1;  
+            LL res = 0;  
+            if (l <= mid) res += queL(id << 1, L, mid, l, r);  
+            if (mid<r) res += queL(id << 1 | 1, mid + 1, R, l, r);  
+            return res;  
+        }  
+    }  
+    LL queR(int id, int L, int R, int l, int r)  
+    {  
+        if (l <= L&&R <= r) return (r - R)*sum[id] + sumr[id];  
+        else  
+        {  
+            pushdown(id, L, R);  
+            int mid = L + R >> 1;  
+            LL res = 0;  
+            if (l <= mid) res += queR(id << 1, L, mid, l, r);  
+            if (mid<r) res += queR(id << 1 | 1, mid + 1, R, l, r);  
+            return res;  
+        }  
+    }  
+    LL que(int id, int L, int R, int l, int r)  
+    {  
+        if (l <= L&&R <= r) return sum[id];  
+        else  
+        {  
+            pushdown(id, L, R);  
+            int mid = L + R >> 1;  
+            LL res = 0;  
+            if (l <= mid) res += que(id << 1, L, mid, l, r);  
+            if (mid<r) res += que(id << 1 | 1, mid + 1, R, l, r);  
+            return res;  
+        }  
+    }  
+    void op(int id, int L, int R, int l, int r)  
+    {  
+        if (l <= L&&R <= r)  
+        {  
+            LL sn = R - L + 1;  
+            add[id]++;  
+            sum[id] += sn;  
+            suml[id] += (1 + sn)*sn >> 1;  
+            sumr[id] += (1 + sn)*sn >> 1;  
+        }  
+        else  
+        {  
+            pushdown(id, L, R);  
+            int mid = L + R >> 1;  
+            if (l <= mid) op(id << 1, L, mid, l, r);  
+            if (mid<r) op(id << 1 | 1, mid + 1, R, l, r);  
+            pushup(id, L, R);  
+        }  
+    }  
+}tz, tf;  
+int main()  
+{  
+    int T;  
+    scanf("%d", &T);  
+    int ks = 0;  
+    while (T--)  
+    {  
+        printf("Case #%d:\n", ++ks);  
+        tz.build();  
+        tf.build();  
+        int n, m;  
+        scanf("%d %d", &n, &m);  
+        while (m--)  
+        {  
+            int op;  
+            scanf("%d", &op);  
+            if (op == 1)  
+            {  
+                int l, r;  
+                scanf("%d %d", &l, &r);  
+                tf.op(1, 1, n << 1, l, r);  
+            }  
+            else if (op == 2)  
+            {  
+                int l, r;  
+                scanf("%d %d", &l, &r);  
+                l += n;  
+                r += n;  
+                tz.op(1, 1, n << 1, l, r);  
+            }  
+            else  
+            {  
+                int x1, y1, x2, y2;  
+                scanf("%d %d %d %d", &x1, &x2, &y1, &y2);  
+                LL ans = 0;  
+                int A, B, C, D;  
+                A = x1 - y1 + n;  
+                B = x1 - y2 + n;  
+                C = x2 - y2 + n;  
+                D = x2 - y1 + n;  
+                if (D >= max(A, C) + 1) ans += tz.queR(1, 1, n << 1, max(A, C) + 1, D);  
+                if (B <= min(A, C) - 1) ans += tz.queL(1, 1, n << 1, B, min(A, C) - 1);  
+                ans += tz.que(1, 1, n << 1, min(A, C), max(A, C))*(min(y2 - y1, x2 - x1) + 1);  
+                A = x1 + y1;  
+                B = x1 + y2;  
+                C = x2 + y2;  
+                D = x2 + y1;  
+                if (A <= min(B, D) - 1) ans += tf.queL(1, 1, n << 1, A, min(B, D) - 1);  
+                if (C >= max(B, D) + 1) ans += tf.queR(1, 1, n << 1, max(B, D) + 1, C);  
+                ans += tf.que(1, 1, n << 1, min(B, D), max(B, D))*(min(y2 - y1, x2 - x1) + 1);  
+                printf("%I64d\n", ans);  
+            }  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/5455_autoAC.cpp b/HDOJ/5455_autoAC.cpp
new file mode 100644
index 0000000..e9c6d6d
--- /dev/null
+++ b/HDOJ/5455_autoAC.cpp
@@ -0,0 +1,92 @@
+#include<iostream>
+#include<algorithm>
+#include<cstring>
+#include<cstdio>
+#include<cmath>
+#include<queue>
+#include<vector>
+#define LL long long
+#define MAXN 100010
+using namespace std;
+string s1;
+int len,k,fg,cnt,ans,fg2;
+int main(){
+    int T,cas,i;
+    scanf("%d",&T);
+    getchar();
+    for(cas=1;cas<=T;cas++)
+    {
+        char s2[MAXN];
+        getline(cin,s1);
+        len=s1.length();
+        fg=0;
+        for(i=0;i<len;i++)
+        {
+            if(s1[i]=='c')
+            {
+                fg=1;
+                k=i;
+                break;
+            }
+        }
+        if(fg)
+        {
+            cnt=0;
+            for(i=k;i<len;i++)
+            {
+                s2[cnt++]=s1[i];
+            }
+            for(i=0;i<k;i++)
+            {
+                s2[cnt++]=s1[i];
+            }
+        }
+        else
+        {
+            ans=(len+1)/2;
+            printf("Case #%d: %d\n",cas,ans);
+            continue;
+        }
+        ans=1;
+        fg2=1;
+        int shuf=0;
+        for(i=1;i<len;i++)
+        {
+            if(s2[i]=='f')
+            {
+                shuf++;
+            }
+            else
+            {
+                if(s2[i]=='c')
+                {
+                    if(shuf<2)
+                    {
+                        printf("Case #%d: -1\n",cas);
+                        break;
+                    }
+                    else
+                    {
+                        ans++;
+                        shuf=0;
+                    }
+                }
+                else
+                {
+                    printf("Case #%d: -1\n",cas);
+                    break;
+                }
+            }
+        }
+        if(i==len&&shuf<2)
+        {
+            printf("Case #%d: -1\n",cas);
+            continue;
+        }
+        if(i==len)
+        {
+            printf("Case #%d: %d\n",cas,ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5456_autoAC.cpp b/HDOJ/5456_autoAC.cpp
new file mode 100644
index 0000000..3a0b5a4
--- /dev/null
+++ b/HDOJ/5456_autoAC.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <vector>
+#include <set>
+#include <map>
+#include <string>
+#include <list>
+#include <cstdlib>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <bitset>
+#include <cassert>
+#define ALL(a) a.begin(), a.end()
+#define clr(a, x) memset(a, x, sizeof a)
+#define X first
+#define Y second
+#define pb push_back
+#define lowbit(x) (x&(-x))
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1|1
+#define rep1(i,x,y) for(int i=x;i<=y;i++)
+#define rep(i,n) for(int i=0;i<(int)n;i++)
+using namespace std;
+const double eps = 1e-6;
+typedef long long LL;
+typedef long long ll;
+typedef pair<int, int> pii;
+const int oo =0x3f3f3f3f;
+const int N = 510;
+const int cnt[]= {6,2,5,5,4,5,6,3,7,6};
+ll d[N][2][8];
+int M,n;
+bool vis[N][2][8];
+ll dp(int i,int j,int s)
+{
+    if(vis[i][j][s]) return d[i][j][s];
+    vis[i][j][s] = 1;
+    d[i][j][s] = 0;
+    if(i == 0)
+    {
+        return d[i][j][s] = (j==0 && s==7);
+    }
+    rep(p,10) rep(q,10)
+    {
+        int nj = (p-j >= q ? 0 : 1);
+        int a = p, b = q , c = nj*10+p-j-q;
+        if((s&1) && c!=0) continue;
+        if((s&2) && b!=0) continue;
+        int nee = cnt[a]+((s&2) ? 0:cnt[b])+((s&1) ? 0 : cnt[c]);
+        if(nee > i) continue;
+        int vv[8]= {0};
+        rep(t,8)
+        {
+            int ts = 0;
+            if((t&1) && (c>0)) ts|=1;
+            if((t&2) && (b>0)) ts|=2;
+            if((t&4) && (a>0) && nj==0 && i==nee) ts|=4;
+            if(!vv[ts]) d[i][j][s] = (d[i][j][s]+dp(i-nee,nj,s|ts))%M,vv[ts]=1;
+        }
+    }
+    return d[i][j][s];
+}
+int main()
+{
+    int T,kase=1;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d %d",&n,&M);
+        memset(vis,false,sizeof(vis));
+        printf("Case #%d: %I64d\n",kase++,dp(n-3,0,0));
+    }
+    return 0;
+}
diff --git a/HDOJ/5457_autoAC.cpp b/HDOJ/5457_autoAC.cpp
new file mode 100644
index 0000000..69e80c1
--- /dev/null
+++ b/HDOJ/5457_autoAC.cpp
@@ -0,0 +1,340 @@
+#include <algorithm>
+#include <iostream>
+#include <iomanip>
+#include <cstring>
+#include <climits>
+#include <complex>
+#include <fstream>
+#include <cassert>
+#include <cstdio>
+#include <bitset>
+#include <vector>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <ctime>
+#include <set>
+#include <map>
+#include <cmath>
+#include <functional>
+#include <numeric>
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+using namespace std;
+#define eps 1e-9
+#define PI acos(-1.0)
+#define INF 0x3f3f3f3f
+#define LLINF 1LL<<60
+#define speed std::ios::sync_with_stdio(false);
+typedef long long ll;
+typedef unsigned long long ull;
+typedef long double ld;
+typedef pair<ll, ll> pll;
+typedef complex<ld> point;
+typedef pair<int, int> pii;
+typedef pair<pii, int> piii;
+typedef vector<int> vi;
+#define CLR(x,y) memset(x,y,sizeof(x))
+#define CPY(x,y) memcpy(x,y,sizeof(x))
+#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
+#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))
+#define debug(a) cout << #a" = " << (a) << endl;
+#define debugarry(a, n) for (int i = 0; i < (n); i++) { cout << #a"[" << i << "] = " << (a)[i] << endl; }
+#define mp(x,y) make_pair(x,y)
+#define pb(x) push_back(x)
+#define lowbit(x) (x&(-x))
+#define MID(x,y) (x+((y-x)>>1))
+#define ls (idx<<1)
+#define rs (idx<<1|1)
+#define lson ls,l,mid
+#define rson rs,mid+1,r
+template<class T>
+inline bool read(T &n)
+{
+    T x = 0, tmp = 1;
+    char c = getchar();
+    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
+    if(c == EOF) return false;
+    if(c == '-') c = getchar(), tmp = -1;
+    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
+    n = x*tmp;
+    return true;
+}
+template <class T>
+inline void write(T n)
+{
+    if(n < 0)
+    {
+        putchar('-');
+        n = -n;
+    }
+    int len = 0,data[20];
+    while(n)
+    {
+        data[len++] = n%10;
+        n /= 10;
+    }
+    if(!len) data[len++] = 0;
+    while(len--) putchar(data[len]+48);
+}
+const int MAXN=10240;
+const int MAXM=40000;
+struct ISAP
+{
+    struct nedge
+    {
+        int u,v,next;
+        ll c;
+    } e[MAXM*2];
+    int head[MAXN],tot,n;
+    int ss,tt;
+    void Resize(int n)
+    {
+        this->n=n;
+    }
+    void Clearall()
+    {
+        tot=1;
+        CLR(head,0);
+    }
+    void addedge(int u,int v,ll w)
+    {
+        e[++tot].v=v;
+        e[tot].u=u;
+        e[tot].c=w;
+        e[tot].next=head[u];
+        head[u]=tot;
+        e[++tot].v=u;
+        e[tot].u=v;
+        e[tot].c=0;
+        e[tot].next=head[v];
+        head[v]=tot;
+    }
+    int dep[MAXN],gap[MAXN];
+    void bfs()
+    {
+        CLR(dep,-1);
+        CLR(gap,0);
+        queue<int> que;
+        gap[0]=1;
+        dep[tt]=0;
+        que.push(tt);
+        while(!que.empty())
+        {
+            int u=que.front();
+            que.pop();
+            for(int i=head[u]; i; i=e[i].next)
+                if(dep[e[i].v]==-1)
+                {
+                    que.push(e[i].v);
+                    dep[e[i].v]=dep[u]+1;
+                    ++gap[dep[e[i].v]];
+                }
+        }
+    }
+    int res,cur[MAXN],num[MAXN];
+    int top;
+    int MaxFlow(int s,int t)
+    {
+        this->ss=s;
+        this->tt=t;
+        bfs();
+        top=res=0;
+        memcpy(cur,head,sizeof(head));
+        int u=ss,i;
+        while(dep[ss]<n)
+        {
+            if(u==tt)
+            {
+                int temp=INF;
+                int inser;
+                for(i=0; i<top; i++)
+                    if(temp>e[num[i]].c)
+                    {
+                        temp=e[num[i]].c;
+                        inser=i;
+                    }
+                for(i=0; i<top; i++)
+                {
+                    e[num[i]].c-=temp;
+                    e[num[i]^1].c+=temp;
+                }
+                res+=temp;
+                top=inser;
+                u=e[num[top]].u;
+            }
+            if(u!=tt && gap[dep[u]-1]==0)
+                break;
+            for(i=cur[u]; i; i=e[i].next)
+                if(e[i].c != 0 && dep[u]==dep[e[i].v]+1)
+                    break;
+            if(i)
+            {
+                cur[u]=i;
+                num[top++]=i;
+                u=e[i].v;
+            }
+            else
+            {
+                int mi=n;
+                for(i=head[u]; i; i=e[i].next)
+                    if(e[i].c>0 && mi>dep[e[i].v])
+                    {
+                        mi=dep[e[i].v];
+                        cur[u]=i;
+                    }
+                --gap[dep[u]];
+                dep[u]=mi+1;
+                ++gap[dep[u]];
+                if(u!=ss)
+                    u=e[num[--top]].u;
+            }
+        }
+        return res;
+    }
+    void print()
+    {
+        puts("GRAPH:");
+        for(int i=0; i<=n; i++)
+        {
+            if(!head[i])
+                continue;
+            printf("%d ->",i);
+            for(int j=head[i]; j; j=e[j].next)
+                printf("%d(%I64d) ",e[j].v,e[j].c);
+            putchar('\n');
+        }
+    }
+}g;
+static int tim;
+struct Node
+{
+    Node *ln[2];
+    int cost[2],idx;
+    bool f;
+    void init()
+    {
+        f=0;
+        idx=tim++;
+        memset(ln,0,sizeof ln);
+        memset(cost,INF,sizeof cost);
+    }
+};
+struct Trie
+{
+    Node T[MAXN];
+    int cnt,pos[MAXN];
+    Node *rt;
+    Node* get()
+    {
+        T[cnt].init();
+        return &T[cnt++];
+    }
+    void init()
+    {
+        cnt=0;
+        rt=get();
+    }
+    void insert(int *s,int j)
+    {
+        Node *p=rt;
+        for(int i=0; i<8; i++)
+        {
+            int v=s[i];
+            if(p->ln[v]==NULL)  p->ln[v]=get();
+            p=p->ln[v];
+        }
+        p->f=1;
+        pos[j]=p->idx;
+    }
+    void find(char *s,int cost)
+    {
+        Node *p=rt;
+        for(int i=0; s[i]; i++)
+        {
+            int v=s[i]-'0';
+            if(p->ln[v]==NULL)  return;
+            if(s[i+1]==0)   p->cost[v]=min(p->cost[v],cost);
+            else    p=p->ln[v];
+        }
+    }
+} pre,su;
+int n,m,ss,tt;
+int a[9];
+char str[9],x[9];
+void dfs(Node *p,int flag)
+{
+    if(flag)
+    {
+        if(p->ln[0])
+        {
+            g.addedge(p->ln[0]->idx,p->idx,p->cost[0]);
+            dfs(p->ln[0],1);
+        }
+        if(p->ln[1])
+        {
+            g.addedge(p->ln[1]->idx,p->idx,p->cost[1]);
+            dfs(p->ln[1],1);
+        }
+    }
+    else
+    {
+        if(p->ln[0])
+        {
+            g.addedge(p->idx,p->ln[0]->idx,p->cost[0]);
+            dfs(p->ln[0],0);
+        }
+        if(p->ln[1])
+        {
+            g.addedge(p->idx,p->ln[1]->idx,p->cost[1]);
+            dfs(p->ln[1],0);
+        }
+    }
+}
+void build()
+{
+    for(int i=1; i<=n; i++)
+        g.addedge(pre.pos[i],su.pos[i],INF);
+    dfs(pre.rt,0);
+    dfs(su.rt ,1);
+}
+int main()
+{
+    int T,cas=1;
+    read(T);
+    while(T--)
+    {
+        scanf("%d %d",&n,&m);
+        tim=0;
+        pre.init();su.init();g.Clearall();
+        for(int i=1,x; i<=n; i++)
+        {
+            scanf("%d",&x);
+            for(int j=0; j<8; j++)
+                if(x&(1<<7-j))  a[j]=1;
+                else    a[j]=0;
+            pre.insert(a,i);
+            for(int j=0; j<8; j++)
+                if(x&(1<<j))    a[j]=1;
+                else    a[j]=0;
+            su.insert(a,i);
+        }
+        g.Resize(tim);
+        ss=0;
+        tt=su.rt->idx;
+        for(int i=1,cost; i<=m; i++)
+        {
+            scanf("%s %s %d",str,x,&cost);
+            if(str[0]=='P') pre.find(x,cost);
+            else
+            {
+                int len=strlen(x);
+                reverse(x,x+len);
+                su.find(x,cost);
+            }
+        }
+        build();
+        ll ans=g.MaxFlow(ss,tt);
+        printf("Case #%d: %lld\n",cas++,ans>=INF?-1:ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5458_autoAC.cpp b/HDOJ/5458_autoAC.cpp
new file mode 100644
index 0000000..8d84d93
--- /dev/null
+++ b/HDOJ/5458_autoAC.cpp
@@ -0,0 +1,310 @@
+#include <algorithm>
+#include <iostream>
+#include <iomanip>
+#include <cstring>
+#include <climits>
+#include <complex>
+#include <cassert>
+#include <cstdio>
+#include <bitset>
+#include <vector>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <ctime>
+#include <set>
+#include <map>
+#include <cmath>
+#include <functional>
+#include <numeric>
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+using namespace std;
+#define eps 1e-9
+#define PI acos(-1.0)
+#define INF 0x3f3f3f3f
+#define LLINF 1LL<<62
+#define speed std::ios::sync_with_stdio(false);
+typedef long long ll;
+typedef unsigned long long ull;
+typedef long double ld;
+typedef pair<ll, ll> pll;
+typedef complex<ld> point;
+typedef pair<int, int> pii;
+typedef pair<pii, int> piii;
+typedef vector<int> vi;
+#define CLR(x,y) memset(x,y,sizeof(x))
+#define CPY(x,y) memcpy(x,y,sizeof(x))
+#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
+#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))
+#define mp(x,y) make_pair(x,y)
+#define pb(x) push_back(x)
+#define lowbit(x) (x&(-x))
+#define MID(x,y) (x+((y-x)>>1))
+#define getidx(l,r) (l+r | l!=r)
+#define ls getidx(l,mid)
+#define rs getidx(mid+1,r)
+#define lson l,mid
+#define rson mid+1,r
+#define root 1,n
+template<class T>
+inline bool read(T &n)
+{
+    T x = 0, tmp = 1;
+    char c = getchar();
+    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
+    if(c == EOF) return false;
+    if(c == '-') c = getchar(), tmp = -1;
+    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
+    n = x*tmp;
+    return true;
+}
+template <class T>
+inline void write(T n)
+{
+    if(n < 0)
+    {
+        putchar('-');
+        n = -n;
+    }
+    int len = 0,data[20];
+    while(n)
+    {
+        data[len++] = n%10;
+        n /= 10;
+    }
+    if(!len) data[len++] = 0;
+    while(len--) putchar(data[len]+48);
+}
+const int MAXN=30005;
+const int MAXM=100005;
+const int MAXQ=100005;
+int t,n,m,q;
+struct edge
+{
+    int a,b;
+    edge(){}
+    edge(int aa,int bb):a(aa),b(bb){}
+    bool operator < (const edge &o) const
+    {
+        if(a == o.a)
+        {
+            return b < o.b;
+        }
+        return a < o.a;
+    }
+};
+multiset<edge> S;
+multiset<edge> V;
+struct Ans
+{
+    int kind;
+    int a;
+    int b;
+    int val;
+}ans[MAXQ];
+struct Edge
+{
+    int u,v,w;
+    int next;
+}e[MAXN<<1];
+int head[MAXN],tot;
+int siz[MAXN],p[MAXN],son[MAXN],dep[MAXN];
+int dfn[MAXN],top[MAXN],tim;
+int sum[MAXN<<1],la[MAXN<<1];
+int bingchafa[MAXN];
+int getfather(int x)
+{
+    if(bingchafa[x] == x) return x;
+    return bingchafa[x] = getfather(bingchafa[x]);
+}
+void init()
+{
+    CLR(head,-1);CLR(sum,0);
+    tot=tim=0;
+    for(int i=1;i<=n;i++) bingchafa[i] = i;
+    S.clear();
+    V.clear();
+}
+void addedge(int u,int v,int w)
+{
+    e[tot].u=u;e[tot].v=v;e[tot].w=w;
+    e[tot].next=head[u];head[u]=tot++;
+}
+void dfs(int u,int fa=0,int depth=0)
+{
+    siz[u]=1;son[u]=-1;
+    p[u]=fa;dep[u]=depth;
+    for(int i=head[u];~i;i=e[i].next)
+    {
+        int v=e[i].v;
+        if(v==p[u])   continue;
+        dfs(v,u,depth+1);
+        siz[u]+=siz[v];
+        if(son[u]==-1 || siz[v]>siz[son[u]])
+            son[u]=v;
+    }
+}
+void getid(int u,int fa)
+{
+    dfn[u]=++tim;top[u]=fa;
+    if(son[u]!=-1)
+        getid(son[u],fa);
+    for(int i=head[u];~i;i=e[i].next)
+    {
+        int v=e[i].v;
+        if(v==p[u] || v==son[u])    continue;
+        getid(v,v);
+    }
+}
+void pushup(int l,int r)
+{
+    int idx=getidx(l,r),mid=MID(l,r);
+    sum[idx]=0;
+    if(!la[ls])
+        sum[idx]+=sum[ls];
+    if(!la[rs])
+        sum[idx]+=sum[rs];
+}
+void pushdown(int l,int r)
+{
+    int idx=getidx(l,r),mid=MID(l,r);
+    if(!la[idx])  return;
+    la[ls]=la[idx];
+    la[rs]=la[idx];
+}
+void build(int l,int r)
+{
+    int idx=getidx(l,r);
+    la[idx]=0;
+    if(l==r)
+    {
+        sum[idx]=1;
+        return;
+    }
+    int mid=MID(l,r);
+    build(l,mid);
+    build(mid+1,r);
+    pushup(l,r);
+}
+void update2(int l,int r,int L,int R)
+{
+    int idx=getidx(l,r);
+    if(L==l && r==R)
+    {
+        la[idx]=1;
+        sum[idx]=0;
+        return;
+    }
+    pushdown(l,r);
+    int mid=MID(l,r);
+    if(R<=mid)
+        update2(l,mid,L,R);
+    else if(L>mid)
+        update2(mid+1,r,L,R);
+    else
+        update2(l,mid,L,mid),update2(mid+1,r,mid+1,R);
+    pushup(l,r);
+}
+int query(int l,int r,int L,int R)
+{
+    int idx=getidx(l,r);
+    if(la[idx]) return 0;
+    if(L==l && r==R)
+    {
+        return sum[idx];
+    }
+    int mid=MID(l,r);
+    if(R<=mid)
+        return query(lson,L,R);
+    if(L>mid)
+        return query(rson,L,R);
+    return query(lson,L,mid)+query(rson,mid+1,R);
+}
+void change(int u,int v)
+{
+    while(top[u]!=top[v])
+    {
+        if(dep[top[u]]>dep[top[v]])
+            swap(u,v);
+        update2(1,tim,dfn[top[v]],dfn[v]);
+        v=p[top[v]];
+    }
+    if(u==v)    return;
+    if(dep[u]>dep[v])
+        swap(u,v);
+    update2(1,tim,dfn[son[u]],dfn[v]);
+}
+int query(int u,int v)
+{
+    int ans=0;
+    while(top[u]!=top[v])
+    {
+        if(dep[top[u]]>dep[top[v]])
+            swap(u,v);
+        ans+=query(1,tim,dfn[top[v]],dfn[v]);
+        v=p[top[v]];
+    }
+    if(u==v)    return ans;
+    if(dep[u]>dep[v])
+        swap(u,v);
+    ans+=query(1,tim,dfn[u]+1,dfn[v]);
+    return ans;
+}
+int main()
+{
+    scanf("%d",&t);
+    for(int cas = 1;cas <= t;cas++)
+    {
+        scanf("%d%d%d",&n,&m,&q);
+        init();
+        for(int i=1;i<=m;i++)
+        {
+            edge tmp;
+            scanf("%d%d",&tmp.a,&tmp.b);
+            if(tmp.a > tmp.b) swap(tmp.a,tmp.b);
+            S.insert(tmp);
+        }
+        for(int i=1;i<=q;i++)
+        {
+            scanf("%d%d%d",&ans[i].kind,&ans[i].a,&ans[i].b);
+            if(ans[i].a > ans[i].b) swap(ans[i].a,ans[i].b);
+            if(ans[i].kind == 1)
+            {
+                multiset<edge>::iterator Pos = S.find(edge(ans[i].a,ans[i].b));
+                S.erase(Pos);
+            }
+        }
+        for(multiset<edge>::iterator It = S.begin();It != S.end();++It)
+        {
+            if(getfather(It->a) != getfather(It->b))
+            {
+                bingchafa[getfather(It->a)] = getfather(It->b);
+                V.insert(*It);
+            }
+        }
+        for(multiset<edge>::iterator It = V.begin();It != V.end();++It)
+        {
+            addedge(It->a,It->b,1);
+            addedge(It->b,It->a,1);
+        }
+        dfs(1);getid(1,1);
+        build(1,tim);
+        for(multiset<edge>::iterator It = S.begin();It != S.end();++It)
+        if(V.find(*It) == V.end())
+        {
+            change(It->a,It->b);
+        }
+        for(int i=q;i>=1;i--)
+        {
+            if(ans[i].kind == 1)
+                change(ans[i].a,ans[i].b);
+            else if(ans[i].kind == 2)
+                ans[i].val = query(ans[i].a,ans[i].b);
+        }
+        printf("Case #%d:\n",cas);
+        for(int i=1;i<=q;i++)
+        if(ans[i].kind == 2)
+            printf("%d\n",ans[i].val);
+    }
+    return 0;
+}
diff --git a/HDOJ/5459_autoAC.cpp b/HDOJ/5459_autoAC.cpp
new file mode 100644
index 0000000..4bf4f54
--- /dev/null
+++ b/HDOJ/5459_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <string>
+#include <cmath>
+#include <queue>
+#include <set>
+#include <stack>
+using namespace std;
+const int maxn = 201315;
+const int mod = 530600414;
+typedef long long LL;
+LL dp[maxn];     
+LL dist[maxn];   
+LL cnt[maxn];    
+LL fibo[maxn];   
+void init() {
+    fibo[1] = 1, fibo[2] = 2;
+    cnt[1] = 1, cnt[2] = 0;
+    for (int  i = 3; i < maxn; i ++) {
+        fibo[i] = (fibo[i-1] % mod + fibo[i-2] % mod) % mod;
+        cnt[i] = (cnt[i-1] % mod + cnt[i-2] % mod) % mod;
+    }
+    dist[1] = dist[2] = 0, dist[3] = 2;
+    for (int i = 4; i < maxn; i ++) {
+        dist[i] = (dist[i-1] % mod + dist[i-2] % mod + (fibo[i-1] % mod * cnt[i-2] % mod) % mod) % mod;
+    }
+    dp[4] = dp[1] = dp[2] = dp[3] = 0;
+    for (int i = 5; i < maxn; i ++) {
+        dp[i] = (dp[i-2] % mod + dp[i-1] % mod
+        + (cnt[i-1] % mod * dist[i-2] % mod) % mod
+        + (cnt[i-2] % mod * ((fibo[i-1] % mod * cnt[i-1] % mod) % mod - dist[i-1] % mod) % mod) % mod) % mod;
+    }
+}
+int main() {
+    init();
+    int cas = 1, t, n;
+    scanf("%d", &t);
+    while (t --) {
+        scanf("%d", &n);
+        printf("Case #%d: ", cas ++);
+        printf("%I64d\n", dp[n]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5460_autoAC.cpp b/HDOJ/5460_autoAC.cpp
new file mode 100644
index 0000000..c53916c
--- /dev/null
+++ b/HDOJ/5460_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <algorithm>
+using namespace std;
+const int maxn = (1<<8)+5;
+const int limit = 32 * 13 * 13;
+typedef long long ll;
+typedef map<int,ll>::iterator iter;
+int N, Q, X[20], multi[maxn], ct[maxn];
+map<int, ll> G[maxn];
+int bitcount(int s) { return s == 0 ? 0 : bitcount(s>>1) + (s&1); }
+void add (int u, int s, ll k) {
+    if (s < 0) return;
+    G[u][s] += k;
+}
+void merge(int u, int p, int q) {
+    for (iter i = G[p].begin(); i != G[p].end(); i++) {
+        for (iter j = G[q].begin(); j != G[q].end(); j++) {
+            ll k = 1LL * i->second * j->second;
+            add(u, i->first + j->first, k * 2);
+            add(u, i->first * j->first, k * 2);
+            add(u, i->first - j->first, k);
+            add(u, j->first - i->first, k);
+            if (i->first && j->first % i->first == 0)
+                add(u, j->first / i->first, k);
+            if (j->first && i->first % j->first == 0)
+                add(u, i->first / j->first, k);
+        }
+    }
+}
+ll solve () {
+    ll ret = 0;
+    for (int i = 1; i < (1<<N); i++) {
+        int cbit = bitcount(i);
+        for (int u = i; u; u = (u-1)&i) {
+            int v = u^i;
+            if (u < v) break;
+            merge(i, u, v);
+        }
+        if (G[i].count(Q))
+            ret += G[i][Q] * cbit * cbit;
+    }
+    return ret;
+}
+int main () {
+    int cas;
+    scanf("%d", &cas);
+    for (int kcas = 1; kcas <= cas; kcas++) {
+        scanf("%d%d", &N, &Q);
+        for (int i = 0; i < (1<<N); i++) G[i].clear();
+        for (int i = 0; i < N; i++) {
+            scanf("%d", &X[i]);
+            G[1<<i][X[i]] = 1;
+        }
+        printf("Case #%d: %lld\n", kcas, solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/5461_autoAC.cpp b/HDOJ/5461_autoAC.cpp
new file mode 100644
index 0000000..475ef47
--- /dev/null
+++ b/HDOJ/5461_autoAC.cpp
@@ -0,0 +1,47 @@
+#include<iostream>
+#include<cstdio>
+#include<utility>
+#include<algorithm>
+using namespace std;
+typedef long long LL;
+typedef pair<LL,int> PLL;
+PLL x[5],y[5];
+bool cmp1(const PLL &x,const PLL &y) {return x.first>y.first;}
+bool cmp2(const PLL &x,const PLL &y) {return x.first<y.first;}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    int n,a,b;
+    LL z;
+    for(int k=1;k<=T;k++)
+    {
+        scanf("%d%d%d",&n,&a,&b);
+        for(int i=0;i<n;i++)
+        {
+            scanf("%lld",&z);
+            x[4]=make_pair(z*z,i);
+            y[4]=make_pair(z,i);
+            if(i<=4)
+            {
+                x[i]=x[4];
+                y[i]=y[4];
+            }else
+            {
+                if(a>0)
+                    sort(x,x+5,cmp1);
+                else sort(x,x+5,cmp2);
+                if(b>0)
+                    sort(y,y+5,cmp1);
+                else sort(y,y+5,cmp2);
+            }
+        }
+        LL ans=-1e20;
+        for(int i=0;i<min(n,2);i++)
+            for(int j=0;j<min(n,2);j++)
+        if(x[i].second!=y[j].second)
+            ans=max(ans,x[i].first*a+b*y[j].first);
+        printf("Case #%d: %lld\n",k,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5462_autoAC.cpp b/HDOJ/5462_autoAC.cpp
new file mode 100644
index 0000000..a5c581f
--- /dev/null
+++ b/HDOJ/5462_autoAC.cpp
@@ -0,0 +1,204 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <math.h>
+using namespace std;
+typedef long long LL;
+const int maxn = 1005;
+const double eps = 1e-7;
+struct Point
+{
+    double x, y;
+    Point(double x = 0, double y = 0) : x(x), y(y) { }
+    bool operator < (const Point &a) const {
+        return a.x < x || (a.x == x && a.y < y);
+    }
+};
+typedef Point Vector;
+struct Line
+{
+    Point P;
+    Vector v;
+    double ang;
+    Line() {}
+    Line(Point P, Vector v) : P(P), v(v) { ang = atan2(v.y, v.x); }
+    bool operator < (const Line &L) const {
+        return ang < L.ang;
+    }
+};
+Vector operator + (Vector A, Vector B) 
+{
+    return Vector(A.x + B.x, A.y + B.y);
+}
+Vector operator - (Vector A, Vector B)
+{
+    return Vector(A.x - B.x, A.y - B.y);
+}
+Vector operator * (Vector A, double p)
+{
+    return Vector(A.x * p, A.y * p);
+}
+Vector operator / (Vector A, double p)
+{
+    return Vector(A.x / p, A.y / p);
+}
+int dcmp(double x)
+{
+    if(fabs(x) < eps) return 0;
+    else return x < 0 ? -1 : 1;
+}
+double Dot(Vector A, Vector B)
+{
+    return A.x * B.x + A.y * B.y;
+}
+double Length(Vector A)
+{
+    return sqrt(Dot(A, A));
+}
+double Angle(Vector A, Vector B)
+{
+    return acos(Dot(A, B) / Length(A) / Length(B));
+}
+double Cross(Vector A, Vector B)
+{
+    return A.x * B.y - A.y * B.x;
+}
+double Area2(Point A, Point B, Point C)
+{
+    return Cross(B - A, C - A);
+}
+double PolyonArea(Point *p, int n)
+{
+    double area = 0;
+    for(int i = 1; i < n-1; i++)
+        area += Cross(p[i] - p[0], p[i+1] - p[0]);
+    return area / 2;
+}
+Vector Rotate(Vector A, double rad)
+{
+    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
+}
+Vector Normal(Vector A)
+{
+    double L = Length(A);
+    return Vector(-A.y / L, A.x / L);
+}
+bool OnLeft(Line L, Point p)
+{
+    return Cross(L.v, p - L.P) > 0;
+}
+Point GetIntersection(Line a, Line b)
+{
+    Vector u = a.P - b.P;
+    double t = Cross(b.v, u) / Cross(a.v, b.v);
+    return a.P + a.v * t;
+}
+int ConvexHull(Point *p, int n, Point *ch)
+{
+    sort(p, p+n);
+    int m = 0;
+    for(int i = 0; i < n; i++) {
+        while(m > 1 && Cross(ch[m-1] - ch[m-2], p[i] - ch[m-2]) <= 0) m--;
+        ch[m++] = p[i];
+    }
+    int k = m;
+    for(int i = n-2; i >= 0; i--) {
+        while(m > k && Cross(ch[m-1] - ch[m-2], p[i] - ch[m-2]) <= 0) m--;
+        ch[m++] = p[i];
+    }
+    if(n > 1) m--;
+    return m;
+}
+Point p[maxn];
+Line q[maxn];
+int HalfplaneInersection(Line* L, int n, Point* poly)
+{
+    sort(L, L+n);
+    int first, last;
+    q[first = last = 0] = L[0];
+    for(int i = 1; i < n; i++) {
+        while(first < last && !OnLeft(L[i], p[last - 1])) last--;
+        while(first < last && !OnLeft(L[i], p[first])) first++;
+        q[++last] = L[i];
+        if(fabs(Cross(q[last].v, q[last-1].v)) < eps) {
+            last--;
+            if(OnLeft(q[last], L[i].P)) q[last] = L[i];
+        }
+        if(first < last) p[last-1] = GetIntersection(q[last-1], q[last]);
+    }
+    while(first < last && !OnLeft(q[first], p[last-1])) last--;
+    if(last - first <= 1) return 0;
+    p[last] = GetIntersection(q[last], q[first]);
+    int m = 0;
+    for(int i = first; i <= last; i++) poly[m++] = p[i];
+    return m;
+}
+double PolygonArea(Point *p, int n) {
+    double area = 0;
+    for(int i = 1; i < n-1; i++)
+        area += Cross(p[i] - p[0], p[i+1] - p[0]);
+    return fabs(area / 2);
+}
+Point poly[1005];
+Point g[105][2005];
+Point P2[10];
+Line line[105];
+double twox[105][2005];
+double twoy[105][2005];
+double xx[105][2005];
+double yy[105][2005];
+int n, m;
+void work()
+{
+    scanf("%d%d", &n, &m);
+    for(int i = 1; i <= n; i++) {
+        twox[i][0] = twoy[i][0] = xx[i][0] = yy[i][0] = 0;
+        for(int j = 1; j <= m; j++) {
+            scanf("%lf%lf", &g[i][j].x, &g[i][j].y);
+            twox[i][j] = g[i][j].x * g[i][j].x;
+            twoy[i][j] = g[i][j].y * g[i][j].y;
+            twox[i][j] += twox[i][j-1];
+            twoy[i][j] += twoy[i][j-1];
+            xx[i][j] = g[i][j].x + xx[i][j-1];
+            yy[i][j] = g[i][j].y + yy[i][j-1];
+        }
+    }
+    for(int i = 1; i <= n; i++) {
+        int cnt = 0;
+        for(int j = 1; j <= n; j++) {
+            if(i == j) continue;
+            double a = 0, b = 0, c = 0;
+            a = 2 * (xx[i][m] - xx[j][m]);
+            b = 2 * (yy[i][m] - yy[j][m]);
+            c += twox[j][m] + twoy[j][m];
+            c -= twox[i][m] + twoy[i][m];
+            Point P;
+            Vector v(b, -a);
+            if(fabs(a) > fabs(b)) P = Point(-c / a, 0);
+            else P = Point(0, -c / b);
+            line[cnt++] = Line(P, v);
+        }
+        for(int j = 0; j < 4; j++) {
+            line[cnt++] = Line(P2[j], P2[(j+1)%4] - P2[j]);
+        }
+        int t = HalfplaneInersection(line, cnt, poly);
+        double area = PolygonArea(poly, t);
+        int ans = area + 0.5;
+        printf("%d%c", ans, i == n ? '\n' : ' ');
+    }
+}
+int main()
+{
+    P2[0] = Point(0, 0);
+    P2[1] = Point(4095, 0);
+    P2[2] = Point(4095, 4095);
+    P2[3] = Point(0, 4095);
+    int _;
+    scanf("%d", &_);
+    for(int i = 1; i <= _; i++) {
+        printf("Case #%d: ", i);
+        work();
+    }
+    return 0;
+}
diff --git a/HDOJ/5463_autoAC.cpp b/HDOJ/5463_autoAC.cpp
new file mode 100644
index 0000000..9b433e7
--- /dev/null
+++ b/HDOJ/5463_autoAC.cpp
@@ -0,0 +1,34 @@
+#include<cstdio>
+#include<cstring>
+const int maxn=1100;
+int T;
+int n,m,r;
+int vis[maxn];
+int main()
+{
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d",&n);
+        memset(vis,0,sizeof(vis));
+        int ans=0;
+        for(int i=0;i<n;i++){
+            scanf("%d %d",&r,&m);
+            vis[r]+=m;
+        }
+        for(int i=0;i<=500;i++){
+            if(vis[i]>0){
+                if(vis[i]%64==0){
+                    ans+=vis[i]/64;
+                }
+                else{
+                    ans+=vis[i]/64+1;
+                }
+            }
+        }
+        if(!ans%36)
+            printf("%d\n",ans/36);
+        else
+            printf("%d\n",ans/36+1);
+    }
+    return 0;
+}
diff --git a/HDOJ/5464_autoAC.cpp b/HDOJ/5464_autoAC.cpp
new file mode 100644
index 0000000..898ab6c
--- /dev/null
+++ b/HDOJ/5464_autoAC.cpp
@@ -0,0 +1,31 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#define ll long long
+using namespace std;
+const int N = 1005;
+const int MOD = 1e9 + 7;
+const int INF = 0x3f3f3f3f;
+int n, p, a[N], f[N][N];
+int main() {
+    int t;
+    scanf("%d", &t);
+    while (t--) {
+        scanf("%d%d", &n, &p);
+        memset(f, 0, sizeof(f));
+        f[0][0] = 1;
+        for (int i = 1; i <= n; i++) {
+            scanf("%d", &a[i]);
+            a[i] %= p;
+            a[i] = (a[i] + p) % p;
+        }
+        for (int i = 1; i <= n; i++) {
+            for (int j = 0; j < p; j++) {
+                f[i][j] = (f[i][j] + f[i - 1][j]) % MOD;
+                f[i][(j + a[i]) % p] = (f[i][(j + a[i]) % p] + f[i - 1][j]) % MOD;
+            }
+        }
+        printf("%d\n", f[n][0]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5465_autoAC.cpp b/HDOJ/5465_autoAC.cpp
new file mode 100644
index 0000000..82ec0b6
--- /dev/null
+++ b/HDOJ/5465_autoAC.cpp
@@ -0,0 +1,117 @@
+#pragma comment(linker, "/STACK:1677721600")
+#include <map>
+#include <set>
+#include <cmath>
+#include <queue>
+#include <stack>
+#include <vector>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <climits>
+#include <cassert>
+#include <iostream>
+#include <algorithm>
+#define pb push_back
+#define mp make_pair
+#define LL long long
+#define lson lo,mi,rt<<1
+#define rson mi+1,hi,rt<<1|1
+#define Min(a,b) ((a)<(b)?(a):(b))
+#define Max(a,b) ((a)>(b)?(a):(b))
+#define mem(a,b) memset(a,b,sizeof(a))
+#define rep(i,a,b) for(int i=(a); i<=(b); i++)
+#define dec(i,a,b) for(int i=(a); i>=(b); i--)
+using namespace std;
+const int mod = 1e9 + 7;
+const double eps = 1e-8;
+const double ee = exp(1.0);
+const int inf = 0x3f3f3f3f;
+const int maxn = 500 + 10;
+const double pi = acos(-1.0);
+const LL iinf = 0x3f3f3f3f3f3f3f3f;
+int readT()
+{
+    char c;
+    int ret = 0,flg = 0;
+    while(c = getchar(), (c < '0' || c > '9') && c != '-');
+    if(c == '-') flg = 1; else ret = c ^ 48;
+    while( c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c ^ 48);
+    return flg ? - ret : ret;
+}
+int c[maxn][maxn];
+int a[maxn][maxn];
+int n, m;
+int lowbit(int x)
+{
+    return x & -x;
+}
+void update(int x, int y, int num)
+{
+    for (int i = x; i <= n; i += lowbit(i))
+    {
+        for (int j = y; j <= m; j += lowbit(j))
+        {
+            c[i][j] ^= num;
+        }
+    }
+}
+int query(int x, int y)
+{
+    int res = 0;
+    int t = x;
+    for (int i = x; i > 0; i -= lowbit(i))
+    {
+        for (int j = y; j > 0; j -= lowbit(j))
+        {
+            res ^= c[i][j];
+        }
+    }
+    return res;
+}
+int sum(int x0, int y0, int x1, int y1)
+{
+    x0--, y0--;
+    return query(x1, y1) ^ query(x0, y1) ^ query(x1, y0) ^ query(x0, y0);
+}
+int main()
+{
+    int ncase = readT();
+    while (ncase--)
+    {
+        mem(c, 0);
+        n = readT();
+        m = readT();
+        int q = readT();
+        rep(i, 1, n)
+        {
+            rep(j, 1, m)
+            {
+                a[i][j] = readT();
+                update(i, j, a[i][j]);
+            }
+        }
+        while (q--)
+        {
+            int op = readT();
+            if (op == 1)
+            {
+                int x1 = readT();
+                int y1 = readT();
+                int x2 = readT();
+                int y2 = readT();
+                int ans = sum(x1, y1, x2, y2);
+                puts(ans ? "Yes" : "No");
+            }
+            else
+            {
+                int x = readT();
+                int y = readT();
+                int num =readT();
+                update(x, y, num ^ a[x][y]);
+                a[x][y] = num;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5467_autoAC.cpp b/HDOJ/5467_autoAC.cpp
new file mode 100644
index 0000000..a97b730
--- /dev/null
+++ b/HDOJ/5467_autoAC.cpp
@@ -0,0 +1,236 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <math.h>
+#include <vector>
+using namespace std;
+typedef long long LL;
+#define mp(x, y) make_pair(x, y)
+const int maxn = 300005;
+const int maxm = 300005;
+const int INF = 0x3f3f3f3f;
+const int mod = 1e9+7;
+struct node *null;
+struct node
+{
+    int size, rev;
+    LL val, sum;
+    node *fa, *ch[2];
+    void init()
+    {
+        rev = val = sum = 0;
+        fa = ch[0] = ch[1] = null;
+    }
+    inline bool d()
+    {
+        return fa->ch[1] == this;
+    }
+    inline bool isroot()
+    {
+        return fa == null || fa->ch[0] != this && fa->ch[1] != this;
+    }
+    inline void setc(node *p, int d)
+    {
+        ch[d] = p;
+        p->fa = this;
+    }
+    inline void pushup()
+    {
+        sum = ch[0]->sum * ch[1]->sum % mod * ((val - 1) * val / 2) % mod;
+    }
+    inline void flip()
+    {
+        if(this == null) return;
+        swap(ch[0], ch[1]);
+        rev ^= 1;
+    }
+    inline void pushdown()
+    {
+        if(rev) {
+            ch[0]->flip();
+            ch[1]->flip();
+            rev = 0;
+        }
+    }
+    inline void go()
+    {
+        if(!isroot()) fa->go();
+        pushdown();
+    }
+    void rot()
+    {
+        node *f = fa, *ff = fa->fa;
+        int c = d(), cc = fa->d();
+        f->setc(ch[!c], c);
+        this->setc(f, !c);
+        if(ff->ch[cc] == f) ff->setc(this, cc);
+        else this->fa = ff;
+        f->pushup();
+    }
+    node* splay()
+    {
+        go();
+        while(!isroot()) {
+            if(!fa->isroot()) d() == fa->d() ? fa->rot() : rot();
+            rot();
+        }
+        pushup();
+        return this;
+    }
+    node* access()
+    {
+        for(node *p = this, *q = null; p != null; q = p, p = p->fa) {
+            p->splay()->setc(q, 1);
+            p->pushup();
+        }
+        return splay();
+    }
+    inline void makeroot()
+    {
+        access()->flip();
+    }
+    node* getroot() {
+        node *x;
+        for(x = access(); x->pushdown(), x->ch[0] != null; x = x->ch[0]);
+        return x;
+    }
+    void cut()
+    {
+        access();
+        ch[0]->fa = null;
+        ch[0] = null;
+        pushup();
+    }
+    void cut(node *o)
+    {
+        makeroot();
+        o->cut();
+    }
+    void link(node *p)
+    {
+        makeroot();
+        fa = p;
+    }
+}*Node[maxn], pool[maxm], *tail;
+struct ope
+{
+    int kk, u, v;
+    ope(int kk = 0, int u = 0, int v = 0) : kk(kk), u(u), v(v) {}
+}op[maxn];
+struct Edge
+{
+    int v;
+    Edge *next;
+}*H[maxn], *edges, E[maxn];
+vector<int> to[maxn];
+LL res[maxn];
+int T[maxn];
+int a[maxn];
+int n, m;
+void addedges(int u, int v)
+{
+    edges->v = v;
+    edges->next = H[u];
+    H[u] = edges++;
+}
+node* newnode(int val)
+{
+    tail->init();
+    tail->val = val;
+    tail->sum = tail->val * (tail->val - 1) / 2;
+    return tail++;
+}
+void init()
+{
+    tail = pool;
+    null = newnode(1);
+    null->sum = 1;
+    edges = E;
+    memset(H, 0, sizeof H);
+    memset(T, 0, sizeof T);
+    memset(res, -1, sizeof res);
+}
+bool add(int u, int v)
+{
+    if(u == v) return 0;
+    if(Node[u]->getroot() == Node[v]->getroot()) return 0;
+    Node[u]->link(Node[v]);
+    return true;
+}
+bool del(int u, int v)
+{
+    if(u == v) return 0;
+    if(Node[u]->getroot() != Node[v]->getroot()) return 0;
+    Node[u]->makeroot();
+    Node[v]->access();
+    if(Node[v]->ch[0] != Node[u] || Node[u]->ch[1] != null) return 0; 
+    else Node[v]->cut(Node[u]);
+    return 1;
+}
+LL query(node *a, node *b)
+{
+    a->access();
+    for(a = null; b != null; a = b, b = b->fa) {
+        b->splay();
+        if(b->fa == null) return b->ch[1]->sum * a->sum % mod * (b->val * (b->val - 1) / 2) % mod;
+        b->setc(a, 1);
+        b->pushup();
+    }
+}
+void modify(int u, LL val)
+{
+    Node[u]->access();
+    Node[u]->val = val;
+    Node[u]->pushup();
+}
+void dfs(int ti)
+{
+    LL tmp = 0;
+    int flag = 0;
+    if(op[ti].kk == 1) flag = add(op[ti].u, op[ti].v);
+    if(op[ti].kk == 2) flag = del(op[ti].u, op[ti].v);
+    if(op[ti].kk == 4) {
+        if(Node[op[ti].u]->getroot() != Node[op[ti].v]->getroot()) res[ti] = 0;
+        else res[ti] = query(Node[op[ti].u], Node[op[ti].v]);
+    }
+    if(op[ti].kk == 5) {
+        tmp = a[op[ti].u];
+        a[op[ti].u] = op[ti].v;
+        modify(op[ti].u, op[ti].v);
+    }
+    for(Edge *e = H[ti]; e; e = e->next) dfs(e->v);
+    if(op[ti].kk == 2 && flag) add(op[ti].u, op[ti].v);
+    if(op[ti].kk == 1 && flag) del(op[ti].u, op[ti].v);
+    if(op[ti].kk == 5) {
+        a[op[ti].u] = tmp;
+        modify(op[ti].u, tmp);
+    }
+}
+void work()
+{
+    scanf("%d%d", &n, &m);
+    for(int i = 1; i <= n; i++) to[i].clear();
+    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
+    for(int i = 1; i <= n; i++) Node[i] = newnode(a[i]);
+    for(int i = 1; i <= m; i++) {
+        int kk, u, v;
+        scanf("%d", &kk);
+        if(kk == 3) scanf("%d", &u), T[i] = u;
+        else scanf("%d%d", &u, &v), T[i] = i-1;
+        op[i] = ope(kk, u, v);
+    }
+    for(int i = 1; i <= m; i++) addedges(T[i], i);
+    dfs(0);
+    for(int i = 1; i <= m; i++) if(res[i] != -1) printf("%lld\n", res[i]);
+}
+int main()
+{
+    int _;
+    scanf("%d", &_);
+    while(_--) {
+        init();
+        work();
+    }
+    return 0;
+}
diff --git a/HDOJ/5468_autoAC.cpp b/HDOJ/5468_autoAC.cpp
new file mode 100644
index 0000000..cfb3184
--- /dev/null
+++ b/HDOJ/5468_autoAC.cpp
@@ -0,0 +1,166 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<iostream>
+#include<vector>
+#include<set>
+#include<map>
+#include<queue>
+#include<sstream>
+#include<string>
+#include<bitset>
+using namespace std;
+typedef long long LL;
+const LL LINF = (1LL <<63);
+const int INF = 1 << 31;
+const int NS = 100010;
+const int MS = 19;
+const int MOD = 1000000007;
+const int EDGE_MAX = NS;
+struct graphEdge
+{
+    int pst;
+    int next;
+};
+struct ForwardStart
+{
+    int top;
+    int head[EDGE_MAX];
+    graphEdge edge[EDGE_MAX << 1];
+    void init(int len)
+    {
+        top = 0;
+        memset(head, -1, sizeof(int) * len);
+    }
+    void addEdge(int u, int v)
+    {
+        edge[top].pst = v;
+        edge[top].next = head[u];
+        head[u] = top++;
+    }
+    void printAll()
+    {
+        printf("top = %d\n", top);
+        for(int i = 1; i < EDGE_MAX; i++)
+        {
+            if(-1 != head[i])
+            {
+                printf("head[%2d]'son:%2d", i, edge[head[i]].pst);
+                for(int j = edge[head[i]].next; j != -1; j = edge[j].next)
+                {
+                    printf(",%2d", edge[j].pst);
+                }
+                puts("");
+            }
+        }
+    }
+}cTree;
+bitset<NS> isPrime;
+vector<int> fac[NS];
+int miu[NS];
+void prepare()
+{
+    isPrime.set();
+    isPrime[1] = false;
+    miu[1] = 1;
+    for(int i = 2; i < NS; i++)
+    {
+        if(isPrime[i])
+        {
+            for(int j = i; j < NS; j+=i)
+            {
+                isPrime[j] = false;
+                int k = j / i;
+                if(k % i)
+                {
+                    miu[j] = -miu[k];
+                }
+                else
+                {
+                    miu[j] = 0;
+                }
+                fac[j].push_back(i);
+            }
+        }
+        else
+        {
+            if(miu[i] != 0)
+            {
+                for(int j = i; j < NS; j+=i)
+                {
+                    fac[j].push_back(i);
+                }
+            }
+        }
+    }
+}
+int n;
+int val[NS];
+int ans[NS];
+int sz[NS];
+int dp[NS];
+void dfs(int rt, int fa)
+{
+    vector<int> temp;
+    sz[rt] = 1;
+    int value = val[rt];
+    int len = fac[value].size();
+    for(int i = 0; i < len; i++)
+    {
+        int d = fac[value][i];
+        int cnt = dp[d];
+        temp.push_back(cnt);
+        dp[d] += 1;
+    }
+    for(int i = cTree.head[rt]; i != -1; i = cTree.edge[i].next)
+    {
+        int cson = cTree.edge[i].pst;
+        if(cson == fa) continue;
+        dfs(cson, rt);
+        sz[rt] += sz[cson];
+    }
+    ans[rt] = sz[rt];
+    for(int i = 0; i < len; i++)
+    {
+        int d = fac[value][i];
+        int cnt = dp[d] - temp[i];
+        if(cnt > 0)
+        {
+            ans[rt] += miu[d] * cnt;
+        }
+    }
+    return ;
+}
+int main()
+{
+    prepare();
+    int nCase = 1;
+    while(~scanf("%d", &n))
+    {
+        cTree.init(n + n + 2);
+        int u, v;
+        for(int i = 1; i < n; i++)
+        {
+            scanf("%d %d", &u, &v);
+            cTree.addEdge(u, v);
+            cTree.addEdge(v, u);
+        }
+        for(int i = 1; i <= n; i++)
+        {
+            scanf("%d", &val[i]);
+            if(val[i] < 0)
+            {
+                val[i] = - val[i];
+            }
+        }
+        memset(dp, 0, sizeof(dp));
+        dfs(1, -1);
+        printf("Case #%d:", nCase++);
+        for(int i = 1; i <= n; i++)
+        {
+            printf(" %d", ans[i]);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5469_autoAC.cpp b/HDOJ/5469_autoAC.cpp
new file mode 100644
index 0000000..678c0f8
--- /dev/null
+++ b/HDOJ/5469_autoAC.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <vector>
+using namespace std;
+#define N  10010
+vector<int>G[N];
+int n,len;
+char value[N],an[N];
+int dis[N];
+int f[N];
+bool visit[N];
+void init() {
+    for(int i = 1; i <= n; i++) G[i].clear();
+    memset(dis,0,sizeof(dis));
+    memset(visit,0,sizeof(visit));
+}
+void dfs(int u) {
+    int ma = -10000000;
+    visit[u] = 1;
+    for(int i = 0; i < G[u].size(); i++)
+      if(!visit[G[u][i]]) {
+          dfs(G[u][i]);
+          f[G[u][i]] = u;
+          ma = max(ma,dis[G[u][i]]);
+      }
+    if(ma == -10000000)
+      dis[u] = 1;
+    else
+      dis[u] = ma+1;
+}
+bool dfs1(int u,int x,int len1) {
+    visit[u] = 1;
+    if(x > len) return 1;
+    if(dis[u] > len1)
+    for(int i = 0; i < G[u].size(); i++) {
+        if(value[G[u][i]] == an[x] && !visit[G[u][i]]) {
+            if(dfs1(G[u][i],x+1,len1-1)) return 1;
+        }
+    }
+    else {
+        if(value[f[u]] == an[x] && !visit[f[u]]) {
+            return dfs1(f[u],x+1,len1-1);
+        }
+    }
+    return 0;
+}
+int main() {
+    int t;scanf("%d",&t);
+    int ca = 1;
+    while(t--) {
+        scanf("%d",&n);
+        init();
+        int x,y;
+        for(int i = 1; i < n; i++) {
+            scanf("%d%d",&x,&y);
+            G[x].push_back(y);
+            G[y].push_back(x);
+        }
+        scanf("%s",value+1);
+        scanf("%s",an+1);
+        dfs(1); bool flag = 0;
+        len = strlen(an+1);
+        for(int i = 1; i <= n; i++)
+          if(value[i] == an[1]) {
+              memset(visit,0,sizeof(visit));
+              if(dfs1(i,2,len-1)) {
+                  printf("Case #%d: Find\n",ca++);
+                  flag = 1;
+                  break;
+              }
+          }
+        if(!flag) printf("Case #%d: Impossible\n",ca++);
+    }
+    return 0;
+}
diff --git a/HDOJ/5470_autoAC.cpp b/HDOJ/5470_autoAC.cpp
new file mode 100644
index 0000000..412867b
--- /dev/null
+++ b/HDOJ/5470_autoAC.cpp
@@ -0,0 +1,114 @@
+#include <algorithm>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+const int N = 100000;
+const int C = 26;
+char s[N + 1];
+struct State {
+    int    length;
+    int    first;
+    State* parent;
+    State* go[C];
+    State* extend(State*, int);
+};
+int    state_count;
+State  states[N << 1];
+State* new_state(int length) {
+    State* state = states + (state_count ++);
+    state->length = length;
+    state->first  = -1;
+    state->parent = NULL;
+    memset(state->go, 0, sizeof(state->go));
+    return state;
+}
+State* State::extend(State* start, int token) {
+    State *p = this;
+    State *np = new_state(length + 1);
+    while (p && !p->go[token]) {
+        p->go[token] = np;
+        p = p->parent;
+    }
+    if (!p) {
+        np->parent = start;
+    } else {
+        State *q = p->go[token];
+        if (p->length + 1 == q->length) {
+            np->parent = q;
+        } else {
+            State *nq = new_state(p->length + 1);
+            memcpy(nq->go, q->go, sizeof(q->go));
+            nq->parent = q->parent;
+            np->parent = q->parent = nq;
+            while (p && p->go[token] == q) {
+                p->go[token] = nq;
+                p = p->parent;
+            }
+        }
+    }
+    return np;
+}
+int       cost[C], a, b, match[N + 1], queue[N + 1];
+State*    end[N + 1];
+long long minimum[N + 1];
+int main() {
+    int T;
+    scanf("%d", &T);
+    for (int t = 1; t <= T; ++ t) {
+        scanf("%s", s);
+        for (int i = 0; i < C; ++ i) {
+            scanf("%d", cost + i);
+        }
+        scanf("%d%d", &a, &b);
+        int n = strlen(s);
+        state_count = 0;
+        end[0] = new_state(0);
+        for (int i = 0; i < n; ++ i) {
+            end[i + 1] = end[i]->extend(end[0], s[i]- 'a');
+        }
+        for (int i = 0; i < n; ++ i) {
+            for (State* p = end[i + 1]; p && !~p->first; p = p->parent) {
+                p->first = i;
+            }
+        }
+        State* p = end[0];
+        for (int i = 0, l = 0; i < n; ++ i) {
+            int c = s[i] - 'a';
+            while (!p->go[c]) {
+                p = p->parent;
+                l = std::min(l, p->length);
+            }
+            p = p->go[c];
+            l ++;
+            while (p->first > i - l) {
+                l --;
+                if (p->parent->length == l) {
+                    p = p->parent;
+                }
+            }
+            match[i + 1] = l;
+        }
+        minimum[0] = 0;
+        int head = 0;
+        int tail = 0;
+        queue[tail ++] = 0;
+        for (int i = 1; i <= n; ++ i) {
+            minimum[i] = minimum[i - 1] + cost[s[i - 1] - 'a'];
+            while (head < tail && queue[head] < i - match[i]) {
+                head ++;
+            }
+            if (head < tail) {
+                int j = queue[head];
+                minimum[i] = std::min(minimum[i], minimum[j] + (long long)a * (i - j) + b + b);
+            }
+#define VALUE(i) (minimum[i] - (long long)a * (i))
+            while (head < tail && VALUE(queue[tail - 1]) > VALUE(i)) {
+                tail --;
+            }
+#undef VALUE
+            queue[tail ++] = i;
+        }
+        std::cout << "Case #" << t << ": " << minimum[n] << std::endl;;
+    }
+    return 0;
+}
diff --git a/HDOJ/5471_autoAC.cpp b/HDOJ/5471_autoAC.cpp
new file mode 100644
index 0000000..a8ccb64
--- /dev/null
+++ b/HDOJ/5471_autoAC.cpp
@@ -0,0 +1,110 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <vector>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+const int maxn = 1024 + 5;
+const int mod = 1e9 + 7;
+struct Rectangle {
+    int x1, y1, x2, y2, c;
+    Rectangle (int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0, int c = 0): x1(x1), y1(y1), x2(x2), y2(y2), c(c) {}
+    void read() { scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &c); }
+    int size() { return (x2-x1+1)*(y2-y1+1); }
+    bool in(const Rectangle& u) const {
+        return x1 <= u.x1 && u.x2 <= x2 && y1 <= u.y1 && u.y2 <= y2;
+    }
+}R[15];
+int N, M, H, W, cc, all, ct[15][maxn], sz[15][maxn];
+vector<int> X, Y, C, G[15];
+int bitcount(int x) { return x == 0 ? 0 : bitcount(x>>1) + (x&1); }
+void init () {
+    scanf("%d%d%d%d", &H, &W, &M, &N);
+    X.clear(), Y.clear(), C.clear();
+    for (int i = 0; i < N; i++) {
+        R[i].read();
+        X.push_back(R[i].x1-1);
+        X.push_back(R[i].x2);
+        Y.push_back(R[i].y1-1);
+        Y.push_back(R[i].y2);
+        C.push_back(R[i].c);
+    }
+    X.push_back(0);
+    X.push_back(H);
+    Y.push_back(0);
+    Y.push_back(W);
+    sort(X.begin(), X.end());
+    sort(Y.begin(), Y.end());
+    sort(C.begin(), C.end());
+    int cx = unique(X.begin(), X.end()) - X.begin();
+    int cy = unique(Y.begin(), Y.end()) - Y.begin();
+    cc = unique(C.begin(), C.end()) - C.begin();
+    int id[15], rk[15];
+    for (int i = 0; i < cc; i++) G[i].clear();
+    for (int i = 0; i < N; i++) {
+        id[i] = lower_bound(C.begin(), C.begin()+cc, R[i].c) - C.begin();
+        rk[i] = G[id[i]].size();
+        G[id[i]].push_back(i);
+    }
+    all = 0;
+    memset(ct, 0, sizeof(ct));
+    memset(sz, 0, sizeof(sz));
+    for (int x = 1; x < cx; x++) {
+        for (int y = 1; y < cy; y++) {
+            int t = cc, s = 0;
+            Rectangle tmp = Rectangle(X[x-1]+1, Y[y-1]+1, X[x], Y[y]);
+            for (int i = 0; i < N; i++) {
+                if (R[i].in(tmp)) {
+                    if (id[i] < t)
+                        s = 0, t = id[i];
+                    if (t == id[i])
+                        s |= (1<<rk[i]);
+                }
+            }
+            if (t == cc) all += tmp.size();
+            else {
+                int add = tmp.size();
+                for (int j = s; j; j = (j-1)&s)
+                    ct[t][j] += add;
+            }
+        }
+    }
+    for (int c = 0; c < cc; c++) {
+        int s = (1<<G[c].size());
+        for (int i = 0; i < s; i++) {
+            for (int j = i; j; j = (j-1)&i)
+                sz[c][i] += ct[c][j] * (bitcount(j)&1 ? 1 : -1);
+        }
+    }
+}
+ll pow_mod(ll x, ll n) {
+    ll ret = 1;
+    while (n) {
+        if (n&1) ret = ret * x % mod;
+        x = x * x % mod;
+        n >>= 1;
+    }
+    return ret;
+}
+int solve () {
+    ll ret = pow_mod(M, all);
+    for (int i = 0; i < cc; i++) {
+        int t = 0, n = (1<<G[i].size());
+        for (int s = 0; s < n; s++) {
+            int si = bitcount(s)&1 ? -1 : 1;
+            t = ((t + si * pow_mod(C[i]-1, sz[i][s]) * pow_mod(C[i], sz[i][n-1]-sz[i][s])) % mod + mod) % mod;
+        }
+        ret = ret * t % mod;
+    }
+    return ret;
+}
+int main () {
+    int cas;
+    scanf("%d", &cas);
+    for (int kcas = 1; kcas <= cas; kcas++) {
+        init();
+        printf("Case #%d: %d\n", kcas, solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/5473_autoAC.cpp b/HDOJ/5473_autoAC.cpp
new file mode 100644
index 0000000..08208ca
--- /dev/null
+++ b/HDOJ/5473_autoAC.cpp
@@ -0,0 +1,93 @@
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <ctime>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+struct Point {
+    ll x, y;
+    Point(ll x = 0, ll y = 0): x(x), y(y) {}
+    void read() { scanf("%lld%lld", &x, &y); } 
+    bool operator < (const Point& u) const { return x < u.x || (x == u.x && y < u.y); }
+    bool operator == (const Point& u) const { return !(*this < u) && !(u < *this); }
+    bool operator != (const Point& u) const { return !(*this == u); }
+    bool operator > (const Point& u) const { return u < *this; }
+    bool operator <= (const Point& u) const { return *this < u || *this == u; }
+    bool operator >= (const Point& u) const { return *this > u || *this == u; }
+    Point operator + (const Point& u) { return Point(x + u.x, y + u.y); }
+    Point operator - (const Point& u) { return Point(x - u.x, y - u.y); }
+    Point operator * (const double u) { return Point(x * u, y * u); }
+    Point operator / (const double u) { return Point(x / u, y / u); }
+    ll operator ^ (const Point& u) { return x*u.y - y*u.x; }
+};
+typedef Point Vector;
+ll Cross(Vector a, Vector b) { return a.x * b.y - a.y * b.x; }
+ll getArea (Point* p, int n) {
+    ll ret = 0;
+    for (int i = 0; i < n-1; i ++)
+        ret += Cross(p[i]-p[0], p[i+1]-p[0]);
+    return ret < 0 ? -ret : ret;
+}
+int getConvexHull (Point* p, int n, Point* ch) {
+    sort(p, p + n);
+    int m = 0;
+    for (int i = 0; i < n; i++) {
+        while (m > 1 && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-1]) <= 0) m--;
+        ch[m++] = p[i];
+    }
+    int k = m;
+    for (int i = n-2; i >= 0; i--) {
+        while (m > k && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-1]) <= 0) m--;
+        ch[m++] = p[i];
+    }
+    if (n > 1) m--;
+    return m;
+}
+const int maxn = 105;
+int N, K;
+ll dp[maxn][maxn];
+Point P[maxn], Q[maxn];
+ll solve () {
+    ll allarea = getArea(P, N);
+    if (K >= N) return allarea;
+    ll ret = 0;
+    bool vis[maxn];
+    memset(vis, 0, sizeof(vis));
+    int ti = min(5 * (N / K), N);
+    for (int t = 0; t < ti; t++) {
+        int s = rand() % N;
+        while (vis[s]) s = rand() % N;
+        vis[s] = 1;
+        memset(dp, 0, sizeof(dp));
+        dp[0][0] = allarea;
+        for (int i = 1; i <= N; i++) {
+            int u = (i + s) % N;
+            ll sum = 0;
+            for (int j = i-1; j >= 0; j--) {
+                int v = (j + s) % N;
+                int p = (v + 1) % N;
+                ll tmp = ((P[p]-P[u])^(P[v]-P[u]));
+                if (tmp < 0) tmp = -tmp;
+                sum += tmp;
+                for (int x = K; x > 0; x--)
+                    dp[i][x] = max(dp[i][x], dp[j][x-1]-sum);
+            }
+        }
+        ret = max(ret, dp[N][K]);
+    }
+    return ret;
+}
+int main () {
+    int cas;
+    scanf("%d", &cas);
+    srand((int)time(NULL));
+    for (int kcas = 1; kcas <= cas; kcas++) {
+        scanf("%d%d", &N, &K);
+        for (int i = 0; i < N; i++) Q[i].read();
+        N = getConvexHull(Q, N, P);
+        printf("Case #%d: %lld\n", kcas, solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/5475_autoAC.cpp b/HDOJ/5475_autoAC.cpp
new file mode 100644
index 0000000..f28a2ab
--- /dev/null
+++ b/HDOJ/5475_autoAC.cpp
@@ -0,0 +1,83 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include  <iostream>
+using namespace std;
+typedef long long ll;
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1|1
+const int maxn=155555;
+ll sum[maxn*4+4];
+int add;
+int a[maxn];
+int L,R;
+int MOD;
+int p;
+void pushup(int rt){
+    sum[rt]=sum[rt<<1]*sum[rt<<1|1]%MOD;
+}
+void build(int l,int r,int rt){
+    if(l==r){
+        sum[rt]=1;
+        return ;
+    }
+    int m=(l+r)>>1;
+    build(lson);
+    build(rson);
+    pushup(rt);
+}
+void update(int l,int r,int rt){
+    if(l==r){
+        sum[rt]=add;
+        return ;
+    }
+    int m=(l+r)>>1;
+    if(p<=m)
+        update(lson);
+    else
+        update(rson);
+    pushup(rt);
+}
+ll query(int l,int r,int rt){
+    ll ret=1;
+    if(L<=l&&R>=r)
+        return sum[rt];
+    int m=(l+r)>>1;
+    if(L<=m)
+        ret*=query(lson)%MOD;
+    if(R>m)
+        ret*=query(rson)%MOD;
+    return ret%MOD;
+}
+int main()
+{
+    int n,m;
+    int op,u,q;
+    int t;
+    scanf("%d",&t);
+    for(int case1=1;case1<=t;case1++){
+        printf("Case #%d:\n",case1);
+        scanf("%d%d",&q,&MOD);
+        build(1,q,1);
+        for(int i=1;i<=q;i++){
+            scanf("%d%d",&op,&u);
+            if(op==1){
+                p=i;
+                add=u;
+                update(1,q,1);
+                L=1;
+                R=i;
+                printf("%I64d\n",query(1,q,1)%MOD);
+            }
+            else{
+                p=u;
+                add=1;
+                update(1,q,1);
+                L=1;
+                R=i;
+                printf("%I64d\n",query(1,q,1)%MOD);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5476_autoAC.cpp b/HDOJ/5476_autoAC.cpp
new file mode 100644
index 0000000..86c4ae3
--- /dev/null
+++ b/HDOJ/5476_autoAC.cpp
@@ -0,0 +1,33 @@
+#include<cstdlib>
+#include<algorithm>
+#include<cstring>
+#include<iostream>
+#include<cstdio>
+#include<vector>
+#include<cmath>
+#include<map>
+#define pi (2*acos(0))
+#define maxn 1000000
+using namespace std;
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    for (int k=1;k<=t;k++)
+    {
+        double ax, ay, bx, by, cx, cy;
+        scanf("%lf%lf%lf%lf%lf%lf", &ax, &ay, &bx, &by, &cx, &cy);
+        double t1 = (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
+        double ab = sqrt(t1);
+        double t2 = (bx - cx) * (bx - cx) + (by - cy) * (by - cy);
+        double bc = sqrt(t2);
+        double h = sqrt(t1 - t2/4);
+        double angle = acos(bc/(2.0*ab));
+        double d = bc / sin(angle);
+        double ans = 0;
+        ans = d * angle;
+        ans = ans + h;
+        printf("Case #%d: %.4f\n", k, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5479_autoAC.cpp b/HDOJ/5479_autoAC.cpp
new file mode 100644
index 0000000..1c91376
--- /dev/null
+++ b/HDOJ/5479_autoAC.cpp
@@ -0,0 +1,51 @@
+#include <map>
+#include <set>
+#include <stack>
+#include <queue>
+#include <cmath>
+#include <ctime>
+#include <vector>
+#include <cstdio>
+#include <cctype>
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define INF 0x3f3f3f3f
+#define inf -0x3f3f3f3f
+#define lson l,m,rt<<1
+#define rson m+1,r,rt<<1|1
+#define mem0(a) memset(a,0,sizeof(a))
+#define mem1(a) memset(a,-1,sizeof(a))
+#define mem(a, b) memset(a, b, sizeof(a))
+typedef long long ll;
+char s[1010];
+int l[1010],r[1010];
+int main(){
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%s",s);
+        mem0(l);
+        mem0(r);
+        int len=strlen(s);
+        for(int i=len-1;i>=0;i--){
+            if(i==len-1)
+                r[i]=(s[i]==')');
+            else
+                r[i]=r[i+1]+(s[i]==')');
+        }
+        for(int i=0;i<len;i++){
+            if(i==0)
+                l[i]=(s[i]=='(');     
+            else
+                l[i]=l[i-1]+(s[i]=='(');
+        }
+        int ans=INF;
+        for(int i=0;i<len;i++)
+            ans=min(ans,l[i]+r[i]-1);   
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5481_autoAC.cpp b/HDOJ/5481_autoAC.cpp
new file mode 100644
index 0000000..e660fb3
--- /dev/null
+++ b/HDOJ/5481_autoAC.cpp
@@ -0,0 +1,97 @@
+#include<stdio.h>  
+#include<string.h>  
+#include<algorithm>  
+#define N 110000  
+#define pr pair<int,int>  
+#define lson l,mid,no<<1  
+#define rson mid+1,r,no<<1|1  
+#define mod 1000000007ll  
+using namespace std;  
+typedef long long ll;  
+int dis[N<<1],len;  
+pr L[N];  
+ll sum[N<<3],cov[N<<3];  
+ll P[N],S[N];  
+void Pushdown(int no,int len)  
+{  
+    if(cov[no])  
+    {  
+        cov[no<<1]+=cov[no];  
+        cov[no<<1|1]+=cov[no];  
+        sum[no<<1]+=cov[no]*(len-(len>>1));  
+        sum[no<<1|1]+=cov[no]*(len>>1);  
+        cov[no]=0;  
+    }  
+}  
+void Pushup(int no)  
+{  
+    sum[no]=sum[no<<1]+sum[no<<1|1];  
+}  
+void update(int l,int r,int no,int st,int en)  
+{  
+    if(st<=l&&r<=en)  
+    {  
+        cov[no]++;  
+        sum[no]+=r-l+1;  
+    }  
+    else  
+    {  
+        int mid=l+r>>1;  
+        Pushdown(no,r-l+1);  
+        if(en<=mid)        update(lson,st,en);  
+        else if(st>mid)    update(rson,st,en);  
+        else update(lson,st,en),update(rson,st,en);  
+        Pushup(no);  
+    }  
+}  
+int query(int l,int r,int no,int k)  
+{  
+    if(l==r)  
+        return sum[no];  
+    else  
+    {  
+        int mid=l+r>>1;  
+        Pushdown(no,r-l+1);  
+        if(k<=mid)    return query(lson,k);  
+        else        return query(rson,k);  
+    }  
+}  
+int main()  
+{  
+    int c,T;  
+    int n,i,l,r;  
+    scanf("%d",&T);  
+    P[1]=1;  
+    for(i=2;i<N;i++)  
+        P[i]=P[i-1]*2%mod;  
+    for(i=1;i<N;i++)  
+        S[i]=(S[i-1]+P[i])%mod;  
+    for(c=1;c<=T;c++)  
+    {  
+        memset(sum,0,sizeof(sum));  
+        memset(cov,0,sizeof(cov));  
+        scanf("%d",&n);  
+        for(i=1;i<=n;i++)  
+        {  
+            scanf("%d%d",&L[i].first,&L[i].second);  
+            dis[i+i-1]=L[i].first;  
+            dis[i+i]=L[i].second;  
+        }  
+        sort(dis+1,dis+n+n+1);  
+        len=unique(dis+1,dis+n+n+1)-dis-1;  
+        for(i=1;i<=n;i++)  
+        {  
+            l=lower_bound(dis+1,dis+len+1,L[i].first)-dis;  
+            r=lower_bound(dis+1,dis+len+1,L[i].second)-dis;  
+            if(l<=r-1)  
+            update(1,len-1,1,l,r-1);  
+        }  
+        ll ans=0;  
+        for(i=1;i<len;i++)  
+        {  
+            ans=(ans+(S[n]-S[n-query(1,len-1,1,i)]+mod)%mod*(((ll)dis[i+1]-dis[i]+mod)%mod)%mod)%mod;  
+        }  
+        printf("%I64d\n",ans);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/5483_autoAC.cpp b/HDOJ/5483_autoAC.cpp
new file mode 100644
index 0000000..42e53bc
--- /dev/null
+++ b/HDOJ/5483_autoAC.cpp
@@ -0,0 +1,138 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<vector>
+using namespace std;
+#define scan(x) scanf("%d",&(x))
+#define scan2(x,y) scanf("%d%d",&(x),&(y))
+#define scan3(x,y,z) scanf("%d%d%d",&(x),&(y),&(z))
+#define scan4(x,y,z,k) scanf("%d%d%d%d",&(x),&(y),&(z),&(k))
+const int maxn = 3003;
+const int maxm = maxn * maxn;
+const int inf = 1000000000;
+int n, m;
+__int64 mst;
+int map[maxn][maxn];
+int dp[maxn][maxn], best[maxn][maxn];
+int dis[maxn], pre[maxn];
+bool vis[maxn];
+vector<int> edge[maxn];
+#include<iostream>
+int minz(int a, int b)
+{
+    return a < b ? a : b;
+}
+void init()
+{
+    int i, j;
+    for(i = 0; i < n; i++)
+    {
+        for(j = 0; j < n; j++)
+            map[i][j] = dp[i][j] = inf;
+        edge[i].clear();
+        vis[i] = 0;
+        pre[i] = -1;
+        dis[i] = inf;
+    }
+}
+void input()
+{
+        for(int i=0;i<n;i++){
+                for(int j=i+1;j<n;j++){
+                        int w;scan(w);
+                        map[i][j] = map[j][i] = w;
+                }
+        }
+}
+void prim()
+{
+    int i, j, k;
+    for(i = 1; i < n; i++)
+    {
+        dis[i] = map[0][i];
+        pre[i] = 0;
+    }
+    dis[0] = inf;
+    vis[0] = 1;
+    pre[0] = -1;
+    mst = 0;
+    for(i = 0; i < n-1; i++)
+    {
+        k = 0;
+        for(j = 1; j < n; j++)
+            if(!vis[j] && dis[k] > dis[j])
+                k = j;
+        vis[k] = 1;
+        mst += dis[k];
+        if(pre[k] != -1)
+            edge[k].push_back(pre[k]),
+            edge[pre[k]].push_back(k);
+        for(j = 1; j < n; j++)
+            if(!vis[j] && dis[j] > map[k][j] )
+                dis[j] = map[k][j], pre[j] = k;
+    }
+}
+int dfs1(int u, int fa, int rt) 
+{
+    int i;
+    for(i = 0; i < edge[u].size(); i++)
+    {
+        int v = edge[u][i];
+        if(v == fa) continue;
+        dp[rt][u] = minz(dp[rt][u], dfs1(v, u, rt));
+    }
+    if(fa != rt) dp[rt][u] = minz(dp[rt][u], map[rt][u]);
+    return dp[rt][u];
+}
+int dfs2(int u, int fa, int rt) 
+{
+    int i;
+    int ans = dp[u][rt];
+    for(i = 0; i < edge[u].size(); i++)
+    {
+        int v = edge[u][i];
+        if(v == fa) continue;
+        ans = minz(ans, dfs2(v, u, rt));
+    }
+    return ans;
+}
+void solve()
+{
+    int i,j;
+    for(i = 0; i < n; i++)
+        dfs1(i, -1, i);
+    for(i = 0; i < n; i++)
+        for(j = 0; j < edge[i].size(); j++)
+        {
+            int v = edge[i][j];
+            best[i][v] = best[v][i] = dfs2(v, i, i);
+        }
+}
+void query()
+{
+    int ans =0 ;
+    for(int i=0;i<n;i++){
+        int x=i;
+        for(int j=0;j<edge[i].size() ; j++){
+                int y=edge[i][j];
+                if(x<y) continue;
+                int sum = mst - map[x][y] + best[x][y];
+                if(sum != mst){
+                        ans++;
+                }
+        }
+    }
+    printf("%d\n",ans);
+}
+int main(){
+    int T;scan(T);
+    while(T--){
+                scan(n);
+                m=n-1;
+                init();
+                input();
+                prim();
+                solve();
+                query();
+    }
+}
diff --git a/HDOJ/5486_autoAC.cpp b/HDOJ/5486_autoAC.cpp
new file mode 100644
index 0000000..9fab550
--- /dev/null
+++ b/HDOJ/5486_autoAC.cpp
@@ -0,0 +1,144 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <algorithm>
+#include <set>
+#include <bitset>
+#include <vector>
+#include <sstream>
+#include <queue>
+#include <typeinfo>
+#include <fstream>
+#include <map>
+#include <stack>
+typedef long long ll;
+using namespace std;
+#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
+#define maxn 1000006
+#define mod 1000000007
+#define eps 1e-9
+#define e exp(1.0)
+#define PI acos(-1)
+const double EP  = 1E-10 ;
+int Num;
+const ll inf=999999999;
+inline ll read()
+{
+    ll x=0,f=1;char ch=getchar();
+    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
+    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
+    return x*f;
+}
+vector<int> Q;
+map<int,int> H;
+struct node
+{
+    int x,y;
+};
+node p[maxn];
+int b[maxn];
+vector<int> Q1[maxn];
+int main()
+{
+    int t=read();
+    for(int cas=1;cas<=t;cas++)
+    {
+        int n=read();
+        H.clear();
+        for(int i=1;i<=n;i++)
+        {
+            p[i].x=read(),p[i].y=read();
+            Q.push_back(p[i].x);
+            Q.push_back(p[i].y);
+        }
+        sort(Q.begin(),Q.end());
+        Q.erase(unique(Q.begin(),Q.end()),Q.end());
+        int len = Q.size();
+        for(int i=0;i<len;i++)
+            H[Q[i]]=i;
+        for(int i=0;i<len;i++)
+            Q1[i].clear(),b[i]=0;
+        Q.clear();
+        for(int i=1;i<=n;i++)
+        {
+            Q1[H[p[i].x]].push_back(H[p[i].y]);
+        }
+        for(int i=0;i<len;i++)
+        {
+            sort(Q1[i].begin(),Q1[i].end());
+            Q1[i].erase(unique(Q1[i].begin(),Q1[i].end()),Q1[i].end());
+        }
+        for(int i=0;i<len;i++)
+        {
+            for(int j=0;j<Q1[i].size();j++)
+                b[Q1[i][j]]++;
+        }
+        int ans1 = 0,ans2 = 0,ans3 = 0;
+        for(int i=0;i<len;i++)
+        {
+            if(Q1[i].size()==0)continue;
+            if(Q1[i].size()==1)
+            {
+                if(b[Q1[i][0]]==1)
+                    ans3++;
+            }
+            else
+            {
+                int flag = 1;
+                for(int j=0;j<Q1[i].size();j++)
+                {
+                    if(b[Q1[i][j]]!=1)
+                    {
+                        flag = 0;
+                        break;
+                    }
+                }
+                if(flag)
+                    ans1++;
+            }
+        }
+        for(int i=0;i<len;i++)
+            Q1[i].clear(),b[i]=0;
+        for(int i=1;i<=n;i++)
+        {
+            Q1[H[p[i].y]].push_back(H[p[i].x]);
+        }
+        for(int i=0;i<len;i++)
+        {
+            sort(Q1[i].begin(),Q1[i].end());
+            Q1[i].erase(unique(Q1[i].begin(),Q1[i].end()),Q1[i].end());
+        }
+        for(int i=0;i<len;i++)
+        {
+            for(int j=0;j<Q1[i].size();j++)
+                b[Q1[i][j]]++;
+        }
+        for(int i=0;i<len;i++)
+        {
+            if(Q1[i].size()==0)continue;
+            if(Q1[i].size()==1)
+            {
+                if(b[Q1[i][0]]==1)
+                    ans3++;
+            }
+            else
+            {
+                int flag = 1;
+                for(int j=0;j<Q1[i].size();j++)
+                {
+                    if(b[Q1[i][j]]!=1)
+                    {
+                        flag = 0;
+                        break;
+                    }
+                }
+                if(flag)
+                    ans2++;
+            }
+        }
+        printf("Case #%d: %d %d %d\n",cas,ans1,ans2,ans3/2);
+    }
+}
diff --git a/HDOJ/5487_autoAC.cpp b/HDOJ/5487_autoAC.cpp
new file mode 100644
index 0000000..3138427
--- /dev/null
+++ b/HDOJ/5487_autoAC.cpp
@@ -0,0 +1,104 @@
+#pragma warning(disable:4996)
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <vector>
+#include <cmath>
+#include <queue>
+using namespace std;
+#define maxn 1005
+int n1, m1, k1;
+int n2, m2, k2;
+bool tar1[maxn];
+bool tar2[maxn];
+int go1[maxn][26];
+int go2[maxn][26];
+int prestate[maxn*maxn];
+char prechar[maxn*maxn];
+bool vis[maxn*maxn];
+bool check(int x)
+{
+    return tar1[x / n2] != tar2[x%n2];
+}
+int nextState(int x, int c)
+{
+    return go1[x / n2][c] * n2 + go2[x%n2][c];
+}
+int main()
+{
+    int T; cin >> T; int ca = 0;
+    while (T--)
+    {
+        memset(go1, -1, sizeof(go1));
+        memset(go2, -1, sizeof(go2));
+        memset(tar1, 0, sizeof(tar1));
+        memset(tar2, 0, sizeof(tar2));
+        int accept;
+        int ui, vi;
+        char ci[3];
+        scanf("%d%d%d", &n1, &m1, &k1);
+        for (int i = 0; i < k1; ++i){
+            scanf("%d", &accept);
+            tar1[accept] = true;
+        }
+        for (int i = 0; i < m1; ++i){
+            scanf("%d%d%s", &ui, &vi, ci);
+            go1[ui][ci[0] - 'a'] = vi;
+        }
+        for (int i = 0; i <= n1; ++i){
+            for (int k = 0; k < 26; ++k){
+                if (go1[i][k] == -1) go1[i][k] = n1;
+            }
+        }
+        scanf("%d%d%d", &n2, &m2, &k2);
+        for (int i = 0; i < k2; ++i){
+            scanf("%d", &accept);
+            tar2[accept] = true;
+        }
+        for (int i = 0; i < m2; ++i){
+            scanf("%d%d%s", &ui, &vi, ci);
+            go2[ui][ci[0] - 'a'] = vi;
+        }
+        for (int i = 0; i <= n2; ++i){
+            for (int k = 0; k < 26; ++k){
+                if (go2[i][k] == -1) go2[i][k] = n2;
+            }
+        }
+        ++n1; ++n2;
+        int ans = -1;
+        memset(vis, 0, sizeof(vis));
+        queue<int> Q;
+        Q.push(0);
+        vis[0] = true;
+        while (!Q.empty())
+        {
+            int state = Q.front(); Q.pop();
+            if (check(state)){
+                ans = state;
+                break;
+            }
+            for (int k = 0; k < 26; ++k){
+                int nstate = nextState(state, k);
+                if (!vis[nstate]){
+                    Q.push(nstate);
+                    vis[nstate] = true;
+                    prestate[nstate] = state;
+                    prechar[nstate] = k;
+                }
+            }
+        }
+        if (-1 == ans){
+            printf("Case #%d: 0\n", ++ca);
+            continue;
+        }
+        string ts;
+        while (ans != 0){
+            ts.push_back(char('a' + prechar[ans]));
+            ans = prestate[ans];
+        }
+        reverse(ts.begin(), ts.end());
+        printf("Case #%d: %s\n", ++ca, ts.c_str());
+    }
+    return 0;
+}
diff --git a/HDOJ/5489_autoAC.cpp b/HDOJ/5489_autoAC.cpp
new file mode 100644
index 0000000..7b79094
--- /dev/null
+++ b/HDOJ/5489_autoAC.cpp
@@ -0,0 +1,103 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<map>
+using namespace std ;
+const int maxn = 1e5+10 ;
+int a[maxn] , b[maxn] ;
+int c[maxn] ;
+pair<int , int> pre[maxn] ;
+int len_b = 0 ;
+int len_a = 0 ;
+int find_b(int l , int r , int v)
+{
+    while(l<=r)
+    {
+        int mid = (l+r)>> 1 ;
+        if(b[mid]>=v)
+        l = mid+1 ;
+        else r = mid - 1 ;
+    }
+    return l;
+}
+int find_a(int l , int r ,int v)
+{
+    while(l<=r)
+    {
+        int mid = (l + r) >> 1 ;
+        if(a[mid]<=v)
+        l = mid+1 ;
+        else r = mid - 1 ;
+    }
+    return l ;
+}
+int find_ans_a(int l , int r , int v)
+{
+    while(l<=r)
+    {
+        int mid = (l+r)>>1 ;
+        if(a[mid]<=v)
+        l = mid + 1 ;
+        else r = mid - 1 ;
+    }
+    return r ;
+}
+int find_ans_b(int l , int r , int v)
+{
+    while(l<=r)
+    {
+        int mid = (l+r) >> 1 ;
+        if(b[mid] >= v)
+        l = mid + 1 ;
+        else r = mid - 1 ;
+    }
+    return r ;
+}
+void debuga()
+{
+    for(int i = 1;i <= len_a;i++)
+    printf("%d%c" , a[i] , i == len_ ?'\n' :' ') ;
+}
+int main()
+{
+    int t ;
+    scanf("%d" , &t) ;
+    int cas = 0 ;
+    while(t--)
+    {
+        int n , l ;
+        scanf("%d%d" , &n , &l) ;
+        for(int i = 1;i <= n;i++)
+        a[i] = b[i] = 0 ;
+        for(int i = 1;i <= n;i++)
+        scanf("%d" , &c[i]) ;
+        len_a = len_b  = 0 ;
+        for(int j = n;j > l;j--)
+        {
+            int pos = find_b(1 , len_ , c[j]) ;
+            pre[j] = make_pair(pos , b[pos]) ;
+            if(!b[pos])len_b++ ;
+            b[pos] = c[j] ;
+        }
+        int ans = len_ ;
+        for(int i = 1;i <= n-l;i++)
+        {
+            int pos = find_a(1 , len_ , c[i]) ;
+            if(a[pos] == 0)len_a++ ;
+            a[pos] = c[i] ;
+            pair<int , int> tmp = pre[i+l] ;
+            if(tmp.second == 0)len_b--;
+            else b[tmp.first] = tmp.second ;
+            int pos_1 = find_ans_b(1  , len_ , c[i]) ;
+            ans = max(pos+pos_ , ans) ;
+            if(tmp.second != 0)
+            {
+                int pos_2 = find_ans_a(1 , len_ , tmp.second) ;
+                ans = max(ans , pos_2 + tmp.first) ;
+            }
+        }
+        printf("Case #%d: " , ++cas) ;
+        printf("%d\n" , ans) ;
+    }
+    return  0 ;
+}
diff --git a/HDOJ/5490_autoAC.cpp b/HDOJ/5490_autoAC.cpp
new file mode 100644
index 0000000..5bb2d3c
--- /dev/null
+++ b/HDOJ/5490_autoAC.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#define LL long long
+#define MOD 1000000007
+using namespace std;
+LL b1, q, a1, d, n, m;
+LL ans, dis[10005];
+void input()
+{
+    ans = 0;
+    scanf("%I64d%I64d%I64d%I64d%I64d%I64d", &b1, &q, &a1, &d, &n, &m);
+}
+void exgcd(LL a, LL b, LL &x, LL &y, LL &d)
+{
+    if (b == 0)
+    {
+        x = 1;
+    y = 0;
+    d = a;
+    }
+    else
+    {
+        exgcd(b, a%b, y, x, d);
+        y -= a/b*x;
+    }
+}
+LL modDiv(LL a, LL b)
+{
+    LL x, y, d;
+    exgcd(b, MOD, x, y, d);
+    x = (x+MOD) % MOD;
+    x = (x*a/d) % MOD;
+    return x;
+}
+LL quickPow(LL x, LL n)
+{
+    LL a = 1;
+    while (n)
+    {
+        a *= n&1 ? x : 1;
+        a %= MOD;
+        n >>= 1 ;
+        x *= x;
+        x %= MOD;
+    }
+    return a;
+}
+void work()
+{
+    LL now = b1, tmp;
+    now %= MOD;
+    for (int i = 1; i <= n; ++i)
+    {
+        tmp = modDiv(now, q-1);
+        now = now+tmp;
+        now %= MOD;
+        dis[i] = (a1+(i-1)*d%MOD-tmp)%MOD;
+        dis[i] = (dis[i]+MOD)%MOD;
+    }
+    LL qt = 1;
+    ans += qt*dis[n];
+    for (int i = n-1; i > 0; --i)
+    {
+        qt = modDiv((qt*((n+m-1)-i)%MOD+MOD)%MOD, n-i);
+        ans += (qt*dis[i])%MOD;
+        ans %= MOD;
+    }
+    tmp = quickPow(q, (m-1)%(MOD-1))%MOD;
+    ans += now*tmp%MOD;
+    ans %= MOD;
+    printf("%I64d\n", ans);
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    for (int times = 1; times <= T; ++times)
+    {
+        printf("Case #%d: ", times);
+        input();
+        work();
+    }
+    return 0;
+}
diff --git a/HDOJ/5491_autoAC.cpp b/HDOJ/5491_autoAC.cpp
new file mode 100644
index 0000000..ef823ce
--- /dev/null
+++ b/HDOJ/5491_autoAC.cpp
@@ -0,0 +1,112 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <algorithm>
+#include <set>
+#include <bitset>
+#include <vector>
+#include <sstream>
+#include <queue>
+#include <typeinfo>
+#include <fstream>
+#include <map>
+#include <stack>
+typedef long long ll;
+using namespace std;
+#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
+#define maxn 300006
+#define mod 1000000007
+#define eps 1e-9
+#define e exp(1.0)
+#define PI acos(-1)
+const double EP  = 1E-10 ;
+int Num;
+const ll inf=999999999;
+inline ll read()
+{
+    ll x=0,f=1;char ch=getchar();
+    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
+    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
+    return x*f;
+}
+int get(ll x)
+{
+    int c =0 ; 
+    while (x >0)
+    {
+        if((x &1) ==1) 
+            c++; ; 
+        x >>=1 ; 
+    }
+    return c ;
+}
+ll change(ll x,int num)
+{
+    for(int i=0;i<132;i++)
+    {
+        if((x&(1LL<<i))==0)
+        {
+            x|=(1LL<<i);
+            num--;
+        }
+        if(num==0)
+            break;
+    }
+    return x;
+}
+ll change2(ll x,int K,int s1,ll P)
+{
+    int l =0;
+    for(int i=0;i<132;i++)
+    {
+        if((x&(1LL<<i))==0)
+        {
+            x|=(1LL<<i);
+            l = i;
+            break;
+        }
+    }
+    int num = K+1;
+    for(int i = l-1;i>=0;i--)
+    {
+        x-=(1LL<<i);
+        num--;
+        if(num==s1)
+            break;
+    }
+    if(x>P*2)return P;
+    return x;
+}
+int main()
+{
+    int t;scanf("%d",&t);
+    for(int cas = 1;cas <= t;cas ++)
+    {
+        ll a=read(),s1=read(),s2=read();
+        ll ans = a+1;
+        printf("Case #%d: ",cas);
+        int len = get(ans);
+        if(len<=s2&&len>=s1)
+        {
+            printf("%I64d\n",ans);
+            continue;
+        }
+        if(len<s1)
+        {
+            printf("%I64d\n",change(ans,s1-len));
+            continue;
+        }
+        if(len>s2)
+        {
+            while(len>s2)
+            {
+                ans = change2(ans,len,s1,a);
+                len = get(ans);
+            }
+            printf("%I64d\n",ans);
+        }
+    }
+}
diff --git a/HDOJ/5492_autoAC.cpp b/HDOJ/5492_autoAC.cpp
new file mode 100644
index 0000000..8f61e01
--- /dev/null
+++ b/HDOJ/5492_autoAC.cpp
@@ -0,0 +1,97 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include <stack>
+#include <map>
+#include <set>
+#include <queue>
+#include <iomanip>
+#include <string>
+#include <ctime>
+#include <list>
+#include <bitset>
+typedef unsigned char byte;
+#define pb push_back
+#define input_fast std::ios::sync_with_stdio(false);std::cin.tie(0)
+#define pi acos(-1)
+using namespace std;
+const int maxn = 30 + 10;
+int dp[maxn][maxn][2000];
+int g[maxn][maxn] , n , m , px ,dir[2][2] = {0,1,1,0},tans;
+int cal(int x,int y)
+{
+    return px*x - y*y;
+}
+bool inmap(int x,int y)
+{
+    return x <= n && x >= 1 && y <= m && y >= 1;
+}
+void initiation()
+{
+    tans = 1 << 29;
+    scanf("%d%d",&n,&m);
+    for(int i = 1 ; i <= n ; ++ i)
+        for(int j = 1 ; j <= m ; ++ j)
+            scanf("%d",&g[i][j]);
+    px = n + m - 1;
+    memset(dp,-1,sizeof(dp));
+    dp[1][1][g[1][1]] = g[1][1]*g[1][1];
+}
+void updata(int &x ,int v)
+{
+    if(x==-1) x=v;
+    else x = min(x,v);
+}
+int solve()
+{
+    for(int i = 1 ; i <= n ; ++ i)
+        for(int j = 1 ; j <= m ; ++ j)
+        {
+            for(int z = 0 ; z <= 1900 ; ++ z)
+            {
+                if(dp[i][j][z] == -1) continue;
+                for(int k = 0 ; k < 2 ; ++ k)
+                {
+                    int newx = i + dir[k][0];
+                    int newy = j + dir[k][1];
+                    if(!inmap(newx,newy)) continue;
+                    int newval = dp[i][j][z] + g[newx][newy]*g[newx][newy];
+                    updata(dp[newx][newy][z+g[newx][newy]],newval);
+                }
+            }
+        }
+    int ans = 1 << 30;
+    for(int i = 0 ; i <= 1900 ; ++ i) if(dp[n][m][i] != -1) ans = min(ans , px*dp[n][m][i] - i*i);
+    return ans;
+}
+void dfs(int x,int y,int s1,int s2)
+{
+    if(x==n&&y==m)
+    {
+        tans =min(tans,s1*px-s2*s2);
+    }
+    else
+    {
+            for(int k = 0 ; k < 2 ; ++ k)
+            {
+                int newx = x + dir[k][0];
+                int newy = y + dir[k][1];
+                if(!inmap(newx,newy)) continue;
+                dfs(newx,newy,s1+g[newx][newy]*g[newx][newy],s2+g[newx][newy]);
+            }
+    }
+}
+int main(int argc,char *argv[])
+{
+    int Case,cas=1;
+    scanf("%d",&Case);
+    while(Case--)
+    {
+        initiation();
+        printf("Case #%d: %d\n",cas++,solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/5493_autoAC.cpp b/HDOJ/5493_autoAC.cpp
new file mode 100644
index 0000000..a08e641
--- /dev/null
+++ b/HDOJ/5493_autoAC.cpp
@@ -0,0 +1,132 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <algorithm>
+#include <set>
+#include <bitset>
+#include <vector>
+#include <sstream>
+#include <queue>
+#include <typeinfo>
+#include <fstream>
+#include <map>
+#include <stack>
+typedef long long ll;
+using namespace std;
+#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
+#define maxn 200006
+#define mod 1000000007
+#define eps 1e-9
+#define e exp(1.0)
+#define PI acos(-1)
+#define lowbit(x) (x)&(-x)
+const double EP  = 1E-10 ;
+int Num;
+const ll inf=999999999;
+inline ll read()
+{
+    ll x=0,f=1;char ch=getchar();
+    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
+    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
+    return x*f;
+}
+int n,val1[maxn],val2[maxn];
+void add(int * vc,int u ,int v)
+{
+    while(u <= n )
+    {
+        vc[u] += v;
+        u += lowbit(u);
+    }
+}
+int query(int * vc,int u)
+{
+    int res=0;
+    while(u)
+    {
+        res += vc[u];
+        u -= lowbit(u);
+    }
+    return res;
+}
+int RankGet(int * vc,int k)
+{
+    int L = 1 , R = n;
+    while(L < R)
+    {
+        int mid = L + ((R-L)>>1);
+        int res = query(vc,mid);
+        if(res == k) R = mid;
+        else if(res < k) L = mid + 1;
+        else R = mid - 1;
+    }
+    return L;
+}
+struct kkk
+{
+    int x,y;
+};
+bool cmp(kkk aa,kkk bb)
+{
+    return aa.x<bb.x;
+}
+kkk p[maxn];
+int ans[maxn];
+vector<int> v1,v2;
+int main()
+{
+    int t=read();
+    for(int cas=1;cas<=t;cas++)
+    {
+        n=read();
+        for(int i=1;i<=n;i++)
+        {
+            p[i].x=read(),p[i].y=read();
+            p[i].y++;
+        }
+        sort(p+1,p+n+1,cmp);
+        int flag=1;
+        memset(val1,0,4*(n+2));memset(val2,0,4*(n+2));
+        for(int i = 1 ; i <= n ; ++ i)
+        {
+            add(val1,i,1);
+            add(val2,i,1);
+        }
+        for(int i=1;i<=n;i++)
+        {
+            if(p[i].y>n-i+1)
+            {
+                flag=0;
+                break;
+            }
+            int p1 = RankGet(val1,p[i].y);
+            int p2 = n-RankGet(val2,p[i].y) + 1;
+            if(p1<p2)
+            {
+                ans[p1]=p[i].x;
+                add(val1,p1,-1);
+                add(val2,n-p1+1,-1);
+            }
+            else
+            {
+                ans[p2]=p[i].x;
+                add(val1,p2,-1);
+                add(val2,n-p2+1,-1);
+            }
+        }
+        printf("Case #%d:",cas);
+        if(!flag)
+        {
+            printf(" impossible\n");
+        }
+        else
+        {
+            for(int i=1;i<=n;i++)
+                printf(" %d",ans[i]);
+            printf("\n");
+        }
+    }
+}
diff --git a/HDOJ/5494_autoAC.cpp b/HDOJ/5494_autoAC.cpp
new file mode 100644
index 0000000..a27f057
--- /dev/null
+++ b/HDOJ/5494_autoAC.cpp
@@ -0,0 +1,44 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <stack>
+#include <queue>
+#include <map>
+#include <set>
+#include <vector>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-6;
+const double pi = acos(-1.0);
+const int INF = 0x3f3f3f3f;
+const int MOD = 1000000007;
+#define ll long long
+#define CL(a) memset(a,0,sizeof(a))
+int main ()
+{
+    int T,n,m;
+    int a[1111],b[1111];
+    cin>>T;
+    while (T--)
+    {
+        cin>>n>>m;
+        for (int i=0; i<n; i++)
+            cin>>a[i];
+        for (int i=0; i<n; i++)
+            cin>>b[i];
+        sort(a, a+n);
+        sort(b, b+n);
+        int suma=0,sumb=0;
+        for (int i=1; i<=m; i++)
+        {
+            suma+=a[i-1];
+            sumb+=b[n-i];
+        }
+        if (suma>sumb)
+            cout<<"YES"<<endl;
+        else
+            cout<<"NO"<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5495_autoAC.cpp b/HDOJ/5495_autoAC.cpp
new file mode 100644
index 0000000..bdd45d2
--- /dev/null
+++ b/HDOJ/5495_autoAC.cpp
@@ -0,0 +1,34 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#include<cstdio>
+using namespace std;
+#define maxn 100007
+int a[maxn],b[maxn],vis[maxn];
+int dfs(int x){
+    vis[x] = 1;
+    if(vis[b[a[x]]]) return 1;
+    return dfs(b[a[x]])+1;
+}
+int main(){
+    int t,n,u;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(int i = 1;i <= n; i++){
+            scanf("%d",&u);
+            a[u] = i;
+        }
+        for(int i = 1;i <= n; i++)
+            scanf("%d",&b[i]);
+        memset(vis,0,sizeof(vis));
+        int ans = n;
+        for(int i = 1;i <= n; i++){
+            if(vis[i] == 0) {
+                if(dfs(i) > 1) ans--;
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5496_autoAC.cpp b/HDOJ/5496_autoAC.cpp
new file mode 100644
index 0000000..30e1597
--- /dev/null
+++ b/HDOJ/5496_autoAC.cpp
@@ -0,0 +1,39 @@
+#include<cstdio>
+#include<cstdlib>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+#include<vector>
+using namespace std;
+typedef long long LL;
+const LL mod = 1000000007;
+const int maxn = 100005;
+int b[maxn],a[maxn];
+int n,m;
+LL cnt[maxn];
+LL B[maxn];
+int main() {
+    int t;
+    cin >> t;
+    B[0] = 1;
+    for (int i = 1;i < maxn;i++) B[i] = (B[i - 1] * 2) % mod;
+    while (t--) {
+        memset(cnt, 0, sizeof(cnt));
+        cin >> n;
+        for (int i = 0;i < n;i++) {
+            scanf("%d", &a[i]);
+            b[i] = a[i];
+        }
+        sort(b, b + n);
+        m = unique(b, b + n) - b;
+        LL ret = 0;
+        for (int i = 0;i < n;i++) {
+            int x = lower_bound(b, b + m, a[i]) - b;
+            ret = ((ret - ((cnt[x] * (LL)a[i]) % mod * B[n - i - 1])%mod)%mod+mod)%mod;
+            ret = (ret + B[n - 1] * (LL)a[i]) % mod;
+            cnt[x] = (cnt[x] + B[i])%mod;
+        }
+        cout << ret << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5497_autoAC.cpp b/HDOJ/5497_autoAC.cpp
new file mode 100644
index 0000000..64e126a
--- /dev/null
+++ b/HDOJ/5497_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <queue>
+#include <string>
+#include <set>
+#include <vector>
+using namespace std;
+#define pr(x) cout << #x << " = " << x << "  "
+#define prln(x) cout << #x << " = " << x << endl
+const int N = 1e5 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
+int n, m, a[N], b[N], c[N];
+void add(int *b, int i, int v) {
+    for(; i <= n; i += i & -i) b[i] += v;
+}
+int sum(int *b, int i) {
+    int ret = 0;
+    for(; i; i -= i & -i) ret += b[i];
+    return ret;
+}
+inline int read() {
+    int c, x;
+    while(c = getchar(), !isdigit(c));
+    x = c - '0';
+    while(c = getchar(), isdigit(c)) x = x * 10 + c - '0';
+    return x;
+}
+int main() {
+    ios_base::sync_with_stdio(0);
+    int t; t = read();
+    while(t--) {
+        n = read(); m = read();
+        for(int i = 1; i <= n; ++i) a[i] = read();
+        memset(b, 0, sizeof b);
+        memset(c, 0, sizeof c);
+        long long tmp = 0;
+        for(int i = m + 1; i <= n; ++i) {
+            tmp += i - m - 1 - sum(c, a[i]);
+            add(c, a[i], 1);
+        }
+        long long ans = tmp;
+        for(int i = m + 1; i <= n; ++i) {
+            tmp -= sum(c, a[i] - 1);
+            tmp -= sum(b, n) - sum(b, a[i]);
+            add(c, a[i], -1);
+            tmp += sum(c, a[i - m] - 1);
+            tmp += sum(b, n) - sum(b, a[i - m]);
+            add(b, a[i - m], 1);
+            ans = min(ans, tmp);
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5498_autoAC.cpp b/HDOJ/5498_autoAC.cpp
new file mode 100644
index 0000000..71c5a3d
--- /dev/null
+++ b/HDOJ/5498_autoAC.cpp
@@ -0,0 +1,99 @@
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+#include<cstdio>
+#include<math.h>
+using namespace std;
+#define ll long long
+#define maxn 101
+int p;
+struct Node{
+    int mat[maxn][maxn];
+    void init(){
+        memset(mat,0,sizeof(mat));
+    }
+    void one(int n){
+        init();
+        for(int i = 0;i < n; i++)
+            mat[i][i] = 1;
+    }
+    int Det(int n,  int mod1){ 
+        int ans = 1;
+        int *p1,*p2,mul;
+        for(int i = 0;i < n; i++){
+            for(int j = i+1;j < n; j++){
+                while(mat[i][i] != 0 && mat[j][i] != 0){
+                    if(abs(mat[i][i]) > abs(mat[j][i]))
+                        p1=mat[i],p2=mat[j],mul=mat[i][i]/mat[j][i];
+                    else
+                        p1=mat[j],p2=mat[i],mul=mat[j][i]/mat[i][i];
+                    for(int l = i;l < n; l++)
+                        p1[l] = (p1[l]-(ll)p2[l]*mul)%mod1;
+                }
+                if(mat[i][i] == 0){
+                    ans = -ans;
+                    for(int l = i;l < n;l++)
+                        swap(mat[i][l],mat[j][l]);
+                }
+            }
+            ans = (ll)ans*mat[i][i] % mod1;
+        }
+        return (ans+mod1)%mod1;
+    }
+};
+int matrix[maxn][maxn];
+void multi(Node& a,Node& b,int n){ 
+    for(int i = 0;i < n; i++)
+        for(int j = 0;j < n; j++)
+            matrix[i][j] = 0;
+    for(int i = 0;i < n; i++){
+        for(int j = 0;j < n; j++){
+            if(a.mat[i][j] == 0) continue;
+            for(int k = 0;k < n; k++){
+                if(b.mat[j][k] == 0) continue;
+                matrix[i][k] = (matrix[i][k]+(ll)a.mat[i][j]*b.mat[j][k])%p;
+            }
+        }
+    }
+    for(int i = 0;i < n; i++)
+        for(int j = 0;j < n; j++)
+            a.mat[i][j] = matrix[i][j];
+}
+int mp[maxn][maxn];
+int main(){
+    int t,n,m,q,u,v;
+    Node a,b,c;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d%d%d",&n,&m,&p,&q);
+        c.init();
+        for(int i = 0;i < m; i++){
+            scanf("%d%d",&u,&v);
+            u--,v--;
+            c.mat[u][u]++;
+            c.mat[v][v]++;
+            c.mat[u][v] = c.mat[v][u] = -1;
+        }
+        if(q < n-1){
+            printf("0\n");
+            continue;
+        }
+        int ans = c.Det(n-1,p);
+        if(ans == 0){
+            printf("0\n");
+            continue;
+        }
+        a.init();
+        b.one(n);
+        for(int i = 1;i < n; i++)
+            a.mat[i][i] = i,a.mat[i][i-1] = n-i;
+        while(q){
+            if(q&1) multi(b,a,n);
+            multi(a,a,n);
+            q/=2;
+        }
+        ans = (ll)ans*b.mat[n-1][0]%p;
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5499_autoAC.cpp b/HDOJ/5499_autoAC.cpp
new file mode 100644
index 0000000..3780348
--- /dev/null
+++ b/HDOJ/5499_autoAC.cpp
@@ -0,0 +1,68 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <algorithm>
+using namespace std;
+#define maxn 110
+class node
+{
+public:
+    string sex,name;
+    double sum;
+    int r1,r2;
+    void set(string n,string s,int o,int t)
+    {
+        sex=s,name=n;
+        r1=o,r2=t;
+    }
+}male[maxn],fe[maxn],ans[maxn];
+bool cmp(node x,node y)
+{
+    return x.sum>y.sum;
+}
+int main()
+{
+    int T;
+    cin>>T;
+    while(T--)
+    {
+        int n,m;
+        cin>>n>>m;
+        string name,sex;
+        int r1,r2,rr1=0,rr2=0;
+        int f=0,p=0,top=0;
+        for(int i=0;i<n;i++)
+        {
+            cin>>name>>sex>>r1>>r2;
+            rr1=max(rr1,r1);
+            rr2=max(rr2,r2);
+            if(sex=="male") male[p++].set(name,sex,r1,r2);
+            else fe[f++].set(name,sex,r1,r2);
+        }
+        double m1,m2;
+        m1=300*1.0/rr1,m2=300*1.0/rr2;
+        for(int i=0;i<p;i++)
+            male[i].sum=male[i].r1*(m1)*0.3+male[i].r2*(m2)*0.7;
+        for(int i=0;i<p;i++)
+            fe[i].sum=fe[i].r1*(m1)*0.3+fe[i].r2*(m2)*0.7;
+        sort(male,male+p,cmp);
+        sort(fe,fe+f,cmp);       
+        if(f)
+            ans[top++]=fe[0];
+        for(int i=0;i<p;i++)
+        {
+            ans[top++]=male[i];
+        }
+        for(int i=0;i<f;i++)
+        {
+            if(fe[i].name!=ans[0].name)
+                ans[top++]=fe[i];
+        }
+        sort(ans+1,ans+top,cmp);
+        sort(ans,ans+m,cmp);
+        cout<<"The member list of Shandong team is as follows:"<<endl;
+        for(int i=0;i<m;i++) cout<<ans[i].name<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5500_autoAC.cpp b/HDOJ/5500_autoAC.cpp
new file mode 100644
index 0000000..3326cf3
--- /dev/null
+++ b/HDOJ/5500_autoAC.cpp
@@ -0,0 +1,40 @@
+#include<cstdio>
+#include<cstdlib>
+#include<vector>
+#include<cstring>
+#include<set>
+#include<queue>
+#include<stack>
+#include<map>
+#include<algorithm>
+#include<iostream>
+#include<ctime>
+#include<bitset>
+using namespace std;
+#define N 300005
+#define NMAX 2000000000 
+typedef long long ll;
+int a[22];
+bool cmp(const int& x, const int& y){
+    return x>y;
+}
+int main(){
+    int T, n, m;
+    while ( scanf("%d", &T) != EOF){
+        while ( T > 0 ){
+            T--;
+            scanf("%d", &n);
+            int index = -1;
+            for ( int i = 0 ;i < n; i++ ){
+                scanf("%d", &a[i]);
+            }
+            int ans = 0, t = n - 1, cur = n;
+            while ( t >= 0 ){
+                if ( a[t] == cur ) cur--;
+                t--;
+            }
+            cout << cur << endl;
+        }
+    } 
+    return 0;
+}
diff --git a/HDOJ/5501_autoAC.cpp b/HDOJ/5501_autoAC.cpp
new file mode 100644
index 0000000..a8a8c61
--- /dev/null
+++ b/HDOJ/5501_autoAC.cpp
@@ -0,0 +1,76 @@
+#include<stdio.h>
+#include<iostream>
+#include<string>
+#include<string.h>
+#include<algorithm>
+#include<iomanip>
+#include<vector>
+#include<time.h>
+#include<queue>
+#include<stack>
+#include<iterator>
+#include<math.h>
+#include<stdlib.h>
+#include<limits.h>
+#include<map>
+#include<set>
+#include<bitset>
+#define eps 1e-5
+#define INF 0x7fffffff
+#define FOR(i,a) for((i)=0;i<(a);(i)++)
+#define MEM(a) (memset((a),0,sizeof(a)))
+#define sfs(a) scanf("%s",a)
+#define sf(a) scanf("%d",&a)
+#define sfI(a) scanf("%I64d",&a)
+#define pf(a) printf("%d\n",a)
+#define pfI(a) printf("%I64d\n",a)
+#define pfs(a) printf("%s\n",a)
+#define sfd(a,b) scanf("%d%d",&a,&b)
+#define sft(a,b,num) scanf("%d%d%d",&a,&b,&num)
+#define for1(i,a,b) for(int i=(a);i<b;i++)
+#define for2(i,a,b) for(int i=(a);i<=b;i++)
+#define for3(i,a,b)for(int i=(b);i>=a;i--)
+#define MEM1(a) memset(a,0,sizeof(a))
+#define MEM2(a) memset(a,-1,sizeof(a))
+#define ll long long
+const double PI=acos(-1.0);
+template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
+template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
+template<class T> inline T Min(T a,T b){return a<b?a:b;}
+template<class T> inline T Max(T a,T b){return a>b?a:b;}
+using namespace std;
+int n,m,L;
+#define N 50005
+#define M 1000100
+#define Mod 1000000007
+#define p(x,y) make_pair(x,y)
+int dp[5010];
+struct Node{
+    int a,b,c;
+    bool operator <(const Node &x) const{
+        return (ll)b*x.c>(ll)x.b*c;
+    }
+}e[1010];
+int main(){
+    int T;
+    sf(T);
+    while(T--){
+        int t;
+        sfd(n,t);
+        for(int i=1;i<=n;i++){
+            scanf("%d%d%d",&e[i].a,&e[i].b,&e[i].c);
+        }
+        sort(e+1,e+n+1);
+        memset(dp,0,sizeof dp);
+        for(int i=1;i<=n;i++){
+            for(int j=t;j>=e[i].c;j--){
+                dp[j] = Max(dp[j],dp[j-e[i].c]+Max(0,e[i].a-j*e[i].b));
+            }
+        }
+        int ans=-INF;
+        for(int i=0;i<=t;i++)
+            ans = Max(ans,dp[i]);
+        pf(ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5502_autoAC.cpp b/HDOJ/5502_autoAC.cpp
new file mode 100644
index 0000000..db3c7bd
--- /dev/null
+++ b/HDOJ/5502_autoAC.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+double dp[1550];
+double power[1550];
+double ans[1550];
+double pre[1550];
+int main(){
+    int T,n;
+    double p,q;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d%lf%lf",&n,&p,&q);
+        power[0]=1;
+        double pro0=q/p;
+        double pro1=(p-q)/p;
+        for(int i=1;i<=n+1;i++){
+            power[i]=power[i-1]*pro0;
+        }
+        ans[0]=0;
+        n++;
+        for(int i=1;i<=n;i++){
+            dp[0]=pre[0]=1;
+            for(int j=1;j<=n;j++){
+                double now=pre[j-1];
+                if(j-1-i>=0) now-=pre[j-1-i]*power[i];
+                dp[j]=now*pro1;
+                pre[j]=pre[j-1]*pro0+dp[j];
+            }
+            ans[i]=dp[n];
+        }
+        double e=0;
+        for(int i=n;i>=1;i--){
+            e+=(ans[i]-ans[i-1])*i;
+        }
+        e/=pro1;
+        printf("%.3lf\n",e);
+    }
+    return 0;
+}
diff --git a/HDOJ/5503_autoAC.cpp b/HDOJ/5503_autoAC.cpp
new file mode 100644
index 0000000..06df29b
--- /dev/null
+++ b/HDOJ/5503_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define LL long long
+#define N 50007
+LL c[N], s[N];
+void init() {
+    for (LL i = 1; i < N; ++i)
+        c[i] = i * (i - 1) >> 1;
+}
+inline int read() {
+    int ret = 0;
+    char ch = getchar();
+    while (!('0' <= ch && ch <= '9'))
+        ch = getchar();
+    while ('0' <= ch && ch <= '9') {
+        ret = ret * 10 + ch - '0';
+        ch = getchar();
+    }
+    return ret;
+}
+int main() {
+    init();
+    int T = read();
+    int n, i;
+    LL sum;
+    bool flag;
+    while (T--) {
+        n = read();
+        for (i = 0; i < n; ++i)
+            s[i] = read();
+        sort(s, s + n);
+        sum = 0;
+        flag = true;
+        for (i = 1; i <= n; ++i) {
+            sum = sum + s[i - 1];
+            if (sum < c[i]) {
+                flag = false;
+                break;
+            }
+        }
+        if (sum != c[n])
+            flag = false;
+        if (flag)
+            puts("It seems to have no problem.");
+        else
+            puts("The data have been tampered with!");
+    }
+    return 0;
+}
diff --git a/HDOJ/5504_autoAC.cpp b/HDOJ/5504_autoAC.cpp
new file mode 100644
index 0000000..eb41b31
--- /dev/null
+++ b/HDOJ/5504_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <stack>
+#include <queue>
+#include <map>
+#include <set>
+#include <vector>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-6;
+const double pi = acos(-1.0);
+const int INF = 0x3f3f3f3f;
+const int MOD = 1000000007;
+#define ll long long
+#define CL(a) memset(a,0,sizeof(a))
+int main()
+{
+    int T;
+    ll n,x,sum;
+    cin>>T;
+    while(T--)
+    {
+        cin>>n;
+        sum = 0;
+        int k=0,re=0;
+        ll maxx = -INF;
+        for(int i=0; i<n; i++)
+        {
+            cin>>x;
+            if(x == 0) {re++; continue;}
+            if(x < 0)
+            {
+                k++;
+                maxx = max(maxx, x);
+            }
+            if(i == re) sum = x;
+            else sum *= x;
+        }
+        if(k%2&&n!=1&&!(k==1&&re+k==n)) sum /= maxx;
+        if(re>0&&(sum<0||n==1)) sum = 0;
+        cout<<sum<<endl;
+    }
+    return 0;
+}