最短路小结 Floyd + Dijkstra + 带花费 + 字符节点

最新推荐文章于 2020-07-10 23:31:10 发布
最新推荐文章于 2020-07-10 23:31:10 发布
阅读量579 收藏 3
点赞数 1
分类专栏： 知识详解 文章标签： dijkstra 二维数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_bai_9527/article/details/75647518
版权

Floyd

这里写图片描述

ps：有向图是带有方向的图，就是有箭头的图，此介绍以有向图为例，无向图不计方向。

初始工作把这张有向图用一个二维数组存储，第一个下表表示起点，第二个表示终点，数组值代表长度。
如下图：

1234
10264
2∞03∞
37∞01
45∞120

自己到自己的距离为 0

从表中看的出，部分路径并不是最短，而且有些路径没有表示出来，所以我们需要更新这个二维数组。

那么如果两点之间不是最短距离，那么需要一个点来中专减少距离
比如：由 4 到 3，直接的话距离为 12，但是经过 节点1 的中转， 变为了 11 ，如果经过 1 和 2 的中转，变为了 10。

假设现在只允许通过 节点1 中转，假设现在从 i 到 j 点，那么长度为G[i][j]， 如果经过 节点1 的话，那么长度就变为 G[i][1] + G[1][j]。

如果

for(int i = 1; i <= n ; i++) 
    for(int j = 1; j <= n; j++) 
        if(G[i][j] > G[i][1] + G[1][j])
            G[i][j] = G[i][1] + G[1][j];

以此类推，把每个节点遍历一遍。

for(int k = 1; k <= n ; k++) 
    for(int i = 1; i <= n ; i++) 
        for(int j = 1; j <= n; j++) 
            if(G[i][j] > G[i][k] + G[k][j])
                G[i][j] = G[i][k] + G[k][j];
1234
10254
29034
36801
457100

这时候可能会问，为什么从 4 到 3 为什么是 10，不是经过一个节点吗，应该是 11，但是在 1 到 3 的时候也用了这个方法，他选择了有节点的走法，然后到 4 和 3 的时候就判断走 不走1节点，1节点以后的长度已经最优。

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2544

参考代码

#include<iostream>  
#define inf 0x3f3f3f3f 
using namespace std;
int G[10010][10010];
int main () {
    int n, m;
    while(~scanf("%d %d", &n, &m) && n) {
        for(int i = 0; i <= n; i++) {
            for(int j = 0; j <= n; j++) {
                if(i == j) G[i][j] = G[j][i] = 0;
                else G[i][j] = G[j][i] = inf;
            }
        }
        int x, y, w;
        for(int i = 1; i <= m; i++) {
            cin >> x >> y >> w;
            if(G[x][y] > w) {
                G[x][y] = G[y][x] = w;
            }
        }
        for(int k = 1; k <= n; k++) {
            for(int i = 1; i <= n; i++) {
                for(int j = 1; j <= n; j++) {
                    if(G[i][j] > G[i][k] + G[k][j])
                        G[i][j] = G[i][k] + G[k][j];
                }
            }
        }
        cout << G[1][n] << endl;
    }
    return 0;
}

下面介绍 Dijkstra

这里写图片描述

首先还是需要一个二维数组来记录

123456
10112∞∞∞
2∞09∞∞∞
3∞∞0∞5∞
4∞∞401314
5∞∞∞∞04
6∞∞∞∞∞0

这次不在G数组中更新数值，而是创建一个 dis 数组，来记录长度。

123456
dis0112∞∞∞

我们设起点为 1 ， 那么dis[1] = 0；（设谁为起点谁为0）

因为是求 1 到其他个点的长度，那么首先就是想找离 1 最近的点，那就是 2 点， 选择了2号顶点， 而且没有中转比它还小，因为 2 号点是里面最小的点了，没有谁能比它还小，而且还需要中转。

那么找到2号顶点之后，引申出两个点3 ，4 点
1 → 2 → 3， 和 1→3， 比较哪个更近， 写入dis[3]，（起点默认为1）
换成代码就应该是

if(dis[3] > dis[2] + G[2][3])
    dis[3] = dis[2] + G[2][3];

