BFS(Breadth-First Search)
A -> B
|
v
C -> D
์ ๊ทธ๋ํ๋ฅผ distance layer ํํ๋ก ๋ํ๋ด๋ฉด ์๋์ ๊ฐ๋ค.

์ถ๋ฐ ๋ ธ๋๋ฅผ A๋ผ๊ณ ํ์ ๋ A์ layer๋ 0์ด๋ฉฐ A์ ๊ฐ์ 1๊ฐ๋ก ์ฐ๊ฒฐ๋ C์ B์ layer๋ A๋ฅผ ๊ธฐ์ค์ผ๋ก 1์ด๋ค.

์ด๋ก์์ผ๋ก ๋ ๊ฐ์ ์ ๊ทธ๋ํ์ distance layer์ ์ํฅ์ ์ฃผ์ง ์์ง๋ง, ๋นจ๊ฐ์ ๊ฐ์ ์ ๊ฒฝ์ฐ A์ D์ ๊ฑฐ๋ฆฌ๋ฅผ 2์์ 1๋ก ๋ฐ๊พธ๋ฏ๋ก distance layer ํํ๋ฅผ ๋ณํ๊ฒ ํ๋ค.
BFS
BFS๋ ์ธ์ ํ ์ ์ ๋ค์ ์ฐ์ ์ผ๋ก ํ์ํ๋ ๋ฐฉ๋ฒ์ผ๋ก, ํ๋ฅผ ์ฌ์ฉํ๋ค. ๋ ์ ์ ์ ๊ฑฐ๋ฆฌ(์ต์ ๊ฒฝ๋ก)๋ฅผ ๊ตฌํ๊ณ ์ ํ ๋ ์ฌ์ฉํ๋ฉฐ ์์ฌ์ฝ๋๋ ์๋์ ๊ฐ๋ค.
def BFS(G, start_v):
for u in V:
dist[u] = infinity
start_v = 0
queue = {start_v}
while queue is not empty:
u = dequeue(queue)
for adj_v in adjacent_vertexes(u):
if dist[adj_v] == infinity:
enqueue(adj_v)
dist[adj_v] = dist[u] + 1
BFS์ ์๊ฐ๋ณต์ก๋ = O(|E| + |V|)
๊ฐ ์ ์ ์ ์ต๋ 1๋ฒ ํ์ ์ฝ์
๋๋ค. -> while๋ฌธ์ |V|
๋งํผ ์คํํ๋ค.
์ ์ ์ฌ์ด์ ๊ฐ ๊ฐ์ ์ ํตํด ์ ์ ์ ๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ์ฒดํฌํ๋ค. -> for๋ฌธ์ ์ด ๊ฐ์ ์ ๊ฐฏ์๋งํผ ์คํํ๋ค.
(๋ฐฉํฅ์๋ ๊ทธ๋ํ๋ ๊ฐ์ ์ ๊ฐฏ์ * 2
๋งํผ ์คํํ๋ค.)
์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ (Shortest-path Tree)
์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ๋ ๋ฐฉํฅ์๋ ๊ทธ๋ํ ๋ด์ ๊ฐ ์ ์ ์ฌ์ด์ ๊ฑฐ๋ฆฌ(์ต๋จ ๊ฒฝ๋ก)๋ฅผ ํธ๋ฆฌ๋ก ๋ํ๋ธ๋ค. ์ด๋ค ์ ์ S
๋ฅผ ์์์ผ๋ก BFS๋ฅผ ์คํํ๊ณ ๋์ ๊ฐ ์ ์ ์์ S
๋ก์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ ์ฅํ๋ค. ํธ๋ฆฌ์ ๋ฃจํธ๋ S
๊ฐ ๋๋ค.

