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 2009 植物大战僵尸 http://www.byvoid.com/blog/noi-2009-pvz/ http://www.byvoid.com/blog/noi-2009-pvz/#comments Tue, 12 Jan 2010 12:47:15 +0000 BYVoid http://www.byvoid.com/blog/?p=1770 问题简述

有一些植物，每个植物携带有一定的资源（可正可负），且有一个攻击范围，可以保护攻击位置上的另一个植物。有一群僵尸从右向左进攻植物，僵尸不能走到植物的攻击范围内。任务是求一个进攻方案，使得僵尸获得的资源尽可能多。

问题建模

首先我们我建立图论模型，把每个植物当做一个顶点，植物携带的资源数目为顶点的权值。如果一个植物b在另一个植物a的攻击范围内，连接一条有向边<a,b>，表示a可以保护b。由于僵尸从右向左进攻，可以认为每个植物都被它右边相邻的植物保护，对于每个植物a（除最左边一列），向其左边的相邻植物b，连接一条有向边<a,b>。

题目中给出的样例建图后如下所示

image

观察上图发现，{5,6}互相依赖，不可能被攻击到。我们可以用拓扑排序去除图中的环依赖结构，以简化图。

image

解法1 搜索

算法描述

建模后，直接观察发现可以搜索。每次寻找一个入度为0的顶点，尝试攻击它，更新它指向的点的入度继续搜索。搜索中记录选取的顶点的权值之和，保留最大值。

image

复杂度分析

搜索的时间复杂度为O(MN)。在实际测试中得到40分。

参考程序
?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

