def del_edge(self, graph, edge):
if edge not in set(self._mst):
return self._mst
# init disjoint set with iterable object
uf = GenericUnionFind([(e.either(), e.other(e.either()))
for e in self._mst if e is not edge])
pq = MinPQ()
for e in graph.edges():
if e is not edge:
pq.insert(e)
tmp = Queue([e for e in self._mst if e is not edge])
# find the minimum edge with both vertices is not connected
while not pq.is_empty():
min_edge = pq.del_min()
vertx_a = min_edge.either()
vertx_b = min_edge.other(vertx_a)
if uf.connected(vertx_a, vertx_b):
continue
# only need one edge
tmp.enqueue(min_edge)
break
self._mst = tmp
return self._mst
def _init_priority_queue(self, vertices, forest):
dup_set = set()
pq = MinPQ()
for v in vertices:
for edge in forest.adjacent_edges(v):
if edge not in dup_set:
pq.insert(edge)
dup_set.add(edge)
return pq
def build_trie(freq):
min_pq = MinPQ()
for i in range(256):
if freq[i]:
min_pq.insert(chr(i), freq, None, None)
while min_pq.size() > 1:
left = min_pq.del_min()
right = min_pq.del_min()
parent = Node('\0', left.freq + right.freq, left, right)
min_pq.insert(parent)
return min_pq.del_min()
def __init__(self, graph, start_vertex):
self._marked = defaultdict(bool)
self._mst = Queue()
self.pq = MinPQ()
self.visit(graph, start_vertex)
while not self.pq.is_empty():
edge = self.pq.del_min()
if self._marked[edge[1]] and self._marked[edge[2]]:
continue
self._mst.enqueue(edge)
if not self._marked[edge[1]]:
self.visit(graph, edge[1])
if not self._marked[edge[2]]:
self.visit(graph, edge[2])
def __init__(self, graph, start_vertex):
self._pq = MinPQ()
self._marked = defaultdict(bool)
self._mst = Queue()
self.visit(graph, start_vertex)
while not self._pq.is_empty():
edge = self._pq.del_min()
a = edge.either()
b = edge.other(a)
if self._marked[a] and self._marked[b]:
continue
self._mst.enqueue(edge)
if not self._marked[a]:
self.visit(graph, a)
if not self._marked[b]:
self.visit(graph, b)
def _init_priority_queue(self, graph, contain_edges):
pq = MinPQ()
for edge in graph.edges():
if edge not in contain_edges:
pq.insert(edge)
return pq
def _init_priority_queue(self, graph):
pq = MinPQ()
for edge in graph.edges():
pq.insert(edge)
return pq