实验七分支限界法
分支限界法实验(单源最短路径)

分⽀限界法实验(单源最短路径)算法分析与设计实验报告第七次实验基本思想:附录:完整代码(分⽀限界法)Shorest_path.cpp//单源最短路径问题分⽀限界法求解#include#include#include#include"MinHeap2.h"using namespace std;templateclass Graph //定义图类{friend int main();public:void shortest_path(int); private:int n, //图的顶点数*prev; //前驱顶点数组Type **c, //图的邻接矩阵*dist; //最短距离数组};templateclass MinHeapNode //最⼩堆中的元素类型为MinHeapNode{friend Graph;public:operator int() const{return length;}private:int i; //顶点编号Type length; //当前路长};//单源最短路径问题的优先队列式分⽀限界法templatevoid Graph::shortest_path(int v){MinHeap> H(1000);//定义最⼩堆的容量为1000//定义源为初始扩展结点MinHeapNode E;//初始化源结点E.i=v;E.length=0;dist[v]=0;while(true)//搜索问题的解空间{for(int j=1;j<=n;j++)if((c[E.i][j]!=0)&&(E.length+c[E.i][j]{//顶点i到顶点j可达,且满⾜控制约束//顶点i和j之间有边,且此路径⼩于原先从源点i到j的路径长度dist[j]=E.length+c[E.i][j];//更新dist数组prev[j]=E.i;//加⼊活结点优先队列MinHeapNode N;N.i=j;N.length=dist[j];H.Insert(N);//插⼊到最⼩堆中}try{H.DeleteMin(E); // 取下⼀扩展结点}catch (int){break;}if(H.currentsize==0)//优先队列空{break;}}}int main(){int n=11;int prev[12]={0,0,0,0,0,0,0,0,0,0,0,0};//初始化前驱顶点数组intdist[12]={1000,1000,1000,1000,1000,1000,1000,1000,1000,1000,1000,1000};//初始化最短距离数组cout<<"单源图的邻接矩阵如下:"<int **c=new int*[n+1];for(int i=1;i<=n;i++) //输⼊图的邻接矩阵{c[i]=new int[n+1];for(int j=1;j<=n;j++){cin>>c[i][j];}}int v=1; //源结点为1Graph G;G.n=n;G.c=c;G.dist=dist;G.prev=prev;clock_t start,end,over; //计算程序运⾏时间的算法start=clock();end=clock();over=end-start;start=clock();G.shortest_path(v);//调⽤图的最短路径查找算法//输出从源结点到⽬的结点的最短路径cout<<"从S到T的最短路长是:"<for(int i=2;i<=n;i++)//输出每个结点的前驱结点{cout<<"prev("<}for(int i=2;i<=n;i++) //输出从源结点到其他结点的最短路径长度{cout<<"从1到"<}for(int i=1;i<=n;i++) //删除动态分配时的内存{delete[] c[i];}delete[] c;c=0;end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK); //显⽰运⾏时间cout< system("pause");return 0;}MinHeap.h#includetemplateclass Graph;templateclass MinHeap //最⼩堆类{templatefriend class Graph;public:MinHeap(int maxheapsize=10); //构造函数,堆的⼤⼩是10~MinHeap(){delete[] heap;} //最⼩堆的析构函数int Size() const{return currentsize;} //Size()返回最⼩堆的个数T Max(){if(currentsize) return heap[1];} //第⼀个元素出堆MinHeap& Insert(const T& x); //最⼩堆的插⼊函数MinHeap& DeleteMin(T& x); //最⼩堆的删除函数void Initialize(T x[],int size,int ArraySize); //堆的初始化void Deactivate();void output(T a[],int n);private:int currentsize,maxsize;T *heap;};templatevoid MinHeap::output(T a[],int n) //输出函数,输出a[]数组的元素{for(int i=1;i<=n;i++)cout<cout<}templateMinHeap::MinHeap(int maxheapsize){maxsize=maxheapsize;heap=new T[maxsize+1]; //创建堆currentsize=0;}templateMinHeap& MinHeap::Insert(const T& x){if(currentsize==maxsize) //如果堆中的元素已经等于堆的最⼤⼤⼩return *this; //那么不能在加⼊元素进⼊堆中int i= ++currentsize;while(i!=1 && x{heap[i]=heap[i/2];i/=2;}heap[i]=x;return *this;}templateMinHeap& MinHeap::DeleteMin(T& x) //删除堆顶元素{if(currentsize==0){cout<<"Empty heap!"<return *this;}x=heap[1];T y=heap[currentsize--];int i=1,ci=2;while(ci<=currentsize){if(ciheap[ci+1])ci++;if(y<=heap[ci])break;heap[i]=heap[ci];i=ci;ci*=2;}heap[i]=y;return *this;}templatevoid MinHeap::Initialize(T x[],int size,int ArraySize) //堆的初始化{ delete[] heap;heap=x;currentsize=size;maxsize=ArraySize;for(int i=currentsize/2;i>=1;i--){T y=heap[i];int c=2*i;while(c<=currentsize){if(cheap[c+1])c++;if(y<=heap[c])break;heap[c/2]=heap[c];c*=2;}heap[c/2]=y;}}templatevoid MinHeap::Deactivate() {heap=0;}。
7 分枝-限界法

