Beyond the Void » POI http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 POI 2001 Glodmine 金矿 http://www.byvoid.com/blog/poi-2001-kop/ http://www.byvoid.com/blog/poi-2001-kop/#comments Sat, 07 Feb 2009 09:26:45 +0000 BYVoid http://www.byvoid.com/blog/?p=849 发现坐标的范围很大，而点并不是很多，首先想到了离散化的方法。然后横向扫描每个带状的区间，对于每个带状区间，再纵向扫描其中点的个数。这种方法是最容易想到的，但是时间复杂度却高达O(N^2logN)。关键在于优化每次确定带状区间的纵向扫描。

显然对于确定的带状区间，我们扫描时只需考虑它们的纵坐标。如果我们把一个纵坐标为y的点描述成两个事件(y,1)和 (y+h+1,-1)，然后把所有事件按照第一关键字排序，定义S[i]为前i项事件的第二关键字之和，那么Max{S[i]}就是确定的带状区间内高度 为w的矩形最多覆盖到的点数。为什么是这样，我们可以想象有两个挡板，分别是y=A-h-1(下板)和y=A(上板)，从下向上移动挡板，从而确定一个矩 形。某个点的第一个事件为(y,1)，当上板A=y时，该点被覆盖，若A继续增大，使得A-h-1=y，该点就恰好离开了覆盖区域，反过来我们可以以为是 A=y+h+1，所以定义第二个事件为(y+h+1,-1)。这样，前i个事件的第二关键字和S[i]，就代表了矩形在某个位置时覆盖的点数。S[i]的 最大值就是确定的带状区间内最大的覆盖点数。

带状区间的左右扫描，也可以考虑成两个挡板之间的问题，首先确定挡板的初始位置在最左端，依次向右移动左右两个挡板。确定一个区间后，统 计点事件的最大前缀和成了最关键的问题。由于左右挡板是移动的，我们需要动态统计一个排序结构。于是我们想到了用平衡树，维护每个点事件的第一关键字(y 坐标)升序，并记录权。移动右挡板时，把右挡边新位置所在线上的所有点对应的两个点事件加入平衡树；移动左挡板时，把左挡板时，把左挡边所在线上的所有点 事件从平衡树中删除。

为了快速统计出最大的前缀和，在此基础上，我们还需要对于平衡树中每个节点维护其子树所有节点权值和，以及子树中最大的前缀和。定义p的权值为p.w，以节点p为根的子树的权值和为p.s，以节点p为根的子树的最大的前缀和为p.m，我们可以递推算出p.m的值。

p.m=Max{
	p.left.m; //最大前缀和的尾元素在左子树
	p.left.s+p.w; //最大前缀和的尾元素就是p
	p.left.s+p.w+p.right.m; //最大前缀和的尾元素在右子树
}

于是全部序列的最大前缀和就是根节点root.m。

于是得到的算法如下：

  1. 建立离散化坐标系;
  2. 左右扫描，确定带状区间，维护平衡树中节点;
  3. 统计对于确定带状区间，平衡树中元素最大的前缀和;

算法总的时间复杂度为O(NlogN)，可以解决问题了。编程中细节要注意，尤其是在于平衡树维护平衡性时要对节点m值重新计算。我用了 Treap，在插入一个点要旋转时，注意要先重新计算旋转到子树的点的m值，再计算子树根节点的m值。而删除仅仅懒惰删除即可，重要的是维护m值。

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

