Summary for BFS Algorithm
BFS ์๊ณ ๋ฆฌ์ฆ ํ์ด๋ฅผ ์ํ ํ์ ํจ์ ์ด์ ๋ฆฌ
๐์ฝ๋ฉํ ์คํธ์์ BFS ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ๊ผญ ํ์ํ ํจ์ ์ด ์ ๋ฆฌ!!!!!๐
์ฝํ ์ ์ BFS ์๊ณ ๋ฆฌ์ฆ ํ์ ์์ฝ ๋ณด๊ณ ๋ค์ด๊ฐ์ธ์!
๊ณ์ ์ ๋ฐ์ดํธ ํฉ๋๋ค.
Queue ๋ง๋๋ ๋ฐฉ๋ฒ
queue์ 2D node๋ฅผ ์ถ๊ฐํ ๋ ์๊ณต๊ฐ ๋ณต์ก๋๊ฐ ๊ฐ์ฅ ๋ฎ์ ๋ฐฉ๋ฒ.
(ํ์ฌ๊น์ง ์งํํ ์ฌ๋ฌ๊ฐ์ง ํ ์คํธ๋กค ํตํด ๋ด๋ฆฐ ๊ฒฐ๋ก ์ด๋ฉฐ, ํฅํ ๋ณ๊ฒฝ๋ ์ ์๋ค.)
-
from collections import deque
q = deque()
-
q.append((sy, sx))
-
(y, x) = q.popleft()
-
q.append((ny, nx))
Graph ๋ง๋๋ ๋ฐฉ๋ฒ
node์ edge๊ฐ ์ฃผ์ด์ง ๋
11724๋ฒ - ์ฐ๊ฒฐ ์์์ ๊ฐ์
# Make Graph
graph=[[]for i in range(node+1)]
for _ in range(edge):
node1, node2 = map(int,sys.stdin.readline().split())
graph[node1].append(node2)
graph[node2].append(node1)
N X M ์ธ์ ํ๋ ฌ(adjacency matrix)์ด ์ฃผ์ด์ง ๋
2667๋ฒ - ๋จ์ง๋ฒํธ๋ถ์ด๊ธฐ
input = sys.stdin.readline
n = int(input())
graph=[]
for i in range(row):
line = input().split() # returns list ex>['0110100']
graph.append([])
for j in line[0]:
graph[i].append(int(j))
visited = [[0]*column for _ in range(row)]
๋ฌธ์ ์ ํ
๋ชจ๋ ๋ ธ๋ ๋ฐฉ๋ฌธํ ๋
- ๋ ธ๋ n๊ฐ๊ฐ ์ฐ๊ฒฐ๋ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋์ง ๊ตฌํ๊ธฐ
- ๋ชจ๋ ๋ ธ๋ ๋ฐฉ๋ฌธํ๋ฉฐ ๊ทธ ์์ ์ถ๋ ฅํ๊ธฐ
- visited = []์ popํ node๋ฅผ ์ถ๊ฐํ๋ค
- visited๋ฅผ returnํ๋ค
- ์ฐ๊ฒฐ ์์(connected component)์ ๊ฐ์ ๊ตฌํ๊ธฐ
11724๋ฒ - ์ฐ๊ฒฐ ์์์ ๊ฐ์
- for๋ฌธ ์ฌ์ฉํ์ฌ ๋ชจ๋ ๋
ธ๋ ๋ฐฉ๋ฌธ
- ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋๋ง ๋ฐฉ๋ฌธํ๋ค
- BFS
- ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋๋ง ๋ฐฉ๋ฌธํ๋ค
์ผ๋ถ ๋ ธ๋๋ง ์ ํ์ ์ผ๋ก ๋ฐฉ๋ฌธํ ๋: 2D
๐ 1. ๋จผ์ ์์ ๋ ธ๋์ ์์น๊ฐ 2D array index ๋ฒ์ ์์ ์์นํ๋์ง ์กฐ์ฌํ๊ธฐ
โ โ๏ธ ๊ฐ๋ฅํ < ๋๋ >์ ์ฌ์ฉํ์โผ๏ธ <= ๋๋ >= ์ฌ์ฉ์ ํผํ์โผ๏ธ
โ ์๋ฅผ๋ค์ด 0<=ny <= n - 1 ์ ์ฌ์ฉํ์ง ๋ง๊ณ , ์๋ฅผ๋ค์ด 0<=ny < n ์ ์ฌ์ฉํ์.
โ ์ด์ ) <=์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ -1 ์ฐ์ฐ์ ์ถ๊ฐ๋ก ํ๊ฒ ๋๋ฏ๋ก ~ ํจ์จ์ฑ์ด ๋ฎ์์ง๋ค.
โ โ๏ธ์ด ๊ณผ์ ์ด ์ ํ๋์ด์ผ ๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ํ์ธํ ๋ 2D array index ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ error๊ฐ ๋ฐ์ํ์ง ์๋๋ค.
๐ 2. ์ดํ ์์ ๋ ธ๋์ ๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ์กฐ์ฌํ๊ณ , ๋์์ ๋ฐฉ๋ฌธ ์ฌ๋ถ ๋ฆฌ์คํธ์ ํ์ ๋น์ฉ์ ์ ์ฅํ์โผ๏ธ
์์ ๋ ธ๋์ ํ์ ๋น์ฉ์ด ๋์ผํ ๋
๐ ๋ชฉํ node๊น์ง ๋๋ฌํ๋๋ฐ ํ์ํ ์ต์ํ์ edge๊ฐ์/์๊ฐ/์ด๋/๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์?
์ฆ, ํ์ ๊น์ด๋ฅผ countํ ๋
โก๏ธ ๋์ผํ ๋ถ๋ชจ ๋ ธ๋์ ์ฐ๊ฒฐ๋ ์์ ๋ ธ๋๋ผ๋ฉด ๊ฐ์ level์ ๊ฐ์ง๋๋ก ํ๋ค.
์ฆ, ๋ชจ๋ ์์ ๋ ธ๋์ visited ๊ฐ์ ๋ถ๋ชจ ๋ ธ๋์ visited ๊ฐ์ 1์ ์ถ๊ฐํ๋ค.
์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ๋ชฉํ node์ ๋๋ฌํ์ ๋ visitied์ ์ ์ฅ๋ level์ด ์์ฐ์ค๋ฝ๊ฒ ์ต์ edge๊ฐ์/์๊ฐ/์ด๋/๊ฑฐ๋ฆฌ๊ฐ ๋๋ค.
1D: ๋ค์ํ ๋ฐฉํฅ
- ์ต๋จ ๊ฒฝ๋ก๋ก ์ด๋ํ ๋ ์ง๋๊ฐ๋ ๋ ธ๋๋ฅผ print ํ๊ธฐ
BFS ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ๊ฐ์ level์ ์์ ๋ ธ๋๋ฅผ node๋ฅผ ๋ฐฉ๋ฌธํ๋ค.
๋ฐ๋ผ์ node๋ฅผ popํ์ฌ ๋ชจ๋ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ผ๋ก๋ ์ต๋จ ๊ฒฝ๋ก๋ฅผ print ํ ์ ์๋ค.
โก๏ธ parent list๋ฅผ ๋ง๋ค์ด์, ์์ ๋ ธ๋ ๋ฐฉ๋ฌธ์ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์ ์ฅํ๋ค.
BFS๋ฅผ ๋ง์น๊ณ ๋์ฐฉํ ๋ ธ๋์ parent list ๊ฐ์ ํ์ธํ์ฌ ์ด์ ์ ๋ฐฉ๋ฌธํ ๋ ธ๋๋ฅผ ์์๋ด๋ ๊ฒ์ ๋ฐ๋ณตํ๋ค.
2D: ์ข ์ฐ ์ ํ
๋ชฉ์ ์ง์ ๋๋ฌํ๊ธฐ ์ํ ์ต์์ ์นธ ์ ๊ตฌํ๊ธฐ
- ๋ชฉ์ ์ง์ ๋๋ฌํ๋ ์ต์ ์ด๋ ๊ฑฐ๋ฆฌ ๊ตฌํ๊ธฐ
- visited = [[0]*node for _ in range(node)]
- for ๋ฌธ์ผ๋ก ๊ฐ๋ฅํ ๋ชจ๋ ์์ ๋
ธ๋ ์กฐ์ฌ (if ๋ฌธ์ผ๋ก ๊ฐ ๊ฒฝ์ฐ๋ฅผ ์กฐ์ฌํ๋ ๊ฒ์ด ๋ ๋น ๋ฅด์ง๋ง ์ฝ๋๊ฐ ๊ธธ์ด์ ธ์ ์์ฑ ์๊ฐ์ด ๋ ์ค๋ ๊ฑธ๋ฆฐ๋ค.)
- ์์ ๋
ธ๋์ row์ column์ด 2D array์ Index ๋ฒ์๋ฅผ ๋ฒ์ด๋์ง ์๋์ง ์กฐ์ฌ
- ๋ฐฉ๋ฌธํ์ง ์์ ์์ ๋
ธ๋๋ง ๋ฐฉ๋ฌธ
- visited[child_y][child_x] = visited[parent_y][parent_x] + 1
- ๋ฐฉ๋ฌธํ์ง ์์ ์์ ๋
ธ๋๋ง ๋ฐฉ๋ฌธ
- ์์ ๋
ธ๋์ row์ column์ด 2D array์ Index ๋ฒ์๋ฅผ ๋ฒ์ด๋์ง ์๋์ง ์กฐ์ฌ
- ์ฐ๊ฒฐ ์์(connected component)์ ๊ฐ์ ๊ตฌํ๊ธฐ
2667๋ฒ - ๋จ์ง๋ฒํธ๋ถ์ด๊ธฐ
- ์์ ๋ ธ๋๊ฐ ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ, ๊ฐ๋ฅํ ๋ชจ๋ ์์ ๋ ธ๋์์ ๋์์ BFS ํ์ํ๊ธฐ
โก๏ธ Queue์์ ๋ชจ๋ ์์ ๋ ธ๋๋ฅผ ์ถ๊ฐํ๋ค. ์ด ๋ฐฉ๋ฒ์ผ๋ก ์ฐจ๋ก๋ก BFS๋ฅผ ์งํํ๊ฒ ๋๋ค.
์๋ฅผ ๋ค์ด ์ด ๋ฌธ์ ์์ [0,0]๊ณผ [3,5]์ ํ ๋งํ ๊ฐ ์กด์ฌํ๋ฏ๋ก, ํ์ ์์ ๋ ธ๋๊ฐ 2๊ฐ๊ฐ ๋๋ค.
๋ฐ๋ผ์ ๋ ๋ ธ๋๋ฅผ queue์ ์ฌ๋ ค์ BFS๋ฅผ ์งํํ๋ฉด์, ์์ ํ ๋งํ ๊ฐ ์ต๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ฑ์์ค๋ค.
๊ทธ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ๋ค.
[[ 1 -1 7 6 5 4] [ 2 -1 6 5 4 3] [ 3 4 5 6 -1 2] [ 4 5 6 7 -1 1]]
2D: ๋ค์ํ ๋ฐฉํฅ
- ๋ชฉ์ ์ง์ ๋๋ฌํ๋ ์ต์ ์ด๋ ๊ฑฐ๋ฆฌ ๊ตฌํ๊ธฐ
dx = [-1,-2,-2,-1,1,2,2,1]
dy = [2,1,-1,-2,-2,-1,1,2]
for i in range(8):
ny, nx = y + dy[i], x + dx[i]
if 0 <= nx < l and 0 <= ny < l and visited[ny][nx] == -1:
q.append((ny, nx))
visited[ny][nx] = visited[y][x] + 1
์์ ๋ ธ๋์ ํ์ ๋น์ฉ์ด ์๋ก ๋ค๋ฅผ ๋
- ์ต๋จ ๊ฒฝ๋ก์ด๋ฉด์ ํ์ ๋น์ฉ์ด ์ต์์ธ ๊ฒฝ๋ก ๊ตฌํ๊ธฐ
1261 ์๊ณ ์คํ, 13549 ์จ๋ฐ๊ผญ์ง 3
โก๏ธ ํ์ ๋น์ฉ์ด ์์ ์์ ๋ ธ๋๋ฅผ queue์ ์์ ์ถ๊ฐํ๊ณ , ํ์ ๋น์ฉ์ด ํฐ ์์ ๋ ธ๋๋ ๋ค์ ์ถ๊ฐํ๋ค.
โ โ๏ธ q.appendleft(), q.append() ๋ฅผ ์ฌ์ฉํ๋ค.
์ด ๋ฐฉ๋ฒ์ ๋น์ฉ์ด ์ ์ ๊ฒฝ๋ก๋ถํฐ ์ฐ์ ์ ์ผ๋ก ํ์ํ๊ณ , ๊ฐ์ฅ ์ ์ ๋น์ฉ์ ๋ํ ํ์์ด ๋๋๊ณ ๋์์ผ ๋น๋ก์ ๋ ํฐ ๋น์ฉ์ ๊ฒฝ๋ก๋ฅผ ํ์ํ๊ธฐ ์์ํ๋ค.
๋ฐ๋ผ์ ์ด ๋ฐฉ๋ฒ์ ํตํด ํ์ ๋น์ฉ๊ณผ ๊ธธ์ด๊ฐ ์ด ์ต์์ธ ๊ฒฝ๋ก๋ฅผ ์ฐพ์ ์ ์๋ค.
- ์ด๋ถ ๊ทธ๋ํ (Bipartite Graph) ํ๋ณํ๊ธฐ
์ด๋ถ ๊ทธ๋ํ๋? ๊ทธ๋ํ์ ์ ์ ์ ์งํฉ์ ๋๋ก ๋ถํ ํ์ฌ, ๊ฐ ์งํฉ์ ์ํ ์ ์ ๋ผ๋ฆฌ๋ ์๋ก ์ธ์ ํ์ง ์๋ ๊ทธ๋ํ์ด๋ค.
โก๏ธ ๋ฐฉ๋ฌธํ์ง ์์ ์์ ๋ ธ๋์ ํ์ ๋น์ฉ ์ ์ฅ์, ๋ถ๋ชจ ๋ ธ๋์ ๊ฐ์ -1์ ๊ณฑํ์ฌ ์๋ก ๋ค๋ฅธ ์งํฉ์์ ํ์ํ๋ค.
๋ง์ฝ ์์ ๋ ธ๋๋ฅผ ์ด๋ฏธ ๋ฐฉ๋ฌธํ์ผ๋ฉฐ, ๋ถ๋ชจ ๋ ธ๋์ ํ์ ๋น์ฉ์ด ๋์ผํ๋ค๋ฉด return false