Dijkstra算法改造

Problem

G是一个n个顶点和e条边的带权有向图,各边的权值为0到N-1之间的整数,N为一非负整数。修改Dijkstra算法使其能在O(Nn+e)时间内计算出从源到所有其他顶点之间的最短路径长度。

Analysis

核心

Dijkstra算法, 最重要的是环节是查找下一个最短路径.

常用的算法有

  • 暴力检索 $ O(n^2 )$
  • 堆排序, 算法复杂度是 $ O(n*log(n ))$
  • 优先队列算法

这里我们给出的算法时间复杂度的要求是$ O(N*n + e )$

问题前提条件设定了一个限制, 就是各边权值最大限定了 $ N $ , 那么也就是说起点到其他所有点的最长长度为 $ N * (n-1) $

其实到不到的(因为题目里权值的取值为 0->N-1).

借用桶排序的思想,定义一个List dis_bucket_list

数据结构就是二维List(在Python里面的使用比较方便) !

《Dijkstra算法改造》 IMG_20170105_163720.jpg

dis_bucket_ptr 是指向当前dis_bucket_list 的下标

检索下一个最小的顶点的时候, 如果元素为空, 则右移. 不为空则pop第一个元素

获取最小的节点的时候, 获取所有与该节点直接相连的元素集合, 即next_node_list[i] 里面的元素

然后遍历其中的所有元素, 更新最小距离, 同步bucket

然后dis_bucket_ptr继续查找下一个元素

核心代码

# 只需要遍历 node_num -1 次
for i in range(node_num-1):
    # 获取桶中下一个距离最小的节点
    node_cur = find_next_minimum_dis()
    # 获取该节点直接相连的所有节点集合
    node_list = next_node_list[node_cur]
    
    # 遍历node_list,更新最小值,同步
    for node_next in node_list:
        dis_temp = min_distance_list[node_cur] + graph_matrix[node_cur][node_next]
        if(min_distance_list[node_next] > dis_temp):
            # 父节点更新为node_next
            parent_node_list[node_next] = node_cur
            # 更新节点在桶中的位置
            update_distance(node_next, dis_temp)

数据结构

graph_matrix

二维数组, row代表其实节点(v), col代表终点(u), 值代表权重(w)

----Graph Matrix----

   0   10    5  INF  INF 
 INF    0    2    1  INF 
 INF    3    0    9    2 
 INF  INF  INF    0    4 
   7  INF  INF    6    0 

next_node_list

二维list, 相当于graph_matrix的压缩版, 用于表示从该节点能直接到达的节点的集合, 减少遍历次数


----Next Node List----

0 : [1, 2]
1 : [2, 3]
2 : [1, 3, 4]
3 : [4]
4 : [0, 3]

dis_bucket_list

做如下初始化操作

  • 将第一个元素置为起点
  • INF位置上放置其他所有节点
  • 其他桶中置为空

利用给出的最大权重 W的限制条件, 得出最大

利用给出的最大权重 W的限制条件, 得出最大

Code

'''
    初始化图
'''
def init_graph(edge_list):
    # 二维矩阵用于记录 每条边 v->u, weight
    graph_matrix = [[ infinity for col in range(node_num)] for row in range(node_num)]
    
    # 记录该节直接到达的下一个节点的所有node集合
    next_node_list = [[] for row in range(node_num)]

    # 对角的距离设为 0
    for node_i in range(node_num):
        graph_matrix[node_i][node_i] = 0

    # 遍历所有的边
    for [e_origin, e_terminal, e_weight] in edge_list:
        graph_matrix[e_origin][e_terminal] = e_weight  # 将边的信息记录到 graph_matrix 中
        next_node_list[e_origin].append(e_terminal)  # 添加e_terminal至e_origin 对应的end_point中
    
    return graph_matrix, next_node_list

'''
    更新node_id与起始节点的最小距离
'''
def update_distance(node,distance):
    old_dis = min_distance_list[node]
    min_distance_list[node] =  distance  # 更新最小距离
    # 更新dis_bucket_list
    dis_bucket_list[old_dis].remove(node)
    dis_bucket_list[distance].append(node)

