基于队列的BellmanFord算法(c++ 有向图)

最新推荐文章于 2024-08-05 11:53:41 发布
最新推荐文章于 2024-08-05 11:53:41 发布
阅读量639 收藏
点赞数
分类专栏： 算法 文章标签： 图 最短路径
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RGBMarco/article/details/77921704
版权

构建图:

DiWeightGraph.h

#pragma once
#include <memory>
#include <fstream>
#include <string>
template <typename T>
class BellmanFordSP;
template <typename T>
class DoCycle;
template <typename T>
class DiDoCycle;
template <typename T>
class NoCycleSP;
template <typename T>
class DiWeightGraph
{
public:
    class AdjacentcyList
    {
    public:
        class Edge
        {
        public:
            int v;
            int w;
            T weight;
            std::shared_ptr<Edge> next;
        public:
            Edge(const int& v, const int& w, const T& weight) :v(v), w(w), weight(weight), next(nullptr)
            {

            }
            Edge(const Edge& e):v(e.from()),w(e.to()),weight(e.weight),next(nullptr)
            {

            }
            int from()const
            {
                return v;
            }
            int to()const
            {
                return w;
            }
        };
        class Iterator
        {
        private:
            std::shared_ptr<Edge> it;
        public:
            Iterator(std::shared_ptr<Edge> e) :it(e)
            {

            }
            Iterator operator ++()
            {
                if (it == nullptr)
                    return *this;
                it = it->next;
                return *this;
            }
            bool operator !=(const Iterator& rhs)const
            {
                return it != rhs.it;
            }
            bool operator == (const Iterator& rhs)const
            {
                return it == rhs.it;
            }
            Edge operator *()
            {
                if (it == nullptr)
                    throw std::out_of_range("* nullptr");
                return *it;
            }
        };
        std::shared_ptr<Edge> head;
    public:
        AdjacentcyList():head(nullptr)
        {

        }
        void addEdge(const Edge& e)
        {
            if (head == nullptr)
            {
                head = std::make_shared<Edge>(Edge(e.from(),e.to(),e.weight));
                return;
            }
            std::shared_ptr<Edge> curr = head;
            while (curr->next != nullptr)
            {
                curr = curr->next;
            }
            curr->next = std::make_shared<Edge>(Edge(e.from(),e.to(),e.weight));
            return;
        }
        Iterator begin()const
        {
            return Iterator(head);
        }
        Iterator end()const
        {
            return Iterator(nullptr);
        }
    };
private:
    std::unique_ptr<AdjacentcyList[]> adj;
    int nV;
    int nE;
public:
    void addedge(const typename AdjacentcyList::Edge& e)
    {
        adj[e.from()].addEdge(e);
        ++nE;
    }
public:
    DiWeightGraph(const std::string& file)
    {
        std::ifstream in(file);
        if (in.fail())
            throw std::domain_error("文件打开失败\n");
        in >> nV;
        adj = std::move(std::unique_ptr<AdjacentcyList[]>(new AdjacentcyList[nV]));
        while (!in.eof())
        {
            int v, w;
            T weight;
            in >> v >> w >> weight;
            addedge(AdjacentcyList::Edge(v, w, weight));
        }
    }
    DiWeightGraph(const int& v):nV(v),adj(new AdjacentcyList[v])
    {

    }
    void display()
    {
        for (int i = 0; i < nV; ++i)
        {
            for (auto &e : adj[i])
                cout << e.from() << ends << e.to() << ends << e.weight << endl;
        }
    }
    friend class BellmanFordSP<T>;
    friend class DoCycle<T>;
    friend class DiDoCycle<T>;
    friend class NoCycleSP<T>;
};

核心算法: BellmanFord.h

#pragma once
#include "DiWeightGraph.h"
#include <queue>
#include "DiDoCycle.h"

