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)
