图论--最短路问题总结

最新推荐文章于 2024-03-10 16:06:32 发布
最新推荐文章于 2024-03-10 16:06:32 发布
阅读量827 收藏 1
点赞数 1
文章标签： 算法 图论 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Boring_Firecar/article/details/116533072
版权

图论–最短路问题

1.png

其中求最短路常用的算法有上面几种， 根据题目给出的相关限制条件来选选择对应的算法，例如Dijkstra算法是不能处理负边权的情况，朴素版本Dijkstra和堆优化版本的Dijkstra，并不是朴素版就比优化版差，当图为稠密图时偏向于使用朴素版本的，因为当 m > n 2 n^2 n2 时，此时堆优化版本相比朴素版本时间复杂度高。计算存在负边权时的两种算法，spfa是对bellman—ford算法的改进，但bellman-ford代码实现比较简单。对于多源汇合最短路，这里只有一个Floyd算法，其算法原理基于dp。下面具体讲解一下上面的算法，及其代码实现.

Dijkstra算法

Dijkstra算法用于单源最短路问题，且用于的情况是边权值都是正数的情况下，常见的问题为从1号节点到n号节点的最短距离， Dijkstra算法又分为朴素Dijkstra算法和堆优化版的Dijkstra算法 。

Dijkstra算法大致思路：主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止.故首先从未遍历的点中找出一个距离起点最近的一个点， 然后比较从目前遍历的点到其下个点的距离 + 自身到起点的距离 与 下一个点目前到起点的距离决定是否更新, 由于其每次是从当前距离起点最近的点到其连接下一个点的距离来判断是否进行距离的更新，因为每次拿来更新的点都是先找出当前未遍历的点中距离起点最近的那个点，故用这个点更新其连接的下一个点到起点的距离，若满足更新条件那么被更新的点是目前遍历情况下该点的距离起点一定是最小的，故当遍历完所有的点后，即可以在d[n]得到正确的答案， 具体见下图. 其中d[] 数组表示: d[x]： 从1 ~ x 的最小距离
1.png

1.朴素Dijkstra算法实现 时间复杂度 O( n 2 n^2 n2)

练习的链接 : Dijkstra求最短路 I

#include<iostream>
#include<cstring>
using namespace std;

constexpr int N = 510;
constexpr int INF = 0x3f3f3f3f;

int n, m, g[N][N], d[N];    // 通过题目信息判断, 此时 n 最多为500, 而m最多为10^5.属于稠密图, 故这里用邻接矩阵存储比较好。
bool st[N];   // 保存某个节点是否被遍历过

auto dijkstra()
{
    d[1] = 0;           // 更新第一个点到起点的距离为0
    
    for(int i = 1; i <= n; ++i)       // 遍历所有节点    
    {
        int t = -1;
        for(int j = 1; j <= n; ++j)     // 找出目前剩余未被遍历节点中距离起点最小的节点
            if(!st[j] && (t == -1 || d[t] > d[j])) t = j;
        
        st[t] = true;            // 将该节点更新为已遍历状态
         
        for(int k = 1; k <= n; ++k)     // 更新距离 
            d[k] = min(d[k], d[t] + g[t][k]);
    }
    
    // 时间复杂度分析， 首先上面的大for循环为n , 然后里面看成2n, 故时间复杂度就是n2
    
    if(d[n] == INF) cout << -1 << endl;   // 若d[n] 未被更新则说明不存在到n号节点的路径
    else cout << d[n] << endl;
}

auto main() -> int
{
    memset(g, 0x3f, sizeof g);    // g邻接矩阵保存的信息为两条边之间的距离，初始化为一个很大的数
    memset(d, 0x3f, sizeof d);    // 同样初始化每个节点到起点1号节点的距离为一个很大的数
    cin >> n >> m;
    
    while(m--)      // 执行m次操作
    {
        int a, b, c; cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c);      // 此时如果有多条重边，只保留一条最短距离的边
    }
    
    dijkstra();
    
    return 0;
}

2.堆优化的Dijkstra算法实现 O( m l o g n mlogn mlogn)

