class Kruskal: def __init__(self, edge_weighted_graph): self.__EWG = edge_weighted_graph self.__distance_to = dict() self.__edge_to = dict() self.__min_pq = MinPQ() self.__mst_vertices = dict() self.__edges = list() for v in self.__EWG.get_vertices(): self.__mst_vertices[v] = False for edge in self.__EWG.edges(): self.__min_pq.insert(edge.weight(), edge) self.__vertices_no = len(self.__mst_vertices.keys()) self.__uf = WeightedQuickUnion(self.__vertices_no) self.__build() def weight(self): sum = 0 for edge in self.__edges: sum += edge.weight() return sum def edges(self): return self.__edges def __build(self): while len(self.__edges) < self.__vertices_no - 1: edge = self.__min_pq.del_min() v = edge.either() w = edge.other(v) if not self.__uf.connected(int(v), int(w)): self.__uf.union(int(v), int(w)) self.__edges.append(edge)
class LazyPrimMST: def __init__(self, ewg): #ewg is an edge weighted graph self.pq = MinPQ() self.marked = [False] * (ewg.v + 1) self.mst = Queue() self._visit(ewg, 0) while not self.pq.isEmpty(): e = self.pq.dequeue() v = e.either() w = e.other(v) if (self.marked[v] == True and self.marked[w] == True): continue self.mst.enqueue(e) if not self.marked[v] == True: self._visit(ewg, v) if not self.marked[w] == True: self._visit(ewg, w) def _visit(self, ewg, v): self.marked[v] = True for e in ewg.adj(v): if not self.marked[e.other(v)] == True: self.pq.enqueue(e) def edges(self): return self.mst
class MST: def __init__(self, G): self.marked = {} for vid in G.getVertexIds(): self.marked[vid] = False self.edges = [] self.pq = MinPQ() self.weight = 0 self.visit(G, 0) while not self.pq.isEmpty(): edge = self.pq.delMin() v = edge.either() w = edge.other(v) if self.marked[v] and self.marked[w]: continue if not self.marked[v]: self.visit(G, v) if not self.marked[w]: self.visit(G, w) self.edges.append(edge) self.weight += edge.getWeight() def visit(self, G, vid): self.marked[vid] = True edges = G.getAdjacentEdges(vid) for edge in edges: if not self.marked[edge.other(vid)]: self.pq.insert(edge) def getEdges(self): return self.edges def getWeight(self): return self.weight
class LazyPrimMST: def __init__(self,ewg): #ewg is an edge weighted graph self.pq = MinPQ() self.marked = [False] * (ewg.v+1) self.mst = Queue() self._visit(ewg,0) while not self.pq.isEmpty(): e = self.pq.dequeue() v = e.either() w = e.other(v) if (self.marked[v] == True and self.marked[w] == True): continue self.mst.enqueue(e) if not self.marked[v] == True: self._visit(ewg,v) if not self.marked[w] == True : self._visit(ewg,w) def _visit(self,ewg,v): self.marked[v] = True for e in ewg.adj(v): if not self.marked[e.other(v)] == True : self.pq.enqueue(e) def edges(self): return self.mst
def __init__(self, G): self.mst = [] self.pq = MinPQ() self.marked = [False] * G.Vertex() self.Weight = 0 for v in range(0, G.Vertex()): if not self.marked[v]: self.prim(G, v)
def __init__(self, edge_weighted_graph): self.__EWG = edge_weighted_graph self.__MST_vertices = dict() self.__MST_edges = list() self.__min_pq = MinPQ() for vertex in self.__EWG.get_vertices(): self.__MST_vertices[vertex] = False self.__build()
def __init__(self, edge_weighted_graph): self.__EWG = edge_weighted_graph self.__distance_to = dict() self.__edge_to = dict() self.__min_pq = MinPQ() self.__mst_vertices = dict() for v in self.__EWG.get_vertices(): self.__mst_vertices[v] = False self.__build()
def __init__(self, edge_weighted_graph): self.__EWG = edge_weighted_graph self.__distance_to = dict() self.__edge_to = dict() self.__min_pq = MinPQ() self.__mst_vertices = dict() self.__edges = list() for v in self.__EWG.get_vertices(): self.__mst_vertices[v] = False for edge in self.__EWG.edges(): self.__min_pq.insert(edge.weight(), edge) self.__vertices_no = len(self.__mst_vertices.keys()) self.__uf = WeightedQuickUnion(self.__vertices_no) self.__build()
def __init__(self, edge_weighted_digraph, source): self.edge_to = dict() self.dist_to = dict() self.relaxed_vertices = dict() self.min_pq = MinPQ() self.EWD = edge_weighted_digraph self.source = source for vertex in self.EWD.get_vertices(): self.dist_to[vertex] = float("inf") self.dist_to[source] = 0 self.relax_vertex(self.source) self.build() for vertex, edge in self.edge_to.items(): print vertex, ' : ', edge.to_string() print self.dist_to
def __init__(self,ewg): self._mst = Queue() self._pq = MinPQ(ewg.edges()) self._uf = UnionFind(ewg.v+1) while not self._pq.isEmpty() and self._mst.size < ewg.v-1: #get minimum weighted ege on the PQ e = self._pq.dequeue() #get the first vertex v = e.either() #get the second w = e.other(v) if (self._uf.connected(v,w)): continue self._uf.union(v,w) self._mst.enqueue(e)
def prim_edge_pq(adj): n = len(adj) - 1 MST = set() MST.add(1) MST_edges = [] total_cost = 0 pq = MinPQ(n) for e in adj[1]: pq.insert(e) while len(MST) != n: edge = pq.extract_min() # print(edge) u = edge.either() v = edge.other(u) if u in MST and v in MST: continue if u in MST: s = v else: s = u MST.add(s) MST_edges.append(edge) total_cost += edge.weight for e in adj[s]: pq.insert(e) return total_cost, MST_edges
class PrimMSTEager: def __init__(self, edge_weighted_graph): self.__EWG = edge_weighted_graph self.__distance_to = dict() self.__edge_to = dict() self.__min_pq = MinPQ() self.__mst_vertices = dict() for v in self.__EWG.get_vertices(): self.__mst_vertices[v] = False self.__build() def weight(self): sum = 0 for distance in self.__distance_to.values(): sum += distance return sum def edges(self): return self.__edge_to.values() def __build(self): v = self.__EWG.get_vertices()[0] # v = '0' self.__distance_to[v] = 0 self.__mst_vertices[v] = True for adjacent in self.__EWG.adj(v): w = adjacent.other(v) self.__min_pq.insert(adjacent.weight(), adjacent) self.__distance_to[w] = adjacent.weight() self.__edge_to[w] = adjacent while not self.__min_pq.is_empty(): edge = self.__min_pq.del_min() if not self.__mst_vertices.get(edge.either()): v = edge.either() self.__mst_vertices[v] = True elif not self.__mst_vertices.get(edge.other(edge.either())): v = edge.other(edge.either()) self.__mst_vertices[v] = True if v is None: continue for adjacent in self.__EWG.adj(v): w = adjacent.other(v) if w == self.__EWG.get_vertices()[0]: continue weight = adjacent.weight() if not self.__distance_to.get(w): self.__distance_to[w] = weight self.__edge_to[w] = adjacent self.__min_pq.insert(weight, adjacent) elif weight < self.__distance_to.get( w) and not self.__mst_vertices.get(w): self.__distance_to[w] = weight self.__edge_to[w] = adjacent self.__min_pq.insert(weight, adjacent)
def __init__(self, ewg): #ewg is an edge weighted graph self.pq = MinPQ() self.marked = [False] * (ewg.v + 1) self.mst = Queue() self._visit(ewg, 0) while not self.pq.isEmpty(): e = self.pq.dequeue() v = e.either() w = e.other(v) if (self.marked[v] == True and self.marked[w] == True): continue self.mst.enqueue(e) if not self.marked[v] == True: self._visit(ewg, v) if not self.marked[w] == True: self._visit(ewg, w)
class LazyPrimMST: def __init__(self, G): self.mst = [] self.pq = MinPQ() self.marked = [False] * G.Vertex() self.Weight = 0 for v in range(0, G.Vertex()): if not self.marked[v]: self.prim(G, v) #assert(self.check(G)) def prim(self, G, s): self.scan(G, s) while not self.pq.isEmpty(): e = self.pq.delMin() v = e.either() w = e.other(v) assert (self.marked[v] or self.marked[w]) if self.marked[v] and self.marked[w]: continue self.mst += [e] self.Weight += e.weight if not self.marked[v]: self.scan(G, v) if not self.marked[w]: self.scan(G, w) def scan(self, G, v): assert (not self.marked[v]) self.marked[v] = True for e in G.adj[v]: if not self.marked[e.other(v)]: self.pq.insert(e) def edges(self): return self.mst def weight(self): return self.Weight '''def check(self, G):
class MSTPrim: def __init__(self, graph): vertex_num = graph.vertex_num() self._marked = zeros(vertex_num, dtype=bool) self._pq = MinPQ() self._mst = Queue() self._visit(0, graph) # Begin from vertex 0 while self._mst.size() != vertex_num - 1: edge = self._pq.remove() # Get the minimum edge vertex_1 = edge.either() # Get the two ends of the edge vertex_2 = edge.other(vertex_1) # If at least of the 2 vertices has not been visited yet # We add the edge to the tree if not self._marked[vertex_1] or not self._marked[vertex_2]: self._mst.enqueue(edge) # Visit the unvisited vertex if not self._marked[vertex_1]: self._visit(vertex_1, graph) if not self._marked[vertex_2]: self._visit(vertex_2, graph) # Mark a vertex when visit it and add all the adjacent edges to it on to the MinPQ def _visit(self, vertex, graph): self._marked[vertex] = True for edge in graph.adj(vertex): if not self._marked[edge.other(vertex)]: self._pq.insert(edge) # All the edges in the minimum spanning tree def edges(self): return self._mst # The total weight of the minimum spanning tree def weight(self): weight = 0 for edge in self._mst: weight += edge.weight() return weight
def __init__(self, G): self.marked = {} for vid in G.getVertexIds(): self.marked[vid] = False self.edges = [] self.pq = MinPQ() self.weight = 0 self.visit(G, 0) while not self.pq.isEmpty(): edge = self.pq.delMin() v = edge.either() w = edge.other(v) if self.marked[v] and self.marked[w]: continue if not self.marked[v]: self.visit(G, v) if not self.marked[w]: self.visit(G, w) self.edges.append(edge) self.weight += edge.getWeight()
class KruskalMST: def __init__(self,ewg): self._mst = Queue() self._pq = MinPQ(ewg.edges()) self._uf = UnionFind(ewg.v+1) while not self._pq.isEmpty() and self._mst.size < ewg.v-1: #get minimum weighted ege on the PQ e = self._pq.dequeue() #get the first vertex v = e.either() #get the second w = e.other(v) if (self._uf.connected(v,w)): continue self._uf.union(v,w) self._mst.enqueue(e) def edges(self): return self._mst
def __init__(self, graph): vertex_num = graph.vertex_num() self._marked = zeros(vertex_num, dtype=bool) self._pq = MinPQ() self._mst = Queue() self._visit(0, graph) # Begin from vertex 0 while self._mst.size() != vertex_num - 1: edge = self._pq.remove() # Get the minimum edge vertex_1 = edge.either() # Get the two ends of the edge vertex_2 = edge.other(vertex_1) # If at least of the 2 vertices has not been visited yet # We add the edge to the tree if not self._marked[vertex_1] or not self._marked[vertex_2]: self._mst.enqueue(edge) # Visit the unvisited vertex if not self._marked[vertex_1]: self._visit(vertex_1, graph) if not self._marked[vertex_2]: self._visit(vertex_2, graph)
class PrimMSTLazy: def __init__(self, edge_weighted_graph): self.__EWG = edge_weighted_graph self.__MST_vertices = dict() self.__MST_edges = list() self.__min_pq = MinPQ() for vertex in self.__EWG.get_vertices(): self.__MST_vertices[vertex] = False self.__build() def edges(self): return self.__MST_edges def weight(self): total_weight = 0 for edge in self.__MST_edges: total_weight += edge.weight() return total_weight def __build(self): v = self.__EWG.get_vertices()[0] # v = '0' self.__MST_vertices[v] = True # print self.__EWG.adj(v) for adjacent in self.__EWG.adj(v): self.__min_pq.insert(adjacent.weight(), adjacent) while not self.__min_pq.is_empty(): edge = self.__min_pq.del_min() v = edge.either() w = edge.other(v) if self.__MST_vertices.get(v) and not self.__MST_vertices.get(w): self.__MST_vertices[w] = True self.__MST_edges.append(edge) for adjacent in self.__EWG.adj(w): if not adjacent.same_edge(edge): self.__min_pq.insert(adjacent.weight(), adjacent) elif self.__MST_vertices.get(w) and not self.__MST_vertices.get(v): self.__MST_vertices[v] = True self.__MST_edges.append(edge) for adjacent in self.__EWG.adj(v): if not adjacent.same_edge(edge): # filter self.__min_pq.insert(adjacent.weight(), adjacent)
def __init__(self,ewg): #ewg is an edge weighted graph self.pq = MinPQ() self.marked = [False] * (ewg.v+1) self.mst = Queue() self._visit(ewg,0) while not self.pq.isEmpty(): e = self.pq.dequeue() v = e.either() w = e.other(v) if (self.marked[v] == True and self.marked[w] == True): continue self.mst.enqueue(e) if not self.marked[v] == True: self._visit(ewg,v) if not self.marked[w] == True : self._visit(ewg,w)
def buildTrie(self, freq): pq = MinPQ() for i in range(0, self.R): if freq[i] > 0: pq.insert(Node(i, freq[i], None, None)) if pq.size() == 1: if freq['\0'] == 0: pq.insert(Node('\0', 0, None, None)) else: pq.insert(Node('\1', 0, None, None)) while pq.size() > 1: left = pq.delMin() right = pq.delMin() parent = Node('\0', left.freq + right.freq, left, right) pq.insert(parent) return pq.delMin()
class DijkstraSP: def __init__(self, edge_weighted_digraph, source): self.edge_to = dict() self.dist_to = dict() self.relaxed_vertices = dict() self.min_pq = MinPQ() self.EWD = edge_weighted_digraph self.source = source for vertex in self.EWD.get_vertices(): self.dist_to[vertex] = float("inf") self.dist_to[source] = 0 self.relax_vertex(self.source) self.build() for vertex, edge in self.edge_to.items(): print vertex, ' : ', edge.to_string() print self.dist_to # def has_path_to(self, node): # return def build(self): while not self.min_pq.is_empty(): v = self.min_pq.del_min() if not self.relaxed_vertices.get(v): self.relax_vertex(v) def has_path_to(self, vertex): return self.dist_to.get(vertex) != float('inf') def path_to(self, vertex): if self.has_path_to(vertex): path = list() vertex = str(vertex) edge = self.edge_to.get(vertex) From = edge.From() To = edge.To() while From != self.source: path.insert(0, To) edge = self.edge_to.get(From) From = edge.From() To = edge.To() path.insert(0, To) path.insert(0, self.source) return path else: return def relax_vertex(self, v): self.relaxed_vertices[v] = True if self.EWD.adj(v) is not None: for edge in self.EWD.adj(v): self.relax_edge(edge) def relax_edge(self, edge): To = edge.To() From = edge.From() # print edge.weight()+ self.dist_to.get(From) # print self.dist_to.get(To) if edge.weight() + self.dist_to.get(From) < self.dist_to.get(To): self.edge_to[To] = edge self.dist_to[To] = edge.weight() + self.dist_to[From] self.min_pq.insert(self.dist_to.get(To), To)
from Tests import test_poll as test_poll from Tests import test_is_empty as test_is_empty from Tests import test_iter as test_iter from Tests import test_peek as test_peek from Tests import test_swim as test_swim from Tests import test_final as test_final from Tests import test_data as test_data from Tests import test_str as test_str from MinPQ import MinPQ as MinPQ print "Testing MinPQ functions..." test_poll.test(MinPQ()) test_is_empty.test(MinPQ()) test_peek.test(MinPQ()) test_swim.test(MinPQ()) test_iter.test(MinPQ()) test_final.test(MinPQ(), test_data.objects) test_str.test(MinPQ())