dis[3] = 12
dis[2] + G[2][3] = 1 + 9 = 10
所以dis[3] = 10
同理 2→4 的时候也是比较 dis[4] 和 dis[2] + G[2][4]
最后如图：

123456
dis01841317

☆小总结

先说读取，把G数组也就是map，全部记为inf 无限大，然后读取数值，更改两点之间的长度。

dis数组初始为直接连点的长度，即图上显示直接连接的长度，如果没有就记为inf

vis数组初始先标记起点

更新dis数组：
1.找到离起点，即与0最近的点，
2.vis标记这个点
3.用这个点为中转站，判断到终点哪个更短
4.更新到dis数组中
这样dis存的点为起点到各个点的最短距离了

练习题目：和上面一样

ac代码：

#include<iostream>  
#include<cstring>
#define inf 0x3f3f3f3f 
using namespace std;
int n, m;
int vis[10010];
int dis[10010];
int G[10010][10010];
void dijkstra(int n) {
    for(int i = 1; i <= n; i++) {
        dis[i] = G[1][i];
    }
    memset(vis, 0, sizeof(vis));
    vis[1] = 1;
    for(int cnt = 1; cnt <= n-1; cnt++) {
        int temp = inf;
        int u;
        for(int i = 1; i <= n; i++) {
            if(!vis[i] && dis[i] < temp) {
                temp = dis[i];
                u = i;
            }
        }
        if(temp == inf) break;
        vis[u] = 1;
        for(int i = 1; i <= n; i++) {
            if(dis[i] > dis[u] + G[u][i]) 
                dis[i] = dis[u] + G[u][i];
        }
    }
}
int main () {
    while(~scanf("%d %d", &n, &m) && n+m) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                if(i == j) G[i][j] = G[j][i] = 0;
                else G[i][j] = G[j][i] = inf;
            }
        } 
        int a, b, c;
        for(int i = 1; i <= m; i++) {
            cin >> a >> b >> c;
            G[a][b] = G [b][a] = c;
        } 
        dijkstra(n);
        printf("%d\n", dis[n]);
    }
    return 0;
}

Dijkstra带有花费的最短最省

顾名思义就是每条路不仅有长度，而且有花费，优先选择路程最少的，如果一样的话，优先选择花费少的。
这里我们选择使用结构体来做

struct {
    int w, v;
}s[1010][1010], dis[1010];

s代表地图， 即上题中的G数组，dis还是dis， w代表路程，v代表花费，初始的时候要初始化

void init(int n) {
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            s[i][j].w = s[i][j].v = inf;
        }
    }
    for(int i = 1; i <= n; i++)
        dis[i].v = dis[i].w = inf;
}

初始化全部为inf ，即无限大
然后数据输入，这里有个判定，
当输入的起点终点一样

花费后来输入的小，那么就要修改花费值
路程后来输入的小，那么就要修改路程

for(int i = 1; i <= m; i++) {
    scanf("%d %d %d %d", &x, &y, &w, &v);
    if(s[x][y].w > w || (s[x][y].w == w && s[y][x].v > v)) {
        s[x][y].w = s[y][x].w = w;
        s[x][y].v = s[y][x].v = v;
    }
}

在dijkstra函数内，更新dis数组的时候 除了dis[i].w > dis[u].w + s[u][i].w之外，还要修改当dis[i].w == dis[u].w + s[u][i].w 时的花费值，dis[i].w == dis[u].w + s[u][i].w && dis[i].v > dis[u].v + s[u][i].v
保证选择当路程一样的时候花费也是最小的

for(int i = 1; i <= n; i++) {
    if(dis[i].w > dis[u].w + s[u][i].w || (dis[i].w == dis[u].w + s[u][i].w && dis[i].v > dis[u].v + s[u][i].v)) {
        dis[i].w = dis[u].w + s[u][i].w;
        dis[i].v = dis[u].v + s[u][i].v;
    } 
}

题目链接 ：http://acm.hdu.edu.cn/showproblem.php?pid=3790

AC代码：

