From 596be6ae110eac7ee22a2b0288e4dc666c8a7bbc Mon Sep 17 00:00:00 2001
From: KiritoTRw <3021577574@qq.com>
Date: Sat, 10 Sep 2016 11:36:30 +0800
Subject: [PATCH] Powered By HC TECH : AutoACer Engine

5000-5099
---
 HDOJ/5000_autoAC.cpp |  39 +++++++
 HDOJ/5001_autoAC.cpp |  62 +++++++++++
 HDOJ/5002_autoAC.cpp | 205 ++++++++++++++++++++++++++++++++++++
 HDOJ/5003_autoAC.cpp |  40 +++++++
 HDOJ/5004_autoAC.cpp | 102 ++++++++++++++++++
 HDOJ/5005_autoAC.cpp | 134 ++++++++++++++++++++++++
 HDOJ/5006_autoAC.cpp |  90 ++++++++++++++++
 HDOJ/5007_autoAC.cpp |  35 +++++++
 HDOJ/5008_autoAC.cpp | 151 +++++++++++++++++++++++++++
 HDOJ/5009_autoAC.cpp |  89 ++++++++++++++++
 HDOJ/5010_autoAC.cpp | 223 +++++++++++++++++++++++++++++++++++++++
 HDOJ/5011_autoAC.cpp |  29 ++++++
 HDOJ/5012_autoAC.cpp |  93 +++++++++++++++++
 HDOJ/5013_autoAC.cpp |  69 +++++++++++++
 HDOJ/5014_autoAC.cpp |  47 +++++++++
 HDOJ/5015_autoAC.cpp |  89 ++++++++++++++++
 HDOJ/5016_autoAC.cpp | 156 ++++++++++++++++++++++++++++
 HDOJ/5017_autoAC.cpp |  57 ++++++++++
 HDOJ/5018_autoAC.cpp |  41 ++++++++
 HDOJ/5019_autoAC.cpp |  42 ++++++++
 HDOJ/5020_autoAC.cpp |  55 ++++++++++
 HDOJ/5021_autoAC.cpp | 106 +++++++++++++++++++
 HDOJ/5022_autoAC.cpp | 125 ++++++++++++++++++++++
 HDOJ/5023_autoAC.cpp |  86 +++++++++++++++
 HDOJ/5024_autoAC.cpp |  65 ++++++++++++
 HDOJ/5025_autoAC.cpp | 134 ++++++++++++++++++++++++
 HDOJ/5027_autoAC.cpp | 137 ++++++++++++++++++++++++
 HDOJ/5029_autoAC.cpp | 187 +++++++++++++++++++++++++++++++++
 HDOJ/5030_autoAC.cpp | 113 ++++++++++++++++++++
 HDOJ/5031_autoAC.cpp | 231 +++++++++++++++++++++++++++++++++++++++++
 HDOJ/5032_autoAC.cpp |  88 ++++++++++++++++
 HDOJ/5033_autoAC.cpp | 146 ++++++++++++++++++++++++++
 HDOJ/5035_autoAC.cpp |  24 +++++
 HDOJ/5036_autoAC.cpp |  42 ++++++++
 HDOJ/5037_autoAC.cpp |  42 ++++++++
 HDOJ/5038_autoAC.cpp |  67 ++++++++++++
 HDOJ/5039_autoAC.cpp | 141 +++++++++++++++++++++++++
 HDOJ/5040_autoAC.cpp | 134 ++++++++++++++++++++++++
 HDOJ/5042_autoAC.cpp | 135 ++++++++++++++++++++++++
 HDOJ/5043_autoAC.cpp |  90 ++++++++++++++++
 HDOJ/5044_autoAC.cpp | 219 +++++++++++++++++++++++++++++++++++++++
 HDOJ/5045_autoAC.cpp |  52 ++++++++++
 HDOJ/5046_autoAC.cpp | 148 ++++++++++++++++++++++++++
 HDOJ/5047_autoAC.cpp |  25 +++++
 HDOJ/5048_autoAC.cpp | 182 ++++++++++++++++++++++++++++++++
 HDOJ/5049_autoAC.cpp | 241 +++++++++++++++++++++++++++++++++++++++++++
 HDOJ/5050_autoAC.cpp | 106 +++++++++++++++++++
 HDOJ/5051_autoAC.cpp |  55 ++++++++++
 HDOJ/5052_autoAC.cpp | 186 +++++++++++++++++++++++++++++++++
 HDOJ/5053_autoAC.cpp |  28 +++++
 HDOJ/5054_autoAC.cpp |  15 +++
 HDOJ/5055_autoAC.cpp |  48 +++++++++
 HDOJ/5056_autoAC.cpp |  64 ++++++++++++
 HDOJ/5057_autoAC.cpp |  65 ++++++++++++
 HDOJ/5058_autoAC.cpp |  47 +++++++++
 HDOJ/5059_autoAC.cpp |  43 ++++++++
 HDOJ/5060_autoAC.cpp |  66 ++++++++++++
 HDOJ/5062_autoAC.cpp |  15 +++
 HDOJ/5063_autoAC.cpp |  70 +++++++++++++
 HDOJ/5064_autoAC.cpp |  52 ++++++++++
 HDOJ/5065_autoAC.cpp |  51 +++++++++
 HDOJ/5066_autoAC.cpp |   9 ++
 HDOJ/5067_autoAC.cpp |  76 ++++++++++++++
 HDOJ/5068_autoAC.cpp | 109 +++++++++++++++++++
 HDOJ/5069_autoAC.cpp | 136 ++++++++++++++++++++++++
 HDOJ/5071_autoAC.cpp | 148 ++++++++++++++++++++++++++
 HDOJ/5072_autoAC.cpp |  95 +++++++++++++++++
 HDOJ/5073_autoAC.cpp |  47 +++++++++
 HDOJ/5074_autoAC.cpp |  48 +++++++++
 HDOJ/5076_autoAC.cpp | 155 ++++++++++++++++++++++++++++
 HDOJ/5077_autoAC.cpp |  18 ++++
 HDOJ/5078_autoAC.cpp |  37 +++++++
 HDOJ/5079_autoAC.cpp | 164 +++++++++++++++++++++++++++++
 HDOJ/5080_autoAC.cpp | 165 +++++++++++++++++++++++++++++
 HDOJ/5082_autoAC.cpp |  30 ++++++
 HDOJ/5083_autoAC.cpp | 159 ++++++++++++++++++++++++++++
 HDOJ/5084_autoAC.cpp |  46 +++++++++
 HDOJ/5086_autoAC.cpp |  35 +++++++
 HDOJ/5087_autoAC.cpp |  35 +++++++
 HDOJ/5088_autoAC.cpp |  64 ++++++++++++
 HDOJ/5089_autoAC.cpp |  78 ++++++++++++++
 HDOJ/5090_autoAC.cpp |  64 ++++++++++++
 HDOJ/5091_autoAC.cpp |  96 +++++++++++++++++
 HDOJ/5092_autoAC.cpp |  55 ++++++++++
 HDOJ/5093_autoAC.cpp |  81 +++++++++++++++
 HDOJ/5094_autoAC.cpp |  71 +++++++++++++
 HDOJ/5095_autoAC.cpp |  74 +++++++++++++
 HDOJ/5096_autoAC.cpp | 164 +++++++++++++++++++++++++++++
 HDOJ/5097_autoAC.cpp |  49 +++++++++
 HDOJ/5098_autoAC.cpp | 106 +++++++++++++++++++
 HDOJ/5099_autoAC.cpp |  72 +++++++++++++
 91 files changed, 8205 insertions(+)
 create mode 100644 HDOJ/5000_autoAC.cpp
 create mode 100644 HDOJ/5001_autoAC.cpp
 create mode 100644 HDOJ/5002_autoAC.cpp
 create mode 100644 HDOJ/5003_autoAC.cpp
 create mode 100644 HDOJ/5004_autoAC.cpp
 create mode 100644 HDOJ/5005_autoAC.cpp
 create mode 100644 HDOJ/5006_autoAC.cpp
 create mode 100644 HDOJ/5007_autoAC.cpp
 create mode 100644 HDOJ/5008_autoAC.cpp
 create mode 100644 HDOJ/5009_autoAC.cpp
 create mode 100644 HDOJ/5010_autoAC.cpp
 create mode 100644 HDOJ/5011_autoAC.cpp
 create mode 100644 HDOJ/5012_autoAC.cpp
 create mode 100644 HDOJ/5013_autoAC.cpp
 create mode 100644 HDOJ/5014_autoAC.cpp
 create mode 100644 HDOJ/5015_autoAC.cpp
 create mode 100644 HDOJ/5016_autoAC.cpp
 create mode 100644 HDOJ/5017_autoAC.cpp
 create mode 100644 HDOJ/5018_autoAC.cpp
 create mode 100644 HDOJ/5019_autoAC.cpp
 create mode 100644 HDOJ/5020_autoAC.cpp
 create mode 100644 HDOJ/5021_autoAC.cpp
 create mode 100644 HDOJ/5022_autoAC.cpp
 create mode 100644 HDOJ/5023_autoAC.cpp
 create mode 100644 HDOJ/5024_autoAC.cpp
 create mode 100644 HDOJ/5025_autoAC.cpp
 create mode 100644 HDOJ/5027_autoAC.cpp
 create mode 100644 HDOJ/5029_autoAC.cpp
 create mode 100644 HDOJ/5030_autoAC.cpp
 create mode 100644 HDOJ/5031_autoAC.cpp
 create mode 100644 HDOJ/5032_autoAC.cpp
 create mode 100644 HDOJ/5033_autoAC.cpp
 create mode 100644 HDOJ/5035_autoAC.cpp
 create mode 100644 HDOJ/5036_autoAC.cpp
 create mode 100644 HDOJ/5037_autoAC.cpp
 create mode 100644 HDOJ/5038_autoAC.cpp
 create mode 100644 HDOJ/5039_autoAC.cpp
 create mode 100644 HDOJ/5040_autoAC.cpp
 create mode 100644 HDOJ/5042_autoAC.cpp
 create mode 100644 HDOJ/5043_autoAC.cpp
 create mode 100644 HDOJ/5044_autoAC.cpp
 create mode 100644 HDOJ/5045_autoAC.cpp
 create mode 100644 HDOJ/5046_autoAC.cpp
 create mode 100644 HDOJ/5047_autoAC.cpp
 create mode 100644 HDOJ/5048_autoAC.cpp
 create mode 100644 HDOJ/5049_autoAC.cpp
 create mode 100644 HDOJ/5050_autoAC.cpp
 create mode 100644 HDOJ/5051_autoAC.cpp
 create mode 100644 HDOJ/5052_autoAC.cpp
 create mode 100644 HDOJ/5053_autoAC.cpp
 create mode 100644 HDOJ/5054_autoAC.cpp
 create mode 100644 HDOJ/5055_autoAC.cpp
 create mode 100644 HDOJ/5056_autoAC.cpp
 create mode 100644 HDOJ/5057_autoAC.cpp
 create mode 100644 HDOJ/5058_autoAC.cpp
 create mode 100644 HDOJ/5059_autoAC.cpp
 create mode 100644 HDOJ/5060_autoAC.cpp
 create mode 100644 HDOJ/5062_autoAC.cpp
 create mode 100644 HDOJ/5063_autoAC.cpp
 create mode 100644 HDOJ/5064_autoAC.cpp
 create mode 100644 HDOJ/5065_autoAC.cpp
 create mode 100644 HDOJ/5066_autoAC.cpp
 create mode 100644 HDOJ/5067_autoAC.cpp
 create mode 100644 HDOJ/5068_autoAC.cpp
 create mode 100644 HDOJ/5069_autoAC.cpp
 create mode 100644 HDOJ/5071_autoAC.cpp
 create mode 100644 HDOJ/5072_autoAC.cpp
 create mode 100644 HDOJ/5073_autoAC.cpp
 create mode 100644 HDOJ/5074_autoAC.cpp
 create mode 100644 HDOJ/5076_autoAC.cpp
 create mode 100644 HDOJ/5077_autoAC.cpp
 create mode 100644 HDOJ/5078_autoAC.cpp
 create mode 100644 HDOJ/5079_autoAC.cpp
 create mode 100644 HDOJ/5080_autoAC.cpp
 create mode 100644 HDOJ/5082_autoAC.cpp
 create mode 100644 HDOJ/5083_autoAC.cpp
 create mode 100644 HDOJ/5084_autoAC.cpp
 create mode 100644 HDOJ/5086_autoAC.cpp
 create mode 100644 HDOJ/5087_autoAC.cpp
 create mode 100644 HDOJ/5088_autoAC.cpp
 create mode 100644 HDOJ/5089_autoAC.cpp
 create mode 100644 HDOJ/5090_autoAC.cpp
 create mode 100644 HDOJ/5091_autoAC.cpp
 create mode 100644 HDOJ/5092_autoAC.cpp
 create mode 100644 HDOJ/5093_autoAC.cpp
 create mode 100644 HDOJ/5094_autoAC.cpp
 create mode 100644 HDOJ/5095_autoAC.cpp
 create mode 100644 HDOJ/5096_autoAC.cpp
 create mode 100644 HDOJ/5097_autoAC.cpp
 create mode 100644 HDOJ/5098_autoAC.cpp
 create mode 100644 HDOJ/5099_autoAC.cpp

