分支界限法Word文档格式.docx
《分支界限法Word文档格式.docx》由会员分享，可在线阅读，更多相关《分支界限法Word文档格式.docx（29页珍藏版）》请在冰点文库上搜索。
2.1分支限界法基本思想
此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。
2.2两种分支限界法
（1）队列式（FIFO）分支限界法
按照队列先进先出（FIFO）原则选取下一个节点为扩展节点。
（2）优先队列式分支限界法
按照优先队列中规定的优先级选取优先级最高的节点成为当前扩展节点
2.3分支限界法的设计思路
设求解最大化问题，解向量为X=（x1,…,xn），xi的取值范围为Si，|Si|=ri。
在使用分支限界搜索问题的解空间树时，先根据限界函数估算目标函数的界[down,up]，然后从根结点出发，扩展根结点的r1个孩子结点，从而构成分量x1的r1种可能的取值方式。
对这r1个孩子结点分别估算可能的目标函数bound（x1），其含义：
以该结点为根的子树所有可能的取值不大于bound（x1），即：
bound（x1）≥bound（x1,x2）≥…≥bound（x1,…,xn）
若某孩子结点的目标函数值超出目标函数的下界，则将该孩子结点丢弃；
否则，将该孩子结点保存在待处理结点表PT中。
再取PT表中目标函数极大值结点作为扩展的根结点，重复上述。
直到一个叶子结点时的可行解X=（x1,…,xn），及目标函数值bound（x1,…,xn）。
2.4分支限界法与回溯法区别
（1）求解目标：
回溯法的求解目标是找出解空间树中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出在某种意义下的最优解。
（2）搜索方式的不同：
回溯法以深度优先的方式搜索解空间树，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间树。
3分支限界法应用
3.1批处理作业问题
（1）问题提出。
给定n个作业的集合J={J1,J2,…,Jn}。
每一个作业Ji都有2项任务要分别在2台机器上完成。
每一个作业必须先由机器1处理，然后再由机器2处理。
作业Ji需要机器j的处理时间为tji，i=1,2,…,n；
j=1,2。
对于一个确定的作业调度，设是Fji是作业i在机器j上完成处理的时间。
则所有作业在机器2上完成处理的时间和
称为该作业调度的完成时间和。
批处理作业调度问题要求对于给定的n个作业，制定最佳作业调度方案，使其完成时间和达到最小。
（2）算法分析。
在结点E处相应子树中叶结点完成时间和的下界是：
注意到如果选择Pk，使t1pk在k>
=r+1时依非减序排列，S1则取得极小值。
同理如果选择Pk使t2pk依非减序排列，则S2取得极小值。
这可以作为优先队列式分支限界法中的限界函数。
（3）主要算法介绍。
do
{
if（enode.s==n）{
if（enode.sf2<
bestc）{
bestc=enode.sf2;
for（inti=0;
i<
n;
i++）
bestx[i]=enode.x[i];
}
else
for（inti=enode.s;
i++）{
MyMath.swap（enode.x,enode.s,i）;
int[]f=newint[3];
intbb=bound（enode,f）;
if（bb<
bestc）{
HeapNodenode=newHeapNode（enode,f,bb,n）;
heap.put（node）;
}
算法的while循环完成对排列树内部结点的有序扩展。
在while循环体内算法依次从活结点优先队列中取出具有最小bb值（完成时间和下界）的结点作为当前扩展结点，并加以扩展。
首先考虑enode.s=n的情形，当前扩展结点enode是排列树中的叶结点。
enode.sf2是相应于该叶结点的完成时间和。
当enode.sf2<
bestc时更新当前最优值bestc和相应的当前最优解bestx。
当enode.s<
n时，算法依次产生当前扩展结点enode的所有儿子结点。
对于当前扩展结点的每一个儿子结点node，计算出其相应的完成时间和的下界bb。
当bb<
bestc时，将该儿子结点插入到活结点优先队列中。
而当bb≥bestc时，可将结点node舍去。
3.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的值。
程序代码：
#include<
stdio.h>
istream>
usingnamespacestd;
//---------------------宏定义------------------------------------------
#defineMAX_CITY_NUMBER10//城市最大数目
#defineMAX_COST10000000//两个城市之间费用的最大值
//---------------------全局变量----------------------------------------
intCity_Graph[MAX_CITY_NUMBER][MAX_CITY_NUMBER];
//表示城市间边权重的数组
intCity_Size;
//表示实际输入的城市数目
intBest_Cost;
//最小费用
intBest_Cost_Path[MAX_CITY_NUMBER];
//最小费用时的路径
//------------------------定义结点---------------------------------------
typedefstructNode{
intlcost;
//优先级
intcc;
//当前费用
intrcost;
//剩余所有结点的最小出边费用的和
ints;
//当前结点的深度，也就是它在解数组中的索引位置
intx[MAX_CITY_NUMBER];
//当前结点对应的路径
structNode*pNext;
//指向下一个结点
}Node;
//---------------------定义堆和相关对操作--------------------------------
typedefstructMiniHeap{
Node*pHead;
//堆的头
}MiniHeap;
//初始化
voidInitMiniHeap（MiniHeap*pMiniHeap）{
pMiniHeap->
pHead=newNode;
pHead->
pNext=NULL;
}
//入堆
voidput（MiniHeap*pMiniHeap,Nodenode）{
Node*next;
Node*pre;
Node*pinnode=newNode;
//将传进来的结点信息copy一份保存
//这样在函数外部对node的修改就不会影响到堆了
pinnode->
cc=node.cc;
lcost=node.lcost;
pNext=node.pNext;
rcost=node.rcost;
s=node.s;
for（intk=0;
k<
City_Size;
k++）{
x[k]=node.x[k];
pre=pMiniHeap->
pHead;
next=pMiniHeap->
pNext;
if（next==NULL）{
pNext=pinnode;
else{
while（next!
=NULL）{
if（（next->
lcost）>
（pinnode->
lcost））{//发现一个优先级大的，则置于其前面
pNext=pre->
pre->
break;
//跳出
pre=next;
next=next->
//放在末尾
//出堆
Node*RemoveMiniHeap（MiniHeap*pMiniHeap）{
Node*pnode=NULL;
if（pMiniHeap->
pNext!
pnode=pMiniHeap->
pNext=pMiniHeap->
pNext->
returnpnode;
//---------------------分支限界法找最优解--------------------------------
voidTraveler（）{
inti,j;
inttemp_x[MAX_CITY_NUMBER];
Node*pNode=NULL;
intminiSum;
//所有结点最小出边的费用和
intminiOut[MAX_CITY_NUMBER];
//保存每个结点的最小出边的索引
MiniHeap*heap=newMiniHeap;
//分配堆
InitMiniHeap（heap）;
//初始化堆
miniSum=0;
for（i=0;
i<
i++）{
miniOut[i]=MAX_COST;
//初始化时每一个结点都不可达
for（j=0;
j<
j++）{
if（City_Graph[i][j]>
0&
&
City_Graph[i][j]<
miniOut[i]）{
//从i到j可达，且更小
miniOut[i]=City_Graph[i][j];
if（miniOut[i]==MAX_COST）{//i城市没有出边
Best_Cost=-1;
return;
miniSum+=miniOut[i];
for（i=0;
i++）{//初始化的最优路径就是把所有结点依次走一遍
Best_Cost_Path[i]=i;
Best_Cost=MAX_COST;
//初始化的最优费用是一个很大的数
pNode=newNode;
//初始化第一个结点并入堆
pNode->
lcost=0;
//当前结点的优先权为0也就是最优
cc=0;
//当前费用为0（还没有开始旅行）
rcost=miniSum;
//剩余所有结点的最小出边费用和就是初始化的miniSum
s=0;
//层次为0
x[k]=Best_Cost_Path[k];
//第一个结点所保存的路径也就是初始化的路径
put（heap,*pNode）;
//入堆
while（pNode!
=NULL&
（pNode->
s）<
City_Size-1）{
//堆不空不是叶子
Best_Cost_Path[k]=pNode->
x[k];
//将最优路径置换为当前结点本身所保存的
/*
**pNode结点保存的路径中的含有这条路径上所有结点的索引
**x路径中保存的这一层结点的编号就是x[City_Size-2]
**下一层结点的编号就是x[City_Size-1]*/
if（（pNode->
s）==City_Size-2）{//是叶子的父亲
Intedge1=City_Graph[（pNode->
x）[City_Size-2]][（pNode->
x）[City_Size-1]];
intedge2=City_Graph[（pNode->
x）[City_Size-1]][（pNode->
x）[0]];
if（edge1>
=0&
edge2>
cc+edge1+edge2）<
Best_Cost）{
Best_Cost=pNode->
cc+edge1+edge2;
cc=Best_Cost;
lcost=Best_Cost;
//优先权为Best_Cost
s++;
//到达叶子层
else{//内部结点
for（i=pNode->
s;
i++）{//从当前层到叶子层
if（City_Graph[pNode->
x[pNode->
s]][pNode->
x[i]]>
=0）{
//pNode的层数就是它在最优路径中的位置
Inttemp_cc=pNode->
cc+City_Graph[pNode->
x[i]];
inttemp_rcost=pNode->
rcost-miniOut[pNode->
s]];
//下一个结点的剩余最小出边费用和
//等于当前结点的rcost减去当前这个结点的最小出边费用
if（temp_cc+temp_rcost<
Best_Cost）{
//下一个结点的最小出边费用和小于当前的最优解，说明可能存在更优解
temp_x[j]=Best_Cost_Path[j];
temp_x[pNode->
s+1]]=Best_Cost_Path[i];
//将当前结点的编号放入路径的深度为s+1的地方
temp_x[i]=Best_Cost_Path[pNode->
s+1];
Node*pNextNode=newNode;
pNextNode->
cc=temp_cc;
lcost=temp_cc+temp_rcost;
rcost=temp_rcost;
s=pNode->
s+1;
x[k]=temp_x[k];
put（heap,*pNextNode）;
deletepNextNode;
pNode=RemoveMiniHeap（heap）;
intmain（）{
printf（"
请输入旅行的节点数"
）;
scanf（"
%d"
&
City_Size）;
请分别输入每个节点与其它节点的路程花费"
City_Graph[i][j]）;
Traveler（）;
最小花费"
"
%d\n"
Best_Cost）;
return1;
}
实验结果如图：
由于我们要寻找的是最小耗费的旅行路径，因此可以使用最小耗费分枝限界法。
3.3单源最短路径问题
下面以一个例子来说明单源最短路径问题：
在下图所给的有向图G中，每一边都有一个非负边权。
要求图3-1从源顶点s到目标顶点t之间的最短路径。
图3-1有向图G
下图3-2是用优先队列式分支限界法解有向图G的单源最短路径问题产生的解空间树。
其中，每一个结点旁边的数字表示该结点所对应的当前路长。
图3-2解空间树
程序代码：
iostream>
vector>
queue>
limits>
structnode_info
{
public:
node_info（inti,intw）
:
index（i）,weight（w）{}
node_info（）
index（0）,weight（0）{}
node_info（constnode_info&
ni）
index（ni.index）,weight（ni.weight）{}
friend
booloperator<
（constnode_info&
lth,constnode_info&
rth）{
returnlth.weight>
rth.weight;
//为了实现从小到大的顺序
intindex;
//结点位置
intweight;
//权值
};
structpath_info
path_info（）
front_index（0）,weight（numeric_limits<
int>
:
max（））{}
intfront_index;
classss_shortest_paths
{
ss_shortest_paths（constvector<
vector<
>
g,intend_location）
no
升级会员 