【Algorithm】最短路径算法

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

1 前言

从某顶点出发，沿图的边到达另一顶点所经过的路径中，各边上权值之和最小的一条路径叫做最短路径。解决最短路的问题有以下算法

  1. Dijkstra 算法
  2. Bellman-Ford 算法
  3. SPFA 算法（Bellman-Ford 算法的优化算法）
  4. Floyd 算法等

给出一些名词解释：

  • 单源最短路径：从图中某个顶点到图其他各顶点的最短路径
  • Relax 松弛：这是最短路径算法里面最关键的一步（我也不清楚怎么解释，自行体会吧）
  • 邻接矩阵与邻接表：都是表示图的方法，很简单，自行搜索
  • 负权值环：最简单的负权值环就是，自己到自己的一个负权值边（构成了一个回环）；如此以来不断地通过这个环（路径），那我岂不可以无限缩短距离，真是鬼才

本文没有详细介绍（写起来太麻烦，还不如直接看视频容易理解）但是有推荐视频或文章，这里主要有我的具体实现，仅供参考

最后推荐一个 Github 项目，这是我在找资料的时候看到的，里面的算法实现均为 JAVA 语言，根据他的实现，本文提供 C++ 的实现，保持尽量了几种算法风格的统一，如发现错误，请指正~

2 Dijkstra 算法

关于这个算法，推荐看一下这个 Video 讲解，我在这里也就不介绍了，主要看实现

关键词：

  • 单源最短路径
  • 贪心算法

缺点：

  • 图中有负权值边时往往不适用，但可以选择 Bellman-Ford 算法代替。注：有负权值边导致出现负权值环才会使 Dijkstra 失效，而 Bellman-Ford 可以定位到负权值环，并且解决这个问题，后面会提到。

2.1 邻接矩阵实现

效率分析，我们用 V 代表顶点数， E 代表边数

  • 时间复杂度 O ( V 2 ) O(V^2) O(V2)

C++ 实现，一般来说需要以下四个完成

  • graph 是由邻接矩阵表示的图，相当于一个二维数组
  • vistied 负责维护访问过的节点，没访问 false，访问了设置 true
  • dis 负责维护由源点到每个顶点的最短距离
  • path 保存的是最短路径，在这里我是维护了完整的路径，但实际上只需要维护前一个点就可以了
#include <vector>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <limits>

using namespace std;

#define POSITIVE_INF (numeric_limits<int>::max())  // <limits> 里定义的

void Dijkstra(vector<vector<double> > &graph, vector<double> &dis, vector<int> *path, const int vNum, const int vStart) {

    fill_n(dis.begin(), vNum, POSITIVE_INF);
    dis[vStart] = 0;

    bool *visited = new bool[vNum];
    fill_n(visited, vNum, false);

    for (int k = 0; k < vNum; k++) {
        int minNum = POSITIVE_INF, minIndex = -1;
        for (int i = 0; i < vNum; i++) { //找一个最小距离的顶点
            if (false == visited[i] && dis[i] < minNum) {
                minNum = dis[i];
                minIndex = i;
            }
        }
        visited[minIndex] = true;
        for (int j = 0; j < vNum; j++) {
            if (true == visited[j]) continue; //已经访问过的跳过
            if (graph[minIndex][j] == POSITIVE_INF) continue; //通过 minIndex 无法到达 j，跳过
            if (dis[j] > dis[minIndex] + graph[minIndex][j]) { //Relax 操作
                dis[j] = dis[minIndex] + graph[minIndex][j]; //更新最短距离
                path[j] = path[minIndex]; //更新路径
                path[j].push_back(minIndex);
            }
        }
    }
    delete[]visited;
}

void AddEdge(vector<vector<double> > &graph, int from, int to, double cost) {
	graph[from][to] = cost;
}

void PrintPath(vector<int>& path, int self) {
    for (int v : path) {
        cout << v << "->";
    }
    cout << self << endl;
}

void PrintMatrix(vector<vector<double> > &graph) {
    for (auto level : graph) {
        cout << "[";
        for (auto v : level) {
            if (v >= POSITIVE_INF) cout << setw(5) << left << "inf";
            else cout << fixed << setprecision(0) << setw(5) << left << v;
        }
        cout << "]\n";
    }
    cout << endl;
}

