概要：
- Dijkstra算法
- Bellman-Ford算法
- SPFA算法
- Floyd算法
1、Dijkstra算法用于解决单源最短路径问题，严格讲是无负权图的最短路径问题。
邻接矩阵版
1 const int maxv=1000;
2 const int INF=1000000000;
3 int n,G[maxv][maxv];
4 int d[maxv]; //起点到各点的最短路径长度
5 bool vis[maxv]={false};
6
7 void Dijkstra(int s){ //s为起点
8 fill(d,d+maxv,INF);
9 d[s]=0;
10 for(int i=0;i<n;i++){ //循环n次
11 int u=-1,MIN=INF; //u使d[u]最小，MIN存放最小d[u]
12 for(int j=0;j<n;j++){
13 if(vis[j]==false && d[j]<MIN){ //未收录的顶点中到起点距离最小者
14 u=j;
15 MIN=d[j];
16 }
17 }
18 //找不到小于INF的d[u]，说明剩下的顶点和起点s不连通
19 if(u==-1) return;
20 vis[u] =true;
21 for(int v=0;v<n;v++){
22 if( G[u][v]!=INF && vis[v]==false && d[u]+G[u][v] < d[v]){
23 d[v]=d[u]+G[u][v];
24 }
25 }
26 }
27 }
邻接表版
1 struct Node{
2 int v,dis; //v为边的目标顶点， dis为边权
3 };
4 vector<Node> Adj[maxv];
5 int n,d[maxv];
6 bool vis[maxv]={0};
7
8 void Dijkstra(int s){
9 fill(d,d+maxv,INF);
10 d[s]=0;
11 for(int i=0;i<n;i++) {
12 int u=-1,MIN=INF;
13 for(int j=0;j<n;j++){
14 if(d[j]<MIN && vis[j]==false){
15 u=j;
16 MIN=d[j];
17 }
18 }
19 if(u==-1) return;
20 vis[u]=true;
21 for(int j=0;j<Adj[u].size();j++){
22 int v=Adj[u][j].v;
23 if(vis[v]==false && d[u] +Adj[u][j].dis <d[v]){
24 d[v]=d[u]+Adj[u][j].dis;
25 }
26 }
27 }
28 }
若要求输出最短路径，以邻接矩阵为例：
1 const int maxv=1000;
2 const int INF=1000000000;
3 int n,G[maxv][maxv];
4 int d[maxv]; //起点到各点的最短路径长度
5 bool vis[maxv]={false};
6 int pre[maxv];
7
8 void Dijkstra(int s){ //s为起点
9 fill(d,d+maxv,INF);
10 for(int i=0;i<n;i++) pre[i]=i;
11 d[s]=0;
12 for(int i=0;i<n;i++){ //循环n次
13 int u=-1,MIN=INF; //u使d[u]最小，MIN存放最小d[u]
14 for(int j=0;j<n;j++){
15 if(vis[j]==false && d[j]<MIN){ //未收录的顶点中到起点距离最小者
16 u=j;
17 MIN=d[j];
18 }
19 }
20 //找不到小于INF的d[u]，说明剩下的顶点和起点s不连通
21 if(u==-1) return;
22 vis[u] =true;
23 for(int v=0;v<n;v++){
24 if( G[u][v]!=INF && vis[v]==false && d[u]+G[u][v] < d[v]){
25 d[v]=d[u]+G[u][v];
26 pre[v]=u;
27 }
28 }
29 }
30 }
31
32 void DFS(int s,int v){ //从终点开始递归
33 if(v==s){ //如果当前已经到达起点，输出起点并返回
34 printf("%d\n",s);
35 }
36 DFS(s,pre[v]);
37 printf("%d\n",v);
38 }
另外还有一种情况，如果某个结点存在多个前驱结点，那上面这种pre数组的方法就不再适用，改成vector即可：
1 const int maxv=1010;
2 const int INF=1000000000;
3 vector<int> pre[maxv];
4 void Dijkstra(int s){
5 fill(d,d+maxv,INF);
6 d[s]=0;
7 for(int i=0;i<n;i++){
8 int u=-1,MIN=INF;
9 for(int j=0;j<n;j++){
10 if(vis[j]==false && d[j]<MIN){
11 u=j;
12 MIN=d[j];
13 }
14 }
15 if(u==-1) return;
16 vis[u]=true;
17 for(int v=0;v<n;v++){
18 if(vis[v]==false &&G[u][v]!=INF){
19 if(d[u]+G[u][v]<d[v]){
20 d[v]=d[u]+G[u][v];
21 pre[v].clear();
22 pre[v].push_back(u);
23 }
24 else if(d[u]+G[u][v]==d[v]){
25 pre[v].push_back(u);
26 }
27 }
28 }
29 }
30 }
当访问的结点是路径起点st时（边界），此时tempPath里存了整条路径（倒序），这时需要计算第二标尺value的值，并与optValue比较，若更优则更新optValue并把path覆盖。
1 const int maxv=1010;
2 const int INF=1000000000;
3 int optValue;
4 vector<int> path,tempPath;
5 vector<int> pre[maxv];
6
7 void Dijkstra(int s){
8 fill(d,d+maxv,INF);
9 d[s]=0;
10 for(int i=0;i<n;i++){
11 int u=-1,MIN=INF;
12 for(int j=0;j<n;j++){
13 if(vis[j]==false && d[j]<MIN){
14 u=j;
15 MIN=d[j];
16 }
17 }
18 if(u==-1) return;
19 vis[u]=true;
20 for(int v=0;v<n;v++){
21 if(vis[v]==false &&G[u][v]!=INF){
22 if(d[u]+G[u][v]<d[v]){
23 d[v]=d[u]+G[u][v];
24 pre[v].clear();
25 pre[v].push_back(u);
26 }
27 else if(d[u]+G[u][v]==d[v]){
28 pre[v].push_back(u);
29 }
30 }
31 }
32 }
33 }
34
35 void DFS(int v){ //v为当前访问结点
36 if(v==st){
37 tempPath.push_back(v);
38 int value;
39 (计算路径的value)
40 if(value优于optValue){
41 path=tempPath;
42 optValue=value;
43 }
44 tempPath.pop_back(); //将刚加入的结点删除
45 return;
46 }
47 tempPath.push_back(v);
48 for(int i=0;i<pre[v].size();i++){
49 DFS(pre[v][i]);
50 }
51 tempPath.pop_back();
52 }
除此之外，还会碰到第二标尺，常见有以下三种：（具体代码见晴神算法笔记，写的很清楚）
- 新增边权（如增加开销）
- 新增点权（如收集到的物资）
- 求最短路径条数
图的算法专题——最短路径
原文地址：https://www.cnblogs.com/Mered1th/p/10418946.html
时间： 2024-10-06 18:43:24