์ผ์ฑ SW ์ญ๋ ํ ์คํธ ๊ธฐ์ถ ๋ฌธ์ - 14499๋ฒ ์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ
14499๋ฒ: ์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ
์ฒซ์งธ ์ค์ ์ง๋์ ์ธ๋ก ํฌ๊ธฐ N, ๊ฐ๋ก ํฌ๊ธฐ M (1 ≤ N, M ≤ 20), ์ฃผ์ฌ์๋ฅผ ๋์ ๊ณณ์ ์ขํ x, y(0 ≤ x ≤ N-1, 0 ≤ y ≤ M-1), ๊ทธ๋ฆฌ๊ณ ๋ช ๋ น์ ๊ฐ์ K (1 ≤ K ≤ 1,000)๊ฐ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ง
www.acmicpc.net
๋ฌธ์
ํฌ๊ธฐ๊ฐ N×M์ธ ์ง๋๊ฐ ์กด์ฌํ๋ค. ์ง๋์ ์ค๋ฅธ์ชฝ์ ๋์ชฝ, ์์ชฝ์ ๋ถ์ชฝ์ด๋ค. ์ด ์ง๋์ ์์ ์ฃผ์ฌ์๊ฐ ํ๋ ๋์ฌ์ ธ ์์ผ๋ฉฐ, ์ฃผ์ฌ์์ ์ ๊ฐ๋๋ ์๋์ ๊ฐ๋ค. ์ง๋์ ์ขํ๋ (r, c)๋ก ๋ํ๋ด๋ฉฐ, r๋ ๋ถ์ชฝ์ผ๋ก๋ถํฐ ๋จ์ด์ง ์นธ์ ๊ฐ์, c๋ ์์ชฝ์ผ๋ก๋ถํฐ ๋จ์ด์ง ์นธ์ ๊ฐ์์ด๋ค.
2
4 1 3
5
6
์ฃผ์ฌ์๋ ์ง๋ ์์ ์ ๋ฉด์ด 1์ด๊ณ , ๋์ชฝ์ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ด 3์ธ ์ํ๋ก ๋์ฌ์ ธ ์์ผ๋ฉฐ, ๋์ฌ์ ธ ์๋ ๊ณณ์ ์ขํ๋ (x, y) ์ด๋ค. ๊ฐ์ฅ ์ฒ์์ ์ฃผ์ฌ์์๋ ๋ชจ๋ ๋ฉด์ 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)๊ฐ ์ฃผ์ด์ง๋ค.
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ง๋์ ์ฐ์ฌ ์๋ ์๊ฐ ๋ถ์ชฝ๋ถํฐ ๋จ์ชฝ์ผ๋ก, ๊ฐ ์ค์ ์์ชฝ๋ถํฐ ๋์ชฝ ์์๋๋ก ์ฃผ์ด์ง๋ค. ์ฃผ์ฌ์๋ฅผ ๋์ ์นธ์ ์ฐ์ฌ ์๋ ์๋ ํญ์ 0์ด๋ค. ์ง๋์ ๊ฐ ์นธ์ ์ฐ์ฌ ์๋ ์๋ 10 ๋ฏธ๋ง์ ์์ฐ์ ๋๋ 0์ด๋ค.
๋ง์ง๋ง ์ค์๋ ์ด๋ํ๋ ๋ช ๋ น์ด ์์๋๋ก ์ฃผ์ด์ง๋ค. ๋์ชฝ์ 1, ์์ชฝ์ 2, ๋ถ์ชฝ์ 3, ๋จ์ชฝ์ 4๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ด๋ํ ๋๋ง๋ค ์ฃผ์ฌ์์ ์ ๋ฉด์ ์ฐ์ฌ ์๋ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ๋ฐ๊นฅ์ผ๋ก ์ด๋์ํค๋ ค๊ณ ํ๋ ๊ฒฝ์ฐ์๋ ํด๋น ๋ช ๋ น์ ๋ฌด์ํด์ผ ํ๋ฉฐ, ์ถ๋ ฅ๋ ํ๋ฉด ์ ๋๋ค.
์์ ์ ๋ ฅ1
4 2 0 0 8
0 2
3 4
5 6
7 8
4 4 4 1 3 3 3 2
์์ ์ถ๋ ฅ1
0
0
3
0
0
8
6
3
ํ์ด
- ์ฃผ์ฌ์๋ฅผ ์ง์ ์ข ์ด์ ๊ทธ๋ ค๋ณด๋ฉด์ ์ดํดํ๋ค
- ์ฃผ์ฌ์ ๊ตด๋ฆฌ๋ ๊ณผ์ ์ ํจ์๋ก ๋ฐ๋ก ๊ตฌํ
# ์ผ์ฑ SW ์ญ๋ ํ
์คํธ ๊ธฐ์ถ ๋ฌธ์
# ๋ฐฑ์ค 14499๋ฒ. ์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ
n, m, x, y, k = map(int, input().split())
arr = [list(map(int, input().split())) for _ in range(n)]
order = list(map(int, input().split()))
dice = [0, 0, 0, 0, 0, 0] # ์ฃผ์ฌ์ ์ด๊ธฐํ
dx = [0, 0, -1, 1]
dy = [1, -1, 0, 0]
# ์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ
def turn_dice(direction):
global dice
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
else: # ๋จ์ชฝ
dice[0], dice[1], dice[2], dice[3], dice[4], dice[5] = b, f, c, d, a, e
# ์ด๋ํ๋ ๋ช
๋ น
for i in order:
idx = i - 1
nx = x + dx[idx]
ny = y + dy[idx]
# ์ง๋ ๋ด์ ๋ฒ์์ด๋ฉด
if 0 <= nx < n and 0 <= ny < m:
turn_dice(i) # ์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ
# ์ด๋ํ ์นธ์ ์ฐ์ฌ์๋ ์๊ฐ 0์ด๋ฉด, ์ฃผ์ฌ์ ๋ฐ๋ฅ๋ฉด์ ์ฐ์ฌ์๋ ์๊ฐ ๋ณต์ฌ
if arr[nx][ny] == 0:
arr[nx][ny] = dice[5]
else: # 0์ด ์๋๋ฉด, ์นธ์ ์ฐ์ธ ์๊ฐ ์ฃผ์ฌ์์ ๋ฐ๋ฅ๋ฉด์ผ๋ก ๋ณต์ฌ, ์นธ์ ์๋ 0์ด ๋จ
dice[5] = arr[nx][ny]
arr[nx][ny] = 0
else: # ์ง๋๋ฅผ ๋ฒ์ด๋๋ฉด ๋ช
๋ น ๋ฌด์
continue
x, y = nx, ny # x์ y ๊ฐ์ ๊ฐฑ์ ํด์ค์ผ ํ๋ค
print(dice[0]) # ์ฃผ์ฌ์์ ๋งจ ์์ ์ซ์ ์ถ๋ ฅ
์๊ณ ๋ฆฌ์ฆ ๋ถ๋ฅ
- ๊ตฌํ
- ์๋ฎฌ๋ ์ด์