Dijkstra最短路径算法例题python 最短路径算法dijkstra算法代码

算法简介

Dijkstra算法是一种全局路径规划算法，是从一个节点遍历其余各节点的最短路径算法，解决的是有权图中最短路径问题。

算法思想

1. 设G=(V,E)是一个带权有向图，把图中节点集合V分成两组，第一组为已求出最短路径的节点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径, 就将该节点加入到集合S中，直到全部节点都加入到S中，算法就结束了）；
2. 第二组为其余未确定最短路径的节点集合（用U表示），按最短路径长度的递增次序依次把第二组的节点加入S中。在加入的过程中，总保持从源点v到S中各节点的最短路径长度不大于从源点v到U中任何节点的最短路径长度。

示例分享

来看下面一幅图，以D节点为源点，依次遍历其他所有节点。

每个节点的信息如下图所示：

算法更新流程

MATLAB实现

clc
clear
close all

%% 图定义
% 根据节点的邻近节点表及字母节点-数字节点对应表，构造节点元胞数组
nodes_dist = cell(0);
nodes_dist(1,:) = {1, [2, 6, 7], [12, 16, 14]};
nodes_dist(2,:) = {2, [1, 3, 6], [12, 10, 7]};
nodes_dist(3,:) = {3, [2, 4, 5, 6], [10, 3, 5, 6]};
nodes_dist(4,:) = {4, [3, 5], [3, 4]};
nodes_dist(5,:) = {5, [3, 4, 6, 7], [5, 4, 2, 8]};
nodes_dist(6,:) = {6, [1, 2, 3, 5, 7], [16, 7, 6, 2, 9]};
nodes_dist(7,:) = {7, [1, 5, 6], [14, 8, 9]};

%% 算法初始化
% S/U的第一列表示节点编号
% 对于S，第二列表示从源节点到本节点已求得的最小距离，不再变更；
% 对于U，第二列表示从源节点到本节点暂时求得的最小距离，可能会变更
S = [4, 0];
U(:,1) = [1, 2, 3, 5, 6, 7];
U(:,2) = [inf, inf, 3, 4, inf, inf];

% 最优路径及暂时最优路径的初始化
path_opt = cell(7,2);
path_opt(4,:) = {4, 4};

path_temp = cell(7,2);
path_temp(3,:) = {3, [4, 3]};
path_temp(4,:) = {4, 4};
path_temp(5,:) = {5, [4, 5]};

%% 循环遍历所有节点
while ~isempty(U)
    
    % 在U集合找出当前最小距离值及对应节点,并移除该节点至S集合中
    [dist_min, idx] = min(U(:,2));
    node_min = U(idx, 1);
    S(end+1,:) = [node_min, dist_min];
    U(idx,:) = [];
    
    % 将最小距离值的节点添加到最优路径集合
    path_opt(node_min,:) = path_temp(node_min,:);
    
    %% 依次遍历最小距离节点的邻节点，判断是否在U集合中更新邻节点的距离值
    for i = 1:length(nodes_dist{node_min, 2})
        
        % 需要判断的节点
        node_temp = nodes_dist{node_min, 2}(i);
        
        % 找出U集合中节点node_temp的索引值
        idx_temp = find(node_temp == U(:,1));
        
        % 判断是否更新
        if ~isempty(idx_temp)
            if dist_min + nodes_dist{node_min, 3}(i) < U(idx_temp, 2)
                U(idx_temp, 2) = dist_min + nodes_dist{node_min, 3}(i);
                
                % 更新暂时最优路径
                path_temp{node_temp, 1} = node_temp;
                path_temp{node_temp, 2} = [path_opt{node_min, 2}, node_temp];                
            end
        end
    end
end

C++实现

Dijkstra.h

#pragma once
#include<iostream>
#include<stack>
using namespace std;

#define MAX_VERTEX_NUM 20  //顶点的最大个数
#define INFINITE 9999      //定义无穷大的数值
#define VRType int		   //顺序存储结构中，对于无权图，用 1 或 0 表示是否相邻；对于带权图，直接为权值
#define VertexType int	   //图中顶点的数据类型


