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;
}