Dijkstra算法基础

基本原理

Dijkstra算法是根据贪心算法实现的，首先找出当前点到所有能到达的点之间最短的距离，然后松弛一次继续循环。所谓松弛一次，就是在已经访问过的点中遍历一遍，看看有没有更近的，如果有更近的就更新距离。这样每次找最近的可达点+松弛遍历历史节点的操作，一直重复就能找到最短路径。
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。
它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。

算法步骤

1. 指定起始点s。
2. 找到起始点相邻的点开始记录
3. 将第二步记录的点作为起始点，如果第二部记录了多个点的话，那么按照与起始点s的距离或者权值，其中权值最小的优先依次作为起始点。
4. 直到遍历完图中所有的点。

过程图解

known表示是否已知，dv表示临时距离，这个距离实际上是使用已知定点作为中间顶点从s到v的最短路径长，pv记录一起dv变换的最后的顶点

初始配置表

v	Known	dv	pv
v1	0	0	0
v2	0	∞	0
v3	0	∞	0
v4	0	∞	0
v5	0	∞	0
v6	0	∞	0
v7	0	∞	0

在v1被声明为已知后的表

v	Known	dv	pv
v1	1	0	0
v2	0	2	v1
v3	0	∞	0
v4	0	1	v1
v5	0	∞	0
v6	0	∞	0
v7	0	∞	0

在v4被声明为已知后的表

v	Known	dv	pv
v1	1	0	0
v2	0	2	v1
v3	0	3	v4
v4	1	1	v1
v5	0	3	v4
v6	0	9	v4
v7	0	5	v4

在v2被声明为已知后的表

v	Known	dv	pv
v1	1	0	0
v2	1	2	v1
v3	0	3	v4
v4	1	1	v1
v5	0	3	v4
v6	0	9	v4
v7	0	5	v4

在v5然后v3被声明为已知后的表

v	Known	dv	pv
v1	1	0	0
v2	1	2	v1
v3	1	3	v4
v4	1	1	v1
v5	1	3	v4
v6	0	8	v3
v7	0	5	v4

在v7被声明为已知后的表

v	Known	dv	pv
v1	1	0	0
v2	1	2	v1
v3	1	3	v4
v4	1	1	v1
v5	1	3	v4
v6	0	6	v7
v7	1	5	v4

在v6被声明为已知后的表

v	Known	dv	pv
v1	1	0	0
v2	1	2	v1
v3	1	3	v4
v4	1	1	v1
v5	1	3	v4
v6	1	6	v7
v7	1	5	v4

至此我们可以得出从v1出发到所有点的最短路径

伪代码

Dijkstar算法的声明

typeof int Vertex;

struct TableEntry
{
	List Header; /*Adjacency list*/
	int Known;
	DistType Dist;
	Vertex Path;
}
/*Vertices are numbered from 0*/
#define NotAVertex(-1)
typeof struct TableEntry Table[NumVertex];

表初始化例程

void InitTable(Vertex Start, Graph G, Table T)
{
	int i;
	ReadGraph(G,T);
	for(i=0; i<NumVertex; i++)
	{
		T[i].Known = false;
		T[i].Dist = Infinity;
		T[i].Path = NotVertex;	
	}
	T[Start].dist = 0;
}

显示实际最短路径的例程

void PrintPath(Vertex V, Table T)
{
	if(T[V].Path != NotVertex)
	{
		PrintPath(T[V].Path,T);
		prithf("to");
	}
	printf("%v",V) /*%v is pseudocode*/
}

Dijkstra算法

void Dijkstra(Table T)
{
	Vertex V, W;
	for(; ;)
	{
		V = smallest unkonwn diatance vertex;
		if(V = NotVertex)
		{
			break;
		}
		T[V].Known = true;
		for each W adjacent to V
		{	
			if(!T[W].Known)
			{
				if(T[V].Dist + Cvw < T[W].Dist)
				{
					Decrease(T[W].Dist to T[V].Dist + Cvw);
					T[W].Path = V;
				}
			}
		}
	}
	
}

例题

有 N 个网络节点，标记为 1 到 N。 给定一个列表 times，表示信号经过有向边的传递时间。 times[i] = (u, v,w)，其中 u 是源节点，v 是目标节点， w 是一个信号从源节点传递到目标节点的时间。 现在，我们从某个节点 K发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1。
输入：times =[[2,1,1],[2,3,1],[3,4,1]], N = 4, K = 2
输出：2

算法思路
将所有节点分成两类：已确定从起点到当前点的最短路长度的节点，以及未确定从起点到当前点的最短路长度的节点（下面简称「未确定节点」和「已确定节点」）。

每次从「未确定节点」中取一个与起点距离最短的点，将它归类为「已确定节点」，并用它「更新」从起点到其他所有「未确定节点」的距离。直到所有点都被归类为「已确定节点」。

用节点 A「更新」节点 B 的意思是，用起点到节点 A 的最短路长度加上从节点 A 到节点 B 的边的长度，去比较起点到节点 B 的最短路长度，如果前者小于后者，就用前者更新后者。这种操作也被叫做「松弛」。

这里暗含的信息是：每次选择「未确定节点」时，起点到它的最短路径的长度可以被确定。

可以这样理解，因为我们已经用了每一个「已确定节点」更新过了当前节点，无需再次更新（因为一个点不能多次到达）。而当前节点已经是所有「未确定节点」中与起点距离最短的点，不可能被其它「未确定节点」更新。所以当前节点可以被归类为「已确定节点」。

class Solution {
public:
    int networkDelayTime(vector<vector<int>> &times, int n, int k) {
        const int inf = INT_MAX / 2;
        vector<vector<int>> g(n, vector<int>(n, inf));
        for (auto &t : times) {
            int x = t[0] - 1, y = t[1] - 1;
            g[x][y] = t[2];
        }

        vector<int> dist(n, inf);
        dist[k - 1] = 0;
        vector<int> used(n);
        for (int i = 0; i < n; ++i) {
            int x = -1;
            for (int y = 0; y < n; ++y) {
                if (!used[y] && (x == -1 || dist[y] < dist[x])) {
                    x = y;
                }
            }
            used[x] = true;
            for (int y = 0; y < n; ++y) {
                dist[y] = min(dist[y], dist[x] + g[x][y]);
            }
        }

        int ans = *max_element(dist.begin(), dist.end());
        return ans == inf ? -1 : ans;
    }
};