Beyond the Void » 动态规划 http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 NOI 2009 二叉查找树 http://www.byvoid.com/blog/noi-2009-treapmod/ http://www.byvoid.com/blog/noi-2009-treapmod/#comments Tue, 12 Jan 2010 12:38:55 +0000 BYVoid http://www.byvoid.com/blog/?p=1763 问题简述

有一棵Treap，每个节点有一个互不相同的数据值和权值，以及一个访问频度。一个节点的访问代价为它的访问频度乘以它在树中的深度，整棵树的访问代价定义为所有节点的访问代价之和。节点的权值可以修改为任意实数，每修改一个节点的权值的代价为K。任务是修改一些节点的权值，使得整棵树的访问代价与修改代价之和最小。

问题建模

首先离散化所有节点的权值，对所有节点按照数据值排序后线性存储。定义S[i,j]为(排序后)第i个节点到第j个节点的访问频度之和。

解法 动态规划

算法描述

定义Weight[i]为状态转移方程为第i个节点离散化后的权值，F[i,j,w]表示从第i个节点到第j个节点组成一棵子树的最小代价，子树根节点的权值≥w。状态转移方程为

clip_image002

边界条件为clip_image004，目标函数为clip_image006。

算法分析

对于一个状态F[i,j,w]，我们要枚举从节点[i..j]组成的这棵子树的根节点k，其左子树为[i..k-1]，右子树为[k+1..j]。

如果根节点k的权值Weight[k]≥w，那么节点k的权值无需修改即可直接作为该子树的根节点。总代价为左子树的代价F[i,k-1, Weight[k]]，加上右子树的代价F[k+1,j, Weight[k]]，以及整个子树的访问频度之和。

另外一种情况，修改节点k的权值，使之不小于w。由于我们已经离散化了权值，修改后的权值不应是整数，以免和已有重复。假设节点k修改后的权值为w加上一个很小的小数，其左右子树根节点的权值都不应小于节点k修改后的权值。我们约定如果根和子节点都必须大于w的话，则子节点的权值比根节点略大，且大于w。于是这种情况的总代价为左子树的代价F[i,k-1, w]，加上右子树的代价F[k+1,j, w]，加上修改权值的代价K，以及整个子树的访问频度之和。

复杂度分析

状态数为O(N3)，每次转移需要以O(N)的时间枚举k，所以时间复杂度为O(N4)。在实际测试中通过了所以测试点，得到100分。

参考程序
?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

