├── .gitattributes
├── BestCoder
    ├── BC18
    │   ├── B.cpp
    │   └── C.cpp
    └── BC26
    │   ├── A.cpp
    │   ├── B.cpp
    │   └── C.cpp
├── SGU
    ├── SGU191.cpp
    ├── SGU192.cpp
    ├── SGU193.java
    ├── SGU194.cpp
    ├── SGU195.cpp
    ├── SGU196.cpp
    ├── SGU197.java
    ├── SGU198.cpp
    └── SGU199.cpp
├── ZOJ
    └── ZOJ_Monthly_January_2015
    │   ├── B.cpp
    │   ├── E.cpp
    │   ├── F.cpp
    │   ├── G.cpp
    │   └── H.cpp
├── hihoCoder
    └── hihoCoder6
    │   ├── A.cpp
    │   ├── B.cpp
    │   └── C.cpp
└── kuangbin的ACM模板（新）.pdf


/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | *.sln    merge=union
 7 | *.csproj merge=union
 8 | *.vbproj merge=union
 9 | *.fsproj merge=union
10 | *.dbproj merge=union
11 | 
12 | # Standard to msysgit
13 | *.doc	 diff=astextplain
14 | *.DOC	 diff=astextplain
15 | *.docx diff=astextplain
16 | *.DOCX diff=astextplain
17 | *.dot  diff=astextplain
18 | *.DOT  diff=astextplain
19 | *.pdf  diff=astextplain
20 | *.PDF	 diff=astextplain
21 | *.rtf	 diff=astextplain
22 | *.RTF	 diff=astextplain
23 | 


--------------------------------------------------------------------------------
/BestCoder/BC18/B.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kuangbin/ACM-ICPC/7467e173d4eab8fdaea0982426cbace8197be737/BestCoder/BC18/B.cpp


--------------------------------------------------------------------------------
/BestCoder/BC18/C.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2014/11/8 20:19:07
 4 | File Name     :BC18\C.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | const int MAXN = 100010;
21 | struct Edge{
22 | 	int to,next;
23 | }edge[MAXN*2];
24 | int head[MAXN],tot;
25 | void init(){
26 | 	tot = 0;
27 | 	memset(head,-1,sizeof(head));
28 | }
29 | inline void addedge(int u,int v){
30 | 	edge[tot].to = v;
31 | 	edge[tot].next = head[u];
32 | 	head[u] = tot++;
33 | }
34 | struct Node{
35 | 	int u,pre,dis;
36 | 	Node(int _u = 0,int _pre = 0,int _dis = 0){
37 | 		u = _u;
38 | 		pre = _pre;
39 | 		dis = _dis;
40 | 	}
41 | };
42 | queue<Node>q;
43 | 
44 | int main()
45 | {
46 |     //freopen("in.txt","r",stdin);
47 |     //freopen("out.txt","w",stdout);
48 |     int T;
49 | 	int n,k;
50 | 	scanf("%d",&T);
51 | 	while(T--){
52 | 		scanf("%d%d",&n,&k);
53 | 		k *= 2;
54 | 		init();
55 | 		int u,v;
56 | 		for(int i = 1;i < n;i++){
57 | 			scanf("%d%d",&u,&v);
58 | 			addedge(u,v);
59 | 			addedge(v,u);
60 | 		}
61 | 		while(!q.empty())q.pop();
62 | 		for(int i = 1;i <= n;i++)
63 | 			q.push(Node(i,i,0));
64 | 		int cnt = 0;
65 | 		long long ans = 0;
66 | 		if(k == 0){
67 | 			printf("0\n");
68 | 			continue;
69 | 		}
70 | 		while(!q.empty()){
71 | 			Node tmp = q.front();
72 | 			q.pop();
73 | 			u = tmp.u;
74 | 			for(int i = head[u];i != -1;i = edge[i].next){
75 | 				v = edge[i].to;
76 | 				if(v == tmp.pre)continue;
77 | 				ans += tmp.dis+1;
78 | 				cnt++;
79 | 				if(cnt >= k)break;
80 | 				q.push(Node(v,u,tmp.dis+1));
81 | 			}
82 | 			if(cnt >= k)break;
83 | 		}
84 | 		printf("%I64d\n",ans/2);
85 | 	}
86 |     return 0;
87 | }
88 | 


--------------------------------------------------------------------------------
/BestCoder/BC26/A.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2015/1/10 18:58:02
 4 | File Name     :BC26\A.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | 
