最大流-最小割定理&poj3469 Dual Core CPU

对于最大流问题中，经常会涉及到一个叫做最小割的部分，那么，首先先来看看最小割是什么。

在一个图G(V,E)中，通过去掉一些边的方式，使得节点u与节点v不连通，这就是节点u和节点v的一个割。

在G之中，有一些路径联通s，t，如果去掉一些边使s，t不连通，那么这个割的办法就是一个s-t割。

每一个割的容量就是这个割集中所有边的容量之和。

讲完这些基础理论，自然容易猜到最小割就是在图G中，容量最小的一个s-t割。

那么要怎么求最小割呢？这里有一个定理：最大流等于最小割。

不难发现，在求最大流的过程中，必然有增广这个过程，以Ek算法执行的方式为例，找到一条s-t路径，其中残量最少的就是这一次所增加的流量，这一条边也相应的在残量网络中去掉，多次执行，假设只去掉残量最少的边，到最后，s和t在残量网络中必然是不连通的，反之，必然能够继续增广，这时候被去掉的边就是最小割的割集，最大流就是最小割。

那么怎么证明它是一定正确的呢？

简要证明：

求最大流时，流量不会停滞在某一个节点中，而是直接从s到t走下去，这样走下去，走过的边的流量都是一样的，这时候转化为最小割问题，就相当于是那么有残量的边都还保留着，没有去掉多余的边。这样求下去，最终一定能够求出最大流，相应地也求出了最小割。

所以，这个定理就是正确的。

那么现在来看一道题目：

题意：

有机器A和B，N个任务，每一个任务在A上的花费和在B上的花费是不一样的。如果任务x和任务y不在同一台机器上工作，那么还要额外花费，求最少花费。

思路：

可以很快想到，这是一道求最小割的题目，首先要建图。

源点表示机器A，汇点表示机器B，源点向每一个节点连接相应的花费，每一个节点向汇点连接相应的花费。

要在同一台机器上工作的两个节点再另外连相应的花费，求一次最小割，也就是最大流即可。

这里有一个要注意的地方，两个任务之间的边应该是无向的，而不是有向的，不然会导致错误。

同时注意到一点，题目的数据量十分大，使用Dinic理论上最坏情况会跑O(80000000000000)的时间，虽然有5秒的限时，但还是肯定会超时嘛……但是实际上，并不会跑这么久都完成不了……

事实上跑得还是很快的，并没有超时，尽管也是临界了……但是如果使用迭代以及不使用STL库的vector来储存，和用queue来做BFS，应该会跑3200MS左右，但是为了方便并没有用，万一用了数组开得不够大呢……

代码：

#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;

const int MAXN = 20000 + 10,
INF = 0x3f3f3f3f;

const int s = 0,
t = 20001;

struct Edge {
int from, to, cap, flow;
};

struct Dinic {
int n, m, s, t;
vector < Edge > edges;
vector < int > G[MAXN];
bool vis[MAXN];
int d[MAXN];
int cur[MAXN];

void AddEdge(int from, int to, int cap) {
edges.push_back((Edge) {
from, to, cap, 0
});

if(from == s || to == t) { // 如果不判断是否是两个点之间连，然后直接将边改成无向，就超时和爆空间了……
edges.push_back((Edge) {
to, from, 0, 0
});
} else {
edges.push_back((Edge) {
to, from, cap, 0
});
}
m = edges.size();
G[from].push_back(m - 2);
G[to].push_back(m - 1);
}

bool BFS() {
memset(vis, 0, sizeof vis);
queue < int > Q;
Q.push(s);
d[s] = 1;
vis[s] = 1;

while(!Q.empty()) {
int x = Q.front();
Q.pop();

for(int i = 0; i < 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) {
if(x == t || a == 0) {
return a;
}

int flow = 0, f;
for(int& i = cur[x]; i < G[x].size(); ++i) {
Edge& e = edges[G[x][i]];

if(d[e.to] == d[x] + 1 && (f = DFS(e.to, min(a, e.cap - e.flow))) > 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) {
this -> s = s;
this -> t = t;

int flow = 0;

while(BFS()) {
memset(cur, 0, sizeof cur);
flow += DFS(s, INF);
}
return flow;
}
} dinic;

int n, m;

int main(void) {
scanf("%d%d", &n, &m);

for(int i = 1; i <= n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
dinic.AddEdge(s, i, a); // 源点与汇点都和节点之间连边
dinic.AddEdge(i, t, b);
}

for(int i = 0; i < m; ++i) {
int a, b, cap;
scanf("%d%d%d", &a, &b, &cap);
dinic.AddEdge(a, b, cap); // 节点之间连边
}

printf("%d\n", dinic.Maxflow(s, t)); // 求最小割

return 0;
}