sgu 176 有上下界的网络流

176. Flow construction

time limit per test: 0.5 sec. 
memory limit per test: 4096 KB

input: standard 
output: standard

You have given the net consisting of nodes and pipes; pipes connect the nodes. Some substance can flow by pipes, and flow speed in any pipe doesn't exceed capacity of this pipe. 
The substance cannot be accumulated in the nodes. But it is being produced in the first node with the non-negative speed and being consumed with the same speed in the last node. 
You have some subset taken from the set of pipes of this net. You need to start the motion of substance in the net, and your motion must fully fill the pipes of the given subset. Speed of the producing substance in the first node must be minimal. 
Calculate this speed and show the scene of substance motion. 
Remember that substance can't be accumulated in the nodes of the net.

Input

Two positive integer numbers N (1<=N<=100) and M have been written in the first line of the input - numbers of nodes and pipes. 
There are M lines follows: each line contains four integer numbers Ui, Vi, Zi, Ci; the numbers are separated by a space. Ui is the beginning of i-th pipe, Vi is its end, Zi is a capacity of i-th pipe (1<=Zi<=10^5) and Ci is 1 if i-th pipe must be fully filled, and 0 otherwise. 
Any pair of nodes can be connected only by one pipe. If there is a pipe from node A to node B, then there is no pipe from B to A. Not a single node is connected with itself. 
There is no pipe which connects nodes number 1 and N. Substance can flow only from the beginning of a pipe to its end.

Output

Write one integer number in the first line of the output - it ought to be the minimal speed of the producing substance in the first node. 
Write M integers in the second line - i-th number ought to be the flow speed in the i-th pipe (numbering of pipes is equal to the input). 
If it is impossible to fill the given subset, write "Impossible".

Sample test(s)

Input

Input 1: 

4 4  

1 2 2 0 

 2 4 1 1 

 1 3 2 1 

 3 4 3 0 

 Input 2: 

 4 4 

 1 2 1 0 

 2 4 2 1 

 1 3 3 1 

 3 4 2 0

Output

Output 1: 
3 
1 1 2 2 
Output 2: 
Impossible

[submit]

[forum]

题意：给出一个有源有汇网络，规定有些边一定要满流，有些边不一定。求网络最小流。

我用的是一种较为简易的做法，将红书稍加改动

求有源汇有上下界最小可行流的方法如下：

（1）重构一个不包含下界的图。

（a）添加超级源SS和超级汇ST

（b）对于原图中的每条边（a->b，L，U）（L代表下界，U代表上界），拆成三条

i. a->b,容量为U-L

ii. SS->b,容量为L

iii. a->ST,容量为L

（2）求一遍SS到ST的最大流

（3）添加边t->s,容量为无穷大。t为原来的源点，s为原来的汇点。

（4) 再求一遍SS到ST的最大流

（5）检查从SS出发的边是否全部满流。如果有不满流的边，说明不存在可行流。

否则新添边t->s上的流量为所求的最小流。

题目中还需要输出方案中每条边的流量。只需要将“a->b，容量为U-L”的边，加上其下界L，就是原边对应的流量。

代码：

#include<queue>
#include<iostream>
#include<string>
#include<cstring>
#include<vector>
#include<iomanip>
#include<stack>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<map>
#include<list>
using namespace std;
const int INF=1e9;
#define rep(i,n) for(int i=0;i<n;i++)
const double eps=1e-6;
const int maxn = 105;
//const int INF=1e9;
struct Edge{
	int from,to,cap,flow;
	int L; //下界
	Edge(int f = 0, int t = 0, int _L = 0, int c = 0, int fl = 0):from(f),to(t),cap(c),flow(fl),L(_L){}
};
int n,m,s,t;
int S,T;
vector<Edge> edges;
vector<int> G[maxn];
bool vis[maxn];
int d[maxn];
int cur[maxn];
void init(int n)
{
	edges.clear();
	rep(i,n+3) G[i].clear();
}
int AddEdge(int from,int to,int L,int cap){
	edges.push_back(Edge(from, to, L, cap, 0)); //返回的是这条的编号
	edges.push_back(Edge(to, from, 0, 0, 0));
	int p = edges.size();
	G[from].push_back(p - 2);
	G[to].push_back(p - 1);
	return p - 2;
}
bool BFS(int s,int t){
	memset(vis,0,sizeof(vis));
	queue<int> q;
	q.push(s);
	d[s] = 0; 
	vis[s] = 1;
	while(!q.empty()){
		int x = q.front(); q.pop();
		for(int i = 0;i<(int)G[x].size();i++){
			Edge &e = edges[G[x][i]];
			if(!vis[e.to] && e.cap > e.flow){
				vis[e.to] = 1; d[e.to] = d[x] + 1;
				q.push(e.to);
			}
		}
	}
	return vis[t];
}
int DFS(int x,int a,int t){
	if(x == t || a == 0) return a;
	int flow = 0,f;
	for(int &i = cur[x];i < (int)G[x].size(); i++){
		Edge& e = edges[G[x][i]];
		if(d[x]+1 == d[e.to] &&(f = DFS(e.to,min(a,e.cap-e.flow),t))>0){
			e.flow += f;
			edges[G[x][i]^1].flow -= f;
			flow += f;
			a -= f;
			if(a == 0) break;
		}
	}
	return flow;
}
int maxflow(int s,int t){ //dinic
	int flow = 0;
	while(BFS(s,t)){
		memset(cur, 0, sizeof(cur));
		flow += DFS(s, INF, t);
	}
	return flow;
}
vector<int> eid; //要输出流量的边的序号
int main() {
#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
	//  freopen("out.txt","w",stdout);
#endif
	while(~scanf("%d%d",&n,&m))
	{
		eid.clear();
		s = 1,t = n;
		S = 0;
		T = n + 1;
		init(n);
		int u,v,z,c;
		while(m--)
		{
			scanf("%d%d%d%d",&u,&v,&z,&c);
			if(c == 0)
			{
				//AddEdge(s,v,0);
				eid.push_back(AddEdge(u, v, 0, z)); 
				//AddEdge(u,t,0);
			}
			else
			{
				AddEdge(S, v, 0, z);
				eid.push_back(AddEdge(u, v, z, z-z));
				AddEdge(u, T, 0, z);
			}
		}
		maxflow(S, T);
		AddEdge(t, s, 0, INF);
		maxflow(S, T);
		bool f = 0;
		for(int i=0;i<G[S].size();i++)
		{
			if(edges[G[S][i]].flow != edges[G[S][i]].cap) //检查从S出发的边是否全部满流
			{
				f = 1;
				break;
			}
		}
		if(f) { puts("Impossible");continue; }
		int ans = edges[edges.size() - 2].flow; //输出t -> s这条边上的流量,即为最小可行流
		cout<<ans<<endl;
		int sz = eid.size();
		rep(i,sz)
		{
			printf("%d%c",edges[eid[i]].flow + edges[eid[i]].L,i == sz - 1 ? '\n' : ' '); //输出各边上的流量
		}
	}
	return 0;
}