分枝限界法——单源最短路径 收藏

最新推荐文章于 2022-12-12 05:30:00 发布
最新推荐文章于 2022-12-12 05:30:00 发布
阅读量859 收藏
点赞数 1
分类专栏： Algorithm 文章标签： branch struct iostream ini 扩展 n2

1,用set模拟优先级队列：

需要注意的是：在编写Node的“<”比较函数时，必须保证它是“严格弱小于”的，因为对set进行操作的函数如insert，find，erase等都是通过这个函数进行比较的，如果对两个键值都不能 判断它们的“<”关系，则认为它们相等。

view plaincopy to clipboardprint?
#include <iostream>  
#include <set>  
using namespace std;  
const int N = 5;  
const int E = 7;  
const int MAX=65536;  
int g[N][N];  
int dis[N];  
int pre[N];  
struct Node  
{  
    int id;  
    int len;  
    bool operator<(const Node &n)const//保证比较函数的严格若排序（如果两个键值，它们之间都不存在“小于关系”，则被视为相等）  
    {  
        if(len == n.len)  
            return id<n.id;  
        else 
            return len<n.len;   
    }  
};  
struct cmp  
{  
    bool operator()(const Node &n1,const Node &n2)const 
    {  
        return n1<n2;  
    }  
};  
set<Node> mq;//模拟优先级队列（len越小优先级越大）  
void branch_remove(int s)  
{  
    dis[s]=0;  
    pre[s]=-1;  
      
    Node e;  
    e.id = s;  
    e.len = 0;  
    mq.insert(e);  
    int j = 0;  
    while(!mq.empty())  
    {  
        Node p = *(mq.begin());//取出最小值(优先级最高)     
        for(j=0;j<N;j++)  
        {  
            if(g[p.id][j]!=MAX && g[p.id][j]+p.len<dis[j])  
            {  
                dis[j] = g[p.id][j]+dis[p.id];  
                pre[j] = p.id;  
                Node t;  
                t.id = j;  
                t.len = dis[j];  
                  
                //如果当前扩展点已经在队列里，修改其优先级，否则插入该扩展节点  
                mq.erase(t);  
                mq.insert(t);  
            }  
        }  
        //移除当前优先级最高的节点（作为活结点已经扩展完毕）  
        mq.erase(p);  
    }  
}  
int main()  
{  
    int i=0;  
    int j =0;  
    int c=1;  
    for(i=0;i<N;i++)  
        for(j=0;j<N;j++)  
            if(i==j)   
                g[i][j] = 0;  
            else 
                g[i][j] = MAX;  
    for(i=0;i<N;i++)  
        dis[i]=MAX;  
    while(c<=E)  
    {  
        cin>>i;  
        cin>>j;  
        cin>>g[i][j];  
        c++;  
    }  
    branch_remove(0);  
    for(i=0;i<N;i++)  
        cout << dis[i]<<" ";  
    cout << endl;  
} 
#include <iostream>
#include <set>
using namespace std;
const int N = 5;
const int E = 7;
const int MAX=65536;
int g[N][N];
int dis[N];
int pre[N];
struct Node
{
 int id;
 int len;
 bool operator<(const Node &n)const//保证比较函数的严格若排序（如果两个键值，它们之间都不存在“小于关系”，则被视为相等）
 {
  if(len == n.len)
   return id<n.id;
  else
   return len<n.len;
 }
};
struct cmp
{
 bool operator()(const Node &n1,const Node &n2)const
 {
  return n1<n2;
 }
};
set<Node> mq;//模拟优先级队列（len越小优先级越大）
void branch_remove(int s)
{
 dis[s]=0;
 pre[s]=-1;
 
 Node e;
 e.id = s;
 e.len = 0;
 mq.insert(e);
 int j = 0;
 while(!mq.empty())
 {
  Node p = *(mq.begin());//取出最小值(优先级最高) 
  for(j=0;j<N;j++)
  {
   if(g[p.id][j]!=MAX && g[p.id][j]+p.len<dis[j])
   {
    dis[j] = g[p.id][j]+dis[p.id];
    pre[j] = p.id;
    Node t;
    t.id = j;
    t.len = dis[j];
    
    //如果当前扩展点已经在队列里，修改其优先级，否则插入该扩展节点
    mq.erase(t);
    mq.insert(t);
   }
  }
  //移除当前优先级最高的节点（作为活结点已经扩展完毕）
  mq.erase(p);
 }
}
int main()
{
 int i=0;
 int j =0;
 int c=1;
 for(i=0;i<N;i++)
  for(j=0;j<N;j++)
   if(i==j)
    g[i][j] = 0;
   else
    g[i][j] = MAX;
 for(i=0;i<N;i++)
  dis[i]=MAX;
 while(c<=E)
 {
  cin>>i;
  cin>>j;
  cin>>g[i][j];
  c++;
 }
 branch_remove(0);
 for(i=0;i<N;i++)
  cout << dis[i]<<" ";
 cout << endl;
}

  2，使用priority_queue