int main() {
    int vNum = 5, vStart = 0;
    vector<vector<double> > graph(vNum, vector<double>(vNum, POSITIVE_INF));
    vector<double> dis(vNum, POSITIVE_INF); //记录源点到其他点的最短距离
    vector<int>* path = new vector<int>[vNum]; //记录最短距离经过的路径

    for(int i = 0; i < vNum; i++) AddEdge(graph, i, i, 0);
    AddEdge(graph, 0, 1, 6);
    AddEdge(graph, 0, 3, 1);
    AddEdge(graph, 1, 0, 6);
    AddEdge(graph, 1, 2, 5);
    AddEdge(graph, 1, 3, 2);
    AddEdge(graph, 1, 4, 2);
    AddEdge(graph, 2, 1, 5);
    AddEdge(graph, 2, 4, 5);
    AddEdge(graph, 3, 0, 1);
    AddEdge(graph, 3, 1, 2);
    AddEdge(graph, 3, 4, 1);
    AddEdge(graph, 4, 1, 2);
    AddEdge(graph, 4, 2, 5);
    AddEdge(graph, 4, 3, 1);

    PrintMatrix(graph);
    
    Dijkstra(graph, dis, path, vNum, vStart);

    for (int i = 0; i < vNum; i++) {
        cout << "From " << vStart << " to " << i << " distance: " << setw(5) << dis[i];
        PrintPath(path[i], i);
    }

    delete[]path;
    system("pause");

    // From 0 to 0 distance: 0    0
    // From 0 to 1 distance: 3    0->3->1
    // From 0 to 2 distance: 7    0->3->4->2
    // From 0 to 3 distance: 1    0->3
    // From 0 to 4 distance: 2    0->3->4
}

2.2 邻接表实现

效率分析，我们用 V 代表顶点数， E 代表边数

  • 简单实现，时间复杂度 O ( E V ) O(EV) O(EV)
  • 优先队列（最小堆），时间复杂度 O ( E l o g V ) O(ElogV) O(ElogV)

C++ 实现，不懂看注释

#include <vector>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <limits>
#include <queue>

using namespace std;

#define POSITIVE_INF (numeric_limits<int>::max())  // <limits> 里定义的

struct Edge {
    int from;
    int to;
    double cost;
    Edge(int from, int to, double cost) :from(from), to(to), cost(cost) {}
};

typedef pair<double, int> Node; // first 为到该顶点的最短距离，second 为顶点编号，这个数据结构用于优先队列里排序用的

void AddEdge(vector<Edge> *graph, int from, int to, double cost) {
    graph[from].push_back(Edge(from, to, cost));
}

//使用优先队列实现，时间复杂度 O((ElogV)
void Dijkstra_PQ(vector<Edge> *graph, vector<double> &dis, vector<int> *path, const int vNum, const int vStart) {
    
    fill_n(dis.begin(), vNum, POSITIVE_INF);
    dis[vStart] = 0;

    priority_queue<Node, vector<Node>, greater<Node> > q; //距离小的先出队，比较的是 Node.frist
    q.push(Node(0, vStart));

    bool *visited = new bool[vNum]; //设置已访问过的数组
    fill_n(visited, vNum, false);

    while (!q.empty()) {
        Node node = q.top(); q.pop();
        visited[node.second] = true;
        if (dis[node.second] < node.first) continue; //队列里的这个节点最短距离的值旧了，跳过
        for (Edge edge : graph[node.second]) {
            if (visited[edge.to]) continue; //已经访问过的节点则跳过
            if (dis[edge.to] > dis[edge.from] + edge.cost) { //Relax 操作
                dis[edge.to] = dis[edge.from] + edge.cost; //更新 distance
                path[edge.to] = path[edge.from]; //更新路径
                path[edge.to].push_back(edge.from);
                q.push(Node(dis[edge.to], edge.to));
            }
        }
    }

    delete[]visited;
}

//简单实现，时间复杂度 O(EV)
void Dijkstra_Simple(vector<Edge> *graph, vector<double> &dis, vector<int> *path, const int vNum, const int vStart) {

    fill_n(dis.begin(), vNum, POSITIVE_INF);
    dis[vStart] = 0;

    bool *visited = new bool[vNum];
    fill_n(visited, vNum, false);

    for (int k = 0; k < vNum; k++) {
        int minNum = POSITIVE_INF, minIndex = -1;
        for (int i = 0; i < vNum; i++) { //找一个最小的
            if (false == visited[i] && dis[i] < minNum) {
                minNum = dis[i];
                minIndex = i;
            }
        }
        visited[minIndex] = true;
        for (Edge edge : graph[minIndex]) {
            if (visited[edge.to]) continue; //已经访问过的节点则跳过
            if (dis[edge.to] > dis[edge.from] + edge.cost) { //Relax 操作
                dis[edge.to] = dis[edge.from] + edge.cost; //更新 distance
                path[edge.to] = path[edge.from]; //更新路径
                path[edge.to].push_back(edge.from);
            }
        }
    }

    delete[]visited;
}

void PrintPath(vector<int>& path, int self) {
    for (int v : path) {
        cout << v << "->";
    }
    cout << self << endl;
}