'''
    找出dis_bucket_list中的下一个最小元素
'''
def find_next_minimum_dis():
    global dis_bucket_ptr
    # 寻找下一个元素不为空的桶
    while(dis_bucket_list[dis_bucket_ptr] == [] and dis_bucket_ptr <= max_distance):
        dis_bucket_ptr = dis_bucket_ptr + 1
    
    if (dis_bucket_ptr == infinity):
        return -1

    return dis_bucket_list[dis_bucket_ptr].pop()


node_num = 5 # 定点数 - (N)
max_weight = 10  # 最大边权重 (W)
max_distance = (node_num - 1)*max_weight # 两个节点的最长距离
infinity = max_distance + 1 # 无限大定义为 max_distance+1

'''
    edge_list 结构说明
    [v, u, w]
    v: 边的起始点
    u: 边的终点
    w: 权重
'''
edge_list = [
    [0, 1, 10],
    [0, 2, 5],
    [1, 2, 2],
    [1, 3, 1],
    [2, 1, 3],
    [2, 3, 9],
    [2, 4, 2],
    [3, 4, 4],
    [4, 0, 7],
    [4, 3, 6]
]

# 起点
node_start = 0

graph_matrix, next_node_list = init_graph(edge_list) # 初始化graph_matrix 和 next_node_list

dis_bucket_list = [[] for i in range(infinity+1)] # 距离桶列表的初始化
dis_bucket_list[infinity] = [i for i in range(0,node_num)] # 将所有的节点挂载到infinity的位置上
dis_bucket_list[infinity].remove(node_start)
dis_bucket_list[0].append(node_start)

dis_bucket_ptr = 0 # 距离桶的指针, 指向dis_bucket_list的坐标

min_distance_list = [infinity]*node_num # 记录当前的最小距离
parent_node_list = [-1] * node_num # 顶点的前驱节点
min_distance_list[node_start] = 0


for i in range(node_num):
    node_cur = find_next_minimum_dis()
    node_list = next_node_list[node_cur]

    for node_next in node_list:
        dis_temp = min_distance_list[node_cur] + graph_matrix[node_cur][node_next]
        if(min_distance_list[node_next] > dis_temp):
            parent_node_list[node_next] = node_cur
            update_distance(node_next, dis_temp)

print('\n----Graph Matrix----\n')
for row in range(node_num):
    temp_str = ""
    for col in range(node_num):
        if(graph_matrix[row][col] == infinity):
            temp_str += " INF "
        else:
            temp_str += ' %3d '%graph_matrix[row][col]
    print(temp_str)

print('\n----Next Node List----\n')
for i in range(len(next_node_list)):
    print("%d : %s"%(i, next_node_list[i]))

print("\n----Result----\n")

for i in range(node_num):
    if i == node_start:
        continue
    print("%d -> %d  min_dis: %3d; parent: %d;"%(node_start,i, min_distance_list[i], parent_node_list[i]))

Result

测试数据

'''
    edge_list 结构说明
    [v, u, w]
    v: 边的起始点
    u: 边的终点
    w: 权重
'''
edge_list = [
    [0, 1, 10],
    [0, 2, 5],
    [1, 2, 2],
    [1, 3, 1],
    [2, 1, 3],
    [2, 3, 9],
    [2, 4, 2],
    [3, 4, 4],
    [4, 0, 7],
    [4, 3, 6]
]

运行结果


----Graph Matrix----

   0   10    5  INF  INF 
 INF    0    2    1  INF 
 INF    3    0    9    2 
 INF  INF  INF    0    4 
   7  INF  INF    6    0 

----Next Node List----

0 : [1, 2]
1 : [2, 3]
2 : [1, 3, 4]
3 : [4]
4 : [0, 3]

----Result----

0 -> 1  min_dis:   8; parent: 2;
0 -> 2  min_dis:   5; parent: 0;
0 -> 3  min_dis:   9; parent: 1;
0 -> 4  min_dis:   7; parent: 2;

Reference

http://115.28.48.229/wordpress/?p=77

    原文作者:1Z实验室阿凯
    原文地址: https://www.jianshu.com/p/453c8acb4505
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