template <typename T>
class BellmanFordSP
{
    using Ed = typename DiWeightGraph<T>::AdjacentcyList::Edge;
private:
    std::queue<int> q;
    std::unique_ptr<T[]> disTo;
    Ed** edge;
    int count;
    std::unique_ptr<bool[]> onQueue;
    bool isnegativeCycle;
    int start;
private:
    void findNegativeCycle()
    {
        DiWeightGraph<T> *dwg = new DiWeightGraph<T>(count);
        for (int i = 0; i < count; ++i)
        {
            if (edge[i] != nullptr)
            {
                dwg->addedge(*(edge[i]));
            }
        }
        DiDoCycle<T> ddc(dwg);
        isnegativeCycle = ddc.negative();
    }
    void relax(DiWeightGraph<T> *dwg,const int& s)
    {
        for (auto& e : dwg->adj[s])
        {
            int w = e.to();
            if (disTo[w] > disTo[s] + e.weight)
            {
                edge[w] = new Ed(e.from(), e.to(), e.weight);
                disTo[w] = disTo[s] + e.weight;
                if (!onQueue[w])
                {
                    q.push(w);
                    onQueue[w] = true;
                }
            }
        }
        if (++count % dwg->nV == 0)
            findNegativeCycle();
    }
public:
    BellmanFordSP(DiWeightGraph<T> *dwg,const int& s) :disTo(new T[dwg->nV]), edge(new Ed*[dwg->nV]), count(0),onQueue(new bool[dwg->nV]),isnegativeCycle(false),start(s)
    {
        for (int i = 0; i < dwg->nV; ++i)
        {
            disTo[i] = std::numeric_limits<T>::max();
            edge[i] = nullptr;
            onQueue[i] = false;
        }
        disTo[s] = T{};
        q.push(s);
        onQueue[s] = true;
        while (!q.empty() && !isnegativeCycle)
        {
            int v = q.front();
            q.pop();
            onQueue[v] = false;
            relax(dwg, v);
        }
    }
    void display_path(const int& e)
    {
        std::stack<int> sk;
        sk.push(e);
        for (auto ed = edge[e]; ed != nullptr; ed = edge[ed->from()])
        {
            sk.push(ed->from());
            if (ed->from() == start)
                break;
        }
        while (sk.size() > 1)
        {
            std::cout << sk.top() << "--> ";
            sk.pop();
        }
        if (sk.size() == 1)
        {
            std::cout << sk.top() << endl;
            sk.pop();
        }
    }
};

处理有无环问题:

DoCycle.h

#pragma once
#include "DiWeightGraph.h"
#include <memory>
#include <unordered_set>
#include <stack>

template <typename T>
class DoCycle
{
    using Ed = typename DiWeightGraph<T>::AdjacentcyList::Edge;
    class Equal
    {
    public:
        Equal()
        {

        }
        bool operator()(std::stack<Ed> lhs,std::stack<Ed> rhs)const
        {
            while (!lhs.empty())
            {
                int v1 = lhs.top().from();
                if (rhs.empty())
                    return false;
                int v2 = rhs.top().from();
                if (v1 != v2)
                    return false;
                lhs.pop();
                rhs.pop();
            }
            if (!rhs.empty())
                return false;
            return true;
        }
    };
    class Hash
    {
    public:
        Hash()
        {

        }
        size_t operator ()(const std::stack<Ed>& sk)const
        {
            size_t ret = std::hash<T>()(sk.top().weight);
            return ret;
        }
    };
private:
    bool iscycle;
    std::unique_ptr<bool[]> onStacked;
    std::unique_ptr<bool[]> marked;
    std::unique_ptr<std::shared_ptr<Ed>[]> edge;
public:
    std::unordered_set<std::stack<Ed>, Hash, Equal> cycle;
private:
    void init(DiWeightGraph<T> *dwg)
    {
        for (int i = 0; i < dwg->nV; ++i)
        {
            onStacked[i] = false;
            marked[i] = false;
            edge[i] = nullptr;
        }
    }
    void dfs(DiWeightGraph<T> *dwg,const int& s)
    {
        marked[s] = true;
        onStacked[s] = true;
        for (auto &e : dwg->adj[s])
        {
            int w = e.to();
            if (!onStacked[w])
            {
                edge[w] = std::make_shared<Ed>(Ed(e.from(), e.to(), e.weight));
                if (!marked[w])
                    dfs(dwg, w);
            }
            else
            {
                std::stack<Ed> sk;
                sk.push(Ed(e.from(), e.to(), e.weight));
                for (std::shared_ptr<Ed> i = edge[s]; i != nullptr; i = edge[i->from()])
                {
                    sk.push(Ed(i->from(), i->to(), i->weight));
                    if (i->from() == w)
                        break;
                }
                cycle.insert(sk);
            }
        }
        onStacked[s] = false;
    }
    void dfs(DiWeightGraph<T> *dwg)
    {
        for (int i = 0; i < dwg->nV; ++i)
        {
            init(dwg);
            dfs(dwg, i);
        }
    }
public:
    DoCycle(DiWeightGraph<T> *dwg):onStacked(new bool[dwg->nV]),marked(new bool[dwg->nV]),edge(new std::shared_ptr<Ed>[dwg->nV]),iscycle(false)
    {
        dfs(dwg);
        if (!cycle.empty())
            iscycle = true;
    }
    void display_cycle()
    {
        if (!iscycle)
            return;
        int i = 1;
        for (auto sk : cycle)
        {
            int loop = sk.top().from();
            std::cout << "第" << i << "个环: ";
            while (!sk.empty())
            {
                std::cout << sk.top().from() << "--> ";
                sk.pop();
            }
            std::cout << loop << std::endl;
            ++i;
        }
    }
    bool Is_cycle()
    {
        return iscycle;
    }
};

