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 2000 解题报告 http://www.byvoid.com/blog/noi-2000-solution/ http://www.byvoid.com/blog/noi-2000-solution/#comments Thu, 12 Mar 2009 06:05:33 +0000 BYVoid http://www.byvoid.com/blog/?p=931 NOI2000的题目是[瓷片项链][单词查找树][青蛙过河][程序分析器][古城之谜][算符破译]。[瓷片项链][单词查找树][青蛙过河][程序分析器]都是简单题，[古城之谜]难度一般，[算符破译]是较难。

[瓷片项链]是简单的二次函数求最值的问题，数学方法可以直接解决。[单词查找树]是一种基本的字符串处理的数据结构。[青蛙过河]是一个递归的数学问题，可以求出直接的公式。[程序分析器]是个模拟题，需要细心。[古城之谜]是个动态规划问题，但是需要对题意尤其是对范式的深入分析。[算符破译]是个较难的搜索题，需要大量剪枝和优化。

[瓷片项链]

看似送分的题，有些细节需要注意。不建议枚举保留最大值，因为精度误差不可避免，容易出问题。

  • 总体积为Vt，每片损耗为V0，设烧制x片
  • 则每片体积 V=Vt/x 应满足V>V0 即x<Vt/V0
  • 直径 D=0.3 * sqrt(V-V0)
  • 总长度
    • L=x*D
    • =x * 0.3 * sqrt(Vt/x-V0)
    • =0.3 *sqrt( Vt * x – V0 * x^2 )

根号内部是一个二次函数，求其最值即可。当L取到最大值，有x=V/(2*V0)。

无解的条件是x的小数部分为0.5。

?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

/* 
 * Problem: NOI2000 ring
 * Author: Guo Jiabao
 * Time: 2009.3.8 17:11
 * State: Solved
 * Memo: 二次函数最值
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
int Vt,V0,Ans;
double x,dx;
int main()
{
	freopen("ring.in","r",stdin);
	freopen("ring.out","w",stdout);
	scanf("%d%d",&Vt,&V0);
	dx=floor(x=(double)Vt/V0/2);
	if (x-dx==0.5) Ans=0;
	else Ans=dx;
	printf("%dn",Ans);
	return 0;
}

[单词查找树]

如果学过Trie，这道题太简单了，只需在创建新节点时计数即可。就算没有学过Trie，通过定义和样例也一样能看懂，很容易搞定。

?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

/* 
 * Problem: NOI2000 trie
 * Author: Guo Jiabao
 * Time: 2009.3.8 17:44
 * State: Solved
 * Memo: 单词查找树 Trie
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
struct TTrie
{
	struct Trie_node
	{
		Trie_node *c[26];
		Trie_node(){memset(c,0,sizeof(c));}
	};
	Trie_node *root;
	int cnt;
	void ins(Trie_node *&p,char *s)
	{
		if (!p) p=new Trie_node(),cnt++;
		if (*s) ins(p->c[*s-'A'],s+1);
	}
}Trie;
using namespace std;
int main()
{
	char Word[70];
	freopen("trie.in","r",stdin);
	freopen("trie.out","w",stdout);
	while (scanf("%s",Word)!=EOF)
		Trie.ins(Trie.root,Word);
	printf("%dn",Trie.cnt);
	return 0;
}

[青蛙过河]

在NOI冬令营上，吴文虎教授曾经多次把这道题当作递归思想的例题讲授。我想这道题很不错，需要一定的数学思维。

首先简化问题，考虑没有石墩的情况。我们设F[s,y]表示有s个石墩和y片荷叶，最多能跳过的青蛙个数。

显然F[0,0]=1，F[0,1]=2，F[0,2]=3，…，可以归纳出F[0,y]=y+1。理解就是先把y只青蛙放在每片荷叶上，让最后一只直接跳过去，然后荷叶上的青蛙依次跳过去。

如果有石墩，假设有两个石墩S1,S2。可以分两步考虑，首先对于A,S1,S2，对于这个系统，让A的一半青蛙跳到S2。然后对于 A,S1,D这个系统，把A的剩余青蛙跳到D。最后对于S1,S2,D这个系统，把S2的青蛙跳到D。这样恰好 F[2,0]=F[1,0]+F[1,0]。

更一般的，F[s,y]=F[s,y]*2 (s>0)，再加上F[0,y]=y+1这个关系，可以很容易地递推出了。实际上F[s,y]可以找到直接的公式，不难证明，即F[s,y]=(y+1)*2^s。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/* 
 * Problem: NOI2000 frog
 * Author: Guo Jiabao
 * Time: 2009.3.9 20:00
 * State: Solved
 * Memo: 递归F[s,y]=F[s-1,y]*2 F[0,y]=y+1
*/
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
	int s,y;
	freopen("frog.in","r",stdin);
	freopen("frog.out","w",stdout);
	scanf("%d%d",&s,&y);
	printf("%dn",(y+1)*1<<s);
	return 0;
}

[程序分析器]

这道题就是一个模拟，只要能看懂范式就行了。由于有大量的访问，建议按行号排序后使用链表+哈希。

对于不能正常结束的问题，有这几种情况

  • 跳转到了一个未定义的行
  • 执行完了最后一条语句，没有遇到End
  • 死循环

前两个还好判断，死循环比较棘手。事实上死循环是被证明不可判定的，对于这道题，我的方法是记录如果执行次数大于10000000，就当作死循环终止，这显然是不完备的，但是可以通过所有测试点。

另外NOI原数据的最后一组答案是错的，应该是5099760。

?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