int main() {
    int vNum = 5, vStart = 0; // vNum 顶点数量，vStart 起始点编号

    vector<Edge> *graph = new vector<Edge>[vNum]; //邻接表表示的图
    vector<double> dis(vNum, POSITIVE_INF); //最短距离
    vector<int> *path = new vector<int>[vNum]; //存储记录的最短路径

    AddEdge(graph, 0, 1, 6);
    AddEdge(graph, 0, 3, 1);
    AddEdge(graph, 1, 0, 6);
    AddEdge(graph, 1, 2, 5);
    AddEdge(graph, 1, 3, 2);
    AddEdge(graph, 1, 4, 2);
    AddEdge(graph, 2, 1, 5);
    AddEdge(graph, 2, 4, 5);
    AddEdge(graph, 3, 0, 1);
    AddEdge(graph, 3, 1, 2);
    AddEdge(graph, 3, 4, 1);
    AddEdge(graph, 4, 1, 2);
    AddEdge(graph, 4, 2, 5);
    AddEdge(graph, 4, 3, 1);

    // Dijkstra_PQ(graph, dis, path, vNum, vStart);
    Dijkstra_Simple(graph, dis, path, vNum, vStart);

    for (int i = 0; i < vNum; i++) {
        cout << "From " << vStart << " to " << i << " distance: " << setw(5) << left << dis[i];
        PrintPath(path[i], i);
    }

    delete[]graph;
    delete[]path;

    system("pause");

    // From 0 to 0 distance: 0    0
    // From 0 to 1 distance: 3    0->3->1
    // From 0 to 2 distance: 7    0->3->4->2
    // From 0 to 3 distance: 1    0->3
    // From 0 to 4 distance: 2    0->3->4
}

3 Bellman Ford 算法

推荐食用这个 Video 以及这篇 Blog，我这里简单讲一下怎么解决负权值的问题。按照视频里说的，事实上就是将核心代码再跑一遍，如果还能进行松弛操作，那证明这里出现了负权值环了，然后可以不断扩散出去，能松弛的就代表受到负权值环的影响。

关键词：

  • 单源最短路径
  • 解决负权值环问题

缺点：

  • 时间复杂度过高，但可进行优化，即后面会提到的 SPFA 算法

3.1 邻接矩阵实现

效率分析，我们用 V 代表顶点数， E 代表边数

  • 时间复杂度 O ( V 3 ) O(V^3) O(V3)
#include <vector>
#include <iomanip>
#include <iostream>
#include <queue>
#include <limits>

using namespace std;

#define POSITIVE_INF (numeric_limits<int>::max())
#define NEGATIVE_INF (numeric_limits<int>::min())

void BellmanFord(vector<vector<double> > &graph, vector<double> &dis, vector<int>* path ,const int vNum, const int vStart) {

    fill_n(dis.begin(), vNum, POSITIVE_INF);
    dis[vStart] = 0;

    for (int k = 0; k < vNum - 1; k++) { // For each vertex, apply relaxation for all the edges
        for (int i = 0; i < vNum; i++) {
            for (int j = 0; j < vNum; j++) {
                if (graph[i][j] == POSITIVE_INF) continue; // 没有 i 到 j 的边，跳过
                if (dis[j] > dis[i] + graph[i][j]) { // Relax 操作
                    dis[j] = dis[i] + graph[i][j]; // 更新最短距离
                    path[j] = path[i]; // 更新路径
                    path[j].push_back(i);
                }
            }   
        }
    }

    for (int k = 0; k < vNum - 1; k++) { // Run algorithm a second time to detect which nodes are part of a negative cycle.
        for (int i = 0; i < vNum; i++) {
            for (int j = 0; j < vNum; j++) {
                if (graph[i][j] == POSITIVE_INF) continue; // 没有 i 到 j 的边，跳过
                if (dis[j] == NEGATIVE_INF) continue;
                if (dis[j] > dis[i] + graph[i][j]) {
                    dis[j] = NEGATIVE_INF;
                    path[j].clear();
                }
            }
        }
    }
}

void AddEdge(vector<vector<double> > &graph, int from, int to, double cost) {
	graph[from][to] = cost;
}

void PrintPath(vector<int>& path, int self) {
    for (int v : path) {
        cout << v << "->";
    }
    cout << self << endl;
}

void PrintMatrix(vector<vector<double> > &graph) {
    for (auto level : graph) {
        cout << "[";
        for (auto v : level) {
            if (v >= POSITIVE_INF) cout << setw(5) << left << "inf";
            else cout << fixed << setprecision(0) << setw(5) << left << v;
        }
        cout << "]\n";
    }
    cout << endl;
}

