Stoer-Wagner求无向图全局最小割

最新推荐文章于 2021-11-18 20:05:22 发布

pi9nc

最新推荐文章于 2021-11-18 20:05:22 发布

阅读量5.3k

点赞数 1

分类专栏：算法

算法专栏收录该内容

538 篇文章

订阅专栏

本文详细介绍了Stoer-Wagner算法的基本概念及其在求解无向图全局最小割问题中的应用。通过实例展示了算法的具体步骤，并给出了AC代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

最小割Stoer-Wagner算法

割：在一个图G（V，E）中V是点集，E是边集。在E中去掉一个边集C使得G（V，E-C）不连通，C就是图G（V，E）的一个割；

最小割：在G（V，E）的所有割中，边权总和最小的割就是最小割。

求G的任意s-t最小割Min-C（s，t）：

设s，t是途中的两个点且边（s，t）∈E（即s，t之间存在一条边）。如果G的最小割Cut把G分成M，N两个点集

①：如果s∈M，t∈N则Min-C（s，t）= Cut（不讨论）

②：如果s，t∈M（或者s，t∈N）则Min-C（s，t）<= Cut

我们来定义一个Contract(a,b)操作，即把a，b两个点合并，表示为删除节点b，把b的节点信息添加到a上

如下图是做了Contract（5,6）

对于所点v有w(v,5)+=w(v,6)

求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加入集合

3.若|A|=|V|，结束，否则更新w(A,x)，转到2

令倒数第二个加入A的点为s，最后一个加入A的点为t，则s-t最小割为w(At,t)

以Poj (pku) 2914 Minimum Cut

的第三个case为例，图为

G（V，E）

我们设法维护这样的一个w[]，初始化为0；

我们把V-A中的点中w[i]最大的点找出来加入A集合；

V-A直到为空

w[]的情况如下

w[i]	0	1	2	3	4	5	6	7
初始值	0	0	0	0	0	0	0	0
A=A∪{0}	---	1	1	1	1	0	0	0
A=A∪{1}		---	2	2	1	0	0	0
A=A∪{2}			---	3	1	0	0	0
A=A∪{3}				---	1	0	0	1
A=A∪{4}					---	1	1	2
A=A∪{7}						2	2	---
A=A∪{5}						---	3
A=A∪{6}							---

每次w[i]+=∑(i,a)的权值a∈A

记录最后加入A的节点为t=6，倒数第二个加入A的为s=5，则s-t的最小割就为w[s]，在图中体现出来的意思就是5-6的最小割为w[s]=3

然后我们做Contract(s,t)操作，得到下图

G(V’,E’)

重复上述操作

w[i]	0	1	2	3	4	5	7
初始值	0	0	0	0	0	0	0
A=A∪{0}	---	1	1	1	1	0	0
A=A∪{1}		---	2	2	1	0	0
A=A∪{2}			---	3	1	0	0
A=A∪{3}				---	1	0	1
A=A∪{4}					---	2	2
A=A∪{5}						---	4
A=A∪{7}							---

s=5，t=7 s-t最小割是4

Contract(s,t)得到

w[i]	0	1	2	3	4	5
初始值	0	0	0	0	0	0
A=A∪{0}	---	1	1	1	1	0
A=A∪{1}		---	2	2	1	0
A=A∪{2}			---	3	1	0
A=A∪{3}				---	1	1
A=A∪{4}					---	4
A=A∪{5}						---

s=4，t=5 s-t最小割是4

Contract(s,t)得到

w[i]	0	1	2	3	4
初始值	0	0	0	0	0
A=A∪{0}	---	1	1	1	1
A=A∪{1}		---	2	2	1
A=A∪{2}			---	3	1
A=A∪{3}				---	2
A=A∪{4}					---

s=3，t=4 s-t最小割是2，（此时已经得出答案，以下省略）

AC代码:

#include <iostream>

#include <stdio.h>

#include <string.h>

#include <queue>

#define INT_MAX 0x3f3f3f3f

using namespace std;

int mp[502][502];

int N,M;

bool combine[502];

int minC=INT_MAX;