/* 
 * Problem: NOI2000 analyser
 * Author: Guo Jiabao
 * Time: 2009.3.9 21:49
 * State: Solved
 * Memo: BNF模拟
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXS=101,MAXL=3001,PLUS=0,PRINT=1,GO=2,IFGO=3,END=4;
using namespace std;
struct statement
{
	statement *next;
	int line,var,value,goline,type;
}L[MAXS];
statement *Skip[MAXL];
int N,l,cnt=1;
int Vars[30];
inline int cmp(const void *a,const void *b)
{
	return ((statement *)a)->line-((statement *)b)->line;
}
void init()
{
	int l,i;char C[MAXL];
	freopen("analyser.in","r",stdin);
	freopen("analyser.out","w",stdout);
	while (scanf("%d",&l)!=EOF)
	{
		L[++N].line=l;
		l=getchar();
		scanf("%s",C);
		if (C[1]=='?') //print
		{
			L[N].var=C[0]-'A';
			L[N].type=PRINT;
		}
		else if (C[1]=='+') //plus
		{
			L[N].var=C[0]-'A';
			L[N].type=PLUS;
			sscanf(C+2,"%d",&l);
			L[N].value=l;
		}
		else if (C[1]=='O') //GO
		{
			L[N].type=GO;
			scanf("%d",&l);
			L[N].goline=l;
		}
		else if (C[1]=='F') //IF
		{
			l=getchar();l=getchar();
			L[N].type=IFGO;
			L[N].var=l-'A';
			l=getchar();
			scanf("%d",&l);
			L[N].value=l;
			l=getchar();l=getchar();l=getchar();l=getchar(); //<S>GO<S>
			scanf("%d",&l);
			L[N].goline=l;
		}
		else
			L[N].type=END;
	}
	qsort(L+1,N,sizeof(L[0]),cmp);
	for (i=1;i<N;i++)
	{
		L[i].next=&L[i+1];
		Skip[L[i].line]=&L[i];
	}
	Skip[L[i].line]=&L[i];
}
bool execute()
{
	for (statement *p=&L[1];p;cnt++)
	{
		if (cnt>10000000) return false;
		if (p->type==PLUS)
			Vars[p->var]+=p->value;
		else if (p->type==END)
			return true;
		else if (p->type==GO)
		{
			p=Skip[p->goline];
			continue;
		}
		else if (p->type==IFGO && Vars[p->var]==p->value)
		{
			p=Skip[p->goline];
			continue;
		}
		p=p->next;
	}
	return false;
}
int main()
{
	init();
	if (!execute())cnt=-1;
	printf("%dn",cnt);
	return 0;
}

[古城之谜]

做出这道题关键在于理解语法。其中名词短语和动词短语给出的都是递归定义，可以转化为更直观的，<名词短语> ::= {<辅词>} <名词>，<动词短语> ::= {<辅词>} <动词>，也就是以一个名词或动词结尾，前面可以加上任意多个辅词。而句子就是要以名词短语开头，后面的名词短语和动词短语交错出现。

分析出语法结构，可以动态规划。定义词性j={0,1,2,3}。j=0表示该词为一个名词，j=1表示该词为一个动词，j=2表示该词为一个辅词，且在它前面的最近的非辅词为名词，j=3表示该词为一个辅词，且在它前面的最近的非辅词为动词。

状态设定

  • F[i,j,k]表示，前i个字母，末尾单词词性为j，组成第k个句子的最少单词数。文章长度为M。

状态转移方程

满足文章中第[a+1,i]可以匹配一个单词，则可以状态转移。i-L<=a<=i-1 且 a>=0，L为所有单词最大长度。

  • 如果匹配的单词为名词

F[i,0,k]=Min { F[a,j,k] + 1 | j=1或j=3, F[a,j,k-1] + 1 | j=0或j=1 }

  • 如果匹配的单词为动词

F[i,1,k]=Min { F[a,j,k] + 1 | j=0或j=2 }

  • 如果匹配的单词为辅词

F[i,2,k]=Min { F[a,j,k] + 1 | j=0或j=2 }

F[i,3,k]=Min { F[a,j,k] + 1 | j=1或j=3, F[a,j,k-1] + 1 | j=0或j=1 }

边界条件

  • F[0,0,0]=0

目标结果

找到最小的k，使得Min{F[M,0,k],F[M,1,k]}有意义，则最小的句子数为k，单词数为Min{F[M,0,k],F[M,1,k]}。

时间复杂度为O(N*M*L)，匹配单词的时候可以用Trie树，第三维状态可以使用滚动数组。

?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

/* 
 * Problem: NOI2000 lostcity
 * Author: Guo Jiabao
 * Time: 2009.3.11 14:00
 * State: Solved
 * Memo: 动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=1001,MAXL=22,MAXM=5002,IMP=0x7FFFFFF;
using namespace std;
struct TTrie
{
	struct Trie_node
	{
		Trie_node *c[26];
		int Wm;
		Trie_node():Wm(0){memset(c,0,sizeof(c));}
	};
	Trie_node *root;
	void ins(Trie_node *&p,int *S,int L,int Wm)
	{
		if (!p) p=new Trie_node();
		if (L==0) p->Wm|=Wm;
		else ins(p->c[*S],S+1,L-1,Wm);
	}
	int find(Trie_node *p,int *S,int L)
	{
		if (!p) return 0;
		if (L==0) return p->Wm;
		else return find(p->c[*S],S+1,L-1);
	}
}Trie;
int N,M,MaxL,Ans1,Ans2;
char Word[MAXL],Passage[MAXM];
int W[MAXL],P[MAXM],F[MAXM][4][2],Mat[MAXM][MAXL];
void init()
{
	int i,j,len,type;
	freopen("lostcity.in","r",stdin);
	freopen("lostcity.out","w",stdout);
	scanf("%d",&N);
	for (i=1;i<=N;i++)
	{
		scanf("%s",Word);
		len=strlen(Word)-2;
		if (len>MaxL) MaxL=len;
		for (j=1;j<=len;j++)
			W[j]=Word[j+1]-'a';
		if (Word[0]=='n')
			type=1;
		else if (Word[0]=='v')
			type=2;
		else
			type=4;
		Trie.ins(Trie.root,W+1,len,type);
	}
	scanf("%s",Passage);
	M=strlen(Passage)-1;
	for (j=1;j<=M;j++)
		P[j]=Passage[j-1]-'a';
	for (i=1;i<=M;i++)
		for (j=1;j<=MaxL;j++)
			Mat[i][j]=-1;
}
inline int Min(int a,int b){return a<b?a:b;}
int dynamic()
{
	int i,j,k,p;
	for (p=0;p<=1;p++)
		for (i=0;i<4;i++)
			for (j=0;j<=M;j++)
			F[j][i][p]=IMP;
	F[0][0][0]=0;
	for (k=p=1;k<=M;k++,p=!p)
	{
		for (i=1;i<=M;i++)
		{
			F[i][0][p]=F[i][1][p]=F[i][2][p]=F[i][3][p]=IMP;
			for (j=i-1;j>=i-MaxL && j>=0;j--)
			{
				if (Mat[i][i-j]==-1)
					Mat[i][i-j]=Trie.find(Trie.root,P+j+1,i-j);
				int Wm=Mat[i][i-j];
				if (Wm&1)
				{
					F[i][0][p]=Min(F[i][0][p],F[j][1][p]+1);
					F[i][0][p]=Min(F[i][0][p],F[j][3][p]+1);
					F[i][0][p]=Min(F[i][0][p],F[j][0][!p]+1);
					F[i][0][p]=Min(F[i][0][p],F[j][1][!p]+1);
				}
				if (Wm&2)
				{
					F[i][1][p]=Min(F[i][1][p],F[j][0][p]+1);
					F[i][1][p]=Min(F[i][1][p],F[j][2][p]+1);
				}
				if (Wm&4)
				{
					F[i][2][p]=Min(F[i][2][p],F[j][0][p]+1);
					F[i][2][p]=Min(F[i][2][p],F[j][2][p]+1);
 
					F[i][3][p]=Min(F[i][3][p],F[j][1][p]+1);
					F[i][3][p]=Min(F[i][3][p],F[j][3][p]+1);
					F[i][3][p]=Min(F[i][3][p],F[j][0][!p]+1);
					F[i][3][p]=Min(F[i][3][p],F[j][1][!p]+1);
				}
			}
		}
		Ans2=Min(F[M][0][p],F[M][1][p]);
		if (Ans2<IMP)
			return k;
	}
}
int main()
{
	init();
	Ans1=dynamic();
	printf("%dn%dn",Ans1,Ans2);
	return 0;
}

[算符破译]

相当变态的搜索题，目前还没能在1s内AC。

基本思路是先确定等号的位置，然后搜索+*的位置，最后往空档中填数。我写了400多行的程序，最大的数据还是5s才能过。继续研究。

?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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413

/* 
 * Problem: NOI2000 equation
 * Author: Guo Jiabao
 * Time: 2009.3.11 21:12
 * State: half-done
 * Memo: 搜索优化
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXL=12,MAXN=1001,LETTER=15,LT=13;
const int EQUAL=-1,PLUS=-2,MULTIPLY=-3,NO=-4,UND=-5;
using namespace std;
struct equation
{
	int len;
	int s[MAXL];
}E[MAXN];
int adjl[LETTER][LETTER];
bool adjm[LETTER][LETTER];
bool ce[LETTER];//可以为等号的字母
bool op[LETTER],appear[100],ava[LETTER],Noway=true;
bool used[LETTER],opu[2];
int Mapp[LETTER],Sp[LETTER];
int P[2][MAXL],L[2];
int N;
void print();
inline int cmp(const void *a,const void *b)
{
	return ((equation *)a)->len-((equation *)b)->len;
}
inline int Max(int a,int b)
{
	return a>b?a:b;
}
void init()
{
	int i,j;
	int te[LETTER];
	char W[MAXL];
	memset(adjm,0,sizeof(adjm));
	freopen("equation.in","r",stdin);
	freopen("equation.out","w",stdout);
	scanf("%d",&N);
	for (i=1;i<=LT;i++)
		ce[i]=true;
	for (i=1;i<=N;i++)
	{
		scanf("%s",W);
		E[i].len=strlen(W);
		memset(te,0,sizeof(te));
		for (j=1;j<=E[i].len;j++)
		{
			E[i].s[j]=W[j-1]-'a'+1;
			ava[E[i].s[j]]=true;
			if (j!=1 && j!=E[i].len)
				te[E[i].s[j]]++;
			if (j>1)
				adjm[E[i].s[j]][E[i].s[j-1]]=adjm[E[i].s[j-1]][E[i].s[j]]=true;
		}
		adjm[E[i].s[1]][0]=adjm[0][E[i].s[1]]=true;
		adjm[E[i].s[E[i].s[j]]][0]=adjm[0][E[i].s[E[i].s[j]]]=true;
		for (j=1;j<=LT;j++)
			if (te[j]!=1)
			ce[j]=false;
	}
	for (i=0;i<=LT+1;i++)
	{
		for (j=0;j<=LT+1;j++)
			if (adjm[i][j])
				adjl[i][ ++adjl[i][0] ]=j;
		Mapp[i]=Sp[i]=UND;
	}
	op[0]=true;
	qsort(E+1,N,sizeof(E[0]),cmp);
}
void debug()
{
	int i,j,c;
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=E[i].len;j++)
		{
			c=Mapp[E[i].s[j]];
			if (c>=0) c+='0';
			else if (c==EQUAL) c='=';
			else if (c==PLUS) c='+';
			else if (c==MULTIPLY) c='*';
			printf("%c",c);
		}
		printf("n");
	}
	printf("n");
}
void solution()
{
	int i;
	//debug();
	if (Sp[1]==UND)
		for (i=1;i<=LT;i++)
		{
			Sp[i]=Mapp[i];
			appear[Sp[i]+10]=true;
		}
	else
		for (i=1;i<=LT;i++)
			if (Sp[i]!=Mapp[i])
			{
				Sp[i]=NO;
				appear[Sp[i]+10]=true;
			}
}
int compute(int *P,int L)
{
	int stack[MAXL],top=0,i;
	for (i=1;i<=L;i++)
	{
		if (P[i]>=0)
			stack[++top]=P[i];
		else if (P[i]==MULTIPLY)
			stack[top]=stack[top]*P[++i];
	}
	for (;top>1;top--)
		stack[top-1]+=stack[top];
	return stack[1];
}
void makeequation(int p)
{
	int i,k=0,v;
	L[0]=L[1]=0;
	memset(P,0,sizeof(P));
	for (i=1;i<=E[p].len;i++)
	{
		v=Mapp[E[p].s[i]];
		if (v==EQUAL)
		{
			k=1;
			continue;
		}
		if (v>=0)
		{
			if (i==1 || Mapp[E[p].s[i-1]]<0)
				L[k]++;
			P[k][L[k]]=P[k][L[k]]*10+v;
		}
		else
		{
			P[k][++L[k]]=v;
		}
	}
}
bool check(int p)
{
	int R[2];
	makeequation(p);
	R[0]=compute(P[0],L[0]);
	R[1]=compute(P[1],L[1]);
	return (R[0]==R[1]);
}
void fillequation(int p,int f)
{
	int i,k=0,v;
	L[0]=L[1]=0;
	memset(P,0,sizeof(P));
	for (i=1;i<=E[p].len;i++)
	{
		v=Mapp[E[p].s[i]];
		if (v==EQUAL)
		{
			k=1;f=10-f;
			continue;
		}
		if (v>=0)
		{
			if (i==1 || Mapp[E[p].s[i-1]]<0)
				L[k]++;
			P[k][L[k]]=P[k][L[k]]*10+f;
		}
		else
		{
			P[k][++L[k]]=v;
		}
	}
}
bool limit()
{
	int i;
	int R[2];
	for (i=1;i<=N;i++)
	{
		fillequation(i,1);//左小右大
		R[0]=compute(P[0],L[0]);
		R[1]=compute(P[1],L[1]);
		if (R[0]>R[1])
			return false;
		fillequation(i,9);//左大右小
		R[0]=compute(P[0],L[0]);
		R[1]=compute(P[1],L[1]);
		if (R[0]<R[1])
			return false;
	}
	return true;
}
void computelen(int *P,int L,int &a,int &b)
{
	int stacka[MAXL],stackb[MAXL],top=0,i;
	for (i=1;i<=L;i++)
	{
		if (P[i]>=0)
		{
			stacka[++top]=P[i];
			stackb[top]=P[i];
		}
		else if (P[i]==MULTIPLY)
		{
			stacka[top]=stacka[top]+P[++i]-1;
			stackb[top]=stackb[top]+P[i];
		}
	}
	for (;top>1;top--)
	{
		stacka[top-1]=Max(stacka[top-1],stacka[top]);
		stackb[top-1]=Max(stackb[top-1],stackb[top])+1;
	}
	a=stacka[1];b=stackb[1];
}
bool lenequation(int p)
{
	int i,k=0,v,l0,l1,r0,r1;
	L[0]=L[1]=0;
	memset(P,0,sizeof(P));
	for (i=1;i<=E[p].len;i++)
	{
		v=Mapp[E[p].s[i]];
		if (v==EQUAL)
		{
			k=1;
			continue;
		}
		if (v>=0 || v==UND)
		{
			if (i==1 || Mapp[E[p].s[i-1]]<0)
				L[k]++;
			P[k][L[k]]=P[k][L[k]]+1;
		}
		else
		{
			P[k][++L[k]]=v;
		}
	}
	computelen(P[0],L[0],l0,r0);
	computelen(P[1],L[1],l1,r1);
	return !(r0<l1 || r1<l0);
}
bool possible()
{
	int i;
	for (i=1;i<=N;i++)
	{
		if (!lenequation(i))
			return false;
	}
	return true;
}
void search_number(int p,int k)//第p个等式 第k个字符
{
	int i,C=E[p].s[k];
	bool rfs,lfs;
 
	for (i=1;i<=LT;i++)
		if (ava[i])
			if (!(Mapp[i]==Sp[i] || Sp[i]==NO))
				break;
	if (i>LT)
		return;
 
	if (p>N)
	{
		Noway=false;
		solution();
		return;
	}
	rfs= k==E[p].len || Mapp[E[p].s[k+1]]<0;
	lfs= k==1 || Mapp[E[p].s[k-1]]<0;
	if (Mapp[C]==0 && !rfs && lfs)
		return;
	while (Mapp[C]!=UND && k<=E[p].len)
	{
		C=E[p].s[--k];
		rfs= k==E[p].len || Mapp[E[p].s[k+1]]<0;
		lfs= k==1 || Mapp[E[p].s[k-1]]<0;
		if (Mapp[C]==0 && !rfs && lfs)
			return;
	}
	if (k==0)
	{
		if (check(p))
			search_number(p+1,E[p+1].len);
		return;
	}
	for (i=0;i<=9;i++)
	{
		if (used[i])
			continue;
		rfs= k==E[p].len || Mapp[E[p].s[k+1]]<0;
		lfs= k==1 || Mapp[E[p].s[k-1]]!=UND;
		if (i==0 && !rfs && lfs)
			continue;
		Mapp[C]=i;
		used[i]=true;
		search_number(p,k-1);
		used[i]=false;
	}
	Mapp[C]=UND;
}
void search_operator(int k)
{
	int i,j;
	while ((!ava[k] || Mapp[k]!=UND) && k<=LT) k++;
	if (k>LT)
	{
		if (possible() && limit())
			search_number(1,E[1].len);
		return;
	}
	for (i=1;i<=adjl[k][0];i++)
	{
		j=adjl[k][i];
		if (op[j])
			break;
	}
	if (i>adjl[k][0])
	{
			op[k]=true;
			if (!opu[0])
			{
				opu[0]=true;
				Mapp[k]=PLUS;
				search_operator(k+1);
				opu[0]=false;
			}
			if (!opu[1])
			{
				opu[1]=true;
				Mapp[k]=MULTIPLY;
				search_operator(k+1);
				opu[1]=false;
			}
			op[k]=false;
			Mapp[k]=UND;
	}
	search_operator(k+1);
}
void solve()
{
	int i;
	for (i=1;i<=LT;i++)
	{
		if (ce[i] && !adjm[i][0])
		{
			op[i]=true;
			Mapp[i]=EQUAL;
			search_operator(1);
			Mapp[i]=UND;
			op[i]=false;
		}
	}
}
void print()
{
	int i,ud=0,j,other;
	for (i=1;i<=LT;i++)
	{
		if (Sp[i]==UND)
		{
			ud++;
			j=i;
		}
		if (!appear[i])
			other=i;
	}
	for (i=1;i<=LT;i++)
	{
		if (ud==1 && i==j)
		{
			int c=other-10;
			if (c==EQUAL) c='=';
			else if (c==PLUS) c='+';
			else if (c==MULTIPLY) c='*';
			else c-='+';
			printf("%c%cn",i+'a'-1,c);
			continue;
		}
		if (Sp[i]==UND || Sp[i]==NO )
			continue;
		if (Sp[i]==EQUAL) printf("%c=n",i+'a'-1);
		else if (Sp[i]==PLUS) printf("%c+n",i+'a'-1);
		else if (Sp[i]==MULTIPLY) printf("%c*n",i+'a'-1);
		else printf("%c%dn",i+'a'-1,Sp[i]);
	}
	if (Noway)
		printf("nowayn");
	exit(0);
}
int main()
{
	init();
	solve();
	print();
	return 0;
}

瓷片项链

原始部落用一种稀有的泥土烧制直径相同的圆瓷片并串成项链，串的时候沿瓷片的直径方向顺次连接，瓷片之间没有空隙也不重叠，一条项链至少由一个瓷片构成。

每个烧制的瓷片厚度是一定的，直径D和所用泥土的体积V有以下关系：

D=0.3*(V-V0)^0.5 (V>V0)

其中V0为烧制每一片的损耗，单位与V相同。当用料小于等于V0时，不能烧制成瓷片。

例： V总 = 10，V0 = 1，若烧制成一片瓷片，V = V总= 10，D = 0.9。如果把泥土均分成2份，每份泥土的体积为V = V总/2 = 5，单个瓷片的直径为 ,串起来的总长为1.2。

给定了泥土的总体积和烧制单个瓷片的损耗，烧制的瓷片数不同，能够得到的项链总长度也不相同，请计算烧制多少个瓷片能使所得到的项链最长。

[输入文件]

文件仅有两行，每一行仅包含一个整数和一个换行/回车符。第一行的数字为泥土总体积V总 (0<V总<60000)，第二行为烧制单个瓷片的损耗V0(0< V0<600)。

[输出文件]

文件中仅包含一个数字和一个换行/回车符。该数字为能获得最长项链而烧制的瓷片数。如果不能烧制成瓷片或者最优解不唯一（存在两个或者两个以上方案均能获得最长项链），输出数字0。

[输入输出文件样例1]

Input

10
1

Output

5

[输入输出文件样例2]

Input

10
2

Output

0

单词查找树

在进行文法分析的时候，通常需要检测一个单词是否在我们的单词列表里。为了提高查找和定位的速度，通常都要画出与单词列表所对应的单词查找树，其特点如下：

  • 根节点不包含字母，除根节点外每一个节点都仅包含一个大写英文字母；
  • 从根节点到某一节点，路径上经过的字母依次连起来所构成的字母序列，称为该节点对应的单词。单词列表中的每个词，都是该单词查找树某个节点所对应的单词；
  • 在满足上述条件下，该单词查找树的节点数最少。

单词列表对应的单词查找树

A
AN
ASP
AS
ASC
ASCII
BAS
BASIC
Image:Trie.gif

对一个确定的单词列表，请统计对应的单词查找树的节点数（包括根节点）

[输入文件]

该文件为一个单词列表，每一行仅包含一个单词和一个换行/回车符。每个单词仅由大写的英文字符组成，长度不超过63个字符。文件总长度不超过32K，至少有一行数据。

[输出文件]

该文件中仅包含一个整数和一个换行/回车符。该整数为单词列表对应的单词查找树的节点数。

[输入输出文件样例]

Input

A
AN
ASP
AS
ASC
ASCII
BAS
BASIC

Output

13

青蛙过河

大小各不相同的一队青蛙站在河左岸的石墩（记为A）上，要过到对岸的石墩(记为D)上去。河心有几片菏叶(分别记为Y1…Ym)和几个石墩(分别记为S1…Sn)。图示如下：

Image:Frog.gif

青蛙的站队和移动方法规则如下：

  1. 每只青蛙只能站在荷叶、石墩，或者仅比它大一号的青蛙背上（统称为合法的落脚点）；
  2. 一只青蛙只有背上没有其它青蛙的时候才能够从一个落脚点跳到另一个落脚点；
  3. 青蛙允许从左岸A直接跳到河心的石墩、荷叶和右岸的石墩D上，允许从河心的石墩和荷叶跳到右岸的石墩D上；
  4. 青蛙在河心的石墩之间、荷叶之间以及石墩和荷叶之间可以来回跳动；
  5. 青蛙在离开左岸石墩后，不能再返回左岸；到达右岸后，不能再跳回；
  6. 假定石墩承重能力很大，允许无论多少只青蛙都可呆在上面。但是，由于石墩的面积不大，至多只能有一只青蛙直接站在上面，而其他的青蛙只能依规则1落在比它大一号的青蛙的背上。
  7. 荷叶不仅面积不大，而且负重能力也有限，至多只能有一只青蛙站在上面。
  8. 每一步只能移动一只青蛙，并且移动后需要满足站队规则；
  9. 在一开始的时候，青蛙均站在A上，最大的一只青蛙直接站在石墩上，而其它的青蛙依规则6站在比其大一号的青蛙的背上。

青蛙希望最终能够全部移动到D上，并完成站队。

设河心有m片荷叶和n个石墩，请求出这队青蛙至多有多少只，在满足站队和移动规则的前提下，能从A过到D。

例如，在m=1且 n=1时，河心有一片荷叶（Y1）和一个石墩（S1），此时至多有4只青蛙能够过河（由小到大称为1、2、3、4），过河的一种方法为：

开始

1

2

3

4

A S1 Y1 D

Step 1

1 from A to Y1

2

3

4 1

A S1 Y1 D

Step 2

2 from A to S1

3

4 2 1

A S1 Y1 D

Step 3

1 from Y1 to S1

3 1

4 2

A S1 Y1 D

Step 4

3 from A to Y1

1

4 2 3

A S1 Y1 D

Step 5

4 from A to D

1

2 3 4

A S1 Y1 D

Step 6

3 from Y1 to D

1 3

2 4

A S1 Y1 D

Step 7

1 from S1 to Y1

3

2 1 4

A S1 Y1 D

Step 8

2 from S1 to D

2

3

1 4

A S1 Y1 D

Step 9

1 from Y1 to D

1

2

3

4

A S1 Y1 D

此例中，当河心有一片荷叶和一个石墩时，4只青蛙能够跳动9步过河。

[输入文件]

文件仅有两行，每一行仅包含一个整数和一个换行/回车符。第一行的数字为河心的石墩数n（0<=n<=25），第二行为荷叶数m（0<=m<=25）。

[输出文件]

文件中仅包含一个数字和一个换行/回车符。该数字为在河心有n个石墩和m片荷叶时，最多能够过河的青蛙的只数。

[输入输出文件样例]

Input

1
1

Output

4

程序分析器

Tiny Basm语言(简称为TB语言)的巴科斯-瑙尔范式(BNF)为：

  • <程序> ::= <语句> [CrLf] { <语句> [CrLf] }
  • <语句> ::= <行号> [Space] <语句体>
  • <语句体> ::= <累加语句> | <输出语句> | <转移语句> | <条件语句> | <结束语句>
  • <累加语句> ::= <变量> + <整数>
  • <输出语句> ::= <变量> ?
  • <转移语句> ::= GO [Space] <行号>
  • <条件语句> ::= IF [Space] <变量> = <整数> [Space] <转移语句>
  • <结束语句> ::= END
  • <变量> ::= <字母>
  • <行号> ::= <整数>
  • <整数> ::= <数字> { <数字> }
  • <字母> ::= A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z
  • <数字> ::= 0|1|2|3|4|5|6|7|8|9

注：其中“::=”表示定义为，“|”表示或，{}内的项可以重复任意多次或不出现，“[Space]”表示空格(一个字符，ASCII码为32)，“[CrLf]”表示回车/换行(两个字符，ASCII码分别为13和10)。

错误语句示例(在输入文件中不会出现任何错误语句)： 10[Space]A+1.5 （不符合累加语句的定义，所加的不是整数） 20[Space]A[Space]? （不符合输出语句的定义，多加了一个空格） 30[Space]IF[Space]A=B[Space]GO[Space]10 （不符合条件语句的定义，不应变量=变量）

TB程序的执行：

  • 程序从行号最小的一条语句开始执行，在未遇到条件语句时按行号由小至大顺序执行。
  • 所有变量在程序执行前被自动初始化为0。
  • 累加语句将语句中变量的值加上语句中的整数送回该变量。
  • 输出语句将语句中变量的值在监视器上显示出来。
  • 执行条件语句时，当且仅当该语句中的变量与紧跟在等号后面的整数值相等，后面的转移语句才被执行。该语句中的所有整数值至多为4位。
  • 转移语句被执行后，程序将转去执行GO后面指定的行号的语句。
  • 当程序执行结束语句后，结束整个程序的执行。
  • 假设该系统能处理任意大小的整数，而不会发生溢出。

请编程，对于给定的TB语言程序P，求该程序所执行的语句数(执行条件语句不论是否成功转移，仅记为执行一条语句)。

[输入文件]

  • 输入文件为一个TB语言程序P，语句数不超过100行。
  • P中每条语句的长度不超过20个字符。
  • P中转移语句里GO后面的行号一定有对应的语句。
  • P中可能有多个不同行号的结束语句。
  • P中行号最大的语句一定是结束语句。
  • P中的行号都不大于3000。
  • 输入文件不一定是按行号递增顺序给出P的。

[输出文件]

  • 输出文件有且仅有一行：
  • 如果程序能够正常结束，输出该程序所执行的语句数；
  • 如果程序不能正常结束，输出-1。

[输入输出文件样例] Input

10 A+1
20 IF A=5 GO 60
60 END
30 A+2
40 A?
50 GO 20

Output

11

[样例说明] 执行语句行号按顺序为 10->20->30->40->50->20->30->40->50->20->60 共11条语句被执行。

古城之谜

著名的考古学家石教授在云梦高原上发现了一处古代城市遗址。让教授欣喜的是在这个他称为冰峰城(Ice-Peak City)的城市中有12块巨大石碑，上面刻着用某种文字书写的资料，他称这种文字为冰峰文。然而当教授试图再次找到冰峰城时，却屡屡无功而返。

幸好当时教授把石碑上的文字都拍摄了下来，为了解开冰峰城的秘密，教授和他的助手牛博士开始研究冰峰文，发现冰峰文只有陈述句这一种句型和名词(n)、动词(v)、辅词(a)这三类单词，且其文法很简单：

  • <文章> ::= <句子> { <句子> }
  • <句子> ::= <陈述句>
  • <陈述句> ::= <名词短语> { <动词短语> <名词短语> } [ <动词短语> ]
  • <名词短语> ::= <名词> | [ <辅词> ] <名词短语>
  • <动词短语> ::= <动词> | [ <辅词> ] <动词短语>
  • <单词> ::= <名词> | <动词> | <辅词>

注：其中<名词>、<动词>和<辅词>由词典给出，“::=”表示定义为，“|”表示或，{}内的项可以重复任意多次或不出现，[]内的项可以出现一次或不出现。

在研究了大量资料后，他们总结了一部冰峰文词典，由于冰峰文恰好有26个字母，为了研究方便，用字母a到z表示它们。

冰峰文在句子和句子之间以及单词和单词之间没有任何分隔符，因此划分单词和句子令石教授和牛博士感到非常麻烦，于是他们想到了使用计算机来 帮助解决这个问题。假设你接受了这份工作，你的第一个任务是写一个程序，将一篇冰峰文文章划分为最少的句子，在这个前提下，将文章划分为最少的单词。

[输入文件]

  • 输入文件第1行为词典中的单词数n（n<=1000）。
  • 输入文件第2行至第(n+1)行每行表示一个单词，形为“α.mot”， α表示词性，可能是n(名词),v（动词）,a（辅词）中的一个，mot为单词，单词的长度不超过20。拼写相同而词性不同的单词视为不同的单词，如输入 示例中的n.kick与v.kick是两个不同的单词。
  • 输入文件第(n+2)行为需要划分的文章，以“.”结束。
  • 输入文件中的文章确保为冰峰文。文章是由有限个句子组成的，每个句子只包含有限个单词。文章长度不超过5KB。

[输出文件]

  • 输出文件为两行，每行一个整数。
  • 输出文件第1行为划分出来的句子数。
  • 输出文件第2行为划分出来的单词数。

[输入输出文件样例]

Input

11
n.table
n.baleine
a.silly
n.snoopy
n.sillysnoopy
v.is
v.isnot
n.kick
v.kick
a.big
v.cry
sillysnoopyisnotbigtablebaleinekicksnoopysillycry.

Output

2
9

[样例说明]

（为了阅读方便，划分的单词用空格分隔，在单词右标出它的词性，每行写一个句子，用句号表示句子结束。）

输出对应的划分：

sillysnoopy[n] isnot[v] big[a] table[n].
baleine[n] kick[v] snoopy[n] silly[a] cry[v].

如果用下面的划分：

silly[a] snoopy[n] isnot[v] big[a] table[n].
baleine[n] kick[v] snoopy[n] silly[a] cry[v].

则划分的句子数仍为2个，但单词数却多了1个，为10个，显然应该按前者而不是后者划分。

算符破译

考古学发现，几千年前古梅文明时期的数学非常的发达，他们懂得多位数的加法和乘法，其表达式和运算规则等都与现在通常所用的方式完全相同（如整数是 十进制，左边是高位，最高位不能为零；表达式为中缀运算，先乘后加等），唯一的区别是其符号的写法与现在不同。有充分的证据表明，古梅文明的数学文字一共 有13个符号，与 0,1,2,3,4,5,6,7,8,9,+,*,= 这13个数字和符号（称为现代算符）一一对应。为了便于标记，我们用13个小写英文字母a,b,…m代替这些符号（称为古梅算符）。但是，还没有人知道这 些古梅算符和现代算符之间的具体对应关系。 在一个石壁上，考古学家发现了一组用古梅算符表示的等式，根据推断，每行有且仅有一个等号，等号左右两边为运算表达式（只含有数字和符号），并且等号两边 的计算结果相等。

假设这组等式是成立的，请编程序破译古梅算符和现代算符之间的对应关系。

[输入文件]

  • 输入文件的第一行为等式的个数N（1<=N<=1000），以下N行每行为一个等式。
  • 每个等式的长度为5个字符到11个字符。

[输出文件]

  • 如果不存在对应关系能够满足这组等式，输出“noway”和一个换行/回车符。
  • 如果有对应关系能够满足这组等式，输出所有能够确定的古梅算符和现代算符的对应关系。每一行有两个字符，其中第一个字符是古梅算符，第二个字符是对应的现代算符。输出按照字典顺序排序。

[输入输出文件样例]

Input

2
abcdec
cdefe

Output

a6
b*
d=
f+

[样例说明]

在上例中，可能对应的现代表达式为{6*2=12，2=1+1}，{6*4=24，4=2+2}，{6*8=48，8=4+4}。可见，能 够确定的对应关系只有a对应6，b对应*，d对应=，f对应+，应该输出；而{c,e}虽然能够找到对应的现代算符使得等式成立，但没有唯一的对应关系， 不能输出。其他古梅算符{g,h…m}完全不能确定，也不能输出。

Maybe you like

]]> http://www.byvoid.com/blog/noi-2000-solution/feed/ 3 NOI 1997 解题报告 http://www.byvoid.com/blog/noi-1997-solution/ http://www.byvoid.com/blog/noi-1997-solution/#comments Sun, 15 Feb 2009 13:33:58 +0000 BYVoid http://www.byvoid.com/blog/?p=866 我的计划就从NOI1997开始。NOI1997一共有6道题，分别是[卫星覆盖][积木游戏][竞赛排名][最佳游览][最优乘车][文件匹配]。这一年的6个题难易分布均衡，做完后收获不小。

其中[竞赛排名]和[最佳游览]是两个最简单的题，但是往往细节是容易忽视的。[积木游戏]和[最优乘车]难度属于中等，分别是动态规划和构造最短路径解题。[卫星覆盖]和[文件匹配]属于较难题，用到了[卫星覆盖]离散化或者立体切割的方法，而[文件匹配]是搜索中的难题，需要很多的优化。

做这些题我花了4天的时间，进度还算正常，希望能继续保持下去。今后做题的宗旨是“不求多，不求快，但求精”。

[最佳游览]

这是一道非常简单的题，读懂题后，发现方法就是统计出每一列的最大值，存为一个数列A。求A的连续最大子序列即可。

?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

/* 
 * Problem: NOI1997 perfecttour
 * Author: Guo Jiabao
 * Time: 2009.2.14 14:01
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
const int MAXN=20001;
int M,N,i,j,t,T,Ans;
int A[MAXN];
 
int main()
{
	freopen("perfecttour.in","r",stdin);
	freopen("perfecttour.out","w",stdout);
	scanf("%d%d",&M,&N);
	N--;
	for (j=1;j<=N;j++)
		A[j]=-0x7FFFFFFF;
	for (i=1;i<=M;i++)
		for (j=1;j<=N;j++)
		{
			scanf("%d",&t);
			if (t>A[j])
				A[j]=t;
		}
	for (i=1,T=0;i<=N;i++)
	{
		T+=A[i];
		if (T<0)
			T=0;
		if (T>Ans)
			Ans=T;
	}
	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

/* 
 * Problem: NOI1997 competitionsort
 * Author: Guo Jiabao
 * Time: 2009.2.13 14:09
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
const int MAXN=1001;
int sum[MAXN],S[MAXN][9];
double avg[9],pos[MAXN],y[MAXN][9];
struct inf{int id,sum;double pos;} P[MAXN];
int N;
void init()
{
	freopen("competitionsort.in","r",stdin);
	freopen("competitionsort.out","w",stdout);
	scanf("%d",&N);
	for (int i=1;i<=N;i++)
		for (int j=1;j<=8;j++)
			scanf("%d",&S[i][j]);
}
 
inline double ABS(double A)
{
	return A<0?-A:A;
}
 
inline int cmp(const void *a,const void *b)
{
	if (((inf *)a)->pos > ((inf *)b)->pos) return -1;
	if (((inf *)a)->pos < ((inf *)b)->pos) return 1;
	if (((inf *)a)->sum > ((inf *)b)->sum) return -1;
	if (((inf *)a)->sum < ((inf *)b)->sum) return 1;
	if (((inf *)a)->id < ((inf *)b)->id) return -1;
	return 1;
}
 
void statistics()
{
	int i,j;
	double m[8];
	for (j=1;j<=8;j++)
	{
		for (i=1;i<=N;i++)
		{
			avg[j]+=S[i][j];
			sum[i]+=S[i][j];
		}
		avg[j]/=N;
	}
	for (j=1;j<=8;j++)
	{
		m[j]=0;
		for (i=1;i<=N;i++)
			m[j]+=ABS(S[i][j]-avg[j]);
		m[j]/=N;
	}
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=8;j++)
		{
			if (m[j]==0)
				y[i][j]=0;
			else
				y[i][j]=(S[i][j]-avg[j])/m[j];
		}
		for (j=1;j<=3;j++)
			pos[i]+=y[i][j];
		for (j=4;j<=8;j++)
			pos[i]+=y[i][j]*0.8;
		P[i].pos=pos[i];
		P[i].sum=sum[i];
		P[i].id=i;
	}
	qsort(P+1,N,sizeof(P[0]),cmp);
	for (i=1;i<=N;i++)
		printf("%dn",P[i].id);
}
 
int main()
{
	init();
	statistics();
	return 0;
}

[积木游戏]

由于把积木分成M堆，每堆中积木的编号都是严格划分的，可以看作把积木按编号顺序划分为M份。可以动态规划，状态转移时只需考虑第i个放置相邻两对的决策。

设定F[i,j,k]表示放置第i个积木时，把它放在第j堆，用第k种方式放置的总最大高度。

第k种放置方式(0<=k<=2)，分别表示了用积木的哪一面作为底。

状态转移方程

  • F[i,j,k]=Max{ F[a,j,b]|(i,k)能放置在(a,b)上 ,F[a,j-1,b] (0<=a<=i-1,0<=b<=2) } + height(i,k)
  • height(i,k)为第i个积木以方式k放置的高。

初始条件为

  • F[i,j,k]=负无穷大;(0<=i<=N,0<=j<=M,0<=k<=2)
  • F[0,0,0]=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

/* 
 * Problem: NOI1997 buildinggame
 * Author: Guo Jiabao
 * Time: 2009.2.12 13:53
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAX=101,INF=0x7FFFFFFF;
struct block{int a,b,c;}B[MAX];
int F[MAX][MAX][3];
int N,M,Ans;
void init()
{
	int i,j,k;
	freopen("buildinggame.in","r",stdin);
	freopen("buildinggame.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
		scanf("%d%d%d",&B[i].a,&B[i].b,&B[i].c);
	for (i=0;i<=N;i++)
		for (j=0;j<=M;j++)
			for (k=0;k<3;k++)
				F[i][j][k]=-INF;
	F[0][0][0]=0;
}
 
inline block roll(block A,int k)
{
	int t;
	if (k==1){t=A.b;A.b=A.c;A.c=t;}
	if (k==2){t=A.a;A.a=A.b;A.b=A.c;A.c=t;}
	return A;
}
 
inline bool available(block A,int k1,block B,int k2)
{
	A=roll(A,k1);B=roll(B,k2);
	return (B.a>=A.a && B.b>=A.b) || (B.a>=A.b && B.b>=A.a);
}
 
void dynamic()
{
	int i,j,k,a,b;
	block T;
	for (i=1;i<=N;i++)
		for (j=1;j<=M;j++)
			for (k=0;k<3;k++)
			{
				for (a=0;a<i;a++)
					for (b=0;b<3;b++)
					{
						if (available(B[i],k,B[a],b) && F[a][j][b] > F[i][j][k])
							F[i][j][k] = F[a][j][b];
						if ( F[a][j-1][b] > F[i][j][k] )
							F[i][j][k] = F[a][j-1][b];
					}
				if ((F[i][j][k] += (T=roll(B[i],k)).c) >Ans)
					Ans=F[i][j][k];
			}
}
 
int main()
{
	init();
	dynamic();
	printf("%dn",Ans);
	return 0;
}

[最优乘车]

可以构造最短路径求解。对于不同线路上的相同编号的车站，应该看作不同的顶点，而且这两个点之间互相连接一条边权为1的有向边。同一条线路上的所有 车站，按照顺序连接边权为0的有向边。为了方便，我们增设一个超级源S和超级汇T。S向所有代表车站1的顶点连接一条边权为0的有向边，所有代表车站N的 顶点向T连接一条边权为0的有向边。

图构造好以后，只需求从S到T的最短路径即可。建议用SPFA，在这种特殊的01图上，SPFA会比Dijkstra(堆)快得多。

?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: NOI1997 bustravel
 * Author: Guo Jiabao
 * Time: 2009.2.14 19:10
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXM=101,MAXN=501,INF=0x7FFFFFF;
struct edge{edge *next;int t,v;};
struct adjl{edge *f,*l;};
int M,N,Total,Target,EC=-1,Queue_cnt,Queue_head,Queue_tail;
int BusLine[MAXM][MAXN]; //第i行第j个点的原始编号
int BusHash[MAXM][MAXN]; //第i行原始编号为j的点正式编号
int sp[MAXM*MAXN],Queue[MAXM*MAXN];
bool inQueue[MAXM*MAXN];
edge ES[MAXM*MAXN];
adjl Adjl[MAXM*MAXN];
void init()
{
	int i,j,k,c;
	freopen("bustravel.in","r",stdin);
	freopen("bustravel.out","w",stdout);
	scanf("%d%d",&M,&N);
	for (i=1;i<=M;i++)
	{
		do c=getchar(); while(c==10 || c==13);
		for (j=0;(c!=10 && c!=13 && c!=EOF);)
		{
			ungetc(c,stdin);
			scanf("%d",&k);
			BusLine[i][++j]=k;
			BusHash[i][k]=++Total;
			c=getchar();
		}
		BusLine[i][0]=j;
	}
	Target=++Total;
}
 
void addedge(int a,int b,int v)
{
	edge *p=&ES[++EC];
	if (Adjl[a].l)
		Adjl[a].l=Adjl[a].l->next=p;
	else
		Adjl[a].f=Adjl[a].l=p;
	p->next=0;p->t=b;p->v=v;
}
 
void makegraph()
{
	int i,j,k,p,a,b;
	for (i=1;i<=M;i++)
	{
		for (j=1;j<=BusLine[i][0]-1;j++)
		{
			a=BusHash[i][ BusLine[i][j]   ];
			b=BusHash[i][ BusLine[i][j+1] ];
			addedge(a,b,0);
			if (BusLine[i][j]==1)
				addedge(0,a,0);
			else if (BusLine[i][j]==N)
				addedge(a,Target,0);
		}
		if (BusLine[i][j]==1)
			addedge(0,b,0);
		else if (BusLine[i][j]==N)
			addedge(b,Target,0);
	}
	for (i=1;i<=M-1;i++)
	{
		for (j=1;j<=BusLine[i][0];j++)
		{
			p=BusLine[i][j];
			a=BusHash[i][p];
			for (k=i+1;k<=M;k++)
			{
				b=BusHash[k][p];
				if (b)
				{
					addedge(a,b,1);
					addedge(b,a,1);
				}
			}
		}
	}
}
 
void Queue_ins(int p)
{
	if (++Queue_head==MAXM*MAXN) Queue_head=0;
	Queue[Queue_head]=p;
	inQueue[p]=true;
	Queue_cnt++;
}
 
int Queue_pop()
{
	int p=Queue[Queue_tail];
	if (++Queue_tail==MAXM*MAXN) Queue_tail=0;
	inQueue[p]=false;
	Queue_cnt--;
	return p;
}
 
void spfa()
{
	int i,u,v;
	for (i=1;i<=Total;i++)
		sp[i]=INF;
	Queue_head=-1;Queue_tail=0;
	Queue_ins(0);
	while (Queue_cnt)
	{
		u=Queue_pop();
		for (edge *k=Adjl[u].f;k;k=k->next)
		{
			v=k->t;
			if (sp[u] + k->v < sp[v])
			{
				sp[v]=sp[u] + k->v;
				if (!inQueue[v])
					Queue_ins(v);
			}
		}
	}
}
 
int main()
{
	init();
	makegraph();
	spfa();
	if (sp[Target]==INF)
		printf("NOn");
	else
		printf("%dn",sp[Target]);
	return 0;
}

[卫星覆盖]

经典的分治问题，方法为立方体切割。和USACO中的Shaping Regions的做法相似，只不过是从二维推广到了三维。

具体方法是，对于第i个立方体，判断大于i的每个立方体是否与之有公共部分，如果有公共部分，把该长方体非公共部分切割成几个规则的长方体，然后递归处理每一个长方体。直到没有公共部分了，体积就是长*宽*高。

对于两个矩形（每条边都平行于坐标轴），我们判断它们相交，有一种简单的方法。两个矩形A和B，定义(A.x1,A.y1)为A的左下角顶 点，(A.x2,A.y2)为A的右上角顶点，同理B，只要满足 A.x1 < B.x2 且 A.y1 < B.y2 且 B.x1 < A.x2 且 B.y1 < A.y2，则A、B一定相交。

相似地，对于两个长方体A、B，只要满足

A.x1 < B.x2 && A.y1 < B.y2 && A.z1 < B.z2 && B.x1 < A.x2 && B.y1 < A.y2 && B.z1 < A.z2

则A、B相交。

上述方法的时间复杂度是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

/* 
 * Problem: NOI1997 satellitecover
 * Author: Guo Jiabao
 * Time: 2009.2.11 21:17
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN=201;
struct cube{int x1,y1,z1,x2,y2,z2;};
int N;
cube Cubes[MAXN];
 
void init()
{
	int i,a,b,c,r;
	freopen("satellitecover.in","r",stdin);
	freopen("satellitecover.out","w",stdout);
	scanf("%d",&N);
	for (i=1;i<=N;i++)
	{
		scanf("%d%d%d%d",&a,&b,&c,&r);
		Cubes[i].x1=a-r; Cubes[i].y1=b-r; Cubes[i].z1=c-r;
		Cubes[i].x2=a+r; Cubes[i].y2=b+r; Cubes[i].z2=c+r;
	}
}
 
inline bool cross(cube A,cube B)
{
	return A.x1 < B.x2 && A.y1 < B.y2 && A.z1 < B.z2 && B.x1 < A.x2 && B.y1 < A.y2 && B.z1 < A.z2;
}
 
cube mcube(int x1,int y1,int z1,int x2,int y2,int z2)
{
	cube A;
	A.x1=x1;A.y1=y1;A.z1=z1;A.x2=x2;A.y2=y2;A.z2=z2;
	return A;
}
 
int devide(cube A,int pos)
{
	cube B;
	int volume=0;
	while (pos<=N && !cross(A,B=Cubes[pos])) pos++;
	if (pos>N)
		volume=(A.x2-A.x1)*(A.y2-A.y1)*(A.z2-A.z1);
	else
	{
		if (A.x1 < B.x1)
		{
			volume+=devide(mcube(A.x1,A.y1,A.z1,B.x1,A.y2,A.z2),pos+1);
			A.x1=B.x1;
		}
		if (A.x2 > B.x2)
		{
			volume+=devide(mcube(B.x2,A.y1,A.z1,A.x2,A.y2,A.z2),pos+1);
			A.x2=B.x2;
		}
		if (A.y1 < B.y1)
		{
			volume+=devide(mcube(A.x1,A.y1,A.z1,A.x2,B.y1,A.z2),pos+1);
			A.y1=B.y1;
		}
		if (A.y2 > B.y2)
		{
			volume+=devide(mcube(A.x1,B.y2,A.z1,A.x2,A.y2,A.z2),pos+1);
			A.y2=B.y2;
		}
		if (A.z1 < B.z1)
			volume+=devide(mcube(A.x1,A.y1,A.z1,A.x2,A.y2,B.z1),pos+1);
		if (A.z2 > B.z2)
			volume+=devide(mcube(A.x1,A.y1,B.z2,A.x2,A.y2,A.z2),pos+1);
	}
	return volume;
}
 
int main()
{
	int i,totalvolume=0;
	init();
	for (i=N;i>-1;i--)
		totalvolume+=devide(Cubes[i],i+1);
	printf("%dn",totalvolume);
	return 0;
}

[文件匹配]

这是NOI1997中最难的一道题，我在这道题上花费了一天时间才通过了。基本框架就是搜索，搜索出匹配串，对所有文件名按照规则匹配，判断是否可行，算出匹配的数目，更新最优值。

暴力的搜索连样例都过不了，我们需要深入分析，进行优化和剪枝。我的搜索顺序是从匹配串的第一位到最后一位(所有文件名长度最大值)。我们定义正文件为标记’+'的文件，负文件为标记’-'的文件。

优化1.记录下所有用过的字符，顺序存入线性表，以备搜索时使用。

优化2.去除多余的状态，例如多个*在一起是浪费的，*?和?*是一样的(但是和*不一样)，在产生状态时应避免出现。

优化3.关于判断文件名是否匹配，在搜索出一位时，不需要把整个串与文件名匹配，如果前面都是匹配的，只需判断最后一位是否 成立，我们需要记录每个文件名已经前缀匹配到了哪一位。但是由于*的存在，使这个判断复杂性大大增加。例如当前的匹配串A*A对A1A2A前缀匹 配，A*A可以匹配到第3位(A1A)，也可以匹配到第5位(A1A2A)。而且由于后面扩展出的状态未知，我们也无法知道究竟匹配到哪一位是合适的，所 以必须都记录下。即对每个文件名开辟一个数组空间，存储该文件名可能匹配到的所有位置。在状态的扩展中，也需要对所有的可能分别扩展。在最终判断时，一个 文件名只要有一种可能使得完全匹配，就算是匹配成功。

优化4.在搜索完匹配串的每一位，计算完全匹配的数目时，需要判断是否还有必要搜索下一位。对于以下三种情况，

  1. 如果所有的正文件全部不能严格匹配，则再搜索下一位已经没有意义，剪枝；
  2. 如果前缀匹配的正文件的个数小于已有答案，再搜索下一位答案一定不会增加，剪枝；
  3. 如果匹配串末字符是*，当前答案小于最优答案，继续搜索一定是不会使答案增加，剪枝。

优化5.在搜索前先对所有的文件排序，使负文件名排在前面，有利于剪枝的提前发生。

上述5个优化，其中优化3是核心，也是算法的重要内容，大量编程的工作都是优化3；而优化4是关键，优化4的三个强力剪枝可以去除许多无用的状态，大大减少运行时间。

这道题虽然写了一天才搞定，收获却是非同一般得大。我个人认为这类题很好，很能考验构造思维能力和编程能力，甚至意志力，但近些年不论在 NOI还是NOIP，却都销声匿迹了。我预测如果今年NOI考这类题，仍然是个难题，能拿到高分的人不会多的。搜索+优化永远是一个万能算法，即使不为了 竞赛，真正掌握它也是很困难，确是很重要的。

?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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

/* 
 * Problem: NOI1997 wildcard
 * Author: Guo Jiabao
 * Time: 2009.2.15 20:17
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN=251,MAXS=62;
const char CharSet[]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
struct File{int name[10],len,matchpre[10],precnt;bool permission;};
int N,N_p,pattern[10],Apt[10],Max_Length,Ans,Nowlen,Al,ccnt;
File F[MAXN];
bool used[200];
int chas[62];
void dfs(int len);
inline int CharToID(char c)
{
	if (c>='0' && c<='9')return c-'0';
	return (c>='A' && c<='Z')?c-'A'+10:c-'a'+36;
}
inline int cmp(const void *a,const void *b)
{return ((File *)a)->permission==false?-1:1;}
void init()
{
	int i,k;
	char c,Name[10];
	freopen("wildcard.in","r",stdin);
	freopen("wildcard.out","w",stdout);
	c=getchar();
	while (c!=EOF)
	{
		ungetc(c,stdin);
		scanf("%s",Name);
		N++;
		for (i=0;Name[i];i++)
		{
			F[N].name[i+1]=k=CharToID(Name[i]);
			used[k]=true;
		}
		F[N].len=i;
		if (i>Max_Length)
			Max_Length=i;
		c=getchar();c=getchar();
		if (c=='+')
		{
			N_p++;
			F[N].permission=true;
		}
		else
			F[N].permission=false;
		F[N].precnt=1;
		c=getchar();c=getchar();
	}
	qsort(F+1,N,sizeof(F[0]),cmp);
	for (i=0;i<MAXS;i++)
		if (used[i])
			chas[++ccnt]=i;
}
bool update(int k)
{
	int i,j,Newans=0,Pans=0;
	bool np=false,tb;
	for (i=1;i<=N;i++)
	{
		tb=false;
		for (j=1;j<=F[i].precnt;j++)
			tb|=F[i].matchpre[j]==F[i].len || ( F[i].matchpre[j]>=0 && pattern[k]==-1 );
		if (tb)
		{
			if (F[i].permission )
				Newans++;
			else
				np=true; //匹配了负串
		}
		if (F[i].permission && F[i].precnt==0)
			Pans++; //记录正串不匹配的个数
	}
	if (Pans==N_p || (N_p-Pans<Ans)) //若正串全部不匹配 或者 前缀匹配串的个数小于已有答案 剪枝
		return false;
	if (pattern[k]==-1 && Newans<Ans) //如果匹配串末字符是*，当前答案小于最优，继续添加一定是多余的  剪枝
		return false;
	if (!np)
	{
		if (Newans>Ans)
		{
			Ans=Newans;
			for(i=1;i<=k;i++)
				Apt[i]=pattern[i];
			Al=k;
		}
		else if (Newans==Ans && k<Al)
		{
			for(i=1;i<=k;i++)
				Apt[i]=pattern[i];
			Al=k;
		}
	}
	return true;
}
 
void match(File &F,int len)
{
	bool newpre[10]={false};
	int k,i;
	if (pattern[len-1]!=-1)
	{
		for (k=1;k<=F.precnt;k++)
			if (F.matchpre[k]+1<=F.len && (pattern[len]==-2 || F.name[F.matchpre[k]+1]==pattern[len]))
				newpre[F.matchpre[k]+1]=true;
	}
	else
	{
		for (k=1;k<=F.precnt;k++)
			for (i=F.matchpre[k]+1;i<=F.len;i++)
				if (F.name[i]==pattern[len] || pattern[len]==-2)
					newpre[i]=true;
	}
	F.precnt=0;
	for (k=1;k<9;k++)
		if (newpre[k])
			F.matchpre[ ++F.precnt ]=k;
}
 
void goon(int len,int p)
{
	if (p==N+1)
	{
		if (update(len))
			dfs(len+1);
		return;
	}
	int i,tprecnt,tmatch[10];
	if (F[p].precnt==0)
		goon(len,p+1);
	else
	{
		/*backup*/
		for (i=1;i<=F[p].precnt;i++)
			tmatch[i]=F[p].matchpre[i];
		tprecnt=F[p].precnt;
		/*backup*/
		if (pattern[len-1]==-1)
		{
			match(F[p],len);
			goon(len,p+1);
		}
		else
		{
			if (pattern[len]!=-1)
				match(F[p],len);
			goon(len,p+1);
		}
		/*restore*/
		F[p].precnt=tprecnt;
		for (i=1;i<=F[p].precnt;i++)
			F[p].matchpre[i]=tmatch[i];
		/*restore*/
	}
}
 