/*
* Problem: NOI2009 pvz
* Author: Guo Jiabao
* Time: 2009.7.29 12:01
* State: Solved
* Memo: 暴力搜索
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
 
using namespace std;
 
const int MAXN=603,MAXM=MAXN*MAXN*4,INF=~0U>>1;
 
struct edge
{
	edge *next;
	int t;
}*V[MAXN],ES[MAXM];
 
FILE *fi,*fo;
 
int R,C,EC,Ans,Maxflow,Stop,S,T,N;
int score[MAXN],ind[MAXN];
bool vis[MAXN];
 
inline void addedge(int a,int b)
{
	ES[++EC].next = V[a]; V[a] = ES+EC; V[a]->t = b;
}
 
inline int point2id(int x,int y)
{
	return x * C + y + 1;
}
 
void init()
{
	int i,j,k,l,q,x,y,s,c;
	fi = fopen("pvz.in","r");
	fo = fopen("pvz.out","w");
	fscanf(fi,"%d%d",&R,&C);
	for (i=0;i<R;i++)
	{
		for (j=0;j<C;j++)
		{
			k = point2id(i,j);
			if (j+1<C)
			{
				q = point2id(i,j+1);
				addedge(q,k);
				ind[k]++;
			}
			fscanf(fi,"%d%d",&s,&c);
			score[k] = s;
			for (l=1;l<=c;l++)
			{
				fscanf(fi,"%d%d",&x,&y);
				q = point2id(x,y);
				addedge(k,q);
				ind[q]++;
			}
		}
	}
	N=R*C;
}
 
void dfs(int s)
{
	if (s > Ans)
		Ans = s;
	int i;
	edge *e;
	for (i=1;i<=N;i++)
		if (ind[i] == 0 && !vis[i])
		{
			vis[i]=true;
			for (e=V[i];e;e=e->next)
				ind[ e->t ]--;
			dfs(s+score[i]);
			vis[i]=false;
			for (e=V[i];e;e=e->next)
				ind[ e->t ]++;
		}
}
 
void solve()
{
	Ans = 0;
	dfs(0);
	fprintf(fo,"%d\n",Ans);
	fclose(fi);
	fclose(fo);
}
 
int main()
{
	init();
	solve();
	return 0;
}

解法2 最大封闭子图

算法描述

将图转置后发现，一个合法的攻击方案是一个封闭子图(Closure of a Graph)，我们的目标就是最大化攻击方案的点权值和，就是要求一个最大封闭子图(Maximum Weight Closure of a Graph)，只需转化为网络流模型，即可解决。

算法分析

样例的图转置后如下，其最大封闭子图为{1,2,4}。

image

最大封闭子图的玩网络流建模方法为：

1. 建立附加源S和附加汇T。

2. 图中原有的边容量设为∞。

3. 从S向每个权值为正的点连接一条容量为该点权值的有向边。

4. 从每个权值不为正的点向T连接一条容量为该点权值绝对值的有向边。

在网络上求S到T的网络最大流Maxflow，最大封闭子图的权值就是(所有正权点权值之和 – Maxflow)。

样例建模后如下图所示，求得Maxflow = 5，所以最大封闭子图的权值为(10 + 20 – 5) = 25。

image

求最大封闭子图的网络流建模方法的严格证明见胡伯涛《最小割模型在信息学竞赛中的应用》。

复杂度分析

该图点数为O(NM)，边数可达O(N2M2)。拓扑排序和建图的时间为O(N2M2)，用Dinic算法求网络最大流的时间为O(|V|2|E|)，所以总时间复杂度为O(N4M4)。在实际测试中通过了所以测试点，得到100分。

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

/*
* Problem: NOI2009 pvz
* Author: Guo Jiabao
* Time: 2009.7.29 11:52
* State: Solved
* Memo: 最大封闭子图 网络最大流
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
 
using namespace std;
 
const int MAXN=603,MAXM=MAXN*MAXN*4,INF=~0U>>1;
 
struct edge
{
	edge *next,*op;
	int t,c;
}*V[MAXN],*V0[MAXN],*P[MAXN],ES[MAXM],*Stae[MAXN];
 
FILE *fi,*fo;
 
int R,C,EC,Ans,Maxflow,Stop,S,T,N;
int score[MAXN],ind[MAXN],Lv[MAXN],Stap[MAXN],Q[MAXN];
bool ts[MAXN];
 
inline void addedge(edge **V,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=0;
	V[a]->op = V[b]; V[b]->op = V[a];
}
 
inline int point2id(int x,int y)
{
	return x * C + y + 1;
}
 
void init()
{
	int i,j,k,l,q,x,y,s,c;
	fi = fopen("pvz.in","r");
	fo = fopen("pvz.out","w");
	fscanf(fi,"%d%d",&R,&C);
	for (i=0;i<R;i++)
	{
		for (j=0;j<C;j++)
		{
			k = point2id(i,j);
			if (j+1<C)
			{
				q = point2id(i,j+1);
				addedge(V0,q,k,1);
				ind[k]++;
			}
			fscanf(fi,"%d%d",&s,&c);
			score[k] = s;
			for (l=1;l<=c;l++)
			{
				fscanf(fi,"%d%d",&x,&y);
				q = point2id(x,y);
				addedge(V0,k,q,1);
				ind[q]++;
			}
		}
	}
	N=R*C;
}
 
void topsort()
{
	int i,j;
	Stop = 0;
	for (i=1;i<=N;i++)
		if (ind[i]==0)
			Stap[++Stop] = i;
	while (Stop)
	{
		i = Stap[Stop--];
		ts[i] = true;
		for (edge *e=V0[i];e;e=e->next)
		{
			j=e->t;
			if (e->c)
			{
				ind[j]--;
				if (ind[j] == 0)
					Stap[++Stop] = j;
			}
		}
	}
}
 
void makegraph()
{
	int i,j;
	S=0;
	T=N+1;
	for (i=1;i<=N;i++)
		if (ts[i])
		{
			if (score[i] > 0)
			{
				addedge(V,S,i,score[i]);
				Ans += score[i];
			}
			else
				addedge(V,i,T,-score[i]);
			for (edge *e=V0[i];e;e=e->next)
			{
				j=e->t;
				if (ts[j] && e->c)
				{
					addedge(V,j,i,INF);
				}
			}
		}
}
 
bool Dinic_label()
{
	int i,j,head,tail;
	memset(Lv,0,sizeof(Lv));
	Q[head=tail=0] = S;
	Lv[S] = 1;
	while (head<=tail)
	{
		i = Q[head++];
		for (edge *e=V[i];e;e=e->next)
		{
			j = e->t;
			if (Lv[j] == 0 && e->c)
			{
				Lv[j] = Lv[i]+1;
				if (j==T)
					return true;
				Q[++tail] = j;
			}
		}
	}
	return false;
}
 
void Dinic_aug()
{
	int i,j,delta;
	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[ j = P[i]->t ] == Lv[i] + 1)
					break;
			if (P[i])
			{
				Stap[++Stop] = j;
				Stae[Stop] = P[i];
			}
			else
				Stop--,Lv[i] = 0;
		}
		else
		{
			delta = INF;
			for (i=Stop;i>=2;i--)
				if (Stae[i]->c < delta)
					delta = Stae[i]->c;
			for (i=Stop;i>=2;i--)
			{
				Stae[i]->c -= delta;
				Stae[i]->op->c += delta;
				if (Stae[i]->c == 0)
					Stop = i-1;
			}
			Maxflow += delta;
		}
	}
}
 
void Dinic()
{
	while (Dinic_label())
		Dinic_aug();
}
 
void solve()
{
	topsort();
	makegraph();
	Dinic();
	Ans -= Maxflow;
	fprintf(fo,"%d\n",Ans);
	fclose(fi);
	fclose(fo);
}
 
int main()
{
	init();
	solve();
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/noi-2009-pvz/feed/ 18 线性规划与网络流24题 解题报告 http://www.byvoid.com/blog/lpf24-solution/ http://www.byvoid.com/blog/lpf24-solution/#comments Tue, 30 Jun 2009 10:36:39 +0000 BYVoid http://www.byvoid.com/blog/?p=1397 经过几天努力终于做完了线性规划与网络流24题，同时对网络流和二分图的理解也上升到了一个新的高度。把所有题解发上来供大家参考，还请多多指教。

感谢ShingRay发现本文一个错误，现已修正。

BYVoid原创 线性规划与网络流24题_解题报告Ver 2 (48KB)

另外附上 线性规划与网络流24题 (1.90MB) 感谢王晓东老师给我们提供这么多好题。

几点说明

  1. 本题解提供所有问题的解析和大部分问题的C++程序源代码，以及个别数据的勘误。
  2. 本题解只讨论问题的分析和建模，具体的实现参照代码。代码中所有网络最大流算法均用Dinic实现。
  3. 读者应具备图论、最短路径、网络流的基础知识，并掌握至少一种网络最大流和最小费用最大流的算法。
  4. 建议读者在阅读题解前先进行充分的思考，确认无法独立解决后再看题解。
  5. 问题8 机器人路径规划问题 是个经典难题，暂时还未解决，欢迎大家讨论。
  6. 本题解系个人原创，请勿商业转载，非商业转载请注明来源。

问题一览

问题编号 问题名称 问题模型 转化模型
1 飞行员配对方案问题 二分图最大匹配 网络最大流
2 太空飞行计划问题 最大权闭合图 网络最小割
3 最小路径覆盖问题 有向无环图最小路径覆盖 网络最大流
4 魔术球问题 有向无环图最小路径覆盖 网络最大流
5 圆桌问题 二分图多重匹配 网络最大流
6 最长递增子序列问题 最多不相交路径 网络最大流
7 试题库问题 二分图多重匹配 网络最大流
8 机器人路径规划问题 (未解决) 最小费用最大流
9 方格取数问题 二分图点权最大独立集 网络最小割
10 餐巾计划问题 线性规划网络优化 最小费用最大流
11 航空路线问题 最长不相交路径 最小费用最大流
12 软件补丁问题 最小转移代价 最短路径
13 星际转移问题 网络判定 网络最大流
14 孤岛营救问题 分层图最短路径 最短路径
15 汽车加油行驶问题 分层图最短路径 最短路径
16 数字梯形问题 最大权不相交路径 最小费用最大流
17 运输问题 网络费用流量 最小费用最大流
18 分配问题 二分图最佳匹配 最小费用最大流
19 负载平衡问题 最小代价供求 最小费用最大流
20 深海机器人问题 线性规划网络优化 最小费用最大流
21 最长k可重区间集问题 最大权不相交路径 最小费用最大流
22 最长k可重线段集问题 最大权不相交路径 最小费用最大流
23 火星探险问题 线性规划网络优化 最小费用最大流
24 骑士共存问题 二分图最大独立集 网络最小割

Maybe you like

]]> http://www.byvoid.com/blog/lpf24-solution/feed/ 18 NOIP2008 传纸条 费用流建模 http://www.byvoid.com/blog/noip2008-message-costflow/ http://www.byvoid.com/blog/noip2008-message-costflow/#comments Wed, 24 Jun 2009 04:05:23 +0000 BYVoid http://www.byvoid.com/blog/?p=1390 把问题抽象成图论问题，数学模型是求从S到T的两条不相交的路径，使得路径上点的权值之和最大。

费用流建模，首先拆点，把顶点i拆成i.a和i.b，i.a 与i.b之间连接一条费用为“好心值”，容量为1的有向边，特殊地，左上角和右下角两个节点拆分后点内边容量设为2，因为我们要找两条不相交路径。i右边和下边的节点j，连接一条(i.b,j.a)费用为0，容量为1的有向边。

求最大费用最大流即可，费用流值就是要求的结果。比动态规划运行得快，空间占用少。

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

/* 
 * Problem: NOIP2008 message
 * Author: Guo Jiabao
 * Time: 2009.6.24 11:52
 * State: Solved
 * Memo: 最小费用最大流
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
const int MAXL=51,MAXN=MAXL*MAXL*2,MAXM=MAXN*3,INF=~0U>>1;
struct Queue
{
	int Q[MAXN],head,tail,size;
	bool inq[MAXN];
	Queue()
	{
		memset(inq,0,sizeof(inq));
		head=size =0;
		tail=-1;
	}
	void ins(int p)
	{
		inq[p]=true;
		if (++tail >= MAXN) tail = 0;
		Q[tail] = p;
		size ++;
	}
	int pop()
	{
		int p=Q[head];
		if (++head >= MAXN) head = 0;
		inq[p]=false;
		size --;
		return p;
	}
}Q;
struct edge
{
	edge *next,*op;
	int t,c,v;
}ES[MAXM],*V[MAXN],*fe[MAXN];
int N,M,EC,S,T,CostFlow;
int dist[MAXN],ft[MAXN];
inline void addedge(int a,int b,int v)
{
	ES[++EC].next = V[a]; V[a]=ES+EC; V[a]->t = b; V[a]->c=1; V[a]->v = v;
	ES[++EC].next = V[b]; V[b]=ES+EC; V[b]->t = a; V[b]->c=0; V[b]->v = -v;
	V[a]->op = V[b]; V[b]->op = V[a];
}
void init()
{
	int i,j,a,b,c;
	freopen("message.in","r",stdin);
	freopen("message.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=M;j++)
		{
			a=(i-1)*M+j;b=a+a;a=b-1;
			scanf("%d",&c);
			addedge(a,b,c);
		}
	}
	ES[EC-1].c=ES[1].c=2;
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=M;j++)
		{
			a=((i-1)*M+j)*2;
			if (j+1<=M)
			{
				b = ((i-1)*M+j+1)*2 - 1;
				addedge(a,b,0);
			}
			if (i+1<=N)
			{
				b = (i*M+j)*2 - 1;
				addedge(a,b,0);
			}
		}
	}	
	S=1; T = N * M * 2;
}
bool spfa()
{
	int i,j;
	for (i=S;i<=T;i++)
		dist[i]=-INF;
	dist[S]=0;
	Q.ins(S);
	while (Q.size)
	{
		i= Q.pop();
		for (edge *e=V[i];e;e=e->next)
		{
			j=e->t;
			if (e->c && dist[i] + e->v > dist[j])
			{
				dist[j] = dist[i] + e->v;
				ft[j] = i;
				fe[j] = e;
				if (!Q.inq[j])
					Q.ins(j);
			}
		}
	}
	return dist[T]!=-INF;
}
void aug()
{
	int i,delta=INF;
	for (i=T;i!=S;i=ft[i])
		if (fe[i]->c < delta)
			delta = fe[i]->c;
	for (i=T;i!=S;i=ft[i])
	{
		fe[i]->c -= delta;
		fe[i]->op->c +=delta;
		CostFlow += fe[i]->v * delta;
	}
}
void solve()
{
	while (spfa())
		aug();
}
int main()
{
	init();
	solve();
	printf("%d\n",CostFlow);
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/noip2008-message-costflow/feed/ 12 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