最短路常用算法

已于 2022-05-29 16:18:59 修改
阅读量191 收藏 4
点赞数 1
分类专栏： 图论 文章标签： 算法 图论 数据结构
于 2022-05-28 16:35:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57193124/article/details/125015724
版权
最短路的专有名词：

源点： 表示起点
汇点： 表示终点
稀疏图： 点数和边数在同一个量级
稠密图： 边数和点数的平方在同一个量级

注意：

求最短路的要求的是该图不能含有负环， 如果图中有负环， 那么我们可以一直在这个负环中走无穷多次， 那么我们的最短路的值就会变成负无穷。

单源最短路和多源最短路有什么区别？

单源最短路： 求的是固定的一个起点， 到它所有能到的点之间的距离。
多源最短路： 求的是起点不固定， 即任意两个点之间的距离
请添加图片描述

普素版dijkstra

思路：

请添加图片描述

模版：
int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < n - 1; i ++ )
    {
        int t = -1;     // 在还未确定最短路的点中，寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);

        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

作者：yxc
链接：https://www.acwing.com/blog/content/405/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
题目1： Dijkstra求最短路 I
分析：

1. 为什么g数组要进行初始化成正无穷？

因为这里是使用领接表进行存储的，两个点之间只能存储一个数字， 题目中说明了这道题是有重边的， 所以我们保留的较小的那一条，
如果两个点之间是正无穷说明了两个点之间不可达。

2. 判断终点(n号点) 能否到达起点(1号点)， 是判断dist[n] == 0x3f3f3f3f, 还是 dist[n] > 0x3f3f3f3f / 2

用哪个方式进行判断主要和两个方面有关： 1. 图是用什么方式进行存储？ 2. 是否有负权边？

根据不同的算法， 图也可以使用不同的存储方式进行存储？ 可以使用领接表， 邻接矩阵进行存储。在bellman_ford算法中还可以使用结构体存下两条边之间的关系 。

若用邻接矩阵进行存储，：

//更新方式： 
 for(int j = 1; j <= n; j ++)
        {
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        }

如果有负权边，那么我们应该使用dist[n] > 0x3f3f3f3f / 2进行判断1号点和n号点是否连通。
但是因为dijkstra算法要求是没有负权边的， 所以如果n号点和1号点是不联通的， 则dist[n]不会变小， 则dist[n]还是保留初始化 0x3f3f3f3f 。

若用邻接表进行存储： 只会更新它能够到达的点， 如果1号点到达不了n好点， 则n号点的距离仍然依旧是初始化时的0x3f3f3f3f。

若用结构体进行存储： 只要两条边之间能到达就会被更新， 所以如果权值为负数可能会造成dist[n] < 0x3f3f3f3f, 但是n号点和一号点依旧不可到达， 所以要使用dist[n] > 0x3f3f3f3f / 2来判断进行判断1号点和n号点是否连通。

时间复杂度： O ( n 2 ) O(n ^ 2) O(n2)
代码区：
#include<iostream>
#include<cstring>

using namespace std;

const int N = 510;

int n, m;
int g[N][N];
bool st[N];
int dist[N];

void dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    for(int i = 0; i < n; i ++)
    {
        int t = -1;
        for(int j = 1; j <= n; j ++)
        {
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
            {
                t = j;
            }
        }
        st[t] = true;
        
        for(int j = 1; j <= n; j ++)
        {
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        }
    }
    
}

int main()
{
    cin >> n >> m;
    
    memset(g, 0x3f, sizeof g);
    while(m --)
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c);
    }
    
    dijkstra();
    
    if(dist[n] == 0x3f3f3f3f) cout << -1;
    else cout << dist[n];
    
    
    return 0;
}

堆优化版的dijkstra

思路：

请添加图片描述

请添加图片描述

时间复杂度：O(mlogn), n 表示点数，m 表示边数
模版：
typedef pair<int, int> PII;

int n;      // 点的数量
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});      // first存储距离，second存储节点编号

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

作者：yxc
链接：https://www.acwing.com/blog/content/405/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
题目1： Dijkstra求最短路 II
分析：
时间复杂度：
代码区：
#include<iostream>
#include<cstring>
#include<queue>

#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;

const int N = 1.5e5 + 10;

int n, m;
int h[N], e[N], ne[N], w[N], idx;
bool st[N];
int dist[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
    
}

void dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});
    
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        int ver = t.y, distance = t.x;
        if(st[ver]) continue;
        st[ver] = true;
        
        for(int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
        
    }
    
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while(m --)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    dijkstra();
    
    if(dist[n] == 0x3f3f3f3f) cout << -1;
    else cout << dist[n];
    
    
    return 0;
}

bellman_ford算法

思路：

两重循环：

  1. 循环所有的点
  2. 循环所有的边

请添加图片描述

时间复杂度： O ( n ∗ m ) O(n * m) O(n∗m)
模版：
int n, m;       // n表示点数，m表示边数
int dist[N];        // dist[x]存储1到x的最短路距离

struct Edge     // 边，a表示出点，b表示入点，w表示边的权重
{
    int a, b, w;
}edges[M];

// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
    for (int i = 0; i < n; i ++ )
    {
        for (int j = 0; j < m; j ++ )
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            if (dist[b] > dist[a] + w)
                dist[b] = dist[a] + w;
        }
    }

    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
}

作者：yxc
链接：https://www.acwing.com/blog/content/405/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
题目1： 有边数限制的最短路
分析：

如果只是用来求有负权边的情况下， 起点到终点的最短距离， 那么我们是会用spfa, 而不是用bellman_ford，因为时间复杂度上spfa最坏是O(n * m), 而bellman_ford就是O(n * m)。但是bellman_ford可以用来求解一类问题：有边数限制的最短路。 注意的是这种做法的话我们需要开一个备份数组。

时间复杂度： O ( n ∗ m ) O(n * m) O(n∗m)
代码区：
#include<iostream>
#include<cstring>

using namespace std;

const int N = 510, M = 10010;

int n, m, k;
struct Edge
{
    int a, b, c;
}edges[M];
int dist[N], backup[N];

void bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    for(int i = 0; i < k; i ++)
    {
        memcpy(backup, dist, sizeof dist);
        for(int j = 0; j < m; j ++)
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].c;
            dist[b] = min(dist[b], backup[a] + w);
        }
    }
    
}

int main()
{
    cin >> n >> m >> k;
    
    for(int i = 0; i < m; i ++)
    {
        int a, b ,c;
        cin >> a >> b >> c;
        edges[i] = {a, b, c};
    }
    
    bellman_ford();
    
    if(dist[n] > 0x3f3f3f3f / 2) puts("impossible");
    else cout << dist[n];
    
    return 0;
}

spfa

思路：

请添加图片描述

时间复杂度： 平均情况下 O(m)，最坏情况下 O(nm), n 表示点数，m 表示边数
模版：
int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

作者：yxc
链接：https://www.acwing.com/blog/content/405/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
题目1：spfa求最短路
分析：
时间复杂度：
代码区：
#include<iostream>
#include<cstring>

using namespace std;

const int N = 1e5 + 10;

int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N];
int q[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

void spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    st[1] = 0;
    int hh = 0, tt = 0;
    q[0] = 1;
    
    while(hh <= tt)
    {
        int t = q[hh ++];
        st[t] = false;
        
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if(!st[j])
                {
                    q[++ tt] = j;
                    st[j] = true;
                }
            }
        }
    }
    
    
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    
    while(m --)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    spfa();
    if(dist[n] == 0x3f3f3f3f) puts("impossible");
    else cout << dist[n];
    
    
    return 0;
}

判断负环：

spfa 和 bellman_ford 都可以用来判断负环， 和时间复杂度有关， 我们一般使用spfa进行判断负环。

时间复杂度： O ( n ∗ m ) O(n * m) O(n∗m)
模版：
int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N];     // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。

    queue<int> q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

作者：yxc
链接：https://www.acwing.com/blog/content/405/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
题目1： spfa判断负环
分析：
时间复杂度： O ( n ∗ m ) O(n * m) O(n∗m)
代码区：
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;

const int N = 2010, M = 10010;

int h[N], ne[M], e[M], idx, w[M];
int dist[N];
bool st[N];
int cnt[N];
int n, m;

void add(int a, int b, int c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx ++;
}

