Dijkstra单源最短路朴素算法

Dijkstra单源最短路朴素算法

基于无优化的朴素算法，这里使用邻接矩阵的方法存储路径（空间复杂度高）

Dijkstra单源最短路的算法原理如下：

从起始点s开始，每次依据贪心选取最近连通点且未被访问过的点，移动到该点上，更新最短路径，直到把所有点都访问完

初始化时，需要将s起始点到所有点的dis[i]距离，赋值为极大值，表示不能连通从s出发

for (int i = 0; i <= n; i++)
		dis[i] = 1e9;

枚举当前能连通的所有点，记录最短路径点min_node（初始化为0），如果不能更新最短路径点，则说明遍历完了所有的点

有：

if (min_node == 0) break;

并对其进行标记，表示以及被访问过了

vis[min_node] = 1;

遍历所有点，更新最短路径：

for (int i = 1; i <= n; i++)
	if (dis[i] > dis[min_node] + g[min_node][i])
		dis[i] = dis[min_node] + g[min_node][i];//如果当前点可以组成更短的路径，那就更新
//或写成
for (int i = 1; i <= n; i++)
		dis[i] = min(dis[i], dis[min_node] + g[min_node][i]);

以上图为例：有参数如下

4 6 1 // 四个节点，六条边，从一号点开始
 
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

我们来逐步推导一遍

初始化：dis[]={1e9, 0, 1e9, 1e9, 1e9}

第一轮：

遍历所有未访问的点，\(1\)号点到自身的路径为 \(0\)，为最短，min_node为\(1\)

标记\(1\)号点，接着遍历所有节点并更新路径为：dis[]={1e9, 0, 2, 5, 4}

第二轮：

遍历所有未访问的点，\(2\)号点到\(1\)号点的路径为 \(2\)，为最短，min_node为\(2\)

标记\(2\)号点，接着遍历所有节点并更新路径为：dis[]={1e9, 0, 2, 4, 3}

第三轮：

遍历所有未访问的点，\(4\)号点到\(1\)号点的路径为 \(3\)，为最短，min_node为\(4\)

标记\(4\)号点，接着遍历所有节点并更新路径为：dis[]={1e9, 0, 2, 4, 3}

第四轮：

遍历所有未访问的点，\(3\)号点到\(1\)号点的路径为 \(4\)，为最短，min_node为\(3\)

标记\(4\)号点，接着遍历所有节点并更新路径为：dis[]={1e9, 0, 2, 4, 3}

第五轮：

遍历所有未访问的点，可以发现所有的点都被遍历过了，于是退出循环

---

Dijkstra是一种基于贪心的最短路径算法，但是他不能处理存在负边权的情况，这是因为如果存在负权边，那就有可能先通过不是距起始点最近的一个次优点，再通过这个负权边，使得路径之和更小

如上图所示，从S点出发，贪心会选择S -> B，而不是全局最优的S -> A -> B，这就发生了错误

• 贪心的正确性这里不做赘述，详情可自行查看：

最短路 - OI Wiki

朴素算法如下：

bool vis[N];
int dis[N];
int g[N][N];//邻接矩阵存储路径
 
void dijkstra(int s) {
	for (int i = 0; i <= n; i++)
		dis[i] = 1e9;//赋值极大值
	dis[s] = 0;//起始点被访问过
	while (true)
	{
		int min_node = 0, min_mem = 1e9;
		for (int i = 1; i <= n; i++) {
			if (!vis[i] && min_mem > dis[i])
			{
				min_node = i;
				min_mem = dis[i];
			}
		}//找到最短路径点，记录编号
		
		if (min_node == 0) break;
		vis[min_node] = 1;
		for (int i = 1; i <= n; i++)
			if (dis[i] > dis[min_node] + g[min_node][i])
				dis[i] = dis[min_node] + g[min_node][i];
	}
}