
Review
์ฃผ์ฌ์๋ผ๋ ๋จ์ด์ ์ซ์๋ค.
๋ฌธ์ ๋ฅผ ํ๋ฉด์ ์ค์ํ๊ฑด "๊ท์น"์ ์ฐพ์ผ๋ ค๊ณ ๋
ธ๋ ฅํด์ผ ํ๋ค๋ ๊ฒ
๋จธ๋ฆฟ์์ผ๋ก ๊ทธ๋ ค๋ดค์ ๋ ์๋๋ค ํ๋๋ผ๋,
๋ฐ๋ก ๋จ์ ํด์ค์ ๋ณด๋ ๊ฒ๋ณด๋ค,
์์ผ๋ก๋ ์จ๋ณด๊ณ ํผ์ ๊ท์น์ ์ฐพ์ผ๋ ค๊ณ ๋
ธ๋ ฅํ๋ ์๊ฐ์ด ํจ์ฌ ๊ฐ์ง๋ค!
โจ HOW? ์ฒ์ ์์ด๋์ด
์ผ๋จ ๋ฐฉํฅ์ด ๋์ค๋, dx/dy๋ฅผ ๋ ์ฌ๋ ธ๋ค.
์, ๊ทธ๋ฆฌ๊ณ dx/dy ์ค์ ํ ๋ ์๋ฌด๋ ๊ฒ ๋๋ ๊ฒ ์๋๋ผ
์กฐ๊ฑด์์ ์๊ตฌํ๋ ์ฌํญ๋๋ก ๋ง์ถ์.
์ด ๋ฌธ์ ์์ ๋์๋ถ๋จ์ด๋,
dx = [0, 0, -1, 1]
dy = [1, -1, 0, 0]
โจ HOW? ์ฃผ์ฌ์ ๊ท์น
์ฃผ์ฌ์์ ๋ฉด์ด [1,2,3,4,5,6] ์์ ๋ [์, ๋ค, ์ค๋ฅธ, ์ผ, ์, ๋ฐ๋ฅ] ์ด๋ผ๋ ๊ธฐ์ค์ ๋๊ณ ,
"๋์๋จ๋ถ ๊ฐ ๋ฐฉํฅ์ผ๋ก ๊ตด๋ ธ์ ๋ ์ด ์ธ๋ฑ์ค๋ค์ด ์ด๋ป๊ฒ ๋ณํ๋"๋ง ์ฐพ์์ผ๋ฉด ๋๋ค.
Code
'''
์ฃผ์ฌ์๋ ์ง๋ ์์ ์ ๋ฉด์ด 1์ด๊ณ , ๋์ชฝ์ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ด 3์ธ ์ํ๋ก ๋์ฌ์ ธ ์์ผ๋ฉฐ, > ???
๋์ฌ์ ธ ์๋ ๊ณณ์ ์ขํ๋ (x, y) ์ด๋ค. ๊ฐ์ฅ ์ฒ์์ ์ฃผ์ฌ์์๋ ๋ชจ๋ ๋ฉด์ 0์ด ์ ํ์ ธ ์๋ค. > ๊ทธ๋์ ์ฃผ์ฌ์๋ 6๋ฉด์ด ๋ค 0์ด๋ผ๋ ๋ง??
์ง๋์ ๊ฐ ์นธ์๋ ์ ์๊ฐ ํ๋์ฉ ์ฐ์ฌ์ ธ ์๋ค.
์ฃผ์ฌ์๋ฅผ ๊ตด๋ ธ์ ๋, ์ด๋ํ ์นธ์ ์ฐ์ฌ ์๋ ์๊ฐ 0์ด๋ฉด,
์ฃผ์ฌ์์ ๋ฐ๋ฅ๋ฉด์ ์ฐ์ฌ ์๋ ์๊ฐ ์นธ์ ๋ณต์ฌ๋๋ค.
0์ด ์๋ ๊ฒฝ์ฐ์๋, ์นธ์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ฌ์์ ๋ฐ๋ฅ๋ฉด์ผ๋ก ๋ณต์ฌ๋๋ฉฐ,
์นธ์ ์ฐ์ฌ ์๋ ์๋ 0์ด ๋๋ค.
์ฃผ์ฌ์๋ฅผ ๋์ ๊ณณ์ ์ขํ์ ์ด๋์ํค๋ ๋ช
๋ น์ด ์ฃผ์ด์ก์ ๋,
์ฃผ์ฌ์๊ฐ ์ด๋ํ์ ๋ ๋ง๋ค ์๋จ์ ์ฐ์ฌ ์๋ ๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. > ???
์ฃผ์ฌ์๋ ์ง๋์ ๋ฐ๊นฅ์ผ๋ก ์ด๋์ํฌ ์ ์๋ค.
๋ง์ฝ ๋ฐ๊นฅ์ผ๋ก ์ด๋์ํค๋ ค๊ณ ํ๋ ๊ฒฝ์ฐ์๋ ํด๋น ๋ช
๋ น์ ๋ฌด์ํด์ผ ํ๋ฉฐ, ์ถ๋ ฅ๋ ํ๋ฉด ์ ๋๋ค.
'''
'''์ฒซ์งธ ์ค์ ์ง๋์ ์ธ๋ก ํฌ๊ธฐ N, ๊ฐ๋ก ํฌ๊ธฐ M (1 โค N, M โค 20),
์ฃผ์ฌ์๋ฅผ ๋์ ๊ณณ์ ์ขํ x, y(0 โค x โค N-1, 0 โค y โค M-1),
๊ทธ๋ฆฌ๊ณ ๋ช
๋ น์ ๊ฐ์ K (1 โค K โค 1,000)๊ฐ ์ฃผ์ด์ง๋ค.
๋์ชฝ์ 1, ์์ชฝ์ 2, ๋ถ์ชฝ์ 3, ๋จ์ชฝ์ 4๋ก ์ฃผ์ด์ง๋ค
์ด๋ํ ๋๋ง๋ค ์ฃผ์ฌ์์ ์ ๋ฉด์ ์ฐ์ฌ ์๋ ์๋ฅผ ์ถ๋ ฅํ๋ค.'''
''' ๋ฐฉํฅ์ด ์์ผ๋ dx dy'''
n, m, x, y, k = map(int, input().split())
arr = []
for _ in range(n):
arr.append(list(map(int, input().split())))
directions = list(map(int, input().split()))
'''๋์๋ถ๋จ ์ผ๋ก ๋ฐฉํฅ ์ค์ '''
dx = [0, 0, -1, 1]
dy = [1, -1, 0, 0]
dice = [0, 0, 0, 0, 0, 0]
def turn(direction):
a, b, c, d, e, f = dice[0], dice[1], dice[2], dice[3], dice[4], dice[5]
if direction == 1:
dice[0], dice[1], dice[2], dice[3], dice[4], dice[5] = d, b, a, f, e, c
elif direction == 2:
dice[0], dice[1], dice[2], dice[3], dice[4], dice[5] = c, b, f, a, e, d
elif direction == 3:
dice[0], dice[1], dice[2], dice[3], dice[4], dice[5] = e, a, c, d, f, b
elif direction == 4:
dice[0], dice[1], dice[2], dice[3], dice[4], dice[5] = b, f, c, d, a, e
for d in directions:
if 0 <= x + dx[d-1] < n and 0 <= y + dy[d-1] < m:
x = x + dx[d-1]
y = y + dy[d-1]
turn(d)
if arr[x][y] == 0:
arr[x][y] = dice[5]
else:
dice[5] = arr[x][y]
arr[x][y] = 0
print(dice[0])
์๊ฐ๋ณต์ก๋
O(n)