Beyond the Void » Pku 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 1679 The Unique MST http://www.byvoid.com/blog/pku-1679/ http://www.byvoid.com/blog/pku-1679/#comments Tue, 14 Apr 2009 06:48:36 +0000 BYVoid http://www.byvoid.com/blog/?p=1212 判断一个图的最小生成树是否唯一，可以求其次小生成树。如果它的次小生成树权值之和等于最小生成树权值之和，则最小生成树不唯一，否则最小生成树唯一。

求次小生成树我的方法是O(N^2 + M)的。首先求出最小生成树，记录权值之和为MinST。然后枚举添加边(u,v)，加上以后一定形成一个环，找到环上非(u,v)边的权值最大的边，把它删掉，计算当前生成树的权值之和，取所有枚举加边后生成树权值之和的最小值，就是次小生成树。

实际上具体更简单的方法为从每个顶点i，遍历整个最小生成树，定义F[j]为从i到j的路径上最大边的权值，用O(N)的方法求出每个F[j]。然后枚举顶点i的邻域，遍历每条不再最小生成树中的边(i,j)，加上这条边，并删除环上最大边(非(i,j))，新的生成树权值之和为MinST + w(i,j) – F[j]，记录其最小值即可，时间复杂度为O(N^2 + M)。求最小生成树可以用最简单的Prim，时间复杂度为O(N^2)，用更好的算法是没有意义的。

这种方法比起那种求出最小生成树后，枚举删除最小生成树上每条边，然后再求最小生成树的方法应该要快些，因为那种方法的时间复杂度为O(N * ( N * logN + M) )(Prim + Heap)。

?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

/* 
 * Problem: pku1679 The Unique MST
 * Author: Guo Jiabao
 * Time: 2009.4.14 8:28
 * State: Solved
 * Memo: 次小生成树 Prim
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=101,MAXM=MAXN*MAXN*4,INF=0x7FFFFFFF;
using namespace std;
struct edge
{
	edge *next,*op;
	int t,c;
	bool mst;
}ES[MAXM],*V[MAXN],*clst[MAXN],*NA[MAXN];
int N,M,EC,MinST,NMST,Ans;
int F[MAXN],MST[MAXN];
inline void addedge(edge **V,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;
	V[a]->op=V[b]; V[b]->op=V[a];
	V[a]->mst=V[b]->mst=false;
}
void init()
{
	int i,a,b,c;
	scanf("%d%d",&N,&M);
	EC=-1;Ans=INF;MinST=0;
	memset(clst,0,sizeof(clst));
	memset(V,0,sizeof(V));
	memset(NA,0,sizeof(NA));
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		addedge(V,a,b,c);
	}
}
void prim()
{
	int i,j;
	for (i=1;i<=N;i++)
		MST[i]=INF;
	for (i=1;;)
	{
		MST[i]=-INF;
		for (edge *e=V[i];e;e=e->next)
		{
			if (e->c < MST[j=e->t])
			{
				MST[j]=e->c;
				clst[j]=e->op;
			}
		}
		int Mini=INF;i=0;
		for (j=1;j<=N;j++)
			if (MST[j]!=-INF && MST[j] < Mini)
			{
				Mini=MST[j];
				i=j;
			}
		if (i==0)
			break;
	}
	for (i=2;i<=N;i++)
	{
		MinST+=clst[i]->c;
		j=clst[i]->t;
		clst[i]->mst=true;
		clst[i]->op->mst=true;
		addedge(NA,i,j,clst[i]->c);
	}
}
void dfs(int i)
{
	for (edge *e=NA[i];e;e=e->next)
	{
		int j=e->t;
		if (F[j]==-INF)
		{
			F[j]=F[i];
			if (e->c > F[j])
				F[j]= e->c;
			dfs(j);
		}
	}
}
void smst()
{
	int i,j;
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=N;j++)
			F[j]=-INF;
		F[i]++;
		dfs(i);
		for (edge *e=V[i];e;e=e->next)
		{
			j=e->t;
			if (!e->mst)
			{
				NMST=MinST + e->c - F[j];
				if (NMST < Ans)
					Ans = NMST;
			}
		}
	}
}
int main()
{
	int T,i;
	freopen("umst.in","r",stdin);
	freopen("umst.out","w",stdout);
	scanf("%d",&T);
	for (i=1;i<=T;i++)
	{
		init();
		prim();
		smst();
		if (Ans > MinST)
			printf("%dn",MinST);
		else
			printf("Not Unique!n");
	}
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/pku-1679/feed/ 8