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 = {}
