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 1998 解题报告 http://www.byvoid.com/blog/noi-1998-solution/ http://www.byvoid.com/blog/noi-1998-solution/#comments Mon, 23 Feb 2009 12:30:19 +0000 BYVoid http://www.byvoid.com/blog/?p=892 这是NOI计划的第二份题解。NOI1998的6道题是[个人所得税][免费馅饼][围巾裁剪][SERNET模拟][软件安装盘][并行计算]，相对于NOI1997要稍难一些，不过还都是可以接受的。

[个人所得税]是一个简单题，[免费馅饼][围巾裁剪]是基本的动态规划问题，难度都还算容易。[SERNET模拟]涉及到了图论的最短路算法构造，需要稍稍思考。[软件安装盘]是一个比较困难的搜索题，目前还没有较好的方法。[并行计算]用了随机+贪心的方法，细节非常多，构造也不是很容易。

做这些题花了我8天时间，主要原因是在[并行计算]上浪费了过多的时间，接下来要掌握节奏。

[个人所得税]

这是最简单的题了，注意读懂题意，按照规则模拟就行了。一次性收入直接统计，按月收入要先把每个人的每月收入统计出，最后计算。

?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

/* 
 * Problem: NOI1998 personaltax
 * Author: Guo Jiabao
 * Time: 2009.2.17 14:03
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
double income(int s)
{
	double w=s;
	if (w<=4000)
		w-=800;
	else
		w*=0.8;
	if (w<=0)
		return 0;
	else if (w<=20000)
		return w*0.2;
	else if (w<=50000)
		return 4000+(w-20000)*0.3;
	else
		return 4000+9000+(w-50000)*0.4;
}
 
double wage(int s)
{
	double w=s-800;
	if (w<=0)
		return 0;
	else if (w<=500)
		return w*0.05;
	else if (w<=2000)
		return 25+(w-500)*0.1;
	else if (w<=5000)
		return 25+150+(w-2000)*0.15;
	else if (w<=20000)
		return 25+150+450+(w-5000)*0.2;
	else if (w<=40000)
		return 25+150+450+3000+(w-20000)*0.25;
	else if (w<=60000)
		return 25+150+450+3000+5000+(w-40000)*0.3;
	else if (w<=80000)
		return 25+150+450+3000+5000+6000+(w-60000)*0.35;
	else if (w<=100000)
		return 25+150+450+3000+5000+6000+7000+(w-80000)*0.40;
	else
		return 25+150+450+3000+5000+6000+7000+8000+(w-100000)*0.45;
}
 
using namespace std;
int pm[50001][13],M;
double Total;
int main()
{
	char c,ct[10];
	int i,j,id,month,t,s;
	freopen("personaltax.in","r",stdin);
	freopen("personaltax.out","w",stdout);
	scanf("%d",&M);
	Total=0;
	while (c!='#')
	{
		scanf("%s%d%d",ct,&id,&month);getchar();scanf("%d%d",&t,&s);
		if (ct[0]=='I')
			Total+=income(s);
		else
			pm[id][month]+=s;
		do c=getchar(); while (c==10 || c==13);
		ungetc(c,stdin);
	}
	for (i=1;i<=M;i++)
	{
		for (j=1;j<=12;j++)
			Total+=wage(pm[i][j]);
	}
	printf("%.2lfn",Total);
	return 0;
}

[免费馅饼]

很明显的动态规划，但是要注意细节。“开始时游戏者站在舞台的正中央”，“当馅饼在某一秒末恰好到达游戏者所在的格子中，游戏者就收集到了这块馅饼。”对于每个馅饼，只有恰好到达才算能接住，也就是如果(高度-1)能够整除下落速度，才可以被接到。

明确题意以后，首先预处理出每个馅饼的落地时间，落地时间相同的馅饼可以合并为一个。定义V[i,j]为时间为i秒时，恰好落到地上第j格的馅饼总价值。

状态设定

  • F[i,j]表示第i秒游戏者在第j格时的最大得分。

状态转移方程

F[i,j]=Max
{
	F[i-1,j-2];
	F[i-1,j-1];
	F[i-1,j];
	F[i-1,j+1];
	F[i-1,j+2];
} + V[i,j];

同时要记录每个状态的转移来源，以输出每秒的策略。

初始状态

  • F[i,j]=负无穷大
  • F[0,(W+1)/2]=0 或者如果第0秒就能接到馅饼的价值

目标状态

  • Max{F[i,j]}

时间复杂度 O(W*T)

?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

/* 
 * Problem: NOI1998 freepizza
 * Author: Guo Jiabao
 * Time: 2009.2.21 14:19
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXT=1001,MAXW=101,INF=0x7FFFFFFF;
using namespace std;
int W,H,N,T,Ans,AT,AP;
int F[MAXT][MAXW],V[MAXT][MAXW],G[MAXT][MAXW];
void init()
{
	int i,j,t,p,v,s,dt;
	freopen("freepizza.in","r",stdin);
	freopen("freepizza.out","w",stdout);
	scanf("%d%d",&W,&H);
	while (scanf("%d%d%d%d",&t,&p,&v,&s)!=EOF)
		if ((H-1)%v==0 || t==0)
		{
			dt=t+(H-1)/v;
			if (dt>T) T=dt;
			V[dt][p]+=s;
		}
	for (j=0;j<=T;j++)
		for (i=1;i<=W;i++)
			F[j][i]=-INF;
	p=(W+1)/2;
	Ans=F[0][p]=V[0][p];
}
void dynamic()
{
	int i,j;
	for (i=1;i<=T;i++)
	{
		for (j=1;j<=W;j++)
		{
			if (j-2>0 && F[i-1][j-2]>F[i][j])
			{
				F[i][j]=F[i-1][j-2];
				G[i][j]=2;
			}
			if (j-1>0 && F[i-1][j-1]>F[i][j])
			{
				F[i][j]=F[i-1][j-1];
				G[i][j]=1;
			}
			if (F[i-1][j]>F[i][j])
			{
				F[i][j]=F[i-1][j];
				G[i][j]=0;
			}
			if (j+1<=W && F[i-1][j+1]>F[i][j])
			{
				F[i][j]=F[i-1][j+1];
				G[i][j]=-1;
			}
			if (j+2<=W && F[i-1][j+2]>F[i][j])
			{
				F[i][j]=F[i-1][j+2];
				G[i][j]=-2;
			}
			F[i][j]+=V[i][j];
			if (F[i][j]>Ans)
			{
				Ans=F[i][j];
				AT=i;
				AP=j;
			}
		}
	}
}
void print()
{
	int i,j,Ar[MAXT];
	for (i=AT,j=AP;i>0;i--)
	{
		Ar[i]=G[i][j];
		j-=G[i][j];
	}
	printf("%dn",Ans);
	if (T==0 && Ans!=0)
		printf("0n");
	for (i=1;i<=AT;i++)
		printf("%dn",Ar[i]);
}
int main()
{
	init();
	dynamic();
	print();
	return 0;
}

[围巾裁剪]

这道题的方法是动态规划，由于要解决寻找两个子三角形的面积和最大，我们可以先简化问题，就是找一个最大的。

找一个最大的子三角形，要分为正着和倒着两种情况。对于正着放的情况，设定状态F[i,j]表示以第i行第j列的三角形为上顶点的子三角形的最大高度。

状态转移方程就是

F[i,j]=
{
	0; //(i,j)被标记为不可用
	1; //(i+1,j) (i+1,j+1) (i+1,j+2) 至少有一个不在界限内或者被标记为不可用
	Min { F[i+1,j] , F[i+1,j+2] } + 1; //不符合以上两个情况
}

对于倒着放的情况，设定状态G[i,j]表示以第i行第j列的三角形为下顶点的子三角形的最大高度。

G[i,j]=
{
	0; //(i,j)被标记为不可用
	1; //(i-1,j) (i-1,j-1) (i-1,j-2) 至少有一个不在界限内或者被标记为不可用
	Min { G[i-1,j] , G[i-1,j-2] } + 1; //不符合以上两个情况
}

上述简化的问题的答案就是Max{ Max{F[i,j]^2},Max{G[i,j]^2} }。

考虑找两个和最大三角形，没有局部最优策略可供利用，不能直接动态规划。于是可以想到枚举分割线，把图形分成一个小三角形和一个梯形，但后分别在两个区域内动态规划，求出两个区域内的值的和的最大值即可。

分割线枚举有三个方向，要O(N)次枚举分割，所以总的时间复杂度为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

/* 
 * Problem: NOI1998 scarfcut
 * Author: Guo Jiabao
 * Time: 2009.2.18 20:05
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=101;
using namespace std;
int N,M,dev,dm,NewAns,Ans;
int F[MAXN][MAXN*2];
bool forbid[MAXN][MAXN*2];
 
void init()
{
	int i,x,y;
	freopen("scarfcut.in","r",stdin);
	freopen("scarfcut.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=M;i++)
	{
		scanf("%d%d",&x,&y);
		forbid[x][y]=true;
	}
}
 
inline int Min(int a,int b)
{
	return a<b?a:b;
}
 
inline int area(int a,int b)
{
	if (a<1 || a>N || b<1 || b>2*a-1) return -1;
	if (dm==1) return a<=dev?1:0;
	if (dm==2) return b<=dev?1:0;
	return (a>=N-dev+1 && b<= (a-(N-dev+1)+1) *2-1)?1:0;
}
 
int dynamic()
{
	int i,j,o,b,M1=0,M2=0;
	for (i=N;i>=1;i--)
	{
		o=2*i-1;
		for (j=1;j<=o;j+=2)
		{
			b=area(i,j);
			if (forbid[i][j])
				F[i][j]=0;
			else if ( b!=area(i+1,j) || b!=area(i+1,j+1) || b!=area(i+1,j+2) )
				F[i][j]=1;
			else if (forbid[i+1][j] || forbid[i+1][j+1] || forbid[i+1][j+2])
				F[i][j]=1;
			else
				F[i][j]=Min( F[i+1][j] , F[i+1][j+2] ) + 1;
			if (b==0 && F[i][j]>M1)
				M1=F[i][j];
			else if (b==1 && F[i][j]>M2)
				M2=F[i][j];
		}
	}
	for (i=1;i<=N;i++)
	{
		o=2*i-1;
		for (j=2;j<=o;j+=2)
		{
			b=area(i,j);
			if (forbid[i][j])
				F[i][j]=0;
			else if ( b!=area(i-1,j-2) || b!=area(i-1,j-1) || b!=area(i-1,j) )
				F[i][j]=1;
			else if (forbid[i-1][j-2] || forbid[i-1][j-1] || forbid[i-1][j])
				F[i][j]=1;
			else
				F[i][j]=Min( F[i-1][j-2] , F[i-1][j] ) + 1;
			if (b==0 && F[i][j]>M1)
				M1=F[i][j];
			else if (b==1 && F[i][j]>M2)
				M2=F[i][j];
		}
	}
	return M1*M1+M2*M2;
}
 
void solve()
{
	for (dm=1;dm<=3;dm++)
		for (dev=1;dev<=N-1;dev++)
		{
			NewAns=dynamic();
			if (NewAns>Ans)
				Ans=NewAns;
		}
}
 
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

[SERNET模拟]

不能直接模拟数据包传输，必须采用更好的算法。由于每个数据包之间没有任何影响，我们可以把它们独立开来看。对于一个数据包，定义它在网络中持续到的时刻是last，那么在时刻T后还存在于网络中的充分必要条件是last>T。

设一个数据包的起始点是Start，目标点是Target，发出时间是Stime。 由于每个节点不会再发送已经接受过数据包，设想一下数据包的传输，我们可以想到信号最先到达点的时间一定是延最短路径传播的。每个节点只会转发一次同一个 数据包，以后接受的都会吸收，所以数据包的在网络中最大持续时间一定与最短路径有关，而且还取决于每个节点连出的最长边。总而言之，持续时间为从起始点 Start出发的到顶点i最短路径的长度与连出i的最长边的最大值。

于是，我们定义以点Start出发的到点i的最短路径是shortest[i]，从点i出发的最长边是far[i]，注意far[Target]=0。则有

  • last=Max{shortest[i]+far[i]} + Stime

根据上述式子，只需对每个数据包求一次单源最短路即可。由于单元最短路算法使用的不同，定义SSSP(N,M)为N个顶点，M条边单源最短路算法的 时间复杂度，例如Floyd(N,M)=O(N^3)，朴素的Dijkstra(N,M)=O(N^2)。所以总的时间复杂度为 O(K*SSSP(N,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

/* 
 * Problem: NOI1998 sernet
 * Author: Guo Jiabao
 * Time: 2009.2.23 13:25
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=101,MAXK=10001,INF=0x7FFFFFF;
using namespace std;
struct packet
{
	int id,s,t,stime;
}P[MAXK];
int N,M,K,S,T,dia,QuestTime,Ans;
int mapping[MAXN],adjm[MAXN][MAXN],dist[MAXN][MAXN],farest[MAXN];
void init()
{
	int i,j,a,b,v;
	freopen("sernet.in","r",stdin);
	freopen("sernet.out","w",stdout);
	scanf("%d",&N);
	for (i=1;i<=N;i++)
	{
		scanf("%d",&a);
		mapping[a]=i;
		for (j=1;j<=N;j++)
			adjm[i][j]=INF;
		adjm[i][i]=0;
	}
	scanf("%d",&M);
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d",&a,&b,&v);
		a=mapping[a];b=mapping[b];
		if (v>farest[a]) farest[a]=v;
		if (v>farest[b]) farest[b]=v;
		adjm[a][b]=adjm[b][a]=v;
	}
	scanf("%d",&K);
	for (i=1;i<=K;i++)
		scanf("%d%d%d%d",&P[i].id,&P[i].stime,&P[i].s,&P[i].t);
	scanf("%d",&QuestTime);
}
void floyd()
{
	int i,j,k;
	for (i=1;i<=N;i++)
		for (j=1;j<=N;j++)
			dist[i][j]=adjm[i][j];
	for (k=1;k<=N;k++)
	{
		if (k==S || k==T) continue;
		for (i=1;i<=N;i++)
		{
			if (i==T) continue;
			for (j=1;j<=N;j++)
			{
				if (j==S) continue;
				if (dist[i][k]+dist[k][j]<dist[i][j])
					dist[i][j]=dist[i][k]+dist[k][j];
			}
		}
	}
	i=S;
	for (j=1;j<=N;j++)
		if (i!=j && i!=T && j!=S && dist[i][j]!=INF)
		{
			k=farest[j];
			if (j==T) k=0;
			if (dist[i][j] + k>dia)
				dia=dist[i][j] + k;
		}
}
void solve()
{
	for (int i=1;i<=K;i++)
	{
		S=mapping[P[i].s];T=mapping[P[i].t];
		dia=0;
		floyd();
		int last=dia+P[i].stime;
		if (last>QuestTime)
			Ans++;
	}
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

[软件安装盘]

这是一个比较令人头痛的问题，对于极端的数据，目前还没有能够保证正确性的有效的算法。我的算法是搜索+卡时，我的算法可以使最优解在前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

/* 
 * Problem: NOI1998 software
 * Author: Guo Jiabao
 * Time: 2009.2.22 21:23
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
const int MAXN=101;
using namespace std;
struct module
{
	int size,rcnt,acnt;
	int affect[MAXN];
	int rely[MAXN];
}md[MAXN];
int N,Space,Ans=0x7FFFFFFF,Lim,st;
int position[MAXN],used[MAXN],Ansp[MAXN],Start[MAXN];
void init()
{
	int i,j,c;
	freopen("software.in","r",stdin);
	freopen("software.out","w",stdout);
	scanf("%d%d",&Space,&N);
	for (i=1;i<=N;i++)
	{
		scanf("%d",&md[i].size);
		while ((c=getchar())!=10 && c!=13)
		{
			while (c!=10 && c!=13 && !(c>='0' && c<='9')) c=getchar();
			if (c==10 || c==13) break;
			ungetc(c,stdin);
			scanf("%d",&md[i].rely[ ++md[i].rcnt ]);
		}
	}
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=md[i].rcnt;j++)
			md[ md[i].rely[j] ].affect[ md[ md[i].rely[j] ].acnt ] =i;
		Start[i]=1;
	}
	st=time(0);
}
void print()
{
	int i,j,A[MAXN][MAXN];
	printf("%dn",Ans);
	for (i=1;i<=Ans;i++)
		A[i][0]=0;
	for (i=1;i<=N;i++)
		A[ Ansp[i] ][ ++A[ Ansp[i] ][0] ]=i;
	for (i=1;i<=Ans;i++)
	{
		for (j=1;j<A[i][0];j++)
			printf("%d ",A[i][j]);
		printf("%dn",A[i][j]);
	}
	exit(0);
}
void dfs(int k,int pcnt)
{
	if (time(0)-st)
		print();
	int i,j,start=1,b=false;
	int A[MAXN];
	if (k>N)
	{
		if (pcnt<Ans)
		{
			Ans=pcnt;
			for (i=1;i<=N;i++)
				Ansp[i]=position[i];
		}
		return;
	}
	for (i=Start[k];i<=Lim && !b && i<Ans;i++)
	{
		if (used[i]+md[k].size>Space)
			continue;
		if (i>pcnt)
			pcnt=i;
		if (used[i]==0)
			b=true;
		used[i]+=md[k].size;
		position[k]=i;
		for (j=1;j<=md[i].acnt;j++)
		{
			A[md[i].affect[j]]=Start[j];
			if (md[i].affect[j]>Start[j])
				Start[j]=A[md[i].affect[j]];
		}
		dfs(k+1,pcnt);
		for (j=1;j<=md[i].acnt;j++)
			Start[j]=A[j];
		used[i]-=md[k].size;
	}
}
void solve()
{
	Lim=N;
	dfs(1,0);
}
int main()
{
	init();
	solve();
 
	print();
	return 0;
}

[并行计算]

很强悍的题，随机+贪心。首先是建立一棵表达式树，方法是从右向左扫描式子，遇到最低级的运算符就把式子分为左右两部分，递归进入扫描，建成一棵表达式树。

表达式树的每个节点可能是一个值也可能是运算符，每个节点要存储其父节点的运算符号op，最初的叶节点都是字母。定义每个节点的ftime 为可使用的时刻，address为存储的地址。定义R[i](i=1,2)为运算器i上次运算完成后的时刻，初始R[1]=R[2]=0。

基本的算法是，每次随机找出一对可合并节点(a,b)，将这两个节点合并，尽量使用R[p]较小的运算器p，必须满足 max{a.ftime,b.ftime}<=R[p] ，如果不满足，则使用另一个（两者必有其一满足）。直到合并完所有的节点，根节点的ftime值就是总时间。重复上述过程1000次以上，保留最后时间最 小的解，最后能给出稳定的接近最优的解，实际上是最优解的概率已经很大。

合并实质就是计算a [b.op] b，方法是把计算后的新地址放到a节点处，然后把b删除（实际上为了保护树的结构不需要真正删除，只需标记“已被删除”）。重要的是，删除后要收缩孤立 点，孤立点就是没有兄弟的叶节点，用孤立点取代其父亲节点。当b就是a的兄弟节点，这时a已经成了孤立点，收缩a。如果b不是a的兄弟节点，且b的兄弟节 点是一个叶节点，此时b的兄弟节点成为了孤立点，收缩b的兄弟节点。

对于收缩节点p，检查p是否已经没有兄弟节点，令p取代其父节点的ftime和address值，然后删除p，访问p的父亲，继续检查，知道p已经有兄弟节点，或者已经到了根节点。

可合并的点对(a,b)并不是任意的，必须满足a和b在同一运算优先级的区间内，在表达式树中的表示就是a,b之间的路径不能跨越不同优先 级的运算符的节点。a和b显然必须是叶节点，其中a还应该满足a是其父亲的左子节点或者a.op为+或*。在随机选取a，b时，可以先从叶节点中随机取出 一个节点，另其为b，然后从b出发搜索出与b在同一运算优先级区间内所有的节点的集合，然后在此集合中随机取出a即可。

该算法的时间复杂度为O(K*N^2)，K为重复贪心的次数，是常数，N为表达式中字母个数(N<=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
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

/* 
 * Problem: NOI1998 parallel
 * Author: Guo Jiabao
 * Time: 2009.2.20 21:52
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXP=1000,MAXL=300,MAX_Repeat=1000;
using namespace std;
struct et_node
{
	et_node *left,*right,*brother,*father;
	char v;
	int ftime,address,op,id;
	bool is_left;
};
struct instruct
{
	int Time,Alu,Op,A1,A2,A3;
};
struct Solution
{
	instruct I[MAXP];
	int eadd,etime,IC;
};
int Len,EC=-1,Acnt,SC,Lcnt,opdevide,SAC;
char Ex[MAXL];
bool usedletter[300],vis[MAXP];
int lt2add[300],bk[MAXL],RT[3],T[5];
et_node ES[MAXP],*root,*S[MAXP],*SA[MAXP];
Solution Best,Current;
void init()
{
	int i,Lv[MAXL],Lp;
	freopen("parallel.in","r",stdin);
	freopen("parallel.out","w",stdout);
	scanf("%d%d%d%dn%s",&T[1],&T[2],&T[3],&T[4],Ex);
	Len=strlen(Ex);
	for (i=Lp=0;i<Len;i++)
	{
		usedletter[Ex[i]]=true;
		if (Ex[i]=='(')
			Lv[++Lp]=i;
		else if (Ex[i]==')')
			bk[i]=Lv[Lp--];
	}
	Lcnt=0;
	for (i='A';i<='Z';i++)
		if (usedletter[i])
			lt2add[i]=++Lcnt;
}
inline int getoperator(char s)
{
	if (s=='+') return 1;
	if (s=='-') return 2;
	if (s=='*') return 3;
	return 4;
}
inline void addshrink(et_node *a)
{
	S[++SC]=a;
}
inline void delshrink(et_node *a)
{
	int k;
	for (k=1;k<=SC;k++)
		if (S[k]==a)
			break;
	S[k]=S[SC--];
}
inline et_node* et_new()
{
	++EC;
	ES[EC].left=ES[EC].right=0;
	ES[EC].id=EC;
	return &ES[EC];
}
et_node* et_build(int l,int r)
{
	int i;
	bool fnd=false;
	et_node *p=et_new();
	if (l==r)
	{
		p->v=Ex[l];
		return p;
	}
	if (Ex[r]==')' && bk[r]==l)
		l++,r--;
	for (i=r;i>=l;i--)
	{
		if (Ex[i]==')')
			i=bk[i];
		else if (Ex[i]=='+' || Ex[i]=='-')
		{
			fnd=true;
			break;
		}
	}
	if (!fnd)
		for (i=r;i>=l;i--)
		{
			if (Ex[i]==')')
				i=bk[i];
			else if (Ex[i]=='*' || Ex[i]=='/')
				break;
		}
	p->v=Ex[i];
	p->left=et_build(l,i-1);
	p->right=et_build(i+1,r);
	p->left->is_left=true;
	p->right->is_left=false;
	p->left->brother=p->right;
	p->right->brother=p->left;
	p->left->father=p->right->father=p;
	p->left->op=p->right->op=getoperator(p->v);
	return p;
}
void clear(et_node *p)
{
	if (!p) return;
	p->ftime=p->address=0;
	if (p->v >='A' && p->v <='Z')
	{
		p->address=lt2add[p->v];
		addshrink(p);
	}
	else
	{
		clear(p->left);
		clear(p->right);
	}
}
void addinstruction(int p,int op,int a1,int a2,int a3)
{
	Current.IC++;
	Current.I[Current.IC].Time=RT[p];
	Current.I[Current.IC].Alu=p;
	Current.I[Current.IC].Op=op;
	Current.I[Current.IC].A1=a1;
	Current.I[Current.IC].A2=a2;
	Current.I[Current.IC].A3=a3;
}
inline bool samelevel(int a,int b)
{
	return ((a==1||a==2) && (b==1||b==2)) || ((a==3||a==4) && (b==3||b==4));
}
void geta(et_node *p)
{
	if (!p || vis[p->id])
		return;
	vis[p->id]=true;
	if (p->address>0)
	{
		if (p->is_left || p->op==1 || p->op==3)
			SA[++SAC]=p;
		else
			return;
	}
	if (!samelevel(getoperator(p->v),opdevide))
		return;
	int r=rand()%2;
	if (r)
	{
		geta(p->left);
		geta(p->right);
	}
	else
	{
		geta(p->right);
		geta(p->left);
	}
	geta(p->father);
}
inline void getab(et_node *&a,et_node *&b)
{
	a=b=0;
	while (!a)
	{
		b=S[rand()%SC+1];
		opdevide=b->op;
		memset(vis,0,sizeof(vis));
		vis[b->id]=true;
		SAC=0;
		geta(b->left);
		geta(b->right);
		geta(b->father);
		if (SAC>0)
			a=SA[rand()%SAC+1];
	}
}
void contract(et_node *a)
{
	delshrink(a);
	while (a->brother && a->brother->address==-1)
	{
		a->father->address=a->address;
		a->father->ftime=a->ftime;
		a->address=-1;
		a=a->father;
	}
	if (a!=root)
		addshrink(a);
}
void bind(et_node *a,et_node *b)
{
	delshrink(b);
	a->address=Acnt;
	b->address=-1;
	if (b==a->brother)
		contract(a);
	else if (b->brother->address>0)
		contract(b->brother);
}
void greedy()
{
	int p,op;
	et_node *a,*b;
	while (SC)
	{
		getab(a,b);
		if (RT[1]<=RT[2])
			p=1;
		else
			p=2;
		if (!(a->ftime<=RT[p] && b->ftime<=RT[p]))
			p=3-p;
		op=b->op;
		addinstruction(p,op,a->address,b->address,++Acnt);
		RT[p]=a->ftime=RT[p]+T[op];
		bind(a,b);
	}
	Current.eadd=root->address;
	Current.etime=root->ftime;
}
void solve()
{
	root=et_build(0,Len-1);
	root->father=0;
	Best.etime=0x7FFFFFFF;
	for (int Repeat=1;Repeat<=MAX_Repeat;Repeat++)
	{
		clear(root);
		RT[1]=RT[2]=Current.IC=0;
		Acnt=Lcnt;
		greedy();
		if (Current.etime<Best.etime)
			Best=Current;
	}
}
void print()
{
	for (int i=1;i<=Best.IC;i++)
		printf("OP %d %d %d %d %d %dn",
		Best.I[i].Time,Best.I[i].Alu,Best.I[i].Op,Best.I[i].A1,Best.I[i].A2,Best.I[i].A3);
	printf("END %d %dn",Best.etime,Best.eadd);
}
int main()
{
	init();
	solve();
	print();
	return 0;
}

个人所得税

某国个人所得税法规定，普通公民的主要应纳税收入项目及纳税金额如下：

工资、薪金所得。按月计算征税，以每月收入额减除费用800元后的余额作为该月应纳税所得额，税率如下表所示：

级数	月应纳税所得额	税率（%）
1	不超过500元的	5
2	超过500元~2000元的部分	10
3	超过2000元~5000元的部分	15
4	超过5000元~20000元的部分	20
5	超过20000元~40000元的部分	25
6	超过40000元~60000元的部分	30
7	超过60000元~80000元的部分	35
8	超过80000元~100000元的部分	40
9	超过100000元的部分	45

一次性劳动报酬所得。按次计算征税，每次不超过4000元的，减除费用800元；4000元以上的，减除20%的费用，余额为应纳税所得额。征税税率如下表所示：

级数	每次应纳税所得额	税率（%）
1	不超过20000元的部分	20
2	超过20000元~50000元的部分	30
3	超过50000元的部分	40

由上面可以看出，个人工资、薪金及一次性劳动报酬所得都是按照超额累进税率来征税的。超额累进税率将应纳税所得额按数额大小分成若干等级，每一等级 规定一个税率，税率依次提高，但每一纳税人的的应纳税所得额依照所属等级同时适用几个税率分别计算，将计算结果相加后的总额作为应纳税款。

例如，某人某月工资总额为3800元，减去800元后，应纳税所得额为3000元。其中1级500元，2级1500元，3级1000元， 税率分别为5%、10%、15%，应纳税总额为500*5%+1500*10%+1000*15%=325（元）。现在需要你编一程序，根据该国某公司的 所有职员一年内的各项收入信息（收入项目、收入时间、收入金额）计算该公司所有职员这一年应交纳的个人所得税总额。

输入

输入文件的第一行为一个正整数M（M<= 50000），表示该公司的职员总数（职员编号依次为1,2,…,M）。接下来的各行每行表示一年内某一个职员的一项收入信息。具体格式如下： 工资、薪金收入信息：PAY 职员编号 收入时间 收入金额

一次性劳务报酬收入信息：INCOME 职员编号 收入时间 收入金额

其中，收入时间格式为：MM/DD，MM表示月份（1<= MM<=12），DD表示日期（1<= DD<=31）；收入金额是一个正整数（单位：元），并假设每人每项收入金额小于100万元。

输入文件以字符“#”表示结束。输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出

输出文件只有一个正数P(保留两位小数)，P表示该公司所有职员一年内应交纳的个人所得税总额（单位：元）。

样例输入

2
PAY 1 2/23 3800
INCOME 2 4/8 4010
INCOME 2 4/18 800
PAY 1 8/14 6700
PAY 1 8/10 1200
PAY 2 12/10 20000
#

样例输出

5476.60

免费馅饼

SERKOI最新推出了一种叫做“免费馅饼”的游戏:游戏在一个舞台上进行。舞台的宽度为W格，天幕的高度为H格，游戏者占一格。开始时游戏者站在舞台的正中央，手里拿着一个托盘。下图为天幕的高度为4格时某一个时刻游戏者接馅饼的情景。

Image:Freepizza.gif

游戏开始后，从舞台天幕顶端的格子中不断出现馅饼并垂直下落。游戏者左右移动去接馅饼。游戏者每秒可以向左或向右移动一格或两格，也可以站在原地不动。

馅饼有很多种，游戏者事先根据自己的口味，对各种馅饼依次打了分。同时，在8-308电脑的遥控下，各种馅饼下落的速度也是不一样的，下落速度以格/秒为单位。

当馅饼在某一秒末恰好到达游戏者所在的格子中，游戏者就收集到了这块馅饼。

写一个程序，帮助我们的游戏者收集馅饼，使得所收集馅饼的分数之和最大。

输入

输入文件的第一行是用空格隔开的两个正整数，分别给出了舞台的宽度W（1到99之间的奇数）和高度H（1到100之间的整数）。

接下来依馅饼的初始下落时间顺序给出了所有馅饼的信息。每一行给出了一块馅饼的信息。由四个正整数组成，分别表示了馅饼的初始下落时刻（0到1000秒），水平位置、下落速度（1到100）以及分值。游戏开始时刻为0。从1开始自左向右依次对水平方向的每格编号。

输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出

输出文件的第一行给出了一个正整数，表示你的程序所收集的最大分数之和。

其后的每一行依时间顺序给出了游戏者每秒的决策。输出0表示原地不动、1或2表示向右移动一步或两步、-1 或-2表示向左移动一步或两步。输出应持续到游戏者收集完他要收集的最后一块馅饼为止。

样例输入

3 3
0 1 2 5
0 2 1 3
1 2 1 3
1 3 1 4

样例输出

12
-1
1
1

围巾裁剪

裁缝有一块非常珍贵的丝绸围巾。可惜的是，围巾的某些部分已经被蛀虫给咬坏了。裁缝当然不愿意就这么把围巾给丢了，于是，他想把围巾给裁成两块小围巾送给他的两个女儿。自然，两块小围巾的面积之和越大越好。

这块围巾是一个正三角形，三条边被均匀地分成了N段，即这个正三角形被均匀地分成了N2个单元，每个单元是一个面积为1的正三角形。图一所 示为一个N=5的围巾，图中带阴影的单元表示被蛀虫咬坏的部分。从上往下看，围巾被分成了N行，第一行有1个单元，第二行有3个单元，其中有2个是形如D 的，有1个是形如Ñ 的（这两种三角形我们认为是形状相同的）。第三行有5个，其中有3个是形如D 的，有2个是形如Ñ 的…… 。用坐标（X,Y）给每个单元定位，第一行的单元的坐标为（1,1）；第二行从左到右的三个单元的坐标依次为（2,1）、（2,2）、（2,3）；…。

Image:Scarfcut.jpg

围巾的剪裁条件如下：

  1. 裁成的两块小围巾形状与原来的大围巾完全相同，都是正三角形。
  2. 每一块小围巾里都不存在被蛀虫咬坏的部分。
  3. 裁剪时必须沿着单元的边界裁剪。
  4. 要求两块小围巾的面积的总和最大。

图中，最优的裁剪方法已经用粗线画了出来，面积和为4+9=13。

现在需要你编一个程序来帮助裁缝解决这个问题。

输入

输入文件第一行为一个整数N（1<=N<=100），表示这块围巾总共被分成了N2个单元。第二行为一个整数M（0<= M<=N2-2），表示这块围巾共有M个单元被蛀虫咬坏了。接下的M行，每一行有两个正整数X和Y，为这M个被蛀虫咬坏的单元的坐标。

输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出

输出文件仅含一个整数，为你所找到的裁出两块小围巾面积总和的最大值。

样例输入

5
5
3 2
4 1
4 4
5 4
5 2

样例输出

13

SERNET模拟

计算机网络是现代科技发展的热点，传输性能是计算机网络的主要性能指标。SERKOI网络开发小组设计了一种称为SERNET的网络，并希望开发一个模拟软件来模拟该网络的数据传输情况，进而计算出网络的传输性能。

SERNET网络由服务器及连接它们的网络传输线路组成，服务器用服务器地址予以标识，网络传输线路为双向传输线路。网络传输过程中将各种 待传输数据分割为若干个大小相同的数据包，以数据包为单位进行传输。数据包在传输线路上传输时需要一定的传输时间，不同的传输线路的传输时间不同。服务器 处理数据的时间较之于传输时间很小，可忽略不计。每一个数据包中除了包括具体的数据信息外，还含有如下标识信息：

  • 数据包编号
  • 数据包源服务器地址
  • 数据包目的服务器地址

网络传输的功能就是将一个个数据包从源服务器传输到目的服务器。对于每一个数据包，具体的网络传输方案为：

源服务器将待发送的数据包一律复制若干份并向与之相连的所有服务器发送该数据包。服务器接收到一个数据包后，如果该数据包符合下面任何一个条件：

  • 数据包的源服务器地址与本服务器地址相同
  • 数据包的目的服务器地址与本服务器地址相同
  • 本服务器已转发过与该数据包编号相同的数据包

则接收该数据包；否则，服务器将其复制若干份并向与它相连的所有服务器转发该数据包。这里，两台服务器“相连”的含义指它们之间有网络传输线路直接相连。

现在需要你编一个程序来模拟SERNET网络中的数据包传输情况。

输入

输入文件的第一行为一个正整数N（N<100），表示SERNET中服务器的数目。第二行有N个互不相等的不超过100的正整数，表 示每个服务器的地址。 第三行有一个正整数M，表示SERNET中传输线路的数目。接下来的M行每行用三个正整数表示一条传输线路连接的两台服务器的地址以及该传输线路的传输时 间。线路传输时间为不超过100的正整数。 接下来的一行为一个正整数K（K<10000），表示SERNET中数据包的数目。以下的K行每行表示一个数据包的信息，格式为： 数据包编号 起始发送时间 源服务器地址 目的服务器地址

其中数据包编号为互不相同的小于100000的正整数。

输入文件的最后一行为一个正整数T（T<10000），T为输出时刻。

输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出

输出文件的第一行为一个整数P，表示T时刻后还在网络中传输的数据包数目（编号相同的数据包为同一数据包）。

约定

  • 本题中所有时间量的单位均相同；
  • 每一条传输线路上在同一时刻能传输任意多个数据包。

样例输入

4
57 42 10 93
4
57 42 6
42 93 5
42 10 2
10 93 10
2
433 10 57 10
5678 11 42 93
23

样例输出

1

软件安装盘

软件安装通常是一件令人头疼的事。软件一般都包括若干个相对独立的部分（称为“组件”），在安装的时候由用户决定安装哪些部分。并且，这些相对独立的组件之间在安装时有一定的先后顺序要求。

由于当代的个人计算机普遍安装了软盘驱动器，所以软件的最流行的载体形式是软盘。然而，由于软盘的容量有限，稍大一些的软件就无法用一张软盘装下。这时，这些软件往往要用很多张软盘来存储。每张磁盘上存储了软件的一个或多个组件。这些软盘称为软件的安装盘。

由于软件的各个组件分散在不同的软盘上，而在安装时又有一定的先后顺序要求，所以很容易发生要求用户反复换盘的情况。而计算机用户在安装软 件的时候，最反感的就是反复在软盘之间切换：找盘、插盘、取盘、找盘、插盘、取盘、…，一切都显得那么琐碎和无序。因此，有必要对软件安装盘的制作提出下 述要求：

永远不要让用户将一张磁盘插入两次。更精确地，要求对安装盘从1开始顺序编号，使得安装的时候，用户只要按顺序插入磁盘即可。

出于经济的考虑，通常要求安装盘的总数最少。写一个程序，对于给定的软件，制定最优的安装盘方案。

输入

  • 输入文件的第一行是一个正整数M（1<= M<= 109），给出了每张磁盘的最大容量（字节数）。
  • 输入文件的第二行是一个正整数N（1<= N<= 100），给出了软件的组件数。接下来的N行每行给出一个组件的详细信息。包括：
  1. 组件所占的字节数；
  2. 在安装该组件之前应先安装的组件序号（如有多个组件须先安装，则每个都应列出其序号，若无须先安装其它组件，则该行只含组件所占字节数）。
  • 输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出

输出文件的第一行给出了最优安装盘方案的软盘数。如果不存在最优安装盘方案，则输出0。接下来的每一行顺序给出了每张盘上存储的组件的序号。如果一张盘上存储了多个组件，则输出所有这些组件的序号，中间用一个空格隔开。

样例输入

1457664
3
512665
912345 1
832542 1

样例输出

2
1 2
3

并行计算

运算器（ALU）是计算机中的重要部件，它的功能是进行数学运算。图一是运算器的工作简图，运算器的一次运算操作过程为：运算器在控制器的控制下， 从指定的存储器（MEMORY）存储单元中读出待运算的两个源操作数A和B，经过一定时间的计算后得到运算结果C，并将它写入指定的存储器存储单元中。

Image:Parallel1.jpg 图一

运算器能完成的运算种类及所需时间如下表所示：

运算种类 运算操作 所需运算时间
1 C=A+B Tadd
2 C=A-B Tsub
3 C=A*B Tmul
4 C=A/B Tdiv

在计算复杂的四则混合运算表达式时，运算器就变成了高速计算的“瓶颈”。为了得到更快的运算速度，计算机科学家们设计了一种有两个运算器的并行计算机，它的结构简图如图二所示。

Image:Parallel2.jpg 图二

由于两个运算器可以同时进行运算，因此大大提高了整机运算速度。该并行计算机有以下两种控制指令：

运算指令

  • OP Time Alu_no Operate_no Address1 Address2 Address3

其中OP为运算指令标识符，其后有六个参数：

  • Time表示执行该指令的开始时间
  • Alu_no表示承担该次运算操作的运算器编号（Alu_no∈{1，2}）
  • Operate_no表示该次运算的运算种类（Operate_no∈{1，2，3，4}）
  • Address1,Address2表示待运算的两个源操作数的存储单元地址
  • Address3表示该次运算结束后存放运算结果的存储单元地址

结束指令

  • END Time Address

其中 END为结束指令标识符，其后有两个参数：

  • Time表示整个控制程序的结束时间
  • Address表示存放最终计算结果的存储单元地址

每个运算器同一时刻可以执行一条运算指令，结束指令表示控制程序结束。

现在需要你编一个程序，对给定的待计算的表达式，自动生成一段控制程序，使图二所示的并行计算机能够正确计算该表达式的值，并使总运算时间尽量小。

输入

输入文件的第一行为四个不超过1000的正整数，依次为Tadd、Tsub、Tmul和Tdiv。 输入文件的第二行为待计算的四则混合运算表达式（长度不超过255个字符），表达式中的变量用大写英文字母表示，各变量的初始值依照变量的字母顺序依次存 放在地址为1,2,…的存储单元中。

输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出

输出文件为完成该表达式计算的最优控制指令段。指令根据其开始执行时间先后依次输出（对于开始执行时间相同的两条指令，输出先后次序不限），每条指令占一行。输出文件中同一行相邻两项之间用一个空格隔开。

约定

  • 控制程序初始执行时间从0时刻开始。
  • 问题中所涉及的各种时间量的单位相同。
  • 存储器的存储单元最多有1K个。
  • 由于数据读写时间同运算时间相比较小，可忽略不计。
  • 如果两个运算器同时对同一个存储单元进行操作，则运算器1先操作，运算器2后操作

评分

  • 程序的得分将取决于其所能找到的最优解与标准最优解相比较的优劣程度。

样例输入

2 2 4 12
C+(A+B)*C-E/F+F

样例输出

OP 0 1 1 1 2 6
OP 0 2 4 4 5 8
OP 2 1 1 3 5 7
OP 4 1 3 6 3 10
OP 8 1 1 10 7 11
OP 12 1 2 11 8 12
END 14 12

Maybe you like

]]> http://www.byvoid.com/blog/noi-1998-solution/feed/ 2 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