[BOJ][๐ก5][๋ฐฑ์ค#03190] ๋ฑ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
ย โDummyโ ๋ผ๋ ๋์ค๊ฒ์์ด ์๋ค. ์ด ๊ฒ์์๋ ๋ฑ์ด ๋์์ ๊ธฐ์ด๋ค๋๋๋ฐ, ์ฌ๊ณผ๋ฅผ ๋จน์ผ๋ฉด ๋ฑ ๊ธธ์ด๊ฐ ๋์ด๋๋ค. ๋ฑ์ด ์ด๋ฆฌ์ ๋ฆฌ ๊ธฐ์ด๋ค๋๋ค๊ฐ ๋ฒฝ ๋๋ ์๊ธฐ์์ ์ ๋ชธ๊ณผ ๋ถ๋ชํ๋ฉด ๊ฒ์์ด ๋๋๋ค. ๊ฒ์์ NxN ์ ์ฌ๊ฐย ๋ณด๋์์์ ์งํ๋๊ณ , ๋ช๋ช ์นธ์๋ย ์ฌ๊ณผ๊ฐ ๋์ฌ์ ธ ์๋ค. ๋ณด๋์ ์ํ์ข์ฐ ๋์ ๋ฒฝ์ด ์๋ค. ๊ฒ์์ด ์์ํ ๋ ๋ฑ์ ๋งจ์ ๋งจ์ข์ธก์ ์์นํ๊ณ ๋ฑ์ ๊ธธ์ด๋ 1 ์ด๋ค. ๋ฑ์ ์ฒ์์ ์ค๋ฅธ์ชฝ์ ํฅํ๋ค. ๋ฑ์ ๋งค ์ด๋ง๋ค ์ด๋์ ํ๋๋ฐ ๋ค์๊ณผ ๊ฐ์ ๊ท์น์ ๋ฐ๋ฅธ๋ค.
๋จผ์ ๋ฑ์ ๋ชธ๊ธธ์ด๋ฅผ ๋๋ คย ๋จธ๋ฆฌ๋ฅผย ๋ค์์นธ์ ์์น์ํจ๋ค. ๋ง์ฝ ์ด๋ํ ์นธ์ ์ฌ๊ณผ๊ฐ ์๋ค๋ฉด, ๊ทธ ์นธ์ ์๋ ์ฌ๊ณผ๊ฐ ์์ด์ง๊ณ ๊ผฌ๋ฆฌ๋ ์์ง์ด์ง ์๋๋ค. ๋ง์ฝ ์ด๋ํ ์นธ์ ์ฌ๊ณผ๊ฐ ์๋ค๋ฉด, ๋ชธ๊ธธ์ด๋ฅผ ์ค์ฌ์ ๊ผฌ๋ฆฌ๊ฐ ์์นํ ์นธ์ ๋น์์ค๋ค. ์ฆ, ๋ชธ๊ธธ์ด๋ ๋ณํ์ง ์๋๋ค.
์ฌ๊ณผ์ ์์น์ ๋ฑ์ ์ด๋๊ฒฝ๋ก๊ฐ ์ฃผ์ด์ง ๋ ์ด ๊ฒ์์ด ๋ช ์ด์ ๋๋๋์ง ๊ณ์ฐํ๋ผ.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ณด๋์ ํฌ๊ธฐ N์ด ์ฃผ์ด์ง๋ค. (2 โค N โค 100) ๋ค์ ์ค์ ์ฌ๊ณผ์ ๊ฐ์ย K๊ฐ ์ฃผ์ด์ง๋ค. (0 โค K โค 100) ๋ค์ K๊ฐ์ ์ค์๋ ์ฌ๊ณผ์ ์์น๊ฐ ์ฃผ์ด์ง๋๋ฐ, ์ฒซ ๋ฒ์งธ ์ ์๋ย ํ, ๋ ๋ฒ์งธ ์ ์๋ย ์ด ์์น๋ฅผ ์๋ฏธํ๋ค.ย ์ฌ๊ณผ์ ์์น๋ ๋ชจ๋ ๋ค๋ฅด๋ฉฐ, ๋งจ ์ ๋งจ ์ข์ธก (1ํ 1์ด) ์๋ ์ฌ๊ณผ๊ฐ ์๋ค. ๋ค์ ์ค์๋ ๋ฑ์ ๋ฐฉํฅ ๋ณํ ํ์ L ์ด ์ฃผ์ด์ง๋ค. (1 โค L โค 100) ๋ค์ L๊ฐ์ ์ค์๋ ๋ฑ์ ๋ฐฉํฅ ๋ณํ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋๋ฐ, ย ์ ์ X์ ๋ฌธ์ C๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ. ๊ฒ์ ์์ ์๊ฐ์ผ๋ก๋ถํฐ X์ด๊ฐ ๋๋ ๋ค์ ์ผ์ชฝ(C๊ฐ โLโ) ๋๋ ์ค๋ฅธ์ชฝ(C๊ฐ โDโ)๋ก 90๋ ๋ฐฉํฅ์ ํ์ ์ํจ๋ค๋ ๋ป์ด๋ค. X๋ 10,000 ์ดํ์ ์์ ์ ์์ด๋ฉฐ, ๋ฐฉํฅ ์ ํ ์ ๋ณด๋ X๊ฐ ์ฆ๊ฐํ๋ ์์ผ๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๊ฒ์์ด ๋ช ์ด์ ๋๋๋์ง ์ถ๋ ฅํ๋ค.
์์
์์ 1
์ ๋ ฅ
6
3
3 4
2 5
5 3
3
3 D
15 L
17 D
์ถ๋ ฅ
9
์์ 2
์ ๋ ฅ
10
4
1 2
1 3
1 4
1 5
4
8 D
10 D
11 D
13 L
์ถ๋ ฅ
21
์์ 3
์ ๋ ฅ
10
5
1 5
1 3
1 2
1 6
1 7
4
8 D
10 D
11 D
13 L
์ถ๋ ฅ
13
My Sol
from collections import deque
def Play():
global mat, arr
hi, hj, hd = 0, 0, 0
mat[hi][hj] = 1
Q = deque()
Q.append((hi, hj))
time = 0
for t, d in arr:
while time < t:
forward = headSee(hi, hj, hd)
if forward==-1: return time + 1
si, sj = forward
fowInfo = mat[si][sj]
mat[si][sj] = 1
Q.append((si, sj))
hi, hj = si, sj
if not fowInfo:
li, lj = Q.popleft()
mat[li][lj] = 0
time += 1
td = -1 if d=='L' else 1
hd += td
if not 0<=hd<4:
hd %= 4
def headSee(i, j, d):
di, dj = dd[d]
si, sj = i+di, j+dj
if not (0<=si<N and 0<=sj<N): return -1
if mat[si][sj]==1: return -1
return si, sj
N = int(input())
mat = [[0]*N for _ in range(N)]
AN = int(input())
for _ in range(AN):
i, j = map(int, input().split())
mat[i-1][j-1] = 4
L = int(input())
arr = []
for _ in range(L):
t, d = input().split()
arr.append((int(t), d))
arr.append((10000,''))
dd = [(0,1), (1,0), (0,-1), (-1,0)]
print(Play())
๋จธ๋ฆฌ์ ์์น์ ๋ฐฉํฅ์ ๋ฐ๋ผ ๋ค์ ์ด๋ํด์ผํ ์ขํ๋ฅผ didj ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํด ๋ง๋ค์๊ณ , ๋ฐฉํฅ์ 0๋ถํฐ 3๊น์ง์ ์ธ๋ฑ์ค๋ก ๋ฐ์ ธ ์กฐํํด์ฃผ์๋ค. ์ด๋ํด์ผํ ์ขํ๊ฐ ๋ฒ์ ์ธ์ด๊ฑฐ๋ ๋ฑ์ ์ ์ฒด๋ผ๋ฉด -1์, ์๋๋ผ๋ฉด ํด๋น ์ขํ๋ฅผ ๋ฐํํ๋ ํจ์ headSee๋ฅผ ๋ง๋ค์๊ณ , ์ด๋ฅผ Play() ํจ์์ ๊ฐ์ ธ๋ค ์ฌ์ฉํ์๋ค.
Play() ํจ์๋ ์กฐ์ ์ ๋ณด๋ง๋ค ํด๋น ์๊ฐ์ ๋๊ธด ์์ ์์ ๋ฐฉํฅ์ ํ์ด์ฃผ๊ณ ๊ณ์ ๋จธ๋ฆฌ์ ๋ฐฉํฅ, ๊ทธ๋ฆฌ๊ณ ๋จธ๋ฆฌ ์์ ์๋ ์ขํ์ ์ ๋ณด์ ๋ฐ๋ผ ๋ชธ์ ๊ธธ์ด๋ฅผ ๊ฒฐ์ ํ๋ค. ๋จธ๋ฆฌ ์์ ์ขํ์ ๊ฐ์ด 0์ด์ด์ ๊ผฌ๋ฆฌ๋ฅผ ๋ค์ ์ค์ด๋ ๊ฒฝ์ฐ, ์ถ๊ฐ๋๋ ๋จธ๋ฆฌ์ ์ ๋ณด๋ฅผ ๋ด๋ deque๋ฅผ ๋ง๋ค์ด, ๊ฐ์ฅ ์ค๋๋ ์ขํ๋ฅผ ๊บผ๋ด ํด๋น ์ขํ๋ฅผ 0์ผ๋ก ์ ๊ฑฐํ๋ ๋ฐฉ์์ ์ฌ์ฉํ์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋๊ธ๋จ๊ธฐ๊ธฐ