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 有向图强连通分量的Tarjan算法 http://www.byvoid.com/blog/scc-tarjan/ http://www.byvoid.com/blog/scc-tarjan/#comments Tue, 14 Apr 2009 23:56:51 +0000 BYVoid http://www.byvoid.com/blog/?p=1235 [有向图强连通分量]

在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。

下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分别是两个强连通分量。

image

直接根据定义，用双向遍历取交集的方法求强连通分量，时间复杂度为O(N^2+M)。更好的方法是Kosaraju算法或Tarjan算法，两者的时间复杂度都是O(N+M)。本文介绍的是Tarjan算法。

[Tarjan算法]

Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。

定义DFN(u)为节点u搜索的次序编号(时间戳)，Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。由定义可以得出，

?View Code CPP
Low(u)=Min
{
    DFN(u),
    Low(v),(u,v)为树枝边，u为v的父节点
    DFN(v),(u,v)为指向栈中节点的后向边(非横叉边)
}

当DFN(u)=Low(u)时，以u为根的搜索子树上所有节点是一个强连通分量。

算法伪代码如下

?View Code CPP
tarjan(u)
{
	DFN[u]=Low[u]=++Index                      // 为节点u设定次序编号和Low初值
	Stack.push(u)                              // 将节点u压入栈中
	for each (u, v) in E                       // 枚举每一条边
		if (v is not visted)               // 如果节点v未被访问过
			tarjan(v)                  // 继续向下找
			Low[u] = min(Low[u], Low[v])
		else if (v in S)                   // 如果节点v还在栈内
			Low[u] = min(Low[u], DFN[v])
	if (DFN[u] == Low[u])                      // 如果节点u是强连通分量的根
		repeat
			v = S.pop                  // 将v退栈，为该强连通分量中一个顶点
			print v
		until (u== v)
}

接下来是对算法流程的演示。

从节点1开始DFS，把遍历到的节点加入栈中。搜索到节点u=6时，DFN[6]=LOW[6]，找到了一个强连通分量。退栈到u=v为止，{6}为一个强连通分量。

image

返回节点5，发现DFN[5]=LOW[5]，退栈后{5}为一个强连通分量。

image

返回节点3，继续搜索到节点4，把4加入堆栈。发现节点4向节点1有后向边，节点1还在栈中，所以LOW[4]=1。节点6已经出栈，(4,6)是横叉边，返回3，(3,4)为树枝边，所以LOW[3]=LOW[4]=1。

image

继续回到节点1，最后访问节点2。访问边(2,4)，4还在栈中，所以LOW[2]=DFN[4]=5。返回1后，发现DFN[1]=LOW[1]，把栈中节点全部取出，组成一个连通分量{1,3,4,2}。

image

至此，算法结束。经过该算法，求出了图中全部的三个强连通分量{1,3,4,2},{5},{6}。

可以发现，运行Tarjan算法的过程中，每个顶点都被访问了一次，且只进出了一次堆栈，每条边也只被访问了一次，所以该算法的时间复杂度为O(N+M)。

求有向图的强连通分量还有一个强有力的算法，为Kosaraju算法。Kosaraju是基于对有向图及其逆图两次DFS的方法，其时间复杂度也是O(N+M)。与Trajan算法相比，Kosaraju算法可能会稍微更直观一些。但是Tarjan只用对原图进行一次DFS，不用建立逆图，更简洁。在实际的测试中，Tarjan算法的运行效率也比Kosaraju算法高30%左右。此外，该Tarjan算法与求无向图的双连通分量(割点、桥)的Tarjan算法也有着很深的联系。学习该Tarjan算法，也有助于深入理解求双连通分量的Tarjan算法，两者可以类比、组合理解。

求有向图的强连通分量的Tarjan算法是以其发明者Robert Tarjan命名的。Robert Tarjan还发明了求双连通分量的Tarjan算法，以及求最近公共祖先的离线Tarjan算法，在此对Tarjan表示崇高的敬意。

附：tarjan算法的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
36
37
38
39

