Beyond the Void » USACO http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 pku 1947 Rebuilding Roads http://www.byvoid.com/blog/pku-1947/ http://www.byvoid.com/blog/pku-1947/#comments Thu, 11 Jun 2009 03:29:02 +0000 BYVoid http://www.byvoid.com/blog/?p=1381 这是一个孩子之间有分配的树形动态规划问题，一般解决的方法为左孩子右兄弟法或孩子背包分配。

左孩子右兄弟表示法中，状态设定为

F[i,j]表示以i为根的子树以及以i右边兄弟为根的子树中选j个点需要删除边的最少数量。F[i,j]还隐含了i的父亲已经被选，否则i是不可能被选的。

状态转移方程为

F[i][j] = Min
{
F[i.brother][j] + 1 (不选节点i)
F[i.child][k] + F[i.brother][j-k-1] (选节点i) 0<=k<=i子树及兄弟子树大小-1 且 k<=j-1
}

边界条件

F[i][0] = F[i.brother][0] + 1
节点0为一个虚构的节点，如果节点i没有兄弟(或儿子)，则它的兄弟(或儿子)为0。
F[0][0]=0
F[0][j]=INF (j>0，INF为一个极大的值)

目标状态

左孩子右兄弟表示法的目标状态表示不很直观，一棵子树分配P个节点，需要表示成子树根第一个孩子及其兄弟分配P-1的节点。另外，如果不是根节点，还要增加1，表示与它的父节点的边也断掉。
Ans = Min{ F[根节点的第一个孩子][P-1] , F[非根节点的第一个孩子][P-1] + 1 }

如果用孩子背包分配法，状态可以表示为

F[i][j]为以i为根的子树中选择j个节点要删除边的最少数量。

状态转移方程为

F[i][j] = Min { Sigma{ F[i.child[k]][m[k]] } } 其中 sigma[m[k]] = j-1
直接在孩子中分配不易，需要再进行一次DP，运用背包的思想，设状态

G[a][b]为对于特定的i时i的前i个孩子分配j个节点的最小值

G[a][b] = Min { G[a-1][b-k] + F[i.child[a]][k] }

于是F[i][j]可以表示为 F[i][j] = G[i.childcount][j-1]

边界条件为

对于每个节点i
G[0][0]=0
G[0][j]=INF (j>0 INF为一个极大的值)

当i为叶节点时
F[i][0]=1
F[i][1]=0

目标状态

Ans = Min{ F[根节点][P] , F[非根节点][P] + 1}

对于这道题，两种方法的时间复杂度均为O(N^3)。左孩子右兄弟法的优点在于状态转移比较简单，缺点是不够直观，尤其在表示目标状态的时候，另外边界情况的考虑也比较复杂，还有就是需要额外建树。孩子背包分配的方法优点是状态直观，易于表示，容易写成非递归，缺点是状态转移较为复杂，需要用一个背包再分配一次。我个人比较倾向于孩子背包分配法，除非必须，我一般都会写成这样的。

左孩子右兄弟

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