优化的思路，首先我们从上面的朴素做法可以看出，我们在找其中未被遍历且距离起点最短的点时间复杂度我们看为On, 故这里可以进行优化，使用小顶堆来保持，故此时找出距离最小的点的时间复杂度为O(1);然后对这个点的每一条边进行遍历，然后判断是否更新，若需要更新，则插入，堆的数据结构插入的时间复杂度为O( l o g n logn logn); 故整个过程最坏的复杂度就是 m l o g n mlogn mlogn; 但我们这里实现一般都是使用C++里的优先队列，故每次插入一个数而不是修改某个数，故造成堆里面最坏有m个数字，故最坏的时间复杂度为 m l o g m mlogm mlogm

练习链接: Dijkstra求最短路 II

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
using T = pair<int,int>;

constexpr int N = 1e+6, INF = 0x3f3f3f3f;
int n, m, e[N],w[N], ne[N], d[N], g[N], idx;    // n, m 都是 $10^5$级别的, 故这里看作稀疏图，采用邻接表来存储整个图
bool st[N];

auto add(int a, int b, int c)   // 邻接表来存储图需要进行插入操作，这里用w数组保存每一条边的权值
{
    e[idx] = b;
    ne[idx] = g[a], w[idx] = c, g[a] = idx++;
}

auto dijkstra()
{
    priority_queue<T, vector<T>, greater<T> > q;    // 堆优化，采用优先队列，并以小顶堆的方式进行存储
    d[1] = 0;
    q.emplace(0, 1);
    while(q.size())
    {
        auto item = q.top(); q.pop();
        int dist = item.first;
        int node = item.second;
        if(st[node]) continue;
        st[node] = true;
        for(int i = g[node]; i != -1; i = ne[i])    // 判断与目前遍历点其连接的点是否需要更新
        {
            int t = e[i];
            if(d[t] > dist + w[i])
            {
                d[t] = dist + w[i];
                q.emplace(d[t], t);       // 更新完一个点则入堆，表示未被遍历且距离得到更新
            }
        }
    }
    
    if(d[n] == INF) cout << -1 << endl;
    else cout << d[n] << endl;
}

auto main() -> int
{
    memset(g, -1, sizeof g);
    memset(d, 0x3f, sizeof d);
    cin >> n >> m;
    while(m--)
    {
        int a, b, c; cin >> a >> b >>c;
        add(a,b,c);
    }
    dijkstra();
    return 0;
}

3.Dijkstra 算法不能用于负权边的情况

对于某些带负权边的情况，可能输出正确的结果，但某些情况是会输出错误的结果的,如下图的情况分析:
在这里插入图片描述

Bellman-Ford 算法

上面分析Dijkstra算法的时候，解释了为什么存在负权边的情况下不能用Dijkstra算法， 因为Dijkstra每次从堆顶取出的点都是距离起点最近的点，是基于贪心实现的，若存在负边权，虽然从堆顶出的点是距离起点最近的，但可能存在一条路径此时某个节点距离起点距离过大，只能在后面弹出，但该路径存在负权边，故这就造成了这个节点只能在其他节点遍历完毕之后再出堆，但此时这条路径已经不能继续遍历了，因为有的节点已经给标记为遍历状态，带来的结果就是，Dijkstra算法无法再确定从起点到这一点的最小距离，因为总可能有像这样未被遍历的点存在。故bellman_ford算法相比于Dijkstra算法就是没有了标记数组，直接每次都遍历所有的边，一直更新,即可重复遍历某个节点。

例题 ： 853. 有边数限制的最短路

代码实现

#include<iostream>
#include<cstring>
using namespace std;

constexpr int N = 1e+6, INF = 0x3f3f3f3f;
int n, m,k, d[N], temp[N];

struct 
{
    int a, b, w;  // 直接存储每条边的信息便于遍历，因为全部都要遍历一遍，故这里直接结构体比邻接表方便
}edge[N];

