分支限界法-优先队列-单源最短路径

算法思想：

分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时为止。     

解题模型:

 （1）队列式(FIFO):  分支限界法按照队列先进先出（FIFO）原则选取下一个节点为扩展节点。

 （2）优先队列式分支限界: 按照优先队列中规定的优先级选取优先级最高的节点成为当前扩展节点。

分支限界法与回溯法的差别：

  (1）求解目标：回溯法的求解目标是找出解空间树中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解（优先队列式求得的解就是最终最优解）, 或是在满足约束条件的解中找出在某种意义下的最优解。

（2）搜索方式的不同：回溯法以深度优先的方式搜索解空间树，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间树。

搜索策略:

在当前节点（扩展节点）处，先生成其所有的儿子节点（分支），然后再从当前的活节点（当前节点的子节点）表中选择下一个扩展节点。为了有效地选择下一个扩展节点，加速搜索的进程，在每一个活节点处，计算一个函数值（限界），并根据函数值，从当前活节点表中选择一个最有利的节点作为扩展节点，使搜索朝着解空间上有最优解的分支推进，以便尽快地找出一个最优解。分支限界法解决了大量离散最优化的问题。

(PS: 分支限界法一般用优先队列解决。队列式对某些问题无法求得最优解)

单源最短路径题意可看链接 ：https://blog.csdn.net/lfb637/article/details/80176172

代码：

/**
   @回溯法-优先队列解単源最短路径
*/
#include<iostream>
#include<algorithm>
#include<queue>
#define MAX 100
#define LIMITLESS 65535
using namespace std;
int cost[MAX];                 //源点到顶点的距离
typedef struct{
    bool operator()(int &a,int &b){
         return cost[a]>cost[b];
    }
}cmp;
typedef struct Graph{
    int v,e;
    int vex[MAX];
    int wei[MAX][MAX];
}Graph,*graph;
void createGraph(graph g){
    cout<<"输入顶点和边数:"<<endl;
    cin>>g->v>>g->e;
    cout<<"输入顶点值:"<<endl;
    for(int i = 1;i<=g->v;i++){
         cin>>g->vex[i];
    }
    for(int i = 1;i<=g->v;i++){          //图的权值初始化
        for(int j = 1;j<=g->v;j++){
            g->wei[i][j] = LIMITLESS;
        }
    }
    cout<<"输入两连接点下标和权值:"<<endl;
    int k1,k2,weight;
    for(int i = 1;i<=g->e;i++){
        cin>>k1>>k2>>weight;
        g->wei[k1][k2] = weight;
    }
}
void  printGraph(graph g){
       for(int i = 1;i<=g->v;i++){
          for(int j = 1;j<=g->v;j++){
              if(g->wei[i][j]!=LIMITLESS){
                  cout<<g->wei[i][j]<<"  ";
              }
              else{
                  cout<<"oo"<<"  ";
              }
          }
          cout<<endl;
      }
}
void  dijkstra(graph g,int sour){
      cost[sour] = 0;
      for(int i = 2;i<=g->v;i++){                   //cost[i]初始化为源点到各顶点的权值
          cost[i] = g->wei[sour][i];
      }
      priority_queue<int,vector<int>,cmp> p;      //优先队列
      p.push(sour);                              //源点入队列
      int flag [MAX];                           //顶点的出队顺序
      int k = 0;
      while(!p.empty()){
          int item = p.top();
          flag[k++] = item;
          p.pop();
          /*顶点间距离优化*/
          for(int i = item;i<=g->v;i++){
             if((g->wei[item][i]!=LIMITLESS)&&(cost[item]+g->wei[item][i]<=cost[i])){
                  cost[i] = cost[item]+g->wei[item][i];
                  p.push(i);
             }
          }
      }
      for(int i = 2;i<=g->v;i++){
          cout<<"源点到"<<i<<"顶点的最短距离为:"<<cost[i]<<endl;
      }
      cout<<"顶点的出队列顺序(按源点到顶点距离短的优先):"<<endl;
      for(int i = 0;i<k;i++){
          cout<<flag[i]<<" ";
      }
}
int main(){
     Graph g;               //不能用指针定义(graph g)
     createGraph(&g);
     cout<<"构建的图为:"<<endl;
     printGraph(&g);
     cout<<"(分治限界法-优先队列)単源最短路径为:"<<endl;
     dijkstra(&g,1);
}