/* 
 * Problem: pku1947 Rebuilding Roads
 * Author: Guo Jiabao
 * Time: 2009.6.11 8:44
 * State: Solved
 * Memo: 树形动态规划 孩子兄弟
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN=151,INF=0x7FFFFFF;
struct edge
{
	edge *next;
	int t;
}ES[MAXN*2],*V[MAXN];
struct TreeNode
{
	int child,brother,size;
}P[MAXN];
int N,K,EC,Ans,F[MAXN][MAXN];
inline void addedge(int a,int b)
{
	ES[++EC].next = V[a];
	V[a]=ES+EC; V[a]->t=b;
}
void buildtree(int i,int f)
{
	for (edge *e=V[i];e;e=e->next)
	{
		int j=e->t;
		if (j==f) continue;
		P[j].brother = P[i].child;
		P[i].child = j;
		buildtree(j,i);
	}
}
void calcsize(int i)
{
	if (i==0) return;
	calcsize(P[i].brother);
	calcsize(P[i].child);
	P[i].size = P[ P[i].brother ].size + P[ P[i].child ].size + 1;
}
inline int min(int a,int b)
{
	return a<b?a:b;
}
void init()
{
	int i,a,b;
	freopen("rr.in","r",stdin);
	freopen("rr.out","w",stdout);
	scanf("%d%d",&N,&K);
	for (i=1;i<N;i++)
	{
		scanf("%d%d",&a,&b);
		addedge(a,b);
		addedge(b,a);
	}
	buildtree(1,0);
	calcsize(1);
	memset(F,-1,sizeof(F));
}
int dp(int i,int j)
{
	int rs = F[i][j];
	if (rs==-1)
	{
		if (i==0)
		{
			if (j==0)
				rs = 0;
			else
				rs = INF;
		}
		else if (j==0)
			rs = dp(P[i].brother,0) + 1;
		else
		{
			rs = INF;
			rs = min(rs,dp(P[i].brother,j) + 1);
			for (int k=0;k<=P[i].size-1 && k<=j-1;k++)
				rs = min(rs,dp(P[i].child,k) + dp(P[i].brother,j-k-1));
		}
		F[i][j]=rs;
	}
	return rs;
}
void solve()
{
	int i;
	if (N==1)
		Ans = 0;
	else if (K==1)
		Ans = 1;
	else
	{
		Ans = dp(P[1].child,K-1);
		for (i=2;i<=N;i++)
			if (P[i].child)
				Ans = min(Ans,dp(P[i].child,K-1) + 1);
	}
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

孩子背包分配

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

/* 
 * Problem: pku1947 Rebuilding Roads
 * Author: Guo Jiabao
 * Time: 2009.6.11 10:04
 * State: Solved
 * Memo: 树形动态规划 孩子链+背包
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN=151,INF=0x7FFFFFF;
struct edge
{
	edge *next;
	int t;
}ES[MAXN*2],*V[MAXN];
int N,K,EC,Ans,F[MAXN][MAXN],G[MAXN],Size[MAXN],A;
inline void addedge(int a,int b)
{
	ES[++EC].next = V[a];
	V[a]=ES+EC; V[a]->t=b;
}
inline int min(int a,int b)
{
	return a<b?a:b;
}
void init()
{
	int i,j,a,b;
	freopen("rr.in","r",stdin);
	freopen("rr.out","w",stdout);
	scanf("%d%d",&N,&K);
	for (i=1;i<N;i++)
	{
		scanf("%d%d",&a,&b);
		addedge(a,b);
		addedge(b,a);
	}
	for (i=1;i<=N;i++)
		for (j=1;j<=N;j++)
			F[i][j]=INF;
}
void dp(int i,int f)
{
	int j,k;
	edge *e;
	Size[i]=1;
	for (e=V[i];e;e=e->next)
	{
		j=e->t;
		if (j==f) continue;
		dp(j,i);
		Size[i] += Size[j];
	}
	if (Size[i]==1)
	{
		F[i][0]=1;
		F[i][1]=0;
	}
	else
	{
		for (j=1;j<=Size[i]-1;j++)
			G[j]=INF;
		G[0]=0;
		for (e=V[i];e;e=e->next)
		{
			if (e->t==f) continue;
			for (j=Size[i]-1;j>=0;j--)
			{
				A=INF;
				for (k=0;k<=Size[e->t] && k<=j;k++)
				{
					A=min(A,G[j-k] + F[e->t][k]);
				}
				G[j]=A;
			}
		}
		F[i][0]=1;
		for (j=1;j<=Size[i];j++)
		{
			F[i][j] = G[j-1];
		}
	}
}
void solve()
{
	int i;
	dp(1,0);
	Ans = F[1][K];
	for (i=2;i<=N;i++)
		Ans = min(Ans,F[i][K]+1);
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/pku-1947/feed/ 2 pku 1743 Musical Theme http://www.byvoid.com/blog/pku-1743/ http://www.byvoid.com/blog/pku-1743/#comments Fri, 17 Apr 2009 11:03:36 +0000 BYVoid http://www.byvoid.com/blog/?p=1255 把原序列相邻每项做差，然后问题就转化成了求一个串的最长不重叠重复子串，且两个子串相距至少一位，可以用后缀数组做。

首先求出后缀数组和Height数组，Height[i]=LCP(SA[i],SA[i-1])。接下来二分答案A，判定A是否为可行解。判断方法是找出在Height数组中找出连续的一段Height[i..j]，使得i<=k<=j均满足Height[k]>=A，并且i-1<=k1,k2<=j中，要有Max{SA[k1]} – Min{SA[k2]} >= A + 1(距离相差至少1)，这时A是可行的。

后缀数组的分组思想十分重要，这道题就是一个经典应用，还应用到了求最长公共子串(LCS)问题。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

/*
 * Problem: pku1743 Musical Theme (USACO 28)
 * Author: Guo Jiabao
 * Time: 2009.4.17 18:45
 * State: Solved
 * Memo: 后缀数组 最长重复子串
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=20011,INF=0x7FFFFFFF;
using namespace std;
struct SufficArray
{
	struct RadixElement
	{
		int id,k[2];
	}RE[MAXN],RT[MAXN],*R1,*R2;
	int N,A[MAXN],SA[MAXN],Rank[MAXN],Height[MAXN],C[MAXN];
	void RadixSort()
	{
		int i,y;
		for (y=1,R1=RE,R2=RT;y>=0;y--)
		{
			memset(C,0,sizeof(C));
			for (i=1;i<=N;i++) C[ R1[i].k[y] ]++;
			for (i=1;i<MAXN;i++) C[i]+=C[i-1];
			for (i=N;i>=1;i--) R2[ C[ R1[i].k[y] ]-- ]=R1[i];
			R1=RT,R2=RE;
		}
		for (i=1;i<=N;i++)
		{
			Rank[RE[i].id]=Rank[RE[i-1].id];
			if ( RE[i].k[0]!=RE[i-1].k[0] || RE[i].k[1]!=RE[i-1].k[1] )
				Rank[RE[i].id]++;
		}
	}
	void CalcSA()
	{
		int i,k;
		Rank[RE[0].id=0]=0;RE[0].k[0]=-1;
		for (i=1;i<=N;i++)
			RE[i].id=i,RE[i].k[0]=A[i],RE[i].k[1]=0;
		RadixSort();
		for (k=1;k+1<=N;k*=2)
		{
			for (i=1;i<=N;i++)
				RE[i].id=i,RE[i].k[0]=Rank[i],RE[i].k[1]=i+k<=N?Rank[i+k]:0;
			RadixSort();
		}
		for (i=1;i<=N;i++)
			SA[Rank[i]]=i;
	}
	void CalcHeight()
	{
		int i,k,h=0;
		for (i=1;i<=N;i++)
		{
			if (Rank[i]==1)
				h=0;
			else
			{
				k=SA[Rank[i]-1];
				if (h) h--;
				for (;A[i+h]==A[k+h];h++);
			}
			Height[Rank[i]]=h;
		}
	}
}SA;
int N,Ans;
bool check(int A)
{
	int i,j,Min,Max;
	for (i=1;i<=SA.N;i++)
	{
		if (SA.Height[i]>=A)
		{
			Min=Max=SA.SA[i-1];
			for (j=i;j<=SA.N && SA.Height[j]>=A;j++)
			{
				if (SA.SA[j]<Min)
					Min = SA.SA[j];
				if (SA.SA[j]>Max)
					Max = SA.SA[j];
			}
			j--;
			if (Max-Min>A)
				return true;
			i=j;
		}
	}
	return false;
}
void solve()
{
	int a,b,m;
	SA.CalcSA();
	SA.CalcHeight();
	a=0;b=SA.N;
	while (a+1<b)
	{
		m=(a+b)/2;
		if (check(m))
			a=m;
		else
			b=m-1;
	}
	if (check(b))
		a=b;
	Ans=a+1;
	if (Ans<5) Ans=0;
}
void init()
{
	int i,c,d,md=INF;
	memset(&SA,0,sizeof(SA));
	d=-100;
	for (i=1;i<=N;i++)
	{
		scanf("%d",&c);
		SA.A[++SA.N]=c-d;
		if (c-d<md)
			md=c-d;
		d=c;
	}
	md--;
	for (i=1;i<=N;i++)
		SA.A[i]-=md;
}
int main()
{
	freopen("theme.in","r",stdin);
	freopen("theme.out","w",stdout);
	while (scanf("%d",&N),N)
	{
		init();
		solve();
		printf("%dn",Ans);
	}
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/pku-1743/feed/ 2 pku 3255 Roadblocks http://www.byvoid.com/blog/pku-3255/ http://www.byvoid.com/blog/pku-3255/#comments Tue, 14 Apr 2009 06:51:49 +0000 BYVoid http://www.byvoid.com/blog/?p=1216 这道题不同于一般的次短路径问题，因为允许边重走。看似更为复杂了，其实是更简单了一些。方法为先用Heap+Dijkstra求出1和N的单源最短路径，把无向边看成两个有向边，然后枚举每单向条边(u,v)，计算Dist=dis(1,u) + dis(N,v)，看看此时Dist的值是否大于dis(1,N)，如果是的话用它更新次短路径，保留一个最小的值。

USACO 2006 November Gold

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

/* 
 * Problem: pku3255 Roadblocks
 * Author: Guo Jiabao
 * Time: 2009.4.14 10:32
 * State: Solved
 * Memo: 次短路径 Dijkstra + Heap (特殊)
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=5001,MAXM=200001,INF=0x7FFFFFF;
using namespace std;
struct Minheap
{
	struct HeapElement
	{
		int key,value;
	}H[MAXN];
	int size,Position[MAXN];
	void init(){H[size=0].value=-INF;}
	void shift(int key,int value,int pos)
	{
		int i,f;
		HeapElement p={key,value};
		for (i=pos;p.value < H[f=i>>1].value;i=f)
		{
			H[i]=H[f];
			Position[H[i].key]=i;
		}
		H[i]=p;
		Position[H[i].key]=i;
	}
	void ins(int key,int value){shift(key,value,++size);}
	void decrease(int key,int value){shift(key,value,Position[key]);}
	void delmin()
	{
		int i,c;
		HeapElement p=H[size--];
		for (i=1;(c=i<<1)<=size;i=c)
		{
			if (c+1 <=size && H[c+1].value < H[c].value)
				c++;
			if (H[c].value < p.value)
			{
				H[i]=H[c];
				Position[H[i].key]=i;
			}
			else
				break;
		}
		H[i]=p;
		Position[H[i].key]=i;
	}
}H;
struct edge
{
	edge *next;
	int t,c;
}ES[MAXM],*V[MAXN];
int N,M,EC=-1,Shortest,Ans;
int sp[2][MAXN];
inline void addedge(int a,int b,int c)
{
	ES[++EC].next=V[a];
	V[a]=ES+EC; V[a]->t=b; V[a]->c=c;
	ES[++EC].next=V[b];
	V[b]=ES+EC; V[b]->t=a; V[b]->c=c;
}
void init()
{
	int i,a,b,c;
	freopen("block.in","r",stdin);
	freopen("block.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		addedge(a,b,c);
	}
}
void dijkstra(int S,int *sp)
{
	int i,j;
	H.init();
	for (i=1;i<=N;i++)
		H.ins(i,sp[i]=INF);
	H.decrease(S,sp[S]=0);
	for (i=S;;)
	{
		H.delmin();
		for (edge *e=V[i];e;e=e->next)
		{
			j=e->t;
			if (sp[i] + e->c <sp[j])
				H.decrease(j,sp[j]=sp[i] + e->c);
		}
		if (H.size)
			i=H.H[1].key;
		else
			break;
	}
}
void solve()
{
	int i,c;
	dijkstra(1,sp[0]);
	dijkstra(N,sp[1]);
	Shortest=sp[0][N];
	Ans=INF;
	for (i=0;i<=EC;i+=2)
	{
		edge *e1=ES+i,*e2=ES+i+1;
		int a=e1->t,b=e2->t;
		c=sp[0][a] + sp[1][b] + e1->c;
		if (c < Ans && c>Shortest)
			Ans=c;
		c=sp[1][a] + sp[0][b] + e1->c;
		if (c < Ans && c>Shortest)
			Ans=c;
	}
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/pku-3255/feed/ 0 pku 3177 (3352) Redundant Paths http://www.byvoid.com/blog/pku-3177/ http://www.byvoid.com/blog/pku-3177/#comments Tue, 07 Apr 2009 12:03:11 +0000 BYVoid http://www.byvoid.com/blog/?p=1114 题目大意是，给定一个连通图，要求添加一些边，使每两个顶点之间都有至少两条不相交的路径，求最小需要添加的边数。

很显然，题中要求的图就是一个边双连通图，即边连通度不小于2。我的方法是在原图中DFS求出所有的桥，然后删除这些桥边，剩下的每个连通块都是一个双连通子图。把每个双连通子图收缩为一个顶点，再把桥边加回来，最后的这个图一定是一棵树，边连通度为1。统计出树中度为1的节点的个数，即为叶节点的个数，记为leaf。有人说至少在树上添加(leaf+1)/2条边，就能使树达到边二连通，所以结果就是(leaf+1)/2。

这个结论我不能证明，但是可以想象出是对的。简单说明一下，首先把两个最近公共祖先最远的两个叶节点之间连接一条边，这样可以把这两个点到祖先的路径上所有点收缩到一起，因为一个形成的环一定是双连通的。然后再找两个最近公共祖先最远的两个叶节点，这样一对一对找完，恰好是(leaf+1)/2次，把所有点收缩到了一起。

这道题跟pku3352一模一样，拿这个程序交两个题一个字不用改都能AC！但实际上两个题也稍有不同，这个题有一点很不容易被注意到，就是可能存在重边，两个点之间如果存在有重边，也算是双连通的。我的处理方法是在DFS时标记每条边及其反向边是否被访问过，而不是判断顶点。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

/* 
 * Problem: pku3177 Redundant Paths (USACO JAN06)
 * Author: Guo Jiabao
 * Time: 2009.4.7 19:37
 * State: Solved
 * Memo: 桥 双连通分支
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=5001,MAXM=10001*2*2;
using namespace std;
struct edge
{
	edge *next,*op;
	int t;
	bool vis;
}ES[MAXM];
edge *V[MAXN],*PAR[MAXN];
int N,M,EC=-1,D,Ans;
int DFN[MAXN],LOW[MAXN],Bel[MAXN],Deg[MAXN];
bool adjm[MAXN][MAXN];
inline void addedge(int a,int b)
{
	ES[++EC].next=V[a];
	V[a]=ES+EC;V[a]->t=b;V[a]->vis=false;
	ES[++EC].next=V[b];
	V[b]=ES+EC;V[b]->t=a;V[b]->vis=false;
	V[a]->op=V[b];V[b]->op=V[a];
}
void init()
{
	int i,a,b;
	freopen("rpaths.in","r",stdin);
	freopen("rpaths.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=M;i++)
	{
		scanf("%d%d",&a,&b);
		addedge(a,b);
	}
}
void dfs(int u)
{
	DFN[u]=LOW[u]=++D;
	for (edge *k=V[u];k;k=k->next)
	{
		int v=k->t;
		if (k->vis) continue;
		k->vis=k->op->vis=true;
		if (!DFN[v])
		{
			PAR[v]=k->op;
			dfs(v);
			if (LOW[v]<LOW[u])
				LOW[u]=LOW[v];
		}
		else if (DFN[v]<LOW[u])
			LOW[u]=DFN[v];
	}
}
void part(int u)
{
	Bel[u]=D;
	for (edge *k=V[u];k;k=k->next)
		if (k->vis && !Bel[k->t])
			part(k->t);
}
void solve()
{
	int i,u,v,leaf=0;
	edge *k;
	dfs(1);
	for (v=2;v<=N;v++)
	{
		k=PAR[v];
		u=k->t;
		if (DFN[u]<LOW[v])
			k->vis=k->op->vis=false;//标记为桥边
	}
	D=0;
	for (u=1;u<=N;u++)
	{
		if (!Bel[u])
		{
			++D;
			part(u);
		}
	}
	for (u=1;u<=N;u++)
		for (k=V[u];k;k=k->next)
			adjm[Bel[u]][Bel[k->t]]=adjm[Bel[k->t]][Bel[u]]=true;
	for (u=1;u<=D;u++)
		for (v=1;v<=D;v++)
			if (u!=v && adjm[u][v])
				Deg[u]++;
	for (i=1;i<=D;i++)
		if (Deg[i]==1)
			leaf++;
	if (leaf!=1)
		Ans=(leaf+1)/2;
	else
		Ans=0;
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/pku-3177/feed/ 5