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