编写的迪杰斯特拉算法求最短路径，运行不正确？

Posted 2023-04-09

求高手！！！
在用c程序时包含文件#include<iostream>后边用加上.h吗。程序我差不多搞懂了谢谢！

你没有附上你的程序，就不方便帮你分析了。说到Dijkstra算法，大体思想就是每次从一个已找到最短路径的顶点集开始，寻找下一个可以确定最短路径的顶点。但应该注意，此算法有不足之处，就是边的权值必须为正数，否则可能结果出错。
说道具体程序呢，必然要建立在图的数据结构的基础上进行。我们一般的图的数据结构，可以用邻接矩阵，或者邻接表来实现。详情请参阅严蔚敏的《数据结构》。这里有我以前编的C++的程序，用到了STL库。不知道你们学过C++没。包含了两种图的数据结构下的Dijkstra算法。本人调试通过。

dijkstra.cpp文件
#include<iostream>
#include<vector>
#include"graph.h"

using namespace ds;
using namespace std;

typedef vector<int> PathMatrix[MAX_VERTEX_NUM];
typedef int ShortestPathTable[MAX_VERTEX_NUM];

//-----------------------邻接矩阵表示-------------------------
template<class T>
void ShortestPath_DIJ(MGraph<T> G,int v0,PathMatrix &P,ShortestPathTable &D)
int v,w,i,min;
int final[MAX_VERTEX_NUM];
for(v=0;v<G.vexnum;v++)
final[v]=FALSE;
D[v]=G.arcs[v0][v].adj;
if(D[v]<INFINITY)
P[v].push_back(v0);
P[v].push_back(v);


D[v0]=0;
final[v0]=TRUE;
for(i=1;i<G.vexnum;i++)
min=INFINITY;
for(w=0;w<G.vexnum;w++)
if(!final[w]&&D[w]<min)
v=w;
min=D[w];

final[v]=TRUE;
for(w=0;w<G.vexnum;w++)
if(!final[w]&&min<INFINITY&&G.arcs[v][w].adj<INFINITY&&min+G.arcs[v][w].adj<D[w])
D[w]=min+G.arcs[v][w].adj;
P[w]=P[v];
P[w].push_back(w);




//================================================================

//----------------------邻接表表示------------------------------

template<class T>
void ShortestPath_DIJ(ALGraph<T> G,int v0,PathMatrix &P,ShortestPathTable &D)
int v,w,i,min;
int final[MAX_VERTEX_NUM];
ArcNode *p;
for(v=0;v<G.vexnum;v++)
final[v]=FALSE;
D[v]=INFINITY;

for(p=G.vertices[v0].firstarc;p;p=p->nextarc)
D[p->adjvex]=*(int *)(p->info);
P[p->adjvex].push_back(v0);
P[p->adjvex].push_back(p->adjvex);


D[v0]=0;
final[v0]=TRUE;

for(i=1;i<G.vexnum;i++)
min=INFINITY;
for(w=0;w<G.vexnum;w++)
if(!final[w]&&D[w]<min)
v=w;
min=D[w];

final[v]=TRUE;
for(p=G.vertices[v].firstarc;p;p=p->nextarc)
w=p->adjvex;
if(!final[w] && min<INFINITY && min+*(int *)(p->info)<D[w])
D[w]=min+*(int *)(p->info);
P[w]=P[v];
P[w].push_back(w);





//================================================================

调用的graph.h文件比较长，包含了两种图的数据结构的各种基本操作，全文如下：
#include<iostream>
#include<vector>
#include"graph.h"

using namespace ds;
using namespace std;

typedef vector<int> PathMatrix[MAX_VERTEX_NUM];
typedef int ShortestPathTable[MAX_VERTEX_NUM];

//-----------------------邻接矩阵表示-------------------------
template<class T>
void ShortestPath_DIJ(MGraph<T> G,int v0,PathMatrix &P,ShortestPathTable &D)
int v,w,i,min;
int final[MAX_VERTEX_NUM];
for(v=0;v<G.vexnum;v++)
final[v]=FALSE;
D[v]=G.arcs[v0][v].adj;
if(D[v]<INFINITY)
P[v].push_back(v0);
P[v].push_back(v);


