@codeforces - 708D@ Incorrect Flow

目录

• @description@
• @solution@
• @accepted code@
• @details@

@description@

给定一个有源点与汇点的图 G，并对于每一条边 (u, v) 给定 f(u, v) 与 c(u, v)。f 表示流量，c 表示容量。G 不一定是合法的网络流。

求一个新图 G'，使得 G' 是一个合法网络流（流量守恒与容量限制） ，且 ∑(|f'(u, v) - f(u, v)| + |c'(u, v) - c(u, v)|) 最小。

输出这个最小值。

input

第一行两个整数 n 和 m (2 ≤ n ≤ 100, 0 ≤ m ≤ 100)，表示点数与边数。

接下来 m 行每行 4 个整数 ui, vi, ci, fi (1 ≤ ui, vi ≤ n, ui ≠ vi, 0 ≤ ci, fi ≤ 1 000 000) ，表示图 G 中有一条 (ui, vi) 且容量为 ci，流量为 fi 的图。

保证 1 为源点而 n 为汇点。输入无自环，但可能有重边。

output

输出一个整数，表示最小值。

sample input1

2 1

1 2 2 1

sample output1

0

note

注意不一定是最大流，比如上面的样例。

sample input2

4 2

2 3 1 1

3 2 1 1

sample output2

0

note

可能会有独立于源点和汇点的流存在。

@solution@

新的容量 c'(u, v) = max(c(u, v), f'(u, v))。

贪心一下就可以得到这个结果。

因此，我们分类讨论：

（1）c(u, v) >= f(u, v)。

当我们将 f(u, v) - 1，则费用 + 1。

因为一条边流量减少等于其反向边流量增加，我们连 (v, u)，容量为 f(u, v)，费用为 1。

当我们将 f(u, v) + 1，如果新的流量不超过 c(u, v)，则费用 + 1；否则，费用 + 2。

因为新的流量越大单位费用不会减少，所以我们连两类边：一是 (u, v)，容量为 c(u, v) - f(u, v)，费用为 1；二是 (u, v)，容量为 inf，费用为 2。

每次沿最短路增广，所以必然先走一类边再走二类边。

（2）c(u, v) < f(u, v)

与上面不同的是，这个时候必然会产生费用 f(u, v) - c(u, v)。我们可以先把这部分费用算入答案。

当 f(u, v) + 1，费用 + 2。连 (u, v)，容量为 inf，费用为 2。

当 f(u, v) - 1，如果新的流量 >= c(u, v)，则不会产生费用：因为这部分费用在一开始就被算入了答案；否则费用 + 1。

因此，我们依然是连两类边：一是 (v, u)，容量为 f(u, v) - c(u, v)，费用为 0；二是 (v, u)，容量为 c(u, v)，费用为 1。

为了使流量守恒，我们统计一个点的进入的流量与出去的流量之差。

如果进入的流量 > 出去的流量，则多出来的流向一个超级汇点流去，即建边 (i, tt)，容量为差值，费用为 0。

如果进入的流量 < 出去的流量，则差的流由一个超级源点流过来，即建边 (ss, i)，容量为差值，费用为 0。

原图中源点 s 和汇点 t 不一定满足流量守恒怎么办？连边 (t, s)，容量为 inf，费用为 0。

这样子，ss 向 tt 跑最小费用最大流即可。

@accepted code@

#include<queue>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXV = 400 + 5;
const int MAXE = 20000 + 5;
const int INF = int(1E9);
struct FlowGraph{
	struct edge{
		int to, flow, cap, dis;
		edge *nxt, *rev;
	}edges[MAXE], *adj[MAXV], *cur[MAXV], *ecnt;
	int s, t, cost, dist[MAXV];
	void init() {
		ecnt = &edges[0];
		for(int i=0;i<MAXV;i++) adj[i] = NULL;
	}
	void addedge(int u, int v, int c, int w) {
		edge *p = (++ecnt), *q = (++ecnt);
		p->to = v, p->flow = 0, p->cap = c, p->dis = w;
		p->nxt = adj[u], adj[u] = p;
		q->to = u, q->flow = 0, q->cap = 0, q->dis = -w;
		q->nxt = adj[v], adj[v] = q;
		p->rev = q, q->rev = p;
	}
	bool inque[MAXV];
	bool relabel() {
		queue<int>que;
		for(int i=0;i<MAXV;i++) dist[i] = INF, cur[i] = adj[i];
		que.push(s); dist[s] = 0, inque[s] = true;
		while( !que.empty() ) {
			int f = que.front(); que.pop(); inque[f] = false;
			for(edge *p=adj[f];p;p=p->nxt) {
				if( p->cap > p->flow && dist[f] + p->dis < dist[p->to] ) {
					dist[p->to] = dist[f] + p->dis;
					if( !inque[p->to] ) {
						que.push(p->to);
						inque[p->to] = true;
					}
				}
			}
		}
		return !(dist[t] == INF);
	}
	bool vis[MAXV];
	int aug(int x, int tot) {
		if( x == t ) {
			cost += tot*dist[x];
			return tot;
		}
		int sum = 0; vis[x] = true;
		for(edge *&p=cur[x];p;p=p->nxt) {
			if( p->cap > p->flow && !vis[p->to] && dist[p->to] == dist[x] + p->dis ) {
				int del = aug(p->to, min(tot-sum, p->cap-p->flow));
				p->flow += del, p->rev->flow -= del, sum += del;
				if( sum == tot ) break;
			}
		}
		vis[x] = false;
		return sum;
	}
	int min_cost_max_flow(int _s, int _t) {
		s = _s, t = _t; int flow = 0; cost = 0;
		while( relabel() )
			flow += aug(s, INF);
		return flow;
	}
}G;
int deg[MAXV];
int main() {
	G.init(); int n, m;
	scanf("%d%d", &n, &m);
	int s = 1, t = n, ss = 0, tt = n + 1, ans = 0;
	for(int i=1;i<=m;i++) {
		int u, v, c, f; scanf("%d%d%d%d", &u, &v, &c, &f);
		if( c < f ) {
			G.addedge(v, u, c, 1);
			G.addedge(u, v, f - c, 0);
			G.addedge(u, v, INF, 2);
			ans += f - c;
			deg[u] += c, deg[v] -= c;
		}
		else {
			G.addedge(v, u, f, 1);
			G.addedge(u, v, c - f, 1);
			G.addedge(u, v, INF, 2);
			deg[u] += f, deg[v] -= f;
		}
	}
	for(int i=1;i<=n;i++) {
		if( deg[i] < 0 ) G.addedge(ss, i, -deg[i], 0);
		if( deg[i] > 0 ) G.addedge(i, tt, deg[i], 0);
	}
	G.addedge(t, s, INF, 0);
	G.min_cost_max_flow(ss, tt);
	printf("%d\n", ans + G.cost);
}

@details@

除此之外，还有另一种建模方法：

考虑一个零流的图，它本身会产生一定的费用。

我们给某一条边的流量增加，费用可能会减少（更接近原图 G 中的流量），不变或者是增加。

我们建一个图，使得这个图可以满足让流量增加过后费用的变化规律。然后在这个图上找一个最小费用循环流。