int main() {
    int vNum = 9, vStart = 0;
	vector<vector<double> > graph(vNum, vector<double>(vNum, POSITIVE_INF));
    vector<double> dis(vNum, POSITIVE_INF);
    vector<int>* path = new vector<int>[vNum];

    for (int i = 0; i < vNum; i++) AddEdge(graph, i, i, 0);
    AddEdge(graph, 0, 1, 1);
    AddEdge(graph, 1, 2, 1);
    AddEdge(graph, 2, 4, 1);
    AddEdge(graph, 4, 3, -3);
    AddEdge(graph, 3, 2, 1);
    AddEdge(graph, 1, 5, 4);
    AddEdge(graph, 1, 6, 4);
    AddEdge(graph, 5, 6, 5);
    AddEdge(graph, 6, 7, 4);
    AddEdge(graph, 5, 7, 3);

    PrintMatrix(graph);

    BellmanFord(graph, dis, path, vNum, vStart);

    for (int i = 0; i < vNum; i++) {
        cout << "From " << vStart << " to " << i << " distance: ";
        if (dis[i] == POSITIVE_INF) cout << left << setw(6) << "+inf";
        else if (dis[i] == NEGATIVE_INF) cout << left << setw(6) << "-inf";
        else cout << left << setw(6) << dis[i];
        PrintPath(path[i], i);
    }

    delete[]path;
    
    system("pause");
}

3.2 邻接表实现

效率分析，我们用 V 代表顶点数， E 代表边数

  • 时间复杂度 O ( E V ) O(EV) O(EV)
#include <vector>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <limits>

using namespace std;

#define POSITIVE_INF (numeric_limits<int>::max())
#define NEGATIVE_INF (numeric_limits<int>::min())

struct Edge {
    int from;
    int to;
    double cost;
    Edge(int from, int to, double cost) :from(from), to(to), cost(cost) {}
};

void AddEdge(vector<Edge>* graph, int from, int to, double cost) {
    graph[from].push_back(Edge(from, to, cost));
}

void BellmanFord(vector<Edge>* graph, vector<double> &dis, vector<int>* path, const int vNum, const int vStart) {

    fill_n(dis.begin(), vNum, POSITIVE_INF);
    dis[vStart] = 0;

    for (int k = 0; k < vNum - 1; k++) {  // For each vertex, apply relaxation for all the edges
        for (int i = 0; i < vNum; i++) {
            for (Edge edge : graph[i]) {
                if (dis[edge.from] + edge.cost < dis[edge.to]) {
                    dis[edge.to] = dis[edge.from] + edge.cost;
                    path[edge.to] = path[edge.from];
                    path[edge.to].push_back(edge.from);
                }
            }
        }
    }
    for (int k = 0; k < vNum - 1; k++) { // Run algorithm a second time to detect which nodes are part of a negative cycle. 
        for (int i = 0; i < vNum; i++) { 
            for (Edge edge : graph[i]) {
                if (dis[edge.from] + edge.cost < dis[edge.to]) {
                    dis[edge.to] = NEGATIVE_INF;
                    path[edge.to].clear();
                }
            }
        }
    }
}

void PrintPath(vector<int>& path, int self) {
    for (int v : path) {
        cout << v << "->";
    }
    cout << self << endl;
}

void PrintEdge(vector<Edge> *graph, int vNum) {
    for (int i = 0; i < vNum; i++) {
        for (Edge edge : graph[i]) {
            cout << "Edge " << edge.from << " to " << edge.to << " , cost: " << edge.cost << endl;
        }
    }
    cout << endl;
}

int main() {
    int vNum = 9, vStart = 0;
    vector<Edge> *graph = new vector<Edge>[vNum];
    vector<double> dis(vNum, POSITIVE_INF);
    vector<int>* path = new vector<int>[vNum];

    AddEdge(graph, 0, 1, 1);
    AddEdge(graph, 1, 2, 1);
    AddEdge(graph, 2, 4, 1);
    AddEdge(graph, 4, 3, -3);
    AddEdge(graph, 3, 2, 1);
    AddEdge(graph, 1, 5, 4);
    AddEdge(graph, 1, 6, 4);
    AddEdge(graph, 5, 6, 5);
    AddEdge(graph, 6, 7, 4);
    AddEdge(graph, 5, 7, 3);

    PrintEdge(graph, vNum);

    BellmanFord(graph, dis, path, vNum, vStart);

    for (int i = 0; i < vNum; i++) {
        cout << "From " << vStart << " to " << i << " distance: ";
        if (dis[i] == POSITIVE_INF) cout << left << setw(6) << "+inf";
        else if (dis[i] == NEGATIVE_INF) cout << left << setw(6) << "-inf";
        else cout << left << setw(6) << dis[i];
        PrintPath(path[i], i);
    }

    delete[]graph;
    delete[]path;

    system("pause");

    // [0    1    inf  inf  inf  inf  inf  inf  inf  ]
    // [inf  0    1    inf  inf  4    4    inf  inf  ]
    // [inf  inf  0    inf  1    inf  inf  inf  inf  ]
    // [inf  inf  1    0    inf  inf  inf  inf  inf  ]
    // [inf  inf  inf  -3   0    inf  inf  inf  inf  ]
    // [inf  inf  inf  inf  inf  0    5    3    inf  ]
    // [inf  inf  inf  inf  inf  inf  0    4    inf  ]
    // [inf  inf  inf  inf  inf  inf  inf  0    inf  ]
    // [inf  inf  inf  inf  inf  inf  inf  inf  0    ]

    // From 0 to 0 distance: 0     0
    // From 0 to 1 distance: 1     0->1
    // From 0 to 2 distance: -inf  2
    // From 0 to 3 distance: -inf  3
    // From 0 to 4 distance: -inf  4
    // From 0 to 5 distance: 5     0->1->5
    // From 0 to 6 distance: 5     0->1->6
    // From 0 to 7 distance: 8     0->1->5->7
    // From 0 to 8 distance: +inf  8
}

