全局最小割集Stoer-Wagner算法

转自：http://www.cnblogs.com/ylfdrib/archive/2010/08/17/1801784.html

【ZZ】最小割集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)

这个Stoer-Wagner算法可以参见这篇paper(http://docs.google.com/fileview?id=0BwxLvD9mcDNtMjk3MWVkMTAtZjMzNi00ZWE3LTkxYjQtYTQwNzcyZTk3Njk2&hl=en), 其核心思想是迭代缩小规模, 算法基于这样一个事实:

 

对于图中任意两点s和t, 它们要么属于最小割的两个不同集中, 要么属于同一个集.

 

如果是后者, 那么合并s和t后并不影响最小割. 基于这么个思想, 如果每次能求出图中某两点之间的最小割, 然后更新答案后合并它们再继续求最小割, 就得到最终答案了. 算法步骤如下:

 

1. 设最小割cut=INF, 任选一个点s到集合A中, 定义W(A, p)为A中的所有点到A外一点p的权总和.

2. 对刚才选定的s, 更新W(A,p)(该值递增).

3. 选出A外一点p, 且W(A,p)最大的作为新的s, 若A!=G(V), 则继续2.

4. 把最后进入A的两点记为s和t, 用W(A,t)更新cut.

5. 新建顶点u, 边权w(u, v)=w(s, v)+w(t, v), 删除顶点s和t, 以及与它们相连的边.

6. 若|V|!=1则继续1.

 

看起来很简单, 每次像做最大生成树一样选最大"边"(注意, 这里其实不是边, 而是已经累计的权值之和, 就当是加权的度好了), 然后把最后进入的两个点缩到一块就可以了. 合并点最多有n-1次, 而不加堆优化的prim是O(n^2)的, 所以最终复杂度O(n^3), 要是你有心情敲一大坨代码, 还可以在稀疏图上用Fibonacci Heap优化一下, 不过网上转了一圈, 大多都是说能用Fibonacci Heap优化到怎样怎样的复杂度, 真正能自己写出来的恐怕也没几个, 看看uoregon(俄勒冈大学)的一大坨代码就有点寒. (http://resnet.uoregon.edu/~gurney_j/jmpc/fib.html)

 

特别注意几个地方, 网上的好几个Stoer-Wagner版本都存在一些小错误:

 

1. 算法在做"最大生成树"时更新的不是普通意义上的最大边, 而是与之相连的边的权值和, 当所有边都是单位权值时就是累计度.

2. "最后进入A的两点记为s和t", 网上对s有两种解释, 一是在t之前一个加进去的点, 二是t的前趋节点, 也就是最后选择的那条边的另一端. 正解是第一种!

3. 对于稠密图, 比如这题, 我用堆, 映射二分堆, 或者STL的优先队列都会TLE, 还不如老老实实O(n^3).

 

 

另一篇论文：

 

最小割 Stoer-Wagner 算法 
Etrnls 2007-4-15 
Stoer-Wagner 算法用来求无向图 G=(V, E)的全局最小割。 

算法基于这样一个定理：对于任意s, t   V ∈ ，全局最小割或者等于原图的s-t 最小割，或者等于将原图进行 Contract(s, 
t)操作所得的图的全局最小割。 

算法框架： 
1. 设当前找到的最小割MinCut 为+∞  
2. 在 G中求出任意 s-t 最小割 c，MinCut = min(MinCut, c)   
3. 对 G作 Contract(s, t)操作，得到 G'=(V', E')，若|V'| > 1，则G=G'并转 2，否则MinCut 为原图的全局最
小割  

Contract 操作定义： 
若不存在边(p, q)，则定义边(p, q)权值w(p, q) = 0 
Contract(a, b): 删掉点 a, b 及边(a, b)，加入新节点 c，对于任意 v  V ∈ ，w(v, c) = w(c, v) = w(a, v) + w(b, 
v) 

求 G=(V, E)中任意 s-t 最小割的算法： 
定义w(A, x) = ∑w(v[i], x)，v[i]  A ∈  
定义 Ax 为在x 前加入 A 的所有点的集合（不包括 x）  
1. 令集合 A={a}，a为 V中任意点  
2. 选取 V - A中的 w(A, x)最大的点 x加入集合 A  
3. 若|A|=|V|，结束 
令倒数第二个加入 A的点为 s，最后一个加入 A的点为 t，则s-t 最小割为 w(At, t)

 

再加一份模板

hdu3691

1. #include<cstdio>  
2. #include<cstring>  
3. #include<algorithm>  
4.   
5. using namespace std;  
6.   
7. const int maxn=310;  
8. const int inf=0x3f3f3f3f;  
9. int maze[maxn][maxn];  
10. int n,m,s;  
11. int v[maxn],dis[maxn],vis[maxn];  
12. int res;  
13.   
14. int sw(int n)  
15. {  
16.     res=inf;  
17.     for(int i=0;i<n;i++)  
18.         v[i]=i+1;  
19.     while(n>1)  
20.     {  
21.         int maxp=1,prev=0;  
22.         for(int i=1;i<n;i++)  
23.         {  
24.             dis[v[i]]=maze[v[0]][v[i]];  
25.             if(dis[v[i]]>dis[v[maxp]])  
26.                 maxp=i;  
27.         }  
28.         memset(vis,0,sizeof(vis));  
29.         vis[v[0]]=1;  
30.         for(int i=1;i<n;i++)  
31.         {  
32.             if(i==n-1)  
33.             {  
34.                 res=min(res,dis[v[maxp]]);  
35.                 for(int j=0;j<n;j++)  
36.                 {  
37.                     maze[v[prev]][v[j]]+=maze[v[j]][v[maxp]];  
38.                     maze[v[j]][v[prev]]=maze[v[prev]][v[j]];  
39.                 }  
40.                 v[maxp]=v[--n];  
41.             }  
42.             vis[v[maxp]]=1;  
43.             prev=maxp;  
44.             maxp=-1;  
45.             for(int j=1;j<n;j++)  
46.             {  
47.                 if(!vis[v[j]])  
48.                 {  
49.                     dis[v[j]]+=maze[v[prev]][v[j]];  
50.                     if(maxp==-1||dis[v[maxp]]<dis[v[j]])  
51.                         maxp=j;  
52.                 }  
53.             }  
54.         }  
55.     }  
56.     return res;  
57. }  
58. int main()  
59. {  
60.     int x,y,z;  
61.     while(~scanf("%d%d%d",&n,&m,&s))  
62.     {  
63.         if(!n&&!m&&!s)  
64.             break;  
65.         memset(maze,0,sizeof(maze));  
66.         while(m--)  
67.         {  
68.             scanf("%d%d%d",&x,&y,&z);  
69.             maze[x][y]+=z;  
70.             maze[y][x]+=z;  
71.         }  
72.         printf("%d\n",sw(n));  
73.     }     
74. }