๋ฌธ์ ๐ค
NxN ํฌ๊ธฐ์ ๋ฏธ๋ก์์ ์ถ๋ฐ์ง์์ ๋ชฉ์ ์ง์ ๋์ฐฉํ๋ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋์ง ํ์ธํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋์ฐฉํ ์ ์์ผ๋ฉด 1, ์๋๋ฉด 0์ ์ถ๋ ฅํ๋ค.
์ฃผ์ด์ง ๋ฏธ๋ก ๋ฐ์ผ๋ก๋ ๋๊ฐ ์ ์๋ค.
๋ค์์ 5x5 ๋ฏธ๋ก์ ์์ด๋ค.
13101
10101
10101
10101
10021
๋ง์ง๋ง ์ค์ 2์์ ์ถ๋ฐํด์ 0์ธ ํต๋ก๋ฅผ ๋ฐ๋ผ ์ด๋ํ๋ฉด ๋งจ ์์ค์ 3์ ๋์ฐฉํ ์ ์๋์ง ํ์ธํ๋ฉด ๋๋ค.
[์
๋ ฅ]
์ฒซ ์ค์ ํ
์คํธ ์ผ์ด์ค ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. 1<=T<=50
๋ค์ ์ค๋ถํฐ ํ ์คํธ ์ผ์ด์ค์ ๋ณ๋ก ๋ฏธ๋ก์ ํฌ๊ธฐ N๊ณผ N๊ฐ์ ์ค์ ๊ฑธ์ณ ๋ฏธ๋ก์ ํต๋ก์ ๋ฒฝ์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. 0์ ํต๋ก, 1์ ๋ฒฝ, 2๋ ์ถ๋ฐ, 3์ ๋์ฐฉ์ด๋ค. 5<=N<=100
[์ถ๋ ฅ]
๊ฐ ์ค๋ง๋ค "#T" (T๋ ํ ์คํธ ์ผ์ด์ค ๋ฒํธ)๋ฅผ ์ถ๋ ฅํ ๋ค, ๊ณ์ฐ๊ฒฐ๊ณผ๋ฅผ ์ ์๋ก ์ถ๋ ฅํ๊ฑฐ๋ ๋๋ ‘error’๋ฅผ ์ถ๋ ฅํ๋ค.
๋ด ํ๐ฆท
# 4875. ๋ฏธ๋ก
# ์ถ๋ฐ์ง์์ ๋ชฉ์ ์ง์ ๋์ฐฉํ๋ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋์ง ํ์ธ
# ๋ง์ง๋ง ์ค์ 2์์ ์ถ๋ฐ, 0์ธ ํต๋ก๋ฅผ ๋ฐ๋ผ ์ด๋ํ๋ฉด ๋งจ ์์ค์ 3์ ๋์ฐฉํ๋์ง
# ์ฌ๋ฐฉ ํ์
dx = [0, 1, 0, -1] # ๋ฒ์ ์ ๋๋ก ํ์ธ
dy = [-1, 0, 1, 0]
def miro(i, j):
global result # ๊ฒฐ๊ณผ๊ฐ ์ ์ญ๋ณ์๋ก ์ค์ ํด์ฃผ๊ธฐ
visited[i][j] = True
for k in range(4):
di = i + dx[k]
dj = j + dy[k] # ํ๋ํ๋ ์ ๊ฒฝ์จ์ ์ ๊ธฐ
if 0 <= di < N and 0 <= dj < N and not visited[di][dj]:
# ํ์์ํ๊ณ 0์ด๋ฉด ์ฌ๊ท
if arr[di][dj] == 0:
miro(di, dj)
# 3 ๋์ฐฉํ๋ฉด ์ฑ๊ณต
elif arr[di][dj] == 3:
result = 1 # ๊ฒฐ๊ณผ๊ฐ ์ฑ๊ณต์ผ๋ก ๋ฐ๊พธ๊ธฐ
break
T = int(input())
for tc in range(1, T + 1):
N = int(input()) # ๋ฏธ๋ก์ ํฌ๊ธฐ
arr = [list(map(int, input().strip())) for _ in range(N)]
# ๋ฐฉ๋ฌธ ๊ฒ์ฌ
visited = [[False for _ in range(N)] for _ in range(N)]
result = 0 # ๊ฒฐ๊ณผ๊ฐ
for i in range(N-1, -1, -1):
for j in range(N-1, -1, -1):
if arr[i][j] == 2:
miro(i, j) # ํจ์์ ์์์ ๋ฃ์ด์ฃผ๊ธฐ
print(f'#{tc} {result}')
๋ฒฝ์ด ์๋๊ณณ์ ํผํด์ ๊ฐ์ผํ๋ค๊ณ ๋ผ๊ณ ๋ผ๊ณ ๋ผํ๋ ํผ์ ์ด๋ฌ๊ณ ์๋ค๊ฐ..
๋ญ๊ฐ ์ค๋ ์ํ์์ ์ฌ์ฉํ(?) ๋ธํ + dfs์์ ๋ฐฐ์ด ๊ฐ๋ ๋ค + ์ฌ๊ท ๋ค ์ฐ๋ฉด ํด๊ฒฐํ ๋ฏ(?)์ผ๋ก ์๊ฐํด๋ณด์์ต๋๋ค์ ๐ค
์ค๊ฐ์ ์ค์ํ ๋ถ๋ถ๋ค ๐ต๐ซ
- ๋ธํ ๋ฒ์ (์ทจ์ค ์ฝ๋ฉํด์ ๊ทธ๋ฐ๊ฐ ์๋ชป ์ ์;;;;
- dj = i + dk[k] (์ญ์ ์๋ชป ์ ์....)
- ์ ๋ ฅ ๋ฐ์ ๋ strip() ์จ์ฃผ์ง ์์์ ๋ฐํ์์๋ฌ ๋ฐ์.... => ์ฌ์ค ์์ง๋ ์ ๋ชจ๋ฅด๊ฒ ์ ์์ธ์ง...
strip()์ ๊ณต๋ฐฑ์ ์ ๊ฑฐํ๋ฉด ๋๋๊ฑฐ์๋์??
split()์ ์ ์ ์ด์ฃผ๋ฉด ๋๋ค ์๋๊ฐ์??
์์๋ ๋ฉ์ง๋ถ์ ๋๊ธ ๊ธฐ๋ค๋ฆฌ๊ณ ์๊ฒ ์ต๋๋ค...
์ฐธ๊ณ ํจ๋ฉด ์ข์ ๊ฐ๋ ๋ค โ๏ธ
1) ๋ธํ๋ฅผ ์ด์ฉํ 2์ฐจ ๋ฐฐ์ด ํ์
: 2์ฐจ ๋ฐฐ์ด์ ํ ์ขํ์์ 4๋ฐฉํฅ์ ์ธ์ ๋ฐฐ์ด ์์๋ฅผ ํ์ํ๋ ๋ฐฉ๋ฒ(8๋ฐฉ๋ ๊ฐ๋ฅ)
arr[0...N-1][0...N-1] # N * N ๋ฐฐ์ด
di = [0, 1, 0, -1] # ํ, ์ฐ, ์, ์ข
dj = [1, 0, -1, 0]
for i in range(N):
for j in range(N): # ์ฌ๊ธฐ๊น์ง๋ ์ฐ๋ฆฌ๊ฐ ํํ์๋ ์ด์ฐจ์ ๋ฐฐ์ด
for k in range(4): # ๋ธ์ฐจ๋ฅผ ์ด์ฉ
ni = i + di[k]
nj = j + dj[k]
if 0 <= ni < N and 0 <= nj < N: # ๋ฒ์์ ์์ ๋ค์ด์๋ ์ธ๋ฑ์ค๋ฉด...
f(arr[ni][nj]) # ์ด ์ ์ ๊ธฐ์ค์ผ๋ก ๋ํด์ฃผ๋ ๊ฐ์๋ฅผ ์ธ์ฃผ๋ ๋ ๋์๊ฐ๋ ๋ฌด๊ถ๋ฌด์งํ ๋ฌธ์ ๋ค์ด ๋์ฌ ์ ์๋ค
2) ์ฌ๊ท๋ฅผ ํ์ฉํ dfs
: ์ฌ๊ท๋ฅผ ํ์ฉํจ์ผ๋ก์จ ์ฝ๊ฒ dfs๋ฅผ ๊ตฌํํ ์ ์๋ค(๋ด์ฉ์ ์์ฌ์... ์ดํดํ๊ธฐ ํ๋ค์์..)
def dfs(v):
global visited
# print(v, "-", end='')
visited[v] = True # ์ด๊ฑฐ์ ํด๋นํ๋ฉด ์งํ
# v ๋
ธ๋์์ ๊ฐ ์ ์๋ ๋
ธ๋๋ฅผ ํ์ธ (์ธ์ ํ ๋
ธ๋)
for u in graphs[v]:
if visited[u] == True: # ๋ฐฉ๋ฌธ์ ํ๋ค๋ฉด
continue
# ๋ฐฉ๋ฌธ์ ํ์ง ์์๋ค๋ฉด ๋ฐฉ๋ฌธ์ ์งํ
else: # u๊ฐ visited์์ ๋ค์ด์์ง ์๋ค๋ฉด u๋ฅผ ๋ค์ dfs ํด์ฃผ๋ฉด ๋๋ค
dfs(u) # ๋ชจ๋ ์์๊ฐ ๋ค ๋์๊ฐ์ ๋ชจ๋ ์์๊ฐ ํธ๋ฃจ๋ก ๋ฐ๋๋ฉด ๋๋๋ค.
'algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
swea 4874. Forth (ํ์ ํ๊ธฐ๋ฒ ๊ณ์ฐํ๊ธฐ) (0) | 2023.08.19 |
---|---|
๋ฐฑ์ค 1920. ์์ฐพ๊ธฐ (set(), Binary Search) (0) | 2023.08.15 |
[๋ฐฑ์ค/์คํ] 9012. ๊ดํธ (์ง๊ธ์ง๊ธ ๐ ๐ ๐ ) (4) | 2023.08.10 |
[๋ฐฑ์ค - ๋ธ๋ฃจํธ ํฌ์ค]19532. ์ํ์ ๋น๋๋ฉด๊ฐ์์ ๋๋ค (2) | 2023.08.09 |
๋ฐฑ์ค ์ฌํ 10988 ํฐ๋ฆฐ๋๋กฌ์ธ์ง ํ์ธํ๊ธฐ (2) | 2023.07.28 |