处理负权重环问题:

#pragma once
#include <stack>
#include "DiWeightGraph.h"

template <typename T>
class DiDoCycle
{
    using Ed = typename DiWeightGraph<T>::AdjacentcyList::Edge;
private:
    bool isnegative;
    T negativeWeight;
public:
    DiDoCycle(DiWeightGraph<T> *dwg):isnegative(false),negativeWeight()
    {
        DoCycle<T> dc(dwg);
        std::stack<Ed> get;
        for (auto sk : dc.cycle)
        {
            if (sk.size() == dwg->nE)
            {
                get = sk;
                break;
            }
        }
        while (!get.empty())
        {
            negativeWeight += get.top().weight;
            get.pop();
        }
        if (negativeWeight < 0)
        {
            isnegative = true;
        }
    }
    bool negative()
    {
        return isnegative;
    }
    T negative_Weight()
    {
        if (negative)
            retrurn negativeWeight;
        else
            throw std::out_of_range("not is nagative");
    }
};

用于可验证处理无环图来验证其正确性(可舍去)

#pragma once
#include "DiWeightGraph.h"
#include <stack>
#include "DoCycle.h"

template <typename T>
class NoCycleSP
{
    using Ed = typename DiWeightGraph<T>::AdjacentcyList::Edge;
private:
    std::unique_ptr<bool[]> marked;
    std::unique_ptr<T[]> disTo;
    std::stack<int> resufdfs;
    Ed **edge;
    int start;
    bool iscycle;
private:
    void dfs(DiWeightGraph<T> *dwg, const int& s)
    {
        marked[s] = true;
        for (auto &e : dwg->adj[s])
        {
            int w = e.to();
            if (!marked[w])
            {
                dfs(dwg, w);
            }
        }
        resufdfs.push(s);
    }
    void dfs(DiWeightGraph<T> *dwg)
    {
        if (iscycle)
            throw std::domain_error("there exist cycle");
        for (int i = 0; i < dwg->nV; ++i)
            if (!marked[i]) dfs(dwg, i);
    }
    void relax(DiWeightGraph<T> *dwg,const int& s)
    {
        for (auto &e : dwg->adj[s])
        {
            int w = e.to();
            if (disTo[w] > disTo[s] + e.weight)
            {
                disTo[w] = disTo[s] + e.weight;
                edge[w] = new Ed(s, w, e.weight);
            }
        }
    }
public:
    NoCycleSP(DiWeightGraph<T>* dwg,const int& s):marked(new bool[dwg->nV]),disTo(new T[dwg->nV]),start(s),edge(new Ed*[dwg->nV]),iscycle(false)
    {
        for (int i = 0; i < dwg->nV; ++i)
        {
            marked[i] = false;
            disTo[i] = std::numeric_limits<T>::max();
            edge[i] = nullptr;
        }
        DoCycle<T> dc(dwg);
        iscycle = dc.Is_cycle();
        dfs(dwg);
        disTo[start] = T{};
        while (!resufdfs.empty())
        {
            int w = resufdfs.top();
            resufdfs.pop();
            relax(dwg, w);
        }
    }
    T getWeight(const int& e)
    {
        return disTo[e];
    }
    void display_path(const int& e)
    {
        std::stack<int> sk;
        sk.push(e);
        for (auto ed = edge[e]; ed != nullptr; ed = edge[ed->from()])
        {
            sk.push(ed->from());
            if (ed->from() == start)
                break;
        }
        while (sk.size() > 1)
        {
            std::cout << sk.top() << "--> ";
            sk.pop();
        }
        if (sk.size() == 1)
        {
            std::cout << sk.top() << endl;
            sk.pop();
        }
    }
};

负权重环图: test.txt

