前言

Dijkstra算法是典型的求最短路径算法，常用于计算两点之间最短路径。

算法

算法具体思路是由起始点开始，层层递进向外搜索，直到找到终点为止。

可设起点 $v_0$，终点 $v_1$，点集合 $V=\{v_0\}$，两点距离 $d_{v_1,v_2}$,具体算法思路如下：

1. 在集合 $V$的所有点中寻找一点 $v_n$，使得 $v_n$的邻点 $v_m$满足 $v_m\notin V$，且路径 $d_{v_0,v_m}$（ $d_{v_0,v_m}=d_{v_0,v_n}+d_{v_n,v_m}$）最短
$\quad$
2. 将 $v_m$加入 $V$中，如果 $v_m=v_1$，返回 $d_{v_0,v_1}$，否则重新执行 第一步

例子

假设要从A到E，可知点集合 $V=\{A\}$，按照上面的算法开始寻路

1. 找到最短路径 AB， AB=AA+AB=10，将B插入 $V$
2. 找到最短路径 AD，AD=AA+AD=30，将D插入 $V$
3. 找到最短路径 DC，AC=AD+DC=50，将C插入 $V$
4. 找到最短路径 CE，AE=AC+CE=60，将E插入 $V$，E已是终点，返回AE

程序

//start：起始点
//end：终点
//topo：邻接矩阵
int Dijkstra(int start,int end,const vector<vector<int>> topo) {
	//集合V，false表示不在集合中
	vector<bool> V(topo.size(), false);
	
	//D中元素表示各点到起始点的位置
	vector<int> D(topo.size(), INT_MAX);

	//循环执行算法，n个点最多需要执行n-1次（除去了起始点）
	//v 为需要插入V集合中的点，初始为起始点
	//min 为D中最小距离，初始为0，起始点到自身为0
	for (int i = 1, v = start, min = 0; i < V.size(); ++i) {

		//每次插入节点前，先更新D中的距离
		for (int j = 0; j < topo[v].size(); ++j) {
			if (!V[v] && topo[v][j] < INT_MAX&&min + topo[v][j] < D[j]) {
				D[j] = min + topo[v][j];
			}
		}

		//更新V集合和min
		V[v] = true;
		min = INT_MAX;

		//在D中寻找最短路径，除去V中的节点
		for (int j = 0; j < D.size(); ++j) {
			if (!V[j] && D[j] < min) {
				min = D[j];
				v = j;
			}
		}

		//找到终点，返回距离
		if (v == end) return min;
	}

	//此情况说明起点没有到终点的路径，返回最大值
	return INT_MAX;
}

扩展

利用Dijkstra算法来寻找任意两点之间的距离，只需在上面的算法基础下进行小改动：

//topo：邻接矩阵
vector<vector<int>> Dijkstra(const vector<vector<int>> topo) {
	//最短距离矩阵path，初始化为最大值
	vector<vector<int>> path(topo.size(), vector<int>(topo.size(), INT_MAX));

	for (int i = 0; i < topo.size(); ++i) {
		//本身距离为0
		path[i][i] = 0;
		//点集合 V
		vector<bool> V(topo.size(), false);

		//此处算法和上面一致，j=i+1是因为之前已经找到最小距离了，无需重复寻找
		for (int j = i + 1, min = 0, v = i; j < topo[i].size(); ++j) {
			for (int k = i + 1; k < path[i].size(); ++k) {
				if (!V[k] && topo[v][k] < INT_MAX&&topo[v][k] + min < path[i][k]) {
					path[i][k] = topo[v][k] + min;
					path[k][i] = path[i][k];
				}
			}

			V[v] = true;
			min = INT_MAX;

			for (int k = i + 1; k < path[i].size(); ++k) {
				if (!V[k] && path[i][k] < min) {
					min = path[i][k];
					v = k;
				}
			}
		}
	}

	return path;
}