void dfs(int len) //-1:* -2:?
{
	if (len>Max_Length)
		return;
	int i;
	if (pattern[len-1]!=-1)//**不连用 但允许?*
	{
		pattern[len]=-1;
		goon(len,1);
	}
	if (pattern[len-1]!=-1)//不允许*?
	{
		pattern[len]=-2;
		goon(len,1);
	}
	for (i=1;i<=ccnt;i++)
	{
		pattern[len]=chas[i];
		goon(len,1);
	}
}
 
void print()
{
	printf("%dn",Ans);
	for (int i=1;i<=Al;i++)
		if (Apt[i]>=0)
			putchar(CharSet[Apt[i]]);
		else if (Apt[i]==-1)
			putchar('*');
		else
			putchar('?');
	putchar('n');
}
 
int main()
{
	init();
	dfs(1);
	print();
	return 0;
}

顺便还说下，这道题SpecialJudge很有意思，由于可能没有唯一解，需要自己编写一个评测插件来判断解的正确性。在给 CmYkRgB123 Online Judge System编写评测插件时，我想到了用正则表达式的方法来判断，因为php中就有preg_match函数，但是这道题中的匹配串并不是真正的正则表达 式。可算让我想了一大会，才想到转化的方法。例如题中E*，转化为正则表达式就是/^E[a-zA-Z0-9]{0,8}$/，^表示必须从开头匹 配，$表示匹配到结尾[a-zA-Z0-9]{0,8}代表*，*只能匹配字母和数字，而且长度在[0,8]之间，很显然?就是[a-zA-Z0-9] {1}了。于是我写出了转化函数