view plaincopy to clipboardprint?
#include <iostream>  
#include <queue>  
#include <functional>  
using namespace std;  
const int N = 5;  
const int E = 7;  
const int MAX=65536;  
int g[N][N];  
int dis[N];  
int pre[N];  
struct Node  
{  
    int id;  
    int len;  
    bool operator<(const Node &n)const//保证比较函数的严格若排序（如果两个键值，它们之间都不存在“小于关系”，则被视为相等）  
    {  
        if(len == n.len)  
            return id<n.id;  
        else 
            return len<n.len;   
              
    }  
};  
struct cmp  
{  
    bool operator()(const Node &n1,const Node &n2)const 
    {  
        return n1<n2;  
    }  
};  
priority_queue<Node,vector<Node>,cmp >mq;  
void branch_remove(int s)  
{  
    dis[s]=0;  
    pre[s]=-1;  
    Node e;  
    e.id = s;  
    e.len = dis[s];  
    mq.push(e);  
    int j = 0;  
    while(!mq.empty())  
    {  
        Node t = mq.top();  
        for(j=0;j<N;j++)  
        {  
            if(g[t.id][j]!=MAX && g[t.id][j]+t.len < dis[j])  
            {  
                dis[j] = g[t.id][j]+t.len;  
                pre[j] = t.id;  
                Node p;  
                p.id = j;  
                p.len = dis[j];  
                mq.push(p);  
            }  
        }  
        mq.pop();  
    }  
}  
int main()  
{  
    int i=0;  
    int j =0;  
    int c=1;  
    for(i=0;i<N;i++)  
        for(j=0;j<N;j++)  
            if(i==j)   
                g[i][j] = 0;  
            else 
                g[i][j] = MAX;  
    for(i=0;i<N;i++)  
        dis[i]=MAX;  
    while(c<=E)  
    {  
        cin>>i;  
        cin>>j;  
        cin>>g[i][j];  
        c++;  
    }  
    branch_remove(0);  
    for(i=0;i<N;i++)  
        cout << dis[i]<<" ";  
    cout << endl;  
} 
#include <iostream>
#include <queue>
#include <functional>
using namespace std;
const int N = 5;
const int E = 7;
const int MAX=65536;
int g[N][N];
int dis[N];
int pre[N];
struct Node
{
 int id;
 int len;
 bool operator<(const Node &n)const//保证比较函数的严格若排序（如果两个键值，它们之间都不存在“小于关系”，则被视为相等）
 {
  if(len == n.len)
   return id<n.id;
  else
   return len<n.len;
   
 }
};
struct cmp
{
 bool operator()(const Node &n1,const Node &n2)const
 {
  return n1<n2;
 }
};
priority_queue<Node,vector<Node>,cmp >mq;
void branch_remove(int s)
{
 dis[s]=0;
 pre[s]=-1;
 Node e;
 e.id = s;
 e.len = dis[s];
 mq.push(e);
 int j = 0;
 while(!mq.empty())
 {
  Node t = mq.top();
  for(j=0;j<N;j++)
  {
   if(g[t.id][j]!=MAX && g[t.id][j]+t.len < dis[j])
   {
    dis[j] = g[t.id][j]+t.len;
    pre[j] = t.id;
    Node p;
    p.id = j;
    p.len = dis[j];
    mq.push(p);
   }
  }
  mq.pop();
 }
}
int main()
{
 int i=0;
 int j =0;
 int c=1;
 for(i=0;i<N;i++)
  for(j=0;j<N;j++)
   if(i==j)
    g[i][j] = 0;
   else
    g[i][j] = MAX;
 for(i=0;i<N;i++)
  dis[i]=MAX;
 while(c<=E)
 {
  cin>>i;
  cin>>j;
  cin>>g[i][j];
  c++;
 }
 branch_remove(0);
 for(i=0;i<N;i++)
  cout << dis[i]<<" ";
 cout << endl;
}