void tarjan(int i)
{
	int j;
	DFN[i]=LOW[i]=++Dindex;
	instack[i]=true;
	Stap[++Stop]=i;
	for (edge *e=V[i];e;e=e->next)
	{
		j=e->t;
		if (!DFN[j])
		{
			tarjan(j);
			if (LOW[j]<LOW[i])
				LOW[i]=LOW[j];
		}
		else if (instack[j] && DFN[j]<LOW[i])
			LOW[i]=DFN[j];
	}
	if (DFN[i]==LOW[i])
	{
		Bcnt++;
		do
		{
			j=Stap[Stop--];
			instack[j]=false;
			Belong[j]=Bcnt;
		}
		while (j!=i);
	}
}
void solve()
{
	int i;
	Stop=Bcnt=Dindex=0;
	memset(DFN,0,sizeof(DFN));
	for (i=1;i<=N;i++)
		if (!DFN[i])
			tarjan(i);
}

[参考资料]

BYVoid 原创作品，转载请注明。

Maybe you like

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

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

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

[最佳游览]

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

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

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

[竞赛排名]

这也是一道送分题，数据很小方法很明确，就是排序。关键在于看清式子，注意关系算出各个量后直接排序就行了。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

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

[积木游戏]

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

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

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

状态转移方程

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

初始条件为

  • F[i,j,k]=负无穷大;(0<=i<=N,0<=j<=M,0<=k<=2)
  • F[0,0,0]=0;
?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

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

[最优乘车]

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

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

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

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

[卫星覆盖]

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

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

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

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

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

则A、B相交。

上述方法的时间复杂度是O(N^3)，是很宽松的。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

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

[文件匹配]

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

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

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

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

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

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

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

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

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

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

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

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

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

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

判断函数就是

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

附上原题

最佳游览

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

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

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

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

输入输出

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

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

样例

INPUT.TXT

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

OUTPUT.TXT

124

竞赛排名

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

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

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

排名规则如下:

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

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

输入输出

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

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

样例

INPUT.TXT

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

OUTPUT.TXT

1
3
2

积木游戏

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

Image:Buildinggame.PNG

游戏规则如下：

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

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

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

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

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

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

输入输出

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

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

样例

INPUT.TXT

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

OUTPUT.TXT

24

最优乘车

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

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

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

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

输入输出

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

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

样例

INPUT.TXT

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

OUTPUT.TXT

2

卫星覆盖

Cover

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

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

Image:Satellitecover.png

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

输入输出

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

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

样例

INPUT.TXT

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

OUTPUT.TXT

1944

文件匹配

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

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

例如：

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

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

输入输出

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

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

样例

INPUT.TXT

EXCHANGE +
EXT +
HARDWARE +
MOUSE -
NETWORK -

OUTPUT.TXT

2
E*

Maybe you like

]]> http://www.byvoid.com/blog/noi-1997-solution/feed/ 3 POI 2001 Wandering flea trainers 跳舞蝇的教练 http://www.byvoid.com/blog/poi-2001-pch/ http://www.byvoid.com/blog/poi-2001-pch/#comments Thu, 05 Feb 2009 11:38:46 +0000 BYVoid http://www.byvoid.com/blog/?p=844 题上描述这种图是很特殊的，每个顶点只有一条指出去的有向边，而且一定存在一个环，哪怕是自环，从任意一个顶点出发，最终一定进入一个环。我们的任务的判断这样的两个图是否同构。

首先，这个图不一定是弱连通的，可能会有多个连通分量，我们需要考虑每个连通分量。每个连通分量中一定存在一个环，去掉环上的边以后，剩下 的是一个森林，每棵树都是内向树。实际上它是环状内向树森林。对于两个内向树，我们可以很容易地判断它们是否同构，于是我们有了解决问题的方法。

首先是两个内向树，如果它们同构，它们的括号序列一定相同，反之也成立。判断两个环状内向树森林同构，首先应该满足环的大小相同，如果两 个环的顶点数都不一样，那么它们一定不会同构。如果环大小相同，则需要枚举两个环上的对应点，然后判断以环上每个顶点为根的内向树是否都同构。用上述方法 可以判断两个连通分量是否同构，对于题中给的两个图，首先判断连通分量的个数是否相同，然后用搜索的方法确定一个对应关系，以此判断每个每对连通分量是否 同构。如果存在一种对应方案使得所有的连通分量通过，那么这两个图同构。

