Beyond the Void » 最短路径 http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 NOI 2007 社交网络 http://www.byvoid.com/blog/noi-2007-network/ http://www.byvoid.com/blog/noi-2007-network/#comments Fri, 05 Jun 2009 02:22:09 +0000 BYVoid http://www.byvoid.com/blog/?p=1374 这是NOI2007最简单的一道题了吧，考察的是细心。由于要求每对顶点的最短路径，可以用floyd求。定义path[i][j]为从i到j的最短路径的条数，floyd松弛时，要更新path[i][j] = path[i][k] * path[k][j]，如果遇到dist[i][k] + dist[k][j] == dist[i][j]这样的情况，要令path[i][j] += path[i][k] * path[k][j]。

接下来就是根据定义求每个顶点重要程度值I了，其中C(s,t)=path[s][t]，根据乘法原理，过v的最短路径条数C(s,t,v)=path[s][v] * path[v][t]。求出I值输出即可。注意最短路径数目不超过10^10，所以要用到64位整型数来记录路径条数。

?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

/* 
 * Problem: NOI2007 network
 * Author: Guo Jiabao
 * Time: 2009.6.5 9:54
 * State: Solved
 * Memo: 最短路径
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXN=101;
const double INF=1e20;
int N,M;
double dist[MAXN][MAXN],path[MAXN][MAXN];
void init()
{
	int i,j,a,b,c;
	freopen("network.in","r",stdin);
	freopen("network.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=N;j++)
		{
			dist[i][j]=INF;
			path[i][j]=1;
		}
		dist[i][i]=0;
	}
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		dist[a][b]=dist[b][a]=c;
	}
}
void floyd()
{
	int i,j,k;
	double I;
	for (k=1;k<=N;k++)
		for (i=1;i<=N;i++)
			for (j=1;j<=N;j++)
			{
				if (i==k || k==j || i==j) continue;
				if (dist[i][k] + dist[k][j] < dist[i][j])
				{
					dist[i][j] = dist[i][k] + dist[k][j];
					path[i][j] = path[i][k] * path[k][j];
				}
				else if (dist[i][k] + dist[k][j] == dist[i][j])
					path[i][j] += path[i][k] * path[k][j];
			}
	for (k=1;k<=N;k++)
	{
		I=0;
		for (i=1;i<=N;i++)
			for (j=1;j<=N;j++)
				if (i!=k && j!=k && i!=j && dist[i][k] + dist[k][j] == dist[i][j])
					I += path[i][k] * path[k][j] / path[i][j];
		printf("%.3lfn",I);
	}
}
int main()
{
	init();
	floyd();
	return 0;
}

社交网络

【问题描述】

在社交网络（social network）的研究中，我们常常使用图论概念去解释一些社会现象。不妨看这样的一个问题。在一个社交圈子里有n个人，人与人之间有不同程度的关系。我 们将这个关系网络对应到一个n个结点的无向图上，两个不同的人若互相认识，则在他们对应的结点之间连接一条无向边，并附上一个正数权值c，c越小，表示两 个人之间的关系越密切。

我们可以用对应结点之间的最短路长度来衡量两个人s和t之间的关系密切程度，注意到最短路径上的其他结点为s和t的联系提供了某种便利， 即这些结点对于s 和t之间的联系有一定的重要程度。我们可以通过统计经过一个结点v的最短路径的数目来衡量该结点在社交网络中的重要程度。

考虑到两个结点A和B之间可能会有多条最短路径。我们修改重要程度的定义如下：

令Cs,t表示从s到t的不同的最短路的数目，Cs,t(v)表示经过v从s到t的最短路的数目；则定义

Image:Network2007 1.jpg

为结点v在社交网络中的重要程度。

为了使I(v)和Cs,t(v)有意义，我们规定需要处理的社交网络都是连通的无向图，即任意两个结点之间都有一条有限长度的最短路径。

现在给出这样一幅描述社交网络s的加权无向图，请你求出每一个结点的重要程度。

【输入文件】

输入文件中第一行有两个整数，n和m，表示社交网络中结点和无向边的数目。在无向图中，我们将所有结点从1到n进行编号。

接下来m行，每行用三个整数a, b, c描述一条连接结点a和b，权值为c的无向边。注意任意两个结点之间最多有一条无向边相连，无向图中也不会出现自环（即不存在一条无向边的两个端点是相同的结点）。

【输出文件】

输出文件包括n行，每行一个实数，精确到小数点后3位。第i行的实数表示结点i在社交网络中的重要程度。

【样例输入】

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

【样例输出】

1.000
1.000
1.000
1.000

【样例说明】

社交网络如下图所示。

Image:Network2007 2.jpg

对于1号结点而言，只有2号到4号结点和4号到2号结点的最短路经过1号结点，而2号结点和4号结点之间的最短路又有2条。因而根据定义，1号结点的重要程度计算为1/2+1/2=1。由于图的对称性，其他三个结点的重要程度也都是1。

【评分方法】

本题没有部分分，仅当你的程序计算得出的各个结点的重要程度与标准输出相差不超过0.001时，才能得到测试点的满分，否则不得分。

【数据规模和约定】

  • 50%的数据中：n ≤10，m ≤45
  • 100%的数据中：n ≤100，m ≤4 500，任意一条边的权值c是正整数，满足：1 ≤c ≤1 000。
  • 所有数据中保证给出的无向图连通，且任意两个结点之间的最短路径数目不超过10^10。

Maybe you like

]]> http://www.byvoid.com/blog/noi-2007-network/feed/ 0 AHOI 上学路线 http://www.byvoid.com/blog/ahoi-route/ http://www.byvoid.com/blog/ahoi-route/#comments Tue, 21 Apr 2009 12:21:42 +0000 BYVoid http://www.byvoid.com/blog/?p=1272 题目要求是删除权值之和最少的一些边，使得从1到N的最短路径变大。方法是求最短路径网络上的最小割集。首先求出从1到N的最短路径网络，方法是分别从1和N求单源最短路径，然后枚举每条边，如果边(a,b)满足dis(1,a) + w(a,b) + dis(b,N) = dis(1,N) ，则(a,b)是最短路径网络上的(有向)边。

接下来求从1到N的网络最大流，即可求出最小割集。由于是求任意一个最小割集，所以只需遍历一边残余网络，S集合与T集合之间的边，就是一个最小割集。

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

/* 
 * Problem: HAOI2008 parterre
 * Author: Guo Jiabao
 * Time: 2009.4.21 10:23
 * State: Solved
 * Memo: 最短路径 + 网络流
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=501,MAXM=124751*4,INF=0x7FFFFFF;
using namespace std;
struct edge
{
	edge *next,*op;
	int s,t,d,c,id;
}*Vr[MAXN],*V[MAXN],ES[MAXM],*P[MAXN],*Stae[MAXN];
int N,M,EC,S,T,Ecnt;
int sp[2][MAXN],Cost[MAXM],Anse[MAXM];
bool vis[MAXN];
int Lv[MAXN],Q[MAXN],Stap[MAXN],Stop;
bool dinic_bfs()
{
	int i,j,head=0,tail=-1;
	memset(Lv,-1,sizeof(Lv));
	Q[++tail]=S;
	Lv[S]=0;
	while (head<=tail)
	{
		i=Q[head++];
		for (edge *e=V[i];e;e=e->next)
		{
			if (Lv[j=e->t]==-1 && e->c)
			{
				Lv[j]=Lv[i]+1;
				Q[++tail]=j;
				if (j==T)
					return true;
			}
		}
	}
	return false;
}
int dinic_augment()
{
	int i,j,k,delta,Flow=0;
	for (i=S;i<=T;i++)
		P[i]=V[i];
	Stap[Stop=1]=S;
	while (Stop)
	{
		i=Stap[Stop];
		if (i!=T)
		{
			for (;P[i];P[i]=P[i]->next)
				if (P[i]->c && Lv[i]+1==Lv[j=P[i]->t])
					break;
			if (P[i])
			{
				Stap[++Stop]=j;
				Stae[Stop]=P[i];
			}
			else
			{
				Stop--;
				Lv[i]=-1;
			}
		}
		else
		{
			delta=INF;
			for (j=Stop;j>=2;j--)
				if (Stae[j]->c < delta)
					delta=Stae[j]->c;
			Flow+=delta;
			for (j=Stop;j>=2;j--)
			{
				Stae[j]->c-=delta;
				Stae[j]->op->c+=delta;
				if (Stae[j]->c==0)
					k=j-1;
			}
			Stop=k;
		}
	}
	return Flow;
}
int dinic()
{
	int Flow=0;
	while (dinic_bfs())
		Flow += dinic_augment();
	return Flow;
}
inline void addedge1(int a,int b,int d,int c,int id)
{
	ES[++EC].next=Vr[a];
	Vr[a]=ES+EC; Vr[a]->t=b; Vr[a]->c=c; Vr[a]->d=d;
	ES[++EC].next=Vr[b];
	Vr[b]=ES+EC; Vr[b]->t=a; Vr[b]->c=c; Vr[b]->d=d;
	Vr[a]->op=Vr[b]; Vr[b]->op=Vr[a];
	Vr[a]->s=a; Vr[b]->s=b;
	Vr[a]->id=Vr[b]->id=id;
}
inline void addedge2(int a,int b,int c,int id)
{
	ES[++EC].next=V[a];
	V[a]=ES+EC; V[a]->t=b; V[a]->c=c;
	ES[++EC].next=V[b];
	V[b]=ES+EC; V[b]->t=a; V[b]->c=0;
	V[a]->op=V[b]; V[b]->op=V[a];
	V[a]->id=V[b]->id=id;
}
void init()
{
	int i,a,b,d,c;
	freopen("routez.in","r",stdin);
	freopen("routez.out","w",stdout);
	scanf("%d%d",&N,&M);
	EC=0;
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d%d",&a,&b,&d,&c);
		addedge1(a,b,d,c,i);
	}
}
void dijkstra(int S,int *sp)
{
	int i,j,Mini;
	memset(vis,0,sizeof(vis));
	for (i=1;i<=N;i++)
		sp[i]=INF;
	sp[i=S]=0;
	for (;i;)
	{
		vis[i]=true;
		for (edge *e=Vr[i];e;e=e->next)
		{
			j=e->t;
			if (sp[i] + e->d < sp[j])
				sp[j] = sp[i]+ e->d;
		}
		i=0;Mini=INF;
		for (j=1;j<=N;j++)
			if (!vis[j] && sp[j]<Mini)
			{
				Mini=sp[j];
				i=j;
			}
	}
}
void network()
{
	int i,a,b,p=EC;
	S=1,T=N;
	Ecnt=0;
	for (i=1;i<=p;i++)
	{
		a=ES[i].s,b=ES[i].t;
		if (sp[0][a] + ES[i].d + sp[1][b] == sp[0][N])
			addedge2(a,b,ES[i].c,ES[i].id);
	}
}
int getcut()
{
	int i,j,C=0;
	dinic_bfs();
	for (i=1;i<=N;i++)
	{
		for (edge *e=V[i];e;e=e->next)
		{
			j=e->t;
			if (Lv[i]!=-1 && Lv[j]==-1)
				Anse[++C]=e->id;
		}
	}
	return C;
}
void solve()
{
	int Ans1,Ans2,Ans3;
	dijkstra(1,sp[0]);
	dijkstra(N,sp[1]);
	Ans1=sp[0][N];
	network();
	Ans3=dinic();
	Ans2=getcut();
	printf("%dn%d %dn",Ans1,Ans2,Ans3);
	for (int i=1;i<=Ans2;i++)
		printf("%dn",Anse[i]);
}
int main()
{
	init();
	solve();
	return 0;
}
上学路线
可可和卡卡家住HF市的东郊，每天上学他们都要转车多次才能到达市区西端的学校。直到有一天他们两人参加了学校的信息学奥林匹克竞赛小组才发现每天上学的乘车路线不一定是最优的。
可可：“很可能我们在上学的路途上浪费了大量的时间，让我们写一个程序来计算上学需要的最少时间吧！”
HF市一共设有 N 个公交车站，不妨将它们编号为 1… N 的自然数，并认为可可和卡卡家住在 1 号汽车站附近，而他们学校在 N 号汽车站。市内有 M 条直达汽车路线，执行第 i 条路线的公交车 往返于 站点 p i 和 q i 之间，从起点到终点需要花费的时间为 t i 。 (1<= i <= M , 1<= p i , q i <= N )
两个人坐在电脑前，根据上面的信息很快就编程算出了最优的乘车方案。然而可可忽然有了一个鬼点子，他想趁卡卡不备，在卡卡的输入数据中删去一些路线，从而让卡卡的程序得出的答案大于实际的最短时间。而对于每一条路线 i 事实上都有一个代价 c i ：删去路线的 c i 越大卡卡就越容易发现这个玩笑，可可想知道什么样的删除方案可以达到他的目的而让被删除的公交车路线 c i 之和最小。
[ 任务 ]
编写一个程序：
•  从输入文件中读取HF市公交路线的信息；
•  计算出实际上可可和卡卡上学需要花费的最少时间；
•  帮助可可设计一个方案，删除输入信息中的一些公交路线，使得删除后从家到学校需要的最少时间变大，而被删除路线的 c i 和最小；
•  向输出文件输出答案。
[ 输入格式 ]
输入文件中第一行有两个正整数 N 和 M ，分别表示HF市公交车站和公交汽车路线的个数。以下 M 行，每行（第 i 行，总第 ( i +1) 行）用四个正整数描述第 i 条路线： p i , q i , t i , c i ；具体含义见上文描述。
[ 输出格式 ]
输出文件最多有两行。
第一行中仅有一个整数，表示从可可和卡卡家到学校需要的最短时间。
第二行描述你为可可制定的方案，首先有两个整数 K 和 C ，表示总共需要删除 K 条路线，它们的 c i 之和为 C 最小；
接着有 K 行，每行1个 1… N 的正整数： d 1 , d 2 , …, d K ，表示需要删除的路线编号，即输入文件中顺数的编号。如果有多解，输出任意一个。
[ 输入样例 ]
6 7
1 2 1 3
2 6 1 5
1 3 1 1
3 4 1 1
4 6 1 1
5 6 1 2
1 5 1 4
[ 输出样例 ]
2
2 5
16
[ 数据约束 ]
2<= N <=500, 1<= M <=124 750, 1<= t i , c i <=10 000
HF市的公交网络十分发达，你可以认为任意两个车站间都可以通过直达或转车互相到达，当然如果在你提供的删除方案中，家和学校无法互相到达，那么则认为上学需要的最短为正无穷大：这显然是一个合法的方案。

Maybe you like

]]> http://www.byvoid.com/blog/ahoi-route/feed/ 6 AHOI2005 穿越磁场 http://www.byvoid.com/blog/ahoi2005-cross/ http://www.byvoid.com/blog/ahoi2005-cross/#comments Fri, 17 Apr 2009 13:18:46 +0000 BYVoid http://www.byvoid.com/blog/?p=1258 这道题道德解法是离散化+染色+BFS最短路径。首先，由于坐标范围很大，离散化处理是很有必要的，这样可以把坐标范围从10000压缩到210以内。在离散化以后的格子中进行一次Floodfill，对每个封闭区域进行染色处理。接下来，把每个染色区域看成图中的一个顶点，相邻的染色区域建立一条权值为1的无向边。最后，求S到T所在染色区域对应顶点之间的最短路径，由于边权全部为1，只需一边BFS即可。

这道题是大名鼎鼎的《骗分导论》上的一道例题，除了骗分以外，这种解法也是非常好的。

?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

/* 
 * Problem: AHOI2005 cross
 * Author: Guo Jiabao
 * Time: 2009.4.17 10:32
 * State: Solved
 * Memo: 离散化 + 染色 + BFS
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=101,MAXL=405,INF=0x7FFFFFF,MAXC=MAXN*MAXN;
const int dx[4]={0,0,-1,1},dy[4]={-1,1,0,0};
using namespace std;
struct Queue
{
	int Q[MAXC],head,tail,size;
	Queue() {head=size=0;tail=-1;}
	void ins(int p)
	{
		if (++tail>=MAXC) tail=0;
		Q[tail]=p;
		size++;
	}
	int pop()
	{
		int r=Q[head];
		if (++head>=MAXC) head=0;
		size--;
		return r;
	}
}Q;
struct edge
{
	edge *next;
	int t;
}*V[MAXC];
struct point
{
	int x,y;
}S,T,Rect[MAXN][2],*P[MAXN*2+3],MaxP;
int N,CP,Color,Start,Target,Ans;
int TK[MAXN*2+3];
int Bel[MAXL][MAXL];
int Dist[MAXC];
void init()
{
	int i,x,y,c;
	freopen("cross.in","r",stdin);
	freopen("cross.out","w",stdout);
	scanf("%d",&N);
	for (i=1;i<=N;i++)
	{
		scanf("%d%d%d",&x,&y,&c);
		Rect[i][0].x=x;Rect[i][0].y=y;
		Rect[i][1].x=x+c;Rect[i][1].y=y+c;
		P[++CP]=&Rect[i][0]; P[++CP]=&Rect[i][1];
	}
	scanf("%d%d%d%d",&S.x,&S.y,&T.x,&T.y);
	P[++CP]=&S; P[++CP]=&T;
}
inline int cmpx(const void *a,const void *b)
{
	point *A=*(point **)a, *B=*(point **)b;
	return A->x - B->x;
}
inline int cmpy(const void *a,const void *b)
{
	point *A=*(point **)a, *B=*(point **)b;
	return A->y - B->y;
}
void dispose()
{
	int i;point PT={-100000,-100000};
	MaxP.x=MaxP.y=0;
	P[0]=&PT;TK[0]=0;
	qsort(P+1,CP,sizeof(P[0]),cmpx);
	for (i=1;i<=CP;i++)
	{
		TK[i]=TK[i-1];
		if (P[i]->x!=P[i-1]->x)
			TK[i]++;
		if (TK[i] > MaxP.x)
			MaxP.x=TK[i];
	}
	for (i=1;i<=CP;i++)
		P[i]->x=TK[i];
	qsort(P+1,CP,sizeof(P[0]),cmpy);
	for (i=1;i<=CP;i++)
	{
		TK[i]=TK[i-1];
		if (P[i]->y!=P[i-1]->y)
			TK[i]++;
		if (TK[i] > MaxP.y)
			MaxP.y=TK[i];
	}
	for (i=1;i<=CP;i++)
		P[i]->y=TK[i];
}
inline bool inrange(int x,int y)
{
	return x>=0 && y>=0 && x<=MaxP.x+1 && y<=MaxP.y+1;
}
inline bool inrect(int x,int y,int k)
{
	return x>=Rect[k][0].x && x<Rect[k][1].x && y>=Rect[k][0].y && y<Rect[k][1].y;
}
bool cross(int x1,int y1,int x2,int y2)
{
	int i;
	for (i=1;i<=N;i++)
	{
		if (inrect(x1,y1,i) ^ inrect(x2,y2,i))
			return true;
	}
	return false;
}
void dfscolor(int x,int y)
{
	int k,tx,ty;
	Bel[x][y]=Color;
	for (k=0;k<4;k++)
	{
		tx=x+dx[k]; ty=y+dy[k];
		if (inrange(tx,ty) && !Bel[tx][ty] && !cross(x,y,tx,ty))
		{
			dfscolor(tx,ty);
		}
	}
}
void floodfill()
{
	int x,y;
	for (x=1;x<MaxP.x;x++)
	{
		for (y=1;y<MaxP.y;y++)
		{
			if (!Bel[x][y])
			{
				Color++;
				dfscolor(x,y);
			}
		}
	}
}
inline void addedge(int a,int b)
{
	edge e={V[a],b};
	V[a]=new edge(e);
}
void MakeGraph()
{
	int x,y,tx,ty,k,a,b;
	for (x=1;x<=MaxP.x;x++)
	{
		for (y=1;y<=MaxP.y;y++)
		{
			a=Bel[x][y];
			if (x==S.x && y==S.y)
				Start=a;
			if (x==T.x && y==T.y)
				Target=a;
			for (k=0;k<4;k++)
			{
				tx=x+dx[k]; ty=y+dy[k];
				if (inrange(tx,ty))
				{
					b=Bel[tx][ty];
					addedge(a,b);
				}
			}
		}
	}
}
void BFS()
{
	int i,j;
	memset(Dist,-1,sizeof(Dist));
	Q.ins(Start);
	Dist[Start]=0;
	while (Q.size)
	{
		i=Q.pop();
		for (edge *e=V[i];e;e=e->next)
		{
			j=e->t;
			if (Dist[j]==-1)
			{
				Dist[j]=Dist[i]+1;
				if (j==Target)
					return;
				Q.ins(j);
			}
		}
	}
}
void solve()
{
	dispose();
	floodfill();
	MakeGraph();
	BFS();
	Ans=Dist[Target];
}
int main()
{
	init();
	solve();
	printf("%d\n",Ans);
	return 0;
}

http://www.ruvtex.cn/cogs/problem/pdetail.php?pid=316

穿越磁场

探险机器人在Samuel星球上寻找一块奇特的矿石，然而此时它陷入了一片神秘的磁场区域，动弹不得。

探险空间站立刻扫描了这片区域，绘制出该区域的磁场分布平面图。这片区域中分布了N个磁场，每个磁场呈正方形，且边与坐标轴平行。

例如下图中，存在3个磁场，白点表示机器人的位置，黑点表示矿石的位置：

Image:Cross 1.gif

科学家们分析平面图，进一步发现：这些磁场为大小不一的正方形，可能相交，甚至覆盖，但是它们的边缘不会重合，顶点也不会重合。

例如下面的两种情形是不会出现的：

Image:Cross 2.gif

科学家们给探险机器人启动了磁力罩，这样它就可以在磁场中自由穿越了。

初始时，探险机器人和所有矿石都不在任何磁场的边缘。由于技术限制，在穿越过程中机器人只能够水平或垂直移动，且不能够沿着磁场的边缘行动。

由于磁力罩的能量有限，科学家们希望探险机器人穿越尽量少的磁场边缘采集到这块矿石。例如上图中，探险机器人最少需要穿越两次磁场边缘。

现在小联请你编写程序，帮助科学家们设计探险机器人的路线，统计探险机器人最少需要穿越多少次磁场边缘。
输入：第一行有一个整数N，表示有N个磁场（1 < N < 100）。随后有N行，每行有三个整数X、Y、C（0 < X ,Y ,C < 10000），表示一个磁场左下角坐标为（X,Y），边长为C。接下来有一行，共有四个整数SX, SY, TX, TY，表示机器人初始坐标为（SX, SY），矿石坐标为（TX，TY）（其中，1 < SX, SY, TX, TY < 10000）。
输出：单行输出一个整数，表示机器人最少需要穿越多少次磁场边缘。
样例：

输入：

2
1 3 3
2 1 4
0 0 3 4

输出：

2

Maybe you like

]]> http://www.byvoid.com/blog/ahoi2005-cross/feed/ 0 HAOI 2005 路由选择问题 http://www.byvoid.com/blog/haoi-2005-route/ http://www.byvoid.com/blog/haoi-2005-route/#comments Tue, 14 Apr 2009 06:54:18 +0000 BYVoid http://www.byvoid.com/blog/?p=1218 前两问是最短路，第三问是标准的次短路径。求法是先求出最短路径，然后枚举每条从S到T的最短路径上的边，删除以后再求一次最短路径，保留最小值就是次短路径。

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

/* 
 * Problem: HAOI2005 route
 * Author: Guo Jiabao
 * Time: 2009.4.14 14:05
 * State: Solved
 * Memo: Dijkstra 次短路径
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=51,MAXM=MAXN*MAXN*2,INF=0x7FFFFFF;
using namespace std;
struct edge
{
	edge *next,*op;
	int t,c;
}ES[MAXM],*V[MAXN],*SPE[MAXN];
int N,S,T,P,SPC,S0,S1,S2,EC=-1;
int sp[MAXN];
bool mf[MAXN],vis[MAXN];
inline void addedge(int a,int b,int c)
{
	ES[++EC].next=V[a];
	V[a]=ES+EC; V[a]->t=b; V[a]->c=c;
	ES[++EC].next=V[b];
	V[b]=ES+EC; V[b]->t=a; V[b]->c=c;
	V[a]->op=V[b]; V[b]->op=V[a];
}
 
int adjm[MAXN][MAXN];
void init()
{
	int i,j,c;
	freopen("route.in","r",stdin);
	freopen("route.out","w",stdout);
	scanf("%d%d%d",&N,&S,&T);
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=N;j++)
		{
			scanf("%d",&c);
			adjm[i][j]=c;
			if (i>=j && adjm[i][j]!=adjm[j][i])
				c=1575;
			if (i<j && c)
				addedge(i,j,c);
		}
	}
	scanf("%d",&P);
	for (i=1;i<=P;i++)
	{
		scanf("%d",&c);
		mf[c]=true;
	}
}
void dijkstra()
{
	int i,j,Mini;
	for (i=1;i<=N;i++)
		sp[i]=INF,vis[i]=false;
	sp[S]=0;
	for (i=S;i;)
	{
		vis[i]=true;
		for (edge *e=V[i];e;e=e->next)
		{
			if (!mf[j=e->t] && sp[i] + e->c < sp[j])
				sp[j]=sp[i] + e->c;
		}
		Mini=INF;i=0;
		for (j=1;j<=N;j++)
			if (!vis[j] && sp[j] < Mini)
			{
				Mini=sp[j];
				i=j;
			}
	}
}
void dfs(int i)
{
	vis[i]=true;
	for (edge *e=V[i];e;e=e->next)
	{
		int j=e->t;
		if (sp[j] + e->c == sp[i])
		{
			SPE[++SPC]=e->op;
			if (!vis[j])
				dfs(j);
		}
	}
}
void solve()
{
	int i,c;
	S2=INF;
	dijkstra();
	S0=sp[T];
	memset(mf,0,sizeof(mf));
	dijkstra();
	S1=sp[T];
	memset(vis,0,sizeof(vis));
	dfs(T);
	for (i=1;i<=SPC;i++)
	{
		edge *e=SPE[i];
		c=e->c;
		e->c=INF;
		dijkstra();
		e->c=c;
		c=sp[T];
		if (c<S2)
			S2=c;
	}
}
int main()
{
	init();
	solve();
	printf("%d %d %dn",S0,S1,S2);
	return 0;
}

http://www.ruvtex.cn/cogs/problem/pdetail.php?pid=22

【问题描述】

X城有一个含有N个节点的通信网络，在通信中，我们往往关心信息从一个节点I传输到节点J的最短路径。遗憾的是，由于种种原因，线路中总有一些节点会出故障，因此在传输中要避开故障节点。
任务一：在己知故障节点的情况下，求避开这些故障节点，从节点I到节点J的最短路径S0。
任务二：在不考虑故障节点的情况下，求从节点I到节点J的最短路径S1、第二最短路径S2。

【输入文件】

第1行： N I J (节点个数 起始节点 目标节点)
第2—N+1行： Sk1 Sk2…SkN (节点K到节点J的距离为SkJ K=1，2，……，N)
最后一行： P T1 T2……Tp (故障节点的个数及编号)

【输出文件】

S0 S1 S2 (S1<=S2 从节点I到节点J至少有两条不同路径)

【输入输出样例】


route.in

5 1 5
0 10 5 0 0
10 0 0 6 20
5 0 0 30 35
0 6 30 0 6
0 20 35 6 0
1 2

route.out

40 22 30

【约束条件】

(1)N<=50 N个节点的编号为1，2，…，N
(2)Skj为整数，Skj<=100，(K，J=1，2…，N 若Skj=0表示节点K到节点J没线路)
(3)P<=5

Maybe you like

]]> http://www.byvoid.com/blog/haoi-2005-route/feed/ 1