DOing
[์๊ณ ๋ฆฌ์ฆ] DFS with Python ๋ณธ๋ฌธ
๐ก DFS ์๊ณ ๋ฆฌ์ฆ
Depth-First Search, ๊ทธ๋ํ์์ ๊น์ ๋ถ๋ถ์ ์ฐ์ ์ ์ผ๋ก ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
๋ฐ์ดํฐ์ ๊ฐฏ์๊ฐ N๊ฐ์ธ ๊ฒฝ์ฐ, O(N)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
๐ก DFS ๋์๊ณผ์
1. ํ์ ์์ ๋ ธ๋๋ฅผ ์คํ์ ์ฝ์ ํ๊ณ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ๋ฅผ ํ๋ค.
2. ์คํ์ ์ต์๋จ ๋ ธ๋์ ๋ฐฉ๋ฌธํ์ง ์์ ์ธ์ ๋ ธ๋๊ฐ ์๋ค๋ฉด, ๊ทธ ์ธ์ ๋ ธ๋๋ฅผ ์คํ์ ๋ฃ๊ณ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ๋ฅผ ํ๋ค.
๋ฐฉ๋ฌธํ์ง ์์ ์ธ์ ๋ ธ๋๊ฐ ์์ผ๋ฉด, ์คํ์์ ์ต์๋จ ๋ ธ๋๋ฅผ ๊บผ๋ธ๋ค.
3. 2๋ฒ๊ณผ์ ์ ๋์ด์ ์ํํ ์ ์์ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
[์ฐธ๊ณ ]
๊ทธ๋ํ์ ๋ ๋ ธ๋๊ฐ ๊ฐ๋์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์๋ค๋ฉด '๋ ๋ ธ๋๋ ์ธ์ ํ๋ค'๋ผ๊ณ ํํํ๋ค.
DFS์์ ์ธ์ ํ ๋ ธ๋๊ฐ ์ฌ๋ฌ๊ฐ ์ผ ์ ์๋ค. ๊ทธ๋์ ์คํ์ ์ด๋ ํ ๋ ธ๋๋ถํฐ ๋ฐฉ๋ฌธํ ๊ฒ์ธ์ง์ ๋ํ ๊ธฐ์ค์ด ํ์ํ๋ค. ์ด๋ ๋ฌธ์ ๋ง๋ค ๋ค๋ฅผ ์๋ ์๊ณ ์์๊ฐ ์๊ด์์ ์ ์๋ค. ํ์ฌ ํฌ์คํ ์์๋ ๋ฎ์ ์๋ถํฐ ๋ฐฉ๋ฌธํ๋ค ๊ฐ์ ํ๋ค.
๐ก DFS ๊ตฌํ ์ฝ๋
DFS๋ ์คํ ์๋ฃ๊ตฌ์กฐ์ ๊ธฐ์ดํ๋ค๋ ์ ์์ ๊ตฌํ์ด ๊ฐ๋จํ๋ค.
์ค์ ๊ตฌํ์ ์คํ์ ์ง์ ์ฌ์ฉํ์ง ์๊ณ ์ฌ๊ทํจ์๋ฅผ ์ด์ฉํ ์ ์๋ค.
def dfs(graph, n, visited):
# ํ์ฌ ๋
ธ๋๋ฅผ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ
visited[n] = True
print(n, end='')
# ํ์ฌ ๋
ธ๋์ ์ธ์ ํ ๋
ธ๋๋ฅผ ํ์ธ
for i in graph[n]:
# ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋๋ผ๋ฉด
if not visited[n]:
# ์ฌ๊ทํธ์ถ
dfs(graph, i, visited)
######## dfs ์ฌ์ฉ
# ๊ฐ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ์ ๋ณด๋ฅผ 2์ฐจ์ ๋ฆฌ์คํธ๋ก ํํ
graph =[
[], # ๋
ธ๋๋ฒํธ๊ฐ 1๋ถํฐ ์์ํ๊ธฐ ๋๋ฌธ์ ์ธ๋ฑ์ค 0์ ๋น์๋๋ค
[2,3,8], # 1๋ฒ ๋
ธ๋์ ์ธ์ ํ ๋
ธ๋ 2,3,8
[1,7],
[1,4,5],
[3,5],
[3,4],
[7],
[2,6,8],
[1,7]
]
# ๊ฐ ๋
ธ๋๊ฐ ๋ฐฉ๋ฌธ๋ ์ ๋ณด
visited = [False]*(8+1) # ์ ์ฒด ๋
ธ๋๊ฐฏ์ 8๊ฐ+์ธ๋ฑ์ค0
# dfs ํธ์ถ
dfs(graph, 1, visited)
๐ก DFS ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์
Q1. ์๋ฃ์ ์ผ๋ ค ๋จน๊ธฐ
N*M ํฌ๊ธฐ์ ์ผ์ํ์ด ์๋ค. ๊ตฌ๋ฉ์ด ๋ซ๋ ค ์๋ ๋ถ๋ถ์ 0, ์นธ๋ง์ด๊ฐ ์กด์ฌํ๋ ๋ถ๋ถ์ 1๋ก ํ์๋๋ค. ๊ตฌ๋ฉ์ด ๋ซ๋ ค์๋ ๋ถ๋ถ๋ผ๋ฆฌ ์,ํ,์ข,์ฐ๋ก ๋ถ์ด ์๋ ๊ฒฝ์ฐ ์๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํ๋ค. ์ด๋ ์ผ์ ํ์ ๋ชจ์์ด ์ฃผ์ด์ก์ ๋ ์์ฑ๋๋ ์ด ์์ด์คํฌ๋ฆผ์ ๊ฐฏ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
* ์ ๋ ฅ ์กฐ๊ฑด
- ์ฒซ์งธ์ค์ ์ผ์ ํ์ ์ธ๋ก ๊ธธ์ด N๊ณผ ๊ฐ๋ก๊ธธ์ด M์ด ์ฃผ์ด์ง๋ค.(1<= N,M <= 1000)
- ๋์งธ์ค๋ถํฐ N+1๋ฒ์งธ ์ค๊น์ง ์ผ์ํ์ ํํ๊ฐ ์ฃผ์ด์ง๋ค.
- ์ด๋ ๊ตฌ๋ฉ์ด ๋ซ๋ ค์๋ ๋ถ๋ถ์ 0, ๊ทธ๋ ์ง ์์ ๋ถ๋ถ์ 1์ด๋ค.
* ์ถ๋ ฅ ์กฐ๊ฑด
- ํ๋ฒ์ ๋ง๋ค ์ ์๋ ์์ด์คํฌ๋ฆผ์ ๊ฐฏ์๋ฅผ ์ถ๋ ฅํ๋ค.
* ์ ๋ ฅ ์์
4 5
00110
00011
11111
00000
* ์ถ๋ ฅ ์์
3
[๋ฌธ์ ์์ด๋์ด]
'์,ํ,์ข,์ฐ๋ก ๋ถ์ด ์๋ ๊ฒฝ์ฐ ์๋ก ์ฐ๊ฒฐ๋์ด์๋ค๊ณ ๊ฐ์ฃผํ๋ค'์์ DFS๋ฅผ ๋ ์ฌ๋ฆด ์ ์์๋ค. ๋์๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ๋ค.
1. ํน์ ํ ์ง์ ์ ์, ํ, ์ข, ์ฐ๋ฅผ ์ดํด๋ณธ ๋ค์ ๊ฐ์ด 0์ด๋ฉด์ ์์ง ๋ฐฉ๋ฌธํ์ง ์์ ์ง์ ์ด ์๋ค๋ฉด ํด๋น ์ง์ ์ ๋ฐฉ๋ฌธํ๋ค.
(=๋ฐฉ๋ฌธํ์ง ์์ ์ธ์ ๋ ธ๋๊ฐ ์๋ค๋ฉด ๋ฐฉ๋ฌธํ๋ค.)
2. ๋ฐฉ๋ฌธํ ์ง์ ์์ ๋ค์ ์, ํ, ์ข, ์ฐ๋ฅผ ์ดํด๋ณด๋ฉด์ ๋ฐฉ๋ฌธ์ ์งํํ๋ฉด, ์ฐ๊ฒฐ๋ ๋ชจ๋ ์ง์ ์ ๋ฐฉ๋ฌธํ ์ ์๋ค.
3. ์ ์ฒด ์ผ์ํ์ ๋ํด์ 1~2๋ฅผ ๋ฐ๋ณตํ๋ฉฐ ๋ง๋ค ์ ์๋ ์์ด์คํฌ๋ฆผ์ ๊ฐฏ์๋ฅผ ์ผ๋ค.
[์ฝ๋]
๊ตฌํ์, visited ๋ฆฌ์คํธ๊ฐ ๊ตณ์ด ํ์ํ์ง ์๋ค.
graph๊ฐ 0, 1๋ก๋ง ์ด๋ฃจ์ด์ ธ์๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ visited๋ก ์ฌ์ฉํ ์ ์๋ค.
# ์ธ๋กn, ๊ฐ๋กm
n, m = map(int, input().split())
# 2์ฐจ์ ๋งต์ ๋ณด ์
๋ ฅ๋ฐ๊ธฐ
graph=[]
for i in range(n):
graph.append(list( map(int, input()) ))
# dfs๋ก ํน์ ํ ๋ฐฉ๋ฌธํ ๋ค์ ์ธ์ ๋
ธ๋๋ค๋ ๋ฐฉ๋ฌธ
def dfs(x,y):
# ์ฃผ์ด์ง ๋ฒ์๋ฅผ ๋ฒ์ด๋ ์์ ์ข
๋ฃ
if x<0 or y<0 or x>n-1 or y>m-1:
return False
# ๋ฐฉ๋ฌธํ ์ ์๋ ๋
ธ๋๋ผ๋ฉด ๋ฐฉ๋ฌธ
if graph[x][y]==0:
graph[x][y]=1 # ๋ฐฉ๋ฌธ์ฒ๋ฆฌ
# ์ธ์ ํ ๋
ธ๋๋ค(์ํ์ข์ฐ)์ ๋ํด ๋ฐ๋ณต ์ํ
dfs(x-1,y) # ์
dfs(x+1,y) # ํ
dfs(x,y-1) # ์ข
dfs(x,y+1) # ์ฐ
return True
return False
# ์์ด์คํฌ๋ฆผ ์ ์ธ๊ธฐ
result = 0
for i in range(n):
for j in range(m):
# ํ์ฌ ์์น์์ DFS ์ํ
# ์ ์ด์ 1์ด์๊ฑฐ๋ ๋ฐฉ๋ฌธํ์ฌ 1์ด๋์๊ฑฐ๋ ๋ฒ์๋ฅผ ๋ฒ์ด๋ ๊ฒฝ์ฐ๋ผ๋ฉด
# false๋ฅผ ๋ฆฌํดํ๋ค.
# ๋ง์ฝ True๋ผ๋ฉด ์ด์ ์ ๋ฐฉ๋ฌธํ์ง ์์ ์๋ก์ด ์์ด์คํฌ๋ฆผ์ด๋ค
if dfs(i,j) == True:
result +=1
print(result)
--> ์ถํ์ ์ถ๊ฐ์์
๐ก DFS ๊ด๋ จ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์
Q1. ์์ค์ ๋์ดํธ
์์ค ์ ์์ ์ฒด์คํ๊ณผ ๊ฐ์ 8*8์ขํ ํ๋ฉด์ด๋ค. ์์ค ์ ์์ ํน์ ํ ํ ์นธ์ ๋์ดํธ๊ฐ ์์๋ค. ๋์ดํธ๋ ์ด๋ํ ๋ L์ ํํ๋ก๋ง ์ด๋ํ ์ ์์ผ๋ฉฐ ์ ์ ๋ฐ์ผ๋ก๋ ๋๊ฐ ์ ์๋ค. ๋์ดํธ๋ ํน์ ํ ์์น์์ ๋ค์๊ณผ ๊ฐ์ 2๊ฐ์ง ๊ฒฝ์ฐ๋ก ์ด๋ํ ์ ์๋ค.
1) ์ํ์ผ๋ก ๋์นธ ์ด๋ํ ๋ค์ ์์ง์ผ๋ก ํ์นธ ์ด๋
2) ์์ง์ผ๋ก ๋์นธ ์ด๋ํ ๋ค์ ์ํ์ผ๋ก ํ์นธ ์ด๋
์ด์ฒ๋ผ 8*8์ขํ ํ๋ฉด์์์ ๋์ดํธ ์์น๊ฐ ์ฃผ์ด์ก์ ๋ ๋์ดํธ๊ฐ ์ด๋ํ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ด๋ ์์ค์ ์ ์์์ ํ ์์น๋ฅผ ํํํ ๋๋ 1๋ถํฐ 8๋ก ํํํ๋ฉฐ, ์ด ์์น๋ฅผ ํํํ ๋๋ a๋ถํฐ h๋ก ํํํ๋ค. ์๋ฅผ ๋ค์ด ๋ง์ฝ ๋์ดํธ๊ฐ a1์ ์์ ๋ ์ด๋ํ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ c2,b3 ๋๊ฐ์ง ์ด๋ค. c2์ ์์นํด ์๋ค๋ฉด ๊ฒฝ์ฐ์ ์๋ 6๊ฐ์ง ์ด๋ค.
*์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ์ค์ 8*8 ์ขํํ๋ฉด ์์์ ํ์ฌ ๋์ดํธ๊ฐ ์์นํ ๊ณณ์ ์ขํ๋ฅผ ๋ํ๋ด๋ ๋๋ฌธ์๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ด ์ ๋ ฅ๋๋ค. ์ ๋ ฅ๋ฌธ์๋ a1์ฒ๋ผ ์ด๊ณผ ํ์ผ๋ก ์ด๋ค์ง๋ค.
*์ถ๋ ฅ ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๋์ดํธ๊ฐ ์ด๋ํ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ถ๋ ฅํ์์ค.
*์ ๋ ฅ ์์
a1
*์ถ๋ ฅ ์์
2
[๋ฌธ์ ์์ด๋์ด]
์๋ฎฌ๋ ์ด์ ๋ฌธ์ ์ ํ์ด๋ค. ์ํ์ข์ฐ์ ๋น์ทํ ๋ฌธ์ ์ธ๋ฐ, ์ขํ์ค์ ์์ ์ฐจ์ด๊ฐ ์๋ค.
์์คํค ์ฝ๋๋ก 'a'๋ 97 ์ด๊ณ 'z'๋ 122์์ ์์๋์.
[์ฝ๋]
position = input()
# ์ด๋๋ฐฉํฅ ์ ์
move_col = [2, 2, -2, -2, 1, 1, -1, -1]
move_row = [1, -1, 1, -1, 2, -2, 2, -2]
# ์ด๋ ๊ฐ๋ฅํ ๋ฐฉํฅ์ ๊ฐฏ์ ๊ตฌํ๊ธฐ
count = 0
for i in range(len(move_col)):
next_col = ord(position[0]) + move_col[i]
next_row = int(position[1]) + move_row[i]
# ํด๋น ๋ฐฉํฅ์ผ๋ก ์ด๋ ๊ฐ๋ฅ ์ฌ๋ถ
if ord('a')<=next_col<=ord('h') and 1<=next_row<=8:
count += 1
print(count)
'์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์ ๋ ฌ with Python (1) | 2021.05.22 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] BFS with Python (1) | 2021.05.22 |
[์๊ณ ๋ฆฌ์ฆ] ๊ตฌํ with Python (0) | 2021.05.21 |
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ฆฌ๋(ํ์๋ฒ) with Python (0) | 2021.05.20 |
์ ๊ทํํ์ (0) | 2021.05.19 |