关于一个应用分枝界限法解决最小顶点覆盖问题的程序说明

最新推荐文章于 2023-06-05 19:00:08 发布
最新推荐文章于 2023-06-05 19:00:08 发布
阅读量3.2k 收藏 6
点赞数
文章标签： class insert delete 扩展 c 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhshow/article/details/5481370
版权

 

//程序下载自：http://download.csdn.net/source/1930594

//头文件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;

}

//MinCover.cpp
#include<iostream.h>
#include<fstream.h>
#include"MinHeap.h"
int *p;
//最小堆结点
class HeapNode                                                                 //堆结点类；
{
friend class VC;
public:
operator int()const{return cn;}                                       //重载运算符，比较两个结点；
private:
   int i,cn,*x,*c;                                                          //i标示堆中结点号，cn标示当前加入的覆盖顶点中权重之和，x数组标示那些                                                                                          //顶点加入了覆盖顶点的行列，c数组标示X中的覆盖顶点中所有的邻接                                                                                            // 顶点；
                                                                                       
};
class VC                                                              // VC类用来对堆中结点内部的的操作，
{
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 VC::BBVC()
{
MinHeap<HeapNode>H(100000);   //建立初始空堆；
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;                                                        
}
}
//cover
bool VC::cover(HeapNode E)
{
for(int j=1;j<=n;j++)
{
   if(E.x[j]==0&&E.c[j]==0)
    return false;        //存在任意一条边的两个顶点都为0的情况下，为未覆盖情况；X[j]记录覆盖顶点，c[j]记录与覆盖顶点相连的顶点；
}                             //0表征未覆盖，1表征已覆盖；
return true;
}
void VC::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)
{
VC Y;
Y.w=new int[n+1];
for(int j=1;j<=n;j++)
{
   Y.w[j]=v[j];       //初始化VC类对象Y;
}
Y.a=a; 
Y.n=n;
Y.bestx=v;        //将地址赋予bestx，
Y.BBVC();
return Y.bestn;      //bestn是最后的最小顶点覆盖集权重；
}                  
int main()
{
int u,v;
int n,c;
ifstream infile("input.txt");
if(!infile)
{
   cout<<"Can't open input.txt"<<endl;
   return 0;
}
ofstream outfile("output.txt");
if(!outfile)
{
   cout<<"Can't open output.txt"<<endl;
   return 0;
}
infile>>n>>c;
//Make2DArray(a,n+1,n+1);
int **a;
a=new int *[n+1];
for(int k=0;k<=n;k++)
   a[k]=new int[n+1];
for(int i=0;i<=n;i++)
   for(int j=0;j<=n;j++)
    a[i][i]=0;
p=new int[n+1];
for(i=1;i<=n;i++)
   infile>>p[i];
for(i=1;i<=c;i++)
{
   infile>>u>>v;
   a[u][v]=1;
   a[v][u]=1;
}
cout<<MinCover(a,p,n)<<endl;
for(i=1;i<=n;i++)
   cout<<p[i]<<" ";
cout<<endl;
return 0;
}
'input.txt'
7 7
1 100 1 1 1 100 10
1 6
2 4
2 5
3 6
4 5 
4 6
6 7
说明：在文章中，顶点与结点是两个不同的概念，结点中有记录当前加入顶点覆盖集的 i,有加入顶点覆盖集中的x[],有加入与顶点覆盖集邻接的c[]顶点集；
此程序的运行流程：首先是初始建最小堆过程，把每个顶点插入到堆中，在每个顶点的内部，X[]数组就是记录此时的顶点覆盖集，然后选取此结点内部顶点覆盖集权重之和cn最小的顶点做为扩展结点，然后以比此顶点标号大1的结点为参考(i = E.i + 1)，分别插入两个结点到堆中，一个是 i 顶点加入顶点覆盖集后的结点，一个是 i顶点没有加入顶点覆盖集后的结点，然后重新建堆，再重新移出堆结点，重复如此，直到所有顶点都被标记进x[]或c[]中（）。

 