/* 
 * Problem: POI2001 kop
 * Author: Guo Jiabao
 * Time: 2009.2.7 16:16
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
using namespace std;
 
const int MAXN=15001;
struct point{int x,y;};
struct linknode{int s;linknode *next;};
class Treap_node
{
	public:
		Treap_node *left,*right;
		int fix,weight,sum,m,key;
		Treap_node(int tk,int w):key(tk),weight(w),sum(w),m(w){fix=rand();left=right=0;}
		inline int leftsum (){return left ?left ->sum:0;}
		inline int rightsum(){return right?right->sum:0;}
};
 
int H,W;//区域高度 宽度
int N,L,Lc=-1,MaxAns;
int D[MAXN];
point P[MAXN];
linknode LS[MAXN],*Line[MAXN];
Treap_node *Treap_root;
 
void Treap_Rotate_Right(Treap_node *&p)
{
	Treap_node *q=p->left;
	q->sum+=p->rightsum()+p->weight;
	p->sum=q->rightsum()+p->rightsum()+p->weight;
	p->left=q->right;
	q->right=p;
	p=q;
}
 
void Treap_Rotate_Left(Treap_node *&p)
{
	Treap_node *q=p->right;
	q->sum+=p->leftsum()+p->weight;
	p->sum=q->leftsum()+p->leftsum()+p->weight;
	p->right=q->left;
	q->left=p;
	p=q;
}
 
void Treap_maintain(Treap_node *&p)
{
	int lm,ls,rm;
	lm=ls=rm=0;
	if (p->left)
		lm=p->left->m,ls=p->left->sum;
	if (p->right)
		rm=p->right->m;
	p->m=lm;
	if (ls + p->weight > p->m)	p->m = ls + p->weight;
	if (ls + p->weight + rm > p->m) p->m=ls + p->weight + rm;
}
 
void Treap_edit(Treap_node *&p,int v,int delta)
{
	if (!p)
		p=new Treap_node(v,delta);
	else
	{
		if ( v < p->key )
		{
			p->sum+=delta;
			Treap_edit(p->left,v,delta);
			if (p->left && p->left->fix < p->fix)
			{
				Treap_Rotate_Right(p);
				Treap_maintain(p->right);
			}
			Treap_maintain(p);
		}
		else if ( v > p->key )
		{
			p->sum+=delta;
			Treap_edit(p->right,v,delta);
			if (p->right && p->right->fix < p->fix)
			{
				Treap_Rotate_Left(p);
				Treap_maintain(p->left);
			}
			Treap_maintain(p);
		}
		else
		{
			p->weight+=delta;
			p->sum+=delta;
			Treap_maintain(p);
		}
	}
}
 
void linktable_ins(linknode *&p,int v)
{
	if (p)
	{
		linknode *t=p;
		p=&LS[++Lc];
		p->next=t;
	}
	else
		p=&LS[++Lc];
	LS[Lc].s=v;
}
 
void init()
{
	freopen("kop.in","r",stdin);
	freopen("kop.out","w",stdout);
	scanf("%d%d%d",&W,&H,&N);
	for (int i=1;i<=N;i++)
		scanf("%d%d",&P[i].x,&P[i].y);
}
 
inline int cmp(const void *a,const void *b)
{
	return ((point *)a)->x - ((point *)b)->x;
}
 
void discrete() //离散化横坐标 建立链表
{
	int i,lastv=-1;
	qsort(P+1,N,sizeof(P[0]),cmp);
	L=0;
	for (i=1;i<=N;i++)
	{
		if (P[i].x!=lastv)
		{
			lastv=P[i].x;
			D[++L]=P[i].x;
			linktable_ins(Line[L],P[i].y);
		}
		else
			linktable_ins(Line[L],P[i].y);
	}
}
 
void RemoveLine(int p)
{
	for (linknode *k=Line[p];k;k=k->next)
	{
		Treap_edit(Treap_root,k->s,-1);
		Treap_edit(Treap_root,k->s+H+1,1);
	}
}
 
void AddLine(int p)
{
	for (linknode *k=Line[p];k;k=k->next)
	{
		Treap_edit(Treap_root,k->s,1);
		Treap_edit(Treap_root,k->s+H+1,-1);
	}
}
 
 
void scanx() //横向扫描 确定区间
{
	int Lb,Rb;
	AddLine(1);
	for (Lb=Rb=1;Rb<L && Lb<=L;)
	{
		while (Rb+1<=L && D[Rb+1]-D[Lb]<=W)
			AddLine(++Rb);
		if (Treap_root->m>MaxAns)
			MaxAns=Treap_root->m;
		RemoveLine(Lb++);
	}
}
 
void solve()
{
	discrete();
	scanx();
	printf("%d",MaxAns);
}
 
int main()
{
	init();
	solve();
	return 0;
}

金矿

问题描述

金矿的老师傅年底要退休了。经理为了奖赏他的尽职尽责的工作，决定在一块包含 n(n ≤ 15000) 个采金点的长方形土地中划出一块长度为 S ，宽度为 W 的区域奖励给他(1 ≤ s , w ≤ 10 000)。老师傅可以自己选择这块地的位置，显然其 中包含的采金点越多越好。你的任务就是计算最多能得到多少个采金点。如果一个采金点的位置在长方形的边上，它也应当被计算在内。

输入格式

输入文件的第一行有两个整数,中间用一个空格隔开，表示长方形土地的长和宽即s和w(1<=s,w<=10 000)。第二行有一个整数n(1<=n<=15 000)，表示金矿数量。下面的n行与金矿相对应，每行两个整数x和y (-30 000<=x,y<=30 000),中间用一个空格隔开，表示金矿的坐标。

输出格式

输出文件只有一个整数，表示选择的最大金矿的数。

输入样例

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

输出样例

4

Maybe you like

]]> http://www.byvoid.com/blog/poi-2001-kop/feed/ 2 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 POI 2001 Travel 旅行 http://www.byvoid.com/blog/poi-2001-pod/ http://www.byvoid.com/blog/poi-2001-pod/#comments Tue, 03 Feb 2009 13:26:39 +0000 BYVoid http://www.byvoid.com/blog/?p=832 题目很长，题意简述可为给定一个动态图(边权随已知最短路径周期变化)，求从X到Y的最短路径。我们只需把换乘车等待的时间看作动态的边长度。

按照路径构造有向图，构图后用一般的最短路径算法(Dijkstra,SPFA)即可解决，关键在松弛边时计算动态的边权。对于每条有向 边，需要记录其长度len，所属的线路b，从线路起点到该边的起始端的距离前缀长度pre。在松弛时，已知当前最短路为S，该边前缀pre，该边所属线路 的周期C，边长len。则我们所需等车的最短时间T，如果(A-pre)能整除C，T=A-pre；如果(A-pre)不能整除C，T=((A- pre)/C+1)*C (/为整除)。动态的边权E=len+T，用动态E松弛即可。

?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

/* 
 * Problem: POI2001 pod
 * Author: Guo Jiabao
 * Time: 2009.2.3 20:50
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
 
const int MAXN=1001,MAXK=2001,MAXE=8001,INF=0x7FFFFFFF;
 
struct edge{int t,len,belong,pre;edge *next;};
struct adjl{edge *f,*l;};
struct queue{int Q[MAXN],size,head,tail;};
 
int N,K,X,Y,G,M,Ec=-1,Ans;
int C[MAXK];
adjl Ad[MAXN];
edge E[MAXE];
queue Q;
bool inq[MAXN];
 
void Q_ins(int p)
{
	inq[p]=true;
	Q.size++;
	if (++Q.head>=MAXN)	Q.head=0;
	Q.Q[Q.head]=p;
}
 
int Q_pop()
{
	int rv=Q.Q[Q.tail];
	inq[rv]=false;
	Q.size--;
	if (++Q.tail>=MAXN)	Q.tail=0;
	return rv;
}
 
void addedge(int a,int b,int len,int belong,int pre)
{
	if (Ad[a].l)
		Ad[a].l=Ad[a].l->next=&E[++Ec];
	else
		Ad[a].f=Ad[a].l=&E[++Ec];
	E[Ec].t=b;
	E[Ec].len=len;
	E[Ec].belong=belong;
	E[Ec].pre=pre;
}
 
void init()
{
	int L,i,j,Path[MAXN],Route[MAXN],S;
	freopen("pod.in","r",stdin);
	freopen("pod.out","w",stdout);
	scanf("%d%d%d%d%d%d",&N,&K,&X,&Y,&G,&M);
	for (i=1;i<=K;i++)
	{
		scanf("%d%d",&L,&C[i]);
		for (j=1;j<=L;j++)
			scanf("%d",&Path[j]);
		for (j=1;j<L;j++)
			scanf("%d",&Route[j]);
		for (S=0,j=1;j<L;j++)
		{
			addedge(Path[j],Path[j+1],Route[j],i,S);
			S+=Route[j];
		}
		for (S=0,j=L-1;j>=1;j--)
		{
			addedge(Path[j+1],Path[j],Route[j],i,S);
			S+=Route[j];
		}
	}
	Q.head=-1;
}
 
void spfa()
{
	int i,sp[MAXN],u,v,e,pre,c;
	for (i=1;i<=N;i++)
		sp[i]=INF;
	sp[X]=960000+M;
	Q_ins(X);
	while (Q.size)
	{
		u=Q_pop();
		for (edge *k=Ad[u].f;k;k=k->next)
		{
			v=k->t;pre=k->pre;c=C[k->belong];
			e=(sp[u]-pre)/c*c;
			if ((sp[u]-pre)%c)
				e+=c;
			e+=pre-sp[u]+k->len;
			if (sp[u]+e<sp[v])
			{
				sp[v]=sp[u]+e;
				if (!inq[v])
					Q_ins(v);
			}
		}
	}
	Ans=sp[Y]-960000;
}
 
void print()
{
	int H=G,M;
	H+=Ans / 60;
	M=Ans % 60;
	H%=24;
	printf("%d %d",H,M);
}
 
int main()
{
	init();
	spfa();
	print();
	return 0;
}

旅行

让我们先确定某个城市的交通网络图，图中的点（编号为1..n），表示车站；边(pi,pj) (其中pi≠pj)，表示有一条路线直接连接车站pi和pj(1≤pi, pj≤n)。城市中的公共汽车线路从1到k编号。在线路l上有车站pl,1, pl,2,…,pl,sl,，用rl,1, rl,2,…,rl,sl-1表示对应相邻两车站间的行驶时间。例如rl,1 是从车站pl,1 到pl,2所需的时间，rl,2是从车站pl,2到pl,3所需的时间。同一线路上的车站互不相同(即若i≠j则pl,i≠pl,j)。在线路l上，发车 时间有固定的周期，表示为cl， 其中cl 属于集合{6, 10, 12, 15, 20, 30, 60}；而且在每个整点g:0 (0≤g≤23)，从车站pl,1 必有一辆车出发。于是可知在g:cl,、g:2cl,… 时(g:cl 表示g小时后的cl分钟)，都有车出发。所有的路线均为双向：从车站pl,1到pl,sl ，从车站pl,sl 到 pl,1，且同时以车。在这样的一个城市中，我们打算做一次从车站x到车站y的旅行。你可以假定该旅行是能够完成的，而且所需的时间不超过24小时。旅行 中在任一车站我们都可以换车，上下车的时间不计，但等车的时间要计算在内。我们的目的是尽可能快地完成从车站x到车站y的旅行。

下图是一个有6个车站的交通网，有两条公共汽车线路。线路1：经过车站1、3、4、6；线路2：经过车站2、4、3、5。发车的周期是：c1=15，c2=20。相邻车站间行驶时间己标在图中的边上，以下标1、2表示不同的线路。

Image:Pod.gif

假定在23:30我们在车站5，目标是到车站6。则必须等10分钟(在23:40)才有一班2路车从车站5出发。接下来有两种旅行方案，其 一：在23:51到达车站3，等3分钟，改乘1路车到达车站6(0:16)。其二：继续乘2路车到车站4(0:8)，再等13分钟(0:21)乘1路车到 车站6(0:31)。因此到达车站6时最早的时间是0:16。

任务：

  • 从文件中读入对交通网的描述，交通路线，起始车站x，终点车站y，旅行开始的时间gx和mx(gx表示小时，mx表示分钟)；
  • 找出从x到y的最早到达时间；
  • 把到车站y的最早时间gy：my写入文件。

输入：

文件的第一行是6个用空格分开的整数：

  • 车站总数n（1≤n≤1000）；
  • 路线数目k（1≤k≤2000）；
  • 起点车站x（1≤x≤n）；
  • 终点车站y（1≤y≤n）；
  • 旅行开始时刻中的小时gx（0≤gx≤23）；
  • 旅行开始时间中的分钟mx（0≤mx≤59）。

车站从1至n编号，路线从1至k编号。接下来的3k行用来描述路线，每条路线的描述占3行：

  • 描述路线l的第一行是两个用一空格分开的整数：sl和cl，分别表示路线经过的车站数目和发车周期，其中2≤sl≤n，cl属于集合｛6,10,15,20,30,60｝。
  • 描述路线l的第二行有sl个不同的整数，以一个空格分开：pl,1,pl,2,…,pl,sl，表示路线l经过车站的编号( 当1≤i≤sl时，1≤pl,i≤n)。
  • 描述路线l的第三行有sl-1个用空格分开的整数：rl,1, rl,2,…, rl,sl-1，表示路线l上相邻两车站间的行驶时间，以分钟作为单位( 当1≤i≤sl-1时，1≤rl,i≤240)。

所有路线的车站数目之和不超过4000（即s1+s2+…+sk≤4000）。

输出：

文件中仅有两个用一空格分开的整数，即最早到达终点的时间：gy和my，（0≤gy≤23，0≤my≤59）。

输入样例：

6 2 5 6 23 30
4 15
1 3 4 6
9 12 10
4 20
5 3 4 2
11 17 11

输出样例：

0 16

Maybe you like

]]> http://www.byvoid.com/blog/poi-2001-pod/feed/ 0 POI 2001 Ants and the ladybug 蚂蚁和瓢虫 http://www.byvoid.com/blog/poi-2001-mro/ http://www.byvoid.com/blog/poi-2001-mro/#comments Tue, 03 Feb 2009 04:57:58 +0000 BYVoid http://www.byvoid.com/blog/?p=829 做出这道题关键在于读懂题目，尤其是第3条和第4条规则。可以知道，所有蚂蚁是一拥而上的，而且蚂蚁很聪明，它们知道如果在某时一只蚂蚁到瓢虫的路 径与另一只蚂蚁的路径相互包含，就让距离近的蚂蚁继续行进，另一只蚂蚁停留不动。蚂蚁们还会互相礼让，如果要同时进入一个节点，就让编号小的蚂蚁进入，其 它蚂蚁停止不再动。

瓢虫会停留在多个位置，但是都是互相不关联的，我们可以把瓢虫停留的每个位置看作独立的测试点，每个测试点要用到上个测试点的结果，所以我们可以分割考虑每次瓢虫停留。

对于每次瓢虫停留，如果简单地模拟，会很容易超时。我们要把每只蚂蚁一次移动到位。首先从瓢虫的位置开始一遍BFS，找到所有可行进的蚂 蚁，记录每只蚂蚁到瓢虫位置的路径。然后按照路径长度从小到大为第一关键字，蚂蚁编号从小到大为第二关键字把蚂蚁进行排序，排名第一的蚂蚁一定是可以驱逐 瓢虫的蚂蚁，把它的路径上的顶点分别标记时间。然后依次处理每只蚂蚁，如果某只蚂蚁路径上有节点已经被标记时间，则这只蚂蚁的最大移动时间就是已经标记的 时间。在移动时也标记时间，用于影响后面的蚂蚁。这样，移动所有蚂蚁的时间复杂度是O(N+K)的。

算法的总的时间复杂度为O((N+K*logK)*L)，可以很快解决问题。实际编写时有很多细节需要注意。

?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

/* 
 * Problem: POI2001 mro
 * Author: Guo Jiabao
 * Time: 2009.2.2 21:43
 * State: Solved 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
 
const int MAXN=5001,MAXK=1001,INF=0x7FFFFFFF;
 
struct edge{int t;edge *next;};
struct adjl{edge *f,*l;};
struct vertex{int id,ant,label;};
struct ant{int vtx,id,dist,hits;};
struct path{path *from;int p;};
 
edge E[MAXN*2];
adjl A[MAXN];
vertex V[MAXN];
ant Ant[MAXK];
int PL[MAXK],Pt[MAXK][MAXN];
int N,K,L,Ec=-1,Target;
int Order[MAXK];
 
inline void addedge(int a,int b)
{
	if (A[a].f)
		A[a].l=A[a].l->next=&E[++Ec];
	else
		A[a].f=A[a].l=&E[++Ec];
	E[Ec].t=b;
}
 
void init()
{
	int i,a,b;
	freopen("mro.in","r",stdin);
	freopen("mro.out","w",stdout);
	scanf("%d",&N);
	for (i=1;i<N;i++)
	{
		scanf("%d%d",&a,&b);
		addedge(a,b);
		addedge(b,a);
	}
	for (i=1;i<=N;i++)
		V[i].id=i;
	scanf("%d",&K);
	for (i=1;i<=K;i++)
	{
		scanf("%d",&a);
		V[a].ant=i;
		Ant[i].id=i;
		Ant[i].vtx=a;
		Order[i]=i;
	}
	scanf("%d",&L);
}
 
void BFS()
{
	path Queue[MAXN],u,v;
	int Head=0,Tail=0;
	bool vis[MAXN];
	int *P;
	memset(vis,0,sizeof(vis));
	Queue[0].p=Target;
	Queue[0].from=0;
	vis[Target]=true;
	while (Head<=Tail)
	{
		v.from=&Queue[Head];
		u=Queue[Head++];
		for (edge *k=A[u.p].f;k;k=k->next)
		{
			v.p=k->t;
			if (!vis[v.p])
			{
				vis[v.p]=true;
				if (V[v.p].ant!=0)
				{
					int a=V[v.p].ant;
					path *b=&v;
					PL[a]=0;
					P=Pt[a];
					while (b->from)
					{
						P[++PL[a]]=b->p;
						b=b->from;
					}
					P[++PL[a]]=Target;
					Ant[a].dist=PL[a]-1;
				}
				else
					Queue[++Tail]=v;
			}
		}
	}
}
 
void Move()
{
	int p,i,j,u,v,MaxStep,Step;
	i=Order[1];
	Ant[i].hits++;
	MaxStep=PL[i];
	for (p=1;p<=K && Ant[i=Order[p]].dist<INF;p++)
	{
		Step=MaxStep;
		for (j=1;j<=PL[i];j++)
		{
			u=Pt[i][j];
			if (V[u].label)
			{
				Step=V[u].label+1;
				break;
			}
		}
		u=Pt[i][1];
		V[u].ant=0;
		for (j=2;j<=Step;j++)
		{
			v=Pt[i][j];
			if (V[u].label+1 > V[v].label)
				V[v].label=V[u].label+1;
			else
				break;
			u=v;
		}
		Ant[i].vtx=u;
		V[u].ant=i;
	}
}
 
inline int cmp(const void *a,const void *b)
{
	int A=*(int *)a,B=*(int *)b;
	if ( Ant[A].dist < Ant[B].dist ) return -1;
	if ( Ant[A].dist > Ant[B].dist ) return 1;
	if ( Ant[A].id   < Ant[B].id   ) return -1;
	return 1;
}
 
void clear()
{
	int i;
	for (i=1;i<=K;i++)
		Ant[i].dist=INF;
	for (i=1;i<=N;i++)
		V[i].label=0;
}
 
void solve()
{
	int i,a;
	for (i=1;i<=L;i++)
	{
		scanf("%d",&Target);
		if (V[Target].ant!=0)
		{
			a=V[Target].ant;
			Ant[a].hits++;
		}
		else
		{
			clear();
			BFS();
			qsort(Order+1,K,sizeof(Order[0]),cmp);
			Move();
		}
	}
	for (i=1;i<=K;i++)
	{
		printf("%d %dn",Ant[i].vtx,Ant[i].hits);
	}
}
 
int main()
{
	init();
	solve();
	return 0;
}

蚂蚁和瓢虫

蚂蚁和蚜虫是共生的。蚜虫分泌出蜜汁给蚂蚁引用。蚂蚁帮助蚜虫赶走它的天敌——瓢虫。在蚂蚁山附近有一个树，这里是蚜虫生活的地方。蚜虫吸取树的汁 液。有n个蚂蚁兵，用1到n编号。一个瓢虫威胁着这个文明，它经常出现在蚜虫活动的地方。当瓢虫坐在树上时，蚂蚁兵会出动把它赶走。他们按照如下的规则：

树上的任意两点之间都只有一条路径,所有的蚂蚁都沿着它所在点到瓢虫的路径前进，每移动一个位置，花的时间是单位1。

  • 如果蚂蚁和瓢虫在同一个位置，那么蚂蚁立即把它赶走。
  • 如果某个蚂蚁的路径上有另外一只蚂蚁，那么距离目标较远的蚂蚁待在原地不动，较近的那个蚂蚁继续前进。
  • 如果有多个蚂蚁要进入同一个位置，那么选择编号最小的蚂蚁，其余的蚂蚁留在原位置不动。
  • 当蚂蚁到达了瓢虫的位置以后，把它赶走，然后停留在该位置。

瓢虫是非常顽固的动物，它被赶走了以后还会再停留到别的位置。然后蚂蚁继续行动。为了使问题简单化，我们假定从一个位置到达与它相邻的位置花1个单位的时间。

任务：

读入树的描述，蚂蚁的开始位置，以及瓢虫停留地点。 给出每个蚂蚁的最后的位置，以及该蚂蚁赶走瓢虫的次数。

输入：

文件的第一行，一个整数n，1<=n<=5000。表示地点的编号。接下来n-1行描述了树里的边，每行两个整数a和b，表示 这两点之间相连。然后一行是整数k，1<=k<=1000 and k<=n。是蚂蚁兵的数目。接下来k行，每行一个整数，表示蚂蚁兵开始的位置。没有两个蚂蚁位于一个位置。然后是一个整数l, 1<=l<=500,即瓢虫停留l次。下面的l行每行一个整数，表示瓢虫依次停留的位置。

输出：

k行。每行两个整数，分别表示第k个蚂蚁最后的位置以及它赶走瓢虫的次数。

Sample Input

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

Sample Output

1 0
4 2

Figure

Image:Mro.gif

Maybe you like

]]> http://www.byvoid.com/blog/poi-2001-mro/feed/ 0