UVa 10480：Sabotage （最小割集）

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1421

题意：给出n个点m条边，每条边有一个花费，问将1和2隔离需要破坏的边的最小花费的边集。

思路：很明显是最小割，但是问题在于如何求出这个最小割集。通过以前的题目，求网络的最大流就是求网络的最小割，那么从源点到汇点的最大流必定就会经过最小割集的边，当这条边满载（flow == cap）的时候，这条边其实就是最小割集的边。求出最大流之后，整个残余网络会被分成两个集合，一个和源点直接间接相连的点集，另一个和汇点直接间接相连的点集，所以只要BFS从源点或者汇点往前扫，一边扫一边标记，直到扫到（flow == cap）的边就停止。然后枚举边，如果一条边有一边的顶点是被标记过的，另一边的顶点没被标记，那么这条边就是最小割集之一了。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <iostream>
#include <stack>
#include <map>
#include <queue>
#include <set>
using namespace std;
typedef long long LL;
#define N 55
#define M 505
#define INF 0x3f3f3f3f
struct Edge {
    int u, v, cap;
    Edge () {}
    Edge (int u, int v, int cap) : u(u), v(v), cap(cap) {}
} edge[M*4];
vector<int> G[N];
int dis[N], cur[N], S, T, tot, vis[N], mp[N][N];

void Add(int u, int v, int cap) {
    edge[tot] = Edge(u, v, cap);
    G[u].push_back(tot++);
    edge[tot] = Edge(v, u, 0);
    G[v].push_back(tot++);
}

int BFS() {
    memset(dis, INF, sizeof(dis));
    queue<int> que;
    que.push(S); dis[S] = 0;
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int i = 0; i < G[u].size(); i++) {
            Edge &e = edge[G[u][i]];
            if(dis[e.v] == INF && e.cap > 0) {
                dis[e.v] = dis[u] + 1;
                que.push(e.v);
            }
        }
    }
    return dis[T] < INF;
}

int DFS(int u, int maxflow) {
    if(u == T) return maxflow;
    for(int i = cur[u]; i < G[u].size(); i++) {
        cur[u] = i;
        Edge &e = edge[G[u][i]];
        if(dis[e.v] == dis[u] + 1 && e.cap > 0) {
            int flow = DFS(e.v, min(e.cap, maxflow));
            if(flow > 0) {
                e.cap -= flow;
                edge[G[u][i]^1].cap += flow;
                return flow;
            }
        }
    }
    return 0;
}

int Dinic() {
    int ans = 0;
    while(BFS()) {
        int flow;
        memset(cur, 0, sizeof(cur));
        while(flow = DFS(S, INF)) ans += flow;
    }
    return ans;
}

void bfs() {
    queue<int> que;
    que.push(S); vis[S] = 1;
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int i = 0; i < G[u].size(); i++) {
            Edge &e = edge[G[u][i]];
            if(!vis[e.v] && e.cap > 0) {
                vis[e.v] = 1;
                que.push(e.v);
            }
        }
    }
}

int main()
{
    int n, m;
    while(~scanf("%d%d", &n, &m), n + m) {
        int u, v, cap; tot = 0;
        for(int i = 1; i <= n; i++) G[i].clear();
        memset(mp, 0, sizeof(mp));
        memset(vis, 0, sizeof(vis));
        for(int i = 0; i < m; i++) {
            scanf("%d%d%d", &u, &v, &cap);
            Add(u, v, cap); Add(v, u, cap);
        } S = 1, T = 2;
        Dinic();
        bfs();
        for(int u = 1; u <= n; u++) {
            for(int i = 0; i < G[u].size(); i++) {
                int v = edge[G[u][i]].v;
                if(vis[u] && !vis[v] || vis[v] && !vis[u]) mp[u][v] = mp[v][u] = 1;
            }
        }
        for(int i = 1; i <= n; i++) {
            for(int j = i + 1; j <= n; j++) {
                if(mp[i][j]) printf("%d %d
", i, j);
            }
        }
        puts("");
    }
    return 0;
}