无向图的最大割问题的实现

问题描述：

什么是无向图的最大割？

有无向图G=(V,E).设U是V的一个子集。对任意的顶点u,v如果(u,v)是E中的一条边，如果u在U中，则v一定不

在U中，这样的边称为顶点集合U的一个割边。那个这个顶点集合U所有的割边就构成图G的一个割。最大割

的意思，就是说含割边最多的割。

编程任务：

给定一个无向图G，计算G的最大割。

数据输入：

第一行2个整数 n,e表示顶点个数和边个数。下面e行是边,每行2个整数对应顶点编号。顶点编号从1-n;

数据输出：

第一行是最大割的边数。

第二行是顶点集的向量对应1-n,0表示不在集合，1表示在集合。

解题思想：

这道题也是一个子集选取问题，所以它的解空间树是一个子集树。这个集合n个元素，每个元素可以有

选取或不选取2种选择，所以共用2^n个子集。

这里用分支界限法。

分支界限法：类似宽度优先搜索，它和回溯的区别在与，它每次都取一个节点，然后把它的所有的儿子节点

都扩展，然后加到队列中，所以说，分支界限法，这种扩展方式导致没个节点最多一次扩展机会，它在扩展

它的分支的时候，根据一定的界限条件，或淘汰不可能产生最优解的分支。

这里的队列有2种，一种是普通队列就是先进先出。

另一种就是优先级队列，它会根据优先级进行出队，这和Windows中的消息队列类似。

在C++中，STL中priority_queue就是优先级队列。queue是普通队列。优先级队列可以用最大堆或最小堆

实现。

#include <iostream>
#include <queue>
using namespace std;

int n,e;//顶点数和边数
int Graph[200][200];//存储图的邻接矩阵
int bestcut = 0;//存储最优解
int bestx[200];//存储最优解
struct HeapNode//队列节点
{
HeapNode()
{
      memset(x,0,sizeof(x));
}
int i;
int cut;
int edges;
int x[200];
    booloperator < (const HeapNode&a)const
{
   returncut<a.cut;
}
};
void maxcut()
{
    HeapNodeE;
priority_queue<HeapNode> Q;
E.cut = 0;
E.edges = e;
E.i = 0;
while (1)
{
   if (E.i==n)
   {
           if (E.cut>bestcut)
           {
    bestcut = E.cut;
    memcpy(bestx,E.x,sizeof(int)*n);
           }
   }
   else
   {
    HeapNodetemp = E;
    int i =E.i;
    for (intj=0;j<n;j++)
    {
    if (Graph[i][j])
    {
     if (temp.x[j])
     {
      temp.cut--;
     }
     else
     {
      temp.cut++;
      temp.edges--;
     }
    }
    }
    temp.x[i] =1;
           temp.i++;
   Q.push(temp);
    if(E.cut+E.edges>bestcut)//界限条件
    {
               E.i++;
    Q.push(E);
    }
   }
   if(Q.size()==0)//队列为空跳出循环
   {
    break;
   }
   E = Q.top();
   Q.pop();
}
}
int main()
{
    intu,v;
cin>>n>>e;
for (int i=0;i<e;i++)
{
  cin>>u>>v;
   Graph[u-1][v-1] = 1;
   Graph[v-1][u-1] = 1;
}
   maxcut();
cout<<bestcut<<endl;
for (int k=0;k<n;k++)
{
  cout<<bestx[k]<<'';
}
cout<<endl;
return 0;
}

输入实例

7 18
1 4
1 5
1 6
1 7
2 3
2 4
2 5
2 6
2 7
3 4
3 5
3 6
3 7
4 5
4 6
5 6
5 7
6 7

输出实例：

12
1 1 1 0 1 0 0