def solution(grid): answer = [] dx = [0, 1, 0, -1] dy = [-1, 0, 1, 0] q = deque() q.append((0,0)) row = len(grid) column = len(grid[0]) answer = set() while q: cx, cy = q.popleft() for i in range(4): nx = cx + dx[i] ny = cy + dy[i] if nx <= 0 or ny <= 0: tmp = (cx, cy, i) if tmp in answer: break return answer
def connection_level_bfs(self, start, target): q = deque() visited = set() # paths = {start: None} q.append((0, start)) visited.add(target) while q: level, current = q.popleft() if current == target: # paths = {str(key): str(value) for key, value in paths.items} # print(json.dumps(path, indent=4)) path = [] while target is not None: path.append(target) target = path[target] return (level, reversed(path)) for neigh in self.network[current]: if neigh not in visited: q.append((level + 1, neigh)) visited.add(neigh)
def kahn_topsort(graph): in_degree = { u : 0 for u in graph } # determine in-degree for u in graph: # of each node for v in graph[u]: in_degree[v] += 1 Q = deque() # collect nodes with zero in-degree for u in in_degree: if in_degree[u] == 0: Q.appendleft(u) L = [] # list for order of nodes while Q: u = Q.pop() # choose node of zero in-degree L.append(u) # and 'remove' it from graph for v in graph[u]: in_degree[v] -= 1 if in_degree[v] == 0: Q.appendleft(v) if len(L) == len(graph): return L else: # if there is a cycle, return [] # then return an
def solution(n, m, image): answer = 0 direct = [(0,1),(0,-1),(1,0),(-1,0)] #방향변수 for y in range(n): for x in range(m): #방문한 값은 대체 if image[y][x] == float('inf'): continue targret = image[y][x] que = deque([(y,x)]) #같은 수 없을때까지 찾기 #-> 같은 수 que에 넣고 그 수의 x,y로 다시 방향변수로 같은 수 찾기 while que: ny, nx = que.popleft() for dy, dx in direct: py = ny+dy px = nx+dx if -1<py<n and -1<px<m and targret==image[py][px]: image[py][px] = float('inf') que.append((py,px)) answer += 1 return answer
def find(self, x): # return True if self.get_element(x) else False stack = deque() stack.append(self.__root) while len(stack) != 0: current_node = stack.pop() if current_node.data == x
def solution(bridge_length, weight, truck_weights): td = [] tmp = -1 queue = deque() for i in truck_weights: tmp = math.ceil(i * bridge_length / weight) if (tmp != None): td.append(tmp) print(td) answer = 0 return answer
def andrews_bfs_iterative(graph_node): q = deque() q.append(graph_node) seen = set() while q: current = q.popleft() if current not in seen: seen.add(current) # DO SOME STUFF, whatever we want print(current.val) for child in current.children: q.append(child)
def sort_012(input_list): """ Given an input array consisting on only 0, 1, and 2, sort the array in a single traversal. Args: input_list(list): List to be sorted """ sorted_list = deque() for el in input_list: if el == 0: sorted_list.append_left(el) elif el == 2: sorted_list.append(el)
def deliver(N, map, height): Q = deque() P = [] K_list = [] for i in range(N): for j in range(N): target = map[i][k] if target == 'P': P = [i, j] if target == 'K': K_list.append([i,j]) return
def solution1(root): if not root: return 0 q=from collections import deque q=deque() q.append([root,1]) while q: node,level=q.popleft() if node.left: q.append([node.left,level+1]) if node.right: q.append([node.right,level+1]) elif not node.left: return level
def depth(x): queue=deque([id(x),x,1]) memo=set() while queue: id_,y,level=queue.popleft() if id_ in memo: continue memo.add(id_) if isinstance(y,dict): queue+=((id(z),z,level+1) for z in y.values()) return level
def helper(root, level): if not root: return if level == len(ans): ans.append(deque()) if level % 2 == 0: ans[level].append(root.val) else: ans[level].appendleft(root.val) helper(root.left, level + 1) helper(root.right, level + 1)
def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]: # empty binary tree (edge case) if not root: return [] # we want to do bfs here, but the direction of traversal will change # after every level (use delimiter for that), using a variable to # track direction zigzagLevelOrderTraversal = [] # a deque supports faster append operation from both sides zigzagLevel = deque() bfsQueue = deque() leftToRight = True # change at every level # using an integer delimiter since all other elements in deque will be # TreeNode objects delimiter = -1 bfsQueue.append(root) bfsQueue.append(delimiter) while bfsQueue: node = bfsQueue.popleft() if node == delimiter: zigzagLevelOrderTraversal.append(zigzagLevel) # we only proceed further if bfsQueue is not empty if bfsQueue: # change leftToRight since level is changing leftToRight = False if leftToRight else True zigzagLevel = deque() # empty current level elements bfsQueue.append(delimiter) else: if leftToRight: zigzagLevel.append(node.val) else: zigzagLevel.appendleft(node.val) if node.left: bfsQueue.append(node.left) if node.right: bfsQueue.append(node.right) return zigzagLevelOrderTraversal
def palindrome_checker(exp_string): exp_deque = deque() for c in exp_string: exp_deque.add_back(c) equal_c = True while exp_deque.size() > 1 and equal_c: first = exp_deque.remove_front() last = exp_deque.remove_back() if first != last: equal_c = False return equal_c
def get_order_by_bfs(self): order_list = [] node = self.root visited = {} traverse_nodes = deque() traverse_nodes.append(node) while traverse_nodes: selected_node = traverse_nodes.pop(0) order_list.append(selected_node) for child in node.children: if visited.get(child.val): continue traverse_nodes.append(node) return order_list
def bfs(start, goal): # previous 사전의 역할은 각각의 역을 key - value 관계로 이어주는 것입니다. previous = {} queue = deque() # 현재 확인하고 있는 역은 없으니 None값으로 지정합니다. current = None # 현재 시작역과 연결된 역은 없다는 뜻입니다. previous[start] = None # 목표 역에 도달할때까지 queue를 통해 확인해야 하므로 시작역을 # 확인열에 집어넣습니다. queue.append(start) while len(queue) > 0 and current != goal: # 여기서 current는 목표 역이 아니라고 판명된(queue 확인열을 통해) 역으로 지정됩니다. # 여기서 None값을 탈출하는 것이죠! current = queue.popleft() for neighbor in current.neighbor: # previous 사전을 만든 이유를 다시 봐야 합니다. # 각각의 역을 이웃지어 주는 역할이므로, 이웃역이 사전에 없을 경우 아래와 같은 식으로 코드를 작성합니다. if neighbor not in previous.keys(): # 아직 확인을 하지 않은 역이므로 확인열에 넣고, queue.append(neighbor) # 사전에 추가합니다. previous[neighbor] = current if current == goal: # 경로를 만들어야 하는데 여기서 가장 적합한 툴은 리스트입니다. # 그러므로 리스트를 통해 경로를 작성해봅시다. path = [goal] # 다시 한 번, previous 사전의 역할을 생각해봅시다. # previous 사전은 각각의 역을 K - V 관계로 엮어주는 것이죠? # 고로 아래와 같이 목표역(goal)에 해당하는 value(이웃 역)이 있을 경우 경로를 만들 수 있기 떄문에 # 아래와 같이 코드를 작성합니다. 다만 역 순서가 역순(reverse)으로 출력되니 # 필요할 경우 reverse 메소드를 활용할 수 있겠네요! while previous[goal] != None: # goal을 목표역과 이웃된 역으로 재지정해줍니다. goal = previous[goal] path.append(goal) return path # 사전에 있는 모든 역을 확인했음에도 목표역을 찾지 못한 경우입니다. if current != goal: return None
def allCellsDistOrder(self, R, C, r0, c0): queue = deque() queue.append((r0, c0)) result = [] visited = set() while queue: r, c = queue.popleft() if r < 0 or r >= R or c < 0 or c >= C: continue if (r, c) in visited: continue result.append((r, c)) visited.add((r, c)) for dr, dc in ((0, 1), (1, 0), (0, -1), (-1, 0)): queue.append((r + dr, c + dc)) return result
def find_step_cnt(table, red, blue, hole): visited = [ [red, blue] ] que = deque([[red, blue, 0]]) while len(que) > 0: next = que.popleft() red_pos, blue_pos, trial = next[0], next[1], next[2] for dir in [ [-1, 0], [1, 0], [0, -1], [0, 1] ]: next_red, next_blue = tilt_table(table, red_pos, blue_pos, hole, dir) if next_blue == hole: continue if next_red == hole: return trial + 1 if [next_red, next_blue] not in visited: visited.append([next_red, next_blue]) que.append([next_red, next_blue, trial + 1]) return -1
def cloneGraph(self, node: 'Node') -> 'Node': if not node: return node queue=deque([node]) head=Node(node.val,[]) visited={ node:head } while queue: node = queue.popleft() for neighbor in node.neighbors: if neighbor in visited: visited[node].neighbors.append(visited[neighbor]) else: queue.append(neighbor) copy=Node(neighbor.val,[]) visited[neighbor]=copy visited[node].neighbors.append(copy) return head
def get_tree_levels(self, level, tree): queue = deque() queue.append((0, self._root)) result = {0: [self.root.data]} while len(queue) != 0: level, current_node = queue.popleft() if level not in result: result[level] = [current_node.data] else: result[level].append(current_node.data) for child in current_node.children: queue.append((level + 1, child)) return result
def BFS(s, G): visit = [False] * (V + 1) D = [0] * (V + 1) Q = deque() Q.append(s) visit[s] = True print(s, end=" ") while Q: v = Q.popleft() for w in G[v]: if not visit[w]: D[w] = D[v] + 1 visit[w] = True Q.append(w) print(w, end=" ") print() return D
while k <= n: dp[i] = min(dp[i], dp[i - k] + 1) k *= 6 k = 1 while k <= n: dp[i] = min(dp[i], dp[i - k] + 1) k *= 9 print(dp[n]) #bfs from collections import deque n = int(input()) max_n = 100000 dp = [10000 for i in range(max_n + 1)] dp[0] = 0 que = deque() que.append(0) while len(que) > 0: v = que.popleft() k = 1 while v + k <= n: if dp[v + k] == 10000: dp[v + k] = dp[v] + 1 que.append(v + k) k *= 6 k = 1 while v + k <= n: if dp[v + k] == 10000: dp[v + k] = dp[v] + 1 que.append(v + k)
Output: [1,#,2,3,#,4,5,6,7,#] Explanation: Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level. -------------------------------------------Tree-Recursion---------------------------------- from collections import deque """ # Definition for a Node. class Node: def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None): self.val = val self.left = left self.right = right self.next = next """ class Solution: def connect(self, root: 'Node') -> 'Node': if not root: return root bfs = deque([root]) while bfs: for i in range(len(bfs)): node = bfs.popleft() if node.left: node.left.next = node.right bfs.append(node.right) return root
#A program to implement List using Queue# import deque queue = deque(["pendrive", "memory", "usb"]) queue.append("computer") queue.append("laptop") queue.popleft() 'pendrive' queue.popleft() 'memory' queue deque(['computer', 'laptop']) print() #A program to implement Dict using Queue# class PriorityQueue(): pq = PriorityQueue() firstDict = {'boy':'short', 'girl':'tall'} secondDict = {'man':'tall', 'woman':'short'} pq.put(secondDict,2) pq.put(firstDict, 1) while not pq.empty(): print(dict['2']) for i in dict: print(i) #A program to implement Tuple using Queue# def worker(): while True: item = q.get() do_work(item) q.task_done()
# for dl, dr in dlr: # nl = cl + dl # nr = cr + dr # logging.info([nl, nr]) # if fields[nl][nr] == "#": # continue # if fields[nl][nr] == "g": # print("Yes") # exit() # stack.append([nl, nr]) # fields[nl][nr] = "#" ###幅優先探索### queue = deque([[sy, sx]]) while queue: cy, cx = queue.popleft() for dy, dx in dyx: ny = cy + dy nx = cx + dx logging.info([ny, nx]) if fields[ny][nx] == "#": continue if fields[ny][nx] == "g": print("Yes") exit() queue.append([ny, nx])
['Mg Mg', 'Aye Aye', 'Mya Mya', 'Ko Ko', 'Phyu Phyu', 'Ni Ni'] >>> students.remove('Mya Mya') >>> students ['Mg Mg', 'Aye Aye', 'Ko Ko', 'Phyu Phyu', 'Ni Ni'] >>> students.pop('Ni Ni') Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object cannot be interpreted as an integer >>> students.pop() 'Ni Ni' >>> students ['Mg Mg', 'Aye Aye', 'Ko Ko', 'Phyu Phyu'] >>> from collections import deque >>> queue = deque(["Eric", "John", "Michael"]) >>> queue.append("Terry") >>> queue.append("Graham") >>> queue deque(['Eric', 'John', 'Michael', 'Terry', 'Graham']) >>> queue.popleft() 'Eric' >>> queue.popleft() 'John' >>> cube = [] >>> for i in range(10): ... cube.append(i**2) ... >>> cube
except: break # output print( x, sep = ' ') print( ''.join( str(x) + ' ' for x in a) ) print( '{:5d}'.format(x) ) # sort a.sort() # list a = [ x for x in range(n) ] a.append(x) # stack stack = [3, 4, 5] # C++ stack.append(6) # push(6) stack.pop() # pop() stack[-1] # top() len(stack) # size() # queue for collections import deque queue = deque([3, 4, 5]) queue.append(6) # push(6) queue.popleft() # pop() queue[0] # front() len(queue) # size()
print(languages) languages = {'Python': 4098, 'Java': 4139, 'C++': 9234} languages['C'] = 3224 print(languages) print(languages) del languages['C++'] print(languages) for k, v in languages.items(): print(k,v) 5. Create a stack and queue. For the queue ensure to use the (from collections import deque) statement at the top of your program. Remember, to use queues , you have to use the following format queue = deque(["Eric", "John", "Michael"]) and use the popleft() and append() methods For the stack, add two elements to the end of the stack and then pop one back out. Print the final stack For the queue, add three elements to the end of the queue and then use popleft() to remove one element from the front of the queue. Print the final queue. SOLUTION: stack = [3, 4, 5] stack.append(6) stack.append(7) stack.pop() print(stack) queue = deque(["Python", "C++", "Java"]) queue.append("C")
m collections import deque K = int(input()) queue = deque([1, 2, 3, 4, 5, 6, 7, 8, 9]) for i in range(K): x = queue.popleft() if x % 10 != 0: queue.append(10 * x + (x % 10) - 1) queue.append((10 * x) + x % 10) if x % 10 != 9: queue.append(10 * x + (x % 10) + 1) print(x)
# Queue Implementation import deque queue = deque(["Eric", "John", "Michael"]) queue.append("Terry") queue.append("Graham") queue.popleft() 'Eric' queue.popleft() 'John' queue deque(['Michael', 'Terry', 'Graham']) #deque coding d = deque('ghi') for elem in d: print(elem.upper()) G H I d.append('j') d.appendleft('f') d deque(['f', 'g', 'h', 'i', 'j']) d.pop() 'j' d.popleft() 'f' list(d)
def testCaseResultFast(r,k,n,gList): g = deque(gList)
def testCaseResultSlow(r,k,n,gList): g = deque(gList)