3.3 一些优化方法

优化一：循环的提前跳出

通常 Bellman Ford 算法经常会在未达到 n-1 轮松弛前就已经计算出最短路。因此每一轮执行后，若没有执行松弛操作则算法就可以停止了，则我们可以添加一个标志位 flag，如下所示

for (int k = 0; k < vNum - 1; k++) { // 一共是执行 vNum - 1 轮
        bool flag = false;
        for (int i = 0; i < vNum; i++) {
            for (Edge edge : graph[i]) {
                if (dis[edge.from] + edge.cost < dis[edge.to]) {
                    dis[edge.to] = dis[edge.from] + edge.cost;
                    path[edge.to] = path[edge.from];
                    path[edge.to].push_back(edge.from);
                    flag = true; // 更新了 dis 则标志设 true
                }
            }
        }
        if(!flag) break; // dis 未更新，跳出循环
    }

优化二：SPFA 的算法，即避免冗余的计算

松弛操作必定只会发生在最短路径前导节点松弛成功过的节点上，则用一个队列记录松弛过的节点，可以避免了冗余计算，这即是 SPFA 算法的核心，下一节将介绍 SPFA 的实现

4 SPFA 算法

通过前面我们知道 SPFA 算法是优化后的 Bellman Ford 算法，如何实现？以下引用自百度百科-SPFA算法

动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾

关于 SPFA 算法，我是仿照百度百科里实现的，里面检测到环的时候将会直接中止算法，为了与前面保持一致，我做了一些改进。与前面一样，改进之后能检测出哪些节点会受到负权值环的影响，受到影响的其最后输出的最短距离为 -inf。

注：此代码可能有误，请大家小心参考

#include <vector>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <limits>
#include <queue>

using namespace std;

#define POSITIVE_INF (numeric_limits<int>::max())
#define NEGATIVE_INF (numeric_limits<int>::min())

struct Edge {
    int from;
    int to;
    double cost;
    Edge(int from, int to, double cost) :from(from), to(to), cost(cost) {}
};

void AddEdge(vector<Edge>* graph, int from, int to, double cost) {
	graph[from].push_back(Edge(from, to, cost));
}

void SPFA(vector<Edge>* graph, vector<double> &dis, vector<int>* path, const int vNum, const int vStart) {

    fill_n(dis.begin(), vNum, POSITIVE_INF);
    dis[vStart] = 0;

    queue<int> q;
    q.push(vStart);

    vector<bool> inQueue(vNum, false); //记录某顶点是否在队列中
    inQueue[vStart] = true;

    vector<int> cnt(vNum, 0); //记录某顶点进入队列的次数
    cnt[vStart] = 1;
    
    while (!q.empty()) {
        int v = q.front(); q.pop();
        inQueue[v] = false;
        for (Edge edge : graph[v]) {
            if (dis[edge.to] == NEGATIVE_INF) continue; //已经被负权环路感染
            if (dis[edge.from] == NEGATIVE_INF) { //将要被负权环路感染
                dis[edge.to] = NEGATIVE_INF;
                path[edge.to].clear();
                if(!inQueue[edge.to]) {
                    q.push(edge.to);
                    inQueue[edge.to] = true;
                }
                continue;
            }
            if (dis[edge.to] > dis[edge.from] + edge.cost) { //松弛
                dis[edge.to] = dis[edge.from] + edge.cost;
                path[edge.to] = path[edge.from];
                path[edge.to].push_back(edge.from);
                if (!inQueue[edge.to]) {
                    cnt[edge.to]++;
                    if (cnt[edge.to] == vNum) { //出现负权值
                        dis[edge.to] = NEGATIVE_INF;
                        path[edge.to].clear();
                    }
                    q.push(edge.to);
                    inQueue[edge.to] = true;
                }
            }
        }
    }
}

