[Baekjoon/๐ฅGoldโ ฃ] 14500: ํ ํธ๋ก๋ฏธ๋ ธ
๐โโ๏ธ ํ ํธ๋ก๋ฏธ๋ ธ
๋ฌธ์ ์ ๋ํ ์์ธํ ์ค๋ช ์ ์ ํ์ด์ง๋ฅผ ์ฐธ๊ณ !!
๐โโ๏ธ ์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ข ์ด์ ์ธ๋ก ํฌ๊ธฐ N๊ณผ ๊ฐ๋ก ํฌ๊ธฐ M์ด ์ฃผ์ด์ง๋ค. (4 โค N, M โค 500)
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ข ์ด์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. i๋ฒ์งธ ์ค์ j๋ฒ์งธ ์๋ ์์์๋ถํฐ i๋ฒ์งธ ์นธ, ์ผ์ชฝ์์๋ถํฐ j๋ฒ์งธ ์นธ์ ์ฐ์ฌ ์๋ ์์ด๋ค. ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ์๋ 1,000์ ๋์ง ์๋ ์์ฐ์์ด๋ค.
๐โโ๏ธ ์ถ๋ ฅ
์ฒซ์งธ ์ค์ ํ ํธ๋ก๋ฏธ๋ ธ๊ฐ ๋์ธ ์นธ์ ์ฐ์ธ ์๋ค์ ํฉ์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
๐ฉโ๐ป Algoritm: Brute Force
ํ์์ ๊ฒฝ์ฐ, ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์ง์ ๋ฐฐ์ด์ ๋ฃ์ด ํ์ธํ๋ ๋ฐฉ์์ผ๋ก ๋ธ๋ฃจํธ ํฌ์ค๋ฅผ ์ ์ฉํ์๋ค.
import sys
n, m = map(int, sys.stdin.readline().split())
answer = 0
graph = []
for _ in range(n):
graph.append(list(map(int, sys.stdin.readline().split())))
dx = [(0, 1, 2, 3), (0, 0, 0, 0), (0, 0, 0, 1), (0, 1, 2, 2), (0, 1, 1, 1)
, (0, 1, 1, 1), (0, 0, 1, 2), (0, -1, -1, -1), (0, -1, -1, -2), (0, 0, 1, 1), (0, 0, -1, -1)
, (0, 1, 1, 2), (0, 1, 1, 2), (0, -1, 0, 1), (0, 0, 0, 1), (0, 0, 0, -1), (0, 0, 1, 1), (0, 0, 1, 2), (0, 0, -1, -2)]
dy = [(0, 0, 0, 0), (0, 1, 2, 3), (0, 1, 2, 2), (0, 0, 0, -1), (0, 0, 1, 2)
, (0, 0, -1, -2), (0, 1, 1, 1), (0, 0, 1, 2), (0, 0, 1, 1), (0, 1, 1, 2), (0, 1, 1, 2)
, (0, 0, 1, 1), (0, 0, 1, 0), (0, 1, 1, 1), (0, 1, 2, 1), (0, 1, 2, 1), (0, 1, 1, 0), (0, -1, -1, -1), (0, -1, -1, -1)]
for i in range(n):
for j in range(m):
for k in range(19):
s = 0
for l in range(4):
ny = i+dy[k][l]
nx = j+dx[k][l]
if 0<=ny<n and 0<=nx<m:
s += graph[ny][nx]
else:
break
answer = max(answer, s)
print(answer)
ํ์ง๋ง ์ด๋ ๊ฒ ์ผ์ผ์ด ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ง์ ๊ตฌํ๋ ๋ฐฉ๋ฒ ๋ง๊ณ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์์๊น ์๊ฐํ๋ค ๋ค๋ฅธ ๋ถ์ ํ์ด๋ฅผ ๋ณด๊ณ dfs๋ฅผ ์ฌ์ฉํ ์ ์๋ค๋ ์ ์ ๋ฐ๊ฒฌํ๋ค.
๊ทธ๋ ๋ค๋ฉด ์ง๊ธ๋ถํฐ dfs๋ฅผ ํตํด ํ์ด๋ฅผ ์งํํด๋ณด์!!
๐ฉโ๐ป Algorithm: dfs
์๋ ๊ทธ๋ฆผ์ ๋ํ๋ค์ ํ์ , ๋์นญ ์ ๋ง๋ค์ด์ง๋ ๋ชจ๋ ๋ํ๋ค์ ๊น์ด 3์ธ dfs๋ฅผ ํตํด์ ๊ตฌํ ์ ์๋ค.
๊ทธ๋ ๋ค๋ฉด ๊ทธ ์ด์ ๋ ๋ฌด์์ผ๊น?
-
์ฐ์ ์ ๋ํ๋ค์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ํ๋์ ์ ์ผ๋ก ์ด์ ์ ์๋ค. ๋ฐ๋ผ์ dfs๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
-
ํ ํธ๋ก๋ฏธ๋ ธ์ ๊ฒฝ์ฐ, 4๊ฐ์ ์ ์ฌ๊ฐํ์ผ๋ก ์ด๋ฃจ์ด์ก๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๊น์ด 3๋งํผ์ ์ด๋ํด ์ด 4๊ฐ์ ์ ์ฌ๊ฐํ์ผ๋ก ์ด๋ฃจ์ด์ง ๋ชจ๋ ๋ํ์ ํ์ธํ ์ ์๊ฒ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ๋๋จธ์ง ํ ๋ํ์ ๊ฒฝ์ฐ๋ ์ด๋ป๊ฒ ์ฒ๋ฆฌํด์ผ ํ ๊น?
๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ํด๋น ๋ํ์ ์์์ ์ผ๋ก๋ถํฐ ์ํ์ข์ฐ ์ค ์ธ๊ฐ์ง ์์๋ง์ ๊ณ ๋ คํ๋ฉด ๋๋ค. ์ด๋ ์ dfs ๊ณผ์ ๊ณผ๋ ๋ณ๋๋ก ์ถ๊ฐ์ ์ผ๋ก ์งํํ๋ฉด ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ์๋์ ์ฝ๋๋ฅผ ํตํด์ ์กฐ๊ธ ๋ ์ ํํ ๊ทธ ๊ณผ์ ์ ์ดํดํด๋ณด์!!
import sys
n, m = map(int, sys.stdin.readline().split())
graph = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
visited = [[0]*m for _ in range(n)]
# ์ต๋๊ฐ
maxValue = 0
# ์ํ์ข์ฐ๋ฅผ ๋ํ๋ด๋ ์ขํ
dy = [0, 0, -1, 1]
dx = [-1, 1, 0, 0]
def dfs(y, x, s, t):
global maxValue
if t == 4: # ์์์ (1)์์ ๊น์ด๊ฐ 3์ผ ๊ฒฝ์ฐ
maxValue = max(maxValue, s)
return
for i in range(4):
ny = y + dy[i]
nx = x + dx[i]
if 0<=ny<n and 0<=nx<m and visited[ny][nx] == 0:
visited[ny][nx] = 1
dfs(ny, nx, s+graph[ny][nx], t+1)
visited[ny][nx] = 0
# ใ
, ใ
, ใ
, ใ
์ ๊ฒฝ์ฐ
def shapeHats(y, x):
global maxValue
for i in range(4):
tmp = graph[y][x] # ์์์ง์ ์ผ๋ก ์ด๊ธฐ๊ฐ ์ค์
for j in range(3): # ์ํ์ข์ฐ ์ค ์ธ์์๋ง ๊ณ ๋ ค
ny = y + dy[(i+j)%4]
nx = x + dx[(i+j)%4]
if not (0<=ny<n and 0<=nx<m):
tmp = 0
break
tmp += graph[ny][nx]
maxValue = max(maxValue, tmp)
# ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ํ์
for i in range(n):
for j in range(m):
visited[i][j] = 1
dfs(i, j, graph[i][j], 1)
visited[i][j] = 0
shapeHats(i, j) # dfs์ ๋ณ๋๋ก ์ถ๊ฐ ์งํ
print(maxValue)
๐โโ๏ธ TIL
์ฒ์ ๋ชจ์์ด ์ ๊ฐ๊ฐ์ธ ๋ํ์ ์ต๋๊ฐ์ ์ด๋ป๊ฒ ๊ตฌํด์ผํ ์ง ๊ฐ์ด ์ ์ค์ง ์์๋ค.
ํ์ง๋ง ๋ฌธ์ ์์ ์ฃผ๋ชฉํด์ผ ํ ๋ถ๋ถ์ ๋ํ์ ๋ชจ์๋ค์ด ์๋๋ผ ๋ํ์ ํน์ง์ด์๋ค. ํ๋์ ์ ์ผ๋ก ์ด์ด์ง๊ธฐ์ **dfs๋ฅผ ์ ์ฉํ ์ ์์๊ณ , ๋ํ์ ๊ตฌ์ฑ ์ ์ฌ๊ฐํ์ ์์ ๋ฐ๋ผ์ ๊ทธ ๊น์ด๋ฅผ ์ง์ ํ ์ ์์๋ค.
dfs์ ์๋ก์ด ์ ๊ทผ๋ฒ์ ๋ํด ํ์ตํ ์ ์์๋ ๊ฒ ๊ฐ๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