CF708D Incorrect Flow 题解

题意：

给定一张 \(n\) 个点 \(m\) 条边的网络，源点为 \(1\)，汇点为 \(n\)。对于每条边，有容量 \(c\)，当前流量 \(f\)。

但这个图是错误的，可能存在 \(c < f\)，或者流量不守恒的情况。你每次操作可以将某条边的 \(c\) 或 \(f\) 加 \(1\) 或减 \(1\)。请你用最少的操作次数将图变成一个正确的网络。

\(n,m \le 100\)，\(c,f \le 10^6\)，\(1\) 没有入边，\(n\) 没有出边。

思路：

被我秒了的黑题，自信心爆棚。

先只考虑只要求流量守恒的情况，发现这就是一个类似于上下界网络流的东西，我们对于 \((u,v,f)\)，建 \((v, u, f, 1)\) 和 \((u, v, f, 1)\)，分别代表减少这条边的流量和增加这条边的流量。

于是我们就可以类似的扩展到容量上了。我们把 \(c \ge f\) 和 \(c < f\) 分开讨论。

不难发现能不改变容量就尽量不要改变容量，我们依据这个来做。

如果 \(c \ge f\)，连 \((v, u, f, 1)\) 表示可以减少到 \(0 \sim f\)，\((u,v,c-f,1)\) 表示可以在不改变容量的情况下增加到 \(c\)，以及 \((u,v,\infty,2)\) 表示如果还要增加就要两个都增加了。

如果 \(c < f\)，则我们考虑如果最后 \(f\) 比 \(c\) 还要小，那肯定有 \(c\) 不变，而如果 \(f\) 比 \(c\) 还要大，那也一定有 \(f = c\)，否则一定也有 \(f=c\)。

不难发先最后一种情况下花费一定是 \(f-c\)，而剩下的两个情况是在这个情况的基础上增加或减少，所以我们先给答案加上 \(f-c\)，然后连 \((v,u,f-c,0)\) 表示这个范围内可以变化，然后 \((v,u,c,1)\) 表示再减少就要再花钱，\((u,v,\infty,2)\) 表示增加就要两个都增加。

以上都是基于对于原有的边流量一定是 \(c\)，这是一个有下界的问题。

所以我们按照上下界有源汇网络流的做法建立超级源超级汇，同时连 \((n,1,\infty,0)\)。

很有意思。

点击查看代码

#include <iostream>
#include <vector>
#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 105;
const int inf = 0x3f3f3f3f;

struct Edge {
	int to, val, cst, rev;
	Edge (int _to = 0, int _val = 0, int _cst = 0, int _rev = 0) :
		to(_to), val(_val), cst(_cst), rev(_rev) {}
};
vector<Edge> e[N];
void add(int u, int v, int w, int c) {
	e[u].push_back(Edge(v, w, c, (int)e[v].size()));
	e[v].push_back(Edge(u, 0, -c, (int)e[u].size() - 1));
}

int d[N] = {0};
bool inq[N] = {false};
bool bfs(int s, int t) {
	memset(d, inf, sizeof d);
	queue<int> q;
	q.push(s), d[s] = 0;
	while (!q.empty()) {
		int h = q.front();
		q.pop();
		inq[h] = false;
		for (auto i: e[h])
			if (i.val > 0 && d[i.to] > d[h] + i.cst) {
				d[i.to] = d[h] + i.cst;
				if (!inq[i.to])
					inq[i.to] = true, q.push(i.to);
			}
	}
	return d[t] != inf;
}

int cur[N] = {0};
bool vis[N] = {false};
int dfs(int x, int t, int f) {
	if (x == t)
		return f;
	int fl = 0;
	vis[x] = true;
	for (int i = cur[x]; i < (int)e[x].size(); i = ++cur[x])
		if (e[x][i].val > 0 && !vis[e[x][i].to] && d[e[x][i].to] == d[x] + e[x][i].cst) {
			fl = dfs(e[x][i].to, t, min(f, e[x][i].val));
			if (fl > 0) {
				e[x][i].val -= fl;
				e[e[x][i].to][e[x][i].rev].val += fl;
				break;
			}
		}
	if (fl == 0)
		d[x] = -1;
	vis[x] = false;
	return fl;
}

int Dinic(int s, int t) {
	int ans = 0;
	while (bfs(s, t)) {
		memset(cur, 0, sizeof cur);
		int ad = 0;
		while ((ad = dfs(s, t, inf)) > 0)
			ans += ad * d[t];
	}
	return ans;
}

int n, m;

int s[N] = {0};

int main() {
	cin >> n >> m;
	int ans = 0;
	for (int i = 1, u, v, f, c; i <= m; i++) {
		cin >> u >> v >> c >> f;
		s[u] += f, s[v] -= f;
		if (c >= f) {
			add(v, u, f, 1);//流回来
			add(u, v, c - f, 1);//流过去，不改变 c
			add(u, v, inf, 2);//流过去，改变 c 
		}
		else {
			ans += f - c;//至少这么多代价 
			add(v, u, f - c, 0);//在可接受范围内 [c, f]
			add(v, u, c, 1);//需要降低流量
			add(u, v, inf, 2);//需要同时增加流量和容量 
		}
	}
	int S = 0, T = n + 1;
	for (int i = 1; i <= n; i++)
		if (s[i] > 0)
			add(i, T, s[i], 0);
		else
			add(S, i, -s[i], 0);
	add(n, 1, inf, 0);
	cout << ans + Dinic(S, T) << endl;
	return 0;
}