def huffman(C): n = len(C) Q = PriorityQueue(C, MinHeap) for i in range(n - 1): x = Q.extract_min() y = Q.extract_min() z = Node(x.key() + y.key()) z.left = x z.right = y Q.insert(z) return Q.extract_min()
def test_node_heaping(): ''' Test priority queues with nodes as elements. ''' a = Node(label='a', msg="boom!", priority=1) b = Node(label='b', msg="hi", priority=2) c = Node(label='c', msg="ok", priority=3) d = Node(label='d', msg="oh", priority=4) q = PriorityQueue([b, c, d]) assert q.min == b assert q.min.msg == 'hi' assert q.min.label == 'b' assert q == [b, c, d] q.insert(a) assert q.min == a assert q.min.msg is 'boom!' assert q.min.label == 'a' assert q == [a, b, d, c] assert q.delete('c') == c assert q.sort() == [a, b, d] assert q.min == a assert q.min.label == 'a' min = q.shift() assert min == a assert min.label == 'a' assert q.sort() == [b, d] assert q.min == b assert q.min.label == 'b' q = PriorityQueue([d, c, b, a]) assert [a, b, c, d] == q.sort() assert [a, b, c, d] == [q.shift() for x in range(q.size)] assert q.size == 0 assert q == [] from itertools import permutations nodes = [a, b, c, d] for perm in permutations(nodes): q = PriorityQueue(perm) assert [a, b, c, d] == q.sort() assert [a, b, c, d] == [q.shift() for x in range(q.size)] assert q.size == 0 assert q == []
class DijkstrasMazeSolver(object): """Gets shortest maze exit path with help of Dijkstras algorithm. It converts 0/1 matrix maze to edge weighted graph representation (due to MazeToGraphConverter) and then finds shortest path. Also it uses Heap data structure to quickly get minimums. """ infinity = 10**10 def __init__(self, input_maze=None): is_text = type(input_maze) == str if is_text: converter = TextToMatrixMazeConverter(input_maze) converter = MazeToGraphConverter(converter.maze, converter.start_cell) else: converter = MazeToGraphConverter(input_maze) self.vertices = converter.graph_vertices self.edge_weights = converter.graph_edge_weights self.adjacency_list = converter.graph_adjacency_list self.edge_weights = converter.graph_edge_weights self.start_v = converter.start_cell self.exit_v = converter.exit_cell self.dist = dict() self.prev = dict() self.queue = PriorityQueue() self.shortest_path = self.shortest_exit_path() def shortest_exit_path(self): self.count_shortest_paths(self.start_v, self.exit_v) length = self.dist[self.exit_v] path = self.get_path(self.exit_v) return path, length def get_path(self, v, path=()): path = (v, ) + path if self.prev[v] and v != self.start_v: return self.get_path(self.prev[v], path) else: return path def count_shortest_paths(self, source, dest): self.dist[source] = 0 self.prev[source] = None for v in self.vertices: if v != source: self.dist[v] = self.infinity self.prev[v] = None else: self.queue.insert((v, self.dist[v])) while self.queue: u = self.queue.pop_min()[0] if u == dest: break for v in self.adjacency_list[u]: edge = frozenset((u, v)) alt = self.dist[u] + self.edge_weights[edge] if alt < self.dist[v]: self.dist[v] = alt self.prev[v] = u if v not in self.queue: self.queue.insert((v, alt))
class DijkstrasMazeSolver(object): """Gets shortest maze exit path with help of Dijkstras algorithm. It converts 0/1 matrix maze to edge weighted graph representation (due to MazeToGraphConverter) and then finds shortest path. Also it uses Heap data structure to quickly get minimums. """ infinity = 10 ** 10 def __init__(self, input_maze=None): is_text = type(input_maze) == str if is_text: converter = TextToMatrixMazeConverter(input_maze) converter = MazeToGraphConverter(converter.maze, converter.start_cell) else: converter = MazeToGraphConverter(input_maze) self.vertices = converter.graph_vertices self.edge_weights = converter.graph_edge_weights self.adjacency_list = converter.graph_adjacency_list self.edge_weights = converter.graph_edge_weights self.start_v = converter.start_cell self.exit_v = converter.exit_cell self.dist = dict() self.prev = dict() self.queue = PriorityQueue() self.shortest_path = self.shortest_exit_path() def shortest_exit_path(self): self.count_shortest_paths(self.start_v, self.exit_v) length = self.dist[self.exit_v] path = self.get_path(self.exit_v) return path, length def get_path(self, v, path=()): path = (v,) + path if self.prev[v] and v != self.start_v: return self.get_path(self.prev[v], path) else: return path def count_shortest_paths(self, source, dest): self.dist[source] = 0 self.prev[source] = None for v in self.vertices: if v != source: self.dist[v] = self.infinity self.prev[v] = None else: self.queue.insert((v, self.dist[v])) while self.queue: u = self.queue.pop_min()[0] if u == dest: break for v in self.adjacency_list[u]: edge = frozenset((u, v)) alt = self.dist[u] + self.edge_weights[edge] if alt < self.dist[v]: self.dist[v] = alt self.prev[v] = u if v not in self.queue: self.queue.insert((v, alt))