UVa 11248 Frequency Hopping（最小割入门）

题意：

给定一个有向网络，每条边均有一个容量。问是否存在一个点 1 到点 N 流量为 C 的流。如果不存在，是否可以恰好修改一条弧的容量，使得存在这样的流。

思路：

1. 首先求最大流，若最大流大于 C ，则直接输出即可。如果不大于 C 则需要修改最小割里面的弧;

2. 关于如何求最小割：求出最大流之后，S->T 已经不存在一条增广路径了。但是仍然按照增广路径的走法，遍历出分别包含 S T 的点集;

3. 关于上面可以反向来理解：如果点集 T 中有一个点位于点集 S，则增加这两点之间的流量就能继续找到一条增广路径，这显然是违背最大流的;

4. 修改割里面的弧，每次求出相应的最大流即可。中间用到 2 点优化，一是在以前的最大流基础上增广，二是每次求最大流只需要求是否满足需求即可;

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int MAXN = 110;
const int INFS = 0x3FFFFFFF;

struct edge {
int from, to, cap, flow;
edge(int _from, int _to, int _cap, int _flow)
: from(_from), to(_to), cap(_cap), flow(_flow) {}
bool operator < (const edge& rhs) const {
if (from == rhs.from) return to < rhs.to;
return from < rhs.from;
}
};

class ISAP {
public:
void clearall(int n) {
this->n = n;
for (int i = 0; i < n; i++)
G[i].clear();
edges.clear();
}
bool bfs() {
queue<int> Q;
d[t] = 0;
memset(vis, false, sizeof(vis));
vis[t] = true;
Q.push(t);
while (!Q.empty()) {
int x = Q.front(); Q.pop();
for (int i = 0; i < G[x].size(); i++) {
edge& e = edges[G[x][i]^1];
if (!vis[e.from] && e.cap > e.flow) {
vis[e.from] = true;
d[e.from] = d[x] + 1;
Q.push(e.from);
}
}
}
return vis[s];
}

void addedge(int u, int v, int cap) {
edges.push_back(edge(u, v, cap, 0));
edges.push_back(edge(v, u, 0, 0));
G[u].push_back(edges.size() - 2);
G[v].push_back(edges.size() - 1);
}
int augment() {
int x = t, a = INFS;
while (x != s) {
edge& e = edges[p[x]];
a = min(a, e.cap - e.flow);
x = e.from;
}
x = t;
while (x != s) {
edges[p[x]].flow += a;
edges[p[x]^1].flow -= a;
x = edges[p[x]].from;
}
return a;
}
int maxflow(int s, int t, int need) {
this->s = s, this->t = t;
bfs();
memset(gap, 0, sizeof(gap));
for (int i = 0; i < n; i++)
cur[i] = 0, gap[d[i]] += 1;

int x = s, flow = 0;
while (d[s] < n) {
if (x == t) {
flow += augment();
if (flow >= need) return flow;
x = s;
}
bool flag = false;
for (int i = cur[x]; i < G[x].size(); i++) {
edge& e = edges[G[x][i]];
if (e.cap > e.flow && d[x] == d[e.to] + 1) {
flag = true;
cur[x] = i;
p[e.to] = G[x][i];
x = e.to;
break;
}
}
if (!flag) {
int m = n - 1;
for (int i = 0; i < G[x].size(); i++) {
edge& e = edges[G[x][i]];
if (e.cap > e.flow)
m = min(m, d[e.to]);
}
if (--gap[d[x]] == 0) break;
gap[d[x] = m+1] += 1;
cur[x] = 0;
if (x != s) x = edges[p[x]].from;
}
}
return flow;
}
void mincut(vector<int>& cut) {
bfs();
for (int i = 0; i < edges.size(); i++) {
edge& e = edges[i];
if (!vis[e.from] && vis[e.to] && e.cap > 0)
cut.push_back(i);
}
}
void reduce() {
for (int i = 0; i < edges.size(); i++)
edges[i].cap -= edges[i].flow;
}
void clearflow() {
for (int i = 0; i < edges.size(); i++)
edges[i].flow = 0;
}
public:
int n, s, t;
vector<edge> edges;
vector<int> G[MAXN];
int p[MAXN], d[MAXN], cur[MAXN], gap[MAXN];
bool vis[MAXN];
};

ISAP sap;

int main() {
int n, e, c, cases = 0;
while (scanf("%d%d%d", &n, &e, &c) && n) {
sap.clearall(n);
while (e--) {
int u, v, fp;
scanf("%d%d%d", &u, &v, &fp);
sap.addedge(u - 1, v - 1, fp);
}
int flow = sap.maxflow(0, n - 1, INFS);
printf("Case %d: ", ++cases);
if (flow >= c) {
printf("possible\n");
} else {
vector<int> cut;
vector<edge> ans;
sap.mincut(cut);
sap.reduce();
for (int i = 0; i < cut.size(); i++) {
edge& e = sap.edges[cut[i]];
sap.clearflow();
e.cap = c;
if (flow + sap.maxflow(0, n - 1, c - flow) >= c)
ans.push_back(e);
e.cap = 0;
}
if(ans.empty())
printf("not possible\n");
else {
sort(ans.begin(), ans.end());
printf("possible option:(%d,%d)", ans[0].from + 1, ans[0].to + 1);
for(int i = 1; i < ans.size(); i++)
printf(",(%d,%d)", ans[i].from + 1, ans[i].to + 1);
printf("\n");
}
}
}
return 0;
}