戴克斯特拉算法

上圖為戴克斯特拉演算法應用示意圖。
起點以左下角的紅點，目標是右上角的綠點，中間灰色的倒L型為障礙物。藍色空圈表示"暫定"，用以搜索下一步；已經填充顏色的表示探訪過，圖中顏色以紅到綠，越綠表示離起點越遠。所有節點都被均勻的探索。

戴克斯特拉算法通過保留目前為止所找到的每個頂點${\displaystyle v\in V}$從${\displaystyle s}$到${\displaystyle v}$的最短路徑來工作[1][2]。初始時，原點${\displaystyle s}$的路径权重被賦為 0 （即原点的实际最短路径=0）[1][2]。同時把所有其他頂點的路徑長度設為無窮大，即表示我們不知道任何通向這些頂點的路徑[1]。當算法結束時，${\displaystyle d[v]}$ 中儲存的便是從${\displaystyle s}$到${\displaystyle v}$的最短路徑，或者如果路徑不存在的話是無窮大[1]。

松弛操作是戴克斯特拉算法的基礎操作：如果存在一條從${\displaystyle u}$到${\displaystyle v}$的邊，那麼從${\displaystyle s}$到${\displaystyle v}$的一条新路径是將邊${\displaystyle w(u,v)\in E}$添加到從${\displaystyle s}$到${\displaystyle u}$的路徑尾部來拓展一條從${\displaystyle s}$到${\displaystyle v}$的路径[1][9]。這條路徑的長度是${\displaystyle d[u]+w(u,v)}$[1]。如果這個值比目前已知的${\displaystyle d[v]}$的值要小，那么可以用这个值來替代當前${\displaystyle d[v]}$中的值[1]。松弛邊的操作一直執行到所有的${\displaystyle d[v]}$都代表從${\displaystyle s}$到${\displaystyle v}$的最短路徑的长度值[1]。

算法維護兩個頂點集合${\displaystyle S}$和${\displaystyle Q}$[1][9]。集合${\displaystyle S}$保留所有已知实际最短路径值的頂點，而集合${\displaystyle Q}$則保留其他所有頂點[1][9]。集合${\displaystyle S}$初始狀態為空，而後每一步都有一個頂點從${\displaystyle Q}$移動到${\displaystyle S}$[1][9]。這個被選擇的頂點是${\displaystyle Q}$中擁有最小的${\displaystyle d[u]}$值的頂點[1][2]。當一個頂點${\displaystyle u}$從${\displaystyle Q}$中轉移到了${\displaystyle S}$中，算法對${\displaystyle u}$的每条外接邊${\displaystyle w(u,v)}$進行松弛[1]。

《算法导论》中给出了以下伪代码[1]：该伪代码计算并保留图${\displaystyle G}$中原点${\displaystyle s}$到每一顶点${\displaystyle v}$的最短距离${\displaystyle d[v]}$。其中，函数${\displaystyle Extract-Min(Q)}$将頂點集合${\displaystyle Q}$中有最小${\displaystyle d[u]}$值的頂點${\displaystyle u}$从${\displaystyle Q}$中删除并返回${\displaystyle u}$[1]。

 1  function Dijkstra(G, w, s)
 2   INITIALIZE-SINGLE-SOURCE(G, s)                //实际上的操作是将每个除原点外的顶点的${\displaystyle d[v]}$置为无穷大，${\displaystyle d[s]=0}$
 3   ${\displaystyle S\leftarrow \emptyset }$
 4   ${\displaystyle Q\leftarrow s}$                                //${\displaystyle Q}$是顶点${\displaystyle V}$的一个优先队列，以顶点的最短路径估计排序
 5   while(${\displaystyle Q\not =\emptyset }$)
 6       do ${\displaystyle u\leftarrow EXTRACT-MIN(Q)}$          //选取${\displaystyle u}$为${\displaystyle Q}$中最短路径估计最小的顶点
 7       ${\displaystyle S\leftarrow S\cup u}$
 8       for each vertex v ${\displaystyle \in Adj[u]}$
 9            do RELAX(u, v, w)            //松弛成功的结点会被加入到队列中

