def are_connected(self, name1, name2): """Is this name1 friends with name2? >>> f = FriendGraph() >>> f.add_person("Romeo") >>> f.add_person("Juliet") >>> f.set_friends("Romeo", ["Juliet"]) >>> f.are_connected("Romeo", "Juliet") True """ # want to do a BFS here checked_friends = Queue() to_check = enqueue(self.nodes[name1]) seen = set() seen.add(self.nodes[name1]) while not to_check is_empty(): current = to_check.dequeue() if current == name2: return True else: checked_friends.append(self.name2.friends)
def __init__(self, filename: str, stream: TextIO = None, *, diagnostics: DiagnosticManager): self.diagnostics = diagnostics self.stream = stream or open(filename, 'r+', encoding='utf-8') self.is_new_line = True self.level = 0 self.queue = Queue() self.indentations = Stack([0]) self.__current_symbol = self.stream.read(1) self.value = StringIO() self.unputed = Queue() self.__location = Location(filename) self.whitespace = '', self.__location
def _balance_insertion(self, curr, last): walk = last path = Queue() path.append(curr), path.append(last) while walk is not None: self.tree[walk].height = max(self.left_height( self.tree[walk]), self.right_height(self.tree[walk])) + 1 if self.is_order_statistic: self.tree[walk].size = (self.left_size(self.tree[walk]) + self.right_size(self.tree[walk]) + 1) last = path.popleft() last2last = path.popleft() if self.balance_factor(self.tree[walk]) not in (1, 0, -1): l = self.tree[walk].left if l is not None and l == last and self.tree[ l].left == last2last: self._right_rotate(walk, last) r = self.tree[walk].right if r is not None and r == last and self.tree[ r].right == last2last: self._left_rotate(walk, last) if l is not None and l == last and self.tree[ l].right == last2last: self._left_right_rotate(walk, last) if r is not None and r == last and self.tree[ r].left == last2last: self._right_left_rotate(walk, last) path.append(walk), path.append(last) walk = self.tree[walk].parent
def build(self): """ Builds the segment tree from the segments, using iterative algorithm based on queues. """ if self.cache: return None endpoints = [] for segment in self.segments: endpoints.extend(segment) endpoints.sort() elem_int = Queue() elem_int.append( TreeNode([False, endpoints[0] - 1, endpoints[0], False], None)) i = 0 while i < len(endpoints) - 1: elem_int.append( TreeNode([True, endpoints[i], endpoints[i], True], None)) elem_int.append( TreeNode([False, endpoints[i], endpoints[i + 1], False], None)) i += 1 elem_int.append( TreeNode([True, endpoints[i], endpoints[i], True], None)) elem_int.append( TreeNode([False, endpoints[i], endpoints[i] + 1, False], None)) self.tree = [] while len(elem_int) > 1: m = len(elem_int) while m >= 2: I1 = elem_int.popleft() I2 = elem_int.popleft() I = self._union(I1, I2) I.left = len(self.tree) I.right = len(self.tree) + 1 self.tree.append(I1), self.tree.append(I2) elem_int.append(I) m -= 2 if m & 1 == 1: Il = elem_int.popleft() elem_int.append(Il) Ir = elem_int.popleft() Ir.left, Ir.right = -3, -2 self.tree.append(Ir) self.root_idx = -1 for segment in self.segments: I = TreeNode([True, segment[0], segment[1], True], None) calls = [self.root_idx] while calls: idx = calls.pop() if self._contains(I, self.tree[idx]): if self.tree[idx].data is None: self.tree[idx].data = [] self.tree[idx].data.append(I) continue calls = self._iterate(calls, I, idx) self.cache = True
def _initialize(self, inputs): if inputs is None: inputs = [] assert isinstance( inputs, (list, tuple)), "inputs must be list or tuple" # NOQA self._raw_stdout = sys.stdout self._raw_stderr = sys.stderr self._stdout = None if settings.REDIRECT_STDERR or settings.REDIRECT_STDOUT: self._stdout = StringIO() if settings.REDIRECT_STDOUT: sys.stdout = self._stdout if settings.REDIRECT_STDERR: sys.stderr = self._stdout settings.INPUT_QUEUE = Queue(inputs) self._locals = { '__name__': '__pytrace__', '__builtins__': builtins.allowed() }
def bfs(initial: State): visited = {hash(initial)} state_queue = Queue([initial]) # while thingies exist in the queue of states, keep going. while state_queue: curr_state = state_queue.popleft() # short-circuit the bfs is a solution is found. # returns the steps to reach the solution in a string. if curr_state.done: return curr_state.ops_string # tries to execute a Q operation if curr_state.operation_Q_allowed(): next_state_q = curr_state.execute_operation_Q() q_hash = hash(next_state_q) if q_hash not in visited: visited.add(q_hash) state_queue.append(next_state_q) # tries to execute an S operation if curr_state.operation_S_allowed(): next_state_s = curr_state.execute_operation_S() s_hash = hash(next_state_s) if s_hash not in visited: visited.add(s_hash) state_queue.append(next_state_s) raise Exception("BFS: No solution found.")
def __init__(self): #压缩参数,后面cv2.imencode将会用到,对于jpeg来说,15代表图像质量,越高代表图像质量越好为 0-100,默认95 self.encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 80] self.init_config() # 这里的队列,用于多线程压缩图片之后,放入队列 # Python的队列是线程安全的 self.Q = Queue()
class Scheduler(object): def __init__(self): self.ready = Queue() self.taskmap = {} def new(self, target): newtask = Task(target) self.taskmap[newtask.tid] = newtask self.schedule(newtask) return newtask.tid def schedule(self, task): self.ready.put(task) def mainloop(self): while self.taskmap: task = self.ready.get() result = task.run() self.schedule(task)
def _expand_all(root): q = Queue() q.append((root, '')) paths = [] while q: node, path = q.popleft() paths.append(path) for c in PathParser._search_graph.get(node, []): q.append((c, path + '/' + c)) return paths
def adj_list_bfs_iterative(graph, marked, source): q = Queue() q.append(source) marked[source] = True while (q): s = q.popleft() for v in graph.adjacent(s): if not marked[v]: marked[v] = True q.append(v)
def _expand_gap(root, end): q = Queue() q.append((root, '')) paths = [] while q: node, path = q.popleft() if node == end: paths.append(path) else: for c in PathParser._search_graph.get(node, []): q.append((c, path + '/' + c)) return paths
def hash_block_with_history(self, byte_sequence): """ Calculate hash of byte sequence """ if len( byte_sequence ) != self.block_size: # length of byte sequence must match specified block size raise BufferError('Byte sequence is %s long instead of %s' % (len(byte_sequence), self.block_size)) self.prev_hash = self._hash_block_unconstrained(byte_sequence) self.chars = Queue() # Queue is used to store history for char in byte_sequence: self.chars.append(char) return self.prev_hash % self.hash_range
def adj_list_bfs_iterative(graph, source, marked, edge_to, dist_to): q = Queue() q.append(source) marked[source] = True while (q): v = q.popleft() for w in graph.adjacent(v): if not marked[w]: q.append(w) marked[w] = True edge_to[w] = v dist_to[w] = dist_to[v] + 1
def bfs(digraph, source_set, marked, edge_to): q = Queue() for s in source_set: q.append(s) while (q): v = q.popleft() marked[v] = True for w in digraph.adjacent(v): if not marked[w]: q.append(w) marked[w] = True edge_to[w] = v
def adj_list_bfs_iterative(graph, source, marked, id, count): q = Queue() q.append(source) marked[source] = True id[source] = count while (q): v = q.popleft() for w in graph.adjacent(v): if not marked[w]: q.append(w) marked[w] = True id[w] = count
def calculate_town_distance(town, input_vals: InputVals) -> int: distances = Queue() for i in range(input_vals.town_count): current_position = (town + i) % input_vals.town_count current_distance = (input_vals.town_count - i) % input_vals.town_count if current_position in input_vals.positions: for i in range(input_vals.positions[current_position]): distances.appendleft(current_distance) distance_sum = sum(distances) if distances_are_valid(distances): return distance_sum else: return -1
def bfs(g, start, counter=0): start.setDistance(0) start.setPred(None) vertQueue = Queue() vertQueue.append(start) while vertQueue: currentvert = vertQueue.popleft() for nbr in currentvert.getConnections(): if (nbr.getColor() == 'white'): nbr.setColor('gray') nbr.setDistance(currentvert.getDistance() + 1) nbr.setPred(currentvert) vertQueue.append(nbr) currentvert.setColor('black') return g
def adj_list_bfs_iterative(graph, source, marked, color): q = Queue() q.append(source) while (q): v = q.popleft() for w in graph.adjacent(v): if not marked[w]: marked[w] = True color[w] = 1 - color[v] q.append(w) elif color[v] == color[w]: return False return True
def bfs(heap): bfs_trav = [] for i in range(len(heap.root_list)): layer = [] bfs_q = Queue() bfs_q.append(heap.root_list[i].root) while len(bfs_q) != 0: curr_node = bfs_q.popleft() if curr_node is not None: layer.append(curr_node.key) for _i in range(curr_node.children._last_pos_filled + 1): bfs_q.append(curr_node.children[_i]) if layer != []: bfs_trav.append(layer) return bfs_trav
def adj_list_bfs_iterative(graph, source, marked, parent_vertex): q = Queue() q.append((source, parent_vertex)) marked[source] = True while (q): s, parent = q.popleft() for v in graph.adjacent(s): if not marked[v]: marked[v] = True q.append((v, s)) elif v != parent: return True return False
def bfs(graph, start): n = len(graph) q, res = Queue(), [MAX] * n for s in start: res[s] = 0 q.append(s) while q: cur = q.popleft() for next in graph[cur]: if res[next] == MAX: res[next] = res[cur] + 1 q.append(next) return res
def bfs(g, start): start.setDistance(0) start.setPred(None) start.setColor('gray') verQ = Queue() verQ.append(start) while verQ: currentvert = verQ.popleft() for neigh in currentvert.getConnections(): if (neigh.getColor() == 'white'): neigh.setColor('gray') neigh.setDistance(currentvert.getDistance() + 1) verQ.append(neigh) neigh.setPred(currentvert) currentvert.setColor('black') return g
def breadth_first_search(startnode, goalnode): queue = Queue() queue.append(startnode) nodesseen = set() nodesseen.add(startnode) while queue: node = queue.popleft() if node is goalnode: return True else: queue.extend(node for node in node.successors if node not in nodesseen) nodesseen.update(node.successors) return False
def bfs_main(): adj_list_graph_one = AdjListGraph(13) adj_list_graph_one = create_graph_one(adj_list_graph_one) marked = [False] * adj_list_graph_one.num_of_vertices() edge_to = [None] * adj_list_graph_one.num_of_vertices() dist_to = [0] * adj_list_graph_one.num_of_vertices() # adj_list_bfs_iteraive(adj_list_graph_one, 0, marked, edge_to, dist_to) queue = Queue() queue.append(0) adj_list_bfs_recursive(adj_list_graph_one, queue, marked, edge_to, dist_to) print(marked) print(edge_to) path = path_to(0, 3, edge_to) print(path)
def bfsGrid(self, grid): N = len(grid) visited = set() queue = Queue() queue.enqueue((0, 0)) direction = [(-1, 0), (0, -1), (1, 0), (0, 1)] while queue: i, j = queue.dequeue() visited.add((i, j)) #add logic to do something for x, y in direction: new_i, new_j = i + x, j + y if (new_i, new_j) not in visited: #check if it is in bounds if 0 <= new_i < N and 0 <= new_j < N: queue.enqueue((new_i, new_j))
def __init__(self, src="C:\\Tools\\titan_test.mp4"): self.config = Config() self.packer = Packer() # initialize the file video stream along with the boolean # used to indicate if the thread should be stopped or not os.environ["OPENCV_VIDEOIO_DEBUG"] = "1" os.environ["OPENCV_VIDEOIO_PRIORITY_MSMF"] = "0" encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 15] self.stream = cv2.VideoCapture(src) # while True: # if cv2.waitKey(1) & 0xFF == ord('q'): # break # ret, frame = self.stream.read() # if ret: # # print(frame.shape) # # frame = frame.reshape(self.packer.h, self.packer.w, self.packer.d) # cv2.imshow('read video data.jpg', frame) # self.stream.set(cv2.CAP_PROP_MODE, cv2.CAP_MODE_YUYV) # print(self.stream.get(cv2.CAP_PROP_FPS)) # 默认帧率30 # self.stream.set(cv2.CAP_PROP_FPS, 20) # cv version is 3.4.2 self.stopped = False self.requesting = False self.request = False self.quit = False self.push_sleep = 0.2 self.push_sleep_min = 0.2 self.push_sleep_max = 0.5 self.frame = None self.frame_size = 0 self.piece_size = 0 self.frame_pieces = 0 self.init_config() self.init_connection() # intialize thread and lock self.thread = Thread(target=self.update, args=()) self.thread.daemon = True self.Q = Queue()
def _breadth_first_search_adjacency_list( graph, source_node, operation, *args, **kwargs): bfs_queue = Queue() visited = dict() bfs_queue.append(source_node) visited[source_node] = True while len(bfs_queue) != 0: curr_node = bfs_queue.popleft() next_nodes = graph.neighbors(curr_node) if len(next_nodes) != 0: for next_node in next_nodes: if visited.get(next_node.name, False) is False: status = operation(curr_node, next_node.name, *args, **kwargs) if not status: return None bfs_queue.append(next_node.name) visited[next_node.name] = True else: status = operation(curr_node, "", *args, **kwargs) if not status: return None
def slider(arr, k): n = len(arr) q = Queue() #from the first k elements keep the max and decreasing for i in range(k): while (len(q) and arr[i] <= arr[q[-1]]): q.pop() q.append(i) for i in range(k, n): #previous window min print(arr[q[0]], end=" ") #if any element does not belong to this window we pop the, while (len(q) and q[0] <= i - k): #this index does not belong to this window q.popleft() #remove all smaller elements curr = arr[i] while (len(q) and curr <= arr[q[-1]]): q.pop() q.append(i) print(arr[q[0]])
def breadth_first_search(self, node=None, strategy='queue'): # TODO: IMPLEMENT ITERATIVE DEEPENING-DEPTH FIRST SEARCH STRATEGY """ Computes the breadth first search traversal of a binary tree. Parameters ========== node : int The index of the node from where the traversal has to be instantiated. By default, set to, root index. strategy : str The strategy using which the computation has to happen. By default, it is set 'queue'. Returns ======= list Each element of the list is of type `TreeNode`. """ strategies = ('queue', ) if strategy not in strategies: raise NotImplementedError("%s startegy is not implemented yet" % (strategy)) if node is None: node = self.tree.root_idx q, visit, tree = Queue(), [], self.tree.tree q.append(node) while len(q) > 0: node = q.popleft() visit.append(tree[node]) if tree[node].left is not None: q.append(tree[node].left) if tree[node].right is not None: q.append(tree[node].right) return visit
def __init__(self): self.ready = Queue() self.taskmap = {}