dijkstra算法怎么记录路径

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了dijkstra算法怎么记录路径相关的知识,希望对你有一定的参考价值。

我用c++已经编出了求最短路径长度的程序,但是不知道怎么输出最短路径 ?请高手指点
看不懂诶
我发我的程序上来,你帮我改改哈

在松弛时用一个pre数组记录中间结点为前一个结点
pre数组初始化为-1
//单源最短路径,dijkstra算法,邻接阵形式,复杂度O(n^2)
//求出源s到所有点的最短路经,传入图的顶点数n,(有向)邻接矩阵mat
//返回到各点最短距离min[]和路径pre[],pre[i]记录s到i路径上i的父结点,pre[s]=-1
//可更改路权类型,但必须非负!
#define MAXN 200
#define inf 1000000000
typedef int elem_t;

void dijkstra(int n,elem_t mat[][MAXN],int s,elem_t* min,int* pre)
int v[MAXN],i,j,k;
for (i=0;i<n;i++)
min[i]=inf,v[i]=0,pre[i]=-1;
for (min[s]=0,j=0;j<n;j++)
for (k=-1,i=0;i<n;i++)
if (!v[i]&&(k==-1||min[i]<min[k]))
k=i;
for (v[k]=1,i=0;i<n;i++)
if (!v[i]&&min[k]+mat[k][i]<min[i])
min[i]=min[k]+mat[pre[i]=k][i];

参考技术A 加一个数组pre[],在更新最短路的时候记录是从哪个点更新过来的,即最短路径的前一个点
求完最短路之后再从终点沿着路径走回去,就可以得到最短的路径了
参考技术B 在松弛时用一个pre数组记录中间结点为前一个结点
pre数组初始化为-1
//单源最短路径,dijkstra算法,邻接阵形式,复杂度O(n^2)
//求出源s到所有点的最短路经,传入图的顶点数n,(有向)邻接矩阵mat
//返回到各点最短距离min[]和路径pre[],pre[i]记录s到i路径上i的父结点,pre[s]=-1
//可更改路权类型,但必须非负!
#define MAXN 200
#define inf 1000000000
typedef int elem_t;

void dijkstra(int n,elem_t mat[][MAXN],int s,elem_t* min,int* pre)
int v[MAXN],i,j,k;
for (i=0;i<n;i++)
min[i]=inf,v[i]=0,pre[i]=-1;
for (min[s]=0,j=0;j<n;j++)
for (k=-1,i=0;i<n;i++)
if (!v[i]&&(k==-1||min[i]<min[k]))
k=i;
for (v[k]=1,i=0;i<n;i++)
if (!v[i]&&min[k]+mat[k][i]<min[i])
min[i]=min[k]+mat[pre[i]=k][i];

有向图的单源非负最短路径算法-dijkstra算法

dijkstra应用范围:

图中各边权值非负。

最短路径在现实中应用很广,比如在地图上找出最短路径等,这个算法很重要。

算法思想很简单,它不是找特定节点対之间的最短路径,它是找出源节点到所有其他节点的最短路径。

怎么找呢?

所需额外参数:path[] 记录路径。 dist[] 记录路径长度, visited [] 标记已找到最短路径的节点。

第一步初始化,

将源节点visited标记为true, 并将其直连边长度,更新到dist[]数组。

 

其次要明白所有路径中最短的路径是哪一条?

肯定是源节点直连边(路径长度为1)中最短的那一条。

第二条呢?

必然是直连边或者第一条最短路径再扩一边中的最小边。

第N条呢?

如果我们把以求出最短路径的点标记为true,那么可以证明,下一条最短路径必然是true点再扩一条边中的最短边所组成的路径。

然后我们依次找下去,找N-1次,就可以找到源节点到所有目标节点的最短路径。

想要找出所有节点间的最短路径,变换源节点,重复N次即可。

下面给出Java代码,图用邻接矩阵存储:

 1 public int minPath(int source, int target){
 2         if (source == target){
 3             System.out.println("(" + source + " " + target + ")");
 4             return 0;
 5         }
 6         int[] path = dijkstra(source);
 7         int result = 0;
 8         String way = "";
 9         while (-1 != path[target]){
10             way = "(" + path[target] + " " + target + ") " + way;
11             result += graph[path[target]][target];
12             target = path[target];
13         }
14         System.out.println(way);
15         return result;
16     }
17     private int[] dijkstra(int vertex){
18        int[] path = new int[numVertices];
19        boolean[] visited = new boolean[numVertices];
20        int[] lenPath = new int[numVertices];
21 
22        // initial
23        int neighbor = getFirstNeighbor(vertex);
24        while (neighbor != -1){
25            lenPath[neighbor] = graph[vertex][neighbor];
26            neighbor = getNextNeighbor(vertex,neighbor);
27        }
28        for (int i = 0; i < numVertices; i++) {
29            if (lenPath[i] == 0){
30                lenPath[i] = 1000;
31                path[i] = -1;
32            }else{
33                path[i] = vertex;
34            }
35        }
36        visited[vertex] = true;
37 
38         // find min pathLen in unvisited vertex.
39        for (int i = 0; i < numVertices-1; i++) {
40            int min = vertex;
41            for (int j = 0; j < numVertices; j++) {
42                if (visited[j] == false && lenPath[j] < lenPath[min]){
43                    min = j;
44                }
45            }
46            if (min == vertex){
47                return path;
48            }
49            visited[min] = true;
50            for (int j = 0; j < numVertices; j++) {
51                if (visited[j] == false && lenPath[j] > lenPath[min] + graph[min][j]){
52                    lenPath[j] = lenPath[min] + graph[min][j];
53                    path[j] = min;
54                }
55            }
56        }
57        return path;
58     }

 

以上是关于dijkstra算法怎么记录路径的主要内容,如果未能解决你的问题,请参考以下文章

Floyd算法与Dijkstra算法的区别?

有向图的单源非负最短路径算法-dijkstra算法

关于Dijkstra算法

Dijkstra最短路径算法(C#实现)

最短路问题 Dijkstra算法- 路径还原

利用Dijkstra算法实现记录每个结点的所有最短路径