D[v0]=0;
final[v0]=TRUE;
for(i=1;i<G.vexnum;i++)
min=INFINITY;
for(w=0;w<G.vexnum;w++)
if(!final[w]&&D[w]<min)
v=w;
min=D[w];

final[v]=TRUE;
for(w=0;w<G.vexnum;w++)
if(!final[w]&&min<INFINITY&&G.arcs[v][w].adj<INFINITY&&min+G.arcs[v][w].adj<D[w])
D[w]=min+G.arcs[v][w].adj;
P[w]=P[v];
P[w].push_back(w);




//================================================================

//----------------------邻接表表示------------------------------

template<class T>
void ShortestPath_DIJ(ALGraph<T> G,int v0,PathMatrix &P,ShortestPathTable &D)
int v,w,i,min;
int final[MAX_VERTEX_NUM];
ArcNode *p;
for(v=0;v<G.vexnum;v++)
final[v]=FALSE;
D[v]=INFINITY;

for(p=G.vertices[v0].firstarc;p;p=p->nextarc)
D[p->adjvex]=*(int *)(p->info);
P[p->adjvex].push_back(v0);
P[p->adjvex].push_back(p->adjvex);


D[v0]=0;
final[v0]=TRUE;

for(i=1;i<G.vexnum;i++)
min=INFINITY;
for(w=0;w<G.vexnum;w++)
if(!final[w]&&D[w]<min)
v=w;
min=D[w];

final[v]=TRUE;
for(p=G.vertices[v].firstarc;p;p=p->nextarc)
w=p->adjvex;
if(!final[w] && min<INFINITY && min+*(int *)(p->info)<D[w])
D[w]=min+*(int *)(p->info);
P[w]=P[v];
P[w].push_back(w);





//================================================================

这个文件又调用了base.h中的一些基本定义：
#ifndef BASE_H_
#define BASE_H_

#include<stdio.h>

namespace ds

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;


#endif 参考技术A 鉴于最小生成树和最短路径的dijkstra是相似的，我把它们合到一块了，另外下面附了一个用堆优化的dijkstra（优先队列）的代码，看看吧。

最小生成树的普利姆算法和求最短路径的dijkstra算法
算法思想：
1.、先将出发点（对最小生成树来说可以是任意一点）放入集合s中（s为元素为图的顶点的集合，记录已经解决的顶点）。
2、找到s外的所有点到s的距离（即到s中所有点的距离的最小值）最小的点，把这一点加入s集合。
3、由于新加入的一个点会使某些点到s的距离更短，更新s外的其他点到集合s的距离（如果可以更短，则更新之）。
4、返回执行第2步，直到所有的点都加入s中。
注：第二步找到的最短距离会逐步增加，所以此算法也可以解决例如第K远的城市这种问题
算法代码：
int const MAXN = 100;
int i,j;

int n; //记录图的顶点个数

int edge[MAXN][MAXN]; //记录各边权值, 默认无向并且已知，两点之间无边则记为无穷大

int dist[MAXN]; //记录当前各个点到集合s的最小距离，在运行过程中不断更新

int s[MAXN] = 0; //记录已经解决的点的下标,标志着该顶点是否加入最小生成树

//初始化，假设各边权值已知，出发点为0
for(i = 0; i < n; i++)

dist[i] = edge[0][i];


/*执行第一步*/
s[0] = 1;

for(i = 0; i < n - 1; i++)//循环n-1次将剩余的n-1个点加入生成树

/*执行第二步*/
int min = inf; // inf 为可能的最大值
int u = 0; // 记录距离s最短的顶点的下标
for(j = 0; j < n; j++)

if(!s[j] && dist[j] < min)

min = dist[j];
u = j;


s[u] = 1;
/*执行第三步*/
/*************最小生成树的普利姆*********************/
for(j = 0; j < n; j++)

if(!s[j] && edge[u][j] < dist[j])
dist[j] = edge[u][j];