๋ฐฉํฅ์๋ ๊ทธ๋ํ์ ์ ์ S
์์ B
๋ก ๊ฐ๋ ์ต๋จ ๊ฒฝ๋ก๋ B
์์ S
๋ก ๊ฐ๋ ์ต๋จ ๊ฒฝ๋ก์ ๊ฐ๋ค. ๋ฐ๋ผ์ ๊ฐ ์ ์ ์์ S
๋ก ํฅํ๋ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ํธ๋ฆฌ ํํ๋ก ๋ง๋ ๊ฒ์ด ์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ๋ค. ์๋ฅผ ๋ค์ด, B
์์ S
๋ก ํฅํ๋ ์ต๋จ ๊ฒฝ๋ก๋ 3์ด๋ค.
์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ฉด
๋ ์ ์ ์ ๊ฑฐ๋ฆฌ(์ต๋จ ๊ฒฝ๋ก)๋ฅผ ๊ตฌํ ์ ์๋ค.
S
->A
์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ํตํดA
->S
์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ ์ ์๋ค.์ด๋ ์ ์ ์ ์์์ ์ผ๋ก ํ์ฌ ๋ชจ๋ ์ ์ ๊ณผ์ ์ต๋จ ๊ฒฝ๋ก๋ค์ ๊ตฌํ ์ ์๋ค.
์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ์ ์ค์ํ ํน์ง ์ค ํ๋๋ ํธ๋ฆฌ๋ก ๋ํ๋ด๋ ๊ทธ๋ํ์ ์ฌ์ดํด์ด ์๋ค๋ ๊ฒ์ด๋ค.

์ ์ S
์ A
์ ๊ฑฐ๋ฆฌ(์ต๋จ ๊ฒฝ๋ก)๊ฐ d
๋ผ๊ณ ํ์ ๋ A
๋ ๋ค๋ฅธ ์ ์ B, C, D, E์ ์ฌ์ดํด์ ์ด๋ฃฌ๋ค๊ณ ๊ฐ์ ํด๋ณด์. A
์์ S
๋ก ํฅํ๋ ์ต๋จ ๊ฒฝ๋ก๋ S
์์ A
๋ก ํฅํ๋ ์ต๋จ ๊ฒฝ๋ก์ ๊ฐ๋ค. ๋ฐ๋ผ์ A
์์ ์ถ๋ฐํ์ฌ ๋ค๋ฅธ ์ ์ ์ผ๋ก ์ด๋ํ ๋๋ง๋ค d
๋ฅผ 1์ฉ ๊ฐ์์์ผ S์ ๋์ฐฉํ์ ๋ 0์ด ๋๋์ง ํ์ธํ๋ ค๊ณ ํ๋ค.

A, B, C, D, E๊ฐ ์ฌ์ดํด์ ์ด๋ฃฐ ๋ ๋ฌดํ์ผ๋ก d
๊ฐ ๊ฐ์๋๋ฏ๋ก A
์์ S
๋ก ํฅํ๋ ์ต๋จ ๊ฒฝ๋ก๋ ๋ง์ด๋์ค ๋ฌดํ๋๊ฐ ๋ ๊ฒ์ด๋ค. ์ด๋ A
์์ S
๋ก ํฅํ๋ ์ต๋จ ๊ฒฝ๋ก๊ฐ d
๋ผ๋ ๊ฐ์ ๊ณผ ๋ชจ์๋๋ฏ๋ก ์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ์ ์ฌ์ดํด์ด ์กด์ฌํ์ง ์์์ ์ฆ๋ช
ํ๋ค.
์๋๋ prev
๋ฐฐ์ด์ ์ด์ ์ ๋ฐฉ๋ฌธํ๋ ์ ์ ์ ์ ์ฅํ์ฌ ์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ๋ฅผ ๋ง๋๋ ์ฝ๋๋ค.
def BFS(G, start_v):
for u in V:
dist[u] = infinity
prev[u] = nil
start_v = 0
queue = {start_v}
while queue is not empty:
u = dequeue(queue)
for adj_v in adjacent_vertexes(u):
if dist[adj_v] == infinity:
enqueue(adj_v)
dist[adj_v] = dist[u] + 1
prev[adj_v] = u
# u์์ S๋ก ํฅํ๋ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ค.
# ์) ConstructPath(S, G, prev) -> (G, B, A, S) ๋ฆฌํด
def ConstructPath(S, u, prev):
result = empty
while u != S:
result.append(u)
u = prev[u]
return reverse(result)
์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ๋ฅผ ์ด์ฉํ์ฌ ๋ ์ ์ ์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ ๋ ์๊ฐ๋ณต์ก๋๋ O(|V| + |E|)
์ด๋ค.
์ถ์ฒ
Last updated
Was this helpful?