zhutuanfei
关注
算法设计与分析: 6-3 最小权顶点覆盖问题
`!_`5 81_09
07-23 7724
6-3 最小权顶点覆盖问题 问题描述 给定一个赋权无向图 G=(V,E)，每个顶点 v∈V 都有一个权值 w(v)。如果 U⊆VU⊆VU\subseteq V，且对任意(u,v)∈E 有 u∈U 或 v∈U，就称 U 为图 G 的一个顶点覆盖。G 的最小权顶点覆盖是指 G 中所含顶点权之和最小的顶点覆盖。 对于给定的无向图 G，设计一个优先队列式分支限界法，计算 G 的最小权顶点覆盖。 ...
分枝限界法求TSP问题--C++/C
gardenpalace的博客
12-07 5040
旅行商问题（TSP）：给定一系列城市和每对城市之间的距离，求解访问每一座城市一次并回到起始城市的最短回路。它是组合优化中的一个NP困难问题，在运筹学和理论计算机科学中非常重要。 这篇文章里介绍一下基于分支限界法的TSP算法。 对于TSP，我们需要利用上界和下界来对BFS进行剪枝，通过不断更新上界和下界，尽可能的排除不符合需求的child，以实现剪枝。最终，当上限和下限等同时，我们可以获得最优的B...
分支限界法 最小权顶点覆盖问题
04-21
★问题描述：给定一个赋权无向图G=(V,E),每个顶点v∈V都有一个权值w(v)。如果U∈V,且对任意(u,v)∈E有u∈U或v∈U,就称U为图G的一个顶点条覆盖.G的最小权顶点覆盖是指G中所含顶点权之和最小的顶点覆盖。 ★算法设计：对于结定的无向图G,设计一个优先队列式分支限界法,计算G的最小权顶点覆盖。 ★数据输入：由文件input.txt给出输入数据。第1行有2个正整数n和m,表示给定的图G有n个顶点和m条边,顶点编号为1,2,.....,n.第2行有n个正整数表示n个顶点的权.接下来的m行中,每行有2 个正整数u,v,表示图G的一条边(u,v)。 ★结果输出：将计算出的最小权顶点覆盖的顶点权之和以及最优输出到文件output.txt.文件第1行是最小权顶点覆盖顶点权之和;第2行是最优解xi,1≤i≤n,xi=0表示顶点i不在最小权顶点覆盖中。
分支限界 最小权的顶点覆盖
07-09
给定一个赋权无向图G=(V,E),每个顶点v∈V都有一个权值w(v).如果UV,且对任意(u,v)∈E有u∈U,就称U为图G的一个顶点覆盖.G的最小权顶点覆盖是指G中所含顶点权之和最小的顶点覆盖. 程序运行结束时,将计算出的最小权顶点覆盖的顶点权之和以及最优解输出到文件output.txt中.文件的第1行是最小权顶点覆盖顶点权之和;文件第2行是最优解Xi.1≤i≤n,Xi=0表示顶点i不在最小权顶点覆盖中,Xi=1表示顶点i在最小权顶点覆盖中. 输入文件示例 输出文件示例 Input.txt output.txt 7 7 13 1 100 1 1 1 100 10 1 0 1 1 0 0 1 1 6 2 4 2 5 3 6 4 5 4 6 6 7
分支限界法之最小权顶点覆盖问题
weixin_44755413的博客
06-03 1万+
问题描述
最小权顶点覆盖问题：分支界限法
最新发布
qq_65209809的博客
06-05 1563
void addNode(Node a,int x){//节点添加函数,a为上一节点，x表示是否取用新的顶点（1=Y/0=N）copy(begin(a.line),end(a.line),begin(cline));if(L.top().ans==1){//全覆盖则不做扩展，尝试更新最优权值。
最小权顶点覆盖问题
nuist_NJUPT的博客
11-17 834
最小权顶点覆盖问题 键盘输入，控制台输出 import java.util.*; public class Main { static int n, m ; //顶点数和边数 static int [] w ; //权值 static int [] cover_in = new int [10000] ;//是否覆盖 static int [] [] connect = new int [10000][10000] ; //边的标记 static int tw =
分支界限法求单元点最短路径
12-14
以下是使用 C++ 语言实现的优先队列式分支限界法程序： ```cpp #include using namespace std; const int size = 100; const int inf = 5000; // 两点距离上界 // 第一组测试参数 const int n = 6; // 图顶点个...
分支定界法——旅行商(TSP)问题
热门推荐
Mind_V的博客
07-01 3万+
问题描述给定一个n顶点网络（有向或无向），找出一个包含n个顶点且具有最小耗费的换路。任何一个包含网络所有顶点的换路称为一个旅行。旅行商问题（Traveling Salesman Problem，TSP）是要寻找一条耗费最少的旅行。 图1 四顶点网络如图1是一个四顶点无向网络。这个网络的一些旅行：1,2,4,
单元最短路径问题 分支界限法
weiyang_8765的博客
07-16 3566
分支界限法类似于回溯法，也是在问题的解空间上搜索问题解的算法。回溯法以深度优先的方式搜索解空间，而分支界限法则以广度优先（队列式分支界限法）或者以最小消耗的方式（优先队列式分支界限法）搜索解空间。 队列式分支界限法：队列式分支界限法将活结点表组织成一个队列，并按照队列的先进先出原则选取下一个结点为当前扩展结点。而且队列式分支界限法不搜索以不可行结点为根的子树。 优先队列式分支界限法：优先队列式
最小权覆盖问题
06-08
算法分析课后习题
最小权顶点覆盖问题的C++代码(完整)
12-24
算法设计与分析第六章算法实现题第二题： 问题描述 给定一个赋权无向图G=(V,E),每个顶点v∈V都有一个权值w(v).如果U包含于V,且对任意(u,v)∈E有u∈U或v∈U,就称U为图G的一个顶点条覆盖.G的最小权顶点覆盖是指G中所含顶点权之和最小的顶点覆盖. 编程任务 对于结定的无向图G,设计一个优先队列式分支限界法,计算G的最小权顶点覆盖. 数据输入 由文件input.txt给出输入数据.第1行有2个正整数n和m,表示给定的图G有n个顶点和m条边,顶点编号为1,2,.....,n.第2行有n个正整数表示n个顶点的权.接下来的m行中,每行有2 个正整数u,v,表示图G的一条边(u,v) 结果输出 将计算出的最小权顶点覆盖的顶点权之和以及最优输出到文件output.txt.文件第1行是最小权顶点覆盖顶点权之和;第2行是最优解xi,1≤i≤n,xi=0表示顶点i不在最小权顶点覆盖中.
算法设计分析最小权顶点覆盖
12-30
有课程文档 有代码 你要的都有。 最小权顶点覆盖问题 问题描述： 给定一个赋权无向图G=(V,E)，每个顶点v∈V都有一个权值w(v)。如果 ，且对任意(u,v)∈E有u∈U或v∈U，就称U为图G的一个顶点覆盖。G的最小权顶点覆盖是指G中所含顶点权之和最小的顶点覆盖。 编程任务： 对于给定的无向图G，设计一个优先队列式分支限界法，计算G的最小权顶点覆盖。
算法课设 - 众数问题，最小权顶点覆盖问题，C++
欢迎光临 我的心
11-01 2231
众数问题 算法分析 题意描述 输入一个大小为n的有序数组，求该数组中出现次数最多的数，及其出现的次数，注：当有多个数出现次数最多时，只输出一个。 算法过程描述 假设我们先求出中位数的重数，再求出中位数往左往右延伸的距离，假设当前数组左右边界为l,r,中位数位置为mid，向左向右延伸为nl，nr。这样就把原数组分为三个子数组：[l,nl-1]，[nl,nr]，[nr+1,nr]，用第二个子数组的长度更新答案，对第一个和第三个子数组继续重复刚才的动作，为了优化搜索，当子数组大小小于当前最优解时，进行剪枝 递归方
最小权顶点覆盖问题——回溯法
lhy666lhy的博客
06-10 1652
#include<iostream> using namespace std; int bestw=100000; int n,m; int tw=0; int connect[100][100]; int w[100]; int cover_in[100]; int cover(int *cover_in){ int cover_all[100]; for(int i=0;i<n;i++){ cover_all[i]=0; } for(int i=0;i<n;i++){
最小权顶点覆盖问题分析
菜鸟变大鸟的博客
07-15 9521
问题描述： 给定一个赋权无向图 G=(V,E)，每个顶点 v∈V 都有一个权值 w(v)。如果 U⊆VU⊆V，且对任意(u,v)∈E 有 u∈U 或 v∈U，就称 U 为图 G 的一个顶点覆盖。G 的最小权顶点覆盖是指 G 中所含顶点权之和最小的顶点覆盖。 算法设计： 对于给定的无向图 G，设计一个优先队列式分支限界法，计算 G 的最小权顶点覆盖。 数据输入： 由文件input.txt给出输入数据。第 1 行有 2 个正整数 n 和 m，表示给定的图 G 有 n 个顶点和 m 条边，顶点编号为 1，2，…，
用java编写一个实验程序，采用分枝限界法求解4皇后问题的一个解
06-03
好的，以下是使用Java语言编写的4皇后问题求解程序，采用分枝限界法： ```java public class NQueenProblem { private static int N = 4; // 皇后数量 private static int[] board = new int[N]; // 存储棋盘 /...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值