Floyd算法模板(多源最短)

 1 /*
 2 INPUT
 3
 4
 5 7 12
 6 1 2 24
 7 1 3 8
 8 1 4 15
 9 2 5 6
10 3 5 7
11 3 6 3
12 4 7 4
13 5 7 9
14 6 5 2
15 6 7 3
16 6 4 5
17 7 2 3
18
19 5
20 1 2
21 3 6
22 1 7
23 4 4
24 3 7
25
26
27 OUTPUT
28
29 1 to 2 need 17
30 3 to 6 need 3
31 1 to 7 need 14
32 4 to 4 need 0
33 3 to 7 need 6
34
35 */
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <algorithm>
40 using namespace std;
41 const int inf=0x3f3f3f3f;
42 int n,m,w[110][110];
43 int main()
44 {
45     while(~scanf("%d%d",&n,&m))
46     {
47         memset(w,inf,sizeof(w));//先全部设为无穷大
48         for(int i=1; i<=n; i++)
49             w[i][i]=0;//自己到自己距离为0;
50         while(m--)
51         {
52             int u,v,c;
53             scanf("%d%d%d",&u,&v,&c);
54             if(c<w[u][v]);
55             w[u][v]=w[v][u]=c;
56         }
57         for(int k=1; k<=n; k++)//为了将i,j与k的情况讨论完,k作为中间点,要放在最外层
58         {
59             for(int i=1; i<=n; i++)
60             {
61                 for(int j=i+1; j<=n; j++)//因为是无向图,j>i或j<i(2,3),(3,2)的情况是一样的,不用重复计算
62                 {
63                     if(k!=i&&j!=k&&w[i][k]!=inf&&w[k][j]!=inf)//k作为中间点,三点不能重合,并且要满足k与i,j都有连接
64                     {
65                         w[i][j]=w[j][i]=min(w[i][j],w[i][k]+w[k][j]);//假如第三点之和小于起点直接到终点之和就更新
66                     }
67                 }
68             }
69         }
70         scanf("%d",&m);
71         while(m--)
72         {
73             int u,v;
74             scanf("%d %d",&u,&v);
75             printf("%d to %d need %d\n",u,v,w[u][v]);
76         }
77     }
78     return 0;
79 }

从任意节点i到任意节点j的最短路径不外乎2种可能,1是直接从i到j,2是从i经过若干个节点k到j。所以,我们假设Dis(i,j)为节点u到节点v的最短路径的距离,对于每一个节点k,我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立,如果成立,证明从i到k再到j的路径比i直接到j的路径短,我们便设置Dis(i,j) = Dis(i,k) + Dis(k,j),这样一来,当我们遍历完所有节点k,Dis(i,j)中记录的便是i到j的最短路径的距离。

时间: 2024-10-11 13:12:03

Floyd算法模板(多源最短)的相关文章

Floyd算法模板