auto bellman_ford()
{
    d[1] = 0;
    for(int i = 1; i <= k; ++i)   // 遍历k次的含义是计算出不超过k条边情况下的某个节点距离起点的最短距离
    {
        // 解释一下上面那句话，因为遍历一次是遍历一条边的, 例如边 a->b ,长度为m, 则d[b]会判断是否进行更新
        // 若进行更新是用上次更新的结果来的，故这里用temp数组保存一下上次的d数组的结果
        memcpy(temp, d, sizeof d); 
        for(int j = 1; j <= m; ++j) // 每次都遍历一遍所有边，即相比Dijkstra算法重复遍历某个节点
        {
            auto e = edge[j];
            d[e.b] = min(d[e.b], temp[e.a] + e.w);     // 更新
        }
    }
    if(d[n] > INF / 2) cout << "impossible" << endl;  // 由于存在负权边，故条件是 > INF , 而不能写成 == INF 
    else cout << d[n] << endl;
}

auto main() -> int
{
    memset(d, 0x3f, sizeof d);
    cin >> n >> m >> k;
    for(int i = 1;i <= m; ++i)
    {
        int a, b, c; cin >> a >> b >> c;
        edge[i] = {a, b, c};
    }
    bellman_ford();
}

SPFA 算法

SPFA算法是对bellman_ford算法的改进， 我们观察bellman_ford算法可以改进的地方，首先为了解决Dijkstra可能漏掉某些节点的重新遍历，bellman_ford算法的解决方式，每次都是遍历一遍所有边，即这个操作

        for(int j = 1; j <= m; ++j) 
        {
            auto e = edge[j];
            d[e.b] = min(d[e.b], temp[e.a] + e.w);     // 更新
        }
// 可以看出要想d[e.b]发生更新，必须d[e.a] 发生变化，因为d[e.b] 和 e.w 这两项是不变的
// 故我们改进的思路就是当某个节点的距离重新更新之后，才遍历其连接的下一节点
// 故为了便于找到其某个节点连接的下一节点，这里最好的方式还是邻接表的实现

代码实现

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

constexpr int N = 1e+5 + 10, INF = 0x3f3f3f3f;
int n, m, g[N], d[N], e[N], ne[N], idx, w[N];    // 为了便于找到其连接的下一节点这里采用邻接表
bool st[N];

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

auto spfa() 
{
    queue<int> q;     // 保存进行遍历的节点，这里其实用什么容器都行
    d[1] = 0;         // 初始化起点
    q.push(1);        
    st[1] = true;     // st数组并不是标记是否被遍历，而是标记是否在队列中等待遍历，减少无效操作次数
    while(q.size())
    {
        int node = q.front(); q.pop();
        st[node] = false;
        for(int i = g[node]; i != -1; i = ne[i])
        {
            int t = e[i];
            if(d[t] > d[node] + w[i])  // 若其到起点的距离发生更新，则将其入队表示下次更新其连接的下一节点
            {
                d[t] = d[node] + w[i];
                if(!st[t]) q.push(t), st[t] = true;
            }
        }
    }
    if(d[n] > INF / 2) cout << "impossible" << endl;
    else cout << d[n] << endl;
}

auto main() -> int
{
    memset(g, -1, sizeof g);
    memset(d, 0x3f, sizeof d);
    cin >> n >> m;
    while(m--)
    {
        int a,b,c; cin >> a >> b >> c;
        add(a, b, c);
    }
    spfa();
    return 0;
}

SPFA应用-判断存在负环

正如前面所分析的, Dijkstra算法并不能用于处理负值权边的问题, 故Bellman_Ford 和 SPFA算法均可以处理负边权的问题, 这里一般判断是否存在负环我们一般用SPFA, 如果此时一个图中存在负权回路, 那么其肯定会绕圈, 会一直经过负权回路中的几个点, 因为根据算法, 这几个点的dist数组肯定会被一直更新, 故其对应的点也会一直被反复遍历, 这里我们引入一个cnt[] 数组, 其中cnt[x]表示的是从1 ~ x的边数, 而我们知道在有 n 个点的图中, 最极端的一个情况, 就是n个点依次顺序相连, 那么最后一个点的cnt数组记录的值应该是 n - 1, 如果 ≥ \ge ≥ n;说明从1 ~ x 的这条回路上一共有 ≥ \ge ≥ n 条变, 那么其经过了 n + 1个点, 显然如果不存在负权回路是不会出现这种情况的, 故一旦判断某个点更新之后的cnt值 ≥ \ge ≥ n 说明这个图存在负权回路.