8
4 5 0.35
5 4 0.35
4 7 0.37
5 7 0.28
7 5 0.28
5 1 0.32
0 4 0.38
0 2 0.26
7 3 0.39
1 3 0.29
2 7 0.34
6 2 -1.20
3 6 0.52
6 0 -1.40
6 4 -1.25

无环图:

8
5 4 0.35
4 7 0.37
5 7 0.28
5 1 0.32
4 0 0.38
0 2 0.26
3 7 0.39
1 3 0.29
7 2 0.34
6 2 0.40
3 6 0.52
6 0 0.58
6 4 0.93

main.cpp

#include <iostream>
#include "DiWeightGraph.h"
#include "DoCycle.h"
#include "DiDoCycle.h"
#include "BellmanFordSP.h"
#include "NoCycleSP.h"

using namespace std;

int main()
{
    DiWeightGraph<double> dwg("Text.txt");
    cout << "BellmanFordSP：" << endl;
    BellmanFordSP<double> bfsp(&dwg, 5);
    bfsp.display_path(6);
    cout << "NoCycleSP: " << endl;
    NoCycleSP<double> ncsp(&dwg,5);
    ncsp.display_path(6);
    system("pause");
    return 0;
}

这里写图片描述

注释掉NoCycleSP内容:改用 Text.txt 寻 0->1路径

这里写图片描述

