POJ 2914

题目大意：给定一个N个点、M条边的无向带权图，边的权值均为正整数。若要使它变成非连通图，需要移除的边总权值最小是多少？

N≤500，图中不存在自环，但可能有重边（这里题意没交代清楚）。

Stoer-Wagner算法裸题。英文维基：https://en.wikipedia.org/wiki/Stoer%E2%80%93Wagner_algorithm

该算法的思想之一是：对于一个无向连通图，选定某两点s，t，以及该图的一个s-t割C，则“C是该图的全局最小割”是“C是s-t的最小割”的充分不必要条件。

也就是说，如果我们求得了某两点s-t的最小割C，那么全局最小割要么就是C，要么就是另一个让s，t保持连通的割。因此我们可以在得到s-t最小割之后，将这两个节点合并，然后继续求另外某两点的最小割。

合并节点的方法：对于s，t以外的每个节点u，设边(s,u)的权值为v1（如果该边不存在则v1=0），边(t,u)的权值为v2，那么合并后的新节点与u之间连一条边，权值为v1+v2（当然如果v1=0且v2=0则不用连这条边，反正权值为0的边可以随便删）。

该算法的流程为：

def MinCutPhase(a)
    点集S ← a
    while |S| < 当前图中点的个数
        记节点u与S中所有节点之间边的权值之和为w(u)，选取不属于S且w(u)最大的节点u0
        将u0加入S
    y = 最后一个加入S的节点
    x = 倒数第二个加入S的节点
    合并点x，y
    return 合并前的w(y)

def MinCut()
    ans = +∞
    while 图中点的个数 > 1
        任选某个点a
        ans = min(ans, MinCutPhase(a))
    return ans

可以证明在MinCutPhase过程中，w(y)就是x-y最小割的总权值（详见维基，说实话我也看不懂￣□￣）。

求w(u)的过程和最小生成树的Prim算法很类似。维护一个cost数组，对于每个新加入S的节点，更新与它相连的节点的cost值。

时间复杂度：单次MinCutPhase过程的复杂度与Prim算法相同。优化前为O(N^2)，如果用邻接表+堆优化，可以将复杂度降到O(M + N logN)。

MinCutPhase过程共执行了O(N)次，因此总的复杂度为O(N^3)或O(MN + N^2 logN)。

O(N^3)的AC代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>

using namespace std;

const int maxN = 500 + 5;

int dist[maxN][maxN]; //edge (u, v) does not exist if dist[u][v] == 0
int cost[maxN];
bool erased[maxN]; //whether a vertex is erased after merging
bool vis[maxN]; //whether a vertex is visited during minCutPhase process
int N, M;

bool input()
{
    if (scanf("%d%d", &N, &M) == EOF)
        return false;

    memset(dist, 0, sizeof(dist));
    for (int u, v, w, i = 0; i < M; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        dist[u][v] = (dist[v][u] += w);
    }
    return true;
}

///@brief: merge u and v, let dist[u][i] += dist[v][i], dist[v][i] = 0; (i.e. "erase" node v)
void mergeVertex(int u, int v)
{
    for (int i = 0; i < N; i++)
    {
        dist[i][u] = (dist[u][i] += dist[v][i]);
        dist[v][i] = dist[i][v] = 0;
    }
    erased[v] = true;
}

///@brief: get the minimum s-t cut, and merge s and t
///@param remN: number of remaining vertices
int minCutPhase(int remN)
{
    memset(vis, 0, sizeof(vis));
    memset(cost, 0, sizeof(cost));

    int cur = static_cast<int>(find(erased, erased + N, false) - erased); //find a non-erased node
    int pre = cur;
    vis[cur] = true;

    for (int i = 1; i < remN; i++) //repeat (remN - 1) times
    {
        for (int to = 0; to < N; to++)
            cost[to] += dist[cur][to];

        int maxCost = 0;
        int maxCostVertex = 0;
        for (int j = 0; j < N; j++)
        {
            if (!vis[j] && cost[j] > maxCost)
            {
                maxCost = cost[j];
                maxCostVertex = j;
            }
        }

        if (maxCost == 0) //not updated at all, indicating that the graph is not connected
            return 0;

        pre = cur;
        cur = maxCostVertex;
        vis[cur] = true;
    }

    mergeVertex(pre, cur);
    return cost[cur];
}

int minCut()
{
    memset(erased, 0, sizeof(erased));

    int ans = INT_MAX;
    for (int remN = N; remN > 1; --remN)
    {
        int t = minCutPhase(remN);
        if (t == 0)
            return 0;
        ans = min(ans, t);
    }
    return ans;
}

int main()
{
    while (input())
        printf("%d
", minCut());
    return 0;
}

 ( G , w , a ) {displaystyle (G,w,a)}

  
    
      
        
          |
        
        V
        
          |
        
        >
        1
      
    
    {displaystyle |V|>1}
  

       MinimumCutPhase
  
    
      
        (
        G
        ,
        w
        ,
        a
        )
      
    
    {displaystyle (G,w,a)}
  

       if the cut-of-the-phase is lighter than the current minimum cut
           then store the cut-of-the-phase as the current minimum cut