void PrintPath(vector<int>& path, int self) {
    for (int v : path) {
        cout << v << "->";
    }
    cout << self << endl;
}

void PrintEdge(vector<Edge> *graph, int vNum) {
    for (int i = 0; i < vNum; i++) {
        for (Edge edge : graph[i]) {
            cout << "Edge " << edge.from << " to " << edge.to << " , cost: " << edge.cost << endl;
        }
    }
    cout << endl;
}

int main() {
	int vNum = 9, vStart = 0;
	vector<Edge> *graph = new vector<Edge>[vNum];
    vector<double> dis(vNum, POSITIVE_INF);
    vector<int>* path = new vector<int>[vNum];

    AddEdge(graph, 0, 1, 1);
    AddEdge(graph, 1, 2, 1);
    AddEdge(graph, 2, 4, 1);
    AddEdge(graph, 4, 3, -3);
    AddEdge(graph, 3, 2, 1);
    AddEdge(graph, 1, 5, 4);
    AddEdge(graph, 1, 6, 4);
    AddEdge(graph, 5, 6, 5);
    AddEdge(graph, 6, 7, 4);
    AddEdge(graph, 5, 7, 3);

    PrintEdge(graph, vNum);

    SPFA(graph, dis, path, vNum, vStart);

    for (int i = 0; i < vNum; i++) {
        cout << "From " << vStart << " to " << i << " distance: ";
        if (dis[i] == POSITIVE_INF) cout << left << setw(6) << "+inf";
        else if (dis[i] == NEGATIVE_INF) cout << left << setw(6) << "-inf";
        else cout << left << setw(6) << dis[i];
        PrintPath(path[i], i);
    }

    delete[]graph;
    delete[]path;

    system("pause");
}

5 Floyd-Warshall 算法

先推荐 Video，这是本文实现的最后一个算法，这也是大家一般学习到的多源最短路径算法，需要注意的是

  • dis 数组上升到了二维（毕竟是多源最短路径）
  • 保存路径的不再是 pre 数组，而是 next 数组，看完视频后好好想想他们之间的区别

5.1 邻接矩阵实现

#include <vector>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <limits>

using namespace std;

#define POSITIVE_INF (numeric_limits<int>::max())
#define NEGATIVE_INF (numeric_limits<int>::min())
#define DOES_NOT_EXIST -1
#define REACHES_NEGATIVE_CYCLE -2

void AddEdge(vector<vector<double> > &graph, int from, int to, double cost) {
	graph[from][to] = cost;
}

void Floyd(vector<vector<double> > &graph, vector<vector<double> > &dis, vector<vector<int> > &next, const int vNum) {

    dis = graph; //赋值操作，不是 java 里的指向对象哈
    
    for (int i = 0; i < vNum; i++) { //pre 数组初始化
        for (int j = 0; j < vNum; j++) {
            if (graph[i][j] != POSITIVE_INF) next[i][j] = j;
        }
    }

    for (int k = 0; k < vNum; k++) {
        for (int i = 0; i < vNum; i++) {
            for (int j = 0; j < vNum; j++) {
                if (dis[i][k] == POSITIVE_INF || dis[k][j] == POSITIVE_INF) continue;
                if (dis[i][j] > dis[i][k] + dis[k][j]) {
                    dis[i][j] = dis[i][k] + dis[k][j];
                    next[i][j] = next[i][k];
                }
            }
        }
    }

    // Identify negative cycles by propagating the value 'NEGATIVE_INFINITY'
    // to every edge that is part of or reaches into a negative cycle.
    for (int k = 0; k < vNum; k++) {
        for (int i = 0; i < vNum; i++) {
            for (int j = 0; j < vNum; j++) {
                if (dis[i][k] == POSITIVE_INF || dis[k][j] == POSITIVE_INF) continue;
                if (dis[i][j] == NEGATIVE_INF) continue;
                if (dis[i][j] > dis[i][k] + dis[k][j]) {
                    dis[i][j] = NEGATIVE_INF;
                    next[i][j] = REACHES_NEGATIVE_CYCLE;
                }
            }
        }
    }
}

template<typename T>
void PrintMatrix(vector<vector<T> > &graph) {
    for (auto level : graph) {
        cout << "[";
        for (auto v : level) {
            if (v >= POSITIVE_INF) cout << setw(5) << left << "+inf";
            else if ( v <= NEGATIVE_INF) cout << setw(5) << left << "-inf";
            else cout << fixed << setprecision(0) << setw(5) << left << v;
        }
        cout << "]\n";
    }
    cout << endl;
}

