Dijkstra算法求解图中最短路径距离

前言：这里是自学内容，讲解的是用python来实现Dijkstra算法，算是入门求解图中最短路径问题的典型案例。

---

算法简介：

        迪杰斯特拉（Dijkstra）算法是一个按照路径长度递增的次序产生的最短路径算法。下图为带权值的有向图，作为程序中的实验数据

       其中，带权值的有向图采用邻接矩阵graph来进行存储，在计算中就是采用n*n的二维数组来进行存储，v0-v5表示数组的索引编号0-5，二维数组的值表示节点之间的权值，若两个节点不能通行，比如，v0->v1不能通行，那么graph[0,1]=+∞ （采用计算机中最大正整数来进行表示）。那如何求解从v0每个v节点的最短路径长度呢?

迪杰斯特拉（Dijkstra）算法主要是针对没有负值的有向图，求解其中的单一起点到其他顶点的最短路径算法

Dijkstra算法实现过程：

1）寻找未被遍历的节点中权值最下的节点

2）将寻找到的最小权值节点更新为已被遍历，在运筹学中记录为被固定标号，其余为临时性标号

3）更新权值，算法将起始的节点定位于当前寻找到的最小权值节点处

4）通过比较节点处向其他节点联通时所产生的权值与初始权值做比较，更新权值

def dijkstra(graph, startIndex, path, cost, max):                                                      
    """                                                                                                
    求解各节点最短路径，获取path，和cost数组，                                                                          
    path[i] 表示vi节点的前继节点索引，一直追溯到起点。                                                                     
    cost[i] 表示vi节点的花费                                                                                  
    V[i] 用于记录是否被标过号                                                                                    
    """                                                                                                
    lenth = len(graph)                                                                                 
    v = [0] * lenth                                                                                    
    # 初始化 path，cost，V                                                                                  
    for i in range(lenth):                                                                             
        if i == startIndex:                                                                            
            v[startIndex] = 1                                                                          
        else:                                                                                          
            cost[i] = graph[startIndex][i]                                                             
            path[i] = (startIndex if (cost[i] < max) else -1)                                          
    print (v, cost, path)                                                                              
    for i in range(1, lenth):                                                                          
        print("-------------","第{0}次".format(i))                                                       
        minCost = max                                                                                  
        curNode = -1                                                                                   
        for w in range(lenth):                                                                         
            if v[w] == 0 and cost[w] < minCost:                                                        
                minCost = cost[w]                                                                      
                curNode = w                                                                            
                print("最小成本",minCost)                                                                  
                print("当前节点",curNode)                                                                  
        # for 获取最小权值的节点                                                                                
        if curNode == -1: break                                                                        
        # 剩下都是不可通行的节点，跳出循环                                                                             
        v[curNode] = 1                                                                                 
        print("已经遍历的节点",v)                                                                             
        for w in range(lenth):                                                                         
            if v[w] == 0 and (graph[curNode][w] + cost[curNode] < cost[w]):                            
                cost[w] = graph[curNode][w] + cost[curNode] # 更新权值                                     
                path[w] = curNode # 更新路径                                                               
                print("更新权值",cost)                                                                     
                print("前级节点",path)                                                                     
                                                                                                       
        # for 更新其他节点的权值（距离）和路径                                                                         
    return path ,cost                                                                                  
                                                                                                       
if __name__ == '__main__':                                                                             
    max = 2147483647                                                                                   
    graph = [                                                                                          
        [max, max, 10, max, 30, 100],                                                                  
        [max, max, 5, max, max, max],                                                                  
        [max, max, max, 50, max, max],                                                                 
        [max, max, max, max, max, 10],                                                                 
        [max, max, max, 20, max, 60],                                                                  
        [max, max, max, max, max, max],                                                                
        ]                                                                                              
    path = [0] * 6                                                                                     
    cost = [0] * 6                                                                                     
    print (dijkstra(graph, 0, path, cost, max))                                                         



********************************************************************************
[1, 0, 0, 0, 0, 0] [0, 2147483647, 10, 2147483647, 30, 100] [0, -1, 0, -1, 0, 0]
------------- 第1次
最小成本 10
当前节点 2
已经遍历的节点 [1, 0, 1, 0, 0, 0]
更新权值 [0, 2147483647, 10, 60, 30, 100]
前级节点 [0, -1, 0, 2, 0, 0]
------------- 第2次
最小成本 60
当前节点 3
最小成本 30
当前节点 4
已经遍历的节点 [1, 0, 1, 0, 1, 0]
更新权值 [0, 2147483647, 10, 50, 30, 100]
前级节点 [0, -1, 0, 4, 0, 0]
更新权值 [0, 2147483647, 10, 50, 30, 90]
前级节点 [0, -1, 0, 4, 0, 4]
------------- 第3次
最小成本 50
当前节点 3
已经遍历的节点 [1, 0, 1, 1, 1, 0]
更新权值 [0, 2147483647, 10, 50, 30, 60]
前级节点 [0, -1, 0, 4, 0, 3]
------------- 第4次
最小成本 60
当前节点 5
已经遍历的节点 [1, 0, 1, 1, 1, 1]
------------- 第5次
([0, -1, 0, 4, 0, 3], [0, 2147483647, 10, 50, 30, 60])