例 7.2
1. 问题描述
单源最短路径问题
下面以一个例子来说明单源最短路径问题:在下图所给的有 向图G中,每一边都有一个非负边权。要求图G的从源顶点s到目 标顶点t之间的最短路径。
2.状态空间树
下图是用优先队列式分支限界法解有向图G的单源最短路径问 题产生的解空间树。其中,每一个结点旁边的数字表示该结点所对 应的当前路长。
1 L=(2,3,4 2 1 2 5 3 6 5 L=(2,3, 6 4 L=(3,4 3 4 1 2 1 3 4
)
L=(2,3,4
)
,5,6)
2
3
4
5,6)
以4后问题的状态空间树的FIFO搜索为例: 最初E-为1,产生儿子2,3,4,5,放入活节点表。
L=(2,3,4,5) X1=1 L=(3,4,5,6,7) L=(,4,5,6,7,8)
11
9
迷途的LC-检索——不能尽快找到
c( E ) c( E )
10 0
1
c
20 0
2
10 10
3
LC没能达到这个最小 成本答案结点的原因在 于有两个这样的结点X 和Y,当其c(X)>c(Y)时,
10
20
4
∞∞
5
∞∞
5
6
却有c( x) c( y )
如果使每一对c(X)<c(Y)的X,Y结点都有
选择下一个E-节点。 检索策略总是选取 有最小成本估值的活结点作为下一个 E-结点。因此,这种检索策略称之为最小代价检索,简 称LC-检索(leastCostSearch)。 伴之有界函数的LC-检索称为LC搜索。
1 L=(2,3,4) 2 3 4 1 2 3 5 6 4
算法课件 第7章 分枝限界法

