์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- URLSession
- ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ
- ํ๋ก๊ทธ๋๋จธ์ค
- binarySearch
- GroupBy
- ๊ธฐ์ด๋ฌธ๋ฒ
- APPJAM
- SOPT
- GCD
- algorithm
- 0์ด๋์ด์๋๊ธธ
- ์ฐ์ํ์ค๋ถ๋ถ์์ด์ํฉ
- duno
- SwiftUI ํํ ๋ฆฌ์ผ
- DynamicProgramming
- SQL
- Til
- dfs
- SwiftUI Tutorials
- ๋์ ๊ณํ๋ฒ
- BFS
- HAVIT
- discardableResult
- ์ด์งํ์
- ๊ณ ๋์ kit
- algoritm
- SwiftUI
- Swift
- IOS
- concurrency
- Today
- Total
suvera-dev ๐ฅฆ
Algorithm) DFS/BFS ์ค์ ๋ฌธ์ ๋ณธ๋ฌธ
๐บ 1๋ฒ ์๋ฃ์ ์ผ๋ ค๋จน๊ธฐ
N x M ํฌ๊ธฐ์ ์ผ์ ํ์ด ์๋ค. ๊ตฌ๋ฉ์ด ๋ซ๋ ค ์๋ ๋ถ๋ถ์ 0, ์นธ๋ง์ด๊ฐ ์กด์ฌํ๋ ๋ถ๋ถ์ 1๋ก ํ์๋๋ค.
๊ตฌ๋ฉ์ด ๋ซ๋ ค์๋ ๋ถ๋ถ๋ผ๋ฆฌ ์,ํ,์ข,์ฐ๋ก ๋ถ์ด ์๋ ๊ฒฝ์ฐ ์๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํ๋ค.
์ด๋ ์ผ์ ํ์ ๋ชจ์์ด ์ฃผ์ด์ก์ ๋ ์์ฑ๋๋ ์ด ์์ด์คํฌ๋ฆผ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑ
==> DFS๋ก ํด๊ฒฐ ! ์ผ์์ ์ผ๋ฆด ์ ์๋ ๊ณต๊ฐ์ด ์ํ์ข์ฐ๋ก ์ฐ๊ฒฐ๋์ด์๋ค๊ณ ํํํ ์ ์์ผ๋ฏ๋ก ๊ทธ๋ํ ํํ๋ก ๋ชจ๋ธ๋ง ๊ฐ๋ฅ !
1) ํน์ ํ ์ง์ ์ ์ฃผ๋ณ ์ํ์ข์ฐ๋ฅผ ์ดํด๋ณธ ๋ค์ ์ฃผ๋ณ ์ง์ ์ค์์ ๊ฐ์ด 0 ์ด๋ฉด์ ์์ง ๋ฐฉ๋ฌธํ์ง ์์ ์ง์ ์ด ์๋ค๋ฉด ํด๋น ์ง์ ๋ฐฉ๋ฌธ
2) ๋ฐฉ๋ฌธํ ์ง์ ์์ ๋ค์ ์ํ์ข์ฐ๋ฅผ ์ดํด๋ณด๋ฉด์ ๋ฐฉ๋ฌธ์ ๋ค์ ์งํํ๋ฉฐ, ์ฐ๊ฒฐ๋ ๋ชจ๋ ์ง์ ๋ฐฉ๋ฌธ ๊ฐ๋ฅ
3) 1-2๋ฒ์ ๊ณผ์ ์ ๋ชจ๋ ๋ ธ๋์ ๋ฐ๋ณตํ์ฌ ๋ฐฉ๋ฌธํ์ง ์์ ์ง์ ์ ์๋ฅผ ์ผ๋ค !
#N,M์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์
๋ ฅ๋ฐ๊ธฐ
n, m = map(int, input())
# 2์ฐจ์ ๋ฆฌ์คํธ์ ๋งต ์ ๋ณด ์
๋ ฅ๋ฐ๊ธฐ
graph = []
for i in range(n):
graph.append(list(map(int, input())))
# DFS๋ก ํน์ ํ ๋
ธ๋๋ฅผ ๋ฐฉ๋ฌธํ ๋ค์ ์ฐ๊ฒฐ๋ ๋ชจ๋ ๋
ธ๋๋ค๋ ๋ฐฉ๋ฌธ !
def dfs(x, y):
#์ฃผ์ด์ง ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ์๋ ์ฆ์ ์ข
๋ฃ
if x <= -1 or x >= n or y <= -1 or y >= m:
return false
# ํ์ฌ ๋
ธ๋๋ฅผ ์์ง ๋ฐฉ๋ฌธํ์ง ์์๋ค๋ฉด
if graph[x][y] == 0:
# ํด๋น ๋
ธ๋ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ
graph[x][y] == 1
# ์ํ์ข์ฐ ์์น๋ ๋ชจ๋ ์ฌ๊ท์ ์ผ๋ก ํธ์ถ
dfs(x -1, y)
dfs(x, y -1)
dfs(x+1, y)
dfs(x, y+1)
return True
return False
# ๋ชจ๋ ๋
ธ๋์ ๋ํ์ฌ ์๋ฃ์ ์ฑ์ฐ๊ธฐ
result = 0
for i in range(n):
for j in range(m):
# ํ์ฌ ์์น์์ DFS ์ํ
if dfs(i, j) == True:
result += 1
print(result)
DFS ๋ฅผ ์ฌ์ฉํด์ ๊ตฌ๋ถ๋ ๊ณต๊ฐ์ ์ ๋ถ ๋ฐฉ๋ฌธํ๋ค ! - ์ด์ด์ ธ ์๋ ๊ณณ์ ํ์์ด ๋๋ฌ์ ๊ฒฝ์ฐ true๋ฅผ ๋ฐํํ์ฌ 1๊ฐ์ ์์ญ์ด ์ธ์ด์ง๊ฒ ๋๋ค !
๋ชจ๋ ๋ ธ๋๋ค์ ๋ํด์ ์ํํ๋ค !
๐ 2๋ฒ ๋ฏธ๋ก ํ์ถ
๋๋น์ด๋ N x M ํฌ๊ธฐ์ ์ง์ฌ๊ฐํ ํํ์ ๋ฏธ๋ก์ ๊ฐํ์๋ค. ๋ฏธ๋ก์๋ ์ฌ๋ฌ ๋ง๋ฆฌ์ ๊ดด๋ฌผ์ด ์์ด ์ด๋ฅผ ํผํด ํ์ถํด์ผํ๋ค.
๋๋น์ด์ ์์น๋ (1,1) ์ด๊ณ ๋ฏธ๋ก์ ์ถ๊ตฌ๋ (N, M)์ ์์น์ ์กด์ฌํ๋ฉฐ ํ๋ฒ์ ํ ์นธ์ฉ ์ด๋ ํ ์ ์๋ค.
์ด๋ ๊ดด๋ฌผ์ด ์๋ ๋ถ๋ถ์ 0์ผ๋ก, ๊ดด๋ฌผ์ด ์๋ ๋ถ๋ถ์ 1๋ก ํ์๋์ด ์๋ค.
๋ฏธ๋ก๋ ๋ฐ๋์ ํ์ถํ ์ ์๋ ํํ๋ก ์ ์๋๋ค. ์ด๋ ๋๋น์ด๊ฐ ํ์ถํ๊ธฐ ์ํด ์์ง์ฌ์ผ ํ๋ ์ต์ ์นธ์ ๊ฐ์.
๋ง์ง๋ง ์นธ๊ณผ ์์์นธ์ ๋ชจ๋ ํฌํจํ์ฌ ๊ณ์ฐ
==> BFS ๋ก ํด๊ฒฐ ! BFS๋ ์์ ์ง์ ์์ ๊ฐ๊น์ด ๋ ธ๋๋ถํฐ ์ฐจ๋ก๋๋ก ๊ทธ๋ํ์ ๋ชจ๋ ๋ ธ๋๋ฅผ ํ์ํ๋ค !
๊ทธ๋ฌ๋ฏ๋ก 1,1 ์์ BFS๋ฅผ ์ํํ์ฌ ๋ชจ๋ ๋ ธ๋์ ๊ฐ์ ๊ฑฐ๋ฆฌ ์ ๋ณด๋ก ๋ฃ์ ! ํน์ ๋ ธ๋์ ๋ฐฉ๋ฌธํ๋ฉด ๊ทธ ์ด์ ๋ ธ๋์ ๊ฑฐ๋ฆฌ์ 1์ ๋ํ ๊ฐ์ ๋ฆฌ์คํธ์ ๋ฃ๋๋ค. ์ฐธ๊ณ ๋ก, ๋ณธ ๋ฌธ์ ์์๋ ๋จ์ํ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์์น๋ก ์ด๋ํ๋ ๊ฒ์ ์๊ตฌํ๊ธฐ ๋๋ฌธ์ ๋ค์ ๋์๊ฐ ๊ฒฝ์ฐ ๋์๊ฐ ๊ณณ์ ์์น๊ฐ์ด ์ฆ๊ฐํ๋ ๊ฒฝ์ฐ๋ ์๋ค !
from collections import deque
n,m = map(int, input().split())
graph = []
for i in range(n):
graph.append(list(map(int, input())))
# ์ด๋ํ ๋ค ๋ฐฉํฅ ์ ์ - ์ํ์ข์ฐ
dx = [-1,1,0,0]
dy = [0,0,-1,1]
# BFS ์์ค์ฝ๋ ๊ตฌํ
def bfs(x, y):
# ํ ๊ตฌํ์ ์ํด deque ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ
queue = deque()
queue.append((x,y))
# ํ๊ฐ ๋น๋๊น์ง ๋ฐ๋ณต
while queue:
x, y = queue.popleft()
# ํ์ฌ ์์น์์ ๋ค ๋ฐฉํฅ์ผ๋ก์ ์์น ํ์ธ
for i in range(4)
nx = x + dx[i]
ny = y + dy[i]
# ๋ฏธ๋ก ๊ณต๊ฐ์ ๋ฒ์ด๋ ๊ฒฝ์ฐ ๋ฌด์
if nx < 0 or ny < 0 or nx >= n or ny >= m:
continue
# ๋ฒฝ์ธ ๊ฒฝ์ฐ ๋ฌด์
if graph[nx][ny] == 0:
continue
# ํด๋น ๋
ธ๋๋ฅผ ์ฒ์ ๋ฐฉ๋ฌธํ๋ ๊ฒฝ์ฐ์๋ง ์ต๋จ ๊ฑฐ๋ฆฌ ๊ธฐ๋ก
if graph[nx][ny] == 1:
graph[nx][ny] = graph[x][y] + 1
queue.append((nx, ny))
# ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋๊น์ง์ ์ต๋จ ๊ฑฐ๋ฆฌ ๋ฐํ
return graph[n-1][m-1]
# ๊ฒฐ๊ณผ ์ถ๋ ฅ
print(bfs(0,0))
'Algorithm > CodingTest - Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Algorithm) Sorting ๊ธฐ๋ณธ๋ฌธ์ (0) | 2022.04.07 |
---|---|
Algorithm) Sorting (0) | 2022.04.03 |
Algorithm) DFS/BFS (0) | 2022.04.02 |
Algorithm) ์๋ฃ๊ตฌ์กฐ ๊ธฐ์ด (Feat. DFS์ BFS์ ๋ค์ด๊ฐ๊ธฐ ์ ..) (1) | 2022.04.01 |
Algorithm ) Implementation (0) | 2022.04.01 |