bool spfa()
{
   queue<int> q;
    
    for(int i = 1; i <= n; i ++)
    {
        q.push(i);
        st[i] = true;
    }
    
    while(q.size())
    {
        auto t = q.front();
        q.pop();
        st[t] = false;
        
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if(cnt[j] >= n) return true;
                if(!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return false;
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    
    while(m --)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    if(spfa()) puts("Yes");
    else puts("No");
    
    return 0;
}

floyd

floyd可以求出任意两点的最短距离，缺点是时间复杂度较高
题目1：floyd求最短路
时间复杂度： O ( n 3 ) O(n^3) O(n3)
代码区：
#include<iostream>
#include<cstring>

using namespace std;

const int N = 210;

int n, m, k;
int d[N][N];

void floyd()
{
    for(int k = 1; k <= n; k ++)
    {
        for(int i = 1; i <= n; i ++)
        {
            for(int j = 1; j <= n; j ++)
            d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
        }
    }
    
    
}

int main()
{
    cin >> n >> m >> k;
    
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= n; j ++)
        {
            if(i == j) d[i][j] = 0;
            else d[i][j] = 0x3f3f3f3f;
        }
    }
    
    while(m --)
    {
        int a, b, c;
        cin >> a >> b >>c;
        d[a][b] = min(d[a][b], c);
    }
    
    floyd();
    
    while(k --)
    {
        int a, b;
        cin >> a >> b;
        if(d[a][b] > 0x3f3f3f3f / 2) puts("impossible");
        else cout << d[a][b] << endl;
    }
    
    
    return 0;
}
串C
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
整合：求最短路算法 floyd prim dijkstra Kruskal spfa算法简析
GrEedWish_X的专栏
07-30 2209
(转载） 一、floyd算法（快速计算i到j的最短距离，复杂度高[n^3]） 1.定义概览 Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。   2.算法描
边权为1的最短路问题
我爱编程
06-05 547
最短路-边权为1 题目 给你一棵以1为根的树，求树的深度给你一副无向图，不保证连通，求图上两点间的最短路，每条边的长度都是1 代码 #include <iostream> #include <cstdio> #include <cstring> #include <queue> using namespace std; int n, m, s, t; struct P { int x, y; }; bool vis[10010]; bool
c语言最短路径弗洛伊德算法,C语言求所有顶点对之间的最短路径：FLOYD算法
weixin_34621896的博客
05-19 317
——所有顶点对之间的最短路径：Floyd算法——(160为无穷远，不可达)1到2的最短距离为10输出路径：1——>2****************************************************1到3的最短距离为50输出路径：1——>4——>3****************************************************1到4的...
算法基础---搜索与图论
qq_67458830的博客
03-19 367
本篇主要是讲解关于图论知识的基础算法。
各种最短路算法
weixin_53744560的博客
02-27 961
注意：我自己都不知道自己在说啥哈哈哈哈 前言 最短路算法一般运用图论问题当中。 常见有 Floyd-warshall,Dijkstra,Bellman-ford,SPFA,BFS,DFS算法 一、Floyd 算法 def floyd(): # 时间复杂度为O（n^3） for k in range(n): for i in range(n): for j in range(n): dp[i][j] = min(dp
最短路算法
qq_41967623的博客
02-06 444
图论：最短路径算法 最短路： 最短路主要分为，单源最短路 和 多源汇最短路。 在单源最短路中要区分是否含有负权边，如果图中不含负权边使用主要算法有 dijkstra 算法，而含负权边则使用 bellman-ford 算法 或 spfa 算法。 在多源汇最短路中主要有 floyd 算法。 单源最短路：不含负权边、 朴素 dijkstra 算法 算法流程：假设存在 n 个点，m 条边，求 s 点到任意一点的最短距离 定义一个数组 dist，dist[i] 表示从 s 点到点 i 的距离。 初始化 dist，
最短路径算法
justlovetao的专栏
08-12 901
球最短路径的经典算法是----迪杰斯特拉算法。 迪杰斯特拉算法的实现过程和普里姆求最小生成树的算法很相似。主要是先理解算法的实现过程在利用模板处理各个题目的不同要求，达到以不变应万变的效果。   下面给出算法的理论实现：   其基本思想是，设置顶点集合S并不断地作贪心选
图论最短路dijkstra算法.doc
05-06
图论最短路 Dijkstra 算法 图论最短路 Dijkstra 算法是计算图论中从一个节点到另一个节点的最短路径的经典算法。该算法于 1959 年由荷兰数学家 Edsger W. Dijkstra 首次提出，是一种常用的图论算法。 算法描述 ...
daima.rar_dijkstra_dijkstra算法_最短路 CSharp
09-20
C#作为一种常用的编程语言，可以很好地实现这一算法。 **C#语言基础** C#是微软开发的一种面向对象的编程语言，具有丰富的类库和强大的功能，尤其适用于Windows平台上的应用程序开发。C#支持多种数据类型、控制...
最短路问题迪杰斯特拉算法PPT课件.pptx
10-12
迪杰斯特拉算法是解决最短路问题的一种常用方法。该算法以埃德斯格·迪杰斯特拉命名，是一种常用的图算法，用于计算从图中的某个节点到其他所有节点的最短路径。 问题的提法及应用背景： 在图论中，寻找两个点之间...
最短路和次短路.zip
05-14
1. **Dijkstra算法**：这是最常用的单源最短路径算法，适用于非负权重的图。Dijkstra算法通过维护一个优先队列（如二叉堆）来逐步扩展最短路径树，直到到达目标节点。每次从队列中取出距离源节点最近的节点，并更新...
c++实现的图论中的最短路算法
05-13
本程序是使用c++编写的最短路算法，需要输入的是一个graph的阶数以及赋权矩阵
最短路算法详解
qq_59539549的博客
06-25 2563
图的最短路算法
双端队列BFS实现01最短路
kaka03200的博客
06-01 1769
什么是01最短路 顾名思义，边权只有0和1的最短路。 算法分析 01最短路是最短路类型中比较特殊的一种，当然你也可以用一般的最短路解法（Dijkstra或spfa） 但总所周知利用bfs队列维护，时间复杂度往往只需要o(N)。那该如何实现呢？如果当前处理的点连接的边为0，那么将这个点移至队首，否则移入队尾，这样就可以保证队列的单调性。 算法正确性 当我们更新到的点边权为0时，那么这个点一定是到当前为止的最短路，所以可以直接将改点移至队首，如果这个点边权为1，那么这个点可能并不是到当前为止最短的，因此我们要将
最短路径问题 （最短距离以及花费）
自渡的博客
08-14 2774
给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。 Input 输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点。n和m为0时输入结束。  (1&lt;n&lt;=1000, 0&lt;m&...
最短路算法总结（超详细~）
热门推荐
wmy0217_的博客
04-11 3万+
文章目录最短路算法框架朴素Dijkstra算法堆优化版Dijkstra算法 最短路算法框架 最短路有五种算法，分别适用不同的情况。 单源最短路： 求一个点到其他点的最短路 多源最短路： 求任意两个点的最短路 稠密图用邻接矩阵存，稀疏图用邻接表存储。 稠密图： m 和 n2 一个级别 稀疏图： m 和 n 一个级别 朴素Dijkstra算法 Dijkstra算法是通过 n 次循环来确定 n 个点...
1488. 最短距离（单源点最短路问题）
唯爱你不弃∞
06-06 638
有 N 个村庄，编号 1 到 N。 村庄之间有 M 条无向道路，第 i 条道路连接村庄 ai 和村庄 bi，长度是 ci。 所有村庄都是连通的。 共有 K 个村庄有商店，第 j 个有商店的村庄编号是 xj。 然后给出 Q 个询问，第 k 个询问给出一个村庄的编号 yk，问该村庄距离最近的商店有多远？ 输入格式 第一行包含两个整数 N,M。 接下来 M 行，每行包含三个整数 ai,bi,ci，表示第 i 条道路连接村庄 ai 和村庄 bi，长度是 ci。 再一行包含整数 K。 接下来 K 行，每行包含一个整数
两种最短路径（测地距离）的算法——Dijkstra和Floyd
zod的博客
05-19 2万+
     从某顶点出发，沿图的边到达另一顶点所经过的路径中，各边上权值之和最小的一条路径叫做最短路径。解决最短路的问题有以下算法，Dijkstra算法，Bellman-Ford算法，Floyd算法和SPFA算法等。 最短路径问题是图论研究中的一个经典算法问题，旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。算法具体的形式包括： （1）确定起点的最短路径问题- 即已知起始结点，求最短路径...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
最新发布
weixin_65180740的博客
07-24 937
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
matlab最短路算法
08-28
常用的最短路算法有Dijkstra算法、Floyd-Warshall算法和Bellman-Ford算法。 Dijkstra算法通过计算从一个起始顶点到所有其他顶点的最短路径，来解决最短路问题。它按照距离起始顶点的距离递增的顺序，依次更新顶点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值