RGBMarco
关注
专栏目录
算法笔记17：基于队列改进的Bellman-ford算法
SGT的博客
06-05 360
改进的Bellman-ford算法 本文承接自算法笔记16：单源最短路径 基于队列的Bellman-ford算法的改进：根据前面讲到，对于边e:v→w，只有distTo[v]改变，distTo[w]才会改变，那么我们不需要放松所有边重复V轮，我们只需要放松可能改变的点，例如在下图中，从起点0开始，只有顶点1 2 3才会改变，那么将1 2 3加入队列去放松，其他顶点的不会改变就不会放松。放松1时将4...
BellmanFord算法与SPFA算法
10247D的博客
12-10 1057
BellmanFord算法与SPFA算法
基于队列优化的Bellman-Ford算法
Greedy Hat的博客
11-10 178
/*队列优化的Bellman-Ford算法*/ #include <bits/stdc++.h> using namespace std; int main(){ int u[8],v[8],w[8]; int first[6],next[8]; int dis[6]={0},book[6]={0}; int inf=9999999; int ...
【c++刷题笔记-图论】day61：Bellman_ford 队列优化算法（又名SPFA）、bellman_ford之判断负权回路、bellman_ford之单源有限最短路
最新发布
qq_48662659的博客
08-05 242
对所有边松弛一次，相当于计算起点到与起点一条边相连的节点的最短距离bellman_ford算法的核心就在松弛操作上。
bellman-ford算法的C++实现，邻接表
11-13
bellman-ford算法的C++实现，邻接表
单源最短路径Bellman_Ford算法C++实现
pleasetojava
11-09 260
// 单源最短路径Bellman_Ford算法.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; #define MAX 100 #define Infinity 65535 typedef int WeiType; us...
Bellman-Ford——C++实现版
铭霏的记事本
11-18 1602
// Bellman_Ford.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #define MAX_VALUE 1000 using namespace std; struct Edge{ int Begin; int End; int Weight; int Pre; }; struct MGraph
C++ 最短路径之Bellman-Ford算法
struct_GS的博客
09-08 1293
贝尔曼-福特（Bellman-Ford）是由 理查德·贝尔曼（Richard Bellman）和 莱斯特·福特 创立的，求解单源最短路径问题的一种算法。有时候这种算法也被称为 Moore-Bellman-Ford 算法，因为 Edward F. Moore 也为这个算法的发展做出了贡献。它的原理是对图进行V-1次松弛操作，得到所有可能的最短路径。其优于Dijkstra 算法的方面是边的权值可以为负数、实现简单，缺点是时间复杂度过高。但算法可以进行若干种优化，提高效率。 时...
队列优化的Bellmanford最短路算法（SPFA）C++实现
01-10
队列优化的Bellman-Ford最短路算法（SPFA，Shortest Path Faster Algorithm）是一种在图论中用于寻找有向图中单源最短路径的算法，它是在经典Bellman-Ford算法基础上进行优化得到的。Bellman-Ford算法本身能够处理...
Dijkstra_bellmanford算法实现
07-17
Dijkstra算法由荷兰计算机科学家艾兹格·迪科斯彻提出，用于寻找带权有向图中从单一源节点到其余所有节点的最短路径。其主要思想是使用贪心策略，每次选取当前未访问节点中距离源节点最近的一个进行扩展。该算法使用...
C++有向带权图单源最短路径
Summit的专栏
10-29 2895
C++有向带权图单源最短路径参考《算法》最短路径章节编写实现代码，包括无负权边无环的Dijkstra算法，也包括可以处理一般性问题的Bellman-Ford算法。同时采用泛型编程，图节点可以实现任意类型，具体原理参见《算法》最短路径章节，实现代码如下所示：#include<iostream> #include<algorithm> #include<queue> using namespace st
bellman-Ford实现
03-28
bellman-Ford算法的具体实现，用c++的语法实现，简单易懂。
Bellman-Ford算法C++实现
qq_41551761的博客
04-13 463
Bellman-Ford算法是一种用于解决带负权重边的单源最短路径问题的经典算法。该算法由理查德·贝尔曼和艾德加·福特于20世纪50年代提出。以下是Bellman-Ford算法的详细介绍:算法概述:算法步骤:算法复杂度:算法应用: 代码说明： 数据结构：使用 来表示图的边， 来表示整个图。 图的初始化：通过 函数向图中添加边。 Bellman-Ford 算法实现： 初始化所有顶点的最短路径估计值为无穷大，除了源顶点为0。 进行 V-1 次迭代来松弛所有边。 最后，再检查一次所有边，以确定图中是否存在
bellman-ford——图论（C++）
Annabel_CM的博客
10-19 296
Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。 这时候，就需要使用其他的算法来求解最短路径，Bellman-Ford算法就是其中最常用的一个。该算法由美国数学家理查德•贝尔曼（Richard Bellman, 动态规划的提出者）和小莱斯特•福特（Lester Ford）发明。 适用条件&范围 1、单源最短路径(从源点s到其它所有顶点v); 2、有向图&无向图(无向图可以看作(u
Bellman-ford 算法详解
dfssbqyrq96616258的博客
07-23 270
昨天说的dijkstra固然很好用，但是却解决不了负权边，想要解决这个问题，就要用到Bellman-ford. 我个人认为Bellman-Ford比dijkstra要好理解一些，还是先上数据（有向图）： 5 7 1 2 8 1 3 5 2 3 -65 4 -3 2 4 7 3 5 -2 4 5 -3 在讲述开，先设几个数组： origin[i]表示编号为i这条...
Bellman-Ford算法图解及手算过程详解 —— C++代码实现
枯木何日可逢春
09-30 1244
Bellman-Ford算法图解及手算过程详解 —— C++代码实现
算法18-基于队列的Bellman-Ford算法、负权重环检测
起舞的日子
04-27 461
读者盆友，晚上好！ 咱们继续介绍加权有向图，这次考虑有环、有边的权重为负的情况。 文章目录一、基于队列的Bellman-Ford算法二、负权重环检测三、源码 一、基于队列的Bellman-Ford算法 package com.cmh.algorithm.graph; import edu.princeton.cs.algs4.Queue; import edu.princeton.cs.algs...
队列优化——Bellman-Ford算法
Archerrrrr的博客
08-01 548
Bellman-Ford算法如果存在一个顶点已经达到最短路径但还会继续判断是否需要松弛 优化关键：每次仅对最短路径估计值发生变化了的顶点的所有出边执行松弛操作 队列优化的Bellman-Ford算法 原理：我们可以用一个队列来维护，该顶点最短路径估计值发生变化的点，因为如果该顶点最短路径发送了变化，则对后续经过该顶点的最短路径也会发生变化，则需要再次以该顶点进行松弛 算法关键 使用邻接表来存储边和点（稀疏图） 先将源点入队，然后以该源点为队首进行相邻边的松弛，如果该队首顶点的出边成功松弛，则出边对应的顶点入
C++实现Bellmanford算法
chriselp
06-06 535
#include #include #include #include #include #include #include #include #include #include #include using namespace std; const int INF = 100000000; struct Node{ int dist; int pre; Node() : dist(
实现Bellmanford算法
06-11
Bellman-Ford算法是一种解决带负权边的单源最短路径问题的算法。它的基本思路是通过对所有边进行松弛操作来逐步逼近最短路径的结果。具体实现步骤如下： 1. 创建一个数组dist，表示源点到各个顶点的距离，初始化为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值