void search(int &s,int &t){

bool vis[502];

int w[502];

memset(vis,0,sizeof(vis));

memset(w,0,sizeof(w));

int tmpj=1000;

for(int i=0;i<N;i++){

int max=-INT_MAX;

for(int j=0;j<N;j++){

if(!vis[j]&&!combine[j]&&max<w[j]){

max=w[j];

tmpj=j;

}

if(t==tmpj){minC=w[t];return;}

vis[tmpj]=1;

s=t,t=tmpj;

for(int j=0;j<N;j++){

if(!vis[j]&&!combine[j])

w[j]+=mp[t][j];

}

minC=w[t];

}

int mincut(){

int ans=INT_MAX;

int s,t;

memset(combine,0,sizeof(combine));

for(int i=0;i<N-1;i++){

s=t=-1;

search(s,t);

combine[t]=true;

ans=ans>minC?minC:ans;

for(int j=0;j<N;j++){

mp[s][j]+=mp[t][j];

mp[j][s]+=mp[j][t];

}

return ans;

}

int main(){

//freopen("in.txt","r",stdin);

while(cin>>N>>M){

memset(mp,0,sizeof(mp));

int u,v,w;

while(M--){

scanf("%d %d %d",&u,&v,&w);

mp[u][v]+=w;

mp[v][u]+=w;

}

cout<<mincut()<<endl;

}

return 0;

}

hdu3691Nubulsa Expo(Stoer-Wagner求无向图全局最小割)

分类：图论 2013-10-04 17:57 128人阅读评论(0) 收藏举报

 
 图论 

题目请戳这里

题目大意：给一张图，n个点，m条无向边，每条边有权值，表示该路人流量上界。给定起点s，问如何选终点t，能是s-t的所有路径上最小人流量总和最大，给出这个最大流量。

题目分析：根据最大流最小割定理，此题就是求一个最小割。给定的起点是无用信息，因为起点一定在某个割集中，那么终点在另一个割集随便找一点即可。所以此题求的是一个全局最小割。最大流可以解决。但需要O(n)枚举终点。再加上最大流的复杂度，至少要O(n^4)，对于此题来说复杂度偏高，所以要找其他算法。

Stoer-Wagner算法是求无向图全局最小割的一个有效算法，最坏时间复杂度O(n^3)，主要思想是先找任意2点的最小割，然后记录下这个最小割，再合并这2个点。这样经过n-1次寻找任意2点最小割，每次更新全局最小割，最后整张图缩成一个点，算法结束，所保存下来的最小割就是全局最小割。

Stoer-Wagner的正确性：

设s和t是图G的2个顶点，图G的全局最小割要么是s-t的最小割，此时s和t在G的全局最小割的2个不同的子集中，或者是G中将s和t合并得的的新图G'的全局最小割，此时s和t在G的全局最小割的同一个子集中。所以只需要不断求出当前图中任意2个点的最小割，然后合并这2个点。不断缩小图的规模求得最小割。

关于更详细的Stoer-Wagner算法：

1：这是英文版论文，英语太烂，没勇气看，不过里面有个插图蛮好的，可以很直观的体会这个算法的工作过程。

2：这篇给了一点证明

3：看看吧

详情请见代码：

[cpp]view plaincopy 
    
 #include <iostream>  
 #include<cstdio>  
 #include<cstring>  
 #include<algorithm>  
 using namespace std;  
 const int N = 305;  
 const int M = 50005;  
 const int inf = 0x3f3f3f3f;  
 int g[N][N],v[N],dis[N];  
 bool vis[N];  
 int m,n,s;  
 void build()  
 {  
     int a,b,c;  
     memset(g,0,sizeof(g));  
     while(m --)  
     {  
         scanf("%d%d%d",&a,&b,&c);  
         g[a][b] += c;  
         g[b][a] += c;  
     }  
 }  
 void solve()  
 {  
     int i,j;  
     int ans = inf;  
     int maxx,maxi;  
     int s,t;  
     for(i = 1;i <= n;i ++)  
         v[i] = i;//初始化点集  
     while(n > 1)  
     {  
         int cur,pre;  
         cur = 1;  
         memset(dis,0,sizeof(dis));  
         memset(vis,false,sizeof(vis));  
         for(i = 2;i <= n;i ++)  
         {  
             dis[v[i]] = g[v[1]][v[i]];  
         }  
         vis[v[1]] = true;  
         for(i = 1;i < n;i ++)  
         {  
             maxx = -1;  
             maxi = 0;  
             for(j = 1;j <= n;j ++)  
             {  
                 if(vis[v[j]] == false && maxx < dis[v[j]])  
                 {  
                     maxx = dis[v[j]];//找离当前集合最远的点  
                     maxi = j;  
                 }  
             }  
             vis[v[maxi]] = true;  
             if(i == n - 2)  
                 s = maxi;  
             if(i == n - 1)  
                 t = maxi;  
             for(j = 1;j <= n;j ++)  
             {  
                 if(vis[v[j]] == false)  
                     dis[v[j]] += g[v[maxi]][v[j]];  
             }  
         }  
         ans = min(ans,dis[v[t]]);  
         for(i = 1;i <= n;i ++)  
         {  
             g[v[s]][v[i]] += g[v[t]][v[i]];  
             g[v[i]][v[s]] = g[v[s]][v[i]];  
         }  
         v[maxi] = v[n];  
         n --;  
     }  
     printf("%d\n",ans);  
 }  
 int main()  
 {  
     while(scanf("%d%d%d",&n,&m,&s),n)  
     {  
         build();  
         solve();  
     }  
     return 0;  
 }  