diff --git a/HDOJ/5000_autoAC.cpp b/HDOJ/5000_autoAC.cpp
new file mode 100644
index 0000000..ee89dec
--- /dev/null
+++ b/HDOJ/5000_autoAC.cpp
@@ -0,0 +1,39 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std ;
+const int mod=1000000007 ;
+int T[2005],dp[2005][2005] ;
+int main()
+{
+    int t ;
+    scanf("%d",&t) ;
+    while(t--)
+    {
+        int n ;
+        scanf("%d",&n) ;
+        int sum=0 ;
+        for(int i=0 ;i<n ;i++)
+        {
+            scanf("%d",&T[i]) ;
+            sum+=T[i] ;
+        }
+        memset(dp,0,sizeof(dp)) ;
+        for(int i=0 ;i<=T[0] ;i++)
+            dp[0][i]=1 ;
+        sum>>=1 ;
+        for(int i=1 ;i<n ;i++)
+        {
+            for(int j=0 ;j<=sum ;j++)
+            {
+                for(int k=0 ;k<=T[i] ;k++)
+                {
+                    if(j<k)break ;
+                    dp[i][j]=(dp[i][j]+dp[i-1][j-k])%mod ;
+                }
+            }
+        }
+        printf("%d\n",dp[n-1][sum]) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5001_autoAC.cpp b/HDOJ/5001_autoAC.cpp
new file mode 100644
index 0000000..e7e7b66
--- /dev/null
+++ b/HDOJ/5001_autoAC.cpp
@@ -0,0 +1,62 @@
+#include <iostream>             
+#include <stdio.h>             
+#include <cmath>             
+#include <algorithm>             
+#include <iomanip>             
+#include <cstdlib>             
+#include <string>             
+#include <memory.h>             
+#include <vector>             
+#include <queue>             
+#include <stack>             
+#include <map>           
+#include <set>           
+#include <ctype.h>           
+#define INF 1000000000000000010LL        
+#define ll long long         
+#define max3(a,b,c) max(a,max(b,c))         
+using namespace std;
+vector<int> way[55];
+int cnt[55];
+double dp[10010][55];
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        memset(way,0,sizeof(way));
+        memset(cnt,0,sizeof(cnt));
+        int n,m,d;
+        cin>>n>>m>>d;
+        for(int i=1;i<=m;i++){
+            int u,v;
+            scanf("%d%d",&u,&v);
+            way[u].push_back(v);
+            way[v].push_back(u);
+            cnt[u]++;
+            cnt[v]++;
+        }
+        for(int i=1;i<=n;i++){
+            dp[0][i]=(1.0/n);  
+        }
+        for(int l=1;l<=n;l++){
+            for(int i=1;i<=d;i++){
+                for(int j=0;j<=n;j++)dp[i][j]=0.0;
+            }
+            for(int i=1;i<=d;i++){            
+                for(int j=1;j<=n;j++){
+                    if(j==l)continue;
+                    for(int k=0;k<cnt[j];k++){
+                        if(way[j][k]==l)continue;
+                        dp[i][way[j][k]]+=dp[i-1][j]/cnt[j];
+                    }
+                }
+            }
+            double ans=0;
+            for(int i=1;i<=n;i++){
+                ans+=dp[d][i];
+            }
+            printf("%.10lf\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5002_autoAC.cpp b/HDOJ/5002_autoAC.cpp
new file mode 100644
index 0000000..7c01f36
--- /dev/null
+++ b/HDOJ/5002_autoAC.cpp
@@ -0,0 +1,205 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+using namespace std;
+typedef long long LL;
+#define FOR(i, n) for(int i = 0; i < n; ++i)
+const int MAXV = 100010;
+const int MAXE = MAXV << 1;
+const int INF = 0x3f3f3f3f;
+const int NINF = -INF;
+struct LCT {
+    struct Node {
+        Node *ch[2], *fa;
+        int val, set, add;
+        int max[2], cnt[2], size;
+        bool rt, rev;
+    } statePool[MAXV], *nil;
+    int ncnt;
+    int head[MAXV], val[MAXV], ecnt;
+    int to[MAXE], next[MAXE];
+    int n, m, T;
+    Node *ptr[MAXV];
+    LCT() {
+        ptr[0] = nil = statePool;
+        nil->size = 0;
+        FOR(k, 2) nil->max[k] = NINF;
+    }
+    void init() {
+        memset(head + 1, -1, n * sizeof(int));
+        ncnt = 1;
+        ecnt = 0;
+    }
+    void add_edge(int u, int v) {
+        to[ecnt] = v; next[ecnt] = head[u]; head[u] = ecnt++;
+        to[ecnt] = u; next[ecnt] = head[v]; head[v] = ecnt++;
+    }
+    Node* new_node(int val, Node *f) {
+        Node* x = &statePool[ncnt++];
+        x->ch[0] = x->ch[1] = nil; x->fa = f;
+        x->val = val; x->set = NINF; x->add = 0;
+        x->max[0] = val; x->cnt[0] = 1;
+        x->max[1] = NINF;
+        x->size = 1;
+        x->rt = true; x->rev = false;
+        return x;
+    }
+    void dfs(int u, int f) {
+        ptr[u] = new_node(val[u], ptr[f]);
+        for(int p = head[u]; ~p; p = next[p]) {
+            int v = to[p];
+            if(v == f) continue;
+            dfs(v, u);
+        }
+    }
+    void get_max(int &a, int &b, int c) {
+        if(a != c) {
+            if(b < c) swap(b, c);
+            if(a < b) swap(a, b);
+        }
+    }
+    void cnt_max(int a, int &cnt, int b, int bcnt) {
+        if(a != NINF && a == b) cnt += bcnt;
+    }
+    void update(Node *x) {
+        x->size = x->ch[0]->size + x->ch[1]->size + 1;
+        x->max[0] = x->val; x->max[1] = NINF;
+        FOR(i, 2) FOR(j, 2)
+            get_max(x->max[0], x->max[1], x->ch[i]->max[j]);
+        FOR(k, 2) x->cnt[k] = 0;
+        FOR(k, 2) cnt_max(x->max[k], x->cnt[k], x->val, 1);
+        FOR(k, 2) FOR(i, 2) FOR(j, 2)
+            cnt_max(x->max[k], x->cnt[k], x->ch[i]->max[j], x->ch[i]->cnt[j]);
+    }
+    void rotate(Node *x) {
+        Node *y = x->fa;
+        int t = (y->ch[1] == x);
+        if(y->rt) y->rt = false, x->rt = true;
+        else y->fa->ch[y->fa->ch[1] == y] = x;
+        x->fa = y->fa;
+        (y->ch[t] = x->ch[t ^ 1])->fa = y;
+        (x->ch[t ^ 1] = y)->fa = x;
+        update(y);
+    }
+    void update_set(Node *x, int val) {
+        if(x == nil) return ;
+        x->add = 0;
+        x->val = x->set = val;
+        x->max[0] = val; x->cnt[0] = x->size;
+        x->max[1] = NINF;
+    }
+    void update_add(Node *x, int val) {
+        if(x == nil) return ;
+        x->add += val;
+        x->val += val;
+        FOR(k, 2) if(x->max[k] != NINF)
+            x->max[k] += val;
+    }
+    void update_rev(Node *x) {
+        if(x == nil) return ;
+        x->rev = !x->rev;
+        swap(x->ch[0], x->ch[1]);
+    }
+    void pushdown(Node *x) {
+        if(x->set != NINF) {
+            FOR(k, 2) update_set(x->ch[k], x->set);
+            x->set = NINF;
+        }
+        if(x->add != 0) {
+            FOR(k, 2) update_add(x->ch[k], x->add);
+            x->add = 0;
+        }
+        if(x->rev) {
+            FOR(k, 2) update_rev(x->ch[k]);
+            x->rev = false;
+        }
+    }
+    void push(Node *x) {
+        if(!x->rt) push(x->fa);
+        pushdown(x);
+    }
+    void splay(Node *x) {
+        push(x);
+        while(!x->rt) {
+            Node *f = x->fa, *ff = f->fa;
+            if(!f->rt) rotate(((ff->ch[1] == f) && (f->ch[1] == x)) ? f : x);
+            rotate(x);
+        }
+        update(x);
+    }
+    Node* access(Node *x) {
+        Node *y = nil;
+        while(x != nil) {
+            splay(x);
+            x->ch[1]->rt = true;
+            (x->ch[1] = y)->rt = false;
+            update(x);
+            y = x; x = x->fa;
+        }
+        return y;
+    }
+    void be_root(Node *x) {
+        access(x);
+        splay(x);
+        update_rev(x);
+    }
+    void link(Node *x, Node *y) {
+        be_root(x);
+        x->fa = y;
+    }
+    void cut(Node *x, Node *y) {
+        be_root(x);
+        access(x);
+        splay(y);
+        y->fa = nil;
+    }
+    void modify_add(Node *x, Node *y, int w) {
+        be_root(x);
+        update_add(access(y), w);
+    }
+    void modify_set(Node *x, Node *y, int w) {
+        be_root(x);
+        update_set(access(y), w);
+    }
+    void query(Node *x, Node *y) {
+        be_root(x);
+        Node *r = access(y);
+        if(r->max[1] == NINF) puts("ALL SAME");
+        else printf("%d %d\n", r->max[1], r->cnt[1]);
+    }
+    void work() {
+        scanf("%d", &T);
+        for(int t = 1; t <= T; ++t) {
+            scanf("%d%d", &n, &m);
+            init();
+            for(int i = 1; i <= n; ++i) scanf("%d", &val[i]);
+            for(int i = 1, u, v; i < n; ++i) {
+                scanf("%d%d", &u, &v);
+                add_edge(u, v);
+            }
+            dfs(1, 0);
+            printf("Case #%d:\n", t);
+            for(int i = 0, x, y, a, b, op; i < m; ++i) {
+                scanf("%d", &op);
+                if(op == 1) {
+                    scanf("%d%d%d%d", &x, &y, &a, &b);
+                    cut(ptr[x], ptr[y]);
+                    link(ptr[a], ptr[b]);
+                } else if(op == 2) {
+                    scanf("%d%d%d", &a, &b, &x);
+                    modify_set(ptr[a], ptr[b], x);
+                } else if(op == 3) {
+                    scanf("%d%d%d", &a, &b, &x);
+                    modify_add(ptr[a], ptr[b], x);
+                } else {
+                    scanf("%d%d", &a, &b);
+                    query(ptr[a], ptr[b]);
+                }
+            }
+        }
+    }
+} S;
+int main() {
+    S.work();
+}
diff --git a/HDOJ/5003_autoAC.cpp b/HDOJ/5003_autoAC.cpp
new file mode 100644
index 0000000..d6b339b
--- /dev/null
+++ b/HDOJ/5003_autoAC.cpp
@@ -0,0 +1,40 @@
+#include <cstdio>
+#include <iostream>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+double POW(int n)
+{
+    double s = 1;
+    for(int i = 1; i <= n; i++)
+    {
+        s*=0.95;
+    }
+    return s;
+}
+int main()
+{
+    int n;
+    int t;
+    double a[57];
+    while(~scanf("%d",&t))
+    {
+        while(t--)
+        {
+            scanf("%d",&n);
+            for(int i = 1; i <= n; i++)
+            {
+                scanf("%lf",&a[i]);
+            }
+            sort(a+1,a+n+1);
+            double ans = 0;
+            int j = 0;
+            for(int i = n; i >= 1; i--)
+            {
+                ans+=a[i]*POW(j++);
+            }
+            printf("%.10lf\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5004_autoAC.cpp b/HDOJ/5004_autoAC.cpp
new file mode 100644
index 0000000..3423633
--- /dev/null
+++ b/HDOJ/5004_autoAC.cpp
@@ -0,0 +1,102 @@
+#include <cstdio>
+#include <cstring>
+#include <queue>
+using namespace std;
+const int ROW = 16;
+const int COL = 10;
+const int dr[] = {-1, 0, 1, 0};
+const int dc[] = { 0, 1, 0,-1};
+struct Node {
+    int r,c;
+    Node() {}
+    Node(int _r,int _c) {
+        r = _r;
+        c = _c;
+    }
+};
+int n; 
+bool ok;
+char grid[ROW+1][COL+1];
+int ans[ROW*COL];
+bool full() {
+    for(int i = 1; i <= ROW; i++) {
+        for(int j = 1; j <= COL; j++) {
+            if(grid[i][j] != grid[1][1]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+void dfs(int x,int y,int cur) {
+    char now[ROW+1][COL+1];
+    int vis[ROW+1][COL+1];
+    if(cur == n) {
+        if(full()) {
+            ok = true;
+        }
+        return ;
+    }
+    int color = grid[x][y] - '0';
+    for(int i = 1; i <= 4; i++) { 
+        if(color == i) {
+            continue;
+        }
+        memset(vis,0,sizeof(vis));
+        memcpy(now,grid,sizeof(grid));
+        queue<Node> que;
+        que.push(Node(x,y));
+        vis[x][y] = true;
+        int r,c;
+        while(!que.empty()) {
+            Node front = que.front();
+            que.pop();
+            grid[front.r][front.c] = i + '0';
+            for(int d = 0; d < 4; d++) {
+                r = front.r + dr[d];
+                c = front.c + dc[d];
+                if(grid[r][c] - '0' != color || vis[r][c]) {
+                    continue;
+                }
+                vis[r][c] = true;
+                que.push(Node(r,c));
+            }
+        }
+        ans[cur] = i;
+        dfs(x,y,cur+1);
+        if(ok) {
+            return ;
+        }
+        memcpy(grid,now,sizeof(grid));
+    }
+}
+void solve() {
+    scanf("%d",&n);
+    memset(grid,0,sizeof(grid));
+    for(int i = 1; i <= ROW; i++) {
+        scanf("%s",grid[i]+1);
+    }
+    for(int i = 1; i <= ROW; i++) {
+        for(int j = 1; j <= COL; j++) {
+            if(grid[i-1][j] == grid[i][j] || grid[i][j-1] == grid[i][j]) {
+                continue;
+            }
+            ok = false;
+            dfs(i,j,0);
+            if(ok) {
+                for(int k = 0; k < n; k++) 
+                    printf("%d %d %d\n",ans[k],i,j);
+                return;
+            }
+        }
+    }
+}
+int main() {
+    int t,cas = 1;
+    scanf("%d",&t);
+    while(t--) {
+        printf("Case #%d:\n",cas++);
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/5005_autoAC.cpp b/HDOJ/5005_autoAC.cpp
new file mode 100644
index 0000000..c0b7814
--- /dev/null
+++ b/HDOJ/5005_autoAC.cpp
@@ -0,0 +1,134 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+#include <algorithm>
+#include <vector>
+#define maxn 210
+using namespace std;
+struct node{
+    int id,A,B;
+    node(){}
+    node(int x,int y,int z){
+        id=x,A=y,B=z;
+    }
+};
+vector<int> e[maxn];
+vector<node> vec;
+int bel[maxn],A[maxn],B[maxn],dp[maxn][2],vis[maxn];;
+bool cmp(const node &x,const node &y){
+    return x.B>y.B;
+}
+void init(int n){
+    for(int i=1;i<=n;i++)
+    e[i].clear();
+}
+void dfs1(int now){
+    if(dp[now][0]!=-1)
+    return;
+    if(bel[now]==-1){
+        dp[now][0]=A[now];
+        dp[now][1]=B[now];
+        return;
+    }
+    for(int i=0;i<e[now].size();i++){
+        int v=e[now][i];
+        dfs1(v);
+        if(bel[now]==0){
+            if(dp[v][0]>dp[now][0]){
+                dp[now][0]=dp[v][0];
+                dp[now][1]=dp[v][1];
+            }
+        }
+        else{
+            if(dp[v][1]>dp[now][1]){
+                dp[now][0]=dp[v][0];
+                dp[now][1]=dp[v][1];
+            }
+        }
+    }
+}
+int dfs2(int now,int limit){
+    if(vis[now]!=-1)
+    return vis[now];
+    if(bel[now]==-1){
+        if(A[now]>limit)
+        return vis[now]=0;
+        return vis[now]=1;
+    }
+    for(int i=0;i<e[now].size();i++){
+        int v=e[now][i];
+        dfs2(v,limit);
+    }
+    for(int i=0;i<e[now].size();i++){
+        int v=e[now][i];
+        if(bel[now]==0){
+            if(!vis[v])
+            return vis[now]=0;
+        }
+        else if(vis[v])
+        return vis[now]=1;
+    }
+    if(bel[now]==0)
+    return vis[now]=1;
+    return vis[now]=0;
+}
+int dfs3(int now,int limit){
+    if(bel[now]==-1){
+        return limit==A[now];
+    }
+    for(int i=0;i<e[now].size();i++){
+        int v=e[now][i];
+        if(vis[v]==1&&dfs3(v,limit))
+        return 1;
+    }
+    return 0;
+}
+int main()
+{
+    int ncase,n,num,x;
+    char typ[4];
+    scanf("%d",&ncase);
+    while(ncase--){
+        scanf("%d",&n);
+        init(n);
+        vec.clear();
+        memset(bel,-1,sizeof(bel));
+        memset(dp,-1,sizeof(dp));
+        for(int i=1;i<=n;i++){
+            scanf("%d",&num);
+            if(num==0){
+                scanf("%d%d",&A[i],&B[i]);
+                vec.push_back(node(i,A[i],B[i]));
+            }
+            else{
+                for(int j=0;j<num;j++){
+                    scanf("%d",&x);
+                    e[i].push_back(x);
+                }
+                scanf("%s",typ);
+                if(typ[0]=='A')
+                bel[i]=0;
+                else
+                bel[i]=1;
+            }
+        }
+        dfs1(1);
+        int ans1=dp[1][1];
+        sort(vec.begin(),vec.end(),cmp);
+        int ans2=-1;
+        for(int i=0;i<(int)vec.size();i++){
+            memset(vis,-1,sizeof(vis));
+            int now=vec[i].id;
+            if(dp[now][0]==-1)
+            continue;
+            if(dfs2(1,vec[i].A)){
+                if(dfs3(1,vec[i].A)){
+                    ans2=vec[i].B;
+                    break;
+                }
+            }
+        }
+        printf("%d %d\n",ans1,ans2);
+    }
+    return 0;
+}
diff --git a/HDOJ/5006_autoAC.cpp b/HDOJ/5006_autoAC.cpp
new file mode 100644
index 0000000..7d472c5
--- /dev/null
+++ b/HDOJ/5006_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cassert>
+#include <queue>
+#include <vector>
+#include <map>
+#include <set>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+#define rep(i,a,b) for(int i=(a);i<(int)(b);++i)
+#define rrep(i,b,a) for(int i=(b);i>=(int)(a);--i)
+#define eps 1e-8
+#define clr(a,x) memset(a,x,sizeof(a))
+#define LL long long
+const int maxn = 10000+5;
+int p[maxn];
+int find(int x)
+{
+    if (x == p[x]) return x;
+    return p[x] = find(p[x]);
+}
+int u[maxn*4],v[maxn*4],c[maxn*4];
+int id[maxn],tot;
+double A[500][500];
+int N,M,S,T;
+void input()
+{
+    scanf("%d%d%d%d",&N,&M,&S,&T);
+    rep(i,0,M)  scanf("%d%d%d",u+i,v+i,c+i);
+}
+void gauss(int n)
+{
+    int i , j , k , r;
+    for(i=0; i < n; ++i) {
+        r = i;
+        for(j = i+1; j <= n; ++j)
+        if (fabs(A[j][i]) > fabs(A[r][i])) r = j;
+        if (r != i) for(j = 0; j <= n; ++j) swap(A[r][j],A[i][j]);
+        for(j = i+1; j <= n; ++j) A[i][j] /= A[i][i];
+        A[i][i] = 1.0;
+        for(k = 0; k < n; ++k) {
+            if (fabs(A[k][i]) < eps || i == k) continue;
+            double f = A[k][i];
+            for(j = 0; j <= n; ++j) A[k][j] -= f * A[i][j];
+        }
+    }
+}
+void solve()
+{
+    rep(i,1,N+1) p[i] = i;
+    rep(i,0,M) if (c[i] == 0)
+        p[find(u[i])] = find(p[v[i]]); 
+    if (find(S) == find(T)) {
+        printf("0.000000\n");
+        return;
+    }
+    tot = 0;
+    rep(i,1,N+1)
+    if (find(i) == i) id[i] = tot++;
+    rep(i,1,N+1)
+    id[i] = id[find(i)];
+    rep(i,0,tot) p[i] = i;
+    rep(i,0,M) p[find(u[i])] = find(v[i]);
+    if (find(S) != find(T)) {
+        puts("inf");
+        return;
+    }
+    clr(A,0);
+    rep(i,0,M) {
+        if (id[u[i]] == id[v[i]]) continue;
+        int x = id[u[i]] , y = id[v[i]];
+        ++A[x][x]; --A[x][y];
+        ++A[y][y]; --A[y][x];
+    }
+    S = id[S]; T = id[T];
+    A[S][tot] = 1.0; A[T][tot] = -1.0;
+    A[tot-1][S]++;
+    gauss(tot);
+    printf("%.6lf\n",-A[T][tot] + A[S][tot] + eps);
+}
+int main()
+{
+    int T; cin >> T;
+    while (T--) {
+        input();
+        solve();
+    }
+}
diff --git a/HDOJ/5007_autoAC.cpp b/HDOJ/5007_autoAC.cpp
new file mode 100644
index 0000000..f8ec9e8
--- /dev/null
+++ b/HDOJ/5007_autoAC.cpp
@@ -0,0 +1,35 @@
+#include<cstdio>
+#include<cstring>
+char str[20000];
+int main()
+{
+    int i;
+    while(gets(str))
+    {
+        int len=strlen(str);
+        for(i=0; i<len; i++)
+        {
+            if(str[i]=='A' && str[i+1]=='p' && str[i+2]=='p' && str[i+3]=='l' && str[i+4]=='e')
+            {
+                printf("MAI MAI MAI!\n");
+            }
+            if(str[i]=='i' && str[i+1]=='P' && str[i+2]=='h' && str[i+3]=='o' && str[i+4]=='n'&&str[i+5] == 'e')
+            {
+                printf("MAI MAI MAI!\n");
+            }
+            if(str[i]=='i' && str[i+1]=='P' && str[i+2]=='a' && str[i+3]=='d')
+            {
+                printf("MAI MAI MAI!\n");
+            }
+            if(str[i]=='i' && str[i+1]=='P' && str[i+2]=='o' && str[i+3]=='d')
+            {
+                printf("MAI MAI MAI!\n");
+            }
+            if(str[i]=='S' && str[i+1]=='o' && str[i+2]=='n' && str[i+3]=='y')
+            {
+                printf("SONY DAFA IS GOOD!\n");
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5008_autoAC.cpp b/HDOJ/5008_autoAC.cpp
new file mode 100644
index 0000000..a02bc51
--- /dev/null
+++ b/HDOJ/5008_autoAC.cpp
@@ -0,0 +1,151 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+#define root 1,n,1
+#define lson l,mid,rt<<1
+#define rson mid+1,r,rt<<1|1
+#define M 120010
+#define INF 10000007
+using namespace std;
+typedef long long LL;
+LL ran[M],sa[M],X[M],Y[M],high[M],init[M];
+LL buc[M];
+struct SegmentTree{
+    LL Min[M << 2];
+    void pushup(LL rt){
+        Min[rt] = min(Min[rt<<1],Min[rt<<1|1]);
+    }
+    void build(LL l,LL r,LL rt){
+        if(l == r){
+            Min[rt] = sa[l];
+            return;
+        }
+        LL mid = (l + r) >> 1;
+        build(lson);
+        build(rson);
+        pushup(rt);
+    }
+    LL query(LL L,LL R,LL l,LL r,LL rt){
+        if(L <= l && r <= R){
+            return Min[rt];
+        }
+        LL mid = (l + r) >> 1;
+        LL ans = INF;
+        if(L <= mid) ans = min(query(L,R,lson),ans);
+        if(mid + 1 <= R) ans = min(query(L,R,rson),ans);
+        return ans;
+    }
+};
+SegmentTree sgt;
+void calhigh(LL n) {
+    LL i , j , k = 0;
+    for(i = 1 ; i <= n ; i++) ran[sa[i]] = i;
+    for(i = 0 ; i < n ; high[ran[i++]] = k)
+        for(k?k--:0 , j = sa[ran[i]-1] ; init[i+k] == init[j+k] ; k++);
+}
+bool cmp(LL *r,LL a,LL b,LL l) {
+    return (r[a] == r[b] && r[a+l] == r[b+l]);
+}
+void suffix(LL n,LL m = 128) {
+    LL i , l , p , *x = X , *y = Y;
+    for(i = 0 ; i < m ; i ++) buc[i] = 0;
+    for(i = 0 ; i < n ; i ++) buc[ x[i] = init[i]  ] ++;
+    for(i = 1 ; i < m ; i ++) buc[i] += buc[i-1];
+    for(i = n - 1; i >= 0 ; i --) sa[ --buc[ x[i] ]] = i;
+    for(l = 1,p = 1 ; p < n ; m = p , l *= 2) {
+        p = 0;
+        for(i = n-l ; i < n ; i ++) y[p++] = i;
+        for(i = 0 ; i < n ; i ++) if(sa[i] >= l) y[p++] = sa[i] - l;
+        for(i = 0 ; i < m ; i ++) buc[i] = 0;
+        for(i = 0 ; i < n ; i ++) buc[ x[y[i]] ] ++;
+        for(i = 1 ; i < m ; i ++) buc[i] += buc[i-1];
+        for(i = n - 1; i >= 0 ; i --) sa[ --buc[ x[y[i]] ] ] = y[i];
+        for(swap(x,y) , x[sa[0]] = 0 , i = 1 , p = 1 ; i < n ; i ++)
+            x[ sa[i] ] = cmp(y,sa[i-1],sa[i],l) ? p-1 : p++;
+    }
+    calhigh(n-1);
+}
+LL Log[M];
+LL best[20][M];
+void initRMQ(LL n) {
+    for(LL i = 1; i <= n ; i ++) best[0][i] = high[i];
+    for(LL i = 1; i <= Log[n] ; i ++) {
+        LL limit = n - (1<<i) + 1;
+        for(LL j = 1; j <= limit ; j ++) {
+            best[i][j] = min(best[i-1][j] , best[i-1][j+(1<<i>>1)]);
+        }
+    }
+}
+LL lcp(LL a,LL b) {
+    if(a>b)return 0;
+    LL t = Log[b - a + 1];
+    return min(best[t][a] , best[t][b - (1<<t) + 1]);
+}
+char str[M];
+LL dlen[M];
+void getlen(LL n,LL len){
+    for(LL i=1;i<=n;i++){
+        dlen[i]=len-sa[i]-high[i];
+    }
+    for(LL i=1;i<=n;i++){
+        dlen[i]+=dlen[i-1];
+    }
+}
+void findK(LL n,LL k,LL &start,LL &len){
+    if(k>dlen[n]||k<=0){
+        start=len=0;
+        return ;
+    }
+    LL l=1,r=n;
+    while(l<=r){
+        LL mid=(l+r)>>1;
+        if(dlen[mid]>=k) r=mid-1;
+        else l=mid+1;
+    }
+    start=l;
+    len=k-dlen[start-1]+high[start];
+}
+LL findLcp(LL start,LL len,LL n){
+    LL l=start + 1,r=n;
+    while(l<=r){
+        LL mid=(l+r)>>1;
+        if(lcp(start+1,mid)>=len)l=mid+1;
+        else r=mid-1;
+    }
+    return sgt.query(start,r,root);
+}
+int main() {
+    LL l,r,q;
+    LL v,u;
+    LL start,llen;
+    Log[0] = -1;
+    for(LL i = 1; i < M ; i ++) {
+        Log[i] = (i&(i-1)) ? Log[i-1] : Log[i-1] + 1 ;
+    }
+    while(scanf("%s",str)!=EOF){
+        l = r  = 0;
+        LL n=strlen(str);
+        for(LL i=0;i<n;i++)init[i]=str[i];
+        init[n]=0;
+        suffix(n+1);
+        initRMQ(n);
+        getlen(n,n);
+        sgt.build(root);
+        scanf("%I64d",&q);
+        for(LL i=1;i<=q;i++){
+            scanf("%I64d",&v);
+            u=(l^r^v)+1;
+            findK(n,u,start,llen);
+            if(llen==0&&start==0){
+                l=0,r=0;
+                printf("0 0\n");
+                continue;
+            }
+            LL ans=findLcp(start,llen,n);
+            l=ans;r=ans+llen-1;
+            l++;r++;
+            printf("%I64d %I64d\n",l,r);
+        }
+    }
+}
diff --git a/HDOJ/5009_autoAC.cpp b/HDOJ/5009_autoAC.cpp
new file mode 100644
index 0000000..1d29114
--- /dev/null
+++ b/HDOJ/5009_autoAC.cpp
@@ -0,0 +1,89 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <vector>
+using namespace std ;
+const int INF=0xfffffff ;
+int n,dp[50005] ;
+struct node 
+{
+    int num ;
+    int id,rank ;
+}kk[50005] ;
+int a[50005] ;
+int vis[50005] ;
+int cmp1(node aa,node bb)
+{
+    return aa.num<bb.num ;
+}
+int cmp2(node aa,node bb)
+{
+    return aa.id<bb.id ;
+}
+int main()
+{
+    while(~scanf("%d",&n))
+    {
+        for(int i=1 ;i<=n ;i++)
+        {
+            scanf("%d",&a[i]) ;
+        }
+        int m=n ;
+        for(int i=2 ;i<=n ;i++)
+        {
+            if(a[i]==a[i-1])
+            {
+                m-- ;
+            }
+        }
+        int cnt=2 ;
+        kk[1].id=1 ;kk[1].num=a[1] ;
+        for(int i=2 ;i<=n ;i++)
+        {
+            if(a[i]!=a[i-1])
+            {
+                kk[cnt].id=cnt ;
+                kk[cnt].num=a[i] ;
+                cnt++ ;
+            }
+        }
+        sort(kk+1,kk+1+m,cmp1) ;
+        kk[1].rank=1 ;
+        cnt=2 ;
+        for(int i=2 ;i<=m ;i++)
+        {
+            if(kk[i].num!=kk[i-1].num)
+            {
+                kk[i].rank=cnt++ ;
+            }
+            else kk[i].rank=kk[i-1].rank ;
+        }
+        sort(kk+1,kk+1+m,cmp2) ;
+        for(int i=0 ;i<50005 ;i++)
+            dp[i]=INF ;
+        dp[0]=0 ;
+        dp[m]=m ;
+        vector <int> v ;
+        for(int i=0 ;i<m ;i++)
+        {
+            cnt=0 ;
+            for(int j=i+1 ;j<=m ;j++)
+            {
+                if(!vis[kk[j].rank])
+                {
+                    v.push_back(kk[j].rank) ;
+                    vis[kk[j].rank]=1 ;
+                    cnt++ ;
+                }
+                if(dp[i]+cnt*cnt>=dp[m])break ;
+                dp[j]=min(dp[j],dp[i]+cnt*cnt) ;
+            }
+            for(int j=0 ;j<v.size() ;j++)
+                vis[v[j]]=0 ;
+            v.clear() ;
+        }
+        printf("%d\n",dp[m]) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5010_autoAC.cpp b/HDOJ/5010_autoAC.cpp
new file mode 100644
index 0000000..91354cb
--- /dev/null
+++ b/HDOJ/5010_autoAC.cpp
@@ -0,0 +1,223 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<queue>
+#include<map>
+#include<set>
+#include<time.h>
+#include<string>
+#define REP(i,n) for(int i=0;i<n;++i)
+#define REP1(i,a,b) for(int i=a;i<=b;++i)
+#define REP2(i,a,b) for(int i=a;i>=b;--i)
+#define MP make_pair
+#define LL long long
+#define ULL unsigned long long
+#define X first
+#define Y second
+#define MAXN 1000050
+using namespace std;
+map<ULL, int> mp;
+int dx[] = { 0, 0, 1, -1 };
+int dy[] = { 1, -1, 0, 0 };
+char s[6][9];
+int id[6][9];
+int qx[100];
+int qy[100];
+int qcnt;
+ULL q[MAXN];
+ULL bas[100];
+struct node {
+    char a[6][9];
+    int scnt;
+    node() {
+    }
+    ;
+    node(ULL now) {
+        scnt = 0;
+        REP(i,6)
+            REP(j,8)
+                a[i][j] = s[i][j];
+        REP(i,qcnt)
+        {
+            ULL k = now & 3;
+            now >>= 2;
+            if (k == 0)
+                continue;
+            if (k == 1) {
+                a[qx[i]][qy[i]] = 'S';
+                scnt++;
+            }
+            if (k == 2)
+                a[qx[i]][qy[i]] = 'M';
+            if (k == 3)
+                a[qx[i]][qy[i]] = 'P';
+        }
+    }
+};
+void init() {
+    qcnt = 0;
+    int cid = 0;
+    memset(id, -1, sizeof(id));
+    REP(i,6)
+        REP(j,8)
+        {
+            if (s[i][j] == '#' || s[i][j] == 'N')
+                continue;
+            qx[qcnt] = i;
+            qy[qcnt++] = j;
+            id[i][j] = cid++;
+        }
+}
+ULL geths(char s[6][9]) {
+    ULL ans = 0;
+    REP(i,6)
+        REP(j,8)
+        {
+            if (s[i][j] == 'S') {
+                ans += bas[id[i][j] << 1];
+                continue;
+            }
+            if (s[i][j] == 'M') {
+                ans += 2 * bas[id[i][j] << 1];
+                continue;
+            }
+            if (s[i][j] == 'P') {
+                ans += 3 * bas[id[i][j] << 1];
+            }
+        }
+    return ans;
+}
+bool check(int x, int y) {
+    if (x < 0 || x >= 6 || y < 0 || y >= 8)
+        return false;
+    return true;
+}
+node move(node a, int x, int y, int dxx, int dyy, int &p) {
+    char c = a.a[x][y];
+    while (true) {
+        int xx = x + dxx;
+        int yy = y + dyy;
+        if ((!check(xx, yy)) || a.a[xx][yy] != '.') {
+            p = 1;
+            return a;
+        }
+        a.a[xx][yy] = a.a[x][y];
+        a.a[x][y] = '.';
+        if (c == 'P') {
+            int flag=0;
+            for (int j = 0; j < 4; ++j) {
+                int px = xx + dx[j];
+                int py = yy + dy[j];
+                if (!check(px, py))
+                    continue;
+                if (a.a[px][py] == 'N') {
+                    p = 0;
+                    return a;
+                }
+                if (a.a[px][py] == 'S' || a.a[px][py] == 'M') {
+                    if (a.a[px][py] == 'S') {
+                        a.scnt--;
+                        if (a.scnt == 0) {
+                            p = 0;
+                            return a;
+                        }
+                    }
+                    a.a[px][py] = '.';
+                    flag=1;
+                }
+            }
+            if(flag)
+            {
+                p=1;
+                return a;
+            }
+        } else {
+            for (int i = 0; i < 4; ++i) {
+                int px = xx + dx[i];
+                int py = yy + dy[i];
+                if (!check(px, py))
+                    continue;
+                if (a.a[px][py] == 'P') {
+                    if (c == 'S') {
+                        a.scnt--;
+                        if (a.scnt == 0) {
+                            p = 0;
+                            return a;
+                        }
+                    }
+                    a.a[xx][yy] = '.';
+                    p = 1;
+                    return a;
+                }
+            }
+            for (int i = 0; i < 4; ++i) {
+                int px = xx + dx[i];
+                int py = yy + dy[i];
+                if (!check(px, py))
+                    continue;
+                if (a.a[px][py] == 'N') {
+                    if (c == 'S') {
+                        p = 2;
+                        return a;
+                    }
+                    p = 0;
+                    return a;
+                }
+            }
+        }
+        x = xx;
+        y = yy;
+    }
+    return a;
+}
+int d[MAXN];
+int bfs(ULL st) {
+    int tail = 0;
+    d[0] = 0;
+    q[tail++] = st;
+    mp.clear();
+    mp[st] = 1;
+    for (int i = 0; i < tail; ++i) {
+        node a = node(q[i]);
+        REP(j,6)
+            REP(k,8)
+            {
+                if (a.a[j][k] == 'S' || a.a[j][k] == 'M' || a.a[j][k] == 'P') {
+                    for (int x = 0; x < 4; ++x) {
+                        int p;
+                        node e = move(a, j, k, dx[x], dy[x], p);
+                        if (p == 2) {
+                            return d[i] + 1;
+                        }
+                        if (p == 1) {
+                            ULL hs = geths(e.a);
+                            if (mp.find(hs) == mp.end()) {
+                                mp[hs] = 1;
+                                q[tail] = hs;
+                                d[tail++] = d[i] + 1;
+                            }
+                        }
+                    }
+                }
+            }
+    }
+    printf("tail:%d\n",tail);
+    return -1;
+}
+int main() {
+    bas[0] = 1;
+    for (int i = 1; i <= 64; ++i)
+        bas[i] = bas[i - 1] * 2;
+    while(scanf(" %s",s[0])!=EOF){
+        for(int i=1;i<6;++i)scanf(" %s",s[i]);
+        init();
+        ULL hs=geths(s);
+        REP(i,6)REP(j,8)if(s[i][j]=='S'||s[i][j]=='M'||s[i][j]=='P')s[i][j]='.';
+        int ans=bfs(hs);
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5011_autoAC.cpp b/HDOJ/5011_autoAC.cpp
new file mode 100644
index 0000000..4fb4c94
--- /dev/null
+++ b/HDOJ/5011_autoAC.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <cstring>
+#include <queue>
+#include <stack>
+#include <vector>
+#include <set>
+#include <map>
+const int inf=0xfffffff;
+typedef long long ll;
+using namespace std;
+int main()
+{
+    int n;
+    ll a, s;
+    while(~scanf("%d", &n)){
+        scanf("%I64d", &s);
+        for(int i=1; i<n; i++){
+            scanf("%I64d", &a);
+            s ^= a;
+        }
+        if(!s) printf("Lose\n");
+        else printf("Win\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5012_autoAC.cpp b/HDOJ/5012_autoAC.cpp
new file mode 100644
index 0000000..d0c9809
--- /dev/null
+++ b/HDOJ/5012_autoAC.cpp
@@ -0,0 +1,93 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <iostream>
+using namespace std;
+struct node
+{
+    int s1,s2,s3,s4,s5,s6;
+    int sum;
+} q[800000];
+int a[7],b[7];
+int c[7][7][7][7][7][7];
+void bfs()
+{
+    memset(c,0,sizeof(c));
+    struct node t,r;
+    t.s1=b[1];
+    t.s2=b[2];
+    t.s3=b[3];
+    t.s4=b[4];
+    t.s5=b[5];
+    t.s6=b[6];
+    t.sum=0;
+    int k=0,l=0;
+    q[l++]=t;
+    while(k<l)
+    {
+        t=q[k++];
+        if(t.s1==a[1] && t.s2==a[2] && t.s3==a[3] && t.s4==a[4] && t.s5==a[5] && t.s6==a[6])
+        {
+            printf("%d\n",t.sum);
+            return ;
+        }
+        for(int i=0; i<4; i++)
+        {
+            if(i==0)
+            {
+                r.s1=t.s4;
+                r.s2=t.s3;
+                r.s3=t.s1;
+                r.s4=t.s2;
+                r.s5=t.s5;
+                r.s6=t.s6;
+            }
+            else if(i==1)
+            {
+                r.s1=t.s3;
+                r.s2=t.s4;
+                r.s3=t.s2;
+                r.s4=t.s1;
+                r.s5=t.s5;
+                r.s6=t.s6;
+            }
+            else if(i==2)
+            {
+                r.s1=t.s5;
+                r.s2=t.s6;
+                r.s3=t.s3;
+                r.s4=t.s4;
+                r.s5=t.s2;
+                r.s6=t.s1;
+            }
+            else
+            {
+                r.s1=t.s6;
+                r.s2=t.s5;
+                r.s3=t.s3;
+                r.s4=t.s4;
+                r.s5=t.s1;
+                r.s6=t.s2;
+            }
+            if(!c[r.s1][r.s2][r.s3][r.s4][r.s5][r.s6])
+            {
+                c[r.s1][r.s2][r.s3][r.s4][r.s5][r.s6]=1;
+                r.sum=t.sum+1;
+                q[l++]=r;
+            }
+        }
+    }
+    printf("-1\n");
+}
+int main()
+{
+    while(~scanf("%d",&a[1]))
+    {
+        for(int i=2; i<=6; i++)
+            scanf("%d",&a[i]);
+        for(int i=1; i<=6; i++)
+        scanf("%d",&b[i]);
+          bfs();
+    }
+    return 0;
+}
diff --git a/HDOJ/5013_autoAC.cpp b/HDOJ/5013_autoAC.cpp
new file mode 100644
index 0000000..f4b299b
--- /dev/null
+++ b/HDOJ/5013_autoAC.cpp
@@ -0,0 +1,69 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <cstring>
+#include <string>
+#include <queue>
+#include <stack>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define RD(x) scanf("%d",&x)
+#define RD2(x,y) scanf("%d%d",&x,&y)
+#define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
+#define clr0(x) memset(x,0,sizeof(x))
+typedef long long LL;
+const int maxn = 20;
+int n, m;
+double p[maxn][maxn],h[maxn][maxn],f[maxn][maxn][maxn],g[maxn][maxn][maxn];
+int main() {
+    while (~RD2(m,n)) {
+        for (int i = 1; i <= m; i++) {
+            scanf("%lf", &p[i][1]);
+            p[i][0] = 1.0;
+            for (int j = 2; j <= n; j++) {
+                p[i][j] = p[i][j - 1] * p[i][1];
+            }
+        }
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                scanf("%lf", &h[i][j]);
+            }
+        }
+        clr0(f),clr0(g);
+        double ans = 0;
+        for (int i = 2; i <= n; i++) {
+            f[i][0][0] = 1;
+            for (int j = 1; j <= m; j++) {
+                for (int x = m; x >= 0; x--) {
+                    for (int y = x; y >= 0; y--) {
+                        f[i][x][y] *= (1.0 - p[j][i - 2]);
+                        if (x > 0) {
+                            f[i][x][y] += f[i][x - 1][y] * p[j][i - 2] * (1.0 - p[j][1]);
+                            if (y > 0) {
+                                f[i][x][y] += f[i][x - 1][y - 1] * p[j][i - 1];
+                            }
+                        }
+                        g[i][x][y] *= (1.0 - p[j][i - 2]);
+                        if (x > 0) {
+                            g[i][x][y] += g[i][x - 1][y] * p[j][i - 2] * (1.0 - p[j][1]);
+                            if (y > 0) {
+                                g[i][x][y] += (g[i][x - 1][y - 1] + f[i][x - 1][y - 1] * h[j][i]) * p[j][i - 1];
+                            }
+                        }
+                    }
+                }
+            }
+            for (int x = 1; x <= m; x++) {
+                for (int y = 1; y <= x; y++) {
+                    ans += g[i][x][y] * ((double)y / x + 1.0);
+                }
+            }
+        }
+        for (int i = 1; i <= m; i++) {
+            ans += h[i][1];
+        }
+        printf("%.10f\n", ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5014_autoAC.cpp b/HDOJ/5014_autoAC.cpp
new file mode 100644
index 0000000..21b51b6
--- /dev/null
+++ b/HDOJ/5014_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <queue>
+#include <stack>
+#include <map>
+#include <algorithm>
+using namespace std;
+#define ll __int64
+#define up(i,x,y) for(i=x;i<=y;i++)
+#define up2(i,x,y) for(i=x;y;i++)
+#define down(i,x,y) for(i=x;i>=y;i--)
+#define down2(i,x,y) for(i=x;y;i--)
+#define mem(a,b) memset(a,b,sizeof(a))
+#define s(a) scanf("%d",&a)
+#define s64(a) scanf("%I64d",&a)
+#define w(a) while(a)
+int n,a[100005],i,has[100005];
+int main()
+{
+    w(~s(n))
+    {
+        up(i,0,n)
+        s(a[i]);
+        printf("%I64d\n",(ll)n*n+n);
+        mem(has,-1);
+        down(i,n,0)
+        {
+            if(has[i]>=0) continue;
+            int num=0,s=1,t=i;
+            w(t)
+            {
+                int tem=((t&1)^1);
+                num=num+s*tem;
+                s*=2;
+                t=t/2;
+            }
+            has[num]=i;
+            has[i]=num;
+        }
+        printf("%d",has[a[0]]);
+        up(i,1,n)
+        printf(" %d",has[a[i]]);
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5015_autoAC.cpp b/HDOJ/5015_autoAC.cpp
new file mode 100644
index 0000000..6c1991b
--- /dev/null
+++ b/HDOJ/5015_autoAC.cpp
@@ -0,0 +1,89 @@
+#include<stdio.h>
+#include<iostream>
+#include<stdlib.h>
+#include<string.h>
+#include<algorithm>
+#include<vector>
+#include<math.h>
+#include<queue>
+#include<stack>
+#include<map>
+#pragma comment(linker, "/STACK:1024000000,1024000000")
+using namespace std;
+#define maxn 110000
+#define mod 10000007
+#define LL __int64
+struct matrix
+{
+    LL mat[15][15];
+    matrix()
+    {
+        memset(mat,0,sizeof(mat));
+    }
+};
+int a[11];
+int n;
+matrix mul(matrix A,matrix B)
+{
+    matrix C;
+    int i,j,k;
+    for(i=1; i<=n+2; i++)
+    {
+        for(j=1; j<=n+2; j++)
+        {
+            for(k=1; k<=n+2; k++)
+            {
+                C.mat[i][j]=(C.mat[i][j]+A.mat[i][k]*B.mat[k][j])%mod;
+            }
+        }
+    }
+    return C;
+}
+matrix powmul(matrix A,int k)
+{
+    matrix B;
+    for(int i=1;i<=n+2;i++)B.mat[i][i]=1;
+    while(k>=1)
+    {
+        if(k&1)B=mul(B,A);
+        A=mul(A,A);
+        k=k/2;
+    }
+    return B;
+}
+void print(matrix A)
+{
+    cout<<"matrix A"<<endl;
+    for(int i=1;i<=n+2;i++)
+    {
+        for(int j=1;j<=n+2;j++)
+        {
+            cout<<A.mat[i][j]<<" ";
+        }
+        cout<<endl;
+    }
+}
+int main()
+{
+    int m;
+    while(~scanf("%d%d",&n,&m))
+    {
+        matrix A,B;
+        A.mat[1][1]=23;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&A.mat[i+1][1]);
+        }
+        A.mat[n+2][1]=3;
+        for(int i=1;i<=n+1;i++)B.mat[i][1]=10;
+        for(int i=1;i<=n+2;i++)B.mat[i][n+2]=1;
+        for(int i=2;i<=n+1;i++)
+        {
+            for(int j=2;j<=i;j++)B.mat[i][j]=1;
+        }
+        B=powmul(B,m);
+        A=mul(B,A);
+        cout<<A.mat[n+1][1]<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5016_autoAC.cpp b/HDOJ/5016_autoAC.cpp
new file mode 100644
index 0000000..8581a21
--- /dev/null
+++ b/HDOJ/5016_autoAC.cpp
@@ -0,0 +1,156 @@
+#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;
+const int INF = 0x3f3f3f3f;
+struct Edge{
+    int to,next,w;
+}edge[MAXN*2];
+int head[MAXN],tot;
+void init(){
+    tot = 0;
+    memset(head,-1,sizeof(head));
+}
+inline void addedge(int u,int v,int w){
+    edge[tot].to = v;
+    edge[tot].w = w;
+    edge[tot].next = head[u];
+    head[u] = tot++;
+}
+int size[MAXN],vis[MAXN],fa[MAXN],que[MAXN];
+int TT;
+inline int getroot(int u){
+    int Min = MAXN, root = 0;
+    int l,r;
+    que[l = r = 1] = u;
+    fa[u] = 0;
+    for(;l <= r;l++)
+        for(int i = head[que[l]]; i != -1;i = edge[i].next){
+            int v = edge[i].to;
+            if(v == fa[que[l]] || vis[v] == TT)continue;
+            que[++r] = v;
+            fa[v] = que[l];
+        }
+    for(l--;l;l--){
+        int x = que[l], Max = 0;
+        size[x] = 1;
+        for(int i = head[x];i != -1;i = edge[i].next){
+            int v = edge[i].to;
+            if(v == fa[x] || vis[v] == TT)continue;
+            Max = max(Max,size[v]);
+            size[x] += size[v];
+        }
+        Max = max(Max,r - size[x]);
+        if(Max < Min){
+            Min = Max; root = x;
+        }
+    }
+    return root;
+}
+int ans[MAXN];
+pair<int,int>pp[MAXN];
+pair<int,int>np[MAXN];
+int dis[MAXN];
+int type[MAXN];
+inline void go(int u,int pre,int w,int tt){
+    int l,r;
+    que[l = r = 1] = u;
+    fa[u] = pre; dis[u] = w;
+    for(;l <= r;l++)
+        for(int i = head[que[l]];i != -1;i = edge[i].next){
+            int v = edge[i].to;
+            if(v == fa[que[l]] || vis[v] == TT)continue;
+            que[++r] = v;
+            fa[v] = que[l];
+            dis[v] = dis[que[l]] + edge[i].w;
+        }
+    int cnt = 0;
+    for(int i = 1;i <= r;i++){
+        int x = que[i];
+        pp[cnt++] = make_pair(np[x].first-dis[x],np[x].second);
+    }
+    sort(pp,pp+cnt);
+    for(int i = 1;i <= r;i++){
+        int x = que[i];
+        if(type[x])continue;
+        int id = lower_bound(pp,pp+cnt,make_pair(dis[x],x)) - pp;
+        ans[x] += (cnt-id)*tt;
+    }
+}
+void solve(int u){
+    int root = getroot(u);
+    vis[root] = TT;
+    go(root,0,0,1);
+    for(int i = head[root];i != -1;i = edge[i].next){
+        int v = edge[i].to;
+        if(vis[v] == TT)continue;
+        go(v,root,edge[i].w,-1);
+    }
+    for(int i = head[root];i != -1;i = edge[i].next){
+        int v = edge[i].to;
+        if(vis[v] == TT)continue;
+        solve(v);
+    }
+}
+bool ff[MAXN];
+int main()
+{
+    int n;
+    memset(vis,0,sizeof(vis));
+    TT = 0;
+    while(scanf("%d",&n) == 1){
+        init();
+        int u,v,w;
+        for(int i = 1;i < n;i++){
+            scanf("%d%d%d",&u,&v,&w);
+            addedge(u,v,w);
+            addedge(v,u,w);
+        }
+        for(int i = 1;i <= n;i++)scanf("%d",&type[i]);
+        queue<int>q;
+        for(int i = 1;i <= n;i++){
+            if(type[i]){
+                np[i] = make_pair(0,i);
+                ff[i] = true;
+                q.push(i);
+            }
+            else{
+                np[i] = make_pair(INF,0);
+                ff[i] = false;
+            }
+        }
+        while(!q.empty()){
+            u = q.front();
+            q.pop();
+            ff[u] = false;
+            for(int i = head[u];i != -1;i = edge[i].next){
+                v = edge[i].to;
+                pair<int,int>tmp = make_pair(np[u].first+edge[i].w,np[u].second);
+                if(tmp < np[v]){
+                    np[v] = tmp;
+                    if(!ff[v]){
+                        ff[v] = true;
+                        q.push(v);
+                    }
+                }
+            }
+        }
+        TT++;
+        for(int i = 1;i <= n;i++)ans[i] = 0;
+        solve(1);
+        int ret = 0;
+        for(int i = 1;i <= n;i++)ret = max(ret,ans[i]);
+        printf("%d\n",ret);
+    }
+    return 0;
+}
diff --git a/HDOJ/5017_autoAC.cpp b/HDOJ/5017_autoAC.cpp
new file mode 100644
index 0000000..898c709
--- /dev/null
+++ b/HDOJ/5017_autoAC.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#define Mod 1000000007
+#define eps 1e-8
+using namespace std;
+int dx[8] = {0,0,1,-1,1,-1,1,-1};
+int dy[8] = {1,-1,0,0,1,1,-1,-1};
+double a,b,c,d,e,f;
+double dis(double x,double y,double z)
+{
+    return sqrt(x*x + y*y + z*z);
+}
+double calc(double x,double y)
+{
+    double A = c;
+    double B = d*y+e*x;
+    double C = f*x*y + a*x*x + b*y*y - 1.0;
+    double delta = B*B-4.0*A*C;
+    if(delta < 0.0) return Mod+10.0;    
+    delta = sqrt(delta);
+    double soz1 = (-B + delta)/(2.0*A);
+    double soz2 = (-B - delta)/(2.0*A);
+    if(dis(x,y,soz1) < dis(x,y,soz2))
+        return soz1;
+    return soz2;
+}
+double Simulated_Annealing()
+{
+    double x = 0,y = 0,z = sqrt(1.0/c);  
+    double step = 1.0, rate = 0.99;
+    while(step > eps)
+    {
+        for(int k=0;k<8;k++)
+        {
+            double kx = x + step*dx[k];
+            double ky = y + step*dy[k];
+            double kz = calc(kx,ky);
+            if(kz >= Mod) continue;
+            if(dis(kx,ky,kz) < dis(x,y,z))
+            {
+                x = kx,y = ky,z = kz;
+            }
+        }
+        step *= rate;
+    }
+    return dis(x,y,z);
+}
+int main()
+{
+    while(scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&e,&f)!=EOF)
+    {
+        printf("%.7f\n",Simulated_Annealing());
+    }
+    return 0;
+}
diff --git a/HDOJ/5018_autoAC.cpp b/HDOJ/5018_autoAC.cpp
new file mode 100644
index 0000000..af2c6e1
--- /dev/null
+++ b/HDOJ/5018_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<cstdio>
+#include<iostream>
+#include<cmath>
+#include<algorithm>
+#include<cstring>
+using namespace std;
+int main()
+{
+    int F[1000];
+    int A,B,C,T,i;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d",&A,&B,&C);
+        F[0]=A,F[1]=B;
+        int flag=0;
+        for(i=2;;i++)
+        {
+            F[i]=F[i-1]+F[i-2];
+            if(F[i]==C)
+            {
+                flag=1;
+                break;
+            }
+            if(F[i]>C)
+            {
+                break;
+            }
+        }
+        if(F[0]==C||F[1]==C) flag=1;
+        if(flag==1)
+        {
+            printf("Yes\n");
+        }
+        else
+        {
+            printf("No\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5019_autoAC.cpp b/HDOJ/5019_autoAC.cpp
new file mode 100644
index 0000000..929230d
--- /dev/null
+++ b/HDOJ/5019_autoAC.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <cstdio>
+#include <cstdlib>
+using namespace std;
+typedef __int64 LL;
+LL gcd(LL a, LL b)
+{
+    if(b==0)
+        return a;
+    return gcd(b, a%b);
+}
+int main()
+{
+    LL a, b, c;
+    int T;
+    vector<LL> v;
+    scanf("%d", &T);
+    while(T--)
+    {
+        scanf("%I64d%I64d%I64d", &a, &b, &c);
+        LL temp = gcd(a, b);
+        v.clear();
+        int cnt = 0;
+        for(LL i=1; i*i<=temp; ++i)
+        {
+            if(temp%i==0)
+             {
+                 v.push_back(i);
+                 if(i*i!=temp)
+                    v.push_back(temp/i);
+             }
+        }
+        sort(v.begin(), v.end());
+        if(v.size() >= c)
+            printf("%I64d\n", v[v.size()-c]);
+        else
+            printf("-1\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5020_autoAC.cpp b/HDOJ/5020_autoAC.cpp
new file mode 100644
index 0000000..9340475
--- /dev/null
+++ b/HDOJ/5020_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <cstring>
+#include <string>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include <set>
+#include <queue>
+#include <map>
+using namespace std;
+#define INF 1e9
+#define maxn 1010
+#define rep(i,x,y) for(int i=x;i<=y;i++)
+#define mset(x) memset(x,0,sizeof(x))
+typedef pair<int, int> pii;
+int t, n;
+struct point{
+    int x, y;
+}p[maxn];
+map< pii, int > tb;
+map< pii, int >::iterator it;
+bool cmp(const point& a, const point& b){
+    return (a.x==b.x&&a.y<b.y) || a.x<b.x;
+}
+int gcd(int a, int b){
+    if(b==0) return a;
+    return gcd(b, a%b);
+}
+int main(){
+    cin>>t;
+    while(t--){
+        cin>>n;
+        rep(i,1,n)    scanf("%d%d", &p[i].x, &p[i].y);
+        sort(p+1, p+n+1, cmp);                
+        int cnt=0;
+        rep(i,1,n-2){
+            tb.clear();
+            rep(j,i+1,n){
+                int dx = p[j].x - p[i].x;
+                int dy = p[j].y - p[i].y;
+                int d = gcd(dx, dy);
+                dx = dx/d;
+                dy = dy/d;
+                tb[make_pair(dx,dy)]++;
+            }
+            for(it=tb.begin(); it!=tb.end(); it++){
+                int x = it->second;
+                if(x>=2)    
+                    cnt += x*(x-1)/2; //C(x,2)
+            }
+        }
+        cout<<cnt<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5021_autoAC.cpp b/HDOJ/5021_autoAC.cpp
new file mode 100644
index 0000000..bff1d0c
--- /dev/null
+++ b/HDOJ/5021_autoAC.cpp
@@ -0,0 +1,106 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std ;
+typedef long long LL ;
+#define travel( e , H , u ) for ( Edge* e = H[u] ; e ; e = e -> next )
+#define rep( i , a , b ) for ( int i = ( a ) ; i <  ( b ) ; ++ i )
+#define rev( i , a , b ) for ( int i = ( a ) ; i >= ( b ) ; -- i )
+#define FOR( i , a , b ) for ( int i = ( a ) ; i <= ( b ) ; ++ i )
+#define clr( a , x ) memset ( a , x , sizeof a )
+#define cpy( a , x ) memcpy ( a , x , sizeof a )
+const int MAXN = 100005 ;
+struct Node {
+    int x , idx ;
+    double v ;
+    bool operator < ( const Node& a ) const {
+        return x < a.x ;
+    }
+} p[MAXN] ;
+int idx[MAXN] ;
+int n , m ;
+double T[MAXN] ;
+void add ( int x , double v ) {
+    while ( x <= n ) {
+        T[x] += v ;
+        x += x & -x ;
+    }
+}
+double sum ( int x , double ans = 0 ) {
+    while ( x ) {
+        ans += T[x] ;
+        x -= x & -x ;
+    }
+    return ans ;
+}
+int L_find ( int x ) {
+    int l = 1 , r = n ;
+    while ( l < r ) {
+        int m = ( l + r ) >> 1 ;
+        if ( p[m].x >= x ) r = m ;
+        else l = m + 1 ;
+    }
+    return l ;
+}
+int R_find ( int x ) {
+    int l = 1 , r = n ;
+    while ( l < r ) {
+        int m = ( l + r + 1 ) >> 1 ;
+        if ( p[m].x <= x ) l = m ;
+        else r = m - 1 ;
+    }
+    return r ;
+}
+void solve () {
+    int x , k ;
+    double ans = 0 ;
+    clr ( T , 0 ) ;
+    scanf ( "%d%d" , &n , &m ) ;
+    FOR ( i , 1 , n ) {
+        scanf ( "%d%lf" , &p[i].x , &p[i].v ) ;
+        p[i].idx = i ;
+    }
+    sort ( p + 1 , p + n + 1 ) ;
+    FOR ( i , 1 , n ) add ( i , p[i].v ) ;
+    FOR ( i , 1 , n ) idx[p[i].idx] = i ;
+    while ( m -- ) {
+        scanf ( "%d%d" , &x , &k ) ;
+        int l = 1 , r = p[n].x ;
+        int v = idx[x] ;
+        while ( l <= r ) {
+            int mid = ( l + r ) >> 1 ;
+            int L = L_find ( p[v].x - mid ) ;
+            int R = R_find ( p[v].x + mid ) ;
+            if ( R - L < k ) l = mid + 1 ;
+            else if ( R - L > k + 1 ) r = mid - 1 ;
+            else if ( R - L == k ) {
+                double tmp = ( sum ( R ) - sum ( L - 1 ) - p[v].v ) / k ;
+                ans += tmp ;
+                add ( v , -p[v].v ) ;
+                add ( v , tmp ) ;
+                p[v].v = tmp ;
+                break ;
+            } else if ( R - L == k + 1 ) {
+                if ( p[v].x - p[L].x == p[R].x - p[v].x ) {
+                    if ( p[L].idx < p[R].idx ) -- R ;
+                    else ++ L ;
+                }
+                else if ( p[v].x - p[L].x < p[R].x - p[v].x ) -- R ;
+                else ++ L ;
+                double tmp = ( sum ( R ) - sum ( L - 1 ) - p[v].v ) / k ;
+                ans += tmp ;
+                add ( v , -p[v].v ) ;
+                add ( v , tmp ) ;
+                p[v].v = tmp ;
+                break ;
+            }
+        }
+    }
+    printf ( "%.3f\n" , ans ) ;
+}
+int main () {
+    int T ;
+    scanf ( "%d" , &T ) ;
+    while ( T -- ) solve () ;
+    return 0 ;
+}
diff --git a/HDOJ/5022_autoAC.cpp b/HDOJ/5022_autoAC.cpp
new file mode 100644
index 0000000..cc51cb1
--- /dev/null
+++ b/HDOJ/5022_autoAC.cpp
@@ -0,0 +1,125 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+typedef long long int64;
+int64 v[210000],tx[210000],ty[210000],rk[210000],a,b,c,d,s,t,P,pp,x,y,sp,gg,tot,rs,ans,cnt;
+int64 gcd(int64 a,int64 b)
+{
+    x=1,y=0;
+    if(!b) return a;
+    int64 d=gcd(b,a%b);
+    int64 xx=x; x=y; y=xx-a/b*y;
+    return d;
+}
+int64 qpow(int64 a,int64 b,int64 c)
+{
+    int64 res=1;
+    for(;b;b>>=1,a=a*a%c)
+      if(b&1) res=res*a%c;
+    return res;
+}
+int64 dt2(int64 a)
+{
+    int l=1,r=cnt,mid;
+    while(l+1<r)
+    {
+        mid=(l+r)>>1;
+        if(tx[rk[mid]]<a) l=mid;
+        else r=mid;
+    }
+    if(tx[rk[l]]==a) return ty[rk[l]];
+    if(tx[rk[r]]==a) return ty[rk[r]];
+    return 0;
+}
+int64 dlog(int64 a)
+{
+    for(int i=0;i<=sp;++i)
+    {
+        int64 k=dt2(a*qpow(gg,i,P)%P);
+        if(!k) continue;
+        return (k-i+pp)%pp;
+    }
+    return -1;
+}
+bool ok(int64 a)
+{
+    for(int i=1;i<=tot;++i)
+      if(qpow(a,pp/v[i],P)==1) return 0;
+    return 1;
+}
+int64 getpg(int64 a)
+{
+    for(int i=2;i<=a-1;++i)
+      if(ok(i)) return i;
+    return -1;
+}
+int64 t2(int64 a)
+{
+    int l=1,r=tot,mid;
+    while(l+1<r)
+    {
+        mid=(l+r)>>1;
+        if(v[mid]<a) l=mid;
+        else r=mid;
+    }
+    if(v[l]>=a) return v[l];
+    return v[r];
+}
+int64 solve(int64 a,int64 b,int64 P,int64 t)
+{
+    a=(a+P)%P; b=(b+P)%P; tot=0; int64 sp=0,ans=b;
+    for(;(sp+1)*(sp+1)<=t;++sp);
+    for(int i=0;sp*sp+i<=t;++i)
+      ans=min(ans,(a*(sp*sp+i)+b)%P);
+    if(!sp) return ans;
+    for(int i=1;i<=sp;++i) v[++tot]=(a*sp*i+b)%P;
+    sort(v+1,v+tot+1);
+    for(int i=0;i<=sp;++i)
+    {
+        int64 x=a*i%P;
+        ans=min(ans,(v[1]+P-x)%P);
+        ans=min(ans,(t2(x)-x+P)%P);
+    }
+    return ans;
+}
+bool cmp(int a,int b)
+{
+    return tx[a]<tx[b];
+}
+int main()
+{
+    while(scanf("%I64d%I64d%I64d%I64d%I64d%I64d",&c,&a,&b,&s,&t,&P),P)
+    {
+        tot=0; pp=P-1;
+        for(sp=1;sp*sp<=pp;++sp);
+        for(int i=2;i*i<=pp;++i)
+        {
+            if(pp%i) continue;
+            v[++tot]=i; while(pp%i==0) pp/=i;
+        }
+        if(pp>1) v[++tot]=pp; pp=P-1;
+        gg=getpg(P); cnt=0;
+        for(int i=1;i<=sp;++i) tx[++cnt]=qpow(gg,sp*i,P),ty[cnt]=sp*i,rk[cnt]=cnt;
+        sort(rk+1,rk+cnt+1,cmp);
+        a=dlog(a); b=dlog(b); c=dlog(c);
+        a=(pp-a)%pp; c=(c-b*s%pp+pp)%pp; t-=s;
+        d=gcd(pp,gcd(a,b));
+        if(c%d)
+        {
+            printf("impossible\n"); continue;
+        }
+        a/=d; b/=d; c/=d; pp/=d; d=gcd(pp,a);
+        gcd(b,d); x=(x%d+d)%d; rs=c*x%d;
+        if(t<rs)
+        {
+            printf("impossible\n"); continue;
+        }
+        t=(t-rs)/d; c=(c-rs*b)/d; a/=d; pp/=d;
+        gcd(a,pp); b=(pp-b*x%pp)%pp; c=(pp+c*x%pp)%pp;
+        ans=solve(b,c,pp,t);
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5023_autoAC.cpp b/HDOJ/5023_autoAC.cpp
new file mode 100644
index 0000000..c396e54
--- /dev/null
+++ b/HDOJ/5023_autoAC.cpp
@@ -0,0 +1,86 @@
+#include<cstdio>
+#include<cstring>
+#include<set>
+#include<algorithm>
+using namespace std;
+#define lson l, mid, root<<1
+#define rson mid+1, r, root<<1|1
+const int N = 1e6 + 5;
+set <int> s;
+set <int> ::iterator it;
+struct Node {
+    int color;
+    int left;
+    int right;
+    int mid;
+} a[N<<2];
+void Push_Down(int root) {
+    if(a[root].color) {
+        a[root<<1].color = a[root].color;
+        a[root<<1|1].color = a[root].color;
+        a[root].color = 0;
+    }
+}
+void Build_Tree(int l, int r, int root) {
+    int mid = (l + r) >> 1;
+    a[root].left = l;
+    a[root].right = r;
+    a[root].mid = mid;
+    a[root].color = 2;
+    if(l == r) return;
+    Build_Tree(lson);
+    Build_Tree(rson);
+}
+void Update(int l, int r, int c, int root) {
+    if(a[root].left == l && a[root].right == r) {
+        a[root].color = c;
+        return;
+    }
+    if(a[root].color == c) return;
+    Push_Down(root);
+    if(l > a[root].mid) Update(l, r, c, root<<1|1);
+    else if(r <= a[root].mid) Update(l, r, c, root<<1);
+    else {
+        Update(l, a[root].mid, c, root<<1);
+        Update(a[root].mid+1, r, c, root<<1|1);
+    }
+}
+void Query(int l, int r, int root) {
+    if(a[root].color) {
+        s.insert(a[root].color);
+        return ;
+    }
+    if(l > a[root].mid) Query(l, r, root<<1|1);
+    else if(r <= a[root].mid) Query(l, r, root<<1);
+    else {
+        Query(l, a[root].mid, root<<1);
+        Query(a[root].mid+1, r, root<<1|1);
+    }
+}
+int main() {
+    int n, m;
+    int l, r, c;
+    char op[10];
+    while(~scanf("%d%d", &n, &m) && (n + m)) {
+        Build_Tree(1, n, 1);
+        for(int i = 0; i < m; i++) {
+            scanf("%s%d%d", op, &l, &r);
+            if(op[0] == 'P') {
+                scanf("%d", &c);
+                Update(l, r, c, 1);
+            }
+            else {
+                s.clear();
+                Query(l, r, 1);
+                int ss = s.size();
+                for(it = s.begin(); it != s.end(); it++) {
+                    printf("%d", *it);
+                    if(ss > 1) printf(" ");
+                    ss--;
+                }
+                printf("\n");
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5024_autoAC.cpp b/HDOJ/5024_autoAC.cpp
new file mode 100644
index 0000000..64ea434
--- /dev/null
+++ b/HDOJ/5024_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+#define N 102
+char mat[N][N];
+int maxn,n;
+int dir1[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
+int dir2[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
+void solve1(int x,int y)
+{
+    int tmp[4];
+    for(int i=0;i<4;i++){
+        int xx=x,yy=y;
+        tmp[i]=0;
+        while(true){
+            xx+=dir1[i][0];
+            yy+=dir1[i][1];
+            if(mat[xx][yy]!='#'&&xx>=0&&xx<n&&yy>=0&&yy<n){
+                tmp[i]++;
+            }
+            else break;
+        }
+    }
+    sort(tmp,tmp+4);
+    maxn = max(maxn,tmp[2]+tmp[3]);
+}
+void solve2(int x,int y)
+{
+    int tmp[4];
+    for(int i=0;i<4;i++){
+        int xx=x,yy=y;
+        tmp[i]=0;
+        while(true){
+            xx+=dir2[i][0];
+            yy+=dir2[i][1];
+            if(mat[xx][yy]!='#'&&xx>=0&&xx<n&&yy>=0&&yy<n){
+                tmp[i]++;
+            }
+            else break;
+        }
+    }
+    sort(tmp,tmp+4);
+    maxn = max(maxn,tmp[2]+tmp[3]);
+}
+int main()
+{
+    while(~scanf("%d",&n)){
+        if(n==0)
+            break;
+        maxn = 0;
+        for(int i=0;i<n;i++)
+            for(int j=0;j<n;j++)
+                cin>>mat[i][j];
+        for(int i=0;i<n;i++)
+            for(int j=0;j<n;j++)
+                if(mat[i][j]!='#'){
+                    solve1(i,j);
+                    solve2(i,j);
+                }
+        printf("%d\n",maxn+1);
+    }
+    return 0;
+}
diff --git a/HDOJ/5025_autoAC.cpp b/HDOJ/5025_autoAC.cpp
new file mode 100644
index 0000000..aa2a5b6
--- /dev/null
+++ b/HDOJ/5025_autoAC.cpp
@@ -0,0 +1,134 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <queue>
+#include <algorithm>
+using namespace std ;
+int n,m ;
+int sx,sy ;
+int tx,ty ;
+char mp[105][105] ;
+int vis[105][105][10][33] ;
+struct node
+{
+    int x,y ;
+    int time ;
+    int snake ;
+    int key ;
+    friend bool operator <(node a,node b)
+    {
+        return a.time>b.time ;
+    }
+} ;
+int cnt ;
+struct sk
+{
+    int x,y ;
+}ss[10] ;
+int OK(node a)
+{
+    if(a.x==tx && a.y==ty)
+    {
+        if(a.key==m)return 1 ;
+    }
+    return 0 ;
+}
+int dx[]={1,-1,0,0} ;
+int dy[]={0,0,1,-1} ;
+int bfs(int x,int y)
+{
+    priority_queue <node> q ;
+    node s ;
+    s.x=x ;s.y=y ;s.time=0 ;s.snake=0 ;s.key=0 ;
+    vis[x][y][0][0]=1 ;
+    q.push(s) ;
+    while(!q.empty())
+    {
+        node u=q.top() ;
+        if(OK(u))return u.time ;
+        q.pop() ;
+        for(int i=0 ;i<4 ;i++)
+        {
+            int xx=u.x+dx[i] ;
+            int yy=u.y+dy[i] ;
+            if(xx<0 || xx>=n || yy<0 || yy>=n)continue ;
+            if(mp[xx][yy]=='#')continue ;
+            if(vis[xx][yy][u.key][u.snake])continue ;
+            node T ;
+            T=u ;
+            T.x=xx ;T.y=yy ;T.time=u.time+1 ;
+            if(mp[xx][yy]>='1' && mp[xx][yy]<='9')
+            {
+                int num=mp[xx][yy]-'0'-1 ;
+                if(T.key==num)
+                {
+                    T.key++ ;
+                    vis[xx][yy][T.key][T.snake]=1 ;
+                    q.push(T) ;
+                }
+                else
+                {
+                    vis[xx][yy][T.key][T.snake]=1 ;
+                    q.push(T) ;
+                }
+            }
+            else if(mp[xx][yy]=='S')
+            {
+                for(int i=0 ;i<cnt ;i++)
+                {
+                    if(xx==ss[i].x && yy==ss[i].y)
+                    {
+                        if((T.snake>>i)&1)
+                        {
+                            vis[xx][yy][T.key][T.snake]=1 ;
+                            q.push(T) ;
+                        }
+                        else
+                        {
+                            T.time++ ;
+                            T.snake+=(1<<i) ;
+                            vis[xx][yy][T.key][T.snake]=1 ;
+                            q.push(T) ;
+                        }
+                        break ;
+                    }
+                }
+            }
+            else
+            {
+                vis[xx][yy][T.key][T.snake]=1 ;
+                q.push(T) ;
+            }
+        }
+    }
+    return -1 ;
+}
+int main()
+{
+    while(~scanf("%d%d",&n,&m))
+    {
+        if(!n && !m)break ;
+        for(int i=0 ;i<n ;i++)
+            scanf("%s",mp[i]) ;
+        cnt=0 ;
+        for(int i=0 ;i<n ;i++)
+        {
+            for(int j=0 ;j<n ;j++)
+            {
+                if(mp[i][j]=='K')sx=i,sy=j ;
+                if(mp[i][j]=='T')tx=i,ty=j ;
+                if(mp[i][j]=='S')
+                {
+                    ss[cnt].x=i ;
+                    ss[cnt++].y=j ;
+                }
+            }
+        }
+        memset(vis,0,sizeof(vis)) ;
+        int ans=bfs(sx,sy) ;
+        if(ans==-1)puts("impossible") ;
+        else printf("%d\n",ans) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5027_autoAC.cpp b/HDOJ/5027_autoAC.cpp
new file mode 100644
index 0000000..7ff8b65
--- /dev/null
+++ b/HDOJ/5027_autoAC.cpp
@@ -0,0 +1,137 @@
+#include<iostream>  
+#include<cstdio>  
+#include<complex>  
+#include<vector>  
+#include<cmath>  
+#include<cstdlib>  
+#include<algorithm>  
+using namespace std;  
+const double eps=1.0e-8;  
+typedef complex<double> point;  
+typedef vector<point> polygon;  
+struct line : public vector<point> {  
+    line() {}  
+    line(const point& a, const point& b) { push_back(a); push_back(b); }  
+};  
+inline point vec(const line& l) { return l[1]-l[0];}  
+inline double dot  (const point& a, const point& b) { return (a*conj(b)).real();}  
+inline double cross(const point& a, const point& b) { return (conj(a)*b).imag();}  
+inline int dlcmp(const double& x){  
+    return x<-eps?-1:x>eps;  
+}  
+bool intersectSP(const line& s, const point& p) {  
+    return abs(s[0]-p)+abs(s[1]-p)<abs(s[1]-s[0])+eps;  
+}  
+point projection(const line &l, const point &p) {  
+    double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);  
+    return l[0] + t*(l[0]-l[1]);  
+}  
+double distanceSP(const line &s, const point &p) {  
+    const point& r = projection(s, p);  
+    if (intersectSP(s, r)) return abs(r - p);  
+    return min(abs(s[0]-p), abs(s[1]-p));  
+}  
+polygon p;  
+const int MAXN=50005;  
+bool direction[MAXN];  
+inline double calc(const point& start, const point& m, const point& target, const double& Vr, const double& Vs){  
+    return abs(start-m)/Vr+abs(m-target)/Vs;  
+}  
+point m1, m2, v;  
+double mid, midd;  
+double solve(const line& S, const point& start, const point& target, const double& Vr, const double& Vs, double& ts){  
+    double l=0.0, r=1.0;  
+    v=vec(S);  
+    while(l+eps<r){  
+        mid=(l+r)/2.0;  
+        midd=(mid+r)/2.0;  
+        m1=S[0]+mid*v;  
+        m2=S[0]+midd*v;  
+        if(calc(start,m1,target,Vr,Vs)<calc(start,m2,target,Vr,Vs)){  
+            r=midd;  
+        }  
+        else{  
+            l=mid;  
+        }  
+    }  
+    ts=abs(S[0]+l*v-target)/Vs;  
+    return calc(start,S[0]+l*v,target,Vr,Vs);  
+}  
+point cut[2];  
+int R[2];  
+point p1, p2;  
+int main(){  
+    int T, n; cin>>T;  
+    while(T--){  
+        double Ts, Vr, Vs; cin>>Ts>>Vr>>Vs;  
+        double Xo, Yo, Xp, Yp; cin>>Xo>>Yo>>Xp>>Yp;  
+        point O(Xo,Yo), P(Xp,Yp);  
+        cin>>n;  
+        p.clear();  
+        double x, y;  
+        for(int i=0; i<n; i++){  
+            scanf("%lf%lf",&x,&y);  
+            p.push_back(point(x,y));  
+        }  
+        if(dlcmp(cross(p[1]-p[0],p[2]-p[1]))<0){  
+            reverse(p.begin(),p.end());  
+        }  
+        double carry_and_swim=1.0e20;  
+        for(int i=0; i<n; i++){  
+            carry_and_swim=min(carry_and_swim,distanceSP(line(p[i],p[(i+1)%n]),P));  
+        }  
+        carry_and_swim=2.0*carry_and_swim/Vs;  
+        double sum=0.0;  
+        for(int i=0; i<n; i++){  
+            direction[i]=dlcmp(cross(p[i]-O,p[(i+1)%n]-p[i]))>=0;  
+            sum+=abs(p[i]-p[(i+1)%n]);  
+        }  
+        int cnt=0;  
+        for(int i=0; i<n; i++){  
+            if(direction[i]!=direction[(i+1)%n]){  
+                R[cnt++]=(i+1)%n;  
+            }  
+            if(intersectSP(line(p[i],p[(i+1)%n]),O)){  
+                cut[0]=p[i];  
+                cut[1]=p[(i+1)%n];  
+                R[0]=i; R[1]=(i+1)%n;  
+            }  
+        }  
+        if(cnt!=0){  
+            if(direction[R[0]]!=0) swap(R[0],R[1]);  
+            cut[0]=p[R[0]]; cut[1]=p[R[1]];  
+        }  
+        double ans=1.0e20;  
+        int st=R[0], ed=R[1];  
+        if(ed<st) ed+=n;  
+        double ft=0.0;  
+        double ts, ts1, ts2, ret;  
+        for(int i=st; i<ed; i++){  
+            p1=p[i%n], p2=p[(i+1)%n];  
+            ret=solve(line(p1,p2),O,P,Vr,Vs,ts);  
+            if(ts+carry_and_swim-eps<=Ts){  
+                ans=min(ans,ret);  
+            }  
+            ft+=abs(p1-p2);  
+        }  
+        swap(st,ed);  
+        if(ed<st) ed+=n;  
+        double bk=0.0, al=(sum-ft), d1, d2;  
+        for(int i=st; i<ed; i++){  
+            p1=p[i%n], p2=p[(i+1)%n];  
+            d1=(abs(O-cut[1])+bk)/Vr+solve(line(p1,p2),p1,P,Vr,Vs,ts1);  
+            d2=(abs(O-cut[0])+al-bk-abs(p1-p2))/Vr+solve(line(p2,p1),p2,P,Vr,Vs,ts2);  
+            if(ts1+carry_and_swim-eps<=Ts){  
+                ans=min(ans,d1);  
+            }  
+            if(ts2+carry_and_swim-eps<=Ts){  
+                ans=min(ans,d2);  
+            }  
+            bk+=abs(p1-p2);  
+        }  
+        ans+=carry_and_swim;  
+        if(ans<=1.0e19) printf("%.2f\n",ans);  
+        else printf("-1\n");  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/5029_autoAC.cpp b/HDOJ/5029_autoAC.cpp
new file mode 100644
index 0000000..3c082d0
--- /dev/null
+++ b/HDOJ/5029_autoAC.cpp
@@ -0,0 +1,187 @@
+#pragma comment(linker, "/STACK:102400000,102400000")
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<queue>
+#include<cmath>
+#include<cctype>
+#include<string>
+#include<algorithm>
+#include<iostream>
+#include<ctime>
+#include<map>
+#include<set>
+using namespace std;
+#define MP(x,y) make_pair((x),(y))
+#define PB(x) push_back(x)
+const int INF = 1000111222;
+const double INFF = 1e100;
+const double eps = 1e-8;
+const int mod = 1000000007;
+const int NN = 100010;
+const int MM = 400010;
+vector<int>ad[NN];
+vector<int>del[NN];
+struct TR
+{
+    int l,r,col,ci;
+    int mid()
+    {
+        return (l+r)>>1;
+    }
+}tr[NN*4];
+struct G
+{
+    int v,next;
+}E[NN*2];
+int p[NN],T;
+//c_dfs1
+int deep[NN],si[NN],per[NN],anc[NN];
+//c_dfs2
+int tsp,pos[NN],top[NN];
+int ans[NN],dui[NN];
+void add(int u,int v)
+{
+    E[T].v=v;
+    E[T].next=p[u];
+    p[u]=T++;
+}
+void c_dfs1(int u,int fa,int cen)
+{
+    anc[u]=fa;
+    deep[u]=cen;
+    si[u]=1;
+    per[u]=-1;
+    int i,v;
+    for(i=p[u];i+1;i=E[i].next)
+    {
+        v=E[i].v;
+        if(v==fa)continue;
+        c_dfs1(v,u,cen+1);
+        si[u]+=si[v];
+        if(per[u]==-1 || si[v]>si[ per[u] ])
+            per[u]=v;
+    }
+}
+void c_dfs2(int u,int fa,int now_top)
+{
+    pos[u]=++tsp;
+    top[u]=now_top;
+    if(per[u]!=-1)c_dfs2(per[u],u,now_top);
+    int i,v;
+    for(i=p[u];i+1;i=E[i].next)
+    {
+        v=E[i].v;
+        if(v==per[u] || v==fa)continue;
+        c_dfs2(v,u,v);
+    }
+}
+void c_update(int u,int v,int col)
+{
+    while(top[u]!=top[v])
+    {
+        if(deep[ top[u] ] > deep[ top[v] ])
+            swap(u,v);
+        ad[ pos[ top[v] ] ].PB(col);
+        del[ pos[v] ].PB(col);
+        v=anc[ top[v] ];
+    }
+    if(pos[u]>pos[v])
+        swap(u,v);
+    ad[ pos[u] ].PB(col);
+    del[ pos[v] ].PB(col);
+}
+void push_up(int R)
+{
+    if(tr[R<<1].ci >= tr[R<<1|1].ci)
+    {
+        tr[R].col = tr[R<<1].col;
+        tr[R].ci = tr[R<<1].ci;
+    }
+    else
+    {
+        tr[R].col = tr[R<<1|1].col;
+        tr[R].ci = tr[R<<1|1].ci;
+    }
+}
+void build(int l,int r,int R)
+{
+    tr[R].l = l;
+    tr[R].r = r;
+    if(l==r)
+    {
+        tr[R].col = l;
+        tr[R].ci = 0;
+        return;
+    }
+    int mid = tr[R].mid();
+    build(l,mid,R<<1);
+    build(mid+1,r,R<<1|1);
+    push_up(R);
+}
+void update(int x,int R,int ad)
+{
+    if(tr[R].l == tr[R].r)
+    {
+        tr[R].ci += ad;
+        return;
+    }
+    int mid = tr[R].mid();
+    if(x <= mid)
+        update(x,R<<1,ad);
+    else
+        update(x,R<<1|1,ad);
+    push_up(R);
+}
+int main()
+{
+    int n,m,u,v,i,c,j,si,s_col;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        if(n==0 && m==0)break;
+        memset(p,-1,sizeof(p));
+        T=0;
+        for(i=1;i<n;i++)
+        {
+            scanf("%d%d", &u, &v);
+            add(u,v);
+            add(v,u);
+        }
+        c_dfs1(1,-1,0);
+        tsp = 0;
+        c_dfs2(1,-1,1);
+        for(i=1;i<=n;i++)
+        {
+            dui[ pos[i] ] = i;
+        }
+        s_col = 1;
+        for(i=0;i<m;i++)
+        {
+            scanf("%d%d%d",&u,&v,&c);
+            s_col = max(s_col,c);
+            c_update(u,v,c);
+        }
+        build(0,s_col,1);
+        for(i=1;i<=n;i++)
+        {
+            si = ad[i].size();
+            for(j=0;j<si;j++)
+            {
+                update(ad[i][j], 1, 1);
+            }
+            ans[ dui[i] ] = tr[1].col;
+            si = del[i].size();
+            for(j=0;j<si;j++)
+            {
+                update(del[i][j], 1, -1);
+            }
+            ad[i].clear();
+            del[i].clear();
+        }
+        for(i=1;i<=n;i++)
+        {
+            printf("%d\n",ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5030_autoAC.cpp b/HDOJ/5030_autoAC.cpp
new file mode 100644
index 0000000..a8c407d
--- /dev/null
+++ b/HDOJ/5030_autoAC.cpp
@@ -0,0 +1,113 @@
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <algorithm>
+using namespace std;
+const int maxn = 1e5+5;
+typedef long long ll;
+struct Suffix_Arr {
+    char s[maxn];
+    int n, SA[maxn], rank[maxn], height[maxn];
+    int tmp_one[maxn], tmp_two[maxn], c[maxn];
+    ll f[maxn];
+    void init ();
+    void build(int m);
+    void get_height();
+    void solve ();
+    bool judge(ll m);
+}AC;
+int K;
+int main () {
+    while (scanf("%d", &K) == 1 && K) {
+        AC.init();
+        AC.build(256);
+        AC.get_height();
+        AC.solve();
+    }
+    return 0;
+}
+bool Suffix_Arr::judge(ll m) {
+    int t = lower_bound(f + 1, f + n + 1, m) - f;
+    int R = n - (f[t] - m + 1);
+    int len = R - SA[t] + 1;
+    memset(c, -1, sizeof(c));
+    c[SA[t]] = len;
+    for (int i = t+1; i <= n; i++) {
+        len = min(len, height[i]);
+        if (len == 0)
+            return false;
+        c[SA[i]] = len;
+    }
+    int ret = 0, p = n + 1;
+    for (int i = 0; i < n; i++) {
+        if (i == p) {
+            ret++;
+            p = n + 1;
+        }
+        if (c[i] != -1)
+            p = min(p, i + c[i]);
+        if (ret >= K)
+            return false;
+    }
+    return true;
+}
+void Suffix_Arr::solve() {
+    ll l = 1, r = f[n];
+    for (int i = 0; i < 70; i++) {
+        ll mid = (l + r) / 2;
+        if (judge(mid))
+            r = mid;
+        else
+            l = mid;
+    }
+    int t = lower_bound(f + 1, f + n + 1, r) - f;
+    int len = n - (f[t] - r + 1);
+    for (int i = SA[t]; i <= len; i++)
+        printf("%c", s[i]);
+    printf("\n");
+}
+void Suffix_Arr::init() {
+    scanf("%s", s);
+    n = strlen(s) + 1;
+}
+void Suffix_Arr::get_height() {
+    for (int i = 0; i < n; i++)
+        rank[SA[i]] = i;
+    int mv = height[n-1] = 0;
+    for (int i = 0; i < n - 1; i++) {
+        if (mv) mv--;
+        int j = SA[rank[i] - 1];
+        while (s[i+mv] == s[j+mv])
+            mv++;
+        height[rank[i]] = mv;
+    }
+    n--;
+    f[0] = 0;
+    for (int i = 1; i <= n; i++)
+        f[i] = f[i-1] + n - SA[i] - height[i];
+}
+void Suffix_Arr::build(int m) {
+    int *x = tmp_one, *y = tmp_two;
+    for (int i = 0; i < m; i++) c[i] = 0;
+    for (int i = 0; i < n; i++) c[x[i] = s[i]]++;
+    for (int i = 1; i < m; i++) c[i] += c[i-1];
+    for (int i = n - 1; i >= 0; i--) SA[--c[x[i]]] = i;
+    for (int k = 1; k <= n; k <<= 1) {
+        int mv = 0;
+        for (int i = n - k; i < n; i++) y[mv++] = i;
+        for (int i = 0; i < n; i++) if (SA[i] >= k)
+            y[mv++] = SA[i] - k;
+        for (int i = 0; i < m; i++) c[i] = 0;
+        for (int i = 0; i < n; i++) c[x[y[i]]]++;
+        for (int i = 1; i < m; i++) c[i] += c[i-1];
+        for (int i = n - 1; i >= 0; i--) SA[--c[x[y[i]]]] = y[i];
+        swap(x, y);
+        mv = 1;
+        x[SA[0]] = 0;
+        for (int i = 1; i < n; i++)
+            x[SA[i]] = (y[SA[i-1]] == y[SA[i]] && y[SA[i-1] + k] == y[SA[i] + k] ? mv - 1 : mv++);
+        if (mv >= n)
+            break;
+        m = mv;
+    }
+}
diff --git a/HDOJ/5031_autoAC.cpp b/HDOJ/5031_autoAC.cpp
new file mode 100644
index 0000000..fed1c9b
--- /dev/null
+++ b/HDOJ/5031_autoAC.cpp
@@ -0,0 +1,231 @@
+#include<iostream>
+#include<stdio.h>
+#include<string.h>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+const int INF=1<<30;
+int n,m,t;
+struct Point
+{
+    int x,y;
+    Point(){}
+    Point(int _x, int _y)
+    {
+        x=_x;
+        y=_y;
+    }
+    void set(int _x, int _y)
+    {
+        x=_x;
+        y=_y;
+    }
+    Point operator + (const Point &b) const
+    {
+        return Point(x+b.x, y+b.y);
+    }
+    Point operator - (const Point &b) const
+    {
+        return Point(x-b.x, y-b.y);
+    }
+    int operator ^(const Point &b) const
+    {
+        return x*b.y - y*b.x;
+    }
+};
+struct Line
+{
+    Point s,e;
+    int cover;
+    Line(){}
+    void set(Point _s, Point _e, int _c)
+    {
+        s=_s;
+        e=_e;
+        cover=_c;
+    }
+    bool operator < (const Line &b)
+    {
+        return cover < b.cover;
+    }
+};
+Point point[5000];
+int p_point = 0;
+int map[70][70];
+int min_ans = 14;
+bool found = false;
+void init()
+{
+    p_point=0;
+    memset(map, 0, sizeof(map));
+    min_ans = 14;
+    found = false;
+    return;
+}
+int gcd(int x, int y)
+{
+    if(x<y)
+        swap(x,y);
+    if(y==0)
+        return x;
+    if(x%y==0)
+        return y;
+    return gcd(y, x%y);
+}
+bool valid(Point p)
+{
+    return p.x >=0 && p.y >= 0 && p.x <=n && p.y <=m;
+}
+bool CheckLine(int p1, int p2, int &cover)
+{
+    Point now_vec = point[p2] - point[p1];
+    if(gcd( abs(now_vec.x), abs(now_vec.y)) != 1)
+        return false;
+    int now_cover = 0;
+    Point tmp = point[p1];
+    tmp = tmp - now_vec;
+    while(valid(tmp))
+    {
+        if(map[tmp.x][tmp.y] == 0)
+            return false;
+        else if(tmp.x <= point[p1].x)
+            return false;
+        now_cover ++;
+        tmp = tmp - now_vec;
+    }
+    tmp = point[p2];
+    tmp = tmp + now_vec;
+    bool found_one = false;
+    while(valid(tmp))
+    {
+        found_one = true;
+        if(map[tmp.x][tmp.y] == 0)
+            return false;
+        now_cover++;
+        tmp = tmp + now_vec;
+    }
+    if(!found_one)
+        return false;
+    cover = now_cover;
+    return true;
+}
+void DetermineLines(Line line[], int &p_line)
+{
+    int i,j;
+    for(i=1; i<=p_point -1;i++)
+    {
+        if(map[point[i].x][point[i].y] ==0)
+            continue;
+        for(j=i+1; j<=p_point; j++)
+        {
+            if(map[point[j].x][point[j].y]==0)
+                continue;
+            int cover;
+            if( CheckLine(i,j, cover) )
+            {
+                line[++p_line].set(point[i], point[j], cover);
+            }
+        }
+    }
+    return;
+}
+void drop(Line l)
+{
+    Point p1 = l.s, p2 = l.e;
+    Point now_vec = p2 - p1;
+    Point tmp = p1;
+    while(valid(tmp))
+    {
+        map[tmp.x][tmp.y] --;
+        tmp = tmp - now_vec;
+    }
+    tmp = p2;
+    while(valid(tmp))
+    {
+        map[tmp.x][tmp.y] --;
+        tmp = tmp + now_vec;
+    }
+    return ;
+}
+void resume(Line l)
+{
+    Point p1 = l.s, p2 = l.e;
+    Point now_vec = p2 - p1;
+    Point tmp = p1;
+    while(valid(tmp))
+    {
+        map[tmp.x][tmp.y]++;
+        tmp = tmp - now_vec;
+    }
+    tmp = p2;
+    while(valid(tmp))
+    {
+        map[tmp.x][tmp.y]++;
+        tmp = tmp + now_vec;
+    }
+    return ;
+}
+bool cmp(const Line &a, const Line &b)
+{
+    return a.cover > b.cover;
+}
+bool check()
+{
+    int i;
+    for(i=1; i<=p_point; i++)
+    {
+        if(map[point[i].x][point[i].y] != 0)
+            return false;
+    }
+    return true;
+}
+void DFS(int depth)
+{
+    Line line[3000];
+    int p_line = 0;
+    DetermineLines(line, p_line);
+    sort(line+1, line + p_line +1, cmp);
+    if(check())
+    {
+        min_ans = depth-1;
+        found = true;
+        return ;
+    }
+    if(depth > min_ans)
+        return;
+    int i;
+    for(i=1; i<=min(p_line,4);i++)
+    {
+        drop(line[i]);
+        DFS(depth+1);
+        if(found)
+            break;
+        resume(line[i]);
+    }
+    return ;
+}
+int main()
+{
+    scanf("%d", &t);
+    int files;
+    for(files=1; files<=t; files++)
+    {
+        init();
+        scanf("%d %d", &n, &m);
+        int i,j;
+        for(i=0; i<=n; i++)
+        {
+            for(j=0; j<=m; j++)
+            {
+                scanf("%d", &map[i][j]);
+                if(map[i][j]!=0)
+                {
+                    point[++p_point].set(i,j);
+                }
+            }
+        }
+        DFS(1);
+        printf("%d\n", min_ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5032_autoAC.cpp b/HDOJ/5032_autoAC.cpp
new file mode 100644
index 0000000..2213b6f
--- /dev/null
+++ b/HDOJ/5032_autoAC.cpp
@@ -0,0 +1,88 @@
+#include<map>
+#include<string>
+#include<cstring>
+#include<cstdio>
+#include<cstdlib>
+#include<cmath>
+#include<queue>
+#include<vector>
+#include<iostream>
+#include<algorithm>
+#include<bitset>
+#include<climits>
+#include<list>
+#include<iomanip>
+#include<stack>
+#include<set>
+using namespace std;
+typedef long long ll;
+ll bit[1010];
+void update(int pos,ll val)
+{
+    for(int i=pos;i<=1000;i+=i&-i)
+        bit[i]+=val;
+}
+ll psum(int pos)
+{
+    ll ans=0;
+    for(int i=pos;i>0;i-=i&-i)
+        ans+=bit[i];
+    return ans;
+}
+struct Point
+{
+    int x,y;
+    bool operator <(Point one)const
+    {
+        return y*one.x<=one.y*x;
+    }
+}point[1000010];
+struct Qu
+{
+    int x,y,len,no;
+    bool operator <(Qu one)const
+    {
+        return ll(y*one.x)<ll(one.y*x);
+    }
+}qu[1000010];
+ll ans[1000010];
+int main()
+{
+    int n=0;
+    for(int i=1;i<=1000;i++)
+        for(int j=1;j<=1000;j++)
+        {
+            point[n].x=i;
+            point[n++].y=j;
+        }
+    sort(point,point+n);
+    int T;
+    scanf("%d",&T);
+    for(int cs=1;cs<=T;cs++)
+    {
+        int a,b,m;
+        scanf("%d%d%d",&a,&b,&m);
+        for(int i=0;i<m;i++)
+        {
+            scanf("%d%d%d",&qu[i].x,&qu[i].y,&qu[i].len);
+            qu[i].no=i;
+        }
+        sort(qu,qu+m);
+        memset(bit,0,sizeof(bit));
+        for(int i=0,j=0;i<m;i++)
+        {
+            Point t;
+            t.x=qu[i].x;
+            t.y=qu[i].y;
+            while(j<n&&point[j]<t)
+            {
+                update(point[j].x,ll(point[j].x+a)*(point[j].y+b));
+                j++;
+            }
+            ans[qu[i].no]=psum(qu[i].len);
+        }
+        printf("Case #%d:\n",cs);
+        for(int i=0;i<m;i++)
+            cout<<ans[i]<<endl;
+    }
+}
diff --git a/HDOJ/5033_autoAC.cpp b/HDOJ/5033_autoAC.cpp
new file mode 100644
index 0000000..820a0a7
--- /dev/null
+++ b/HDOJ/5033_autoAC.cpp
@@ -0,0 +1,146 @@
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#include<queue>
+#include<cmath>
+#include<cctype>
+#include<string>
+#include<algorithm>
+#include<iostream>
+#include<ctime>
+#include<map>
+#include<set>
+using namespace std;
+#define MP(x,y) make_pair((x),(y))
+#define PB(x) push_back(x)
+typedef __int64 LL;
+const int INF = 1000111222;
+const double INFF = 1e100;
+const double eps = 1e-8;
+const int mod = 1000000007;
+const int NN = 100010;
+const int MM = 400010;
+struct node
+{
+    double h;
+    double x;
+    bool operator<(const node &tt)const
+    {
+        return x < tt.x;
+    }
+}a[NN];
+struct Q
+{
+    int l,r,id;
+    double x;
+    bool operator<(const Q &tt)const
+    {
+        return x < tt.x;
+    }
+}line[NN];
+int q[NN];
+double ans[NN];
+const double pi = acos(-1.0);
+int main()
+{
+    int cas, ee = 0;
+    int i, n, m, j, j1, j2, tail;
+    double t, t1, t2;
+    scanf("%d", &cas);
+    while (cas--)
+    {
+        scanf("%d",&n);
+        for (i = 1; i <= n; i ++)
+        {
+            scanf("%lf%lf", &a[i].x, &a[i].h);
+        }
+        sort(a+1, a+1+n);
+        scanf("%d", &m);
+        for (i = 1; i <= m; i ++)
+        {
+            scanf("%lf", &line[i].x);
+            line[i].id = i;
+        }
+        sort(line+1, line+1+m);
+        q[tail = 1] = 1;
+        j = 2;
+        for (i = 1; i <= m; i ++)
+        {
+            while (j <= n && a[j].x < line[i].x)
+            {
+                while (tail > 0 && a[j].h >= a[ q[tail] ].h)
+                    tail--;
+                while (tail > 1)
+                {
+                    j2 = q[tail-1];
+                    j1 = q[tail];
+                    if( (a[j1].h - a[j].h) * (a[j1].x - a[j2].x) <=
+                       (a[j2].h-a[j1].h) * (a[j].x - a[j1].x) )
+                        tail--;
+                    else
+                        break;
+                }
+                q[++tail] = j;
+                j++;
+            }
+            while (tail > 1)
+            {
+                j1 = q[tail-1];
+                j2 = q[tail];
+                if(a[j1].h/(line[i].x - a[j1].x) >=
+                   a[j2].h/(line[i].x - a[j2].x))
+                    tail--;
+                else
+                    break;
+            }
+            line[i].l = q[tail];
+        }
+        q[tail = 1] = n;
+        j = n-1;
+        for (i = m; i >= 1; i --)
+        {
+            while (j >= 1 && a[j].x > line[i].x)
+            {
+                while (tail > 0 && a[j].h >= a[ q[tail] ].h)
+                    tail--;
+                while (tail > 1)
+                {
+                    j1 = q[tail];
+                    j2 = q[tail-1];
+                    if( (a[j1].h - a[j].h) * (a[j2].x - a[j1].x) <=
+                       (a[j2].h-a[j1].h) * (a[j1].x - a[j].x) )
+                        tail--;
+                    else
+                        break;
+                }
+                q[++tail] = j;
+                j--;
+            }
+            while (tail > 1)
+            {
+                j1 = q[tail-1];
+                j2 = q[tail];
+                if(a[j1].h/(a[j1].x - line[i].x) >=
+                   a[j2].h/(a[j2].x - line[i].x))
+                    tail--;
+                else
+                    break;
+            }
+            line[i].r = q[tail];
+        }
+        for (i = 1; i <= m; i ++)
+        {
+            t1 = a[ line[i].l ].h/( line[i].x - a[ line[i].l ].x + 0.0 );
+            t2 = a[ line[i].r ].h/( line[i].x - a[ line[i].r ].x + 0.0 );
+            t2 = -t2;
+            t = pi - atan(t1) - atan(t2);
+            ans[ line[i].id ] = t*180.0/pi;
+        }
+        printf("Case #%d:\n", ++ee);
+        for (i = 1; i <= m; i ++)
+        {
+            printf("%.10lf\n", ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5035_autoAC.cpp b/HDOJ/5035_autoAC.cpp
new file mode 100644
index 0000000..797c186
--- /dev/null
+++ b/HDOJ/5035_autoAC.cpp
@@ -0,0 +1,24 @@
+#include <cstdio>
+#include <algorithm>
+#include <cstring>
+using namespace std;
+int N,T;
+double sum,k;
+int c;
+int main(void)
+{
+    int cas = 1;
+    scanf("%d", &T);
+    while(T--){
+        scanf("%d", &N);
+        sum = 0.0;
+        for(int i = 0; i < N; ++i){
+            scanf("%lf",&k);
+            sum += k;
+        }
+        for(int i = 0; i < N; ++i)
+            scanf("%d", &c);
+        printf("Case #%d: %.6f\n",cas++,(N + 1.0) / sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/5036_autoAC.cpp b/HDOJ/5036_autoAC.cpp
new file mode 100644
index 0000000..c837249
--- /dev/null
+++ b/HDOJ/5036_autoAC.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <bitset>
+using namespace std;
+const int maxn = 1005;
+bitset<maxn> a[maxn];
+int main() {
+    int t, cas = 1;
+    int n;
+    scanf("%d", &t);
+    while (t--) {
+        scanf("%d", &n);
+        for (int i = 0; i < n; i++) {
+            a[i].reset();
+            a[i][i] = 1;
+        }
+        int c, x;
+        for (int i = 0; i < n; i++) {
+            scanf("%d", &c);
+            while (c--) {
+                scanf("%d", &x);
+                a[i][--x] = 1;
+            }
+        }
+        for (int i = 0; i < n; i++)
+            for (int j = 0; j < n; j++) 
+                if (a[j][i])
+                    a[j] |= a[i];
+        double ans = 0;
+        for (int i = 0; i < n; i++) {
+            c = 0;
+            for (int j = 0; j < n; j++)
+                if (a[j][i]) 
+                    c++;
+            ans += 1.0 / c;
+        }
+        printf("Case #%d: %.5lf\n",cas++,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5037_autoAC.cpp b/HDOJ/5037_autoAC.cpp
new file mode 100644
index 0000000..7ab51b5
--- /dev/null
+++ b/HDOJ/5037_autoAC.cpp
@@ -0,0 +1,42 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+#define MOD 1000000007
+typedef long long ll;
+using namespace std;
+const int maxn=200005;
+int da[maxn];
+int main()
+{
+    int T,n,m,l,cas=0;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%d",&n,&m,&l);
+        for(int i=1;i<=n;i++)
+            scanf("%d",&da[i]);
+        da[++n]=m;da[0]=0;
+        int ans=0;
+        int k=l;
+        sort(da,da+n);
+        for(int i=1;i<=n;i++)
+        {
+            int x=(da[i]-da[i-1])%(l+1);
+            int y=(da[i]-da[i-1])/(l+1);
+            if(k+x>=l+1)
+            {
+                k=x;
+                ans+=y*2+1;
+            }
+            else if(k+x<l+1)
+            {
+                k=x+k;
+                ans+=y*2;
+            }
+        }
+        printf("Case #%d: %d\n",++cas,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5038_autoAC.cpp b/HDOJ/5038_autoAC.cpp
new file mode 100644
index 0000000..8581210
--- /dev/null
+++ b/HDOJ/5038_autoAC.cpp
@@ -0,0 +1,67 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<vector>
+#include<set>
+#include<string>
+#include<algorithm>
+using namespace std;
+vector <int> g[10005];
+int fun(int x) {
+    return 10000 - (100 - x) * (100 - x);
+}
+int main()
+{
+    int n, w, T, cas = 0;
+    scanf("%d",&T);
+    while(T--) {
+        scanf("%d",&n);
+        set <int> s;
+        memset(g, 0, sizeof(g));
+        for(int i = 0; i < n; i++) {
+            scanf("%d", &w);
+            int grade = fun(w);
+            s.insert(grade);
+            g[grade].push_back(w);
+        }
+        set <int> ::iterator it;
+        vector <int> v;
+        for(it = s.begin(); it != s.end(); it++) {
+            v.push_back(g[*it].size());
+        }
+        sort(v.begin(), v.end());
+        int ssize = v.size();
+        int cnt = 0;
+        for(int i = ssize - 1; i >= 0; i--) {
+            if(v[i] == v[ssize-1])
+                cnt++;
+        }
+        printf("Case #%d:\n", ++cas);
+        if(cnt == 1) {
+            for(it = s.begin(); it != s.end(); it++)
+            if(g[*it].size() == v[ssize-1]) {
+                printf("%d\n", *it);
+                break;
+            }
+        }
+        else {
+            if(cnt == ssize)
+                printf("Bad Mushroom\n");
+            else {
+                vector <int> ans;
+                for(it = s.begin(); it != s.end(); it++) {
+                    int tmp = *it;
+                    if(g[tmp].size() == v[ssize-1]) {
+                        ans.push_back(tmp);
+                    }
+                }
+                sort(ans.begin(), ans.end());
+                int z = ans.size();
+                for(int i = 0; i < z - 1; i++)
+                    printf("%d ", ans[i]);
+                printf("%d\n", ans[z-1]);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5039_autoAC.cpp b/HDOJ/5039_autoAC.cpp
new file mode 100644
index 0000000..52d1733
--- /dev/null
+++ b/HDOJ/5039_autoAC.cpp
@@ -0,0 +1,141 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<stack>
+#include<set>
+#include<cmath>
+#include<vector>
+#define inf 0x3f3f3f3f
+#define Inf 0x3FFFFFFFFFFFFFFFLL
+#define eps 1e-6
+#define pi acos(-1.0)
+using namespace std;
+typedef long long ll;
+const int maxn = 30000 + 10;
+struct Edge
+{
+    int v,color,next;
+    Edge(int v = 0,int color = 0,int next = 0):v(v),color(color),next(next){}
+}edges[maxn<<1];
+int head[maxn],Lx[maxn],Rx[maxn],N,nEdge;
+int a[maxn];
+map<string,int>mp;
+void AddEdges(int u,int v,int color)
+{
+    edges[++nEdge] = Edge(v,color,head[u]);
+    head[u] = nEdge;
+    edges[++nEdge] = Edge(u,color,head[v]);
+    head[v] = nEdge;
+}
+void dfs(int u,int fa,int c)
+{
+    for(int k = head[u];k != -1;k = edges[k].next)
+    {
+        int v = edges[k].v;
+        if(v == fa) continue;
+        Lx[k/2] = ++N;
+        a[N] = c^edges[k].color;
+        dfs(v,u,c^edges[k].color);
+        Rx[k/2] = N;
+    }
+}
+int sum[maxn<<2],flip[maxn<<2];
+inline void PushUp(int rt)
+{
+    sum[rt] = sum[rt<<1] + sum[rt<<1|1];
+}
+void PushDown(int l,int r,int rt)
+{
+    if(flip[rt])
+    {
+        flip[rt<<1] ^= 1;
+        flip[rt<<1|1] ^= 1;
+        int m = (l + r)>>1;
+        sum[rt<<1] = (m - l + 1) - sum[rt<<1];
+        sum[rt<<1|1] = (r - m) - sum[rt<<1|1];
+        flip[rt] = 0;
+    }
+}
+void build(int l,int r,int rt)
+{
+    flip[rt] = 0;
+    if(l == r)
+    {
+        sum[rt] = a[l];
+        return ;
+    }
+    int m = (l + r)>>1;
+    build(l,m,rt<<1);
+    build(m+1,r,rt<<1|1);
+    PushUp(rt);
+}
+void Update(int L,int R,int l,int r,int rt)
+{
+    if(l >= L && r <= R)
+    {
+        flip[rt] ^= 1;
+        sum[rt] = r - l + 1 - sum[rt];
+        return ;
+    }
+    PushDown(l,r,rt);
+    int m = (l + r)>>1;
+    if(m >= L) Update(L,R,l,m,rt<<1);
+    if(m < R) Update(L,R,m+1,r,rt<<1|1);
+    PushUp(rt);
+}
+void Init()
+{
+    memset(head,0xff,sizeof(head));
+    nEdge = -1; N = 0;
+    mp.clear();
+}
+int main()
+{
+    char str[20];
+    int t,tcase = 0;
+    scanf("%d",&t);
+    while(t--)
+    {
+        Init();
+        int n,m;
+        scanf("%d",&n);
+        for(int i = 1;i <= n;++i)
+        {
+            scanf("%s",str);
+            mp[(string)str] = i;
+        }
+        int u,v,c;
+        for(int i = 1;i < n;++i)
+        {
+            scanf("%s",str);
+            u = mp[(string)str];
+            scanf("%s",str);
+            v = mp[(string)str];
+            scanf("%d",&c);
+            AddEdges(u,v,c);
+        }
+        dfs(1,-1,0);
+        build(1,N,1);
+        scanf("%d",&m);
+        printf("Case #%d:\n",++tcase);
+        while(m--)
+        {
+            scanf("%s",str);
+            if(str[0] == 'Q')
+            {
+                ll x = sum[1];
+                printf("%I64d\n",x*(n - x)*2LL);
+            }
+            else
+            {
+                scanf("%d",&u);
+                Update(Lx[u-1],Rx[u-1],1,N,1);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5040_autoAC.cpp b/HDOJ/5040_autoAC.cpp
new file mode 100644
index 0000000..f1f6357
--- /dev/null
+++ b/HDOJ/5040_autoAC.cpp
@@ -0,0 +1,134 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <queue>
+#include <map>
+using namespace std ;
+int n ;
+int vis[505][505][4] ;
+int b[505][505][4] ;
+char mp[505][505] ;
+int aa,bb ;
+struct node
+{
+    int x,y ;
+    int step ;
+    friend bool operator <(node aaa,node bbb)
+    {
+        return aaa.step>bbb.step ;
+    }
+} ;
+int dx[]={-1,0,1,0,0} ;
+int dy[]={0,1,0,-1,0} ;
+int bfs(int x,int y)
+{
+    memset(vis,0,sizeof(vis)) ;
+    priority_queue <node> q ;
+    node s ;
+    s.x=x ;s.y=y ;s.step=0 ;
+    vis[x][y][0]=1 ;
+    q.push(s) ;
+    while(!q.empty())
+    {
+        node u=q.top() ;
+        //printf("%d %d %d\n",u.x,u.y,u.step) ;
+        if(u.x==aa && u.y==bb)
+        {
+            return u.step ;
+        }
+        q.pop() ;
+        for(int i=0 ;i<5 ;i++)
+        {
+            int xx=u.x+dx[i] ;
+            int yy=u.y+dy[i] ;
+            if(xx<0 || xx>=n || yy<0 || yy>=n)continue ;
+            if(mp[xx][yy]=='#')continue ;
+            node p ;
+            p=u ;
+            if(b[xx][yy][u.step%4] || b[u.x][u.y][u.step%4])
+            {
+                if(xx==u.x && yy==u.y && !vis[xx][yy][(u.step+1)%4])
+                {
+                    p.step++ ;
+                    vis[xx][yy][p.step%4]=1 ;
+                    q.push(p) ;
+                }
+                else if(!vis[xx][yy][(u.step+3)%4])
+                {
+                    p.x=xx ;p.y=yy ;
+                    p.step+=3 ;
+                    vis[xx][yy][p.step%4]=1 ;
+                    q.push(p) ;
+                }
+            }
+            else if(!vis[xx][yy][(u.step+1)%4])
+            {
+                p.x=xx ;p.y=yy ;p.step++ ;
+                vis[xx][yy][p.step%4]=1 ;
+                q.push(p) ;
+            }
+        }
+    }
+    return -1 ;
+}
+int main()
+{
+    int T ;
+    scanf("%d",&T) ;
+    for(int cas=1 ;cas<=T ;cas++)
+    {
+        scanf("%d",&n) ;
+        for(int i=0 ;i<n ;i++)
+            scanf("%s",mp[i]) ;
+        int x,y ;
+        memset(b,0,sizeof(b)) ;
+        for(int i=0 ;i<n ;i++)
+        {
+            for(int j=0 ;j<n ;j++)
+            {
+                if(mp[i][j]=='M')
+                {
+                    x=i ;y=j ;
+                }
+                if(mp[i][j]=='N')
+                {
+                    b[i][j][0]=b[i][j][1]=b[i][j][2]=b[i][j][3]=1 ;
+                    if(i-1>=0)b[i-1][j][0]=1 ;
+                    if(j+1<n)b[i][j+1][1]=1 ;
+                    if(j-1>=0)b[i][j-1][3]=1 ;
+                    if(i+1<n)b[i+1][j][2]=1 ;
+                }
+                if(mp[i][j]=='W')
+                {
+                    b[i][j][0]=b[i][j][1]=b[i][j][2]=b[i][j][3]=1 ;
+                    if(i-1>=0)b[i-1][j][1]=1 ;
+                    if(j+1<n)b[i][j+1][2]=1 ;
+                    if(j-1>=0)b[i][j-1][0]=1 ;
+                    if(i+1<n)b[i+1][j][3]=1 ;
+                }
+                if(mp[i][j]=='S')
+                {
+                    b[i][j][0]=b[i][j][1]=b[i][j][2]=b[i][j][3]=1 ;
+                    if(i-1>=0)b[i-1][j][2]=1 ;
+                    if(j+1<n)b[i][j+1][3]=1 ;
+                    if(j-1>=0)b[i][j-1][1]=1 ;
+                    if(i+1<n)b[i+1][j][0]=1 ;
+                }
+                if(mp[i][j]=='E')
+                {
+                    b[i][j][0]=b[i][j][1]=b[i][j][2]=b[i][j][3]=1 ;
+                    if(i-1>=0)b[i-1][j][3]=1 ;
+                    if(j+1<n)b[i][j+1][0]=1 ;
+                    if(j-1>=0)b[i][j-1][2]=1 ;
+                    if(i+1<n)b[i+1][j][1]=1 ;
+                }
+                if(mp[i][j]=='T')
+                {
+                    aa=i ;bb=j ;
+                }
+            }
+        }
+        printf("Case #%d: %d\n",cas,bfs(x,y)) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5042_autoAC.cpp b/HDOJ/5042_autoAC.cpp
new file mode 100644
index 0000000..111e5c6
--- /dev/null
+++ b/HDOJ/5042_autoAC.cpp
@@ -0,0 +1,135 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<stack>
+#include<set>
+#include<cmath>
+#include<vector>
+#include<bitset>
+#define inf 0x3f3f3f3f
+#define Inf 0x3FFFFFFFFFFFFFFFLL
+#define eps 1e-6
+#define pi acos(-1.0)
+using namespace std;
+typedef long long ll;
+const int maxn = 100000 + 10;
+struct Node
+{
+    int pos,l,r,gval;
+    Node(int pos = 0,int l = 0,int r = 0,int gval = 0):pos(pos),l(l),r(r),gval(gval){}
+    bool operator < (const Node & a) const
+    {
+        if(gval != a.gval) return gval < a.gval;
+        if(pos != a.pos) return pos < a.pos;
+        return r < a.r;
+    }
+}node[maxn*20];
+ll sum[maxn*20];
+int cnt[maxn*20];
+int a[maxn],pa[maxn],pre[maxn],val[maxn],n,tot;
+int gcd(int a,int b) { return b == 0?a:gcd(b,a%b);}
+vector<Node>vt[maxn];
+void precal()
+{
+    for(int i = 0;i <= n;++i) vt[i].clear();
+    vt[n].push_back(Node(n,n,n,a[n]));
+    Node ntmp;
+    int x;
+    for(int i = n - 1;i >= 1;--i)
+    {
+        int size = vt[i + 1].size();
+        int cnt = 1;
+        vt[i].push_back(Node(i,i,i,a[i]));
+        for(int j = 0;j < size;++j)
+        {
+            ntmp = vt[i+1][j];
+            x = gcd(a[i],ntmp.gval);
+            if(cnt && vt[i][cnt-1].gval == x)
+                vt[i][cnt - 1].r = ntmp.r;
+            else
+                vt[i].push_back(Node(i,ntmp.l,ntmp.r,x)),cnt++;
+        }
+    }
+    tot = 0;
+    for(int i = 1;i <= n;++i)
+        for(int j = 0;j < (int)vt[i].size();++j)
+            node[++tot] = Node(vt[i][j]);
+    sort(node + 1,node + tot + 1);
+    sum[0] = 0;
+    for(int i = 1;i <= tot;++i)
+        sum[i] = sum[i-1] + node[i].r - node[i].l + 1;
+    cnt[1] = 1;
+    for(int i = 2;i <= tot;++i)
+        cnt[i] = cnt[i-1] + (node[i].gval != node[i-1].gval);
+}
+int f(int l,int r)
+{
+    int L = 0,R = vt[l].size() - 1;
+    while(L < R)
+    {
+        int m = (L + R)>>1;
+//        cout<<vt[l][m].r<<endl;
+        if(vt[l][m].r < r)
+            L = m + 1;
+        else
+            R = m;
+    }
+    return vt[l][L].gval;
+}
+int main()
+{
+    char str[20];
+    int t,tcase = 0,Q;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&Q);
+        for(int i = 1;i <= n;++i)
+            scanf("%d",&a[i]);
+        precal();
+        ll x,y,ans1,ans2;
+        Node tmp;
+        printf("Case #%d:\n",++tcase);
+        while(Q--)
+        {
+            scanf("%s",str);
+            scanf("%I64d%I64d",&x,&y);
+            if(str[0] == 'S')
+            {
+                if(cnt[tot] < x)
+                {
+                    puts("-1");
+                    continue;
+                }
+                int L = lower_bound(cnt + 1,cnt + tot + 1,x) - cnt;
+                int R = upper_bound(cnt + 1,cnt + tot + 1,x) - cnt - 1;
+                if(sum[R] - sum[L - 1] < y)
+                {
+                    puts("-1");
+                    continue;
+                }
+                int pos = lower_bound(sum + L,sum + R + 1,y + sum[L-1]) - sum;
+                ll tx = sum[pos] - sum[L - 1] - y;
+                ans1 = node[pos].pos;
+                ans2 = node[pos].r - tx;
+                printf("%I64d %I64d\n",ans1,ans2);
+            }
+            else
+            {
+                int val = f(x,y),p1,p2;
+                tmp = Node(-inf,0,0,val);
+                p1 = lower_bound(node + 1,node + tot + 1,tmp) - (node );
+                ans1 = cnt[p1];
+                tmp = Node(x,x,y,val);
+                p2 = lower_bound(node + p1,node + tot + 1,tmp) - node;
+                ans2 = sum[p2 - 1] - sum[p1 - 1] + y - node[p2].l + 1;
+                printf("%I64d %I64d\n",ans1,ans2);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5043_autoAC.cpp b/HDOJ/5043_autoAC.cpp
new file mode 100644
index 0000000..dd3974d
--- /dev/null
+++ b/HDOJ/5043_autoAC.cpp
@@ -0,0 +1,90 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+#include <assert.h>
+using namespace std;
+const int MOD = 1e8+9;
+void Add(int &a,int b){
+    a += b;
+    if(a >= MOD)a -= MOD;
+}
+int vis[10][33][22][1<<10];
+int dp[10][33][22][1<<10];
+int TT;
+int prime;
+int n;
+int bit[10][33];
+int dfs(int id,int pos,int sum,int s){
+    if(id == n){
+        id = 0;
+        pos--;
+        sum = 0;
+        if(pos == -1)return 1;
+    }
+    if(vis[id][pos][sum][s] == TT)return dp[id][pos][sum][s];
+    int end = (s&(1<<id))?bit[id][pos]:prime-1;
+    int ans = 0;
+    for(int i = 0;i <= end;i++){
+        if(sum + i >= prime)break;
+        Add(ans,dfs(id+1,pos,sum+i,i == end? s : (s & (~(1<<id)))));
+    }
+    vis[id][pos][sum][s] = TT;
+    return dp[id][pos][sum][s] = ans;
+}
+int x[10];
+int solve(){
+    memset(bit,0,sizeof(bit));
+    int Max = 0;
+    for(int i = 0;i < n;i++){
+        int cnt = 0;
+        do{
+            bit[i][cnt++] = x[i]%prime;
+            x[i] /= prime;
+        }
+        while(x[i]);
+        Max = max(Max,cnt);
+    }
+    return dfs(0,Max-1,0,(1<<n)-1);
+}
+int main()
+{
+    TT = 0;
+    memset(vis,0,sizeof(vis));
+    int T;
+    scanf("%d",&T);
+    assert(T <= 50 && T >= 1);
+    int iCase = 0;
+    while(T--){
+        iCase++;
+        TT++;
+        scanf("%d%d",&n,&prime);
+        assert(n >= 1 && n <= 10);
+        assert(prime == 2
+                || prime == 3
+                || prime == 5
+                || prime == 7
+                || prime == 11
+                || prime == 13
+                || prime == 17
+                || prime == 19);
+        long long tot = 1;
+        for(int i = 0;i < n;i++){
+            scanf("%d",&x[i]);
+            assert(x[i] >= 1 && x[i] <= 1000000000);
+            tot = tot*(1+x[i])%MOD;
+        }
+        tot -= solve();
+        tot = (tot%MOD+MOD)%MOD;
+        printf("Case #%d: %d\n",iCase,(int)tot);
+    }
+    return 0;
+}
diff --git a/HDOJ/5044_autoAC.cpp b/HDOJ/5044_autoAC.cpp
new file mode 100644
index 0000000..4f34e8d
--- /dev/null
+++ b/HDOJ/5044_autoAC.cpp
@@ -0,0 +1,219 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+#include <assert.h>
+using namespace std;
+const int MAXN = 100010;
+struct Edge{
+    int to,next;
+    int index;
+}edge[MAXN*2];
+int head[MAXN],tot;
+void init(){
+    tot = 0;
+    memset(head,-1,sizeof(head));
+}
+inline void addedge(int u,int v,int index){
+    edge[tot].to = v;
+    edge[tot].next = head[u];
+    edge[tot].index = index;
+    head[u] = tot++;
+}
+int F[MAXN];
+inline int find(int x){
+    if(F[x] == -1)return x;
+    return F[x] = find(F[x]);
+}
+inline void bing(int x,int y){
+    int t1 = find(x);
+    int t2 = find(y);
+    if(t1 != t2)F[t1] = t2;
+}
+long long PF[MAXN],EF[MAXN];
+struct Node{
+    int id;
+    int v,val;
+    int next;
+    Node(int _id = 0,int _v = 0,int _val = 0){
+        id = _id;
+        v = _v;
+        val = _val;
+    }
+}query[MAXN*2];
+int h[MAXN];
+int tt;
+inline void init2(){
+    tt = 0;
+    memset(h,-1,sizeof(h));
+}
+inline void add_query(int u,int v,int id,int val){
+    query[tt].id = id;
+    query[tt].next = h[u];
+    query[tt].v = v;
+    query[tt].val = val;
+    h[u] = tt++;
+}
+bool vis[MAXN];
+int fa[MAXN];
+bool ff[MAXN];
+int sta[MAXN];
+int cur[MAXN];
+void dfs1(int u,int pre){
+    memcpy(cur,head,sizeof(head));
+    memset(ff,false,sizeof(ff));
+    fa[1] = -1;
+    int top = 0;
+    sta[top++] = 1;
+    while(top != 0){
+        u = sta[top-1];
+        if(!ff[u])ff[u] = true;
+        bool flag = false;
+        for(int i = cur[u];i != -1;i = edge[i].next){
+            int v = edge[i].to;
+            if(ff[v])continue;
+            fa[v] = u;
+            sta[top++] = v;
+            flag = true;
+            cur[u] = edge[i].next;
+            break;
+        }
+        if(!flag){
+            top--;
+            for(int i = h[u];i != -1;i = query[i].next){
+                int v = query[i].v;
+                int type = query[i].id;
+                int w = query[i].val;
+                if(vis[v]){
+                    if(type == 1){
+                        PF[find(v)] -= w;
+                        if(fa[find(v)] != -1)PF[fa[find(v)]] -= w;
+                        PF[v] += w;
+                    }
+                    else {
+                        EF[find(v)] -= 2*w;
+                        EF[v] += w;
+                    }
+                }
+                else {
+                    if(type == 1)PF[v] += w;
+                    else EF[v] += w;
+                }
+            }
+            if(fa[u] != -1)bing(u,fa[u]);
+            vis[u] = true;
+        }
+    }
+}
+long long a[MAXN];
+long long ans1[MAXN],ans2[MAXN];
+int gg[MAXN];
+void dfs2(int u,int pre){
+    int l,r;
+    gg[l = r = 1] = 1;
+    for(;l <= r;l++)
+        for(int i = head[gg[l]];i != -1;i = edge[i].next){
+            int v = edge[i].to;
+            if(v == fa[gg[l]])continue;
+            gg[++r] = v;
+        }
+    for(l--;l;l--){
+        u = gg[l];
+        for(int i = head[u];i != -1;i = edge[i].next){
+            int v = edge[i].to;
+            if(v == fa[u])continue;
+            EF[u] += EF[v];
+            PF[u] += PF[v];
+            ans2[edge[i].index] = EF[v];
+        }
+        ans1[u] = PF[u] + a[u];
+    }
+}
+template <class T>
+inline bool scan_d(T &ret) {
+    char c; int sgn;
+    if(c=getchar(),c==EOF) return 0; 
+    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
+    sgn=(c=='-')?-1:1;
+    ret=(c=='-')?0:(c-'0');
+    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
+    ret*=sgn;
+    return 1;
+}
+inline void out(long long x) {
+    if(x>9) out(x/10);
+    putchar(x%10+'0');
+}
+int main()
+{
+    int n,m;
+    int T;
+    scanf("%d",&T);
+    int iCase = 0;
+    while(T--){
+        iCase++;
+        init();
+        scan_d(n);
+        scan_d(m);
+        assert(n >= 1 && n <= 100000 && m >= 1 && m <= 100000);
+        memset(a,0,sizeof(a));
+        int u,v,w;
+        for(int i = 1;i < n;i++){
+            scan_d(u);
+            scan_d(v);
+            addedge(u,v,i);
+            addedge(v,u,i);
+        }
+        char op[20];
+        init2();
+        while(m--){
+            scanf("%s",op);
+            scan_d(u);
+            scan_d(v);
+            scan_d(w);
+            assert(u >= 1 && u <= n);
+            assert(v >= 1 && v <= n);
+            assert(abs(w) <= 100000);
+            if(op[3] == '1'){
+                if(u == v)a[u] += w;
+                else {
+                    add_query(u,v,1,w);
+                    add_query(v,u,1,w);
+                }
+            }
+            else {
+                if(u == v)continue;
+                else {
+                    add_query(u,v,2,w);
+                    add_query(v,u,2,w);
+                }
+            }
+        }
+        memset(PF,0,sizeof(PF));
+        memset(EF,0,sizeof(EF));
+        memset(F,-1,sizeof(F));
+        memset(vis,false,sizeof(vis));
+        dfs1(1,-1);
+        dfs2(1,-1);
+        printf("Case #%d:\n",iCase);
+        for(int i = 1;i <= n;i++){
+            out(ans1[i]);
+            if(i < n)printf(" ");
+            else printf("\n");
+        }
+        for(int i = 1;i < n;i++){
+            out(ans2[i]);
+            if(i < n-1)printf(" ");
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5045_autoAC.cpp b/HDOJ/5045_autoAC.cpp
new file mode 100644
index 0000000..e237c92
--- /dev/null
+++ b/HDOJ/5045_autoAC.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+#include <map>
+#include <algorithm>
+using namespace std ;
+typedef __int64 ll ;
+double dp[1005][1050] ;
+double p[15][1005] ;
+int n,m ;
+int main()
+{
+    int T ;
+    scanf("%d",&T) ;
+    for(int cas=1 ;cas<=T ;cas++)
+    {
+        scanf("%d%d",&n,&m) ;
+        for(int i=0 ;i<n ;i++)
+        {
+            for(int j=0 ;j<m ;j++)
+                scanf("%lf",&p[i][j]) ;
+        }
+        for(int i=0 ;i<1005 ;i++)
+            for(int j=0 ;j<1050 ;j++)
+                dp[i][j]=-1.0 ;
+        dp[0][0]=0.0 ;
+        int sm=(1<<n)-1 ;
+        for(int i=0 ;i<m ;i++)
+        {
+            for(int s=0 ;s<=sm ;s++)
+            {
+                if(dp[i][s]<0.0)continue ;
+                int st=0 ;
+                for(int j=0 ;j<n ;j++)
+                {
+                    if(!((1<<j)&s))
+                    {
+                        st=(1<<j)|s ;
+                        if(st==sm)st=0 ;
+                        dp[i+1][st]=max(dp[i+1][st],dp[i][s]+p[j][i]) ;
+                    }
+                }
+            }
+        }
+        double ans=0.0 ;
+        for(int i=0 ;i<=sm ;i++)
+            ans=max(ans,dp[m][i]) ;
+        printf("Case #%d: %.5lf\n",cas,ans) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5046_autoAC.cpp b/HDOJ/5046_autoAC.cpp
new file mode 100644
index 0000000..49fc58a
--- /dev/null
+++ b/HDOJ/5046_autoAC.cpp
@@ -0,0 +1,148 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+#include <assert.h>
+using namespace std;
+const int maxnode = 4000;
+const int MaxM = 70;
+const int MaxN = 70;
+int K;
+struct DLX
+{
+    int n,m,size;
+    int U[maxnode],D[maxnode],R[maxnode],L[maxnode],Row[maxnode],Col[maxnode];
+    int H[MaxN],S[MaxM];
+    int ands,ans[MaxN];
+    void init(int _n,int _m)
+    {
+        n = _n;
+        m = _m;
+        for(int i = 0;i <= m;i++)
+        {
+            S[i] = 0;
+            U[i] = D[i] = i;
+            L[i] = i-1;
+            R[i] = i+1;
+        }
+        R[m] = 0; L[0] = m;
+        size = m;
+        for(int i = 1;i <= n;i++)
+            H[i] = -1;
+    }
+    void Link(int r,int c)
+    {
+        ++S[Col[++size]=c];
+        Row[size] = r;
+        D[size] = D[c];
+        U[D[c]] = size;
+        U[size] = c;
+        D[c] = size;
+        if(H[r] < 0)H[r] = L[size] = R[size] = size;
+        else
+        {
+            R[size] = R[H[r]];
+            L[R[H[r]]] = size;
+            L[size] = H[r];
+            R[H[r]] = size;
+        }
+    }
+    void remove(int c)
+    {
+        for(int i = D[c];i != c;i = D[i])
+            L[R[i]] = L[i], R[L[i]] = R[i];
+    }
+    void resume(int c)
+    {
+        for(int i = U[c];i != c;i = U[i])
+            L[R[i]]=R[L[i]]=i;
+    }
+    bool v[maxnode];
+    int f()
+    {
+        int ret = 0;
+        for(int c = R[0];c != 0;c = R[c])v[c] = true;
+        for(int c = R[0];c != 0;c = R[c])
+            if(v[c])
+            {
+                ret++;
+                v[c] = false;
+                for(int i = D[c];i != c;i = D[i])
+                    for(int j = R[i];j != i;j = R[j])
+                        v[Col[j]] = false;
+            }
+        return ret;
+    }
+    bool Dance(int d)
+    {
+        if(d + f() > K)return false;
+        if(R[0] == 0)return d <= K;
+        int c = R[0];
+        for(int i = R[0];i != 0;i = R[i])
+            if(S[i] < S[c])
+                c = i;
+        for(int i = D[c];i != c;i = D[i])
+        {
+            remove(i);
+            for(int j = R[i];j != i;j = R[j])remove(j);
+            if(Dance(d+1))return true;
+            for(int j = L[i];j != i;j = L[j])resume(j);
+            resume(i);
+        }
+        return false;
+    }
+};
+DLX g;
+struct Point
+{
+    int x,y;
+    void input()
+    {
+        scanf("%d%d",&x,&y);
+    }
+}city[MaxM];
+long long dis(Point a,Point b)
+{
+    return (long long)abs(a.x-b.x)+(long long)abs(a.y-b.y);
+}
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    int iCase = 0;
+    while(T--)
+    {
+        iCase++;
+        scanf("%d%d",&n,&K);
+        assert(n >= 1 && n <= 60 && K >= 1 && K <= n);
+        for(int i = 0;i < n;i++){
+            city[i].input();
+            assert(abs(city[i].x) <= 1000000000);
+            assert(abs(city[i].y) <= 1000000000);
+        }
+        long long l = 0, r = 100000000000LL;
+        long long ans = 0;
+        while(l <= r)
+        {
+            long long mid = (l+r)/2;
+            g.init(n,n);
+            for(int i = 0;i < n;i++)
+                for(int j = 0;j < n;j++)
+                    if(dis(city[i],city[j]) <= mid)
+                        g.Link(i+1,j+1);
+            if(g.Dance(0)){r = mid-1;ans = mid;}
+            else l = mid+1;
+        }
+        printf("Case #%d: %I64d\n",iCase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5047_autoAC.cpp b/HDOJ/5047_autoAC.cpp
new file mode 100644
index 0000000..fdf4a91
--- /dev/null
+++ b/HDOJ/5047_autoAC.cpp
@@ -0,0 +1,25 @@
+#include <cstdio>
+using namespace std ;
+typedef __int64 ll ;
+const ll mod=1000000 ;
+int main()
+{
+    int T ;
+    scanf("%d",&T) ;
+    for(int cas=1 ;cas<=T ;cas++)
+    {
+        ll n ;
+        scanf("%I64d",&n) ;
+        ll t=8*n-7 ;
+        ll lt=t/mod ;
+        ll rt=t%mod ;
+        lt*=n ;
+        rt=rt*n+1 ;
+        lt=lt+rt/mod ;
+        rt%=mod ;
+        printf("Case #%d: ",cas) ;
+        if(lt)printf("%I64d%06I64d\n",lt,rt) ;
+        else printf("%I64d\n",rt) ;
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5048_autoAC.cpp b/HDOJ/5048_autoAC.cpp
new file mode 100644
index 0000000..8a188a3
--- /dev/null
+++ b/HDOJ/5048_autoAC.cpp
@@ -0,0 +1,182 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+#include <assert.h>
+using namespace std;
+const double eps = 1e-8;
+inline double sqr(double x){return x*x;}
+struct Point{
+    double x,y,z;
+    void input(){
+        scanf("%lf%lf%lf",&x,&y,&z);
+        assert(fabs(x) <= 10000);
+        assert(fabs(y) <= 10000);
+        assert(fabs(z) <= 10000);
+    }
+};
+struct Line{
+    Point s,e;
+    void input(){
+        s.input();
+        e.input();
+    }
+    double len(){
+        return sqrt((s.x-e.x)*(s.x-e.x)+(s.y-e.y)*(s.y-e.y)+(s.z-e.z)*(s.z-e.z));
+    }
+};
+struct Ellipsoid{
+    double x,y,z,a,b,c;
+    char color[5];
+    void input(){
+        scanf("%lf%lf%lf%lf%lf%lf%s",&x,&y,&z,&a,&b,&c,color);
+        assert(fabs(x) <= 10000);
+        assert(fabs(y) <= 10000);
+        assert(fabs(z) <= 10000);
+        assert(a >= 1 && a <= 10000);
+        assert(b >= 1 && b <= 10000);
+        assert(c >= 1 && c <= 10000);
+        assert(color[0] == 'R' || color[0] == 'G' || color[0] == 'B');
+    }
+    void output(){
+        printf("%lf %lf %lf %lf %lf %lf %s\n",x,y,z,a,b,c,color);
+    }
+};
+double calc(vector<Line>line,vector<Ellipsoid>el){
+    double ans = 0;
+    int sz1 = line.size();
+    for(int i = 0;i < sz1;i++){
+        vector<pair<double,int> >vec;
+        vec.push_back(make_pair(0.0,0));
+        vec.push_back(make_pair(1.0,0));
+        double len = line[i].len();
+        if(fabs(len) < eps)continue;
+        double x1 = line[i].s.x;
+        double y1 = line[i].s.y;
+        double z1 = line[i].s.z;
+        double dx = line[i].e.x - line[i].s.x;
+        double dy = line[i].e.y - line[i].s.y;
+        double dz = line[i].e.z - line[i].s.z;
+        int sz = el.size();
+        for(int j = 0;j < sz;j++){
+            double a = sqr(dx)/sqr(el[j].a) + sqr(dy)/sqr(el[j].b) + sqr(dz)/sqr(el[j].c);
+            double b = 2*dx*(x1-el[j].x)/sqr(el[j].a) + 
+                2*dy*(y1-el[j].y)/sqr(el[j].b) + 2*dz*(z1-el[j].z)/sqr(el[j].c);
+            double c = sqr(x1-el[j].x)/sqr(el[j].a) + sqr(y1-el[j].y)/sqr(el[j].b)
+                + sqr(z1-el[j].z)/sqr(el[j].c) - 1;
+            double delta = b*b - 4*a*c;
+            if(delta < eps)continue;
+            double k1 = (-b+sqrt(delta))/(2*a);
+            double k2 = (-b-sqrt(delta))/(2*a);
+            if(k1 > k2)swap(k1,k2);
+            k1 = max(0.0,k1);
+            k2 = min(1.0,k2);
+            if(k1 >= k2)continue;
+            vec.push_back(make_pair(k1,1));
+            vec.push_back(make_pair(k2,-1));
+        }
+        int cnt = 0;
+        sort(vec.begin(),vec.end());
+        int sz2 = vec.size();
+        double pre = 0;
+        for(int j = 0;j < sz2;j++){
+            if(cnt > 0)
+                ans += (vec[j].first - pre)*len;
+            pre = vec[j].first;
+            cnt += vec[j].second;
+        }
+    }
+    return ans;
+}
+Line line[110];
+Ellipsoid el[110];
+vector<Line>vec1;
+vector<Ellipsoid>vec2;
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    assert(T >= 1 && T  <= 100);
+    int iCase = 0;
+    int n,m;
+    while(T--){
+        iCase++;
+        scanf("%d%d",&n,&m);
+        for(int i = 0;i < n;i++)line[i].input();
+        for(int i = 0;i < m;i++){
+            el[i].input();
+        }
+        vec1.clear();
+        for(int i = 0;i < n;i++)vec1.push_back(line[i]);
+        double tot = 0;
+        for(int i = 0;i < n;i++)tot += line[i].len();
+        vec2.clear();
+        for(int i = 0;i < m;i++)
+            if(el[i].color[0] == 'R')
+                vec2.push_back(el[i]);
+        double R = calc(vec1,vec2);
+        vec2.clear();
+        for(int i = 0;i < m;i++)
+            if(el[i].color[0] == 'G')
+                vec2.push_back(el[i]);
+        double G = calc(vec1,vec2);
+        vec2.clear();
+        for(int i = 0;i < m;i++)
+            if(el[i].color[0] == 'B')
+                vec2.push_back(el[i]);
+        double B = calc(vec1,vec2);
+        vec2.clear();
+        for(int i = 0;i < m;i++)
+            if(el[i].color[0] == 'R' || el[i].color[0] == 'G')
+                vec2.push_back(el[i]);
+        double RG = calc(vec1,vec2);
+        vec2.clear();
+        for(int i = 0;i < m;i++)
+            if(el[i].color[0] == 'R' || el[i].color[0] == 'B')
+                vec2.push_back(el[i]);
+        double RB = calc(vec1,vec2);
+        vec2.clear();
+        for(int i = 0;i < m;i++)
+            if(el[i].color[0] == 'G' || el[i].color[0] == 'B')
+                vec2.push_back(el[i]);
+        double GB = calc(vec1,vec2);
+        vec2.clear();
+        for(int i = 0;i < m;i++)
+            if(el[i].color[0] == 'R' || el[i].color[0] == 'G' || el[i].color[0] == 'B')
+                vec2.push_back(el[i]);
+        double RGB = calc(vec1,vec2);
+        double ans1 = RGB - GB;
+        double ans2 = RGB - RB;
+        double ans3 = RGB - RG;
+        double ans4 = RGB - B - ans1 - ans2;
+        double ans5 = RGB - G - ans1 - ans3;
+        double ans6 = RGB - R - ans2 - ans3;
+        double ans7 = R + G - RG - ans4;
+        double aa = tot-RGB;
+        if(fabs(aa) < eps)aa = 0;
+        if(fabs(ans1) < eps)ans1 = 0;
+        if(fabs(ans2) < eps)ans2 = 0;
+        if(fabs(ans3) < eps)ans3 = 0;
+        if(fabs(ans4) < eps)ans4 = 0;
+        if(fabs(ans5) < eps)ans5 = 0;
+        if(fabs(ans6) < eps)ans6 = 0;
+        if(fabs(ans7) < eps)ans7 = 0;
+        printf("%.10lf\n",aa);
+        printf("%.10lf\n",ans1);
+        printf("%.10lf\n",ans2);
+        printf("%.10lf\n",ans3);
+        printf("%.10lf\n",ans4);
+        printf("%.10lf\n",ans5);
+        printf("%.10lf\n",ans6);
+        printf("%.10lf\n",ans7);
+    }
+    return 0;
+}
diff --git a/HDOJ/5049_autoAC.cpp b/HDOJ/5049_autoAC.cpp
new file mode 100644
index 0000000..f7394d6
--- /dev/null
+++ b/HDOJ/5049_autoAC.cpp
@@ -0,0 +1,241 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+#include <assert.h>
+using namespace std;
+const int MOD = 20140927;
+struct Matrix{
+    int mat[2][2];
+    void init(){
+        memset(mat,0,sizeof(mat));
+    }
+    Matrix operator *(const Matrix &b)const{
+        Matrix ret;
+        for(int i = 0;i < 2;i++)
+            for(int j = 0;j < 2;j++){
+                ret.mat[i][j] = 0;
+                for(int k = 0;k < 2;k++){
+                    ret.mat[i][j] += (long long)mat[i][k]*b.mat[k][j]%MOD;
+                    if(ret.mat[i][j] >= MOD)
+                        ret.mat[i][j] -= MOD;
+                }
+            }
+        return ret;
+    }
+    void output(){
+        printf("%d %d\n%d %d\n",mat[0][0],mat[0][1],mat[1][0],mat[1][1]);
+    }
+};
+Matrix pow_M(Matrix A,int n){
+    Matrix ret;
+    ret.mat[0][0] = ret.mat[1][1] = 1;
+    ret.mat[0][1] = ret.mat[1][0] = 0;
+    Matrix tmp = A;
+    while(n){
+        if(n&1)ret = ret*tmp;
+        tmp = tmp*tmp;
+        n >>= 1;
+    }
+    return ret;
+}
+Matrix A[11*11*11 + 100];
+vector<int>vec;
+Matrix B;
+Matrix C;
+struct Matrix2{
+    int mat[2][2];
+    void init(){
+        memset(mat,0,sizeof(mat));
+    }
+    Matrix2 operator *(const Matrix2 &b)const{
+        Matrix2 ret;
+        for(int i = 0;i < 2;i++)
+            for(int j = 0;j < 2;j++){
+                ret.mat[i][j] = 0;
+                for(int k = 0;k < 2;k++)
+                    if(mat[i][k] && b.mat[k][j])
+                        ret.mat[i][j] = 1;
+            }
+        return ret;
+    }
+};
+Matrix2 pow_M(Matrix2 A,int n){
+    Matrix2 ret;
+    ret.mat[0][0] = ret.mat[1][1] = 1;
+    ret.mat[0][1] = ret.mat[1][0] = 0;
+    Matrix2 tmp = A;
+    while(n){
+        if(n&1)ret = ret*tmp;
+        tmp = tmp*tmp;
+        n >>= 1;
+    }
+    return ret;
+}
+Matrix2 A2[11*11*11 + 100];
+Matrix2 B2;
+Matrix2 C2;
+void Add(int &a,int b){
+    if(a || b)a = 1;
+}
+int main()
+{
+    for(int i = 0;i < 11*11*11;i++)A[i].init();
+    for(int i = 0;i < 11*11*11;i++)A2[i].init();
+    for(int x = 0;x < 11;x++)
+        for(int y = 0;y < 11;y++)
+            for(int z = 0; z < 11;z++){
+                int id = x*11*11 + y*11 + z;
+                for(int i = 0;i < 10;i++){
+                    if(x != 10 && x != i)continue;
+                    for(int j = 0;j < 10;j++){
+                        if(y != 10 && y != j)continue;
+                        for(int k = 0;k < 10;k++){
+                            if(z != 10 && z != k)continue;
+                            if(i + j == k)A[id].mat[0][0]++;
+                            if(i + j == 10 + k)A[id].mat[0][1]++;
+                            if(i + j + 1 == k)A[id].mat[1][0]++;
+                            if(i + j + 1 == 10 + k)A[id].mat[1][1]++;
+                            if(i + j == k)Add(A2[id].mat[0][0],1);
+                            if(i + j == 10 + k)Add(A2[id].mat[0][1],1);
+                            if(i + j + 1 == k)Add(A2[id].mat[1][0],1);
+                            if(i + j + 1 == 10 + k)Add(A2[id].mat[1][1],1);
+                        }
+                    }
+                }
+            }
+    int T;
+    int iCase = 0;
+    int n1,m1,n2,m2,n3,m3;
+    scanf("%d",&T);
+    while(T--){
+        iCase++;
+        scanf("%d%d",&n1,&m1);
+        assert(n1 >= 1 && n1 <= 10000000);
+        assert(m1 >= 0 && m1 <= n1);
+        map<int,int>mp1;
+        map<int,int>mp2;
+        map<int,int>mp3;
+        bool flag = true;
+        vec.clear();
+        int id,x;
+        while(m1--){
+            scanf("%d%d",&id,&x);
+            id = n1 - 1 - id;
+            vec.push_back(id);
+            if(mp1.find(id) != mp1.end()){
+                if(mp1[id] != x)flag = false;
+            }
+            else mp1[id] = x;
+        }
+        scanf("%d%d",&n2,&m2);
+        assert(n2 >= 1 && n2 <= 10000000);
+        assert(m2 >= 0 && m2 <= n2);
+        while(m2--){
+            scanf("%d%d",&id,&x);
+            id = n2 - 1 - id;
+            vec.push_back(id);
+            if(mp2.find(id) != mp2.end()){
+                if(mp2[id] != x)flag = false;
+            }
+            else mp2[id] = x;
+        }
+        scanf("%d%d",&n3,&m3);
+        assert(n3 >= 1 && n3 <= 10000000);
+        assert(m3 >= 0 && m3 <= n3);
+        while(m3--){
+            scanf("%d%d",&id,&x);
+            id = n3 - 1 - id;
+            vec.push_back(id);
+            if(mp3.find(id) != mp3.end()){
+                if(mp3[id] != x)flag = false;
+            }
+            else mp3[id] = x;
+        }
+        if((!flag) || (n1 < max(n2,n3)) || (n1 > max(n2,n3)+1)){
+            printf("Case #%d: IMPOSSIBLE\n",iCase);
+            continue;
+        }
+        vec.push_back(n2-1);
+        vec.push_back(n3-1);
+        sort(vec.begin(),vec.end());
+        vec.erase(unique(vec.begin(),vec.end()),vec.end());
+        int mn = max(n2,n3);
+        B.init();
+        B.mat[0][0] = B.mat[1][1] = 1;
+        B2.init();
+        B2.mat[0][0] = B2.mat[1][1] = 1;
+        if(vec[0] > 0)B = B * pow_M(A[10*11*11+10*11+10],vec[0]);
+        if(vec[0] > 0)B2 = B2 * pow_M(A2[10*11*11+10*11+10],vec[0]);
+        int sz = vec.size();
+        for(int i = 0;i < sz;i++){
+            if(i > 0){
+                B = B * pow_M(A[10*11*11+10*11+10],vec[i]-vec[i-1]-1);
+            }
+            int x,y,z;
+            if(mp2.find(vec[i]) == mp2.end())x = 10;
+            else x = mp2[vec[i]];
+            if(vec[i] >= n2)x = 0;
+            if(mp3.find(vec[i]) == mp3.end())y = 10;
+            else y = mp3[vec[i]];
+            if(vec[i] >= n3)y = 0;
+            if(mp1.find(vec[i]) == mp1.end())z = 10;
+            else z = mp1[vec[i]];
+            if(vec[i] >= n1)z = 0;
+            if(vec[i] != n2-1 && vec[i] != n3-1){
+                B = B * A[x*11*11+y*11+z];
+                B2 = B2 * A2[x*11*11+y*11+z];
+            }
+            else {
+                C.init();
+                C2.init();
+                for(int p = 0;p < 10;p++)
+                    for(int q = 0;q < 10;q++)
+                        for(int r = 0;r < 10;r++){
+                            if(x != 10 && p != x)continue;
+                            if(y != 10 && q != y)continue;
+                            if(z != 10 && r != z)continue;
+                            if(n2 != 1 && vec[i] == n2-1 && p == 0)continue;
+                            if(n3 != 1 && vec[i] == n3-1 && q == 0)continue;
+                            if(vec[i] >= n2 && p != 0)continue;
+                            if(vec[i] >= n3 && q != 0)continue;
+                            if(p+q == r)C.mat[0][0]++;
+                            if(p+q == r+10)C.mat[0][1]++;
+                            if(p+q+1 == r)C.mat[1][0]++;
+                            if(p+q+1 == r + 10)C.mat[1][1]++;
+                            if(p+q == r)Add(C2.mat[0][0],1);
+                            if(p+q == r+10)Add(C2.mat[0][1],1);
+                            if(p+q+1 == r)Add(C2.mat[1][0],1);
+                            if(p+q+1 == r + 10)Add(C2.mat[1][1],1);
+                        }
+                B = B*C;
+                B2 = B2*C2;
+            }
+        }
+        int ans = 0;
+        int ans2 = 0;
+        if(n1 == max(n2,n3)){
+            ans = B.mat[0][0];
+            ans2 = B2.mat[0][0];
+        }
+        else{
+            if(mp1.find(n1-1) != mp1.end() && mp1[n1-1] != 1){
+                printf("Case #%d: IMPOSSIBLE\n",iCase);
+                continue;
+            }
+            ans = B.mat[0][1];
+            ans2 = B2.mat[0][1];
+        }
+        if(ans2 == 0)printf("Case #%d: IMPOSSIBLE\n",iCase);
+        else printf("Case #%d: %d\n",iCase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5050_autoAC.cpp b/HDOJ/5050_autoAC.cpp
new file mode 100644
index 0000000..52a8479
--- /dev/null
+++ b/HDOJ/5050_autoAC.cpp
@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+struct BigNum{
+    int a[10100];
+    int n;
+    void input(char str[]){
+        n = strlen(str);
+        for(int i = 0;i < n;i++)
+            a[i] = str[n-1-i]-'0';
+    }
+    bool operator <(const BigNum &b)const{
+        if(n < b.n)return true;
+        if(n > b.n)return false;
+        for(int i = n-1;i >= 0;i--){
+            if(a[i] < b.a[i])return true;
+            if(a[i] > b.a[i])return false;
+        }
+        return true;
+    }
+    BigNum operator -(const BigNum &b)const{
+        BigNum ret;
+        ret.n = n;
+        int mu = 0;
+        for(int i = 0;i < n;i++){
+            int tmp;
+            if(i < b.n)tmp = a[i] - b.a[i] - mu;
+            else tmp = a[i] - mu;
+            if(tmp >= 0){
+                mu = 0;
+                ret.a[i] = tmp;
+            }
+            else {
+                mu = 1;
+                ret.a[i] = tmp+2;
+            }
+        }
+        while(ret.n > 0 && ret.a[ret.n-1] == 0)ret.n--;
+        return ret;
+    }
+    BigNum div2(){
+        BigNum ret;
+        ret.n = n-1;
+        for(int i = 0;i < n-1;i++)
+            ret.a[i] = a[i+1];
+        return ret;
+    }
+    void output(){
+        for(int i = n-1;i >= 0;i--)
+            printf("%d",a[i]);
+    }
+};
+void gcd(BigNum a,BigNum b){
+    int c2 = 0;
+    while(a.n && b.n){
+        if(a.a[0]){
+            if(b.a[0]){
+                if(b < a)a = a-b;
+                else b = b-a;
+            }
+            else b = b.div2();
+        }
+        else {
+            if(b.a[0])a = a.div2();
+            else{
+                a = a.div2();
+                b = b.div2();
+                c2++;
+            }
+        }
+    }
+    if(a.n)a.output();
+    else b.output();
+    while(c2--){
+        printf("0");
+    }
+    printf("\n");
+}
+char str[10010];
+BigNum a,b,c;
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    int iCase = 0;
+    while(T--){
+        iCase++;
+        scanf("%s",str);
+        a.input(str);
+        scanf("%s",str);
+        b.input(str);
+        printf("Case #%d: ",iCase);
+        gcd(a,b);
+    }
+    return 0;
+}
diff --git a/HDOJ/5051_autoAC.cpp b/HDOJ/5051_autoAC.cpp
new file mode 100644
index 0000000..c8d2a48
--- /dev/null
+++ b/HDOJ/5051_autoAC.cpp
@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+int main()
+{
+    int T;
+    int iCase = 0;
+    scanf("%d",&T);
+    int n,b,q;
+    while(T--){
+        iCase++;
+        scanf("%d%d%d",&n,&b,&q);
+        printf("Case #%d: ",iCase);
+        if(q == 1){
+            bool flag = false;
+            while(b){
+                if(n == b){
+                    flag = true;
+                    break;
+                }
+                b /= 10;
+            }
+            if(flag)printf("1.00000\n");
+            else printf("0.00000\n");
+        }
+        else if(q == 10 || q == 100 || q == 1000){
+            b *= 100000;
+            bool flag = false;
+            while(b){
+                if(n == b){
+                    flag = true;
+                    break;
+                }
+                b /= 10;
+            }
+            if(flag)printf("1.00000\n");
+            else printf("0.00000\n");
+        }
+        else {
+            double ans = (log(n+1)-log(n))/log(10);
+            printf("%.5lf\n",ans);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5052_autoAC.cpp b/HDOJ/5052_autoAC.cpp
new file mode 100644
index 0000000..82a99c3
--- /dev/null
+++ b/HDOJ/5052_autoAC.cpp
@@ -0,0 +1,186 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+#include <assert.h>
+using namespace std;
+const int MAXN = 50010;
+const int INF = 0x3f3f3f3f;
+struct Node *null;
+struct Node{
+    Node *fa,*ch[2];
+    int val;
+    int Max,Min;
+    int mm;
+    int rmm;
+    int rev,add;
+    inline void clear(int _val){
+        fa = ch[0] = ch[1] = null;
+        val = Max = Min = _val;
+        mm = 0;
+        rmm = 0;
+        rev = 0;
+        add = 0;
+    }
+    inline void push_up(){
+        if(this == null)return;
+        mm = 0;
+        mm = max(mm,ch[0]->mm);
+        mm = max(mm,ch[1]->mm);
+        mm = max(mm,max(val,ch[1]->Max)-ch[0]->Min);
+        mm = max(mm,ch[1]->Max-min(ch[0]->Min,val));
+        rmm = 0;
+        rmm = max(rmm,ch[0]->rmm);
+        rmm = max(rmm,ch[1]->rmm);
+        rmm = max(rmm,max(val,ch[0]->Max)-ch[1]->Min);
+        rmm = max(rmm,ch[0]->Max-min(ch[1]->Min,val));
+        Max = max(val,max(ch[0]->Max,ch[1]->Max));
+        Min = min(val,min(ch[0]->Min,ch[1]->Min));
+    }
+    inline void setc(Node *p,int d){
+        ch[d] = p;
+        p->fa = this;
+    }
+    inline bool d(){
+        return fa->ch[1] == this;
+    }
+    inline bool isroot(){
+        return fa == null || fa->ch[0] != this && fa->ch[1] != this;
+    }
+    inline void flip(){
+        if(this == null)return;
+        swap(ch[0],ch[1]);
+        swap(mm,rmm);
+        rev ^= 1;
+    }
+    inline void update_add(int w){
+        if(this == null)return;
+        val += w;
+        Min += w;
+        Max += w;
+        add += w;
+    }
+    inline void push_down(){
+        if(this == null)return;
+        if(rev){
+            ch[0]->flip(); ch[1]->flip(); rev = 0;
+        }
+        if(add){
+            ch[0]->update_add(add);ch[1]->update_add(add);
+            add = 0;
+        }
+    }
+    inline void go(){
+        if(!isroot())fa->go();
+        push_down();
+    }
+    inline void rot(){
+        Node *f = fa, *ff = fa->fa;
+        int c = d(), cc = fa->d();
+        f->setc(ch[!c],c);
+        this->setc(f,!c);
+        if(ff->ch[cc] == f)ff->setc(this,cc);
+        else this->fa = ff;
+        f->push_up();
+    }
+    inline Node* splay(){
+        go();
+        while(!isroot()){
+            if(!fa->isroot())
+                d()==fa->d() ? fa->rot() : rot();
+            rot();
+        }
+        push_up();
+        return this;
+    }
+    inline Node* access(){
+        for(Node *p = this, *q = null; p != null; q = p, p = p->fa){
+            p->splay()->setc(q,1);
+            p->push_up();
+        }
+        return splay();
+    }
+    inline void make_root(){
+        access()->flip();
+    }
+};
+Node pool[MAXN],*tail;
+Node *node[MAXN];
+struct Edge{
+    int to,next;
+}edge[MAXN*2];
+int head[MAXN],tot;
+void init(){
+    tot = 0;
+    memset(head,-1,sizeof(head));
+}
+inline void addedge(int u,int v){
+    edge[tot].to = v;
+    edge[tot].next = head[u];
+    head[u] = tot++;
+}
+int g[MAXN];
+int fa[MAXN];
+void bfs(int s){
+    int l,r;
+    g[l=r=1] = s;
+    fa[s] = s;
+    while(l <= r){
+        int u = g[l++];
+        for(int i = head[u];i != -1;i = edge[i].next){
+            int v = edge[i].to;
+            if(v == fa[u])continue;
+            fa[v] = u;
+            node[v]->fa = node[u];
+            g[++r] = v;
+        }
+    }
+}
+int main()
+{
+    int T;
+    int n,m;
+    scanf("%d",&T);
+    assert(T > 0 && T <= 10);
+    while(T--){
+        scanf("%d",&n);
+        tail = pool;
+        null = tail++;
+        null->fa = null->ch[0] = null->ch[1] = null;
+        null->Max = -INF;
+        null->Min = INF;
+        null->mm = 0;
+        null->add = null->rev = 0;
+        int w;
+        for(int i = 1;i <= n;i++){
+            scanf("%d",&w);
+            node[i] = tail++;
+            node[i]->clear(w);
+        }
+        init();
+        int u,v;
+        for(int i = 1;i < n;i++){
+            scanf("%d%d",&u,&v);
+            addedge(u,v);
+            addedge(v,u);
+        }
+        bfs(1);
+        scanf("%d",&m);
+        while(m--){
+            scanf("%d%d%d",&u,&v,&w);
+            node[u]->make_root();
+            node[v]->access();
+            printf("%d\n",node[v]->mm);
+            node[v]->update_add(w);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5053_autoAC.cpp b/HDOJ/5053_autoAC.cpp
new file mode 100644
index 0000000..bb36b49
--- /dev/null
+++ b/HDOJ/5053_autoAC.cpp
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+int main()
+{
+    int T;
+    int iCase = 0;
+    scanf("%d",&T);
+    long long a,b;
+    while(T--){
+        iCase++;
+        scanf("%I64d%I64d",&a,&b);
+        a--;
+        long long ans = (b*(b+1)/2)*(b*(b+1)/2) - (a*(a+1)/2)*(a*(a+1)/2);
+        printf("Case #%d: %I64d\n",iCase,ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5054_autoAC.cpp b/HDOJ/5054_autoAC.cpp
new file mode 100644
index 0000000..8abf767
--- /dev/null
+++ b/HDOJ/5054_autoAC.cpp
@@ -0,0 +1,15 @@
+#include<iostream>
+#include<stdio.h>
+using namespace std;
+int main()
+{
+    int N,M,x,y;
+    while(scanf("%d%d%d%d",&N,&M,&x,&y)!=EOF)
+    {
+        if(2*x==N&&2*y==M)
+            printf("YES\n");
+        else
+            printf("NO\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5055_autoAC.cpp b/HDOJ/5055_autoAC.cpp
new file mode 100644
index 0000000..94b7f9d
--- /dev/null
+++ b/HDOJ/5055_autoAC.cpp
@@ -0,0 +1,48 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<functional>
+#include<iostream>
+using namespace std;
+int str[120];
+int main()
+{
+  int n,i,res;
+  while(scanf("%d",&n)!=EOF)
+  {
+      res=10;
+      for(i=0;i<n;i++)
+    {
+       scanf("%d",&str[i]);
+      if(str[i]&1==1&&res>str[i])
+          res=str[i];
+    }
+    if(res==10){
+        printf("-1\n");
+        continue;
+    }
+    sort(str,str+n,greater<int>());
+     int fir=-1,st=res;
+    for(i=0;i<n;i++)
+    {
+        if(res==str[i]) res=-1;
+        else
+        {
+            fir=str[i];
+            break;
+        }
+    }
+    if(fir==0) printf("-1\n");
+    else
+    {
+        if(fir!=-1)
+          printf("%d",fir);
+        for( i++; i<n;i++)
+        if(res==str[i])res=-1;
+        else
+         printf("%d",str[i]);
+        printf("%d\n",st);
+    }
+  }
+  return 0;
+}
diff --git a/HDOJ/5056_autoAC.cpp b/HDOJ/5056_autoAC.cpp
new file mode 100644
index 0000000..e479b59
--- /dev/null
+++ b/HDOJ/5056_autoAC.cpp
@@ -0,0 +1,64 @@
+#include <cstdio>
+#include <stack>
+#include <set>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <queue>
+#include <functional>
+#include <cstring>
+#include <algorithm>
+#include <cctype>
+#include <ctime>
+#include <cstdlib>
+#include <fstream>
+#include <string>
+#include <sstream>
+#include <map>
+#include <cmath>
+#define LL long long
+#define lowbit(x) ((x) & (-x))
+#define MP(a, b) make_pair(a, b)
+#define MS(arr, num) memset(arr, num, sizeof(arr))
+#define PB push_back
+#define F first
+#define S second
+#define ROP freopen("input.txt", "r", stdin);
+#define BitCount(x) __builtin_popcount(x)
+const double PI = acos(-1.0);
+const int INF = 0x3f3f3f3f;
+using namespace std;
+const int MAXN = 1e5 + 100;
+const int MOD = 20071027;
+typedef pair<int, int> pii;
+typedef vector<int>::iterator viti;
+typedef vector<pii>::iterator vitii;
+char str[MAXN];
+int cnt[30];
+int main()
+{
+    //ROP;
+    int n, i, j, last, T, k;
+    scanf("%d", &T);
+    while (T--)
+    {
+        MS(cnt, 0);
+        int pos = 1;
+        scanf("%s", str + 1);
+        scanf("%d", &k);
+        int len = strlen(str + 1);
+        LL ans = 0;
+        for (i = 1; i <= len; i++)
+        {
+            cnt[str[i] - 'a']++;
+            while (cnt[str[i] - 'a'] > k)
+            {
+                cnt[str[pos] - 'a']--;
+                pos++;
+            }
+            ans += i - pos + 1;
+        }
+        cout << ans << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/5057_autoAC.cpp b/HDOJ/5057_autoAC.cpp
new file mode 100644
index 0000000..7497b44
--- /dev/null
+++ b/HDOJ/5057_autoAC.cpp
@@ -0,0 +1,65 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<vector>
+#define ll long long
+using namespace std;
+const int maxn=100005;
+int n,m;
+int digit[maxn][10];
+int block[400][10][10];
+int X,Y,L,R,D,P;
+int main()
+{
+    int x;
+    char str[10];
+    int t;
+    scanf("%d",&t);
+    while(t--) {
+        scanf("%d%d",&n,&m);
+        memset(block,0,sizeof(block));
+        for(int i=1;i<=n;i++) {
+            scanf("%d",&x);
+            int b=(i>>8);
+            for(int j=1;j<=10;j++) {
+                digit[i][j]=x%10;
+                block[b][j][x%10]++;
+                x/=10;
+            }
+        }
+        for(int i=0;i<m;i++) {
+            scanf("%s",str);
+            if(str[0]=='S') {
+                scanf("%d%d",&X,&Y);
+                int b=(X>>8);
+                for(int j=1;j<=10;j++) {
+                    block[b][j][digit[X][j]]--;
+                    digit[X][j]=Y%10;
+                    block[b][j][Y%10]++;
+                    Y/=10;
+                }
+            }
+            else {
+                scanf("%d%d%d%d",&L,&R,&D,&P);
+                int bl=((L-1)>>8)+1,br=((R+1)>>8)-1;
+                int ans=0;
+                if(bl<=br) {
+                    for(int i=bl;i<=br;i++)
+                        ans+=block[i][D][P];
+                    for(int i=L;i<(bl<<8);i++)
+                        ans+=(digit[i][D]==P);
+                    for(int i=((br+1)<<8);i<=R;i++)
+                        ans+=(digit[i][D]==P);
+                }
+                else {
+                    for(int i=L;i<=R;i++) {
+                        ans+=(digit[i][D]==P);
+                    }
+                }
+                printf("%d\n",ans);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5058_autoAC.cpp b/HDOJ/5058_autoAC.cpp
new file mode 100644
index 0000000..8c3a1ae
--- /dev/null
+++ b/HDOJ/5058_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <cstdio>
+#include <algorithm>
+#include <set>
+using namespace std;
+int main()
+{
+    set<int>s1,s2;
+    int n;
+    while(~scanf("%d",&n))
+    {
+        s1.clear();
+        s2.clear();
+        int tt;
+        for(int i = 0; i < n; i++)
+        {
+            scanf("%d",&tt);
+            s1.insert(tt);
+        }
+        for(int i = 0; i < n; i++)
+        {
+            scanf("%d",&tt);
+            s2.insert(tt);
+        }
+        if(s1.size() != s2.size())
+        {
+            printf("NO\n");
+            continue;
+        }
+        int flag = 0;
+        set<int>::iterator it1, it2;
+        for(it1 = s1.begin(),it2 = s2.begin(); it1!=s1.end()&&it2!=s2.end(); it1++,it2++)
+        {
+            if(*it1 != *it2)
+            {
+                flag = 1;
+                break;
+            }
+        }
+        if(flag)
+        {
+            printf("NO\n");
+        }
+        else
+            printf("YES\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5059_autoAC.cpp b/HDOJ/5059_autoAC.cpp
new file mode 100644
index 0000000..f1cfa4b
--- /dev/null
+++ b/HDOJ/5059_autoAC.cpp
@@ -0,0 +1,43 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+char S[200];
+char C[200];
+int len;
+long long a,b;
+int getans(char *A)
+{
+    int i;
+    int lena=strlen(A);
+    if(lena==0) return 0;
+    if(lena!=1&&A[0]=='0') return 0;
+    for(i=0;i<lena;i++)
+    if(!('0'<=A[i]&&A[i]<='9')) return 0;
+    return 1; 
+}
+int main()
+{
+    int ans;
+    long long k;
+    while(gets(S)!=NULL)
+    {
+        scanf("%I64d%I64d",&a,&b);
+        gets(C);
+        len=strlen(S);
+        if(S[0]=='-'&&S[1]=='0')  { printf("NO\n");continue;}    
+        if(len>11||len==0) { printf("NO\n");continue;}    
+        if(len==11&&S[0]!='-') { printf("NO\n");continue;}    
+        if(S[0]=='-')
+        ans=getans(S+1);
+        else ans=getans(S);
+        if(!ans) { printf("NO\n");continue;}
+        else
+          {
+              k=strtoll(S,NULL,10);
+            if(a<=k&&k<=b) printf("YES\n");    
+            else printf("NO\n");
+          }
+                  memset(S,0,sizeof(S));
+    }
+    return 0;
+}
diff --git a/HDOJ/5060_autoAC.cpp b/HDOJ/5060_autoAC.cpp
new file mode 100644
index 0000000..204c8cf
--- /dev/null
+++ b/HDOJ/5060_autoAC.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+#include <algorithm>
+#include <map>
+using namespace std;
+const double pi=3.14159265358979,eps=1e-7;
+double r,hr,hz;
+double f(double n)
+{
+    return pi*(r*r-n*n);
+}
+double simpson(double a,double b)
+{
+    return (b-a)/6.0*(f(a)+4*f((a+b)/2.0)+f(b));
+}
+double cal(double a,double b)
+{
+    double sum=simpson(a,b),mid=(a+b)/2.0;
+    double t=simpson(a,mid)+simpson(mid,b);
+    if(fabs(t-sum)<eps) return sum;
+    return cal(a,mid)+cal(mid,b);
+}
+int main()
+{
+    while(scanf("%lf%lf%lf",&r,&hr,&hz)!=EOF)
+    {
+        double v=0,hv=0;
+        if(hr>=r&&hz>=r)
+        {
+            v=4.0/3.0*pi*r*r*r;
+            hv=2*pi*hr*hr*hz;
+            printf("%.6lf\n",v/hv);
+            continue;
+        }
+        if(hr>=r&&hz<r)
+        {
+            v=4.0/3.0*pi*r*r*r;
+            double t=2*cal(hz,r);
+            hv=2*pi*hr*hr*hz;
+            printf("%.6lf\n",(v-t)/(hv+t));
+            continue;
+        }
+        if(r*r>=hr*hr+hz*hz)
+        {
+            v=4.0/3.0*pi*r*r*r;
+            hv=2*pi*hr*hr*hz;
+            printf("%.6lf\n",hv/v);
+            continue;
+        }
+        if(hr<r&&hz>=r)
+        {
+            v=4.0/3.0*pi*r*r*r;
+            double t=2*cal(sqrt(r*r-hr*hr),r)+2*sqrt(r*r-hr*hr)*pi*hr*hr;
+            hv=2*pi*hr*hr*hz;
+            printf("%.6lf\n",t/(hv+v-t));
+            continue;
+        }
+        v=4.0/3.0*pi*r*r*r;
+        hv=2*pi*hr*hr*hz;
+        double t=2*cal(sqrt(r*r-hr*hr),hz)+2*sqrt(r*r-hr*hr)*pi*hr*hr;
+        printf("%.6lf\n",t/(hv+v-t));
+    }
+    return 0;
+}
diff --git a/HDOJ/5062_autoAC.cpp b/HDOJ/5062_autoAC.cpp
new file mode 100644
index 0000000..5730ae3
--- /dev/null
+++ b/HDOJ/5062_autoAC.cpp
@@ -0,0 +1,15 @@
+#include <iostream>
+#include <cstdio>
+using namespace std;
+int main()
+{
+    int T,N;
+    int array[8] = {1,9,18,54,90,174,258};
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&N);
+        printf("%d\n",array[N]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5063_autoAC.cpp b/HDOJ/5063_autoAC.cpp
new file mode 100644
index 0000000..7c5a302
--- /dev/null
+++ b/HDOJ/5063_autoAC.cpp
@@ -0,0 +1,70 @@
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+#include <cstdio>
+#define MOD 1000000007
+#define MAX 200007
+using namespace std;
+typedef long long LL;
+LL a[MAX];
+int p,cnt1,cnt2;
+int t,n,m;
+int bf1 ( int i )
+{
+    if ( i > (n+1)/2 )
+    {
+        int temp = i*2-n-1;
+        if ( n&1 ) return temp;
+        else return temp+1;
+    }
+    else return i*2-1;
+}
+int bf2 ( int i )
+{
+    return n+1-i;
+}
+void f3 ( )
+{
+    p++;
+}
+LL ans[107];
+char s[5];
+int q[MAX],x;
+int query ( int x , int cnt )
+{
+    for ( int i = cnt-1 ; i >= 0 ; i-- )
+        if ( q[i] == 1 ) x = bf1(x);
+        else x = bf2(x);
+    return x;
+}
+int main ( )
+{
+    scanf ( "%d" , &t );
+    while ( t-- )
+    {
+        p = cnt1 = cnt2 = 0;
+        scanf ( "%d%d" , &n , &m );
+        for ( int i = 1 ; i <= n ; i++ )
+            a[i] = i;
+        for ( int i = 1 ; i <= m ; i++ )
+        {
+            scanf ( "%s" , s );
+            scanf ( "%d" , &x );
+            if ( s[0] == 'O' )
+            {
+                if ( x == 3 ) f3( );
+                else q[cnt1++] = x;
+            }
+            else 
+            {
+                int id = query ( x , cnt1 );
+                LL tx = a[id];
+                for ( int i = 0 ; i < p ; i++ )
+                    tx *= tx , tx %= MOD;
+                ans[cnt2++] = tx;
+            }
+        }
+      for ( int i = 0 ; i < cnt2 ; i++ )
+        printf ( "%I64d\n" , ans[i] );  
+    }
+}
diff --git a/HDOJ/5064_autoAC.cpp b/HDOJ/5064_autoAC.cpp
new file mode 100644
index 0000000..93a10cd
--- /dev/null
+++ b/HDOJ/5064_autoAC.cpp
@@ -0,0 +1,52 @@
+#include<iostream>
+#include<stdio.h>
+#include<algorithm>
+#include<math.h>
+#include<string.h>
+using namespace std;
+#define N 10000000
+#define M 3000
+int a[N],dp[M][M],s[M],num[M];
+int n,m;
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        scanf("%d%d",&n,&m);
+        for(int i=0;i<n;i++)
+            scanf("%d",&a[i]);
+        sort(a,a+n);
+        int tot=0;
+        int x=1;
+        a[n]=-1;
+        for(int i=0;i<n;i++)
+        if(a[i]!=a[i+1]){
+            num[tot]=a[i];
+            s[tot++]=x;
+            x=1;
+        }
+        else x++;
+        int ans=0;
+        for(int i=0;i<tot;i++)
+        {
+            dp[i][i]=s[i];
+            int k=i;
+            int ma=0;
+            ans=max(dp[i][i],ans);
+            for(int j=i+1;j<tot;j++)
+            {
+                while((num[j]-num[i])>=(num[i]-num[k])&&k>=0)
+                {
+                    ma=max(ma,dp[k][i]);
+                    k--;
+                }
+                dp[i][j]=ma+1;
+                ans=max(ans,dp[i][j]);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5065_autoAC.cpp b/HDOJ/5065_autoAC.cpp
new file mode 100644
index 0000000..b4e47b8
--- /dev/null
+++ b/HDOJ/5065_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<iostream>
+#include<cmath>
+#include<cstdio>
+using namespace std;
+int A,B,y;
+double ans=0;
+double inline f(double x)
+{
+   return A*x*x-(B*sin(x)+y);
+}
+double inline absf(double x)
+{
+    if(f(x)<0)return -f(x);
+    return f(x);
+}
+bool findans(double l,double r)         
+{
+    if(f(l)*f(r)>0)return 0;
+    while(r-l>0.00000001)      
+    {
+        double mid1=l+(r-l)/3,mid2=r-(r-l)/3;
+        if(absf(mid1)<=absf(mid2))
+            r=mid2;
+        else
+           l=mid1;
+    }
+    ans=l;
+    return 1;
+}
+int main()
+{
+   int T;
+   scanf("%d",&T);
+   while(T--)
+   {
+      scanf("%d%d%d",&A,&B,&y);
+      bool marks=0;ans=0;
+      for(double x=0;x<50;x=x+0.3)
+      {
+          if(findans(x,x+0.3))
+          {
+              marks=1;break;
+          }
+      }
+      if(marks)
+          printf("%.5lf\n",ans);
+      else
+          printf("error\n");
+   }
+   return 0;
+}
diff --git a/HDOJ/5066_autoAC.cpp b/HDOJ/5066_autoAC.cpp
new file mode 100644
index 0000000..038c8d8
--- /dev/null
+++ b/HDOJ/5066_autoAC.cpp
@@ -0,0 +1,9 @@
+#include <cstdio>
+using namespace std;
+int main(void)
+{
+    int v,v0;
+    while(~scanf("%d %d", &v,&v0))
+        printf("%d\n",2 * v - v0);
+    return 0;
+}
diff --git a/HDOJ/5067_autoAC.cpp b/HDOJ/5067_autoAC.cpp
new file mode 100644
index 0000000..e56f1be
--- /dev/null
+++ b/HDOJ/5067_autoAC.cpp
@@ -0,0 +1,76 @@
+#include "cstdio"
+#include "iostream"
+#include "cstring"
+#include "vector"
+#include "queue"
+using namespace std;
+#define inf 0x3f3f3f3f
+int area[55][55],dp[1<<15][15],vis[55][55],dis[55][55],dir[4][2]={-1,0,1,0,0,-1,0,1},n,m,g;
+struct status
+{
+    int x,y,dep;
+    status(int x,int y,int dep):x(x),y(y),dep(dep) {}
+};
+int bfs(status s,status e)
+{
+    memset(vis,0,sizeof(vis));
+    vis[s.x][s.y]=true;
+    queue<status> Q;
+    Q.push(status(s.x,s.y,0));
+    while(!Q.empty())
+    {
+        status t=Q.front();Q.pop();
+        for(int s=0;s<4;s++)
+        {
+            int X=t.x+dir[s][0],Y=t.y+dir[s][1];
+            if(X<1||X>n||Y<1||Y>m||vis[X][Y]) continue;
+            vis[X][Y]=true;
+            if(X==e.x&&Y==e.y) return t.dep+1;
+            Q.push(status(X,Y,t.dep+1));
+        }
+    }
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        vector<status> stone;
+        stone.push_back(status(1,1,0));
+        for(int i=1;i<=n;i++)
+          for(int j=1;j<=m;j++)
+            {
+               scanf("%d",&g);
+               if(i==1&&j==1) continue;
+               if(g) stone.push_back(status(i,j,0));
+            }
+        for(int i=0;i<stone.size();i++)
+        {
+            for(int j=0;j<stone.size();j++)
+            {
+                if(i==j) dis[i][j]=0;
+                else {if(!dis[i][j]) dis[i][j]=dis[j][i]=bfs(stone[i],stone[j]);}
+            }
+        }
+        int s=stone.size();
+        int cnt=1<<s;
+        for(int i=0;i<cnt;i++)
+        {
+            for(int j=0;j<s;j++)
+            {
+                if(!i&(1<<j)) continue;
+                if(i==(1<<j)) dp[i][j]=dis[0][j];
+                else
+                {
+                    dp[i][j]=inf;
+                    for(int k=0;k<s;k++) if(i&(1<<k)&&k!=j) dp[i][j]=min(dp[i][j],dp[i^(1<<j)][k]+dis[k][j]);
+                }
+            }
+        }
+        int ans=inf;
+        for(int i=0;i<s;i++)
+            ans=min(ans,dp[cnt-1][i]+dis[i][0]);
+        printf("%d\n",ans);
+        memset(dp,0,sizeof(dp));
+        memset(dis,0,sizeof(dis));
+    }
+}
diff --git a/HDOJ/5068_autoAC.cpp b/HDOJ/5068_autoAC.cpp
new file mode 100644
index 0000000..d0743c7
--- /dev/null
+++ b/HDOJ/5068_autoAC.cpp
@@ -0,0 +1,109 @@
+#include<iostream>
+#include<sstream>
+#include<map>
+#include<cmath>
+#include<fstream>
+#include<queue>
+#include<vector>
+#include<sstream>
+#include<cstring>
+#include<cstdio>
+#include<stack>
+#include<bitset>
+#include<ctime>
+#include<string>
+#include<cctype>
+#include<iomanip>
+#include<algorithm>
+using namespace std  ;
+#define INT __int64
+#define L(x)  (x * 2)
+#define R(x)  (x * 2 + 1)
+const int INF = 0x3f3f3f3f ;
+const double esp = 0.0000000001 ;
+const double PI = acos(-1.0) ;
+const INT mod =  1000000007 ;
+const int MY = 1400 + 5 ;
+const int MX = 50000 + 5 ;
+int n ,m ;
+struct node
+{
+    int le ,rt ;
+    INT p[2][2] ;
+}T[MX*8] ;
+node operator *(const node& a ,const node& b)
+{
+    node c ;
+    memset(c.p ,0 ,sizeof(c.p)) ;
+    for(int i = 0 ;i < 2 ; ++i)
+      for(int k = 0 ;k < 2 ; ++k)
+         if(a.p[i][k])
+            for(int j = 0 ;j < 2 ; ++j)
+               c.p[i][j] = (c.p[i][j] + a.p[i][k]*b.p[k][j])%mod ;
+    return c ;
+}
+void build(int x ,int le ,int rt)
+{
+    T[x].le = le ; T[x].rt = rt ;
+    if(le == rt)
+    {
+        for(int i = 0 ;i < 2 ; ++i)
+          for(int j = 0 ;j < 2 ; ++j)
+              T[x].p[i][j] = 1 ;
+        return ;
+    }
+    int Mid = (le + rt)>>1 ;
+    build(L(x) ,le ,Mid) ;
+    build(R(x) ,Mid+1 ,rt) ;
+    T[x] = T[L(x)] * T[R(x)] ;
+    T[x].le = le ; T[x].rt = rt ;
+}
+void update(int x ,int pos ,int i ,int j)
+{
+    if(T[x].le == T[x].rt)
+    {
+        T[x].p[i][j] ^= 1 ;
+        return ;
+    }
+    int Mid = (T[x].le + T[x].rt)>>1 ;
+    if(pos <= Mid)   update(L(x) ,pos ,i ,j) ;
+    else    update(R(x) ,pos ,i ,j) ;
+    int le = T[x].le ,rt = T[x].rt ;
+    T[x] = T[L(x)] * T[R(x)] ;
+    T[x].le = le ; T[x].rt = rt ;
+}
+node section(int x ,int le ,int rt) 
+{
+    if(T[x].le == le && T[x].rt == rt)
+        return T[x] ;
+    int Mid = (T[x].le + T[x].rt)>>1 ;
+    if(rt <= Mid)      return   section(L(x) ,le ,rt) ;
+    else if(le > Mid)  return   section(R(x) ,le ,rt) ;
+    else
+          return  section(L(x) ,le ,Mid)*section(R(x) ,Mid+1 ,rt) ;
+}
+int main()
+{
+    //freopen("input.txt" ,"r" ,stdin) ;
+    int p ,u ,v ,z ;
+    while(~scanf("%d%d" ,&n ,&m))
+    {
+        build(1 ,1 ,n) ;
+        for(int i = 0 ;i < m ; ++i)
+        {
+            scanf("%d" ,&p) ;
+            if(p)
+            {
+                scanf("%d%d%d" ,&u ,&v ,&z) ;
+                update(1 ,u ,v-1 ,z-1) ;
+            }
+            else
+            {
+               scanf("%d%d" ,&u ,&v) ;
+               node ans = section(1 ,u ,v-1) ;
+               printf("%I64d\n" ,(ans.p[0][0] + ans.p[0][1] + ans.p[1][0] + ans.p[1][1])%mod) ;
+            }
+        }
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5069_autoAC.cpp b/HDOJ/5069_autoAC.cpp
new file mode 100644
index 0000000..5e5b96b
--- /dev/null
+++ b/HDOJ/5069_autoAC.cpp
@@ -0,0 +1,136 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<cmath>
+#include<queue>
+#include<vector>
+#include<set>
+#include<stack>
+#include<map>
+#include<ctime>
+#include<bitset>
+#define LL long long
+#define mod 1000000007
+#define maxn 200010
+#define INF 0x3f3f3f3f
+using namespace std;
+struct node
+{
+    int u,id;
+    bool operator<(const node&s)const
+    {
+        return u < s.u ;
+    }
+};
+struct SAM
+{
+    SAM *pre,*son[4] ;
+    int len ,vi;
+    void init()
+    {
+        pre=NULL ;
+        memset(son,NULL,sizeof(son)) ;
+        vi=0;
+    }
+}que[maxn*2],*root,*tail,*b[maxn];
+int tot,ans[maxn] ,cnt[maxn],s[maxn];
+int id(char a )
+{
+    if(a=='A') return 0 ;
+    else if(a=='C') return 1 ;
+    else if(a=='G') return 2 ;
+    return 3 ;
+}
+vector<node>qe[maxn] ;
+void add(int c ,int l)
+{
+    que[tot].init();
+    SAM *p = tail,*np=&que[tot++] ;
+    np->len=l;tail=np ;
+    while(p&&p->son[c]==NULL)p->son[c]=np,p=p->pre ;
+    if(p==NULL) np->pre = root ;
+    else
+    {
+        SAM *q = p->son[c] ;
+        if(p->len+1==q->len)np->pre = q ;
+        else
+        {
+            que[tot].init();
+            SAM *nq = &que[tot++] ;
+            *nq=*q ;
+            nq->len = p->len+1;
+            np->pre=q->pre=nq;
+            while(p&&p->son[c]==q) p->son[c]=nq,p=p->pre;
+        }
+    }
+}
+char str[maxn] ;
+int main()
+{
+    int i , j ,k ,len,n , m;
+    int u,v ;
+    node a ;
+    while(scanf("%d%d",&n,&m) != EOF)
+    {
+        for(i=1;i<=n;i++)
+          qe[i].clear();
+        len=1;
+        for( i = 1 ; i <= n ;i++)
+        {
+            scanf("%s",str+len) ;
+            k = strlen(str+len) ;
+            s[i]=len;
+            cnt[i]=k;
+            len += k+1 ;
+        }
+        for( i = 1 ; i <= m ;i++)
+        {
+            scanf("%d%d",&u,&v) ;
+            a.id = i ;
+            a.u = v ;
+            qe[u].push_back(a);
+        }
+        for( i = 1 ; i <= n ;i++)
+        {
+            if(qe[i].size()==0) continue ;
+            sort(qe[i].begin(),qe[i].end());
+            tot=0;
+            que[0].init();
+            root=tail=&que[tot++];
+            k=1;
+            for( j = s[i] ; j < s[i]+cnt[i];j++){
+                add(id(str[j]),k++);
+            }
+            SAM *p= tail;
+            while(p != NULL )
+            {
+                p->vi = true;
+                p=p->pre;
+            }
+            for( j = 0 ; j < qe[i].size();j++){
+                a=qe[i][j] ;
+                ans[a.id]=0;
+                if(j&&a.u==qe[i][j-1].u)
+                {
+                    ans[a.id]=ans[qe[i][j-1].id];
+                    continue ;
+                }
+                p = root ;
+                int tmp=0;
+                for( k = s[a.u] ; k < s[a.u]+cnt[a.u];k++)
+                {
+                    int v = id(str[k]) ;
+                    if(p->son[v]==NULL) break ;
+                    p=p->son[v] ;
+                    tmp++;
+                    if(p->vi)
+                        ans[a.id]=max(ans[a.id],tmp);
+                }
+            }
+        }
+        for( i = 1 ; i <= m ;i++)
+            printf("%d\n",ans[i]);
+    }
+    return 0 ;
+}
diff --git a/HDOJ/5071_autoAC.cpp b/HDOJ/5071_autoAC.cpp
new file mode 100644
index 0000000..f49d69a
--- /dev/null
+++ b/HDOJ/5071_autoAC.cpp
@@ -0,0 +1,148 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+int sta[5010];
+int cnt;
+int top;
+int index;
+map<int,long long>mp;
+void gao1(int u){
+    for(int i = 1;i <= cnt;i++)
+        if(sta[i] == u){
+            printf("Operation #%d: same priority.\n",index);
+            return;
+        }
+    printf("Operation #%d: success.\n",index);
+    sta[++cnt] = u;
+    mp[u] = 0;
+}
+void gao2(int u){
+    for(int i = 1;i <= cnt;i++)
+        if(sta[i] == u){
+            if(top != -1){
+                if(top == u){
+                    top = -1;
+                }
+            }
+            for(int j = i;j < cnt;j++)sta[j] = sta[j+1];
+            cnt--;
+            printf("Operation #%d: close %d with %I64d.\n",index,u,mp[u]);
+            return;
+        }
+    printf("Operation #%d: invalid priority.\n",index);
+}
+void gao3(int w){
+    if(cnt == 0){
+        printf("Operation #%d: empty.\n",index);
+        return;
+    }
+    if(top != -1)mp[top] += w;
+    else mp[sta[1]] += w;
+    printf("Operation #%d: success.\n",index);
+}
+void gao4(int x){
+    if(x < 1 || x > cnt){
+        printf("Operation #%d: out of range.\n",index);
+        return;
+    }
+    int tmp = sta[x];
+    for(int i = x;i > 1;i--)sta[i] = sta[i-1];
+    sta[1] = tmp;
+    printf("Operation #%d: success.\n",index);
+}
+void gao5(){
+    if(cnt == 0){
+        printf("Operation #%d: empty.\n",index);
+        return;
+    }
+    int id = 1;
+    for(int i = 1;i <= cnt;i++)
+        if(sta[i] > sta[id])
+            id = i;
+    gao4(id);
+}
+void gao6(int u){
+    for(int i = 1;i <= cnt;i++)
+        if(sta[i] == u){
+            gao4(i);
+            return;
+        }
+    printf("Operation #%d: invalid priority.\n",index);
+}
+void gao7(int u){
+    for(int i = 1;i <= cnt;i++)
+        if(sta[i] == u){
+            top = u;
+            printf("Operation #%d: success.\n",index);
+            return;
+        }
+    printf("Operation #%d: invalid priority.\n",index);
+}
+void gao8(){
+    if(top != -1){
+        top = -1;
+        printf("Operation #%d: success.\n",index);
+    }
+    else printf("Operation #%d: no such person.\n",index);
+}
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d",&n);
+        cnt = 0;
+        top = -1;
+        mp.clear();
+        char op[20];
+        int u;
+        for(index = 1;index <= n;index++){
+            scanf("%s",op);
+            if(strcmp(op,"Add") == 0){
+                scanf("%d",&u);
+                gao1(u);
+            }
+            else if(strcmp(op,"Close") == 0){
+                scanf("%d",&u);
+                gao2(u);
+            }
+            else if(strcmp(op,"Chat") == 0){
+                scanf("%d",&u);
+                gao3(u);
+            }
+            else if(strcmp(op,"Rotate") == 0){
+                scanf("%d",&u);
+                gao4(u);
+            }
+            else if(strcmp(op,"Prior") == 0){
+                gao5();
+            }
+            else if(strcmp(op,"Choose") == 0){
+                scanf("%d",&u);
+                gao6(u);
+            }
+            else if(strcmp(op,"Top") == 0){
+                scanf("%d",&u);
+                gao7(u);
+            }
+            else gao8();
+        }
+        if(top != -1 && mp[top])
+            printf("Bye %d: %I64d\n",top,mp[top]);
+        for(int i = 1;i <= cnt;i++)
+            if(sta[i] != top && mp[sta[i]])
+                printf("Bye %d: %I64d\n",sta[i],mp[sta[i]]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5072_autoAC.cpp b/HDOJ/5072_autoAC.cpp
new file mode 100644
index 0000000..df1e5f3
--- /dev/null
+++ b/HDOJ/5072_autoAC.cpp
@@ -0,0 +1,95 @@
+#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 = 100000;
+int prime[MAXN+1];
+void getPrime(){
+    memset(prime,0,sizeof(prime));
+    for(int i = 2;i <= MAXN;i++){
+        if(!prime[i])prime[++prime[0]] = i;
+        for(int j = 1;j <= prime[0] && prime[j] <= MAXN/i;j++){
+            prime[prime[j]*i] = 1;
+            if(i%prime[j] == 0)break;
+        }
+    }
+}
+int factor[100][2];
+int fatCnt;
+inline int getFactor(int x){
+    fatCnt = 0;
+    for(int i = 1;prime[i] <= x/prime[i];i++)
+        if(x%prime[i] == 0){
+            factor[fatCnt][0] = prime[i];
+            factor[fatCnt][1] = 0;
+            while(x%prime[i] == 0){
+                factor[fatCnt][1]++;
+                x /= prime[i];
+            }
+            fatCnt++;
+        }
+    if(x != 1){
+        factor[fatCnt][0] = x;
+        factor[fatCnt++][1] = 1;
+    }
+    return fatCnt;
+}
+int a[100010];
+int num[100010];
+int two[20];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    two[0] = 1;
+    for(int i = 1;i < 20;i++)
+        two[i] = two[i-1]<<1;
+    getPrime();
+    while(T--){
+        scanf("%d",&n);
+        memset(num,0,sizeof(num));
+        for(int i = 0;i < n;i++){
+            scanf("%d",&a[i]);
+            getFactor(a[i]);
+            for(int j = 0;j < two[fatCnt];j++){
+                int tmp = 1;
+                for(int k = 0;k < fatCnt;k++)
+                    if(j&two[k]){
+                        tmp *= factor[k][0];
+                    }
+                num[tmp]++;
+            }
+        }
+        long long ret = 0;
+        for(int i = 0;i < n;i++){
+            getFactor(a[i]);
+            int cc = 0;
+            for(int j = 0;j < two[fatCnt];j++){
+                int tmp = 1;
+                int cnt = 0;
+                for(int k = 0;k < fatCnt;k++)
+                    if(j&two[k]){
+                        cnt++;
+                        tmp *= factor[k][0];
+                    }
+                if(cnt&1)cc -= num[tmp];
+                else cc += num[tmp];
+            }
+            if(a[i] == 1)cc--;
+            ret += (long long)cc*(n-1-cc);
+        }
+        long long tot = (long long)n*(n-1)*(n-2)/6;
+        printf("%I64d\n",tot-ret/2);
+    }
+    return 0;
+}
diff --git a/HDOJ/5073_autoAC.cpp b/HDOJ/5073_autoAC.cpp
new file mode 100644
index 0000000..8ebe6cd
--- /dev/null
+++ b/HDOJ/5073_autoAC.cpp
@@ -0,0 +1,47 @@
+#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;
+double x[50010];
+int main()
+{
+    int T;
+    int n,k;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d%d",&n,&k);
+        for(int i = 0;i < n;i++)
+            scanf("%lf",&x[i]);
+        sort(x,x+n);
+        if(n == k){
+            printf("0\n");
+            continue;
+        }
+        int cnt = n-k;
+        double sum = 0;
+        double sum2 = 0;
+        for(int i = 0;i < cnt;i++){
+            sum += x[i];
+            sum2 += x[i]*x[i];
+        }
+        double ans = sum2 - 2*sum*(sum/cnt) + cnt*(sum/cnt)*(sum/cnt);
+        for(int i = cnt;i < n;i++){
+            sum += x[i];
+            sum2 += x[i]*x[i];
+            sum -= x[i-cnt];
+            sum2 -= x[i-cnt]*x[i-cnt];
+            ans = min(ans,sum2-2*sum*(sum/cnt)+cnt*(sum/cnt)*(sum/cnt));
+        }
+        printf("%.10lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5074_autoAC.cpp b/HDOJ/5074_autoAC.cpp
new file mode 100644
index 0000000..d1d21b4
--- /dev/null
+++ b/HDOJ/5074_autoAC.cpp
@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+int a[100][100];
+int dp[110][55];
+int b[110];
+int main()
+{
+    int T;
+    int n,m;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d%d",&n,&m);
+        for(int i = 1;i <= m;i++)
+            for(int j = 1;j <= m;j++)
+                scanf("%d",&a[i][j]);
+        memset(dp,-1,sizeof(dp));
+        for(int i = 1;i <= n;i++)scanf("%d",&b[i]);
+        for(int i = 1;i <= m;i++)
+            dp[1][i] = 0;
+        int ans = -1;
+        for(int i = 1;i <= n;i++){
+            for(int j = 1;j <= m;j++){
+                if(b[i] > 0 && j != b[i])
+                    dp[i][j] = -1;
+                if(dp[i][j] == -1)continue;
+                if(i == n){
+                    ans = max(ans,dp[i][j]);
+                    continue;
+                }
+                for(int k = 1;k <= m;k++)
+                    dp[i+1][k] = max(dp[i+1][k],dp[i][j]+a[j][k]);
+            }
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5076_autoAC.cpp b/HDOJ/5076_autoAC.cpp
new file mode 100644
index 0000000..5003e1a
--- /dev/null
+++ b/HDOJ/5076_autoAC.cpp
@@ -0,0 +1,155 @@
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<set>
+#include<vector>
+#include<queue>
+#include<cstdlib>
+#include<ctime>
+#include<cmath>
+#include<bitset>
+using namespace std;
+#define N 300
+#define inf 50000000
+int T, S, n, m, tot, cas, ans;
+int head[N * 2], f[N], g[N], Less[N], Lid[N], More[N], Mid[N], dis[N * 2], qu[N
+        * 2];
+struct edge {
+    int v, w, next;
+} ed[N * N * 100];
+int cut(int x) {
+    int i;
+    for (i = 0; x; x -= (x & (-x)), i++)
+        ;
+    return i;
+}
+void add(int u, int v, int w) {
+    ed[tot].v = v;
+    ed[tot].w = w;
+    ed[tot].next = head[u];
+    head[u] = tot++;
+    ed[tot].v = u;
+    ed[tot].w = 0;
+    ed[tot].next = head[v];
+    head[v] = tot++;
+}
+bool bfs() {
+    int l, r, u, v, i;
+    memset(dis, -1, sizeof(dis));
+    dis[S] = 0;
+    qu[0] = S;
+    l = 0;
+    r = 1;
+    while (l < r) {
+        u = qu[l++];
+        for (i = head[u]; ~i; i = ed[i].next) {
+            v = ed[i].v;
+            if (dis[v] < 0 && ed[i].w > 0) {
+                dis[v] = dis[u] + 1;
+                if (v == T)
+                    return true;
+                qu[r++] = v;
+            }
+        }
+    }
+    return false;
+}
+int dfs(int u, int nowflow) {
+    if (u == T)
+        return nowflow;
+    int i, v, tmp, res = 0;
+    for (i = head[u]; ~i; i = ed[i].next) {
+        v = ed[i].v;
+        if (dis[v] == dis[u] + 1 && ed[i].w > 0) {
+            tmp = dfs(v, min(nowflow, ed[i].w));
+            nowflow -= tmp;
+            ed[i].w -= tmp;
+            ed[i ^ 1].w += tmp;
+            res += tmp;
+            if (!nowflow)
+                break;
+        }
+    }
+    if (!nowflow)
+        dis[u] = -1;
+    return res;
+}
+int main() {
+    scanf("%d", &cas);
+    while (cas--) {
+        scanf("%d%d", &n, &m);
+        n = 1 << n;
+        m = 1 << m;
+        tot = 0;
+        memset(head, -1, sizeof(head));
+        ans = 0;
+        memset(Less, -1, sizeof(Less));
+        memset(More, -1, sizeof(More));
+        S = 0;
+        T = n * 2 + 1;
+        for (int i = 0; i < n; i++)
+            scanf("%d", &f[i]);
+        for (int i = 0; i < n; i++)
+            scanf("%d", &g[i]);
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                int k;
+                scanf("%d", &k);
+                k += 1024;
+                if (j < f[i]) {
+                    if (Less[i] < k) {
+                        Less[i] = k;
+                        Lid[i] = j;
+                    }
+                } else {
+                    if (More[i] < k) {
+                        More[i] = k;
+                        Mid[i] = j;
+                    }
+                }
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            int aa = cut(i);
+            if (aa & 1) {
+                add(S, i + 1, Less[i]);
+                add(i + 1 + n, T, More[i]);
+            } else {
+                add(S, i + 1, More[i]);
+                add(i + 1 + n, T, Less[i]);
+            }
+            add(i + 1, i + 1 + n, inf);
+            for (int j = i + 1; j < n; j++) {
+                if (cut(i ^ j) == 1) {
+                    if (aa & 1)
+                        add(i + 1, j + 1 + n, g[i] ^ g[j]);
+                    else
+                        add(j + 1, i + 1 + n, g[i] ^ g[j]);
+                }
+            }
+        }
+        while (bfs())
+            ans += dfs(S, inf);
+        for (int i = 0; i < n; i++) {
+            if (i)
+                printf(" ");
+            int aa = cut(i);
+            if (aa & 1) {
+                if (dis[i + 1] != -1)
+                    printf("%d", Lid[i]);
+                else
+                    printf("%d", Mid[i]);
+            } else {
+                if (dis[i + 1] != -1)
+                    printf("%d", Mid[i]);
+                else
+                    printf("%d", Lid[i]);
+            }
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5077_autoAC.cpp b/HDOJ/5077_autoAC.cpp
new file mode 100644
index 0000000..e15f998
--- /dev/null
+++ b/HDOJ/5077_autoAC.cpp
@@ -0,0 +1,18 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int ans[300] = {1, 5, 6, 3, 6, 3, 7, 4, 7, 8, 4, 5, 4, 5, 4, 1, 6, 3, 7, 4, 7, 4, 9, 7, 8, 8, 7, 5, 7, 5, 7, 4, 7, 8, 4, 5, 8, 8, 7, 5, 8, 9, 5, 6, 8, 8, 5, 5, 4, 5, 4, 1, 7, 5, 7, 4, 8, 8, 5, 5, 5, 7, 6, 4, 7, 8, 8, 8, 4, 5, 7, 5, 8, 9, 8, 8, 5, 6, 5, 5, 4, 5, 7, 5, 4, 1, 7, 4, 8, 8, 5, 7, 5, 5, 6, 4, 8, 9, 8, 8, 8, 8, 5, 7, 11, 9, 8, 9, 8, 9, 8, 8, 5, 6, 5, 5, 5, 5, 6, 4, 8, 9, 8, 8, 8, 8, 8, 7, 8, 9, 9, 9, 9, 9, 10, 9, 5, 7, 6, 6, 6, 6, 7, 6, 9, 9, 10, 9, 10, 9, 10, 10, 7, 6, 7, 7, 7, 7, 9, 7, 5, 7, 6, 6, 7, 6, 7, 7, 5, 6, 2, 3, 6, 6, 4, 3, 6, 6, 7, 6, 7, 7, 9, 7, 6, 6, 4, 3, 7, 7, 7, 6, 5, 7, 7, 6, 6, 6, 7, 7, 5, 6, 6, 6, 2, 3, 4, 3, 6, 6, 7, 7, 7, 6, 9, 7, 6, 6, 7, 7, 4, 3, 7, 6, 5, 6, 6, 6, 6, 6, 7, 7, 8, 9, 5, 6, 5, 6, 2, 5, 2, 3, 4, 3, 4, 3, 7, 6, 5, 6, 2, 5, 2, 5, 4, 1};
+int main () {
+    int cas;
+    char p[10];
+    scanf("%d", &cas);
+    while (cas--) {
+        scanf("%s", p);
+        int ret = 0;
+        for (int i = 0; i < 8; i++)
+            ret = ret * 2 + p[i] - '0';
+        printf("%d\n", ans[ret]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5078_autoAC.cpp b/HDOJ/5078_autoAC.cpp
new file mode 100644
index 0000000..55b78ce
--- /dev/null
+++ b/HDOJ/5078_autoAC.cpp
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <queue>
+#include <set>
+#include <map>
+#include <string>
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+using namespace std;
+struct Node{
+    double t,x,y;
+    void input(){
+        scanf("%lf%lf%lf",&t,&x,&y);
+    }
+    double calc(Node b){
+        return hypot(x-b.x,y-b.y)/(b.t-t);
+    }
+}node[1010];
+int main()
+{
+    int T;
+    int n;
+    scanf("%d",&T);
+    while(T--){
+        scanf("%d",&n);
+        for(int i = 0;i < n;i++)node[i].input();
+        double ans = -1.0;
+        for(int i = 0;i < n-1;i++)
+            ans = max(ans,node[i].calc(node[i+1]));
+        printf("%.10lf\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5079_autoAC.cpp b/HDOJ/5079_autoAC.cpp
new file mode 100644
index 0000000..d18f841
--- /dev/null
+++ b/HDOJ/5079_autoAC.cpp
@@ -0,0 +1,164 @@
+#pragma comment(linker,"/STACK:102400000,102400000")
+#include <cctype>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+#include <string>
+#include <algorithm>
+#include <bitset>
+#include <functional>
+#include <numeric>
+#include <deque>
+#include <list>
+#include <map>
+#include <queue>
+#include <vector>
+#include <set>
+#include <stack>
+#include <iterator>
+#include <memory>
+#include <utility>
+#include <string>
+#include <sstream>
+using namespace std;
+#define X first
+#define Y second
+#define mp make_pair
+#define pb push_back
+#define mset(a) memset(a,0,sizeof(a))
+#define mmset(a) memset(a,-1,sizeof(a))
+#define mcpy(a,b) memcpy(a,b,sizeof(a))
+typedef double lf;
+typedef long long ll;
+typedef unsigned int uint;
+typedef unsigned long long ull;
+typedef pair<int,int> pii;
+typedef pair<ll,ll> pll;
+typedef pair<ll,int> pli;
+typedef pair<lf,lf> pdd;
+typedef pair<int,pii> pip;
+typedef pair<pii,int> ppi;
+typedef pair<pii,pii> ppp;
+typedef vector<int> vi;
+typedef vector<pii> vpii;
+const int inf=1000000007;
+const ll linf=1000000000000000000LL;
+const ull ulinf=(1ULL<<63)-10ULL;
+const lf eps=0.000000001;
+const lf pi=3.14159265358979323846;
+template <class T> T abs(T a){return a>=0?a:-a;}
+template <class T> int sign(T a){return a>eps?1:a<-eps?-1:0;}
+template <class T> T sqr(T a){return a*a;}
+template <class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
+template <class T> T mod(T a,T b){T ret=a%b;if(ret<0)ret+=b;return ret;}
+template <class T> T lowbit(T x){return x&-x;}
+ll addmod(ll a,ll b,ll c){return ((a+b)%c+c)%c;}
+ll mulmod(ll a,ll b,ll c){if(b==0LL)return 0LL;ll ret=mulmod(a,b>>1,c);ret=(ret+ret)%c;if(b&1LL)ret=(ret+a)%c;return ret;}
+ll powmod(ll a,ll b,ll c){if(b==0LL)return 1LL;ll ret=powmod(a,b>>1,c);ret=ret*ret%c;if(b&1LL)ret=ret*a%c;return ret;}
+ll modinv(ll a,ll b){return powmod(a,b-2LL,b);}
+template <class T> void maxe(T &a,T b){if(a<b)a=b;}
+template <class T> void mine(T &a,T b){if(a>b)a=b;}
+int iszero(lf a){return a<=eps&&a>=-eps;}
+template <class T> void geti(T &a){a=0;T b=1;char c=getchar();if(c=='-')b=-1;else a=c-48;while((c=getchar())!=' '&&c!='\n')a=a*10+c-48;a*=b;}
+#define DEBUG(X) 
+const int N=11;
+const int M=111111;
+const int K=33;
+const ll md=inf;
+int test;
+int n,m,k,ans;
+int cnt;
+char s[N];
+int a[N];
+int flag[N];
+int dp[N][M];
+int powsz[N];
+int aa[N];
+int main()
+{ 
+    scanf("%d",&test);
+    for(int tc=1;tc<=test;tc++)
+    {
+        scanf("%d",&n);
+        m=1;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%s",s);
+            a[i]=0;
+            for(int j=0;j<n;j++)
+                if(s[j]=='o')
+                    m=m*2%md;
+                else
+                    a[i]|=1<<j;
+        }
+        aa[0]=1;
+        aa[1]=(m-1+md)%md;
+        for(int sz=2;sz<=n;sz++)
+        {
+            int cntst=1;
+            powsz[0]=1;
+            k=n+1-sz;
+            for(int i=1;i<=k;i++)
+                powsz[i]=cntst*=sz;
+            dp[0][0]=1;
+            for(int st=1;st<cntst;st++)
+                dp[0][st]=0;
+            for(int i=1;i<=n;i++)
+            {
+                for(int st=0;st<cntst;st++)
+                    dp[i][st]=0;
+                for(int cur=0;cur<(1<<n);cur++)
+                {
+                    if(cur&a[i])
+                        continue;
+                    for(int j=0;j<k;j++)
+                        flag[j]=0;
+                    for(int bit=0;bit<n;bit++)
+                    {
+                        if(cur&(1<<bit))
+                            continue;
+                        for(int j=0;j<k;j++)
+                            if(bit>=j&&bit<j+sz)
+                                flag[j]=1;
+                    }
+                    for(int st=0;st<cntst;st++)
+                    {
+                        if(!dp[i-1][st])
+                            continue;
+                        int newst=0;
+                        for(int j=0;j<k;j++)
+                        {
+                            int t=st/powsz[j]%sz;
+                            if(flag[j])
+                                t=0;
+                            else if(t!=sz-1)
+                                t++;
+                            else
+                            {
+                                newst=-1;
+                                break;
+                            }
+                            newst+=t*powsz[j];
+                        }
+                        if(newst==-1)
+                            continue;
+                        dp[i][newst]=(dp[i][newst]+dp[i-1][st])%md;
+                    }
+                }
+            }
+            aa[sz]=0;
+            for(int st=0;st<cntst;st++)
+                aa[sz]=(aa[sz]+dp[n][st])%md;
+            aa[sz]=(m-aa[sz]+md)%md;
+            aa[sz-1]=(aa[sz-1]-aa[sz]+md)%md;
+        }
+        for(int sz=0;sz<=n;sz++)
+            printf("%d\n",aa[sz]);
+    }
+    return 0;
+}
diff --git a/HDOJ/5080_autoAC.cpp b/HDOJ/5080_autoAC.cpp
new file mode 100644
index 0000000..6d4efc6
--- /dev/null
+++ b/HDOJ/5080_autoAC.cpp
@@ -0,0 +1,165 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<math.h>
+#include<algorithm>
+#include<vector>
+#include<map>
+#include<set>
+#include<queue>
+#include<string>
+#define ll long long
+#define db double
+#define PB push_back
+#define lson k<<1
+#define rson k<<1|1
+using namespace std;
+const int N = 55;
+const db eps = 1e-8;
+const db PI = acos(-1.0);
+const ll MOD = 1000000007;
+int n,m,mp[N][N];
+bool mk[N];
+ll c;
+int sgn(db t)
+{
+    return t<-eps?-1:t>eps;
+}
+ll inv(ll t)
+{
+    ll res=1,k=MOD-2;
+    while(k)
+    {
+        if(k&1) res=(res*t)%MOD;
+        t=(t*t)%MOD;
+        k>>=1;
+    }
+    return res;
+}
+struct E
+{
+    int a,b;
+    void input()
+    {
+        scanf("%d%d",&a,&b);
+    }
+} ed[N*N];
+struct P
+{
+    db x,y;
+    int id;
+    void input()
+    {
+        int _x,_y;
+        scanf("%d%d",&_x,&_y);
+        x=_x,y=_y;
+    }
+    P(db _x=0,db _y=0):x(_x),y(_y){}
+    P rot(db thta)
+    {
+        return P(x*cos(thta)-y*sin(thta),
+                 x*sin(thta)+y*cos(thta));
+    }
+    P rotByP(P center,db thta)
+    {
+        P tmp(x-center.x,y-center.y);
+        P ans=tmp.rot(thta);
+        ans=ans+center;
+        return ans;
+    }
+    P operator + (const P &t) const
+    {
+        return P(x+t.x,y+t.y);
+    }
+    bool operator == (const P &t) const
+    {
+        return sgn(x-t.x)==0&&sgn(y-t.y)==0;
+    }
+}p[N],pb,np[N];
+int pt[N];
+ll g,ans;
+bool check()
+{
+    for(int i=0;i<m;i++)
+    {
+        int a=ed[i].a,b=ed[i].b;
+        a=pt[a],b=pt[b];
+        if(mp[a][b]&&mp[b][a]){}
+        else return false;
+    }
+    return true;
+}
+bool fl[N];
+int find_t()
+{
+    memset(fl,false,sizeof(fl));
+    int res=0;
+    for(int i=0;i<n;i++)
+    {
+        if(!fl[i])
+        {
+            res++;
+        }
+        int t=i;
+        while(!fl[t]) fl[t]=true,t=pt[t];
+    }
+    return res;
+}
+void dfs(int k)
+{
+    if(k==n)
+    {
+        if(check())
+        {
+            int t=find_t();
+            g++;
+            ll res=1;
+            for(int i=0;i<t;i++) res=res*c%MOD;
+            ans=(ans+res)%MOD;
+        }
+    }else
+    {
+        for(int i=0;i<n;i++)
+            if(!mk[i]&&np[k]==p[i])
+        {
+            mk[i]=true;
+            pt[k]=i;
+            dfs(k+1);
+            mk[i]=false;
+        }
+    }
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d%I64d",&n,&m,&c);
+        pb.x=pb.y=0.0;
+        for(int i=0;i<n;i++)
+        {
+            p[i].input();
+            p[i].id=i;
+            pb.x+=p[i].x,pb.y+=p[i].y;
+        }
+        pb.x/=(db)n,pb.y/=(db)n;
+        memset(mp,0,sizeof(mp));
+        for(int i=0;i<m;i++)
+        {
+            ed[i].input();
+            ed[i].a--,ed[i].b--;
+            mp[ed[i].a][ed[i].b]=mp[ed[i].b][ed[i].a]=1;
+        }
+        ans=0,g=0;
+        memset(mk,false,sizeof(mk));
+        for(int i=0;i<4;i++)
+        {
+            for(int j=0;j<n;j++)
+                np[j]=p[j].rotByP(pb,i*PI/2.0);
+            dfs(0);
+        }
+        printf("%I64d\n",ans*inv(g)%MOD);
+    }
+    return 0;
+}
diff --git a/HDOJ/5082_autoAC.cpp b/HDOJ/5082_autoAC.cpp
new file mode 100644
index 0000000..1c3634c
--- /dev/null
+++ b/HDOJ/5082_autoAC.cpp
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <algorithm>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+char ans[500], s[500];
+char pattern[] = "_small_";
+int main ( )
+{
+    while ( ~scanf ( "%s" ,  s ) ) 
+    {
+        int i = 0;
+        while ( s[i] )
+            if ( s[i++] == '_' ) break;
+        int j = 0;
+        while ( s[i] )
+            ans[j++] = s[i++];
+        i = 0;
+        while ( pattern[i] )
+            ans[j++] = pattern[i++];
+        i = 0;
+        scanf ( "%s" , s);
+        while ( s[i] )
+            if ( s[i++] == '_' ) break;
+        while ( s[i] )
+            ans[j++] = s[i++];
+        ans[j] = 0;
+        printf ( "%s\n" , ans );
+    }
+}
diff --git a/HDOJ/5083_autoAC.cpp b/HDOJ/5083_autoAC.cpp
new file mode 100644
index 0000000..6ddf036
--- /dev/null
+++ b/HDOJ/5083_autoAC.cpp
@@ -0,0 +1,159 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <map>
+#include <stack>
+#include <vector>
+#include <set>
+#include <queue>
+#pragma comment (linker,"/STACK:102400000,102400000")
+#define maxn 1005
+#define MAXN 2005
+#define mod 1000000009
+#define INF 0x3f3f3f3f
+#define pi acos(-1.0)
+#define eps 1e-6
+typedef long long ll;
+using namespace std;
+char ope[6][5]={{"ADD"},{"SUB"},{"DIV"},{"MUL"},{"MOVE"},{"SET"}};
+char code[6][7]={{"000001"},{"000010"},{"000011"},{"000100"},{"000101"},{"000110"}};
+char co[31][6]={ {"00001"} , {"00010"} , {"00011"} , {"00100"} , {"00101"} , {"00110"} , {"00111"} , {"01000"} , {"01001"} , {"01010"}
+               , {"01011"} , {"01100"} , {"01101"} , {"01110"} , {"01111"} , {"10000"} , {"10001"} , {"10010"} , {"10011"} , {"10100"}
+               , {"10101"} , {"10110"} , {"10111"} , {"11000"} , {"11001"} , {"11010"} , {"11011"} , {"11100"} , {"11101"} , {"11110"}
+               , {"11111"}};
+char s1[5],s2[10];
+int OP(char str[])
+{
+    for (int i=0;i<6;i++)
+    {
+        if (strcmp(str,ope[i])==0)
+            return i;
+    }
+}
+int main()
+{
+    int n;
+    while (~scanf("%d",&n))
+    {
+        if (n==1)
+        {
+            scanf("%s%s",s1,s2);
+            int x=OP(s1);
+            int dd=x;
+            printf("%s",code[x]);
+            x=s2[1]-'0';
+            int ok=0;
+            if (isdigit(s2[2]))
+            {
+                ok=1;
+                x=x*10;
+                x=x+s2[2]-'0';
+            }
+            x--;
+            printf("%s",co[x]);
+            if (dd==5)
+            {
+                printf("00000\n");
+                continue;
+            }
+            if (ok)
+            {
+                x=s2[5]-'0';
+                if (isdigit(s2[6]))
+                {
+                    x=x*10;
+                    x=x+s2[6]-'0';
+                }
+            }
+            else
+            {
+                x=s2[4]-'0';
+                if (isdigit(s2[5]))
+                {
+                    x=x*10;
+                    x=x+s2[5]-'0';
+                }
+            }
+            x--;
+            printf("%s\n",co[x]);
+        }
+        else if (n==0)
+        {
+            scanf("%s",s1);
+            int len=strlen(s1);
+            int t=1;
+            int sum=0;
+            for (int i=5;i>=0;i--)
+            {
+                int x=s1[i]-'0';
+                sum+=t*x;
+                t=t*2;
+            }
+            if (sum>6||sum==0)
+            {
+                printf("Error!\n");
+                continue;
+            }
+            sum--;
+            int o=sum;
+            int flag=sum;
+            t=1;
+            sum=0;
+            for (int i=10;i>=6;i--)
+            {
+                int x=s1[i]-'0';
+                sum+=t*x;
+                t=t*2;
+            }
+            if (sum>31||sum==0)
+            {
+                printf("Error!\n");
+                continue;
+            }
+            int aa=sum;
+            if (flag==5)
+            {
+                t=1;
+                sum=0;
+                for (int i=15;i>=11;i--)
+                {
+                    int x=s1[i]-'0';
+                    sum+=t*x;
+                    t=t*2;
+                }
+                if (sum==0)
+                {
+                    printf("%s",ope[o]);
+                    printf(" R%d",aa);
+                    printf("\n");
+                    continue;
+                }
+                else
+                {
+                    printf("Error!\n");
+                    continue;
+                }
+            }
+            t=1;
+            sum=0;
+            for (int i=15;i>=11;i--)
+            {
+                int x=s1[i]-'0';
+                sum+=t*x;
+                t=t*2;
+            }
+            if (sum>31||sum==0)
+            {
+                printf("Error!\n");
+                continue;
+            }
+            printf("%s",ope[o]);
+            printf(" R%d",aa);
+            printf(",R%d\n",sum);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/5084_autoAC.cpp b/HDOJ/5084_autoAC.cpp
new file mode 100644
index 0000000..a6c22a1
--- /dev/null
+++ b/HDOJ/5084_autoAC.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+__int64 dp[2200][2200];
+__int64 num[2200];
+bool mark[2200][2200];
+int N, Q;
+int main(){
+    while( scanf( "%d", &N ) != EOF ){
+        for( int i = 0; i <= 2 * N - 2; i++ ){
+            scanf( "%I64d", &num[i] );
+        }
+        memset( mark, false, sizeof( mark ) );
+        for( int i = 0; i <= N - 1; i++ ){
+            for( int j = 2 * N - 2; j >= N - 1; j-- ){
+                if( mark[i][j] )    continue;
+                __int64 sum = 0;
+                int t1 = i, t2 = j, t3 = N;
+                while( t3-- ){
+                    sum += num[t1++] * num[t2--];
+                }
+                dp[i][j] = sum;
+                mark[i][j] = true;
+                t1 = i + 1, t2 = j - 1;
+                while( t1 <= N - 1 && t2 >= N - 1 ){
+                    sum = sum - num[t1-1] * num[t2+1] + num[t1+N-1] * num[t2-N+1];
+                    dp[t1][t2] = sum;
+                    mark[t1][t2] = true;
+                    t1++, t2--;
+                }
+            }
+        }
+        scanf( "%d", &Q );
+        __int64 ans = 0, ans1 = 0;
+        int r, c;
+        while( Q-- ){
+            scanf( "%d%d", &r, &c );
+            ans1 = dp[N-1-(r+ans1)%N][N-1+(c+ans1)%N];
+            ans += ans1;
+        }
+        printf( "%I64d\n", ans );
+    }
+    return 0;
+}
diff --git a/HDOJ/5086_autoAC.cpp b/HDOJ/5086_autoAC.cpp
new file mode 100644
index 0000000..9bb4414
--- /dev/null
+++ b/HDOJ/5086_autoAC.cpp
@@ -0,0 +1,35 @@
+#include<iostream>
+#include<cstdio>
+#include<string.h>
+#define MAX  10000007
+#define LL __int64
+using namespace std;
+int n;
+LL a[MAX];
+int main()
+{
+    LL t,m,i,j,sum,xx=1000000007;
+    scanf("%I64d",&t);
+    while(t--)
+    {
+        scanf("%I64d",&n);
+        for(j=1; j<=n; j++)
+        {
+            scanf("%I64d",&a[j]);
+        }
+        a[0] = 0;
+        for(j=1;j<=n;j++)
+        {
+            a[j] = a[j]*j+a[j-1];
+            a[j] = a[j]%xx;
+        }
+        sum = 0;
+        for(j=1;j<=n;j++)
+        {
+            sum = sum+a[j];
+            sum = sum%xx;
+        }
+        printf("%I64d\n",sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/5087_autoAC.cpp b/HDOJ/5087_autoAC.cpp
new file mode 100644
index 0000000..9613d01
--- /dev/null
+++ b/HDOJ/5087_autoAC.cpp
@@ -0,0 +1,35 @@
+#include <cstdio>  
+#include <algorithm>  
+using namespace std;  
+const int N = 1005;  
+int n, a[N];  
+int d[N], c[N], cas, ans;  
+int main()  
+{  
+    scanf("%d", &cas);  
+    while (cas--)  
+    {  
+        scanf("%d", &n);  
+        int sum = ans = 0;  
+        for (int i = 1; i <= n; ++i)  
+        {  
+            scanf("%d", &a[i]);  
+            d[i] = 1, c[i] = 1;  
+            for (int j = 1; j < i; ++j)  
+            {  
+                if (a[j] >= a[i]) continue;  
+                if (d[j] + 1 > d[i])  
+                {  
+                    d[i] = d[j] + 1;  
+                    c[i] = c[j];  
+                }  
+                else if (d[j] + 1 == d[i])    c[i] = 2;  
+            }  
+            if(d[i] > ans) ans = d[i];  
+        }  
+        for (int i = 1; i <= n; ++i)  
+            if (d[i] == ans)  sum += c[i];  
+        printf("%d\n", sum > 1 ? ans : ans - 1);  
+    }  
+    return 0;  
+}
diff --git a/HDOJ/5088_autoAC.cpp b/HDOJ/5088_autoAC.cpp
new file mode 100644
index 0000000..ed91d86
--- /dev/null
+++ b/HDOJ/5088_autoAC.cpp
@@ -0,0 +1,64 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<string>
+#include<algorithm>
+#include<map>
+#include<queue>
+#include<stack>
+#include<set>
+#include<cmath>
+#include<vector>
+#include<bitset>
+#define inf 0x3f3f3f3f
+#define Inf 0x3FFFFFFFFFFFFFFFLL
+#define eps 1e-6
+#define pi acos(-1.0)
+using namespace std;
+typedef long long ll;
+const int maxn = 1000 + 10;
+ll a[maxn];
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int n;
+        scanf("%d",&n);
+        for(int i = 0;i < n;++i)
+            scanf("%I64d",&a[i]);
+        if(n > 40)
+        {
+            puts("Yes");
+            continue;
+        }
+        int x = 0;
+        for(ll i = 0;i < 40;++i)
+        {
+            int p = -1;
+            for(ll j = x;j < n;++j)
+            {
+                if((a[j]>>i) & 1)
+                {
+                    p = j;
+                    break;
+                }
+            }
+            if(p == -1) continue;
+            swap(a[x],a[p]);
+            for(int j = x + 1;j < n;++j)
+                if((a[j]>>i) & 1)
+                    a[j] ^= a[x];
+            x++;
+        }
+        int cnt = 0;
+        for(int i = 0;i < n;++i)
+            if(a[i]) cnt++;
+        if(cnt < n)
+            puts("Yes");
+        else
+            puts("No");
+    }
+    return 0;
+}
diff --git a/HDOJ/5089_autoAC.cpp b/HDOJ/5089_autoAC.cpp
new file mode 100644
index 0000000..a2e2065
--- /dev/null
+++ b/HDOJ/5089_autoAC.cpp
@@ -0,0 +1,78 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <cstring>
+#include <string>
+#include <queue>
+#include <map>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define RD(x) scanf("%d",&x)
+#define RD2(x,y) scanf("%d%d",&x,&y)
+#define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
+#define clr0(x) memset(x,0,sizeof(x))
+#define clr1(x) memset(x,-1,sizeof(x))
+#define eps 1e-9
+const double pi = acos(-1.0);
+typedef long long LL;
+typedef unsigned long long ULL;
+const int modo = 1e9 + 7;
+const int INF = 0x3f3f3f3f;
+const int inf = 0x3fffffff;
+const LL _inf = 1e18;
+const int maxn = 55,maxm = 1<<12;
+int n,k;
+bool vis[maxn];
+double p[maxn];
+int pos[maxn],s[maxn];
+int main()
+{
+    int _,_g;RD(_);
+    while(_--){
+        RD2(n,k);
+        clr0(vis);
+        for(int i = 0;i < n;++i){
+            RD(s[i]);
+            p[i] = ((double)s[i])/100.0;
+        }
+        double mx = 0;
+        for(int g = 0;g <= k;++g){//╁g涓k - g涓
+            double _p,res = 0;
+            int cnt = 0;
+            for(int i = 0;i < g;++i)
+                pos[cnt++] = i;
+            for(int i = 1;i <= k - g;++i)
+                pos[cnt++] = n - i;
+            for(int i = 0;i < cnt;++i){
+                _p = 1;
+                for(int j = 0;j < cnt;++j){
+                    if(j != i)
+                        _p *= p[pos[j]];
+                    else
+                        _p *= (1 - p[pos[j]]);
+                }
+                res += _p;
+            }
+            if(mx - res < eps){
+                mx = res;
+                _g = g;
+            }
+        }
+        for(int i = 0;i < _g;++i)
+            vis[i] = 1;
+        for(int i = n - (k - _g);i < n;++i){
+            for(int j = i;j >= 0;--j){
+                if(vis[j] || s[j] > s[i])
+                    break;
+                _g = j;
+            }
+            vis[_g] = 1;
+        }
+        _g = 1;
+        for(int i = 0;i < n;++i)
+            if(vis[i])
+                printf("%d%c",i+1," \n"[_g == k]),_g++;
+    }
+    return 0;
+}
diff --git a/HDOJ/5090_autoAC.cpp b/HDOJ/5090_autoAC.cpp
new file mode 100644
index 0000000..d3201b0
--- /dev/null
+++ b/HDOJ/5090_autoAC.cpp
@@ -0,0 +1,64 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+const int maxn = 110 ;
+bool con[maxn][maxn],vis[maxn];
+int match[maxn],n,k,x;
+void initial()
+{
+    memset(con,0,sizeof(con));
+    memset(match,-1,sizeof(match));
+}
+void input()
+{
+    scanf("%d %d",&n,&k);
+    for(int i=1;i<=n;i++)
+    {
+         scanf("%d",&x);
+         while(x<=n)
+         {
+              con[x][i]=1;
+              x+=k;
+         }
+    }
+}
+bool dfs(int x)
+{
+    for(int i=1;i<=n;i++)
+    {
+        if(!vis[i] && con[x][i])
+        {
+            vis[i]=1;
+            if(match[i]==-1 || dfs(match[i]))
+            {
+                 match[i]=x;
+                 return true;
+            }
+        }
+    }
+    return false;
+}
+void solve()
+{
+    int cnt=0;
+    for(int i=1;i<=n;i++)
+    {
+         memset(vis,0,sizeof(vis));
+         if(dfs(i))  cnt++;
+    }
+    if(cnt==n)   printf("Jerry\n");
+    else   printf("Tom\n");
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        initial();
+        input();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/5091_autoAC.cpp b/HDOJ/5091_autoAC.cpp
new file mode 100644
index 0000000..e6a4502
--- /dev/null
+++ b/HDOJ/5091_autoAC.cpp
@@ -0,0 +1,96 @@
+#include<iostream>
+#include<algorithm>
+#include<cstring>
+#include<string>
+#include<stdio.h>
+#include<math.h>
+#define N 20000
+#define inf 0x7ffffff
+#define eps 1e-9
+#define pi acos(-1.0)
+using namespace std;
+struct node
+{
+    int x,y,flag;
+}s[2*N+5];
+bool cmp(node a,node b)
+{
+    if(a.x != b.x)  return a.x < b.x;
+    return  a.flag > b.flag;
+}
+struct tree
+{
+    int l,r,flag,maxx;
+}tree[4*2*N];
+void build(int o,int l,int r)
+{
+    tree[o].l = l;
+    tree[o].r = r;
+    tree[o].maxx = tree[o].flag = 0;
+    if(l == r)  return ;
+    int m = (l+r)/2;
+    build(2*o,l,m);
+    build(2*o+1,m+1,r);
+}
+void pushup(int o)
+{
+    tree[o].maxx = max(tree[2*o].maxx, tree[2*o+1].maxx );
+}
+void pushdown(int o)
+{
+    if(tree[o].flag != 0)
+    {
+        tree[2*o].flag += tree[o].flag;
+        tree[2*o+1].flag += tree[o].flag;
+        tree[2*o].maxx += tree[o].flag;
+        tree[2*o+1].maxx += tree[o].flag;
+        tree[o].flag = 0;
+    }
+}
+void update(int o,int x,int y,int v)
+{
+    if(x <= tree[o].l && tree[o].r <= y)
+    {
+        tree[o].flag += v;
+        tree[o].maxx += v;
+        return;
+    }
+    pushdown(o);
+    int m = (tree[o].l + tree[o].r)/2;
+    if(x <= m)  update(2*o,x,y,v);
+    if(y > m)   update(2*o+1,x,y,v);
+    pushup(o);
+}
+int main()
+{
+    int n,w,h;
+    while(scanf("%d",&n))
+    {
+        if(n < 0)  break;
+        scanf("%d%d",&w,&h);
+        int i;
+        for(i = 0; i < n; i++)
+        {
+            int x,y;
+            scanf("%d%d",&x,&y);
+            x += N;
+            y += N;
+            s[2*i].x = x;
+            s[2*i].y = y;
+            s[2*i].flag = 1;
+            s[2*i+1].x = x+w;
+            s[2*i+1].y = y;
+            s[2*i+1].flag = -1;
+        }
+        sort(s,s+2*n,cmp);
+        build(1,1,2*N+1);
+        int ans = 0;
+        for(i = 0; i < 2*n; i++)
+        {
+            update(1,s[i].y, s[i].y+h ,s[i].flag);
+            ans = max(ans,tree[1].maxx);
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/5092_autoAC.cpp b/HDOJ/5092_autoAC.cpp
new file mode 100644
index 0000000..3f0e995
--- /dev/null
+++ b/HDOJ/5092_autoAC.cpp
@@ -0,0 +1,55 @@
+#include "stdio.h"
+#include "string.h"
+int inf=0x3f3f3f3f;
+struct node
+{
+    int x,y;
+}dp[110][110];
+int main()
+{
+    int Case,ii,i,j,n,m,ans;
+    int a[110][110];
+    scanf("%d",&Case);
+    for (ii=1;ii<=Case;ii++)
+    {
+        scanf("%d%d",&n,&m);
+        for (i=1;i<=n;i++)
+            for (j=1;j<=m;j++)
+            scanf("%d",&a[i][j]);
+        memset(dp,inf,sizeof(dp));
+        for (i=1;i<=m;i++)
+            dp[n][i].x=a[n][i];
+        for (i=n-1;i>=1;i--)
+            for (j=1;j<=m;j++)
+            {
+                dp[i][j].x=dp[i+1][j].x+a[i][j];
+                dp[i][j].y=j;
+                if (j-1>=1 && dp[i+1][j-1].x+a[i][j]<dp[i][j].x)
+                {
+                    dp[i][j].x=dp[i+1][j-1].x+a[i][j];
+                    dp[i][j].y=j-1;
+                }
+                if (j+1<=m && dp[i+1][j+1].x+a[i][j]<=dp[i][j].x)
+                {
+                    dp[i][j].x=dp[i+1][j+1].x+a[i][j];
+                    dp[i][j].y=j+1;
+                }
+            }
+        ans=inf;
+        for (i=1;i<=m;i++)
+        if (dp[1][i].x<=ans)
+        {
+            ans=dp[1][i].x;
+            j=i;
+        }
+        printf("Case %d\n",ii);
+        printf("%d",j);
+        for (i=1;i<n;i++)
+        {
+            j=dp[i][j].y;
+            printf(" %d",j);
+        }
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/5093_autoAC.cpp b/HDOJ/5093_autoAC.cpp
new file mode 100644
index 0000000..d5f0870
--- /dev/null
+++ b/HDOJ/5093_autoAC.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <cstdio>
+#include <queue>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+struct node{
+    int s,t,nxt ; 
+}e[2500005] ;
+int m,n,head[5005],cnt,match[5005],vis[5005] ;
+int find(int s)
+{
+    for(int i=head[s] ;i!=-1 ;i=e[i].nxt)
+    {
+        int tt=e[i].t ;
+        if(!vis[tt])
+        {
+            vis[tt]=1 ;
+            if(match[tt]==-1 || find(match[tt]))
+            {
+                match[tt]=s ;
+                return 1 ;
+            }
+        }
+    }
+    return 0 ;
+}
+int cr,cc;
+int max_match()
+{
+    int ans=0 ;
+    memset(match,-1,sizeof(match)) ;
+    for(int i=1 ;i<cr ;i++)
+    {
+        memset(vis,0,sizeof(vis)) ;
+        ans+=find(i);
+    }
+    return ans;
+}
+void add(int s,int t) {e[cnt].s=s ;e[cnt].t=t ;e[cnt].nxt=head[s] ;head[s]=cnt++ ;}
+char M[55][55];
+int mpr[55][55],mpc[55][55];
+void read_graph()
+{
+    memset(head,-1,sizeof(head)) ;
+    cnt=0 ;
+    for(int i=0;i<n;i++)
+        for(int j=0;j<m;j++)
+            if(M[i][j]=='*')
+                add(mpr[i][j],mpc[i][j]+cr);
+}
+int main(){
+    int T;
+    scanf("%d",&T);
+    for(int cas=1;cas<=T;cas++){
+        scanf("%d%d",&n,&m);
+        for(int i=0;i<n;i++){
+            scanf("%s",M[i]);
+        }
+        memset(mpr,-1,sizeof(mpr));
+        memset(mpc,-1,sizeof(mpc));
+        cr=cc=1;
+        for(int i=0;i<n;i++){
+            for(int j=0;j<m;j++){
+                if(M[i][j]=='*' && mpr[i][j]==-1){         
+                    for(int k=j;(M[i][k]=='*' || M[i][k]=='o') && k<m;k++)
+                        mpr[i][k]=cr; 
+                    cr++;
+                }
+                if(M[j][i]=='*' && mpc[j][i]==-1){          
+                    for(int k=j;(M[k][i]=='*' || M[k][i]=='o') && k<n;k++)
+                        mpc[k][i]=cc;
+                    cc++;
+                }
+            }
+        }
+        read_graph();
+        printf("%d\n",max_match());
+    }
+    return 0;
+}
diff --git a/HDOJ/5094_autoAC.cpp b/HDOJ/5094_autoAC.cpp
new file mode 100644
index 0000000..0fb9854
--- /dev/null
+++ b/HDOJ/5094_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<cstdio>
+#include<cstring>
+#include<queue>
+using namespace std;
+int n, m, p;
+int door[51][51][4], map[51][51];
+bool vis[51][51][1<<10];
+int xl[4]={-1,1,0,0};
+int yl[4]={0,0,-1,1};
+int getd(int a, int b, int c, int d){
+    if(a==c){
+        if(b<d)    return 3;
+        return 2;
+    }
+    else{
+        if(a<c)    return 1;
+        return 0;
+    }
+}
+struct Node{
+    int x, y, st, u;
+    Node(){}
+    Node(int x, int y, int st, int u):x(x),y(y),st(st),u(u){}
+};
+int solve(){
+    if(n==1 && m==1)    return 0;
+    queue<Node> Q;
+    Q.push(Node(1,1,map[1][1],0));
+    while(!Q.empty()){
+        Node nd = Q.front(); Q.pop();
+        if(vis[nd.x][nd.y][nd.st])    continue;
+        vis[nd.x][nd.y][nd.st] = 1;
+        for(int i=0; i<4; i++){
+            int a = nd.x+xl[i];
+            int b = nd.y+yl[i];
+            if(a<1 || a>n || b<1 || b>m)    continue;
+            if(!door[nd.x][nd.y][i])    continue;
+            int st = nd.st;
+            if(door[nd.x][nd.y][i]>0){
+                int d = 1<<(door[nd.x][nd.y][i]-1);
+                if(!(st&d))    continue;
+            }
+            if(a==n && b==m)    return nd.u+1;
+            st |= map[a][b];
+            if(!vis[a][b][st])    Q.push(Node(a,b,st,nd.u+1));
+        }
+    }
+    return -1;
+}
+int main(){
+    while(~scanf("%d %d %d", &n, &m, &p)){
+        memset(door, -1, sizeof(door));
+        memset(map, 0, sizeof(map));
+        memset(vis, 0, sizeof(vis));
+        int k;
+        scanf("%d", &k);
+        int a, b, c, d, e;
+        while(k--){
+            scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);
+            door[a][b][getd(a,b,c,d)] = e;
+            door[c][d][getd(c,d,a,b)] = e;
+        }
+        scanf("%d", &k);
+        while(k--){
+            scanf("%d %d %d", &a, &b, &c);
+            map[a][b] |= (1<<(c-1));
+        }
+        printf("%d\n", solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/5095_autoAC.cpp b/HDOJ/5095_autoAC.cpp
new file mode 100644
index 0000000..84da365
--- /dev/null
+++ b/HDOJ/5095_autoAC.cpp
@@ -0,0 +1,74 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <cstring>
+#include <string>
+#include <queue>
+#include <map>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define RD(x) scanf("%d",&x)
+#define RD2(x,y) scanf("%d%d",&x,&y)
+#define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
+#define clr0(x) memset(x,0,sizeof(x))
+#define clr1(x) memset(x,-1,sizeof(x))
+#define eps 1e-9
+const double pi = acos(-1.0);
+typedef long long LL;
+typedef unsigned long long ULL;
+const int modo = 1e9 + 7;
+const int INF = 0x3f3f3f3f;
+const int inf = 0x3fffffff;
+const LL _inf = 1e18;
+const int maxn = 105,maxm = 10005;
+int p[maxn],n,k;
+char q[maxn] = {'p','q','r','u','v','w','x','y','z','\n'};
+char ch[maxn];
+void work()
+{
+    for(int i = 0;i < 10;++i){
+        RD(p[i]);
+    }
+    int k = 0;
+    while(k < 10 && p[k] == 0)k++;
+    if(k == 10){
+        puts("0");
+        return ;
+    }
+    if(k == 9){
+        printf("%d\n",p[9]);
+        return;
+    }
+    if(p[k] == 1)
+        printf("%c",q[k]);
+    else if(p[k] == -1)
+        printf("-%c",q[k]);
+    else
+        printf("%d%c",p[k],q[k]);
+    for(int i = k+1;i < 9;++i){
+        if(p[i] > 1)
+            printf("+%d%c",p[i],q[i]);
+        else if(p[i] < -1)
+            printf("%d%c",p[i],q[i]);
+        else if(p[i] == 1)
+            printf("+%c",q[i]);
+        else if(p[i] == -1)
+            printf("-%c",q[i]);
+    }
+    if(p[9] == 0)
+        puts("");
+    else if(p[9] > 0)
+        printf("+%d\n",p[9]);
+    else
+        printf("%d\n",p[9]);
+    return;
+}
+int main()
+{
+    int _;RD(_);
+    while(_--){
+        work();
+    }
+    return 0;
+}
diff --git a/HDOJ/5096_autoAC.cpp b/HDOJ/5096_autoAC.cpp
new file mode 100644
index 0000000..eb56381
--- /dev/null
+++ b/HDOJ/5096_autoAC.cpp
@@ -0,0 +1,164 @@
+#include<cstdio>
+#include<cstring>
+#include<map>
+#include<set>
+#include<algorithm>
+using namespace std;
+const int N = 100100;
+const int M = 5000;
+int n, m, sol_num, tot;
+int arr[11][M];
+int cnt[N][11];
+int sum[11];
+bool solve[N][10];
+char s1[20], s2[20];
+int solved[N];
+int pen[N];
+int last[N];
+struct Team{
+    int id, ac;
+    Team(){}
+    Team(int id, int ac):id(id),ac(ac){}
+    bool operator < (const Team &A)const{
+        return ac<A.ac;
+    }
+};
+int lowbit(int x){
+    return x&(-x);
+}
+void add(int sol, int x, int v){
+    if(x==0){
+        arr[sol][x]+=v;
+        return;
+    }
+    for(; x<M; x+=lowbit(x))    arr[sol][x]+=v;
+}
+int cal(int sol, int x){
+    if(x<0)    return 0;
+    int res = arr[sol][0];
+    for(; x>0; x-=lowbit(x))    res += arr[sol][x];
+    return res;
+}
+Team t[N];
+map<int, set<Team> > MP[11];
+set<int> ST;
+void init(){
+    for(int i=1; i<=m; i++){
+        MP[i].clear();
+    }
+    ST.clear();
+    for(int i=0; i<n; i++){
+        ST.insert(i);
+        t[i] = Team(i,-10);
+        last[i] = -10;
+    }
+    tot = 0;
+    sol_num = 0;
+    memset(solved, 0, sizeof(solved));
+    memset(pen, 0, sizeof(pen));
+    memset(arr, 0, sizeof(arr));
+    memset(solve, 0, sizeof(solve));
+    memset(cnt, 0, sizeof(cnt));
+    memset(sum, 0, sizeof(sum));
+}
+inline void in(int &x){
+    char c=getchar();
+    x = 0;
+    while(c<48 || c>57)    c=getchar();
+    while(c>=48 && c<=57){
+        x = x*10+c-48;
+        c = getchar();
+    }
+}
+inline void read(int &x){
+    char c=getchar();
+    x = c-'A';
+}
+void submit(){
+    int min, id, flag, pro;
+    in(min);
+    in(id);
+    read(pro);
+    in(flag);
+    if(min - last[id] < 5 || solve[id][pro])    return;
+    last[id] = min;
+    if(flag){
+        printf("[%d][%c]\n", id, pro+'A');
+        int sol = solved[id];
+        int penlty = pen[id];
+        if(sol){
+            MP[sol][penlty].erase(t[id]);
+            add(sol, penlty, -1);
+            sum[sol]--;
+        }
+        else{
+            sol_num++;
+            ST.erase(id);
+        }
+        sol++;
+        penlty += min + cnt[id][pro]*20;
+        solved[id]++;
+        pen[id] = penlty;
+        t[id].ac = ++tot;
+        MP[sol][penlty].insert(t[id]);
+        add(sol, penlty, 1);
+        solve[id][pro]=1;
+        sum[sol]++;
+    }
+    else{
+        cnt[id][pro]++;
+    }
+}
+int R(){
+    int id, res;
+    in(id);
+    if(solved[id]==0)    return sol_num+1;
+    res = cal(solved[id], pen[id]-1)+1;
+    for(int i=solved[id]+1; i<=m; i++)    res+=sum[i];
+    return res;
+}
+int find(int sol, int rank){
+    int low=0, top=M, mid;
+    int ans = M;
+    while(low<=top){
+        mid = (low+top)>>1;
+        int res = cal(sol, mid);
+        if(res >= rank){
+            ans = min(ans, mid);
+            top = mid-1;
+        }
+        else{
+            low = mid+1;
+        }
+    }
+    int tmp = cal(sol, ans-1);
+    if(tmp + 1 != rank)    return -1;
+    return MP[sol][ans].begin()->id;
+}
+int T(){
+    int rank;
+    in(rank);
+    if(rank > n)    return -1;
+    if(rank == sol_num+1)    return *ST.begin();
+    if(rank > sol_num)    return -1;
+    int i, res = 0;
+    for(i=m; i>=0; i--){
+        res += sum[i];
+        if(res >= rank)    break;
+    }
+    res -= sum[i];
+    return find(i, rank - res);
+}
+int main(){
+    while(~scanf("%d %d", &n, &m)){
+        init();
+        while(~scanf("%s", s1) && s1[0]!='C'){
+            if(s1[0]=='S')    submit();
+            else if(s1[0]=='T')    printf("%d\n", T());
+            else    printf("%d\n", R());
+        }
+        scanf("%s", s1);
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/5097_autoAC.cpp b/HDOJ/5097_autoAC.cpp
new file mode 100644
index 0000000..0451dda
--- /dev/null
+++ b/HDOJ/5097_autoAC.cpp
@@ -0,0 +1,49 @@
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+const double alpha = 0.85;
+const double eps = 1e-10;
+const int N = 3010;
+int n;
+double mat[N][N], q[2][N];
+inline double sqr(double x){
+    return x*x;
+}
+bool ok(){
+    double s = 0.0;
+    for(int i=0; i<n; i++)  s += sqr(q[0][i]-q[1][i]);
+    return fabs(s)<eps;
+}
+char s[N];
+int main(){
+    while(~scanf("%d", &n)){
+        double b = (1.0-alpha)/n;
+        for(int i=0; i<n; i++){
+            scanf("%s", s);
+            int m = 0;
+            for(int j=0; j<n; j++)  m += s[j]-'0';
+            for(int j=0; j<n; j++){
+                mat[j][i] = s[j]=='0'?0.0:(1.0/m);
+                mat[j][i] = mat[j][i]*alpha + b;
+            }
+            q[1][i] = 0.0;
+            q[0][i] = 1.0;
+        }
+        bool f = 0;
+        while(!ok()){
+            for(int i=0; i<n; i++){
+                q[f^1][i] = 0.0;
+                for(int j=0; j<n; j++){
+                    q[f^1][i] += mat[i][j] * q[f][j];
+                }
+            }
+            f^=1;
+        }
+        for(int i=0; i<n; i++){
+            if(i)   putchar(' ');
+            printf("%.2f", q[f][i]);
+        }
+        puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/5098_autoAC.cpp b/HDOJ/5098_autoAC.cpp
new file mode 100644
index 0000000..60805f4
--- /dev/null
+++ b/HDOJ/5098_autoAC.cpp
@@ -0,0 +1,106 @@
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cmath>
+#include <vector>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <stack>
+#include <queue>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define lp (p << 1)
+#define rp (p << 1|1)
+#define getmid(l,r) (l + (r - l) / 2)
+#define MP(a,b) make_pair(a,b)
+typedef long long ll;
+const int INF = 1 << 30;
+const int maxn = 1010;
+int n,m,cnt;
+int din[maxn],dout[maxn],reb[maxn];
+int vis[maxn],first[maxn],nex[maxn * maxn],ver[maxn * maxn],ecnt;
+string s,id1,id2;
+char name[1500];
+map< string,int > mp;
+queue<int> q1,q2;
+void Add_edge(int u,int v){
+    nex[++ecnt] = first[u];
+    ver[ecnt] = v;
+    first[u] = ecnt;
+}
+void Init(){
+    memset(reb,0,sizeof(reb));
+    memset(vis,0,sizeof(vis));
+    memset(din,0,sizeof(din));
+    memset(dout,0,sizeof(dout));
+    memset(first,-1,sizeof(first));
+    while(!q1.empty()) q1.pop();
+    while(!q2.empty()) q2.pop();
+    ecnt = cnt = 0;
+    mp.clear();
+}
+int Topo_count(){
+    for(int i = 1; i <= cnt; ++i) if(din[i] == 0){
+        if(reb[i] == 0) q1.push(i);
+        else q2.push(i);
+    }
+    int res = 0;
+    while(!q1.empty() || !q2.empty()){
+        if(q1.empty() && !q2.empty()){
+            ++res;
+            while(!q2.empty()){
+                int x = q2.front(); q2.pop();
+                q1.push(x);
+            }
+        }
+        while(!q1.empty()){
+            int x = q1.front(); q1.pop();
+            vis[x] = 1;
+            for(int i = first[x]; i != -1; i = nex[i]){
+                int v = ver[i];
+                din[v]--;
+                if(din[v] == 0){
+                    if(!reb[v]) q1.push(v);
+                    else q2.push(v);
+                }
+            }
+        }
+    }
+    return res;
+}
+int main(){
+    int a,b,len,flag;
+    scanf("%d",&n);
+    getchar();
+    getchar();
+    for(int Case = 1; Case <= n; ++Case){
+        Init();
+        while(getline(cin,s) != NULL){
+             if(s[0] == '\0')
+                 break;
+             istringstream sin(s);
+             sin >> name;
+             flag = 0;
+             int len = strlen(name);
+             for(int i = 0; i < len; ++i)
+                 if(name[i] == '*') flag = 1;
+             name[len - 1 - flag] = '\0';
+             id1 = name;
+             if(mp.find(id1) == mp.end())
+                mp[id1]= ++cnt;
+             reb[mp[id1]] = flag;
+             while(sin >> id2){
+                 if(mp.find(id2) == mp.end())
+                     mp[id2] = ++cnt;
+                 Add_edge(mp[id2],mp[id1]);
+                 dout[mp[id2]]++;
+                 din[mp[id1]]++;
+             }
+        }
+           printf("Case %d: %d\n",Case,Topo_count());
+    }
+    return 0;
+}
diff --git a/HDOJ/5099_autoAC.cpp b/HDOJ/5099_autoAC.cpp
new file mode 100644
index 0000000..5456728
--- /dev/null
+++ b/HDOJ/5099_autoAC.cpp
@@ -0,0 +1,72 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <cstring>
+#include <string>
+#include <queue>
+#include <map>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define RD(x) scanf("%d",&x)
+#define RD2(x,y) scanf("%d%d",&x,&y)
+#define RD3(x,y,z) scanf("%d%d%d",&x,&y,&z)
+#define clr0(x) memset(x,0,sizeof(x))
+#define clr1(x) memset(x,-1,sizeof(x))
+#define eps 1e-9
+const double pi = acos(-1.0);
+typedef long long LL;
+typedef unsigned long long ULL;
+const int modo = 1e9 + 7;
+const int INF = 0x3f3f3f3f;
+const int inf = 0x3fffffff;
+const LL _inf = 1e18;
+const int maxn = 105,maxm = 10005;
+int p[maxn],n,k,cas = 1;
+char a[maxn],b[maxn];
+void work()
+{
+    scanf("%s%s",a,b);
+    int n = strlen(a),m = strlen(b);
+    printf("Case %d: ",cas++);
+    if(a[0] > b[0])
+        printf("%c ",'>');
+    else if(a[0] == b[0])
+        printf("%c ",'=');
+    else
+        printf("%c ",'<');
+    int _a = (a[3]-'0')*10 + a[4] - '0',_b = (b[3]-'0')*10 + b[4] - '0';
+    char __a,__b;
+    if(n == 5)
+        __a = 'A';
+    else
+        __a = a[5];
+    if(m == 5)
+        __b = 'A';
+    else
+        __b = b[5];
+    if(a[1] != b[1]){
+        if(a[2] < b[2] || (a[2] == b[2] && _a < _b))
+           printf("%c\n",'<');
+        else if(a[2] > b[2] || (a[2] == b[2] && _a > _b))
+           printf("%c\n",'>');
+        else
+           printf("%c\n",'=');
+    }else if(a[1] == b[1]){
+        if(a[2] < b[2] || (a[2] == b[2] && _a < _b) || (a[2] == b[2] && _a == _b && __a < __b))
+           printf("%c\n",'<');
+        else if(a[2] > b[2] || (a[2] == b[2] && _a > _b) || (a[2] == b[2] && _a == _b && __a > __b))
+           printf("%c\n",'>');
+        else
+           printf("%c\n",'=');
+    }
+    return;
+}
+int main()
+{
+    int _;RD(_);
+    while(_--){
+        work();
+    }
+    return 0;
+}