最小权顶点覆盖问题

问题描述：

给定一个赋权无向图G=(V,E)，每个顶点v∈V都有一个权值w(v)。如果UV，且对任意（u,v）∈E有u∈U或v∈U，就称U为图G的一个顶点覆盖。G的最小权顶点覆盖是指G中所含顶点权之和最小的顶点覆盖。

问题解决：

用优先队列分支限界方法解最小权顶点覆盖，在算法的搜索的进程中保存当前已构造出的部分解空间树，在算法搜索达到叶节点时，其最优值对应的最优解同时保存下来。优先队列的优先级为每个活节点的权值，权值最小的活节点成为下一个扩展节点。

<1>、算法思路：

算法BBVC求取最小权顶点覆盖的最优值和最优解；算法cover判断图中顶点是否被完全覆盖；算法AddLiveNode将产生的子节点加入到活节点优先队列的最小堆中；算法MinCover返回最小权顶点覆盖的最优值和最优解。

<2>、算法程序：

#include<iostream>
#include<fstream>
#include"MinHeap.h"
using namespace std;

//最小堆结点
class HeapNode                              //堆结点类；
{
friend class DealNode;
public:
operator int()const{return cn;}
private:
int i,                                  //i标示堆中结点号
cn,                                 //cn标示当前加入的覆盖顶点中权重之和
*x,                                 //x数组标示那些顶点加入了覆盖顶点的行列
*c;                                 //c数组标示X中的覆盖顶点中所有的邻接顶点
};

// VC类用来对堆中结点内部的的操作
class DealNode
{
friend MinCover(int **,int [],int);
private:
void BBVC();
bool cover(HeapNode E);
void AddLiveNode(MinHeap<HeapNode>&H,HeapNode E,int cn,int i,bool ch);
int **a,n,*w,*bestx,bestn;
};

void DealNode::BBVC()
{
//建立初始空堆
MinHeap<HeapNode>H(1000);
HeapNode E;
E.x=new int[n+1];
E.c=new int[n+1];
for(int j=1;j<=n;j++)
{
E.x[j]=E.c[j]=0;
}

int i=1,cn=0;
while(true)
{
if(i>n)
{
if(cover(E))
{
for(int j=1;j<=n;j++)
bestx[j]=E.x[j];
bestn=cn;
break;
}
}
else
{
if(!cover(E))
AddLiveNode(H,E,cn,i,true);//加入结点标号为i 的结点到顶点覆盖集中，并把更新后的结点再插入堆中
AddLiveNode(H,E,cn,i,false); //不把结点标号为 i 的结点加入到顶点覆盖集中，并把更新后的结点插入堆中
}
if(H.IsEmpty())break;
H.RemoveMin(E);  //取堆顶点赋给E
cn=E.cn;
i=E.i+1;
}
}

//检测图是否被覆盖
bool DealNode::cover(HeapNode E)
{
for(int j=1;j<=n;j++)
{
if(E.x[j]==0 && E.c[j]==0)//存在任意一条边的两个顶点都为0的情况下，为未覆盖情况
return false;      //X[j]记录覆盖顶点，c[j]记录与覆盖顶点相连的顶点 0表征未覆盖，1表征已覆盖
}
return true;
}

void DealNode::AddLiveNode(MinHeap<HeapNode> &H,HeapNode E,int cn,int i,bool ch)
{
HeapNode N;
N.x=new int[n+1];
N.c=new int[n+1];
for(int j=1;j<=n;j++)
{
N.x[j]=E.x[j];
N.c[j]=E.c[j];
}
N.x[i] = ch ? 1:0;

if(ch)
{
N.cn=cn+w[i];       //记录i顶点是否加入覆盖的行列中；
for(int j=1;j<=n;j++)
if(a[i][j]>0)   //如果i,j相邻，刚把j顶点加入覆盖邻接顶点集中；
N.c[j]++;
}
else
{
N.cn=cn;
}
N.i=i;
H.Insert(N);                                                        //插入堆中
}

int MinCover(int **a,int v[],int n)
{
DealNode Y;
Y.w=new int[n+1];
for(int j=1;j<=n;j++)
{
Y.w[j]=v[j];                   //初始化DealNode类对象Y;
}
Y.a=a;
Y.n=n;
Y.bestx=v;                        //将地址赋予bestx，
Y.BBVC();
return Y.bestn;                   //bestn是最后的最小顶点覆盖集权重；
}