题目链接: acwing 852.spfa判断负环

具体代码实现

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
constexpr int INF = 0x3f3f3f3f, N = 10010; 
int d[N], e[N], ne[N], w[N], g[N], cnt[N], n, m, idx; 
bool st[N]; 

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

void spfa()
{
    queue<int> q;
    d[1] = 0; 
    for(int i = 1; i <= n; ++i)  // 由于是判断整个图中是否有负权回路,故初始应将所有点入队 
    {
        q.push(i); 
        st[i] = true; 
    }
    
    while(q.size())
    {
        auto node = q.front(); q.pop(); 
        st[node] = false; 
        for(int i = g[node]; ~i; i = ne[i]) 
        {
            int b = e[i]; 
            if(d[b] > d[node] + w[i]) 
            {
                d[b] = d[node] + w[i]; 
                cnt[b] = cnt[node] + 1; 
                if(cnt[b] > n) return true; 
                if(!st[b]) 
                {
                    q.push(b); 
                    st[b] = true;
                }
            }
        }
    }
    cout << "No" << endl; 
}

auto main() -> int
{
    ios::sync_with_stdio(false); 
    memset(d, 0x3f, sizeof d); 
    memset(g, -1, sizeof g); 
    cin >> n >> m;    
    for(int i = 0; i < m; ++i)
    {
        int a, b, c; cin >> a >> b >> c;  
        add(a, b, c); 
    }
    if(spfa()) cout << "Yes" << endl ; 
    else cout << "No" << endl; 
    return 0; 
}

Floyd 算法

这针对多源最短路的问题， 即此时求解的答案并不是计算从1号节点到n号节点的最短距离，是计算从任意节点到另外一个节点的最短距离， 这个算法的思路是基于DP的, 故这里采用闫氏dp分析法分析一波

闫氏dp分析法

                             | 集合: 从i这个点开始只经过第1 ~ k个中间点到达 j的路径的集合  
                             |		(只经过并不代表都要经过)
  |---------状态表示--------- |
  |                          |
  |             f(k,i,j)     | 属性 : 集合中可行方案路径最短的值 min
  | 
  | 
  |
  DP    
  |
  |
  |
  |
  |------------状态计算   根据集合划分，将一个大集合划分为若干个子集，
                         设我们要求解f(k, i, j), 可以将其分为两个集合
                         不经过第k个点到达j 和 必定经过第k个点到达j
                         即f(k - 1, i, j) 和 f(k - 1, i, k) + f(k - 1, k, j); 
                         即从i 开始只经过第 1 ~ k - 1个中间点到达 k 这个点的最短距离, 
                         加上从 k 这个点开始只经过 1 ~ k - 1 个中间点到达 j 的最短距离 
                         即此时的状态转移方程为 : 
                         f[k, i, j] = min(f[k - 1, i, j] ,f[k - 1, i, k] + f[k - 1, k, j]);
                         
即:
for(int k = 1; k <= n; ++k)
	for(int i = 1; i <= n; ++i)
    	for(int j = 1; j <= n; ++j)
        	f[k][i][j] = min(f[k - 1][i][j] ,f[k - 1][i][k] + f[k - 1][k][j]);
                        
对上述状态转移方程进行进一步优化去掉一维得到:
for(int k = 1; k <= n; ++k)
	for(int i = 1; i <= n; ++i)
    	for(int j = 1; j <= n; ++j)
        	f[i][j] = min(f[i][j] ,f[i][k] + f[k][j]);
 
 这个形式是否等价于前面的情况呢? 
 因为前面未优化之前的状态是从 k - 1层转移过来的, 这里分几种情况讨论下:
 (1) i < k && j < k; 
 此时更新f[i][j] 时的 f[i][k] 和 f[k][j] 均在 f[i][j] 之后才更新, 故这种情况直接去掉一个维度依然成立 
 
 (2) i > k && j < k; 
 跟上面的情况类似, f[i][k] 这一项属于前一层未被更新的, 但是由于 i > k, 故f[k][j] 应该属于第 k 层被更新的
 那是不是就不成立了呢? 那我们看它更新了个啥?
 f[k][k][j] = min(f[k - 1][k][j], f[k - 1][k][j] + f[k - 1][k][k]); 显然f[k - 1][k][k] = 0; 
 故k - 1层 和 k层的 f[k][j] 是相同的并没有被更新
 
 (3) i < k && j > k  和  i > k && j > k 这两种情况同理, 其实上一层的本层情况相同, 所以并没有被更新
 
 
 结论: 直接去掉第一维与原本的形式等价 
 
 