?View Code PHP
function getz($Ab)
{
	$str='/^';
	$Ab=str_replace('*','[a-zA-Z0-9]{0,8}',$Ab);
	$Ab=str_replace('?','[a-zA-Z0-9]{1}',$Ab);
	$str.=$Ab.'$/';
	return $str;
}

判断函数就是

?View Code PHP
function plugin_compare($fin,$fout,$fans)
{
	$score=0;
	fscanf($fout,"%s",$As);
	fscanf($fout,"%s",$Ab);
	fscanf($fans,"%s",$Bs);
	fscanf($fans,"%s",$Bb);
	if ($As==$Bs)
	{
		$score=0.5;
		if (strlen($Ab)==strlen($Bb))
		{
			$zab=getz($Ab);
			$score=0.6;
			$pcnt=0;$wrong=false;
			while (!feof($fin))
			{
				fscanf($fin,"%s %sn",$subject,$method);
				$r=preg_match($zab,$subject);
				if ($r && $method=='+')
					$pcnt++;
				if ($r && $method=='-')
					$wrong=true;
			}
			if ($As==$pcnt && !$wrong)
				$score=1;
		}
	}
	return $score;
}

附上原题

最佳游览

有一座旅游城，它的街道成网格状．其中东西向的街道是“风景线、两旁分布着许多景观：南北向的街道都是林荫道，两旁没有任何建筑物。由于游客众多，风最线被规定为单行道，游客在风景线上只能从西走到东，林荫道上则可以任意行走。

