Dijkstra算法

Dijkstra算法是求解带权有向图中两点之间最短路径的经典算法，它采用贪心策略，维护一个向量dis用来表示从起点到其余顶点的路径“长度”。其主要原理如下：

1.定义一个向量dis[]，下标表示顶点，即dis[v]的值表示为从起点到v点的已知最短路径长度。初始化向量时，若v不是起点的相邻顶点，则dis[v]=∞，起点dis[0]=0。

2.定义向量edge[]，下标和值都表示顶点，假设edge[v]的值为w，则表示w→v为树中连接v和它的父结点的边（也是从起点s到v的最短路径上的最后一条边）。

3.根据有向图的边集中的信息维护向量值。假设存在边集v→w，权值为x，则dis[w] = min(w, w+x)。dis[w]的值更新（即w+x < w），则edge[w]的值也要同步更新为v。

定义一幅带权有向图的结构如下：

//带权有向图
struct EdgeWeightedDigraph
{
	size_t V; //顶点数
	size_t E; //边数
	map<int, forward_list<tuple<int, int, double>> adj; //改进后的邻接表，tuple存储的是边集
}

则Dijkstra算法的实现如下： 

struct Comp
{
	bool operator()(tuple<int, int, double> &a, tuple<int, int, double> &b)
	{
		return get<2>(a) > get<2>(b);
	}
};

void Dijkstra(EdgeWeightedDigraph &g)
{
    vector<double> dis(g.V, DBL_MAX);
    vector<int> edge(g.V);
    priority_queue<tuple<int, int, double>, vector<tuple<int, int, double>>, Comp> pq;

    //初始化起始顶点到各顶点的距离，初始化优先队列
    dis.at(0) = 0.0;
    for (const auto &i : g.adj.at(0))
    {
        dis.at(get<1>(i)) = get<2>(i);
        pq.push(i);
    }

    //从优先队列中取出权值最小的顶点，并维护向量dis和edge
    while (!pq.empty())
    {
        int v = get<0>(pq.top());
        pq.pop();
        for (const auto &e : g.adj.at(v))
        {
            if (dis.at(get<0>(e)) + get<2>(e) < dis.at(get<1>(e)))
            {
                dis.at(get<1>(e)) = dis.at(get<0>(e)) + get<2>(e);
                edge.at(get<1>(e)) = v;
                for (const auto &w : g.adj.at(get<1>(e)))
                {
                    pq.push(w);
                }
            }
        }
    }
    return edge;
}
/*
    Dijkstra函数执行完成后，dis[v]就是最短路径长度（若为DBL_MAX则不存在）
    若指定顶点v存在最短路径，对edge[v]进行遍历直到初始顶点，逆序输出就是最短路径
*/

上面的实现默认起始顶点为0，但实际上Dijkstra算法能够求解任意两个顶点之间的最短路径问题，即使是有环的加权有向图。另外，Dijkstra算法要求所有边的权值都是非负的。