再开始前我们先普及一下简单的图论知识
图的保存：
1.邻接矩阵。 G[maxn][maxn];
2.邻接表
邻接表我们有两种方式
（1）vector< Node > G[maxn];
这个是之前就定义了图的大小了，再下面使用的时候就不用对图的大小进行申请了， 但是因为是直接申请了大小
要对图进行初始化，因此可能在某些题目中这样使用的话会超时
（2）vector< vector<Node> > G;
这个是未定义大小，但是在使用之前要对其的大小内存进行申请。
G.resize(n+1);
Dijkstra‘s Algorithm
算法思想：
1.从源点出发源点所有能一步到达的点的距离更新，然后从除源点外的所有点之中找出距离源点最近的点。
2.然后更新我们之前所找到的最短路点所有连接的点，但是要求这个点未曾被当做最短点处理过
3.重复上述操作n次。
单源最短路 我们还可以对他进行优先队列优化下面是以HDU2544为模板的用Dijkstra‘s Algorithm
邻接矩阵版，不用优先队列优化
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define INF 0xfffffff
#define maxn 1002
int G[maxn][maxn];//保存图
int dist[maxn];//表示从起点到第i点的距离
bool vis[maxn];//判断这个点是否被参观过
int m, n;//边数 m 顶点数 n
void Init()
{
for(int i=0; i<=n; i++)
{
vis[i] = false;
dist[i] = INF;
for(int j=0; j<=i; j++)
G[i][j] = G[j][i] = INF;
}
}
int Dij(int Star,int End)//起点 --- 终点
{
dist[Star] = 0;
for(int i=1; i<=n; i++)
{
int index = 0, Min = INF;
for(int j=1; j<=n; j++)
{
if( !vis[j] && Min > dist[j] )//找出没有被参观过，并且距离起点最近的点
Min = dist[j], index = j;
}
vis[index] = true;
for(int j=1; j<=n; j++)//更新所有未曾到达的点距离，使之成为最近的点
{
if( !vis[j] && dist[j] > dist[index] + G[index][j] )
dist[j] = dist[index] + G[index][j];
}
}
return dist[End];
}
int main()
{
while(cin >> n >> m, m + n)
{
Init();
int a, b , c;
for(int i=0; i<m; i++)
{
cin >> a >> b >> c;
G[a][b] = min(G[a][b], c);
G[b][a] = G[a][b];
}
int ans = Dij(1,n);
cout << ans << endl;
}
return 0;
}
接下来是邻接表版，用到了优先队列优化
1 #include <iostream>
2 #include <cmath>
3 #include <cstring>
4 #include <cstdlib>
5 #include <cstdio>
6 #include <algorithm>
7 #include <vector>
8 #include <queue>
9 using namespace std;
10 #define INF 0xfffffff
11 #define maxn 1002
12
13 struct Node
14 {
15 int e;
16 int w;
17 friend bool operator < (Node A, Node B)
18 {
19 return A.w > B.w;
20 }
21 };
22
23 bool vis[maxn];
24
25 int m, n;
26 vector< vector<Node> > G;
27
28 int Dij(int Star,int End)
29 {
30 Node P, Pn;
31 P.e = Star;
32 P.w = 0;
33
34 priority_queue<Node> Q;
35
36 Q.push(P);
37
38 while( !Q.empty() )
39 {
40 P = Q.top();
41 Q.pop();
42
43 if( vis[P.e] )
44 continue;
45
46 vis[P.e] = true;
47
48 if( P.e == End )
49 return P.w;
50
51 int len = G[P.e].size();
52
53 for(int i=0; i< len; i++)
54 {
55 Pn.e = G[P.e][i].e;
56 Pn.w = G[P.e][i].w + P.w;
57
58 if( !vis[Pn.e] )
59 Q.push(Pn);
60 }
61 }
62 return -1;
63 }
64
65 int main()
66 {
67 Node P;
68 while(cin >> n >> m, m+n)
69 {
70 G.clear();
71 G.resize(n+1);
72
73 memset(vis,false,sizeof(vis));
74
75 for(int i=0; i<m; i++)
76 {
77 int a, b, c;
78 cin >> a >> b >> c;
79 P.e = b;
80 P.w = c;
81 G[a].push_back(P);
82 P.e = a;
83 G[b].push_back(P);
84 }
85
86 int ans = Dij(1,n);
87
88 cout << ans << endl;
89 }
90 return 0;
91 }
下面是Floyd算法
Floyd是求多源最短路， 即可以求出所有点对之间的最短路
这个算法就只要注意两点就行了，初始化的时候 G[i][i] = 0, 其他的初始化为INF
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define INF 0xfffffff
#define maxn 1002
int G[maxn][maxn];
int dist[maxn][maxn];
int m, n;
void Floyd()
{
for(int k=1; k<=n; k++)
{
for(int i=1; i<=n; i++)
{
for(int j=1; j<=n; j++)
{
G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
}
}
}
}
void Init()
{
for(int i=0; i<=n; i++)
{
G[i][i] = 0;
for(int j=0; j<i; j++)
G[i][j] = G[j][i] = INF;
}
}
int main()
{
while(cin >> n >> m, m+n)
{
Init();
for(int i=0; i<m; i++)
{
int a, b, c;
cin >> a >> b >> c;
G[a][b] = min(G[a][b],c);
G[b][a] = G[a][b];
}
Floyd();
cout << G[1][n] << endl;
}
return 0;
}
时间： 2024-10-14 16:24:06