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())
