数据结构算法题总结

python数据结构与算法——图的最短路径（Dijkstra算法）

# Dijkstra算法——通过边实现松弛
# 指定一个点到其他各顶点的路径——单源最短路径

# 初始化图参数
G = {0:{0:0,    1:2,    2:6,    3:4},
     1:{0:INF,  1:0,    2:3,    3:INF},
     2:{0:7,    1:INF,  2:0,    3:1},
     3:{0:5,    1:INF,  2:12,   3:0}
     }


# 每次找到离源点最近的一个顶点，然后以该顶点为重心进行扩展
# 最终的到源点到其余所有点的最短路径
# 一种贪婪算法

def Dijkstra(G,v0,INF=999):
    """ 使用 Dijkstra 算法计算指定点 v0 到图 G 中任意点的最短路径的距离
        INF 为设定的无限远距离值
        此方法不能解决负权值边的图
    """
    book = set()
    minv = v0

    # 源顶点到其余各顶点的初始路程
    dis = dict((k,INF) for k in G.keys())
    dis[v0] = 0

    while len(book)<len(G):
        book.add(minv)                                  # 确定当期顶点的距离
        for w in G[minv]:                               # 以当前点的中心向外扩散
            if dis[minv] + G[minv][w] < dis[w]:         # 如果从当前点扩展到某一点的距离小与已知最短距离      
                dis[w] = dis[minv] + G[minv][w]         # 对已知距离进行更新

        dis_min = INF                                       # 从剩下的未确定点中选择最小距离点作为新的扩散点
        for v in dis.keys():
            if v in book: continue
            if dis[v] < new: 
                dis_min = dis[v]
                minv = v
    return dis

distance = Dijkstra(G,0)
print(distance)

python数据结构与算法——图的最短路径（Floyd-Warshall算法）

使用Floyd-Warshall算法 求图两点之间的最短路径

不允许有负权边，时间复杂度高，思路简单

import numpy as np
# 城市地图（字典的字典）
# 字典的第1个键为起点城市，第2个键为目标城市其键值为两个城市间的直接距离
# 将不相连点设为INF,方便更新两点之间的最小值
INF = 99999
G = {0:{0:0,    1:2,    2:6,    3:4},
     1:{0:INF,  1:0,    2:3,    3:INF},
     2:{0:7,    1:INF,  2:0,    3:1},
     3:{0:5,    1:INF,  2:12,   3:0}
     }
path = [[ -1 for i in range(len(G))] for i in range(len(G))]

# 算法思想：
# 每个顶点都有可能使得两个顶点之间的距离变短
# 当两点之间不允许有第三个点时，这些城市之间的最短路径就是初始路径

# Floyd-Warshall算法核心语句
# 分别在只允许经过某个点k的情况下，更新点和点之间的最短路径
for k in G.keys():      # 不断试图往两点i,j之间添加新的点k，更新最短距离
    for i in G.keys():
        for j in G[i].keys():
            if G[i][j] > G[i][k] + G[k][j]:
                G[i][j] = G[i][k] + G[k][j]
                path[i][j] = k

for i in G.keys():
    print(list(G[i].values()))

print(np.array(path))