@codeforces - 708D@ Incorrect Flow
@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 中的流量），不变或者是增加。
我们建一个图，使得这个图可以满足让流量增加过后费用的变化规律。然后在这个图上找一个最小费用循环流。