/****************************************************/

/************最短路径的dijstra算法********************/
for(j = 0; j < n; j++)

if( !s[j] && dist[u] + edge[u][j] < dist[j])
dist[j] = dist[u] + edge[u][j];

/***************************************************/


附：
/*dijkstra priority_queue 邻接链表实现*/

#include <iostream>
#include <queue>
using namespace std;

const int MAXN = 110;

int head[MAXN],size;
int dist[MAXN];
int n;

struct enode
int v,cost,next;
enode()
enode(int _v,int _cost):v(_v),cost(_cost)
enode(int _v, int _cost, int _next):v(_v), cost(_cost), next(_next)
bool operator < (const enode &t) const
return cost > t.cost;

;
enode edges[MAXN*MAXN];

void add_edge(int u,int v,int cost)
edges[size] = enode(v,cost,head[u]);
head[u] = size++;


int init()
int m,u,v,c;
memset(head,-1,sizeof(head));
size = 0;
scanf("%d%d",&n,&m); //输入顶点数和边数
if(m == 0 && n == 0)return 0;
for(int i = 0; i < m; i++)
scanf("%d%d%d",&u,&v,&c); //输入边的两个顶点和边的权值
add_edge(u-1,v-1,c);
add_edge(v-1,u-1,c);

return 1;


void Dijkstra(int st)

memset(dist,0x3f,sizeof(dist));
dist[st] = 0;

priority_queue < enode > q;
q.push( enode(st,0) );
while ( !q.empty() )

enode top = q.top();
q.pop();

if(top.cost != dist[top.v]) continue;

int u,v;
u = top.v;
for(int i = head[u] ;i != -1; i = edges[i].next)
v = edges[i].v;
if ( dist[v] > dist[u] + edges[i].cost )

dist[v] = dist[u] + edges[i].cost;
q.push( enode(v,dist[v]) );





int main()
while( init() )
Dijkstra(0);
printf("%d\n",dist[n-1]);

return 0;

[总结]最短路径算法

所谓最短路径问题是指：如果从图中某一顶点（源点）到达另一顶点（终点）的路径可能不止一条，如何找到一条路径使得沿此路径上各边的权值总和（称为路径长度）达到最小。

下面我们介绍两种比较常用的求最短路径算法：

Dijkstra（迪杰斯特拉）算法

迪杰斯特拉算法思想是按路径长度递增的次序一步一步并入来求取，是贪心算法的一个应用，用来解决单源点到其余顶点的最短路径问题。另外，要注意D算法是无法解决负权重问题的，所以图的权重必须为正。
首先，我们引入一个辅助向量(D)，它的每个分量(D[i])表示当前找到的从起始节点(v)到终点节点(v_i)的最短路径的长度。它的初始态为：若从节点(v)到节点(v_i)有弧，则(D[i])为弧上的权值，否则(D[i])为(∞)，显然，长度为(D[j] = Min{D[i] | v_i ∈V})的路径就是从(v)出发最短的一条路径，路径为((v, v_i))。
那么，下一条长度次短的最短路径是哪一条呢？假设次短路径的终点是(v_k)，则可想而知，这条路径或者是((v, v_k))或者是((v, v_j, v_k))。它的长度或者是从(v)到(v_k)的弧上的权值，或者是(D[j])与从(v_j)到(v_k)的权值之和。

一般情况下，假设(S)为已知求得的最短路径的终点集合，则可证明：一条最短路径（设其终点为(x)）或者是弧((v, x))或者是中间只经过(S)中的顶点而最后到达顶点(x)的路径。这可用反证法来证明，假设此路径上有一个顶点不在(S)中，则说明存在一条终点不在(S)中而长度比此路径短的路径。但是这是不可能的。因为，我们是按路径长度的递增次序来产生个最短路径的，故长度比此路径短的所有路径均已产生，他们的终点必定在(S)集合中，即假设不成立。