#include<iostream>
#include<cstring> 
#define inf 0x3f3f3f3f 
using namespace std;
int vis[10010];
struct {
    int w, v;
}s[1010][1010], dis[1010];
void init(int n) {
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            s[i][j].w = s[i][j].v = inf;
        }
    }
    for(int i = 1; i <= n; i++)
        dis[i].v = dis[i].w = inf;
}
void dijkstra(int st, int ed, int n) {
    dis[st].w = 0;
    dis[st].v = 0;
    memset(vis, 0, sizeof(vis));
    for(int cnt = 1; cnt <= n; cnt++) {
        int minn = inf;
        int u = - 1;
        for(int i = 1; i <= n; i++) {
            if(vis[i] == 0 && dis[i].w < minn) {
                minn = dis[i].w;
                u = i;
            }
        }
        if(u == -1) break;
        vis[u] = 1;
        for(int i = 1; i <= n; i++) {
            if(dis[i].w > dis[u].w + s[u][i].w || (dis[i].w == dis[u].w + s[u][i].w && dis[i].v > dis[u].v + s[u][i].v)) {
                dis[i].w = dis[u].w + s[u][i].w;
                dis[i].v = dis[u].v + s[u][i].v;
            } 
        }
    }
}
int main () {
    int n, m;
    while(~scanf("%d %d", &n, &m) && n+m) {
        init(n);
        int x, y, w, v;
        for(int i = 1; i <= m; i++) {
            scanf("%d %d %d %d", &x, &y, &w, &v);
            if(s[x][y].w > w || (s[x][y].w == w && s[y][x].v > v)) {
                s[x][y].w = s[y][x].w = w;
                s[x][y].v = s[y][x].v = v;
            }
        }
        int st, ed;
        scanf("%d %d", &st, &ed);
        dijkstra(st, ed, n);
        printf("%d %d\n", dis[ed].w, dis[ed].v);
    }
    return 0;
}

名字为字母的最短路

当输入并不是1234点的时候，我们需要把它归结于数字，然后用通常的方法去解；
这里使用的是STL中的map
定义为

map<string, int> cnt;

利用map的功能，每次可以从map中查询有没有出现过这个地名，如果没有，那么附一个数值kase给这个地名，然后kase++，保证每次赋的值是不同的，cnt.count(s1) 的意思是在cnt中查询有没有出现过s1字符串，如果没有返回非，如果有返回是，一旦把这个工作做完，cnt[s1]就代表一个数字，就如前面题目中的1234，把地名转换为数字来求解

for(int i = 0; i < n; i++) {
     cin >> s1 >> s2 >> x;
     if(!cnt.count(s1)) cnt[s1] = ++t;
     if(!cnt.count(s2)) cnt[s2] = ++t;
     G[cnt[s2]][cnt[s1]] = G[cnt[s1]][cnt[s2]] = min(x, G[cnt[s1]][cnt[s2]]);
 }

练习题目 ：http://acm.hdu.edu.cn/showproblem.php?pid=3790
AC代码 ： 

#include<map>
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int inf = 0x3f3f3f3f;
int G[155][155], vis[155], dis[155];
map<string, int> cnt;
int t, n;

int dijkstra(int S,int T) {
    int u;
    memset(vis,0,sizeof(vis));
    for(int i = 0; i <= t; i++) dis[i] = G[S][i];
    dis[S] = 0;
    vis[S] = 1;
    for(int i = 1; i < n; i++) {
        int temp = inf;
        for(int j = 0; j <= t; j++) {
            if(!vis[j] && dis[j] < temp) {
                temp = dis[j];
                u = j;
            }
        }
        if(temp == inf) continue;
        vis[u] = true;
        for(int j = 0; j <= t; j++) {
            if(!vis[j] && dis[j] > dis[u] + G[u][j])
            dis[j] = dis[u] + G[u][j];
        }
    }
    return dis[T];
}