如果我們只對在${\displaystyle s}$和${\displaystyle t}$之間尋找一條最短路徑的話，我們可以在第5或第6行添加條件如果滿足${\displaystyle u=t}$的話終止程序[1][2]。

在肯尼·罗森所著的《离散数学及其应用》中给出了如下的另一份伪代码[2]：

 1 procedure Dijkstra(G：边全为正权的图）
 2   {G带有顶点${\displaystyle a=v_{0},v_{1},v_{2}...}$和若干边${\displaystyle w(v_{i},v_{j})}$}
 3    for ${\displaystyle i:=1}$ to n
 4       ${\displaystyle D(v_{i}):=\infty }$
 5    ${\displaystyle D(a):=0}$
 6    ${\displaystyle S:=\emptyset }$
 7    while ${\displaystyle z\notin S}$
 8    begin
 9          ${\displaystyle u:=}$不属于${\displaystyle S}$的${\displaystyle D(u)}$最小的一个顶点
 10        ${\displaystyle S:=S\cup \{u\}}$
 11        for 所有不属于${\displaystyle S}$的顶点${\displaystyle v}$
 12            if ${\displaystyle D(u)+w(u,v)<D(v)}$ then ${\displaystyle D(v):=D(u)+w(u,v)}$
 13    end{${\displaystyle D(z)=}$从a到z的最短路长度}

我們可以用大O符號將该算法的運行時間表示為邊數${\displaystyle |E|}$和頂點數${\displaystyle |V|}$的函數[1]。

对于任何基于顶点集${\displaystyle Q}$的实现，算法的运行时间是${\displaystyle O(|E|\cdot dk_{Q}+|V|\cdot em_{Q})}$，其中${\displaystyle dk_{Q}}$和${\displaystyle em_{Q}}$分别表示完成键的降序排列时间和从${\displaystyle Q}$中提取最小键值的时间[1]。

对于没有任何优化的戴克斯特拉算法，实际上等价于每次遍历了整个图的所有结点来找到Q中满足条件的元素（即寻找最小的頂點是${\displaystyle O(|V|)}$的），此外实际上还需要遍历所有的边一遍，因此算法的复杂度是${\displaystyle O(|V|^{2}+|E|)}$[2]。

對於邊數少於${\displaystyle |V|^{2}}$的稀疏圖來說，可以用鄰接表來更有效的實現该算法[1]。

可以使用一個二叉堆或者斐波納契堆用作優先隊列來尋找最小的頂點（${\displaystyle Extract-Min}$）以优化算法[14][15]。當用到二叉堆的時候，算法所需的時間為${\displaystyle O((|E|+|V|)\log |V|)}$[14]，斐波納契堆能提高一些性能，讓算法運行時間達到${\displaystyle O(|E|+|V|\log |V|)}$[4][15]。然而，使用斐波納契堆进行编程，有时会由于算法常数过大而导致速度没有显著提高[16]。

下面是一些戴克斯特拉算法经典实现的复杂度比较：

算法	最坏时间复杂度	发现者（按照论文发表时间从前向后排序）
使用鄰接表的戴克斯特拉算法	${\displaystyle O(|V|^{2})}$	莱索雷克及格雷等人[17]，艾兹赫尔·戴克斯特拉[9]，明蒂[18]，怀廷及希利尔[19]
使用二叉堆优化的戴克斯特拉算法	${\displaystyle O((|E|+|V|)\log |V|)}$	唐纳德·约翰逊[14]
使用斐波那契堆优化的戴克斯特拉算法	${\displaystyle O(|E|+|V|\log |V|)}$	迈克尔·弗雷德曼及羅伯特·塔揚[4][15]
	${\displaystyle O(|E|\log \log |L|)}$	唐纳德·约翰逊[20]，洛夫·卡尔松及帕特里西奥·波夫莱特[21]

艾兹赫尔·戴克斯特拉，戴克斯特拉算法的发现者

戴克斯特拉本人在他的论文中给出了一份简单的证明[9]。

《算法导论》使用循环不变式（数学归纳法）给出了如下的一份证明[1]：

已知一带权图${\displaystyle G=<V,E>}$，其加权函数${\displaystyle w}$的值非负，源点为${\displaystyle s}$。对该图运行戴克斯特拉算法，对所有${\displaystyle u\in V}$有${\displaystyle d[u]=\delta (s,u)}$。其中${\displaystyle d[u]}$表示u点的最短路径估计，${\displaystyle \delta (s,u)}$表示${\displaystyle s}$到${\displaystyle u}$点的最短路径。

证明：证明如下的循环不变式成立即可：在每次执行EXTRACT-MIN时，对每个顶点${\displaystyle u\in S}$，有${\displaystyle d[u]=\delta (s,u)}$成立即可。由于上界性质，在${\displaystyle u}$加入了${\displaystyle S}$之后，一旦有${\displaystyle d[u]=\delta (s,u)}$，则在后面的每次循环中都不会改变这个性质。

初始化：第一次循环前，${\displaystyle S=\emptyset }$，因此循环不变式显然成立。

保持：实际上要证明每一轮循环中加入到${\displaystyle S}$中的结点满足${\displaystyle d[u]=\delta (s,u)}$。利用反证法，假设${\displaystyle u}$是第一个不满足此条件的结点，考虑循环开始前的状况，首先${\displaystyle u}$一定不等于${\displaystyle s}$，这是显然的。其次${\displaystyle s}$一定有到${\displaystyle u}$的路径，否则路径为无穷大。那么假设在${\displaystyle u}$进入时，有最短路径${\displaystyle p=s->u}$，假设该路径上存在两个点${\displaystyle x}$，${\displaystyle y}$。${\displaystyle y\in V-S}$、${\displaystyle x\in S}$，且x是y的前驱，路径${\displaystyle p}$可以分解为${\displaystyle s-p_{1}->x->y-p_{2}->u}$（此处${\displaystyle -p_{1}->}$表示经过${\displaystyle p_{1}}$这条路径，后同），其中路径${\displaystyle p_{1}}$和路径${\displaystyle p_{2}}$可以为空。由于${\displaystyle u}$是第一个不满足${\displaystyle d[u]=\delta (s,u)}$的，又因为${\displaystyle x}$是满足该条件的，而且${\displaystyle (x,y)}$一定已经被松弛过了，所以${\displaystyle y}$是满足该条件的。

现在只需要推出矛盾，即可证明u不存在：${\displaystyle y}$在${\displaystyle u}$之前出现，而且图中所有权值非负，因此有${\displaystyle \delta (s,y)\leq \delta (s,u)}$，所以：
${\displaystyle d[y]\leq \delta (s,y)\leq \delta (s,u)\leq d[u]}$，但是由于${\displaystyle u}$和${\displaystyle y}$同时在${\displaystyle V-S}$中，因此${\displaystyle d[u]\leq d[y]}$，因此必有${\displaystyle d[y]=\delta (s,y)=\delta (s,u)=d[u]}$，也就证明了${\displaystyle u}$点不可能不满足该条件，上述假设为假，原命题得证。

终止：终止时，${\displaystyle Q=\emptyset }$，由于${\displaystyle Q=V-S}$，因此${\displaystyle V=S}$，因此对所有${\displaystyle u\in V}$有${\displaystyle d[u]=\delta (s,u)}$。

从鹿特丹到格罗宁根的最短路径是什么？实际上，这就是对于任意两座城市之间的最短路问题。解决这个问题实际上大概只花了我20分钟：一天早上，我和我的未婚妻在阿姆斯特丹购物，累了，我们便坐在咖啡馆的露台上喝咖啡，然后我就试了一下能否用一个算法解决最短路问题。正如我所说，这是一个20分钟的发现。不过实际上，我在3年后的1959年才把这个算法发表在论文上。即使现在来看这篇论文的可读性也非常高，这个算法之所以如此优雅，其中一个原因就是我没用笔纸就设计了它。后来我才知道，没用笔纸设计的优点之一是你不得不避免所有可避免的复杂问题。令我惊讶的是，这个算法最终成为我成名的基石之一。

——艾兹赫尔·戴克斯特拉在2001年的采访中提到戴克斯特拉算法的发现历程[8]

戴克斯特拉1956年在荷兰数学和计算机科学研究学会担任程序员时为了展示新型计算机ARMAC的功能曾思考过最短路径问题的解法[22]。他的目标是让不去实际计算的人也能理解这个问题和解决的方法，于是他在发现了这个算法之后在ARMAC上做了简单实验[8]。1959年，他正式将此算法发表在期刊上，该算法也成为了戴克斯特拉成名的基石之一[8][9]。

一个多区域OSPF网络，在OSPF中使用本算法计算最短路径

链路状态路由协议中需要计算最短路时常常要用到该算法，该算法在開放最短路徑優先和中间系统到中间系统协议中的相关应用是其在網絡路由中的典型實現[12]。

戴克斯特拉算法及其改进算法应用广泛，尤其是在寻路、交通、规划中[23][24][25][26]。

如果有已知信息可用來估計某一點到目標點的距離，則可改用A*搜尋算法，以減小最短路徑的搜索範圍，戴克斯特拉算法本身也可以看作是A*搜索算法的一个特例[27][28]。

戴克斯特拉算法本身采用了与Prim算法类似的贪心策略[9][29][30][31]。快速行进算法与戴克斯特拉算法同样有相似之处[32]。

以下是该算法使用堆优化的一个C++实现参考[33]：

#include<bits/stdc++.h> 
using namespace std; 
# define INF 0x3f3f3f3f 
  
// iPair ==> Integer Pair（整数对）
typedef pair<int, int> iPair; 
  
// 加边
void addEdge(vector <pair<int, int> > adj[], int u, 
                                     int v, int wt) 
{ 
    adj[u].push_back(make_pair(v, wt)); 
    adj[v].push_back(make_pair(u, wt)); 
} 
   
  
// 计算最短路
void shortestPath(vector<pair<int,int> > adj[], int V, int src) 
{ 
    // 关于stl中的优先队列如何实现，参考下方网址：
    // http://geeksquiz.com/implement-min-heap-using-stl/ 
    priority_queue< iPair, vector <iPair> , greater<iPair> > pq; 
  
    // 距离置为正无穷大
    vector<int> dist(V, INF); 
    vector<bool> visited(V, false);

    // 插入源点，距离为0
    pq.push(make_pair(0, src)); 
    dist[src] = 0; 
  
    /* 循环直到优先队列为空 */
    while (!pq.empty()) 
    { 
        // 每次从优先队列中取出顶点事实上是这一轮最短路径权值确定的点
        int u = pq.top().second; 
        pq.pop(); 
        if (visited[u]) {
            continue;
        }
        visited[u] = true;
        // 遍历所有边
        for (auto x : adj[u]) 
        { 
            // 得到顶点边号以及边权
            int v = x.first; 
            int weight = x.second; 
  
            //可以松弛
            if (dist[v] > dist[u] + weight) 
            { 
                // 松弛 
                dist[v] = dist[u] + weight; 
                pq.push(make_pair(dist[v], v)); 
            } 
        } 
    } 
  
    // 打印最短路
    printf("Vertex Distance from Source\n"); 
    for (int i = 0; i < V; ++i) 
        printf("%d \t\t %d\n", i, dist[i]); 
} 
int main() 
{ 
    int V = 9; 
    vector<iPair > adj[V]; 
    addEdge(adj, 0, 1, 4); 
    addEdge(adj, 0, 7, 8); 
    addEdge(adj, 1, 2, 8); 
    addEdge(adj, 1, 7, 11); 
    addEdge(adj, 2, 3, 7); 
    addEdge(adj, 2, 8, 2); 
    addEdge(adj, 2, 5, 4); 
    addEdge(adj, 3, 4, 9); 
    addEdge(adj, 3, 5, 14); 
    addEdge(adj, 4, 5, 10); 
    addEdge(adj, 5, 6, 2); 
    addEdge(adj, 6, 7, 1); 
    addEdge(adj, 6, 8, 6); 
    addEdge(adj, 7, 8, 7); 
  
    shortestPath(adj, V, 0); 
  
    return 0; 
}

以下是该算法Python的一个实现:

import sys
max = sys.maxsize

vertices_number = 6
adjacency_matrix = [
    [0, 1, 10, -1, -1, 2],
    [10, 0, 1, -1, -1, -1],
    [1, 10, 0, -1, -1, -1],
    [-1, -1, 2, 0, 1, 10],
    [-1, -1, -1, 10, 0, 1],
    [-1, -1, -1, 1, 10, 0]]
start = []
dest = ["2", "5"]
key = []


def init_keys(s: int):
    global key
    key = [ max ] * vertices_number
    key[s] = 0


def dijkstra(from_vertex, dest_vertex):
    fid = int(from_vertex) - 1
    tid = int(dest_vertex) - 1
    init_keys(fid)
    rel = [fid]
    min_vertex = fid
    hop_path = {}

    while len(rel) <= vertices_number and min_vertex != tid:
        for i in range(vertices_number):
            if i != min_vertex and i not in rel and \
                adjacency_matrix[min_vertex][i] > 0 \
                and key[i] > key[min_vertex] + adjacency_matrix[min_vertex][i]:
                key[i] = key[min_vertex] + adjacency_matrix[min_vertex][i]
                hop_path.update({i + 1: {"from": min_vertex + 1, "cost": adjacency_matrix[min_vertex][i]}})

        if min_vertex not in rel:
            rel.append(min_vertex)

        min_vertex = tid
        for i in range(vertices_number):
            if i not in rel and key[i] < key[min_vertex]:
                min_vertex = i

    if len(hop_path) == 0 or int(dest_vertex) not in hop_path:
        return -1, -1
    else:
        next_hop = int(dest_vertex)
        path_str = dest_vertex
        while hop_path[next_hop]["from"] != int(from_vertex):
            cost = hop_path[next_hop]["cost"]
            next_hop = hop_path[next_hop]["from"]
            path_str =  "{} -({})-> {}".format(str(next_hop), cost ,path_str)
        path_str =  "{} -({})-> {}".format(str(hop_path[next_hop]["from"]), hop_path[next_hop]["cost"], path_str)

        return key[tid], path_str



def find_shortest_router():
    for s in start:
        print("Forwarding Table for {}".format(s))
        print("{:>10} {:>10}       {}".format("To", "Cost", "Path"))
        for d in dest:
            c, n = dijkstra(s, d)
            print("{:>10} {:>10}       {}".format(d, c, n))


def main():
    for i in range(1, vertices_number + 1):
        if str(i) not in dest:
            start.append(str(i))
    find_shortest_router()

if __name__ == '__main__':
    main()

• 图论
• A*搜尋演算法
• 贝尔曼-福特算法
• 宽度优先搜索
• Flood fill
• Floyd-Warshall算法
• 最长路径问题

维基共享资源上的相关多媒体资源：戴克斯特拉算法

• 迪科斯彻算法分解演示视频（优酷） （页面存档备份，存于）
• Animation of Dijkstra's algorithm （页面存档备份，存于）
• The Boost Graph Library (BGL) （页面存档备份，存于）
• Interactive Implementation of Dijkstra's Algorithm （页面存档备份，存于）
• Shortest Path Problem: Dijkstra's Algorithm
• Dijkstra算法使用TDD的一个实现 （页面存档备份，存于）
• Graphical explanation of Dijkstra's algorithm step-by-step on an example （页面存档备份，存于）