分支限界法求图的最短路径

分支限界法

定义：

  分支定界 (branch and bound) 算法是一种在问题的解空间树上搜索问题的解的方法。但与回溯算法不同，分支定界算法采用广度优先或最小耗费优先的方法搜索解空间树，并且，在分支定界算法中，每一个活结点只有一次机会成为扩展结点。利用分支定界算法对问题的解空间树进行搜索，它的搜索策略是：

　　1 ．产生当前扩展结点的所有孩子结点；

　　2 ．在产生的孩子结点中，抛弃那些不可能产生可行解（或最优解）的结点；

　　3 ．将其余的孩子结点加入活结点表；

　　4 ．从活结点表中选择下一个活结点作为新的扩展结点。

如此循环，直到找到问题的可行解（最优解）或活结点表为空。分支限界法的思想是：首先确定目标值的上下界，边搜索边减掉搜索树的某些支，提高搜索效率。

问题描述：

   给定n个城市，有一个旅行商从某一城市出发，访问每个城市各一次后再回到原出发城市，要求找出的巡回路径最短。

问题分析：

分支限界法是在生成当前E-结点全部儿子之后再生成其它活结点的儿子，且用限界函数帮助避免生成不包含答案结点子树的状态空间的检索方法。在总的原则下，根据对状态控件树中结点检索的次序的不同又将分支限界设计策路分为数种不同的检索方法。在求解旅行商问题时，程序中采用FIFO检索（First In First Out），它的活结点表采用一张先进先出表（即队列）。可以看出，分支限界法在两个方面加速了算法的搜索速度，一是选择要扩展的节点时，总是选择选择一个最小成本的结点，尽可能早的进入最有可能成为最优解的分支；二是扩展节点的过程中，舍弃导致不可行解或导致非最优解的子结点。

代码实现：

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

//各个城市之间的路径长度
int CityVal[4][4]={
                    {0 ,30,6,4},
                    {30,0 ,5,10},
                    {6,5,0 ,20 },
                    {4,10,20 ,0}};

struct CityNum{
    int MinVal[2];       //最短路径长度
    int PastCity[2][4]; //走过的路径
}city[4];

int find(int j,int k,int boolnum)
{
    int i;
    for(i=0;i<4;i++)
        if(j==city[k].PastCity[boolnum][i])
            return 1;
    return 0;
}
void copy(int k,int boolnum1,int j,int boolnum2)
{
    int i=0;
    while(city[k].PastCity[boolnum1][i]!=0)
    {
    city[j].PastCity[boolnum2][i]=city[k].PastCity[boolnum1][i];
    i++;
    }
    city[j].PastCity[boolnum2][i]=k;
}



int main()
{
    int i,j,k;
    int boolnum=0;
    int TempMinVal;
    int TempCity;
    int TempVal;
    for(i=0;i<2;i++)
        for(j=0;j<4;j++)
            for(k=0;k<4;k++)
                city[k].PastCity[i][j]=0;
    for(i=1;i<4;i++)
        city[i].MinVal[boolnum]=CityVal[i][0];
    for(i=0;i<2;i++)
    {
        for(j=1;j<4;j++)
        {
            TempMinVal=32767;
            for(k=1;k<4;k++)
            {
                if(j!=k&&!find(j,k,boolnum))
                {
                TempVal=CityVal[j][k]+city[k].MinVal[boolnum];
                    if(TempMinVal>TempVal)
                    {
                        TempMinVal=TempVal;
                        TempCity=k;
                    }
                }
            }
            city[j].MinVal[(boolnum+1)%2]=TempMinVal;
            copy(TempCity,boolnum,j,(boolnum+1)%2);
        }
        boolnum=(boolnum+1)%2;
    }
    TempMinVal=32767;
    for(i=1;i<4;i++)
    {
        TempVal=CityVal[0][i]+city[i].MinVal[boolnum];
        if(TempMinVal>TempVal)
        {
            TempMinVal=TempVal;
            TempCity=i;
        }
    }
    cout<<"最小费用为:"<<TempMinVal<<endl;
    cout<<"最佳周游路径为:";
    cout<<1<<' ';
    cout<<TempCity+1<<' ';
    for(i=1;i>=0;i--)
        cout<<city[TempCity].PastCity[boolnum][i]+1<<' ';
    cout<<1<<endl;
}