最小割集◎Stoer-Wagner演算法

一個無向連通網路，去掉一個邊集可以使其變成兩個連通分量則這個邊集就是割集；最小割集當然就權和最小的割集。
可以用最小切割最大流定理：
1.min=MAXINT,確定一個源點
2.列舉匯點
3.計算最大流，並確定當前源匯的最小割集，若比min小更新min
4.轉到2直到列舉完畢
5.min即為所求輸出min
不難看出複雜度很高：列舉匯點要O(n)，最短增廣路最大流演算法求最大流是O((n^2)m)複雜度，在複雜網路中O(m)=O(n^2)，演算法總複雜度 就是O(n^5)；哪怕採用最高標號預進流演算法求最大流O((n^2)(m^0.5))，演算法總複雜度也要O(n^4)
所以用網路流演算法求解最小割集複雜度不會低於O(n^4)。
－－－－－－－－－
prim演算法不僅僅可以求最小生成樹，也可以求“最大生成樹”。最小割集Stoer-Wagner演算法就是典型的應用例項。
求解最小割集普遍採用Stoer-Wagner演算法，不提供此演算法證明和程式碼，只提供演算法思路：
1.min=MAXINT，固定一個頂點P
2.從點P用類似prim的s演算法擴展出“最大生成樹”，記錄最後擴充套件的頂點和最後擴充套件的邊
3.計算最後擴充套件到的頂點的切割值（即與此頂點相連的所有邊權和），若比min小更新min
4.合併最後擴充套件的那條邊的兩個端點為一個頂點（當然他們的邊也要合併，這個好理解吧？）
5.轉到2，合併N-1次後結束
6.min即為所求，輸出min
prim本身複雜度是O(n^2)，合併n-1次，演算法複雜度即為O(n^3)
如果在prim中加堆優化，複雜度會降為O((n^2)logn) 　　

#include <iostream>
using namespace std;
int mat[600][600];
int res;
//Stoer-Wagner演算法，加了自己看得懂的備註
//無向圖全域性最小割，用求prim類似方法o（n^3)，學習了一個下午……
//一開始用列舉源點匯點的最大流求解，複雜度o(n^5) 超時
 
void Mincut(int n) {
    int node[600], dist[600];
    bool visit[600];
    int i, prev, maxj, j, k;
    for (i = 0; i < n; i++)
        node[i] = i;
    while (n > 1) {
        int maxj = 1;
        for (i = 1; i < n; i++) { //初始化到已圈集合的割大小
            dist[node[i]] = mat[node[0]][node[i]];
            if (dist[node[i]] > dist[node[maxj]])
                maxj = i;
        }
        prev = 0;
        memset(visit, false, sizeof (visit));
        visit[node[0]] = true;
        for (i = 1; i < n; i++) {
            if (i == n - 1) { //只剩最後一個沒加入集合的點，更新最小割
                res = min(res, dist[node[maxj]]);
                for (k = 0; k < n; k++) //合併最後一個點以及推出它的集合中的點
                    mat[node[k]][node[prev]] = (mat[node[prev]][node[k]] += mat[node[k]][node[maxj]]);
                node[maxj] = node[--n]; //縮點後的圖
            }
            visit[node[maxj]] = true;
            prev = maxj;
            maxj = -1;
            for (j = 1; j < n; j++)
                if (!visit[node[j]]) { //將上次求的maxj加入集合，合併與它相鄰的邊到割集
                    dist[node[j]] += mat[node[prev]][node[j]];
                    if (maxj == -1 || dist[node[maxj]] < dist[node[j]])
                        maxj = j;
                }
        }
 
    }
    return;
}
 
int main() {
    int n, m, a, b, v;
    while (scanf("%d%d", &n, &m) != EOF) {
        res = (1 << 29);
        memset(mat, 0, sizeof (mat));
        while (m--) {
            scanf("%d%d%d", &a, &b, &v);
            mat[a][b] += v;
            mat[b][a] += v;
        }
        Mincut(n);
        printf("%d\n", res);
    }
}