๐ณ ๋งํฌ
๐ ๋ฌธ์
'Dummy' ๋ผ๋ ๋์ค๊ฒ์์ด ์๋ค. ์ด ๊ฒ์์๋ ๋ฑ์ด ๋์์ ๊ธฐ์ด๋ค๋๋๋ฐ, ์ฌ๊ณผ๋ฅผ ๋จน์ผ๋ฉด ๋ฑ ๊ธธ์ด๊ฐ ๋์ด๋๋ค. ๋ฑ์ด ์ด๋ฆฌ์ ๋ฆฌ ๊ธฐ์ด๋ค๋๋ค๊ฐ ๋ฒฝ ๋๋ ์๊ธฐ์์ ์ ๋ชธ๊ณผ ๋ถ๋ชํ๋ฉด ๊ฒ์์ด ๋๋๋ค.
๊ฒ์์ NxN ์ ์ฌ๊ฐ ๋ณด๋์์์ ์งํ๋๊ณ , ๋ช๋ช ์นธ์๋ ์ฌ๊ณผ๊ฐ ๋์ฌ์ ธ ์๋ค. ๋ณด๋์ ์ํ์ข์ฐ ๋์ ๋ฒฝ์ด ์๋ค. ๊ฒ์์ด ์์ํ ๋ ๋ฑ์ ๋งจ์ ๋งจ์ข์ธก์ ์์นํ๊ณ ๋ฑ์ ๊ธธ์ด๋ 1 ์ด๋ค. ๋ฑ์ ์ฒ์์ ์ค๋ฅธ์ชฝ์ ํฅํ๋ค.
๋ฑ์ ๋งค ์ด๋ง๋ค ์ด๋์ ํ๋๋ฐ ๋ค์๊ณผ ๊ฐ์ ๊ท์น์ ๋ฐ๋ฅธ๋ค.
๋จผ์ ๋ฑ์ ๋ชธ๊ธธ์ด๋ฅผ ๋๋ ค ๋จธ๋ฆฌ๋ฅผ ๋ค์์นธ์ ์์น์ํจ๋ค.
๋ง์ฝ ์ด๋ํ ์นธ์ ์ฌ๊ณผ๊ฐ ์๋ค๋ฉด, ๊ทธ ์นธ์ ์๋ ์ฌ๊ณผ๊ฐ ์์ด์ง๊ณ ๊ผฌ๋ฆฌ๋ ์์ง์ด์ง ์๋๋ค.
๋ง์ฝ ์ด๋ํ ์นธ์ ์ฌ๊ณผ๊ฐ ์๋ค๋ฉด, ๋ชธ๊ธธ์ด๋ฅผ ์ค์ฌ์ ๊ผฌ๋ฆฌ๊ฐ ์์นํ ์นธ์ ๋น์์ค๋ค. ์ฆ, ๋ชธ๊ธธ์ด๋ ๋ณํ์ง ์๋๋ค.
์ฌ๊ณผ์ ์์น์ ๋ฑ์ ์ด๋๊ฒฝ๋ก๊ฐ ์ฃผ์ด์ง ๋ ์ด ๊ฒ์์ด ๋ช ์ด์ ๋๋๋์ง ๊ณ์ฐํ๋ผ.
๐พ ํ์ด ๋ฐฉ๋ฒ
๋จผ์ , n*n ํฌ๊ธฐ์ board๋ฅผ ๋ชจ๋ 0์ผ๋ก ์ด๊ธฐํํด์ค๋ค. ์ดํ, ์ฌ๊ณผ๊ฐ ์๋ ์์น๋ง 1๋ก ํ์ํจ์ผ๋ก์จ ์ฌ๊ณผ๊ฐ ์์์ ๋ํ๋ด์ค๋ค.
๋ํ ๋ฑ์ด ์์ ์ ๋ชธ์ ๋ฟ์๋ ์ข
๋ฃํ๋ฏ๋ก ๋ฑ์ ๋ชธ ์์น๋ฅผ ๋ํ๋ด๊ธฐ ์ํด snake๋ผ๋ ๋ฐฐ์ด์ ํ์ฉํ์ฌ ๋ฑ์ ๋ชธ์ด ์๋ ๊ฒฝ์ฐ์๋ง 1๋ก ๋ํ๋ธ๋ค.
๋ฑ์ ์ฒ์์๋ [0,1] ์ฆ, ์ค๋ฅธ์ชฝ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ค ์ผ์ ์๊ฐ ์ดํ ๋ค์ด์จ ์ ๋ ฅ์ ํตํด ๋ฐฉํฅ์ ๋ณ๊ฒฝํ๋ค. ๋ฐ๋ผ์ ์ฒ์์ direction์ [0,1]๋ก ์ค์ ํ์ฌ ์ด๋ํ๋ค. ์ดํ ๋ฐฉํฅ์ ๋ณ๊ฒฝํ๋ผ๋ L์ด ์ ๋ ฅ๋์์ ๋, Rotation ํจ์๋ฅผ ํ์ฉํ์ฌ dir๋ฅผ ๋ณ๊ฒฝํด์ค๋ค.
์ด๋ Rotation ํจ์๋, ํ์ ๋ณํํ๋ ฌ์ ์ด์ฉํ์ฌ ์๋ก์ด dir๋ฅผ ๊ณ์ฐํด์ค๋ค. ํ์ ๋ณํํ๋ ฌ์ R(theta) = [[cos, -sin], [sin, cos]] ์ผ๋ก ์ด๋ฃจ์ด์ง ํ๋ ฌ์ด๋ค.
๋ฑ์ด ์ด๋ํ๋ค๊ฐ ์ฌ๊ณผ๋ฅผ ๋ฐ๊ฒฌํ ๊ฒฝ์ฐ์๋ ๊ผฌ๋ฆฌ๋ฅผ ์ค์ด์ง ์๊ณ , ์ฌ๊ณผ๋ฅผ ๋ฐ๊ฒฌํ์ง ์์ ๊ฒฝ์ฐ์๋ ๊ผฌ๋ฆฌ๋ฅผ ์ค์ด๊ฒ ๋๋ค. ๋ฐ๋ผ์ ๋ง์ง๋ง ๊ผฌ๋ฆฌ์ ์์น๋ฅผ ์ ์ฅํ๋ tail์ด๋ผ๋ ๋ฐฐ์ด์ ์ ์ธํ์ฌ, ๊ฐ์ฅ ๋ง์ง๋ง ๊ผฌ๋ฆฌ๋ฅผ ์ญ์ ํด์ฃผ๋๋ก ํ๋ค.
๋ชจ๋ ํ ์คํธ์ผ์ด์ค ์ฑ๊ณต ์ฝ๋
import sys
import math
sys.stdin = open("input.txt","rt")
def R(x):
return [[round(math.cos(x)), -round((math.sin(x)))],[round(math.sin(x)), round(math.cos(x))]]
def Rotation(str, d):
result = []
if str == 'L': #left
rMatrix = R(math.radians(90))
elif str == 'D': #right
rMatrix = R(math.radians(-90))
for i in range(len(rMatrix)):
tmpVal = 0
for j in range(len(rMatrix[0])):
tmpVal += rMatrix[i][j] * d[j]
result.append(tmpVal)
return result
n = int(input()) #๋ณด๋์ ํฌ๊ธฐ
board = [[0] * n for _ in range(n)]
snake = [[0] * n for _ in range(n)]
snake[0][0] = 1
k = int(input()) #์ฌ๊ณผ์ ๊ฐ์ K
for _ in range(k):
apple = list(map(int,input().split()))
board[apple[0]-1][apple[1]-1] = 1 #์ฌ๊ณผ๊ฐ ์๋ ์๋ฆฌ๋ 1๋ก ํ์
l = int(input())
going = list()
for _ in range(l):
going.append(list(input().split()))
time,rotation = going.pop(0)
time = int(time)
#๋ฑ์ ๋จธ๋ฆฌ(์ด๋)
x = 0
y = 0
dir = [0, 1] #์ด๋ํ๋ ๋ฐฉํฅ
second = 1 #์๊ฐ ์ด
tail = list() #๋ฑ์ ๊ผฌ๋ฆฌ
while True:
if second - 1 == time:
dir = Rotation(rotation, dir)
if going:
time, rotation = going.pop(0)
time = int(time)
else:
time = -1
tail.append([x,y])
x = x + dir[0]
y = y + dir[1]
if (0 > x or n <= x) or (0 > y or n <= y):
break
if snake[x][y] == 1: #์ด๋ฏธ ๋ฑ์ ๋ชธ์ด ์๋ ๊ฒฝ์ฐ
break
if board[x][y] == 0: #์ฌ๊ณผ๊ฐ ์๋ ๊ฒฝ์ฐ
s_x, s_y = tail.pop(0)
snake[s_x][s_y] = 0 #๊ผฌ๋ฆฌ๋ฅผ ํ์นธ ์ฎ๊น
else:
board[x][y] = 0 #์ฌ๊ณผ๋ฅผ ๋จน์์ผ๋ฏ๋ก 0์ผ๋ก ๋ฐ๊พธ์ด์ค
snake[x][y] = 1
second += 1
print(second)