最短路的四种算法

这里总结复习一下最短路的四种算法

------------------------------------------------

以下题目过于占用篇幅，请自行上OJ看题

1）Floyd算法

　　Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。（百度百科）

　　重点是多源点。

　　邻接矩阵 mp[i][j] 表示的是从 i 点到 j 点的权值，现在在 i 到 j 之间插一个 k 点，那么状态转移方程为 mp[i][j] = min(mp[i][k] + mp[k][j], mp[i][j])；

　　这算法缺点是时间复杂度大，好像一个图到 500 个点就会爆时间了。。。。

　　核心代码

 

1 for(int k = 1;k <= n;++k)
2     for(int i = 1;i <= n;++i)
3         for(int j = 1;j <= n;++j)
4         mp[i][j] = min(mp[i][k] + mp[k][j], mp[i][j]);

 

　　HDU1874 畅通工程续（这题有几个坑点注意一下就好）

这里用Floyd算法AC

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <string>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <sstream>
 7 #include <algorithm>
 8 #include <set>
 9 #include <map>
10 #include <vector>
11 #include <queue>
12 #include <iomanip>
13 #include <stack>
14 
15 using namespace std;
16 
17 typedef long long LL;
18 const int INF = 0x3f3f3f3f;
19 const int MAXN = 100005;
20 const int MOD = 1e9 + 7;
21 
22 #define MemN(x) memset(x, -1, sizeof(x))
23 #define Mem0(x) memset(x, 0, sizeof(x))
24 #define MemM(x) memset(x, 0x3f, sizeof(x))
25 
26 int main()
27 {
28     int n, m, dp[205][205];
29     int a, b, c;
30     while(cin >> n >> m)
31     {
32         MemM(dp);
33         int i, j, k;
34         for(i = 0;i < n;++i)
35             dp[i][i] = 0;
36         for(i = 0;i < m;++i)
37         {
38             cin >> a >> b >> c;
39             dp[a][b] = min(dp[a][b], c);
40             dp[b][a] = dp[a][b];
41         }
42 
43         for(k = 0;k < n;++k)
44             for(i = 0;i < n;++i)
45                 for(j = 0;j < n;++j)
46                 dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
47         cin >> a >> b;
48         if(dp[a][b] != INF)
49             cout << dp[a][b] << endl;
50         else
51             cout << -1 << endl;
52     }
53 }

View Code