int main() {
    int S, T, x;
    string s1, s2;
    while(scanf("%d", &n) && n != -1) {
        t = -1;
        cnt.clear();
        memset(G, inf, sizeof(G));
        cin >> s1 >> s2;
        cnt[s1] = ++t;
        S = t;
        if(!cnt.count(s2))
        cnt[s2] = ++t;
        T = t;
        for(int i = 0; i < n; i++) {
            cin >> s1 >> s2 >> x;
            if(!cnt.count(s1)) cnt[s1] = ++t;
            if(!cnt.count(s2)) cnt[s2] = ++t;
            G[cnt[s2]][cnt[s1]] = G[cnt[s1]][cnt[s2]] = min(x, G[cnt[s1]][cnt[s2]]);
        }
        int ans = dijkstra(S, T);
        if(ans == inf) printf("-1\n");
        else printf("%d\n", ans);
    }
    return 0;
}
东さん
关注
专栏目录
最短路径附带限制问题
allia990718的博客
08-16 2562
这一节要讨论的是带有额外条件的DP问题。 以下的这个问题是个很好的例子。 无向图G有N个结点，它的边上带有正的权重值。 你从结点1开始走，并且一开始的时候你身上带有M元钱。如果你经过结点i， 那么你就要花掉S[i]元(可以把这想象为收过路费)。如果你没有足够的钱， 就不能从那个结点经过。在这样的限制条件下，找到从结点1到结点N的最短路径。 或者输出该路径不存在。如果存在多条最短路径...
牛客oj 习题11.6最短路径(并查集+Dijkstra+大数加乘比较)
Iguodala的博客
04-13 397
题目链接：click here 题意：中问题，数据非常大 思路： （1）、由于后输入的边一定要大于之前所有边的总和，所以用并查集解决多余边问题，若输入边的两点不在同一集合，则合并，代表这个集合内的边都是尽可能小的边，若输入边的两点已经在同一集合，则将边舍弃； （2）、使用Dijkstra算法解决最短路问题，由于输入数据太庞大，所以用字符串存储以及运算，这里用到了大数加法、乘法、...
求最小费用或最短路径（最小生成树）
11-21
求最小费用或最短路径（最小生成树） 网络建设问题，旅行路径问题等等
带费用的Dijkstra
henucm的博客
02-25 369
朱民钦的回家之旅Description我们的寒假集训就快要结束了，而优秀的朱民钦学长也要踏上回家之旅了，给你一个图有N个地点，分别是1-N，我们学校是在1这个点，而朱民钦学长的家在N这个点，N个点之间存在M条道路，每一条道路有距离和花费金额，而朱民钦学长想想找一条距离最短的路，如果存在多条距离相等的路，那么输出花费最小的道路。现在请你告诉朱民钦学长，他回家的最短距离是多少，花费又是多少。Input...
最小花费（Dijkstra）
我很菜的好吧
12-27 598
最小花费 Description 在n个人中，某些人的银行账号之间可以互相转账。这些人之间转账的手续费各不相同。给定这些人之间转账时需要从转账金额里扣除百分之几的手续费，请问A最少需要多少钱使得转账后B收到100元。 Input 第一行输入两个用空格隔开的正整数n和m，分别表示总人数和可以互相转账的人的对数。以下m行每行输入三个用空格隔开的正整数x,y,z，表示标号为x的人和标号为y的人之间互相转...
最短路径问题 （最短距离以及花费）
自渡的博客
08-14 2807
给你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&...
整合：求最短路算法 floyd prim dijkstra Kruskal spfa算法简析
GrEedWish_X的专栏
07-30 2239
(转载） 一、floyd算法（快速计算i到j的最短距离，复杂度高[n^3]） 1.定义概览 Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。   2.算法描
解题报告：【kuangbin带你飞】专题四 最短路练习题
繁凡さん的博客
07-10 1020
最短路合集
Dijkstra算法和Floyd算法的实现
Zxdon的专栏
07-05 4320
摘 要 在实际生活当中，我们需要知道从一个城市到达另一个城市的最短路径，在旅行时可以减少在路途中的时间。路由器的路由表的更新也需要知道两个路由之间的最短距离。很多的关于两点之间的最短路径问题都可以抽象为求最短路径的数学模型。Dijkstra算法和Floyd算法是在求解最短路径问题上的最有效的算法。Dijkstra算法主要应用在求某一顶点到其余各顶点的最短路径。Floyd算法主要应用在求任意一
PTA 最短路径（Dijkstra和Floyd算法）
abyss_miracle的博客
04-07 3857
最短路径问题实际上就是在图中储存好每个点到别的点的最小距离，单源（单起点）问题往往用数组存放，多源问题常用邻接矩阵来处理。 多源问题常用Floyd算法来做，Floyd的核心是：当前I 到J的最小距离为I 到一小部分顶点 再到J的最小距离。然后不断的把K个顶点加到那一小部分顶点的集合中。直到K等于总顶点数N-1，就是整个图的实际多源距离。 例题： 07-图4 哈利·波特的考试 (25分) 哈利·波...
POJ 1724 二维费用最短路
weixin_30578677的博客
05-14 158
题目大意：有N个城市，编号1-N有R条路，每条路（单向）的起点为Si，终点为Di，长度为Li，如果要走这条路需要花Ti的钱现在你只有K元钱，求在不超支的前提下，从1走到N需要的最短距离 这里总是希望路程尽可能的短，那么利用dijkstra的方法来解决问题，总是先扩展距离近的点，这样能更快的找到终点的最短路 节点的扩展满足二维的情况，只要路程和费用两个限制条件中的其中一个满足情况...
POJ 1724 花销限制的最短路径
ClearRiver 's Style
12-20 910
题意：在图中寻找一条从节点1到节点n的路径，在保证花销的前体下，使得路径最短。题解：1，使用dfs，超时，不会优化。2，使用优先级队列+BFS能保证得到一个最优解。下面是BFS的代码#include #include using namespace std;struct node{ int id; int len; int cost; bool
Dijkstra模板 最短路最小花费
KEMNHAN的博客
08-30 164
struct dij { int n; const int inf = 0x3f3f3f3f; int maps[maxn][maxn]; int d[maxn], v[maxn]; int Dijkstra(int s, int t) { memset(d, inf, sizeof d); memset(v, 0,...
最短路径算法（Dijkstra、Floyd）总结
南极企鹅
10-04 3506
引言最短路径算法是图算法中比较重要的组成部分，在《算法导论》中有比较详细的阐述和证明。很长时间没在看过图算法的内容，在接触到增强学习后，复习了下A*算法，故对最短路径算法进行一下简单的总结，A*算法将会另外开一篇文章。Dijkstra和Floyd算法是最为经典的两个针对无向图进行最短路径求取的算法，本文先对这两个算法进行回顾和总结。Dijkstra算法Dijkstra算法在解决最短路径算法时有一定的
dijkstra和floyd
qq_43540087的博客
12-01 1395
dijstra和floyd最短路径 对于网图来说，最短路径，是指两顶点之间经过的边上权值之和最少的路径，并且我们称路径上的第一个顶点是源点，最后一个顶点是终点。关于最短路径主要有两种算法，迪杰斯特拉(dijkstra) 算法和弗洛伊德(floyd) 算法。 dijkstra算法将间隔一个（或多个）顶点的远距离路径问题转化为一步步求出它们之间顶点的最短路径问题，过程中都是基于已经求出的最短路径的基础...
几个最短路径算法Floyd、Dijkstra、Bellman-Ford、SPFA的比较
dinongxu8804的博客
02-12 1197
几大最短路径算法比较 July、二零一一年二月十二日。----------------------------------- 几个最短路径算法的比较：Floyd 求多源、无负权边的最短路。用矩阵记录图。时效性较差，时间复杂度O(V^3)。Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任...
JSP学生学籍管理系统设计与实现(源代码+论文+开题报告+外文翻译+答辩PPT).zip
09-21
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
省市区数据，完成三级联动，选择地区
09-21
省市区数据，完成三级联动，选择地区
机械原理课程设计网球自动捡球机.doc
最新发布
09-21
机械原理课程设计网球自动捡球机.doc
ACM竞赛中最短路算法详解：Dijkstra与Floyd-Warshall
本文将重点介绍两种常用的最短路算法：Dijkstra算法和Floyd-Warshall算法。 1. **Dijkstra算法**： Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻提出的一种解决单源最短路径问题的算法。它适用于无负权边的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值