[BOJ][๐ก4][๋ฐฑ์ค#01987] ์ํ๋ฒณ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold IV
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
์ธ๋ก R์นธ, ๊ฐ๋ก C์นธ์ผ๋ก ๋ ํ ๋ชจ์์ ๋ณด๋๊ฐ ์๋ค. ๋ณด๋์ ๊ฐ ์นธ์๋ ๋๋ฌธ์ ์ํ๋ฒณ์ด ํ๋์ฉ ์ ํ ์๊ณ , ์ข์ธก ์๋จ ์นธ (1ํ 1์ด) ์๋ ๋ง์ด ๋์ฌ ์๋ค. ๋ง์ ์ํ์ข์ฐ๋ก ์ธ์ ํ ๋ค ์นธ ์ค์ ํ ์นธ์ผ๋ก ์ด๋ํ ์ ์๋๋ฐ, ์๋ก ์ด๋ํ ์นธ์ ์ ํ ์๋ ์ํ๋ฒณ์ ์ง๊ธ๊น์ง ์ง๋์จ ๋ชจ๋ ์นธ์ ์ ํ ์๋ ์ํ๋ฒณ๊ณผ๋ ๋ฌ๋ผ์ผ ํ๋ค. ์ฆ, ๊ฐ์ ์ํ๋ฒณ์ด ์ ํ ์นธ์ ๋ ๋ฒ ์ง๋ ์ ์๋ค. ์ข์ธก ์๋จ์์ ์์ํด์, ๋ง์ด ์ต๋ํ ๋ช ์นธ์ ์ง๋ ์ ์๋์ง๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋ง์ด ์ง๋๋ ์นธ์ ์ข์ธก ์๋จ์ ์นธ๋ ํฌํจ๋๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ R๊ณผ C๊ฐ ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. (1 โค R,C โค 20) ๋์งธ ์ค๋ถํฐ R๊ฐ์ ์ค์ ๊ฑธ์ณ์ ๋ณด๋์ ์ ํ ์๋ C๊ฐ์ ๋๋ฌธ์ ์ํ๋ฒณ๋ค์ด ๋น์นธ ์์ด ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ง์ด ์ง๋ ์ ์๋ ์ต๋์ ์นธ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์์ 1
์ ๋ ฅ
2 4
CAAB
ADCB
์ถ๋ ฅ
3
์์ 2
์ ๋ ฅ
3 6
HFDFFB
AJHGDH
DGAGEH
์ถ๋ ฅ
6
์์ 3
์ ๋ ฅ
5 5
IEFCJ
FHFKC
FFALF
HFGCF
HMCHH
์ถ๋ ฅ
10
My Sol
maxCnt = 0
I, J = map(int, input().split())
mat = [list(input()) for _ in range(I)]
visits = [[[] for _ in range(J)] for _ in range(I)]
visits[0][0].append((1, 0^(1<<(ord(mat[0][0])-65))))
cntSet = set()
Q = set()
Q.add((0, 0))
while Q:
ni, nj = Q.pop()
while visits[ni][nj]:
cntNow, visit = visits[ni][nj].pop()
needCnt = 1
for di, dj in ((-1,0),(1,0),(0,-1),(0,1)):
si, sj = ni+di, nj+dj
if not (0<=si<I and 0<=sj<J): continue
if visit&(1<<(ord(mat[si][sj])-65)): continue
needCnt = 0
visits[si][sj].append((cntNow+1, visit|(1<<(ord(mat[si][sj])-65))))
Q.add((si, sj))
if needCnt:
maxCnt = max(maxCnt, cntNow)
print(maxCnt)
๋ฉ๋ชจ๋ฆฌ์ ์๊ฐ ๋ชจ๋ ๊ณ ๋ คํด์ผ ํ๋ ๋ฌธ์ ์๋ค. ๊ฐ ์ํ๋ฒณ์ ord๋ก ASCII๋ฌธ์ ์ซ์๋ก ๋ฐ๊พผ ๋ค, ๋นํธ๋ง์คํน์ ์ฌ์ฉํด visit์ ์ ์ฅํ์๋ค. ์ฆ, A๋ผ๋ฉด 0๋ฒ์งธ, B๋ผ๋ฉด 1๋ฒ์งธ ์ฒดํฌ๋ฅผ ๋งค ์ขํ๋ง๋ค ๋์๊ณ , ๋งค๋ฒ ์๋ฅผ ์ธ์ง ์๊ธฐ ์ํด ํ์ ์ขํ๊ฐ visit์ด ๊ฐ๋ฅํ๋ค๋ฉด cnt๋ฅผ 1 ์ถ๊ฐํ ๊ฐ๊ณผ ํจ๊ป visit ์ฒดํฌํ์ฌ tuple๋ก ์ ์ฅํ์๋ค.
ํ์ ์ขํ์์ ๋ ์ฃผ๋ณ ์ธ์ ์ขํ๋ก visitํ ์ ์๋์ง ํ์ธํด์ผํ๋ฏ๋ก Q์ ์ง์ด๋ฃ๊ณ Q์์ ๋งค๋ฒ ์ขํ๋ฅผ ๊บผ๋ด์ ์ธ์ ์ขํ๋ก ์ด๋ํ ์ ์๋์ง ํ์ธํ๋ค๊ฐ ๊ฒฐ๊ตญ ๋ชจ๋ Q์์ ์ด๋ํ ์ ์๋ ์ขํ๊ฐ ์๋ค๋ฉด ์ข ๋ฃํ๋ ๊ฒ์ด๋ค.
์ด๋ค ๊ธฐ์ค์ ์์ ์ํ์ข์ฐ ์ธ์ ์ขํ๋ฅผ ๋ชจ๋ visitํ ์ ์๋ค๋ฉด needCnt๊ฐ 0์ผ๋ก ๊ฐฑ์ ๋์ง ์์ maxCnt๋ฅผ cntNow์ ๋น๊ตํ์ฌ ๊ฐฑ์ ํด์ค๋ค.
์ด๋ ค์ ๋ ์
ํ์ ์ขํ๋ฅผ Q์ ์ถ๊ฐํ๋ ๊ณผ์ ์์ ๊น์ด๊ฐ ๊น์ด์ง์๋ก ์ค๋ณต๋๋ ์ขํ๋ค์ด ๋ง์์ก๊ณ , ์ต์ด deque๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ set์ผ๋ก ๋ฐ๊พธ์ด add์ pop ํด์ฃผ์๋ค. deque๋ฅผ ์ฌ์ฉํ๋ฉด popleft๋ฅผ ์ฌ์ฉํ ์ ์์ง๋ง, ๊ตณ์ด ์ถ๊ฐ๋ ์์๋๋ก ํ ํ์ ์์ด Q๊ฐ ์กด์ฌํ๋๋์๋ง ์งํํ๋ฉด ๋๋ฏ๋ก ์ค๋ณต์ขํ๋ฅผ ํ๊ธฐ์ ์ผ๋ก ์ค์ผ ์ ์๋ ๋ฐฉ๋ฒ์ด์๋ค.
๊ทธ๋ฆฌ๊ณ ์ต์ด์๋ visits์ ๊ฐ ์ขํ์ visitํ ์ ์์ผ๋ฉด visit ์ฒดํฌ ํ visit๋ง ์ถ๊ฐํ์๋ค. ๊ทธ๋ฐ๋ฐ ์ํ์ข์ฐ๋ก ์ด๋ํ ์ ์์ ๋ visit์ ๊ฐ ์๋ฆฌ์ 1์ด ์๋ค๋ฉด cnt๋ฅผ 1 ์ฌ๋ฆฌ๊ณ toggle ํ๋ฉฐ ๋นํธ๋ฐฉ์์ผ๋ก cnt๋ฅผ ์ผ ๋ค์, visit์ด 0์ด ๋๋ฉด cnt๋ฅผ maxCnt์ ๋น๊ตํ๋ ๋ฐฉ์์ ์ฌ์ฉํ์๋ค. ๊ทธ๋ฐ๋ฐ visit์ด ๋ง์์ง๋ฉด์ ์๊ฐ ์ด๊ณผ์ ์ฃผ๋ฒ์ด ๋์๊ณ , tuple ๋ฐฉ์์ผ๋ก cnt๋ฅผ ํ ๋ฒ์ maxCnt์ ๋น๊ตํ์ฌ ๊ฐฑ์ ํ๋๋ก ํ์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
import sys
read = sys.stdin.readline
R, C = map(int, read().split())
graph = [read().strip() for _ in range(R)]
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
def bfs(a, b):
q = {(a, b, graph[a][b])}
check = [['' for _ in range(C)] for _ in range(R)]
check[a][b] = graph[a][b]
result = 1
while q:
x, y, track = q.pop()
result = max(result, len(track))
if result == 26:
break
for i in range(4):
nx, ny = x + dx[i], y + dy[i]
# ์ขํ nx, ny์ ๊ธฐ์ค์ผ๋ก (ํ์ฌ ์์น์ ์ ์ฅ๋์ด ์๋ ๊ฒฐ๊ณผ ์ ์ด์ ๊ฒฐ๊ณผ + graph ํ์ฌ ์์น) ๊ฐ ๋ค๋ฅด๋ค๋ฉด
# check nx, ny์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๋ค.
if 0 <= nx < R and 0 <= ny < C and graph[nx][ny] not in track and check[nx][ny] != track + graph[nx][ny]:
check[nx][ny] = track + graph[nx][ny]
q.add((nx, ny, check[nx][ny]))
return result
print(bfs(0, 0))
์ฐ์ฐ์๊ฐ์ด ํ๊ธฐ์ ์ผ๋ก ์งง์ ํ์ด๋ฅผ ๋ฐ๊ฒฌํ์ฌ ๋ถ์ํ๋ค. ์ญ์ q๋ set์ ์ด์ฉํ์ฌ ์ถ๊ฐํด์ฃผ์๋ค. ๋ฌธ์์ด์ ๋ถ์ฌ๊ฐ๋ฉฐ ๋ถ์ฌ์จ ๊ฒฝ๋ก ๋ฌธ์์ด ๋ด์ ํ์ ์ขํ์ ๋ฌธ์์ด์ด ์๋ ๊ฒฝ์ฐ๋ฅผ not in์ ์ด์ฉํด ํ์ธํด์ฃผ์๋ค.
์ธ์์ ์ธ ๋ถ๋ถ์ ํ์ ์ขํ์ visitํ ์ ์๋ค๋ฉด ํด๋น ์ขํ์ ๊ฐ๊น์ง ๊ฒฝ๋ก์ ๋ถ์ฌ ๊ฐฑ์ ํด์ฃผ๋๋ฐ, ์ด๋ฏธ ๋ค๋ฅธ ๊ฒฝ๋ก๋ก ํด๋น ์ขํ์ ์ ์ฅ์ด ๋์ด์๋ ๊ฒฝ์ฐ ๊ฒฝ๋ก๊ฐ ๋งค๋ฒ ๋ค๋ฅธ๋ฐ check์ ๋ฎ์ด์์๋ ๋๋๊ฐ ํ๋ ์๊ฐ์ด ๋ ๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