int main() {
    int vNum = 7;
    vector<vector<double> > graph(vNum, vector<double>(vNum, POSITIVE_INF)); //图中所有值初始化为 POSITIVE_INF 即两点不联通
    vector<vector<double> > dis(vNum, vector<double>(vNum, POSITIVE_INF)); //dis[i][j] 记录当前 i 到 j 的最短距离，是动态规划中的 dp 数组
    vector<vector<int> > next(vNum, vector<int>(vNum, DOES_NOT_EXIST)); //保存 i 到 j 当前最短路径的下一个节点

    //设置图
    for (int i = 0; i < vNum; i++) graph[i][i] = 0;
    AddEdge(graph, 0, 1, 2);
    AddEdge(graph, 0, 2, 5);
    AddEdge(graph, 0, 6, 10);
    AddEdge(graph, 1, 2, 2);
    AddEdge(graph, 1, 4, 11);
    AddEdge(graph, 2, 6, 2);
    AddEdge(graph, 6, 5, 11);
    AddEdge(graph, 4, 5, 1);
    AddEdge(graph, 5, 4, -2);

    PrintMatrix(graph);

    Floyd(graph, dis, next, vNum);
    
    PrintMatrix(dis);
    PrintMatrix(next);

    system("pause");
}

6 最后我想说的

我的实现并不是标准，仅供大家参考，如果你有更好的实现也欢迎在评论区留言。如果有误请立即联系我，感谢。

然后，本文只列举了 4 种算法，还有其他的并未提及，所以可能还会有续篇~

7 参考资料

[1] 百度百科/Bellman-Ford算法 https://baike.baidu.com/item/Bellman-Ford算法

[2] Bellman-Ford算法（解决负权边）https://blog.csdn.net/wtyvhreal/article/details/43450727

[3] SPFA算法 https://baike.baidu.com/item/SPFA%E7%AE%97%E6%B3%95

[4] Github/williamfiset https://github.com/williamfiset/Algorithms

[5] 最短路径搜索之A*算法 https://blog.csdn.net/yuxuan20062007/article/details/80914210

