Beyond the Void » 2000 http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 CTSC2000 丘比特的烦恼 http://www.byvoid.com/blog/ctsc2000-cupid/ http://www.byvoid.com/blog/ctsc2000-cupid/#comments Tue, 24 Mar 2009 06:12:12 +0000 BYVoid http://www.byvoid.com/blog/?p=994 很容易看出来是求二分图的最佳匹配(最大权完备匹配)，直接用KM算法解决。

建图的过程中要注意细节，判断两人之间不能有第三者，距离小于等于射程。用向量共线的判定即可。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
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

/* 
 * Problem: 丘比特的烦恼
 * Author: Guo Jiabao
 * Time: 2009.3.24 12:49
 * State: Solved
 * Memo: KM O(N^3) with slack
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=61,MAXL=21,INF=0x7FFFFFFF;
using namespace std;
struct Person
{
	char Name[MAXL];
	int x,y;
}P[MAXN];
int N,M,T,Distance;
int adj[MAXN][MAXN],Match[MAXN],L[MAXN];
int slack[MAXN];
bool vis[MAXN];
inline int dist2(int x1,int y1,int x2,int y2)
{
	return (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);
}
inline bool iscross(int a,int b,int c)
{
	if ((P[a].x-P[b].x)*(P[b].y-P[c].y) == (P[b].x-P[c].x)*(P[a].y-P[b].y)) //共线
	{
		if (P[a].y==P[c].y)
			return (P[a].x < P[b].x && P[b].x < P[c].x)||(P[c].x < P[b].x && P[b].x < P[a].x);
		else
			return (P[a].y < P[b].y && P[b].y < P[c].y)||(P[c].y < P[b].y && P[b].y < P[a].y);
	}
	return false;
}
void shot()
{
	int i,j,k;
	for (i=1;i<=N;i++)
		for (j=M;j<=T;j++)
		{
			if (dist2(P[i].x,P[i].y,P[j].x,P[j].y)>Distance*Distance)
				adj[i][j]=0;
			else
			{
				for (k=1;k<=T;k++)
					if (k!=i && k!=j && iscross(i,k,j))
						break;
				adj[i][j]=k>T?1:0;
			}
		}
}
inline int scanname(char *S)
{
	for (int i=1;i<=T;i++)
		if (strcmp(P[i].Name,S)==0)
			return i;
}
void format(char *s)
{
	for (;*s;s++)
		if (*s>='a' && *s<='z')
			*s=*s-'a'+'A';
}
void init()
{
	int i,a,b,c,v;char Name[MAXL];
	freopen("cupid.in","r",stdin);
	freopen("cupid.out","w",stdout);
	scanf("%d%d",&Distance,&N);
	M=N+1;T=N+N;
	for (i=1;i<=T;i++)
	{
		scanf("%d%d%s",&P[i].x,&P[i].y,P[i].Name);
		format(P[i].Name);
	}
	shot();
	while (scanf("%s",Name)!=EOF)
	{
		if (strcmp(Name,"End")==0) break;
		format(Name);
		a=scanname(Name);
		scanf("%s",Name);format(Name);
		b=scanname(Name);
		scanf("%d",&v);
		if (a>b) {c=a;a=b;b=c;}
		if (adj[a][b]!=0)
			adj[a][b]=v;
	}
}
bool path(int i)
{
	vis[i]=true;
	for (int j=M;j<=T;j++)
	{
		if (!vis[j] && adj[i][j]>0)
		{
			int t=L[i]+L[j]-adj[i][j];
			if (t==0)
			{
				vis[j]=true;
				if (Match[j]==0 || path(Match[j]))
				{
					Match[j]=i;
					return true;
				}
			}
			else if (t<slack[j])
				slack[j]=t;
		}
	}
	return false;
}
void KM()
{
	int i,j,k,delta;
	memset(L,0,sizeof(L));
	memset(Match,0,sizeof(Match));
	for (i=1;i<=N;i++)
		for (j=M;j<=T;j++)
			if (adj[i][j]>L[i])
				L[i]=adj[i][j];
	for (i=1;i<=N;i++)
	{
		for (;;)
		{
			memset(vis,0,sizeof(vis));
			for (j=M;j<=T;j++)
				slack[j]=INF;
			if (path(i)) break;
			delta=INF;
			for (k=M;k<=T;k++)
				if (!vis[k] && slack[k]<delta)
					delta=slack[k];
			for (j=1;j<=N;j++)
				if (vis[j])
					L[j]-=delta;
			for (j=M;j<=T;j++)
				if (vis[j])
					L[j]+=delta;
		}
	}
}
void print()
{
	int i,Ans=0;
	for (i=M;i<=T;i++)
		Ans+=adj[Match[i]][i];
	printf("%d\n",Ans);
}
int main()
{
	init();
	KM();
	print();
	return 0;
}

丘比特的烦恼

随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国，找到了掌管东方人爱情的神——月下老人，向他求教。
月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他没有找到。在东方，人们讲究的是缘分。月下老人只要做一男一女两个泥人，在他们之间连上一条红线，那 么它们所代表的人就会相爱——无论他们身处何地。而丘比特的爱情之箭只能射中两个距离相当近的人，选择的范围自然就小了很多，不能找到真正的有缘人。
丘比特听了月下老人的解释，茅塞顿开，回去之后用了人间的最新科技改造了自己的弓箭，使得丘比特之箭的射程大大增加。这样，射中有缘人的机会也增加了不少。
情人节(Valentine’s day)的午夜零时，丘比特开始了自己的工作。他选择了一组数目相等的男女，感应到他们互相之间的缘分大小，并依此射出了神箭，使他们产生爱意。他希望能 选择最好的方法，使被他选择的每一个人被射中一次，且每一对被射中的人之间的缘分的和最大。
当然，无论丘比特怎么改造自己的弓箭，总还是存在缺陷的。首先，弓箭的射程尽管增大了，但毕竟还是有限的，不能像月下老人那样，做到“千里姻缘一线牵 ”。其次，无论怎么改造，箭的轨迹终归只能是一条直线，也就是说，如果两个人之间的连线段上有别人，那么莫不可向他们射出丘比特之箭，否则，按月下老人的话，就是“乱点鸳鸯谱”了。
作为一个凡人，你的任务是运用先进的计算机为丘比特找到最佳的方案。

输入文件格式：
输入文件第一行为正整数k，表示丘比特之箭的射程，第二行为正整数n(n<30)，随后有2n行，表示丘比特选中的人的信息，其中前n行为男子，后n行为女子。每个人的信息由两部分组成：他的姓名和他的位置。姓名是长度小于20且仅包含字母的字符串，忽略大小写的区别， 位置是由一对整数表示的坐标，它们之间用空格分隔。格式为x y Name。输入文件剩下的部分描述了这些人的缘分。每一行的格式为Name1 Name2 p。Name1和Name2为有缘人的姓名，p是他们之间的缘分值(p为小于等于255的正整数)。以一个End作为文件结束标志。每两个人之间的缘分如果被描述多次，以最后一次为准。如果没有被描述，则说明他们缘分值为1。

输出文件格式：
输出文件仅一个正整数，表示每一对被射中的人之间的缘分的总和。这个和应当是最大的。

输入样例
2
3
0 0 Adam
1 1 Jack
0 2 George
1 0 Victoria
0 1 Susan
1 2 Cathy
Adam Cathy 100
Susan George 20
George Cathy 40
Jack Susan 5
Cathy Jack 30
Victoria Jack 20
Adam Victoria 15
End

输出样例
65

Maybe you like

]]> http://www.byvoid.com/blog/ctsc2000-cupid/feed/ 0 NOI 2001 解题报告 http://www.byvoid.com/blog/noi-2001-solution/ http://www.byvoid.com/blog/noi-2001-solution/#comments Sat, 21 Mar 2009 09:31:06 +0000 BYVoid http://www.byvoid.com/blog/?p=982 NOI2001的题目是[反正切函数的应用][聪明的打字员][陨石的秘密][食物链][炮兵阵地][方程的解数]。

其中[反正切函数的应用][聪明的打字员]较为简单，[陨石的秘密][食物链][炮兵阵地][方程的解数]稍有难度。

[反正切函数的应用]是一个求函数最值的问题，要配合数学知识解决。[聪明的打字员]是广度优先搜索问题。[陨石的秘密]是一个树形动态规划的问题，需要仔细思考。[食物链]用到了并差集。[  炮兵阵地]是个不易看出的动态规划问题。[方程的解数]是搜索问题，需要用哈希表来优化。

[反正切函数的应用]

根据题中公式，可以推出 a=(b*c-1)/(b+c)。由此得出c=(a*b+1)/(b-a)。因为b,c均为正整数，所以b>a。

我们要求b+c最小，设函数y=f(x)，自变量x为b的取值，但不限于正整数。则有

  • f(x) = (a*x+1)/(x-a) + x = a + ((1+a^2)/(x-a)) + x

对f(x)求导，得导数

  • f’(x)=1-(1+a^2)/(x-a)^2

f’(x)=0 得出 x = a+(a^2+1)^0.5 或 x = a-(a^2+1)^0.5，由于x>0，取 x = a+(a^2+1)^0.5。

且x > a+(a^2+1)^0.5时，f’(x)>0，x < a+(a^2+1)^0.5时，f’(x)<0，所以当x = a+(a^2+1)^0.5时，f(x)取得最小值。

由于b和c都是正整数，只需在x一边寻找距离x最近的整数b,c，b+c即要求的最小值。

?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

/*
 * Problem: NOI2001 arctan
 * Author: Guo Jiabao
 * Time: 2009.3.21 14:18
 * State: Solved
 * Memo: 函数最值问题
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
int a,b,c,Ans=0x7FFFFFFF;
int main()
{
	freopen("arctan.in","r",stdin);
	freopen("arctan.out","w",stdout);
	scanf("%d",&a);
	double t=ceil(a+sqrt((double)a*a+1));
	for (;;t--)
	{
		b=(int)(t+0.1);
		long long q=a;
		q=q*b+1;
		if (q%(b-a)==0)
		{
			c=q/(b-a);
			Ans=b+c;
			break;
		}
	}
	printf("%d\n",Ans);
	return 0;
}

[聪明的打字员]

简单的广搜题，对于每个状态，直接按照规则扩展6状态，开一个哈希表判重，直到搜索到结果为止。

?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

/*
 * Problem: NOI2001 clever
 * Author: Guo Jiabao
 * Time: 2009.3.17 13:37
 * State: Solved
 * Memo: BFS
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int LIM=1000000;
using namespace std;
struct state
{
	int s,step,pos;
};
bool used[LIM][7];
int S,T;
int Q_size,Q_head,Q_tail;
state Q[LIM];
state start;
void init()
{
	freopen("clever.in","r",stdin);
	freopen("clever.out","w",stdout);
	scanf("%d%d",&S,&T);
	start.s=S;
	start.pos=1;
	start.step=0;
	Q_head=-1;Q_tail=0;Q_size=0;
}
void Answer(int ans)
{
	printf("%d\n",ans);
	exit(0);
}
void Q_ins(state p)
{
	if (used[p.s][p.pos]) return;
	used[p.s][p.pos]=true;
	if (p.s==T) Answer(p.step);
	Q_size++;
	if (++Q_head==LIM) Q_head=0;
	Q[Q_head]=p;
}
state Q_pop()
{
	state r=Q[Q_tail];
	Q_size--;
	if (++Q_tail==LIM) Q_tail=0;
	return r;
}
void BFS()
{
	state u,v;
	int pos[7],su,sv,tim,p,i;
	Q_ins(start);
	while (Q_size)
	{
		u=Q_pop();
		su=sv=u.s;
		p=u.pos;
		tim=LIM;
		for (i=1;i<=p;i++)
			tim/=10;
		for (i=6;i>=1;i--)
		{
			pos[i]=sv%10;
			sv/=10;
		}
		if (p>1) //swap0
		{
			sv=su;
			sv-=100000*pos[1] + tim*pos[p];
			sv+=tim*pos[1] + 100000*pos[p];
			v.pos=u.pos;
			v.step=u.step+1;
			v.s=sv;
			Q_ins(v);
		}
		if (p<6) //swap1
		{
			sv=su;
			sv-=pos[6] + tim*pos[p];
			sv+=tim*pos[6] + pos[p];
			v.pos=u.pos;
			v.step=u.step+1;
			v.s=sv;
			Q_ins(v);
		}
		if (pos[p]!=9) //up
		{
			sv=su;
			sv+=tim;
			v.pos=u.pos;
			v.step=u.step+1;
			v.s=sv;
			Q_ins(v);
		}
		if (pos[p]!=0) //down
		{
			sv=su;
			sv-=tim;
			v.pos=u.pos;
			v.step=u.step+1;
			v.s=sv;
			Q_ins(v);
		}
		if (p>1) //left
		{
			v.s=u.s;
			v.pos=u.pos-1;
			v.step=u.step+1;
			Q_ins(v);
		}
		if (p<6) //right
		{
			v.s=u.s;
			v.pos=u.pos+1;
			v.step=u.step+1;
			Q_ins(v);
		}
	}
}
int main()
{
	init();
	BFS();
	return 0;
}

[陨石的秘密]

容易看出是动态规划，但是状态转移方程容易考虑不周全。

题目中样例的8种方案为

{[]()} {()[]} {}[()] [()]{} []{()} {()}[] (){[]} {[]}()

可以看出每个SS表达式都可以看成由几个小的SS组成，组成方式可能是嵌套或者连接。如果是嵌套（包括仅1层），我们把这个嵌套体看作一个整体部分，称为一个组。则每个SS表达式都是由几个组连接而成了。

设定 F[p1,p2,p3,d]为深度不超过d，包含p1个{}，p2个[],p3个()的SS表达式的可能组成的方案数。S[p1,p2,p3,d]为深度不超过d，包含p1个{}，p2个[],p3个()的一个组的可能组成的方案数。

则状态转移方程为

S[p1,p2,p3,d]=
{
	0 (p1==p2==p3==0)
	F[p1-1,p2,p3,d-1] (p1>=1)
	F[p1,p2-1,p3,d-1] (p1==0 && p2>=1)
	F[p1,p2,p3-1,d-1] (p1==0 && p2==0 && p3>=1)
}

F[p1,p2,p3,d]=Σ(S[x1,x2,x3,d]*F[p1-x1,p2-x2,p3-x3,d]) (0<=x1<=p1,0<=x2<=p2,0<=x3<=p3且x1,x2,x3不同时为0)

初始条件

  • F[0,0,0,i]=1 (0<=i<=D)

最终的结果就是

  • F[L1,L2,L3,D]-F[L1,L2,L3,D-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

/* 
 * Problem: NOI2001 secret
 * Author: Guo Jiabao
 * Time: 2009.3.18 13:54
 * State: Solved
 * Memo: 动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXL=11,MAXD=31,MOD=11380;
using namespace std;
int L1,L2,L3,D,Ans;
int F[MAXL][MAXL][MAXL][MAXD];
int single(int p1,int p2,int p3,int d);
int dp(int p1,int p2,int p3,int d);
void init()
{
	freopen("secret.in","r",stdin);
	freopen("secret.out","w",stdout);
	scanf("%d%d%d%d",&L1,&L2,&L3,&D);
	int p1,p2,p3,d;
	for (d=0;d<=D;d++)
	{
		for (p1=0;p1<=L1;p1++)
			for (p2=0;p2<=L2;p2++)
				for (p3=0;p3<=L3;p3++)
					F[p1][p2][p3][d]=-1;
		F[0][0][0][d]=1;
	}
}
int single(int p1,int p2,int p3,int d)
{
	if (p1>=1)
		return dp(p1-1,p2,p3,d-1);
	else if (p1==0 && p2>=1)
		return dp(p1,p2-1,p3,d-1);
	else
		return dp(p1,p2,p3-1,d-1);
}
int dp(int p1,int p2,int p3,int d)
{
	if (d<0) return 0;
	if (F[p1][p2][p3][d]==-1)
	{
		int x1,x2,x3,y1,y2,y3;
		F[p1][p2][p3][d]=0;
		for (x1=0;x1<=p1;x1++)
			for (x2=0;x2<=p2;x2++)
				for (x3=0;x3<=p3;x3++)
				{
					y1=p1-x1;y2=p2-x2;y3=p3-x3;
					if (x1+x2+x3==0) continue;
					F[p1][p2][p3][d]+=single(x1,x2,x3,d)*dp(y1,y2,y3,d)%MOD;
					F[p1][p2][p3][d]%=MOD;
				}
	}
	return F[p1][p2][p3][d];
}
int main()
{
	init();
	Ans=(dp(L1,L2,L3,D)-dp(L1,L2,L3,D-1)+MOD)%MOD;
	printf("%d\n",Ans);
	return 0;
}

[食物链]

这道题真是个并差集的典型应用问题。由于判断真假总是根据前面得到的关系，在某时关系不是完全的，所以不能直接判断a,b究竟是哪个物种，但是可以知道部分的关系。

很显然，合法的关系都是三角形环，如果a,b同属于一个环内，那么它们的关系是可以直接判断的。如果不属于同一环，因为不与前面矛盾，就认 为是正确的，然后把a,b所在的两个环合并。建立一个并差集，表示每个生物所属的物种类型。对于物种i，定义prev[i]为可以吃掉i的物种类 型，next[i]为i可以吃掉的物种类型。初始时，每个物种i对应一个单独的类型，并且引入两个虚节点prev[i]和next[i]，可分别为一个单 独的类型。

合并两个环时，对于D=1，a与b为同一物种，分别把(a,b),(prev[a],prev[b]),(next[a],next[b])依次合并。

对于D=2，a可以吃掉b，则分别把(next[a],b),(a,prev[b]),(prev[a],next[b])依次合并。

?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

/* 
 * Problem: NOI2001
 * Author: Guo Jiabao
 * Time: 2009.3.13 13:28
 * State: Solved
 * Memo: 并差集 等价类判断
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=50001;
struct UFS
{
	int f[MAXN*3];
	int getroot(int a)
	{
		int t,r=a;
		while (f[r]!=r) r=f[r];
		while (f[a]!=a) {t=f[a];f[a]=r;a=t;}
		return r;
	}
	bool judge(int a,int b){return getroot(a)==getroot(b);}
	void merge(int a,int b){f[getroot(b)]=getroot(a);}
}U;
using namespace std;
int N,M,Fake;
int prev[MAXN*3],next[MAXN*3];
void init()
{
	int i,p,n;
	freopen("eat.in","r",stdin);
	freopen("eat.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
	{
		p=N+i;n=p+N;
		U.f[i]=i;U.f[p]=p;U.f[n]=n;
		prev[i]=p;next[i]=n;prev[n]=i;
		next[n]=p;prev[p]=n;next[p]=i;
	}
}
bool relation(int d,int a,int b)
{
	if (d==1)
	{
		if (U.judge(a,b))
			return true;
		if (U.judge(prev[a],b) || U.judge(next[a],b))
			return false;
		U.merge(a,b);
		U.merge(prev[a],prev[b]);
		U.merge(next[a],next[b]);
	}
	else
	{
		if (U.judge(next[a],b))
			return true;
		if (U.judge(a,b) || U.judge(prev[a],b))
			return false;
		U.merge(next[a],b);
		U.merge(a,prev[b]);
		U.merge(prev[a],next[b]);
	}
	return true;
}
void solve()
{
	int i,d,a,b;
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d",&d,&a,&b);
		if (a>N || b>N || (d==2 && a==b) ||!relation(d,a,b))
			Fake++;
	}
}
int main()
{
	init();
	solve();
	printf("%d\n",Fake);
	return 0;
}

[炮兵阵地]

较难看出的动态规划问题。注意到数据范围N≤100；M≤10，发现每行的宽度都不大，所以可以考虑把一行看成一个状态，表示该行的布置方案。每行的布置方案可以预先处理出，由数学知识可以算出，每行最多的布置方案数也不过60个而已。

状态设定

F[i,a,b]为前i行，第i行的方案为A[a]，第i-1行的方案为A[b]的最大炮兵数。

状态转移方程

  • F[i,a,b]=Max{ F[i-1,b,c] + P[a] }

其中c为i-2行的布置方案，a,b,c应保证互不冲突，即放置方案中炮兵都在平地上，且不会互相攻击到。

目标结果

  • Ans=Max{F[N,a,b]}
?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

/* 
 * Problem: NOI2001 cannon
 * Author: Guo Jiabao
 * Time: 2009.3.20 17:54
 * State: Solved
 * Memo: 动态规划 位表示状态
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=101,MAXM=11,MAXA=61;
using namespace std;
int N,M,Ans,AC;
bool used[MAXN];
int F[MAXN][MAXA][MAXA];
int A[MAXA],C[MAXA],Pla[MAXN];
void init()
{
	int i,j;
	char c;
	freopen("cannon.in","r",stdin);
	freopen("cannon.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
	{
		do c=getchar(); while(c==10 || c==13);
		ungetc(c,stdin);
		Pla[i]=0;
		for (j=1;j<=M;j++)
			if ((c=getchar())=='H')
				Pla[i]+=1<<(j-1);
	}
}
inline int Max(int a,int b)
{
	return a>b?a:b;
}
void dynamic()
{
	int i,j,k,l,x,y,z,p,q;
	for (i=2,j=1;j<=AC;j++)
	{
		x=A[j];
		p=C[j];
		if ((x&Pla[1])==0)
		for (k=1;k<=AC;k++)
		{
			y=A[k];
			q=C[k];
			if ((y&Pla[i])==0 && (x&y)==0)
				F[i][k][j]=p+q;
			if (F[i][j][k] > Ans)
				Ans = F[i][j][k];
		}
	}
	for (i=3;i<=N;i++)
	{
		for (j=1;j<=AC;j++)
		{
			x=A[j];	p=C[j];
			if ((x&Pla[i])==0)
				for (k=1;k<=AC;k++)
				{
					y=A[k];
					if ((y&Pla[i-1])==0 && (x&y)==0)
						for (l=1;l<=AC;l++)
						{
							z=A[l];
							if ((z&Pla[i-2])==0 && ((y|z)&x)==0)
								F[i][j][k]=Max(F[i][j][k],F[i-1][k][l] + p);
						}
					if (F[i][j][k] > Ans)
						Ans = F[i][j][k];
				}
		}
	}
}
void arrange(int p)
{
	if (p>M)
	{
		int r=0,c=0;
		for (int i=1;i<=M;i++)
			if (used[i])
			{
				c++;
				r+=1<<(i-1);
			}
		AC++;
		A[AC]=r;
		C[AC]=c;
		return ;
	}
	used[p]=true;
	arrange(p+3);
	used[p]=false;
	arrange(p+1);
}
void solve()
{
	arrange(1);
	dynamic();
}
int main()
{
	init();
	solve();
	printf("%d\n",Ans);
	return 0;
}

[方程的解数]

经典的搜索问题，方法是搜索每个x的所有可能值[1,M]，判断符合条件的解的个数。但是对于N=6，搜索量高达11390625000000，显然会超时。

我们不妨把等式变形，对于N项，把后N/2项移到等式右边，则移过去的项的k值全部取相反数。对于左边剩下的N/2项，搜索x的所有可能 值，计算左边式子的值，并插入到哈希表中。然后再对于右边的N-2项，搜索x的所有可能值，计算左边式子的值，然后再哈希表中查找与之相等的值的个数，加 到结果上。

插入到哈希表时先把绝对值Mod一个大质数，我选的是4000037，然后挂链解决冲突。为了提高效率，在哈希表的每个位置上我都建立了一个Treap，这样解决冲突时就能更快得找到了。

做这道题起初我试图直接用一个Treap存储所有的算式可能值，但是这样做会超时。通过使用哈希表，使数据平均分布了许多。哈希表和平衡树，或者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
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

/* 
 * Problem: NOI2001 equation1
 * Author: Guo Jiabao
 * Time: 2009.3.21 16:15
 * State: Solved
 * Memo: 搜索 + Hash +Treap判重
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=7,MAXM=151,MAXP=7,MOD=4000037;
const bool LEFT=true,RIGHT=false;
using namespace std;
struct TTreap
{
	struct Treap_node
	{
		Treap_node *left,*right;
		int value,weight,fix;
		Treap_node(int v):value(v),weight(1)
		{
			left=right=0;
			fix=rand();
		}
	};
	Treap_node *root;
	TTreap():root(0){}
	inline void rotate_left(Treap_node *&p)
	{
		Treap_node *q=p->right;
		p->right=q->left;
		q->left=p;
		p=q;
	}
	inline void rotate_right(Treap_node *&p)
	{
		Treap_node *q=p->left;
		p->left=q->right;
		q->right=p;
		p=q;
	}
	void insert(Treap_node *&p,int value)
	{
		if (!p)
			p=new Treap_node(value);
		else if (value == p->value)
			p->weight++;
		else if (value < p->value)
		{
			insert(p->left,value);
			if (p->left->fix < p->fix)
				rotate_right(p);
		}
		else
		{
			insert(p->right,value);
			if (p->right->fix < p->fix)
				rotate_left(p);
		}
	}
	int find(Treap_node *p,int value)
	{
		if (!p)
			return 0;
		else if (value == p->value)
			return p->weight;
		else if (value < p->value)
			return find(p->left,value);
		else
			return find(p->right,value);
	}
};
struct item
{
	int k,p,x;
}I[MAXN];
int N,LIM,Mid,Ans;
int POW[MAXM][MAXP];
TTreap Hash[MOD];
bool L;
void init()
{
	freopen("equation1.in","r",stdin);
	freopen("equation1.out","w",stdout);
	scanf("%d%d",&N,&LIM);
	Mid=N/2;
	for (int i=1;i<=N;i++)
	{
		scanf("%d%d",&I[i].k,&I[i].p);
		if (i>Mid)
			I[i].k=-I[i].k;
	}
	srand(9112);
}
inline int power(int x,int p)
{
	if (!POW[x][p])
	{
		POW[x][p]=1;
		for (int i=1;i<=p;i++)
			POW[x][p]*=x;
	}
	return POW[x][p];
}
int compute(int a,int b)
{
	int rs=0,i;
	for (i=a;i<=b;i++)
		rs+=power(I[i].x,I[i].p)*I[i].k;
	return rs;
}
inline int Abs(int a) {return a<0?-a:a;}
void search(int e)
{
	int i,H;
	if (L && e>Mid )
	{
		i=compute(1,Mid);
		H=Abs(i)%MOD;
		Hash[H].insert(Hash[H].root,i);
	}
	else if (!L && e>N)
	{
		i=compute(Mid+1,N);
		H=Abs(i)%MOD;
		int a=Hash[H].find(Hash[H].root,i);
		Ans+=a;
	}
	else
		for (i=1;i<=LIM;i++)
		{
			I[e].x=i;
			search(e+1);
		}
}
void solve()
{
	L=LEFT;
	search(1);
	L=RIGHT;
	search(Mid+1);
}
int main()
{
	init();
	solve();
	printf("%d\n",Ans);
	return 0;
}

反正切函数的应用

Image:Arctan.gif

输入文件

输入文件中只有一个正整数a ，其中1<=a<=60000 。

输出文件

输出文件中只有一个整数，为b + c的值。
输入样例

1

输出样例

5

聪明的打字员

阿兰是某机密部门的打字员，她现在接到一个任务：需要在一天之内输入几百个长度固定为6的密码。当然，她希望输入的过程中敲击键盘的总次数越少越好。

不幸的是，出于保密的需要，该部门用于输入密码的键盘是特殊设计的，键盘上没有数字键，而只有以下六个键：Swap0, Swap1, Up, Down, Left, Right，为了说明这6个键的作用，我们先定义录入区的6个位置的编号，从左至右依次为1，2，3，4，5，6。下面列出每个键的作用：

  • Swap0：按Swap0，光标位置不变，将光标所在位置的数字与录入区的1号位置的数字（左起第一个数字）交换。如果光标已经处在录入区的1号位置，则按Swap0键之后，录入区的数字不变；
  • Swap1：按Swap1，光标位置不变，将光标所在位置的数字与录入区的6号位置的数字（左起第六个数字）交换。如果光标已经处在录入区的6号位置，则按Swap1键之后，录入区的数字不变；
  • Up：按Up，光标位置不变，将光标所在位置的数字加1（除非该数字是9）。例如，如果光标所在位置的数字为2，按Up之后，该处的数字变为3；如果该处数字为9，则按Up之后，数字不变，光标位置也不变；
  • Down：按Down，光标位置不变，将光标所在位置的数字减1（除非该数字是0），如果该处数字为0，则按Down之后，数字不变，光标位置也不变；
  • Left：按Left，光标左移一个位置，如果光标已经在录入区的1号位置（左起第一个位置）上，则光标不动；
  • Right：按Right，光标右移一个位置，如果光标已经在录入区的6号位置（左起第六个位置）上，则光标不动。

当然，为了使这样的键盘发挥作用，每次录入密码之前，录入区总会随机出现一个长度为6的初始密码，而且光标固定出现在1号位置上。当巧妙地使用上述六个特殊键之后，可以得到目标密码，这时光标允许停在任何一个位置。 现在，阿兰需要你的帮助，编写一个程序，求出录入一个密码需要的最少的击键次数。

输入文件

文件仅一行，含有两个长度为6的数，前者为初始密码，后者为目标密码，两个密码之间用一个空格隔开。

输出文件

文件仅一行，含有一个正整数，为最少需要的击键次数。

输入样例

123456 654321

输出样例

11

样例说明：

初始密码是123456，光标停在数字1上。对应上述最少击键次数的击键序列为：

Image:Clever.gif

最少的击键次数为11。

陨石的秘密

公元11380年，一颗巨大的陨石坠落在南极。于是，灾难降临了，地球上出现了一系列反常的现象。当人们焦急万分的时候，一支中国科学家组成的南极考察队赶到了出事地点。经过一番侦察，科学家们发现陨石上刻有若干行密文，每一行都包含5个整数：

1 1 1 1 6
0 0 6 3 57
8 0 11 3 2845

著名的科学家SS发现，这些密文实际上是一种复杂运算的结果。为了便于大家理解这种运算，他定义了一种SS表达式：

  1. SS表达式是仅由‘{’，‘}’，‘[’，‘]’，‘（’，‘）’组成的字符串。
  2. 一个空串是SS表达式。
  3. 如果A是SS表达式，且A中不含字符‘{’，‘}’，‘[’，‘]’，则(A)是SS表达式。
  4. 如果A是SS表达式，且A中不含字符‘{’，‘}’，则[A]是SS表达式。
  5. 如果A是SS表达式，则{A}是SS表达式。
  6. 如果A和B都是SS表达式，则AB也是SS表达式。

例如

  • ()(())[]
  • {()[()]}
  • {{[[(())]]}}

都是SS表达式。

而

  • ()([])()
  • [()

不是SS表达式。

一个SS表达式E的深度D(E)定义如下：

例如(){()}[]的深度为2。

密文中的复杂运算是这样进行的：

设密文中每行前4个数依次为L1，L2，L3，D，求出所有深度为D，含有L1对{}，L2对[]，L3对()的SS串的个数，并用这个数对当前的年份11380求余数，这个余数就是密文中每行的第5个数，我们称之为“神秘数”。

密文中某些行的第五个数已经模糊不清，而这些数字正是揭开陨石秘密的钥匙。现在科学家们聘请你来计算这个神秘数。

输入文件

共一行，4个整数L1，L2，L3，D。相邻两个数之间用一个空格分隔。（0≤L1≤10，0≤L2≤10，0≤L3≤10，0≤D≤30）

输出文件

共一行，包含一个整数，即神秘数。

输入样例

1 1 1 2

输出样例

8

食物链

动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。

现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这N个动物所构成的食物链关系进行描述：

  • 第一种说法是“1 X Y”，表示X和Y是同类。
  • 第二种说法是“2 X Y”，表示X吃Y。

此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

  1. 当前的话与前面的某些真的话冲突，就是假话；
  2. 当前的话中X或Y比N大，就是假话；
  3. 当前的话表示X吃X，就是假话。

你的任务是根据给定的N（1<=N<=50,000）和K句话（0<=K<=100,000），输出假话的总数。

输入文件

第一行是两个整数N和K，以一个空格分隔。

以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。

  • 若D=1，则表示X和Y是同类。
  • 若D=2，则表示X吃Y。

输出文件

只有一个整数，表示假话的数目。

输入样例

输入文件

100 7
1 101 1
2 1 2
2 2 3
2 3 3
1 1 3
2 3 1
1 5 5

输出样例

3

样例说明

对7句话的分析

  • 1 101 1 假话
  • 2 1 2 真话
  • 2 2 3 真话
  • 2 3 3 假话
  • 1 1 3 假话
  • 2 3 1 真话
  • 1 5 5 真话

炮兵阵地

司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用“H” 表示），也可能是平原（用“P”表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击 范围如图中黑色区域所示：

如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。

现在，将军们规划如何部署炮兵部队，在防止误伤的前提下（保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内），在整个地图区域内最多能够摆放多少我军的炮兵部队。

Image:Cannon.gif

输入文件

文件的第一行包含两个由空格分割开的正整数，分别表示N和M；

接下来的N行，每一行含有连续的M个字符（‘P’或者‘H’），中间没有空格。按顺序表示地图中每一行的数据。N≤100；M≤10。

输出文件

文件仅在第一行包含一个整数K，表示最多能摆放的炮兵部队的数量。

输入样例

5 4
PHPP
PPHH
PPPP
PHPP
PHHP

输出样例

6

方程的解数

问题描述

已知一个n元高次方程：

Image:Equation1.gif

其中：x1, x2, …,xn是未知数，k1,k2,…,kn是系数，p1,p2,…pn是指数。且方程中的所有数均为整数。

假设未知数1≤ xi ≤M, i=1,,,n，求这个方程的整数解的个数。

输入文件

文件的第1行包含一个整数n。第2行包含一个整数M。第3行到第n+2行，每行包含两个整数，分别表示ki和pi。两个整数之间用一个空格隔开。第3行的数据对应i=1，第n+2行的数据对应i=n。
输出文件

文件仅一行，包含一个整数，表示方程的整数解的个数。

输入样例

3
150
1 2
-1 2
1 2

输出样例

178

约束条件

1<=n<=6；1<=M<=150；

Image:Equation2.gif

方程的整数解的个数小于2^31。

★本题中，指数Pi(i=1,2,……,n)均为正整数。

Maybe you like

]]> http://www.byvoid.com/blog/noi-2001-solution/feed/ 3 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 POI 2000 Repetitions 最长公共子串 http://www.byvoid.com/blog/poi-2000-pow/ http://www.byvoid.com/blog/poi-2000-pow/#comments Mon, 05 Jan 2009 06:11:08 +0000 BYVoid http://www.byvoid.com/blog/?p=789 这是一个经典的求多个串的最长公共子串的问题。如果设字符串的个数为N，每个串最大的长度为L，则这道题有时间复杂度为O(N*L^4),O(N*L^3),O(N*L^2)和O(N*L)的算法。

最简单的想法是对于某一个串，取出它的所有的L^2个子串，然后再在其他每一个字符串中进行朴素的匹配，很显然是O(N*L^4)。如果生搬硬套地用KMP，那么是O(N*L^3)的算法。仔细一想，其实枚举所有的L^2个子串是完全没有必要的，仅仅取出某一个串的L个后缀，对于每一个后缀在其他的所有串中部分匹配即可，用朴素匹配就是O(N*L^3)，用KMP就是O(N*L^2)，可以通过所有测试点。

另外，如果用Trie，把每个串的所有后缀全部插入Trie树中，标记每个节点所属的原串。找到最深的属于所有串的节点，它的最大深度就是最长公共前缀，时间复杂度依然是O(N*L^2)，但是会有一点超时。

对于这道题来说，对某个串的每个后缀进行部分模式匹配，O(N*L^2)的算法就可以了。如果想进一步探究，恐怕就要用到后缀树了，广义后缀树求最长公共子串有O(N*L)的算法，我还没有学过，现在正在苦读中。

下面是我的O(N*L^2)的KMP。

?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

/* 
 * Problem: POI2000 pow
 * Author: Guo Jiabao
 * Time: 2009.1.5 13:53
 * State: Solved 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
 
const int MAXL=2002;
const int MAXN=6;
 
int N,Ans,Max;
char S[MAXN][MAXL];
int Flee[MAXL];
 
void init()
{
	freopen("pow.in","r",stdin);
	freopen("pow.out","w",stdout);
	scanf("%d",&N);
	for (int i=1;i<=N;i++)
	{
		S[i][0]=1;
		scanf("%sn",S[i]+1);
	}
}
 
void KMP(char *A,char *B)
{
	int i,j,La,Lb;
	La=strlen(A+1);
	Lb=strlen(B+1);
	Flee[1]=0;
	for (j=0,i=2;i<=Lb;i++)
	{
		while (j>0 && B[j+1]!=B[i]) j=Flee[j];
		if (B[j+1]==B[i]) j++;
		Flee[i]=j;
	}
	for (j=0,i=1;i<=La;i++)
	{
		while (j>0 && B[j+1]!=A[i]) j=Flee[j];
		if (B[j+1]==A[i]) j++;
		if (j>Max)
			Max=j;
	}
}
 
void solve()
{
	int i,Min;
	char *s;
	for (s=S[1];*s;s++)
	{
		Min=2000;
		for (i=2;i<=N;i++)
		{
			Max=0;
			KMP(S[i],s);
			if (Max < Min)
				Min=Max;
		}
		if (Min>Ans)
			Ans=Min;
	}
}
 
int main()
{
	init();
	solve();
	printf("%d",Ans);
	return 0;
}

最长公共子串

给出几个由小写字母构成的单词，求它们最长的公共子串的长度。

任务

  • 从文件中读入单词
  • 计算最长公共子串的长度
  • 输出结果到文件

输入

文件的第一行是整数 n，1<=n<=5，表示单词的数量。接下来n行每行一个单词，只由小写字母组成，单词的长度至少为1，最大为2000。

输出：

仅一行，一个整数，最长公共子串的长度。

样例输入：

3
abcb
bca
acbc

样例输出：

2

Maybe you like

]]> http://www.byvoid.com/blog/poi-2000-pow/feed/ 1