故优化后也就是平常见到的Floyd代码为：
for(int k = 1; k <= n; ++k)
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			f[i][j] = min(f[i][j], f[i][k] + f[k][j]);

练习链接: acwing 854.Floyd求最短路

代码实现 -----时间复杂度 O( n 3 n^3 n3)

#include<iostream>
using namespace std;
constexpr int N  = 210, INF = 0x3f3f3f3f;
int n, m, k, f[N][N];   // 采用邻接矩阵的方式存储图 

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

auto main() -> int
{
    cin >> n >> m >> k;
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= n; ++j)
            if(i == j) f[i][j] = 0;
            else f[i][j] = INF;
    while(m--)
    {
        int a, b, c; cin >> a >> b >> c;
        f[a][b] = min(f[a][b], c);
    }
    floyd();
    while(k--)
    {
        int a, b; cin >> a >> b;
        if(f[a][b] > INF / 2) cout << "impossible" << endl;
        else cout << f[a][b] << endl;
    }
    return 0;
}
Boring_Firecar
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Dijkstra算法求由顶点a到顶点h的最短路径
weixin_47230213的博客
05-25 1910
问题 下图使用Dijkstra算法求由顶点a到顶点h的最短路径，按实验报告模板编写算法。 解析 Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。 然后，从dis数组选择最小值，
图论优化——最短路问题
VioletGrief的博客
08-25 286
![ 在这里插入图片描述 ](https://img-blog.csdnimg.cn/249ecbdf2934451d9c5e667515e825f5.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_Q1NETiBAVmlvbGV0IEdyaWVm,size_45,color_FFFFFF,t_70,g_se,x_16#pic_center)
Folyd 算法为什么不能处理带负权值的边组成的回路？
ThePythonFucker的博客
02-28 4539
我们都知道Dijkstra算法的局限性是不可以处理带有负权值的图，但是Floyd算法可以 不过在Folyd算法对应的解释中，说“Floyd算法允许有带负权值的边，但不允许有包含带负权值的边组成的回路” 起初我看到这句话对后半部分是有些不太明白的，前半部分很简单，主要解释后半部分 这句话的意思并不是说“只要回路中存在负权值Floyd就不可以解决” 而是“组成这个回路的所有的边的权值之和如果为负，就无法解决，否则还是可以解决的” 下面给出两个例子就明白了 这个图中右侧的三个边组成了一个回
（数据结构）最短路径问题——Floyd问题
最新发布
2301_79580018的博客
03-10 323
Floyd算法： Floyd算法核心代码： Floyd算法实例： 练习：Floyd算法用于负权图 Floyd算法不能解决带有“负权回路”的图：
最短路之Floyd算法
清风
04-28 340
最短路之Floyd算法 关于原理请看：只有五行的Floyd最短路算法 需要注意的是：Floyd算法不能解决带有“负权回路”（或者叫“负权环”）的图，因为带有“负权回路”的图没有最短路。例如下面这个图就不存在1号顶点到3号顶点的最短路径。因为1->2->3->1->2->3->…->1->2->3这样路径中，每绕一次1->-2>3这样的环，最短路就会减少1，永远找不到最短路。其实如果一个图中带有“负权回路”那么这个图则没有最短路。 #incl
C++图论 最短路问题总结
m0_62946761的博客
12-29 8753
C++ 图论关于最短路问题的总结，包括Dijkstra，Bellman_ford，spfa算法等。
图论- 最短路- Floyd 算法.rar
09-16
**图论中的最短路径问题** 在图论中，寻找两个节点之间的最短路径是一个基本且重要的问题。这种问题在很多领域都有应用，比如网络路由、交通规划、社交网络分析等。Floyd算法，也称为Floyd-Warshall算法，是解决...
cpp代码-dijkstra单源最短路
07-14
cpp代码-dijkstra单源最短路 Dijkstra算法是一种经典的图论算法，用于寻找图中一个顶点到其他所有顶点的最短路径。在计算机科学中，它广泛应用于网络路由、路径规划等领域。该算法是由荷兰计算机科学家艾兹格·...
最短路(图论)1
08-03
总结来说，解决“最短路(图论)1”问题的关键在于将迷宫转化为有向图，并应用Dijkstra算法找出从任意内部点到出口的最短路径，然后找出这些路径中成本最大的一个。这个过程涉及到图的表示、最短路径的概念以及...
动态最短路_动态最短路算法程序_
10-03
动态最短路算法是图论中的一个重要概念，用于在带权重的有向或无向图中寻找从一个起点到其他所有节点的最短路径。在实际应用中，它广泛应用于网络设计、物流优化、交通路线规划等领域。在这个场景中，我们讨论的是...
最短路（HDU-2544）.rar
09-16
总结，最短路问题在理论和实践上都有着重要的地位。理解并掌握各种算法不仅可以深化对图论的理解，还能在实际项目中发挥关键作用。无论是学术研究还是工程应用，对于最短路问题的探索和创新将持续推动计算机科学的...
最短路问题总结
qq_64468032的博客
07-10 248
时间复杂度：o(m*logn) m为边数n为顶点数。时间复杂度：o(n*m) 分别为边数和顶点数。该算法也可以在限制最多走的边数情况下的最短路。时间复杂度为o(n)~o(nlogn)时间复杂度：o(n^3)
看完就懂了！一篇搞定图论最短路径问题
weixin_30732825的博客
06-26 725
看完就懂了！一篇搞定图论最短路径问题 最最原始的问题——两点间的最短路 这类背景一般是类似：已知各城市之间距离，请给出从城市A到城市B的最短行车方案 or 各城市距离一致，给出需要最少中转方案。 也就是，固定起始点的情况下，求最短路。 这个问题用简单的搜索就能轻松解决。（本部分内容不涉及图论算法，可跳过） 假设用邻接矩阵存图，就比如下面这个例子： 深度优先搜索（dfs）的做法： void d...
图论 ——五种最短路算法
qq_46056407的博客
03-29 8991
文章目录 前言 一、最短路是什么？ 二、朴素Dijkstra算法 三、堆优化版Dijkstra算法 四、Bellman-Ford算法 五、Spfa算法 六、Floyd算法 总结 前言 本篇文章讲的是图论里的最短路问题，如果你还没有图论的基础知识，可以看看我之前的文章： DFS（深度优先算法）BFS(广度优先算法）邻接表和邻接矩阵、树的遍历 （DFS和BFS） 这些都是关于图论的基本知识。 一、最短路是什么？ 最短路径： 从某个点A（位置）到另一个点B(位置)的最..
【图论】最短路算法
weixin_62313535的博客
01-03 379
图论的最短路算法
图论——最短路
m0_64378422的博客
07-14 543
最短路
【图论】——最短路问题
GXT020507的博客
02-06 893
图论整理——最短路 内含有“最短路 ”的图论模版和相关题目； 内容正在不断更新，解题思路和代码将一并呈上。
最短路总结--模板及例题
Gank_Wind的博客
07-29 713
前言 最短路是图论中的一种常见题目，通常用邻接表和邻接矩阵来储存，用邻接矩阵存可能会因为空间超大而不可取，但更加方便，具体选择要根据题目要求来 1.Floyd算法 弗洛伊德（floyd）算法是一种用来解决任意两点之间的最短路的算法，以动态规划的思路来进行遍历 我们定义一个数组dp[k][i][j]来表示第i个点到第j个点的小于等于点k标号的中转点时的最短路，如果从i到k再从k到j的两条路之和比目前从i到j的最短路更短，那么就更新dp[k][i][j] 如 for(int k=1;k<=n;k+
dijkstra模板及例题（最短路算法）
热门推荐
weixin_61017400的博客
04-22 1万+
dijkstra算法、模板及例题
图论课件--最短路算法、图和代数表示.ppt
10-12
图论课件--最短路算法、图和代数表示.ppt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值