21 | int main()
22 | {
23 |     //freopen("in.txt","r",stdin);
24 |     //freopen("out.txt","w",stdout);
25 |     int n,m;
26 | 	while(scanf("%d%d",&n,&m) == 2)
27 | 		printf("%d\n",(m-1)%n);
28 |     return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/BestCoder/BC26/B.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2015/1/10 19:05:55
 4 | File Name     :BC26\B.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | int C[10][10];
21 | 
22 | int main()
23 | {
24 |     //freopen("in.txt","r",stdin);
25 |     //freopen("out.txt","w",stdout);
26 | 	C[0][0] = 1;
27 | 	for(int i = 1;i < 10;i++){
28 | 		C[i][0] = C[i][i] = 1;
29 | 		for(int j = 1;j < i;j++)
30 | 			C[i][j] = C[i-1][j] + C[i-1][j-1];
31 | 	}
32 | 	int T;
33 |    int a,b;
34 | 	scanf("%d",&T);   
35 | 	int iCase = 0;
36 | 	while(T--){
37 | 		iCase++;
38 | 		scanf("%d%d",&a,&b);
39 | 		double tmp = 0.0;
40 | 		for(int i = 1;i <= b;i++){
41 | 			tmp += (double)C[b][i]*pow((double)(a-1),(double)(b-i));
42 | 		}
43 | 		tmp /= 2;
44 | 		for(int i = 1;i < b;i++)tmp /= a;
45 | 		tmp *= (a+1);
46 | 		//printf("%.3lf\n",tmp);
47 | 		double ans = (1-pow((double)(a-1)/a,(double)b))*a*(a+1)/2;
48 | 		printf("Case #%d: %.3lf\n",iCase,ans);
49 | 	}
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/BestCoder/BC26/C.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2015/1/10 20:20:47
 4 | File Name     :BC26\C.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | const int MOD = 1e9+7;
21 | const int MAXN = 100010;
22 | long long pow_m(long long a,long long n){
23 | 	long long ret = 1;
24 | 	long long tmp = a%MOD;
25 | 	while(n){
26 | 		if(n&1)ret = ret*tmp%MOD;
27 | 		tmp = tmp*tmp%MOD;
28 | 		n >>= 1;
29 | 	}
30 | 	return ret;
31 | }
32 | long long p[MAXN];
33 | long long rp[MAXN];
34 | long long C(int n,int m){
35 | 	long long ret = p[n]*rp[m]%MOD*rp[n-m]%MOD;
36 | 	return ret;
37 | }
38 | int a[MAXN];
39 | 
40 | int main()
41 | {
42 |     //freopen("in.txt","r",stdin);
43 |     //freopen("out.txt","w",stdout);
44 |     p[0] = 1;
45 | 	rp[0] = 1;
46 | 	for(int i = 1;i < MAXN;i++){
47 | 		p[i] = p[i-1]*i%MOD;
48 | 		rp[i] = pow_m(p[i],MOD-2);
49 | 	}
50 | 	int T;
51 | 	int n;
52 | 	scanf("%d",&T);
53 | 	int iCase = 0;
54 | 	while(T--){
55 | 		iCase++;
56 | 		scanf("%d",&n);
57 | 		map<int,int>mp;
58 | 		for(int i = 0;i < n;i++){
59 | 			scanf("%d",&a[i]);
60 | 			mp[a[i]]++;
61 | 		}
62 | 		int c0 = 0 , c1 = 0;
63 | 		long long tmp1 = 1, tmp2 = 1;
64 | 		map<int,int>::iterator it;
65 | 		for(it = mp.begin();it != mp.end();it++){
66 | 			int val = it->first;
67 | 			int cc = it->second;
68 | 			c1 += cc;
69 | 			tmp2 = tmp2*rp[cc]%MOD;
70 | 		}
71 | 		long long ans = 0;
72 | 		for(it = mp.begin();it != mp.end();it++){
73 | 			int val = it->first;
74 | 			int cc = it->second;
75 | 			c1 -= cc;
76 | 			tmp2 = tmp2*p[cc]%MOD;
77 | 			for(int i = 0;i < cc;i++){
78 | 				long long tt = C(cc-i+c1-1,c1)*p[c1]%MOD*tmp2%MOD;
79 | 				tt = tt*C(n-c0+1+c0-1,c0)%MOD*p[c0]%MOD*tmp1%MOD;
80 | 				ans += tt*val%MOD;
81 | 				ans%=MOD;
82 | 			}
83 | 			c0 += cc;
84 | 			tmp1 = tmp1*rp[cc]%MOD;
85 | 		}
86 | 		printf("Case #%d: %d\n",iCase,(int)ans);
87 | 	}
88 |     return 0;
89 | }
90 | 


--------------------------------------------------------------------------------
/SGU/SGU191.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2015/1/25 12:58:24
 4 | File Name     :E:\2014ACM\SGU\SGU191.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | const int MAXN = 30010;
21 | char str[MAXN];
22 | int sta[MAXN];
23 | 
24 | int main()
25 | {
26 |     //freopen("in.txt","r",stdin);
27 |     //freopen("out.txt","w",stdout);
28 |     while(scanf("%s",str) == 1){
29 | 		int cnt = 0;
30 | 		sta[0] = 1;
31 | 		sta[1] = 0;
32 | 		cnt = 1;
33 | 		sta[cnt++] = 1-sta[cnt-1];
34 | 		printf("%d\n",sta[1]);
35 | 		cnt = 0;
36 | 		sta[cnt++] = (str[0]=='B');
37 | 		scanf("%s",str);
38 | 		int len = strlen(str);
39 | 		int i = 0;
40 | 		while(i < len && cnt > 0){
41 | 			if(sta[cnt-1] == (str[i]=='A'))cnt--;
42 | 			else {
43 | 				sta[cnt++] = (str[i]=='A');
44 | 			}
45 | 			i++;
46 | 		}
47 | 		if(i == len && cnt == 0)printf("YES\n");
48 | 		else printf("NO\n");
49 | 	}
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/SGU/SGU192.cpp:
--------------------------------------------------------------------------------
  1 | /* ***********************************************
  2 | Author        :kuangbin
  3 | Created Time  :2015/1/21 18:18:18
  4 | File Name     :E:\2014ACM\SGU\SGU192.cpp
  5 | ************************************************ */
  6 | 
  7 | #include <stdio.h>
  8 | #include <string.h>
  9 | #include <iostream>
 10 | #include <algorithm>
 11 | #include <vector>
 12 | #include <queue>
 13 | #include <set>
 14 | #include <map>
 15 | #include <string>
 16 | #include <math.h>
 17 | #include <stdlib.h>
 18 | #include <time.h>
 19 | using namespace std;
 20 | const double eps = 1e-8;
 21 | int sgn(double x){
 22 | 	if(fabs(x) < eps)return 0;
 23 | 	if(x < 0)return -1;
 24 | 	else return 1;
 25 | }
 26 | struct Point{
 27 | 	double x,y;
 28 | 	Point(){}
 29 | 	Point(double _x,double _y){
 30 | 		x = _x;
 31 | 		y = _y;
 32 | 	}
 33 | 	void input(){
 34 | 		scanf("%lf%lf",&x,&y);
 35 | 	}
 36 | 	Point operator -(const Point &b)const{
 37 | 		return Point(x-b.x,y-b.y);
 38 | 	}
 39 | 	double operator ^(const Point &b)const{
 40 | 		return x*b.y - y*b.x;
 41 | 	}
 42 | 	double operator *(const Point &b)const{
 43 | 		return x*b.x + y*b.y;
 44 | 	}
 45 | };
 46 | struct Line{
 47 | 	Point s,e;
 48 | 	int type;
 49 | 	int get_type(char ch){
 50 | 		if(ch == 'R')return 0;
 51 | 		else if(ch == 'G')return 1;
 52 | 		else return 2;
 53 | 	}
 54 | 	void input(){
 55 | 		s.input();
 56 | 		e.input();
 57 | 		if(s.x > e.x)swap(s,e);
 58 | 		char ss[3];
 59 | 		scanf("%s",ss);
 60 | 		type = get_type(ss[0]);
 61 | 	}
 62 | 	int segcrossseg(Line v){
 63 | 		int d1 = sgn((e-s)^(v.s-s));
 64 | 		int d2 = sgn((e-s)^(v.e-s));
 65 | 		int d3 = sgn((v.e-v.s)^(s-v.s));
 66 | 		int d4 = sgn((v.e-v.s)^(e-v.s));
 67 | 		if( (d1^d2) == -2 && (d3^d4) == -2 )return 2;
 68 | 		return (d1 == 0 && sgn((v.s-s)*(v.s-e)) <=0) ||
 69 | 			(d2 == 0 && sgn((v.e-s)*(v.e-e)) <= 0) ||
 70 | 			(d3 == 0 && sgn((s-v.s)*(s-v.e)) <= 0) ||
 71 | 			(d4 == 0 && sgn((e-v.s)*(e-v.e)) <= 0);
 72 | 	}
 73 | 	Point crosspoint(Line v){
 74 | 		double a1 = (v.e-v.s)^(s-v.s);
 75 | 		double a2 = (v.e-v.s)^(e-v.s);
 76 | 		return Point((s.x*a2-e.x*a1)/(a2-a1),(s.y*a2-e.y*a1)/(a2-a1));
 77 | 	}
 78 | };
 79 | Line line[330];
 80 | double x[160000];
 81 | 
 82 | int main()
 83 | {
 84 |     //freopen("in.txt","r",stdin);
 85 |     //freopen("out.txt","w",stdout);
 86 |     int n;
 87 | 	while(scanf("%d",&n) == 1){
 88 | 		int cnt = 0;
 89 | 		for(int i = 0;i < n;i++){
 90 | 			line[i].input();
 91 | 			x[cnt++] = line[i].s.x;
 92 | 			x[cnt++] = line[i].e.x;
 93 | 		}
 94 | 		for(int i = 0;i < n;i++)
 95 | 			for(int j = i+1;j < n;j++)
 96 | 				if(line[i].segcrossseg(line[j]) == 2){
 97 | 					Point tmp = line[i].crosspoint(line[j]);
 98 | 					x[cnt++] = tmp.x;
 99 | 				}
100 | 		sort(x,x+cnt);
101 | 		cnt = unique(x,x+cnt)-x;
102 | 		double ans[3];
103 | 		ans[0] = ans[1] = ans[2] = 0;
104 | 		for(int i = 0;i < cnt-1;i++){
105 | 			if(fabs(x[i+1]-x[i]) < eps)continue;
106 | 			double xx = (x[i]+x[i+1])/2;
107 | 			double now;
108 | 			int tt = -1;
109 | 			for(int j = 0;j < n;j++){
110 | 				if(line[j].s.x < xx && xx < line[j].e.x){
111 | 					double yy = line[j].s.y + (xx-line[j].s.x)*(line[j].e.y-line[j].s.y)/(line[j].e.x-line[j].s.x);
112 | 					if(tt == -1){
113 | 						tt = line[j].type;
114 | 						now = yy;
115 | 					}
116 | 					else if(now > yy){
117 | 						tt = line[j].type;
118 | 						now = yy;
119 | 					}
120 | 				}
121 | 			}
122 | 			if(tt != -1){
123 | 				ans[tt] += x[i+1]-x[i];
124 | 			}
125 | 		}
126 | 		printf("R %.2lf\n",ans[0]);
127 | 		printf("G %.2lf\n",ans[1]);
128 | 		printf("B %.2lf\n",ans[2]);
129 | 	}
130 |     return 0;
131 | }
132 | 


--------------------------------------------------------------------------------
/SGU/SGU193.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | import java.math.*;
 3 | 
 4 | public class Solution
 5 | {
 6 | 	public static void main(String []arg){
 7 | 		Scanner cin = new Scanner(System.in);
 8 | 		BigInteger n = cin.nextBigInteger();
 9 | 		if(n.mod(BigInteger.valueOf(2)).equals(BigInteger.ONE)){
10 | 			System.out.println(n.divide(BigInteger.valueOf(2)));
11 | 		}
12 | 		else {
13 | 			BigInteger n2 = n.divide(BigInteger.valueOf(2));
14 | 			n2 = n2.subtract(BigInteger.ONE);
15 | 			if(n2.mod(BigInteger.valueOf(2)).equals(BigInteger.ZERO))
16 | 				n2 = n2.subtract(BigInteger.ONE);
17 | 			System.out.println(n2);
18 | 		}
19 | 	}
20 | }
21 | 
22 | 


--------------------------------------------------------------------------------
/SGU/SGU194.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kuangbin/ACM-ICPC/7467e173d4eab8fdaea0982426cbace8197be737/SGU/SGU194.cpp


--------------------------------------------------------------------------------
/SGU/SGU195.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2014/11/28 18:42:49
 4 | File Name     :E:\2014ACM\SGU\SGU195.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | const int MAXN = 500010;
21 | int fa[MAXN];
22 | bool vis[MAXN];
23 | 
24 | int main()
25 | {
26 |     //freopen("in.txt","r",stdin);
27 |     //freopen("out.txt","w",stdout);
28 |     int n;
29 | 	while(scanf("%d",&n) == 1){
30 | 		fa[1] = 1;
31 | 		for(int i = 2;i <= n;i++){
32 | 			scanf("%d",&fa[i]);
33 | 		}
34 | 		vector<int>ans;
35 | 		memset(vis,false,sizeof(vis));
36 | 		for(int i = n;i > 1;i--){
37 | 			int u = i;
38 | 			if(vis[u] || vis[fa[u]])continue;
39 | 			ans.push_back(u);
40 | 			vis[u] = true;
41 | 			vis[fa[u]] = true;
42 | 		}
43 | 		sort(ans.begin(),ans.end());
44 | 		int sz = ans.size();
45 | 		printf("%d\n",sz*1000);
46 | 		for(int i = 0;i < sz;i++){
47 | 			printf("%d",ans[i]);
48 | 			if(i < sz-1)printf(" ");
49 | 			else printf("\n");
50 | 		}
51 | 	}
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/SGU/SGU196.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2014/11/21 22:57:16
 4 | File Name     :E:\2014ACM\SGU\SGU196.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | int du[10010];
21 | 
22 | int main()
23 | {
24 |     //freopen("in.txt","r",stdin);
25 |     //freopen("out.txt","w",stdout);
26 |     int n,m;
27 | 	while(scanf("%d%d",&n,&m) == 2){
28 | 		memset(du,0,sizeof(du));
29 | 		int u,v;
30 | 		while(m--){
31 | 			scanf("%d%d",&u,&v);
32 | 			du[u]++;
33 | 			du[v]++;
34 | 		}
35 | 		int ans = 0;
36 | 		for(int i = 1;i <= n;i++)
37 | 			ans += du[i]*du[i];
38 | 		printf("%d\n",ans);
39 | 	}
40 |     return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/SGU/SGU197.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | import java.math.*;
 3 | 
 4 | public class Solution
 5 | {
 6 | 	static int P;
 7 | 	static Matrix pow_M(Matrix a,BigInteger n){
 8 | 		Matrix ret = new Matrix();
 9 | 		Matrix tmp = a;
10 | 		ret.init(a.n,P);
11 | 		for(int i = 0;i < a.n;i++)
12 | 			ret.mat[i][i] = 1;
13 | 		while(!n.equals(BigInteger.ZERO)){
14 | 			if(n.mod(BigInteger.valueOf(2)).equals(BigInteger.ONE))
15 | 				ret = ret.mul(tmp);
16 | 			tmp = tmp.mul(tmp);
17 | 			n = n.divide(BigInteger.valueOf(2));
18 | 		}
19 | 		return ret;
20 | 	}
21 | 	static boolean check(int s1,int s2,int n){
22 | 		for(int i = 0;i < n-1;i++){
23 | 			if( (s1&(1<<i)) == 0 && (s1&(1<<(i+1))) == 0 
24 | 					&& (s2&(1<<i)) == 0 && (s2&(1<<(i+1))) == 0)
25 | 				return false;
26 | 			if( (s1&(1<<i)) > 0 && (s1&(1<<(i+1))) > 0 
27 | 					&& (s2&(1<<i)) > 0 && (s2&(1<<(i+1))) > 0)
28 | 				return false;
29 | 		}
30 | 		return true;
31 | 	}
32 | 	public static void main(String[] args)
33 | 	{
34 | 		// TODO Auto-generated method stub
35 | 		Scanner cin = new Scanner(System.in);
36 | 		BigInteger n;
37 | 		int m;
38 | 		while(cin.hasNext()){
39 | 			n = cin.nextBigInteger();
40 | 			m = cin.nextInt();
41 | 			P = cin.nextInt();
42 | 			Matrix a = new Matrix();
43 | 			a.init(1<<m,P);
44 | 			for(int i = 0;i < (1<<m);i++)
45 | 				for(int j = 0;j < (1<<m);j++)
46 | 					if(check(i,j,m))
47 | 						a.mat[i][j] = 1;
48 | 			a = pow_M(a,n.subtract(BigInteger.ONE));
49 | 			int ans = 0;
50 | 			for(int i = 0;i < (1<<m);i++)
51 | 				for(int j = 0;j < (1<<m);j++){
52 | 					ans = ans + a.mat[i][j];
53 | 					ans = ans%P;
54 | 				}
55 | 			System.out.println(ans);
56 | 		}
57 | 		cin.close();
58 | 	}
59 | }
60 | class Matrix{
61 | 	static int P;
62 | 	int [][]mat = new int[100][100];
63 | 	int n;
64 | 	void init(int _n,int _p){
65 | 		n = _n;
66 | 		P = _p;
67 | 		for(int i = 0;i < n;i++)
68 | 			for(int j = 0;j < n;j++)
69 | 				mat[i][j] = 0;
70 | 	}
71 | 	Matrix mul(Matrix b){
72 | 		Matrix ret = new Matrix();
73 | 		ret.init(n,P);
74 | 		for(int i = 0;i < n;i++)
75 | 			for(int j = 0;j < n;j++){
76 | 				for(int k = 0;k < n;k++){
77 | 					ret.mat[i][j] = ret.mat[i][j] + mat[i][k]*b.mat[k][j]%P;
78 | 					ret.mat[i][j] %= P;
79 | 				}
80 | 			}
81 | 		return ret;
82 | 	}
83 | }
84 | 


--------------------------------------------------------------------------------
/SGU/SGU198.cpp:
--------------------------------------------------------------------------------
  1 | /* ***********************************************
  2 | Author        :kuangbin
  3 | Created Time  :2014/11/10 20:16:21
  4 | File Name     :D:\github\ACM-ICPC\SGU\SGU198.cpp
  5 | ************************************************ */
  6 | 
  7 | #include <stdio.h>
  8 | #include <string.h>
  9 | #include <iostream>
 10 | #include <algorithm>
 11 | #include <vector>
 12 | #include <queue>
 13 | #include <set>
 14 | #include <map>
 15 | #include <string>
 16 | #include <math.h>
 17 | #include <stdlib.h>
 18 | #include <time.h>
 19 | using namespace std;
 20 | const double eps = 1e-8;
 21 | const int MAXN = 310;
 22 | struct Circle{
 23 | 	double x,y,r;
 24 | 	Circle(double _x = 0,double _y = 0,double _r = 0){
 25 | 		x = _x; y = _y; r = _r;
 26 | 	}
 27 | 	void input(){
 28 | 		scanf("%lf%lf%lf",&x,&y,&r);
 29 | 	}
 30 | 	bool check(Circle b){
 31 | 		double d = hypot(x-b.x,y-b.y);
 32 | 		return d < r + b.r - eps;
 33 | 	}
 34 | 	Circle operator -(const Circle &b)const{
 35 | 		return Circle(x-b.x,y-b.y,0);
 36 | 	}
 37 | 	double operator *(const Circle &b)const{
 38 | 		return x*b.x + y*b.y;
 39 | 	}
 40 | 	double operator ^(const Circle &b)const{
 41 | 		return x*b.y - y*b.x;
 42 | 	}
 43 | }circle[MAXN];
 44 | Circle p0;
 45 | double rad(Circle a,Circle b){
 46 | 	return atan2((a-p0)^(b-p0),(a-p0)*(b-p0));
 47 | }
 48 | 
 49 | struct Edge{
 50 | 	int to,next;
 51 | 	double w;
 52 | }edge[MAXN*MAXN];
 53 | int head[MAXN],tot;
 54 | void init(){
 55 | 	tot = 0;
 56 | 	memset(head,-1,sizeof(head));
 57 | }
 58 | inline void addedge(int u,int v,double w){
 59 | 	edge[tot].to = v;
 60 | 	edge[tot].w = w;
 61 | 	edge[tot].next = head[u];
 62 | 	head[u] = tot++;
 63 | }
 64 | double dist[MAXN];
 65 | bool vis[MAXN];
 66 | int cnt[MAXN];
 67 | bool SPFA(int n){
 68 | 	for(int i = 0;i < n;i++){
 69 | 		dist[i] = 0.0;
 70 | 		vis[i] = false;
 71 | 		cnt[i] = 0;
 72 | 	}
 73 | 	queue<int>q;
 74 | 	for(int i = 0;i < n;i++){
 75 | 		vis[i] = true;
 76 | 		q.push(i);
 77 | 		cnt[i]++;
 78 | 	}
 79 | 	while(!q.empty()){
 80 | 		int u = q.front();
 81 | 		q.pop();
 82 | 		vis[u] = false;
 83 | 		for(int i = head[u];i != -1;i = edge[i].next){
 84 | 			int v = edge[i].to;
 85 | 			double w = edge[i].w;
 86 | 			if(dist[u] + w < dist[v] - eps){
 87 | 				dist[v] = dist[u] + w;
 88 | 				if(!vis[v]){
 89 | 					vis[v] = true;
 90 | 					cnt[v]++;
 91 | 					q.push(v);
 92 | 					if(cnt[v] > n)return false;
 93 | 				}
 94 | 			}
 95 | 		}
 96 | 	}
 97 | 	return true;
 98 | }
 99 | 
100 | int main()
101 | {
102 |     //freopen("in.txt","r",stdin);
103 |     //freopen("out.txt","w",stdout);
104 |     int n;
105 | 	while(scanf("%d",&n) == 1){
106 | 		for(int i = 0;i < n;i++)
107 | 			circle[i].input();
108 | 		p0.input();
109 | 		for(int i = 0;i < n;i++)
110 | 			circle[i].r += p0.r;
111 | 		init();
112 | 		for(int i = 0;i < n;i++)
113 | 			for(int j = 0;j < n;j++)
114 | 				if(i != j){
115 | 					if(circle[i].check(circle[j]))
116 | 						addedge(i,j,rad(circle[i],circle[j]));
117 | 				}
118 | 		if(SPFA(n))printf("YES\n");
119 | 		else printf("NO\n");
120 | 	}
121 |     return 0;
122 | }
123 | 


--------------------------------------------------------------------------------
/SGU/SGU199.cpp:
--------------------------------------------------------------------------------
  1 | /* ***********************************************
  2 | Author        :kuangbin
  3 | Created Time  :2014/11/4 11:37:23
  4 | File Name     :E:\2014ACM\SGU\SGU199.cpp
  5 | ************************************************ */
  6 | 
  7 | #include <stdio.h>
  8 | #include <string.h>
  9 | #include <iostream>
 10 | #include <algorithm>
 11 | #include <vector>
 12 | #include <queue>
 13 | #include <set>
 14 | #include <map>
 15 | #include <string>
 16 | #include <math.h>
 17 | #include <stdlib.h>
 18 | #include <time.h>
 19 | using namespace std;
 20 | const int MAXN = 100010;
 21 | int dp[MAXN];
 22 | int c[MAXN];
 23 | int cnt;
 24 | int lowbit(int x){
 25 | 	return x&(-x);
 26 | }
 27 | void add(int x,int id){
 28 | 	int i = x;
 29 | 	while(i <= cnt){
 30 | 		if(dp[id] > dp[c[i]])
 31 | 			c[i] = id;
 32 | 		i += lowbit(i);
 33 | 	}
 34 | }
 35 | int query(int i){
 36 | 	int ret = 0;
 37 | 	while(i > 0){
 38 | 		if(dp[c[i]] > dp[ret])ret = i;
 39 | 		i -=lowbit(i);
 40 | 	}
 41 | 	return ret;
 42 | }
 43 | struct Node{
 44 | 	int x,y;
 45 | 	int index;
 46 | 	bool operator <(const Node &b)const{
 47 | 		return x < b.x || (x == b.x && y < b.y);
 48 | 	}
 49 | }node[MAXN];
 50 | int yy[MAXN];
 51 | int pre[MAXN];
 52 | 
 53 | int main()
 54 | {
 55 |     //freopen("in.txt","r",stdin);
 56 |     //freopen("out.txt","w",stdout);
 57 | 	int n;
 58 | 	while(scanf("%d",&n) == 1){
 59 | 		cnt = 0;
 60 | 		for(int i = 1;i <= n;i++){
 61 | 			scanf("%d%d",&node[i].x,&node[i].y);
 62 | 			node[i].index = i;
 63 | 			yy[++cnt] = node[i].y;
 64 | 		}
 65 | 		sort(node+1,node+n+1);
 66 | 		sort(yy+1,yy+cnt+1);
 67 | 		cnt = unique(yy+1,yy+cnt+1) - yy - 1;
 68 | 		map<int,int>mp;
 69 | 		for(int i = 1;i <= cnt;i++)mp[yy[i]] = i;
 70 | 		for(int i = 1;i <= n;i++)
 71 | 			node[i].y = mp[node[i].y];
 72 | 		memset(c,0,sizeof(c));
 73 | 		memset(dp,0,sizeof(dp));
 74 | 		int id = 1;
 75 | 		for(int i = 1;i <= n;i++){
 76 | 			while(node[id].x != node[i].x){
 77 | 				add(node[id].y,id);
 78 | 				id++;
 79 | 			}
 80 | 			int tmp = query(node[i].y-1);
 81 | 			dp[i] = dp[tmp] + 1;
 82 | 			pre[i] = tmp;
 83 | 		}
 84 | 		int now = 0;
 85 | 		for(int i = 1;i <= n;i++)
 86 | 			if(dp[i] > dp[now])
 87 | 				now = i;
 88 | 		vector<int>ans;
 89 | 		while(now){
 90 | 			ans.push_back(node[now].index);
 91 | 			now = pre[now];
 92 | 		}
 93 | 		reverse(ans.begin(),ans.end());
 94 | 		int sz = ans.size();
 95 | 		printf("%d\n",sz);
 96 | 		for(int i = 0;i < sz;i++){
 97 | 			printf("%d",ans[i]);
 98 | 			if(i < sz-1)printf(" ");
 99 | 			else printf("\n");
100 | 		}
101 | 	}
102 |     return 0;
103 | }
104 | 


--------------------------------------------------------------------------------
/ZOJ/ZOJ_Monthly_January_2015/B.cpp:
--------------------------------------------------------------------------------
  1 | /* ***********************************************
  2 | Author        :kuangbin
  3 | Created Time  :2015/1/11 13:37:50
  4 | File Name     :ZOJ\B.cpp
  5 | ************************************************ */
  6 | 
  7 | #include <stdio.h>
  8 | #include <string.h>
  9 | #include <iostream>
 10 | #include <algorithm>
 11 | #include <vector>
 12 | #include <queue>
 13 | #include <set>
 14 | #include <map>
 15 | #include <string>
 16 | #include <math.h>
 17 | #include <stdlib.h>
 18 | #include <time.h>
 19 | using namespace std;
 20 | char str[100];
 21 | int a[100];
 22 | 
 23 | int cnt[20];
 24 | const int MOD = 1e9+7;
 25 | long long p[100];
 26 | long long rp[100];
 27 | long long pow_m(long long a,long long n){
 28 | 	long long ret = 1;
 29 | 	long long tmp = a%MOD;
 30 | 	while(n){
 31 | 		if(n&1){
 32 | 			ret = ret*tmp%MOD;
 33 | 		}
 34 | 		tmp = tmp*tmp%MOD;
 35 | 		n >>= 1;
 36 | 	}
 37 | 	return ret;
 38 | }
 39 | long long calc(){
 40 | 	int tot = 0;
 41 | 	for(int i = 1;i <= 13;i++)
 42 | 		tot += cnt[i];
 43 | 	long long ret = p[tot];
 44 | 	for(int i = 1;i <= 13;i++)
 45 | 		ret = ret*rp[cnt[i]]%MOD;
 46 | 	return ret;
 47 | }
 48 | 
 49 | int main()
 50 | {
 51 | 	p[0] = 1;
 52 | 	rp[0] = 1;
 53 | 	for(int i = 1;i < 100;i++){
 54 | 		p[i] = p[i-1]*i%MOD;
 55 | 		rp[i] = pow_m(p[i],MOD-2);
 56 | 	}
 57 |     //freopen("in.txt","r",stdin);
 58 |     //freopen("out.txt","w",stdout);
 59 |     while(scanf("%s",str) == 1){
 60 | 		int len = strlen(str);
 61 | 		for(int i = 1;i <= 13;i++)
 62 | 			cnt[i] = 4;
 63 | 		int n = 0;
 64 | 		for(int i = 0;i < len;i++){
 65 | 			if(str[i] == 'A'){
 66 | 				cnt[1]--;
 67 | 				a[n++] = 1;
 68 | 			}
 69 | 			else if(str[i] == '1'){
 70 | 				cnt[10]--;
 71 | 				a[n++] = 10;
 72 | 				i++;
 73 | 			}
 74 | 			else if(str[i] == 'J'){
 75 | 				cnt[11]--;
 76 | 				a[n++] = 11;
 77 | 			}
 78 | 			else if(str[i] == 'Q'){
 79 | 				cnt[12]--;
 80 | 				a[n++] = 12;
 81 | 			}
 82 | 			else if(str[i] == 'K'){
 83 | 				cnt[13]--;
 84 | 				a[n++] = 13;
 85 | 			}
 86 | 			else {
 87 | 				cnt[str[i]-'0']--;
 88 | 				a[n++] =str[i]-'0';
 89 | 			}
 90 | 		}
 91 | 		long long ans = 0;
 92 | 		int n2 = 52-n;
 93 | 		if(n2 == 0){
 94 | 			printf("1\n");
 95 | 			continue;
 96 | 		}
 97 | 		for(int i = 0;i < n;i++){
 98 | 			if(n2 == 0){
 99 | 				ans = (ans+1)%MOD;
100 | 				break;
101 | 			}
102 | 			for(int j = 1;j < a[i];j++){
103 | 				if(cnt[j]){
104 | 					cnt[j]--;
105 | 					ans = (ans+calc())%MOD;
106 | 					cnt[j]++;
107 | 				}
108 | 			}
109 | 			if(cnt[a[i]] == 0)break;
110 | 			cnt[a[i]]--;
111 | 			n2--;
112 | 		}
113 | 		printf("%d\n",(int)ans);
114 | 	}
115 |     return 0;
116 | }
117 | 


--------------------------------------------------------------------------------
/ZOJ/ZOJ_Monthly_January_2015/E.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2015/1/11 12:17:01
 4 | File Name     :ZOJ\E.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | int a[20];
21 | int n;
22 | bool same(){
23 | 	for(int i = 1;i < n;i++)
24 | 		if(a[i] != a[i-1])
25 | 			return false;
26 | 	return true;
27 | }
28 | void go(){
29 | 	int id1 = 0, id2 = 0;
30 | 	for(int i = 1;i < n;i++){
31 | 		if(a[i] < a[id1])
32 | 			id1 = i;
33 | 		if(a[i] > a[id2])
34 | 			id2 = i;
35 | 	}
36 | 	int tmp = a[id2] - a[id1];
37 | 	a[id1] = a[id2] = tmp;
38 | }
39 | 
40 | int main()
41 | {
42 |     //freopen("in.txt","r",stdin);
43 |     //freopen("out.txt","w",stdout);
44 |     int T;
45 | 	scanf("%d",&T);
46 | 	while(T--){
47 | 		scanf("%d",&n);
48 | 		for(int i = 0;i < n;i++)scanf("%d",&a[i]);
49 | 		bool f = false;
50 | 		for(int i = 1;i <= 1000000;i++){
51 | 			if(same()){
52 | 				printf("%d\n",a[0]);
53 | 				f = true;
54 | 				break;
55 | 			}
56 | 			go();
57 | 		}
58 | 		if(!f)printf("Nooooooo!\n");
59 | 	}
60 |     return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/ZOJ/ZOJ_Monthly_January_2015/F.cpp:
--------------------------------------------------------------------------------
  1 | /* ***********************************************
  2 | Author        :kuangbin
  3 | Created Time  :2015/1/11 14:16:16
  4 | File Name     :ZOJ\F.cpp
  5 | ************************************************ */
  6 | 
  7 | #include <stdio.h>
  8 | #include <string.h>
  9 | #include <iostream>
 10 | #include <algorithm>
 11 | #include <vector>
 12 | #include <queue>
 13 | #include <set>
 14 | #include <map>
 15 | #include <string>
 16 | #include <math.h>
 17 | #include <stdlib.h>
 18 | #include <time.h>
 19 | using namespace std;
 20 | unsigned int bit[32];
 21 | long long C[50][50];
 22 | unsigned int c;
 23 | int k;
 24 | long long calc1(unsigned int n){
 25 | 	int c0,c1;
 26 | 	c0 = c1 = 0;
 27 | 	long long ans = 0;
 28 | 	int i = 31;
 29 | 	while(i >= 0){
 30 | 		int end;
 31 | 		if(n&bit[i])end = 1;
 32 | 		else end = 0;
 33 | 		if(end){
 34 | 			int re = 0;
 35 | 			int cc0 = c0, cc1 = c1;
 36 | 			cc0++;
 37 | 			for(int j = i-1;j >= 0;j--){
 38 | 				if((c&bit[j]) == 0)
 39 | 					cc0++;
 40 | 				else re++;
 41 | 			}
 42 | 			for(int j = 0;j <= re;j++){
 43 | 				if(abs( (j+cc0) - (cc1 + re-j) ) <= k)
 44 | 					ans += C[re][j];
 45 | 			}
 46 | 		}
 47 | 		if(end == 1 && (c&bit[i]) == 0)break;
 48 | 		if(end)c1++;
 49 | 		else c0++;
 50 | 		i--;
 51 | 	}
 52 | 	if(i < 0){
 53 | 		if(abs(c0-c1) <= k)ans++;
 54 | 	}
 55 | 	return ans;
 56 | }
 57 | long long calc2(unsigned int n){
 58 | 	int c0,c1;
 59 | 	c0 = c1 = 0;
 60 | 	long long ans = 0;
 61 | 	int i = 31;
 62 | 	while(i >= 0){
 63 | 		int end;
 64 | 		if(n&bit[i])end = 1;
 65 | 		else end = 0;
 66 | 		if(end){
 67 | 			int re = 0;
 68 | 			int cc0 = c0, cc1 = c1;
 69 | 			cc0++;
 70 | 			re = i;
 71 | 			for(int j = 0;j <= re;j++)
 72 | 				if(abs((j+cc0)-(cc1+re-j)) <= k)
 73 | 					ans += C[re][j];
 74 | 		}
 75 | 		if(end)c1++;
 76 | 		else c0++;
 77 | 		i--;
 78 | 	}
 79 | 	if(i < 0){
 80 | 		if(abs(c0-c1) <= k)ans++;
 81 | 	}
 82 | 	return ans;
 83 | }
 84 | long long calc3(unsigned int n){
 85 | 	int c0,c1;
 86 | 	c0 = c1 = 0;
 87 | 	long long ans = 0;
 88 | 	int i = 31;
 89 | 	while(i >= 0){
 90 | 		int end;
 91 | 		if(n&bit[i])end = 1;
 92 | 		else end = 0;
 93 | 		if(end && (c&bit[i]) == 0){
 94 | 			int re = 0;
 95 | 			int cc0 = c0, cc1 = c1;
 96 | 			cc0++;
 97 | 			for(int j = i-1;j >= 0;j--){
 98 | 				if((c&bit[j]) == 0)
 99 | 					re++;
100 | 				else cc1++;
101 | 			}
102 | 			for(int j = 0;j <= re;j++)
103 | 				if(abs((j+cc0) - (cc1+re-j)) <= k)
104 | 					ans += C[re][j];
105 | 		}
106 | 		if(end == 0 && (c&bit[i]) != 0)break;
107 | 		if(end)c1++;
108 | 		else c0++;
109 | 		i--;
110 | 	}
111 | 	if(i < 0){
112 | 		if(abs(c0-c1) <= k)ans++;
113 | 	}
114 | 	return ans;
115 | }
116 | 
117 | int main()
118 | {
119 |     //freopen("in.txt","r",stdin);
120 |     //freopen("out.txt","w",stdout);
121 |     bit[0] = 1;
122 | 	for(int i = 1;i < 32;i++)
123 | 		bit[i] = bit[i-1]<<1;
124 | 	C[0][0] = 1;
125 | 	for(int i = 1;i < 40;i++){
126 | 		C[i][0] = C[i][i] = 1;
127 | 		for(int j = 1;j < i;j++)
128 | 			C[i][j] = C[i-1][j] + C[i-1][j-1];
129 | 	}
130 | 	unsigned int L,R;
131 | 	int T;
132 | 	scanf("%d",&T);
133 | 	int iCase = 0;
134 | 	while(T--){
135 | 		iCase++;
136 | 		cin>>L>>R>>c;
137 | 		cin>>k;
138 | 		printf("Case %d:",iCase);
139 | 		long long ans1 = calc1(R);
140 | 		if(L > 0)ans1 -= calc1(L-1);
141 | 		cout<<" "<<ans1;
142 | 		if(c)printf(" 0");
143 | 		else{
144 | 			long long ans2 = calc2(R);
145 | 			if(L)ans2 -= calc2(L-1);
146 | 			cout<<" "<<ans2;
147 | 		}
148 | 		long long ans3 = calc3(R);
149 | 		if(L > 0)ans3 -= calc3(L-1);
150 | 		cout<<" "<<ans3<<endl;
151 | 	}
152 |     return 0;
153 | }
154 | 


--------------------------------------------------------------------------------
/ZOJ/ZOJ_Monthly_January_2015/G.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2015/1/11 12:25:13
 4 | File Name     :ZOJ\G.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | long long gcd(long long a,long long b){
21 | 	if(b == 0)return a;
22 | 	else return gcd(b,a%b);
23 | }
24 | int a[100010];
25 | 
26 | int main()
27 | {
28 |     //freopen("in.txt","r",stdin);
29 |     //freopen("out.txt","w",stdout);
30 |     int n;
31 | 	int iCase = 0;
32 | 	while(scanf("%d",&n) == 1){
33 | 		iCase++;
34 | 		int tot = 0;
35 | 		for(int i = 0;i < n;i++){
36 | 			scanf("%d",&a[i]);
37 | 			tot = gcd(tot,a[i]);
38 | 		}
39 | 		if(tot != 1){
40 | 			printf("Case %d: -1\n\n",iCase);
41 | 			continue;
42 | 		}
43 | 		printf("Case %d: %d\n",iCase,2*(n-1));
44 | 		for(int i = 1;i < n;i++)
45 | 			printf("%d %d\n",1,i+1);
46 | 		for(int i = 1;i < n;i++)
47 | 			printf("%d %d\n",1,i+1);
48 | 		printf("\n");
49 | 	}
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/ZOJ/ZOJ_Monthly_January_2015/H.cpp:
--------------------------------------------------------------------------------
  1 | /* ***********************************************
  2 | Author        :kuangbin
  3 | Created Time  :2015/1/11 12:51:27
  4 | File Name     :ZOJ\H.cpp
  5 | ************************************************ */
  6 | 
  7 | #include <stdio.h>
  8 | #include <string.h>
  9 | #include <iostream>
 10 | #include <algorithm>
 11 | #include <vector>
 12 | #include <queue>
 13 | #include <set>
 14 | #include <map>
 15 | #include <string>
 16 | #include <math.h>
 17 | #include <stdlib.h>
 18 | #include <time.h>
 19 | using namespace std;
 20 | char str[25][25];
 21 | 
 22 | int n,m;
 23 | int dp[25][25][21110];
 24 | 
 25 | struct Node{
 26 | 	int x,y,s;
 27 | 	Node(){}
 28 | 	Node(int _x,int _y,int _s){
 29 | 		x = _x;
 30 | 		y = _y;
 31 | 		s = _s;
 32 | 	}
 33 | };
 34 | int Move[][2]={
 35 | 	{0,1},{1,0},{0,-1},{-1,0}
 36 | };
 37 | struct Trie{
 38 | 	int next[21110][26];
 39 | 	bool end[21110];
 40 | 	int fail[20010];
 41 | 	int root,L;
 42 | 	int newnode(){
 43 | 		for(int i = 0;i < 26;i++)
 44 | 			next[L][i] = -1;
 45 | 		end[L] = false;
 46 | 		return L++;
 47 | 	}
 48 | 	void init(){
 49 | 		L = 0;
 50 | 		root = newnode();
 51 | 	}
 52 | 	void insert(char s[]){
 53 | 		int len = strlen(s);
 54 | 		int now = root;
 55 | 		for(int i = 0;i < len;i++){
 56 | 			int id = s[i] - 'A';
 57 | 			if(next[now][id] == -1)
 58 | 				next[now][id] = newnode();
 59 | 			now = next[now][id];
 60 | 		}
 61 | 		end[now] = true;
 62 | 	}
 63 | 	void build(){
 64 | 		queue<int>Q;
 65 | 		fail[root] = root;
 66 | 		for(int i = 0;i < 26;i++)
 67 | 			if(next[root][i] == -1)
 68 | 				next[root][i] = root;
 69 | 			else {
 70 | 				fail[next[root][i]] = root;
 71 | 				Q.push(next[root][i]);
 72 | 			}
 73 | 		while(!Q.empty()){
 74 | 			int now = Q.front();
 75 | 			Q.pop();
 76 | 			end[now] |= end[fail[now]];
 77 | 			for(int i = 0;i < 26;i++)
 78 | 				if(next[now][i] == -1)
 79 | 					next[now][i] = next[fail[now]][i];
 80 | 				else {
 81 | 					fail[next[now][i]] = next[fail[now]][i];
 82 | 					Q.push(next[now][i]);
 83 | 				}
 84 | 		}
 85 | 	}
 86 | 	int solve(){
 87 | 		queue<Node>q;
 88 | 		memset(dp,-1,sizeof(dp));
 89 | 		int sx,sy;
 90 | 		for(int i = 0;i < n;i++)
 91 | 			for(int j = 0;j < m;j++){
 92 | 				if(str[i][j] == '@'){
 93 | 					sx = i;
 94 | 					sy = j;
 95 | 					str[i][j] = '.';
 96 | 					dp[sx][sy][0] = 0;
 97 | 					q.push(Node(sx,sy,0));
 98 | 				}
 99 | 			}
100 | 		while(!q.empty()){
101 | 			Node tmp = q.front();
102 | 			q.pop();
103 | 			int x = tmp.x;
104 | 			int y = tmp.y;
105 | 			int s = tmp.s;
106 | 			if(end[s])return dp[x][y][s];
107 | 			for(int i = 0;i < 4;i++){
108 | 				int nx = x+Move[i][0];
109 | 				int ny = y+Move[i][1];
110 | 				if(nx < 0 || nx >= n || ny < 0 || ny >= m)continue;
111 | 				if(str[nx][ny] == '#')continue;
112 | 				if(str[nx][ny] == '.'){
113 | 					if(dp[nx][ny][s] == -1){
114 | 						dp[nx][ny][s] = dp[x][y][s]+1;
115 | 						q.push(Node(nx,ny,s));
116 | 					}
117 | 				}
118 | 				else {
119 | 					int id = str[nx][ny]-'A';
120 | 					int now = s;
121 | 					while(dp[nx][ny][next[now][id]] == -1){
122 | 						now = next[now][id];
123 | 						if(dp[nx][ny][now] == -1){
124 | 							dp[nx][ny][now] = dp[x][y][s]+1;
125 | 							q.push(Node(nx,ny,now));
126 | 						}
127 | 					}
128 | 				}
129 | 			}
130 | 		}
131 | 		return -1;
132 | 	}
133 | }tree;
134 | char ss[11000];
135 | 
136 | int main()
137 | {
138 |     //freopen("in.txt","r",stdin);
139 |     //freopen("out.txt","w",stdout);
140 |     int T;
141 | 	scanf("%d",&T);
142 | 	while(T--){
143 | 		scanf("%d%d",&n,&m);
144 | 		if(n <= 0 || n > 20)while(1);
145 | 		while(m <= 0 || m > 20)while(1);
146 | 		for(int i = 0;i < n;i++)
147 | 			scanf("%s",str[i]);
148 | 		tree.init();
149 | 		int k;
150 | 		scanf("%d",&k);
151 | 		//gets(ss);
152 | 		while(k--){
153 | 			scanf("%s",ss);
154 | 			//gets(ss);
155 | 			tree.insert(ss);
156 | 		}
157 | 		tree.build();
158 | 		printf("%d\n",tree.solve());
159 | 	}
160 |     return 0;
161 | }
162 | 


--------------------------------------------------------------------------------
/hihoCoder/hihoCoder6/A.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2014/12/14 18:58:29
 4 | File Name     :hihoCoder6\A.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | char str[100010];
21 | bool check(int i){
22 | 	if(str[i] != 'm' && str[i] != 'M')return false;
23 | 	if(str[i+1] != 'a' && str[i+1] != 'A')return false;
24 | 	if(str[i+2] != 'r' && str[i+2] != 'R')return false;
25 | 	if(str[i+3] != 's' && str[i+3] != 'S')return false;
26 | 	if(str[i+4] != 'h' && str[i+4] != 'H')return false;
27 | 	if(str[i+5] != 't' && str[i+5] != 'T')return false;
28 | 	if(str[i+6] != 'o' && str[i+6] != 'O')return false;
29 | 	if(str[i+7] != 'm' && str[i+7] != 'M')return false;
30 | 	if(str[i+8] != 'p' && str[i+8] != 'P')return false;
31 | 	return true;
32 | }
33 | 
34 | int main()
35 | {
36 |     //freopen("in.txt","r",stdin);
37 |     //freopen("out.txt","w",stdout);
38 |     while(gets(str)){
39 | 		int len = strlen(str);
40 | 		for(int i = 0;i < len;i++){
41 | 			if(i + 9 <= len && check(i)){
42 | 				printf("fjxmlhx");
43 | 				i += 8;
44 | 			}
45 | 			else printf("%c",str[i]);
46 | 		}
47 | 		printf("\n");
48 | 	}
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/hihoCoder/hihoCoder6/B.cpp:
--------------------------------------------------------------------------------
 1 | /* ***********************************************
 2 | Author        :kuangbin
 3 | Created Time  :2014/12/14 19:46:09
 4 | File Name     :hihoCoder6\B.cpp
 5 | ************************************************ */
 6 | 
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | #include <iostream>
10 | #include <algorithm>
11 | #include <vector>
12 | #include <queue>
13 | #include <set>
14 | #include <map>
15 | #include <string>
16 | #include <math.h>
17 | #include <stdlib.h>
18 | #include <time.h>
19 | using namespace std;
20 | const double eps = 1e-6;
21 | int sgn(double x){
22 | 	if(fabs(x) < eps)return 0;
23 | 	else if(x < 0)return -1;
24 | 	else return 1;
25 | }
26 | double calc(double x1,double y1,double x2,double y2){
27 | 	if(sgn(x1-x2) == 0)return 0;
28 | 	double k = (y2-y1)/(x2-x1);
29 | 	double b = y1 - k*x1;
30 | 	return k*(x2*x2*x2-x1*x1*x1)/3 + b*(x2*x2-x1*x1)/2;
31 | }
32 | struct Point{
33 | 	double x,y;
34 | 	Point(double _x = 0,double _y = 0){
35 | 		x = _x;
36 | 		y = _y;
37 | 	}
38 | 	double operator ^(const Point &b)const{
39 | 		return x*b.y - y*b.x;
40 | 	}
41 | 	void input(){
42 | 		scanf("%lf%lf",&x,&y);
43 | 	}
44 | };
45 | Point p[10010];
46 | double calc2(Point a,Point b){
47 | 	return calc(a.x,a.y,b.x,b.y);
48 | }
49 | 
50 | 
51 | int main()
52 | {
53 |     //freopen("in.txt","r",stdin);
54 |     //freopen("out.txt","w",stdout);
55 |     int T;
56 | 	int n;
57 | 	scanf("%d",&T);
58 | 	while(T--){
59 | 		scanf("%d",&n);
60 | 		for(int i = 0;i < n;i++){
61 | 			p[i].input();
62 | 		}
63 | 		double ret = 0;
64 | 		double tot = 0;
65 | 		double ans = 0;
66 | 		ret = 0;
67 | 		for(int i = 0;i < n;i++){
68 | 			ans += calc2(p[i],p[(i+1)%n]);
69 | 			ret += (p[i]^p[(i+1)%n]);
70 | 		}
71 | 		if(sgn(ret) < 0)tot -= ans;
72 | 		else tot += ans;
73 | 		ans = ret = 0;
74 | 		for(int i = 0;i < n;i++)swap(p[i].x,p[i].y);
75 | 		for(int i = 0;i < n;i++){
76 | 			ans += calc2(p[i],p[(i+1)%n]);
77 | 			ret += (p[i]^p[(i+1)%n]);
78 | 		}
79 | 		if(sgn(ret) < 0)tot -= ans;
80 | 		else tot += ans;
81 | 		ans = -tot;
82 | 		if(fabs(ans) < 0.000001)ans = 0.0;
83 | 		printf("%.2f\n",ans);
84 | 	}
85 |     return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/hihoCoder/hihoCoder6/C.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kuangbin/ACM-ICPC/7467e173d4eab8fdaea0982426cbace8197be737/hihoCoder/hihoCoder6/C.cpp


--------------------------------------------------------------------------------
/kuangbin的ACM模板（新）.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kuangbin/ACM-ICPC/7467e173d4eab8fdaea0982426cbace8197be737/kuangbin的ACM模板（新）.pdf


--------------------------------------------------------------------------------