def dijkstra(self, src, dest):
V = self.V
dist = []
minHeap = Heap()
directions = [] ## for directions - revathi
parents = [-1] * (len(self.nodes)) ## for path - revathi
path = []
path.append(src)
for v in range(V):
dist.append(sys.maxsize)
minHeap.array.append(minHeap.newMinHeapNode(v, dist[v]))
minHeap.pos.append(v)
minHeap.pos[src] = src
dist[src] = 0
minHeap.decreaseKey(src, dist[src])
minHeap.size = V
#TODO: modify to show proper route -- done revathi
while minHeap.isEmpty() == False:
newHeapNode = minHeap.extractMin()
u = newHeapNode[0]
for pCrawl in self.graph[(u)]:
v = pCrawl[0]
if minHeap.isInMinHeap(v) and dist[
u] != sys.maxsize and pCrawl[1] + dist[u] < dist[v]:
dist[v] = pCrawl[1] + dist[u]
parents[v] = u
minHeap.decreaseKey(v, dist[v])
path = self.getSolution(dist, parents, src, dest)
directions, directions_text = self.getDirections(path, dest)
return round(dist[dest], 2), path, directions, directions_text
def prims(graph, n, m, startVertex):
minHeap = Heap()
dist = {}
parent = []
for x in graph.vertices1:
minHeap.array.append(minHeap.addNode(x[0], sys.maxsize))
dist[x[0]] = int(sys.maxsize)
minHeap.pos.append(x[0])
parent.append(-1)
minHeap.pos[startVertex] = startVertex
dist[startVertex] = 0
minHeap.decreaseKey(startVertex, dist[startVertex])
minHeap.size = n
while minHeap.size != 0:
root = minHeap.extractMin()
u = root[0]
for adj in graph.graph[u]:
v = adj[0]
distV = int(adj[1])
if minHeap.isPresent(v) and (distV < dist[v]):
dist[v] = distV
parent[v] = u
minHeap.decreaseKey(v, dist[v])
graph.printMSTEdges(dist, parent, n, startNode)
def PrimLocal(self):
# 存每个节点的key值
data = self.leftData
V = len(data)
edges = {}
key = []
# 记录构造的MST
parent = []
# 建立最小堆
minHeap = Heap()
# 初始化以上三个数据结构
for v in range(V):
parent.append(-1) #初始时，每个节点的父节点是-1
key.append(float('inf')) #初始时，每个节点的key值都是无穷大
minHeap.array.append(minHeap.newMinHeapNode(v, key[v]))
#newMinHeapNode方法返回一个list，包括节点id、节点key值
#minHeap.array成员存储每个list，所以是二维list
#所以初始时堆里的每个节点的key值都是无穷大
minHeap.pos.append(v)
minHeap.pos[0] = 0 #不懂这句，本来pos的0索引元素就是0啊
key[0] = 0 #让0节点作为第一个被挑选的节点
minHeap.decreaseKey(0, key[0])
#把堆中0位置的key值变成key[0]，函数内部重构堆
# 初始化堆的大小为V即节点个数
minHeap.size = V
# print('初始时array为',minHeap.array)
# print('初始时pos为',minHeap.pos)
# print('初始时size为',minHeap.size)
while minHeap.isEmpty() == False:
# 抽取最小堆中key值最小的节点
newHeapNode = minHeap.extractMin()
# print('抽取了最小元素为',newHeapNode)
u = newHeapNode[0]
for i in range(minHeap.size):
id = minHeap.array[i][0]
dist = max(1 / 42, data[u].dtw_dist(data[id]))
if dist < key[id]:
key[id] = dist
parent[id] = u
# 也更新最小堆中节点的key值，重构
minHeap.decreaseKey(id, key[id])
edges[(u, id)] = dist
edges[(id, u)] = dist
edgePairs = []
for i in range(1, V):
edgePairs.append((self.partitionId,
Edge(data[parent[i]].getId(), data[i].getId(),
edges[(parent[i], i)])))
return edgePairs
def dijkstra(self, src, dest, vertices_map):
V = self.V # Get the number of vertices in graph
dist = [] # dist values used to pick minimum
# weight edge in cut
# minHeap represents set E
minHeap = Heap()
# Initialize min heap with all vertices.
# dist value of all vertices
for v in range(V):
dist.append(sys.maxsize)
minHeap.array.append(minHeap.newMinHeapNode(v, dist[v]))
minHeap.pos.append(v)
# Make dist value of src vertex as 0 so
# that it is extracted first
minHeap.pos[src] = src
dist[src] = 0
minHeap.decreaseKey(src, dist[src])
# Initially size of min heap is equal to V
minHeap.size = V
# In the following loop, min heap contains all nodes
# whose shortest distance is not yet finalized.
while minHeap.isEmpty() == False:
# Extract the vertex with minimum distance value
newHeapNode = minHeap.extractMin()
u = newHeapNode[0]
# Break the loop when minimum distance vertex = destination node
if u == dest:
break
# Traverse through all adjacent vertices of u (the extracted vertex) and update their distance values
for pCrawl in self.graph[u]:
v = pCrawl[0]
# If shortest distance to v is not finalized
# yet, and distance to v through u is less
# than its previously calculated distance
if minHeap.isInMinHeap(v) and dist[
u] != sys.maxsize and pCrawl[1] + dist[u] < dist[v]:
dist[v] = pCrawl[1] + dist[u]
self.parent[v] = u
# update distance value in min heap
minHeap.decreaseKey(v, dist[v])
print_arr(dist, V)
printSolution(src, dist, self.parent)
print_src_dest(dist, src, dest, self.parent, vertices_map)
def KruskalMST_heap(self):
V = len(self.node)
result = [] # 存MST的每条边
E = len(self.graph)
i = 0 # 用来遍历原图中的每条边，但一般情况都遍历不完
e = 0 # 用来判断当前最小生成树的边数是否已经等于V-1
# 按照权重对每条边进行排序，如果不能改变给的图，那么就创建一个副本，内建函数sorted返回的是一个副本
# self.graph = sorted(self.graph, key=lambda item: item[2])
#初始化最小堆
minHeap = Heap()
for i in range(len(self.graph)):
edge = self.graph[i]
minHeap.array.append(minHeap.newMinHeapNode(v=i, dist=edge[2]))
#newMinHeapNode方法返回一个list，包括节点id、节点key值
#minHeap.array成员存储每个list，所以是二维list
#所以初始时堆里的每个节点的key值都是无穷大
minHeap.pos.append(i)
minHeap.size = E
minHeap.decreaseKey(0, minHeap.array[0][1])
parent = []
rank = []
# 创建V个子树，都只包含一个节点
for node in range(V):
parent.append(node)
rank.append(0)
# MST的最终边数将为V-1
while (e < V - 1):
if i > len(self.graph) - 1:
break
# 选择权值最小的边，这里已经排好序
edge = minHeap.extractMin()
index = edge[0]
dist = edge[1]
minHeap.decreaseKey(index, dist)
u, v, w = self.graph[index]
i = i + 1
x = self.find(parent, u)
y = self.find(parent, v)
# 如果没形成边，则记录下来这条边
if x != y:
# 不等于才代表没有环
e = e + 1
result.append(Edge(self.node[u], self.node[v], w))
#result.append([u,v,w])
self.union(parent, rank, u, v, x, y)
# 否则就抛弃这条边
return result
def BipartiteMST(self):
# 存每个节点的key值
edges = {}
left_data = self.leftData
right_data = self.rightData
num_left = len(left_data)
num_right = len(right_data)
key_left = []
key_right = []
parent_left = []
parent_right = []
# 建立最小堆
minHeap_left = Heap()
minHeap_right = Heap()
# 初始化左节点三个数据结构
for v in range(num_left):
parent_left.append(-1) #初始时，每个节点的父节点是-1
key_left.append(float('inf')) #初始时，每个节点的key值都是无穷大
minHeap_left.array.append(
minHeap_left.newMinHeapNode(v, key_left[v]))
minHeap_left.pos.append(v)
# 初始化右节点三个数据结构
for v in range(num_right):
parent_right.append(-1) #初始时，每个节点的父节点是-1
key_right.append(float('inf')) #初始时，每个节点的key值都是无穷大
minHeap_right.array.append(
minHeap_right.newMinHeapNode(v, key_right[v]))
minHeap_right.pos.append(v)
minHeap_left.pos[0] = 0 #不懂这句，本来pos的0索引元素就是0啊
key_left[0] = 0 #让0节点作为第一个被挑选的节点
minHeap_left.decreaseKey(0, key_left[0])
#把堆中0位置的key值变成key[0]，函数内部重构堆
minHeap_right.pos[0] = 0
#key_right[0] = 0
minHeap_right.decreaseKey(0, key_right[0])
# 初始化堆的大小为V即节点个数
minHeap_left.size = num_left
minHeap_right.size = num_right
label = 'left'
while minHeap_left.isEmpty(
) == False | minHeap_right.isEmpty() == False:
# 抽取最小堆中key值最小的节点
if label == 'left':
newHeapNode = minHeap_left.extractMin()
u = newHeapNode[0]
for i in range(minHeap_right.size):
id = minHeap_right.array[i][0]
dist = max(1 / 42, left_data[u].dtw_dist(right_data[id]))
if dist < key_right[id]:
key_right[id] = dist
parent_right[id] = u
# 也更新最小堆中节点的key值，重构
minHeap_right.decreaseKey(id, key_right[id])
edges[(u, id)] = dist
label = 'right'
else:
newHeapNode = minHeap_right.extractMin()
v = newHeapNode[0]
for i in range(minHeap_left.size):
id = minHeap_left.array[i][0]
dist = max(1 / 42, right_data[v].dtw_dist(left_data[id]))
if dist < key_left[id]:
key_left[id] = dist
parent_left[id] = v
# 也更新最小堆中节点的key值，重构
minHeap_left.decreaseKey(id, key_left[id])
edges[(id, v)] = dist
label = 'left'
edgePairs = []
for i in range(1, num_left):
edgePairs.append((self.partitionId,Edge(right_data[parent_left[i]].getId(),left_data[i].getId(),\
edges[(i,parent_left[i])])))
for j in range(0, num_right):
edgePairs.append((self.partitionId,Edge(left_data[parent_right[j]].getId(),right_data[j].getId(),\
edges[(parent_right[j],j)])))
return edgePairs