二者的实现不同之处是：

使用set时，由于set能保证键值的唯一，所以在进行节点的扩展时，实际上是替换set中已存在节点的len值或者添加新节点。

而使用priority_queue不能保证键值唯一，且又不方便查找已存在节点（没有迭代器适配器等操作），故在进行节点扩展时，队列中可能存在重复键值节点，单它们的len值不同，这并不影响对本问题的求解，因为可以通过约束函数将len值较大的节点进行剪枝，但是在运用priority_queue求解其它问题时，这是应当注意的。

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/clearriver/archive/2009/08/30/4499739.aspx

lewutian
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分支界限法实现单源最短路径
gavinloverqq的博客
05-11 2048
#include <iostream> #include <queue> #include <vector> #include <algorithm> #include <ctime> using namespace std; //黑科技最小堆实现方法 /* priority_queue <int> q; int main() { //priority_queue comp() <int>
单源最短路径问题（分支限界法）
独钓寒江雪
12-07 8187
问题描述：在所给的有向图G中，每一边都有一个非负边权，要求图G的从源顶点s到目标顶点t之间的最短路径；算法思想：使用优先队列式分支限界法代码：/************************************************************************//* 单源点最短路劲/* 优先队列式分支限界法
单源最短路径问题——分支限界法（Java）
最新发布
CSDN2022博客之星Top39；华为云博主7&，CSDN、稀土掘金、微信公众号、阿里云开发者社区、腾讯云社区、博客园、知乎、51CTO同名博主WHYBIGDATA；
12-12 1899
单源最短路径问题——分支限界法（Java）
使用分支限界法解决单源最短路径问题。
z2431435的博客
05-30 1万+
#include<iostream> #include<cstdio> #include<queue> using namespace std; typedef struct ArcCell{ int weight;//保存权值 weight=1说明一开始就输入了这条边，=0说明这两个点之间没有边 int min_length;//存储最短路径长度 }ArcCell,AdjMaxtrix[100][100]; typedef struct{
0033算法笔记——【分支限界法】分支限界法与单源最短路径问题
热门推荐
liufeng_king的专栏
05-08 5万+
1、分支限界法     (1)描述：采用广度优先产生状态空间树的结点，并使用剪枝函数的方法称为分枝限界法。      所谓“分支”是采用广度优先的策略，依次生成扩展结点的所有分支（即：儿子结点）。      所谓“限界”是在结点扩展过程中，计算结点的上界（或下界），边搜索边减掉搜索树的某些分支，从而提高搜索效率。     (2)原理：按照广度优先的原则，一个活结点一旦成为扩展结点（E-结点
分支限界法-单源最短路径
11-08
分支限界法 (1)描述：采用广度优先产生状态空间树的结点，并使用剪枝函数的方法称为分枝限界法。 所谓“分支”是采用广度优先的策略，依次生成扩展结点的所有分支（即：儿子结点）。 所谓“限界”是在结点扩展过程中，计算结点的上界（或下界），边搜索边减掉搜索树的某些分支，从而提高搜索效率。 (2)原理：按照广度优先的原则，一个活结点一旦成为扩展结点（E-结点）R后，算法将依次生成它的全部孩子结点，将那些导致不可行解或导致非最优解的儿子舍弃，其余儿子加入活结点表中。然后，从活结点表中取出一个结点作为当前扩展结点。重复上述结点扩展过程，直至找到问题的解或判定无解为止。
分支限界法之单源最短路径
就很秃然
01-01 817
参考文章：分支限界法之单源最短路径
分支限界法求解单源最短路径.zip
12-21
在本案例中，我们关注的是如何利用分支限界法求解单源最短路径问题。单源最短路径问题是从一个指定的起点到图中所有其他顶点的最短路径问题，这个问题在图论和计算机科学中有广泛的应用，例如网络路由优化、物流配送...
贪新算法和分支限界法解单源最短路径.doc
05-12
贪新算法和分支限界法解单源最短路径 贪新算法和分支限界法是两种不同类型的算法，分别用于解决单源最短路径问题。下面将对这两种算法进行详细的介绍和分析。 一、分支限界法 分支限界法是一种搜索算法，用于解决...
单源最短路径--分支限界法
10-23
"单源最短路径--分支限界法" 单源最短路径是图论中的一种常见问题，它是指从一个源顶点到所有其他顶点的最短路径长度。这里的长度是指路上各边权之和。本文将介绍一种解决单源最短路径问题的方法，即分支限界法。 ...
分支限界法求解单源最短路径
12-20
在分支限界法求解单源最短路径的过程中，我们通常从源点开始，初始化路径长度为0，并将源点放入最小堆。然后，我们不断从堆中取出路径长度最小的节点，检查它是否为目标节点，如果是，则找到了最短路径；如果不是，...
算法设计-分支界限法——单源最短路径问题
weixin_44034024的博客
12-22 1万+
算法介绍 分支界限法： 分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。 在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。 此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时为止。 与回溯法的区别： （1）求解目标：回溯法的求解目标是找出解空间树中满足约束条件的所有解
单源最短路径-贪心算法和分支限界法
qq_41701219的博客
12-30 1498
单元最短路径一、贪心法二、分支限界法 一、贪心法 来源：0024算法笔记——【贪心算法】单源最短路径问题 二、分支限界法
分支限界法-优先队列-单源最短路径
lfbcsdn博客
06-23 1万+
算法思想：分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时...
单源最短路径（分支限界）
哈哈哈哈哈哈哈哈的博客
06-09 3088
优先级：当前路径长度 剪枝函数：由于图G中各边的权均非负，所以结点所对应的当前路长也是解空间树中以该结点为根的子树中所有结点对应的路长的一个下界。扩展结点的过程中，一旦发现一个结点的下界不小于当前找到的最短路长，则算法剪去以该结点为根的子树。 数据的存储： ①二维数组Type G[n][n]存储邻接矩阵 ②数组Type dist[n]记录源点到各顶点的距离 ③数组int prev[n]记录从源到各顶点路径上的前驱顶点 Graph： template <class Type>.
单源点最短路径 c++实现 分支限界算法
longzuo
05-25 3333
问题描述：在一个网（带权图）中，从指定节点出发，找到到各个节点的最短路径   分支限界思想： 一个问题的解空间可以用一棵树来表示，比如此题，在此题的解空间树中，根是指定节点，任何一个节点的子女是与此节点连接的除父节点之外的所有节点。 当使用分支限界思想来解决此题时，在广度遍历此树的过程中，及时对那些不可能的子树进行剪枝。 用一个最小堆来存储活节点表，其key是对应节点
分支限界----最短路径
Me的专栏
06-04 2961
最短路径 #include #include #include #include #include using namespace std; class MinNode { public : int id;//顶点编号 int length;//当前路长 friend bool operator<(MinNode A, MinNode B) { return (A
单源最短路径问题
新博客：https://aping-dev.com/
10-19 555
#include "cstdio" #include "queue" #define MAX 20 #define INF 999 using namespace std; int c[11][11];//邻接矩阵 int n; //图中结点个数 int dist[MAX]; //存储从源结点到各个结点的最短距离 int pre[MAX]; //pre[i]表示从源节点到结点i最短
分枝限界法求解单源最短路径实验
"分枝限界法实验，用于求解单源最短路径问题，对比回溯算法，涉及数组存储、权重更新、路径查找等环节。实验要求包括算法描述、编写程序、调试和结果分析。" 在这个实验中，我们将探讨分枝限界法（Branch and Bound...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值