From 27767e72ab099d727572429de910e8f899628e56 Mon Sep 17 00:00:00 2001
From: KiritoTRw <3021577574@qq.com>
Date: Wed, 24 Aug 2016 18:25:36 +0800
Subject: [PATCH] Powered By HC TECH : AutoACer Engine

2800-2899
---
 HDOJ/2800_autoAC.cpp |  10 ++
 HDOJ/2802_autoAC.cpp |  17 +++
 HDOJ/2803_autoAC.cpp |  25 ++++
 HDOJ/2804_autoAC.cpp |  17 +++
 HDOJ/2806_autoAC.cpp |  68 +++++++++++
 HDOJ/2807_autoAC.cpp |  74 ++++++++++++
 HDOJ/2809_autoAC.cpp |  69 +++++++++++
 HDOJ/2811_autoAC.cpp |  43 +++++++
 HDOJ/2812_autoAC.cpp |  71 +++++++++++
 HDOJ/2813_autoAC.cpp |  86 ++++++++++++++
 HDOJ/2814_autoAC.cpp | 133 +++++++++++++++++++++
 HDOJ/2815_autoAC.cpp | 109 +++++++++++++++++
 HDOJ/2816_autoAC.cpp |  61 ++++++++++
 HDOJ/2817_autoAC.cpp |  41 +++++++
 HDOJ/2818_autoAC.cpp |  58 +++++++++
 HDOJ/2819_autoAC.cpp |  67 +++++++++++
 HDOJ/2820_autoAC.cpp | 125 ++++++++++++++++++++
 HDOJ/2821_autoAC.cpp | 170 +++++++++++++++++++++++++++
 HDOJ/2822_autoAC.cpp |  75 ++++++++++++
 HDOJ/2823_autoAC.cpp | 274 +++++++++++++++++++++++++++++++++++++++++++
 HDOJ/2824_autoAC.cpp |  25 ++++
 HDOJ/2825_autoAC.cpp | 118 +++++++++++++++++++
 HDOJ/2826_autoAC.cpp |  88 ++++++++++++++
 HDOJ/2827_autoAC.cpp | 140 ++++++++++++++++++++++
 HDOJ/2828_autoAC.cpp | 126 ++++++++++++++++++++
 HDOJ/2829_autoAC.cpp |  75 ++++++++++++
 HDOJ/2830_autoAC.cpp |  45 +++++++
 HDOJ/2831_autoAC.cpp |  58 +++++++++
 HDOJ/2832_autoAC.cpp |  35 ++++++
 HDOJ/2833_autoAC.cpp |  65 ++++++++++
 HDOJ/2834_autoAC.cpp |  99 ++++++++++++++++
 HDOJ/2835_autoAC.cpp |  68 +++++++++++
 HDOJ/2836_autoAC.cpp |  94 +++++++++++++++
 HDOJ/2837_autoAC.cpp |  51 ++++++++
 HDOJ/2838_autoAC.cpp |  57 +++++++++
 HDOJ/2840_autoAC.cpp |  64 ++++++++++
 HDOJ/2841_autoAC.cpp |  41 +++++++
 HDOJ/2842_autoAC.cpp |  78 ++++++++++++
 HDOJ/2843_autoAC.cpp |  18 +++
 HDOJ/2844_autoAC.cpp |  51 ++++++++
 HDOJ/2845_autoAC.cpp |  16 +++
 HDOJ/2846_autoAC.cpp |  67 +++++++++++
 HDOJ/2847_autoAC.cpp |  49 ++++++++
 HDOJ/2848_autoAC.cpp |  43 +++++++
 HDOJ/2850_autoAC.cpp |  58 +++++++++
 HDOJ/2851_autoAC.cpp |  68 +++++++++++
 HDOJ/2852_autoAC.cpp |  87 ++++++++++++++
 HDOJ/2853_autoAC.cpp | 107 +++++++++++++++++
 HDOJ/2854_autoAC.cpp |  39 ++++++
 HDOJ/2855_autoAC.cpp |  49 ++++++++
 HDOJ/2857_autoAC.cpp |  50 ++++++++
 HDOJ/2858_autoAC.cpp | 148 +++++++++++++++++++++++
 HDOJ/2859_autoAC.cpp |  38 ++++++
 HDOJ/2860_autoAC.cpp |  68 +++++++++++
 HDOJ/2861_autoAC.cpp |  30 +++++
 HDOJ/2863_autoAC.cpp |  80 +++++++++++++
 HDOJ/2864_autoAC.cpp |  32 +++++
 HDOJ/2865_autoAC.cpp | 143 ++++++++++++++++++++++
 HDOJ/2866_autoAC.cpp |  39 ++++++
 HDOJ/2868_autoAC.cpp |  51 ++++++++
 HDOJ/2869_autoAC.cpp |  38 ++++++
 HDOJ/2870_autoAC.cpp |  89 ++++++++++++++
 HDOJ/2871_autoAC.cpp | 184 +++++++++++++++++++++++++++++
 HDOJ/2872_autoAC.cpp |  95 +++++++++++++++
 HDOJ/2873_autoAC.cpp |  46 ++++++++
 HDOJ/2874_autoAC.cpp | 114 ++++++++++++++++++
 HDOJ/2876_autoAC.cpp |  47 ++++++++
 HDOJ/2878_autoAC.cpp | 114 ++++++++++++++++++
 HDOJ/2879_autoAC.cpp |  59 ++++++++++
 HDOJ/2881_autoAC.cpp |  41 +++++++
 HDOJ/2883_autoAC.cpp | 159 +++++++++++++++++++++++++
 HDOJ/2886_autoAC.cpp |  75 ++++++++++++
 HDOJ/2887_autoAC.cpp | 157 +++++++++++++++++++++++++
 HDOJ/2888_autoAC.cpp |  60 ++++++++++
 HDOJ/2889_autoAC.cpp |  18 +++
 HDOJ/2890_autoAC.cpp | 121 +++++++++++++++++++
 HDOJ/2891_autoAC.cpp |  63 ++++++++++
 HDOJ/2892_autoAC.cpp | 114 ++++++++++++++++++
 HDOJ/2894_autoAC.cpp |  65 ++++++++++
 HDOJ/2895_autoAC.cpp |  36 ++++++
 HDOJ/2896_autoAC.cpp | 110 +++++++++++++++++
 HDOJ/2897_autoAC.cpp |  19 +++
 HDOJ/2898_autoAC.cpp |  38 ++++++
 HDOJ/2899_autoAC.cpp |  46 ++++++++
 84 files changed, 6159 insertions(+)
 create mode 100644 HDOJ/2800_autoAC.cpp
 create mode 100644 HDOJ/2802_autoAC.cpp
 create mode 100644 HDOJ/2803_autoAC.cpp
 create mode 100644 HDOJ/2804_autoAC.cpp
 create mode 100644 HDOJ/2806_autoAC.cpp
 create mode 100644 HDOJ/2807_autoAC.cpp
 create mode 100644 HDOJ/2809_autoAC.cpp
 create mode 100644 HDOJ/2811_autoAC.cpp
 create mode 100644 HDOJ/2812_autoAC.cpp
 create mode 100644 HDOJ/2813_autoAC.cpp
 create mode 100644 HDOJ/2814_autoAC.cpp
 create mode 100644 HDOJ/2815_autoAC.cpp
 create mode 100644 HDOJ/2816_autoAC.cpp
 create mode 100644 HDOJ/2817_autoAC.cpp
 create mode 100644 HDOJ/2818_autoAC.cpp
 create mode 100644 HDOJ/2819_autoAC.cpp
 create mode 100644 HDOJ/2820_autoAC.cpp
 create mode 100644 HDOJ/2821_autoAC.cpp
 create mode 100644 HDOJ/2822_autoAC.cpp
 create mode 100644 HDOJ/2823_autoAC.cpp
 create mode 100644 HDOJ/2824_autoAC.cpp
 create mode 100644 HDOJ/2825_autoAC.cpp
 create mode 100644 HDOJ/2826_autoAC.cpp
 create mode 100644 HDOJ/2827_autoAC.cpp
 create mode 100644 HDOJ/2828_autoAC.cpp
 create mode 100644 HDOJ/2829_autoAC.cpp
 create mode 100644 HDOJ/2830_autoAC.cpp
 create mode 100644 HDOJ/2831_autoAC.cpp
 create mode 100644 HDOJ/2832_autoAC.cpp
 create mode 100644 HDOJ/2833_autoAC.cpp
 create mode 100644 HDOJ/2834_autoAC.cpp
 create mode 100644 HDOJ/2835_autoAC.cpp
 create mode 100644 HDOJ/2836_autoAC.cpp
 create mode 100644 HDOJ/2837_autoAC.cpp
 create mode 100644 HDOJ/2838_autoAC.cpp
 create mode 100644 HDOJ/2840_autoAC.cpp
 create mode 100644 HDOJ/2841_autoAC.cpp
 create mode 100644 HDOJ/2842_autoAC.cpp
 create mode 100644 HDOJ/2843_autoAC.cpp
 create mode 100644 HDOJ/2844_autoAC.cpp
 create mode 100644 HDOJ/2845_autoAC.cpp
 create mode 100644 HDOJ/2846_autoAC.cpp
 create mode 100644 HDOJ/2847_autoAC.cpp
 create mode 100644 HDOJ/2848_autoAC.cpp
 create mode 100644 HDOJ/2850_autoAC.cpp
 create mode 100644 HDOJ/2851_autoAC.cpp
 create mode 100644 HDOJ/2852_autoAC.cpp
 create mode 100644 HDOJ/2853_autoAC.cpp
 create mode 100644 HDOJ/2854_autoAC.cpp
 create mode 100644 HDOJ/2855_autoAC.cpp
 create mode 100644 HDOJ/2857_autoAC.cpp
 create mode 100644 HDOJ/2858_autoAC.cpp
 create mode 100644 HDOJ/2859_autoAC.cpp
 create mode 100644 HDOJ/2860_autoAC.cpp
 create mode 100644 HDOJ/2861_autoAC.cpp
 create mode 100644 HDOJ/2863_autoAC.cpp
 create mode 100644 HDOJ/2864_autoAC.cpp
 create mode 100644 HDOJ/2865_autoAC.cpp
 create mode 100644 HDOJ/2866_autoAC.cpp
 create mode 100644 HDOJ/2868_autoAC.cpp
 create mode 100644 HDOJ/2869_autoAC.cpp
 create mode 100644 HDOJ/2870_autoAC.cpp
 create mode 100644 HDOJ/2871_autoAC.cpp
 create mode 100644 HDOJ/2872_autoAC.cpp
 create mode 100644 HDOJ/2873_autoAC.cpp
 create mode 100644 HDOJ/2874_autoAC.cpp
 create mode 100644 HDOJ/2876_autoAC.cpp
 create mode 100644 HDOJ/2878_autoAC.cpp
 create mode 100644 HDOJ/2879_autoAC.cpp
 create mode 100644 HDOJ/2881_autoAC.cpp
 create mode 100644 HDOJ/2883_autoAC.cpp
 create mode 100644 HDOJ/2886_autoAC.cpp
 create mode 100644 HDOJ/2887_autoAC.cpp
 create mode 100644 HDOJ/2888_autoAC.cpp
 create mode 100644 HDOJ/2889_autoAC.cpp
 create mode 100644 HDOJ/2890_autoAC.cpp
 create mode 100644 HDOJ/2891_autoAC.cpp
 create mode 100644 HDOJ/2892_autoAC.cpp
 create mode 100644 HDOJ/2894_autoAC.cpp
 create mode 100644 HDOJ/2895_autoAC.cpp
 create mode 100644 HDOJ/2896_autoAC.cpp
 create mode 100644 HDOJ/2897_autoAC.cpp
 create mode 100644 HDOJ/2898_autoAC.cpp
 create mode 100644 HDOJ/2899_autoAC.cpp

