dijkstra算法怎么记录路径

Posted 2023-04-01

我用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     }