poj 2914 Minimum Cut 无向图最小割

Stoer-Wagner算法

附模板

Stoer-Wagner算法：

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;
#define MAXN 511
int map[MAXN][MAXN];
//model start
inline int min(int a, int b) {
	return a > b ? b : a;
}
int MinCut(int n) {
	int ans = 0x7fffffff;
    int node[MAXN], dist[MAXN];
    bool visit[MAXN];
    int i, prev, 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]] = map[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) {
                ans = min(ans, dist[node[maxj]]);
                for(k = 0; k < n; k++)
                    map[node[k]][node[prev]] = (map[node[prev]][node[k]] += map[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]]) {
                    dist[node[j]] += map[node[prev]][node[j]];
                    if(maxj == -1 || dist[node[maxj]] < dist[node[j]])
                        maxj = j;
                }
			}
        }
    }
	return ans;
}
//model end
int main() {
//freopen("in.txt", "r", stdin);
	int n, m;
	int a, b, w;
	while(scanf("%d%d", &n, &m) != EOF) {
		//init
		memset(map, 0, sizeof(map));
		for(int i=0; i<m; i++) {
			scanf("%d%d%d", &a, &b, &w);
			map[a][b] += w;
			map[b][a] += w;
		}
		//print ans
		printf("%d/n", MinCut(n));
	}
	return 0;
}