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里面的使用比较方便) !
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