《算法导论》24.3-Dijkstra(迪杰斯特拉)算法（含C++代码）

---

一、相关含义

1、Dijkstra算法在运行过程中维持的关键信息是一组结点集合S。从源结点s到该集合中每个结点之间的最短路径已经被找到。算法重复从结点集V- S中选择最短路径估计最小的结点u,将u加入到集合S，然后对所有从u发出的边进行松弛。在下面给出的实现方式中，我们使用一个最小优先队列Q来保存结点集合，每个结点的关键值为其d值。
2、要求：对于所有的边(u,v)∈E,都有w(u,v)>=0.

二、伪代码：

DIJKSTRA.(G,w,s)
INITIALIZE-SINGLE-SOURCE(G,s)//对d和π进行初始化
S = ∅	//S初始为空集
Q = G.V	//最小优先队列Q初始为G的所有结点
while Q != ∅
	u = EXTRACT-MIN(Q)	//结点u是所有结点的最短路径估计
	S = S∪{u}
	for each vertex v ∈ G.Adj[u]
		RELAX(u,v,w)

初始化
INITIALIZE-SINGLE-SOURCE(G,s)
for each vertex v ∈ G.V
	v.d = ∞
	v.π = NIL
s.d = 0

RELAX(u,v,w)
//在松弛操作中，如果一个点v的最短路径值大于u.d加上（u,v）的权重
if v.d > u.d + w(u,v)
	v.d = u.d + w(u,v)//更新v.d
	v.π = u	//让u直接成为v的前驱结点，因为u之前不是后者的前驱

三、C++代码

//这个程序做了很多具象化操作，就比如直接给出结点数量之类的，可以在用的时候适当修改。
#include <iostream>
#include<vector>
using namespace std;
struct Vertex
{
	int id;
	int d;//最短路径估计
	int pre;//前驱结点
	bool flag;
	Vertex(int i=99999,int pr = NULL, int di = 99999,int fl = 0) :id(i),pre(pr), d(di),flag(fl) {}
};

//对边进行定义
struct Edge
{
	//起始点和终点
	Vertex start;
	Vertex final;
	int dist;//路程 
};

//带距离的有向图
struct Graph {
	//顶点数和边数
	int V;
	int E;
	Edge* edge;//指针
};

//邻接矩阵（直接把数字写好了）横坐标为起始边
void AdjMatrix(int adjMat[][5])  //邻接矩阵表示法
{
    for (int i = 0; i < 5; i++)   //初始化邻接矩阵
        for (int j = 0; j < 5; j++)
        {
            adjMat[i][j] = 99999; //初始化为99999
        }
    //对称矩阵，一共十条边
    adjMat[0][1] = 10;  adjMat[0][3] = 5;
    adjMat[1][2] = 1;  adjMat[1][3] = 2; 
    adjMat[2][4] = 1; 
    adjMat[3][1] = 3; adjMat[3][2] = 9; adjMat[3][4] = 2;
    adjMat[4][0] = 7; adjMat[4][2] = 6; 
}

//创建图
Graph* CreateGraph(int v, int e)
{
	Graph* graph = new Graph();
	graph->E = e;
	graph->V = v;
	graph->edge = new Edge();
	return graph;
}

//具体算法
void Dijkstra(Graph* G,int adjMat[][5]) {
	vector<Vertex*>V;
	//默认0为源头
	Vertex* v0 = new Vertex(0,NULL,0,1);
	V.push_back(v0);
	for (int i = 1; i < 5; i++) {
		Vertex* v = new Vertex(i,NULL,99999,0);
		V.push_back(v);
	}
	int count = 0;//计数器
	int minIndex = 0;
	//循环四次
	while (count < 4) {
		for (int k = 1; k < 5; k++) {
			if (adjMat[minIndex][k] != 99999) {
				//松弛操作
				if (V[k]->d > V[minIndex]->d + adjMat[minIndex][k]) {
					V[k]->d = V[minIndex]->d + adjMat[minIndex][k];
					V[k]->pre = V[minIndex]->id;
				}
			}
		}
		//找到最小距离估计值
		int min = 99999;
		int temp = minIndex;
		for (int j = 0; j < 5; j++) {
			if (V[j]->d < min&&V[j]->flag==0)
			{
				min = V[j]->d;
				temp = j;
			}
		}
		minIndex = temp;
		//代表V的第minIndex元素已经被使用
		V[minIndex]->flag = 1;
		count++;
	}
	//打印
	for (int i = 0; i < 5; i++) {
		cout << V[i]->d << " ";
	}
}

//程序里暂时没有用到Edge，因为用邻接矩阵代替了。
int main()
{
	Graph*graph = CreateGraph(5,10);
	int adjMat[5][5] = { 0 };
	AdjMatrix(adjMat);
	Dijkstra(graph, adjMat);
	return 0;
}

总结以及一些拓展

Dijkstra算法的原理

Dijkstra算法是一种用于求解单源最短路径问题的贪心算法。它以一个源结点作为起点，通过不断扩展已经找到的最短路径集合，逐步找到从源结点到其他所有结点的最短路径。

Dijkstra算法的基本思想是维护一个结点集合S，其中包含从源结点s到每个结点之间的最短路径已经被找到的结点。算法通过不断选择最短路径估计最小的结点u，并将其加入到集合S中，然后对从u发出的边进行松弛操作。直到所有结点都被加入到集合S中，最短路径就被找到了。

松弛操作

在Dijkstra算法的每一次迭代中，都会对从当前结点u发出的边进行松弛操作。松弛操作的目的是通过更新结点的最短路径估计值，逐步逼近真实的最短路径。

在上面代码中，已经实现了松弛操作的函数RELAX(u,v,w)——在该函数中，如果结点v的最短路径估计值大于结点u的最短路径估计值加上边(u,v)的权重，则更新结点v的最短路径估计值为结点u的最短路径估计值加上边(u,v)的权重，并将结点u设为结点v的前驱结点。

最小优先队列

在Dijkstra算法中，需要选择最短路径估计值最小的结点来扩展已经找到的最短路径集合。为了高效地选择最小值，可以使用最小优先队列。

最小优先队列是一种数据结构，它可以维护一组元素，并且能够快速地找到其中的最小值。在你的代码中，使用了一个最小优先队列Q来保存结点集合，每个结点的关键值为其最短路径估计值d。在每次选择最短路径估计值最小的结点时，可以使用EXTRACT-MIN(Q)操作。

拓展知识示例代码

下面是一个使用Python语言实现Dijkstra算法的示例代码：

import heapq

def dijkstra(graph, start):
    distances = {vertex: float('inf') for vertex in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_vertex = heapq.heappop(priority_queue)

        if current_distance > distances[current_vertex]:
            continue

        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

在这个示例代码中，使用了一个字典来表示图，其中键表示结点，值表示该结点到其他结点的边及其权重。使用最小堆（即优先队列）来选择最短路径估计值最小的结点。