一名游客将到这座旅游城旅游。他根据自己对景观的喜好给所有的风景线打了分，分值是从-100到+100的整数，分值越大表示我们的旅游者越喜欢这条风最线上的景致。显然这位游客不可能给这座旅游城的所有风景线都打负分。

-50	–47	–36	–30	–23
17	–19	34	–13	–8
-42	–3	43	34	-45

游客可以从旅游城的任一个十字路口开始游览，在任一个十字路口结束游览。我们的旅游者希望一路上游览的所有风最线的分值之和能够尽可能地大。请你写一个程序，帮助这位游客寻找一条最佳的游览路线。

输入输出

输入文件是INPUT.TXT。文件的第一行是两个整数M和N，之间用一个空格符隔开，M表示旅游城南北向林荫道的段数，N表示东西向风景 线的段数，1<=M<=100，1<=N<=20000。接下来的M行依次给出了由北向南各条风景线的分值信息。每行有N个整 数，依次表示了自西向东每段风景线的分值。同一行相邻两个数之间用一个空格隔开。

输出文件是OUTPUT.TXT。文件只有一行，含一个整数，表示你的程序所找到的最佳游览路线的总分值。

样例

INPUT.TXT

3 6
50 -47 -36 -30 -23
17 -19 34 -13 -8
-42 -3 43 34 -45

