poj 2914 Minimum Cut 求无向图的最小割 Stoer-Wagner算法模板

用求最大流的方法去求无向图的最小割，C(n,2)枚举s和t，每次都得重新加载图。。直接TLE。。看来得学新方法了。正解将会在之后给出。

//这个程序TLE了
#include <cstdio>
#include <iostream>
#include <cstring>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;

struct edge{
    int to, cap, rev;
    edge(int to, int cap, int rev) :
        to(to), cap(cap), rev(rev) {}
};

const int inf = 0x7fffffff;
const int maxv = 500;
const int maxe = 500*499/2;
vector<edge> G[maxv+5];
int level[maxv+5];
int iter[maxv+5];
int X[maxe+5], Y[maxe+5], C[maxe+5];

inline void AddEdge(int from, int to, int cap){
    G[from].push_back(edge(to, cap, G[to].size()));
    G[to].push_back(edge(from, 0, G[from].size() - 1));
}

void bfs(int s){
    memset(level, -1, sizeof(level));
    queue<int> que;
    level[s] = 0;
    que.push(s);
    while(!que.empty()){
        int v = que.front(); que.pop();
        for(int i=0; i<G[v].size(); i++){
            edge& e = G[v][i];
            if(e.cap > 0 && level[e.to] < 0){
                level[e.to] = level[v] + 1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v, int t, int f){
    if(v == t) return f;
    for(int& i=iter[v]; i<G[v].size(); i++){
        edge& e = G[v][i];
        if(e.cap > 0 && level[v] < level[e.to]){
            int d = dfs(e.to, t, min(f, e.cap));
            if(d > 0){
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int MaxFlow(int s, int t){
    int flow = 0;
    while(true){
        bfs(s);
        if(level[t] < 0) return flow;
        memset(iter, 0, sizeof(iter));
        int f;
        while((f = dfs(s, t, inf)) > 0){
            flow += f;
        }
    }
}

int main(){
    int N, M;
    while(~scanf("%d%d", &N, &M)){
        for(int i=0; i<N; i++)
            G[i].clear();
        for(int i=0; i<M; i++){
            scanf("%d%d%d", &X[i], &Y[i], &C[i]);
            AddEdge(X[i], Y[i], C[i]);
            AddEdge(Y[i], X[i], C[i]);
        }
        //printf("%d\n", MaxFlow(0, N-1));
        //printf("%d\n", MaxFlow(0, N-1));
        int res = inf;
        for(int i=0; i<N-1; i++){
            for(int j=i+1; j<N; j++){
                for(int k=0; k<N; k++) G[k].clear();
                for(int k=0; k<M; k++){
                    AddEdge(X[k], Y[k], C[k]);
                    AddEdge(Y[k], X[k], C[k]);
                }
                int mf = MaxFlow(i, j);
                //cout<<mf<<" ";
                if(mf < res) res = mf;
            }
            //cout<<endl;
        }
        printf("%d\n", res);
    }
    return 0;
}

不会了。。网上找的模板，Stoer-Wagner算法，速度还蛮快的。http://blog.csdn.net/vsooda/article/details/7397449

模板代码如下：

//Stoer-Wagner算法
//无向图全局最小割，用求prim类似方法o（n^3)
//一开始用枚举源点汇点的最大流求解，复杂度o(n^5) 超时
//1128K	3250MS
#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;

const int maxn = 500;
const int inf = 0x7fffffff;
int mat[maxn+5][maxn+5];
int res;

void Mincut(int n) {
    int node[maxn+5], dist[maxn+5];
    bool visit[maxn+5];
    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 = inf;
        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);
    }
    return 0;
}