J1JJOSH
关注
专栏目录
用java写一个最短路径算法
weixin_42612405的博客
02-09 626
您可以使用 Dijkstra 算法来解决最短路径问题。该算法基于贪心策略，通过不断地选择未确定的最短路径节点来实现。在 Java 中，您可以使用优先队列来维护未确定的节点，从而确定最短路径。 以下是 Java 代码的简单实现： ``` import java.util.*; class Dijkstra { private int dist[]; private Set settl...
最短路径的最优化算法
04-24
在已存在的一些最短路径算法测试总结的基础上, 根据GIS 中网络计算的实际情况, 从网络结构的拓扑表示以及D ijk st ra 算法中快速搜索技术的实现入手, 提出了一种D ijk st ra 最短路径算法的高效率实现方法
顶点间最短路径长度之探寻算法
weixin_33817333的博客
06-10 165
1.最短路径概念 在一个无权的图中，若从一顶点到另一顶点存在着一条路径，则称该路径长度为该路径上所经过的边的数目，它等于该路径上的顶点数减1。由于从一顶点到另一顶点可能存在着多条路径，每条路径上所经过的边数可能不同，即路径长度不同，我们把路径长度最短（即经过的边数最少）的那条路径叫做最短路径，其路径长度叫做最短路径长度或最短距离。 对于带权...
最短路径算法(算法篇)
最新发布
hellmorning的博客
07-09 1160
本篇讲述图论算法中的最短路径算法，有bfs,floyd和dijkstra算法
dijkstra求最短路（堆优化）
falldeep的算法世界
07-16 214
题目 给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为非负值。 请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出−1。 输入格式 第一行包含整数n和m。 接下来m行每行包含三个整数x,y,z，表示存在一条从点x到点y的有向边，边长为z。 输出格式 输出一个整数，表示1号点到n号点的最短距离。 如果路径不存在，则输出−1。 数据范围 1≤n,m≤1.5×105 图中涉及边长均不小于0，且不超过...
求一条从顶点i到顶点s的简单路径_最短路径问题：Dijkstra算法
weixin_39719165的博客
12-06 652
定义所谓最短路径问题是指：如果从图中某一顶点(源点)到达另一顶点(终点)的路径可能不止一条，如何找到一条路径使得沿此路径上各边的权值总和(称为路径长度)达到最小。下面我们介绍两种比较常用的求最短路径算法：Dijkstra(迪杰斯特拉)算法他的算法思想是按路径长度递增的次序一步一步并入来求取，是贪心算法的一个应用，用来解决单源点到其余顶点的最短路径问题。算法思想首先，我们引入一个辅助向量D，它的每个...
数据结构例程——从一个顶点到其余各顶点的最短路径
weixin_33997389的博客
11-07 1018
本文是[数据结构基础系列(7)：图]中第13课时[从一个顶点到其余各顶点的最短路径]的例程。 （程序中graph.h是图存储结构的“算法库”中的头文件，详情请单击链接…） #include <stdio.h> #include <malloc.h> #include "graph.h" #define M...
Python Dijkstra Algorithm 迪杰斯特拉算法 最短路径算法示例代码
08-10
# Python Dijkstra Algorithm 迪杰斯特拉算法 最短路径算法示例代码 本项目是基于Python的Dijkstra算法示例程序。该程序使用Python实现Dijkstra算法，计算给定图中从一个起始节点到其他节点的最短路径。 示例图的...
（来点有用的）含障碍的两点最短路径算法完整代码
07-29
"含障碍的两点最短路径算法"是一种解决特定空间规划问题的方法，它适用于那些包含静态障碍物的环境，比如寻路问题或者游戏中的角色移动路径规划。在标题和描述中提到的，这个算法并不涉及图论中的节点或经典最短路径...
前k条最短路径算法实例
03-19
前k条最短路径算法（Top-k Shortest Path Algorithm）旨在找出图中源节点到目标节点的k条最短路径，而不仅仅是一条。这种算法相对于经典的Dijkstra算法或Floyd-Warshall算法更进一步，提供了更多的解决方案选择，有...
android 各种最短路径算法
04-01
在Android开发中，最短路径算法是解决网络、图论问题的一种重要技术，广泛应用于地图导航、社交网络分析、任务调度等领域。以下是对几种常见最短路径算法的详细讲解： 1. **迪杰斯特拉算法 (Dijkstra's Algorithm)*...
求最短路径的两种算法（C语言实现）
03-24
NULL 博文链接：https://touch-2011.iteye.com/blog/1076031
Dijstra 单源最短路径算法 堆优化-1（二维数组存储数据）
72 73 76 89 82 84 89 81
04-17 944
#include"iostream" #include"cstdio" #include"cstdlib" using namespace std; int map[100][100]; int dis[100]; int n,m; int heap[100]; int sum; int minpoint; int inf=99999999; int x,y,
最短路径算法Dijstra及优化
qq_55729911的博客
04-15 4481
1.算法简介 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 2.算法流程 迪杰斯塔拉的思想比较容易理解，是采用的纯粹的贪心，但一般我们不需要证明贪心。有兴趣的可以看看这篇文章，里面提到了贪心，这里不再细说。这里我们采用邻接矩阵进行图存储。 注：图片
图的最短路径算法
Fatestay_DC的专栏
12-02 650
1、问题描述 给定一个顶点（始点），求该顶点（始点）到（连通）图中其它顶点的最短路径。   2、算法 ⑴、初始化： S ← {v1 };                               // 始点送S D[i] ← arc[1][i],   i = 2, 3, …, n;               // 从v1到vi的距离 P[i] = {1,i}           
最短路径第二尺度求解优化算法（Dijkstra+DSF)
小魚兒
11-02 364
#include <cstdio> #include <cstring> #include <algorithm> #include <vector> using namespace std; const int maxv=520; const int INF=1000000000; //利用pre数组先求出每个点的点权或边权之和的模板。可直...
学习笔记——图最短路相关算法——弗洛伊德算法(WFI)
banxikuan1546的博客
10-31 195
蒟蒻写文，难免疏忽，欢迎指正！ 什么是弗洛伊德算法？ 弗洛伊德算法(Floyd Algorithm)，又称Floyd-Warshall算法。弗洛伊德算法是一种动态规划的算法，通过松弛记录图的邻接矩阵中的各个边，达到计算任何点之间的最短路的目的。 弗洛伊德算法的原理 输入： 对于任意一个没有负周期的加权图，考虑采用邻接矩阵的形式存储图。 对于邻接矩阵map...
最短路径的四种算法
热门推荐
我の名字
07-30 1万+
最短路径四种算法 1 2 3 4 Floyd Dijkstra Bellman-Ford 队列优化的Bellman-Ford 一，只有四行的算法——Floyd-Warshall 假设求顶点ViViVi到VjVjVj的最短路径。弗洛伊德算法依次找从ViViVi到VjVjVj，中间经过结点序号不大于000的最短路径，不大于111的最短路径，…直到中间顶点序号不大于n−1n-1n−1...
使用Matlab实现Dijkstra最短路径算法教程
资源摘要信息:"迪杰特斯拉最短路径算法（Dijkstra's algorithm）是一种用于在加权图中找到最短路径的算法，由荷兰计算机科学家艾兹赫尔·迪杰斯特拉（Edsger W. Dijkstra）于1956年提出。此算法适用于有向图和无向图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值