OUTPUT.TXT

124

竞赛排名

某市组织了一次中学生科技全能竞赛，每个选手要参加数学、物理、化学、天文、地理、生物、计算机和英语共八项竞赛,最后综合八项竞赛的成绩排出总名次。选手编号依次为：1,2…N（N为参赛总人数）。

设Image:Competitionsort 1.gif分别表示编号为i的选手第j项竞赛的成绩Image:Competitionsort 2.gif。其它指标如下：

  • 第j项竞赛的平均分 Image:Competitionsort 3.gif
  • 选手i的总分 Image:Competitionsort 4.gif
  • 选手i第j项竞赛的位置分 Image:Competitionsort 5.gif
  • 选手i的总位置分 Image:Competitionsort 6.gif

排名规则如下:

  1. 总位置分高的选手名次在前：
  2. 若两个或两个以上的选手总位置分相同，则总分高的选手名次在前：
  3. 若两个或两个以上的选手总位置分和总分均相同，则编号在前的选手名次在前。

请你为竞赛组委会编一程序，计算本次全能竞赛的总排名情况。

输入输出

输入文件为INPUT.TXT。文件的第一行为参赛总人数NImage:Competitionsort 7.gif，从第二行到第N行依次为编号为1到编号为N的选手的成绩，每行有8个0～100之间的整数，代表该选手的8项竞赛成绩Image:Competitionsort 8.gif。同一行相邻两个数之间用一个空格符隔开。

