Beyond the Void » Ural http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 Ural 1416 Confidential http://www.byvoid.com/blog/ural-1416/ http://www.byvoid.com/blog/ural-1416/#comments Tue, 14 Apr 2009 06:49:52 +0000 BYVoid http://www.byvoid.com/blog/?p=1214 第一问是求最小生成树，第二问是求次小生成树。如果次小生成树不存在（本身就是一棵树），则输出-1。

?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

/* 
 * Problem: Ural1416 Confidential
 * Author: Guo Jiabao
 * Time: 2009.4.14 9:34
 * State: Solved
 * Memo: 次小生成树 Prim
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=501,MAXM=MAXN*MAXN*4,INF=0x7FFFFFFF;
using namespace std;
struct edge
{
	edge *next,*op;
	int t,c;
	bool mst;
}ES[MAXM],*V[MAXN],*MST[MAXN],*CLS[MAXN];
int N,M,EC=-1,MinST,Ans,NMST;
int DM[MAXN],F[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;
	freopen("conf.in","r",stdin);
	freopen("conf.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		addedge(V,a,b,c);
	}
	Ans=INF;
}
void prim()
{
	int i,j,Mini;
	for (i=1;i<=N;i++)
		DM[i]=INF;
	for (i=1;i;)
	{
		DM[i]=-INF;
		for (edge *e=V[i];e;e=e->next)
		{
			if (e->c < DM[j=e->t])
			{
				DM[j]=e->c;
				CLS[j]=e->op;
			}
		}
		Mini=INF;i=0;
		for (j=1;j<=N;j++)
			if (DM[j]!=-INF && DM[j]<Mini)
			{
				Mini=DM[j];
				i=j;
			}
	}
	for (i=2;i<=N;i++)
	{
		MinST+=CLS[i]->c;
		CLS[i]->mst=CLS[i]->op->mst=true;
		addedge(MST,CLS[i]->t,CLS[i]->op->t,CLS[i]->c);
	}
}
void dfs(int i)
{
	for (edge *e=MST[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)
		{
			if (!e->mst)
			{
				NMST=MinST + e->c -F[e->t];
				if (NMST < Ans)
					Ans=NMST;
			}
		}
	}
}
int main()
{
	init();
	prim();
	smst();
	if (Ans==INF)
		Ans=-1;
	printf("Cost: %dnCost: %dn",MinST,Ans);
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/ural-1416/feed/ 0 Ural 1076 Trash http://www.byvoid.com/blog/ural-1076/ http://www.byvoid.com/blog/ural-1076/#comments Wed, 25 Mar 2009 14:37:40 +0000 BYVoid http://www.byvoid.com/blog/?p=1007 题目大意是给定N个垃圾桶，每个垃圾桶内装有N种数量不同的垃圾，现你把垃圾分类，要求每个垃圾桶装一种垃圾，移动一个单位的垃圾消耗1的代价，求最小的移动代价，使得完成垃圾分类。

这个问题可以构建出二分图的最佳匹配的模型。把原有的垃圾桶看作X集合中的顶点，垃圾种类看作Y集合中的顶点，边(a,b)表示a垃圾桶装b类垃圾，所需移动的代价。求二分图的最小权完备匹配，匹配边权值之和最小值就是要求的结果。

为了能够使用求最大权匹配的KM算法，只需把所有边的权值取相反数，求最大权匹配，结果再取相反数即可。

?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

/* 
 * Problem: Ural1076 Trash
 * Author: Guo Jiabao
 * Time: 2009.3.25 22:20
 * State: Solved
 * Memo: KM
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAX=301,INF=0x7FFFFFFF;
using namespace std;
int N,M,U;
int adj[MAX][MAX];
int Match[MAX],L[MAX],Slack[MAX];
bool vis[MAX];
void init()
{
	int i,j,c;
	freopen("trash.in","r",stdin);
	freopen("trash.out","w",stdout);
	scanf("%d",&N);M=N+1;U=N+N;
	for (i=1;i<=N;i++)
	{
		c=0;
		for (j=M;j<=U;j++)
		{
			scanf("%d",&adj[i][j]);
			c+=adj[i][j];
		}
		for (j=M;j<=U;j++)
			adj[i][j]=c-adj[i][j];
	}
	for (i=1;i<=N;i++)
		for (j=M;j<=U;j++)
			adj[i][j]=-adj[i][j];
}
bool path(int i)
{
	vis[i]=true;
	for (int j=M;j<=U;j++)
	{
		if (!vis[j])
		{
			int t=L[i]+L[j]-adj[i][j];
			if (t==0)
			{
				vis[j]=true;
				if (Match[j]==0 || path(Match[j]))
				{
					Match[j]=i;
					return true;
				}
			}
			else if (t<Slack[j])
				Slack[j]=t;
		}
	}
	return false;
}
void KM()
{
	int i,j,delta;
	for (i=1;i<=N;i++)
	{
		L[i]=-INF;
		for (j=M;j<=U;j++)
			if (adj[i][j]>L[i])
				L[i]=adj[i][j];
	}
	for (i=1;i<=N;i++)
	{
		for (;;)
		{
			memset(vis,0,sizeof(vis));
			for (j=M;j<=U;j++)
				Slack[j]=INF;
			if (path(i)) break;
			delta=INF;
			for (j=M;j<=U;j++)
				if (!vis[j] && Slack[j]<delta)
					delta=Slack[j];
			for (j=1;j<=N;j++)
				if (vis[j])
					L[j]-=delta;
			for (j=M;j<=U;j++)
				if (vis[j])
					L[j]+=delta;
		}
	}
}
void print()
{
	int i,Ans=0;
	for (i=M;i<=U;i++)
		Ans+=adj[Match[i]][i];
	Ans=-Ans;
	printf("%dn",Ans);
}
int main()
{
	init();
	KM();
	print();
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/ural-1076/feed/ 0 Ural 1183 Brackets sequence http://www.byvoid.com/blog/ural-1183/ http://www.byvoid.com/blog/ural-1183/#comments Mon, 10 Nov 2008 14:02:52 +0000 BYVoid http://www.byvoid.com/blog/?p=511 括号序列问题，刘汝佳黑书上的动态规划第一题，真是经典问题。不过这道题要输出方案。

动态规划状态设定
F[i,j]表示子序列[i,j]要成为括号序列所需添加的最小括号数目。

状态转移方程
F[i,j]=Min
{
F[i+1,j-1] (S[i]与S[j]匹配) //剥离一层匹配的括号
F[i+1,j] + 1 (S[i]为左半括号) //在结尾添加对应的右半括号
F[i,j-1] + 1 (S[j]为右半括号) //在开头添加对应的左半括号
F[i,k] + F[k+1,j] //从第k位分裂开
}

时间复杂度
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
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

#include <iostream>
 
using namespace std;
 
const int MAX=201;
const int INF=0x7FFFFFFF;
 
struct T
{
	int pos,fi,fj,gi,gj;
	char addition;
};
 
char S[MAX];
int N;
int F[MAX][MAX];
T G[MAX][MAX];
 
void init()
{
	freopen("1183.in","r",stdin);
	freopen("1183.out","w",stdout);
	scanf("%s",S+1);
	N=strlen(S+1);
}
 
inline char opp(char a)
{
	switch(a)
	{
		case '(': return ')';
		case ')': return '(';
		case '[': return ']';
	}
	return '[';
}
 
void peel(int i,int j)
{
	if (i+1<=N && j-1>=1)
	{
		if ((S[i]=='(' && S[j]==')') || (S[i]=='[' && S[j]==']'))
		{
			if (F[i+1][j-1]<F[i][j])
			{
				F[i][j]=F[i+1][j-1];
				G[i][j].fi=i+1;	G[i][j].fj=j-1;	G[i][j].pos=-1;
			}
		}
	}
}
 
void addhead(int i,int j)
{
	if (S[j]==')' || S[j]==']')
	{
		if (F[i][j-1]+1<F[i][j])
		{
			F[i][j]=F[i][j-1]+1;
			G[i][j].fi=i;	G[i][j].fj=j-1;	G[i][j].pos=1;
			G[i][j].addition=opp(S[j]);
		}
	}
}
 
void addtail(int i,int j)
{
	if (S[i]=='(' || S[i]=='[')
	{
		if (F[i+1][j]+1<F[i][j])
		{
			F[i][j]=F[i+1][j]+1;
			G[i][j].fi=i+1;	G[i][j].fj=j;	G[i][j].pos=2;
			G[i][j].addition=opp(S[i]);
		}
	}
}
 
void split(int i,int j)
{
	for (int k=i;k<j;k++)
	{
		if (F[i][k]+F[k+1][j]<F[i][j])
		{
			F[i][j]=F[i][k]+F[k+1][j];
			G[i][j].fi=i; G[i][j].fj=k;
			G[i][j].gi=k+1; G[i][j].gj=j;
			G[i][j].pos=-2;
		}
	}
}
 
void dynamic()
{
	int i,j;
	for (i=N;i>=1;i--)
	{
		for (j=i;j<=N;j++)
		{
			F[i][j]=INF;
			split(i,j);
			peel(i,j);
			addtail(i,j);
			addhead(i,j);
		}
	}
}
 
void print(int i,int j)
{
	if (i>j) return;
	if (G[i][j].pos==-1)
	{
		putchar(S[i]);
		print(i+1,j-1);
		putchar(S[j]);
	}
	else if (G[i][j].pos==-2)
	{
		print(G[i][j].fi,G[i][j].fj);
		print(G[i][j].gi,G[i][j].gj);
	}
	else if (G[i][j].pos==1)
	{
		putchar(G[i][j].addition);
		print(G[i][j].fi,G[i][j].fj);
		putchar(S[j]);
	}
	else
	{
		putchar(S[i]);
		print(G[i][j].fi,G[i][j].fj);
		putchar(G[i][j].addition);
	}
}
 
int main()
{
	init();
	dynamic();
	print(1,N);
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/ural-1183/feed/ 4 Ural 1167 Bicoloured Horses http://www.byvoid.com/blog/ural-1167/ http://www.byvoid.com/blog/ural-1167/#comments Mon, 10 Nov 2008 13:51:42 +0000 BYVoid http://www.byvoid.com/blog/?p=508 动态规划，由于是马进入马厩连续的，要先预处理求出每个连续序列的马进入一个马厩的不快乐值。然后以O(N^2*K)时间复杂度DP。

设A[0][i]为前i匹马中种类为0的马的数量，A[1][i]为前i匹马中种类为1的马的数量。则一个区间[i,j]内的马进入一个马厩的不快乐度U[i,j]为
U[i,j]=( A[0][j] – A[0][i-1] ) * ( A[1][j] – A[1][i-1] )

动态规划状态设定
F[i,j]表示前i个马厩，进入前j匹马的最小不快乐度。

状态转移方程
F[i,j]=min{ F[i-1,k] + U[k+1,j] | k=0..j-1 }

边界条件
F[0,0]=0
F[0,i]=MAX (i=1..N)

目标解
F[K,N]

以下是程序代码

?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

#include <iostream>
 
using namespace std;
 
const int MAX=501;
const int INF=0x7FFFFFF;
 
int N,K;
int Q[MAX],A[2][MAX];
int F[MAX][MAX];
 
void init()
{
	int i;
	freopen("1167.in","r",stdin);
	freopen("1167.out","w",stdout);
	scanf("%d%d",&N,&K);
	for (i=1;i<=N;i++)
	{
		scanf("%d",&Q[i]);
		A[0][i]=A[0][i-1];
		A[1][i]=A[1][i-1];
		if (Q[i]==0)
			A[0][i]++;
		else
			A[1][i]++;
		F[0][i]=INF;
	}
}
 
inline int U(int i,int j)
{
	return (A[0][j]-A[0][i-1])*(A[1][j]-A[1][i-1]);
}
 
void dynamic()
{
	int i,j,k,t,min,u;
	for (i=1;i<=K;i++)
	{
		for (j=1;j<=N;j++)
		{
			min=INF;
			for (k=0;k<=j-1;k++)
			{
				u=U(k+1,j);
				t=F[i-1][k] + u;
				if (t<min)
					min=t;
			}
			F[i][j]=min;
		}
	}
}
 
int main()
{
	init();
	dynamic();
	cout << F[K][N] << endl;
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/ural-1167/feed/ 0