class MGraph //图的顺序存储结构
{
public:
	VertexType vexs[MAX_VERTEX_NUM]; //一维数组，存储图中顶点数据
	VRType arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; //二维数组，记录顶点之间的关系 //对于无权图，用 1 或 0 表示是否相邻；对于带权图，直接为权值
	int vexnum;	//记录图的顶点数
	int arcnum; //记录图的弧（或边）数
};

class Dijkstra
{
public:
	Dijkstra();//构造函数，初始化邻接矩阵
	int LocateVex(MGraph &G, VertexType v); //根据顶点本身数据，判断出顶点在二维数组中的位置
	void CreateUDN(MGraph &G);//构造无向带权图
	void PrintGrapth(MGraph G); //打印整个图
	void ShortestPath_Dijkstra();

public:
	MGraph G;//创建图的对象
	int V0 = 0;//起点下标，初始化为0，也就是默认输入的第一个值就是起点
	int Patharc[MAX_VERTEX_NUM];//存储最短路径下标，也就是每个顶点被访问后的前驱顶点的下标；
	int Distance[MAX_VERTEX_NUM];//存储到各点最短路径的权值之和
	bool final[MAX_VERTEX_NUM];//标志位，final[w]=true表示已经求得V0到Vw的最短路径，w这个顶点已经被访问；
	int k;//临时下标
	int min;//min是临时最短路径的权值（最小权值之和）；
	stack<int> path;//用于打印
};

Dijkstra.cpp

#include "Dijkstra.h"

Dijkstra::Dijkstra()//构造函数，初始化邻接矩阵
{
	CreateUDN(G);//在初始化时就创建图	

	//遍历所有顶点，更新Distance、Patharc和final三个数组，更新起点信息；
	for (int i = 0; i < G.vexnum; i++)
	{
		final[i] = false;//全部顶点先初始化为未找到最短路径；
		Distance[i] = G.arcs[V0][i];//将与V0邻接的顶点所构成的边加上权值，其他保持为INFINITE；也就是读取邻接矩阵里的信息，赋值到Distance数组中；
		Patharc[i] = V0;//前驱顶点的下标先全部置为V0；//这里不能初始化为0或者-1，后续会出错，要初始化为源点；
	}
	Distance[V0] = 0;//起点就是V0，V0到V0距离为0；
	final[V0] = true;//起点V0已经找到最短路径；

	cout << endl;
	PrintGrapth(G);//打印整个图
}

int Dijkstra::LocateVex(MGraph &G, VertexType v) //根据顶点本身数据，判断出顶点在数组中的位置
{
	//遍历一维数组，找到变量v
	for (int i = 0; i < G.vexnum; i++)
	{
		if (G.vexs[i] == v)
		{
			return i;//找到了
		}
	}
	//如果找不到，输出提示语句，返回-1
	cout << "no such vertex." << endl;
	return -1;
}

void Dijkstra::CreateUDN(MGraph &G)//构造无向带权图
{
	int v;
	int a;

reInput1:
	cout << "请输入网的顶点数：" << endl;
	cin >> v;
	if (v > MAX_VERTEX_NUM || v <= 0)
	{
		cout << "顶点数超出范围，请重新输入" << endl;
		goto reInput1;
	}

reInput2:
	cout << "请输入网的边数：" << endl;
	cin >> a;
	if (a > (v * (v - 1) / 2) || a <= 0)
	{
		cout << "边数超出范围，请重新输入" << endl;
		goto reInput2;
	}

	G.vexnum = v;
	G.arcnum = a;

	int vex;
	for (int i = 0; i < G.vexnum; i++) //输入每个顶点的元素数据，给一维数组赋值
	{
		cout << "请输入该顶点的元素：" << endl;
		cin >> vex;
		G.vexs[i] = vex;
	}

	for (int i = 0; i < G.vexnum; i++) //初始化矩阵，给矩阵赋值
	{
		for (int j = 0; j < G.vexnum; j++)
		{
			G.arcs[i][j] = INFINITE;//先把矩阵的每个元初始化为无穷
		}
	}

	for (int i = 0; i < G.arcnum; i++) //创建顶点之间的连接关系，更新矩阵
	{
		VertexType v1, v2;
		VRType w;
		cout << "请输入要创建关系的两个顶点元素：" << endl;
		cin >> v1;
		cin >> v2;
		cout << "请输入这两个顶点之间边的权值：" << endl;
		cin >> w;

		int n = LocateVex(G, v1);
		int m = LocateVex(G, v2); //确定顶点位置
		if (m == -1 || n == -1)
		{
			cout << "no this vertex." << endl;//输入的两个顶点至少有一个不存在
			return;
		}

		G.arcs[n][m] = w;//权值赋值
		G.arcs[m][n] = w;//矩阵对称
	}

	for (int i = 0; i < G.vexnum; i++)
	{
		for (int j = 0; j < G.vexnum; j++)
		{
			if (i == j) //对角线上的元置0
			{
				G.arcs[i][j] = 0;
			}
		}
	}
}