输出文件为OUTPUT.TXT. 文件有N行，从第1行到第N行依次为排名第1的选手的编号，排名第2的选手的编号，…，排名第N的选手的编号。

样例

INPUT.TXT

3
72 82 73 68 95 86 82 90
72 90 50 60 80 70 65 80
72 82 73 68 95 86 82 90

OUTPUT.TXT

1
3
2

积木游戏

SERCOI 最近设计了一种积木游戏。每个游戏者有N块编号依次为1 ，2，…，N的长方体积木。对于每块积木,它的三条不同的边分别称为”a边”、“b边”和”c边”，如下图所示：

Image:Buildinggame.PNG

游戏规则如下：

1.从N块积木中选出若干块，并将它们分成M（l<=M<=N） 堆，称为第1堆，第2 堆…，第M堆。每堆至少有1块积木，并且第K堆中任意一块积木的编号要大于第K+1堆中任意一块积木的编号(2<=K<=M)。

2.对于每一堆积木,游戏者要将它们垂直摞成一根柱子,并要求满足下面两个条件：

(1)除最顶上的一块积木外，任意一块积木的上表面同且仅同另一块积木的下表面接触，并且要求下面的积木的上表面能包含上面的积木的下表面，也就是说，要求下面的积木的上表面的两对边的长度分别大于等于上面的积木的两对边的长度。

(2)对于任意两块上下表面相接触的积木，下面的积木的编号要小于上面的积木的编号。

最后，根据每人所摞成的M根柱子的高度之和来决出胜负。

请你编一程序，寻找一种摞积木的方案，使得你所摞成的M根柱子的高度之和最大。

输入输出

输入文件是INPUT.TXT。文件的第一行有两个正整数N和M（1<=M<=N<=100），分别表示积木总数和要求 摞成的柱子数。这两个数之间用一个空格符隔开。接下来N行依次是编号从1到N的N个积木的尺寸，每行有三个1至1000之间的整数，分别表示该积木a 边,b边和c边的长度。同一行相邻两个数之间用一个空格符隔开。

输出文件是OUTPUT.TXT。文件只有一行，为一个整数，表示M根柱子的高度之和。

样例

INPUT.TXT

4 2
10 5 5
8 7 7
2 2 2
6 6 6

OUTPUT.TXT

24

最优乘车

H城是一个旅游胜地，每年都有成千上万的人前来观光。为方便游客，巴士公司在各个旅游景点及宾馆，饭店等地都设置了巴士站并开通了一些单程巴上线路。每条单程巴士线路从某个巴士站出发，依次途经若干个巴士站，最终到达终点巴士站。

一名旅客最近到H城旅游，他很想去S公园游玩，但如果从他所在的饭店没有一路巴士可以直接到达S公园，则他可能要先乘某一路巴士坐几站，再下来换乘同一站台的另一路巴士, 这样换乘几次后到达S公园。

现在用整数1,2,…N 给H城的所有的巴士站编号，约定这名旅客所在饭店的巴士站编号为1,S公园巴士站的编号为N。

写一个程序，帮助这名旅客寻找一个最优乘车方案,使他在从饭店乘车到S公园的过程 中换车的次数最少。

输入输出

输入文件是INPUT.TXT。文件的第一行有两个数字M和N(1<=M<=100 1<N<=500），表示开通了M条单程巴士线路，总共有N个车站。从第二行到第M+1行依次给出了第1条到第M条巴士线路的信息。其中第 i+1行给出的是第i条巴士线路的信息，从左至右按运行顺序依次给出了该线路上的所有站号相邻两个站号之间用一个空格隔开。

输出文件是OUTPUT.TXT，文件只有一行。如果无法乘巴士从饭店到达S公园，则输出”N0″，否则输出你的程序所找到的最少换车次数，换车次数为0表示不需换车即可到达

样例

INPUT.TXT

3 7
6 7
4 7 3 6
2 1 3 5

OUTPUT.TXT

2

卫星覆盖

Cover

SERCOI（Space-Earth Resource Cover-Observe lnstitute）是一个致力于利用卫星技术对空间和地球资源进行覆盖观测的组织。现在他们研制成功一种新型资源观测卫星-SERCOI-308。这种 卫星可以覆盖空间直角坐标系中一定大小的立方体空间，卫星处于该立方体的中心。

其中（x,y,z）为立方体的中心点坐标，r为此中心点到立方体各个面的距离（即r为立方体高的一半）．立方体的各条边均平行于相应的坐标轴。我们可以用一个四元组(x,y,z,r)描述一颗卫星的状态，它所能覆盖的空间体积 。 由于一颗卫星所能覆盖的空间体积是有限的，因此空间中可能有若干颗卫星协同工作。它们所覆盖的空间区域可能有重叠的地方，如下图所示（阴影部分表示重叠的区域）。

Image:Satellitecover.png

写一个程序，根据给定的卫星分布情况，计算它们所覆盖的总体积。

输入输出

输入文件是INPU.TXT。文件的第一行是一个正整数N（1<=N<=100）：表示空间中的卫星总数。接下来的N行每行给 出了一颗卫星的状态，用空格隔开的四个正整数x,y,z,r依次表示了该卫星所能覆盖的立方体空间的中心点坐标和半高，其中 -1000<=x,y,z<=1000, 1<=r<=200。

输出文件是OUTPUT.TXT。文件只有一行,包括一个正整数，表示所有这些卫星所覆盖的空间总体积。

样例

INPUT.TXT

3
0 0 0 3
1 -1 0 1
19 3 5 6

OUTPUT.TXT

1944

文件匹配

在计算机的日常操作中，经常需要对当前回录下的所有文件中的一部分文件进行操作。例如，将当前目录下的所有文本文件复制至另一个目录下：将当前目录下所有以a 打头的文件删除; 等等。

很多操作系统都采用正则表达式来实现文件匹配功能。一种简单的正则表达式由英文字母（区分大小写）。数字及通配符”*”和”?”组成，”?”代表任意一个字符，”*””则可以代表零个或任意多个字符。

例如：

  • a*b可以匹配acb(*代表c)
    • 可以匹配aabb (*代表ab）
    • 可以匹配asdsfdfdb (*代表sdsfdfd)
    • 可以匹配ab (*不代表任何字符)
  • a*b不可以匹配ac（缺少最右边的字母b)
    • 不可以匹配bb（缺少最左边的字母a )
    • 不可以匹配 abbc（最右边的字母不是b)
  • a?b可以匹配acb（？代表c)
    • 不可以匹配ab（缺少中间的一个字符）
    • 不可以匹配accb（？只能代表一个字符）

