[BOJ][๐ก5][๋ฐฑ์ค#18405] ๊ฒฝ์์ ์ ์ผ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
NxN ํฌ๊ธฐ์ ์ํ๊ด์ด ์๋ค. ์ํ๊ด์ 1x1 ํฌ๊ธฐ์ ์นธ์ผ๋ก ๋๋์ด์ง๋ฉฐ, ํน์ ํ ์์น์๋ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ ์ ์๋ค. ๋ชจ๋ ๋ฐ์ด๋ฌ์ค๋ 1๋ฒ๋ถํฐ K๋ฒ๊น์ง์ ๋ฐ์ด๋ฌ์ค ์ข ๋ฅ ์ค ํ๋์ ์ํ๋ค. ์ํ๊ด์ ์กด์ฌํ๋ ๋ชจ๋ ๋ฐ์ด๋ฌ์ค๋ 1์ด๋ง๋ค ์, ํ, ์ข, ์ฐ์ ๋ฐฉํฅ์ผ๋ก ์ฆ์ํด ๋๊ฐ๋ค. ๋จ, ๋งค ์ด๋ง๋ค ๋ฒํธ๊ฐ ๋ฎ์ ์ข ๋ฅ์ ๋ฐ์ด๋ฌ์ค๋ถํฐ ๋จผ์ ์ฆ์ํ๋ค. ๋ํ ์ฆ์ ๊ณผ์ ์์ ํน์ ํ ์นธ์ ์ด๋ฏธ ์ด๋ ํ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ๋ค๋ฉด, ๊ทธ ๊ณณ์๋ ๋ค๋ฅธ ๋ฐ์ด๋ฌ์ค๊ฐ ๋ค์ด๊ฐ ์ ์๋ค. ์ํ๊ด์ ํฌ๊ธฐ์ ๋ฐ์ด๋ฌ์ค์ ์์น ์ ๋ณด๊ฐ ์ฃผ์ด์ก์ ๋, S์ด๊ฐ ์ง๋ ํ์ (X,Y)์ ์กด์ฌํ๋ ๋ฐ์ด๋ฌ์ค์ ์ข ๋ฅ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋ง์ฝ S์ด๊ฐ ์ง๋ ํ์ ํด๋น ์์น์ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ฉด, 0์ ์ถ๋ ฅํ๋ค. ์ด ๋ X์ Y๋ ๊ฐ๊ฐ ํ๊ณผ ์ด์ ์์น๋ฅผ ์๋ฏธํ๋ฉฐ, ์ํ๊ด์ ๊ฐ์ฅ ์ผ์ชฝ ์์ ํด๋นํ๋ ๊ณณ์ (1,1)์ ํด๋นํ๋ค. ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ด 3x3 ํฌ๊ธฐ์ ์ํ๊ด์ด ์๋ค๊ณ ํ์. ์๋ก ๋ค๋ฅธ 1๋ฒ, 2๋ฒ, 3๋ฒ ๋ฐ์ด๋ฌ์ค๊ฐ ๊ฐ๊ฐ (1,1), (1,3), (3,1)์ ์์นํด ์๋ค. ์ด ๋ 2์ด๊ฐ ์ง๋ ๋ค์ (3,2)์ ์กด์ฌํ๋ ๋ฐ์ด๋ฌ์ค์ ์ข ๋ฅ๋ฅผ ๊ณ์ฐํด๋ณด์.
1์ด๊ฐ ์ง๋ ํ์ ์ํ๊ด์ ์ํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
2์ด๊ฐ ์ง๋ ํ์ ์ํ๊ด์ ์ํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก 2์ด๊ฐ ์ง๋ ๋ค์ (3,2)์ ์กด์ฌํ๋ ๋ฐ์ด๋ฌ์ค์ ์ข ๋ฅ๋ 3๋ฒ ๋ฐ์ด๋ฌ์ค๋ค. ๋ฐ๋ผ์ 3์ ์ถ๋ ฅํ๋ฉด ์ ๋ต์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์์ฐ์ N, K๊ฐ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. (1 โค N โค 200, 1 โค K โค 1,000) ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฑธ์ณ์ ์ํ๊ด์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ์ N๊ฐ์ ์์๋ก ๊ตฌ์ฑ๋๋ฉฐ, ํด๋น ์์น์ ์กด์ฌํ๋ ๋ฐ์ด๋ฌ์ค์ ๋ฒํธ๊ฐ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. ๋จ, ํด๋น ์์น์ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ 0์ด ์ฃผ์ด์ง๋ค. ๋ํ ๋ชจ๋ ๋ฐ์ด๋ฌ์ค์ ๋ฒํธ๋ K์ดํ์ ์์ฐ์๋ก๋ง ์ฃผ์ด์ง๋ค. N+2๋ฒ์งธ ์ค์๋ S, X, Y๊ฐ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. (0 โค S โค 10,000, 1 โค X, Y โค N)
์ถ๋ ฅ
S์ด ๋ค์ (X,Y)์ ์กด์ฌํ๋ ๋ฐ์ด๋ฌ์ค์ ์ข ๋ฅ๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ S์ด ๋ค์ ํด๋น ์์น์ ๋ฐ์ด๋ฌ์ค๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ฉด, 0์ ์ถ๋ ฅํ๋ค.
์์
์์ 1
์ ๋ ฅ
3 3
1 0 2
0 0 0
3 0 0
2 3 2
์ถ๋ ฅ
3
์์ 2
์ ๋ ฅ
3 3
1 0 2
0 0 0
3 0 0
1 2 2
์ถ๋ ฅ
0
My Sol
def main():
def find_position():
P = [set() for _ in range(K+1)]
for i in range(N):
for j in range(N):
P[mat[i][j]].add((i, j))
mn, mx = 1, K
while not P[mn]: mn += 1
while not P[mx]: mx -= 1
return P, mn, mx
def move():
def move_one(i, j):
v = mat[i][j]
for di, dj in ((-1,0),(1,0),(0,-1),(0,1)):
si, sj = i+di, j+dj
if not (0<=si<N and 0<=sj<N): continue
if mat[si][sj]: continue
mat[si][sj] = v
add_set.add((si, sj))
for v in range(mn, mx+1):
if not P[v]: continue
add_set = set()
for i, j in P[v]:
move_one(i, j)
P[v] = add_set
N, K = map(int, input().split())
mat = [list(map(int, input().split())) for _ in range(N)]
S, X, Y = map(int, input().split())
P, mn, mx = find_position()
for _ in range(S):
move()
while not P[mn] and mn < mx: mn+=1
while not P[mx] and mn < mx: mx-=1
return mat[X-1][Y-1]
print(main())
์ฌ๋ฐฉ์ ํ์ธํ๋ ๊ทธ๋ํ ๋ฌธ์ ์๋ค. ์ด๋ ต์ง ์๊ฒ ํ ์ ์์๋ค.
- ์ ๋ ฅ์ ๋ฐ๋๋ค.
- 1๋ถํฐ K๊น์ง์ ๋ฐ์ด๋ฌ์ค ์ข
๋ฅ๊ฐ ์์ผ๋ฏ๋ก
P
๋ผ๋ ๋ฆฌ์คํธ์ K+1๊ฐ์ set์ ์ฑ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ต์ด ์ ๋ ฅ๋ฐ์mat
์ ๋ฐ์ด๋ฌ์ค ์ข ๋ฅ์ ๋ฐ๋ฅธ ์ขํ ์ ๋ณด๋ฅผ ์ ์ฅํ๋ค. ๋ํ ์กฐํ์ ์์๊ณผ ๋์ด ๋mn
๊ณผmx
๋ฅผ ๊ณ์ฐํ์ฌ ํจ๊ป ๋ฐํํ๋ค. ์ด๋ฅผ ๋ถ๋ฆฌํ ํจ์๊ฐfind_position
์ด๋ค. - ๋ฐ์ด๋ฌ์ค์ ์ด๋์ด S๋ฒ ๋ฐ๋ณตํ๋ฏ๋ก, for๋ฌธ์ผ๋ก
move
ํจ์๋ฅผ ์คํํ๊ณ , ์ด๋์ ๋ฐ๋ผ ์กฐํ์ ๋ฒ์๋ฅผ ๋งค๋ฒ ์ฌํ์ธํ๊ธฐ ์ํดmn
๊ณผmx
์ ํฌ๊ธฐ๋ฅผ ํ์ธํด ์กฐํ ๋ฒ์๋ฅผ ์ขํ์ค๋ค. - ๋ฒํธ๊ฐ ์์ ๋ฐ์ด๋ฌ์ค๋ถํฐ ์์ญ์ ํ์ฅํด๋๊ฐ๊ธฐ ๋๋ฌธ์ mn๋ถํฐ mx๊น์ง
P
์ ๊ฐ set์ ์์ ์ธ๋ฑ์ค๋ถํฐ ์กฐํํดmove_one
ํจ์๋ฅผ ์คํํ๋move
ํจ์๋ฅผ ์์ฑํ์๋ค. move_one
ํจ์๋ ์ธ์๋ก ๋ฐ์ ์ขํ์ ์ํ์ข์ฐ๋ฅผ ํ์ธํ์ฌ N์ ๋ฒ์ ๋ด์ด๋ฉด์ ์ด๋ฏธ ์ ์ ํ ๋ฐ์ด๋ฌ์ค๊ฐ ์๋ ๊ฒฝ์ฐ ํด๋น ์ขํ์ ๋ฐ์ด๋ฌ์ค์ ๋ฒํธ๋ฅผ ์ถ๊ฐํ๊ณP
์ ์ขํ๊ฐ set์ ๊ฐฑ์ ํ๊ธฐ ์ํadd_set
์ ํ์ฅ ์ขํ๋ฅผ ์ถ๊ฐํ๋ค. ํ ๋ฒํธ์ ๋ฐ์ด๋ฌ์ค์ ํ์ฅ์ด ๋๋๋ฉด ๊ธฐ์กด ์ขํ๋ ๋ค์ ํ์ํ ํ์๊ฐ ์์ผ๋ฏ๋ก ์๋กญ๊ฒ ์ถ๊ฐ๋add_set
์ P์ ํด๋น ๋ฒํธ์ set์ผ๋ก ๊ฐฑ์ ํด์ค๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋๊ธ๋จ๊ธฐ๊ธฐ