/* 
 * Problem: NOI2009 treapmod
 * Author: Guo Jiabao
 * Time: 2009.9.24 14:50
 * State: Solved
 * Memo: 动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
 
typedef long long big;
 
const int MAXN = 72;
const big INF = ~0ULL>>1;
 
struct node
{
	int val,wei,freq;
}P[MAXN];
 
int N,K;
big sf[MAXN],F[MAXN][MAXN][MAXN],Ans=INF;
 
void init()
{
	int i;
	freopen("treapmod.in","r",stdin);
	freopen("treapmod.out","w",stdout);
	scanf("%d%d",&N,&K);
	for (i=1;i<=N;i++)
		scanf("%d",&P[i].val);
	for (i=1;i<=N;i++)
		scanf("%d",&P[i].wei);
	for (i=1;i<=N;i++)
		scanf("%d",&P[i].freq);
	memset(F,-1,sizeof(F));
}
 
inline int cmp1(const void *a,const void *b)
{
	return ((node *)a) -> wei - ((node *)b) -> wei;
}
 
inline int cmp2(const void *a,const void *b)
{
	return ((node *)a) -> val - ((node *)b) -> val;
}
 
inline big sum(int i,int j)
{
	return sf[j] - sf[i-1];
}
 
big dp(int i,int j,int w)
{
	if (i>j)
		return 0;
	if (F[i][j][w] == -1)
	{
		int a;
		big t,rs=INF;
		for (a=i;a<=j;a++)
		{
			t = dp(i,a-1,w) + dp(a+1,j,w) + sum(i,j) + K;
			if (t < rs)
				rs = t;
			if (P[a].wei >= w)
			{
				t = dp(i,a-1,P[a].wei) + dp(a+1,j,P[a].wei) + sum(i,j);
				if (t < rs)
					rs = t;
			}
		}
		F[i][j][w] = rs;
	}
	return F[i][j][w];
}
 
void solve()
{
	int i;
	qsort(P+1,N,sizeof(P[0]),cmp1);
	for (i=1;i<=N;i++)
		P[i].wei = i;
	qsort(P+1,N,sizeof(P[0]),cmp2);
	for (i=1;i<=N;i++)
	{
		P[i].val = i;
		sf[i] = sf[i-1] + P[i].freq;
	}
	for (i=0;i<=1;i++)
	{
		big t = dp(1,N,i);
		if (t < Ans)
			Ans = t;
	}
}
 
int main()
{
	init();
	solve();
	cout << Ans << endl;
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/noi-2009-treapmod/feed/ 4 NOI 2009 诗人小G http://www.byvoid.com/blog/noi-2009-poet/ http://www.byvoid.com/blog/noi-2009-poet/#comments Tue, 12 Jan 2010 09:58:21 +0000 BYVoid http://www.byvoid.com/blog/?p=1757 问题简述

有N个诗句需要被排版为若干行，顺序不能改变。一行内可以有若干个诗句，相邻诗句之间有一个空格。定义行标准长度L，每行的不协调度为|实际长度-L|P，整首诗的不协调度就是每行不协调度之和。任务是安排一种排版方案，使得整首诗的不协调度最小。

问题建模

这是一个最优化问题，抽象成动态规划模型。设第i个诗句的长度为Len[i]，前i个诗句的总长度为SumL[i]，clip_image002[4]。F[i]为对前i个诗句排版的最小不协调度。

解法1 朴素的动态规划

算法描述

显然每个F[i]可以被分解为F[j]和第j+1…i个句子组成一行的状态，所以状态转移方程为

clip_image004[4]

简化后，可以书写成

clip_image006

在具体实现时，应记录每个状态的决策，以便于输出合法方案。考虑到“最小的不协调度超过1018输出”Too hard to arrange””，为防止64位整型运算溢出，可以先用浮点数类型计算，然后再用整型算出具体值。

复杂度分析

状态数为O(N)，每次转移需要以O(N)的时间枚举j，所以时间复杂度为O(N2)。在实际测试中通过了测试点1，2，3，得到30分。

参考程序
?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

/* 
 * Problem: NOI2009 poet
 * Author: Guo Jiabao
 * Time: 2009.9.22 13:30
 * State: Solved
 * Memo: 朴素动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
 
typedef long long big;
 
const int MAXN=100001,SMAXL=32;
const big INF=~0ULL>>1,LIMIT=1000000000000000000LL;
 
big F[MAXN],sumL[MAXN];
int N,L,P;
int Len[MAXN],deci[MAXN],sel[MAXN];
char sent[MAXN][SMAXL];
 
void init()
{
	scanf("%d%d%d\n",&N,&L,&P);
	for (int i=1;i<=N;++i)
	{
		gets(sent[i]);
		Len[i] = strlen(sent[i]);
		sumL[i] = sumL[i-1] + Len[i];
	}
}
 
big power(big a)
{
	big t=1;
	double dt=1;
	if (a < 0)
		a = -a;
	for (int i=1;i<=P;i++)
	{
		dt *= a;
		if (dt > LIMIT)
			return INF;
		t *= a;
	}
	return t;
}
 
void solve()
{
	int i,j,k;
	big minv,t;
	for (i=1;i<=N;++i)
	{
		minv = INF;
		for (j=0;j<=i-1;++j)
		{
			t = power(sumL[i] - sumL[j] + i-j-1 - L);
			if ( double(t) + double(F[j]) <= LIMIT && t + F[j] < minv)
			{
				minv = t + F[j];
				k = j;
			}
		}
		F[i] = minv;
		deci[i] = k;
	}
}
 
void print()
{
	if (F[N] <= LIMIT)
	{
		cout << F[N] << endl;
		int i,j;
		for (i=N,j=0;i;i=deci[i])
			sel[++j] = i;
		for (i=0;j;j--)
		{
			for (++i;i < sel[j];++i)
				printf("%s ",sent[i]);
			printf("%s\n",sent[i]);
		}
	}
	else
		printf("Too hard to arrange\n");
	printf("--------------------\n");
}
 
int main()
{
	int i,T;
	freopen("poet.in","r",stdin);
	freopen("poet.out","w",stdout);
	scanf("%d",&T);
	for (i=1;i<=T;i++)
	{
		init();
		solve();
		print();
	}
	return 0;
}

解法2 贪心的动态规划

算法描述

观察测试点4，5的N值较大，而L值较小，因此可以限制每行长度，以优化状态转移。

clip_image008

实现时应让j从i-1到0枚举，当j<i-1时一旦发现行长度超过2L，即停止枚举j，因为j继续减少会让行长度继续增加。

算法证明

一个空行的不协调度为LP，若一行内包含多余一个句子，且行长度L’>2L，则行不协调度(L’-L)P>LP。把该行拆分为两行后，设长度分别为L1和L2，L1+L2=L’-1，拆分后的两行不协调度之和为(L1-L)P+(L2-L)P<(L’-L)P，所以拆分为两行后比合在一行好。因此应保证当一行包含多于一个句子时，行长度<=2L。

复杂度分析

状态数为O(N)，每次转移需要O(Min{N,L})的时间，所以时间复杂度为O(Min{N2,NL})。在实际测试中通过了前5个测试点，得到50分。

参考程序
?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

/* 
 * Problem: NOI2009 poet
 * Author: Guo Jiabao
 * Time: 2009.9.22 13:51
 * State: Solved
 * Memo: 朴素动态规划 剪枝
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
 
typedef long long big;
 
const int MAXN=100001,SMAXL=32;
const big INF=~0ULL>>1,LIMIT=1000000000000000000LL;
 
big F[MAXN],sumL[MAXN];
int N,L,P;
int Len[MAXN],deci[MAXN],sel[MAXN];
char sent[MAXN][SMAXL];
 
void init()
{
	scanf("%d%d%d\n",&N,&L,&P);
	for (int i=1;i<=N;++i)
	{
		gets(sent[i]);
		Len[i] = strlen(sent[i]);
		sumL[i] = sumL[i-1] + Len[i];
	}
}
 
big power(big a)
{
	big t=1;
	double dt=1;
	if (a < 0)
		a = -a;
	for (int i=1;i<=P;i++)
	{
		dt *= a;
		if (dt > LIMIT)
			return INF;
		t *= a;
	}
	return t;
}
 
void solve()
{
	int i,j,k;
	big minv,t;
	for (i=1;i<=N;++i)
	{
		minv = INF;
		for (j=i-1;j>=0;--j)
		{
			t = sumL[i] - sumL[j] + i-j-1 - L;
			if (j < i-1 && t > L + L)
				break;
			t = power(t);
			if ( double(t) + double(F[j]) <= LIMIT && t + F[j] < minv)
			{
				minv = t + F[j];
				k = j;
			}
		}
		F[i] = minv;
		deci[i] = k;
	}
}
 
void print()
{
	if (F[N] <= LIMIT)
	{
		cout << F[N] << endl;
		int i,j;
		for (i=N,j=0;i;i=deci[i])
			sel[++j] = i;
		for (i=0;j;j--)
		{
			for (++i;i < sel[j];++i)
				printf("%s ",sent[i]);
			printf("%s\n",sent[i]);
		}
	}
	else
		printf("Too hard to arrange\n");
	printf("--------------------\n");
}
 
int main()
{
	int i,T;
	freopen("poet.in","r",stdin);
	freopen("poet.out","w",stdout);
	scanf("%d",&T);
	for (i=1;i<=T;i++)
	{
		init();
		solve();
		print();
	}
	return 0;
}

解法3 凸壳优化动态规划

算法描述

观察发现测试点6，7的N和L都很大，而P值为2。经分析发现可以使用单调队列维护凸壳。

算法分析与证明

当P=2时，观察状态转移方程

clip_image010

设对于F[i]的最优决策为k，那么对于所有的j≠k，均满足

clip_image012

设clip_image014，clip_image016，则有

clip_image018

clip_image020

clip_image022

因为SumL为单调增函数，所以A，B均为增函数。当B[j]>B[k] ⇒j>k，有

clip_image024

相对的，当j<k时有

clip_image026

如果把(B[i],F[i]+B[i]2)看作是二维平面上的一个点，那么clip_image028恰为斜率公式。因此对于最优决策k，应保证在对应点右边任意一个决策j的对应点，满足直线kj斜率大于2A[i]；在对应点左边任意一个决策j的对应点，满足直线kj斜率小于2A[i]。

image

因此所有最优决策在平面上的对应点连线就是一个斜率递增的凸壳。

image

具体实现时，用单调队列维护每个点(B[i],F[i]+B[i]2)，每在队尾加入一个新的点，判断斜率是否递增，如果不是则不断删除队尾元素。求F[i]的最优决策只需不断在队首删除点，直到队首两点组成的直线斜率刚好大于2A[i]，最优决策就是左端点的对应决策。

复杂度分析

用单调队列每次维护凸壳的时间复杂度为均摊O(1)，所以时间复杂度为O(N)。经测试可以通过测试点6，7，配合解法2，一共可以得到70分。

参考程序
?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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

/* 
 * Problem: NOI2009 poet
 * Author: Guo Jiabao
 * Time: 2009.9.22 14:30
 * State: Solved
 * Memo: 朴素动态规划 剪枝 凸壳优化
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
 
typedef long long big;
 
const int MAXN=100001,SMAXL=32;
const big INF=~0ULL>>1,LIMIT=1000000000000000000LL;
 
struct MonoQueue
{
	struct point
	{
		big x,y;
		int id;
	}P[MAXN];
 
	int head,tail;
 
	void initialize()
	{
		head = 0;
		tail = -1;
	}
 
	void insert(big x,big y,int id)
	{
		point p={x,y,id};
		for (;head + 1 <= tail;--tail)
		{
			double k1,k2;
			k1 = (p.y - P[tail].y) / double(p.x - P[tail].x);
			k2 = (P[tail].y - P[tail-1].y) / double(P[tail].x - P[tail-1].x);
			if (k1 > k2)
				break;
		}
		P[++tail] = p;
	}
 
	int getmin(big v)
	{
		for (;head + 1 <= tail;++head)
		{
			double k = (P[head+1].y - P[head].y) / double(P[head+1].x - P[head].x);
			if (k > v)
				break;
		}
		return P[head].id;
	}
}MQ;
 
big F[MAXN],sumL[MAXN],A[MAXN],B[MAXN];
int N,L,P;
int Len[MAXN],deci[MAXN],sel[MAXN];
char sent[MAXN][SMAXL];
 
void init()
{
	scanf("%d%d%d\n",&N,&L,&P);
	for (int i=1;i<=N;++i)
	{
		gets(sent[i]);
		Len[i] = strlen(sent[i]);
		sumL[i] = sumL[i-1] + Len[i];
	}
}
 
big power(big a)
{
	big t=1;
	double dt=1;
	if (a < 0)
		a = -a;
	for (int i=1;i<=P;i++)
	{
		dt *= a;
		if (dt > LIMIT)
			return INF;
		t *= a;
	}
	return t;
}
 
void tq()
{
	int i,j;
	big t;
	MQ.initialize();
	MQ.insert(0,0,0);
	for (i=1;i<=N;i++)
	{
		B[i] = sumL[i] + i;
		A[i] = B[i] - 1 - L;
	}
	for (i=1;i<=N;i++)
	{
		j = MQ.getmin(A[i] + A[i]);
		t = power(sumL[i] - sumL[j] + i-j-1 - L);
		if ( double(t) + double(F[j]) <= LIMIT )
			F[i] = F[j] + t;
		else
			F[i] = INF;
		if ( double(B[i]) * double(B[i]) + F[i] <= LIMIT)
			t = F[i] + B[i] * B[i];
		else
			t = INF;
		MQ.insert(B[i],t,i);
		deci[i] = j;
	}
}
 
void simple()
{
	int i,j,k;
	big minv,t;
	k = -1;
	for (i=1;i<=N;++i)
	{
		minv = INF;
		for (j=i-1;j>=0;--j)
		{
			t = sumL[i] - sumL[j] + i-j-1 - L;
			if (t > L + L)
				break;
			t = power(t);
			if ( double(t) + double(F[j]) <= LIMIT && t + F[j] < minv)
			{
				minv = F[j] + t;
				k = j;
			}
		}
		F[i] = minv;
		deci[i] = k;
	}
}
 
void solve()
{
	if (P == 2)
		tq();
	else
		simple();
}
 
void print()
{
	if (F[N] <= LIMIT)
	{
		cout << F[N] << endl;
		int i,j;
		for (i=N,j=0;i;i=deci[i])
			sel[++j] = i;
		for (i=0;j;j--)
		{
			for (++i;i < sel[j];++i)
				printf("%s ",sent[i]);
			printf("%s\n",sent[i]);
		}
	}
	else
		printf("Too hard to arrange\n");
	printf("--------------------\n");
}
 
int main()
{
	int i,T;
	freopen("poet.in","r",stdin);
	freopen("poet.out","w",stdout);
	scanf("%d",&T);
	for (i=1;i<=T;i++)
	{
		init();
		solve();
		print();
	}
	return 0;
}

解法4 决策单调性优化动态规划

算法描述

可以观察到或证明出，该状态转移方程满足决策单调性。因此我们可以使用双端队列维护每个决策区间，对于每个新决策使用二分查找确定位置并更新决策队列。

算法证明

再次观察状态转移方程

clip_image034

设clip_image036，状态转移方程可以化为1D/1D标准形式

clip_image038

要证明上述状态转移方程具有决策单调性，k(i)表示F[i]的最优决策，即

clip_image040

当且仅当满足四边形不等式

clip_image042

设clip_image044，clip_image046，clip_image048。其中clip_image050。

于是clip_image052。要证明①，只需证明

clip_image054

设clip_image056，clip_image058，则②等价于

clip_image060

clip_image062

因为clip_image064，且D[i+1]恒为正数，所以S<T。于是要证明③，只需证明下列函数在整数域内(非严格)单调递增

clip_image066

(1)若P为偶数

clip_image068，求导得clip_image070。

因为clip_image072，P-1为奇数，所以clip_image074，clip_image076恒成立，f(x)在实数域内单调递增。

(2)若P为奇数
(a)当X-C>=0

clip_image068[1]，求导得clip_image070[1]。

因为clip_image080，P-1为偶数，所以clip_image074[1]，clip_image076[1]恒成立，f(x)在实数域内单调递增。

(b)当X<=0

clip_image084，求导得clip_image086。因为P-1为偶数，clip_image076[2]恒成立，f(x)在实数域内单调递增。

(c)当0<X<C

clip_image090，求导得clip_image086[1]。因为P-1为偶数，clip_image076[3]恒成立，f(x)在实数域内单调递增。

综上所述，f(x)在实数域内单调递增，即在正数域内单调递增，因而③②①依次得证。

因此状态转移方程clip_image006[1]具有决策单调性。

复杂度分析

状态数为O(N)，每次维护决策队列的时间为O(logN)，所以时间复杂度为O(NlogN)。在测试中通过了全部测试点，拿到了100分。

参考程序
?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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

/* 
 * Problem: NOI2009 poet
 * Author: Guo Jiabao
 * Time: 2009.9.22 16:30
 * State: Solved
 * Memo: 动态规划 决策单调性
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
 
typedef long long big;
 
const int MAXN=100001,SMAXL=32;
const big LIMIT=1000000000000000000LL;
 
struct interval
{
	int s,t,deci;
}di[MAXN];
 
double F[MAXN];
int N,L,P,Stop;
int Len[MAXN],deci[MAXN],sel[MAXN];
char sent[MAXN][SMAXL];
big G[MAXN],sumL[MAXN];
 
void init()
{
	scanf("%d%d%d\n",&N,&L,&P);
	for (int i=1;i<=N;++i)
	{
		gets(sent[i]);
		Len[i] = strlen(sent[i]);
		sumL[i] = sumL[i-1] + Len[i];
	}
}
 
double dpower(double a)
{
	double t=1;
	if (a < 0)
		a = -a;
	for (int i=1;i<=P;i++)
		t *= a;
	return t;
}
 
double getF(int i,int j)
{
	double t = dpower(sumL[i] - sumL[j] + i-j-1 - L);
	return F[j] + t;
}
 
big power(big a)
{
	big t=1;
	double dt=1;
	if (a < 0)
		a = -a;
	for (int i=1;i<=P;i++)
	{
		dt *= a;
		if (dt > LIMIT)
			return LIMIT+1;
		t *= a;
	}
	return t;
}
 
big getG(int i,int j)
{
	big t = power(sumL[i] - sumL[j] + i-j-1 - L);
	if (F[j] + t <= LIMIT)
		return G[j] + t;
	else
		return LIMIT + 1;
}
 
void update(int i)
{
	while (di[Stop].s > i && getF(di[Stop].s,i) < getF(di[Stop].s,di[Stop].deci) )
	{
		di[Stop-1].t = di[Stop].t;
		Stop --;
	}
	int a=di[Stop].s,b=di[Stop].t,m;
	if (a < i+1)
		a = i+1;
	while (a+1<b)
	{
		m = (a + b) >> 1;
		if ( getF(m,di[Stop].deci) < getF(m,i) )
			a = m;
		else
			b = m-1;
	}
	if ( a < b && getF(b,di[Stop].deci) < getF(b,i) )
		a = b;
	if (a+1 <= di[Stop].t)
	{
		di[Stop + 1].s = a+1;
		di[Stop + 1].t = di[Stop].t;
		di[Stop + 1].deci = i;
		di[Stop].t = a;
		++Stop;
	}
}
 
void solve()
{
	int i,j;
	di[Stop=1].s = 1;
	di[Stop].t = N;
	for (i=j=1;i<=N;i++)
	{
		if (i > di[j].t)
			++j;
		deci[i] = di[j].deci;
		F[i] = getF(i,deci[i]);
		update(i);
	}
	for (i=1;i<=N;i++)
		G[i] = getG(i,deci[i]);
}
 
void print()
{
	if (G[N] <= LIMIT)
	{
		cout << G[N] << endl;
		int i,j;
		for (i=N,j=0;i;i=deci[i])
			sel[++j] = i;
		for (i=0;j;j--)
		{
			for (++i;i < sel[j];++i)
				printf("%s ",sent[i]);
			printf("%s\n",sent[i]);
		}
	}
	else
		printf("Too hard to arrange\n");
	printf("--------------------\n");
}
 
int main()
{
	int i,T;
	freopen("poet.in","r",stdin);
	freopen("poet.out","w",stdout);
	scanf("%d",&T);
	for (i=1;i<=T;i++)
	{
		init();
		solve();
		print();
	}
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/noi-2009-poet/feed/ 23 NOI 2006 网络收费 http://www.byvoid.com/blog/noi-2006-network/ http://www.byvoid.com/blog/noi-2006-network/#comments Wed, 03 Jun 2009 13:27:26 +0000 BYVoid http://www.byvoid.com/blog/?p=1369 对于我来说，这道题不易想到是动态规划，即使想到了，实现也是不容易的。

首先仔细观察表格可以发现一个等价的转化。假设一对付费节点i,j的最近公共祖先为p，如果p的nA<nB，称p为A付费节点，否则 为B付费节点。对于i和p，如果i和p的节点性质相同，则需要一倍的付费，j也相同。这时候，i,j的付费可以独立考虑了。这种付费方式与原题描述是等价 的。这一步是动态规划的必要前提条件。

经过这一步的转化，问题就明了多了。问题可以被描述为，安排每个叶节点的付费方案，使每个节点到其所有祖先需要付费之和最小。考虑一个叶 节点i到每个祖先p需要付费多少，取决于i相对于p的另一棵子树中所有节点j与i的流量F[i,j]之和。定义Cost[i,k]为叶节点i到其第k个祖 先需要的付费，我们可以求出每两个叶节点i,j的最近公共祖先p，并令Cost[i,p]和Cost[j,p]的值增加F[i,j]。

定义状态DP[i,j,k]为以第i个节点为根的子树中分配j个A节点，从根节点到i的每个祖先的状态集合为k的最小费用。k可以用二进制位表示，如果一个节点nA<nB，则标记该节点状态为A付费节点。状态转移方程为

F[i,j,k] = Min{ F[i.left,a,k+this] + F[i.right,j-a,k+this] }

其中 k+this表示加上当前节点状态

对于边界状态，就是i为叶节点，计算方法就是i的所有父节点中与i状态相同的节点k的Cost[i,k]之和，如果i与原先付费方式不同，还要加上C[i]。

观察发现F[i,j,k]的取值范围都是0..2^N，如果直接这样写，对于2^10会超空间的，只能拿到80%的分，直观难以发现如何减 少状态数，实际上后两维是有浪费的。假设叶节点为第0层，根节点为第N层，那么对于第k层的节点，它能控制的叶节点的个数最多为2^k，于是j的取值范围 就是0..2^k，一共有2^k + 1种可能。它的祖先一共有N-k个，每个祖先个状态可能有两种，于是k的取值一共有2^(N-k)种可能。因此，j,k的取值一共有(2^k + 1) * (2^(N-k)) = 2^N + 2^(N-k) <=2^(N+1)个，于是我们就可以把后两维状态数压缩到2^(N+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
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
145
146
147
148
149
150

/* 
 * Problem: NOI2006 network
 * Author: Guo Jiabao
 * Time: 2009.6.3 16:34
 * State: Solved
 * Memo: 树形动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN=11,MAXM=1025,MAXP=MAXM*2,INF=0x7FFFFFFF / 4;
struct Rec
{
	int r[MAXP],lim;
	int get(int a,int b)
	{
		int c=a*lim + b;
		return r[c];
	}
	void set(int a,int b,int v)
	{
		int c=a*lim + b;
		r[c]=v;
	}
}Record[MAXP];
int N,M,Ac,Ans,NewAns;
int Ancestor[MAXM][MAXN],Cost[MAXM][MAXN],Flow[MAXM][MAXM];
int Convert[MAXM];
bool Type[MAXM],mark;
void init()
{
	int i,j,a;
	freopen("network.in","r",stdin);
	freopen("network.out","w",stdout);
	scanf("%d",&N);
	M=1 << N;
	for (i=1;i<=M;i++)
	{
		scanf("%d",&a);
		Type[i] = a==0;
	}
	for (i=1;i<=M;i++)
		scanf("%d",&Convert[i]);
	for (i=1;i<=M-1;i++)
	{
		for (j=i+1;j<=M;j++)
		{
			scanf("%d",&a);
			Flow[i][j]=Flow[j][i]=a;
		}
	}
	Ans = INF;
}
int Brink(int a,int na,int S)
{
	int i,Ca=0,Cb=0;
	for (i=1;i<=N;i++,S=(S>>1))
	{
		if (S & 1)
			Ca += Cost[a][i];
		else
			Cb += Cost[a][i];
	}
	if (na==1)
		return Ca + (Type[a]?0:Convert[a]);
	else
		return Cb + (Type[a]?Convert[a]:0);
}
int DP(int i,int j,int k,int height)
{
	int rs=Record[i].get(j,k);
	if (rs==0)
	{
		if (height)
		{
			rs=INF;
			int newrs,a,ls,tk;
			mark=j < ((1 << height) - j);
			tk=(k << 1) + mark;
			ls=1<<(height-1);
			if ((a=j-ls)<0) a=0;
			for (;a<=j && a<=ls;a++)
			{
				newrs  = DP(i << 1,a,tk,height-1);
				newrs += DP((i << 1) + 1,j-a,tk,height -1);
				if (newrs < rs)
					rs = newrs;
			}
		}
		else
			rs = Brink(i-M+1,j,k);
		Record[i].set(j,k,rs);
	}
	return rs;
}
void solve()
{
	int i,j,k,l,p,a,b,NewAns;
	for (i=1;i<=M;i++)
	{
		k=i+M-1;
		for (j=1;j<=N;j++)
		{
			k=k >> 1;
			Ancestor[i][j]=k;
		}
	}
	for (k=1;k<=N+1;k++)
	{
		a=1 << (k-1);
		b=(1 << k) -1;
		l=N-k+1;
		for (p=a;p<=b;p++)
		{
			Record[p].lim=1 << (N-l);
			memset(Record[p].r,0,sizeof(Record[p].r));
		}
	}
	for (i=1;i<=M;i++)
	{
		for (j=i+1;j<=M;j++)
		{
			for (k=1;k<=N;k++)
			{
				if (Ancestor[i][k] == Ancestor[j][k])
				{
					Cost[i][k] += Flow[i][j];
					Cost[j][k] += Flow[i][j];
					break;
				}
			}
		}
	}
	for (i=0;i<=M;i++)
	{
		NewAns = DP(1,i,0,N);
		if (NewAns < Ans)
			Ans = NewAns;
	}
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

【问题描述】

网络已经成为当今世界不可或缺的一部分。每天都有数以亿计的人使用网络进行学习、科研、娱乐等活动。然而，不可忽视的一点就是网络本身有着 庞大的运行费用。所以，向使用网络的人进行适当的收费是必须的，也是合理的。 MY 市NS 中学就有着这样一个教育网络。网络中的用户一共有2N 个，编号依次为1, 2, 3, …, 2^N。这些用户之间是用路由点和网线组成的。用户、路由点与网线共同构成一个满二叉树结构。树中的每一个叶子结点都是一个用户，每一个非叶子结点（灰 色）都是一个路由点，而每一条边都是一条网线（见下图，用户结点中的数字为其编号）。

Image:Networkcost1.png

MY 网络公司的网络收费方式比较奇特，称为“ 配对收费 ”。即对于每两个用户i, j (1≤i < j ≤2^N ) 进行收费。由于用户可以自行选择两种付费方式A、B中的一种，所以网络公司向学校收取的费用与每一位用户的付费方式有关。该费用等于每两位不同用户配对产 生费用之和。

为了描述方便，首先定义这棵网络树上的一些概念：

  • 祖先：根结点没有祖先，非根结点的祖先包括它的父亲以及它的父亲的祖先；
  • 管辖叶结点：叶结点本身不管辖任何叶结点，非叶结点管辖它的左儿子所管辖的叶结点与它的右儿子所管辖的叶结点；
  • 距离：在树上连接两个点之间的用边最少的路径所含的边数。

对于任两个用户i, j (1≤i<j≤2^N )，首先在树上找到与它们距离最近的公共祖先：路由点P，然后观察P 所管辖的叶结点（即用户）中选择付费方式A 与B的人数，分别记为nA 与nB，接着按照网络管理条例第X 章第Y 条第Z 款进行收费（如下表），其中Fi, j 为i 和j 之间的流量，且为已知量。

Image:Networkcost2.png

由于最终所付费用与付费方式有关，所以NS 中学的用户希望能够自行改变自己的付费方式以减少总付费。然而，由于网络公司已经将每个用户注册时所选择的付费方式记录在案，所以对于用户i，如果他/她 想改变付费方式（由A 改为B 或由B 改为A），就必须支付Ci 元给网络公司以修改档案（修改付费方式记录）。

现在的问题是，给定每个用户注册时所选择的付费方式以及Ci，试求这些用户应该如何选择自己的付费方式以使得NS 中学支付给网络公司的总费用最少（更改付费方式费用+配对收费的费用）。

【输入文件】

输入文件中第一行有一个正整数N。

第二行有2N 个整数，依次表示1 号，2 号，…，2^N 号用户注册时的付费方式，每一个数字若为0，则表示对应用户的初始付费方式为A，否则该数字为1，表示付费方式为B。

第三行有2N 个整数，表示每一个用户修改付费方式需要支付的费用，依次为C1, C2, …,CM 。( M=2^N ) 以下2^N-1 行描述给定的两两用户之间的流量表F，总第(i + 3)行第j 列的整数为Fi, j+i 。（1≤i<2^N，1≤j≤2^N – i） 所有变量的含义可以参见题目描述。

【输出文件】

你的程序只需要向输出文件输出一个整数，表示NS 中学支付给网络公司的最小总费用。（单位：元）

【样例输入】

2
1 0 1 0
2 2 10 9
10 1 2
2 1
3

【样例输出】

8

【样例说明】

将1 号用户的付费方式由B 改为A，NS 中学支付给网络公司的费用达到最小。

【评分方法】

本题没有部分分，你的程序的输出只有和我们的答案完全一致才能获得满分，否则不得分。

【数据规模和约定】

  • 40%的数据中N≤4；
  • 80%的数据中N≤7；
  • 100%的数据中N≤10，0≤Fi, j≤500，0≤Ci≤500 000。

Maybe you like

]]> http://www.byvoid.com/blog/noi-2006-network/feed/ 3 NOI 2005 聪聪与可可 http://www.byvoid.com/blog/noi-2005-cchkk/ http://www.byvoid.com/blog/noi-2005-cchkk/#comments Mon, 01 Jun 2009 12:06:38 +0000 BYVoid http://www.byvoid.com/blog/?p=1358 首先要求出每对点之间的最短路径(All Pairs Shortest Path,APSP)，需要记录的是path[i][j]，表示在i点时，通向j的最短路径上比i更接近j的一个点。

然后动态规划，状态 F[i][j] 表示猫在i，老鼠在j时，猫追上老鼠的步数的数学期望。Degree(i)为点i的度。

状态转移方程

F[i][j]=sigma{ F[i'][j'] / ( Degree(j) + 1 ) } + 1

最终结果

F[C][M]

?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

/* 
 * Problem: NOI2005 cchkk
 * Author: Guo Jiabao
 * Time: 2009.6.1 17:30
 * State: Solved
 * Memo: 动态规划 期望计算
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN=1001;
struct edge
{
	edge *next;
	int t;
}*V[MAXN],ES[MAXN*2];
int N,M,X,Y,EC;
int dist[MAXN],path[MAXN][MAXN],deg[MAXN],Q[MAXN];
double F[MAXN][MAXN];
bool flag[MAXN];
inline void addedge(int a,int b)
{
	ES[++EC].next = V[a];
	V[a]=ES+EC; V[a]->t=b;
	deg[a]++;
}
void init()
{
	int i,j,a,b;
	freopen("cchkk.in","r",stdin);
	freopen("cchkk.out","w",stdout);
	scanf("%d%d%d%d",&N,&M,&X,&Y);
	for (i=1;i<=M;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]=-1;
		F[i][i]=0;
	}
}
void APSP()
{
	int i,j,k,head,tail;
	for (k=1;k<=N;k++)
	{
		memset(dist,-1,sizeof(dist));
		dist[k]=0;
		path[k][k]=k;
		for (Q[head=tail=0]=k;head<=tail;)
		{
			i=Q[head++];
			for (edge *e=V[i];e && (j=e->t);e=e->next)
			{
				if (dist[j] == -1)
				{
					dist[j] = dist[i] + 1;
					path[j][k] = i;
					Q[++tail]=j;
				}
				else if (dist[j] == dist[i] + 1 && i < path[j][k])
					path[j][k] = i;
			}
		}
	}
}
double dp(int i,int j)
{
	if (F[i][j]==-1)
	{
		double rs=0;
		int x = path[ path[i][j] ][j];
		rs = dp(x,j) + 1;
		if (x!=j)
		{
			for (edge *e=V[j];e;e=e->next)
				rs += dp(x,e->t) + 1;
			rs /= deg[j] + 1;
		}
		F[i][j]=rs;
	}
	return F[i][j];
}
 
int main()
{
	init();
	APSP();
	printf("%.3lfn",dp(X,Y));
	return 0;
}

聪聪与可可

【问题描述】

在一个魔法森林里，住着一只聪明的小猫聪聪和一只可爱的小老鼠可可。虽然灰姑娘非常喜欢她们俩，但是，聪聪终究是一只猫，而可可终究是一只老鼠，同样不变的是，聪聪成天想着要吃掉可可。

一天，聪聪意外得到了一台非常有用的机器，据说是叫GPS，对可可能准确的定位。有了这台机器，聪聪要吃可可就易如反掌了。于是，聪聪准备 马上出发，去找可可。而可怜的可可还不知道大难即将临头，仍在森林里无忧无虑的玩耍。小兔子乖乖听到这件事，马上向灰姑娘报告。灰姑娘决定尽快阻止聪聪， 拯救可可，可她不知道还有没有足够的时间。

整个森林可以认为是一个无向图，图中有N个美丽的景点，景点从1至N编号。小动物们都只在景点休息、玩耍。在景点之间有一些路连接。

当聪聪得到GPS时，可可正在景点M(M≤N)处。以后的每个时间单位，可可都会选择去相邻的景点(可能有多个)中的一个或停留在原景点不 动。而去这些地方所发生的概率是相等的。假设有P个景点与景点M相邻，它们分别是景点R、景点S，……景点Q，在时刻T可可处在景点M，则在(T＋1)时 刻，可可有1/(P+1)的可能在景点R，有1/(P+1)的可能在景点S，……，有1/(P+1)的可能在景点Q，还有1/(P+1)的可能停在景点 M。

我们知道，聪聪是很聪明的，所以，当她在景点C时，她会选一个更靠近可可的景点，如果这样的景点有多个，她会选一个标号最小的景点。由于聪聪太想吃掉可可了，如果走完第一步以后仍然没吃到可可，她还可以在本段时间内再向可可走近一步。

在每个时间单位，假设聪聪先走，可可后走。在某一时刻，若聪聪和可可位于同一个景点，则可怜的可可就被吃掉了。灰姑娘想知道，平均情况下，聪聪几步就可能吃到可可。而你需要帮助灰姑娘尽快的找到答案。

【输入文件】

  • 从文件中读入数据。
  • 数据的第1行为两个整数N和E，以空格分隔，分别表示森林中的景点数和连接相邻景点的路的条数。
  • 第2行包含两个整数C和M，以空格分隔，分别表示初始时聪聪和可可所在的景点的编号。
  • 接下来E行，每行两个整数，第i+2行的两个整数Ai和Bi表示景点Ai和景点Bi之间有一条路。
  • 所有的路都是无向的，即：如果能从A走到B，就可以从B走到A。
  • 输入保证任何两个景点之间不会有多于一条路直接相连，且聪聪和可可之间必有路直接或间接的相连。

【输出文件】

  • 输出到文件中。
  • 输出1个实数，四舍五入保留三位小数，表示平均多少个时间单位后聪聪会把可可吃掉。

【样例输入1】

4 3
1 4
1 2
2 3
3 4

【样例输出1】

1.500

【样例说明1】

开始时，聪聪和可可分别在景点1和景点4。

第一个时刻，聪聪先走，她向更靠近可可(景点4)的景点走动，走到景点2，然后走到景点3；假定忽略走路所花时间。

可可后走，有两种可能：

第一种是走到景点3，这样聪聪和可可到达同一个景点，可可被吃掉，步数为1，概率为 0.5。 第二种是停在景点4，不被吃掉。概率为 0.5。

到第二个时刻，聪聪向更靠近可可(景点4)的景点走动，只需要走一步即和可可在同一景点。因此这种情况下聪聪会在两步吃掉可可。

所以平均的步数是1* 0.5+2* 0.5=1.5步。

【样例输入2】

9 9
9 3
1 2
2 3
3 4
4 5
3 6
4 6
4 7
7 8
8 9

【样例输出2】

2.167

【样例说明2】

森林如下图所示：

Image:Cchkk.gif

【数据范围】

  • 对于所有的数据，1≤N,E≤1000。
  • 对于50%的数据，1≤N≤50。

Maybe you like

]]> http://www.byvoid.com/blog/noi-2005-cchkk/feed/ 0