diff --git a/HDOJ/4600_autoAC.cpp b/HDOJ/4600_autoAC.cpp
new file mode 100644
index 0000000..9fed935
--- /dev/null
+++ b/HDOJ/4600_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <stdio.h>
+#include <string.h>
+#define LL __int64
+struct corns {
+    int q, p, n, m;
+}a[1111];
+int s[11] , ss[11], D, Y;
+LL ans , val[1002];
+void solve1(int i) {
+    LL cur = Y;
+    int day = 0, j;
+    while(day <= D) {
+        if(day + a[i].n <= D) {
+            LL tot = cur/a[i].q;
+            for(j = 9;j >= 1; j--) if(s[j]) {
+                if(j*a[i].p > a[i].q)   {
+                    if(tot <= s[j]) {
+                        cur += tot * (LL)( j*a[i].p - a[i].q );
+                        tot = 0;
+                        break;
+                    }
+                    else {
+                        cur += (LL)s[j] * ( j*a[i].p - a[i].q );
+                        tot -= s[j];
+                    }
+                }
+                else    break;
+            }
+        }
+        day += a[i].n;
+    }
+    if(cur > ans)        ans = cur;
+}
+void solve2(int i) {
+    int j, k, l;
+    memset(val, 0, sizeof(val));
+    LL cur = Y;
+    for(j = 1;j <= 9; j++)    ss[j] = s[j];
+    for(j=  0;j <= D; j++) {
+        cur += val[j];
+        LL tot = cur/a[i].q;
+        for(k = 9;k >= 1; k--) if(ss[k]){
+            int to = j+a[i].n;
+            if(to > D)    break;
+            LL now = k*a[i].p;
+            now += (LL)(D-to)/a[i].m * k*a[i].p;
+            if(now > a[i].q) {
+                LL get;
+                if(tot > ss[k])    get = ss[k];
+                else    get = tot;
+                ss[k] -= (int)get;
+                tot -= get;
+                cur -= get*a[i].q;
+                val[to] += get * k *a[i].p;
+                for(l = to+a[i].m;l <= D; l += a[i].m)    val[l] += get *k * a[i].p;
+            }
+            else    break;
+        }
+    }
+    if(cur > ans)    ans = cur;
+}
+int main() {
+    int t, w, h, A, i;
+    scanf("%d", &t);
+    while(t--) {
+        scanf("%d%d%d%d%d", &w, &h, &A, &D, &Y);
+        memset(s, 0, sizeof(s));
+        s[9] = (w/3) * (h/3);
+        s[(w%3)*3] += h/3;
+        s[(h%3)*3] += w/3;
+        if((w%3) * (h%3) == 1) {
+            s[5]++;    s[3] -= 2; s[1] += 2;
+        }
+        else if((w%3) * (h%3) == 4) {
+            s[8]++; s[6] -= 2; s[4] += 2;
+        }
+        else if((w%3)*(h%3) == 2) {
+            s[7]++; s[6]--; s[3]--; s[2] += 2;
+        }
+        else    s[(w%3)*(h%3)] ++;
+        for(i =0;i < A; i++)    scanf("%d%d%d%d", &a[i].q, &a[i].p, &a[i].n, &a[i].m);
+        ans = Y;
+        for(i = 0;i < A ; i++) {
+            if(a[i].m == 0)    solve1(i);
+            else    solve2(i);
+        }
+        printf("%I64d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4601_autoAC.cpp b/HDOJ/4601_autoAC.cpp
new file mode 100644
index 0000000..315ff74
--- /dev/null
+++ b/HDOJ/4601_autoAC.cpp
@@ -0,0 +1,179 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include<vector>
+#define ll __int64
+using namespace std ;
+const int maxn = 211111 ;
+int c[26][maxn] , tot , dis[maxn] , pos[maxn] , rk[maxn] ;
+int tim[maxn] , dp[25][maxn] , cnt[maxn] , g[maxn] , line[maxn] , lon[maxn] ;
+ll val[maxn] , f[25] , pow26[maxn] ;
+const int mod = 1000000007 ;
+struct Edge
+{
+    int to , next , v ;
+} edge[maxn<<1] ;
+int head[maxn] , E , n ;
+struct Point
+{
+    int id ;
+    int tim ;
+    bool operator < ( const Point &t ) const
+    {
+        return tim < t.tim ;
+    }
+} ;
+vector<Point> vec[maxn] ;
+void new_edge ( int a , int b , char *s )
+{
+    edge[E].to = b ;
+    edge[E].next = head[a] ;
+    edge[E].v = s[0] - 'a' ;
+    head[a] = E ++ ;
+    edge[E].to = a ;
+    edge[E].next = head[b] ;
+    edge[E].v = s[0] - 'a' ;
+    head[b] = E ++ ;
+}
+int new_node ()
+{
+    int i ;
+    for ( i = 0 ; i < 26 ; i ++ ) c[i][tot] = 0 ;
+    val[tot] = 0 ;
+    return tot ++ ;
+}
+int step ;
+void cal ( int u , int fa , int now )
+{
+    int i ;
+    Point fuck ;
+    for ( i = head[u] ; i != -1 ; i = edge[i].next )
+    {
+        int v = edge[i].to ;
+        if ( v == fa ) continue ;
+        dis[v] = dis[u] + 1 ;
+        tim[v] = ++ step ;
+        fuck.id = v , fuck.tim = step ;
+        vec[dis[v]].push_back ( fuck ) ;
+        int k = edge[i].v ;
+        if ( !c[k][now] ) 
+        {
+            c[k][now] = new_node () ;
+            val[c[k][now]] = ( (ll) val[now] * 26 % mod + k ) % mod ;
+        }
+        pos[v] = c[k][now] ;
+        cal ( v , u , c[k][now] ) ;
+        lon[u] = max ( lon[u] , lon[v] ) ;
+        cnt[u] += cnt[v] ;
+    }
+    lon[u] = max ( lon[u] , dis[u] ) ;
+    cnt[u] ++ ;
+}
+void cal1 ( int now )
+{
+    rk[now] = step ++ ;
+    g[rk[now]] = now ;
+    int i ;
+    for ( i = 0 ; i < 26 ; i ++ )
+        if ( c[i][now] )
+            cal1 ( c[i][now] ) ;
+}
+int dep ;
+void init ()
+{
+    for ( int i = 0 ; i <= n ; i ++ )
+    {
+        head[i] = -1 , vec[i].clear () ;
+        lon[i] = dis[i] = rk[i] = cnt[i] = 0 ;
+    }
+    tot = E = 0 ;
+    new_node () ;
+}
+int T ;
+void rmq ()
+{
+    int i , j ;
+    T = 0 ;
+    for ( i = 1 ; i <= n ; i ++ )
+    {
+        int l = vec[i].size () ;
+        if ( l == 0 ) break ;
+        line[i] = T + 1 ;
+        for ( j = 0 ; j < l ; j ++ )
+            dp[0][++T] = rk[pos[vec[i][j].id]] ;
+    }
+    for ( i = 1 ; f[i] <= T ; i ++ )
+        for ( j = 1 ; j + f[i] - 1 <= T ; j ++ )
+            dp[i][j] = max ( dp[i-1][j] , dp[i-1][j+f[i-1]] ) ;
+}
+int query ( int l , int r )
+{
+    if ( l == r ) return dp[0][l] ;
+    if ( l > r ) swap ( l , r ) ;
+    int i , j , k ;
+    for ( i = 0 ; i <= 22 ; i ++ )
+        if ( f[i] >= ( r - l + 1 ) )
+        {
+            k = i - 1 ;
+            break ;
+        }
+    return max ( dp[k][l] , dp[k][r-f[k]+1] ) ;
+}
+char s[111] ;
+int main ()
+{
+    int cas , i , j , a , b , q ;
+    f[0] = pow26[0] = 1 ;
+    for ( i = 1 ; i <= 22 ; i ++ )
+        f[i] = (ll) f[i-1] * 2 % mod ;
+    for ( i = 1 ; i < 100005 ; i ++ )
+        pow26[i] = (ll) pow26[i-1] * 26 % mod ;
+    scanf ( "%d" , &cas ) ;
+    while ( cas -- )
+    {
+        scanf ( "%d" , &n ) ;
+        init () ;
+        for ( i = 1 ; i < n ; i ++ )
+        {
+            scanf ( "%d%d%s" , &a , &b , s ) ;
+            new_edge ( a , b , s ) ;
+        }
+        step = 0 ;
+        cal ( 1 , 0 , 0 ) ;
+        step = 0 ;
+        cal1 ( 0 ) ;
+        rmq () ;
+        pos[1] = 0 ;
+        scanf ( "%d" , &q ) ;
+        while ( q -- )
+        {
+            int u , m ;
+            scanf ( "%d%d" , &u , &m ) ;
+            if ( m == 0 )
+            {
+                puts ( "0" ) ;
+                continue ;
+            }
+            if ( dis[u] + m > lon[u] )
+            {
+                puts ( "IMPOSSIBLE" ) ;
+                continue ;
+            }
+            int dep = dis[u] + m ;
+            Point fuck ;
+            fuck.tim = tim[u] ;
+            int l = lower_bound ( vec[dep].begin () , vec[dep].end () , fuck ) - vec[dep].begin () ;
+            if ( l == vec[dep].size () ) l -- ;
+            l += line[dep] ;
+            fuck.tim = tim[u] + cnt[u] - 1 ;
+            int r = upper_bound ( vec[dep].begin () , vec[dep].end () , fuck ) - vec[dep].begin () ;
+            r -- ;
+            r += line[dep] ;
+            int k = query ( l , r ) ;
+            k = g[k] ;
+            u = pos[u] ;
+            printf ( "%I64d\n" , ( val[k] - val[u] * pow26[m] % mod + mod ) % mod ) ;
+        }
+    }
+}
diff --git a/HDOJ/4602_autoAC.cpp b/HDOJ/4602_autoAC.cpp
new file mode 100644
index 0000000..701503d
--- /dev/null
+++ b/HDOJ/4602_autoAC.cpp
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int mod=1000000007;
+struct Matrix{
+    long long arr[2][2];
+};
+Matrix init,unit;
+int n,k;
+long long num[2][2]={{4,-4},{1,0}};
+void Init(){
+    for(int i=0;i<2;i++)
+        for(int j=0;j<2;j++){
+            init.arr[i][j]=num[i][j];
+            unit.arr[i][j]=(i==j)?1:0;
+        }
+}
+Matrix Mul(Matrix a,Matrix b){
+    Matrix c;
+    for(int i=0;i<2;i++)
+        for(int j=0;j<2;j++){
+            c.arr[i][j]=0;
+            for(int k=0;k<2;k++)
+                c.arr[i][j]=(c.arr[i][j]%mod+a.arr[i][k]*b.arr[k][j]%mod+mod)%mod;
+            c.arr[i][j]%=mod;
+        }
+    return c;
+}
+Matrix Pow(Matrix a,Matrix b,int k){
+    while(k){
+        if(k&1){
+            b=Mul(a,b);
+        }
+        a=Mul(a,a);
+        k>>=1;
+    }
+    return b;
+}
+int main(){
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&k);
+        Init();
+        if(k>n){
+            printf("0\n");
+            continue;
+        }
+        int tmp=n-k+1;
+        if(tmp==1){
+            printf("1\n");
+            continue;
+        }
+        if(tmp==2){
+            printf("2\n");
+            continue;
+        }
+        if(tmp==3){
+            printf("5\n");
+            continue;
+        }
+        Matrix res=Pow(init,unit,tmp-3);
+        long long ans=(res.arr[0][0]*5+res.arr[0][1]*2)%mod;
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4603_autoAC.cpp b/HDOJ/4603_autoAC.cpp
new file mode 100644
index 0000000..212a703
--- /dev/null
+++ b/HDOJ/4603_autoAC.cpp
@@ -0,0 +1,370 @@
+#pragma comment(linker, "/STACK:102400000,102400000")  
+#include<iostream>  
+#include<vector>  
+#include<algorithm>  
+#include<cstdio>  
+#include<queue>  
+#include<stack>  
+#include<string>  
+#include<map>  
+#include<set>  
+#include<cmath>  
+#include<cassert>  
+#include<cstring>  
+#include<iomanip>  
+#include<ctime>  
+using namespace std;  
+#ifdef _WIN32  
+typedef __int64 i64;  
+#define out64 "%I64d\n"  
+#define in64 "%I64d"  
+#else  
+typedef long long i64;  
+#define out64 "%lld\n"  
+#define in64 "%lld"  
+#endif  
+#define foreach(c,itr)  for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)  
+#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)  
+#define FF(i,a)         for( int i = 0 ; i < (a) ; i ++)  
+#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)  
+#define S64(a)          scanf(in64,&a)  
+#define SS(a)           scanf("%d",&a)  
+#define LL(a)           ((a)<<1)  
+#define RR(a)           (((a)<<1)+1)  
+#define pb              push_back  
+#define pf              push_front  
+#define X               first  
+#define Y               second  
+#define CL(Q)           while(!Q.empty())Q.pop()  
+#define MM(name,what)   memset(name,what,sizeof(name))  
+#define MC(a,b)     memcpy(a,b,sizeof(b))  
+#define MAX(a,b)        ((a)>(b)?(a):(b))  
+#define MIN(a,b)        ((a)<(b)?(a):(b))  
+const int inf = 0x3f3f3f3f;  
+const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;  
+const double oo = 10e9;  
+const double eps = 10e-9;  
+const double pi = acos(-1.0);  
+const int maxn = 100111;  
+const int maxlevel = 21;  
+struct Node  
+{  
+    int now;  
+    int to;  
+    int c;  
+    int tot;  
+    int ss;  
+    const bool operator <  (const Node& cmp) const {  
+        return tot > cmp.tot;  
+    }  
+};  
+int all;  
+int n, m;  
+vector<Node>g[maxn];  
+int t[maxn];  
+int dep[maxn];  
+int df;  
+int dfn[maxn];  
+int dfv[maxn * 2];  
+int st[maxn * 2][maxlevel];  
+int up[maxn][maxlevel];  
+int dp[maxn];   //down sum   
+int xtof[maxn];  
+int ftox[maxn];  
+int vis[maxn];  
+int lg2[maxn*2];  
+void dfs(int now)  
+{  
+    vis[now] = true;  
+    int to;  
+    for (int i = 0; i < (int)g[now].size(); i++) {  
+        to = g[now][i].to;  
+        if (!vis[to])   {  
+            t[to] = now;  
+            dfs(to);  
+        }  
+    }  
+}  
+int treedp(int now)  
+{     
+    int to,id;  
+    dp[now] = 0;  
+    for (int i = 0; i < (int)g[now].size(); i++) {  
+        to = g[now][i].to;  
+        if (to != t[now]) {  
+            int temp = treedp(to) + g[now][i].c;  
+            g[now][i].tot = temp;  
+            dp[now] += temp;  
+        }  
+        else {  
+            id = i;  
+        }  
+    }  
+    if (t[now] != -1) {  
+        g[now][id].tot = all - dp[now];  
+    }  
+    return dp[now];  
+}  
+void euler_circuit(int now ,int step)  
+{  
+    dep[now] = step;  
+    dfn[now] = df;  
+    dfv[df++] = now;  
+    int to;  
+    for (int i = 0; i < (int)g[now].size(); i++) {  
+        to = g[now][i].to;  
+        if (to != t[now]) {  
+            euler_circuit(to,step+1);  
+            dfv[df++] = now;  
+        }  
+    }  
+}  
+void get_up_node()  
+{  
+    for (int i = 1; i <= n; i++) {  
+        up[i][0] = t[i];  
+    }  
+    int to;  
+    for (int step = 1; step < maxlevel; step++) {  
+        for (int now = 1; now <= n; now++) {  
+            to = up[now][step - 1];  
+            if (to == -1) {  
+                up[now][step] = -1;  
+            }  
+            else {  
+                up[now][step] = up[to][step - 1];  
+            }  
+        }  
+    }  
+}  
+void sparse_table()  
+{  
+    for (int i = 1; i < df; i++){  
+        st[i][0] = dep[dfv[i]];  
+    }  
+    int to;  
+    for (int step = 1; step <= lg2[n] + 1; step++){  
+        for (int now = 1; now < df; now++) {  
+            to = now + (1 << (step - 1));  
+            if (to < df){  
+                st[now][step] = min(st[now][step - 1], st[to][step - 1]);  
+            }  
+            else{  
+                st[now][step] = st[now][step - 1];  
+            }  
+        }  
+    }  
+}  
+void relation()  
+{  
+    int to;  
+    for (int now = 1; now <= n; now++){  
+        for (int i = 0; i < (int)g[now].size(); i++){  
+            to = g[now][i].to;  
+            if (to == t[now]){  
+                xtof[now] = i;  
+            }  
+            else{  
+                ftox[to] = i;  
+            }  
+        }  
+    }  
+}  
+int rmq(int l,int r)  
+{  
+    return min(st[l][lg2[r - l]], st[r - (1 << lg2[r - l])][lg2[r - l]] );  
+}  
+int calculate(int x,bool first,int id1,int id2=-1)  
+{  
+    if (id2 != -1){  
+        if (id1 > id2){  
+            swap(id1, id2);  
+        }  
+    }  
+    int sum = g[x][0].ss;  
+    sum -= g[x][id1].tot;  
+    if (id2 != -1){  
+        sum -= g[x][id2].tot;  
+    }  
+    int size = (int)g[x].size() - 1;  
+    if (size >= 1){  
+        sum += g[x][1].ss;  
+    }  
+    int ans = g[x][0].ss;  
+    if (id1 % 2 ){  
+        if (id1 + 1 <= size){  
+            ans -= g[x][id1 + 1].ss;  
+            if (id1 + 2 <= size){  
+                ans += g[x][id1 + 2].ss;  
+            }  
+        }  
+        if (id2 != -1){  
+            if (id2 % 2){  
+                ans -= g[x][id2].ss;  
+                if (id2 + 1 <= size){  
+                    ans += g[x][id2 + 1].ss;  
+                }  
+            }  
+            else{  
+                if (id2 + 1 <= size){  
+                    ans -= g[x][id2 + 1].ss;  
+                    if (id2 + 2 <= size){  
+                        ans += g[x][id2 + 2].ss;  
+                    }  
+                }  
+            }  
+        }  
+    }  
+    else{  
+        ans -= g[x][id1].ss;  
+        if (id1 + 1 <= size){  
+            ans += g[x][id1 + 1].ss;  
+        }  
+        if (id2 != -1){  
+            if (id2 % 2){  
+                ans -= g[x][id2].ss;  
+                if (id2 + 1 <= size){  
+                    ans += g[x][id2 + 1].ss;  
+                }  
+            }  
+            else{  
+                if (id2 + 1 <= size){  
+                    ans -= g[x][id2 + 1].ss;  
+                    if (id2 + 2 <= size){  
+                        ans += g[x][id2 + 2].ss;  
+                    }  
+                }  
+            }  
+        }  
+    }  
+    if (first) return ans;  
+    else return sum - ans;  
+}  
+int go_up(int now, int x)  
+{  
+    int step = 0;  
+    while (x) {  
+        if (x & 1) {  
+            now = up[now][step];  
+        }  
+        step++;  
+        x >>= 1;  
+    }  
+    return now;  
+}  
+int find(int a,int b)  
+{  
+    int l = dfn[a];  
+    int r = dfn[b];  
+    if (l == r){  
+        return g[a][0].ss;  
+    }  
+    if (l > r){  
+        swap(l, r);  
+    }  
+    int lca = rmq(l, r + 1);    
+    if (dep[a] - lca + dep[b] - lca == 1){  
+        if (dep[a] == lca){  
+            return g[b][xtof[b]].tot + calculate(b, false, xtof[b]);  
+        }  
+        else if (dep[b] == lca){  
+            return g[b][ftox[a]].tot + calculate(b, false, ftox[a]);  
+        }  
+    }  
+    else if (dep[a] > dep[b]+1){  
+        int temp = dep[a] - dep[b];  
+        int mid = lca + temp / 2;  
+        int child = go_up(a, dep[a] - mid - 1);  
+        if (temp % 2){  
+            return g[t[child]][ftox[child]].tot + calculate(t[child], false, ftox[child], xtof[t[child]]);  
+        }  
+        else{  
+            return g[t[child]][ftox[child]].tot + calculate(t[child], true, ftox[child], xtof[t[child]]);  
+        }  
+    }  
+    else if (dep[a] == dep[b] + 1) {  
+        int ca = go_up(a, dep[a] - lca - 1);  
+        int cb = go_up(b, dep[b] - lca - 1);  
+        int meet = t[ca];  
+        return g[meet][ftox[ca]].tot + calculate(meet, false, ftox[ca], ftox[cb]);  
+    }  
+    else if (dep[a] < dep[b]){  
+        int temp = dep[b] - dep[a];  
+        int mid = lca + (temp + 1)/ 2;  
+        int child = go_up(b, dep[b] - mid - 1);  
+        if (temp % 2){  
+            return g[t[child]][xtof[t[child]]].tot + calculate(t[child], false, xtof[t[child]], ftox[child]);  
+        }  
+        else{  
+            return g[t[child]][xtof[t[child]]].tot + calculate(t[child], true, xtof[t[child]], ftox[child]);  
+        }  
+    }  
+    else if(dep[a] == dep[b]) {  
+        int ca = go_up(a, dep[a] - lca - 1);  
+        int cb = go_up(b, dep[b] - lca - 1);  
+        int meet = t[ca];  
+        return g[meet][ftox[ca]].tot + calculate(meet, true, ftox[ca], ftox[cb]);  
+    }  
+    assert(false);    
+}  
+void start()  
+{  
+    for (int i = 1; i <= n; i++) {  
+        vis[i] = false;  
+    }  
+    t[0] = t[1] = -1;  
+    dfs(1);  
+    treedp(1);  
+    for (int now = 1; now <= n; now++) {  
+        sort(g[now].begin(), g[now].end());  
+        for (int i =(int) g[now].size() - 1; i >= 0; i--) {  
+            g[now][i].ss = g[now][i].tot;  
+            if (i + 3 <= (int)g[now].size()) {  
+                g[now][i].ss += g[now][i + 2].ss;  
+            }  
+        }  
+    }  
+    df = 1;  
+    euler_circuit(1, 0);  
+    get_up_node();  
+    sparse_table();  
+    relation();  
+}  
+int main()  
+{  
+    for (int i = 0; i < maxlevel; i++){  
+        if ( (1<<i) < maxn*2)  
+        lg2[1 << i] = i;  
+    }  
+    for (int i = 3; i < maxn*2; i++) {  
+        if (!lg2[i]){  
+            lg2[i] = lg2[i - 1];  
+        }  
+    }  
+    int T;  
+    cin >> T;  
+    while (T--) {  
+        all = 0;  
+        cin >> n >> m;  
+        for (int i = 0; i <= n; i++){  
+            g[i].clear();  
+        }  
+        Node node;  
+        for (int i = 1; i <= n - 1; i++) {  
+            SS(node.now);  
+            SS(node.to);  
+            SS(node.c);  
+            g[node.now].push_back(node);  
+            swap(node.now, node.to);  
+            g[node.now].push_back(node);  
+            all += node.c;  
+        }  
+        start();  
+        int a, b;  
+        for (int i = 1; i <= m; i++){  
+            SS(a); SS(b);  
+            printf("%d\n", find(a, b));  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4604_autoAC.cpp b/HDOJ/4604_autoAC.cpp
new file mode 100644
index 0000000..dc5f372
--- /dev/null
+++ b/HDOJ/4604_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#include <cmath>
+#include <map>
+#include <queue>
+#include <set>
+#include <vector>
+#define MAXM 111111
+#define MAXN 111111
+#define INF 1000000007
+#define eps 1e-8
+using namespace std;
+typedef vector<int>::iterator Viter;
+int n;
+vector<int>g;
+int a[MAXN];
+int dp1[MAXN], dp2[MAXN], num1[MAXN], num2[MAXN];
+void gao(int dp[], int num[])
+{
+    g.clear();
+    Viter it;
+    for(int i = n - 1; i >= 0; i--)
+    {
+        int sz = g.size();
+        if(!sz || a[i] >= g[sz - 1])
+        {
+            g.push_back(a[i]);
+            dp[i] = sz + 1;
+        }
+        else
+        {
+            it = upper_bound(g.begin(), g.end(), a[i]);
+            dp[i] = it - g.begin() + 1;
+            *it = a[i];
+        }
+        pair<Viter, Viter>bounds = equal_range(g.begin(), g.end(), a[i]);
+        num[i] = bounds.second - bounds.first;
+    }
+}
+int main()
+{
+    int T;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%d", &n);
+        for(int i = 0; i < n; i++) scanf("%d", &a[i]);
+        gao(dp1, num1);
+        for(int i = 0; i < n; i++) a[i] = -a[i];
+        gao(dp2, num2);
+        int ans = 0;
+        for(int i = 0; i < n; i++)
+            ans = max(ans, dp1[i] + dp2[i] - min(num1[i], num2[i]));
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4605_autoAC.cpp b/HDOJ/4605_autoAC.cpp
new file mode 100644
index 0000000..377b892
--- /dev/null
+++ b/HDOJ/4605_autoAC.cpp
@@ -0,0 +1,142 @@
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#include<stdio.h>
+#include<iostream>
+#include<vector>
+#include<algorithm>
+#include<string.h>
+using namespace std;
+#define maxn 100005
+struct list
+{
+    int l,r;
+    int w;
+}node[maxn];
+int fs[maxn*2];
+int fss[maxn*2];
+struct qq
+{
+    int x;
+    int id;
+}xx;
+vector<qq>num[maxn];
+int ans[maxn][2];
+int sum[maxn][2];
+int w[maxn];
+int n,m,q,len;
+int lowbit(int x)
+{
+     return (x&(-x));
+}
+int search(int l,int r,int w)
+{
+    while(l<r)
+    {
+        int mid=(l+r)/2;
+        if(fs[mid]==w)return mid;
+        if(fs[mid]<w)l=mid+1;
+        else r=mid;
+    }
+}
+void add(int x,int bs,int num)
+{
+    for(;x<len;x+=lowbit(x))
+    {
+        sum[x][bs]+=num;
+    }
+}
+int allsum(int s,int bs)
+{
+    int ss;
+    ss=0;
+    while(s>0)
+    {
+        ss+=sum[s][bs];
+        s=s-lowbit(s);
+    }
+    return ss;
+}
+void dfs(int x)
+{
+    int s;
+    s=num[x].size();
+    for(int i=0;i<s;i++)
+    {
+        xx=num[x][i];
+        int z,id;
+        z=search(1,len,xx.x);
+        id=xx.id;
+        if(allsum(z,0)-allsum(z-1,0)+allsum(z,1)-allsum(z-1,1)>0)
+        {
+            ans[id][0]=-1;
+            continue;
+        }
+        int ll,lr,rl,rr;
+        ll=allsum(len-1,0)-allsum(z,0);
+        rl=allsum(z,0);
+        lr=allsum(len-1,1)-allsum(z,1);
+        rr=allsum(z,1);
+        ans[id][0]=rr;
+        ans[id][1]=(rl+rr)*3+ll+lr;
+    }
+    s=search(1,len,node[x].w);
+    if(node[x].l!=-1)
+    {
+        add(s,0,1);
+        dfs(node[x].l);
+        add(s,0,-1);
+    }
+    if(node[x].r!=-1)
+    {
+        add(s,1,1);
+        dfs(node[x].r);
+        add(s,1,-1);
+    }
+}
+int main()
+{
+    int T,a,b,c,i;
+    cin>>T;
+    while(T--)
+    {
+        cin>>n;
+        int ll=1;
+        memset(fs,0,sizeof(fs));
+        memset(ans,0,sizeof(ans));
+        memset(fss,0,sizeof(fss));
+        for (i = 1; i <= n; ++i) node[i].l = node[i].r = node[i].w = -1;
+        for(i=1;i<=n;i++)
+        {
+            num[i].clear();
+            scanf("%d",&w[i]);
+            node[i].w=w[i];
+            fss[ll++]=w[i];
+        }
+        cin>>m;
+        for(i=1;i<=m;i++)
+        {
+            scanf("%d%d%d",&a,&b,&c);
+            node[a].l=b;
+            node[a].r=c;
+        }
+        cin>>q;
+        for(i=1;i<=q;i++)
+        {
+            scanf("%d%d",&a,&b);
+            fss[ll++]=b;
+            xx.id=i;
+            xx.x=b;
+            num[a].push_back(xx);
+        }
+        len=1;
+        sort(fss,fss+ll);
+        for(i=1;i<ll;i++)
+            if(fss[i]!=fss[i-1])fs[len++]=fss[i];
+        dfs(1);
+        for(i=1;i<=q;i++)
+        {
+            if(ans[i][0]==-1)printf("0\n");
+            else printf("%d %d\n",ans[i][0],ans[i][1]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4606_autoAC.cpp b/HDOJ/4606_autoAC.cpp
new file mode 100644
index 0000000..77c8158
--- /dev/null
+++ b/HDOJ/4606_autoAC.cpp
@@ -0,0 +1,191 @@
+#include <stdio.h>
+#include <iostream>
+#include <algorithm>
+#include <string.h>
+#include <math.h>
+#include <vector>
+using namespace std;
+const double eps = 1e-6;
+int sgn(double x)
+{
+    if(fabs(x) < eps)return 0;
+    if(x < 0)return -1;
+    else return 1;
+}
+struct Point
+{
+    double x,y;
+    Point(double _x = 0,double _y = 0)
+    {
+        x = _x; y = _y;
+    }
+    Point operator -(const Point &b)const
+    {
+        return Point(x-b.x,y-b.y);
+    }
+    double operator ^(const Point &b)const
+    {
+        return x*b.y - y*b.x;
+    }
+    double operator *(const Point &b)const
+    {
+        return x*b.x + y*b.y;
+    }
+    void input()
+    {
+        scanf("%lf%lf",&x,&y);
+    }
+};
+struct Line
+{
+    Point s,e;
+    Line(){}
+    Line(Point _s,Point _e)
+    {
+        s = _s; e = _e;
+    }
+    void input()
+    {
+        s.input();
+        e.input();
+    }
+};
+double dist(Point a,Point b)
+{
+    return sqrt((a-b)*(a-b));
+}
+bool inter(Line l1,Line l2)
+{
+    return
+    sgn((l2.s-l1.e)^(l1.s-l1.e))*sgn((l2.e-l1.e)^(l1.s-l1.e)) < 0 &&
+    sgn((l1.s-l2.e)^(l2.s-l2.e))*sgn((l1.e-l2.e)^(l2.s-l2.e)) < 0;
+}
+const int MAXN = 440;
+Point p[MAXN];
+Line line[MAXN];
+const double INF = 100000000.0;
+double dis[MAXN][MAXN];
+int n,m,P;
+int b[MAXN];
+int uN,vN;
+struct Edge
+{
+    int to,next;
+}edge[MAXN*MAXN];
+int head[MAXN];
+int tot;
+void addedge(int u,int v)
+{
+    edge[tot].to = v;
+    edge[tot].next = head[u];
+    head[u] = tot++;
+}
+void init()
+{
+    tot = 0;
+    memset(head,-1,sizeof(head));
+}
+int linker[MAXN];
+bool used[MAXN];
+bool dfs(int u)
+{
+    for(int i = head[u]; i!= -1;i = edge[i].next)
+    {
+        int v = edge[i].to;
+        if(!used[v])
+        {
+            used[v] = true;
+            if(linker[v]==-1 || dfs(linker[v]))
+            {
+                linker[v] = u;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int hungary()
+{
+    int res = 0;
+    memset(linker,-1,sizeof(linker));
+    for(int u = 0;u < uN;u ++)
+    {
+        memset(used,false,sizeof(used));
+        if(dfs(u))res++;
+    }
+    return res;
+}
+bool check(double d)
+{
+    uN = vN = n;
+    init();
+    for(int i = 0;i < n;i++)
+        for(int j = i+1;j < n;j++)
+           if(dis[b[i]][b[j]] < d + eps)
+              addedge(b[i],b[j]);
+    if(n - hungary() <= P)return true;
+    else return false;
+}
+double solve()
+{
+    double l = 0, r = 100000.0;
+    double ans;
+    while(r-l >= eps)
+    {
+        double mid = (l+r)/2;
+        if(check(mid))
+        {
+            ans = mid;
+            r = mid - eps;
+        }
+        else l = mid + eps;
+    }
+    return ans;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d",&n,&m,&P);
+        for(int i = 0;i < n;i++)
+            p[i].input();
+        int t = n;
+        for(int i = 0;i < m;i++)
+        {
+            line[i].input();
+            p[n+2*i] = line[i].s;
+            p[n+2*i+1] = line[i].e;
+        }
+        for(int i = 0;i < n+2*m;i++)
+            for(int j = 0;j < n+2*m;j++)
+            {
+                if(i == j)
+                {
+                    dis[i][j] = 0;
+                    continue;
+                }
+                bool flag = false;
+                for(int k = 0;k < m;k++)
+                    if(inter(line[k],Line(p[i],p[j])))
+                    {
+                        flag = true;
+                        break;
+                    }
+                if(flag)dis[i][j] = 1e20;
+                else dis[i][j] = dist(p[i],p[j]);
+            }
+        for(int k = 0;k < n+2*m;k++)
+            for(int i = 0;i < n+2*m;i++)
+                for(int j = 0;j < n+2*m;j++)
+                    dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j]);
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d",&b[i]);
+            b[i]--;
+        }
+        printf("%.2lf\n",solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/4607_autoAC.cpp b/HDOJ/4607_autoAC.cpp
new file mode 100644
index 0000000..76851a7
--- /dev/null
+++ b/HDOJ/4607_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+const int N=200010;
+int head[N],to[N],ne[N],w[N];
+int dis[N],que[N];
+bool vis[N];
+int edge,m,n;
+void init()
+{
+    memset(head,-1,sizeof(head));
+    edge=0;
+}
+void add(int u,int v,int c)
+{
+    to[edge]=v,w[edge]=c,ne[edge]=head[u],head[u]=edge++;
+    to[edge]=u,w[edge]=c,ne[edge]=head[v],head[v]=edge++;
+}
+void bfs(int s)
+{
+    memset(vis,0,sizeof(vis));
+    memset(dis,0,sizeof(dis));
+    int l,r,v,u;
+    l=r=0;
+    vis[s]=1;
+    dis[s]=0;
+    que[r++]=s;
+    while(r>l)
+    {
+        u=que[l++];
+        for(int i=head[u]; ~i; i=ne[i])
+        {
+            if(!vis[v=to[i]])
+            {
+                vis[v]=1;
+                dis[v]=dis[u]+w[i];
+                que[r++]=v;
+            }
+        }
+    }
+}
+int treediameter(int s)
+{
+    int u,maxl;
+    bfs(s);
+    maxl=0,u=s;
+    for(int i=1; i<=n; i++)
+        if(dis[i]>maxl)
+            u=i,maxl=dis[i];
+    bfs(u);
+    maxl=0;
+    for(int i=1; i<=n; i++)
+        if(dis[i]>maxl)
+            maxl=dis[i];
+    return maxl;
+}
+int main()
+{
+    int u,v,d=1,t,i,j,x;
+    scanf("%d",&t);
+    while(t--)
+    {
+        init();
+        scanf("%d%d",&n,&m);
+        for(i=1;i<=n-1;i++)
+        {
+            scanf("%d%d",&u,&v);
+            add(u,v,1);
+        }
+        int ans=treediameter(1);
+        ans++;
+        while(m--)
+        {
+            scanf("%d",&x);
+            if(x<=ans) printf("%d\n",x-1);
+            else       printf("%d\n",(x-ans)*2+ans-1);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4608_autoAC.cpp b/HDOJ/4608_autoAC.cpp
new file mode 100644
index 0000000..6034c59
--- /dev/null
+++ b/HDOJ/4608_autoAC.cpp
@@ -0,0 +1,61 @@
+#include <iostream>
+#include <stdio.h>
+#include <cstring>
+using namespace std;
+char str[100050];
+int num[100050];
+int main()
+{
+    int t,i;
+    while(~scanf("%d",&t))
+    {
+        while(t--)
+        {
+            scanf("%s",str);
+            int n;
+            n = strlen(str);
+            for(i = 0;i < n;i++)
+            num[i] = str[i]-'0';
+            int rest;
+            rest  = 0;
+            for(i = 0;i < n;i++)
+            rest += num[i];
+            rest = 10-rest%10;
+            num[n-1] += rest;
+            int bit;
+            bit = 0;
+            if(num[n-1] > 9)
+            {
+                for(i = n-2;i >= 0;i--)
+                {
+                    bit++;
+                    num[i]++;
+                    num[i] %= 10;
+                    if(num[i])
+                    break;
+                }
+                if(i<0)
+                {
+                    printf("1");
+                    for(i = n-1;i > 0;i--)
+                    printf("0");
+                    puts("9");
+                }
+                else
+                {
+                    num[n-1] = (num[n-1]+1000000-bit)%10;
+                    for(i = 0;i < n;i++)
+                    printf("%d",num[i]);
+                    puts("");
+                }
+            }
+            else
+            {
+                for(i = 0;i < n;i++)
+                printf("%d",num[i]);
+                puts("");
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4609_autoAC.cpp b/HDOJ/4609_autoAC.cpp
new file mode 100644
index 0000000..a4ae71e
--- /dev/null
+++ b/HDOJ/4609_autoAC.cpp
@@ -0,0 +1,121 @@
+#include <stdio.h>
+#include <iostream>
+#include <string.h>
+#include <algorithm>
+#include <math.h>
+using namespace std;
+const double PI = acos(-1.0);
+struct complex
+{
+    double r,i;
+    complex(double _r = 0,double _i = 0)
+    {
+        r = _r; i = _i;
+    }
+    complex operator +(const complex &b)
+    {
+        return complex(r+b.r,i+b.i);
+    }
+    complex operator -(const complex &b)
+    {
+        return complex(r-b.r,i-b.i);
+    }
+    complex operator *(const complex &b)
+    {
+        return complex(r*b.r-i*b.i,r*b.i+i*b.r);
+    }
+};
+void change(complex y[],int len)
+{
+    int i,j,k;
+    for(i = 1, j = len/2;i < len-1;i++)
+    {
+        if(i < j)swap(y[i],y[j]);
+        k = len/2;
+        while( j >= k)
+        {
+            j -= k;
+            k /= 2;
+        }
+        if(j < k)j += k;
+    }
+}
+void fft(complex y[],int len,int on)
+{
+    change(y,len);
+    for(int h = 2;h <= len;h <<= 1)
+    {
+        complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
+        for(int j = 0;j < len;j += h)
+        {
+            complex w(1,0);
+            for(int k = j;k < j+h/2;k++)
+            {
+                complex u = y[k];
+                complex t = w*y[k+h/2];
+                y[k] = u+t;
+                y[k+h/2] = u-t;
+                w = w*wn;
+            }
+        }
+    }
+    if(on == -1)
+        for(int i = 0;i < len;i++)
+            y[i].r /= len;
+}
+const int MAXN = 400040;
+complex x1[MAXN];
+int a[MAXN/4];
+long long num[MAXN];
+long long sum[MAXN];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        memset(num,0,sizeof(num));
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d",&a[i]);
+            num[a[i]]++;
+        }
+        sort(a,a+n);
+        int len1 = a[n-1]+1;
+        int len = 1;
+        while( len < 2*len1 )len <<= 1;
+        for(int i = 0;i < len1;i++)
+            x1[i] = complex(num[i],0);
+        for(int i = len1;i < len;i++)
+            x1[i] = complex(0,0);
+        fft(x1,len,1);
+        for(int i = 0;i < len;i++)
+            x1[i] = x1[i]*x1[i];
+        fft(x1,len,-1);
+        for(int i = 0;i < len;i++)
+            num[i] = (long long)(x1[i].r+0.5);
+        len = 2*a[n-1];
+        for(int i = 0;i < n;i++)
+            num[a[i]+a[i]]--;
+        for(int i = 1;i <= len;i++)
+        {
+            num[i]/=2;
+        }
+        sum[0] = 0;
+        for(int i = 1;i <= len;i++)
+            sum[i] = sum[i-1]+num[i];
+        long long cnt = 0;
+        for(int i = 0;i < n;i++)
+        {
+            cnt += sum[len]-sum[a[i]];
+            cnt -= (long long)(n-1-i)*i;
+            cnt -= (n-1);
+            cnt -= (long long)(n-1-i)*(n-i-2)/2;
+        }
+        long long tot = (long long)n*(n-1)*(n-2)/6;
+        printf("%.7lf\n",(double)cnt/tot);
+    }
+    return 0;
+}
diff --git a/HDOJ/4610_autoAC.cpp b/HDOJ/4610_autoAC.cpp
new file mode 100644
index 0000000..72ee2c3
--- /dev/null
+++ b/HDOJ/4610_autoAC.cpp
@@ -0,0 +1,142 @@
+#include<cstdio>
+#include<iostream>
+#include<bitset>
+#include<cmath>
+#include<cstring>
+#include<vector>
+#include<algorithm>
+using namespace std;
+typedef long long ll;
+const int N = (int)4e6+10;
+const int M = (int)1e6+10;
+typedef pair<int,int> pii;
+bool p[N];
+int prime[M];
+void init(){
+    memset(p,true,sizeof(p));
+    p[0] = p[1] = false;
+    for(int i=2;i*i<N;i++)
+        for(int j=i;j*i<N;j++)
+            p[i*j] = 0;
+    prime[0] = 0;
+    for(int i=2;i<N;i++)
+        if(p[i])prime[++prime[0]] = i;
+}
+vector<pii>factor;
+void div(int n){
+    factor.clear();
+    for(int i=1;prime[i] * prime[i] <= n;i++){
+        if(n % prime[i]  == 0){
+            int cnt = 0;
+            while(n % prime[i] == 0){
+                n /= prime[i];
+                ++cnt;
+            }
+            factor.push_back(make_pair(prime[i],cnt));
+        }
+    }
+    if(n > 1)factor.push_back(make_pair(n,1));
+}
+ll Pow(ll a,ll b){
+    ll ans = 1;
+    while(b){
+        if(b&1)ans = ans * a;
+        a = a * a;
+        b >>= 1;
+    }
+    return ans;
+}
+bool isPrime_amount(int n){
+    if(factor.size() > 1|| n==1 )return false;
+    return p[factor[0].second + 1];
+}
+bool isPrime_sum(int n){
+    if(factor.size() > 1|| n== 1)return false;
+    int a = factor[0].first,b = factor[0].second;
+    int sum = 1LL*(Pow(a,b+1) - 1) / (a - 1);
+    return p[sum];
+}
+bool isSquare(ll n){
+    ll _ = sqrt(n*1.0);
+    return _ * _ == n;
+}
+bool isSquare_product(int n){
+    int all = 1;
+    for(int i=0;i<factor.size();i++)
+        all *= factor[i].second + 1;
+    ll sq = sqrt(n*1.0);
+    ll cur = 1;
+    int p = all >> 1;
+    if(p & 1)cur *= n;
+    if(all & 1)cur *= sq;
+    return isSquare(cur);
+}
+int extra[5];
+int V[16],cur[5],hash[16];
+int have[16];
+int main(){
+    for(int i=0;i<16;i++){
+        int all = 0;
+        for(int j=0;j<4;j++)
+            if(!(i&(1<<j)))++all;
+        have[i] = all;
+    }
+    init();
+    int T,n,K;
+    scanf("%d",&T);
+    while(T--){
+        memset(V,0,sizeof(V));
+        scanf("%d%d",&n,&K);
+        for(int i=1;i<=n;i++){
+            int a,b;
+            scanf("%d%d",&a,&b);
+            int flag = 15,cnt = 0;
+            div(a);
+            if(p[a])flag ^= 1<<0 ,cnt ++;
+            if(isPrime_amount(a)) flag ^= 1<<1,cnt ++;
+            if(isPrime_sum(a))flag ^= 1<<2,cnt ++;
+            if(isSquare_product(a)) flag ^= 1<<3,cnt++;
+            V[flag] += b;
+            if(i!=1)printf(" ");
+            printf("%d",cnt);
+        }
+        puts("");
+        int ans = -(~0u>>2);
+        for(int i=0;i< 4;i++)scanf("%d",&extra[i]);
+        for(int i=0;i < 1<<16;i++){
+            memset(cur,0,sizeof(cur));
+            int res = K,number = 0,all = 0;
+            int flag = 15;
+            for(int j = 0;j < 16;j++){
+                if(i&(1<<j)){
+                    if(V[j] > 0){
+                        flag &= j;
+                        res --;
+                        all += have[j];
+                        cur[have[j]] += V[j] - 1;
+                    }else{
+                        res = -1;
+                        break;
+                    }
+                }
+            }
+            if(res < 0 )continue;
+            for(int k=4;k >= 0 && res > 0;k--){
+                if(cur[k] <= res){
+                    all += k * cur[k];
+                    res -= cur[k];
+                }else{
+                    all += res * k;
+                    res =0;
+                }
+            }
+            if(res == 0){
+                for(int j=0;j<4;j++)
+                    if(flag & (1<<j))all += extra[j];
+                ans = max(ans,all);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4611_autoAC.cpp b/HDOJ/4611_autoAC.cpp
new file mode 100644
index 0000000..538073b
--- /dev/null
+++ b/HDOJ/4611_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+long long gcd(long long x,long long y)
+{
+    return y==0?x:gcd(y,x%y);
+}
+long long Count(long long n,long long a,long long b)
+{
+    long long now=0,ret=0,tmp,x=0,y=0;
+    while(now<n)
+    {
+        tmp=min(a-x,b-y);
+        if (now+tmp>n) tmp=n-now;
+        ret+=tmp*abs(x-y);
+        x=(x+tmp)%a;
+        y=(y+tmp)%b;
+        now+=tmp;
+    }
+    return ret;
+}
+int main()
+{
+    int i,j,T;
+    long long a,b,n,l,ans;
+    scanf("%d",&T);
+    while(T--)
+    {
+        cin>>n>>a>>b;
+        l=a*b/gcd(a,b);
+        if (l>=n) ans=Count(n,a,b);
+        else ans=Count(l,a,b)*(n/l)+Count(n%l,a,b);
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4612_autoAC.cpp b/HDOJ/4612_autoAC.cpp
new file mode 100644
index 0000000..b824bc4
--- /dev/null
+++ b/HDOJ/4612_autoAC.cpp
@@ -0,0 +1,171 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include<iostream>
+#include<string>
+#include<algorithm>
+#include<cstdlib>
+#include<cstdio>
+#include<set>
+#include<map>
+#include<vector>
+#include<cstring>
+#include<stack>
+#include<cmath>
+#include<queue>
+using namespace std;
+#define CL(x,v); memset(x,v,sizeof(x));
+#define INF 0x3f3f3f3f
+#define LL long long
+#define REP(i,r,n) for(int i=r;i<=n;i++)
+#define RREP(i,n,r) for(int i=n;i>=r;i--)
+const int MAXN=2e5+100;
+int n,m;
+struct Edge{
+    int u,v;
+    Edge(){}
+    Edge(int a,int b){
+        u=a;
+        v=b;
+    }
+};
+vector<Edge> edges;
+vector<int> G[MAXN];
+vector<int> P[MAXN];
+int dfs_clock,bcc_cnt;
+int pre[MAXN];
+int T[MAXN];
+int dfs1(int u,int fa)
+{
+    int lowu=pre[u]=++dfs_clock;
+    for(int i=0;i<G[u].size();i++)
+    {
+        int mm=G[u][i];
+        int v=edges[mm].v;
+        if(fa==(mm^1))continue;
+        if(!pre[v])
+        {
+            int lowv=dfs1(v,mm);
+            lowu=min(lowu,lowv);
+            if(lowv>pre[u])
+            {
+                P[v].push_back(u);
+                P[u].push_back(v);
+            }
+        }
+        else if(pre[v]<pre[u])
+        {
+            lowu=min(pre[v],lowu);
+        }
+    }
+    return lowu;
+}
+void dfs2(int u,int fa)
+{
+    T[u]=bcc_cnt;
+    for(int i=0;i<G[u].size();i++)
+    {
+        int v=edges[G[u][i]].v;
+        bool f=true;
+        for(int j=0;j<P[u].size();j++)
+        {
+            int vv=P[u][j];
+            if(v==vv)
+            {
+                f=false;break;
+            }
+        }
+        if(!f||T[v])continue;
+        dfs2(v,u);
+    }
+}
+void find_bcc(int n)
+{
+     dfs_clock=0,bcc_cnt=0;
+    memset(pre,0,sizeof(pre));
+    memset(T,0,sizeof(T));
+    for(int i=1;i<=n;i++)
+        if(!pre[i])
+            dfs1(i,-1);
+    for(int i=1;i<=n;i++)
+        if(!T[i])
+        {
+            bcc_cnt++;
+            dfs2(i,-1);
+        }
+}
+vector<int> GG[MAXN];
+int d[MAXN];
+void dfs(int u,int dep)
+{
+    d[u]=dep;
+    for(int i=0;i<GG[u].size();i++)
+    {
+        int v=GG[u][i];
+        if(!d[v])
+        {
+            dfs(v,dep+1);
+        }
+    }
+}
+int main()
+{
+    while(~scanf("%d%d",&n,&m))
+    {
+        if(n+m==0)break;
+        REP(i,0,n){
+            G[i].clear();
+            P[i].clear();
+        }
+        edges.clear();
+        int a,b;
+        REP(i,1,m)
+        {
+            scanf("%d%d",&a,&b);
+            Edge e;
+            e=Edge(a,b);
+            edges.push_back(e);
+            e=Edge(b,a);
+            edges.push_back(e);
+            int mm=edges.size();
+            G[a].push_back(mm-2);
+            G[b].push_back(mm-1);
+        }
+        find_bcc(n);
+        REP(i,0,n)
+        {
+            GG[i].clear();
+        }
+        for(int i=1;i<=n;i++)
+        {
+            for(int j=0;j<P[i].size();j++)
+            {
+                int v=P[i][j];
+                if(T[i]!=T[v])
+                {
+                    GG[T[i]].push_back(T[v]);
+                }
+            }
+        }
+        CL(d,0);
+        dfs(1,1);
+        int maxn=0;
+        int flag=0;
+        for(int i=1;i<=bcc_cnt;i++)
+        {
+            if(d[i]>maxn)
+            {
+                maxn=d[i];
+                flag=i;
+            }
+        }
+        CL(d,0);
+        dfs(flag,1);
+        maxn=0;
+        for(int i=1;i<=bcc_cnt;i++)
+        {
+            if(d[i]>maxn)
+                maxn=d[i];
+        }
+        cout<<bcc_cnt-maxn<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4614_autoAC.cpp b/HDOJ/4614_autoAC.cpp
new file mode 100644
index 0000000..a8dd213
--- /dev/null
+++ b/HDOJ/4614_autoAC.cpp
@@ -0,0 +1,205 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+#include <set>
+#include <map>
+#include <vector>
+#include <queue>
+#include <string>
+#include <math.h>
+using namespace std;
+const int MAXN = 50010;
+struct Node
+{
+    int l,r;
+    int sum;
+    int lazy;
+    int first;
+    int last;
+}segTree[MAXN*3];
+void push_up(int i)
+{
+    if(segTree[i].l==segTree[i].r)return;
+    segTree[i].sum = segTree[i<<1].sum+segTree[(i<<1)|1].sum;
+    if(segTree[i<<1].first != -1)segTree[i].first = segTree[i<<1].first;
+    else segTree[i].first = segTree[(i<<1)|1].first;
+    if(segTree[(i<<1)|1].last != -1)segTree[i].last = segTree[(i<<1)|1].last;
+    else segTree[i].last = segTree[(i<<1)].last;
+}
+void push_down(int i)
+{
+    if(segTree[i].r == segTree[i].l)return;
+    if(segTree[i].lazy==1)
+    {
+        segTree[i<<1].first = segTree[i<<1].l;
+        segTree[i<<1].last = segTree[i<<1].r;
+        segTree[i<<1].sum = segTree[i<<1].r-segTree[i<<1].l+1;
+        segTree[i<<1].lazy=1;
+        segTree[(i<<1)|1].first = segTree[(i<<1)|1].l;
+        segTree[(i<<1)|1].last = segTree[(i<<1)|1].r;
+        segTree[(i<<1)|1].sum = segTree[(i<<1)|1].r-segTree[(i<<1)|1].l+1;
+        segTree[(i<<1)|1].lazy=1;
+    }
+    if(segTree[i].lazy == -1)
+    {
+        segTree[i<<1].first = -1;
+        segTree[i<<1].last = -1;
+        segTree[i<<1].sum = 0;
+        segTree[i<<1].lazy=-1;
+        segTree[(i<<1)|1].first = -1;
+        segTree[(i<<1)|1].last = -1;
+        segTree[(i<<1)|1].sum = 0;
+        segTree[(i<<1)|1].lazy=-1;
+    }
+    segTree[i].lazy = 0;
+}
+void build(int i,int l,int r)
+{
+    segTree[i].l = l;
+    segTree[i].r = r;
+    segTree[i].sum = r-l+1;
+    segTree[i].lazy = 0;
+    segTree[i].first = l;
+    segTree[i].last = r;
+    if(l==r)return ;
+    int mid = (l+r)/2;
+    build(i<<1,l,mid);
+    build((i<<1)|1,mid+1,r);
+}
+void update(int i,int l,int r,int type)
+{
+    if(segTree[i].l == l && segTree[i].r==r)
+    {
+        if(type == 0)
+        {
+            if(segTree[i].sum == 0)return;
+            segTree[i].sum = 0;
+            segTree[i].lazy = -1;
+            segTree[i].first = -1;
+            segTree[i].last = -1;
+            return;
+        }
+        else if(type == 1)
+        {
+            if(segTree[i].sum == segTree[i].r-segTree[i].l+1)return;
+            segTree[i].sum = segTree[i].r-segTree[i].l+1;
+            segTree[i].lazy = 1;
+            segTree[i].first = segTree[i].l;
+            segTree[i].last = segTree[i].r;
+            return;
+        }
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)/2;
+    if(r <= mid)update(i<<1,l,r,type);
+    else if(l > mid)update((i<<1)|1,l,r,type);
+    else
+    {
+        update(i<<1,l,mid,type);
+        update((i<<1)|1,mid+1,r,type);
+    }
+    push_up(i);
+}
+int sum(int i,int l,int r)
+{
+    if(segTree[i].l == l && segTree[i].r == r)
+    {
+        return segTree[i].sum;
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)/2;
+    if(r <= mid)return sum(i<<1,l,r);
+    else if(l > mid)return sum((i<<1)|1,l,r);
+    else return sum((i<<1)|1,mid+1,r)+sum(i<<1,l,mid);
+}
+int n,m;
+int query1(int i,int l,int r)
+{
+    if(segTree[i].l == l && segTree[i].r == r)
+    {
+        return segTree[i].first;
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)/2;
+    int ans1,ans2;
+    if(r <= mid)return query1(i<<1,l,r);
+    else if(l > mid)return query1((i<<1)|1,l,r);
+    else
+    {
+        ans1 = query1(i<<1,l,mid);
+        if(ans1 != -1)return ans1;
+        return query1((i<<1)|1,mid+1,r);
+    }
+}
+int query2(int i,int l,int r)
+{
+    if(segTree[i].l == l && segTree[i].r == r)
+    {
+        return segTree[i].last;
+    }
+    push_down(i);
+    int mid = (segTree[i].l + segTree[i].r)/2;
+    int ans1,ans2;
+    if(r <= mid)return query2(i<<1,l,r);
+    else if(l > mid)return query2((i<<1)|1,l,r);
+    else
+    {
+        ans1 = query2((i<<1)|1,mid+1,r);
+        if(ans1 != -1)return ans1;
+        return query2(i<<1,l,mid);
+    }
+}
+int bisearch(int A,int F)
+{
+    if(sum(1,A,n)==0)return -1;
+    if(sum(1,A,n)<F)return n;
+    int l= A,r = n;
+    int ans=A;
+    while(l<=r)
+    {
+        int mid = (l+r)/2;
+        if(sum(1,A,mid)>=F)
+        {
+            ans = mid;
+            r = mid-1;
+        }
+        else l = mid+1;
+    }
+    return ans;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&n,&m);
+        build(1,1,n);
+        int op,u,v;
+        while(m--)
+        {
+            scanf("%d%d%d",&op,&u,&v);
+            if(op == 1)
+            {
+                u++;
+                int t = bisearch(u,v);
+                if(t==-1)
+                {
+                    printf("Can not put any one.\n");
+                    continue;
+                }
+                printf("%d %d\n",query1(1,u,t)-1,query2(1,u,t)-1);
+                update(1,u,t,0);
+            }
+            else
+            {
+                u++;v++;
+                printf("%d\n",v-u+1-sum(1,u,v));
+                update(1,u,v,1);
+            }
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4616_autoAC.cpp b/HDOJ/4616_autoAC.cpp
new file mode 100644
index 0000000..40dc7b7
--- /dev/null
+++ b/HDOJ/4616_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <cstdio>
+#include <cstring>
+#define  N 50005
+#define INF 99999999
+struct Edge
+{
+    int e, next;
+}edge[N*2];
+int head[N], eNum;
+int c[N], val[N], n, k, ans, dp[N][4][2];
+void init()
+{
+    memset(head, -1, sizeof(head));
+    eNum = 0; ans = 0;
+    for(int i=0; i<n; i++)
+    {
+        for(int j=0; j<4; j++)
+        {
+            for(int l=0; l<2; l++)
+                dp[i][j][l] = -INF;
+        }
+    }
+}
+void AddEdge(int u, int v)
+{
+    edge[eNum].e = v;
+    edge[eNum].next = head[u];
+    head[u] = eNum++;
+}
+int max2(int x, int y)
+{
+    return x > y ? x : y;
+}
+void dfs(int u, int fa)
+{
+    dp[u][c[u]][c[u]] = val[u]; 
+    for(int i=head[u]; i!=-1; i=edge[i].next)
+    {
+        int v = edge[i].e;
+        if(v==fa) continue;
+        dfs(v, u);
+        for(int j=0; j<=k; j++) 
+        {
+            for(int l=0; l+j<=k; l++)
+            {
+                ans = max2(ans, dp[u][j][1]+dp[v][l][1]); 
+                if(j+l!=k) ans = max2(ans, dp[u][j][0]+dp[v][l][0]); 
+                ans = max2(ans, dp[u][j][0]+dp[v][l][1]); 
+                ans = max2(ans, dp[u][j][1]+dp[v][l][0]); 
+            }
+        }
+        for(int j=0; j<k; j++)
+        {
+            dp[u][j+c[u]][1] = max2(dp[u][j+c[u]][1],dp[v][j][1]+val[u]); 
+            dp[u][j+c[u]][0] = max2(dp[u][j+c[u]][0],dp[v][j][0]+val[u]);
+        }
+        if(c[u]==0) dp[u][k][1] = max2(dp[u][k][1], dp[v][k][1]+val[u]); 
+    }
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&k);
+        for(int i=0; i<n; i++)
+            scanf("%d%d",&val[i],&c[i]);
+        init();
+        int u, v;
+        for(int i=0; i<n-1; i++)
+        {
+            scanf("%d%d",&u,&v);
+            AddEdge(u, v);
+            AddEdge(v, u);
+        }
+        dfs(0,-1);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4617_autoAC.cpp b/HDOJ/4617_autoAC.cpp
new file mode 100644
index 0000000..c4ea368
--- /dev/null
+++ b/HDOJ/4617_autoAC.cpp
@@ -0,0 +1,120 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+#include <set>
+#include <map>
+#include <vector>
+#include <queue>
+#include <string>
+#include <math.h>
+using namespace std;
+const double eps = 1e-8;
+int sgn(double x)
+{
+    if(fabs(x) < eps)return 0;
+    if(x < 0)return -1;
+    else return 1;
+}
+struct Point3D
+{
+    double x,y,z;
+    Point3D(double _x = 0,double _y = 0,double _z = 0)
+    {
+        x = _x;
+        y = _y;
+        z = _z;
+    }
+    Point3D operator -(const Point3D &b)const
+    {
+        return Point3D(x-b.x,y-b.y,z-b.z);
+    }
+    Point3D operator ^(const Point3D &b)const
+    {
+        return Point3D(y*b.z-z*b.y,z*b.x-x*b.z,x*b.y-y*b.x);
+    }
+    double operator *(const Point3D &b)const
+    {
+        return x*b.x+y*b.y+z*b.z;
+    }
+    void input()
+    {
+        scanf("%lf%lf%lf",&x,&y,&z);
+    }
+};
+double Norm(Point3D p)
+{
+    return sqrt(p*p);
+}
+double calc(Point3D a,Point3D k1,Point3D b,Point3D k2)
+{
+    Point3D tmp = k1^k2;
+    return fabs(tmp*(a-b))/sqrt(tmp*tmp);
+}
+struct Node
+{
+    Point3D o,p1,p2;
+    void input()
+    {
+        o.input();
+        p1.input();
+        p2.input();
+    }
+}node[50];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        for(int i = 0;i < n;i++)
+            node[i].input();
+        bool flag = false;
+        double Min = 1e20;
+        for(int i = 0;i < n;i++)
+            for(int j = i+1;j < n;j++)
+            {
+                if(flag)break;
+                double  r1 = sqrt((node[i].p1-node[i].o)*(node[i].p1-node[i].o));
+                double  r2 = sqrt((node[j].p1-node[j].o)*(node[j].p1-node[j].o));
+                Point3D  k1 = (node[i].p1-node[i].o)^(node[i].p2-node[i].o);
+                Point3D  k2 = (node[j].p1-node[j].o)^(node[j].p2-node[j].o);
+                if(sgn(Norm(k1^k2))==0)
+                {
+                    if(sgn( Norm( k1^(node[i].o-node[j].o)) ) == 0)
+                    {
+                        if(sgn(r1-r2) == 0)
+                        {
+                            flag = true;
+                            break;
+                        }
+                        else continue;
+                    }
+                    else
+                    {
+                        double dd = (k1*(node[i].o-node[j].o))/Norm(k1);
+                        double d = sqrt( Norm(node[i].o-node[j].o)*Norm(node[i].o-node[j].o) - dd*dd );
+                        if(d > fabs(r1-r2) &&d < fabs(r1+r2))
+                        {
+                            flag = true;
+                            break;
+                        }
+                        Min = min(Min,d-r1-r2);
+                    }
+                    continue;
+                }
+                double d = calc(node[i].o,k1,node[j].o,k2);
+                if(d < r1 + r2 -eps)
+                {
+                    flag = true;
+                    break;
+                }
+                Min = min(Min,d-r1-r2);
+            }
+        if(flag || sgn(Min)<=0)printf("Lucky\n");
+        else printf("%.2lf\n",Min);
+    }
+    return 0;
+}
diff --git a/HDOJ/4619_autoAC.cpp b/HDOJ/4619_autoAC.cpp
new file mode 100644
index 0000000..3feca92
--- /dev/null
+++ b/HDOJ/4619_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<string.h>
+#include<vector>
+using namespace std;
+const int MAXN=2505;
+int linker[MAXN];
+bool used[MAXN];
+vector<int>map[MAXN];
+int uN;
+bool dfs(int u)
+{
+    for(int i=0;i<map[u].size();i++)
+    {
+        if(!used[map[u][i]])
+        {
+            used[map[u][i]]=true;
+            if(linker[map[u][i]]==-1||dfs(linker[map[u][i]]))
+            {
+                linker[map[u][i]]=u;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int hungary()
+{
+    int u;
+    int res=0;
+    memset(linker,-1,sizeof(linker));
+    for(u=0;u<uN;u++)
+    {
+        memset(used,false,sizeof(used));
+        if(dfs(u)) res++;
+    }
+    return res;
+}
+pair<int,int>p1[MAXN];
+pair<int,int>p2[MAXN];
+int main()
+{
+    int n,m;
+    int x,y;
+    while(scanf("%d%d",&n,&m)==2)
+    {
+        if(n==0 &&m==0)break;
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d%d",&x,&y);
+            p1[i]= make_pair(x,y);
+        }
+        for(int i = 0;i < m;i++)
+        {
+            scanf("%d%d",&x,&y);
+            p2[i]= make_pair(x,y);
+        }
+        uN = n;
+        for(int i = 0;i < n;i++)
+            map[i].clear();
+        for(int i = 0;i < n;i++)
+        {
+            for(int j = 0;j < m;j++)
+            {
+                int x1 = p1[i].first;
+                int y1 = p1[i].second;
+                int x2 = p2[j].first;
+                int y2 = p2[j].second;
+                if( (x1==x2 && y1==y2)
+                   ||(x1==x2 && y1==y2+1)
+                   ||(x1+1==x2 && y1==y2)
+                   ||(x1+1==x2 && y1==y2+1)
+                   )
+                    map[i].push_back(j);
+            }
+        }
+        int ans = n+m-hungary();
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4620_autoAC.cpp b/HDOJ/4620_autoAC.cpp
new file mode 100644
index 0000000..cf1c9d3
--- /dev/null
+++ b/HDOJ/4620_autoAC.cpp
@@ -0,0 +1,76 @@
+#include <iostream>
+#include <cstring>
+#include <string>
+#include <cstdio>
+#include <algorithm>
+#include <vector>
+#include <cmath>
+using namespace std;
+struct node
+{
+    int t,p[15],c,id;
+}cut[35];
+bool cmp(node x,node y)
+{
+    return x.t<y.t;
+}
+int T,longe,ans[35],tmpa[35],tmpl,n,w,m,vis[205],num;
+void dfs(int pos,int lastt)
+{
+    if(n-pos+tmpl<=longe) return;
+    int num,i,j,tmp;
+    for(i=pos+1;i<=n;i++)
+    {
+        for(j=1,num=0;j<=cut[i].c;j++)
+        {
+            tmp=cut[i].p[j];
+            if(vis[tmp]==0)
+                num++;
+            vis[tmp]++;
+        }
+        if((cut[i].t-lastt<=w||!tmpl)&&num>=3)
+        {
+            tmpl++;
+            tmpa[tmpl]=cut[i].id;
+            dfs(i,cut[i].t);
+            tmpl--;
+        }
+        for(j=1;j<=cut[i].c;j++)
+        {
+            tmp=cut[i].p[j];
+            vis[tmp]--;
+        }
+    }
+    if(longe<tmpl)
+    {
+        longe=tmpl;
+        for(j=0;j<longe;j++)
+            ans[j]=tmpa[j+1];
+    }
+}
+int main()
+{
+    int i,j;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d",&n,&m,&w);
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d%d",&cut[i].c,&cut[i].t);
+            for(j=1;j<=cut[i].c;j++)
+                scanf("%d",&cut[i].p[j]);
+            cut[i].id=i;
+        }
+        sort(cut+1,cut+n+1,cmp);
+        memset(vis,0,sizeof vis);
+        longe=0;tmpl=0;
+        dfs(0,cut[1].t);
+        sort(ans,ans+longe);
+        printf("%d\n",longe);
+        for(i=0;i<longe-1;i++)
+            printf("%d ",ans[i]);
+        printf("%d\n",ans[longe-1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4622_autoAC.cpp b/HDOJ/4622_autoAC.cpp
new file mode 100644
index 0000000..bee8be0
--- /dev/null
+++ b/HDOJ/4622_autoAC.cpp
@@ -0,0 +1,116 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#include <stdlib.h>
+#define ll __int64
+using namespace std ;
+const int maxn = 1111111 ;
+ll f[maxn] , g[maxn] ;
+int wa[maxn] , wb[maxn] , wv[maxn] , ws[maxn] , pos[maxn] ;
+struct suf
+{
+    int sa[maxn] , hei[maxn] , rank[maxn] ;
+    int cmp ( int *r , int i , int j , int l )
+    {
+        return r[i] == r[j] && r[i+l] == r[j+l] ;
+    }
+    void da ( int *r , int n , int m )
+    {
+        int *x = wa , *y = wb , *t ;
+        int i , j , p ;
+        for ( i = 0 ; i < m ; i ++ ) ws[i] = 0 ;
+        for ( i = 0 ; i < n ; i ++ ) ws[x[i]=r[i]] ++ ;
+        for ( i = 1 ; i < m ; i ++ ) ws[i] += ws[i-1] ;
+        for ( i = n - 1 ; i >= 0 ; i -- ) sa[--ws[x[i]]] = i ;
+        for ( j = 1 , p = 1 ; p < n ; j *= 2 , m = p )
+        {
+            for ( p = 0 , i = n - j ; i < n ; i ++ ) y[p++] = i ;
+            for ( i = 0 ; i < n ; i ++ ) if ( sa[i] >= j ) y[p++] = sa[i] - j ;
+            for ( i = 0 ; i < m ; i ++ ) ws[i] = 0 ;
+            for ( i = 0 ; i < n ; i ++ ) ws[x[i]] ++ ;
+            for ( i = 1 ; i < m ; i ++ ) ws[i] += ws[i-1] ;
+            for ( i = n - 1 ; i >= 0 ; i -- ) sa[--ws[x[y[i]]]] = y[i] ;
+            for ( t = x , x = y , y = t , p = 1 , x[sa[0]] = 0 , i = 1 ; i < n ; i ++ )
+                x[sa[i]] = cmp ( y , sa[i-1] , sa[i] , j ) ? p - 1 : p ++ ;
+        }
+        int k = 0 ;
+        for ( i = 1 ; i < n ; i ++ ) rank[sa[i]] = i ; 
+        for ( i = 0 ; i < n - 1 ; hei[rank[i++]] = k )
+            for ( k ? k -- : 0 , j = sa[rank[i]-1] ; r[i+k] == r[j+k] ; k ++ ) ;
+    }
+    int solve ( int n )
+    {
+        int ans = 0 , i ;
+        for ( i = 1 ; i <= n ; i ++ )
+            ans += n - sa[i] - hei[i] ;
+        return ans ;
+    }
+} arr ;
+int s1[maxn] , dp[20][2222] ;
+void rmq ( int n )
+{
+    int i , j ;
+    f[0] = 1 ;
+    for ( i = 1 ; i <= 15 ; i ++ )
+        f[i] = f[i-1] * 2 ;
+    g[0] = -1 ;
+    for ( i = 1 ; i < 2222 ; i ++ )
+        g[i] = g[i>>1] + 1 ;
+    for ( i = 1 ; f[i] <= n ; i ++ )
+        for ( j = 1 ; j + f[i] - 1 <= n ; j ++ )
+            dp[i][j] = min ( dp[i-1][j] , dp[i-1][j+f[i-1]] ) ;
+}
+int query ( int l , int r )
+{
+    if ( l == r ) return dp[0][l] ;
+    if ( l > r ) swap ( l , r ) ;
+    int i , j , k ;
+    k = g[r-l+1] ;
+    return min ( dp[k][l] , dp[k][r-f[k]+1] ) ;
+}
+char s[maxn] ;
+int num[maxn] ;
+int main ()
+{
+    int n , k , i , l , r ;
+    int cas ;
+    scanf ( "%d" , &cas ) ;
+    while ( cas -- )
+    {
+        int q ;
+        scanf ( "%s" , s ) ;
+        int len = strlen ( s ) ;
+        for ( i = 0 ; i < len ; i ++ ) s1[i] = s[i] ;
+        s1[len] = 0 ;
+        arr.da ( s1 , len + 1 , 555 ) ;
+        for ( i = 1 ; i <= len ; i ++ )
+            dp[0][i] = arr.hei[i] ;
+        rmq ( len ) ;
+        n = len ;
+        scanf ( "%d" , &q ) ;
+        while ( q -- )
+        {
+            scanf ( "%d%d" , &l , &r ) ;
+            int ans = ( r - l + 1 ) * ( r - l + 2) / 2 ;
+            for ( i = 0 ; i <= n ; i ++ ) pos[i] = -1 ;
+            for ( i = l ; i <= r ; i ++ ) 
+                pos[arr.rank[i-1]] = i - 1 ;
+            int last = -1 , d = 0 ;
+            for ( i = 1 ; i <= n ; i ++ )
+            {
+                if ( pos[i] != -1 )
+                {
+                    if ( last != -1 )
+                    {
+                        int t = query ( arr.rank[last] + 1 , arr.rank[pos[i]] ) ;
+                        d = min ( d , t ) ;
+                        d = max ( d , min ( t , r - last ) ) ;
+                        ans -= min ( d , r - pos[i] ); 
+                    }
+                    last = pos[i] ;
+                }
+            }
+            printf ( "%d\n" , ans ) ;
+        }
+    }
+}
diff --git a/HDOJ/4623_autoAC.cpp b/HDOJ/4623_autoAC.cpp
new file mode 100644
index 0000000..16a0a56
--- /dev/null
+++ b/HDOJ/4623_autoAC.cpp
@@ -0,0 +1,123 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+const int prime[]={2,3,5,7,11,13,17,19,23};
+const int np=9;
+int state[30];
+int g[300][300];
+int vi[300];
+int num[30];
+int base[30];
+short dp[19][2000000];
+bool ok[29];
+int n,m,ns,st;
+void ini()
+{
+    scanf("%d%d",&n,&m);
+    memset(g,0,sizeof(g));
+    memset(vi,0,sizeof(vi));
+    memset(num,0,sizeof(num));
+    ns=0;
+    state[++ns]=0;
+    num[ns]=1;
+    for(int i=2;i<=n;i++)
+    {
+        st=0;
+        if(ok[i])
+        {
+            num[1]++;
+            continue;
+        }
+        for(int j=0;j<np;j++)
+        {
+            if(i%prime[j]==0)
+            {
+                st|=(1<<j);
+            }
+        }
+        if(!vi[st])
+        {
+            state[++ns]=st;
+            num[ns]=1;
+            vi[st]=ns;
+        }
+        else
+        {
+            num[vi[st]]++;
+        }
+    }
+    for(int i=1;i<=ns;i++)
+    {
+        for(int j=1;j<=ns;j++)
+        {
+            if((state[i]&state[j])==0)
+                g[i][j]=1;
+        }
+    }
+    base[1]=1;
+    st=0;
+    for(int i=1;i<=ns;i++)
+    {
+        base[i+1]=base[i]*(num[i]+1);
+        st+=base[i]*num[i];
+    }
+}
+int getnum(int i,int x)
+{
+    int res=(x%base[i+1])/(base[i]);
+    return res;
+}
+int getstate(int i,int num)
+{
+    return num*base[i];
+}
+void dfs(int t,int x)
+{
+    if(t==0)
+    {
+        dp[x][0]=1;
+        return ;
+    }
+    if(dp[x][t]!=-1)
+        return;
+    dp[x][t]=0;
+    for(int i=1;i<=ns;i++)
+    {
+        if(g[x][i]&&getnum(i,t)>=1)
+        {
+            dfs(t-base[i],i);
+            dp[x][t]=((int)dp[x][t]+dp[i][t-base[i]])%m;
+        }
+    }
+    return;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    memset(ok,0,sizeof(ok));
+    ok[17]=1;
+    ok[19]=1;
+    ok[23]=1;
+    while(T--)
+    {
+        ini();
+        memset(dp,-1,sizeof(dp));
+        int ans=0;
+        for(int i=1;i<=ns;i++)
+        {
+            dfs(st-base[i],i);
+            ans=((int)ans+dp[i][st-base[i]])%m;
+        }
+        for(int i=1;i<=ns;i++)
+        {
+            while(num[i]>1)
+            {
+                ans=((int)ans*num[i])%m;
+                num[i]--;
+            }
+        }
+        printf("%d\n",ans);
+    }
+}
diff --git a/HDOJ/4625_autoAC.cpp b/HDOJ/4625_autoAC.cpp
new file mode 100644
index 0000000..32ef270
--- /dev/null
+++ b/HDOJ/4625_autoAC.cpp
@@ -0,0 +1,94 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <vector>
+using namespace std;
+const int maxn = 5e4 + 10;
+const int maxk = 5e2 + 10;
+const int mod = 10007;
+typedef long long LL;
+struct edge {
+  int v, to;
+};
+vector<edge> E;
+int L[maxn];
+void graph_init()
+{
+  E.clear();
+  memset(L, -1, sizeof(L));
+}
+void graph_add(int u, int v)
+{
+  edge t = {v, L[u]};
+  L[u] = E.size();
+  E.push_back(t);
+}
+int s[maxk][maxk];  
+int f[maxk];       
+int c[maxk][maxk]; 
+void init()
+{
+  s[0][0] = f[0] = c[0][0] = 1;
+  for (int i = 1; i < maxk; i++) {
+    f[i] = f[i-1] * i % mod;
+    c[i][0] = 1;
+    for (int j = 1; j < maxk; j++) {
+      s[i][j] = (j * s[i-1][j] % mod + s[i-1][j-1]) % mod;
+      c[i][j] = (c[i-1][j] + c[i-1][j-1]) % mod;
+    }
+  }
+}
+int n, k;
+int d[maxn][maxk];
+void dp_son(int u = 0, int p = -1)
+{
+  memset(d[u], 0, sizeof(d[u]));
+  for (int i = L[u]; i != -1; i = E[i].to)
+    if (i != p) {
+      int v = E[i].v;
+      dp_son(v, i^1);
+      for (int j = 0; j <= k; j++)
+        d[u][j] = (d[u][j] + d[v][j] + (j? d[v][j-1]: 0) + c[1][j]) % mod;
+    }
+}
+int tmp[maxk];
+void dp_father(int u = 0, int p = -1)
+{
+  if (p != -1) {
+    int v = E[p].v;
+    memcpy(tmp, d[v], sizeof(d[v]));
+    for (int j = 0; j <= k; j++)
+      tmp[j] = (tmp[j] - (d[u][j] + (j? d[u][j-1]: 0) + c[1][j]) % mod + mod) % mod;
+    for (int j = 0; j <= k; j++)
+      d[u][j] = (d[u][j] + tmp[j] + (j? tmp[j-1]: 0) + c[1][j]) % mod;
+  }
+  for (int i = L[u]; i != -1; i = E[i].to)
+    if (i != p) dp_father(E[i].v, i^1);
+}
+int main()
+{
+  init();
+  int T;
+  scanf("%d", &T);
+  for ( ; T--; ) {
+    graph_init();
+    scanf("%d%d", &n, &k);
+    for (int i = 0; i < n-1; i++) {
+      int u, v;
+      scanf("%d%d", &u, &v);
+      u--, v--;
+      graph_add(u, v);
+      graph_add(v, u);
+    }
+    dp_son();
+    dp_father();
+    for (int u = 0; u < n; u++) {
+      int sum = 0;
+      for (int i = 0; i <= k; i++)
+        sum = (sum + s[k][i]*f[i]%mod*d[u][i]%mod) % mod;
+      printf("%d\n", sum);
+    }
+  }
+  return 0;
+}
diff --git a/HDOJ/4627_autoAC.cpp b/HDOJ/4627_autoAC.cpp
new file mode 100644
index 0000000..2899bec
--- /dev/null
+++ b/HDOJ/4627_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+using namespace std;
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+    __int64 n;
+    scanf("%I64d",&n);
+    if(n==2)
+    {
+        printf("1\n");
+        continue;
+    }
+    if(n&1)
+        printf("%I64d\n",(n/2)*(n/2+1));
+    else
+    {
+        n/=2;
+        if(n&1)
+        printf("%I64d\n",(n-2)*(n+2));
+        else
+        printf("%I64d\n",(n-1)*(n+1));
+    }
+    }
+    return 0;
+}
diff --git a/HDOJ/4628_autoAC.cpp b/HDOJ/4628_autoAC.cpp
new file mode 100644
index 0000000..2ce41ba
--- /dev/null
+++ b/HDOJ/4628_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <cstdio>  
+#include <cstring>  
+#include <algorithm>  
+#include <cmath>  
+#include <iostream>  
+using namespace std;  
+bool legal[(1<<16)+1];  
+int dp[(1<<16)+1];  
+char s[20];  
+char str[20];  
+int main()  
+{  
+    int t;  
+    scanf("%d",&t);  
+    while(t--)  
+    {  
+        scanf("%s",s);  
+        int num=0;  
+        int len=strlen(s);  
+        for(int i=1;i<(1<<len);i++)  
+        {  
+            int cnt=0;  
+            for(int j=0;j<len;j++)  
+                if(i&(1<<j))  
+                    str[cnt++]=s[j];  
+            int l=0,r=cnt-1;  
+            while(l<r && str[l]==str[r])  
+            {  
+                l++;  
+                r--;  
+            }  
+            if(l==r || l-1==r)  
+                legal[i]=true;  
+            else  
+                legal[i]=false;  
+        }  
+        memset(dp,0x3f,sizeof(dp));  
+        dp[0]=0;  
+        for(int i=1;i<(1<<len);i++)  
+        {  
+            for(int j=i;j>0;j=i&(j-1))  
+                if(legal[j])  
+                    dp[i]=min(dp[i],dp[i-j]+1);  
+        }  
+        printf("%d\n",dp[(1<<len)-1]);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4629_autoAC.cpp b/HDOJ/4629_autoAC.cpp
new file mode 100644
index 0000000..bc3c29b
--- /dev/null
+++ b/HDOJ/4629_autoAC.cpp
@@ -0,0 +1,168 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<vector>
+#include<cstdlib>
+#define pbk push_back
+using namespace std;
+const int N = 25050+10;
+const double eps = 1e-10;
+inline double sqr(double x){
+    return x * x;
+}
+inline int dcmp(double x){
+    return x < -eps ? -1 : x > eps;
+}
+struct Point{
+    double x,y;
+    int kind;
+    Point(){}
+    Point(double x,double y,int kind = 0):x(x),y(y),kind(kind){}
+    bool operator < (const Point &p)const{
+        return dcmp(x - p.x) < 0 || ( dcmp(x - p.x) == 0 && dcmp(y - p.y) < 0 );
+    }
+    Point operator - (const Point &p)const{
+        return Point(x - p.x, y - p.y);
+    }
+    Point operator + (const Point &p)const{
+        return Point(x + p.x, y + p.y);
+    }
+    Point operator * (const double &k)const{
+        return Point (x*k , y*k);
+    }
+    Point operator / (const double &k)const{
+        return Point (x/k, y/k);
+    }
+    double operator * (const Point &p)const{
+        return x * p.y - y * p.x;
+    }
+    double operator / (const Point &p)const{
+        return x * p.x + y * p.y;
+    }
+    void input(){
+        scanf("%lf%lf",&x,&y);
+    }
+    void ot(){
+        printf("%lf %lf\n",x,y);
+    }
+};
+struct Line{
+    Point a,b;
+    int kind;
+    Line (){}
+    Line (Point a,Point b,int kind = 0):a(a),b(b),kind(kind){}
+    double operator * (const Point &p)const{
+        return ( b - a ) * ( p - a );
+    }
+    double operator / (const Point &p)const{
+        return ( p - a) / ( p - b);
+    }
+    bool parallel(const Line &v){
+        return !dcmp( ( b - a ) * ( v.b - v.a ) ); 
+    }
+    int LineCrossLine(const Line &v){
+        if ( (*this).parallel(v) ){
+            return ( dcmp( v * a ) == 0);
+        }return 2;
+    }
+    int SegCrossSeg(const Line &v){
+        int d1 = dcmp( (*this) * v.a);
+        int d2 = dcmp( (*this) * v.b);
+        int d3 = dcmp( v * a);
+        int d4 = dcmp( v * b);
+        if ( ( d1 ^ d2 ) == -2 && ( d3 ^ d4 ) == -2 ) return 2;
+        return ( ( d1 == 0 && dcmp( (*this) / v.a ) <= 0 )
+            ||   ( d2 == 0 && dcmp( (*this) / v.b ) <= 0 )
+            ||   ( d3 == 0 && dcmp( v / a ) <= 0 )
+            ||   ( d4 == 0 && dcmp( v / b ) <= 0 )
+            );
+    }
+    Point CrossPoint(const Line &v){
+        double s1 = v * a, s2 = v * b;
+        return ( a * s2 - b * s1) / (s2 - s1);
+    }
+    void input(){
+        a.input(); b.input();
+    }
+    void ot(){
+        a.ot(); b.ot();
+    }
+};
+int n,poly_n,xn;
+vector<double> lx;
+vector<Line> line;
+double ans[N];
+void init(){
+    int sz = line.size();
+    for (int i = 0; i < sz; i++){
+        for (int j = i+1; j < sz; j++){
+            if (line[i].SegCrossSeg(line[j]) == 2){
+                Point p = line[i].CrossPoint(line[j]);
+                lx.pbk(p.x);
+            }
+        }
+    }
+    sort(lx.begin(),lx.end());
+    xn = unique(lx.begin(),lx.end()) - lx.begin();
+}
+vector<Point> qu[N];
+void work(){
+    for (int i = 0; i <= n; i++) ans[i] = 0;
+    for (int i = 0; i < xn-1; i++){
+        int k = 0;
+        for (int j = 0; j+1 < qu[i].size(); j++){
+            k += qu[i][j].kind;
+            ans[ k ] += (lx[i+1] - lx[i]) * (qu[i][j+1].x+qu[i][j+1].y - qu[i][j].x - qu[i][j].y) / 2;        
+        }
+    }
+    for (int i = 1; i <= n; i++) printf("%.10lf\n",ans[i]);
+}
+void solve(){
+    for (int i = 0; i < xn; i++) qu[i].clear();
+    for (int i = 0; i < line.size(); i++){
+        int j = lower_bound(lx.begin(),lx.begin()+xn,line[i].a.x) - lx.begin();
+        for (; j+1 < xn; j++ ){
+            double l = lx[j], r = lx[j+1];
+            if (dcmp(r - line[i].b.x) > 0) break;
+            Point p1 = line[i].CrossPoint(Line(Point(l,0), Point(l,1)));
+            Point p2 = line[i].CrossPoint(Line(Point(r,0), Point(r,1)));
+            qu[j].pbk(Point(p1.y, p2.y,line[i].kind));
+        }
+    }
+    for (int i = 0; i < xn - 1; i++) sort(qu[i].begin(), qu[i].end());
+    work();
+}
+int main(){
+    int T; scanf("%d",&T);
+    while (T--){
+        scanf("%d",&n);
+        lx.clear(); line.clear();;
+        for (int i = 0; i < n ;i++){
+            Point t[4];
+            for (int j = 0; j < 3; j++ ){
+                t[j].input(); 
+            }
+            t[3] = t[0];
+            int flag = 1;
+            if (dcmp( (t[1] - t[0])*(t[2] - t[0]) ) == 0) flag = 0;
+            for (int i = 0; i < 3 && flag; i++ ){
+                lx.pbk(t[i].x);
+                for (int j = i+1; j < 3; j++){
+                    Line tmp; tmp.a = t[i]; tmp.b = t[j];
+                    if (dcmp( tmp.a.x - tmp.b.x ) > 0) swap(tmp.a, tmp.b);
+                    Line tmp2 = Line(t[3-i-j], Point(t[3-i-j].x, t[3-i-j].y - 1));
+                    if (tmp.LineCrossLine(tmp2) != 2) continue;
+                    Point tp = tmp.CrossPoint(tmp2);
+                    if (dcmp(tp.y - t[3-i-j].y) < 0) tmp.kind = 1;
+                        else tmp.kind = -1;    
+                    line.pbk(tmp);
+                }
+            }
+        }
+        init();
+        solve();    
+    }
+    return 0;
+}
diff --git a/HDOJ/4630_autoAC.cpp b/HDOJ/4630_autoAC.cpp
new file mode 100644
index 0000000..e9fac84
--- /dev/null
+++ b/HDOJ/4630_autoAC.cpp
@@ -0,0 +1,121 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <algorithm>
+using namespace std;
+#define lz 2*u,l,mid
+#define rz 2*u+1,mid+1,r
+const int maxn=50005;
+int maxx[4*maxn], flag[4*maxn];
+int a[maxn];
+int pre[maxn];
+int n, m, T;
+vector<int>vt;
+struct node
+{
+    int l, r, id;
+    int ans;
+    friend bool operator<(const node A, const node B)
+    {
+        return A.r<B.r;
+    }
+}f[maxn];
+bool cmp(node A, node B)
+{
+    return A.id<B.id;
+}
+void push_down(int u, int l, int r)
+{
+    if(flag[u])
+    {
+        flag[2*u]=max(flag[2*u],flag[u]);
+        flag[2*u+1]=max(flag[2*u+1],flag[u]);
+        maxx[2*u]=max(maxx[2*u],flag[u]);
+        maxx[2*u+1]=max(maxx[2*u+1],flag[u]);
+        flag[u]=0;
+    }
+}
+void Update(int u, int l, int r, int tl, int tr, int val)
+{
+    maxx[u]=max(maxx[u],val);
+    if(tl<=l&&r<=tr)
+    {
+        flag[u]=max(flag[u],val);
+        maxx[u]=max(maxx[u],val);
+        return ;
+    }
+    push_down(u,l,r);
+    int mid=(l+r)>>1;
+    if(tr<=mid) Update(lz,tl,tr,val);
+    else if(tl>mid) Update(rz,tl,tr,val);
+    else
+    {
+        Update(lz,tl,mid,val);
+        Update(rz,mid+1,tr,val);
+    }
+}
+int Query(int u, int l, int r, int tl, int tr)
+{
+    if(tl<=l&&r<=tr) return maxx[u];
+    push_down(u,l,r);
+    int mid=(l+r)>>1;
+    if(tr<=mid) return Query(lz,tl,tr);
+    else if(tl>mid) return Query(rz,tl,tr);
+    else
+    {
+        int t1=Query(lz,tl,mid);
+        int t2=Query(rz,mid+1,tr);
+        return max(t1,t2);
+    }
+}
+void Solve(int x, int r)
+{
+    vt.clear();
+    vt.push_back(x);
+    for(int i=2; i*i<=x; i++)
+        if(x%i==0)
+        {
+            vt.push_back(i);
+            vt.push_back(x/i);
+        }
+    for(int i=0; i<vt.size(); i++)
+    {
+        int l=pre[ vt[i] ];
+        pre[ vt[i] ]=r;
+        if(l==-1||l==r) continue;
+        Update(1,1,n,l,l,vt[i]);
+    }
+}
+int main()
+{
+    cin >> T;
+    while(T--)
+    {
+        cin >> n;
+        for(int i=1; i<=n; i++) scanf("%d", a+i), pre[i]=-1;
+        cin >> m;
+        for(int i=1; i<=m; i++) f[i].id=i, scanf("%d%d",&f[i].l,&f[i].r);
+        sort(f+1,f+m+1);
+        for(int i=1; i<=4*n; i++) maxx[i]=1, flag[i]=0;
+        int i=1, j=1;
+        while(j<=m)
+        {
+            if(i<=f[j].r&&i<=n)
+            {
+                Solve(a[i],i);
+                i++;
+            }
+            else
+            {
+                if(f[j].l!=f[j].r)f[j].ans=Query(1,1,n,f[j].l,f[j].r);
+                else f[j].ans=0;
+                j++;
+            }
+        }
+        sort(f+1,f+m+1,cmp);
+        for(int i=1; i<=m; i++)
+            printf("%d\n",f[i].ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4631_autoAC.cpp b/HDOJ/4631_autoAC.cpp
new file mode 100644
index 0000000..191c04c
--- /dev/null
+++ b/HDOJ/4631_autoAC.cpp
@@ -0,0 +1,113 @@
+#include <stdio.h>
+#include <algorithm>
+#include <string.h>
+#include <iostream>
+#include <map>
+#include <vector>
+#include <queue>
+#include <set>
+#include <string>
+#include <math.h>
+using namespace std;
+const int MAXN = 500010;
+struct Point
+{
+    int x,y;
+    int id;
+    int index;
+    Point(int _x = 0,int _y = 0,int _index = 0)
+    {
+        x = _x;
+        y = _y;
+        index = _index;
+    }
+};
+Point P[MAXN];
+long long dist(Point a,Point b)
+{
+    return ((long long)(a.x-b.x)*(a.x-b.x) + (long long)(a.y-b.y)*(a.y-b.y));
+}
+Point p[MAXN];
+Point tmpt[MAXN];
+bool cmpxy(Point a,Point b)
+{
+    if(a.x != b.x)return a.x < b.x;
+    else return a.y < b.y;
+}
+bool cmpy(Point a,Point b)
+{
+    return a.y < b.y;
+}
+pair<int,int> Closest_Pair(int left,int right)
+{
+    long long d = (1LL<<50);
+    if(left == right)return make_pair(left,right);
+    if(left + 1 == right)
+        return make_pair(left,right);
+    int mid = (left+right)/2;
+    pair<int,int>pr1 = Closest_Pair(left,mid);
+    pair<int,int>pr2 = Closest_Pair(mid+1,right);
+    long long d1,d2;
+    if(pr1.first == pr1.second)
+        d1 = (1LL<<50);
+    else d1 = dist(p[pr1.first],p[pr1.second]);
+    if(pr2.first == pr2.second)
+        d2 = (1LL<<50);
+    else d2 = dist(p[pr2.first],p[pr2.second]);
+    pair<int,int>ans;
+    if(d1 < d2)ans = pr1;
+    else ans = pr2;
+    d = min(d1,d2);
+    int k = 0;
+    for(int i = left;i <= right;i++)
+    {
+        if((long long)(p[mid].x - p[i].x)*(p[mid].x - p[i].x) <= d)
+            tmpt[k++] = p[i];
+    }
+    sort(tmpt,tmpt+k,cmpy);
+    for(int i = 0;i <k;i++)
+    {
+        for(int j = i+1;j < k && (long long)(tmpt[j].y - tmpt[i].y)*(tmpt[j].y - tmpt[i].y) < d;j++)
+        {
+            if(d > dist(tmpt[i],tmpt[j]))
+            {
+                d = dist(tmpt[i],tmpt[j]);
+                ans = make_pair(tmpt[i].id,tmpt[j].id);
+            }
+        }
+    }
+    return ans;
+}
+int main()
+{
+    int T;
+    int n,Ax,Ay,Bx,By,Cx,Cy;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d%d%d%d%d",&n,&Ax,&Bx,&Cx,&Ay,&By,&Cy);
+        P[0] = Point(0,0,0);
+        for(int i = 1;i <= n;i++)
+        {
+            long long x= ((long long)P[i-1].x*Ax + Bx)%Cx;
+            long long y = ((long long)P[i-1].y*Ay + By)%Cy;
+            P[i] = Point(x,y,i);
+        }
+        int end = n;
+        long long ans = 0;
+        while(end > 1)
+        {
+            for(int i = 0;i < end;i++)
+                p[i] = P[i+1];
+            sort(p,p+end,cmpxy);
+            for(int i = 0;i < end;i++)
+                p[i].id = i;
+            pair<int,int>pr = Closest_Pair(0,end-1);
+            int Max = max(p[pr.first].index,p[pr.second].index);
+            ans += (long long)(end-Max+1)*dist(p[pr.first],p[pr.second]);
+            end = Max-1;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4632_autoAC.cpp b/HDOJ/4632_autoAC.cpp
new file mode 100644
index 0000000..ffccee1
--- /dev/null
+++ b/HDOJ/4632_autoAC.cpp
@@ -0,0 +1,66 @@
+#include"iostream"
+#include"cstdio"
+#include"cstring"
+using namespace std;
+const int N=1006;
+const int mod=10007;
+int n,lowbit[N];
+__int64 C[N],ans[N];
+char str[N];
+void update(int k,int dir)
+{
+    while(0<k && k<=n)
+    {
+        C[k]=(C[k]+dir)%mod;
+        k+=lowbit[k];
+    }
+}
+int sum(int k)
+{
+    __int64 p=0;
+    while(0<k && k<=n)
+    {
+        p=(p+C[k])%mod;
+        k-=lowbit[k];
+    }
+    return p;
+}
+int main()
+{
+    int T,Case;
+    int i,l;
+    __int64 a,b,t;
+    __int64 hehe;
+    for(i=1;i<=1000;i++)    lowbit[i]=i&(-i);
+    cin>>T;
+    for(Case=1;Case<=T;Case++)
+    {
+        hehe=0;
+        scanf("%s",str+1);
+        memset(C,0,sizeof(C));
+        memset(ans,0,sizeof(ans));
+        for(n=1;str[n];n++);
+        n--;
+        for(i=n;i>=1;i--)
+        {
+            ans[i]=1;
+            update(i,1);
+            for(l=n;l>i;l--)
+            {
+                if(str[l]==str[i])
+                {
+                    a=sum(i);
+                    b=sum(l-1);
+                    t=(b-a)%mod;
+                    while(t<0)    t+=mod;
+                    ans[i]=(ans[i]+1+t)%mod;
+                    update(l,1+t);
+                }
+            }
+        }
+        hehe=0;
+        for(i=1;i<=n;i++)    hehe=(hehe+ans[i])%mod;
+        printf("Case %d: %I64d\n",Case,hehe);
+    }
+    return 0;
+}
diff --git a/HDOJ/4633_autoAC.cpp b/HDOJ/4633_autoAC.cpp
new file mode 100644
index 0000000..b3e60b3
--- /dev/null
+++ b/HDOJ/4633_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+const LL MOD=10007;
+LL quick_mod(LL a,LL b)
+{
+    LL ans=1;
+    a%=MOD;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans=ans*a%MOD;
+            b--;
+        }
+        b>>=1;
+        a=a*a%MOD;
+    }
+    return ans;
+}
+int main()
+{
+    LL tt=1,t,k,ans;
+    cin>>t;
+    while(t--)
+    {
+        cin>>k;
+        ans=quick_mod(k,74);
+        ans+=3*(2*quick_mod(k,20)+quick_mod(k,38))%MOD;
+        ans+=6*quick_mod(k,38);
+        ans+=8*quick_mod(k,26);
+        ans%=MOD;
+        ans*=quick_mod(24,MOD-2);
+        ans%=MOD;
+        printf("Case %I64d: %I64d\n",tt++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4634_autoAC.cpp b/HDOJ/4634_autoAC.cpp
new file mode 100644
index 0000000..3c422b7
--- /dev/null
+++ b/HDOJ/4634_autoAC.cpp
@@ -0,0 +1,142 @@
+#include <stdio.h>
+#include <algorithm>
+#include <string.h>
+#include <iostream>
+#include <map>
+#include <vector>
+#include <queue>
+#include <set>
+#include <string>
+#include <math.h>
+using namespace std;
+char g[220][220];
+int sx,sy,ex,ey;
+int n,m;
+int keynum;
+int key_s[220][220];
+int mo[][2] = {{0,1},{0,-1},{1,0},{-1,0}};
+struct Node
+{
+    int key;
+    int num;
+    int x,y;
+};
+queue<Node>q;
+bool used[202][202][1<<7];
+bool used2[202][202][1<<7][4];
+int bfs()
+{
+    while(!q.empty())q.pop();
+    Node tmp,now;
+    tmp.key = 0;
+    tmp.num = 0;
+    tmp.x = sx;
+    tmp.y = sy;
+    q.push(tmp);
+    memset(used,false,sizeof(used));
+    memset(used2,false,sizeof(used2));
+    used[sx][sy][0] = true;
+    while(!q.empty())
+    {
+        tmp = q.front();
+        q.pop();
+        for(int i = 0;i < 4;i++)
+        {
+            int mx = mo[i][0];
+            int my = mo[i][1];
+            int x = tmp.x;
+            int y = tmp.y;
+            int ss = tmp.key;
+            while(1)
+            {
+                if(g[x][y] =='L')
+                {
+                    mx = 0; my = -1;
+                }
+                if(g[x][y] == 'U')
+                {
+                    mx = -1;my = 0;
+                }
+                if(g[x][y] == 'D')
+                {
+                    mx = 1;my = 0;
+                }
+                if(g[x][y] == 'R')
+                {
+                    mx = 0; my = 1;
+                }
+                int dir;
+                if(mx==-1&&my==0)dir=0;
+                else if(mx==1&&my==0)dir=1;
+                else if(mx==0&&my==1)dir=2;
+                else if(mx==0&&my==-1)dir=3;
+                if(used2[x][y][ss][dir])break;
+                used2[x][y][ss][dir] = true;
+                x += mx;
+                y += my;
+                if(x < 0 || y < 0 || x >= n || y >= m)break;
+                if(g[x][y] =='#')break;
+                if( x == ex && y== ey && ss ==((1<<keynum)-1) )
+                    return tmp.num+1;
+                if(g[x][y] =='L')
+                {
+                    mx = 0; my = -1;
+                }
+                if(g[x][y] == 'U')
+                {
+                    mx = -1;my = 0;
+                }
+                if(g[x][y] == 'D')
+                {
+                    mx = 1;my = 0;
+                }
+                if(g[x][y] == 'R')
+                {
+                    mx = 0; my = 1;
+                }
+                if(g[x][y] == 'K')
+                    ss |= key_s[x][y];
+                if(x+mx >=0 && x+mx < n && y+my>=0 && y+my < m && g[x+mx][y+my]=='#')
+                {
+                    if(used[x][y][ss])break;
+                    now.x = x;now.y = y;
+                    now.key = ss;
+                    now.num = tmp.num + 1;
+                    q.push(now);
+                    used[x][y][ss] = true;
+                    break;
+                }
+            }
+        }
+    }
+    return -1;
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m)==2)
+    {
+        keynum = 0;
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%s",g[i]);
+            for(int j = 0;j < m;j++)
+            {
+                if(g[i][j] == 'S')
+                {
+                    sx = i;sy = j;
+                }
+                if(g[i][j] == 'E')
+                {
+                    ex = i;ey = j;
+                }
+                if(g[i][j] == 'K')
+                {
+                    key_s[i][j] = (1<<keynum);
+                    keynum++;
+                }
+            }
+        }
+        printf("%d\n",bfs());
+    }
+    return 0;
+}
diff --git a/HDOJ/4635_autoAC.cpp b/HDOJ/4635_autoAC.cpp
new file mode 100644
index 0000000..43d4422
--- /dev/null
+++ b/HDOJ/4635_autoAC.cpp
@@ -0,0 +1,93 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int VM=200010;
+const int EM=200010;
+const int INF=0x3f3f3f3f;
+struct Edge{
+    int to,nxt;
+}edge[EM<<1];
+long long n,m,cnt,head[VM];
+long long dep,top,atype;
+long long dfn[VM],low[VM],vis[VM],stack[VM],belong[VM],indeg[VM],outdeg[VM],sum[VM];
+void addedge(int cu,int cv){
+    edge[cnt].to=cv;    edge[cnt].nxt=head[cu];     head[cu]=cnt++;
+}
+void Tarjan(int u){
+    dfn[u]=low[u]=++dep;
+    stack[top++]=u;
+    vis[u]=1;
+    for(int i=head[u];i!=-1;i=edge[i].nxt){
+        int v=edge[i].to;
+        if(!dfn[v]){
+            Tarjan(v);
+            low[u]=min(low[u],low[v]);
+        }else if(vis[v]){
+            low[u]=min(low[u],dfn[v]);
+        }
+    }
+    int j;
+    if(dfn[u]==low[u]){
+        atype++;
+        do{
+            j=stack[--top];
+            belong[j]=atype;
+            sum[atype]++;   
+            vis[j]=0;
+        }while(u!=j);
+    }
+}
+void init(){
+    cnt=0;
+    memset(head,-1,sizeof(head));
+    dep=0,  top=0,  atype=0;
+    memset(dfn,0,sizeof(dfn));
+    memset(low,0,sizeof(low));
+    memset(vis,0,sizeof(vis));
+    memset(belong,0,sizeof(belong));
+    memset(indeg,0,sizeof(indeg));
+    memset(outdeg,0,sizeof(outdeg));
+    memset(sum,0,sizeof(sum));
+}
+int main(){
+    int t,cases=0;
+    scanf("%d",&t);
+    while(t--){
+        cin>>n>>m;
+        if(n==1){
+            printf("Case %d: -1\n",++cases);
+            continue;
+        }
+        init();
+        int u,v;
+        for(int i=0;i<m;i++){
+            scanf("%d%d",&u,&v);
+            addedge(u,v);
+        }
+        for(int i=1;i<=n;i++)
+            if(!dfn[i])
+                Tarjan(i);
+        if(atype==1){
+            printf("Case %d: -1\n",++cases);
+            continue;
+        }
+        for(int u=1;u<=n;u++)
+            for(int i=head[u];i!=-1;i=edge[i].nxt){
+                int v=edge[i].to;
+                if(belong[u]!=belong[v]){
+                    outdeg[belong[u]]++;
+                    indeg[belong[v]]++;
+                }
+            }
+        long long ans=0,tmp;
+        for(long long i=1;i<=atype;i++)
+            if(indeg[i]==0 || outdeg[i]==0){   
+                tmp=sum[i];
+                ans=max(ans,tmp*(tmp-1)+(n-tmp)*(n-tmp-1)+tmp*(n-tmp)-m);
+            }
+        cout<<"Case "<<(++cases)<<": "<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4636_autoAC.cpp b/HDOJ/4636_autoAC.cpp
new file mode 100644
index 0000000..487232d
--- /dev/null
+++ b/HDOJ/4636_autoAC.cpp
@@ -0,0 +1,98 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+#include <cmath>
+#include <queue>
+#include <vector>
+#define MID(x,y) ((x+y)>>1)
+#define iabs(x) ((x)>0?(x):-(x))
+using namespace std;
+vector <int>v[40];
+inline void v_pb(int a,int b){
+    v[a].push_back(b);
+}
+int num[40];
+queue<int>q;
+bool vis[40];
+bool bfs(int s,int flag){
+    while(!q.empty()) q.pop();
+    q.push(s);
+    int cnt = -1;
+    while(!q.empty()){
+        int k = q.front(); q.pop();
+        cnt++;
+        for (int i = 0; i < v[k].size(); i++){
+            int d = v[k][i];
+            if (!vis[d] && num[d] == flag){
+                vis[d] = 1;
+                q.push(d);
+            }
+        }
+    }
+    if(flag == 0 && cnt == 0)return 1;
+    return 0;
+}
+int main(){
+    v_pb(1,2);v_pb(1,3);v_pb(1,17);v_pb(1,18);v_pb(1,20);v_pb(1,13);
+    v_pb(2,1);v_pb(2,3);v_pb(2,4);v_pb(2,7);v_pb(2,12);v_pb(2,13);
+    v_pb(3,1);v_pb(3,2);v_pb(3,4);v_pb(3,5);v_pb(3,20);
+    v_pb(4,2);v_pb(4,3);v_pb(4,5);v_pb(4,6);v_pb(4,7);v_pb(4,8);
+    v_pb(5,3);v_pb(5,4);v_pb(5,6);v_pb(5,20);v_pb(5,21);v_pb(5,24);
+    v_pb(6,4);v_pb(6,5);v_pb(6,8);v_pb(6,9);v_pb(6,24);
+    v_pb(7,2);v_pb(7,4);v_pb(7,8);v_pb(7,10);v_pb(7,12);
+    v_pb(8,4);v_pb(8,6);v_pb(8,7);v_pb(8,9);v_pb(8,10);v_pb(8,11);
+    v_pb(9,6);v_pb(9,8);v_pb(9,11);v_pb(9,24);v_pb(9,26);v_pb(9,27);
+    v_pb(10,7);v_pb(10,8);v_pb(10,11);v_pb(10,12);v_pb(10,14);v_pb(10,16);
+    v_pb(11,8);v_pb(11,9);v_pb(11,10);v_pb(11,16);v_pb(11,27);
+    v_pb(12,2);v_pb(12,7);v_pb(12,10);v_pb(12,13);v_pb(12,14);v_pb(12,15);
+    v_pb(13,12);v_pb(13,15);v_pb(13,2);v_pb(13,1);v_pb(13,17);
+    v_pb(14,10);v_pb(14,12);v_pb(14,15);v_pb(14,16);v_pb(14,30);
+    v_pb(15,12);v_pb(15,13);v_pb(15,14);v_pb(15,30);v_pb(15,32);v_pb(15,17);
+    v_pb(16,10);v_pb(16,11);v_pb(16,14);v_pb(16,27);v_pb(16,29);v_pb(16,30);
+    v_pb(17,1);v_pb(17,18);v_pb(17,19);v_pb(17,13);v_pb(17,15);v_pb(17,32);
+    v_pb(18,1);v_pb(18,17);v_pb(18,19);v_pb(18,20);v_pb(18,22);
+    v_pb(19,17);v_pb(19,18);v_pb(19,31);v_pb(19,22);v_pb(19,23);v_pb(19,32);
+    v_pb(20,1);v_pb(20,3);v_pb(20,5);v_pb(20,18);v_pb(20,21);v_pb(20,22);
+    v_pb(21,5);v_pb(21,20);v_pb(21,22);v_pb(21,24);v_pb(21,25);
+    v_pb(22,19);v_pb(22,18);v_pb(22,20);v_pb(22,21);v_pb(22,23);v_pb(22,25);
+    v_pb(23,19);v_pb(23,22);v_pb(23,25);v_pb(23,28);v_pb(23,31);
+    v_pb(24,5);v_pb(24,6);v_pb(24,9);v_pb(24,21);v_pb(24,25);v_pb(24,26);
+    v_pb(25,21);v_pb(25,22);v_pb(25,23);v_pb(25,24);v_pb(25,26);v_pb(25,28);
+    v_pb(26,9);v_pb(26,24);v_pb(26,25);v_pb(26,27);v_pb(26,28);
+    v_pb(27,9);v_pb(27,11);v_pb(27,16);v_pb(27,26);v_pb(27,28);v_pb(27,29);
+    v_pb(28,25);v_pb(28,26);v_pb(28,27);v_pb(28,29);v_pb(28,31);v_pb(28,23);
+    v_pb(29,16);v_pb(29,27);v_pb(29,28);v_pb(29,30);v_pb(29,31);
+    v_pb(30,14);v_pb(30,15);v_pb(30,16);v_pb(30,29);v_pb(30,31);v_pb(30,32);
+    v_pb(31,28);v_pb(31,29);v_pb(31,30);v_pb(31,32);v_pb(31,23);v_pb(31,19);
+    v_pb(32,30);v_pb(32,31);v_pb(32,15);v_pb(32,19);v_pb(32,17);
+    int t;
+    scanf("%d", &t);
+    for (int cas = 1; cas <= t; cas++){
+        printf("Case %d: ", cas);
+        int black = 0,white = 0;
+        for (int i = 1; i <= 32; ++i){
+            scanf("%d", &num[i]);
+            if(num[i]) black ++;
+        }
+        if (black == 0) {puts("0");continue;}
+        memset(vis,0,sizeof(vis));
+        black = 0;
+        for (int i = 1; i <= 32; ++i){
+            if (!vis[i]){
+                vis[i] = 1;
+                if (num[i]){
+                    black ++;
+                    bfs(i,1);
+                }else {
+                    white ++;
+                    if(bfs(i,0)) white --;
+                }
+            }
+        }
+        if(black <= 2) printf("%d\n", black);
+        else if (white == 1) puts("2");
+        else puts("3");
+    }
+    return 0;
+}
diff --git a/HDOJ/4637_autoAC.cpp b/HDOJ/4637_autoAC.cpp
new file mode 100644
index 0000000..22d0d87
--- /dev/null
+++ b/HDOJ/4637_autoAC.cpp
@@ -0,0 +1,317 @@
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <set>
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+const double eps=1e-10;
+const int INF=1<<29;
+const double PI=acos(-1.0);
+int doublecmp(double x){
+    if(fabs(x)<eps)return 0;else return x<0?-1:1;
+}
+struct Point{
+    double x,y;
+    Point(double x=0,double y=0):x(x),y(y){}
+};
+typedef Point Vector;
+Vector operator+(Vector a,Vector b){return Vector(a.x+b.x,a.y+b.y);}
+Vector operator-(Point a,Point b){return Vector(a.x-b.x,a.y-b.y);}
+Vector operator*(Vector a,double p){return Vector(a.x*p,a.y*p);}
+Vector operator/(Vector a,double p){return Vector(a.x/p,a.y/p);}
+bool operator<(const Point&a,const Point&b){return a.x<b.x||(a.x==b.x&&a.y<b.y);}
+bool operator==(const Point&a,const Point&b){
+    return doublecmp(a.x-b.x)==0&&doublecmp(a.y-b.y)==0;
+}
+bool operator!=(const Point&a,const Point&b){return a==b?false:true;}
+struct Segment{
+    Point a,b;
+    Segment(){}
+    Segment(Point _a,Point _b){a=_a,b=_b;}
+    bool friend operator<(const Segment& p,const Segment& q){return p.a<q.a||(p.a==q.a&&p.b<q.b);}
+    bool friend operator==(const Segment& p,const Segment& q){return (p.a==q.a&&p.b==q.b)||(p.a==q.b&&p.b==q.a);}
+};
+struct Circle{
+    Point c;
+    double r;
+    Circle(){}
+    Circle(Point _c, double _r):c(_c),r(_r) {}
+    Point point(double a)const{return Point(c.x+cos(a)*r,c.y+sin(a)*r);}
+    bool friend operator<(const Circle& a,const Circle& b){return a.r<b.r;}
+};
+struct Line{
+    Point p;
+    Vector v;
+    double ang;
+    Line() {}
+    Line(const Point &_p, const Vector &_v):p(_p),v(_v){ang = atan2(v.y, v.x);}
+    bool operator<(const Line &L)const{return  ang < L.ang;}
+};
+double Dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
+double Length(Vector a){return sqrt(Dot(a,a));}
+double Angle(Vector a,Vector b){return acos(Dot(a,b)/Length(a)/Length(b));}
+double Cross(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
+double Area2(Point a,Point b,Point c){return Cross(b-a,c-a);}
+double DegreeToRadius(double deg){return deg/180*PI;}
+double GetRerotateAngle(Vector a,Vector b){
+    double tempa=Angle(a,Vector(1,0));
+    if(a.y<0) tempa=2*PI-tempa;
+    double tempb=Angle(b,Vector(1,0));
+    if(b.y<0) tempb=2*PI-tempb;
+    if((tempa-tempb)>0) return tempa-tempb;
+    else return tempa-tempb+2*PI;
+}
+Vector Rotate(Vector a,double rad){
+    return Vector(a.x*cos(rad)-a.y*sin(rad),a.x*sin(rad)+a.y*cos(rad));
+}
+Vector Normal(Vector a){
+    double L=Length(a);
+    return Vector(-a.y/L,a.x/L);
+}
+Point GetLineProjection(Point p,Point a,Point b){
+    Vector v=b-a;
+    return a+v*(Dot(v,p-a)/Dot(v,v));
+}
+Point GetLineIntersection(Point p,Vector v,Point q,Vector w){
+    Vector u=p-q;
+    double t=Cross(w,u)/Cross(v,w);
+    return p+v*t;
+}
+int ConvexHull(Point* p,int n,Point* ch){
+    sort(p,p+n);
+    int m=0;
+    for(int i=0;i<n;i++){
+        while(m>1&&Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2])<=0) m--;
+        ch[m++]=p[i];
+    }
+    int k=m;
+    for(int i=n-2;i>=0;i--){
+        while(m>k&&Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2])<=0) m--;
+        ch[m++]=p[i];
+    }
+    if(n>0) m--;
+    return m;
+}
+double Heron(double a,double b,double c){
+    double p=(a+b+c)/2;
+    return sqrt(p*(p-a)*(p-b)*(p-c));
+}
+bool SegmentProperIntersection(Point a1,Point a2,Point b1,Point b2){
+    double c1=Cross(a2-a1,b1-a1),c2=Cross(a2-a1,b2-a1);
+    double c3=Cross(b2-b1,a1-b1),c4=Cross(b2-b1,a2-b1);
+    return doublecmp(c1)*doublecmp(c2)<0&&doublecmp(c3)*doublecmp(c4)<0;
+}
+double CutConvex(const int n,Point* poly, const Point a,const Point b, vector<Point> result[3]){
+    vector<Point> points;
+    Point p;
+    Point p1=a,p2=b;
+    int cur,pre; 
+    result[0].clear(); 
+    result[1].clear(); 
+    result[2].clear();
+    if(n==0) return 0;
+    double tempcross;
+    tempcross=Cross(p2-p1,poly[0]-p1);
+    if(doublecmp(tempcross)==0) pre=cur=2;
+    else if(tempcross>0) pre=cur=0;
+    else pre=cur=1;
+    for(int i=0;i<n;i++){
+        tempcross=Cross(p2-p1,poly[(i+1)%n]-p1);
+        if(doublecmp(tempcross)==0) cur=2;
+        else if(tempcross>0) cur=0;
+        else cur=1;
+        if(cur==pre){
+            result[cur].push_back(poly[(i+1)%n]); 
+        }
+        else{
+            p1=poly[i]; 
+            p2=poly[(i+1)%n];
+            p=GetLineIntersection(p1,p2-p1,a,b-a);
+            points.push_back(p); 
+            result[pre].push_back(p); 
+            result[cur].push_back(p); 
+            result[cur].push_back(poly[(i+1)%n]); 
+            pre=cur;
+        }
+    }
+    sort(points.begin(),points.end());
+    if(points.size()<2){
+        return 0; 
+    }
+    else{
+        return Length(points.front()-points.back());
+    }
+}
+double DistanceToSegment(Point p,Segment s){
+    if(s.a==s.b) return Length(p-s.a);
+    Vector v1=s.b-s.a,v2=p-s.a,v3=p-s.b;
+    if(doublecmp(Dot(v1,v2))<0) return Length(v2);
+    else if(doublecmp(Dot(v1,v3))>0) return Length(v3);
+    else return fabs(Cross(v1,v2))/Length(v1);
+}
+bool isPointOnSegment(Point p,Segment s){
+    return doublecmp(DistanceToSegment(p,s))==0;
+}
+int isPointInPolygon(Point p, Point* poly,int n){
+    int wn=0;
+    for(int i=0;i<n;i++){
+        Point& p2=poly[(i+1)%n];
+        if(isPointOnSegment(p,Segment(poly[i],p2))) return -1;
+        int k=doublecmp(Cross(p2-poly[i],p-poly[i]));
+        int d1=doublecmp(poly[i].y-p.y);
+        int d2=doublecmp(p2.y-p.y);
+        if(k>0&&d1<=0&&d2>0)wn++;
+        if(k<0&&d2<=0&&d1>0)wn--;
+    }
+    if(wn) return 1;
+    else return 0;
+}
+double PolygonArea(vector<Point> p){
+    double area=0;
+    int n=p.size();
+    for(int i=1;i<n-1;i++)
+        area+=Cross(p[i]-p[0],p[i+1]-p[0]);
+    return area/2;
+}
+int PSLGtoPolygons(Segment arr[],int n,vector<Point>* Polygons){
+    int count=n-1;
+    bool vis[9999];memset(vis,0,sizeof vis);
+    Point star=arr[0].a,pre=arr[0].a,cur=arr[0].b,purpose=arr[0].b;vis[0]=true;
+    int mark;
+    while(purpose!=star){
+        double theta=-INF;
+        for(int i=0;i<n;i++)if(!vis[i]&&arr[i].a==cur&&arr[i].b!=pre){
+            if(theta<GetRerotateAngle(pre-cur,arr[i].b-cur)){
+                theta=GetRerotateAngle(pre-cur,arr[i].b-cur);
+                purpose=arr[i].b;
+                mark=i;
+            }
+        }
+        vis[mark]=true;count--;
+        pre=cur;cur=purpose;
+    }
+    int polyidx=0;
+    while(count>0){
+        for(int i=0;i<n;i++)if(!vis[i]){
+            star=arr[i].a,pre=arr[i].a,cur=arr[i].b,purpose=arr[i].b;vis[i]=true;count--;
+            Polygons[polyidx].clear();
+            Polygons[polyidx].push_back(cur);
+            break;
+        }
+        while(purpose!=star){
+            double theta=-INF;
+            for(int i=0;i<n;i++)if(!vis[i]&&arr[i].a==cur&&arr[i].b!=pre){
+                if(theta<GetRerotateAngle(pre-cur,arr[i].b-cur)){
+                    theta=GetRerotateAngle(pre-cur,arr[i].b-cur);
+                    purpose=arr[i].b;
+                    mark=i;
+                }
+            }
+            vis[mark]=true;count--;
+            Polygons[polyidx].push_back(purpose);
+            pre=cur;cur=purpose;
+        }
+        polyidx++;
+    }
+    return polyidx;
+}
+int GetLineCircleIntersection(Line L,Circle C,Point& p1,Point& p2){
+    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y-C.c.y;
+    double e = a*a + c*c, f = 2*(a*b+c*d), g = b*b + d*d -C.r*C.r;
+    double delta = f*f - 4*e*g;
+    if(doublecmp(delta) < 0)  return 0;
+    if(doublecmp(delta) == 0) {
+        p1=p1=C.point(-f/(2*e));
+        return 1;
+    }
+    p1=(L.p+L.v*(-f-sqrt(delta))/(2*e));
+    p2=(L.p+L.v*(-f+sqrt(delta))/(2*e));
+    return 2;
+}
+struct Allpoint{
+    Point p;
+    int pos;
+    bool friend operator<(Allpoint a,Allpoint b){
+        if(a.pos==-1&&a.pos==b.pos) return a.p<b.p;
+        else if(a.pos==-1) return true;
+        else if(b.pos==-1) return false;
+        else return a.p<b.p;
+    }
+}allpoint[8000];
+int idx=0;
+int lpint(Line l, Point a, Point b, Point c, Allpoint *sol) {
+    int ret = 0;
+    if (doublecmp(Cross(l.v, a - b)) != 0) {
+        sol[ret].p = GetLineIntersection(l.p,l.v, a, b-a);
+        if (isPointOnSegment(sol[ret].p, Segment(a, b))) ret++;
+    }
+    if (doublecmp(Cross(l.v, c - b)) != 0) {
+        sol[ret].p = GetLineIntersection(l.p,l.v,c, b-c);
+        if (isPointOnSegment(sol[ret].p, Segment(c, b))) ret++;
+    }
+    if (doublecmp(Cross(l.v, a - c)) != 0) {
+        sol[ret].p = GetLineIntersection(l.p,l.v, a, c-a);
+        if (isPointOnSegment(sol[ret].p, Segment(a, c))) ret++;
+    }
+    if (ret < 2) return 0;
+    sort(sol, sol + ret);
+    if (ret == 3) {
+        if (sol[0].p == sol[1].p) sol[1].p = sol[2].p;
+    }
+    if (sol[0].p == sol[1].p) return 0;
+    return 2;
+}
+int main()
+{
+    int T,cas=1;
+    scanf("%d",&T);
+    while(T--){
+        double v1,v2,v,t,x;
+        int n;
+        idx=0;
+        scanf("%lf%lf%lf%lf%lf",&v1,&v2,&v,&t,&x);
+        scanf("%d",&n);
+        double time = v2 * t / (v2 - v1);
+        Line l = Line(Point(x, 0), Point(x - v1 * time, v * time)-Point(x,0));
+        for(int i=0;i<n;i++){
+            Point O;
+            double r,h;
+            Allpoint ip[4];
+            scanf("%lf%lf%lf%lf", &O.x, &O.y, &r, &h);
+            int ipp = lpint(l, Point(O.x + r, O.y), Point(O.x - r, O.y), Point(O.x, O.y + h), ip);
+            if (ipp) {
+                if (ip[1] < ip[0]) swap(ip[0], ip[1]);
+                for (int i = 0; i < 2; i++) ip[i].pos= i & 1, allpoint[idx++] = ip[i];
+            }
+            int ipc = GetLineCircleIntersection(l,Circle(O, r), ip[0].p,ip[1].p);
+            if (ipc==2) {
+                if (ip[1] < ip[0]) swap(ip[0], ip[1]);
+                if (doublecmp(ip[1].p.y - O.y) >= 0) continue;
+                if (doublecmp(ip[0].p.y - O.y) > 0) ip[0].p = GetLineIntersection(l.p,l.v, O, Point(1.0, 0));
+                for (int i = 0; i < 2; i++) ip[i].pos = i & 1, allpoint[idx++] = ip[i];
+            }
+        }
+        sort(allpoint, allpoint + idx);
+        int cnt = 0;
+        double sum = 0, lp = x - v1 * time, rp = x, ls = lp;
+        for (int i = 0; i < idx; i++) {
+            if (allpoint[i].p.x > rp) break;
+            if (allpoint[i].p.x < lp) {
+                if (allpoint[i].pos) cnt--; 
+                else cnt++;
+            } else {
+                if (allpoint[i].pos) {
+                    if (cnt == 1) sum += allpoint[i].p.x - ls;
+                    cnt--;
+                } else {
+                    if (cnt == 0) ls = allpoint[i].p.x;
+                    cnt++;
+                }
+            }
+        }
+        if (cnt > 0) sum += rp - ls;
+        printf("Case %d: %.4f\n", cas++, sum / v1);
+    }
+}
diff --git a/HDOJ/4638_autoAC.cpp b/HDOJ/4638_autoAC.cpp
new file mode 100644
index 0000000..0132df1
--- /dev/null
+++ b/HDOJ/4638_autoAC.cpp
@@ -0,0 +1,101 @@
+#include<iostream>
+#include<string>
+#include<algorithm>
+#include<cstdlib>
+#include<cstdio>
+#include<set>
+#include<map>
+#include<vector>
+#include<cstring>
+#include<stack>
+#include<cmath>
+#include<queue>
+using namespace std;
+#define CL(x,v); memset(x,v,sizeof(x));
+#define INF 0x3f3f3f3f
+#define LL long long
+#define REP(i,r,n) for(int i=r;i<=n;i++)
+#define RREP(i,n,r) for(int i=n;i>=r;i--)
+const int MAXN=1e5+100;
+int tree[MAXN];
+int n;
+int lowbit(int x)
+ {
+     return x&(-x);
+ }
+ void add(int pos,int val)
+ {
+     while(pos <=n)
+     {
+         tree[pos] += val;
+         pos += lowbit(pos);
+     }
+ }
+ int read(int x)
+ {
+     int s=0;
+     while(x>0)
+     {
+         s += tree[x];
+         x -= lowbit(x);
+     }
+     return s;
+ }
+int A[MAXN],pos[MAXN];
+struct node{
+    int l,r,index;
+    bool operator <(const node& rsh)const{
+        if(r==rsh.r)
+            return l<rsh.l;
+        else return r<rsh.r;
+    }
+};
+vector<node> Q;
+int ans[MAXN];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        int m;
+        scanf("%d%d",&n,&m);
+        REP(i,1,n){
+            scanf("%d",&A[i]);
+            pos[A[i]]=i;
+        }
+        Q.clear();
+        node tmp;
+        REP(i,1,m)
+        {
+            scanf("%d%d",&tmp.l,&tmp.r);
+            tmp.index=i;
+            Q.push_back(tmp);
+        }
+        sort(Q.begin(),Q.end());
+        CL(tree,0);
+        int j=0;
+        for(int i=1;i<=n;i++)
+        {
+            add(i,1);
+            if(A[i]+1<=n&&pos[A[i]+1]<i)
+            {
+                add(pos[A[i]+1],-1);
+            }
+            if(A[i]-1>=1&&pos[A[i]-1]<i)
+            {
+                add(pos[A[i]-1],-1);
+            }
+            while(Q[j].r==i)
+            {
+                ans[Q[j].index]=read(Q[j].r)-read(Q[j].l-1);
+                j++;
+            }
+        }
+        REP(i,1,m)
+        {
+            printf("%d\n",ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4639_autoAC.cpp b/HDOJ/4639_autoAC.cpp
new file mode 100644
index 0000000..7594a26
--- /dev/null
+++ b/HDOJ/4639_autoAC.cpp
@@ -0,0 +1,37 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <cmath>
+#include <vector>
+using namespace std;
+const int V = 5050 + 50;
+const int MaxN = 500 + 5;
+const int mod = 10000 + 7;
+int T, ans, num[V];
+char ch[10100];
+int main() {
+    int i, j, k;
+    scanf("%d", &T);
+    num[0] = num[1] = 1;
+    for(i = 2; i <= V; ++i)
+        num[i] = (num[i - 1] + num[i - 2]) % mod;
+    for(i = 1; i <= T; ++i) {
+        ans = 1;
+        int sum = 0;
+        scanf("%s", &ch);
+        int len = strlen(ch);
+        for(j = 1; j < len; ++j) {
+            if(ch[j] == 'e' && ch[j - 1] == 'h') {
+                sum++;
+                j++;
+            }
+            else {
+                ans = (ans * num[sum]) % mod;
+                sum = 0;
+            }
+        }
+        ans = (ans * num[sum]) % mod;
+        printf("Case %d: %d\n", i, ans);
+    }
+}
diff --git a/HDOJ/4640_autoAC.cpp b/HDOJ/4640_autoAC.cpp
new file mode 100644
index 0000000..9e8ccbb
--- /dev/null
+++ b/HDOJ/4640_autoAC.cpp
@@ -0,0 +1,91 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+#define INF 2000000000
+int q[4*(1<<17)][2];
+int maxQ=4*(1<<17)-3;
+int front,rear,n,m;
+int mat[20][20];
+int dp[1<<17],f[1<<17],dist[1<<17][18],vis[1<<17][18];
+int main ()
+{
+    int T;scanf("%d",&T);
+    for(int kk=1;kk<=T;++kk)
+    {
+        scanf("%d%d",&n,&m);
+        memset(dist,127,sizeof(dist));
+        memset(dp,127,sizeof(dp));
+        memset(vis,0,sizeof(vis));
+        memset(mat,127,sizeof(mat));
+        front=rear=0;
+        int u,v,s;
+        for(int i=1;i<=m;++i)
+        {
+            scanf("%d%d%d",&u,&v,&s);
+            u--;v--;
+            if(mat[u][v]>s)
+                mat[u][v]=mat[v][u]=s;
+        }
+        dist[0][0]=0;
+        q[++rear][0]=0;q[rear][1]=0;
+        vis[0][0]=1;
+        while(front!=rear)
+        {
+            if(++front==maxQ) front=0;
+            int u_sta=q[front][0],u=q[front][1];
+            vis[u_sta][u]=0;
+            for(int i=0;i<n;++i)
+            {
+                int v_sta=u_sta|(1<<i);
+                if(dist[v_sta][i]>dist[u_sta][u]+mat[u][i])
+                {
+                    dist[v_sta][i]=dist[u_sta][u]+mat[u][i];
+                    if(!vis[v_sta][i])
+                    {
+                        if(++rear==maxQ) rear=0;
+                        vis[v_sta][i]=1;
+                        q[rear][0]=v_sta;q[rear][1]=i;
+                    }
+                }
+            }
+        }
+        for(int i=0;i<(1<<n);++i)
+            for(int j=0;j<n;++j)
+            dp[i>>1]=min(dp[i>>1],dist[i][j]);
+        int tot_sta=1<<n-1;
+        for(int i=0;i<tot_sta;++i)
+            f[i]=dp[i];
+        for(int k=1;k<=2;++k)
+        {
+            for(int i=tot_sta-1;i;--i)
+                for(u=i;u;u=(--u)&i)
+            {
+                v=i^u;
+                if(dp[i]>max(dp[u],f[v]))
+                {
+                    if(i==224 && max(dp[u],f[v])==5)
+                        cout<<"dd";
+                    dp[i]=max(dp[u],f[v]);
+                }
+            }
+        }
+        int query;scanf("%d",&query);
+        int sta=0;
+        while(query--)
+        {
+            scanf("%d",&u);
+            sta|=1<<u-2;
+        }
+        int ans=INF;
+        for(int i=0;i<tot_sta;++i)
+            if((i&sta)==sta)
+        {
+            ans=min(ans,dp[i]);
+        }
+        if(ans>=INF)
+            printf("Case %d: -1\n",kk);
+        else printf("Case %d: %d\n",kk,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4641_autoAC.cpp b/HDOJ/4641_autoAC.cpp
new file mode 100644
index 0000000..ae4cdac
--- /dev/null
+++ b/HDOJ/4641_autoAC.cpp
@@ -0,0 +1,131 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define Maxn 250009
+int root,last;
+int tots;
+int l;
+int sv[Maxn*2];
+struct query{int a;long long ans;}qu[Maxn];
+struct sam_node{
+    int fa,son[26];
+    int len;
+    void init(int _len){len=_len;fa=-1;memset(son,-1,sizeof(son));}
+}t[Maxn*2];
+void sam_init(){
+    tots=0;
+    root=last=0;
+    t[tots].init(0);
+}
+void extend(int w){
+    int p=last;
+    int np=++tots;t[tots].init(t[p].len+1);
+    sv[l]=np;
+    int q,nq;
+    while(p!=-1&&t[p].son[w]==-1){t[p].son[w]=np;p=t[p].fa;}
+    if (p==-1) t[np].fa=root;
+    else{
+        q=t[p].son[w];
+        if (t[p].len+1==t[q].len){t[np].fa=q;}
+        else{
+            nq=++tots;t[nq].init(0);
+            t[nq]=t[q];
+            t[nq].len=t[p].len+1;
+            t[q].fa=nq;t[np].fa=nq;
+            while(p!=-1&&t[p].son[w]==q){t[p].son[w]=nq;p=t[p].fa;}
+        }
+    }
+    last=np;
+}
+int w[Maxn],r[Maxn*2];
+void topsort(){
+    int i;
+    for(i=0;i<=l;++i)   w[i]=0;
+    for(i=1;i<=tots;++i)w[t[i].len]++;
+    for(i=1;i<=l;++i)   w[i]+=w[i-1];
+    for(i=tots;i>=1;--i)r[w[t[i].len]--]=i;
+    r[0]=0;
+}
+int dp[Maxn*2];
+int sub[Maxn*2];
+char s[Maxn];
+int set[Maxn*2];
+int findset(int x){
+    int y;
+    while(x!=set[x]){
+        y=set[x];
+        set[x]=set[y];
+        x=y;
+    }
+    return x;
+}
+int main(){
+    int n,m,k,f,y,p,i,a;
+    long long ans;
+    while(scanf("%d%d%d",&n,&m,&k)!=EOF){
+        scanf("%s",s);
+        int tl=strlen(s);
+        l=0;
+        sam_init();
+        for(i=0;i<tl;++i){
+            ++l;
+            extend(s[i]-'a');
+        }
+        char ts[20];
+        for(i=1;i<=m;++i){
+            scanf("%d",&a);
+            if (a==1){
+                scanf("%s",ts);
+                s[l++]=ts[0];
+                qu[i].a=a;
+                extend(ts[0]-'a');
+            }
+            else if (a==2) qu[i].a=a;
+        }
+        for(i=0;i<=tots;++i){dp[i]=0;}
+        topsort();
+        p=root;
+        for(i=0;i<l;++i){
+            p=t[p].son[s[i]-'a'];
+            dp[p]++;
+        }
+        for(i=tots;i>=1;--i){
+            p=r[i];
+            if (t[p].fa!=-1) dp[t[p].fa]+=dp[p];
+        }
+        ans=0;
+        for(i=1;i<=tots;++i)
+            if (dp[i]>=k) ans+=t[i].len-t[t[i].fa].len;
+        for(i=0;i<=tots;++i){set[i]=i;sub[i]=0;}
+        for(i=m;i>=1;--i){
+            if (qu[i].a==2) qu[i].ans=ans;
+            else{
+                p=sv[l];
+                l--;
+                y=findset(p);
+                while(y!=0&&dp[y]<k){          
+                    f=t[y].fa;
+                    set[y]=f=findset(f);
+                    y=f;
+                }
+                y=findset(p);
+                if (y==root) {continue;}
+                sub[y]++;
+                while(y!=0&&(dp[y]-sub[y]<k)){   
+                    ans=ans-t[y].len+t[t[y].fa].len;
+                    f=t[y].fa;
+                    f=findset(f);
+                    sub[f]+=sub[y];
+                    set[y]=f;
+                    y=f;
+                }
+            }
+        }
+        for(i=1;i<=m;++i)if (qu[i].a==2){
+            printf("%I64d\n",qu[i].ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4642_autoAC.cpp b/HDOJ/4642_autoAC.cpp
new file mode 100644
index 0000000..9b59166
--- /dev/null
+++ b/HDOJ/4642_autoAC.cpp
@@ -0,0 +1,22 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+int n,m;
+int main(){
+    int t;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&m);
+        int x;
+        for(int i=0;i<n;i++)
+            for(int j=0;j<m;j++)
+                scanf("%d",&x);
+        if(x)
+            puts("Alice");
+        else
+            puts("Bob");
+    }
+    return 0;
+}
diff --git a/HDOJ/4643_autoAC.cpp b/HDOJ/4643_autoAC.cpp
new file mode 100644
index 0000000..78124f8
--- /dev/null
+++ b/HDOJ/4643_autoAC.cpp
@@ -0,0 +1,190 @@
+#include<stdio.h>
+#include<algorithm>
+#include<math.h>
+using namespace std;
+const double eps=1e-11;
+struct point
+{
+    double x,y;
+}city[55],base[55];
+int N,M,K,a,b;
+struct node
+{
+    int i,j;
+    point p;
+    double dist;
+}jiao[3000];
+inline bool mo_ee(double x,double y)
+{
+    double ret=x-y;
+    if(ret<0) ret=-ret;
+    if(ret<eps) return 1;
+    return 0;
+}
+inline bool mo_gg(double x,double y)  {   return x > y + eps;} // x > y   
+inline bool mo_ll(double x,double y)  {   return x < y - eps;} // x < y   
+inline bool mo_ge(double x,double y) {   return x > y - eps;} // x >= y   
+inline bool mo_le(double x,double y) {   return x < y + eps;}     // x <= y   
+inline double min(double a,double b)
+{
+    if(a<b) return a;
+    return b;
+}
+inline double max(double a,double b)
+{
+    if(a>b) return a;
+    return b;
+}
+point getxiang(point xiang)
+{
+    point a;
+    if(mo_ee(xiang.x,0))
+    {
+        a.x=1;
+        a.y=0;
+        return a;
+    }else if(mo_ee(xiang.y,0))
+    {
+        a.x=0;
+        a.y=1;
+        return a;
+    }else
+    {
+        a.x=1;
+        a.y=-1.0*xiang.x/xiang.y;
+        return a;
+    }
+}
+inline double mo_distance(point p1,point p2)
+{
+    return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
+}
+point mo_intersection(point u1,point u2,point v1,point v2)
+{
+    point ret=u1;
+    double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x))
+             /((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x));
+    ret.x+=(u2.x-u1.x)*t;
+    ret.y+=(u2.y-u1.y)*t;
+    return ret;
+}
+int segjiao(point &ji,point a,point b,point c,point d)
+{
+    ji=mo_intersection(a,b,c,d);
+    if(mo_ll(ji.x,min(c.x,d.x))) return 0;
+    if(mo_ll(ji.y,min(c.y,d.y))) return 0;
+    if(mo_gg(ji.x,max(c.x,d.x))) return 0;
+    if(mo_gg(ji.y,max(c.y,d.y))) return 0;
+    return 1;
+}
+node jiaojiao(int a,int b,int ii,int jj)
+{
+    node cur;
+    point xiang1,xiang2;
+    xiang1.x=city[b].x-city[a].x,xiang1.y=city[b].y-city[a].y;
+    xiang2.x=base[jj].x-base[ii].x,xiang2.y=base[jj].y-base[ii].y;
+    if(mo_ee(xiang1.x*xiang2.x,xiang1.y*xiang2.y))
+    {
+        cur.i=-1;
+        return cur;
+    }
+    xiang2=getxiang(xiang2);
+    point zhong;
+    zhong.x=(base[ii].x+base[jj].x)/2,zhong.y=(base[ii].y+base[jj].y)/2;
+    point zhongxia;
+    zhongxia.x=zhong.x+xiang2.x;
+    zhongxia.y=zhong.y+xiang2.y;
+    point jiaodian;
+    int jjao=segjiao(jiaodian,zhong,zhongxia,city[a],city[b]);
+    if(jjao==0)
+    {
+        cur.i=-1;
+        return cur;
+    }
+    cur.p=jiaodian;
+    cur.i=ii;
+    cur.j=jj;
+    cur.dist=mo_distance(jiaodian,city[a]);
+    return cur;
+}
+bool cmp(const node &aa,const node &bb)
+{
+    if(mo_ee(aa.dist,bb.dist))
+    {
+        point temp;
+        temp.x=(base[aa.i].x+base[aa.j].x)/2;
+        temp.y=(base[aa.i].y+base[aa.j].y)/2;
+        double dist1=mo_distance(aa.p,temp);
+        temp.x=(base[bb.i].x+base[bb.j].x)/2;
+        temp.y=(base[bb.i].y+base[bb.j].y)/2;
+        double dist2=mo_distance(bb.p,temp);
+        return mo_ll(dist1,dist2);
+    }
+    return mo_ll(aa.dist,bb.dist);
+}
+inline int nextno(int j,int no)
+{
+    if(jiao[j].i==no) return jiao[j].j;
+    if(jiao[j].j==no) return jiao[j].i;
+    return no;
+}
+int main()
+{
+    int i,j,ncase;
+    while(scanf("%d%d",&N,&M)!=EOF)
+    {
+        for(i=1;i<=N;++i)
+        {
+            scanf("%lf%lf",&city[i].x,&city[i].y);
+        }
+        for(i=1;i<=M;++i)
+        {
+            scanf("%lf%lf",&base[i].x,&base[i].y);
+        }
+        scanf("%d",&K);
+        for(ncase=0;ncase<K;++ncase)
+        {
+            int yong=0;
+            scanf("%d%d",&a,&b);
+            for(i=1;i<=M;++i)
+            {
+                for(j=i+1;j<=M;++j)
+                {
+                    if(i==j) continue;
+                    node cur=jiaojiao(a,b,i,j);
+                    if(cur.i<0)
+                    {
+                        continue;
+                    }else
+                    {
+                        jiao[yong++]=cur;
+                    }
+                }
+            }
+            sort(jiao,jiao+yong,cmp);
+            double mindist=-1;
+            int minno;
+            for(i=1;i<=M;++i)
+            {
+                double disttemp=sqrt((city[a].x-base[i].x)*(city[a].x-base[i].x)+(city[a].y-base[i].y)*(city[a].y-base[i].y));
+                if(mindist<0||mo_ll(disttemp,mindist))
+                {
+                    mindist=disttemp;
+                    minno=i;
+                }
+            }
+            int dang=minno,ret=0;
+            for(i=0;i<yong;++i)
+            {
+                int xinno=nextno(i,dang);
+                if(xinno!=dang)
+                {
+                    dang=xinno;
+                    ret++;
+                }
+            }
+            printf("%d\n",ret);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4644_autoAC.cpp b/HDOJ/4644_autoAC.cpp
new file mode 100644
index 0000000..22117ff
--- /dev/null
+++ b/HDOJ/4644_autoAC.cpp
@@ -0,0 +1,56 @@
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+char str[2000100];
+char t[100100];
+pair<int,int>s[100100];
+int index[100100];
+int n;
+int ne[100100];
+void get_next(char* str,int len){
+    ne[0]=0;
+    for(int i=1;i<len;i++){
+        int j=ne[i-1];
+        while(j&&str[i]!=str[j])j=ne[j-1];
+        if(str[i]==str[j])j++;
+        ne[i]=j;
+    }
+}
+bool match(char *s,int len){
+    int k=0;
+    for(int i=0;i<n;i++){
+        while(k&&str[k]!=s[i])k=ne[k-1];
+        if(str[k]==s[i])k++;
+        if(k==len)return true;
+    }
+    return false;
+}
+int main(){
+    while(~scanf("%s",str)){
+        n=strlen(str);
+        for(int i=0;i<n;i++){
+            s[i].first=str[i];
+            s[i].second=i;
+        }
+        stable_sort(s,s+n);
+        for(int i=0;i<n;i++)index[i]=s[i].second;
+        int now=index[0];
+        n--;
+        for(int i=0;i<n;i++){
+            t[i]=s[now].first;
+            now=index[now];
+        }
+        t[n]='\0';
+        int q;
+        scanf("%d",&q);
+        while(q--){
+            scanf("%s",str);
+            int len=strlen(str);
+            get_next(str,len);
+            if(match(t,len))printf("YES\n");
+            else printf("NO\n");
+        }
+    }
+}
diff --git a/HDOJ/4646_autoAC.cpp b/HDOJ/4646_autoAC.cpp
new file mode 100644
index 0000000..e8b08da
--- /dev/null
+++ b/HDOJ/4646_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#define ll long long
+using namespace std;
+ll t,n;
+map<ll,ll> g;
+ll f(ll x)
+{
+    if (x%2==0) return 2*(x/6+1)-1;
+        else return 2*((x-3)/6+1);
+}
+ll get(ll x)
+{
+    if (g[x]!=0) return g[x];
+    g[x]=f(x);
+    for (ll i=2; i*i<=x; i++)
+    {
+        if (x%i>0) continue;
+        g[x]-=get(i);
+        if (i*i!=x)
+        {
+            g[x]-=get(x/i);
+        }
+    }
+    return g[x];
+}
+int main()
+{
+    scanf("%I64d",&t);
+    while (t--)
+    {
+        scanf("%I64d",&n);
+        if (n%3==0)
+        {
+            printf("0\n");
+            continue;
+        }
+        if ((n&1)==0)
+        {
+            printf("0\n");
+            continue;
+        }
+        if (n==1)
+        {
+            printf("1\n");
+            continue;
+        }
+        if (n==3)
+        {
+            printf("0\n");
+            continue;
+        }
+        n=(n+3)>>1;
+        printf("%I64d\n",get(n));
+    }
+    return 0;
+}
diff --git a/HDOJ/4647_autoAC.cpp b/HDOJ/4647_autoAC.cpp
new file mode 100644
index 0000000..8e11728
--- /dev/null
+++ b/HDOJ/4647_autoAC.cpp
@@ -0,0 +1,32 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int N=100010;
+int n,m;
+double a[N];
+int cmp(double x,double y){
+    return x>y;
+}
+int main(){
+    while(~scanf("%d%d",&n,&m)){
+        for(int i=1;i<=n;i++)
+            scanf("%lf",&a[i]);
+        int u,v,w;
+        while(m--){
+            scanf("%d%d%d",&u,&v,&w);
+            a[u]+=1.0*w/2;
+            a[v]+=1.0*w/2;
+        }
+        double t1=0,t2=0;
+        sort(a+1,a+1+n,cmp);
+        for(int i=1;i<=n;i++)
+            if(i&1)
+                t1+=a[i];
+            else
+                t2+=a[i];
+        printf("%.0lf\n",t1-t2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4648_autoAC.cpp b/HDOJ/4648_autoAC.cpp
new file mode 100644
index 0000000..25f1c7a
--- /dev/null
+++ b/HDOJ/4648_autoAC.cpp
@@ -0,0 +1,32 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <vector>
+#include <cmath>
+using namespace std;
+const int V = 100000 + 50;
+const int MaxN = 80 + 5;
+const int mod = 10000 + 7;
+const __int64 INF = 0x7FFFFFFFFFFFFFFFLL;
+const int inf = 0x7fffffff;
+int n, m, sum[V], ans;
+int main() {
+    int i, j;
+    while(~scanf("%d%d", &n, &m)) {
+        ans = 0;
+        for(i = 1; i <= n; ++i) {
+            int temp;
+            scanf("%d", &temp);
+            sum[i] = (sum[i - 1] + temp) % m;
+        }
+        for(i = n; i >= 1 && i > ans; --i) {
+            for(j = 1; j + i - 1 <= n; ++j)
+                if((sum[j + i - 1] - sum[j - 1]) % m == 0) {
+                    ans = max(ans, i);
+                    break;
+                }
+        }
+        printf("%d\n", ans);
+    }
+}
diff --git a/HDOJ/4649_autoAC.cpp b/HDOJ/4649_autoAC.cpp
new file mode 100644
index 0000000..7ecc2a6
--- /dev/null
+++ b/HDOJ/4649_autoAC.cpp
@@ -0,0 +1,72 @@
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <stack>
+#include <queue>
+#include <map>
+#include <set>
+#include <vector>
+#include <math.h>
+#include <bitset>
+#include <algorithm>
+#include <climits>
+using namespace std;
+#define ls 2*i
+#define rs 2*i+1
+#define UP(i,x,y) for(i=x;i<=y;i++)
+#define DOWN(i,x,y) for(i=x;i>=y;i--)
+#define MEM(a,x) memset(a,x,sizeof(a))
+#define W(a) while(a)
+#define gcd(a,b) __gcd(a,b)
+#define LL long long
+#define N 205
+#define MOD 1000000007
+#define INF 0x3f3f3f3f
+#define EXP 1e-8
+#define rank rank1
+const int mod = 10007;
+int n,a[N];
+double dp[N],p[N],ans;
+char op[N][5];
+int main()
+{
+    int i,j,k,cas=1;
+    while(~scanf("%d",&n))
+    {
+        for(i = 0; i<=n; i++)
+            scanf("%d",&a[i]);
+        for(i = 1; i<=n; i++)
+            scanf("%s",op[i]);
+        for(i = 1; i<=n; i++)
+            scanf("%lf",&p[i]);
+        ans = 0;
+        for(i = 0; i<=20; i++)
+        {
+            double q;
+            if(a[0]&(1<<i)) q = 1;
+            else q = 0;
+            for(j = 1; j<=n; j++)
+            {
+                if(a[j]&(1<<i))
+                {
+                    if(op[j][0]=='&')
+                        continue;
+                    else if(op[j][0]=='^')
+                        q = q*p[j]+(1-q)*(1-p[j]);
+                    else
+                        q = q*p[j]+(1-p[j]);
+                }
+                else
+                {
+                    if(op[j][0]=='&')
+                        q = q*p[j];
+                    else
+                        continue;
+                }
+            }
+            ans += q*(1<<i);
+        }
+        printf("Case %d:\n%lf\n",cas++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4650_autoAC.cpp b/HDOJ/4650_autoAC.cpp
new file mode 100644
index 0000000..cea90cc
--- /dev/null
+++ b/HDOJ/4650_autoAC.cpp
@@ -0,0 +1,61 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+const int N = 101;
+const double INF = 10000000000.0;
+const int INF_INT =10000000;
+int side[N][N];
+int dis[N][N];
+int vis[N][N];
+int tmp[N][N];
+double ans[N][N];
+int main(){
+    int n,m;
+    while(~scanf("%d%d",&n,&m)){
+        memset(vis,-1,sizeof(vis));
+        for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){ans[i][j]=INF;side[i][j]=INF_INT;}
+        for(int i=0;i<m;i++){
+            int u,v,w;
+            scanf("%d%d%d",&u,&v,&w);
+            side[u][v]=w;
+            vis[u][v]=1;
+        }
+        for(int k=1;k<=n;k++)for(int i=1;i<=n;i++)if(vis[i][k]!=-1){
+            for(int j=1;j<=n;j++)if(vis[k][j]!=-1){
+                if(vis[i][j]==-1)vis[i][j]=vis[i][k]+vis[k][j];
+                else vis[i][j]=min(vis[i][j],vis[i][k]+vis[k][j]);
+            }
+        }
+        for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)dis[i][j]=side[i][j];
+        for(int k=1;k<=n;k++){
+            for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(vis[i][j]!=-1&&k>=vis[i][j]){
+                ans[i][j]=min(ans[i][j],(double)dis[i][j]/k);
+            }
+            for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){tmp[i][j]=dis[i][j];dis[i][j]=INF_INT;}
+            for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){
+                for(int h=1;h<=n;h++){
+                    if(vis[i][h]==-1||k<vis[i][h])continue;
+                    if(vis[h][j]==-1||k<vis[h][j])continue;
+                    dis[i][j]=min(dis[i][j],tmp[i][h]+side[h][j]);
+                }
+            }
+        }
+        for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(vis[i][j]!=-1){
+            for(int k=1;k<=n;k++)if(vis[i][k]!=-1&&vis[k][j]!=-1&&vis[k][k]!=-1){
+                ans[i][j]=min(ans[i][j],ans[k][k]);
+            }
+        }
+        for(int i=1;i<=n;i++){
+            int j=1;
+            if(vis[i][j]==-1)printf("NO");
+            else printf("%.3lf",ans[i][j]);
+            for(j=2;j<=n;j++){
+                if(vis[i][j]==-1)printf(" NO");
+                else printf(" %.3lf",ans[i][j]);
+            }
+            printf("\n");
+        }
+    }
+}
diff --git a/HDOJ/4651_autoAC.cpp b/HDOJ/4651_autoAC.cpp
new file mode 100644
index 0000000..b49175c
--- /dev/null
+++ b/HDOJ/4651_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <cstring>
+#include <cmath>
+using namespace std;
+long long tar[100002];
+const int MOD=1000000007;
+void init()
+{
+    memset(tar,0,sizeof(tar));
+    tar[0]=1;
+    for(int i=1;i<=100000;i++)
+    {
+        int nbit;
+        for(int j=1;;j++)
+        {
+            int element1,element2;
+            element1=i-j*(3*j-1)/2;
+            element2=i-j*(3*j+1)/2;
+            if(j&1)
+                nbit=1;
+            else if(j%2==0)
+                nbit=-1;
+            if(element2<0 && element1<0)
+                break;
+            if(element1>=0)
+            {
+                tar[i]=(tar[i]+nbit*tar[element1])%MOD;
+            }
+            if(element2>=0)
+            {
+                tar[i]=(tar[i]+nbit*tar[element2])%MOD;
+            }
+        }
+        tar[i]=(tar[i]+MOD)%MOD;
+    }
+}
+int main()
+{
+    int testcase;
+    init();
+    cin>>testcase;
+    while(testcase--)
+    {
+        int rat;
+        cin>>rat;
+        cout<<tar[rat]<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4652_autoAC.cpp b/HDOJ/4652_autoAC.cpp
new file mode 100644
index 0000000..172628e
--- /dev/null
+++ b/HDOJ/4652_autoAC.cpp
@@ -0,0 +1,41 @@
+#include <cstdio>  
+#include <iostream>  
+#include <cstring>  
+#include <algorithm>  
+#include <cmath>  
+using namespace std;  
+double solve0(int m,int n)  
+{  
+    double ans=0;  
+    for(int i=0;i<=n-1;i++)  
+        ans+=pow(1.0*m,i);  
+    return ans;  
+}  
+double solve1(int m,int n)  
+{  
+    double ans=0;  
+    double tmp=1;  
+    for(int i=1;i<=n;i++)  
+    {  
+        ans+=tmp;  
+        tmp*=(m+0.0)/(m-i);  
+    }  
+    return ans;  
+}  
+int main()  
+{  
+    int t;  
+    while(scanf("%d",&t)!=EOF)  
+    {  
+        while(t--)  
+        {  
+            int n,m,op;  
+            scanf("%d%d%d",&op,&m,&n);  
+            if(op==0)  
+                printf("%.9lf\n",solve0(m,n));  
+            else  
+                printf("%.9lf\n",solve1(m,n));  
+        }  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4654_autoAC.cpp b/HDOJ/4654_autoAC.cpp
new file mode 100644
index 0000000..1fbb142
--- /dev/null
+++ b/HDOJ/4654_autoAC.cpp
@@ -0,0 +1,102 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+using namespace std;
+#define inf (1<<29)
+const int maxn = 105;
+int g[maxn][maxn],a[maxn][maxn],p[maxn];
+bool vis[maxn],combine[maxn],par[maxn];
+int d[maxn],node[maxn],st[maxn],k,s,t;
+vector <int> vst[maxn];
+vector <int> pa , pb;
+int prim(int n) {
+    memset(vis,0,sizeof(vis));
+    memset(d,0,sizeof(d));
+    int mincut = 0 , tmp = -1;
+    s = t = -1;
+    int top = 0;
+    for(int i=0;i<k;i++) {
+        int maxi = -inf;
+        for(int j=0;j<k;j++) {
+            int u = node[j];
+            if(!combine[u]&&!vis[u]&&d[u]>maxi) {
+                tmp = u;
+                maxi = d[u];
+            }
+        }
+        st[top++] = tmp;
+        vis[tmp] = true;
+        if(i == k-1)
+            mincut = d[tmp];
+        for(int j=0;j<k;j++) {
+            int u = node[j];
+            if(!combine[u]&&!vis[u])
+                d[u] += g[tmp][u];
+        }
+    }
+    s = st[top-2];
+    t = st[top-1];
+    for(int i=0;i<top;i++) node[i] = st[i];
+    return mincut;
+}
+int stoer_wagner(int n) {
+    for(int i=0;i<n;i++) {
+        vst[i].clear();
+        vst[i].push_back(i);
+    }
+    int ans = inf;
+    memset(combine,0,sizeof(combine));
+    for(int i=0;i<n;i++) node[i] = i;
+    for(int i=1;i<n;i++) {
+        k = n - i + 1;
+        int cur = prim(n);
+        if(cur < ans) {
+            ans = cur;
+            for(int j=0;j<n;j++) par[j] = 0;
+            for(int j=0;j<vst[t].size();j++) par[ vst[t][j] ] = 1;
+        }
+        combine[t] = true;
+        for(int j=0;j<vst[t].size();j++) vst[s].push_back(vst[t][j]);
+        for(int j=0;j<n;j++) {
+            if(j == s) continue;
+            if(!combine[j]) {
+                g[s][j] += g[t][j];
+                g[j][s] += g[j][t];
+            }
+        }
+    }
+    pa.clear(); pb.clear();
+    for(int i=0;i<n;i++)
+        if(par[i]) pa.push_back(i);
+        else pb.push_back(i);
+    return ans;
+}
+int K;
+int dfs(vector <int> t) {
+    int n = t.size();
+    for(int i=0;i<n;i++) for(int j=0;j<n;j++) g[i][j] = a[t[i]][t[j]];
+    if(stoer_wagner(n) >= K) return 1;
+    vector <int> x , y;
+    for(int i=0;i<pa.size();i++) x.push_back(t[pa[i]]);
+    for(int i=0;i<pb.size();i++) y.push_back(t[pb[i]]);
+    return dfs(x) + dfs(y);
+}
+int main() {
+    int n , m;
+    while(~scanf("%d%d%d",&n,&m,&K)) {
+        memset(a , 0 ,sizeof(a));
+        while(m--) {
+            int u , v;
+            scanf("%d%d",&u,&v);
+            u --; v --;
+            a[u][v] += 1;
+            a[v][u] += 1;
+        }
+        vector <int> t;
+        for(int i=0;i<n;i++) t.push_back(i);
+        printf("%d\n" , dfs(t));
+    }
+    return 0;
+}
diff --git a/HDOJ/4655_autoAC.cpp b/HDOJ/4655_autoAC.cpp
new file mode 100644
index 0000000..a283c14
--- /dev/null
+++ b/HDOJ/4655_autoAC.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <stack>
+#include <queue>
+#include <set>
+#include <time.h>
+using namespace std;
+const int MOD = 1e9+7;
+long long inv(long long a,long long m)
+{
+    if(a == 1)return 1;
+    return inv(m%a,m)*(m-m/a)%m;
+}
+const int MAXN = 1000010;
+int a[MAXN];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&n);
+        long long S = 1;
+        for(int i = 0;i < n;i++)
+        {
+            scanf("%d",&a[i]);
+            S *= a[i];
+            S %=MOD;
+        }
+        long long ans = S*n%MOD;
+        sort(a,a+n);
+        reverse(a,a+n);
+        int cnt = n-1;
+        for(int i = 0;i < n;i++)
+        {
+            if(cnt == 0)break;
+            long long tmp = S*inv(a[i],MOD)%MOD;
+            ans -= tmp;
+            ans = (ans%MOD+MOD)%MOD;
+            cnt--;
+            if(cnt == 0)break;
+            ans -= tmp;
+            ans = (ans%MOD+MOD)%MOD;
+            cnt--;
+            if(cnt == 0)break;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4656_autoAC.cpp b/HDOJ/4656_autoAC.cpp
new file mode 100644
index 0000000..f65f045
--- /dev/null
+++ b/HDOJ/4656_autoAC.cpp
@@ -0,0 +1,116 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int P = 1000003;
+const int N1 = 262144;
+const int N2 = N1+1;
+const int P1 = 998244353;
+const int P2 = 995622913;
+const int E1 = 996173970;
+const int E2 = 88560779;
+const int F1 = 121392023;
+const int F2 = 840835547;
+const int I1 = 998240545;
+const int I2 = 995619115;
+const long long M1 = 397550359381069386LL;
+const long long M2 = 596324591238590904LL;
+const long long MM = 993874950619660289LL;
+long long mul(long long x,long long y,long long z){
+    return (x*y - (long long)(x/(long double)z*y+1e-3)*z+z)%z;
+}
+int trf(int x1,int x2){
+    return (mul(M1,x1,MM)+mul(M2,x2,MM))%MM%P;
+}
+int A[N2],B[N2],C[N2];
+int A1[N2],B1[N2],C1[N2];
+void fft(int *A,int PM,int PW){
+    for(int m = N1,h;h = m/2, m >= 2;PW = (long long)PW*PW%PM,m=h)
+        for(int i = 0,w=1;i < h;i++, w = (long long)w*PW%PM)
+            for(int j = i;j < N1;j += m){
+                int k = j+h, x = (A[j]-A[k]+PM)%PM;
+                (A[j]+=A[k])%=PM;
+                A[k] = (long long)w*x%PM;
+            }
+    for(int i = 0,j = 1;j < N1-1;j++){
+        for(int k = N1/2; k > (i^=k);k /= 2);
+        if(j < i)swap(A[i],A[j]);
+    }
+}
+void mul(){
+    memset(C,0,sizeof(C));
+    memcpy(A1,A,sizeof(A));
+    memcpy(B1,B,sizeof(B));
+    fft(A1,P1,E1); fft(B1,P1,E1);
+    for(int i = 0;i < N1;i++)C1[i] = (long long)A1[i]*B1[i]%P1;
+    fft(C1,P1,F1);
+    for(int i = 0;i < N1;i++)C1[i] = (long long)C1[i]*I1%P1;
+    fft(A,P2,E2); fft(B,P2,E2);
+    for(int i = 0;i < N1;i++)C[i] = (long long)A[i]*B[i]%P2;
+    fft(C,P2,F2);
+    for(int i = 0;i < N1;i++)C[i] = (long long)C[i]*I2%P2;
+    for(int i = 0;i < N1;i++)C[i] = trf(C1[i],C[i]);
+}
+int INV[P];
+const int MAXN = 100010;
+int F[MAXN];
+int a[MAXN];
+int pd[MAXN];
+int pb[MAXN];
+int pc2[MAXN];
+int p[MAXN];
+int main()
+{
+    INV[1] = 1;
+    for(int i = 2;i < P;i++)
+        INV[i] = (long long)P/i*(P-INV[P%i])%P;
+    F[0] = 1;
+    for(int i = 1;i < MAXN;i++)
+        F[i] = (long long)F[i-1]*i%P;
+    int n,b,c,d;
+    while(scanf("%d%d%d%d",&n,&b,&c,&d) == 4){
+        for(int i = 0;i < n;i++)scanf("%d",&a[i]);
+        pd[0] = 1;
+        for(int i = 1;i < n;i++)
+            pd[i] = (long long)pd[i-1]*d%P;
+        memset(A,0,sizeof(A));
+        memset(B,0,sizeof(B));
+        for(int i = 0;i < n;i++)
+            A[i] = (long long)a[n-1-i]*F[n-1-i]%P;
+        for(int i = 0;i < n;i++)
+            B[i] = (long long)pd[i]*INV[F[i]]%P;
+        mul();
+        for(int i = 0;i < n;i++)p[i] = C[i];
+        reverse(p,p+n);
+        memset(A,0,sizeof(A));
+        pb[0] = 1;
+        for(int i = 1;i < n;i++)
+            pb[i] = (long long)pb[i-1]*b%P;
+        pc2[0] = 1;
+        int c2 = (long long)c*c%P;
+        for(int i = 1, s = c;i < n;i++){
+            pc2[i] = (long long)pc2[i-1]*s%P;
+            s = (long long)s*c2%P;
+        }
+        for(int i = 0;i < n;i++)
+            A[i] = (long long)pb[i]*INV[F[i]]%P*p[i]%P*pc2[i]%P;
+        memset(B,0,sizeof(B));
+        B[0] = 1;
+        for(int i = 1;i < n;i++)
+            B[i] = B[N1-i] = INV[pc2[i]];
+        mul();
+        for(int i = 0;i < n;i++)C[i] = (long long)C[i]*pc2[i]%P;
+        for(int i = 0;i < n;i++)
+            printf("%d\n",C[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4657_autoAC.cpp b/HDOJ/4657_autoAC.cpp
new file mode 100644
index 0000000..4894574
--- /dev/null
+++ b/HDOJ/4657_autoAC.cpp
@@ -0,0 +1,45 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+#include<iomanip>
+#include<cmath>
+#include<ctime>
+#include<cstring>
+#include<vector>
+#define ll __int64
+#define pi acos(-1.0)
+#define MAX 100005
+#define mod 1000003
+using namespace std;
+int a[MAX],b[MAX],c[MAX],index[MAX];
+int main(){
+    int t,n,i,j;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d",&n);
+        for(i=0;i<n;i++) scanf("%d",&b[i]);
+        for(i=0;i<n;i++) a[i]=c[i]=index[i]=i;
+        for(i=0;i<n;i++){
+            int cur=i;
+            while((a[cur]+b[cur])%n!=c[cur]){
+                int l = index[(c[cur]-b[cur]+n)%n];
+                swap(a[l],a[cur]);
+                swap(index[a[l]],index[a[cur]]);
+                if(l>i) break;
+                cur=l;
+                swap(c[i+1],c[cur]);
+            }
+        }
+        for(i=0;i<n;i++){
+            printf("%d",a[i]);
+            if(i!=n-1) printf(" ");
+            else printf("\n");
+        }
+        for(i=0;i<n;i++){
+            printf("%d",c[i]);
+            if(i!=n-1) printf(" ");
+            else printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4658_autoAC.cpp b/HDOJ/4658_autoAC.cpp
new file mode 100644
index 0000000..a050fd3
--- /dev/null
+++ b/HDOJ/4658_autoAC.cpp
@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <iostream>
+using namespace std;
+const int mod=1e9+7;
+int f[100010];
+void init()
+{
+    f[0]=1;
+    int i,j,k,flag,t,tt;
+    for(i=1;i<=100000;i++)
+    {
+        f[i]=0;
+        flag=1;
+        for(j=1;;j++)
+        {
+            t=i-j*(3*j-1)/2;
+            tt=i-j*(3*j+1)/2;
+            if(t<0)break;
+            f[i]=(f[i]+flag*f[t])%mod;
+            if(tt<0)break;
+            f[i]=(f[i]+flag*f[tt])%mod;
+            flag=-flag;
+        }
+        f[i]=(f[i]+mod)%mod;
+    }
+}
+int find(int n,int k)
+{
+    int i,j,ans,flag=-1,t,tt;
+    ans=f[n];
+    for(i=1;;i++)
+    {
+        t=k*i*(i*3-1)/2;
+        tt=k*i*(i*3+1)/2;
+        if(t>n)break;
+        ans=(ans+flag*f[n-t])%mod;
+        if(tt>n)break;
+        ans=(ans+flag*f[n-tt])%mod;
+        flag=-flag;
+    }
+    return (ans+mod)%mod;
+}
+int main()
+{
+    init();
+    int T;
+    cin>>T;
+    while(T--)
+    {
+        int n,k,ans;
+        scanf("%d%d",&n,&k);
+        ans=find(n,k) ;
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4661_autoAC.cpp b/HDOJ/4661_autoAC.cpp
new file mode 100644
index 0000000..4099a54
--- /dev/null
+++ b/HDOJ/4661_autoAC.cpp
@@ -0,0 +1,141 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include<cstdio>
+#include<cstring>
+typedef long long LL;
+#define MAXN 1000010
+#define MAXM 2000010
+#define MOD 1000000007
+int n;
+LL fac[MAXN];
+LL invfac[MAXN];
+int first[MAXN], next[MAXM], v[MAXM], e;
+bool vis[MAXN];
+LL dp[MAXN];
+LL f[MAXN];
+int size[MAXN];
+LL ext_gcd(LL a, LL b, LL &x, LL &y) {
+    LL t, d;
+    if (b == 0) {
+        x = 1;
+        y = 0;
+        return a;
+    }
+    d = ext_gcd(b, a % b, x, y);
+    t = x;
+    x = y;
+    y = t - a / b * y;
+    return d;
+}
+LL invmod(LL a, LL n = MOD) {
+    LL x, y;
+    if (ext_gcd(a, n, x, y) != 1)
+        return -1;
+    return (x % n + n) % n;
+}
+void init() {
+    int i;
+    fac[0] = 1;
+    for (i = 1; i < MAXN; i++) {
+        fac[i] = fac[i - 1] * i;
+        fac[i] %= MOD;
+    }
+    for (i = 0; i < MAXN; i++) {
+        invfac[i] = invmod(fac[i]);
+    }
+}
+inline void addEdge(int x, int y) {
+    v[e] = y;
+    next[e] = first[x];
+    first[x] = e++;
+}
+void getSize(int x) {
+    vis[x] = true;
+    size[x] = 1;
+    for (int i = first[x]; i != -1; i = next[i]) {
+        int y = v[i];
+        if (!vis[y]) {
+            getSize(y);
+            size[x] += size[y];
+        }
+    }
+}
+void dfs(int x) {
+    vis[x] = true;
+    dp[x] = fac[size[x] - 1];
+    for (int i = first[x]; i != -1; i = next[i]) {
+        int y = v[i];
+        if (!vis[y]) {
+            dfs(y);
+            dp[x] *= invfac[size[y]];
+            dp[x] %= MOD;
+            dp[x] *= dp[y];
+            dp[x] %= MOD;
+        }
+    }
+}
+void search(int x, int pre) {
+    vis[x] = true;
+    if (pre != -1) {
+        f[x] = fac[n - 1];
+        f[x] *= invfac[n - size[x]];
+        f[x] %= MOD;
+        LL tmp = f[pre];
+        tmp *= invfac[n - 1];
+        tmp %= MOD;
+        tmp *= fac[n - 1 - size[x]];
+        tmp %= MOD;
+        tmp *= fac[size[x]];
+        tmp %= MOD;
+        tmp *= invmod(dp[x]);
+        tmp %= MOD;
+        f[x] *= tmp;
+        f[x] %= MOD;
+        for (int i = first[x]; i != -1; i = next[i]) {
+            int y = v[i];
+            if (!vis[y]) {
+                f[x] *= invfac[size[y]];
+                f[x] %= MOD;
+                f[x] *= dp[y];
+                f[x] %= MOD;
+            }
+        }
+    }
+    for (int i = first[x]; i != -1; i = next[i]) {
+        int y = v[i];
+        if (!vis[y]) {
+            search(y, x);
+        }
+    }
+}
+int main() {
+    int T;
+    int i;
+    int x, y;
+    int ans;
+    init();
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d", &n);
+        e = 0;
+        memset(first, -1, sizeof(first));
+        for (i = 1; i < n; i++) {
+            scanf("%d%d", &x, &y);
+            addEdge(x, y);
+            addEdge(y, x);
+        }
+        memset(vis, false, sizeof(vis));
+        getSize(1);
+        memset(vis, false, sizeof(vis));
+        dfs(1);
+        memset(vis, false, sizeof(vis));
+        f[1] = dp[1];
+        search(1, -1);
+        ans = 0;
+        for (i = 1; i <= n; i++) {
+            ans += (f[i] * f[i]) % MOD;
+            ans %= MOD;
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4662_autoAC.cpp b/HDOJ/4662_autoAC.cpp
new file mode 100644
index 0000000..1f2da7d
--- /dev/null
+++ b/HDOJ/4662_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<cstdio>
+#include<cstring>
+#define MAXN 1000010
+char str[MAXN];
+bool isOK(int len) {
+    if (str[0] != 'M') {
+        return false;
+    }
+    for (int i = 1; i < len; i++) {
+        if (str[i] == 'M') {
+            return false;
+        }
+    }
+    return true;
+}
+int main() {
+    int T;
+    int len;
+    int cnt;
+    int i;
+    scanf("%d", &T);
+    while (T--) {
+        scanf(" %s", str);
+        len = strlen(str);
+        if (isOK(len)) {
+            cnt = 0;
+            for (i = 1; i < len; i++) {
+                if (str[i] == 'U') {
+                    cnt += 3;
+                } else {
+                    cnt++;
+                }
+            }
+            if (len == 2 && str[1] == 'I') {
+                puts("Yes");
+            } else if (cnt % 6 == 2 || cnt % 6 == 4) {
+                puts("Yes");
+            } else {
+                puts("No");
+            }
+        } else {
+            puts("No");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4664_autoAC.cpp b/HDOJ/4664_autoAC.cpp
new file mode 100644
index 0000000..c417625
--- /dev/null
+++ b/HDOJ/4664_autoAC.cpp
@@ -0,0 +1,65 @@
+#include<cstdio>
+#include<cstring>
+#define MAXN 1010
+int sg[MAXN];
+bool vis[MAXN];
+int SG(int n) {
+    if (n == 0) {
+        sg[n] = 0;
+    } else if (n == 1) {
+        sg[n] = 0;
+    } else if (n == 2) {
+        sg[n] = 1;
+    } else if (n == 3) {
+        sg[n] = 1;
+    } else if (sg[n] == -1) {
+        int i;
+        memset(vis, false, sizeof(vis));
+        for (i = 0; i <= n - 2; i++) {
+            vis[SG(i) ^ SG(n - i - 2)] = true;
+        }
+        for (i = 0;; i++) {
+            if (!vis[i]) {
+                break;
+            }
+        }
+        sg[n] = i;
+    }
+    return sg[n];
+}
+void init() {
+    int i;
+    memset(sg, -1, sizeof(sg));
+    for (i = 0; i < MAXN; i++) {
+        sg[i] = SG(i);
+    }
+}
+int getSG(int n) {
+    if (n < MAXN) {
+        return sg[n];
+    } else {
+        return sg[n % 34 + 2 * 34];
+    }
+}
+int main() {
+    int T;
+    int n;
+    int tmp;
+    int res;
+    init();
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d", &n);
+        res = 0;
+        while (n--) {
+            scanf("%d", &tmp);
+            res ^= getSG(tmp);
+        }
+        if (res) {
+            puts("Carol");
+        } else {
+            puts("Dave");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4665_autoAC.cpp b/HDOJ/4665_autoAC.cpp
new file mode 100644
index 0000000..3ce23f8
--- /dev/null
+++ b/HDOJ/4665_autoAC.cpp
@@ -0,0 +1,82 @@
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+#include<vector>
+#define MAXN 2010
+using namespace std;
+int arr[MAXN];
+char str[MAXN];
+bool flag;
+int idx[MAXN];
+int cnt[MAXN];
+int st[2][MAXN];
+int belong[MAXN];
+int n;
+vector<int> pos[MAXN];
+void dfs(int x, int p1, int p2) {
+    if (x > n) {
+        flag = true;
+    }
+    if (flag) {
+        return;
+    }
+    if (p1 > 0 && p2 > 0
+            && arr[st[0][min(p1, p2)]] != arr[st[1][min(p1, p2)]]) {
+        return;
+    }
+    if (belong[x] == 0) {
+        st[0][p1 + 1] = x;
+        dfs(x + 1, p1 + 1, p2);
+    } else if (belong[x] == 1) {
+        st[1][p2 + 1] = x;
+        dfs(x + 1, p1, p2 + 1);
+    } else {
+        st[0][p1 + 1] = x;
+        belong[pos[arr[x]][2]] = 1;
+        dfs(x + 1, p1 + 1, p2);
+        if (!flag) {
+            st[1][p2 + 1] = x;
+            belong[pos[arr[x]][2]] = 0;
+            dfs(x + 1, p1, p2 + 1);
+            belong[pos[arr[x]][2]] = -1;
+        }
+    }
+}
+int main() {
+    int T;
+    int i;
+    scanf("%d", &T);
+    while (T--) {
+        scanf("%d", &n);
+        memset(idx, 0, sizeof(idx));
+        memset(cnt, 0, sizeof(cnt));
+        for (i = 1; i <= n; i++) {
+            scanf("%d", &arr[i]);
+            cnt[arr[i]]++;
+            idx[i] = cnt[arr[i]];
+            pos[arr[i]].clear();
+        }
+        memset(belong, -1, sizeof(belong));
+        for (i = 1; i <= n; i++) {
+            if (idx[i] == 1) {
+                belong[i] = 0;
+            } else if (idx[i] == 2 && cnt[arr[i]] == 2) {
+                belong[i] = 1;
+            } else if (idx[i] == 4) {
+                belong[i] = 1;
+            }
+            pos[arr[i]].push_back(i);
+        }
+        flag = false;
+        dfs(1, 0, 0);
+        for (i = 1; i <= (n >> 1); i++) {
+            str[st[0][i]] = '0';
+            str[st[1][i]] = '1';
+        }
+        for (i = 1; i <= n; i++) {
+            putchar(str[i]);
+        }
+        putchar('\n');
+    }
+    return 0;
+}
diff --git a/HDOJ/4666_autoAC.cpp b/HDOJ/4666_autoAC.cpp
new file mode 100644
index 0000000..f02700e
--- /dev/null
+++ b/HDOJ/4666_autoAC.cpp
@@ -0,0 +1,66 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+#include<set>
+using namespace std;
+#define maxn 60002
+int maps[maxn][6];
+multiset<int>se[1<<5];
+multiset<int>::iterator i1,i2;
+int main()
+{
+    int i,j,leap,x,n,m,a;
+    while(~scanf("%d%d",&n,&m))
+    {
+        for(i=0;i<(1<<5);i++)
+            se[i].clear();
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d",&leap);
+            if(leap==0)
+            {
+                for(j=0;j<m;j++)
+                {
+                    scanf("%d",&maps[i][j]);
+                }
+                for(a=0;a<(1<<m);a++)
+                {
+                    int as;
+                    as=0;
+                    for(j=0;j<m;j++)
+                    {
+                        if(a&(1<<j))as+=maps[i][j];
+                        else as-=maps[i][j];
+                    }
+                    se[a].insert(as);
+                }
+            }
+            else
+            {
+                scanf("%d",&x);
+                for(a=0;a<(1<<m);a++)
+                {
+                    int as;
+                    as=0;
+                    for(j=0;j<m;j++)
+                    {
+                        if(a&(1<<j))as+=maps[x][j];
+                        else as-=maps[x][j];
+                    }
+                    i1=se[a].find(as);
+                    se[a].erase(i1);
+                }
+            }
+            int ans=0;
+            for(a=0;a<(1<<m);a++)
+            {
+                i1=se[a].begin();
+                i2=se[a].end();
+                i2--;
+                ans=max(ans,(*i2)-(*i1));
+            }
+            cout<<ans<<endl;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4667_autoAC.cpp b/HDOJ/4667_autoAC.cpp
new file mode 100644
index 0000000..054d117
--- /dev/null
+++ b/HDOJ/4667_autoAC.cpp
@@ -0,0 +1,116 @@
+#include<stdio.h>
+#include<iostream>
+#include<math.h>
+#include<algorithm>
+#define PI  3.1415926
+using namespace std;
+struct list
+{
+    double x;
+    double y;
+    int r;
+    int pos;
+}point[500001],tu[500001],pp;
+int tops,num;
+int cmp1(struct list a,struct list b)
+{
+    if(a.y!=b.y)return a.y<b.y;
+    else return a.x<b.x;
+}
+int cmp2(struct list a,struct list b)
+{
+    if((a.x-point[0].x)*(b.y-point[0].y)==(b.x-point[0].x)*(a.y-point[0].y))
+        return ((a.x-point[0].x)*(a.x-point[0].x)+(a.y-point[0].y)*(a.y-point[0].y))<((point[0].x-b.x)*(point[0].x-b.x)+(point[0].y-b.y)*(point[0].y-b.y));
+    return (a.x-point[0].x)*(b.y-point[0].y)>(b.x-point[0].x)*(a.y-point[0].y);
+}
+int ts;
+void yuan(int x,int y,int r)
+{
+    pp.r=r;
+    for(int i=0;i<500;i++)
+    {
+        double du;
+        du=(double)2.0*PI*i/500.0;
+        pp.x=1.0*x+1.0*r*cos(du);
+        pp.y=1.0*y+1.0*r*sin(du);
+        pp.pos=ts;
+        point[tops++]=pp;
+    }
+}
+int pan(int z,int b,int a)
+{
+    double x1,y1,x2,y2;
+    if(a<0)return 1;
+    x1=tu[b].x-tu[a].x;
+    y1=tu[b].y-tu[a].y;
+    x2=point[z].x-tu[b].x;
+    y2=point[z].y-tu[b].y;
+    if(x1*y2>x2*y1)return 1;
+    return 0;
+}
+double len(struct list p1,struct list p2)
+{
+    return (double)sqrt(1.0*((p1.x-p2.x)*(p1.x-p2.x)+1.0*(p1.y-p2.y)*(p1.y-p2.y)));
+}
+void init(int n,int m)
+{
+    int i,j;
+    tops=0;
+    int a,b,c;
+    ts=0;
+    for(i=0;i<n;i++)
+    {
+        scanf("%d%d%d",&a,&b,&c);
+        ts++;
+        yuan(a,b,c);
+    }
+    for(i=0;i<m;i++)
+    for(j=0;j<3;j++)
+    {
+        scanf("%lf%lf",&point[tops].x,&point[tops].y);
+        point[tops].pos=0;
+        tops++;
+    }
+}
+void jiantu()
+{
+    int i;
+    sort(point,point+tops,cmp1);
+    sort(point+1,point+tops,cmp2);
+    tu[0]=point[0];
+    tu[1]=point[1];
+    tu[2]=point[2];
+    num=3;
+    for(i=3;i<tops;i++)
+    {
+        while(!pan(i,num-1,num-2))num--;
+        tu[num++]=point[i];
+    }
+}
+void print()
+{
+    double lens;
+    int i;
+    lens=0.0;
+    for(i=0;i<num;i++)
+    {
+        if(tu[i].pos>0&&(tu[i].pos==tu[(i+1)%num].pos))
+        {
+            lens+=1.0*tu[i].r*2*PI/500.0;
+        }
+        else
+        lens+=len(tu[i],tu[(i+1)%num]);
+    }
+    printf("%.5lf\n",lens);
+}
+int main()
+{
+    int n,m;
+    while(~scanf("%d%d",&n,&m))
+    {
+        init(n,m);
+        jiantu();
+        print();
+    }
+    return 0;
+}
diff --git a/HDOJ/4668_autoAC.cpp b/HDOJ/4668_autoAC.cpp
new file mode 100644
index 0000000..6997604
--- /dev/null
+++ b/HDOJ/4668_autoAC.cpp
@@ -0,0 +1,147 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <vector>
+#include <string>
+#include <queue>
+#include <cmath>
+#include <algorithm>
+#define lson step << 1
+#define rson step << 1 | 1
+#pragma comment(linker,"/STACK:102400000,102400000")
+using namespace std;
+typedef long long LL;
+const int N = 5005;
+struct Node {
+    string s;
+    int cnt;
+    Node () {}
+    Node (string _s , int c) :s(_s) , cnt(c) {}
+    string cat () {
+        string t = s;
+        for (int i = 1 ; i < cnt ; i ++)
+            s = s + t;
+        cnt = 1;
+        return s;
+    }
+    LL len () {
+        return (LL)s.size() * cnt;
+    }
+    string prefix (int l) {
+        string str = s;
+        for (int i = 1 ; i < cnt && str.size() < l ; i ++) {
+            str += s;
+        }
+        return str.substr (0 , l);
+    }
+    string suffix (int l) {
+        string str = s;
+        for (int i = 1 ; i < cnt && str.size() < l ; i ++) {
+            str += s;
+        }
+        return str.substr (str.size() - l , l);
+    }
+}a[N];
+char str[N] , pat[N];
+int ne[N] , idx , l , p;
+void get_next (char *s , int l) {
+    ne[0] = -1;
+    int i = 0 , j = -1;
+    while (i < l) {
+        if (j == -1 || s[i] == s[j]) {
+            i ++; j ++;
+            ne[i] = j;
+        }
+        else j = ne[j];
+    }
+}
+void gao (string s , int tot) {
+    if (s == "") return ;
+    if (idx == 0 || s.size() * tot >= p || a[idx - 1].len() >= p) {
+        a[idx ++] = Node (s , tot);
+    }
+    else {
+        a[idx - 1].cat ();
+        a[idx - 1].s += Node (s , tot).cat();
+    }
+} 
+int match (string s , char *t , int p) {
+    int l = s.size() ;
+    int i = 0 , j = 0 , ans = 0;
+    while (i < s.size()) {
+        if (j == - 1 || s[i] == t[j]) {
+            i ++; j ++;
+            if (j == p) {
+                ans ++;
+                j = ne[j];
+            }
+        }
+        else j = ne[j];
+    }
+    return ans;
+} 
+int main () {
+    while (scanf ("%s %s" , str , pat) != EOF) {
+        idx = 0;
+        l = strlen (str);p = strlen (pat);
+        get_next (pat , p);
+        string s = "";
+        int tot = 1;
+        for (int i = 0 ; i < l ; i ++) {
+            if (str[i] == '[') {
+                if (s == "") continue;
+                gao (s , tot);
+                s = ""; tot = 1;
+            }
+            else if (str[i] == ']') {
+                tot = 0;
+                i ++;
+                while (isdigit(str[i]))
+                    tot = tot * 10 + str[i ++] - '0';
+                i --;
+                gao (s , tot);
+                s = ""; tot = 1;
+            }
+            else s += str[i];
+        }
+        gao (s , tot);
+        s = ""; tot = 1;
+        LL ans = 0;
+        for (int i = 0 ; i < idx ; i ++) {
+            if (a[i].len() < p) continue;
+            if (a[i].cnt == 1) ans += match (a[i].s , pat , p);
+            else {
+                int use = min(a[i].cnt , 1 + (p - 1 + (int)a[i].s.size() - 1) / (int)a[i].s.size());
+                string s = "";
+                for (int j = 1 ; j < use ; j ++) {
+                    s += a[i].s;
+                }
+                s = a[i].s + s.substr (0 , min ((int)s.size() , p - 1));
+                int tmp = match (s , pat , p);
+                ans += (LL)tmp * (a[i].cnt - use + 1);
+                if (p) {
+                    s = "";
+                    for (int j = 1 ; j < use ; j ++)
+                        s += a[i].s;
+                    ans += match (s , pat , p);
+                }
+            }
+        }
+        for (int i = 0 ; i < idx - 1 ; i ++) {
+            s = a[i].suffix (min (a[i].len () , p - 1LL));
+            if (a[i + 1].len () < p - 1) {
+                s += a[i + 1].cat ();
+                if (i + 2 < idx) {
+                    s += a[i + 2].prefix (min (a[i + 2].len () , p - 1 - a[i + 2].len ()));
+                }
+            }
+            else {
+                s += a[i + 1].prefix (min (a[i + 1].len () , p - 1LL));
+            }
+            ans += match (s , pat , p);
+        }
+        printf ("%I64d\n" , ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4669_autoAC.cpp b/HDOJ/4669_autoAC.cpp
new file mode 100644
index 0000000..cb71410
--- /dev/null
+++ b/HDOJ/4669_autoAC.cpp
@@ -0,0 +1,73 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <vector>
+#include <string>
+#include <queue>
+#include <cmath>
+#include <algorithm>
+#define lson step << 1
+#define rson step << 1 | 1
+#pragma comment(linker,"/STACK:102400000,102400000")
+using namespace std;
+typedef long long LL;
+const int N = 50005;
+const int M = 205;
+int n , k , a[N] ,l[N];
+int dp[2][M] , prefix[N] , fac[N << 2] , suffix[N];
+int cnt[M];
+int cal (int x) {
+    int cnt = 0;
+    while (x) x /= 10 , cnt ++;
+    return cnt;
+}
+int main () {
+    while (scanf ("%d %d" , &n , &k) != EOF) {
+        fac[0] = 1;
+        for (int i = 1 ; i <= (n << 2) ; i ++)
+            fac[i] = fac[i - 1] * 10 % k;
+        for (int i = 1 ; i <= n ; i ++) {
+            scanf ("%d" , &a[i]);
+            l[i] = cal (a[i]);
+        }
+        for (int i = 0 ; i < 2 ; i ++) {
+            for (int j = 0 ; j < k ; j ++)
+                dp[i][j] = 0;
+        }
+        dp[1][a[1] % k] = 1;
+        LL ans = dp[1][0];
+        for (int i = 2 ; i <= n ; i ++) {
+            for (int j = 0 ; j < k ; j ++)
+                dp[i & 1][j] = 0;
+            dp[i & 1][a[i] % k] ++;
+            for (int j = 0 ; j < k ; j ++) {
+                dp[i & 1][(j * fac[l[i]] + a[i]) %k] += dp[(i - 1) & 1][j];
+            }
+            ans += dp[i & 1][0];
+        }
+        prefix[0] = 0;suffix[n + 1] = 0;
+        for (int i = 1 ; i <= n ; i ++) {
+            prefix[i] = (prefix[i - 1] * fac[l[i]] + a[i]) % k;
+        }
+        int len = 0;
+        for (int i = n ; i >= 1 ; i --) {
+            suffix[i] = (a[i] * fac[len] + suffix[i + 1]) % k;
+            len += l[i];
+        }
+        len = 0;
+        for (int i = 0 ; i < k ; i ++)
+            cnt[i] = 0;
+        for (int i = 1 ; i <= n ; i ++) {
+            cnt[suffix[i]] ++;
+            len += l[i];
+            int p = prefix[i];
+            for (int j = 0 ; j < k ; j ++) {
+                if ((j * fac[len] + p) % k) continue;
+                ans += dp[n & 1][j] - cnt[j];
+            }
+        }
+        printf ("%I64d\n" , ans);
+    }
+    return 0;    
+}
diff --git a/HDOJ/4670_autoAC.cpp b/HDOJ/4670_autoAC.cpp
new file mode 100644
index 0000000..061abc9
--- /dev/null
+++ b/HDOJ/4670_autoAC.cpp
@@ -0,0 +1,171 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <map>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+#define rep(i,s,t) for(int i=s;i<t;i++)
+#define red(i,s,t) for(int i=s-1;i>=t;i--)
+#define ree(i,now) for(int i=head[now];i!=-1;i=edge[i].next)
+#define clr(a,v) memset(a,v,sizeof a)
+const int N=50005;
+const int K=33;
+struct Edge{
+    int v,next;
+}edge[N*2];
+int head[N],e;
+int Num[N][K];
+int son[N],MaxSize;
+int root,all;
+int n,k,a[K],d[K],x,y,cnt;
+ll v[N],dis[N],three[K],mark[N];
+int Ans;
+bool vis[N];
+map<ll,int>mp,mpp;
+inline void Init(){
+    three[0]=1;
+    rep(i,1,K) three[i]=three[i-1]*3;
+}
+inline int getPos(ll v,int x){
+    return v%three[x+1]/three[x];
+}
+inline ll get(ll val,int *x){
+    ll ans=0;
+    rep(i,0,k) ans+=((getPos(val,i)+x[i])%3)*three[i];
+    return ans;
+}
+inline void getCh(ll b,int i){
+    bool ok=1;
+    mark[i]=0;
+    if(b==0)return;
+    rep(j,0,k){
+        Num[i][j]=0;
+        while(b>1 && b%a[j]==0){
+            Num[i][j]++;
+            b/=a[j];
+        }
+        Num[i][j]%=3;
+        mark[i]+=three[j]*Num[i][j];
+        if(Num[i][j]!=0) ok=0;
+    }
+    if(ok) Ans++;
+}
+inline void addEdge(int u,int v){
+    edge[e].v=v;
+    edge[e].next=head[u];
+    head[u]=e++;
+}
+inline void In(){
+    scanf("%d",&k);
+    rep(i,0,k) scanf("%d",&a[i]);
+    rep(i,1,n+1){
+        scanf("%I64d",&v[i]);
+        getCh(v[i],i);
+    }
+    clr(head,-1),e=0;
+    rep(i,1,n){
+        scanf("%d%d",&x,&y);
+        addEdge(x,y);addEdge(y,x);
+    }
+    clr(vis,0);
+}
+inline void dfs_Size(int now,int pre){
+    all++;
+    ree(i,now){
+        int nxt=edge[i].v;
+        if(!vis[nxt] && nxt!=pre) dfs_Size(nxt,now);
+    }
+}
+inline void dfs_Root(int now,int pre){
+    int Max=0;
+    son[now]=0;
+    ree(i,now){
+        int nxt=edge[i].v;
+        if(!vis[nxt] && pre!=nxt){
+            dfs_Root(nxt,now);
+            son[now]+=son[nxt]+1;
+            if(son[nxt]+1>Max) Max=son[nxt]+1;
+        }
+    }
+    int res=all-son[now]-1;
+    if(Max<res) Max=res;
+    if(Max<MaxSize){
+        MaxSize=Max;root=now;
+    }
+}
+inline ll Val(int *c){
+    ll ans=0;
+    rep(j,0,k) ans+=c[j]*three[j];
+    return ans;
+}
+inline ll Transform(ll a,ll b){
+    ll ans=0;
+    rep(j,0,k) ans+=(getPos(a,j)+getPos(b,j))%3*three[j];
+    return ans;
+}
+inline void dfs_Dis(int now,int pre,ll val){
+    dis[cnt++]=val;
+    ree(i,now){
+        int nxt=edge[i].v;
+        if(!vis[nxt] && nxt!=pre){
+            dfs_Dis(nxt,now,Transform(val,mark[nxt]));
+        }
+    }
+}
+inline ll Suit(ll v){
+    ll ans=0;
+    rep(i,0,k){
+        int x=getPos(v,i);
+        int y=(3-x)%3;
+        ans+=three[i]*y;
+    }
+    return ans;
+}
+inline void Work(int now){
+    all=0;
+    dfs_Size(now,-1);
+    MaxSize=n+10;
+    dfs_Root(now,-1);
+    vis[root]=1;
+    mp.clear();
+    ree(i,root){
+        int nxt=edge[i].v;cnt=0;
+        if(vis[nxt]) continue;
+        dfs_Dis(nxt,root,mark[nxt]);
+        rep(j,0,cnt){
+            int vv=mp[Suit(dis[j])];
+            if(vv) Ans+=vv;
+        }
+        rep(j,0,cnt){
+            ll p=get(dis[j],Num[root]);
+            if(p==0) Ans++;
+            mp[p]++;
+        }
+    }
+    ree(i,root){
+        int nxt=edge[i].v;
+        if(!vis[nxt]){
+            Work(nxt);
+        }
+    }
+}
+inline void app(){
+    int a[]={2,3,5,7,11,13,17,19,23,29};
+    rep(j,0,10){
+        printf("3000 10 2 3 5 7 11 13 17 19 23 29\n");
+        rep(i,0,3000) printf("%d ",a[rand()%10]);
+        rep(i,1,3000) printf("%d 1\n",i+1);
+    }
+}
+int main(){
+    Init();
+    while(~scanf("%d",&n)){
+        Ans=0;
+        In();
+        Work(1);
+        printf("%d\n",Ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/4671_autoAC.cpp b/HDOJ/4671_autoAC.cpp
new file mode 100644
index 0000000..b226398
--- /dev/null
+++ b/HDOJ/4671_autoAC.cpp
@@ -0,0 +1,42 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int V = 105;
+int n, m, ans[V][V];
+bool vis[V][V];
+int main() {
+    int i, j, k;
+    while(~scanf("%d%d", &n, &m)) {
+        memset(ans, 0, sizeof(ans));
+        memset(vis, false, sizeof(vis));
+        for(i = 0, j = 1; i < m; ++i) {
+            ans[i][0] = j;
+            vis[i][j] = true;
+            j = j == n ? 1 : j + 1;
+        }
+        for(i = 0; i < m; ++i) {
+            if(ans[i][1] != 0)
+                continue;
+            int now = m % n + 1;
+            for(j = i; j < m; j += n) {
+                if(now == ans[j][0])
+                    now = now == n ? 1 : now + 1;
+                ans[j][1] = now;
+                vis[j][now] = true;
+                now = now == n ? 1 : now + 1;
+            }
+        }
+        for(i = 0; i < m; ++i)
+            for(j = 2, k = 1; j < n; ++j) {
+                while(vis[i][k])
+                    k++;
+                ans[i][j] = k++;
+            }
+        for(i = 0; i < m; ++i) {
+            for(j = 0; j < n - 1; ++j)
+                printf("%d ", ans[i][j]);
+            printf("%d\n", ans[i][n - 1]);
+        }
+    }
+}
diff --git a/HDOJ/4672_autoAC.cpp b/HDOJ/4672_autoAC.cpp
new file mode 100644
index 0000000..e816a14
--- /dev/null
+++ b/HDOJ/4672_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+#include<cmath>
+#include<cstring>
+#define I(x) scanf("%d",&x)
+using namespace std;
+int sg[10001],a[100001];
+char x[20],y[20];
+int main(){
+    int n,m,i,j,MIN,b,t,ans;
+    while(scanf("%d%d%s%s",&n,&m,x,y)!=EOF){
+        memset(sg,-1,sizeof(sg));
+        sg[0]=0;MIN=1e9;
+        bool flag=0;
+        for(i=0;i<n;i++) I(a[i]);
+        for(i=0;i<m;i++){
+            I(b);
+            MIN=min(MIN,b);
+            for(j=0;j+b<=10000;j++)
+                if(sg[j]>=0)
+                    sg[j+b]=max(sg[b+j],sg[j]+1);
+        }
+        ans=0;
+        for(i=0;i<n;i++){
+            t=a[i];
+            if(t<=10000){
+                if(sg[t]<0) flag=1;
+                else ans^=sg[t];
+            }
+            else{
+                t=(t-10000+MIN)%MIN+10000-MIN;
+                if(sg[t]<0) flag=1;
+                else ans^=sg[t]+(a[i]-t)/MIN;
+            }
+        }
+        if(!flag&&ans) puts(x);
+        else puts(y);
+    }
+    return 0;
+}
diff --git a/HDOJ/4674_autoAC.cpp b/HDOJ/4674_autoAC.cpp
new file mode 100644
index 0000000..3c17029
--- /dev/null
+++ b/HDOJ/4674_autoAC.cpp
@@ -0,0 +1,153 @@
+#pragma comment(linker, "/STACK:65536000")
+#include <iostream>
+#include <stdio.h>
+#include <string.h>
+#include <vector>
+#include <map>
+#include <math.h>
+#include <queue>
+#include <set>
+#include <algorithm>
+#define clr(a,b) memset(a,b,sizeof(a))
+#define mpr(a,b) make_pair(a,b)
+#define ll long long
+#define eps 1e-6
+using namespace std;
+const int N=100005,M=300005;
+int n,m,q,eid,id,now,top;
+int head[N],ed[M],nxt[M];
+int dfn[N],low[N],gid[N];
+int sta[N],block[N];
+vector<pair<int,int> >gra[N],qu[N];
+int f[N],vis[N],come[N],out[N],fa[N];
+int tlca[3*N],pt[3*N][2];
+int aa[N],bb[N],cc[N];
+int findfa(int s){return s==fa[s]?s:fa[s]=findfa(fa[s]);}
+void addedge(int s,int e){
+     ed[eid]=e;nxt[eid]=head[s];head[s]=eid++;
+}
+void tarjan(int s,int f,int b){
+     dfn[s]=low[s]=++now;
+     sta[top++]=s;block[s]=b;
+     for(int i=head[s];~i;i=nxt[i]){
+          int e=ed[i];
+          if(i==f||i==(f^1))continue;
+          if(!dfn[e]){
+               tarjan(e,i,b);
+               low[s]=min(low[s],low[e]);
+          }else
+               low[s]=min(low[s],dfn[e]);
+     }
+     if(low[s]==dfn[s]){
+          id++;
+          while(top){
+               int k=sta[--top];
+               gid[k]=id;
+               if(k==s)return ;
+          }
+     }
+}
+void lca(int s,int f){
+     fa[s]=s;
+     for(int i=0;i<(int)gra[s].size();i++){
+          int e=gra[s][i].first;
+          if(e==f)continue;
+          lca(e,s);
+          fa[findfa(e)]=s;
+     }
+     vis[s]=1;
+     for(int i=0;i<(int)qu[s].size();i++){
+          int e=qu[s][i].first,d=qu[s][i].second;
+          if(vis[e])tlca[d]=findfa(e);
+     }
+}
+void dfs(int s,int f){
+     for(int i=0;i<(int)qu[s].size();i++){
+          int d=qu[s][i].second;
+          int k=(tlca[d]==s)?-1:out[tlca[d]];
+          if(~pt[d][0])pt[d][1]=k;
+          else pt[d][0]=k;
+     }
+     for(int i=0;i<(int)gra[s].size();i++){
+          int e=gra[s][i].first,g=gra[s][i].second;
+          if(e==f){
+               come[s]=g;continue;
+          }
+          out[s]=g;
+          dfs(e,s);
+     }
+}
+int main(){
+     while(~scanf("%d%d",&n,&m)){
+          eid=0;clr(head,-1);
+          for(int i=0;i<m;i++){
+               int a,b;scanf("%d%d",&a,&b);
+               addedge(a,b);addedge(b,a);
+          }
+          id=now=top=0;
+          for(int i=1;i<=n;i++)dfn[i]=0;
+          int cnt=0;
+          for(int i=1;i<=n;i++)
+               if(!dfn[i])tarjan(i,-1,++cnt);
+          for(int i=1;i<=id;i++){
+               gra[i].clear();qu[i].clear();
+          }
+          for(int i=1;i<=n;i++)
+               for(int j=head[i];~j;j=nxt[j]){
+                    int s=gid[i],e=gid[ed[j]];
+                    if(s!=e)gra[s].push_back(mpr(e,i));
+               }
+          clr(f,0);
+          scanf("%d",&q);
+          for(int i=0;i<q;i++){
+               int a,b,c;scanf("%d%d%d",&a,&b,&c);
+               if(block[a]!=block[b]){f[i]=1;continue;}
+               if(block[b]!=block[c]){f[i]=1;continue;}
+               if(block[a]!=block[c]){f[i]=1;continue;}
+               if(a==b&&a!=c){f[i]=1;continue;}
+               int s=gid[a],e=gid[b],k=gid[c];
+               qu[s].push_back(mpr(e,i*3));
+               qu[e].push_back(mpr(s,i*3));
+               qu[s].push_back(mpr(k,i*3+1));
+               qu[k].push_back(mpr(s,i*3+1));
+               qu[e].push_back(mpr(k,i*3+2));
+               qu[k].push_back(mpr(e,i*3+2));
+               aa[i]=a;bb[i]=b;cc[i]=c;
+          }
+          for(int i=1;i<=id;i++)vis[i]=0;
+          for(int i=0;i<q*3;i++)
+               pt[i][0]=pt[i][1]=-1;
+          for(int i=1;i<=id;i++)
+               if(!vis[i]){
+                    lca(i,-1);
+                    dfs(i,-1);
+               }
+          for(int i=0;i<q;i++){
+               if(f[i]){
+                    puts("No");continue;
+               }
+               if(gid[aa[i]]==gid[bb[i]]){
+                    if(gid[cc[i]]==gid[aa[i]])puts("Yes");
+                    else puts("No");
+               }
+               else if(gid[cc[i]]==tlca[i*3]){
+                    if(pt[i*3][1]==-1){
+                         int k=(gid[aa[i]]==gid[cc[i]])?aa[i]:bb[i];
+                         if(k==pt[i*3][0]&&cc[i]!=k) puts("No");
+                         else puts("Yes");
+                    }else{
+                         if(pt[i*3][0]==pt[i*3][1]&&cc[i]!=pt[i*3][0]) puts("No");
+                         else puts("Yes");
+                    }
+               }else if(tlca[i*3+1]==gid[cc[i]]&&tlca[i*3+2]==tlca[i*3]){
+                    int k=(pt[i*3+1][0]==-1)?aa[i]:pt[i*3+1][0];
+                    if(come[gid[cc[i]]]==k&&k!=cc[i])puts("No");
+                    else puts("Yes");
+               }else if(tlca[i*3+2]==gid[cc[i]]&&tlca[i*3+1]==tlca[i*3]){
+                    int k=(pt[i*3+2][0]==-1)?bb[i]:pt[i*3+2][0];
+                    if(come[gid[cc[i]]]==k&&k!=cc[i])puts("No");
+                    else puts("Yes");
+               }else puts("No");
+          }
+     }
+}
diff --git a/HDOJ/4675_autoAC.cpp b/HDOJ/4675_autoAC.cpp
new file mode 100644
index 0000000..ce17e83
--- /dev/null
+++ b/HDOJ/4675_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+using namespace std;
+const int MOD = 1e9+7;
+long long pow_m(long long a,long long n)
+{
+    long long ret = 1;
+    long long tmp = a%MOD;
+    while(n)
+    {
+        if(n&1)
+        {
+            ret *= tmp;
+            ret %= MOD;
+        }
+        tmp *= tmp;
+        tmp %= MOD;
+        n >>= 1;
+    }
+    return ret;
+}
+long long C[300010];
+long long inv(long long a,long long m)
+{
+    if(a == 1)return 1;
+    return inv(m%a,m)*(m-m/a)%m;
+}
+long long ans[300010];
+int a[300010];
+int num[300010];
+int b[300010];
+int main()
+{
+    int N,M,K;
+    while(scanf("%d%d%d",&N,&M,&K) == 3)
+    {
+        memset(num,0,sizeof(num));
+        for(int i = 1;i <= N;i++)
+        {
+            scanf("%d",&a[i]);
+            num[a[i]]++;
+        }
+        C[N-K] = 1;
+        for(int i = N-K+1;i <= N;i++)
+        {
+            C[i] = C[i-1]*i%MOD*inv(i-(N-K),MOD)%MOD;
+        }
+        for(int i = M;i>= 1;i--)
+        {
+            int cnt = 0;
+            long long ss = 0;
+            for(int j = 1; j*i <= M;j++)
+            {
+                cnt += num[i*j];
+                if(j > 1)ss = (ss + ans[i*j])%MOD;
+            }
+            int t = M/i;
+            if(t == 1)
+            {
+                if(cnt == N-K)ans[i] = 1;
+                else ans[i] = 0;
+                continue;
+            }
+            if(cnt < N-K)
+            {
+                ans[i] = 0;
+                continue;
+            }
+            long long tmp = 1;
+            tmp =(tmp*C[cnt])%MOD;
+            tmp = ( tmp * pow_m(t-1,cnt-(N-K)) )%MOD;
+            tmp = (tmp * pow_m(t,N-cnt));
+            ans[i] = (tmp - ss + MOD)%MOD;
+        }
+        for(int i = 1;i <= M;i++)
+        {
+            printf("%I64d",ans[i]);
+            if(i < M)printf(" ");
+            else printf("\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4676_autoAC.cpp b/HDOJ/4676_autoAC.cpp
new file mode 100644
index 0000000..8e9221a
--- /dev/null
+++ b/HDOJ/4676_autoAC.cpp
@@ -0,0 +1,102 @@
+#include<cstdio>
+#include<cstring>
+#include<climits>
+#include<string>
+#include<algorithm>
+#include<cmath>
+#include<iostream>
+#include<queue>
+#include<vector>
+#include<stack>
+#include<map>
+#include<set>
+#include<stdlib.h>
+using namespace std;
+typedef long long ll;
+const int MAXN = 20007;
+vector<int> divisor[MAXN];
+int f[MAXN], a[MAXN], L[MAXN], R[MAXN], cnt[MAXN], qid[MAXN], M;
+ll ans[MAXN];
+void getdivisor() {
+    int i, j;
+    for(i = 1; i < MAXN; i++) for(j = i; j < MAXN; j += i) divisor[j].push_back(i);
+}
+void getf() {
+    for(int i = 1; i < MAXN; i++) {
+        int t = i;
+        int j, sz = divisor[i].size();
+        for(j = 0; j < sz; j++) t -= f[divisor[i][j]];
+        f[i] = t;
+    }
+}
+int qcmp(int x, int y) {
+    int px = L[x] / M; 
+    int py = L[y] / M;
+    if(px != py) return px < py;
+    return R[x] < R[y];
+}
+ll erase(int x) {
+    int i, y, sz = divisor[x].size();
+    ll ret = 0;
+    for(i = 0; i < sz; i++) {
+        y = divisor[x][i];
+        ret += 1LL*f[y]*(--cnt[y]);
+    }
+    return ret;
+}
+ll insert(int x) {
+    int i, y, sz = divisor[x].size();
+    ll ret = 0;
+    for(i = 0; i < sz; i++) {
+        y = divisor[x][i];
+        ret += 1LL*f[y]*(cnt[y]++);
+    }
+    return ret;
+}
+void solve(int n, int q) {
+    int i;
+    for(i = 1; i <= q; i++) qid[i] = i;
+    M = (int)sqrt(n*1.0);
+    sort(qid+1, qid+1+q, qcmp);
+    memset(cnt, 0, sizeof(cnt));
+    int l = 0, r = 0;
+    ll now = 0;
+    for(i = 1; i <= q; i++) {
+        int id = qid[i];
+        int nl = L[id], nr = R[id];
+        while(l < nl) {
+            now -= erase(a[l]);
+            l++;
+        }
+        while(l > nl) {
+            l--;
+            now += insert(a[l]);
+        }
+        while(r < nr) {
+            r++;
+            now += insert(a[r]);
+        }
+        while(r > nr) {
+            now -= erase(a[r]);
+            r--;
+        }
+        ans[id] = now;
+    }
+}
+int main() {
+    getdivisor();
+    getf();
+    int T, id = 0;
+    scanf("%d", &T);
+    while(T--) {
+        int i, n, q;
+        scanf("%d", &n);
+        for(i = 1; i <= n; i++) scanf("%d", a+i);
+        scanf("%d", &q);
+        for(i = 1; i <= q; i++) scanf("%d%d", L+i, R+i);
+        solve(n, q);
+        printf("Case #%d:\n", ++id);
+        for(i = 1; i <= q; i++) printf("%I64d\n", ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4677_autoAC.cpp b/HDOJ/4677_autoAC.cpp
new file mode 100644
index 0000000..ffb4aba
--- /dev/null
+++ b/HDOJ/4677_autoAC.cpp
@@ -0,0 +1,122 @@
+#include <iostream>
+#include <cstdio>
+#include <vector>
+#include <cmath>
+#include <algorithm>
+#include <cstring>
+using namespace std;
+#define N 30050
+struct Q
+{
+    int r,idx;
+    Q(int _r=0,int _idx=0):r(_r),idx(_idx){}
+};
+vector<Q>que[N];
+vector<int>edge[N];
+int fa[N][200],scc[200],rr[200];
+int ta[N],first[N],ans[N];
+int n,m,tot,every;
+int find(int i,int pos)
+{
+    return fa[i][pos]==i?i:fa[i][pos]=find(fa[i][pos],pos);
+}
+void init()
+{
+    for(int i=0;i<=n;++i)
+        edge[i].clear(),que[i].clear();
+    memset(scc,0,sizeof(scc));
+    every=tot=sqrt(n*1.0);
+    if(n*n!=tot) tot++;
+    for(int i=0;;++i)
+    {
+        rr[i]=i*every;
+        if(i*every>=n) break;
+    }
+    for(int i=0;i<=tot;++i)
+        for(int j=0;j<=n;++j)
+        fa[j][i]=j;
+    memset(first,-1,sizeof(first));
+}
+int main ()
+{
+    int T;scanf("%d",&T);
+    for(int kk=1;kk<=T;++kk)
+    {
+        scanf("%d%d",&n,&m);
+        init();
+        for(int i=1,u,v;i<=m;++i)
+        {
+            scanf("%d%d",&u,&v);
+            if(u==v) continue;
+            edge[u].push_back(v);
+            edge[v].push_back(u);
+        }
+        int q;scanf("%d",&q);
+        for(int i=1,u,v;i<=q;++i)
+        {
+            scanf("%d%d",&u,&v);
+            que[u].push_back(Q(v,i));
+        }
+        int run_clock=0;
+        for(int u=n;u>=1;--u)
+        {
+            for(int j=1;j<=tot;++j)
+            {
+                if(u>rr[j]) continue;
+                scc[j]++;
+                int inc=0;
+                for(int i=0;i<edge[u].size();++i)
+                {
+                    int v=edge[u][i];
+                    if(u<v&&v<=rr[j])
+                    {
+                        int u1=find(u,j);
+                        int v1=find(v,j);
+                        if(u1!=v1)
+                        {
+                            inc++;
+                            fa[v1][j]=u1;
+                        }
+                    }
+                }
+                scc[j]-=inc;
+            }
+            for(int z=0;z<que[u].size();++z)
+            {
+                run_clock++;
+                int right=que[u][z].r;
+                int pos;int inc=0;
+                for(pos=0;pos<tot;++pos)
+                    if(rr[pos]<right&&right<=rr[pos+1]) break;
+                for(int i=max(u+1,rr[pos]+1);i<=right;++i)
+                {
+                    if(first[i]!=run_clock)
+                    {
+                        first[i]=run_clock;
+                        fa[i][tot+1]=i;
+                    }
+                    for(int j=0;j<edge[i].size();++j)
+                        if(u<=edge[i][j]&&edge[i][j]<i)
+                        {
+                            int v1=find(edge[i][j],pos);
+                            if(first[v1]!=run_clock)
+                            {
+                                first[v1]=run_clock;
+                                fa[v1][tot+1]=v1;
+                            }
+                            if(find(i,tot+1)!=find(v1,tot+1))
+                            {
+                                fa[find(v1,tot+1)][tot+1]=find(i,tot+1);
+                                inc++;
+                            }
+                        }
+                }
+                ans[que[u][z].idx]=scc[pos]+right-max(rr[pos],u-1)-inc;
+            }
+        }
+        printf("Case #%d:\n",kk);
+        for(int i=1;i<=q;++i)
+            printf("%d\n",ans[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4678_autoAC.cpp b/HDOJ/4678_autoAC.cpp
new file mode 100644
index 0000000..f10d31d
--- /dev/null
+++ b/HDOJ/4678_autoAC.cpp
@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <stdlib.h>
+#include <vector>
+#include <set>
+#include <queue>
+#include <stack>
+#define loop(s,i,n) for(i = s;i < n;i++)
+#define cl(a,b) memset(a,b,sizeof(a))
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+using namespace std;
+int map[1005][1005];
+int vis[1005][1005];
+int n,m,k;
+int num,odd,uod;
+int to[8][2] = {{0,1},{0,-1},{1,0},{1,-1},{1,1},{-1,-1},{-1,0,},{-1,1}};
+int judge(int a,int b)
+{
+    if(a >= 0 && a < n && b>= 0 &&b < m)
+    return 1;
+    return 0;
+}
+void paint(int x,int y)
+{
+    int i,j;
+    for(i = 0;i < 8;i++)
+    {
+        int a,b;
+        a = x+to[i][0];
+        b = y+to[i][1];
+        if(judge(a,b) && !vis[a][b])
+        map[a][b]++;
+    }
+}
+void dfs(int x,int y)
+{
+    if(map[x][y] == -1 || vis[x][y])
+    return;
+    vis[x][y] = 1;
+    int i;
+    for(i = 0;i < 8;i++)
+    {
+        int a,b;
+        a = x+to[i][0];
+        b = y+to[i][1];
+        if(judge(a,b)&&vis[a][b] == 0)
+        {
+            if(map[a][b] > 0)
+            num++,vis[a][b] = 1;
+            else if(map[a][b] == 0)
+            dfs(a,b);
+        }
+    }
+    return;
+}
+int main()
+{
+    int t,i,j,x,y;
+    scanf("%d",&t);
+    int icase = 0;
+    while(t--)
+    {
+        scanf("%d %d %d",&n,&m,&k);
+        loop(0,i,n)
+        {
+            loop(0,j,m)
+            map[i][j] = vis[i][j] = 0;
+        }
+        while(k--)
+        {
+            scanf("%d %d",&x,&y);
+            map[x][y] = -1;
+            vis[x][y] = 1;
+            paint(x,y);
+        }
+        odd = uod = 0;
+        loop(0,i,n)
+        {
+            loop(0,j,m)
+            {
+                num = 0;
+                if(map[i][j] == 0 && !vis[i][j])
+                {
+                    dfs(i,j);
+                    if(num%2)
+                    odd++;
+                    else
+                    uod++;
+                }
+            }
+        }
+        loop(0,i,n)
+        {
+            loop(0,j,m)
+            {
+                if(!vis[i][j] && map[i][j] > 0)
+                uod++;
+            }
+        }
+        printf("Case #%d: ",++icase);
+        if(uod%2 || odd%2)
+        puts("Xiemao");
+        else
+        puts("Fanglaoshi");
+    }
+    return 0;
+}
diff --git a/HDOJ/4679_autoAC.cpp b/HDOJ/4679_autoAC.cpp
new file mode 100644
index 0000000..81dd0b4
--- /dev/null
+++ b/HDOJ/4679_autoAC.cpp
@@ -0,0 +1,177 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<queue>
+using namespace std;
+#define maxn 100011
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+#define INF 99999999
+struct list
+{
+    int u,v,w,number;
+    int next;
+} node[maxn*4];
+struct list2
+{
+    int point;
+    int len;
+}no[4][maxn],pp;
+int head[maxn*10];
+int low[maxn*2];
+int f[maxn];
+int ipf[maxn][2];
+int ips[maxn][2];
+int h[maxn];
+int tops,maxx,ipos,n;
+void add(int u,int v,int w,int number)
+{
+    node[tops].u=u;
+    node[tops].v=v;
+    node[tops].w=w;
+    node[tops].number=number;
+    node[tops].next=head[u];
+    head[u]=tops++;
+}
+void init()
+{
+    memset(head,-1,sizeof(head));
+    memset(f,0,sizeof(f));
+    memset(h,0,sizeof(h));
+    memset(ipf,0,sizeof(ipf));
+    memset(low,0,sizeof(low));
+    memset(ips,0,sizeof(ips));
+    tops=0;
+    maxx=INF;
+    ipos=maxn+10;
+    scanf("%d",&n);
+    for(int i=0;i<=n;i++)
+    {
+        no[1][i].len=no[2][i].len=no[3][i].len=0;
+        no[1][i].point=no[2][i].point=no[3][i].point=0;
+    }
+    int a,b,c;
+    for(int i=1; i<n; i++)
+    {
+        scanf("%d%d%d",&a,&b,&c);
+        add(a,b,c,i);
+        add(b,a,c,i);
+    }
+}
+int dfs(int x,int pre)
+{
+    int ts,tt;
+    ts=0;
+    f[x]=0;
+    for(int i=head[x]; i!=-1; i=node[i].next)
+    {
+        int y=node[i].v;
+        if(y==pre)continue;
+        tt=dfs(y,x)+1;
+        ts=max(tt,ts);
+        if(f[y]>=ipf[x][0])
+        {
+            ipf[x][1]=ipf[x][0];
+            ipf[x][0]=f[y];
+            ips[x][1]=ips[x][0]=y;
+        }
+        else if(f[y]>=ipf[x][1])
+        {
+            ipf[x][1]=f[y];
+        }
+        f[x]=max(f[x],f[y]);
+        pp.point=y;
+        pp.len=tt;
+        for(int j=1; j<=3; j++)
+            if(no[j][x].len<=tt)
+            {
+                for(int k=3; k>=j+1; k--)
+                {
+                    no[k][x]=no[k-1][x];
+                }
+                no[j][x]=pp;
+                break;
+            }
+    }
+    int ds=no[1][x].len+no[2][x].len;
+    f[x]=max(f[x],ds);
+    return ts;
+}
+int chu(int pre,int x,int y)
+{
+    int s1,s2,s3,s4;
+    int leap=0;
+    s1=s2=s3=s4=0;
+    if(ips[x][0]!=y)s1=ipf[x][0];
+    else s1=ipf[x][1];
+    if(no[1][x].point!=y)s2=no[1][x].len,leap++;
+    if(no[2][x].point!=y)s2+=no[2][x].len,leap++;
+    if(no[3][x].point!=y&&leap==1)s2+=no[3][x].len,leap++;
+    s3=h[x];
+    if(no[1][pre].point!=x)s4=no[1][pre].len;
+    else s4=no[2][pre].len;
+    s4=max(s4,low[pre]);
+    if(no[1][x].point!=y)s4+=no[1][x].len;
+    else s4+=no[2][x].len;
+    if(pre!=0)s4++;
+    return max(max(s1,s2),max(s3,s4));
+}
+void spfa(int x,int pre)
+{
+    int visit[maxn];
+    memset(visit,0,sizeof(visit));
+    queue<int>q;
+    queue<int>qp;
+    q.push(x);
+    qp.push(pre);
+    visit[x]=1;
+    while(!q.empty())
+    {
+        x=q.front();
+        q.pop();
+        pre=qp.front();
+        qp.pop();
+        for(int i=head[x]; i!=-1; i=node[i].next)
+        {
+            int y=node[i].v;
+            if(y==pre)continue;
+            h[y]=chu(pre,x,y);
+            int ss=max(h[y],f[y])*node[i].w;
+            if(ss<maxx)
+            {
+                maxx=ss;
+                ipos=node[i].number;
+            }
+            else if(ss==maxx)ipos=min(ipos,node[i].number);
+            q.push(y);
+            qp.push(x);
+        }
+    }
+}
+void panlow(int x,int pre)
+{
+    for(int i=head[x]; i!=-1; i=node[i].next)
+    {
+        int y=node[i].v;
+        if(y==pre)continue;
+        if(y!=no[1][x].point)
+        {
+            low[y]=max(no[1][x].len+1,low[x]+1);
+        }
+        else low[y]=max(no[2][x].len+1,low[x]+1);
+        panlow(y,x);
+    }
+}
+int main()
+{
+    int t,T;
+    scanf("%d",&T);
+    for(t=1; t<=T; t++)
+    {
+        init();
+        if(dfs(1,0));
+        panlow(1,0);
+        spfa(1,0);
+        printf("Case #%d: %d\n",t,ipos);
+    }
+    return 0;
+}
diff --git a/HDOJ/4680_autoAC.cpp b/HDOJ/4680_autoAC.cpp
new file mode 100644
index 0000000..29511dc
--- /dev/null
+++ b/HDOJ/4680_autoAC.cpp
@@ -0,0 +1,336 @@
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+#define L x->c[0]
+#define R x->c[1]
+#define KT root->c[1]->c[0]
+using namespace std;
+const int maxn = 300010;
+const int inf = 1000000007;
+int n,Type;
+int gcd(int a,int b)
+{
+    if(a<0||a>=inf) return b;
+    if(b<0||b>=inf) return a;
+    return b == 0?a:gcd(b,a%b);
+}
+struct Node
+{
+    struct Node *c[2],*fa;
+    int id,size,g,val,who;
+}S[maxn],*null = &S[0];
+Node* Q[maxn];
+Node* ID[maxn];
+int scnt;
+struct snode
+{
+    int type;
+    Node*root;
+    inline Node *NewNode(int value,Node *p)
+    {
+        Node *e = S+(++scnt);
+        e->val = value;
+        e->id = scnt;
+        e->size = 1;
+        e->fa = p;
+        e->g = value;
+        e->c[0] = e->c[1] = null;
+        ID[scnt] = e;
+        return e;
+    }
+    inline void Update(Node *p)
+    {
+        p->size = p->c[0]->size+p->c[1]->size+1;
+        p->g = gcd(p->c[0]->g,p->c[1]->g);
+        p->g = gcd(p->val,p->g);
+    }
+    inline void Rotate(Node *x,int k)
+    {
+        Node *y=x->fa;
+        y->c[k]=x->c[!k];
+        y->c[k]->fa=y;
+        x->fa=y->fa;
+        if(y->fa->c[0]==y)
+            y->fa->c[0]=x;
+        else
+            y->fa->c[1]=x;
+        y->fa=x;
+        x->c[!k]=y;
+        Update(y);
+        Update(x);
+        if(root==y) root=x;
+    }
+    inline void Splay(Node *x,Node *y)
+    {
+        while(x->fa!=y)
+        {
+            if(x->fa->fa==y)
+            {
+                if(x->fa->c[0]==x)
+                    Rotate(x,0);
+                else
+                    Rotate(x,1);
+            }
+            else if(x->fa->fa->c[0]==x->fa)
+            {
+                if(x->fa->c[0]==x)
+                    Rotate(x->fa,0),Rotate(x,0);
+                else
+                    Rotate(x,1),Rotate(x,0);
+            }
+            else
+            {
+                if(x->fa->c[1]==x)
+                    Rotate(x->fa,1),Rotate(x,1);
+                else
+                    Rotate(x,0),Rotate(x,1);
+            }
+        }
+        Update(x);
+    }
+    inline void Select(int k,Node *y)
+    {
+        Node *x=root;
+        while(k!=x->c[0]->size+1)
+        {
+            if(k<=x->c[0]->size)
+                x=x->c[0];
+            else
+            {
+                k-=x->c[0]->size+1;
+                x=x->c[1];
+            }
+        }
+        Splay(x,y);
+    }
+    inline void Init(int v)
+    {
+        root = NewNode(v,null);
+        type = ++Type;
+        root->who = type;
+    }
+    inline void Delete(Node *x)
+    {
+        Splay(x,null);
+        Node *t = root;
+        if(t->c[1]!=null)
+        {
+            root = t->c[1];
+            Select(1,null);
+            root->c[0] = t->c[0];
+            if(root->c[0]!=null)
+                root->c[0]->fa = root;
+        }
+        else
+        {
+            root = t->c[0];
+        }
+        root->fa = null;
+        if(root!=null)Update(root);
+    }
+    inline void Insert(Node *x)
+    {
+        x->c[0] = x->c[1] = null;
+        insert(root,x);
+        Splay(x,null);
+        x->who = type;
+    }
+    inline void insert(Node* &x,Node* y)
+    {
+        if(x == null)
+        {
+            x = y;
+            return;
+        }
+        if(y->val<=x->val)
+        {
+            insert(x->c[0],y);
+            x->c[0]->fa = x;
+        }
+        else
+        {
+            insert(x->c[1],y);
+            x->c[1]->fa = x;
+        }
+        Update(x);
+    }
+    inline void Change(Node* tmp,int v)
+    {
+        Delete(tmp);
+        tmp->val = v;
+        Insert(tmp);
+    }
+    inline Node *FindSucc(Node *x,int v,int opt)
+    {
+        if(x == null)return x;
+        if(x->val == v&&opt)return x;
+        else if(x->val>v)
+        {
+            Node *tmp = FindSucc(x->c[0],v,opt);
+            return tmp == null?x:tmp;
+        }
+        else
+        {
+            return FindSucc(x->c[1],v,opt);
+        }
+    }
+    inline Node *FindSucc(int v,int opt)
+    {
+        Node *tmp = FindSucc(root,v,opt);
+        Splay(tmp,null);
+        return tmp;
+    }
+    inline Node *FindPre(Node *x,int v)
+    {
+        if(x == null)return x;
+        if(x->val<v)
+        {
+            Node *tmp = FindPre(x->c[1],v);
+            return tmp == null?x:tmp;
+        }
+        else return FindPre(x->c[0],v);
+    }
+    inline Node *FindPre(int v)
+    {
+        Node* tmp = FindPre(root,v);
+        Splay(tmp,null);
+        return tmp;
+    }
+    inline void Merge(snode &tree)
+    {
+        int head,tail;
+        head = tail = 0;
+        tree.Select(1,null);
+        tree.Select(tree.root->size,tree.root);
+        Q[++tail] = tree.KT;
+        while(head<tail)
+        {
+            Node* f = Q[++head];
+            if(f->c[0]!=null)Q[++tail] = f->c[0];
+            if(f->c[1]!=null)Q[++tail] = f->c[1];
+            Insert(f);
+            f->who = type;
+        }
+        tree.KT = null;
+        tree.Update(tree.root->c[1]);
+        tree.Update(tree.root);
+    }
+    inline int SolveTri()
+    {
+        if(root->size<=4)return root->size-2;
+        Select(2,null);
+        int a = root->val;
+        Select(3,null);
+        int b = root->val;
+        int ans = 2;
+        while(true)
+        {
+            if(a+b>=inf)break;
+            int c = FindSucc(a+b,1)->val;
+            if(c>=inf||c == -1)break;
+            a = b;
+            b = c;
+            ans++;
+        }
+        return ans;
+    }
+    inline int SolveGcd(int l,int r)
+    {
+        Node *pre = FindPre(l);
+        Node *succ = FindSucc(r,0);
+        Splay(pre,null);
+        Splay(succ,root);
+        return KT->g;
+    }
+    void vist(Node *x)
+    {
+        if(x != null)
+        {
+            printf("root %2d:  left-son: %2d    right-son: %2d  size:%2d val=%2d   gcd: %2d\n",x->id,x->c[0]->id,x->c[1]->id,x->size,x->val,x->g);
+            vist(x->c[0]);
+            vist(x->c[1]);
+        }
+    }
+}spt[maxn];
+void prepare()
+{
+    null->id = 0;
+    null->c[0] = null->c[1] = null->fa = NULL;
+    null->size = null->val = 0;
+    null->g = -1;
+    Type = 0;
+    scnt = 0;
+}
+int main()
+{
+    int t,n,m,a,u,v,op,l,r,x,cas = 1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        prepare();
+        printf("Case #%d:\n",cas++);
+        scanf("%d%d",&n,&m);
+        for(int i = 1;i<=n;i++)
+        {
+            spt[i].Init(-1);
+            Node *tmp = spt[i].NewNode(inf,null);
+            spt[i].Insert(tmp);
+        }
+        for(int i = 1;i<=n;i++)
+        {
+            scanf("%d",&a);
+            Node *tmp = spt[i].NewNode(a,null);
+            spt[i].Insert(tmp);
+        }
+        int tot = 0;
+        while(m--)
+        {
+            scanf("%d",&op);
+            if(op == 1)
+            {
+                scanf("%d%d",&u,&v);
+                Node *t1 = ID[u+2*n];
+                Node *t2 = ID[v+2*n];
+                int tree1 = t1->who;
+                int tree2 = t2->who;
+                if(tree1 == tree2)continue;
+                int size1 = spt[tree1].root->size;
+                int size2 = spt[tree2].root->size;
+                if(size1>size2)spt[tree1].Merge(spt[tree2]);
+                else spt[tree2].Merge(spt[tree1]);
+            }
+            else if(op == 2)
+            {
+                scanf("%d%d",&u,&v);
+                Node *t1 = ID[u+2*n];
+                Node *t2 = ID[v+2*n];
+                int tree1 = t1->who;
+                int tree2 = t2->who;
+                spt[tree1].Delete(t1);
+                spt[tree2].Insert(t1);
+            }
+            else if(op == 3)
+            {
+                scanf("%d%d",&u,&x);
+                Node *tmp = ID[u+2*n];
+                int tree = tmp->who;
+                spt[tree].Change(tmp,x);
+            }
+            else if(op == 4)
+            {
+                scanf("%d",&u);
+                Node *tmp = ID[u+2*n];
+                int tree = tmp->who;
+                printf("%d\n",spt[tree].SolveTri());
+            }
+            else
+            {
+                scanf("%d%d%d",&u,&l,&r);
+                Node *tmp = ID[u+2*n];
+                int tree = tmp->who;
+                printf("%d\n",spt[tree].SolveGcd(l,r));
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4681_autoAC.cpp b/HDOJ/4681_autoAC.cpp
new file mode 100644
index 0000000..cfdbab6
--- /dev/null
+++ b/HDOJ/4681_autoAC.cpp
@@ -0,0 +1,125 @@
+#include<iostream>
+#include<stdio.h>
+#include<vector>
+#include<algorithm>
+#include<string.h>
+using namespace std;
+char sta[1001];
+char stb[1001];
+char stc[1001];
+int lena,lenb,lenc;
+int dp[1001][1001];
+int dpf[1001][1001];
+struct list
+{
+    int x;
+    int y;
+}node,n1,n2;
+vector<list>vec[5];
+void dps()
+{
+    int i,j;
+    for(i=0;i<lena;i++)
+        if(sta[i]==stb[0])
+            for(i;i<lena;i++)dp[i][0]=1;
+    for(i=0;i<lenb;i++)
+        if(sta[0]==stb[i])
+            for(i;i<lenb;i++)dp[0][i]=1;
+    for(i=1;i<lena;i++)
+    {
+        for(j=1;j<lenb;j++)
+        {
+            if(sta[i]==stb[j])dp[i][j]=dp[i-1][j-1]+1;
+            else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
+        }
+    }
+}
+void dpfs()
+{
+    int i,j;
+    for(i=lena-1;i>=0;i--)
+        if(sta[i]==stb[lenb-1])
+            for(i;i>=0;i--)dpf[i][lenb-1]=1;
+    for(i=lenb-1;i>=0;i--)
+        if(sta[lena-1]==stb[i])
+            for(i;i>=0;i--)dpf[lena-1][i]=1;
+    for(i=lena-2;i>=0;i--)
+    {
+        for(j=lenb-2;j>=0;j--)
+        {
+            if(sta[i]==stb[j])dpf[i][j]=dpf[i+1][j+1]+1;
+            else dpf[i][j]=max(dpf[i+1][j],dpf[i][j+1]);
+        }
+    }
+}
+void init()
+{
+    memset(dp,0,sizeof(dp));
+    memset(dpf,0,sizeof(dpf));
+    vec[0].clear();
+    vec[1].clear();
+    gets(sta);
+    gets(stb);
+    gets(stc);
+    lena=strlen(sta);
+    lenb=strlen(stb);
+    lenc=strlen(stc);
+}
+void sear(char str[],int pos)
+{
+    int lens=strlen(str);
+    int i,j,k;
+    for(i=0;i<lens;i++)
+    {
+        if(str[i]==stc[0])
+        {
+            for(k=0,j=i;j<lens;j++)
+            {
+                if(str[j]==stc[k])k++;
+                if(k==lenc)break;
+            }
+            if(j<lens)
+            {
+                node.x=i;
+                node.y=j;
+                vec[pos].push_back(node);
+            }
+        }
+    }
+}
+void prin(int cas)
+{
+    int l1=vec[0].size();
+    int l2=vec[1].size();
+    int maxx=0;
+    int i,j;
+    for(i=0;i<l1;i++)
+    {
+        for(j=0;j<l2;j++)
+        {
+            n1=vec[0][i];
+            n2=vec[1][j];
+            int c1,c2;
+            c1=c2=0;
+            if(n1.x-1>=0&&n2.x-1>=0)c1=dp[n1.x-1][n2.x-1];
+            if(n1.y+1<lena&&n2.y+1<lenb)c2=dpf[n1.y+1][n2.y+1];
+            maxx=max(maxx,c1+c2+lenc);
+        }
+    }
+    printf("Case #%d: %d\n",cas,maxx);
+}
+int main()
+{
+    int T,t;
+    scanf("%d%*c",&T);
+    for(t=1;t<=T;t++)
+    {
+        init();
+        dps();
+        dpfs();
+        sear(sta,0);
+        sear(stb,1);
+        prin(t);
+    }
+    return 0;
+}
diff --git a/HDOJ/4685_autoAC.cpp b/HDOJ/4685_autoAC.cpp
new file mode 100644
index 0000000..7959c0f
--- /dev/null
+++ b/HDOJ/4685_autoAC.cpp
@@ -0,0 +1,125 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<stack>
+#include<vector>
+using namespace std;
+#define MAXN 1111
+int n,m,N,cnt;
+bool map[MAXN][MAXN];
+bool mark[MAXN];
+int ly[MAXN];
+int lx[MAXN];
+int dfs(int u,int m)
+{
+    for(int v=1;v<=m;v++){
+        if(map[u][v]&&!mark[v]){
+            mark[v]=true;
+            if(ly[v]==-1||dfs(ly[v],m)){
+                ly[v]=u;
+                lx[u]=v;
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+int MaxMatch(int n,int m)
+{
+    memset(ly,-1,sizeof(ly));
+    memset(lx,-1,sizeof(lx));
+    int ans=0;
+    for(int i=1;i<=n;i++){
+        memset(mark,false,sizeof(mark));
+        ans+=dfs(i,m);
+    }
+    return ans;
+}
+vector<vector<int> >g;
+vector<vector<int> >ans;
+int dfn[MAXN],low[MAXN];
+int color[MAXN],_count;
+stack<int>S;
+void Tarjan(int u)
+{
+    low[u]=dfn[u]=++cnt;
+    mark[u]=true;
+    S.push(u);
+    for(int i=0;i<g[u].size();i++){
+        int v=g[u][i];
+        if(dfn[v]==0){
+            Tarjan(v);
+            low[u]=min(low[u],low[v]);
+        }else if(mark[v]){
+            low[u]=min(low[u],dfn[v]);
+        }
+    }
+    if(low[u]==dfn[u]){
+        _count++;
+        int x;
+        do{
+            x=S.top();
+            S.pop();
+            mark[x]=false;
+            color[x]=_count;
+        }while(x!=u);
+    }
+}
+int main()
+{
+    int _case,k,x,t=1;
+    scanf("%d",&_case);
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        memset(map,false,sizeof(map));
+        for(int i=1;i<=n;i++){
+            scanf("%d",&k);
+            while(k--){
+                scanf("%d",&x);
+                map[i][x]=true;
+            }
+        }
+        cnt=MaxMatch(n,m);
+        N=n+m-cnt;
+        for(int i=n+1;i<=N;i++)
+            for(int j=1;j<=N;j++)
+                map[i][j]=true;
+        for(int i=m+1;i<=N;i++)
+            for(int j=1;j<=N;j++)
+                map[j][i]=true;
+        MaxMatch(N,N);
+        g.clear();
+        g.resize(N+2);
+        ans.clear();
+        ans.resize(N+2);
+        for(int i=1;i<=N;i++){
+            for(int j=1;j<=N;j++){
+                if(lx[i]!=j&&map[i][j]){
+                    g[lx[i]].push_back(j);
+                }
+            }
+        }
+        memset(dfn,0,sizeof(dfn));
+        memset(mark,false,sizeof(mark));
+        _count=cnt=0;
+        for(int i=1;i<=N;i++)
+            if(dfn[i]==0)Tarjan(i);
+        for(int i=1;i<=n;i++){
+            for(int j=1;j<=m;j++){
+                if(map[i][j]&&color[lx[i]]==color[j]){
+                    ans[i].push_back(j);
+                }
+            }
+        }
+        printf("Case #%d:\n",t++);
+        for(int i=1;i<=n;i++){
+            printf("%d",(int)ans[i].size());
+            for(int j=0;j<ans[i].size();j++){
+                printf(" %d",ans[i][j]);
+            }
+            puts("");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/4686_autoAC.cpp b/HDOJ/4686_autoAC.cpp
new file mode 100644
index 0000000..bc21a3d
--- /dev/null
+++ b/HDOJ/4686_autoAC.cpp
@@ -0,0 +1,76 @@
+#include<stdio.h>
+#include<string.h>
+#define LL long long
+#define M 1000000007
+struct Matrix
+{
+    LL a[6][6];
+}origin,res,tmp,A,ans;
+int n;
+Matrix mul(Matrix x,Matrix y)
+{
+    int i,j,k;
+    memset(tmp.a,0,sizeof(tmp.a));
+    for(i=1;i<=n;i++)
+        for(j=1;j<=n;j++)
+            for(k=1;k<=n;k++)
+            {
+                tmp.a[i][j]+=(x.a[i][k]*y.a[k][j])%M;
+                tmp.a[i][j]%=M;
+            }
+    return tmp;
+}
+void quickpow(LL k)
+{
+    int i;
+    memset(res.a,0,sizeof(res.a));
+    for(i=1;i<=n;i++)
+        res.a[i][i]=1;
+    while(k)
+    {
+        if(k&1)
+            res=mul(res,A);
+        A=mul(A,A);
+        k>>=1;
+    }
+}
+int main()
+{
+    LL N,a0,ax,ay,b0,bx,by;
+    LL f1,a1,b1,s0;
+    while(scanf("%lld %lld %lld %lld %lld %lld %lld",&N,&a0,&ax,&ay,&b0,&bx,&by)!=EOF)
+    {
+        if(N==0)
+        {
+            printf("0\n");
+            continue;
+        }
+        a1=(a0*ax+ay)%M;
+        b1=(b0*bx+by)%M;
+        f1=(a1*b1)%M;
+        s0=(a0*b0)%M;
+        n=5;
+        memset(origin.a,0,sizeof(origin.a));
+        origin.a[1][1]=f1;
+        origin.a[1][2]=a1;
+        origin.a[1][3]=b1;
+        origin.a[1][4]=1;
+        origin.a[1][5]=s0;
+        memset(A.a,0,sizeof(A.a));
+        A.a[1][1]=(ax*bx)%M;
+        A.a[1][5]=1;
+        A.a[2][1]=(ax*by)%M;
+        A.a[2][2]=ax%M;
+        A.a[3][1]=(ay*bx)%M;
+        A.a[3][3]=bx%M;
+        A.a[4][1]=(ay*by)%M;
+        A.a[4][2]=ay%M;
+        A.a[4][3]=by%M;
+        A.a[4][4]=1;
+        A.a[5][5]=1;
+        quickpow(N-1);
+        ans=mul(origin,res);
+        printf("%lld\n",ans.a[1][5]);
+    }
+    return 0;
+}
diff --git a/HDOJ/4687_autoAC.cpp b/HDOJ/4687_autoAC.cpp
new file mode 100644
index 0000000..681bc52
--- /dev/null
+++ b/HDOJ/4687_autoAC.cpp
@@ -0,0 +1,187 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int MAXN = 50;
+int N; 
+bool Graph[MAXN][MAXN];
+int Match[MAXN];
+bool InQueue[MAXN],InPath[MAXN],InBlossom[MAXN];
+int Head,Tail;
+int Queue[MAXN];
+int Start,Finish;
+int NewBase;
+int Father[MAXN],Base[MAXN];
+int Count;
+void Push(int u)
+{
+    Queue[Tail] = u;
+    Tail++;
+    InQueue[u] = true;
+}
+int Pop()
+{
+    int res = Queue[Head];
+    Head++;
+    return res;
+}
+int FindCommonAncestor(int u,int v)
+{
+    memset(InPath,false,sizeof(InPath));
+    while(true)
+    {
+        u = Base[u];
+        InPath[u] = true;
+        if(u == Start) break;
+        u = Father[Match[u]];
+    }
+    while(true)
+    {
+        v = Base[v];
+        if(InPath[v])break;
+        v = Father[Match[v]];
+    }
+    return v;
+}
+void ResetTrace(int u)
+{
+    int v;
+    while(Base[u] != NewBase)
+    {
+        v = Match[u];
+        InBlossom[Base[u]] = InBlossom[Base[v]] = true;
+        u = Father[v];
+        if(Base[u] != NewBase) Father[u] = v;
+    }
+}
+void BloosomContract(int u,int v)
+{
+    NewBase = FindCommonAncestor(u,v);
+    memset(InBlossom,false,sizeof(InBlossom));
+    ResetTrace(u);
+    ResetTrace(v);
+    if(Base[u] != NewBase) Father[u] = v;
+    if(Base[v] != NewBase) Father[v] = u;
+    for(int tu = 1; tu <= N; tu++)
+        if(InBlossom[Base[tu]])
+        {
+            Base[tu] = NewBase;
+            if(!InQueue[tu]) Push(tu);
+        }
+}
+void FindAugmentingPath()
+{
+    memset(InQueue,false,sizeof(InQueue));
+    memset(Father,0,sizeof(Father));
+    for(int i = 1;i <= N;i++)
+        Base[i] = i;
+    Head = Tail = 1;
+    Push(Start);
+    Finish = 0;
+    while(Head < Tail)
+    {
+        int u = Pop();
+        for(int v = 1; v <= N; v++)
+            if(Graph[u][v] && (Base[u] != Base[v]) && (Match[u] != v))
+            {
+                if((v == Start) || ((Match[v] > 0) && Father[Match[v]] > 0))
+                    BloosomContract(u,v);
+                else if(Father[v] == 0)
+                {
+                    Father[v] = u;
+                    if(Match[v] > 0)
+                        Push(Match[v]);
+                    else
+                    {
+                        Finish = v;
+                        return;
+                    }
+                }
+            }
+    }
+}
+void AugmentPath()
+{
+    int u,v,w;
+    u = Finish;
+    while(u > 0)
+    {
+        v = Father[u];
+        w = Match[v];
+        Match[v] = u;
+        Match[u] = v;
+        u = w;
+    }
+}
+void Edmonds()
+{
+    memset(Match,0,sizeof(Match));
+    for(int u = 1; u <= N; u++)
+        if(Match[u] == 0)
+        {
+            Start = u;
+            FindAugmentingPath();
+            if(Finish > 0)AugmentPath();
+        }
+}
+int getMatch()
+{
+    Edmonds();
+    Count = 0;
+    for(int u = 1; u <= N;u++)
+        if(Match[u] > 0)
+            Count++;
+    return Count/2;
+}
+bool g[MAXN][MAXN];
+pair<int,int>p[150];
+int main()
+{
+    int m;
+    while(scanf("%d%d",&N,&m)==2)
+    {
+        memset(g,false,sizeof(g));
+        memset(Graph,false,sizeof(Graph));
+        int u,v;
+        for(int i = 1;i <= m;i++)
+        {
+            scanf("%d%d",&u,&v);
+            p[i] = make_pair(u,v);
+            g[u][v] = true;
+            g[v][u] = true;
+            Graph[u][v] = true;
+            Graph[v][u] = true;
+        }
+        int cnt0 = getMatch();
+        vector<int>ans;
+        for(int i = 1;i <= m;i++)
+        {
+            u = p[i].first;
+            v = p[i].second;
+            memcpy(Graph,g,sizeof(g));
+            for(int j = 1;j <= N;j++)
+                Graph[j][u] = Graph[u][j] = Graph[j][v] = Graph[v][j] = false;
+            int cnt = getMatch();
+            if(cnt < cnt0-1)
+                ans.push_back(i);
+        }
+        int sz = ans.size();
+        printf("%d\n",sz);
+        for(int i = 0;i < sz;i++)
+        {
+            printf("%d",ans[i]);
+            if(i < sz-1)printf(" ");
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4689_autoAC.cpp b/HDOJ/4689_autoAC.cpp
new file mode 100644
index 0000000..1c5c5ba
--- /dev/null
+++ b/HDOJ/4689_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <vector>
+using namespace std;
+#define ll long long
+char a[100];
+ll dp[22][22][22];
+int main ()
+{
+    while(scanf("%s",a)!=EOF)
+    {
+        if(a[0]=='-')
+        {
+            printf("0\n");
+            continue;
+        }
+        memset(dp,0,sizeof(dp));
+        dp[1][0][1]=1;
+        int cnt=0;
+        for(int i=1;i<strlen(a);++i)
+        {
+            if(a[i]=='-')
+            {
+                cnt++;
+                for(int j=0;j<i;++j)
+                    for(int k=0;k<=i;++k)
+                {
+                    if(i-j-k>0)
+                        dp[i+1][j+1][k]+=dp[i][j][k]*(i-j-k);
+                    if(k)
+                        dp[i+1][j+1][k-1]+=dp[i][j][k]*k;
+                }
+            }
+            else
+            {
+                for(int j=0;j<=i;++j)
+                    for(int k=0;k<=i;++k)
+                    {
+                        dp[i+1][j][k+1]+=dp[i][j][k];
+                        if(i-j-k>0)
+                            dp[i+1][j][k+1]+=dp[i][j][k]*(i-j-k);
+                        dp[i+1][j][k]+=dp[i][j][k]*k;
+                    }
+            }
+        }
+        cout<<dp[strlen(a)][cnt][0]<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/4690_autoAC.cpp b/HDOJ/4690_autoAC.cpp
new file mode 100644
index 0000000..1febc21
--- /dev/null
+++ b/HDOJ/4690_autoAC.cpp
@@ -0,0 +1,105 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <cctype>
+#include <algorithm>
+#include <queue>
+#include <deque>
+#include <queue>
+#include <list>
+#include <map>
+#include <set>
+#include <vector>
+#include <utility>
+#include <functional>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <numeric>
+#include <cassert>
+#include <ctime>
+#include <iterator>
+const int INF = 0x3f3f3f3f;
+const int dir[8][2] = {{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{-1,1},{1,-1},{1,1}};
+using namespace std;
+string A[16][16] = {
+    "NUL","SOH","STX","ETX","","HT","","DEL","","","","VT","FF","CR","SO","SI",
+    "DLE","DC1","DC2","DC3","","","BS","","CAN","EM","","","IFS","IGS","IRS","IUS ITB",
+    "","","","","","LF","ETB","ESC","","","","","","ENQ","ACK","BEL",
+    "","","SYN","","","","","EOT","","","","","DC4","NAK","","SUB",
+    "SP","","","","","","","","","","",".","<","(","+","|",
+    "&","","","","","","","","","","!","$","*",")",";","",
+    "-","/","","","","","","","","","",",","%","_",">","?",
+    "","","","","","","","","","`",":","#","@","'","=","\"",
+    "","a","b","c","d","e","f","g","h","i","","","","","","",
+    "","j","k","l","m","n","o","p","q","r","","","","","","",
+    "","~","s","t","u","v","w","x","y","z","","","","","","",
+    "^","","","","","","","","","","[","]","","","","",
+    "{","A","B","C","D","E","F","G","H","I","","","","","","",
+    "}","J","K","L","M","N","O","P","Q","R","","","","","","",
+    "\\","","S","T","U","V","W","X","Y","Z","","","","","","",
+    "0","1","2","3","4","5","6","7","8","9","","","","","",""
+};
+string B[8][16] = {
+"NUL",    "SOH",    "STX",    "ETX",    "EOT",    "ENQ",    "ACK",    "BEL",    "BS",    "HT",    "LF",    "VT",    "FF",    "CR",    "SO",    "SI",
+"DLE",    "DC1",    "DC2",    "DC3",    "DC4",    "NAK",    "SYN",    "ETB",    "CAN",    "EM",    "SUB",    "ESC",    "IFS",    "IGS",    "IRS",    "IUS ITB",
+"SP",    "!",    "\"",    "#",    "$",    "%",    "&",    "'",    "(",    ")",    "*",    "+",    ",",    "-",    ".",    "/",
+"0",    "1",    "2",    "3",    "4",    "5",    "6",    "7",    "8",    "9",    ":",    ";",    "<",    "=",    ">",    "?",
+"@",    "A",    "B",    "C",    "D",    "E",    "F",    "G",    "H",    "I",    "J",    "K",    "L",    "M",    "N",    "O",
+"P",    "Q",    "R",    "S",    "T",    "U",    "V",    "W",    "X",    "Y",    "Z",    "[", "\\","]","^","_",
+"`",    "a",    "b",    "c",    "d",    "e",    "f",    "g",    "h",    "i",    "j",    "k",    "l",    "m",    "n",    "o",
+"p",    "q",    "r",    "s",    "t",    "u",    "v",    "w",    "x",    "y",    "z",    "{",    "|",    "}",    "~",    "DEL"
+};
+map<pair<int,int>, pair<int,int> > coll;
+int main(void)
+{
+    string sad;
+    ios::sync_with_stdio(false);
+    cin>>sad; coll.clear();
+    string tmp; pair<int,int> so, to;
+    for (int i = 0; i < 16; ++i)
+    {
+        for (int j = 0; j < 16; ++j)
+        {
+            if (A[i][j]!="")
+            {
+                so.first=i, so.second=j;
+                bool mrk = false;
+                for (int k = 0; k < 8; ++k)
+                {
+                    for (int h = 0; h < 16; ++h)
+                    {
+                        if (A[i][j]==B[k][h])
+                        {
+                            mrk = true;
+                            to.first=k,to.second=h;
+                            coll[so] = to; break;
+                        }
+                    }
+                    if (mrk) break;
+                }
+            }
+        }
+    }
+    for (int i = 0; i < sad.size(); i+=2)
+    {
+        int X, Y; tmp.clear();
+        if (sad[i]>='A'&&sad[i]<='F') X = sad[i]- 'A'+10;
+        else X = sad[i] - '0';
+        if (sad[i+1]>='A'&&sad[i+1]<='F') Y = sad[i+1]- 'A'+10;
+        else Y = sad[i+1] - '0';
+        pair<int,int> hehe, TM;
+        hehe.first = X, hehe.second = Y;
+        TM = coll[hehe];
+        int j = TM.first, k = TM.second;
+        char XX, YY;
+        XX = j+ '0';
+        if (k >= 10) YY = k - 10 + 'A';
+        else YY = k + '0';
+        printf("%c%c", XX, YY);
+    }
+    printf("\n");
+    return 0;
+}
diff --git a/HDOJ/4691_autoAC.cpp b/HDOJ/4691_autoAC.cpp
new file mode 100644
index 0000000..21097d4
--- /dev/null
+++ b/HDOJ/4691_autoAC.cpp
@@ -0,0 +1,140 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+const int MAXN=100010;
+int t1[MAXN],t2[MAXN],c[MAXN];
+bool cmp(int *r,int a,int b,int l)
+{
+    return r[a] == r[b] && r[a+l] == r[b+l];
+}
+void da(int str[],int sa[],int ran[],int height[],int n,int m)
+{
+    n++;
+    int i, j, p, *x = t1, *y = t2;
+    for(i = 0;i < m;i++)c[i] = 0;
+    for(i = 0;i < n;i++)c[x[i] = str[i]]++;
+    for(i = 1;i < m;i++)c[i] += c[i-1];
+    for(i = n-1;i >= 0;i--)sa[--c[x[i]]] = i;
+    for(j = 1;j <= n; j <<= 1)
+    {
+        p = 0;
+        for(i = n-j; i < n; i++)y[p++] = i;
+        for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
+        for(i = 0; i < m; i++)c[i] = 0;
+        for(i = 0; i < n; i++)c[x[y[i]]]++;
+        for(i = 1; i < m;i++)c[i] += c[i-1];
+        for(i = n-1; i >= 0;i--)sa[--c[x[y[i]]]] = y[i];
+        swap(x,y);
+        p = 1; x[sa[0]] = 0;
+        for(i = 1;i < n;i++)
+            x[sa[i]] = cmp(y,sa[i-1],sa[i],j)?p-1:p++;
+        if(p >= n)break;
+        m = p;
+    }
+    int k = 0;
+    n--;
+    for(i = 0;i <= n;i++)ran[sa[i]] = i;
+    for(i = 0;i < n;i++)
+    {
+        if(k)k--;
+        j = sa[ran[i]-1];
+        while(str[i+k] == str[j+k])k++;
+        height[ran[i]] = k;
+    }
+}
+int ran[MAXN],height[MAXN];
+int RMQ[MAXN];
+int mm[MAXN];
+int best[20][MAXN];
+void initRMQ(int n)
+{
+    mm[0]=-1;
+    for(int i=1;i<=n;i++)
+        mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
+    for(int i=1;i<=n;i++)best[0][i]=i;
+    for(int i=1;i<=mm[n];i++)
+        for(int j=1;j+(1<<i)-1<=n;j++)
+        {
+            int a=best[i-1][j];
+            int b=best[i-1][j+(1<<(i-1))];
+            if(RMQ[a]<RMQ[b])best[i][j]=a;
+            else best[i][j]=b;
+        }
+}
+int askRMQ(int a,int b)
+{
+    int t;
+    t=mm[b-a+1];
+    b-=(1<<t)-1;
+    a=best[t][a];b=best[t][b];
+    return RMQ[a]<RMQ[b]?a:b;
+}
+int lcp(int a,int b)
+{
+    a=ran[a];b=ran[b];
+    if(a>b)swap(a,b);
+    return height[askRMQ(a+1,b)];
+}
+char str[MAXN];
+int r[MAXN];
+int sa[MAXN];
+int A[MAXN],B[MAXN];
+int calc(int n)
+{
+    if(n == 0)return 1;
+    int ret = 0;
+    while(n)
+    {
+        ret++;
+        n /= 10;
+    }
+    return ret;
+}
+int main()
+{
+    while(scanf("%s",str)==1)
+    {
+        int n = strlen(str);
+        for(int i = 0;i < n;i++)
+            r[i] = str[i];
+        r[n] = 0;
+        da(r,sa,ran,height,n,128);
+        for(int i = 1;i <= n;i++)
+            RMQ[i] = height[i];
+        initRMQ(n);
+        int k,u,v;
+        long long ans1 = 0, ans2 = 0;
+        scanf("%d",&k);
+        for(int i = 0;i < k;i++)
+        {
+            scanf("%d%d",&A[i],&B[i]);
+            if(i == 0)
+            {
+                ans1 += B[i] - A[i] + 1;
+                ans2 += B[i] - A[i] + 3;
+                continue;
+            }
+            int tmp ;
+            if(A[i]!= A[i-1])tmp = lcp(A[i],A[i-1]);
+            else tmp = 10000000;
+            tmp = min(tmp,B[i]-A[i]);
+            tmp = min(tmp,B[i-1]-A[i-1]);
+            ans1 += B[i] - A[i] + 1;
+            ans2 += B[i] - A[i] - tmp + 1;
+            ans2 += 1;
+            ans2 += calc(tmp);
+        }
+        printf("%I64d %I64d\n",ans1,ans2);
+    }
+    return 0;
+}
diff --git a/HDOJ/4696_autoAC.cpp b/HDOJ/4696_autoAC.cpp
new file mode 100644
index 0000000..c605388
--- /dev/null
+++ b/HDOJ/4696_autoAC.cpp
@@ -0,0 +1,92 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+#define LL __int64
+#define maxn 100011
+int t[maxn],c[maxn],n,q,m[maxn],vis[maxn],a[maxn],b[maxn];
+map<int,map<int,int> >nn;
+map<int,int>mm;
+map<int,int>ll;
+int bb[1001];
+int flag[maxn],s[maxn],ss[maxn];
+void find(int x)
+{
+    ll.clear();
+    int tt=1,i,j,k,y,z,d;
+    s[0]=0;s[1]=c[x];ll[x]=1,ss[1]=x;
+    for(i=2;;i++)
+    {
+        vis[x]=1;
+        x=t[x];
+        ss[i]=x;
+        if(ll[x])
+            break;
+        if(vis[x])
+        {
+            for(j=i-1;j>=1;j--)
+            {
+                a[ss[j]]=s[i-1]-s[j-1]+a[x];
+                b[ss[j]]=b[x];
+            }
+            return;
+        }
+        ll[x]=++tt;
+        s[i]=s[i-1]+c[x];
+    }
+    d=s[i-1]-s[ll[x]-1];
+    for(j=1;j<i;j++)
+    {
+        if(j<=ll[x])
+            a[ss[j]]=s[ll[x]-1]-s[j-1];
+        else
+            a[ss[j]]=s[i-1]-s[j-1];
+        b[ss[j]]=d;
+    }
+}
+int main()
+{
+    while(scanf("%d%d",&n,&q)!=EOF)
+    {
+        int i,j,k;
+        for(i=1;i<=n;i++)
+            scanf("%d",&t[i]);
+        for(i=1;i<=n;i++)
+            scanf("%d",&c[i]);
+        for(i=1;i<=q;i++)
+            scanf("%d",&m[i]);
+        memset(vis,0,sizeof(vis));
+        for(i=1;i<=n;i++)
+        {
+            if(!vis[i])
+            find(i);
+        }
+        mm.clear();
+        nn.clear();
+        int tt=0;
+        for(i=1;i<=n;i++)
+        {
+            if(mm[b[i]]==0)
+            {
+                mm[b[i]]=++tt;
+                bb[tt]=b[i];
+            }
+            nn[tt][a[i]]=1;
+        }
+        memset(flag,0,sizeof(flag));
+        for(j=1;j<=q;j++)
+        {
+            if(m[j]<=0)continue;
+            for(i=1;i<=tt;i++)
+            if(nn[i][m[j]%bb[i]]){flag[j]=1;break;}
+        }
+        for(i=1;i<=q;i++)
+            if(flag[i])printf("YES\n");
+            else printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/4697_autoAC.cpp b/HDOJ/4697_autoAC.cpp
new file mode 100644
index 0000000..d09a44d
--- /dev/null
+++ b/HDOJ/4697_autoAC.cpp
@@ -0,0 +1,129 @@
+#include <cstdio>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+const double eps = 1e-9;
+inline int dcmp(double x) {
+    if (fabs(x) < eps)
+        return 0;
+    return x > eps ? 1 : -1;
+}
+struct point {
+    double x, y;
+    int id;
+    inline void in(int i) {
+        scanf("%lf%lf", &x, &y);
+        id = i;
+    }
+    point(double x = 0, double y = 0) :
+            x(x), y(y) {
+    }
+    inline point operator -(const point &t) const {
+        return point(x - t.x, y - t.y);
+    }
+    inline point operator +(const point &t) const {
+        return point(x + t.x, y + t.y);
+    }
+    point operator /(const double &t) const {
+        return point(x / t, y / t);
+    }
+    point operator *(const double &t) const {
+        return point(x * t, y * t);
+    }
+    inline double operator *(const point &t) const {            
+        return x*t.y-y*t.x;
+    }
+    bool operator <(const point &t) const {
+        if(y == t.y) return x < t.x;
+        return y < t.y;
+    }
+}p[55], v[55], tp[55], st[55];
+double t[55*55*55], T, cur, ans;
+int sz, n, m;
+double a, b, c;
+inline double cross(const point &o, const point &a, const point &b) {
+    return (a.x-o.x)*(b.y-o.y)-(a.y-o.y)*(b.x-o.x);
+}
+int graham(point *p, int n, point *st) {        
+    sort(p, p + n);
+    int top = 0;
+    int i;
+    for (i = 0; i < n; i++) {
+        while (top >= 2 && cross(st[top - 2], st[top - 1], p[i]) < eps)
+            top--;
+        st[top++] = p[i];
+    }
+    int t = top + 1;
+    for (i = n - 2; i >= 0; i--) {
+        while (top >= t && cross(st[top - 2], st[top - 1], p[i]) < eps)
+            top--;
+        st[top++] = p[i];
+    }
+    return top;
+}
+inline void gao(int i, int j, int k) {        
+    point a1 = p[i]-p[j], a2 = p[i]-p[k];
+    point b1 = v[i]-v[j], b2 = v[i]-v[k];
+    a += b1*b2; b += a1*b2+b1*a2; c += a1*a2;
+}
+inline void solve(double a, double b, double c) {    
+    double x;
+    if(a == 0) {
+        if(b!= 0) {
+            x = -c/b;
+            if(x >= 0 && x <= T) t[sz++] = x;
+        }
+        return;
+    }
+    double dlt = b*b-4*a*c;
+    if(dlt < 0) return;
+    if(dlt == 0) {
+        x = -b*0.5/a;
+        if(x >= 0 && x <= T) t[sz++] = x;
+        return;
+    }
+    dlt = sqrt(dlt);
+    x = 0.5*(-b+dlt)/a;
+    if(x >= 0 && x <= T) t[sz++] = x;
+    x = 0.5*(-b-dlt)/a;
+    if(x >= 0 && x <= T) t[sz++] = x;
+}
+inline double F(double x) {        
+    return a*x*x*x/3.0+b*x*x/2.0+c*x;
+}
+int main() {
+    int i, j, k;
+    while( ~scanf("%d%lf", &n, &T)) {
+        for(i = 0; i < n; i++) p[i].in(i), v[i].in(i);
+        if(n <= 2) {
+            printf("%.10f\n", 0.0);
+            continue;
+        }
+        t[0] = 0; t[1] = T;    
+        sz = 2;
+        for(i = 0; i < n; i++)
+            for(j = i+1; j < n; j++)
+                for(k = j+1; k < n; k++) {
+                    a = b = c = 0;
+                    gao(i, j, k);
+                    solve(a, b, c);
+                }
+        sort(t, t+sz);
+        ans = 0;
+        for(i = 0; i < sz-1; i++) {
+            cur = 0.5*(t[i]+t[i+1]);
+            a = b = c = 0;
+            for(j = 0; j < n; j++) {
+                tp[j] = p[j]+v[j]*cur;
+                tp[j].id = p[j].id;
+            }
+            m = graham(tp, n, st);
+            for(j = 2; j < m; j++)
+                gao(st[0].id, st[j-1].id, st[j].id);    
+            ans += F(t[i+1])- F(t[i]);
+        }
+        printf("%.10f\n", fabs(ans*0.5/T));
+    }
+    return 0;
+}
diff --git a/HDOJ/4698_autoAC.cpp b/HDOJ/4698_autoAC.cpp
new file mode 100644
index 0000000..2e1a306
--- /dev/null
+++ b/HDOJ/4698_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <cstdio>  
+#include <cstdlib>  
+#include <cmath>  
+#include <cstring>  
+#include <algorithm>  
+#include <vector>  
+#include <stack>  
+#include <queue>  
+#include <set>  
+#define LL long long  
+#define mod 1000000007  
+#define M 1005  
+#define INF 0x7fffffff  
+using namespace std;  
+struct Point  
+{  
+    int x, y;  
+    bool operator < (const Point &temp) const  
+    {  
+        if(x!=temp.x) return x<temp.x;  
+        else return y<temp.y;  
+    }  
+    int readPoint()  
+    {  
+        return scanf("%d%d", &x, &y);  
+    }  
+} p[M];  
+int n, m, k;  
+int val[M];  
+set<int>sset;  
+set<int>::iterator it;  
+int main ()  
+{  
+    while(~scanf("%d%d%d", &n, &m, &k))  
+    {  
+        for(int i = 1; i <= k; ++i)  
+        {  
+            p[i].readPoint();  
+            val[i] = p[i].x;  
+        }  
+        sort(p+1, p+1+k);  
+        sort(val+1, val+1+k);  
+        int tot = unique(val+1, val+1+k) - val;  
+        val[0] = 0;  
+        val[tot] = n+1;  
+        LL ans = 0;  
+        for(int i = 1; i < tot; ++i)  
+        {  
+            LL tt = 0;  
+            int pre = val[i]-val[i-1];  
+            int r;  
+            for(r = 1; r <= k && p[r].x < val[i]; ++r);  
+            sset.clear();  
+            sset.insert(0);  
+            sset.insert(m+1);  
+            for(int j = i; j < tot; ++j)  
+            {  
+                int top, bottom;  
+                for( ; r <= k && p[r].x == val[j]; ++r)  
+                {  
+                    if(sset.count(p[r].y)) continue;  
+                    it = sset.lower_bound(p[r].y);  
+                    top = *it;  
+                    bottom = *(--it);  
+                    tt = (tt+(LL)(top-p[r].y)*(p[r].y-bottom)%mod)%mod;  
+                    sset.insert(p[r].y);  
+                }  
+                int rear = val[j+1]-val[j];  
+                ans = (ans+tt*rear%mod*pre%mod)%mod;  
+            }  
+        }  
+        printf("%I64d\n", ans);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/4699_autoAC.cpp b/HDOJ/4699_autoAC.cpp
new file mode 100644
index 0000000..4087cd2
--- /dev/null
+++ b/HDOJ/4699_autoAC.cpp
@@ -0,0 +1,91 @@
+#include<iostream>
+#include<cstdio>
+#include<vector>
+using namespace std;
+#define max(a,b) a>b?a:b
+#define min(a,b) a<b?a:b
+struct node
+{
+    int sum;
+    int m;
+    int v;
+}ne,cur;
+vector<node>a,b;
+int main()
+{
+    int num,j,n;
+    char k;
+    while(scanf("%d",&num)!=EOF)
+    {
+        a.clear();
+        b.clear();
+        while(num--)
+        {
+            getchar();
+            scanf("%c",&k);
+            if(k=='I')
+            {
+                scanf("%d",&n);
+                ne.m=n;
+                ne.v=n;
+                ne.sum=n;
+                if(a.size()==0)
+                    a.push_back(ne);
+                else
+                {
+                    int sz=a.size();
+                    cur=a[sz-1];
+                    ne.sum = cur.sum + ne.v;
+                    ne.m = max(ne.sum,cur.m);
+                    a.push_back(ne);
+                }
+            }
+            else if(k=='L')
+            {
+                int sz = a.size() ;
+                if(sz)
+                {    
+                    cur = a[sz-1] ;
+                    a.pop_back();
+                    b.push_back(cur);
+                }
+            }
+            else if(k=='R')
+            {
+                j = b.size();
+                if(j)
+                {                
+                    ne=b[j-1];
+                    b.pop_back();
+                    ne.sum=ne.v;
+                    ne.m=ne.v;
+                    int sz = a.size();
+                    if(sz==0)
+                    {
+                        ne.sum=ne.v;
+                        ne.m=ne.v;
+                        a.push_back(ne);
+                    }
+                    else
+                    {
+                        cur = a[sz-1];
+                        ne.sum = cur.sum + ne.v;
+                        ne.m = max(ne.sum,cur.m);
+                        a.push_back(ne);
+                    }
+                }
+            }
+            else if(k=='D')
+            {
+                if(a.size())
+                a.pop_back();
+            }
+            else if(k=='Q')
+            {
+                scanf("%d",&n);
+                printf("%d\n",a[n-1].m);
+            }
+        }
+    }
+    return 0;
+}