int main()
{
int startV,endV;        //一条边的起始节点，终止节点
int vertexNum,edgeNum;  //顶点数，边数

//读出输入文件中的数据
fstream fin;
fin.open("input.txt",ios::in);
if(fin.fail())
{
cout<<"File does not exist!"<<endl;
cout<<"Exit program"<<endl;
return 0;
}

fin>>vertexNum>>edgeNum;

int **a;                            //图的邻接矩阵表示，1表示有边
a=new int *[vertexNum+1];

for(int k=0;k<=vertexNum;k++)
a[k]=new int[vertexNum+1];
for(int i=0;i<=vertexNum;i++)
for(int j=0;j<=vertexNum;j++)
a[i][i]=0;

int *p;                             //顶点的权值数组
p=new int[vertexNum+1];
for(i=1;i<=vertexNum;i++)
fin>>p[i];

for(i=1;i<=edgeNum;i++)
{
fin>>startV>>endV;
a[startV][endV]=1;
a[endV][startV]=1;
}

//将结果数据写入到输出文件
fstream fout;
fout.open("output.txt",ios::out);

int minVertex=MinCover(a,p,vertexNum);

cout<<minVertex<<endl;
fout<<minVertex<<endl;

for(i=1;i<=vertexNum;i++)
{
cout<<p[i]<<" ";
fout<<p[i]<<" ";
}

cout<<endl;

fin.close();
fout.close();
system("pause");
return 0;
}
2387

其中最小堆代码MinHeap.h

template <class Type>
class MinHeap                           //最小堆类；
{
public:
MinHeap(Type a[], int n);           //带两参数的构造函数，在此程序中没有应用；
MinHeap(int ms);                    //构造函数重载，只初始化堆的大小，对堆中结点不初始化；另外，堆元素的存储是以数组
~MinHeap();                         //形式，且无父、子指针，访问父亲结点，利用数组标号进行；
bool Insert(const Type &x);         //插入堆中一个元素；
bool RemoveMin(Type &x);            //删除堆顶最小结点；
void MakeEmpty();                   //使堆为空
bool IsEmpty();
bool IsFull();
int Size();
protected:
void FilterDown(const int start, const int endOfHeap);            //自顶向下构造堆
void FilterUp(const int start);                                   //自底向上构造堆
private:
Type *heap;
int maxSize;
const int defaultSize;
int currentSize;                                                  //堆当前结点个数大小
};

template <class Type>
MinHeap<Type>::MinHeap(int ms):defaultSize(100)
{
maxSize = (ms>defaultSize) ? ms : defaultSize;
heap=new Type[maxSize];
currentSize=0;
}

template <class Type>
MinHeap<Type>::MinHeap(Type a[], int n):defaultSize(100)
{
maxSize = (n>defaultSize) ? n : defaultSize;
heap=new Type[maxSize];
currentSize=n;
for (int i=0; i<n; i++) heap[i]=a[i];
int curPos=(currentSize-2)/2;
while (curPos>=0)
{
FilterDown(curPos, currentSize-1);
curPos--;
}
}

template <class Type>
MinHeap<Type>::~MinHeap()
{
delete []heap;
}

template <class Type>
void MinHeap<Type>::FilterDown(const int start, const int endOfHeap)
{
int i=start, j=i*2+1;
Type temp=heap[i];
while (j<=endOfHeap)
{
if (j<endOfHeap&&heap[j]>heap[j+1]) j++;
if (temp<heap[j]) break;
else
{
heap[i]=heap[j];
i=j;
j=2*i+1;
}
}
heap[i]=temp;
}

template <class Type>
void MinHeap<Type>::FilterUp(const int start)
{
int i=start, j=(i-1)/2;
Type temp=heap[i];
while (i>0)
{
if (temp>=heap[j]) break;
else
{
heap[i]=heap[j];
i=j;
j=(i-1)/2;
}
}
heap[i]=temp;
}

template <class Type>
bool MinHeap<Type>::RemoveMin(Type &x)
{
if (IsEmpty())
{
cerr<<"Heap empty!"<<endl;
return false;
}
x=heap[0];
heap[0]=heap[currentSize-1];
currentSize--;
FilterDown(0, currentSize-1);
return true;
}

template <class Type>
bool MinHeap<Type>::Insert(const Type &x)
{
if (IsFull())
{
cerr<<"Heap Full!"<<endl;
return false;
}
heap[currentSize]=x;
FilterUp(currentSize);
currentSize++;
return true;
}

template <class Type>
bool MinHeap<Type>::IsEmpty()
{
return currentSize==0;
}

template <class Type>
bool MinHeap<Type>::IsFull()
{
return currentSize==maxSize;
}

template <class Type>
void MinHeap<Type>::MakeEmpty()
{
currentSize=0;
}

template <class Type>
int MinHeap<Type>::Size()
{
return currentSize;
}