Floyd可以求出任意两点间的最短距离,代码也相对简单,对于稀疏图来说效率也还是不错的,但由于三个for循环导致时间复杂度较高,不适合稠密图. Floyd算法模板(精简版): void Floyd() { int dist[maxn][maxn]; // dist存储i到j的最短距离 for(int k = 1; k <= n; k++) for(int i = 1;i <= n; i++) for(int j = 1; j <= n; j++) if(dist[i][k] + dist

Floyd 算法求多源最短路径

Floyd算法: Floyd算法用来找出每对顶点之间的最短距离,它对图的要求是,既可以是无向图也可以是有向图,边权可以为负,但是不能存在负环. 基本算法: Floyd算法基于动态规划的思想,以 u 到 v 的最短路径至少经过前 k 个点为转移状态进行计算,通过 k 的增加达到寻找最短路径的目的.当 k 增加 1 时,最短路径要么不边,如果改变,必经过第 k 各点,也就是说当起点 u 到第 k 个点的最短距离加上第 k 个点到终点 v 的最短路径小于不经过第 k 个节点的最优最短路经长度的时候更新

最短路--floyd算法模板

floyd算法是求所有点之间的最短路的,复杂度O(n3)代码简单是最大特色 1 #include<stdio.h> 2 #include<string.h> 3 4 const int maxn=105; 5 const int INF=0x3f3f3f3f; 6 int ma[maxn][maxn],n; 7 8 inline int min(int a,int b){return a<b?a:b;} 9 inline int max(int a,int b){return

Floyd算法解决多源最短路问题

说好的写dijkstra 算法堆优化版本的,但是因为,妹子需要,我还是先把Floyd算法写一下吧!啦啦啦! 咳咳,还是说正事吧! ------------------------------------------------说正事专用分隔符------------------------------------------ 用一个关系式,表达一下Floyd算法和dijkstra算法之间的关系 是不是很好懂,其实就把dijkstra算法做了n遍,额鹅鹅鹅,也不能说n遍吧,看有多少个点, 每个点轮

Floyd算法解决多源最短路径问题

Floyd-Warshall算法是解决任意两点间的最短路径的一种算法,可以正确处理有向图或负权(但不可存在负权回路)的最短路径问题,同时也被用于计算有向图的传递闭包. Floyd-Warshall算法的时间复杂度为O(N^3),空间复杂度为O(N^2). Floyd-Warshall算法的原理是动态规划: 从i到j,要么是直接从i到j的,要么是从i出发经过中间节点到j的,假设中间节点有k种可能,那么只要求出这k种可能的最小值,即可得到最短路径. d[ i ][ j ]=min{ d[ i ][

Floyd算法求多源最短路径

#include<stdio.h> int main() { int m, n, i, j, k, t1, t2, t3, e[10][10]; scanf_s("%d %d", &n, &m); for (i = 1; i <= n;i++) for (j = 1; j <= n; j++)//Initialize the matrix { if (i == j) e[i][j] = 0; else e[i][j] = 99999; } for

Restoring Road Network(Floyd算法的推广)

个人心得:看懂题目花费了不少时间,后面实现确实时间有点仓促了,只是简单的做出了判断是否为真假的情况, 后面看了题解发现其实在判断时候其实能够一起解决的,算了,基础比较差还是慢慢的来吧. 题意概述: 就是给定一个N阶方阵,规定Auv,为u到v的最短路径,若给出的数据存在其他通路少于此时的值则不存在即为假, 解决方法就是利用Floyd算法进行单源最短路的判断,只要后面的矩阵与原来的不相符就是假的.真的的时候,是要求 存在的最短总路程使得矩阵的数成立,我画了下就是只要存在从其他城市能够转到目的地的时候

[Python] 弗洛伊德(Floyd)算法求图的直径并记录路径

相关概念 对于一个图G=(V, E),求图中两点u, v间最短路径长度,称为图的最短路径问题.最短路径中最长的称为图的直径. 其中,求图中确定的某两点的最短路径算法,称为单源最短路径算法.求图中任意两点间的最短路径算法,称为多源最短路径算法. 常用的路径算法有: Dijkstra算法 SPFA算法\Bellman-Ford算法 Floyd算法\Floyd-Warshall算法 Johnson算法 其中最经典的是Dijkstra算法和Floyd算法.Floyd算法是多源最短路径算法,可以直接求出图

最短路算法模板合集(Dijkstar,Dijkstar(优先队列优化), 多源最短路Floyd)

再开始前我们先普及一下简单的图论知识 图的保存: 1.邻接矩阵. G[maxn][maxn]; 2.邻接表 邻接表我们有两种方式 (1)vector< Node > G[maxn]; 这个是之前就定义了图的大小了,再下面使用的时候就不用对图的大小进行申请了, 但是因为是直接申请了大小 要对图进行初始化,因此可能在某些题目中这样使用的话会超时 (2)vector< vector<Node> > G; 这个是未定义大小,但是在使用之前要对其的大小内存进行申请. G.resi