上述方法中，生成所有内向树括号序列需要O(N^2logN)时间(需要排序)，枚举每个环的对应关系需要O(N)，判断两个内向树括号 序列相同需要O(N)，枚举连通分量间的对应关系由于是搜索，尽管实际搜索的很少，但是从时间复杂度上分析仍然是O(N!)。每个文件有D个测试数据，于 是总的时间复杂度是O((N^2logN+N^2*N!)*D)。但是实际上这个时间复杂度由于全部从最坏情况考虑(实际上所有最坏的情况不可能同时达 到)，所以是相当悲观的估计。实际编程对于N<=2000，已经可以完全应付了。

在编程实现的时候，许多地方要用到链表，否则空间是不够用的。细节不容忽视。

关于内向树以及生成括号序列，请参看有向树与树的括号序列表示法。

?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

/* 
 * Problem: POI2001 pch
 * Author: Guo Jiabao
 * Time: 2009.2.5 14:05
 * State: Solved 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
using namespace std;
const int MAXN=4001,PERN=2000;
struct edge{int t;edge *next;};
struct sequence{int len;string s;};
struct subsq{int len;string *s;};
template <typename T> class linknode
{
	public:
		linknode *next;
		T s;
		linknode(T ts):next(0),s(ts){}
};
template <typename T> class linklist
{
	public:
		linknode<T> *f,*l;
		linklist():f(0),l(0){}
		void ins(T s)
		{
			if (l)l=l->next=new linknode<T>(s);
			else f=l=new linknode<T>(s);
		}
		void clear()
		{
			linknode<T> *a=f,*b;
			while (a){b=a;a=a->next;delete b;}
			f=l=0;
		}
};
int D,N,Ec,Bc,S1,S2;
int Bel[MAXN];//每个顶点所属连通分量
int TB[MAXN],TC; //暂存正向搜索的连通分量
linklist<int> Circle[MAXN]; //链表存储每个圈
bool inCircle[MAXN]; //记录每个节节点
bool used[MAXN]; //生成排列时DFS用到的记录数组
sequence seq[MAXN]; //每个子树的括号序列
int Cs[MAXN]; //每个圈的大小
edge E[MAXN*2];//边集的空间
edge *Ap[MAXN],*An[MAXN];//正图和逆图的邻接表
subsq S[MAXN];//暂存括号序列
 
void addedge(edge *&A,int t)
{
	if (A)
	{
		edge *t=A;
		A=&E[++Ec];
		A->next=t;
	}
	else
	{
		A=&E[++Ec];
		A->next=0;
	}
	E[Ec].t=t;
}
 
void init()
{
	int i,t;
	Ec=-1;Bc=0;
	memset(Ap,0,sizeof(Ap));
	memset(An,0,sizeof(An));
	scanf("%d",&N);
	for (i=1;i<=N;i++)
	{
		scanf("%d",&t);
		addedge(Ap[i],t);
		addedge(An[t],i);
		Bel[i]=0;
		seq[i].len=0;
		seq[i].s="";
		inCircle[i]=false;
	}
	for (i=PERN+1;i<=PERN+N;i++)
	{
		scanf("%d",&t);
		t+=PERN;
		addedge(Ap[i],t);
		addedge(An[t],i);
		Bel[i]=0;
		seq[i].len=0;
		seq[i].s="";
		inCircle[i]=false;
	}
}
 
void connect_dfs_n(int u) //逆向求连通分量
{
	Bel[u]=Bc;
	for (edge *k=An[u];k;k=k->next)
	{
		int v=k->t;
		if (!Bel[v])
			connect_dfs_n(v);
	}
}
 
int connect_dfs_p(int u) //正向求连通分量，并查找圈
{
	Bel[u]=Bc;
	TB[++TC]=u;
	int v=Ap[u]->t;
	if (!Bel[v])
	{
		int r=connect_dfs_p(v);
		if (r)
		{
			++Cs[Bc];
			Circle[Bc].ins(u);
			inCircle[u]=true;
			if (r==u)
				return 0;
			else
				return r;
		}
		else
			return 0;
	}
	else
	{
		++Cs[Bc];
		Circle[Bc].ins(u);
		inCircle[u]=true;
		if (u==v) v=0;
		return v;
	}
}
 
void connect(int A,int B)
{
	for (int i=A;i<=B;i++)
	{
		if (!Bel[i])
		{
			Bc++;
			Cs[Bc]=0;
			TC=0;
			connect_dfs_p(i);
			for (int j=1;j<=TC;j++)
				connect_dfs_n(TB[j]);
		}
	}
}
 
inline int cmp(const void *a,const void *b)
{
	return  ((subsq *)a)->s->compare(*(((subsq *)b)->s)) ;
}
 
void TreeSeq(int u)//求内向树序列
{
	linklist<subsq> LL;
	subsq T;
	int L=0;
	++seq[u].len;
	seq[u].s+='(';
	for (edge *k=An[u];k;k=k->next)
	{
		int v=k->t;
		if (inCircle[v]) continue;
		TreeSeq(v);
		T.s=&seq[v].s;
		T.len=seq[v].len;
		LL.ins(T);
	}
	for (linknode<subsq> *p=LL.f;p;p=p->next)
		S[++L]=p->s;
	qsort(S+1,L,sizeof(S[0]),cmp);
	for (int i=1;i<=L;i++)
	{
		seq[u].s+=*(S[i].s);
		seq[u].len+=S[i].len;
	}
	++seq[u].len;
	seq[u].s+=')';
	LL.clear();
}
 
bool compare(int a,int b)
{
	if (Cs[a]!=Cs[b]) return false; //圈大小不相等
	linknode<int> *k,*l,*pl;
	for (pl=Circle[b].f;pl;pl=pl->next) //枚举偏移量
	{
		l=pl;
		for (k=Circle[a].f;k;k=k->next)
		{
			int x=k->s,y=l->s;
			if (!(l=l->next)) l=Circle[b].f;
			if (seq[x].len!=seq[y].len || seq[x].s!=seq[y].s) //内向树序列不相同
				break;
		}
		if (!k)
			return true;
	}
	return false;
}
 
bool arrange_dfs(int k) //生成两图连通分量对应关系的排列
{
	if (k>S1)
		return true;
	for (int i=S1+1;i<=S2;i++)
		if (!used[i] && compare(k,i))
		{
			used[i]=true;
			bool b=arrange_dfs(k+1);
			used[i]=false;
			if (b) return true;
		}
	return false;
}
 
bool solve()
{
	int i,j;
	init();
	connect(1,N);S1=Bc;
	connect(1+PERN,N+PERN);S2=Bc;
	if (S1!=S2-S1) //1..S1为图1的连通分量 S1+1..S2为图2的连通分量
		return false; //两图连通分量个数不相等
	for (i=1;i<=S2;i++)
		for (linknode<int> *k=Circle[i].f;k;k=k->next)
			TreeSeq(k->s); //计算以每个圈上顶点为根的内向树括号序列
	return arrange_dfs(1);
}
 
void clear()
{
	for (int i=1;i<=S2;i++)
		Circle[i].clear();
}
 
int main()
{
	int i;
	freopen("pch.in","r",stdin);
	freopen("pch.out","w",stdout);
	scanf("%d",&D);
	for (i=1;i<=D;i++)
	{
		if (solve())
			printf("Tn");
		else
			printf("Nn");
		clear(); //清理 释放内存
	}
	return 0;
}

跳舞蝇的教练

Byteland一直以奇妙的跳舞蝇而闻名于世。驯养的苍蝇能和着音乐的节奏精确地做每一次飞跃。通常，训练者会在桌上放一排硬币，这些硬币的排列 并不按照特定的顺序。每枚硬币上都有一行题字：i→j，i是这枚硬币的编号，j是站在硬币i上的苍蝇下一步应该飞往的硬币编号。训练者在每个硬币上放一只 苍蝇，然后开始放音乐。那些苍蝇就跟着音乐的节拍开始跳舞，在每一拍中苍蝇都会直接跳到编号为j的硬币上。在舞蹈中，可能会出现多只苍蝇在同一硬币上的情 况。这样，跳舞蝇就会一起继续表演。假定有n只苍蝇，n枚硬币。则一旦确定了n枚硬币上的题字，那么这场表演也就确定了。然而，对硬币不同的设置也可能导 致相同的表演，只要我们把硬币按适当的顺序排列。 让我们先来看3枚硬币上的表演。如果表演是这样进行：从第一个硬币到第二个，第二个到第三个，第三个又回到第一个硬币（表示为1→2，2→3，3→1）。 具体表演是3只苍蝇绕圈跳跃，从不相遇。那么表演1→2，2→3，3→3，则是与其不同的。因为该表演为：两拍后，所有的苍蝇在第3枚硬币上相遇，然后一 直在原地跳跃。

但是，设置1→2，2→3，3→2，4→4和1→1、2→3、3→2、4→3就是同样的类型。如果你把前者的硬币从左到右排列，而把后者从右到左排列，就会看到相同的表演。

任务：

如果跳舞蝇的两次表演是相同的，就会使观众不满，请编写一个程序：

  • 从文件中读入测试任务的个数；
  • 对每一个测试任务，从PCH.IN中读入两组硬币设置，验证是否能把硬币按一定顺序排列，使跳舞蝇给出相同的表演；
  • 把结果写入文件。

输入：

文件的第一行是测试任务的个数d(1≤d≤100)，以下3*d行，每三行描述一个任务。三行中的第一行是一个整数 n(1≤n≤2000)，表示硬币的个数。后两行每行均为一套硬币的描述。格式为n个用空格分开的1…n范围内的整数，第i个整数表示硬币i上的苍蝇应该 飞向的硬币的编号。

输出：

对每个任务，均要在文件中输出一行，仅包含一个字母。如果可以按一定顺序排硬币使表演相同则输出“T”，否则输出“N”。

输入样例：

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

输出样例：

N
T

Maybe you like

]]> http://www.byvoid.com/blog/poi-2001-pch/feed/ 0 有向树与树的括号序列最小表示法 http://www.byvoid.com/blog/directed-tree-bracket-sequence/ http://www.byvoid.com/blog/directed-tree-bracket-sequence/#comments Thu, 05 Feb 2009 06:36:46 +0000 BYVoid http://www.byvoid.com/blog/?p=839 [有向树] 一个弱连通有向图，若去掉方向后得到一棵树，则称此有向图为一棵有向树，记为T。

[外向树] 若一个有向树T，有且只有一个顶点入度为0，其余顶点入度都为1，则称T为外向树。T中入度为0的节点被称为T的根节点，出度为0的节点被称为T的叶节点。每个节点的有向边指向的节点被称为该节点的子节点。

[内向树] 若一个有向树T，有且只有一个顶点出度为0，其余顶点出度都为1，则称T为内向树。T中出度为0的节点被称为T的根节点，入度为0的节点被称为T的叶节点。每个节点的有向边的反向边指向的节点被称为该节点的子节点。

外向树和内向树都是有根树。

e5a496e59091e6a091 e58685e59091e6a091
图1 图2

如上，图1为一棵外向树，图2为一棵内向树。

[树的括号序列最小表示法]

定义S[t]表示以t为根的子树的括号序列

S[t]=

{

‘(‘,’)’ (如果t为叶节点)

‘(‘,S[c1],S[c2],…,S[ck],’)’ (c1,c2,…,ck为t的k个子节点，S[c1],S[c2],…,S[ck]要按照字典序排列)

}

为了保证同构的树的括号序列表示具有唯一性，我们必须规定子树点的顺序。按照子树的括号序列的字典序就是一种不错的方法。

例如上述图2，它的括号序列最小表示就是((()()())())。

[有根树的同构]

对于一个有根树，我们可以通过比较他们的括号序列的最小表示，如果他们的括号序列最小表示完全相等，那么他们同构。

BYVoid 原创讲解，转载请注明。

Maybe you like

]]> http://www.byvoid.com/blog/directed-tree-bracket-sequence/feed/ 4