diff --git a/HDOJ/2800_autoAC.cpp b/HDOJ/2800_autoAC.cpp
new file mode 100644
index 0000000..f037802
--- /dev/null
+++ b/HDOJ/2800_autoAC.cpp
@@ -0,0 +1,10 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+ int n;
+ while(scanf("%d",&n)!=EOF&&n)
+ {
+  printf("%d\n",(n+1)>>1);
+ }
+}
diff --git a/HDOJ/2802_autoAC.cpp b/HDOJ/2802_autoAC.cpp
new file mode 100644
index 0000000..a7e9611
--- /dev/null
+++ b/HDOJ/2802_autoAC.cpp
@@ -0,0 +1,17 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+    long T,yu;
+    long feng;
+   while(cin>>T&&T)
+   {
+    yu=T%4018;
+    if(yu%2==0)    
+        feng=((((yu*yu)/4)%2009)*((2*yu+3)%2009));
+    else
+        feng=((((yu+1)*(yu+1)/4)%2009)*((2*yu-1)%2009));
+    printf("%ld\n",feng%2009);
+   }
+return 0;
+}
diff --git a/HDOJ/2803_autoAC.cpp b/HDOJ/2803_autoAC.cpp
new file mode 100644
index 0000000..0cd6845
--- /dev/null
+++ b/HDOJ/2803_autoAC.cpp
@@ -0,0 +1,25 @@
+#include <stdio.h>
+int main ()
+{
+    __int64 n,m,a[102],i,max,t;
+    while(scanf("%I64d",&n)!=EOF&&n!=0)
+    {
+        max=0;t=0;
+        for(i=0;i<n;i++)
+        {
+            scanf("%I64d",&a[i]);
+            if(a[i]>max)
+            {
+                max=a[i];
+                t=i;
+            }
+        }
+        m=0;
+        for(i=0;i<n;i++)
+        {
+            m=m+a[i];
+        }
+        m=m-a[t]+a[t]*(2010-n);
+        printf("%I64d\n",m);
+    }
+}
diff --git a/HDOJ/2804_autoAC.cpp b/HDOJ/2804_autoAC.cpp
new file mode 100644
index 0000000..721254d
--- /dev/null
+++ b/HDOJ/2804_autoAC.cpp
@@ -0,0 +1,17 @@
+#include <cstdio>
+#include <iostream>
+using namespace std;
+int main()
+{
+    long long n, a, b, ans;
+    while( cin >> n, n )
+    {
+        n--;
+        a = n/3;
+        b = n%3;
+        ans = a*2+1;
+        if( b == 2 )    ans++;
+        cout << ans << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/2806_autoAC.cpp b/HDOJ/2806_autoAC.cpp
new file mode 100644
index 0000000..a08398e
--- /dev/null
+++ b/HDOJ/2806_autoAC.cpp
@@ -0,0 +1,68 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<algorithm>
+#include<vector>
+using namespace std;
+vector<int>v[20][20];
+int n,m,k;
+int q[1005];
+char ch[22];
+bool work(int a)
+{
+    int i,j;
+    int res=0;
+     for(i=0;i<v[m][a].size();i++)
+     {    res=0;
+         for(j=1;j<=n;j++)
+         {     
+             if((v[m][a][i]^q[j])==v[m][a][i]+q[j])
+             {    
+                     res++;
+             }    
+         }
+         if(res>=k) return true;
+     }
+     return false;
+}                 
+int main()
+{
+    int i,j,a,b,c;
+    v[1][0].push_back(0);
+    v[1][1].push_back(1);
+    for(i=2;i<=15;i++)
+    {
+          for(j=0;j<i;j++)
+          {
+              for(int k=0;k<v[i-1][j].size();k++)
+              {
+                  v[i][j].push_back(v[i-1][j][k]<<1);
+                  v[i][j+1].push_back(v[i-1][j][k]<<1^1);
+              }
+          }
+     }    
+    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
+    {
+        for(i=1;i<=n;i++)
+        {
+            q[i]=(1<<m)-1;
+            scanf("%s %d",ch,&a);
+            for(j=0;j<a;j++)
+            {
+                scanf("%d",&b);
+                q[i]^=(1<<(b-1));
+            }
+        }
+        int l=0,r=m,mid;
+        while(l+1<r)
+        {
+            mid=(l+r)>>1;
+            if(work(mid))   l=mid;
+            else
+            r=mid-1;
+        }
+        if(work(r))  { printf("%d\n",r);}
+        else printf("%d\n",l);
+    }
+    return 0;
+}
diff --git a/HDOJ/2807_autoAC.cpp b/HDOJ/2807_autoAC.cpp
new file mode 100644
index 0000000..98a9a8d
--- /dev/null
+++ b/HDOJ/2807_autoAC.cpp
@@ -0,0 +1,74 @@
+#include<iostream>
+#include<climits>
+using namespace std;
+const int maxn=85;
+int N,M,K,X,Y;
+int matrix[maxn][maxn][maxn];
+int t[maxn][maxn];                                 
+int dis[maxn][maxn];
+bool judge(int a,int b,int c) 
+{
+    int i,j,k;
+    for(i=1;i<=M;++i)
+    {
+        t[0][i]=0;                                  
+        for(j=1;j<=M;++j)
+            t[0][i]+=matrix[a][i][j]*t[b][j];
+    }
+    for(i=1;i<=M;++i)
+        if(t[0][i]!=t[c][i])                     
+            return false;
+    return true;
+}
+int main()
+{
+    int i,j,k;
+    while(cin>>N>>M&&(M+N))
+    {
+        for(i=1;i<=N;++i)
+            for(j=i+1;j<=N;++j)
+                dis[i][j]=dis[j][i]=INT_MAX;
+        for(i=1;i<=N;++i)                                       
+            for(j=1;j<=M;++j)                                   
+            {
+                t[i][j]=0;                                      
+                for(k=1;k<=M;++k)                               
+                {
+                    cin>>matrix[i][j][k];
+                    t[i][j]+=matrix[i][j][k]*k;                
+                }
+            }
+        for(i=1;i<=N;++i)
+            for(j=1;j<=N;++j)
+            {
+                if(i==j)
+                    continue;
+                for(k=1;k<=N;++k)
+                {
+                    if(i==k||j==k||dis[i][k]==1)
+                        continue;
+                    if(judge(i,j,k))                           
+                        dis[i][k]=1;
+                }
+            }
+        for(k=1;k<=N;++k)                                          
+            for(i=1;i<=N;++i)
+            { 
+                if(dis[i][k]==INT_MAX)
+                    continue;
+                for(j=1;j<=N;++j)
+                    if(dis[k][j]<INT_MAX&&dis[i][k]+dis[k][j]<dis[i][j])
+                        dis[i][j]=dis[i][k]+dis[k][j];
+            }
+        cin>>K;
+        for(i=1;i<=K;++i)
+        {
+            cin>>X>>Y;
+            if(dis[X][Y]==INT_MAX)
+                cout<<"Sorry"<<endl;
+            else
+                cout<<dis[X][Y]<<endl;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2809_autoAC.cpp b/HDOJ/2809_autoAC.cpp
new file mode 100644
index 0000000..8a0516d
--- /dev/null
+++ b/HDOJ/2809_autoAC.cpp
@@ -0,0 +1,69 @@
+# include<stdio.h>
+# include<string.h>
+# define INF 0xfffffff
+int n,m;
+struct node{
+    int ati,def,hp,exp;
+}str[21];
+int s[21]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576};
+struct node1{
+    int ati,def,hp,exp;
+}DP[1049000];
+int max(int a,int b)
+{
+    return a>b?a:b;
+}
+int judge(int a1,int b1,int c1,int a2,int b2,int c2)
+{
+    int ans1,ans2,num1,num2;
+    ans1=max(1,a1-b2);
+    ans2=max(1,a2-b1);
+    num1=c1/ans2;
+    if(num1*ans2!=c1) num1++;
+    num2=c2/ans1;
+    if(num2*ans1!=c2) num2++;
+    if(num2>num1) return 0;
+    c1-=(num2-1)*ans2;
+    return c1;
+}
+int main()
+{
+    int i,j,in_ati,in_def,in_hp,ati,def,hp,num,temp,ans;
+    char ch[105];
+    while(scanf("%d%d%d %d%d%d",&ati,&def,&hp,&in_ati,&in_def,&in_hp)!=EOF)
+    {
+        scanf("%d",&n);
+        for(i=0;i<n;i++)
+            scanf("%s %d%d%d%d",&ch,&str[i].ati,&str[i].def,&str[i].hp,&str[i].exp);
+        DP[0].hp=hp;
+        DP[0].exp=0;
+        DP[0].ati=ati;
+        DP[0].def=def;
+        for(i=1;i<s[n];i++)
+        {
+            DP[i].hp=-1;
+            for(j=0;j<n;j++)
+            {
+                if(i&s[j])
+                {
+                    ans=i-s[j];
+                    if(DP[ans].hp==-1) continue;
+                    temp=judge(DP[ans].ati,DP[ans].def,DP[ans].hp,str[j].ati,str[j].def,str[j].hp);
+                    if(temp==0) continue;
+                    num=DP[ans].exp+str[j].exp;
+                    num/=100;
+                    if(DP[i].hp<temp +num*in_hp)
+                    {
+                        DP[i].hp=temp+num*in_hp;
+                        DP[i].ati=DP[ans].ati+num*in_ati;
+                        DP[i].def=DP[ans].def+num*in_def;
+                        DP[i].exp=(DP[ans].exp+str[j].exp)%100;
+                    }
+                }
+            }
+        }
+        if(DP[s[n]-1].hp==-1) printf("Poor LvBu,his period was gone.\n");
+        else printf("%d\n",DP[s[n]-1].hp);
+    }
+    return 0;
+}
diff --git a/HDOJ/2811_autoAC.cpp b/HDOJ/2811_autoAC.cpp
new file mode 100644
index 0000000..0c09b7e
--- /dev/null
+++ b/HDOJ/2811_autoAC.cpp
@@ -0,0 +1,43 @@
+#include<stdio.h>
+__int64 mmg[1005],n,k;
+__int64 C[1005][1000],flag[1005][1000];
+int main()
+{
+    int i,j;
+    while(scanf("%I64d%I64d",&n,&k)!=EOF)
+    {
+        C[1][0]=C[1][1]=1%k;
+        flag[1][0]=flag[1][1]=(1/k)%2;
+        for(i=2;i<=n;i++)
+        {
+            C[i][0]=C[i][i]=1%k;
+            flag[i][0]=flag[i][i]=(1/k)%2;
+            for(j=1;j<i;j++)
+            {
+                C[i][j]=(C[i-1][j]+C[i-1][j-1])%k;
+                flag[i][j]=flag[i-1][j]+flag[i-1][j-1]+(C[i-1][j]+C[i-1][j-1])/k;
+                flag[i][j]=flag[i][j]%2;
+            }
+        }
+        mmg[1]=1%k;
+        mmg[2]=1%k;
+        for(i=3;i<=n;i++)
+        {
+            mmg[i]=mmg[i-1];
+            for(j=1;j<=(i-1)/2;j++)
+            {
+                if(i-1==2*j)
+                {
+                    if(flag[i-1][j]==1)
+                        mmg[i]+=(((mmg[j]%k)*(mmg[i-j-1]%k))%k)*(((C[i-1][j]+k)/2)%k);
+                    else
+                        mmg[i]+=(((mmg[j]%k)*(mmg[i-j-1]%k))%k)*(((C[i-1][j])/2)%k);
+                }
+                else
+                    mmg[i]+=(((mmg[j]%k)*(mmg[i-j-1]%k))%k)*(C[i-1][j]%k);
+                mmg[i]=mmg[i]%k;
+            }
+        }
+        printf("%I64d\n",mmg[n]);
+    }
+}
diff --git a/HDOJ/2812_autoAC.cpp b/HDOJ/2812_autoAC.cpp
new file mode 100644
index 0000000..afd9cfa
--- /dev/null
+++ b/HDOJ/2812_autoAC.cpp
@@ -0,0 +1,71 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+double pin[15];
+bool judge()
+{
+    if(fabs(pin[14] - 5)  < 1e-16 && (pin[7] >= 0 && pin[7] <= 0.8))
+        return true;
+    else
+        return false;
+}
+bool gaodi(double a)
+{
+    int temp;
+    if(a >= 0.0 && a <= 0.8)
+        return 0; //low
+    else
+            return 1; //high
+}
+char cal(double a, double b)
+{
+    if(gaodi(a) && gaodi(b))
+        return 'L';
+    else
+        return 'H';
+}
+int main()
+{
+    int n;
+    int a;
+    double dianya;
+    while(scanf("%d", &n) != EOF)
+    {
+        for(int i = 1; i <= 14; ++i)
+            pin[i] = -1.0;
+        for(int i = 0; i < n; ++i)
+        {
+            scanf("%d%lf", &a, &dianya);
+            pin[a] = dianya;
+        }
+        if(!judge())
+        {
+            printf("No\n");
+            continue;
+        }
+        else
+        {
+            printf("Yes\n");
+            if(pin[1] != -1 && pin[2] != -1)
+            {
+                printf("3 %c\n", cal(pin[1], pin[2]));
+            }
+            if(pin[4] != -1 && pin[5] != -1)
+            {
+                printf("6 %c\n", cal(pin[4], pin[5]));
+            }
+            if(pin[9] != -1 && pin[10] != -1)
+            {
+                printf("8 %c\n", cal(pin[9], pin[10]));
+            }
+            if(pin[12] != -1 && pin[13] != -1)
+            {
+                printf("11 %c\n", cal(pin[12], pin[13]));
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2813_autoAC.cpp b/HDOJ/2813_autoAC.cpp
new file mode 100644
index 0000000..c2948d5
--- /dev/null
+++ b/HDOJ/2813_autoAC.cpp
@@ -0,0 +1,86 @@
+#include<stdio.h>
+#include<string.h>
+#include<map>
+#include<iostream>
+using namespace std;
+map<string,int>q;
+const int M=201;
+const int inf=999999999;
+int Map[M][M],match[M],lx[M],ly[M],vx[M],vy[M];
+int n,m;
+int hungery(int u)
+{
+    int i;
+    vx[u]=1;
+    for(i=1;i<=m;i++)
+    {
+        if(!vy[i]&&lx[u]+ly[i]==Map[u][i])
+        {
+            vy[i]=1;
+            if(match[i]==-1||hungery(match[i]))
+            {
+                match[i]=u;
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+void KM()
+{
+    int i,temp,j;
+    for(i=1;i<=n;i++)
+    for(j=1;j<=m;j++)
+    lx[i]=max(lx[i],Map[i][j]);
+    memset(ly,0,sizeof(ly));
+    memset(match,-1,sizeof(match));
+    for(i=1;i<=n;i++)
+    {
+        while(1)
+        {
+            memset(vx,0,sizeof(vx));
+            memset(vy,0,sizeof(vy));
+            if(hungery(i))
+            break;
+            temp=inf;
+            for(j=1;j<=n;j++)
+            if(vx[j])
+            for(int z=1;z<=m;z++)
+            if(!vy[z]&&temp>lx[j]+ly[z]-Map[j][z])
+            temp=lx[j]+ly[z]-Map[j][z];
+            for(j=1;j<=n;j++)
+            if(vx[j])
+            lx[j]-=temp;
+            for(j=1;j<=m;j++)
+            if(vy[j])
+            ly[j]+=temp;
+        }
+    }
+}
+int main()
+{
+    int i,k,w,num1,num2,j;
+    char s1[21],s2[21];
+    while(~scanf("%d%d%d",&n,&m,&k))
+    {
+        for(i=1;i<=n;i++)
+        for(j=1;j<=m;j++)
+        Map[i][j]=-inf;
+        num1=num2=0;
+        for(i=1;i<=k;i++)
+        {
+            scanf("%s%s%d",s1,s2,&w);
+            if(q[s1]==0)
+            q[s1]=++num1;
+            if(q[s2]==0)
+            q[s2]=++num2;
+            Map[q[s1]][q[s2]]=-w;
+        }
+        KM();
+        int sum=0;
+        for(i=1;i<=m;i++)
+        if(match[i]!=-1&&Map[match[i]][i]!=-inf)
+        sum+=Map[match[i]][i];
+        printf("%d\n",-sum);
+    }
+}
diff --git a/HDOJ/2814_autoAC.cpp b/HDOJ/2814_autoAC.cpp
new file mode 100644
index 0000000..b926a97
--- /dev/null
+++ b/HDOJ/2814_autoAC.cpp
@@ -0,0 +1,133 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+using namespace std;
+typedef unsigned __int64 LL;
+struct Matrix
+{
+    LL m[3][3];
+}E, D;
+LL Pow(LL a, LL b, LL mod)
+{
+    LL ans = 1;
+    while (b)
+    {
+        if (b & 1)
+        {
+            b--;
+            ans = (ans*a)%mod;
+        }
+        else
+        {
+            b /= 2;
+            a = (a*a)%mod;
+        }
+    }
+    return ans;
+}
+void init()
+{
+    for (int i = 1; i <= 2; i++)
+        for (int j = 1; j <= 2; j++)
+        {
+            D.m[i][j] = 1;
+            E.m[i][j] = (i == j);
+        }
+        D.m[2][2] = 0;
+}
+Matrix Multi(Matrix A, Matrix B, LL mod)
+{
+    Matrix ans;
+    for (int i = 1; i <= 2; i++)
+        for (int j = 1; j <= 2; j++)
+        {
+            ans.m[i][j] = 0;
+            for (int k = 1; k <= 2; k++)
+                ans.m[i][j] = (ans.m[i][j] + A.m[i][k] * B.m[k][j])%mod;
+        }
+        return ans;
+}
+Matrix Pow(Matrix A, LL k, LL mod)
+{
+    Matrix ans = E;
+    while (k)
+    {
+        if (k & 1)
+        {
+            k--;
+            ans = Multi(ans, A, mod);
+        }
+        else
+        {
+            k /= 2;
+            A = Multi(A, A, mod);
+        }
+    }
+    return ans;
+}
+LL Fib(LL n, LL mod)
+{
+    return Pow(D, n, mod).m[2][1];
+}
+long long euler(long long x)
+{
+    long long i, res = x;
+    for (i = 2; i*i <= x; i++)
+        if (x%i == 0)
+        {
+            res = res / i*(i - 1);
+            while (x%i == 0)
+                x /= i;
+        }
+        if (x > 1)
+            res = res / x*(x - 1);
+        return res;
+}
+LL s_mod(LL n)
+{
+    LL a1 = 0, a2 = 1, a3 = 1, tmp, ans = 1;
+    while (a2 != 0 || a3 != 1)
+    {
+        ans++;
+        tmp = (a2 + a3)%n;
+        a2 = a3;
+        a3 = tmp;
+    }
+    return ans;
+}
+LL smod[305];
+int main()
+{
+    init();
+    smod[1] = 1;
+    for (int i = 2; i <= 300; i++)
+        smod[i] = s_mod(i);
+    LL a, b, n;
+    int c;
+    int t;
+    scanf("%d", &t);
+    LL mod1, mod2, tmp, cnt, ans, eul;
+    for (int cas = 1; cas <= t; cas++)
+    {
+        scanf("%I64u%I64u%I64u%d", &a, &b, &n, &c);
+        if (c == 1)
+        {
+            printf("Case %d: 0\n", cas);
+            continue;
+        }
+        mod1 = smod[c];
+        eul = euler(c);
+        mod2 = smod[eul];
+        tmp = Pow(a%mod1, b, mod1);
+        tmp = Fib(tmp, c);
+        cnt = Pow(a%mod2, b, mod2);
+        cnt = Fib(cnt, eul);
+        cnt = Pow(cnt, n - 1, eul);
+        cnt += eul;
+        ans = Pow(tmp, cnt, c);
+        printf("Case %d: %I64u\n", cas, ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/2815_autoAC.cpp b/HDOJ/2815_autoAC.cpp
new file mode 100644
index 0000000..4bf8dab
--- /dev/null
+++ b/HDOJ/2815_autoAC.cpp
@@ -0,0 +1,109 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+#include<cmath>
+#define LL __int64
+#define N 1000000
+using namespace std;
+struct Node{
+    int idx;
+    int val;
+}baby[N];
+bool cmp(Node n1,Node n2){
+    return n1.val!=n2.val?n1.val<n2.val:n1.idx<n2.idx;
+}
+int gcd(int a,int b){
+    return b==0?a:gcd(b,a%b);
+}
+int extend_gcd(int a,int b,int &x,int &y){
+    if(b==0){
+        x=1;
+        y=0;
+        return a;
+    }
+    int gcd=extend_gcd(b,a%b,x,y);
+    int t=x;
+    x=y;
+    y=t-a/b*y;
+    return gcd;
+}
+int inval(int a,int b,int n){
+    int e,x,y;
+    extend_gcd(a,n,x,y);
+    e=((LL)x*b)%n;
+    return e<0?e+n:e;
+}
+int PowMod(int a,int b,int MOD){
+    LL ret=1%MOD,t=a%MOD;
+    while(b){
+        if(b&1)
+            ret=((LL)ret*t)%MOD;
+        t=((LL)t*t)%MOD;
+        b>>=1;
+    }
+    return (int)ret;
+}
+int BinSearch(int num,int m){
+    int low=0,high=m-1,mid;
+    while(low<=high){
+        mid=(low+high)>>1;
+        if(baby[mid].val==num)
+            return baby[mid].idx;
+        if(baby[mid].val<num)
+            low=mid+1;
+        else
+            high=mid-1;
+    }
+    return -1;
+}
+int BabyStep(int A,int B,int C){
+    LL tmp,D=1%C;
+    int temp;
+    for(int i=0,tmp=1%C;i<100;i++,tmp=((LL)tmp*A)%C)
+        if(tmp==B)
+            return i;
+    int d=0;
+    while((temp=gcd(A,C))!=1){
+        if(B%temp) return -1;
+        d++;
+        C/=temp;
+        B/=temp;
+        D=((A/temp)*D)%C;
+    }
+    int m=(int)ceil(sqrt((double)C));
+    for(int i=0,tmp=1%C;i<=m;i++,tmp=((LL)tmp*A)%C){
+        baby[i].idx=i;
+        baby[i].val=tmp;
+    }
+    sort(baby,baby+m+1,cmp);
+    int cnt=1;
+    for(int i=1;i<=m;i++)
+        if(baby[i].val!=baby[cnt-1].val)
+            baby[cnt++]=baby[i];
+    int am=PowMod(A,m,C);
+    for(int i=0;i<=m;i++,D=((LL)(D*am))%C){
+        int tmp=inval(D,B,C);
+        if(tmp>=0){
+            int pos=BinSearch(tmp,cnt);
+            if(pos!=-1)
+                return i*m+pos+d;
+        }
+    }
+    return -1;
+}
+int main(){
+    int A,B,C;
+    while(scanf("%d%d%d",&A,&C,&B)!=EOF){
+        if(B>=C){
+            puts("Orz,I cant find D!");
+            continue;
+        }
+        int ans=BabyStep(A,B,C);
+        if(ans==-1)
+            puts("Orz,I cant find D!");
+        else
+            printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/2816_autoAC.cpp b/HDOJ/2816_autoAC.cpp
new file mode 100644
index 0000000..4d1d66c
--- /dev/null
+++ b/HDOJ/2816_autoAC.cpp
@@ -0,0 +1,61 @@
+#include<iostream>
+#include<cstdlib>
+#include<cstdio>
+#include<string.h>
+#include<map>
+using namespace std;
+char s[1024];
+int rec[506],word[506];
+int main()
+{ 
+    map<int,char> mp;
+    mp[21]='K';
+    mp[22]='X';
+    mp[23]='V';
+    mp[31]='M';
+    mp[32]='C';
+    mp[33]='N';
+    mp[41]='O';
+    mp[42]='P';
+    mp[43]='H';
+    mp[51]='Q';
+    mp[52]='R';
+    mp[53]='S';
+    mp[61]='Z';
+    mp[62]='Y';
+    mp[63]='I';
+    mp[71]='J';
+    mp[72]='A';
+    mp[73]='D';
+    mp[74]='L';
+    mp[81]='E';
+    mp[82]='G';
+    mp[83]='W';
+    mp[91]='B';
+    mp[92]='U';
+    mp[93]='F';
+    mp[94]='T';
+    while(scanf("%s",s)!=EOF) {
+          int len = strlen(s),cnt = 0;
+          memset(rec,0,sizeof(rec));
+          for(int i = 0; i < len; i += 2,cnt++) {
+                  rec[cnt] = s[i] - '0';
+                  rec[cnt] = rec[cnt] * 10 + s[i+1] - '0';
+          }
+          int lim = (cnt-1)>>1;
+          for(int i = lim, j = cnt - 1, k = 0; i >= 0; --i,--j,k += 2) {
+                  if(cnt & 1) {
+                         word[k] = rec[i];
+                         word[k+1] = rec[j];
+                  }else {
+                        word[k] = rec[j];
+                        word[k+1] = rec[i];
+                  }
+          }
+          for(int i = 0; i < cnt; ++i) {
+                  printf("%c",mp[word[i]]);
+          }
+          puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/2817_autoAC.cpp b/HDOJ/2817_autoAC.cpp
new file mode 100644
index 0000000..518a3a2
--- /dev/null
+++ b/HDOJ/2817_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int M=200907;
+int main()
+{
+    __int64 a1,a2,a3,q;
+    int n,T;
+    __int64 ans;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%I64d%I64d%I64d%d",&a1,&a2,&a3,&n);
+        if(a2-a1==a3-a2)
+        {
+            q=a2-a1;
+            ans=(a1%M+(((n-1)%M)*(q%M))%M)%M;
+        }
+        else
+        {
+            q=(a2/a1)%M;
+            long long temp=1;
+            n--;
+            a1=a1%M;
+            while(n)
+            {
+                if(n&1)
+                {
+                    temp=temp*q;
+                    temp%=M;
+                }
+                q=(q*q)%M;
+                n/=2;
+            }
+            ans=(a1*temp)%M;
+        }
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/2818_autoAC.cpp b/HDOJ/2818_autoAC.cpp
new file mode 100644
index 0000000..ef0cf62
--- /dev/null
+++ b/HDOJ/2818_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<cstdio>
+#include<algorithm>
+#include<cmath>
+#include<string>
+#include<memory.h>
+#include<cstring>
+using namespace std;
+int father[30002],low[30002],high[30002];
+int find(int x)
+{
+    if(x==father[x])
+        return x;
+    int dx=find(father[x]);
+    low[x]+=low[father[x]];
+    return father[x]=dx;
+}
+void clear()
+{
+    for(int i=0;i<30002;i++)
+    {
+        father[i]=i;
+        high[i]=1;
+    }
+    memset(low,0,sizeof(low));
+}
+int main()
+{
+    char ch;
+    int a,b,n;
+    while(cin>>n)
+    {
+        getchar();
+        clear();
+        while(n--)
+        {
+            cin>>ch;
+            if(ch=='M')
+            {
+                scanf("%d %d%*c",&a,&b);
+                int x=find(a);
+                int y=find(b);
+                if(x==y)
+                    continue;
+                father[x]=y;
+                low[x]=high[y];
+                high[y]+=high[x];
+            }
+            if(ch=='C')
+            {
+                scanf("%d%*c",&a);
+                find(a);
+                cout<<low[a]<<endl;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2819_autoAC.cpp b/HDOJ/2819_autoAC.cpp
new file mode 100644
index 0000000..ced6fbf
--- /dev/null
+++ b/HDOJ/2819_autoAC.cpp
@@ -0,0 +1,67 @@
+#include <map>
+#include <set>
+#include <stack>
+#include <queue>
+#include <cmath>
+#include <ctime>
+#include <vector>
+#include <cstdio>
+#include <cctype>
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#define eps 1e-15
+#define MAXN 105
+#define INF 1000000007
+#define MAX(a,b) (a > b ? a : b)
+#define MIN(a,b) (a < b ? a : b)
+#define mem(a) memset(a,0,sizeof(a))
+bool G[MAXN][MAXN],vis[MAXN];
+int Left[MAXN],N,M,T,a[MAXN],b[MAXN];
+bool DFS(int u)
+{
+    for(int v=0;v<=N;v++) if(G[u][v] && !vis[v])
+    {
+        vis[v] = true;
+        if(!Left[v] || DFS(Left[v]))
+        {
+            Left[v] = u;
+            return true;
+        }
+    }
+    return false;
+}
+int main()
+{
+    while(~scanf("%d", &N))
+    {
+        mem(G); mem(Left);
+        int x,ans = 0;
+        for(int i=1;i<=N;i++) for(int j=1;j<=N;j++)
+        {
+            scanf("%d", &x);
+            if(x)G[i][j] = true;
+        }
+        for(int i=1;i<=N;i++)
+        {
+            mem(vis);
+            if(DFS(i)) ans ++;
+        }
+        if(ans < N){printf("-1\n");continue;}
+        int tot = 0,j;
+        for(int i=1;i<=N;i++)
+        {
+            for(j=1;j<=N && Left[j]!=i ;j++);
+            if(i != j)
+            {
+                a[tot] = i;  b[tot] = j; tot ++;
+                int t = Left[i]; Left[i] = Left[j]; Left[j] = t;
+            }
+        }
+        printf("%d\n",tot);
+        for(int i=0;i<tot;i++) printf("C %d %d\n", a[i],b[i]);
+    }
+    return 0;
+}
diff --git a/HDOJ/2820_autoAC.cpp b/HDOJ/2820_autoAC.cpp
new file mode 100644
index 0000000..a5f0db5
--- /dev/null
+++ b/HDOJ/2820_autoAC.cpp
@@ -0,0 +1,125 @@
+#include<cstdio>
+#include<cstring>
+#include<cstdlib>
+#include<cmath>
+#include<algorithm>
+#include<iostream>
+using namespace std;
+typedef long long LL;
+const LL PP=1000000007;
+const int P=10007;
+struct Node
+{
+    int len;
+    int va[12];
+};
+LL dp[2][110000];
+Node ST[2][110000];
+struct Edge{int ne,id;Node st;}e[110000];
+int p[P+10],mod[P+10],Hashnum;
+void Hashinit()
+{
+    memset(p,-1,sizeof(p));
+    memset(mod,0,sizeof(mod));
+    Hashnum=0;
+}
+int find(Node st,int re)
+{
+    if(mod[re])
+    {
+        for(int i=p[re];i!=-1;i=e[i].ne)
+        {
+            if(e[i].st.len!=st.len)continue;
+            for(int j=0;j<st.len;j++)
+            if(e[i].st.va[j]!=st.va[j])continue;
+            return e[i].id;
+        }
+    }
+    mod[re]=1;
+    e[Hashnum].st.len=st.len;
+    for(int i=0;i<st.len;i++)
+    e[Hashnum].st.va[i]=st.va[i];
+    e[Hashnum].id=Hashnum;e[Hashnum].ne=p[re];
+    p[re]=Hashnum++;
+    return Hashnum-1;
+}
+int num[120];
+void add(Node st,LL va,int id)
+{
+    int re=st.len;
+    for(int i=0;i<st.len;i++)
+    {
+        re*=12;
+        re+=st.va[i];
+        re%=P;
+    }
+    int tt=find(st,re);
+    if(tt+1>num[id])
+    {
+        ST[id][tt].len=st.len;
+        for(int i=0;i<st.len;i++)
+        ST[id][tt].va[i]=st.va[i];
+        num[id]=tt+1;
+    }
+    dp[id][tt]+=va;
+    dp[id][tt]%=PP;
+}
+int n,K,i,j,k,l,fl,te,po;
+int main()
+{
+    while(~scanf("%d%d",&n,&K))
+    {
+        if(K==0){puts("0");continue;}
+        num[0]=1;fl=0;num[1]=0;
+        ST[0][0].len=1;
+        ST[0][0].va[0]=1;
+        memset(dp,0,sizeof(dp));dp[0][0]=1;
+        for(i=2;i<=n;i++)
+        {
+            te=1-fl;
+            for(j=0;j<num[te];j++)
+            dp[te][j]=0;
+            num[te]=0;
+            Hashinit();
+            for(j=0;j<num[fl];j++)
+            {
+                Node ts=ST[fl][j];
+                for(k=0;k<=ts.len;k++)
+                {
+                    bool can=true;
+                    if(k!=0&&ts.va[k-1]==0)can=false;
+                    if(k!=ts.len&&ts.va[k]==0)can=false;
+                    if(!can)continue;
+                    Node tt;
+                    for(l=0;l<k;l++)
+                    {
+                        if(ts.va[l]!=0)tt.va[l]=(ts.va[l]+1)%(K+1);
+                        else tt.va[l]=0;
+                    }
+                    tt.va[k]=1;
+                    for(l=ts.len;l>k;l--)
+                    {
+                        if(ts.va[l-1]!=0)tt.va[l]=(ts.va[l-1]+1)%(K+1);
+                        else tt.va[l]=0;                        
+                    }
+                    tt.len=ts.len+1;po=1;
+                    for(l=1;l<=ts.len;l++)
+                    {
+                        if(tt.va[l]==0&tt.va[po-1]==0)continue;
+                        else tt.va[po++]=tt.va[l];
+                    }
+                    tt.len=po;
+                    add(tt,dp[fl][j],te);
+                }
+            }
+            fl=te;
+        }
+        LL ans=0;
+        for(i=0;i<num[fl];i++)
+        {
+            ans+=dp[fl][i];
+            ans%=PP;
+        }
+        cout<<ans<<endl;
+    }
+}
diff --git a/HDOJ/2821_autoAC.cpp b/HDOJ/2821_autoAC.cpp
new file mode 100644
index 0000000..75332fe
--- /dev/null
+++ b/HDOJ/2821_autoAC.cpp
@@ -0,0 +1,170 @@
+#include <cstdio>
+#include <iostream>
+#include <deque>
+#define M 28
+using namespace std;
+int n,m,res,found;
+int mp[M][M];
+deque<char>deq;
+void dfs(int y,int x){
+    if(res==0){
+        found=1;
+        return;
+    }
+    if(found)return;
+    int flag=0,i;
+    for(i=y-2;i>=0;i--)
+        if(mp[i][x]){
+            flag=1;
+            break;
+        }
+    if(y>0&&mp[y-1][x])flag=0;
+    if(flag){
+        int d=mp[i][x];
+        if(i==0){
+            res-=mp[i][x];
+            mp[i][x]=0;
+            deq.push_back('U');
+            dfs(i,x);if(found)return;
+            mp[i][x]=d;
+            deq.pop_back();
+            res+=mp[i][x];
+        }
+        else {
+            res--;
+            mp[i][x]=0;
+            deq.push_back('U');
+            mp[i-1][x]+=d-1;
+            dfs(i,x);if(found)return;
+            mp[i][x]=d;
+            mp[i-1][x]-=d-1;
+            deq.pop_back();
+            res++;
+        }
+    }
+    flag=0;
+    for(i=y+2;i<n;i++)
+        if(mp[i][x]){
+            flag=1;
+            break;
+        }
+    if(y<n-1&&mp[y+1][x])flag=0;
+    if(flag){
+        int d=mp[i][x];
+        if(i==n-1){
+            res-=mp[i][x];
+            mp[i][x]=0;
+            deq.push_back('D');
+            dfs(i,x);if(found)return;
+            mp[i][x]=d;
+            deq.pop_back();
+            res+=mp[i][x];
+        }
+        else {
+            res--;
+            mp[i][x]=0;
+            deq.push_back('D');
+            mp[i+1][x]+=d-1;
+            dfs(i,x);if(found)return;
+            mp[i][x]=d;
+            deq.pop_back();
+            mp[i+1][x]-=d-1;
+            res++;
+        }
+    }
+    flag=0;
+    for(i=x-2;i>=0;i--)
+        if(mp[y][i]){
+            flag=1;
+            break;
+        }
+    if(x>0&&mp[y][x-1])flag=0;
+    if(flag){
+        int d=mp[y][i];
+        if(i==0){
+            mp[y][i]=0;
+            deq.push_back('L');
+            res-=d;
+            dfs(y,i);if(found)return;
+            deq.pop_back();
+            res+=d;
+            mp[y][i]=d;
+        }
+        else {
+            mp[y][i]=0;
+            deq.push_back('L');
+            res--;
+            mp[y][i-1]+=d-1;
+            dfs(y,i);if(found)return;
+            deq.pop_back();
+            res++;
+            mp[y][i]=d;
+            mp[y][i-1]-=d-1;
+        }
+    }
+    flag=0;
+    for(i=x+2;i<m;i++)
+        if(mp[y][i]){
+            flag=1;
+            break;
+        }
+    if(x<m-1&&mp[y][x+1])flag=0;
+    if(flag){
+        int d=mp[y][i];
+        if(i==m-1){
+            mp[y][i]=0;
+            deq.push_back('R');
+            res-=d;
+            dfs(y,i);if(found)return;
+            deq.pop_back();
+            res+=d;
+            mp[y][i]=d;
+        }
+        else {
+            mp[y][i]=0;
+            deq.push_back('R');
+            res--;
+            mp[y][i+1]+=d-1;
+            dfs(y,i);if(found)return;
+            deq.pop_back();
+            res++;
+            mp[y][i]=d;
+            mp[y][i+1]-=d-1;
+        }
+    }
+}
+int main(void){
+    while(~scanf("%d%d",&m,&n)){
+        res=0;
+        char c;
+        for(int i=0;i<n;i++){
+            getchar();
+            for(int j=0;j<m;j++){
+                c=getchar();
+                if(c!='.'){
+                    mp[i][j]=(c-'a')+1;
+                    res+=(c-'a')+1;
+                }
+                else mp[i][j]=0;
+            }
+        }
+        found=0;
+        for(int i=0;i<n;i++){
+            for(int j=0;j<m;j++){
+                if(mp[i][j]!=0)continue;
+                dfs(i,j);
+                if(found){
+                    printf("%d\n%d\n",i,j);
+                    while(!deq.empty()){
+                        putchar(deq.front());
+                        deq.pop_front();
+                    }
+                    puts("");
+                    break;
+                }
+            }
+            if(found)break;
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2822_autoAC.cpp b/HDOJ/2822_autoAC.cpp
new file mode 100644
index 0000000..2633971
--- /dev/null
+++ b/HDOJ/2822_autoAC.cpp
@@ -0,0 +1,75 @@
+#include<stdio.h>
+#include<string.h>
+#include<queue>
+using namespace std;
+#define inf 999999999
+struct node
+{
+    int x,y,time;
+    friend bool operator<(node a,node b)
+    {
+        return a.time>b.time;
+    }
+};
+char map[1010][1010];
+int visit[1010][1010];
+int dir[4][2]={1,0,0,1,-1,0,0,-1};
+int n,m;
+int judge(int x,int y)
+{
+    if(x>=1&&x<=n&&y>=1&&y<=m)
+        return 1;
+    return 0;
+}
+int bfs(int sx,int sy,int dx,int dy)
+{
+    priority_queue<node>q;
+    node in,out;
+    int i;
+    visit[sx][sy]=0;
+    in.x=sx;
+    in.y=sy;
+    in.time=0;
+    q.push(in);
+    while(!q.empty())
+    {
+        in=q.top();
+        q.pop();
+        if(in.x==dx&&in.y==dy)
+            return in.time;
+        for(i=0;i<4;i++)
+        {
+            out.x=in.x+dir[i][0];
+            out.y=in.y+dir[i][1];
+            if(judge(out.x,out.y))
+            {
+                if(map[out.x][out.y]=='X')
+                    out.time=in.time;
+                else
+                    out.time=in.time+1;
+                if(visit[out.x][out.y]>out.time)
+                {
+                    visit[out.x][out.y]=out.time;
+                    q.push(out);
+                }
+            }
+        }
+    }
+    return 1;
+}
+int main()
+{
+    int x0,y0,x1,y1,i,j,ans;
+    while(scanf("%d%d",&n,&m),n+m)
+    {
+        for(i=1;i<=n;i++)
+            scanf("%s",map[i]+1);
+        for(i=1;i<=n;i++)
+            for(j=1;j<=m;j++)
+                visit[i][j]=inf;
+            scanf("%d%d%d%d",&x0,&y0,&x1,&y1);
+            ans=bfs(x0,y0,x1,y1);
+            printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/2823_autoAC.cpp b/HDOJ/2823_autoAC.cpp
new file mode 100644
index 0000000..9581331
--- /dev/null
+++ b/HDOJ/2823_autoAC.cpp
@@ -0,0 +1,274 @@
+#include<iostream>
+#include<cmath>
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+const int maxn = 50100;
+const double eps = 1e-8;
+const double pi = acos( -1.0 );
+const double inf = 1e100;
+#define _sign(x) ((x)>eps?1:((x<-eps)?2:0))
+int D( double x ) { return ( x < -eps ? -1 : x > eps ); }
+struct point {
+    double x, y;
+    point( double _x = 0, double _y = 0 ) : x( _x ), y( _y ) { }
+    void input( ) { scanf( "%lf%lf", &x, &y ); }
+    bool operator < (const point a)const 
+    {
+        if(y==a.y)
+            return x<a.x;
+        return y<a.y;
+    }
+};
+typedef struct line 
+{
+    point a,b;
+}Line;
+point operator + ( const point & a, const point & b ) {
+    return point( a.x + b.x, a.y + b.y );
+}
+point operator - ( const point & a, const point & b ) {
+    return point( a.x - b.x, a.y - b.y );
+}
+point operator * ( const point & a, const double scale ) {
+    return point( a.x * scale, a.y * scale );
+}
+point operator / ( const point & a, const double scale ) {
+    return point( a.x / scale, a.y / scale );
+}
+double operator ^ ( const point & a, const point & b ) {
+    return ( a.x * b.y - a.y * b.x );
+}
+double operator & ( const point & a, const point & b ) {
+    return ( a.x * b.x + a.y * b.y );
+}
+double dis2( const point & a, const point & b ) {
+    point p = a - b;
+    return ( p.x * p.x + p.y * p.y );
+}
+double dis( const point & a, const point & b ) {
+    return sqrt( dis2( a, b ) );
+}
+double displ( const point & a, const point & b, const point & p ) {
+    if( D( b - a & p - a ) > 0 && D( a - b & p - b ) > 0 ) {
+        return fabs( a - p ^ b - p ) / dis( a, b );
+    }
+    return min( dis( p, a ), dis( p, b ) );
+}
+double disll( const point & a, const point &b, const point &c, const point &d ) {
+    return min( min( displ( a, b, c ), displ( a, b, d ) ),
+        min( displ( c, d, a ), displ( c, d, b ) ) );
+}
+double det(double x1,double y1,double x2,double y2)        
+{ 
+    return x1*y2-x2*y1;
+}
+double cross (const point & a, const point &b, const point &c)        
+{
+    return det(b.x-a.x,b.y-a.y,c.x-a.x,c.y-a.y);
+}
+point a[maxn],np[maxn];
+struct poly {
+    int n;
+    point p[ maxn ];
+    void in( ) {
+        for( int i = 0; i < n; i++ ) {
+            p[ i ].x=np[i].x;
+            p[i].y=np[i].y;
+        }
+        if( get_area( ) < 0 ) {
+            reverse( p, p + n );
+        }
+    }
+    double get_area( ) const {
+        double area = 0;
+        for( int i = 0; i < n; i++ ) {
+            area += ( p[ i ] ^ p[ ( i + 1 ) % n ] );
+        }
+        return area;
+    }
+};
+void solve( const poly & g1, const poly & g2 ) {
+    int f[ 2 ] = { 0, 0 };
+    point p0, p1, p2, p3;
+    for( int i = 0; i < g1.n; i++ ) {
+        if( g1.p[ i ].y < g1.p[ f[ 0 ] ].y ) {
+            f[ 0 ] = i;
+        }
+    }
+    for( int i = 0; i < g2.n; i++ ) {
+        if( g2.p[ i ].y > g2.p[ f[ 1 ] ].y ) {
+            f[ 1 ] = i;
+        }
+    }
+    int cnt = 0;
+    double best = inf;
+    while( cnt < g1.n ) {
+        p0 = g1.p[ f[ 0 ] ], p1 = g1.p[ ( f[ 0 ] + 1 ) % g1.n ];
+        p2 = g2.p[ f[ 1 ] ], p3 = g2.p[ ( f[ 1 ] + 1 ) % g2.n ];
+        int tmp = D( p1 - p0 ^ p3 - p2 );
+        if( tmp == 0 ) {
+            cnt++;
+            f[ 0 ] = ( f[ 0 ] + 1 ) % g1.n;
+            f[ 1 ] = ( f[ 1 ] + 1 ) % g2.n;
+            best = min( best, disll( p0, p1, p2, p3 ) );
+        }
+        else if( tmp < 0 ) {
+            cnt++;
+            f[ 0 ] = ( f[ 0 ] + 1 ) % g1.n;
+            best = min( best, displ( p0, p1, p2 ) );
+        }
+        else {
+            f[ 1 ] = ( f[ 1 ] + 1 ) % g2.n;
+            best = min( best, displ( p2, p3, p0 ) );    
+        }
+    }
+    printf( "%.4lf\n", best );
+}
+int covex_hull(int n)
+{ 
+    int sz;
+    sort(a,a+n); 
+    np[0]=a[0]; 
+    np[1]=a[1]; 
+    sz=1; 
+    for(int i=2;i<n;i++) 
+    { 
+        while(sz>0 && cross(np[sz],a[i],np[sz-1])<=0){
+            sz--; }
+        np[++sz]=a[i];
+    } 
+    int temp=sz; 
+    for(int i=n-2;i>=0;i--) 
+    { 
+        while(sz>temp && cross(np[sz],a[i],np[sz-1])<=0) {
+            sz--; }
+        np[++sz]=a[i]; 
+    }
+    return sz;
+}
+bool pequal(const point & a,const point & b)
+{
+    if(D(a.x-b.x)==0&&D(a.y-b.y)==0)return 1;
+    else return 0;
+}
+int intersect(Line a,Line b)
+{
+    if(D(cross(a.a,b.a,a.b)*cross(a.a,a.b,b.b))>0)return 1;
+    else return 0;
+} 
+int dotsOnSeg(const point & p,Line l)
+{
+    if(pequal(l.a,l.b)){if(pequal(p,l.a))return 1 ;else return 0;}
+    if(D(cross(p,l.a,l.b))==0&&(l.a.x-p.x)*(l.b.x-p.x)<=eps&&(l.a.y-p.y)*(l.b.y-p.y)<=eps)return 1;
+    else return 0;
+}
+int intersectSegToSeg(Line a,Line b)
+{
+    if(dotsOnSeg(a.a,b)||dotsOnSeg(a.b,b)||dotsOnSeg(b.a,a)||dotsOnSeg(b.b,a))return 1;
+    if(intersect(a,b)&&intersect(b,a))return 1;
+    else return 0;
+}
+int inside_convex(const point &q,int n,const point *p)
+{
+    int i,s[3]={1,1,1};
+    for(i=0;i<n&&s[1]|s[2];i++)
+    {
+        s[_sign(cross(p[i],p[(i+1)%n],q))]=0;
+    }
+    return s[1]|s[2];
+}
+poly g1, g2;
+int convex_intersect()
+{
+    int flag=0;
+    Line l1,l2;
+    for(int i=1;i<=g1.n&&!flag;i++)
+    {
+        l1.a=g1.p[i-1];
+        l1.b=g1.p[i%g1.n];
+        for(int j=1;j<=g2.n;j++)
+        {
+            l2.a=g2.p[j-1];
+            l2.b=g2.p[j%g2.n];
+            if(intersectSegToSeg(l1,l2)){flag=1;break;}
+        }
+    }
+    for(int i=0;i<g1.n&&g2.n>=3;i++)
+    {
+        if(inside_convex(g1.p[i],g2.n,g2.p)){flag=1;break;}
+    }
+    if(!flag)for(int i=0;i<g2.n&&g1.n>=3;i++)
+    {
+        if(inside_convex(g2.p[i],g1.n,g1.p)){flag=1;break;}
+    }
+    return flag;
+}
+int main( ) {
+    int n,m;
+    while(cin>>n>>m){
+        for(int i=0;i<n;i++)
+        {
+            a[i].input();
+        }    
+        g1.n=covex_hull(n);
+        g1.in( );
+        for(int i=0;i<m;i++)
+        {
+            a[i].input();
+        }    
+        g2.n=covex_hull(m);
+        g2.in( );
+        if(g1.n==1&&g2.n==1)
+        {
+            double ans=dis(g2.p[0],g1.p[0]);
+            printf("%.4lf\n",ans);
+            continue ;
+        }
+        if(!convex_intersect()){    
+            if(g1.n==1&&g2.n>1)
+            {
+                double ans=inf;
+                for(int i=1;i<=g2.n;i++)
+                {
+                    ans=min(ans,displ(g2.p[i-1],g2.p[i%g2.n],g1.p[0]));
+                }
+                printf("%.4lf\n",ans);
+                continue ;
+            }
+            if(g2.n==1&&g1.n>1)
+            {
+                double ans=inf;
+                for(int i=1;i<=g1.n;i++)
+                {
+                    ans=min(ans,displ(g1.p[i-1],g1.p[i%g1.n],g2.p[0]));
+                }
+                printf("%.4lf\n",ans);
+                continue ;
+            }
+            if(g2.n==2&&g1.n>1)
+            {
+                double ans=inf;
+                for(int i=1;i<=g1.n;i++)
+                {
+                    ans=min(ans,disll(g1.p[i-1],g1.p[i%g1.n],g2.p[0],g2.p[1]));
+                }
+                printf("%.4lf\n",ans);
+                continue ;
+            }
+            if(g1.n==2&&g2.n>1)
+            {
+                double ans=inf;
+                for(int i=1;i<=g2.n;i++)
+                {
+                    ans=min(ans,disll(g2.p[i-1],g2.p[i%g1.n],g1.p[0],g1.p[1]));
+                }
+                printf("%.4lf\n",ans);
+                continue ;
+            }
+            solve( g1, g2 );
+        }
+        else printf("%.4lf\n",0);
+    }
+    return 0;
+}
diff --git a/HDOJ/2824_autoAC.cpp b/HDOJ/2824_autoAC.cpp
new file mode 100644
index 0000000..d3eea5a
--- /dev/null
+++ b/HDOJ/2824_autoAC.cpp
@@ -0,0 +1,25 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+const int MAX=3000004;
+long long e[MAX];
+void euler()
+{
+    e[1]=0;
+    for(int i=2;i<MAX;++i)
+        e[i]=i;
+    for(int i=2;i<MAX;++i)
+        if(e[i]==i)
+            for(int j=i;j<MAX;j+=i)
+                e[j]=e[j]/i*(i-1);
+    for(int i=2;i<MAX;++i)
+        e[i]+=e[i-1];
+}
+int main()
+{
+    euler();
+    int a,b;
+    while(cin>>a>>b)
+        cout<<e[b]-e[a-1]<<endl;
+    return 0;
+}
diff --git a/HDOJ/2825_autoAC.cpp b/HDOJ/2825_autoAC.cpp
new file mode 100644
index 0000000..e9cbcf8
--- /dev/null
+++ b/HDOJ/2825_autoAC.cpp
@@ -0,0 +1,118 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <queue>
+#include <vector>
+using namespace std;
+const int mod = 20090717;
+const int maxn = 103;
+const int max_num = 26;
+int idx[256];
+int n, m, x;
+int dp[26][103][1026];
+bool vis[26][103][1026];
+int cnt[1025];
+struct node {
+    int v, p, zt;
+    node(){}
+    node(int v, int p, int zt) : v(v), p(p), zt(zt){}
+}Q[1000006];
+struct AcAuto {
+    int val[maxn], f[maxn];
+    int ch[maxn][max_num], tot;
+    void init() {
+        tot = 0;
+        new_node();
+        int i;
+        for(i = 0; i < 26; i++)
+            idx['a'+i] = i;
+    }
+    inline int new_node() {
+        memset(ch[tot], 0, sizeof(ch[tot]));
+        val[tot] = 0;
+        f[tot] = 0;
+        return tot++;
+    }
+    void insert(char *s, int id) {
+        int i, j, p = 0;
+        for(;*s; s++) {
+            int k = idx[*s];
+            if(!ch[p][k]) ch[p][k] = new_node();
+            p = ch[p][k];
+        }
+        val[p] |= 1<<id;
+    }
+    void getfail() {
+        int i, j, p = 0;
+        int q[maxn];
+        int *s = q, *e = q;
+        for(i = 0; i < max_num; i++) if(ch[0][i]) *e++ = ch[0][i];
+        while(s != e) {
+            int u = *s++;
+            for(i = 0; i < max_num; i++) {
+                int &v = ch[u][i];
+                if(!v) { v = ch[f[u]][i]; continue; }
+                *e++ = v;
+                j = f[u];
+                while(j && !ch[j][i]) j = f[j];
+                f[v] = ch[j][i];
+                val[v] |= val[f[v]];
+            }
+        }
+    }
+    void solve() {
+        int i, j, k, u;
+        int M = (1<<m);
+        for(i = 0; i <= n; i++)
+            for(k = 0; k < tot; k++)
+                for(j = 0; j < M; j++)
+                    dp[i][k][j] = 0;
+        dp[0][0][0] = 1;
+        node *s = Q, *e = Q;
+        *e++ = node(0, 0, 0);
+        vis[0][0][0] = 1;
+        while(s != e) {
+            node u = *s++;
+            vis[u.v][u.p][u.zt] = 0;
+            if(u.v >= n) continue;
+            for(i = 0; i < max_num; i++) {
+                int p = ch[u.p][i];
+                node v = node(u.v+1, p, u.zt|val[p]);
+                dp[v.v][v.p][v.zt] += dp[u.v][u.p][u.zt];
+                if(dp[v.v][v.p][v.zt] >= mod) dp[v.v][v.p][v.zt] -= mod;
+                if(!vis[v.v][v.p][v.zt]) {
+                    vis[v.v][v.p][v.zt] = 1;
+                    *e++ = v;
+                }
+            }
+        }
+        int ans = 0;
+        for(i = 0; i < M; i++) {
+            if(cnt[i] >= x)
+            for(j = 0; j < tot; j++) {
+                ans += dp[n][j][i];
+                if(ans >= mod) ans -= mod;
+            }
+        }
+        printf("%d\n", ans);
+    }
+}AC;
+char str[13];
+int main() {
+    int i, j;
+    for(i = 0; i < 1024; i++) {
+        int c = 0;
+        for(j = i; j; j -= (j&-j)) c++;
+        cnt[i] = c;
+    }
+    while( ~scanf("%d%d%d", &n, &m, &x) && (n || m || x)) {
+        AC.init();
+        for(i = 0; i < m; i++) {
+            scanf("%s", str);
+            AC.insert(str, i);
+        }
+        AC.getfail();
+        AC.solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/2826_autoAC.cpp b/HDOJ/2826_autoAC.cpp
new file mode 100644
index 0000000..5202b6e
--- /dev/null
+++ b/HDOJ/2826_autoAC.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+#include <string>
+#include<algorithm>
+#include <cstdio>
+#include<cmath>
+using namespace std;
+const double eps = 1e-8;
+int dcmp(double x)
+{
+    if( fabs(x)<eps)
+        return 0;
+    return x < 0 ? -1:1;
+}
+struct pnode
+{
+    double x,y;
+    pnode(double x =0.0,double y=0.0):x(x),y(y){}
+    int pread()
+    {
+        return scanf("%lf %lf",&x,&y);
+    }
+    pnode operator - (const pnode &b)const{ return pnode(x-b.x,y-b.y);}
+    bool operator < (const pnode&b)const
+    {
+        return dcmp(x-b.x) <0 || (dcmp(x-b.x)== 0 && dcmp(y-b.y)<0);
+    }
+    double operator ^(const pnode&b)const
+    {
+        return x*b.y - y *b.x;
+    }
+};
+typedef pnode myvec;
+myvec a,b,c,d;
+pnode pa[305],pb[305];
+double cross( pnode p0,pnode p1,pnode p2)
+{
+    return (p1-p0) ^ (p2-p0);
+}
+double polygon_area(pnode*p,int n)
+{
+    double area = 0.0;
+    for( int i = 1;i < n-1 ;++i )
+        area += cross( p[0], p[i], p[i+1]);
+    return area*0.5;
+}
+double dot(myvec v)
+{
+    return v.x*v.x + v.y *v.y;
+}
+void getpnode(int n,pnode *p,myvec &v,myvec &w)
+{
+    p[0].pread();
+    p[1].pread();
+    myvec tmp = p[1] - p[0];
+    v = w = tmp;
+    for( int i = 2; i < n ;++i )
+    {
+        p[i].pread();
+        v = p[i] - p[i-1];
+        if( dcmp(dot(tmp)-dot(v))<0 )
+            v = tmp;
+        if( dcmp( dot(tmp)-dot(v)) > 0 )
+            w = tmp;
+    }
+    tmp = p[n-1] - p[0];
+    if( dcmp(dot(tmp)-dot(v))<0 )
+            v = tmp;//v 涓哄澶杈瑰舰杈
+    if( dcmp( dot(tmp)-dot(v)) > 0 )
+            w = tmp;
+}
+int main()
+{
+    int n;
+    while( ~scanf("%d\n",&n))
+    {
+        getpnode(n,pa,a,c);
+        getpnode(n,pb,b,d);
+        double aarea =  polygon_area(pa,n);
+        double barea =  polygon_area(pb,n);
+        double k1 = sqrt(dot(a))/sqrt(dot(b));
+        double k2 = sqrt( dot(c)) /sqrt(dot(d));
+        if( dcmp(aarea - barea*k1*k1)==0 && dcmp(aarea - barea *k2*k2)==0 && dcmp(k1-k2)==0)
+            puts("Yes");
+        else
+            puts("No");
+    }
+    return 0;
+}
diff --git a/HDOJ/2827_autoAC.cpp b/HDOJ/2827_autoAC.cpp
new file mode 100644
index 0000000..e16597b
--- /dev/null
+++ b/HDOJ/2827_autoAC.cpp
@@ -0,0 +1,140 @@
+#include<cstdio>
+#include<iostream>
+#include<algorithm>
+#include<cstring>
+#include<string>
+#define LL long long
+using namespace std;
+ LL n,m,A[105][105],p[10000],pos,d[105],r[105],len,B[105][105];
+ bool vd[10005]={0};
+ void prime()
+{
+    pos=0;
+    for(int i=2;i<10005;i++)
+    {
+        if(!vd[i])
+        {
+           if(i>1000) p[pos++]=i;
+            for(int j=(i<<1);j<10005;j+=i)
+                vd[i]=1;
+        }
+    }
+}
+void deal(LL k)
+{
+    len=0;
+    for(int i=0;i<pos&&k!=1;i++)
+    {
+        if(k%p[i]==0)
+        {
+            while(k%p[i]==0)
+            {
+                d[len++]=p[i];
+                k/=p[i];
+            }
+        }
+    }
+}
+LL exp(LL a,LL b,LL mod)
+{
+    LL ans=1;
+    while(b)
+    {
+        if(b&1)ans=ans*a%mod;
+        a=a*a%mod;b>>=1;
+    }
+    return ans;
+}
+void ex_gcd(LL a,LL b,LL &dd,LL &x,LL &y)
+{
+    if(b==0)
+        x=1,y=0,dd=a;
+    else
+    {
+        ex_gcd(b,a%b,dd,y,x);
+        y-=x*(a/b);
+    }
+}
+LL gauss(LL mod)
+{
+    bool flag=0;
+    LL ans=1;
+    for(int i=0;i<n;i++)
+        for(int j=0;j<n;j++)
+            B[i][j]=A[i][j];
+    for(int k=0;k<n-1;k++)
+    {
+        LL max_b=B[k][k];int bin=k;
+        for(int i=k+1;i<n;i++)
+            if(B[i][k]>max_b)
+                max_b=B[i][k],bin=i;
+        if(bin!=k)
+        {
+            for(int i=k;i<n;i++)
+                swap(B[bin][i],B[k][i]);
+            flag^=1;
+        }
+        if(B[k][k]<0)B[k][k]+=mod;
+        LL Ni,y,dd;
+        ex_gcd(B[k][k],mod,dd,Ni,y);
+        Ni%=mod;
+        if(Ni<0)Ni+=mod;
+        for(int j=k+1;j<n;j++)
+        {
+            B[k][j]=B[k][j]*Ni%mod;
+            if(B[k][j]<0)B[k][j]+=mod;
+            for(int i=k+1;i<n;i++)
+            {
+                B[i][j]=(B[i][j]-(B[k][j]*B[i][k])%mod)%mod;
+                if(B[i][j]<0)B[i][j]+=mod;
+            }
+        }
+        ans*=B[k][k];
+        ans%=mod;
+        if(ans<0)ans+=mod;
+    }
+    ans*=B[n-1][n-1];
+    ans%=mod;
+    if(flag)ans=-ans;
+    if(ans<0)ans+=mod;
+    return ans;
+}
+LL china_remain()
+{
+    LL a,b,c,c1,c2,x,y,dd,N;
+    a=d[0],c1=r[0];
+    if(c1==0)c1=d[0];
+    for(int i=1;i<len;i++)
+    {
+        b=d[i],c2=r[i];
+        ex_gcd(a,b,dd,x,y);
+        c=c2-c1;
+        LL b1=b/dd;
+        x=((c/dd*x)%b1+b1)%b1;
+        c1=a*x+c1;
+        a=a*b1;
+    }
+    return c1%m;
+}
+int main()
+{
+    prime();
+    while(cin>>n>>m)
+    {
+        deal(m);
+        for(int i=0;i<n;i++)
+            for(int j=0;j<n;j++)
+                cin>>A[i][j];
+        if(m==1)
+        {
+            cout<<0<<endl;
+            continue;
+        }
+        for(int i=0;i<len;i++)
+        {
+            r[i]=gauss(d[i]);
+        }
+        cout<<china_remain()<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/2828_autoAC.cpp b/HDOJ/2828_autoAC.cpp
new file mode 100644
index 0000000..ce94083
--- /dev/null
+++ b/HDOJ/2828_autoAC.cpp
@@ -0,0 +1,126 @@
+#include <iostream>
+#include <cstring>
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+const int maxn=1010,maxm=510;
+const int maxnode=maxn*maxm;
+const int INF=0x3f3f3f3f;
+int n,m;
+bool flag;
+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 ansd,ans[maxn];
+    int LAMP[maxn];
+    bool vis[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++)
+        {
+            vis[i]=false;
+            LAMP[i]=0;
+            H[i]=-1;
+        }
+        flag=false;
+    }
+    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;
+    }
+    void Dance(int d)
+    {
+        if(flag) return ;
+        if(R[0]==0)
+        {
+            for(int i=0;i<d;i++)
+            {
+               int lamp=(ans[i]+1)/2;
+               if(ans[i]%2) LAMP[lamp]=1;
+            }
+            for(int i=1;i<=n/2;i++)
+            {
+                if(LAMP[i]==1) printf("ON");
+                else printf("OFF");
+                if(i!=n/2) putchar(32); else putchar(10);
+            }
+            flag=true;
+            return ;
+        }
+        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])
+        {
+            if(vis[Row[i]]) continue;
+            int r1=Row[i],r2=Row[i];
+            if(r1%2==0) r2--;else r2++;
+            vis[r1]=true; vis[r2]=true;
+            remove(i);
+            for(int j=R[i];j!=i;j=R[j]) remove(j);
+            ans[d]=Row[i];
+            Dance(d+1);
+            for(int j=L[i];j!=i;j=L[j]) resume(j);
+            resume(i);
+            vis[r1]=false; vis[r2]=false;
+        }
+    }
+};
+DLX dlx;
+int main()
+{
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        dlx.init(2*m,n);
+        for(int i=1;i<=n;i++)
+        {
+            int k;
+            scanf("%d",&k);
+            for(int j=0;j<k;j++)
+            {
+                int p; char sw[20];
+                scanf("%d%s",&p,sw);
+                if(sw[1]=='N') dlx.Link(2*p-1,i);
+                else if(sw[1]=='F') dlx.Link(2*p,i);
+            }
+        }
+        dlx.Dance(0);
+        if(flag==false) puts("-1");
+    }
+    return 0;
+}
diff --git a/HDOJ/2829_autoAC.cpp b/HDOJ/2829_autoAC.cpp
new file mode 100644
index 0000000..da384c5
--- /dev/null
+++ b/HDOJ/2829_autoAC.cpp
@@ -0,0 +1,75 @@
+#include<stdio.h>
+#include<iostream>
+#include<string.h>
+#include<algorithm>
+using namespace std;
+const int MAXN=1010;
+int a[MAXN];
+int sum[MAXN];
+int cost[MAXN];
+int q[MAXN];
+int head,tail;
+int n,m;
+int dp[MAXN][MAXN];
+int DP()
+{
+    for(int i=1;i<=n;i++)
+    {
+        dp[i][0]=cost[i];
+        dp[i][i-1]=0;
+    }
+    for(int j=1;j<=m;j++)
+    {
+        head=tail=0;
+        q[tail++]=j;
+        for(int i=j+1;i<=n;i++)
+        {
+            while(head+1<tail)
+            {
+                int p1=q[head];
+                int p2=q[head+1];
+                int x1=sum[p1];
+                int x2=sum[p2];
+                int y1=dp[p1][j-1]-cost[p1]+sum[p1]*sum[p1];
+                int y2=dp[p2][j-1]-cost[p2]+sum[p2]*sum[p2];
+                if((y2-y1)<=sum[i]*(x2-x1)) head++;
+                else break;
+            }
+            int k=q[head];
+            dp[i][j]=dp[k][j-1]+cost[i]-cost[k]-sum[k]*sum[i]+sum[k]*sum[k];
+            while(head+1<tail)
+            {
+                int p1=q[tail-2];
+                int p2=q[tail-1];
+                int p3=i;
+                int x1=sum[p1];
+                int x2=sum[p2];
+                int x3=sum[p3];
+                int y1=dp[p1][j-1]-cost[p1]+sum[p1]*sum[p1];
+                int y2=dp[p2][j-1]-cost[p2]+sum[p2]*sum[p2];
+                int y3=dp[p3][j-1]-cost[p3]+sum[p3]*sum[p3];
+                if((y2-y1)*(x3-x2)>=(y3-y2)*(x2-x1))tail--;
+                else break;
+            }
+            q[tail++]=i;
+        }
+    }
+    return dp[n][m];
+}
+int main()
+{
+    while(scanf("%d%d",&n,&m)==2)
+    {
+        if(n==0&&m==0)break;
+        sum[0]=0;
+        cost[0]=0;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&a[i]);
+            sum[i]=sum[i-1]+a[i];
+            cost[i]=cost[i-1]+sum[i-1]*a[i];
+        }
+        printf("%d\n",DP());
+    }
+    return 0;
+}
diff --git a/HDOJ/2830_autoAC.cpp b/HDOJ/2830_autoAC.cpp
new file mode 100644
index 0000000..7f7ad42
--- /dev/null
+++ b/HDOJ/2830_autoAC.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+using namespace std;
+const int size = 1010;
+char str[size];
+int h[size];
+int cnt[size];
+int main()
+{
+    cin.sync_with_stdio(false);
+    int n , m , ans , sum , maxH , area;
+    while( cin >> n >> m )
+    {
+        memset( cnt , 0 , sizeof(cnt) );
+        memset( h , 0 , sizeof(h) );
+        ans = 0;
+        for( int i = 1 ; i<=n ; i++ )
+        {
+            maxH = sum = 0;
+            cin >> str;
+            for( int j = 0 ; str[j]!='\0' ; j++ )
+            {
+                if( str[j]=='1' )
+                    h[j+1] ++;
+                else
+                    h[j+1] = 0;
+                cnt[ h[j+1] ] ++;
+                if( maxH < h[j+1] )
+                    maxH = h[j+1];            
+            }
+            for( int k = 0 ; k<=maxH ; k++ )
+            {
+                if( cnt[k]!=0 )
+                {
+                    area = k * (m-sum);
+                    sum += cnt[k];
+                    if( area>ans )
+                        ans = area;
+                }
+                cnt[k] = 0;
+            }
+        }
+        cout << ans << endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/2831_autoAC.cpp b/HDOJ/2831_autoAC.cpp
new file mode 100644
index 0000000..fb08708
--- /dev/null
+++ b/HDOJ/2831_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#define N 111
+int n,need;
+int V[N],D[N];
+int match[N],visit[N];
+struct Eage{
+    int to,next;
+}eage[N*N];
+int tot,head[N];
+void add(int a,int b){
+    eage[tot].to=b;eage[tot].next=head[a];head[a]=tot++;
+}
+int dfs(int k)
+{
+    int j,v;
+    for(j=head[k];j!=-1;j=eage[j].next)
+    {
+        v=eage[j].to;
+        if(visit[v])    continue;
+        visit[v]=1;
+        if(k*need+D[v]>V[v])    continue;
+        if(match[v]==-1 || dfs(match[v]))
+        {
+            match[v]=k;
+            return 1;
+        }
+    }
+    return 0;
+}
+int main()
+{
+    int i,l;
+    int flag;
+    while(scanf("%d%d",&n,&need)!=-1)
+    {
+        for(i=1;i<=n;i++)    scanf("%d%d",&V[i],&D[i]);
+        tot=0;
+        memset(head,-1,sizeof(head));
+        for(i=1;i<=n;i++)for(l=1;l<=n;l++)
+            add(i,l);
+        flag=0;
+        memset(match,-1,sizeof(match));
+        for(i=1;i<=n;i++)
+        {
+            memset(visit,0,sizeof(visit));
+            if(!dfs(i))    {flag=1;break;}
+        }
+        if(flag)    {printf("The zombies eat your brains!\n");continue;}
+        for(i=1;i<=n;i++)    if(match[i]==1)    {printf("%d",i);break;}
+        for(i=2;i<=n;i++)
+        for(l=1;l<=n;l++)
+            if(match[l]==i)    {printf(" %d",l);break;}
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/2832_autoAC.cpp b/HDOJ/2832_autoAC.cpp
new file mode 100644
index 0000000..8d951ab
--- /dev/null
+++ b/HDOJ/2832_autoAC.cpp
@@ -0,0 +1,35 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<math.h>
+#define N 111
+int ans[N];
+void init()
+{
+    ans[5]=272400600;
+    ans[6]=9717617;
+    ans[7]=898515;
+    int k,q;
+    double t,temp;
+    for(k=8;k<=100;k++)
+    {
+        t=0;
+        temp=1;
+        q=0;
+        while(t<100)
+        {
+            t+=k/temp;
+            temp++;
+            q++;
+        }
+        ans[k]=q;
+    }
+}
+int main()
+{
+    init();
+    int k;
+    while(scanf("%d",&k)!=-1)
+        printf("%d\n",ans[k]);
+    return 0;
+}
diff --git a/HDOJ/2833_autoAC.cpp b/HDOJ/2833_autoAC.cpp
new file mode 100644
index 0000000..4e4f773
--- /dev/null
+++ b/HDOJ/2833_autoAC.cpp
@@ -0,0 +1,65 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#define N 311
+int num[N][N];
+int len[N][N];
+int main()
+{
+    int n,m;
+    int i,l,k,t;
+    int s,e,dis;
+    int a,b,c,d;
+    while(scanf("%d%d",&n,&m),n||m)
+    {
+        memset(num,0,sizeof(num));
+        for(i=1;i<=n;i++)
+        {
+            for(l=1;l<=n;l++)
+            {
+                if(i==l)    len[i][l]=0;
+                else        len[i][l]=22222222;
+            }
+        }
+        for(i=0;i<m;i++)
+        {
+            scanf("%d%d%d",&s,&e,&dis);
+            if(len[s][e]<dis)    continue;
+            len[s][e]=len[e][s]=dis;
+            num[s][e]=num[e][s]=1;
+        }
+        for(k=1;k<=n;k++)
+        {
+            for(i=1;i<=n;i++)
+            {
+                for(l=1;l<=n;l++)
+                {
+                    t=len[i][k]+len[k][l];
+                    if(t>len[i][l])    continue;
+                    if(t<len[i][l])
+                    {
+                        len[i][l]=t;
+                        num[i][l]=num[i][k]+num[k][l];
+                    }
+                    else if(num[i][k]+num[k][l]>num[i][l])
+                        num[i][l]=num[i][k]+num[k][l];
+                }
+            }
+        }
+        scanf("%d%d%d%d",&a,&b,&c,&d);
+        int ans=-1;
+        for(i=1;i<=n;i++)
+        {
+            for(l=1;l<=n;l++)
+            {
+                if(num[i][l]>ans
+                    && (len[a][b]==len[a][i]+len[i][l]+len[l][b])
+                    && (len[c][d]==len[c][i]+len[i][l]+len[l][d])
+                    )
+                    ans=num[i][l];
+            }
+        }
+        printf("%d\n",ans+1);
+    }
+    return 0;
+}
diff --git a/HDOJ/2834_autoAC.cpp b/HDOJ/2834_autoAC.cpp
new file mode 100644
index 0000000..906b1b2
--- /dev/null
+++ b/HDOJ/2834_autoAC.cpp
@@ -0,0 +1,99 @@
+#include <stdio.h>
+#include <string.h>
+#define For(i, n) for(i=0; i<(n); i++)
+const int N = 64;
+double P[N][N];
+double A[N][N];
+int out[N];
+int t;
+double s[N];
+int n, m;
+double dp[N][N];
+double dpx[N][N];
+int pre[N][N];
+int ppt[N];
+void read()
+{
+ int i, j;
+ For(i, n)
+ scanf("%lf", &s[i]);
+ For(i, n)
+ For(j, n)
+ scanf("%lf", &P[i][j]);
+ For(i, n)
+ For(j, m)
+ scanf("%lf", &A[i][j]);
+ For(i, n)
+ {
+ s[i] /= 100;
+ For(j, n)
+ P[i][j] /= 100, A[i][j] /= 100;
+ }
+ scanf("%d", &t);
+ For(i, t)
+ scanf("%d", &out[i]);
+ For(i, t)
+ out[i] -= 1;
+}
+void doit()
+{
+ memset(dpx, 0, sizeof(dpx));
+ int i, j, k;
+ double tmp;
+ For(j, n)
+ {
+ dp[0][j] = s[j];
+ dpx[0][j] = dp[0][j] * A[j][out[0]];
+ }
+ for (i = 1; i < t; i++)
+ {
+ For(j, n)
+ {
+ For(k, n)
+ {
+ tmp = dpx[i - 1][k] * P[k][j] * A[j][out[i]];
+ if (tmp > dpx[i][j])
+ {
+ dpx[i][j] = tmp;
+ dp[i][j] = dp[i - 1][k] * P[k][j];
+ pre[i][j] = k;
+ }
+ }
+ }
+ }
+}
+void pt()
+{
+ int i;
+ int tmp;
+ double mx = 0;
+ For(i, n)
+ if (dpx[t - 1][i] > mx)
+ {
+ mx = dpx[t - 1][i];
+ tmp = i;
+ }
+ ppt[t - 1] = tmp;
+ for (i = n-1; i > 0; i--)
+ {
+ ppt[i - 1] = pre[i][tmp];
+ tmp = ppt[i - 1];
+ }
+ For(i, t)
+ {
+ if (i)
+ putchar(' ');
+ printf("%d", ppt[i] + 1);
+ }
+ puts("");
+}
+int main()
+{
+ while (2 == scanf("%d %d", &n, &m))
+ {
+ read();
+ doit();
+ pt();
+ }
+ return 0;
+}
diff --git a/HDOJ/2835_autoAC.cpp b/HDOJ/2835_autoAC.cpp
new file mode 100644
index 0000000..523d359
--- /dev/null
+++ b/HDOJ/2835_autoAC.cpp
@@ -0,0 +1,68 @@
+#include <iostream>
+#include <stdio.h>
+#include <algorithm>
+#include <math.h>
+#include <string.h>
+#include <set>
+#include <queue>
+using namespace std;
+typedef struct abcd
+{
+    int p,last;
+} abcd;
+abcd a[110000];
+int flag[110000];
+int main()
+{
+    int c,n,b,i,j,now,ans;
+    while(~scanf("%d%d%d",&c,&n,&b))
+    {
+        for(i=0; i<n; i++)flag[i]=110000;
+        for(i=0; i<b; i++)
+            scanf("%d",&a[i].p);
+        for(i=b-1; i>=0; i--)
+        {
+            a[i].last=flag[a[i].p];
+            flag[a[i].p]=i;
+        }
+        ans=now=0;
+        memset(flag,0,sizeof(flag));
+        priority_queue<pair<int,int> > q;
+        while(!q.empty())q.pop();
+        for(i=0; i<b; i++)
+        {
+            if(now<c)
+            {
+                if(flag[a[i].p])
+                {
+                    q.push(make_pair(a[i].last,a[i].p));
+                }
+                else
+                {
+                    flag[a[i].p]=1;
+                    now++;
+                    ans++;
+                    q.push(make_pair(a[i].last,a[i].p));
+                }
+            }
+            else
+            {
+                if(flag[a[i].p])
+                {
+                    q.push(make_pair(a[i].last,a[i].p));
+                }
+                else
+                {
+                    ans++;
+                    while(flag[q.top().second]==0)q.pop();
+                    pair<int,int >t=q.top();
+                    q.pop();
+                    flag[a[i].p]=1;
+                    flag[t.second]=0;
+                    q.push(make_pair(a[i].last,a[i].p));
+                }
+            }
+        }
+        cout<<ans<<endl;
+    }
+}
diff --git a/HDOJ/2836_autoAC.cpp b/HDOJ/2836_autoAC.cpp
new file mode 100644
index 0000000..f042b6a
--- /dev/null
+++ b/HDOJ/2836_autoAC.cpp
@@ -0,0 +1,94 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+const int N=100111;
+const int Limit=9901;
+int n,h;
+int high[N],index[N],lowbit[N];
+int C[N];
+struct node{
+    int index,high;
+}E[N];
+int cmp(const void *a,const void *b)
+{
+    node *c,*d;
+    c=(node *)a;
+    d=(node *)b;
+    return c->high-d->high;
+}
+void update(int k,int dir)
+{
+    while(0<k && k<=n)
+    {
+        C[k]+=dir;
+        C[k]%=Limit;
+        k+=lowbit[k];
+    }
+}
+int sum(int k)
+{
+    int p=0;
+    while(0<k && k<=n)
+    {
+        p+=C[k];
+        p%=Limit;
+        k-=lowbit[k];
+    }
+    return p;
+}
+int solve()
+{
+    int i;
+    int low,mid,up;
+    int a,b,c,temp,x,z;
+    int ans;
+    memset(C,0,sizeof(C));
+    E[0].high=-1111;
+    qsort(E,n+1,sizeof(node),cmp);
+    for(i=1;i<=n;i++)    index[E[i].index]=i;
+    for(i=1;i<=n;i++)
+    {
+        temp=high[i]-h;
+        low=1;up=n;
+        while(low<=up)
+        {
+            mid=(low+up)>>1;
+            if(E[mid].high<temp)    low=mid+1;
+            else                    up=mid-1;
+        }
+        a=low;
+        b=index[i];
+        temp=high[i]+h;
+        low=1;up=n;
+        while(low<=up)
+        {
+            mid=(low+up)>>1;
+            if(E[mid].high<=temp)    low=mid+1;
+            else                    up=mid-1;
+        }
+        c=low-1;
+        if(a-1<=0)    x=0;
+        else        x=sum(a-1);
+        z=sum(c);
+        update(b,z-x+1);
+    }
+    ans=sum(n)-n;
+    while(ans<0)    ans+=9901;
+    return ans;
+}
+int main()
+{ 
+    int i;
+    for(i=1;i<=100000;i++)    lowbit[i]=i&(-i);
+    while(scanf("%d%d",&n,&h)!=-1)
+    {
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d",&high[i]);
+            E[i].index=i;
+            E[i].high=high[i];
+        }
+        printf("%d\n",solve());
+    }
+    return 0;
+}
diff --git a/HDOJ/2837_autoAC.cpp b/HDOJ/2837_autoAC.cpp
new file mode 100644
index 0000000..1902def
--- /dev/null
+++ b/HDOJ/2837_autoAC.cpp
@@ -0,0 +1,51 @@
+#include <cstdio>
+using namespace std;
+typedef long long LL;
+LL phi(LL x)
+{
+    LL ans=x;
+    for(LL i=2;i*i<=x;i++)
+        if(x%i==0){
+            ans=ans/i*(i-1);
+            while(x%i==0) x/=i;
+        }
+    if(x>1)
+        ans=ans/x*(x-1);
+    return ans;
+}
+LL pow_mod(LL a,LL p,LL mod)
+{
+    LL ans=1;
+    while(p)
+    {
+        if(p&1)
+        {
+            ans=ans*a;
+            if(ans>mod)
+                ans=ans%mod+mod;
+        }
+        a=a*a;
+        if(a>mod)
+            a=a%mod+mod;
+        p>>=1;
+    }
+    return ans;
+}
+LL f(LL n,LL m)
+{
+    if(n<10) return n;
+    LL p=f(n/10,phi(m));
+    return pow_mod(n%10,p,m);
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        LL n,m;
+        scanf("%I64d%I64d",&n,&m);
+        printf("%I64d\n",f(n,m)%m);
+    }
+    return 0;
+}
diff --git a/HDOJ/2838_autoAC.cpp b/HDOJ/2838_autoAC.cpp
new file mode 100644
index 0000000..8018ce6
--- /dev/null
+++ b/HDOJ/2838_autoAC.cpp
@@ -0,0 +1,57 @@
+#include<iostream>
+#include<string.h>
+using namespace std;
+__int64 a[100005],c[100005],d[100005],n;
+int lowbit(int x)
+{
+    return x&(-x);
+}
+__int64 sumc(int x)
+{
+    __int64 s=0;
+    while(x>0)
+    {
+        s+=c[x];
+        x-=lowbit(x);
+    }
+    return s;
+}
+__int64 sumd(int x)
+{
+    __int64 s=0;
+    while(x>0)
+    {
+        s+=d[x];
+        x-=lowbit(x);
+    }
+    return s;
+}
+void updata(int i,int j)
+{
+    while(i<=n)
+    {
+        c[i]+=1;
+        d[i]+=j;
+        i+=lowbit(i);
+    }
+}
+int main()
+{
+    while(scanf("%I64d",&n)>0)
+    {
+        memset(a,0,sizeof(a));
+        memset(c,0,sizeof(c));
+        memset(d,0,sizeof(d));
+        __int64 s=0,count=0;
+        for(int i=1;i<=n;i++)
+        {
+            scanf("%d",&a[i]);
+            updata(a[i],a[i]);
+            count+=a[i];
+            s+=(i-sumc(a[i]))*a[i];
+            s+=count-sumd(a[i]);
+        }
+        printf("%I64d\n",s);
+    }
+    return 0;
+}
diff --git a/HDOJ/2840_autoAC.cpp b/HDOJ/2840_autoAC.cpp
new file mode 100644
index 0000000..ef59f48
--- /dev/null
+++ b/HDOJ/2840_autoAC.cpp
@@ -0,0 +1,64 @@
+#include<iostream>
+#include<cstdio>
+#include<list>
+#include<algorithm>
+#include<cstring>
+#include<string>
+#include<stack>
+#include<map>
+#include<vector>
+#include<cmath>
+#include<memory.h>
+#include<set>
+#include<cctype>
+#define ll long long
+#define LL __int64
+#define eps 1e-8
+#define inf 0xfffffff
+using namespace std;
+typedef struct Node {
+    char s[2000 + 10];
+};
+Node sasd[2000 + 10];
+int b,n;
+int num[2000 + 10];
+int tot;
+void clear() {
+    memset(num,0,sizeof(num));
+    tot = 0;
+}
+void dfs(int pos,int e) {
+    if(pos == n) {
+        if(n != 1 && num[pos - 1] == 0)return;
+        for(int i=pos - 1;i>=0;i--) {
+            if(num[i] >= 10)
+                sasd[tot].s[n - i - 1] = 'A' + num[i] - 10;
+            else 
+                sasd[tot].s[n - i - 1] = '0' + num[i];
+        }
+        sasd[tot++].s[n] = 0;
+        return;
+    }
+    for(int i=0;i<b;i++) {
+        num[pos] = i;
+        int ans = 0;
+        for(int j=0;j<=pos;j++)
+            ans += num[j] * num[pos - j];
+        if((ans + e)%b == i)
+            dfs(pos + 1,(ans + e)/b);
+    }
+}
+bool cmp(Node x,Node y) {
+    return strcmp(x.s,y.s) < 0;
+}
+int main() {
+    while(scanf("%d %d",&b,&n) == 2) {
+        clear();
+        dfs(0,0);
+        sort(sasd,sasd + tot,cmp);
+        printf("%d\n",tot);
+        for(int i=0;i<tot;i++)
+            printf("%s\n",sasd[i].s);
+    }
+    return 0;
+}
diff --git a/HDOJ/2841_autoAC.cpp b/HDOJ/2841_autoAC.cpp
new file mode 100644
index 0000000..f57b56a
--- /dev/null
+++ b/HDOJ/2841_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<vector>
+#include<string>
+#include<algorithm>
+#include<queue>
+#define LL long long
+#define eps 1e-7
+using namespace std;
+int prime[100005][20];
+int cnt[100005]={0};
+void Init(){
+    for(int i=2;i<=100000;i++){
+        if(cnt[i]) continue;
+        prime[i][0]=i;
+        cnt[i]=1;
+        for(int j=2;j*i<=100000;j++)
+            prime[i*j][cnt[i*j]++]=i;
+    }
+}
+LL dfs(int m,int n,int idx){
+    LL ret=0;
+    for(int i=idx;i<cnt[m];i++)
+        ret+=n/prime[m][i]-dfs(m,n/prime[m][i],i+1);
+    return ret;
+}
+int main(){
+    Init();
+    int t,n,m;
+    scanf("%d",&t);
+    while(t--){
+        scanf("%d%d",&n,&m);
+        LL ans=n;
+        for(int i=2;i<=m;i++)
+            ans+=n-dfs(i,n,0);
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/2842_autoAC.cpp b/HDOJ/2842_autoAC.cpp
new file mode 100644
index 0000000..c783dfe
--- /dev/null
+++ b/HDOJ/2842_autoAC.cpp
@@ -0,0 +1,78 @@
+#include <iostream>
+#include <string.h>
+using namespace std;
+#define  N 3
+#define ll __int64
+#define MOD 200907
+struct Mat 
+{
+    ll martix[N][N];
+};
+Mat res,q,tp,tp1,tp2,tp3;
+void er_fun(int x)   
+{   
+    int i,j,k,flag=0;   
+    tp1=q;   
+    tp=res;   
+    while (x)   
+    {   
+        if(x&1)   
+        {   
+            flag=1;   
+            memset(tp2.martix,0,sizeof(tp2.martix));   
+            for (i=0;i<N;i++)   
+            {   
+                for (j=0;j<N;j++)   
+                {   
+                    for(k=0;k<N;k++)   
+                    {   
+                        tp2.martix[i][j]+=(tp.martix[i][k]*tp1.martix[k][j])%MOD;   
+                        tp2.martix[i][j]%=MOD;   
+                    }   
+                }   
+            }   
+        }   
+        memset(tp3.martix,0,sizeof(tp3.martix));   
+        for (i=0;i<N;i++)   
+        {   
+            for (j=0;j<N;j++)   
+            {   
+                for(k=0;k<N;k++)   
+                {   
+                    tp3.martix[i][j]+=(tp1.martix[i][k]*tp1.martix[k][j])%MOD;   
+                }   
+            }   
+        }   
+        if(flag)   
+            tp=tp2;   
+        tp1=tp3;   
+        x>>=1;   
+    }   
+}
+int main()
+{
+    int i,j;
+    ll n,sum;
+    for (i=0;i<N;i++)
+    {
+        for (j=0;j<N;j++)
+        {
+            res.martix[i][j]=(i==j);
+        }
+    }
+    q.martix[0][0]=q.martix[1][0]=q.martix[0][2]=q.martix[2][2]=1;
+    q.martix[1][1]=q.martix[1][2]=q.martix[2][0]=q.martix[2][1]=0;
+    q.martix[0][1]=2;
+    while (scanf("%I64d",&n),n)
+    {
+        if(n==1 || n==2)
+        {
+            printf("%I64d\n",n);
+            continue;
+        }
+        er_fun(n-2);
+        sum=(tp.martix[0][0]*2+tp.martix[0][1]+tp.martix[0][2])%MOD;
+        printf("%I64d\n",sum);
+    }
+    return 0;
+}
diff --git a/HDOJ/2843_autoAC.cpp b/HDOJ/2843_autoAC.cpp
new file mode 100644
index 0000000..c21a4c6
--- /dev/null
+++ b/HDOJ/2843_autoAC.cpp
@@ -0,0 +1,18 @@
+#include<stdio.h>
+#include<string.h>
+int gcd(int a, int  b)
+{
+    return b == 0 ? a : gcd(b, a % b);
+}
+int main()
+{
+    int n,m,c;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        if(n==0&&m==0)break;
+        n+=2;m+=1;
+        c=gcd(n,m);
+        printf("%d %d\n",m/c,n/c);
+    }
+    return 0;
+}
diff --git a/HDOJ/2844_autoAC.cpp b/HDOJ/2844_autoAC.cpp
new file mode 100644
index 0000000..def68ae
--- /dev/null
+++ b/HDOJ/2844_autoAC.cpp
@@ -0,0 +1,51 @@
+#include<cstdio>
+#include<iostream>
+#include<cstring>
+using namespace std;
+int v[105],num[105];
+int dp[100010];
+int main()
+{
+    int i,j,k,n,m,tmp,sum;
+    while(cin>>n>>m,(m+n))
+    {
+        sum=0;
+        memset(dp,0,sizeof(dp));
+        dp[0]=1;
+        for(i=1;i<=n;i++)
+        {
+            cin>>v[i];
+        }
+        for(i=1;i<=n;i++)
+        {
+            cin>>num[i];
+        }
+        for(i=1;i<=n;i++)
+        {
+            tmp=num[i];
+            for(j=1;j<=tmp;j*=2)
+            {
+                for(k=m;k>=j*v[i];k--)
+                {
+                   dp[k]+=dp[k-j*v[i]];
+                }
+                tmp-=j;
+            }
+            if(tmp)
+            {
+                for(k=m;k>=tmp*v[i];k--)
+                {
+                    dp[k]+=dp[k-tmp*v[i]];
+                }
+            }
+        }
+        for(j=1;j<=m;j++)
+        {
+            if(dp[j])
+            {
+                sum++;
+            }
+        }
+        cout<<sum<<endl;
+    }
+}
diff --git a/HDOJ/2845_autoAC.cpp b/HDOJ/2845_autoAC.cpp
new file mode 100644
index 0000000..e21d179
--- /dev/null
+++ b/HDOJ/2845_autoAC.cpp
@@ -0,0 +1,16 @@
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+int const N = 200010;
+int m, n, c[N], l, dp[N], i, j;
+int main() {
+  while(~scanf("%d%d", &m, &n)) {
+    for(j=1; j<=m; c[j++]=dp[n])
+      for(i=2, scanf("%d", &dp[1]); i<=n && scanf("%d", &l); i++)
+        dp[i] = max(dp[i-2]+l, dp[i-1]);
+    for(i=2, dp[1]=c[1]; i<=m; i++)
+      dp[i] = max(dp[i-2]+c[i], dp[i-1]);
+    printf("%d\n", dp[m]);
+  }
+  return 0;
+}
diff --git a/HDOJ/2846_autoAC.cpp b/HDOJ/2846_autoAC.cpp
new file mode 100644
index 0000000..d6f1df6
--- /dev/null
+++ b/HDOJ/2846_autoAC.cpp
@@ -0,0 +1,67 @@
+#include <string>
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+using namespace std;
+struct node
+{
+    int id;   
+    int cnt;
+    int al[26];
+};
+int ptr=0;
+node word[1000000];
+void Init(int z)
+{     
+    for(int i=0;i<26;i++)
+        word[z].al[i]=-1;      
+}      
+void Insert(char*s,int len,int x)
+{
+    int now=0;
+    for(int i=0;i<len;i++)  
+    {
+        if(word[now].al[s[i]-'a']==-1)
+        {
+            word[now].al[s[i]-'a']=++ptr;
+            Init(ptr); now=ptr;
+        }
+        else now=word[now].al[s[i]-'a'];
+        if(word[now].id!=x) word[now].cnt++;
+        //cout<<now<<endl;
+        word[now].id=x;
+    }
+}
+int find(char*s)
+{
+    int now=0;
+    int len=strlen(s);
+    for(int i=0;i<len;i++)
+    {
+        if(word[now].al[s[i]-'a']==-1)
+            return 0;
+        now=word[now].al[s[i]-'a'];
+    }
+    return word[now].cnt;
+}
+int main()
+{
+    int n,m,len;
+    char s[21];
+    Init(0);
+    scanf("%d",&n);
+    while(n--)
+    {      
+        scanf("%s",&s);
+        len=strlen(s);
+        for(int i=0;i<len;i++)
+            Insert(s+i,len-i,n+1);
+    }
+    scanf("%d",&m);
+    while(m--)
+    {
+        scanf("%s",&s);
+        printf("%d\n",find(s));
+    }                            
+    return 0;
+}
diff --git a/HDOJ/2847_autoAC.cpp b/HDOJ/2847_autoAC.cpp
new file mode 100644
index 0000000..6b7f7e0
--- /dev/null
+++ b/HDOJ/2847_autoAC.cpp
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <iostream>
+#include <algorithm>
+#include <math.h>
+#include <vector>
+#include <set>
+#include <queue>
+#include <string.h>
+using namespace std;
+#define ll __int64
+ll n, m, k;
+char s[40], t[40];
+void go(ll x, char *S){
+    ll top = 1;
+    while(x){ S[top++] = ('0'+(x&1));    x>>=1;    }
+    S[top] = 0;
+}
+ll z, o;//n涓0 1涓
+ll Zero(ll x){ll ans = 0; while(x){ans += !(x&1);x>>=1;}return ans;}
+ll One(ll x){ll ans = 0; while(x){ans += (x&1);x>>=1;}return ans;}
+ll work(char *c){
+    ll ans = 0, er = 1;
+    for(ll i = strlen(c)-1; i>=0; i--, er<<=1)if(c[i]=='1')ans += er;
+    return ans;
+}
+bool ok(ll x){
+    if(Zero(x)<z || One(x)<o)return false;
+    go(x, t);
+    ll len = 0;
+    for(ll i = 1, j = 1; s[i] && t[j]; j++)
+        if(s[i] == t[j])len++, i++;
+    return len == (z+o);
+}
+int main()
+{
+    ll i, j, k;
+    while(~scanf("%s",s))
+    {
+        n = work(s);
+        scanf("%I64d",&m); 
+        if(n==0){puts("0");continue;}
+        z = Zero(n), o = One(n);
+        go(n, s);
+        for(i = 1;;i++)if(ok(i*m))break;
+        go(i*m, s);
+        for(i=strlen(s+1); i; i--)printf("%c",s[i]);puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/2848_autoAC.cpp b/HDOJ/2848_autoAC.cpp
new file mode 100644
index 0000000..f3429c3
--- /dev/null
+++ b/HDOJ/2848_autoAC.cpp
@@ -0,0 +1,43 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <queue>
+using namespace std;
+const int MAX_N = 22;
+long long base[MAX_N];
+void makeBase()
+{
+    base[0] = 1;
+    for (int i = 1; i <= 18; ++i)
+        base[i] = base[i-1] * 10;
+}
+bool dfs (long long n, int k);
+bool test (long long n, int k, int nPart, long long curSum) 
+{
+    if (nPart == k)
+        return ! dfs (curSum+n, k);      
+    for (int i = 1; i < 20; ++i)
+    {
+        long long a = n % base[i];
+        long long b = n / base[i];
+        if (b == 0) break;
+        if (test(b, k, nPart+1, curSum+a))
+            return true;
+    }
+    return false;
+}
+bool dfs (long long n, int k)
+{
+    if (n < base[k-1]) return false;
+    else return test(n, k, 1, 0);
+}
+int main ()
+{
+    makeBase();
+    int k;
+    long long n;
+    while (cin >> n >> k)
+        cout << dfs(n, k) << endl;
+    return 0;
+}
diff --git a/HDOJ/2850_autoAC.cpp b/HDOJ/2850_autoAC.cpp
new file mode 100644
index 0000000..ca6a490
--- /dev/null
+++ b/HDOJ/2850_autoAC.cpp
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<cstdlib>
+#include<queue>
+using namespace std;
+const int N=100011;
+int n,m,ans[N];
+struct node0
+{
+    int cost,index;
+}E[N];
+struct node
+{
+    int index,load;
+    bool friend operator<(node n1,node n2)
+    {
+        return n2.load<n1.load;
+    }
+};
+int cmp(const void *a,const void *b)
+{
+    node0 *c,*d;
+    c=(node0 *)a;
+    d=(node0 *)b;
+    return d->cost-c->cost;
+}
+void solve()
+{
+    int i;
+    priority_queue<node>q;
+    node now;
+    qsort(E,n,sizeof(E[0]),cmp);
+    for(i=0;i<m;i++)    {now.index=i;now.load=0;q.push(now);}
+    for(i=0;i<n;i++)
+    {
+        now=q.top();
+        q.pop();
+        now.load+=E[i].cost;
+        ans[E[i].index]=now.index;
+        q.push(now);
+    }
+    cout<<n<<endl;
+    cout<<ans[0];
+    for(i=1;i<n;i++)    cout<<" "<<ans[i];
+    cout<<endl;
+}
+int main()
+{
+    int T;
+    int i;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d%d",&n,&m);
+        for(i=0;i<n;i++)    {scanf("%d",&E[i].cost);E[i].index=i;}
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/2851_autoAC.cpp b/HDOJ/2851_autoAC.cpp
new file mode 100644
index 0000000..9973ca2
--- /dev/null
+++ b/HDOJ/2851_autoAC.cpp
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<stdio.h>
+using namespace std;
+const int MAX=2001;
+const int MAXINT=999999999;
+struct point 
+{
+   int x1,x2;
+   int length;
+}sq[MAX];
+int map[MAX][MAX];
+int visit[MAX];
+int dist[MAX];
+int n,m;
+void Dijkstra()
+{
+    for(int i=1;i<=n;i++)
+    {
+          visit[i]=0;
+          dist[i]=map[1][i];
+    } 
+    visit[1]=1;
+    int k,min; 
+    for(int i=1;i<n;i++)
+    {
+              min=MAXINT; 
+              for(int j=1;j<=n;j++)
+                    if(!visit[j]&&dist[j]<min)
+                    {
+                             min=dist[j];
+                             k=j; 
+                    }
+              visit[k]=1;
+              for(int j=1;j<=n;j++)
+                   if(!visit[j]&&dist[k]+map[k][j]<dist[j])
+                         dist[j]=dist[k]+map[k][j]; 
+    }
+}
+int main()
+{
+   int num;
+   scanf("%d",&num);
+   while(num--)
+   {
+   scanf("%d%d",&n,&m);
+   for(int i=1;i<=n;i++)
+      scanf("%d%d%d",&sq[i].x1,&sq[i].x2,&sq[i].length);  
+   for(int i=1;i<=n;i++)
+   { 
+       for(int j=1;j<=n;j++)
+               map[i][j]=MAXINT;
+       map[i][i]=0;         
+   }  
+   for(int i=1;i<n;i++)
+       for(int j=i+1;j<=n;j++)
+           if(sq[i].x2>=sq[j].x1&&sq[i].x2<=sq[j].x2)
+                    map[i][j]=sq[j].length;
+   Dijkstra(); 
+   int T; 
+   for(int i=1;i<=m;i++)
+   { 
+          scanf("%d",&T); 
+           if(dist[T]==MAXINT) printf("-1\n");
+           else printf("%d\n",sq[1].length+dist[T]); 
+   } 
+   }
+   return 0;
+}
diff --git a/HDOJ/2852_autoAC.cpp b/HDOJ/2852_autoAC.cpp
new file mode 100644
index 0000000..49c30de
--- /dev/null
+++ b/HDOJ/2852_autoAC.cpp
@@ -0,0 +1,87 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+using namespace std;
+#define N 100010
+#define Lowbit(x) ((x)&(-x))
+int C[N];
+bool vis[N];
+void add(int x,int num)
+{
+    while(x < N)
+    {
+        C[x] += num;
+        x += Lowbit(x);
+    }
+}
+int Sum(int x)
+{
+    int ans = 0;
+    while(x > 0)
+    {
+        ans += C[x];
+        x -= Lowbit(x);
+    }
+    return ans;
+}
+int binarysearch(int l,int k){
+    int mid, left, right, tmp;
+    left = l + 1;
+    right = N - 1;
+    if(Sum(right) - Sum(l) < k)return -1;
+    while(left <= right){
+        mid = (left + right) >> 1;
+        tmp = Sum(mid) - Sum(l);
+        if(tmp == k){
+            if(vis[mid]){
+                return mid;
+            }
+            right = mid - 1;
+        }
+        else if(tmp > k){
+            if(Sum(mid - 1) - Sum(l) < k)return mid;
+            right = mid - 1;
+        }
+        else {
+            left = mid + 1;
+        }
+    }
+    return -1;
+}
+int main()
+{
+    int p, n, m, T, e, a, k, l, r, mid;
+    while(~scanf("%d",&T))
+    {
+        memset(C,0,sizeof(C));
+        memset(vis,0,sizeof(vis));
+        while(T--)
+        {
+            scanf("%d",&p);
+            switch(p)
+            {
+            case 0:
+                scanf("%d",&e);
+                add(e,1);
+                vis[e] = 1;
+                break;
+            case 1:
+                scanf("%d",&e);
+                m = Sum(e) - Sum(e-1);
+                if(!m)printf("No Elment!\n");
+                else add(e,-1);
+                if(m == 1)vis[e] = 0;
+                break;
+            case 2:
+                scanf("%d%d",&a,&k);
+                m = binarysearch(a,k);
+                if(m == -1)
+                printf("Not Find!\n");
+                else
+                printf("%d\n",m);
+                break;
+            }
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2853_autoAC.cpp b/HDOJ/2853_autoAC.cpp
new file mode 100644
index 0000000..cf000aa
--- /dev/null
+++ b/HDOJ/2853_autoAC.cpp
@@ -0,0 +1,107 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+#include<cmath>
+#include<algorithm>
+using namespace std;
+#define N 55
+#define MAX 1<<28
+#define CLR(arr, what) memset(arr, what, sizeof(arr))
+int map[N][N];
+int lx[N], ly[N], slack[N];
+bool visitx[N], visity[N];
+int match[N];
+int n, m;
+bool Hungary(int u)
+{
+    int temp;
+    visitx[u] = true;
+    for(int i = 1; i <= m; ++i)
+    {
+        if(visity[i])
+            continue;
+        temp = lx[u] + ly[i] - map[u][i];
+        if(temp == 0)
+        {
+            visity[i] = true;
+            if(match[i] == - 1 || Hungary(match[i]))
+            {
+                match[i] = u;
+                return true;
+            }
+        }
+        else
+            slack[i] = min(slack[i], temp);
+    }
+    return false;
+}
+bool KM_Perfect_Match()
+{
+    int temp;
+    CLR(lx, 0);
+    CLR(ly, 0);
+    for(int i = 1; i <= n; ++i)
+        for(int j = 1; j <= m; ++j)
+            lx[i] = max(lx[i], map[i][j]);
+    for(int i = 1; i <= n; ++i)
+    {
+        for(int j = 1; j <= m; ++j)
+            slack[j] = MAX;
+        while(1)
+        {
+            CLR(visitx, false);
+            CLR(visity, false);
+            if(Hungary(i))
+                break;
+            else
+            {
+                temp = MAX;
+                for(int j = 1; j <= m; ++j)
+                    if(!visity[j])
+                        temp = min(temp, slack[j]);
+                if(temp == MAX)
+                    return false;
+                for(int j = 1; j <= n; ++j)
+                    if(visitx[j])
+                        lx[j] -= temp;
+                for(int j = 1; j <= m; ++j)
+                    if(visity[j])
+                        ly[j] += temp;
+                    else
+                        slack[j] -= temp;
+            }
+        }
+    }
+    return true;
+}
+int main()
+{
+    int finish;
+    int ans, res; 
+    while(~scanf("%d%d", &n, &m))
+    {
+        res = ans = 0;
+        CLR(match, -1);
+        CLR(map, 0);
+        for(int i = 1; i <= n; ++i)
+            for(int j = 1; j <= m; ++j)
+            {
+                scanf("%d", &map[i][j]);
+                map[i][j] *= 100; 
+            }
+        for(int i = 1; i <= n; ++i)
+        {
+            scanf("%d", &finish);
+            res += map[i][finish];
+            map[i][finish] += 1; 
+        }
+        KM_Perfect_Match();
+        for(int i = 1; i <= m; ++i)
+        {
+            if(match[i] != -1)
+                ans += map[ match[i] ][i];
+        }
+        printf("%d %d\n", n - ans % 100, ans / 100 - res / 100);
+    }
+    return 0;
+}
diff --git a/HDOJ/2854_autoAC.cpp b/HDOJ/2854_autoAC.cpp
new file mode 100644
index 0000000..797ed39
--- /dev/null
+++ b/HDOJ/2854_autoAC.cpp
@@ -0,0 +1,39 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+const int N=5011;
+int flag[N];
+void init()
+{
+    int i,l,j;
+    int a,b;
+    memset(flag,0,sizeof(flag));
+    for(i=1;i<=5000;i++)
+    {
+        for(l=1;l<=1000;l++)
+        {
+            for(j=1;j<=1000;j++)
+            {
+                a=l*l*j+1;
+                b=l*l+j;
+                if(a%i==0 && b%i)    flag[i]=1;
+                if(flag[i])    break;
+            }
+            if(flag[i])    break;
+        }
+    }
+}
+int main()
+{
+    init();
+    int T;
+    int n;
+    cin>>T;
+    while(T--)
+    {
+        cin>>n;
+        if(flag[n])    cout<<"NO"<<endl;
+        else        cout<<"YES"<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/2855_autoAC.cpp b/HDOJ/2855_autoAC.cpp
new file mode 100644
index 0000000..fa7e2a5
--- /dev/null
+++ b/HDOJ/2855_autoAC.cpp
@@ -0,0 +1,49 @@
+#include<iostream>
+using namespace std;
+int n,m;
+struct Matrix{
+    int map[2][2];
+};
+Matrix mat,unit;
+void Initiate(){
+    mat.map[0][0]=2;
+    mat.map[0][1]=1;
+    mat.map[1][0]=1;
+    mat.map[1][1]=1;
+    unit.map[0][0]=unit.map[1][1]=1;
+    unit.map[0][1]=unit.map[1][0]=0;
+}
+Matrix Mul(Matrix &a,Matrix &b){
+    Matrix c;
+    for(int i=0;i<2;i++){
+        for(int j=0;j<2;j++){
+            c.map[i][j]=0;
+            for(int k=0;k<2;k++){
+                c.map[i][j]+=a.map[i][k]*b.map[k][j];
+                c.map[i][j]%=m;
+            }
+        }
+    }
+    return c;
+}
+Matrix Pow(int n){
+    Matrix p=unit,q=mat;
+    while(n){
+        if(n&1)
+            p=Mul(p,q);
+        n>>=1;
+        q=Mul(q,q);
+    }
+    return p;
+}
+int main(){
+    int _case;
+    scanf("%d",&_case);
+    Initiate();
+    while(_case--){
+        scanf("%d%d",&n,&m);
+        Matrix remat=Pow(n);
+        printf("%d\n",remat.map[0][1]);
+    }
+    return 0;
+}
diff --git a/HDOJ/2857_autoAC.cpp b/HDOJ/2857_autoAC.cpp
new file mode 100644
index 0000000..335259a
--- /dev/null
+++ b/HDOJ/2857_autoAC.cpp
@@ -0,0 +1,50 @@
+#include<stdio.h>
+#include<math.h>
+struct line
+{
+       double a,b,c;
+}p,s;
+double x3, y3, x2, y2, x, y;
+double xs,xe,ys,ye,ansx,ansy;
+void jiaodian()
+{
+       s.a=y-ye;
+       s.b=xe-x;
+       s.c=x*ye-y*xe;
+       if(fabs(p.b)<1e-6)
+       {
+          ansx = -p.c / p.a;
+          ansy = (-s.c - s.a * ansx) / s.b;
+       }
+       else
+       {
+           ansx = (p.c * s.b - p.b * s.c) / (p.b * s.a - s.b * p.a);
+           ansy = (-p.c- p.a* ansx) / p.b;
+       }
+}
+void duichen()
+{
+       double d;
+       p.a=y3-y2;
+       p.b=x2-x3;
+       p.c=x3*y2-y3*x2;
+       d=p.a*p.a+p.b*p.b;
+       x=(p.b * p.b * xs - p.a * p.a * xs - 2 * p.a * p.b * ys - 2 * p.a * p.c) / d;
+       y=(p.a * p.a * ys - p.b * p.b * ys - 2 * p.a * p.b * xs - 2 * p.b * p.c) / d;
+}
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%lf%lf%lf%lf",&x3,&y3,&x2,&y2);
+        scanf("%lf%lf%lf%lf",&xs,&ys,&xe,&ye);
+        duichen();
+        jiaodian();
+        if(fabs(ansx)<1e-6)ansx=fabs(ansx);
+        if(fabs(ansy)<1e-6)ansy=fabs(ansy);
+        printf("%.3lf %.3lf\n",ansx,ansy);
+    }
+    return 0;
+}
diff --git a/HDOJ/2858_autoAC.cpp b/HDOJ/2858_autoAC.cpp
new file mode 100644
index 0000000..ecaef67
--- /dev/null
+++ b/HDOJ/2858_autoAC.cpp
@@ -0,0 +1,148 @@
+#include<iostream>
+#include<queue>
+#include<string.h>
+#include<stdio.h>
+using namespace std;
+struct node
+{
+    int k,l,r,ans,nl,nr,level;
+    node(){};
+    node(int kk,int ll,int rr,int anss,int nll,int nrr,int le)
+    {
+        k=kk;l=ll;r=rr;ans=anss;level=le;nl=nll;nr=nrr;
+    }
+    friend bool operator<(const node &A,const node &B)
+    {
+        if(A.level==B.level)
+        {
+            return A.ans<B.ans;
+        }
+        return A.level>B.level;
+    }
+}s,e;
+bool has[230][15][15][15][15][2];
+priority_queue<node>q;
+int map[20][20],b[20][20][20];
+int n,m,k,ans;
+int x,y,now;
+void solve()
+{
+    if(e.k<0||e.k>(n-e.level-1)*(e.nr-e.nl+1))
+        return;
+    if(has[e.k][e.l][e.r][e.nl][e.nr][1-now]==true)
+        return;
+    q.push(e);
+    has[e.k][e.l][e.r][e.nl][e.nr][1-now]=true;
+}
+void bfs(int l)
+{
+    int i,j;
+    memset(has,0,sizeof(has));
+    q.push(node(0,0,0,0,0,0,-1));
+    while(!q.empty())
+    {
+        s=q.top();
+        q.pop();
+        if(s.k==0&&s.ans>ans)
+            ans=s.ans;
+        if(s.level==n-1)
+            continue;
+        if(s.level!=l)
+        {
+            now=1-now;
+            l=s.level;
+            for(i=0;i<m;i++)
+            {
+                for(j=i;j<m;j++)
+                {
+                    e=s;
+                    e.level++;
+                    e.l=i;
+                    e.r=j;
+                    e.nl=0;
+                    e.nr=m-1;
+                    e.k=k-(j-i+1);
+                    e.ans=b[e.level][i][j];
+                    solve();
+                }
+            }
+        }
+        has[s.k][s.l][s.r][s.nl][s.nr][now]=false;
+        if(s.level==-1)
+            continue;
+        if(s.k>(n-s.level-1)*(s.nr-s.nl+1))
+            continue;
+        for(i=s.nl;i<=s.nr;i++)
+        {
+            for(j=i;j<=s.nr;j++)
+            {
+                if(i<s.nl||j>s.nr||j<s.l||i>s.r)
+                    continue;
+                e=s;
+                e.level++;
+                e.l=i;
+                e.r=j;
+                e.k-=(j-i+1);
+                if(i>s.l&&j<s.r)
+                {
+                    e.nl=i;
+                    e.nr=j;
+                    e.ans+=b[e.level][i][j];
+                }
+                else if(i>s.l)
+                {
+                    e.nl=i;
+                    e.nr=s.nr;
+                    e.ans+=b[e.level][i][j];
+                }
+                else if(j<s.r)
+                {
+                    e.nl=s.nl;
+                    e.nr=j;
+                    e.ans+=b[e.level][i][j];
+                }
+                else
+                {
+                    e.nl=s.nl;
+                    e.nr=s.nr;
+                    e.ans+=b[e.level][i][j];
+                }
+                solve();
+            }
+        }
+    }
+}
+int main()
+{
+    int i,j;
+    while(scanf("%d%d%d",&n,&m,&k)==3)
+    {
+        ans=0;
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<m;j++)
+            {
+                scanf("%d",&map[i][j]);
+                ans+=map[i][j];
+            }
+        }
+        for(i=0;i<n;i++)
+        {
+            for(x=0;x<m;x++)
+            {
+                for(y=x;y<m;y++)
+                {
+                    if(y==x)
+                        b[i][x][y]=map[i][x];
+                    else
+                        b[i][x][y]=b[i][x][y-1]+map[i][y];
+                }
+            }
+        }
+        ans=0;
+        now=0;
+        bfs(-2);
+        printf("Oil : %d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/2859_autoAC.cpp b/HDOJ/2859_autoAC.cpp
new file mode 100644
index 0000000..f9b0ade
--- /dev/null
+++ b/HDOJ/2859_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+using namespace std;
+int dp[1010][1010];
+char str[1010][1010];
+int main()
+{
+    int n;
+    while(scanf("%d",&n) == 1 && n)
+    {
+        for(int i = 0;i < n;i++)
+            scanf("%s",str[i]);
+        int ans = 1;
+        for(int i = 0;i < n;i++)
+            for(int j = 0;j < n;j++)
+            {
+                if(i == 0 || j == n-1)
+                {
+                    dp[i][j] = 1;
+                    continue;
+                }
+                int t1 = i, t2 = j;
+                while(t1 >= 0 && t2 < n && str[t1][j] == str[i][t2])
+                {
+                    t1--;
+                    t2++;
+                }
+                t1 = i - t1;
+                if(t1 >= dp[i-1][j+1]+1)dp[i][j] = dp[i-1][j+1]+1;
+                else dp[i][j] = t1;
+                ans = max(ans,dp[i][j]);
+            }
+        printf("%d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/2860_autoAC.cpp b/HDOJ/2860_autoAC.cpp
new file mode 100644
index 0000000..ea30896
--- /dev/null
+++ b/HDOJ/2860_autoAC.cpp
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int N=100111;
+int n,m,q;
+int pre[N],val[N];
+void build()
+{
+    int i;
+    int a,b;
+    memset(val,-1,sizeof(val));
+    for(i=0;i<n;i++)    pre[i]=i;
+    while(m--)
+    {
+        scanf("%d%d",&a,&b);
+        if(val[b]==-1 || a<val[b])    val[b]=a;
+    }
+}
+int find(int k)
+{
+    if(pre[k]==k)    return k;
+    pre[k]=find(pre[k]);
+    return pre[k];
+}
+int main()
+{
+    int a,b;
+    char str[11];
+    while(scanf("%d%d%d",&n,&m,&q)!=-1)
+    {
+        build();
+        while(q--)
+        {
+            scanf("%s",str);
+            if(str[0]=='A')
+            {
+                scanf("%d%d",&a,&b);
+                if(pre[b]!=b)    printf("Reject\n");
+                else
+                {
+                    printf("Accept\n");
+                    if(val[b]==-1 || a<val[b])    val[b]=a;
+                }
+            }
+            else if(str[0]=='M')
+            {
+                scanf("%d%d",&a,&b);
+                if(pre[a]!=a || pre[b]!=b || a==b)    printf("Reject\n");
+                else
+                {
+                    printf("Accept\n");
+                    pre[b]=a;
+                    if(val[b]!=-1 && (val[a]==-1 || val[b]<val[a]))    val[a]=val[b];
+                }
+            }
+            else
+            {
+                scanf("%d",&a);
+                if(pre[a]==a && val[a]!=-1)        printf("Lowest rate: %d.\n",val[a]);
+                else if(pre[a]==a && val[a]==-1)printf("Company %d is empty.\n",a);
+                else if(pre[a]!=a)                printf("Company %d is a part of company %d.\n",a,find(a));
+            }
+        }
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/2861_autoAC.cpp b/HDOJ/2861_autoAC.cpp
new file mode 100644
index 0000000..c12c195
--- /dev/null
+++ b/HDOJ/2861_autoAC.cpp
@@ -0,0 +1,30 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int N=205;
+const int M=22;
+__int64 a[N][N][M],b[N][N][M];
+void init()
+{
+    int i,l,j;
+    memset(a,0,sizeof(a));
+    memset(b,0,sizeof(b));
+    a[1][0][1]=1;
+    b[1][1][1]=1;
+    for(i=2;i<=200;i++)
+    for(l=0;l<=i;l++)
+    for(j=1;j<=i && j<=20;j++)
+    {
+        a[i][l][j]=a[i-1][l][j]+b[i-1][l][j-1];
+        if(l)    b[i][l][j]=a[i-1][l-1][j-1]+b[i-1][l-1][j];
+    }
+}
+int main()
+{
+    init();
+    int n,m,k;
+    while(scanf("%d%d%d",&n,&m,&k)!=-1)
+        printf("%I64d\n",a[n][m][k]+b[n][m][k]);
+    return 0;
+}
diff --git a/HDOJ/2863_autoAC.cpp b/HDOJ/2863_autoAC.cpp
new file mode 100644
index 0000000..02f9fa9
--- /dev/null
+++ b/HDOJ/2863_autoAC.cpp
@@ -0,0 +1,80 @@
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <string>
+#include <deque>
+#include <stack>
+#include <algorithm>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <limits.h>
+#include <time.h>
+#include <string.h>
+using namespace std;
+#define LL long long
+#define PI acos(-1.0)
+#define Max INT_MAX
+#define Min INT_MIN
+#define eps 1e-8
+#define N 1001
+priority_queue<int , vector<int> ,greater<int> > p[701];
+int s[51];
+int n,m;
+bool vis[51];
+int live,die;
+void gao(){
+    int i,j,k;
+    live=0,die=0;
+    int t=1;
+    while(live+die<m){
+        i=0;
+        while(i<n && !p[t].empty()){
+            int x=p[t].top();
+            p[t].pop();
+            if(x>=s[i]){
+                die++;
+                i++;
+            }
+            else
+            if(x-1>=s[0]){
+                x--;
+                p[t+1].push(x);
+            }
+            else
+            live++;
+        }
+        while(!p[t].empty()){
+            int x=p[t].top();
+            p[t].pop();
+            if(x-1>=s[0]){
+            x--;
+            p[t+1].push(x);
+            }
+            else
+            live++;
+        }
+        t++;
+    }
+    printf("%d\n",die);
+}
+int main(){
+    while(scanf("%d%d",&n,&m)!=EOF){
+        int i,j;
+        for(i=0;i<n;i++)scanf("%d",&s[i]);
+        sort(s,s+n);
+        for(i=0;i<=700;i++)
+        while(!p[i].empty())
+        p[i].pop();
+        for(i=0;i<m;i++){
+            int a,b;
+            scanf("%d%d",&a,&b);
+            p[a].push(b);
+        }
+        gao();
+    }
+    return 0;
+}
diff --git a/HDOJ/2864_autoAC.cpp b/HDOJ/2864_autoAC.cpp
new file mode 100644
index 0000000..e312f10
--- /dev/null
+++ b/HDOJ/2864_autoAC.cpp
@@ -0,0 +1,32 @@
+#include <stdio.h>
+int main ()
+{
+int n,a,b,i,j,k,t=1;
+int c[100];
+while (scanf("%d %d %d",&n,&a,&b)!=EOF)
+{
+   printf ("Case %d:",t++);
+   i=0;
+   while (n)
+   {
+    c[i]=n%b;
+    n/=b;
+    i++;
+   }
+   c[i]=0;
+   for (k=0;k<i-1;k++)
+   {
+    while (c[k]<a)
+    {
+     c[k]+=b;
+     c[k+1]--;
+    }
+   }
+   while (c[k]==0 && k)
+    k--;
+   while (k)
+    printf (" %d",c[k--]);
+   printf (" %d\n",c[0]);
+}
+return 0;
+}
diff --git a/HDOJ/2865_autoAC.cpp b/HDOJ/2865_autoAC.cpp
new file mode 100644
index 0000000..3cea258
--- /dev/null
+++ b/HDOJ/2865_autoAC.cpp
@@ -0,0 +1,143 @@
+#include<cstdio>
+#include<cstring>
+#include<vector>
+#define P 1000000007
+#define MAXM 2
+#define MAXN 32000
+typedef long long LL;
+using namespace std;
+bool p[MAXN];
+vector<int> factor;
+vector<int> prime;
+struct Matrix {
+    LL mat[MAXM][MAXM];
+    void Zero() {
+        memset(mat, 0, sizeof(mat));
+    }
+    void Unit() {
+        Zero();
+        mat[0][0] = mat[1][1] = 1;
+    }
+    void Build(int k) {
+        Zero();
+        mat[0][1] = 1;
+        mat[0][0] = k - 2;
+        mat[1][0] = k - 1;
+    }
+};
+Matrix operator *(Matrix &a, Matrix &b) {
+    int i, j, k;
+    Matrix tmp;
+    tmp.Zero();
+    for (i = 0; i < MAXM; i++) {
+        for (j = 0; j < MAXM; j++) {
+            for (k = 0; k < MAXM; k++)
+                tmp.mat[i][j] += a.mat[i][k] * b.mat[k][j];
+            tmp.mat[i][j] %= P;
+        }
+    }
+    return tmp;
+}
+Matrix operator ^(Matrix a, int k) {
+    Matrix tmp;
+    for (tmp.Unit(); k; k >>= 1) {
+        if (k & 1)
+            tmp = tmp * a;
+        a = a * a;
+    }
+    return tmp;
+}
+void Factor(int n) {
+    int i;
+    factor.clear();
+    for (i = 1; i * i < n; i++) {
+        if (n % i == 0) {
+            factor.push_back(i);
+            factor.push_back(n / i);
+        }
+    }
+    if (i * i == n)
+        factor.push_back(i);
+}
+LL ExtGcd(LL a, LL b, LL &x, LL &y) {
+    LL t, d;
+    if (b == 0) {
+        x = 1;
+        y = 0;
+        return a;
+    }
+    d = ExtGcd(b, a % b, x, y);
+    t = x;
+    x = y;
+    y = t - a / b * y;
+    return d;
+}
+LL InvMod(LL a, LL n) {
+    LL x, y;
+    ExtGcd(a, n, x, y);
+    return (x % n + n) % n;
+}
+int Count(int x) {
+    int res, i;
+    res = x;
+    for (i = 0; prime[i] * prime[i] <= x; i++) {
+        if (x % prime[i] == 0) {
+            res -= res / prime[i];
+            while (x % prime[i] == 0)
+                x /= prime[i];
+        }
+    }
+    if (x > 1)
+        res -= res / x;
+    return res;
+}
+LL F(int n, int k) {
+    LL res;
+    if (n == 1)
+        res = 0;
+    else if (n == 2)
+        res = (LL) k * (k - 1);
+    else if (n == 3)
+        res = (LL) k * (k - 1) % P * (k - 2);
+    else {
+        Matrix g;
+        g.Build(k);
+        g = g ^ (n - 3);
+        res = g.mat[0][0] * k % P * (k - 1) % P * (k - 2);
+        res += g.mat[1][0] * k % P * (k - 1);
+    }
+    return res % P;
+}
+LL Burnside(int n, int k) {
+    LL ans;
+    int i;
+    Factor(n);
+    for (i = ans = 0; i < (int) factor.size(); i++) {
+        ans += F(factor[i], k) * Count(n / factor[i]) % P;
+        if (ans >= P)
+            ans -= P;
+    }
+    return ans * InvMod(n, P) % P;
+}
+void Init() {
+    int i, j;
+    memset(p, true, sizeof(p));
+    for (i = 2; i < 180; i++) {
+        if (p[i]) {
+            for (j = i * i; j < MAXN; j += i)
+                p[j] = false;
+        }
+    }
+    prime.clear();
+    for (i = 2; i < MAXN; i++) {
+        if (p[i])
+            prime.push_back(i);
+    }
+}
+int main() {
+    int n, k;
+    Init();
+    while (~scanf("%d%d", &n, &k))
+        printf("%I64d\n", Burnside(n, k - 1) * k % P);
+    return 0;
+}
diff --git a/HDOJ/2866_autoAC.cpp b/HDOJ/2866_autoAC.cpp
new file mode 100644
index 0000000..122de8d
--- /dev/null
+++ b/HDOJ/2866_autoAC.cpp
@@ -0,0 +1,39 @@
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+#include <iostream>
+#include <cstdio>
+using namespace std;
+#define maxn 1000010
+bool prime[maxn];
+void Prime()
+{
+    memset(prime,true,sizeof(prime));
+    prime[0]=prime[1]=0;
+    for(int i=2;i*i<maxn;i++)
+        if(prime[i])
+            for(int j=2*i;j<maxn;j+=i)
+                prime[j]=0;
+}
+int main()
+{
+    Prime();
+    int n,ans,p;
+    while(scanf("%d",&n)!=EOF)
+    {
+        ans=0;
+        for(int i=1;;i++)
+        {
+            int tmp=3*i*i+3*i+1;
+            if(tmp>n)
+                break;
+            if(prime[tmp])
+                ans++;
+        }
+        if(ans)
+            printf("%d\n",ans);
+        else
+            printf("No Special Prime!\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/2868_autoAC.cpp b/HDOJ/2868_autoAC.cpp
new file mode 100644
index 0000000..9b216b0
--- /dev/null
+++ b/HDOJ/2868_autoAC.cpp
@@ -0,0 +1,51 @@
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <string>
+#include <deque>
+#include <stack>
+#include <algorithm>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <limits.h>
+#include <time.h>
+#include <string.h>
+using namespace std;
+#define LL long long
+#define PI acos(-1.0)
+#define Max INT_MAX
+#define Min INT_MIN
+#define eps 1e-8
+#define N 201
+bool g[N][N];
+bool gg[N][N];
+int main(){
+    int n,m;
+    while(scanf("%d%d",&n,&m)!=EOF){
+        int i,j,k;
+        memset(g,false,sizeof(g));
+        memset(gg,false,sizeof(gg));
+        while(m--){
+            int a,b;
+            scanf("%d%d",&a,&b);
+            g[a][b]=true;
+        }
+        int res=0;
+        for(i=1;i<=n;i++)
+        for(j=1;j<=n;j++)
+        for(k=1;k<=n;k++)
+        if(g[j][i] && g[i][k]){
+            g[j][k]=gg[j][k]=true;   
+        }
+        for(i=1;i<=n;i++)
+        for(j=i+1;j<=n;j++)
+        if(gg[i][j] || gg[j][i])
+        res++;
+        printf("%d\n",n*(n-1)/2-res);
+    }
+    return 0;
+}
diff --git a/HDOJ/2869_autoAC.cpp b/HDOJ/2869_autoAC.cpp
new file mode 100644
index 0000000..e43e2f6
--- /dev/null
+++ b/HDOJ/2869_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <iostream>
+#include <cmath>
+#include <cstdio>
+using namespace std;
+int main()
+{
+        int prime[100];
+        int k = 0;
+        for(int i=2;i<=500;i++)
+        {
+        bool flag = false;
+        for(int j=2;j<=(int)sqrt((double) i);j++)
+        if( i % j == 0) { flag = true; break;}
+        if(!flag) prime[k++] = i;
+        }
+        int a,b;
+        while(scanf("%d%d",&a,&b)!=EOF)
+        {
+        int w=0,h=0;
+        int c = a,d = b;
+        for(int i=0;i<=94;i++) 
+        {
+            while(a % prime[i] == 0 && prime[i] != c)
+            {
+                w++;
+                a /= prime[i];
+            }
+            while(b % prime[i] == 0 && prime[i] != d)
+            {
+                h++;
+                b /= prime[i];
+            }
+        }
+        if( w> h) printf("Win\n");
+        else      printf("Lose\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/2870_autoAC.cpp b/HDOJ/2870_autoAC.cpp
new file mode 100644
index 0000000..c52e384
--- /dev/null
+++ b/HDOJ/2870_autoAC.cpp
@@ -0,0 +1,89 @@
+#include<iostream>
+#include<cstdio>
+#include<vector>
+#include<algorithm>
+#include<cstring>
+#include<queue>
+#include<set>
+#include<math.h>
+#include<string>
+using namespace std;
+typedef long long ll;
+#define PI acos(-1.0)
+#define INF 2*1e9
+#define eps   1e-6
+using namespace std;
+#define MAXN 100010
+int n,m;
+int a[1010][1010];
+int l[1010],r[1010];
+char map[1010][1010],map1[1010][1010];
+bool can[50][50];
+char  ok[5][7]={"wabww","xbcxx", "yacyy","zabcz"}; 
+char tar[]= "abc";
+int solve();
+int main()
+{
+    memset(can,0,sizeof(can));
+    memset(map1,0,sizeof(map1));
+    int i,j ,k ;
+    for(i=0;i<111;i++) map1[i][0]='1';
+    for(i=0;i<4;i++) 
+    {
+        for(j=1;j<5;j++) 
+        {
+            can[ok[i][0]-'a'][ok[i][j]-'a'] = 1;
+        }
+    }
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        for(i=1;i<=n;scanf("%s",map[i++]+1) );  
+        int ans =-1;
+        for(k=0;k<strlen(tar);k++)
+        {
+            memset(a,0,sizeof(a));
+            for(i=1;i<=n;i++)
+            for(j=1;j<=m;j++) 
+            {
+                map1[i][j] = map[i][j];
+                if(can[ map[i][j]-'a' ][tar[k]-'a'] )
+                    map1[i][j] = tar[k];
+                if(map1[i][j]==map1[i-1][j]) 
+                    a[i][j] =1+a[i-1][j];
+                else 
+                    a[i][j] = 1;
+            }
+            int qqq=solve();
+            if( qqq>ans ) ans =qqq;
+        }
+        printf("%d\n",ans);
+    }
+}
+int solve()
+{
+    int i,j;
+    int ans = -1 ,t;
+    for(i=1;i<=n;i++)
+    {
+        a[i][0]= a[i][m+1] =-1;
+        for(j=1;j<=m;j++) 
+            r[j]=l[j] =j;
+        for(j=1;j<=m;j++) 
+        {
+             while( map1[i][j] == map1[i][l[j]-1] && a[i][j]<= a[i][l[j]-1] )
+                l[j]= l[l[j]-1 ];
+        }
+        for(j=m;j>=1;j--) 
+        {
+            while( map1[i][j]==map1[i][r[j]+1] && a[i][j]<= a[i][ r[j]+1] )
+                r[j] =r[r[j]+1] ;
+        }
+        for(j=1;j<=m;j++) 
+        {
+            t= a[i][j]*( r[j]-l[j] +1 );
+            if(t> ans) 
+                ans= t;
+        }
+    }
+    return ans;
+}
diff --git a/HDOJ/2871_autoAC.cpp b/HDOJ/2871_autoAC.cpp
new file mode 100644
index 0000000..13b63ee
--- /dev/null
+++ b/HDOJ/2871_autoAC.cpp
@@ -0,0 +1,184 @@
+#include<cstdio>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+#define MAXN 50010
+struct node
+{
+    int left,right,sum,lazy,s,e,cnt,cover;
+};
+node tree[MAXN<<2];
+inline void PushUp(int mid,int L,int R,int rt)
+{
+    tree[rt].left=tree[rt<<1].left;
+    tree[rt].right=tree[rt<<1|1].right;
+    if(tree[rt].left==mid-L+1)
+        tree[rt].left+=tree[rt<<1|1].left;
+    if(tree[rt].right==R-mid)
+        tree[rt].right+=tree[rt<<1].right;
+    tree[rt].sum=max(tree[rt<<1].sum,tree[rt<<1|1].sum);
+    tree[rt].sum=max(tree[rt].sum,tree[rt<<1].right+tree[rt<<1|1].left);
+}
+inline void PushDown(int mid,int L,int R,int rt)
+{
+    if(tree[rt].lazy!=-1)
+    {
+        tree[rt<<1].lazy=tree[rt<<1|1].lazy=tree[rt].lazy;
+        tree[rt<<1].sum=tree[rt<<1].left=tree[rt<<1].right=(mid-L+1)*tree[rt].lazy;
+        tree[rt<<1|1].sum=tree[rt<<1|1].left=tree[rt<<1|1].right=(R-mid)*tree[rt].lazy;
+        tree[rt<<1].s=tree[rt<<1|1].s=tree[rt].s;
+        tree[rt<<1].e=tree[rt<<1|1].e=tree[rt].e;
+        tree[rt].lazy=-1;
+    }
+}
+void Update(int x,int y,int val,int L,int R,int rt)
+{
+    if(x<=L&&R<=y)
+    {
+        tree[rt].lazy=val;
+        tree[rt].sum=tree[rt].left=tree[rt].right=val*(R-L+1);
+        if(val)
+            tree[rt].s=tree[rt].e=-1;
+        else
+        {
+            tree[rt].s=x;
+            tree[rt].e=y;
+        }
+    }
+    else
+    {
+        int mid=(L+R)>>1;
+        PushDown(mid,L,R,rt);
+        if(x<=mid)
+            Update(x,y,val,L,mid,rt<<1);
+        if(y>mid)
+            Update(x,y,val,mid+1,R,rt<<1|1);
+        PushUp(mid,L,R,rt);
+    }
+}
+int New(int x,int L,int R,int rt)
+{
+    if(L==R)
+        return L;
+    int mid=(L+R)>>1;
+    PushDown(mid,L,R,rt);
+    if(tree[rt<<1].sum>=x)
+        return New(x,L,mid,rt<<1);
+    else if(tree[rt<<1].right+tree[rt<<1|1].left>=x)
+        return mid-tree[rt<<1].right+1;
+    else
+        return New(x,mid+1,R,rt<<1|1);
+}
+int Free(int x,int L,int R,int rt)
+{
+    if(L==R)
+        return rt;
+    int mid=(L+R)>>1;
+    PushDown(mid,L,R,rt);
+    if(x<=mid)
+        return Free(x,L,mid,rt<<1);
+    else
+        return Free(x,mid+1,R,rt<<1|1);
+}
+inline void CountUp(int rt)
+{
+    tree[rt].cnt=tree[rt<<1].cnt+tree[rt<<1|1].cnt;
+}
+inline void CountDown(int rt)
+{
+    if(tree[rt].cover)
+    {
+        tree[rt<<1].cnt=tree[rt<<1|1].cnt=0;
+        tree[rt<<1].cover=tree[rt<<1|1].cover=1;
+        tree[rt].cover=0;
+    }
+}
+int Get(int x,int L,int R,int rt)
+{
+    if(L==R)
+        return L;
+    else
+    {
+        int mid=(L+R)>>1;
+        CountDown(rt);
+        if(tree[rt<<1].cnt>=x)
+            return Get(x,L,mid,rt<<1);
+        else
+            return Get(x-tree[rt<<1].cnt,mid+1,R,rt<<1|1);
+    }
+}
+void Count(int x,int val,int L,int R,int rt)
+{
+    if(L==R)
+        tree[rt].cnt=val;
+    else
+    {
+        int mid=(L+R)>>1;
+        CountDown(rt);
+        if(x<=mid)
+            Count(x,val,L,mid,rt<<1);
+        else
+            Count(x,val,mid+1,R,rt<<1|1);
+        CountUp(rt);
+    }
+}
+inline void Reset(int n)
+{
+    Update(1,n,1,1,n,1);
+    tree[1].cover=1;
+    tree[1].cnt=0;
+}
+int main()
+{
+    char s[12];
+    int n,m,x,y;
+    while(~scanf("%d%d",&n,&m))
+    {
+        Reset(n);
+        while(m--)
+        {
+            scanf(" %s",s);
+            if(!strcmp(s,"Reset"))
+            {
+                Reset(n);
+                puts("Reset Now");
+            }
+            else if(!strcmp(s,"New"))
+            {
+                scanf("%d",&x);
+                if(tree[1].sum>=x)
+                {
+                    y=New(x,1,n,1);
+                    printf("New at %d\n",y);
+                    Count(y,1,1,n,1);
+                    Update(y,y+x-1,0,1,n,1);
+                }
+                else
+                    puts("Reject New");
+            }
+            else if(!strcmp(s,"Free"))
+            {
+                scanf("%d",&x);
+                y=Free(x,1,n,1);
+                if(tree[y].s<0)
+                    puts("Reject Free");
+                else
+                {
+                    printf("Free from %d to %d\n",tree[y].s,tree[y].e);
+                    Count(tree[y].s,0,1,n,1);
+                    Update(tree[y].s,tree[y].e,1,1,n,1);
+                }
+            }
+            else
+            {
+                scanf("%d",&x);
+                if(x>tree[1].cnt)
+                    puts("Reject Get");
+                else
+                    printf("Get at %d\n",Get(x,1,n,1));
+            }
+        }
+        putchar('\n');
+    }
+    return 0;
+}
diff --git a/HDOJ/2872_autoAC.cpp b/HDOJ/2872_autoAC.cpp
new file mode 100644
index 0000000..02c8ba1
--- /dev/null
+++ b/HDOJ/2872_autoAC.cpp
@@ -0,0 +1,95 @@
+#include <iostream>
+#include <cstdio>
+#include <string.h>
+#include <string>
+#include <algorithm>
+#include <queue>
+#include <map>
+#include <vector>
+#include <set>
+#include <stack>
+#include <cmath>
+using namespace std;
+#define N 20
+#define inf 0x3f3f3f3f
+#define eps 1e-16
+#define LL long long
+#define Pi acos(-1)
+struct Point{
+ double x, y;
+};
+Point p[N], pnt[N];
+int res, t, n;
+bool mark[N];
+double dot(double x1, double y1, double x2, double y2){
+ return x1 * x2 + y1 * y2;
+}
+double cross(double x1, double y1, double x2, double y2){
+ return x1 * y2 - x2 * y1;
+}
+int dblcmp(double n) {
+ if (fabs(n) < eps) {
+ return 0;
+ } else {
+ return n > 0 ? +1 : -1;
+ }
+}
+bool segXseg(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4){
+ double c1 = cross(x1 - x3, y1 - y3, x2 - x3, y2 - y3);
+ double c2 = cross(x1 - x4, y1 - y4, x2 - x4, y2 - y4);
+ double c3 = cross(x3 - x1, y3 - y1, x4 - x1, y4 - y1);
+ double c4 = cross(x3 - x2, y3 - y2, x4 - x2, y4 - y2);
+ if (c1 * c2 < -eps && c3 * c4 < -eps) return true;
+ if ((dblcmp(c1) == 0 && dblcmp(dot(x1 - x3, y1 - y3, x2 - x3, y2 - y3)) <= 0) ||
+ (dblcmp(c2) == 0 && dblcmp(dot(x1 - x4, y1 - y4, x2 - x4, y2 - y4)) <= 0) ||
+ (dblcmp(c3) == 0 && dblcmp(dot(x3 - x1, y3 - y1, x4 - x1, y4 - y1)) <= 0) ||
+ (dblcmp(c4) == 0 && dblcmp(dot(x3 - x2, y3 - y2, x4 - x2, y4 - y2)) <= 0)) {
+ return true;
+ }
+ return false;
+}
+bool ok(int k){
+ double c = cross(pnt[t].x - pnt[t - 1].x, pnt[t].y - pnt[t - 1].y, p[k].x - pnt[t].x, p[k].y - pnt[t].y);
+ double d = dot(pnt[t].x - pnt[t - 1].x, pnt[t].y - pnt[t - 1].y, p[k].x - pnt[t].x, p[k].y - pnt[t].y);
+ if (!((c > eps || (fabs(c) < eps && d > 0)))){
+ return false;
+ }
+ Point tmp;
+ for (int i = 0; i <= t - 2; ++i){
+ tmp.x = pnt[t].x + (p[k].x - pnt[t].x) * 100000000.0;
+ tmp.y = pnt[t].y + (p[k].y - pnt[t].y) * 100000000.0;
+ if (segXseg(pnt[i].x, pnt[i].y, pnt[i + 1].x, pnt[i + 1].y, pnt[t].x, pnt[t].y, tmp.x, tmp.y)){
+ return false;
+ }
+ }
+ return true;
+}
+void DFS(){
+ int i;
+ for (i = 1; i <= n; ++i){
+ if (res == n) return ;
+ if (!mark[i] && (t < 1 || ok(i))){
+ pnt[++t] = p[i];
+ mark[i] = true;
+ if (t > res) res = t;
+ DFS();
+ t--;
+ mark[i] = false;
+ }
+ }
+}
+int main(){
+ int i;
+ while (scanf("%d", &n) != EOF){
+ for (i = 1; i <= n; ++i){
+ scanf("%lf%lf", &p[i].x, &p[i].y);
+ }
+ memset(mark, false, sizeof(mark));
+ pnt[0].x = pnt[0].y = 0;
+ t = 0;
+ res = 0;
+ DFS();
+ printf("%d\n", res);
+ }
+ return 0;
+}
diff --git a/HDOJ/2873_autoAC.cpp b/HDOJ/2873_autoAC.cpp
new file mode 100644
index 0000000..7e69708
--- /dev/null
+++ b/HDOJ/2873_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<iostream>
+#include<cstdlib>
+#include<stdio.h>
+#include<memory.h>
+using namespace std;
+int sg[60][60];
+char str[60][60];
+int num[600];
+int dfs(int x,int y)
+{
+    memset(num,-1,sizeof(num));
+    for(int i=0;i<x;i++)
+    for(int j=0;j<y;j++)
+    {
+        num[sg[i][y]^sg[x][j]]=1;
+    }
+    for(int i=0;;i++)
+    if(num[i]==-1) return i;
+}
+int main()
+{
+    for(int i=0;i<=50;i++)
+    sg[0][i]=sg[i][0]=i;
+    for(int i=1;i<=50;i++)
+    for(int j=1;j<=50;j++)
+    sg[i][j]=dfs(i,j);
+    int n,m;
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        if(n==0&&m==0) break;
+        int ans=0;
+        for(int i=0;i<n;i++)
+        {
+            scanf("%s",str[i]);
+            for(int j=0;j<m;j++)
+            {
+                if(str[i][j]=='#')
+                {
+                    ans^=sg[i][j];
+                }
+            }
+        }
+        if(ans) puts("John");
+        else puts("Jack");
+    }
+}
diff --git a/HDOJ/2874_autoAC.cpp b/HDOJ/2874_autoAC.cpp
new file mode 100644
index 0000000..128f728
--- /dev/null
+++ b/HDOJ/2874_autoAC.cpp
@@ -0,0 +1,114 @@
+#include <cstdio>
+#include <algorithm>
+#include <string>
+#include <cstring>
+#include <stack>
+#include <cmath>
+#include <queue>
+#include <list>
+#include <cstdlib>
+#include <vector>
+#include <set>
+#include <map>
+#include <sstream>
+#include <iostream>
+#include <stack>
+using namespace std;
+int n,m,q;
+struct Node
+{
+    int e,xia,val;
+}e1[20001];
+struct Node2
+{
+    int e,xia;
+}e2[2000001];
+int d1,d2,head1[10001],head2[10001];
+bool vis[10001];
+int fat[10001],dis[10001],ans[1000001];
+void add1(int s,int e,int val)
+{
+    e1[d1].e=e,e1[d1].val=val,e1[d1].xia=head1[s];
+    head1[s]=d1++;
+}
+void add2(int s,int e)
+{
+    e2[d2].e=e,e2[d2].xia=head2[s];
+    head2[s]=d2++;
+}
+int find(int num)
+{
+    if(fat[num] == num)return num;
+    return fat[num]=find(fat[num]);
+}
+void Union(int s,int e)
+{
+    fat[e]=s;
+}
+void tarjan(int s)
+{
+    int i;
+    vis[s]=true;
+    fat[s]=s;
+    for(i=head1[s];i != -1;i=e1[i].xia)
+    {
+        if(!vis[e1[i].e])
+        {
+            dis[e1[i].e]=dis[s]+e1[i].val;
+            tarjan(e1[i].e);
+            Union(s,e1[i].e);
+        }
+    }
+    for(i=head2[s];i != -1 ;i=e2[i].xia)
+    {
+        if(vis[e2[i].e])
+        {
+            if(dis[e2[i].e] != -1)
+            {
+                ans[i/2]=dis[s]+dis[e2[i].e]-2*dis[find(e2[i].e)];
+            }
+            else ans[i/2]=-1;
+        }
+    }
+}
+int main()
+{
+    int i,j,ji1,ji2,ji3;
+    while(~scanf("%d %d %d",&n,&m,&q))
+    {
+        d1=d2=0;
+        memset(head1,-1,sizeof(head1));
+        memset(head2,-1,sizeof(head2));
+        for(i=0;i<m;i++)
+        {
+            scanf("%d %d %d",&ji1,&ji2,&ji3);
+            add1(ji1,ji2,ji3);
+            ji1^=ji2,ji2^=ji1,ji1^=ji2;
+            add1(ji1,ji2,ji3);
+        }
+        for(i=0;i<q;i++)
+        {
+            scanf("%d %d",&ji1,&ji2);
+            add2(ji1,ji2);
+            ji1^=ji2,ji2^=ji1,ji1^=ji2;
+            add2(ji1,ji2);
+        }
+        memset(vis,false,sizeof(vis));
+        for(i=1;i<=n;i++)fat[i]=i;
+        for(i=1;i<=n;i++)
+        {
+            if(!vis[i])
+            {
+                memset(dis,-1,sizeof(dis));
+                dis[i]=0;
+                tarjan(i);
+            }
+        }
+        for(i=0;i<q;i++)
+        {
+            if(ans[i] == -1)puts("Not connected");
+            else printf("%d\n",ans[i]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2876_autoAC.cpp b/HDOJ/2876_autoAC.cpp
new file mode 100644
index 0000000..d1c2c09
--- /dev/null
+++ b/HDOJ/2876_autoAC.cpp
@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <math.h>
+int main()
+{
+    double xQ,yQ;
+    double k1;
+    int a,b,x0,y0,T;
+    while(~scanf("%d",&T))
+    {
+        while(T--)
+        {
+            scanf("%d%d%d%d",&a,&b,&x0,&y0);
+            k1=y0/(x0*1.0);
+            xQ=sqrt((a*a*b*b*1.0)/(a*a*k1*k1+b*b));
+            yQ=k1*xQ;int flag= 0;
+            int w=a*a-b*b;
+            if((x0*x0)/(a*a)+(y0*y0)/(b*b)<1)
+            {
+                printf("In ellipse\n");
+                continue;
+            }
+            if(w < 0)
+            {
+                flag =1;
+                w=-w;
+            }
+            double F1,F2;
+            double c =sqrt(w*1.0);
+            if(flag == 0)
+            {
+                 F1 = sqrt((xQ+c)*(xQ+c)+(yQ*yQ));
+                 F2 = sqrt((xQ-c)*(xQ-c)+yQ*yQ);
+            }
+            else
+            { 
+                F1 = sqrt(xQ*xQ+(yQ+c)*(yQ+c));
+                F2 = sqrt(xQ*xQ+(yQ-c)*(yQ-c));
+            }
+            double t = (sqrt)((xQ*xQ*b*b*b*b)*1.0+(yQ*yQ*a*a*a*a)*1.0);
+            double d =a*a*b*b/(t*1.0);
+            double D=d*d*F1*F2;
+             D = a*a*b*b;
+            printf("%.0lf\n",D);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2878_autoAC.cpp b/HDOJ/2878_autoAC.cpp
new file mode 100644
index 0000000..e629af7
--- /dev/null
+++ b/HDOJ/2878_autoAC.cpp
@@ -0,0 +1,114 @@
+#include<stdio.h>
+#include<string.h>
+#include<algorithm>
+#define MAXM 1010
+#define MAXN 250010
+#define MAXD 501010
+#define INF 0x3f3f3f3f
+int N, M, K, P, a[510], b[510], g[510][510];
+int size, U[MAXD], D[MAXD], L[MAXD], R[MAXD], C[MAXD];
+int S[MAXM], H[MAXN], ANS;
+void read(int X, int *a, int c)
+{
+    int i, j, x, y, n;
+    memset(a, 0, sizeof(int) * (N + 1));
+    for(i = 0; i < X; i ++)
+    {
+        scanf("%d%d", &x, &y);
+        if(x > y) std::swap(x, y);
+        if(c) y += 2;
+        for(j = x; j <= y; j ++) a[j] = 1;
+    }
+}
+void prep(int n, int m)
+{
+    int i;
+    for(i = 0; i <= m; i ++)
+    {
+        R[i] = i + 1, L[i + 1] = i;
+        U[i] = D[i] = i, S[i] = 0;
+    }
+    R[m] = 0, size = m;
+    for(i = 0; i <= n; i ++) H[i] = -1;
+}
+void insert(int r, int c)
+{
+    ++ size;
+    C[size] = c, ++ S[c];
+    D[size] = D[c], U[size] = c, U[D[c]] = size, D[c] = size;
+    if(H[r] == -1) L[size] = R[size] = size, H[r] = size;
+    else L[size] = H[r], R[size] = R[H[r]], L[R[H[r]]] = size, R[H[r]] = size;
+}
+void init()
+{
+    int i, j, k;
+    scanf("%d%d", &N, &M);
+    memset(g, 0, sizeof(g));
+    for(i = 0; i < M; i ++)
+    {
+        scanf("%d", &K), read(K, a, 0);
+        scanf("%d", &P), read(P, b, 1);
+        for(j = 1; j <= N; j ++)
+            if(a[j])
+                for(k = 1; k <= N; k ++)
+                    if(b[k]) g[j][k] = 1;
+    }
+    prep(N * N, N + N);
+    for(i = 1; i <= N; i ++)
+        for(j = 1; j <= N; j ++)
+            if(g[i][j]) insert((i - 1) * N + j, i), insert((i - 1) * N + j, N + j);
+}
+void remove(int c)
+{
+    int i, j;
+    R[L[c]] = R[c], L[R[c]] = L[c];
+    for(i = D[c]; i != c; i = D[i])
+        for(j = R[i]; j != i; j = R[j])
+            U[D[j]] = U[j], D[U[j]] = D[j], -- S[C[j]];
+}
+void resume(int c)
+{
+    int i, j;
+    for(i = U[c]; i != c; i = U[i])
+        for(j = L[i]; j != i; j = L[j])
+            U[D[j]] = j, D[U[j]] = j, ++ S[C[j]];
+    R[L[c]] = c, L[R[c]] = c;
+}
+void dance()
+{
+    if(R[0] == 0)
+    {
+        ++ ANS;
+        return ;
+    }
+    int i, j, t = INF, id;
+    for(i = R[0]; i != 0; i = R[i])
+        if(S[i] < t) t = S[i], id = i;
+    remove(id);
+    for(i = D[id]; i != id; i = D[i])
+    {
+        for(j = R[i]; j != i; j = R[j]) remove(C[j]);
+        dance();
+        if(ANS > 65535) return ;
+        for(j = L[i]; j != i; j = L[j]) resume(C[j]);
+    }
+    resume(id);
+}
+void solve()
+{
+    ANS = 0;
+    dance();
+    if(ANS > 65535) printf("OVERFLOW!\n");
+    else printf("%d\n", ANS);
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    while(t --)
+    {
+        init();
+        solve();
+    }
+    return 0;
+}
diff --git a/HDOJ/2879_autoAC.cpp b/HDOJ/2879_autoAC.cpp
new file mode 100644
index 0000000..16eb260
--- /dev/null
+++ b/HDOJ/2879_autoAC.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <string.h>
+#include <stdio.h>
+using namespace std;
+typedef long long LL;
+const int N = 10000005;
+const int M = 1000005;
+bool prime[N];
+int p[N];
+int k;
+void isprime()
+{
+    k = 0;
+    memset(prime,true,sizeof(prime));
+    for(int i=2;i<N;i++)
+    {
+        if(prime[i])
+        {
+            p[k++] = i;
+            for(int j=i+i;j<N;j+=i)
+                prime[j] = false;
+        }
+    }
+}
+LL quick_mod(LL a,LL b,LL m)
+{
+    LL ans = 1;
+    a %= m;
+    while(b)
+    {
+        if(b&1)
+        {
+            ans = ans * a % m;
+            b--;
+        }
+        b >>= 1;
+        a = a * a % m;
+    }
+    return ans;
+}
+int main()
+{
+    int n,m,t;
+    isprime();
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&m);
+        LL cnt = 0;
+        for(int i=0;i < k;i++)
+        {
+            if(p[i] > n) break;
+            cnt += n / p[i];
+        }
+        LL ans = quick_mod(2,cnt,m);
+        printf("%I64d\n",ans);
+    }
+    return 0;
+}
diff --git a/HDOJ/2881_autoAC.cpp b/HDOJ/2881_autoAC.cpp
new file mode 100644
index 0000000..cf074a5
--- /dev/null
+++ b/HDOJ/2881_autoAC.cpp
@@ -0,0 +1,41 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+#include<cstring>
+#include<algorithm>
+using namespace std;
+const int M=10005;
+int n,m;
+struct node{
+    int t,x,y;
+}E[M];
+int dp[M];
+int cmp(node n1,node n2){
+    return n1.t<n2.t;
+}
+int main()
+{
+    int i,l;
+    int temp;
+    while(scanf("%d%d",&n,&m),n||m)
+    {
+        for(i=0;i<m;i++)    scanf("%d%d%d",&E[i].t,&E[i].x,&E[i].y);
+        sort(E,E+m,cmp);
+        int ans;
+        ans=dp[0]=1;
+        for(i=1;i<m;i++)
+        {
+            dp[i]=0;
+            for(l=i-1;l>=0;l--)
+            {
+                temp=abs(E[i].x-E[l].x)+abs(E[i].y-E[l].y);
+                if(temp>E[i].t-E[l].t)    continue;
+                dp[i]=dp[i]>(dp[l]+1)?dp[i]:(dp[l]+1);
+            }
+            if(!dp[i])    dp[i]=1;
+            if(dp[i]>ans)    ans=dp[i];
+        }
+        cout<<ans<<endl;
+    }
+    return 0;
+}
diff --git a/HDOJ/2883_autoAC.cpp b/HDOJ/2883_autoAC.cpp
new file mode 100644
index 0000000..b4a7591
--- /dev/null
+++ b/HDOJ/2883_autoAC.cpp
@@ -0,0 +1,159 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <climits>
+#include <algorithm>
+using namespace std;
+#define min(a,b)(a)<(b)?(a):(b)
+const int INF=INT_MAX;
+const int maxn=2000;
+const int maxm=10000000;
+struct node
+{
+    int from,to,next,c;
+}e[maxm];
+int tot;
+int head[maxn];
+void add(int s,int u,int f1,int f2)
+{
+    e[tot].from=s;
+    e[tot].to=u;
+    e[tot].c=f1;
+    e[tot].next=head[s];
+    head[s]=tot++;
+    e[tot].from=u;
+    e[tot].to=s;
+    e[tot].c=f2;
+    e[tot].next=head[u];
+    head[u]=tot++;
+}
+int q[maxn];
+int cnt[maxn];
+int d[maxn];
+int low[maxn];
+int cur[maxn];
+int maxflow(int s,int t,int n)
+{
+    int *front=q,*rear=q;
+    for(int i=0;i<n;i++)
+    {
+        d[i]=n;
+        cnt[i]=0;
+    }
+    cnt[n]=n-1;
+    cnt[0]++;
+    d[t]=0;
+    *rear++=t;
+    while(front<rear)
+    {
+        int v=*front++;
+        for(int i=head[v];i!=-1;i=e[i].next)
+        {
+            if(d[e[i].to]==n&&e[i^1].c>0)
+            {
+                d[e[i].to]=d[v]+1;
+                cnt[n]--;
+                cnt[d[e[i].to]]++;
+                *rear++=e[i].to;
+            }
+        }
+    }
+    int flow=0, u=s, top=0;
+    low[0]=INF;
+    for(int i=0;i<n;i++)
+        cur[i]=head[i];
+    while(d[s]<n)
+    {
+        int &i=cur[u];
+        for(;i!=-1;i=e[i].next)
+        {
+            if(e[i].c>0&&d[u]==d[e[i].to]+1)
+            {
+                low[top+1]=min(low[top],e[i].c);
+                q[++top]=i;
+                u=e[i].to;
+                break;
+            }
+        }
+        if(i!=-1)
+        {
+            if(u==t)
+            {
+                int minf=low[top];
+                for(int p=1,i;p<=top;++p)
+                {
+                    i=q[p];
+                    e[i].c-=minf;
+                    e[i^1].c+=minf;
+                }
+                flow+=minf;
+                u=s;
+                low[0]=INF;
+                top=0;
+            }
+        }
+        else
+        {
+            int old_du=d[u];
+            cnt[old_du]--;
+            d[u]=n-1;
+            for(int i=head[u];i!=-1;i=e[i].next)
+                if(e[i].c>0&&d[u]>d[e[i].to])
+                    d[u]=d[e[i].to];
+            cnt[++d[u]]++;
+            if(d[u]<n)
+                cur[u]=head[u];
+            if(u!=s)
+            {
+                u=e[q[top]].from;
+                --top;
+            }
+            if(cnt[old_du]==0)
+                break;
+        }
+    }
+    return flow;
+}
+struct edge
+{
+    int st,en,c,d;
+}ta[205];
+int di[500];
+int main()
+{
+    int i, j, k, n, m;
+    int sum;
+    while(scanf("%d %d",&m, &n)!=EOF)
+    {
+        tot = 0;
+        sum = 0;
+        memset(head,-1,sizeof(head));
+        int s = 0;
+        int t = m+2*m;
+        int a,b,c,d;
+        int top = 0;
+        for(i = 1; i <= m; i++)
+        {
+            scanf("%d %d %d %d",&ta[i].st, &ta[i].c, &ta[i].en, &ta[i].d);
+            di[top++] = ta[i].st;
+            di[top++] = ta[i].en;
+        }
+        sort(di,di+top);
+        top--;
+        for(i = 1; i <= top; i++)
+            add(i+m,t,(di[i]-di[i-1])*n,0);
+        for(i = 1; i <= m; i++)
+        {
+            add(s,i,ta[i].c*ta[i].d,0);
+            sum += ta[i].c*ta[i].d;
+            for(j = 1; j <= top; j++)
+                if(ta[i].st<=di[j-1]&&di[j] <=ta[i].en)
+                      add(i,j+m,INF,0);
+        }
+        int res = maxflow(s,t,t+1);
+        if(res == sum)
+        printf("Yes\n");
+        else printf("No\n");
+    }
+    return 0;
+}
diff --git a/HDOJ/2886_autoAC.cpp b/HDOJ/2886_autoAC.cpp
new file mode 100644
index 0000000..3c58d02
--- /dev/null
+++ b/HDOJ/2886_autoAC.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <algorithm>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <queue>
+#include <cmath>
+#include <stack>
+#include <map>
+#pragma comment(linker, "/STACK:1024000000");
+#define EPS (1e-8)
+#define LL long long
+#define ULL unsigned long long int
+#define _LL __int64
+#define _INF 0x3f3f3f3f
+#define Mod 1000000007
+#define LM(a,b) (((ULL)(a))<<(b))
+#define RM(a,b) (((ULL)(a))>>(b))
+using namespace std;
+map<int,int> Max;
+int Cal(int x,int n)
+{
+  if(n == 1)
+    return x;
+  if(n == 2)
+    return x*x;
+  if(Max.find(n) == Max.end())
+  {
+    if(n&1)
+    {
+      int t1 = Cal(x,n/2);
+      int t2 = Cal(x,n/2 + 1);
+      t1 = t1*t2;
+      t1 %= 2009;
+      Max.insert(pair<int,int>(n,t1));
+      return t1;
+    }
+    else
+    {
+      int t1 = Cal(x,n/2);
+      t1 = t1*t1;
+      t1 %= 2009;
+      Max.insert(pair<int,int>(n,t1));
+      return t1;
+    }
+  }
+  return Max[n];
+}
+int main()
+{
+  int n;
+  while(scanf("%d",&n) != EOF)
+  {
+    if(n <= 4)
+    {
+      printf("%d\n",n);
+    }
+    else
+    {
+      if(n%3 == 0)
+      {
+        printf("%d\n",Cal(3,n/3)%2009);
+      }
+      else if(n%3 == 2)
+      {
+        printf("%d\n",(Cal(3,n/3)*2)%2009);
+      }
+      else
+      {
+        printf("%d\n",(Cal(3,n/3 - 1)*4)%2009);
+      }
+    }
+  }
+  return 0;
+}
diff --git a/HDOJ/2887_autoAC.cpp b/HDOJ/2887_autoAC.cpp
new file mode 100644
index 0000000..12cf8f2
--- /dev/null
+++ b/HDOJ/2887_autoAC.cpp
@@ -0,0 +1,157 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <cstdlib>
+#include <cmath>
+using namespace std;
+const int N = 5005;
+const int M = N << 4;
+int p[N], n, m, sum, w[N];
+struct Edge {
+    int u, v, w;
+    void init(int a, int b, int c) {
+        u = a, v = b, w = c;
+    }
+    bool operator <(const Edge& e) const {
+        return w < e.w;
+    }
+}E[M];
+int find(int u) {
+    if (p[u] != u) 
+        p[u] = find(p[u]);
+    return p[u];
+}
+const int lim = 17;
+struct Tree {
+    struct Edge {
+        int v, w;
+        Edge* next;
+        void init(int a, Edge* e, int b) {
+            v = a;
+            w = b;
+            next = e;
+        }    
+    };
+    Edge E[M];
+    Edge* it, * head[N];
+    int pa[N][lim], dep[N], dis[N];
+    int maxv[N][lim];
+    int W[N];
+    int n;
+    void init(int n) {
+        this->n = n;
+        for (int i = 0; i < n; head[i++] = 0);
+        it = E;
+    }
+    void add(int u, int v, int w) {
+        it->init(v, head[u], w);
+        head[u] = it++;
+        it->init(u, head[v], w);
+        head[v] = it++;
+    }
+    int lca(int u, int v) {
+        if (dep[u] > dep[v]) swap(u, v);
+        if (dep[u] < dep[v]) {
+            int d = dep[v] - dep[u];
+            for (int i = 0; i < lim; i++)
+                if (d & (1 << i))
+                    v = pa[v][i];
+        }
+        if (u != v) {
+            for (int i = lim - 1; i >= 0; i--)
+                if (pa[u][i] != pa[v][i]) {
+                    u = pa[u][i];
+                    v = pa[v][i];
+                }
+            u = pa[u][0];
+        }
+        return u;
+    }
+    int query(int u, int v) {
+        if (dep[u] > dep[v]) swap(u, v);
+        int res = -1;
+        if (dep[u] < dep[v]) {
+            int d = dep[v] - dep[u];
+            for (int i = 0; i < lim; i++)
+                if (d & (1 << i)) {
+                    res = max(maxv[v][i], res);
+                    v = pa[v][i];        
+                }
+        }
+        if (u != v) {
+            for (int i = lim - 1; i >= 0; i--) {
+                if (pa[u][i] != pa[v][i]) {
+                    res = max(res, maxv[u][i]);
+                    res = max(res, maxv[v][i]);
+                    u = pa[u][i];
+                    v = pa[v][i];
+                }
+            }
+            res = max(res, maxv[u][0]);
+            res = max(res, maxv[v][0]);
+        }
+        return res;
+    }
+    void dfs(int u, int fa) {
+        pa[u][0] = fa;
+        maxv[u][0] = W[u];
+        dep[u] = dep[fa] + 1;
+        for (int i = 1; (1 << i) < n; i++) {
+            pa[u][i] = pa[pa[u][i - 1]][i - 1];
+            maxv[u][i] = max(maxv[u][i - 1], maxv[pa[u][i - 1]][i - 1]);
+        }
+        for (Edge* e = head[u]; e; e = e->next) {
+            int v = e->v;
+            if (v != fa) {
+                W[v] = e->w;
+                dfs(v, u);
+            }
+        }    
+    }
+    void run(int rt) {
+        dep[rt] = -1;
+        W[rt] = -1;
+        dfs(rt, rt);
+    }
+}T;
+int main() {
+    int u, v, w, c;
+    while (~scanf("%d%d%d", &n, &m, &sum)) {
+        c = 0;
+        for (int i = 1; i <= n; i++) {
+            scanf("%d", &w);
+            E[c].init(0, i, w);
+            c++;
+        }
+        for (int i = 0; i < m; i++) {
+            scanf("%d%d%d", &u, &v, &w);
+            E[c].init(u, v, w);
+            c++;
+        }
+        n++;
+        m += n;
+        T.init(n);
+        int res = 0;
+        sort(E, E + c);
+        int cnt = 0;
+        for (int i = 0; i < n; i++) p[i] = i;
+        for (int i = 0; i < c; i++) {
+            int fu = find(E[i].u), fv = find(E[i].v);
+            if (fu != fv) {
+                p[fu] = fv;
+                res += E[i].w;
+                T.add(E[i].u, E[i].v, E[i].w);    
+                cnt++;
+            }
+            if (cnt == n - 1) break;
+        }
+        T.run(0);
+        for (int i = 0; i < sum; i++) {
+            scanf("%d%d", &u, &v);
+            int tmp = T.query(u, v);
+            printf("%d\n", res - tmp);
+        }
+    }    
+    return 0;
+}
diff --git a/HDOJ/2888_autoAC.cpp b/HDOJ/2888_autoAC.cpp
new file mode 100644
index 0000000..4f1f9ee
--- /dev/null
+++ b/HDOJ/2888_autoAC.cpp
@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
+#include <string.h>
+using namespace std;
+int val[310][310];
+int dp[310][310][9][9];
+int mm[310];
+void initRMQ(int n,int m)
+{
+    for(int i = 1;i <= n;i++)
+        for(int j = 1;j <= m;j++)
+            dp[i][j][0][0] = val[i][j];
+    for(int ii = 0; ii <= mm[n]; ii++)
+        for(int jj = 0; jj <= mm[m]; jj++)
+            if(ii+jj)
+                for(int i = 1; i + (1<<ii) - 1 <= n;i++)
+                    for(int j = 1; j + (1<<jj) - 1 <= m;j++)
+                    {
+                        if(ii)dp[i][j][ii][jj] = max(dp[i][j][ii-1][jj],dp[i+(1<<(ii-1))][j][ii-1][jj]);
+                        else dp[i][j][ii][jj] = max(dp[i][j][ii][jj-1],dp[i][j+(1<<(jj-1))][ii][jj-1]);
+                    }
+}
+int rmq(int x1,int y1,int x2,int y2)
+{
+    int k1 = mm[x2-x1+1];
+    int k2 = mm[y2-y1+1];
+    x2 = x2 - (1<<k1) + 1;
+    y2 = y2 - (1<<k2) + 1;
+    return max(max(dp[x1][y1][k1][k2],dp[x1][y2][k1][k2]),max(dp[x2][y1][k1][k2],dp[x2][y2][k1][k2]));
+}
+int main()
+{
+    mm[0] = -1;
+    for(int i = 1;i <= 305;i++)
+        mm[i] = ((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
+    int n,m;
+    int Q;
+    int r1,c1,r2,c2;
+    while(scanf("%d%d",&n,&m) == 2)
+    {
+        for(int i = 1;i <= n;i++)
+            for(int j = 1;j <= m;j++)
+                scanf("%d",&val[i][j]);
+        initRMQ(n,m);
+        scanf("%d",&Q);
+        while(Q--)
+        {
+            scanf("%d%d%d%d",&r1,&c1,&r2,&c2);
+            if(r1 > r2)swap(r1,r2);
+            if(c1 > c2)swap(c1,c2);
+            int tmp = rmq(r1,c1,r2,c2);
+            printf("%d ",tmp);
+            if(tmp == val[r1][c1] || tmp == val[r1][c2] || tmp == val[r2][c1] || tmp == val[r2][c2])
+                printf("yes\n");
+            else printf("no\n");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2889_autoAC.cpp b/HDOJ/2889_autoAC.cpp
new file mode 100644
index 0000000..7471e58
--- /dev/null
+++ b/HDOJ/2889_autoAC.cpp
@@ -0,0 +1,18 @@
+#include <iostream>
+using namespace std;
+int main(int argc, const char * argv[])
+{
+    int a,b,set(int, const int = 10,const int = 9, const int = 1);
+    while (cin >>a>>b) {
+        cout<<set(set(a)-set(b),9,10,0)<<endl;
+    }
+    return 0;
+}
+int set(int s, const int x, const int y, const int z)
+{
+    int sum=0;
+    for(int i=1;s>0;s/=x,i*=y) {
+        sum+=(z||(s%x)?s%x:((s-=9),9))*i;
+    }
+    return sum;
+}
diff --git a/HDOJ/2890_autoAC.cpp b/HDOJ/2890_autoAC.cpp
new file mode 100644
index 0000000..8d595ff
--- /dev/null
+++ b/HDOJ/2890_autoAC.cpp
@@ -0,0 +1,121 @@
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#include <cstring>
+using namespace std;
+const int maxn=50050;
+char str[maxn];
+int  num[maxn];
+int sa[maxn]; 
+int ran[maxn];
+int height[maxn]; 
+int wa[maxn], wb[maxn], wv[maxn], wd[maxn];
+int X[maxn],  que[maxn];
+int pos;
+int cmp(int *r, int a, int b, int l)
+{
+    return r[a]==r[b]&&r[a+l]==r[b+l];
+}
+void da(int *r, int n, int m){         
+    int i, j, p, *x = wa, *y = wb, *t;
+    for(i = 0; i < m; i ++) wd[i] = 0;
+    for(i = 0; i < n; i ++) wd[x[i]=r[i]] ++;
+    for(i = 1; i < m; i ++) wd[i] += wd[i-1];
+    for(i = n-1; i >= 0; i --) sa[-- wd[x[i]]] = i;
+    for(j = 1, p = 1; p < n; j *= 2, m = p){
+        for(p = 0, i = n-j; i < n; i ++) y[p ++] = i;
+        for(i = 0; i < n; i ++) if(sa[i] >= j) y[p ++] = sa[i] - j;
+        for(i = 0; i < n; i ++) wv[i] = x[y[i]];
+        for(i = 0; i < m; i ++) wd[i] = 0;
+        for(i = 0; i < n; i ++) wd[wv[i]] ++;
+        for(i = 1; i < m; i ++) wd[i] += wd[i-1];
+        for(i = n-1; i >= 0; i --) sa[-- wd[wv[i]]] = y[i];
+        for(t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i ++){
+            x[sa[i]] = cmp(y, sa[i-1], sa[i], j) ? p - 1: p ++;
+        }
+    }
+}
+void calHeight(int *r, int n){           
+    int i, j, k = 0;
+    for(i = 1; i <= n; i ++) ran[sa[i]] = i;
+    for(i = 0; i < n; height[ran[i ++]] = k){
+        for(k ? k -- : 0, j = sa[ran[i]-1]; r[i+k] == r[j+k]; k ++);
+    }
+}
+int find(int tmp, int n)
+{
+    int l=0, r=n, mid;
+    while(l<=r)
+    {
+        mid=(l+r)>>1;
+        if(X[mid]==tmp) return mid;
+        else if(X[mid]<tmp) l=mid+1;
+        else r=mid-1;
+    }
+}
+bool judge(int mid, int rear, int k)
+{
+    sort(que,que+rear);
+    int pre=que[0], cnt=1;
+    for(int i=1; i<rear; i++)
+        if(que[i]-pre>=mid) pre=que[i], cnt++;
+    return cnt>=k;
+}
+bool check(int mid, int n, int k)
+{
+    int rear=0;
+    for(int i=1; i<=n; i++)
+    {
+        if(height[i]<mid)
+        {
+            if(judge(mid,rear,k))
+            {
+                pos=sa[i-1];
+                return true;
+            }
+            rear=0, que[rear++]=sa[i];
+        }
+        else que[rear++]=sa[i];
+    }
+    if(judge(mid,rear,k))
+    {
+        pos=sa[n-1];
+        return true;
+    }
+    return false;
+}
+int main()
+{
+    int n, k, T;
+    cin >> T;
+    while(T--)
+    {
+        scanf("%d%d",&n,&k);
+        for(int i=0; i<n; i++) scanf("%d",num+i), X[i]=num[i];
+        sort(X,X+n);
+        int ep=0;
+        for(int i=1; i<n; i++)
+            if(X[i]!=X[ep]) X[++ep]=X[i];
+        for(int i=0; i<n; i++)
+            num[i]=find(num[i],ep)+2;
+        num[n]=0;
+        da(num,n+1,n+5);
+        calHeight(num,n);
+        int l=1, r=n, mid, ans=0;
+        while(l<=r)
+        {
+            mid=(l+r)>>1;
+            if(check(mid,n,k))
+            {
+                l=mid+1;
+                ans=mid;
+            }
+            else r=mid-1;
+        }
+        printf("%d\n",ans);
+        for(int i=pos; i<pos+ans; i++) printf("%d\n",X[num[i]-2]);
+        if(T) puts("");
+    }
+    return 0;
+}
diff --git a/HDOJ/2891_autoAC.cpp b/HDOJ/2891_autoAC.cpp
new file mode 100644
index 0000000..95698b9
--- /dev/null
+++ b/HDOJ/2891_autoAC.cpp
@@ -0,0 +1,63 @@
+#include<cstdio>
+#include<algorithm>
+using namespace std;
+int h[10004];
+struct add{
+    int t;
+    int a;
+    int minn;
+}ad[10004];
+bool cmp(add a, add b){
+    if(a.a == b.a)
+        return a.t > b.t;
+    else
+        return a.a < b.a;
+}
+bool comp(add a, int sum){
+    return a.a < sum;
+}
+int main(){
+    int n, m, hp;
+    while(~scanf("%d%d%d", &n, &m, &hp)){
+        h[0] = 0;
+        for(int i = 1; i <= n; i++)
+            scanf("%d", &h[i]);
+        for(int i = 0; i < m; i++)
+        {
+            scanf("%d%d", &ad[i].t, &ad[i].a);
+            ad[i].minn = n;
+        }
+        sort(ad, ad+m, cmp);
+        int sum = 0, ans = 0;
+        for(int i = n; i > 0; i--){
+            sum += h[i];
+            if(sum > ans)
+                ans = sum;
+            int n = lower_bound(ad, ad+m, sum, comp) - ad;
+            bool boo = false;
+            for(int j = n; j < m; j++){
+                if(i <= ad[j].minn){
+                    boo = true;
+                    ad[j].minn -= ad[j].t;
+                    sum = 0;
+                    break;
+                }
+            }
+            if(!boo)
+                for(int j = n-1; j >= 0; j--){
+                    if(i <= ad[j].minn){
+                        ad[j].minn -= ad[j].t;
+                        sum -= ad[j].a;
+                        if(sum < 0){
+                            sum = 0;
+                            break;
+                        }
+                    }
+                }
+        }
+        if(hp-ans <= 0)
+            puts("Die");
+        else
+            printf("%d\n", hp-ans); 
+    }
+}
diff --git a/HDOJ/2892_autoAC.cpp b/HDOJ/2892_autoAC.cpp
new file mode 100644
index 0000000..ee69f16
--- /dev/null
+++ b/HDOJ/2892_autoAC.cpp
@@ -0,0 +1,114 @@
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+#include<math.h>
+#include<algorithm>
+const int maxn = 111111;
+const int maxisn = 21;
+const double eps = 1e-8;
+const double pi = acos(-1.0);
+int dcmp(double x)
+{
+    if(x > eps) return 1;
+    return x < -eps ? -1 : 0;
+}
+struct Point
+{
+    double x, y;
+    Point(){x = y = 0;}
+    Point(double a, double b)
+    {x = a, y = b;}
+    inline Point operator-(const Point &b)const
+    {return Point(x - b.x, y - b.y);}
+    inline Point operator+(const Point &b)const
+    {return Point(x + b.x, y + b.y);}
+    inline Point operator*(const double &b)const
+    {return Point(x * b, y * b);}
+    inline double dot(const Point &b)const
+    {return x * b.x + y * b.y;}
+    inline double cross(const Point &b, const Point &c)const
+    {return (b.x - x) * (c.y - y) - (c.x - x) * (b.y - y);}
+    inline double Dis(const Point &b)const
+    {return sqrt((*this - b).dot(*this - b));}
+    inline bool InLine(const Point &b, const Point &c)const
+    {return !dcmp(cross(b, c));}
+    inline bool OnSeg(const Point &b, const Point &c)const
+    {return InLine(b, c) && (*this - c).dot(*this - b) < eps;}
+};
+inline double min(double a, double b)
+{return a < b ? a : b;}
+inline double max(double a, double b)
+{return a > b ? a : b;}
+inline double Sqr(double x)
+{return x * x;}
+inline double Sqr(const Point &p)
+{return p.dot(p);}
+Point LineCross(const Point &a, const Point &b, const Point &c, const Point &d)
+{
+    double u = a.cross(b, c), v = b.cross(a, d);
+    return Point((c.x * v + d.x * u) / (u + v), (c.y * v + d.y * u) / (u + v));
+}
+double LineCrossCircle(const Point &a, const Point &b, const Point &r, 
+            double R, Point &p1, Point &p2)
+{
+    Point fp = LineCross(r, Point(r.x + a.y - b.y, r.y + b.x - a.x), a, b);
+    double rtol = r.Dis(fp);
+    double rtos = fp.OnSeg(a, b) ? rtol : min(r.Dis(a), r.Dis(b));
+    double atob = a.Dis(b);
+    double fptoe = sqrt(R * R - rtol * rtol) / atob;
+    if(rtos > R - eps) return rtos;
+    p1 = fp + (a - b) * fptoe;
+    p2 = fp + (b - a) * fptoe;
+    return rtos;
+}
+double SectorArea(const Point &r, const Point &a, const Point &b, double R)
+{
+    double A2 = Sqr(r - a), B2 = Sqr(r - b), C2 = Sqr(a - b);
+    return R * R * acos((A2 + B2 - C2) * 0.5 / sqrt(A2) / sqrt(B2)) * 0.5;
+}
+double TACIA(const Point &r, const Point &a, const Point &b, double R)
+{
+    double adis = r.Dis(a), bdis = r.Dis(b);
+    if(adis < R + eps && bdis < R + eps) return r.cross(a, b) * 0.5;
+    Point ta, tb;
+    if(r.InLine(a, b)) return 0.0;
+    double rtos = LineCrossCircle(a, b, r, R, ta, tb);
+    if(rtos > R - eps) return SectorArea(r, a, b, R);
+    if(adis < R + eps) return r.cross(a, tb) * 0.5 + SectorArea(r, tb, b, R);
+    if(bdis < R + eps) return r.cross(ta, b) * 0.5 + SectorArea(r, a, ta, R);
+    return r.cross(ta, tb) * 0.5 + 
+        SectorArea(r, a, ta, R) + SectorArea(r, tb, b, R);
+}
+double SPICA(int n, Point r, double R)
+{
+    int i;
+    Point ori, p[2];
+    scanf("%lf%lf", &ori.x, &ori.y);
+    p[0] = ori;
+    double res = 0, if_clock_t;
+    for(i = 1; i <= n; ++ i)
+    {
+        if(i == n) p[i & 1] = ori;
+        else scanf("%lf%lf", &p[i & 1].x, &p[i & 1].y);
+        if_clock_t = dcmp(r.cross(p[~i & 1], p[i & 1]));
+        if(if_clock_t < 0) res -= TACIA(r, p[i & 1], p[~i & 1], R);
+        else res += TACIA(r, p[~i & 1], p[i & 1], R);
+    }
+    return fabs(res);
+}
+Point boom;
+int n;
+double R;
+int main()
+{
+    double sx, sy, h, vx, vy;
+    while(scanf("%lf%lf%lf", &sx, &sy, &h) != EOF)
+    {
+        scanf("%lf%lf%lf", &vx, &vy, &R);
+        h = sqrt(2 * h / 10);
+        boom = Point(h * vx + sx, h * vy + sy);
+        scanf("%d", &n);
+        printf("%.2f\n", SPICA(n, boom, R));
+    }
+    return 0;
+}
diff --git a/HDOJ/2894_autoAC.cpp b/HDOJ/2894_autoAC.cpp
new file mode 100644
index 0000000..186f0f4
--- /dev/null
+++ b/HDOJ/2894_autoAC.cpp
@@ -0,0 +1,65 @@
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <cstring>
+using namespace std;
+bool fg,d[1<<15],vis[1<<15];
+int tot,k;
+void read()
+{
+    memset(vis,0,sizeof vis);
+    fg=false;
+    tot=1<<k;
+}
+bool check()
+{
+    int i=1,j=tot+1;
+    for(;i<=k-1;i++,j++)
+    {
+        if(d[i]!=d[j]) return false;
+    }
+    fg=true;
+    for(i=1;i<=tot;i++) printf("%d",d[i]);
+}
+void dfs(int step,int num)
+{
+    if(fg) return;
+    if(step==tot)
+    {
+        check();
+        return;
+    }
+    for(int i=0;i<tot;i++)
+    {
+        if(!vis[i])
+        {
+            int sk;
+            if((num>>(k-1))==1) sk=num-(1<<(k-1));
+            else sk=num;
+            if(sk==(i>>1))
+            {
+                d[step+k]=i&1;
+                vis[i]=true;
+                dfs(step+1,i);
+                vis[i]=false;
+            }
+        }
+    }
+}
+void go()
+{
+    printf("%d ",tot);
+    for(int i=1;i<=k;i++) d[i]=0;
+    vis[0]=true;
+    dfs(1,0);
+    printf("\n");
+}
+int main()
+{
+    while(scanf("%d",&k)!=EOF)
+    {
+        read();
+        go();
+    }
+    return 0;
+}
diff --git a/HDOJ/2895_autoAC.cpp b/HDOJ/2895_autoAC.cpp
new file mode 100644
index 0000000..605b2d9
--- /dev/null
+++ b/HDOJ/2895_autoAC.cpp
@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <string.h>
+char p1[10001],p2[10001];
+int main()
+{
+    int i,j,len1,len2;
+    while(scanf("%s%s",p1,p2)!=EOF)
+    {
+        len1 = strlen(p1);
+        len2 = strlen(p2);
+        if(len1 > len2)
+        {
+            for(i = 0;i <= len1-len2-1;i ++)
+            printf("d %c\n",p1[i]);
+            for(j = 0;j <= len2-1;j ++)
+            {
+                printf("m %c\n",p2[j]);
+            }
+        }
+        else if(len1 == len2)
+        {
+            for(i = 0;i <= len2-1;i ++)
+            {
+                printf("m %c\n",p2[i]);
+            }
+        }
+        else if(len1 < len2)
+        {
+            for(i = 0;i <= len2-len1-1;i ++)
+            printf("a %c\n",p2[i]);
+            for(j = len2-len1;j <= len2-1;j ++)
+            printf("m %c\n",p2[j]);
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2896_autoAC.cpp b/HDOJ/2896_autoAC.cpp
new file mode 100644
index 0000000..99896ef
--- /dev/null
+++ b/HDOJ/2896_autoAC.cpp
@@ -0,0 +1,110 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+const int N=130;
+int n,m,tag[520];
+struct Trie{
+    int count;      
+    Trie *fail;     
+    Trie *next[N];
+    Trie(){     
+        count=0;
+        fail=NULL;
+        memset(next,NULL,sizeof(next));
+    }
+}*q[5000010];      
+char word[520];    
+char str[1000010];  
+int head,tail;      
+void Insert(char *str,Trie *Root,int id){
+    Trie *loc=Root;
+    int i=0;
+    while(str[i]!='\0'){
+        int id=str[i]-31;
+        if(loc->next[id]==NULL)
+            loc->next[id]=new Trie();
+        loc=loc->next[id];
+        i++;
+    }
+    loc->count=id;      
+}
+void AC_automation(Trie *Root){
+    Root->fail=NULL;
+    q[head++]=Root;
+    Trie *cur,*tmp;
+    while(head!=tail){
+        cur=q[tail++];      
+        tmp=NULL;
+        for(int i=0;i<N;i++){
+            if(cur->next[i]!=NULL){     
+                if(cur==Root)   
+                    cur->next[i]->fail=Root;
+                else{   
+                    tmp=cur->fail;  
+                    while(tmp!=NULL){
+                        if(tmp->next[i]!=NULL){     
+                            cur->next[i]->fail=tmp->next[i];    
+                            break;
+                        }
+                        tmp=tmp->fail;  
+                    }
+                    if(tmp==NULL)       
+                        cur->next[i]->fail=Root;    
+                }
+                q[head++]=cur->next[i]; 
+            }
+        }
+    }
+}
+int query(Trie *Root){
+    int i=0,cnt=0;
+    Trie *loc=Root,*tmp;
+    while(str[i]!='\0'){
+        int id=str[i]-31;   
+        while(loc->next[id]==NULL && loc!=Root){
+            loc=loc->fail;  
+        }
+        loc=loc->next[id];      
+        loc=(loc==NULL)?Root:loc;
+        tmp=loc;
+        while(tmp!=Root && tmp->count!=0){
+            if(tmp->count!=0 && !tag[tmp->count]){  
+                cnt++;
+                tag[tmp->count]=1;
+            }
+            tmp=tmp->fail;
+        }
+        i++;
+    }
+    return cnt;
+}
+int main(){
+    while(scanf("%d",&n)!=EOF){
+        head=tail=0;
+        Trie *Root=new Trie();
+        getchar();
+        for(int i=1;i<=n;i++){
+            gets(word);
+            Insert(word,Root,i);
+        }
+        AC_automation(Root);
+        scanf("%d",&m);
+        int total=0;
+        for(int i=1;i<=m;i++){
+            memset(tag,0,sizeof(tag));
+            scanf("%s",str);
+            int flag=query(Root);
+            if(flag){
+                printf("web %d:",i);
+                for(int j=1;j<=n;j++)
+                    if(tag[j])
+                        printf(" %d",j);
+                printf("\n");
+                total++;
+            }
+        }
+        printf("total: %d\n",total);
+    }
+    return 0;
+}
diff --git a/HDOJ/2897_autoAC.cpp b/HDOJ/2897_autoAC.cpp
new file mode 100644
index 0000000..2ecf287
--- /dev/null
+++ b/HDOJ/2897_autoAC.cpp
@@ -0,0 +1,19 @@
+#include<iostream>
+#include<cstdio>
+#include<cstring>
+using namespace std;
+int main(){
+    int n,p,q;
+    while(~scanf("%d%d%d",&n,&p,&q)){
+        if(n%(p+q)==0){
+            puts("WIN");
+        }else {
+            int tmp=n%(p+q);
+            if(tmp<=p){
+                puts("LOST");
+            }else
+                puts("WIN");
+        }
+    }
+    return 0;
+}
diff --git a/HDOJ/2898_autoAC.cpp b/HDOJ/2898_autoAC.cpp
new file mode 100644
index 0000000..eda06e5
--- /dev/null
+++ b/HDOJ/2898_autoAC.cpp
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+struct node
+{
+    double x,y,z;
+}p,q,r,t,t2,t3,t4,t5;
+int main()
+{
+    double a,b,hu;
+    while(~scanf("%lf%lf%lf",&p.x,&p.y,&p.z))
+    {
+        scanf("%lf%lf%lf",&q.x,&q.y,&q.z);
+        scanf("%lf",&hu);
+        a=atan(q.y/q.x);
+        r.x=sqrt(q.x*q.x+q.y*q.y);
+        r.y=0;
+        r.z=q.z;
+        b=atan(r.x/r.z);
+        t.x=p.x*cos(a)+p.y*sin(a);
+        t.y=-p.x*sin(a)+p.y*cos(a);
+        t.z=p.z;
+        t2.x=t.x*cos(b)-t.z*sin(b);
+        t2.z=t.x*sin(b)+t.z*cos(b);
+        t2.y=t.y;
+        t3.x=t2.x*cos(hu)-t2.y*sin(hu);
+        t3.y=t2.x*sin(hu)+t2.y*cos(hu);
+        t3.z=t2.z;
+        t4.x=t3.x*cos(b)+t3.z*sin(b);
+        t4.z=-t3.x*sin(b)+t3.z*cos(b);
+        t4.y=t3.y;
+        t5.x=t4.x*cos(a)-t4.y*sin(a);
+        t5.y=t4.x*sin(a)+t4.y*cos(a);
+        t5.z=t4.z;
+        printf("%.3lf %.3lf %.3lf\n",t5.x,t5.y,t5.z);
+    }
+    return 0;
+}
diff --git a/HDOJ/2899_autoAC.cpp b/HDOJ/2899_autoAC.cpp
new file mode 100644
index 0000000..b205d18
--- /dev/null
+++ b/HDOJ/2899_autoAC.cpp
@@ -0,0 +1,46 @@
+#include<cstdio>
+#include<cstring>
+#include<iostream>
+#include<utility>
+#include<string>
+#include<vector>
+#include<algorithm>
+#include<queue>
+#include<cstdlib>
+#include<cmath>
+using namespace std;
+const double eps=1e-8;
+int y;
+double g(double x)
+{
+    return 42*pow(x,6)+48*pow(x,5)+21*pow(x,2)+10*x;
+}
+double f(double x)
+{
+    return 6*pow(x,7)+8*pow(x,6)+7*pow(x,3)+5*pow(x,2)-y*x;
+}
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    while(T--)
+    {
+        scanf("%d",&y);
+        if(g(100.0)-y<=0)
+        {
+            printf("%.4lf\n",f(100.0));
+            continue;
+        }
+        double l=0,r=100,m;
+        while(l+eps<=r)
+        {
+            m=(l+r)/2;
+            if(g(m)-y<0)
+                l=m;
+            else
+                r=m;
+        }
+        printf("%.4lf\n",f(m));
+    }
+    return 0;
+}