Floyd算法解决最短路径问题

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

  万圣节的中午,A和B在吃过中饭之后,来到了一个新的鬼屋!鬼屋中一共有N个地点,分别编号为1..N,这N个地点之间互相有一些道路连通,两个地点之间可能有多条道路连通,但是并不存在一条两端都是同一个地点的道路。由于没有肚子的压迫,A和B决定好好的逛一逛这个鬼屋,逛着逛着,A产生了这样的问题:鬼屋中任意两个地点之间的最短路径是多少呢?

输入

每个测试点(输入文件)有且仅有一组测试数据。

在一组测试数据中:

第1行为2个整数N、M,分别表示鬼屋中地点的个数和道路的条数。

接下来的M行,每行描述一条道路:其中的第i行为三个整数u_i, v_i, length_i,表明在编号为u_i的地点和编号为v_i的地点之间有一条长度为length_i的道路。

对于100%的数据,满足N<=10^2,M<=10^3, 1 <= length_i <= 10^3。

对于100%的数据,满足迷宫中任意两个地点都可以互相到达。

输出

对于每组测试数据,输出一个N*N的矩阵A,其中第i行第j列表示,从第i个地点到达第j个地点的最短路径的长度,当i=j时这个距离应当为0。

样例输入

5 12

1 2 967

2 3 900

3 4 771

4 5 196

2 4 788

3 1 637

1 4 883

2 4 82

5 2 647

1 4 198

2 4 181

5 2 665

样例输出

0 280 637 198 394

280 0 853 82 278

637 853 0 771 967

198 82 771 0 196

394 278 967 196 0

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<algorithm>
 4 using namespace std;
 5
 6 int n, m, map[101][101];
 7
 8 void flody(){
 9     for(int k = 1; k <= n; ++k){
10         for(int i = 1; i <= n; ++i){
11             for(int j = 1; j <= n; ++j){
12                 map[i][j] = min(map[i][j], map[i][k] + map[k][j]);
13             }
14         }
15     }
16 }
17
18 int scan(){
19     char c;
20     while(c = getchar(), c < ‘0‘ || ‘9‘ < c)
21         ;
22     int ret = c - ‘0‘;
23     while(c = getchar(), ‘0‘ <= c && c <= ‘9‘)
24         ret = ret * 10 + c - ‘0‘;
25     return ret;
26 }
27
28 void print(int x){
29     if(x > 9)
30         print(x / 10);
31     putchar(x % 10 + ‘0‘);
32 }
33 int main(){
34     int u_i, v_i, length_i;
35     memset(map, 10, sizeof(map));
36     n = scan();
37     m = scan();
38     while(m--){
39         u_i = scan();
40         v_i = scan();
41         length_i = scan();
42         if(map[u_i][v_i] > length_i)
43             map[u_i][v_i] = map[v_i][u_i] = length_i;
44     }
45     flody();
46     for(int i = 1; i <= n; ++i){
47         for(int j = 1; j <= n; ++j){
48             if(i == j){ putchar(‘0‘); putchar(‘ ‘);}
49             else{ print(map[i][j]); putchar(‘ ‘); }
50         }
51         puts("");
52     }
53     return 0;
54 }
时间: 2024-10-15 19:38:52

Floyd算法解决最短路径问题的相关文章

四大算法解决最短路径问题(Dijkstra+Bellman-ford+SPFA+Floyd)

什么是最短路径问题? 简单来讲,就是用于计算一个节点到其他所有节点的最短路径. 单源最短路算法:已知起点,求到达其他点的最短路径. 常用算法:Dijkstra算法.Bellman-ford算法.SPFA算法 多源最短路算法:求任意两点之间的最短路径. 常用算法:floyd算法 单源最短路径——Dijkstra Dijkstra算法是经典的最短路径算法,用于计算一个节点到其他所有节点的最短路径. 主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止. 时间复杂度:O(n^2) 处理问题:单源.

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 ][

Bellman - Ford 算法解决最短路径问题

Bellman - Ford 算法: 一:基本算法 对于单源最短路径问题,上一篇文章中介绍了 Dijkstra 算法,但是由于 Dijkstra 算法局限于解决非负权的最短路径问题,对于带负权的图就力不从心了,而Bellman - Ford算法可以解决这种问题. Bellman - Ford 算法可以处理路径权值为负数时的单源最短路径问题.设想可以从图中找到一个环路且这个环路中所有路径的权值之和为负.那么通过这个环路,环路中任意两点的最短路径就可以无穷小下去.如果不处理这个负环路,程序就会永远运

算法_最短路径

一.概述  定义:在一幅加权有向图中,从顶点s到顶点t的最短路径是所有从s到t的路径中的权重的最小者.从定义可以看出单点最短路径的实现是建立在加权有向图的基础上的. 最短路径树:给定一幅加权有向图和一个顶点s,以s为起点的一颗最短路径树是图的一幅子图,它包含s和从s可达的所有顶点.这颗有向树的根节点是s,树的每条路径都是有向图中的一条最短路径.它包含了顶点s到所有可达的顶点的最短路径. 二.加权有向图和加权有向边的数据结构 加权有向图和加权有向边的数据结构和加权无向图无向边的数据结构类型基本相同

hihocoder-1089-最短路径Floyd算法

hihocoder-1089-最短路径Floyd算法 #1089 : 最短路径·二:Floyd算法 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 万圣节的中午,小Hi和小Ho在吃过中饭之后,来到了一个新的鬼屋! 鬼屋中一共有N个地点,分别编号为1..N,这N个地点之间互相有一些道路连通,两个地点之间可能有多条道路连通,但是并不存在一条两端都是同一个地点的道路. 由于没有肚子的压迫,小Hi和小Ho决定好好的逛一逛这个鬼屋,逛着逛着,小Hi产生了这样的问题:鬼屋中任意

最短路径Dijkstra算法和Floyd算法整理、

转载自:http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html 最短路径—Dijkstra算法和Floyd算法 Dijkstra算法 1.定义概览 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止.Dijkstra算法是很有代表性的最短路径算法,在很多专业课程中都作为基本内容有详细的介绍,如数据结构,图论,运筹

最短路径—Dijkstra算法和Floyd算法

Dijkstra算法 1.定义概览 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止.Dijkstra算法是很有代表性的最短路径算法,在很多专业课程中都作为基本内容有详细的介绍,如数据结构,图论,运筹学等等.注意该算法要求图中不存在负权边. 问题描述:在无向图 G=(V,E) 中,假设每条边 E[i] 的长度为 w[i],找到由顶点 V0 到其余各点的最短路径.(单源最短路径) 2.算法

最短路径—Floyd算法

Floyd算法 所有顶点对之间的最短路径问题是:对于给定的有向网络G=(V,E),要对G中任意两个顶点v,w(v不等于w),找出v到w的最短路径.当然我们可以n次执行DIJKSTRA算法,用FLOYD则更为直接,两种方法的时间复杂度都是一样的. 1.定义概览 Floyd-Warshall算法(Floyd-Warshall algorithm)是解决任意两点间的最短路径的一种算法,可以正确处理有向图或负权的最短路径问题,同时也被用于计算有向图的传递闭包.Floyd-Warshall算法的时间复杂度