因此，Dijkstra算法描述如下：
假设存在(G=<V,E>)，源顶点为(V_0)，(S={V_0}),(distance[i])记录(V_0)到(i)的最短距离，(matrix[i][j])记录从(i)到(j)的边的权值，即两点之间的距离。
1）从(V-S)中选择使(dist[i])值最小的顶点(i)，将(i)加入到(U)中；
2）更新与(i)直接相邻顶点的dist值。(dist[j]=min{dist[j],dist[i]+matrix[i][j]})
3）直到(S=V)，所有顶点都包含进来了，算法停止。

图使用邻接矩阵存储,python代码如下：

# _*_ encoding:utf-8 _*_
# 辅助信息
# 图中的顶点数
V = 7
# 标记数组：used[v]值为False说明改顶点还没有访问过，在S中，否则在U中！
used = [False for _ in range(V)]
# 距离数组：distance[i]表示从源点s到ｉ的最短距离，distance[s]=0
distance = [float('inf') for _ in range(V)]
# cost[u][v]表示边e=(u,v)的权值，不存在时设为INF
cost = [[float('inf') for _ in range(V)] for _ in range(V)]


def dijkstra(s):
    distance[s] = 0
    while True:
        # v在这里相当于是一个哨兵，对包含起点s做统一处理！
        v = -1
        # 从未使用过的顶点中选择一个距离最小的顶点
        for u in range(V):
            if not used[u] and (v == -1 or distance[u] < distance[v]):
                v = u
        if v == -1:
            # 说明所有顶点都维护到S中了！
            break

        # 将选定的顶点加入到S中, 同时进行距离更新
        used[v] = True
        # 更新U中各个顶点到起点s的距离。之所以更新U中顶点的距离，是由于上一步中确定了k是求出最短路径的顶点，从而可以利用k来更新其它顶点的距离；例如，(s,v)的距离可能大于(s,k)+(k,v)的距离。
        for u in range(V):
            distance[u] = min(distance[u], distance[v] + cost[v][u])


if __name__ == '__main__':
    for _ in range(12):
        v, u, w = list(map(int, input().split()))
        cost[v][u] = w
    s = int(input('请输入一个起始点：'))
    dijkstra(s)
    print(distance)

Floyd（弗洛伊德）算法

Floyd算法是一个经典的动态规划算法。是解决任意两点间的最短路径(称为多源最短路径问题)的一种算法，可以正确处理有向图或无向图或负权（但不可存在负权回路)的最短路径问题，同时也被用于计算有向图的传递闭包。
从任意节点(i)到任意节点(j)的最短路径不外乎2种可能：1)直接从节点(i)到节点(j)，2)从节点(i)经过若干个节点(k)到节点(j)。所以，我们假设(arcs(i,j))为节点(i)到节点(j)的最短路径的距离，对于每一个节点(k)，我们检查(arcs(i,k) + arcs(k,j) < arcs(i,j))是否成立，如果成立，证明从节点(i)到节点(k)再到节点(j)的路径比节点(i)直接到节点(j)的路径短，我们便设置(arcs(i,j) = arcs(i,k) + arcs(k,j))，这样一来，当我们遍历完所有节点(k)，(arcs(i,j))中记录的便是节点(i)到节点(j)的最短路径的距离。

图使用邻接矩阵存储,python代码如下：

# _*_ encoding:utf-8 _*_
# 辅助信息
# 图中的顶点数
n = 4
# 距离数组：distance[i]表示从源点s到ｉ的最短距离，distance[s]=0
matrix = [[float('inf') for j in range(n)] for i in range(n)]

def floyd(matrix,n):
    for i in range(n):
        for j in range(n):
            for k in range(n):
                matrix[j][k] = min(matrix[j][k], matrix[j][i] + matrix[i][k])
    return matrix


if __name__ == '__main__':
    matrix[0][1] = 3
    matrix[1][2] = 1
    matrix[2][3] = 1
    matrix[1][3] = 4
    for i in range(n):
        matrix[i][i] = 0
    res = floyd(matrix,n)
    print(res)

参考：
Python实现迪杰斯特拉算法
最短路径问题：Dijkstra与Floyd算法