7.2 求最优解的分枝限界法
分枝限界法的三种形式:FIFO分枝限界法、LIFO分枝限 界法和LC分枝限界法都可用于求解最优化问题。当分枝限界法 用于求最优解时,需要使用上下界函数作为限界函数。
定义7-1 状态空间树上一个结点X的代价函数c(·)定义为: 若X是答案结点,则c(X)为X所代表的可行解的目标函数值;若 X为非可行解结点,则c(X)=;若X代表部分向量,则c(X)是以 X为根的子树上具有最小代价的结点代价。
本章要点
• 队列式分枝限界法 • 优先队列式分枝限界法 • 0/1背包问题 • 带限期作业排序 • TSP问题 • 单源点最短路径问题
章节内容
7.1 算法思想 7.2 求最优解的分枝限界法 7.3 组合问题中的分枝限界算法 7.4 图问题中的分枝限界算法 7.5 典型的c++程序 7.6 小结
7.1 算法思想
➢相对代价函数g(.)
衡量一个结点X的相对代价一般有两种标准:①在生成一个答案结点之前,子 树X上需要生成的结点数目;②在子树X上,离X最近的答案结点到X的路径长度。 容易看出,如果采用标准①总是生成最小数目的结点;如果采用标准②,则要成为 E-结点的结点只是由根到最近的那个答案结点路径上的那些结点。
do{ for(对结点E的每个孩子){ x=new Node;x->parent=E;//构造E的孩子结点x if(ĉ(X)<U){ //x子树未被限界函数剪枝 lst.Append(x); if(x是一个答案结点&&cost(x)<U) //x为答案结点时修正U if(u(x)+ < cost(x))U=u(x)+ ; else{U=cost(x);ans=x;} else if(u(x)+ < U) U=u(x)+ ;//x为非答案结点时修正U } } if(!lst.isempty()){ lst.serve(E);//从队列中取出活结点E if(ĉ(E)≥U) return ans; //若ĉ(E)≥U,则算法结束 } else return ans; //若队列为空,则算法结束
第七章分枝-限界法

6
▪如果使用度量2,则要成为E-结点的结点 只是由根到最近的那个答案结点路径上的 那些结点。
▪以后用C(.)表示“有智力的”排序函数,有称
为结点的成本函数。其定义如下:
在子树X中离X最近的那个答案结点到X的路径长 度
5
▪使用后一种度量,图7.1中树的根结点付出 的代价是4。结点(18和34),(29和35) 以及(30和38)的代价分别是3,2和1。
▪所有在2,3和4级上剩余结点的代价应分别 大于3,2和1。以这些代价作为选择下一个E结点的依据,则E-结点依次为1,18,29和30。
▪初始排列和目标排列叫做初始状态和目标状 态。
▪若由初始状态到某状态存在一系列合法的移 动,则称该状态可由初始状态到达。
▪一种初始状态的状态空间由所有可从初始状
态到达的状态构成。
12
例:15-谜问题
▪ 可以看出棋盘上这些牌有16!种不同的排列, 所以这个问题的状态空间是相当庞大的。
▪有必要在具体求解问题之前判定目标状态是 否在这个初始状态的状态空间中。
1
例7.1 :4-皇后问题
39
55
2
本例考察用一个FIFO分支-限界算法检索 4-皇后问题的状态空间树的基本过程。
起初,只有一个活结点,即结点1。这表 示没有皇后被放在棋盘上。
扩展这个结点,生成它的儿子结点 2,18,34和50。这些结点分别表示皇后1在 第1行的1,2,3,4列情况下的棋盘。
因此这种检索策略称之为最小成本检索,简称 LC-检索。
10
例:15-谜问题
分支限界法实验(最优装载问题)

姓名 时间
12.26 上午
学号 地点
实验名称 分支限界法实验(最优装载问题)
班级 工训楼 309
1. 掌握分支限界法求解问题的思想 实验目的
2. 学会利用队列求解最优装载问题
实验原理
问题描述: 有一批共个集装箱要装上 2 艘载重量分别为 C1 和 C2 的轮船,其中集装
if(Ew+r>=bestw) Enqueue(Q,Ew,i,n,bestw,E,bestE,bestx,false);//将右 节点加入队列 E=Q.front(); //取出当前扩展节点
Q.pop(); if(!E) //到达同层的最末,此时需要更新剩余装箱载重量
{ if(Q.empty()) break; //此时队列为空 Q.push(0); //加入0,表示该层结束
箱 i 的重量为 Wi,且装载问题要求确定是否有一个合理的装载方案可将这个 集装箱装上这 2 艘轮船。如果有,找出一种优装载 方案。 (1)首先将第一艘轮船尽可能装满; (2)将剩余的集装箱装上第二艘轮船。
实验步骤
(1)在算法的循环体中,首先检测当前扩展结点的左儿子结点是否为可行结 点; (2)如果是则将其加入到活结点队列中。然后将其右儿子结点加入到活结点 队列中(右儿子结点一定是可行结点)。2 个儿子结点都产生后,当前扩展结点 被舍弃; (3)活结点队列中的队首元素被取出作为当前扩展结点,由于队列中每一层 结点之后都有一个尾部标记-1,故在取队首元素时,活结点队列一定不空; (4)当取出的元素是-1 时,再判断当前队列是否为空。如果队列非空,则将 尾部标记-1 加入活结点队列,算法开始处理下一层的活结点。
E=Q.front(); Q.pop(); i++; //进入下一层 r-=w[i];//更新剩余集装箱的值
分支限界法实验(单源最短路径)

算法分析与设计实验报告第七次实验姓名学号班级时间12.26上午地点工训楼309实验名称分支限界法实验(单源最短路径)实验目的1.掌握并运用分支限界法的基本思想2.运用分支限界法实现单源最短路径问题实验原理问题描述:在下图所给的有向图G中,每一边都有一个非负边权。
要求图G的从源顶点s 到目标顶点t之间的最短路径。
基本思想:下图是用优先队列式分支限界法解有向图G的单源最短路径问题产生的解空间树。
其中,每一个结点旁边的数字表示该结点所对应的当前路长。
为了加速搜索的进程,应采用有效地方式选择活结点进行扩展。
按照优先队列中规定的优先级选取优先级最高的结点成为当前扩展结点。
catch (int){break;}if(H.currentsize==0) //优先队列空{break;}}}上述有向图的结果:测试结果附录:完整代码(分支限界法)Shorest_path.cpp//单源最短路径问题分支限界法求解#include<iostream>#include<time.h>#include<iomanip>#include"MinHeap2.h"using namespace std;template<class Type>class Graph //定义图类{friend int main();public:void shortest_path(int); private:int n, //图的顶点数*prev; //前驱顶点数组Type **c, //图的邻接矩阵*dist; //最短距离数组};template<class Type>class MinHeapNode //最小堆中的元素类型为MinHeapNode{friend Graph<Type>;public:operator int() const{return length;}private:int i; //顶点编号Type length; //当前路长};//单源最短路径问题的优先队列式分支限界法template<class Type>void Graph<Type>::shortest_path(int v){MinHeap<MinHeapNode<Type>> H(1000);//定义最小堆的容量为1000//定义源为初始扩展结点MinHeapNode<Type> E;//初始化源结点E.i=v;E.length=0;dist[v]=0;while(true)//搜索问题的解空间{for(int j=1;j<=n;j++)if((c[E.i][j]!=0)&&(E.length+c[E.i][j]<dist[j])){//顶点i到顶点j可达,且满足控制约束//顶点i和j之间有边,且此路径小于原先从源点i到j的路径长度dist[j]=E.length+c[E.i][j];//更新dist数组prev[j]=E.i;//加入活结点优先队列MinHeapNode<Type> N;N.i=j;N.length=dist[j];H.Insert(N);//插入到最小堆中}try{H.DeleteMin(E); // 取下一扩展结点}catch (int){break;}if(H.currentsize==0)//优先队列空{break;}}}int main(){int n=11;int prev[12]={0,0,0,0,0,0,0,0,0,0,0,0};//初始化前驱顶点数组intdist[12]={1000,1000,1000,1000,1000,1000,1000,1000,1000,1000,1000,1000 };//初始化最短距离数组cout<<"单源图的邻接矩阵如下:"<<endl;int **c=new int*[n+1];for(int i=1;i<=n;i++) //输入图的邻接矩阵{c[i]=new int[n+1];for(int j=1;j<=n;j++){cin>>c[i][j];}}int v=1; //源结点为1Graph<int> G;G.n=n;G.c=c;G.dist=dist;G.prev=prev;clock_t start,end,over; //计算程序运行时间的算法start=clock();end=clock();over=end-start;start=clock();G.shortest_path(v);//调用图的最短路径查找算法//输出从源结点到目的结点的最短路径cout<<"从S到T的最短路长是:"<<dist[11]<<endl;for(int i=2;i<=n;i++)//输出每个结点的前驱结点{cout<<"prev("<<i<<")="<<prev[i]<<" "<<endl;}for(int i=2;i<=n;i++) //输出从源结点到其他结点的最短路径长度{cout<<"从1到"<<i<<"的最短路长是:"<<dist[i]<<endl;}for(int i=1;i<=n;i++) //删除动态分配时的内存{delete[] c[i];}delete[] c;c=0;end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK); //显示运行时间cout<<endl;system("pause");return 0;}MinHeap.h#include<iostream>template<class Type>class Graph;template<class T>class MinHeap //最小堆类{template<class Type>friend class Graph;public:MinHeap(int maxheapsize=10); //构造函数,堆的大小是10~MinHeap(){delete[] heap;} //最小堆的析构函数int Size() const{return currentsize;} //Size()返回最小堆的个数T Max(){if(currentsize) return heap[1];} //第一个元素出堆MinHeap<T>& Insert(const T& x); //最小堆的插入函数MinHeap<T>& DeleteMin(T& x); //最小堆的删除函数void Initialize(T x[],int size,int ArraySize); //堆的初始化void Deactivate();void output(T a[],int n);private:int currentsize,maxsize;T *heap;};template<class T>void MinHeap<T>::output(T a[],int n) //输出函数,输出a[]数组的元素{for(int i=1;i<=n;i++)cout<<a[i]<<" ";cout<<endl;}template<class T>MinHeap<T>::MinHeap(int maxheapsize){maxsize=maxheapsize;heap=new T[maxsize+1]; //创建堆currentsize=0;}template<class T>MinHeap<T>& MinHeap<T>::Insert(const T& x){if(currentsize==maxsize) //如果堆中的元素已经等于堆的最大大小return *this; //那么不能在加入元素进入堆中int i= ++currentsize;while(i!=1 && x<heap[i/2]){heap[i]=heap[i/2];i/=2;}heap[i]=x;return *this;}template<class T>MinHeap<T>& MinHeap<T>::DeleteMin(T& x) //删除堆顶元素{if(currentsize==0){cout<<"Empty heap!"<<endl;return *this;}x=heap[1];T y=heap[currentsize--];int i=1,ci=2;while(ci<=currentsize){if(ci<currentsize && heap[ci]>heap[ci+1])ci++;if(y<=heap[ci])break;heap[i]=heap[ci];i=ci;ci*=2;}heap[i]=y;return *this;}template<class T>void MinHeap<T>::Initialize(T x[],int size,int ArraySize) //堆的初始化{delete[] heap;heap=x;currentsize=size;maxsize=ArraySize;for(int i=currentsize/2;i>=1;i--){T y=heap[i];int c=2*i;while(c<=currentsize){if(c<currentsize && heap[c]>heap[c+1])c++;if(y<=heap[c])break;heap[c/2]=heap[c];c*=2;}heap[c/2]=y;}}template<class T>void MinHeap<T>::Deactivate(){heap=0; }。
分枝限界法_实验报告

一、课题名称用分枝限界法求解单源最短路径问题二、课题内容和要求设计要求:学习算法设计中分枝限界法的思想,设计算法解决数据结构中求解单源最短路径问题,编程实现:(1)给出指定源点的单源最短路径;(2)说明算法的时间复杂度。
三、需求分析1.实现极小堆的创建,用来存储活结点表。
2.实现循环队列的创建、初始化、入队、出队等操作。
3.实现分支限界法来实现求解单元最短路径的算法。
4.实现最短路径的正确输出。
四、概要设计建立工程MinPath.dsw,加入源文件main.cpp,头文件CirQueue.h,init.h,Minpath.h和output.h. CirQueue.h中实现极小堆的创建,循环队列的创建、初始化、入队、出队等操作,Minpath.h中实现分支限界法来实现求解单元最短路径的算法。
output.h中实现最短路径的正确输出。
如下图所示:实验用例如下,通过邻接矩阵的方式写在init.h 中:五、详细设计12581134 69 7103 43292212223733352main函数:#include<iostream.h>#include"init.h"#include"CirQueue.h"#include"MinPath.h"#include"output.h"void main(){int k;int q;cout<<"------------欢迎使用本系统---------------"<<endl;cout<<"------------请选择单元路径的起点:---------------"<<endl;cout<<"------------提示:输入"<<1<<"到"<<n-1<<"之间的整数---------------"<<endl;cin>>k;cout<<"------------请选择单元路径的终点:---------------"<<endl;cin>>q;while(k<1||k>11){cout<<"------------提示:输入"<<1<<"到"<<n-1<<"之间的数,请重新输入---------------"<<endl;cin>>k;}MinPath(k);output(k,q);}init.hconst int size = 200;const int inf = 1000; //两点距离上界置为1000const int n = 12; //图顶点个数加1int prev[n]; //图的前驱顶点int dist[] = {0,inf,inf,inf,inf,inf,inf,inf,inf,inf,inf,inf}; //最短距离数组int c[n][n] = {{0,0,0,0,0,0,0,0,0,0,0,0},{0,0,2,3,4,inf,inf,inf,inf,inf,inf,inf},{0,inf,0,3,inf,7,2,inf,inf,inf,inf,inf},{0,inf,inf,0,inf,inf,9,2,inf,inf,inf,inf},{0,inf,inf,inf,0,inf,inf,2,inf,inf,inf,inf},{0,inf,inf,inf,inf,0,inf,inf,3,3,inf,inf},{0,inf,inf,inf,inf,inf,0,1,inf,3,inf,inf},{0,inf,inf,inf,inf,inf,inf,0,inf,5,1,inf},{0,inf,inf,inf,inf,inf,inf,inf,0,inf,inf,3},{0,inf,inf,inf,inf,inf,inf,inf,inf,0,inf,2},{0,inf,inf,inf,inf,inf,inf,inf,inf,2,inf,2},{0,inf,inf,inf,inf,inf,inf,inf,inf,inf,inf,0},}; //图的邻接矩阵CirQueue.hclass MinHeapNode//创建极小堆用来存储活结点表{public :int i; //顶点编号int length; //当前路长};class CirQueue//循环队列{private:int front,rear;//头指针和尾指针MinHeapNode data[size];public:CirQueue()//初始化建空队列{front = rear = 0;}void queryIn(MinHeapNode e)//元素入队操作{if((rear +1)%size != front)//队列未满{rear = (rear+1)%size; //插入新的队尾元素data[rear] = e; //在队尾插入元素 }}void queryOut()//元素出队操作{if(rear != front){front = (front+1)%size; //删除队头元素}}MinHeapNode getQuery()//读取队头元素,但不出队 {if(rear != front){return data[(front+1)%size];}return data[1];}bool empty()//判断队列是否为空{return front == rear;}bool full()//判断队列是否为满{return (rear +1)%size == front;}};//CirQueue结束MainPath.hvoid MinPath(int v){CirQueue s;//定义源为初始扩展结点MinHeapNode e;e.i = v;e.length = 0;dist[v] = 0;s.queryIn(e); //将源节点加入队列while(true){for(int j = 1;j<n;j++){if(j>=n){break;}MinHeapNode m = s.getQuery();if((c[m.i][j]<inf)&&(m.length + c[m.i][j] < dist[j]))//顶点i到顶点j可达,且从源出发途经i到j的路径长度小于当前最优路径长度{dist[j] = m.length + c[m.i][j];prev[j] = m.i;MinHeapNode mi;//加入活结点优先队列mi.i = j;mi.length = dist[j];if(s.full()){break;}s.queryIn(mi); //元素入队}}//for循环结束if(s.empty()){break;}s.queryOut(); //当该结点的孩子结点全部入队后,删除该结点 }//while循环结束}//方法结束output.hvoid output(int k,int q){int q1=q;if(dist[q1]==1000){cout<<"------------找不到此路径---------------"<<endl;return;}cout<<"最短路径长为: "<<dist[q1]<<endl;cout<<"单源最短路径为: ";int a[12]={0};int t =q1;int s=0;for(int i=0;t!=k;i++){a[i] = prev[t];t = prev[t];s=s+1;}for(i=s-1;i>-1;i--) {cout<<a[i]<<" ";}cout<<q1;cout<<endl<<"------------欢迎使用本系统---------------"<<endl; }六、测试数据及其结果分析1.选择起点:1,终点:111到11最短路径长为8,为1->3->7->10->11所获得。
分支限界法

11
6.2 单源最短路径问题
2. 算法思想
用最大堆还是最小堆存储活结点表? 其优先级是结点所对应的当前路长。 算法从图G的源顶点s和空优先队列开始。结点s被扩展 后,它的儿子结点被依次插入堆中。此后,算法从堆中取出 具有最小当前路长的结点作为当前扩展结点,并依次检查与 当前扩展结点相邻的所有顶点。如果从当前扩展结点i到顶 点j有边可达,且从源出发,途经顶点i再到顶点j的所相应 的路径的长度小于当前最优路径长度,则将该顶点作为活结 点插入到活结点优先队列中。这个结点的扩展过程一直继续 到活结点优先队列为空时为止。 12
分支限界法
1
6.1 分支限界法的基本思想
1. 分支限界法与回溯法的不同
(1)求解目标: 回溯法:找出解空间树中满足约束条件的所有解; 分支限界法:找出满足约束条件的一个解,或是在满足约 束条件的解中找出在某种意义下的最优解。 (2)搜索方式的不同:
回溯法:深度优先的方式搜索解空间树;
分支限界法则:广度优先或以最小耗费优先的方式搜索解 空间树。
2
为何称为分支限界法? ※ 分支 在扩展结点处,先生成其所有的儿子结点(分支),然 后再从当前的活结点表中选择下一个扩展结点。 ※ 限界 为了有效地选择下一扩展结点,加速搜索进程,在每个 活结点处,计算一个函数值(限界),并根据函数值,从 当 前活结点表中选择一个最有利的结点作为扩展结点,使搜 索 朝着解空间树上有最优解的分支推进,一遍尽快找出一个 最 优解。
优先队列式分支限界法:用最大堆实现优先队列,优先级 为活结点所获得的价值。(197页)
A入堆→B,C入堆(并且舍弃A)→E入堆(D不可行,舍弃)→J不可行, 舍弃,K是可行的叶结点,是一个可行解→ F,G入堆→ L,M均为可行叶结 点,得到相应的可行解→N,O可行叶结点,得相应可行解→活结点堆空
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验七分支限界法(2学时)
一、实验目的与要求
1、掌握旅行商售货员问题的分支限界算法;
2、区分分支限界算法与回溯算法的区别,加深对分支限界法的理解。
二、实验题:
某售货员要到若干城市去推销商品,已知各城市之间的路程(或旅费)。
他要选定一条从驻地出发,经过每个城市一次,最后回到驻地的路线,使总的路程(或总旅费)最小。
三、实验提示
旅行商问题的解空间是一个排列树。
有两种实现的方法。
第一种是只使用一个优先队列,队列中的每个元素中都包含到达根的路径。
另一种是保留一个部分解空间树和一个优先队列,优先队列中的元素并不包含到达根的路径。
以下为第一种方法。
由于我们要寻找的是最小耗费的旅行路径,因此可以使用最小耗费分枝定界法。
在实现过程中,使用一个最小优先队列来记录活节点,队列中每个节点的类型为MinHeapNode。
每个节点包括如下区域: x(从1到n的整数排列,其中x[0] = 1 ),s(一个整数,使得从排列树的根节点到当前节点的路径定义了旅行路径的前缀x[0:s], 而剩余待访问的节点是x [s + 1 : n - 1 ]),cc(旅行路径前缀,即解空间树中从根节点到当前节点的耗费),lcost(该节点子树中任意叶节点中的最小耗费), rcost(从顶点x[s : n - 1]出发的所有边的最小耗费之和)。
当类型为MinHeapNode( T )的数据被转换成为类型T时,其结果即为lcost的值。
分枝定界算法的代码见程序
程序首先生成一个容量为100的最小堆,用来表示活节点的最小优先队列。
活节点按lcost值从最小堆中取出。
接下来,计算有向图中从每个顶点出发的边中耗费最小的边所具有的耗费MinOut。
如果某些顶点没有出边,则有向图中没有旅行路径,搜索终止。
如果所有的顶点都有出边,则可以启动最小耗费分枝定界搜索。
根的孩子B作为第一个E-节点,在此节点上,所生成的旅行路径前缀只有一个顶点1,因此s=0, x[0]=1, x[1:n-1]是剩余的顶点(即顶点2 , 3 ,., n )。
旅行路径前缀1的开销为0 ,即cc = 0 ,并且,rcost=n && i=1时MinOut 。
在程序中,bestc 给出了当前能找到的最少的耗费值。
初始时,由于没有找到任何旅行路径,因此bestc的值被设为NoEdge。
旅行商问题的最小耗费分枝定界算法
template
T AdjacencyWDigraph::BBTSP(int v[])
{s + + ;
H . I n s e r t ( E ) ; }
else delete [] ;}
else {I n s e r t ( N ) ; }
} // 结束可行的孩子
delete [] ;} // 对本节点的处理结束
try {(E);} // 取下一个E-节点
catch (OutOfBounds) {break;} // 没有未处理的节点
}
if (bestc == NoEdge) return NoEdge; // 没有旅行路径
// 将最优路径复制到v[1:n] 中
for (i = 0; i < n; i++)
v[i+1] = ;
while (true) {//释放最小堆中的所有节点
delete [] ;
try {(E);}
catch (OutOfBounds) {break;}
}
return bestc;
}
算法思路:
算法思路
旅行售货员问题的解空间可以组织成一棵树,从树的根结点到任一叶结点的路径定义了图的一条周游路线。
旅行售货员问题要在图G中找出费用最小的周游路线。
路线是一个带权图。
图中各边的费用(权)为正数。
图的一条周游路线是包括V中的每个顶点在内的一条回路。
周游路线的费用是这条路线上所有边的费用之和。
算法开始时创建一个最小堆,用于表示活结点优先队列。
堆中每个结点的子树费用的下界lcost值是优先队列的优先级。
接着算法计算出图中每个顶点的最小费用出边并用minout记录。
如果所给的有向图中某个顶点没有出边,则该图不可能有回路,算法即告结束。
如果每个顶点都有出边,则根据计算出的minout作算法初始化。
算法的while循环体完成对排列树内部结点的扩展。
对于当前扩展结点,算法分2种情况进行处理:
1、首先考虑s=n-2的情形,此时当前扩展结点是排列树中某个叶结点的父结点。
如果该叶结点相应一条可行回路且费用小于当前最小费用,则将该叶结点插入到优先队列中,否则舍去该叶结点。
2、当s<n-2时,算法依次产生当前扩展结点的所有儿子结点。
由于当前扩展结点所相应的路径是x[0:s],其可行儿子结点是从剩余顶点x[s+1:n-1]中选取的顶点x[i],且(x[s],x[i])是所给有向图G中的一条边。
对于当前扩展结点的每一个可行儿子结点,计算出其前缀(x[0:s],x[i])的费用cc和相应的下界lcost。
当lcost<bestc时,将这个可行儿子结点插入到活结点优先队列中。
算法中while循环的终止条件是排列树的一个叶结点成为当前扩展结点。
当s=n-1时,已找到的回路前缀是x[0:n-1],它已包含图G的所有n个顶点。
因此,当s=n-1时,相应的扩展结点表示一个叶结点。
此时该叶结点所相应的回路的费用等于cc和lcost的值。
剩余的活结点的lcost值不小于已找到的回路的费用。
它们都不可能导致费用更小的回路。
因此已找到的叶结点所相应的回路是一个最小费用旅行售货员回路,算法可以结束。
算法结束时返回找到的最小费用,相应的最优解由数组v给出。
代码:
实验结果:。