现要对某目录下的部分文件进行操作。写一个程序,寻找一个正则表达式，使其能匹配的待操作文件最多，但不能匹配任何不进行操作的文件。注意你所找到的最优正则表达式的长度应当是最短的。如果有多个长度最短的最优正则表达式，则其中任意一个都是允许的。

输入输出

输入文件是INPUT.TXT.文件由N（1<=N<=250）行组成。每行给出了一个文件名（由英文字母和数字组成：英文字 符要区分大小写，文件名长度不超过8个字符），其后是一个空格符和一个字符（“+”或”-”）.“+”表示要对该行给出的文件进行操作，”-”表示不进行 操作。

输出文件是OUTPUT.TXT ，文件由两行组成。第一行是一个整数，给出了你的程序所找到的最优正则表达式所能匹配的文件数目．在第二行给出你的程序所找到的最优正则表达式。

样例

INPUT.TXT

EXCHANGE +
EXT +
HARDWARE +
MOUSE -
NETWORK -

OUTPUT.TXT

2
E*

Maybe you like

]]> http://www.byvoid.com/blog/noi-1997-solution/feed/ 3 POI 1999 三色二叉树 Three−coloring of binary trees http://www.byvoid.com/blog/poi-1999-tro/ http://www.byvoid.com/blog/poi-1999-tro/#comments Sun, 14 Dec 2008 10:50:54 +0000 BYVoid http://www.byvoid.com/blog/?p=664 首先是根据输入的前序遍历建树，然后树形动态规划，递归地建立二叉树。假设绿色为0，红色为1，蓝色为2。要求两遍动态规划。

以最大值为例，动态规划状态设定

  • F[i,c] 以节点i为根的子树中，根的颜色为c时，这棵子树上颜色为0的节点的个数。

状态转移方程

如果i为叶节点

  • F[i,c]=1 (c为0)
  • F[i,c]=0 (c不为0)

如果i只有一个子节点

  • F[i,0]=Max { F[i.left,1] , F[i.left,2] } + 1
  • F[i,1]=Max { F[i.left,0] , F[i.left,2] }
  • F[i,2]=Max { F[i.left,0] , F[i.left,1] }

如果i有两个子节点

  • F[i,0]=Max { F[i,left,1]+F[i.right,2] , F[i,left,2]+F[i.right,1] } + 1
  • F[i,1]=Max { F[i,left,0]+F[i.right,2] , F[i,left,2]+F[i.right,0] }
  • F[i,2]=Max { F[i,left,0]+F[i.right,1] , F[i,left,1]+F[i.right,0] }

目标状态

  • Max{ F[root,0] , F[root,1] , F[root,2] } (root为根)

以上为求最大值，求最小值方法一样，把Max全部改成Min即可。

?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

/* 
 * Problem: POI1999 trot
 * Author: Guo Jiabao
 * Time: 2008.12.14 17:09:22
 * State: Solved 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
 
const int MAX=10002;
const int INF=0x7FFFFFFF;
 
class node
{
	public:
		int c,p;
		node *l,*r;
		node() : l(0),r(0){}
};
 
char S[MAX];
node E[MAX],*root;
int L,N,Q,Ans1,Ans2;
int F[MAX][3];
bool (*compare)(int,int);
 
bool bigger(int a,int b) { return a>b; }
bool smaller(int a,int b) { return a<b; }
 
void build(node *P)
{
	Q++;
	int k=S[Q]-'0';
	P->c=k;
	if (k)
	{
		N++;
		P->l=&E[N];
		E[N].p=N;
		build(P->l);
		if (k==2)
		{
			N++;
			P->r=&E[N];
			E[N].p=N;
			build(P->r);
		}
	}
}
 
void init()
{
	freopen("trot.in","r",stdin);
	freopen("trot.out","w",stdout);
	scanf("%s",S);
	E[N=1].p=1;	Q=-1;
	root=&E[1];
	build(root);
}
 
int dp(node *P,int C)
{
	int L,R;
	if (P->c==0) //leaf
	{
		if (C==0)
			return 1;
		else
			return 0;
	}
	else if (P->c==1) //link
	{
		L=P->l->p;
		if (F[L][0]==-1)
			F[L][0]=dp(P->l,0);
		if (F[L][1]==-1)
			F[L][1]=dp(P->l,1);
		if (F[L][2]==-1)
			F[L][2]=dp(P->l,2);
		if (C==0)
		{
			if (compare(F[L][1] , F[L][2]))
				return F[L][1] + 1;
			else
				return F[L][2] + 1;
		}
		else if (C==1)
		{
			if (compare(F[L][0] , F[L][2]))
				return F[L][0];
			else
				return F[L][2];
		}
		else
		{
			if (compare(F[L][0] , F[L][1]))
				return F[L][0];
			else
				return F[L][1];
		}
	}
	else
	{
		L=P->l->p; R=P->r->p;
		if (F[L][0]==-1)
			F[L][0]=dp(P->l,0);
		if (F[L][1]==-1)
			F[L][1]=dp(P->l,1);
		if (F[L][2]==-1)
			F[L][2]=dp(P->l,2);
		if (F[R][0]==-1)
			F[R][0]=dp(P->r,0);
		if (F[R][1]==-1)
			F[R][1]=dp(P->r,1);
		if (F[R][2]==-1)
			F[R][2]=dp(P->r,2);
		if (C==0)
		{
			if (compare(F[L][1]+F[R][2] , F[L][2]+F[R][1]))
				return F[L][1]+F[R][2] + 1;
			else
				return F[L][2]+F[R][1] + 1;
		}
		else if (C==1)
		{
			if (compare(F[L][0]+F[R][2] , F[L][2]+F[R][0]))
				return F[L][0]+F[R][2];
			else
				return F[L][2]+F[R][0];
		}
		else
		{
			if (compare(F[L][0]+F[R][1] , F[L][1]+F[R][0]))
				return F[L][0]+F[R][1];
			else
				return F[L][1]+F[R][0];
		}
	}
}
 
void rin()
{
	int i;
	for (i=1;i<=N;i++)
		F[i][0]=F[i][1]=F[i][2]=-1;
}
 
void solve()
{
	Ans1=0;Ans2=INF;
	rin();
	compare=bigger;
	F[1][0]=dp(root,0);if (F[1][0] > Ans1) Ans1=F[1][0];
	F[1][1]=dp(root,1);if (F[1][1] > Ans1) Ans1=F[1][1];
	F[1][2]=dp(root,2);if (F[1][2] > Ans1) Ans1=F[1][2];
	rin();
	compare=smaller;
	F[1][0]=dp(root,0);if (F[1][0] < Ans2) Ans2=F[1][0];
	F[1][1]=dp(root,1);if (F[1][1] < Ans2) Ans2=F[1][1];
	F[1][2]=dp(root,2);if (F[1][2] < Ans2) Ans2=F[1][2];
}
 
int main()
{
	init();
	solve();
	printf("%d %d",Ans1,Ans2);
	return 0;
}

三色二叉树

问题描述

一棵二叉树可以按照如下规则表示成一个由0、1、2组成的字符序列，我们称之为“二叉树序列S”：

  • 0 该树没有子节点
  • 1S1 该树有一个子节点，S1为其二叉树序列
  • 1S1S2 该树有两个子节点，S1,S2分别为两个二叉树的序列

例如，下图所表示的二叉树可以用二叉树序列S=21200110来表示。

Image:Trot.gif

你的任务是要对一棵二叉树的节点进行染色。每个节点可以被染成红色、绿色或蓝色。并且，一个节点与其子节点的颜色必须不同，如果该节点有两个子节点，那么这两个子节点的颜色也必须不相同。给定一棵二叉树的二叉树序列，请求出这棵树中最多和最少有多少个点能够被染成绿色。

输入文件
输入文件仅有一行，不超过10000个字符，表示一个二叉树序列。

输出文件

输出文件也只有一行，包含两个数，依次表示最多和最少有多少个点能够被染成绿色。

样例输入

1122002010

样例输出

5 2

Maybe you like

]]> http://www.byvoid.com/blog/poi-1999-tro/feed/ 3 USACO 4.2.2 The Perfect Stall 完美的牛栏 stall4 http://www.byvoid.com/blog/usaco-422-the-perfect-stall/ http://www.byvoid.com/blog/usaco-422-the-perfect-stall/#comments Tue, 17 Jun 2008 07:34:28 +0000 BYVoid http://www.byvoid.com/blog/?p=147
最简单的求二分图最大匹配，最朴素的匈牙利算法解决。

?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

/*
ID: cmykrgb1
PROG: stall4
LANG: C++
*/
#include <iostream>
#include <fstream>
#define MAX 402
#define PV 200
using namespace std;
ifstream fi("stall4.in");
ofstream fo("stall4.out");
int N,M,mat;
int adjl[MAX][MAX];
int match[MAX];
bool onpath[MAX];
 
void init()
{
	int i,j,a,b;
	fi >> N >> M;
	for (i=1;i<=N;i++)
	{
		fi >> a;
		for (j=1;j<=a;j++)
		{
			fi >> b;
			adjl[i][ ++adjl[i][0] ]=b+PV;
			adjl[b+PV][ ++adjl[b+PV][0] ]=i;
		}
	}
}
 
bool cross(int i)
{
	int k,j;
	for (k=1;k<=adjl[i][0];k++)
	{
		j=adjl[i][k];
		if (!onpath[j])
		{
			onpath[j]=true;
			if (!match[j] || cross(match[j]))
			{
				match[j]=i;
				return true;
			}
		}
	}
	return false;
}
 
void hungary()
{
	int i;
	for (i=1;i<=N;i++)
	{
		if (cross(i))
			mat++;
		memset(onpath,0,sizeof(onpath));
	}
}
 
void print()
{
	fo << mat << endl;
	fi.close();
	fo.close();
}
 
int main()
{
	init();
	hungary();
	print();
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/usaco-422-the-perfect-stall/feed/ 1