void Dijkstra::PrintGrapth(MGraph G) //打印整个图
{
	cout << "图的邻接矩阵是：" << endl;
	for (int i = 0; i < G.vexnum; i++)
	{
		for (int j = 0; j < G.vexnum; j++)
		{
			cout << G.arcs[i][j] << ", ";
		}
		cout << endl;
	}
	cout << endl;
}

void Dijkstra::ShortestPath_Dijkstra()
{
	for (int i = 1; i < G.vexnum; i++)//v从1开始，因为V0已经确定了，不再考虑；//遍历邻接矩阵的每一列
	{
		min = INFINITE;//先让min=无穷，先和无穷比，比无穷小说明有连线，否则没有连线；
		for (int j = 0; j < G.vexnum; j++)//遍历邻接矩阵的每一行
		{
			if (!final[j] && Distance[j] < min)//如果w这个顶点还没有确认最短路径，并且现有的权值之和小于min
			{
				k = j;//更新下标
				min = Distance[j];//更新min
			}
			//到这里为止只是更新了两个临时变量，还没有更新三个数组的内容
		}
		final[k] = true;//将目前找到的顶点置为ture，也就是k这个顶点已经找到最短路径 //final数组被更新

		for (int j = 0; j < G.vexnum; j++)//还是遍历每一行，更新当前最短路径前驱顶点和路径值
		{
			if (!final[j])//如果w这个顶点还没有确认最短路径，
			{
				if (min + G.arcs[k][j] < Distance[j])//并且经过k顶点到达j顶点的路径总和，要小于不经过k顶点、直接到达j顶点的路径；
				{
					Distance[j] = min + G.arcs[k][j];//就把最短路径的值更新为经过k顶点的路径总和，也就是选更小的权值和；//Distance数组被更新
					Patharc[j] = k;//前驱顶点下标更新为k //Patharc数组被更新
				}
			}
		}
	}
	cout << endl;

	/*for (auto i : Patharc)
	{
		cout << i << " ";
	}
	cout << endl;*/ //调试用

	//打印
	cout << "Dijkstra算法求出的最短路径是：" << endl;
	for (int i = 0; i < G.vexnum; i++)
	{
		if (i != 0 && Distance[i] != INFINITY)
		{
			cout << "从顶点" << G.vexs[V0] << "到顶点" << G.vexs[i] << "，" << "最短路径权值是：" << Distance[i] << "，最短路径为：";

			int m = i;
			while (m != 0)
			{
				path.push(G.vexs[m]);//入栈
				m = Patharc[m];//m更新为m的前驱
			}
			path.push(G.vexs[V0]);

			while (!path.empty())
			{
				if (path.size() == 1)
				{
					cout << ();//打印最后一个栈元素
				}
				else
				{
					cout << () << "->";//打印栈顶
				}
				path.pop();//出栈
			}
			cout << endl;
		}
	}
	cout << endl;
}

int main()
{
	Dijkstra D0; //创建Dijkstra类的对象
	D0.ShortestPath_Dijkstra();//求最短路径

	system("pause");
	return 0;
}