[์๊ณ ๋ฆฌ์ฆ] ๊ตฌํ(Implementation) / ํ๋ ฌ, ์๋ฎฌ๋ ์ด์ ๋ฌธ์ ์ ๊ทผ ๋ฐฉ๋ฒ!
1. ๊ตฌํ(Implementation) ์ ํ์ ๋ฌธ์ ๋?
๊ตฌํ ์ ํ์ ๋ฌธ์ ๋ ํ์ด๋ฅผ ๋ ์ฌ๋ฆฌ๋ ๊ฒ์ ์ฝ์ง๋ง ์์ค์ฝ๋๋ก ์ฎ๊ธฐ๊ธฐ ์ด๋ ค์ด ๋ฌธ์ ๋ฅผ ์ง์นญํฉ๋๋ค.
- ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋จํ๋ฐ ์ฝ๋๊ฐ ์ง๋์น ๋งํผ ๊ธธ์ด์ง๋ ๋ฌธ์
- ์ค์ ์ฐ์ฐ์ ๋ค๋ฃจ๊ณ , ํน์ ์์์ ์๋ฆฌ๊น์ง ์ถ๋ ฅํด์ผ ํ๋ ๋ฌธ์
- ๋ฌธ์์ด์ ํน์ ํ ๊ธฐ์ค์ ๋ฐ๋ผ์ ๋์ด ์ฒ๋ฆฌํด์ผ ํ๋ ๋ฌธ์
- ์ ์ ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฐพ์์ ์ฌ์ฉํด์ผ ํ๋ ๋ฌธ์
์ผ๋ฐ์ ์ผ๋ก ๊ตฌํ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์ 2์ฐจ์ ๊ณต๊ฐ์ ํ๋ ฌ(Matrix)์ ์๋ฏธ๋ก ์ฌ์ฉ๋๊ณ ์์ฃผ ์ถ์ ๋ฉ๋๋ค.
ํ๋ ฌ์ด๋ 2์ฐจ์ ๋ฐ์ดํฐ๋ฅผ ์ผ์ข
์ ํ์ ๊ฐ์ ํํ๋ก ์ฝ๊ฒ ๋ํ๋ด๋ ์ํ ๊ฐ๋
์
๋๋ค.
์ฆ, ํ์ด์ฌ์์ 2์ฐจ์ ๋ฐฐ์ด์ ๋งํฉ๋๋ค.
๋ณดํต ์๋ฎฌ๋ ์ด์ ๋ฐ ์์ ํ์ ๋ฌธ์ ์์๋ 2์ฐจ์ ๊ณต๊ฐ์์์ ๋ฐฉํฅ๋ฒกํฐ๊ฐ ์์ฃผ ํ์ฉ๋ฉ๋๋ค.
์๋ฎฌ๋ ์ด์ ๋ฌธ์ ๊ฐ์ ๊ฒฝ์ฐ์๋ ์ด๋ ํ ์บ๋ฆญํฐ๋ ์ฌ๋ฌผ๋ฑ์ด ํน์ ์์น์ ์กด์ฌํ์ฌ ์ํ์ข์ฐ๋ก ์์ง์ผ ์ ์๋ค๋ ๋ฌธ์ ๊ฐ ์ถ์ ํ๊ณ ๋ฐฉํฅ๋ฒกํฐ๋ฅผ ์์ฃผ ์ฌ์ฉํฉ๋๋ค. ๋ฐฉํฅ ๋ฒกํฐ์ ์์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
ํ์ฌ ์์น x, y = (2, 2)
๋ ๋ถ ์ ๋จ
dx = [1, 0, -1, 0] # ๊ฐ๋ก์ถ
dy = [0, -1, 0, 1] # ์ธ๋ก์ถ
๋์ชฝ : ์ค๋ฅธ์ชฝ ํ์นธ (2, 2) → (2, 3)
๋ถ์ชฝ : ์์ชฝ ํ์นธ (2, 2) → (1, 2)
์์ชฝ: ์ผ์ชฝ ํ ์นธ (2, 2) → (2, 1)
๋จ์ชฝ: ์๋์ชฝ ํํฐ (2, 2) → (3, 2)
๋ค์ ์ด๋ ๋ฐฉํฅ ์ค์ ๋ก์ง
for i in range(4):
# ๋ค์ ์์น
nx = x + dx[i] # ํ ๋ฐฉํฅ
ny = y + dy[i] # ์ด ๋ฐฉํฅ
print(nx, ny)
2. <๋ฌธ์ > ์ํ์ข์ฐ
์ฌํ๊ฐ A๋ N * N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ ์์ ์ ์์ต๋๋ค. ์ด ๊ณต๊ฐ์ 1 * 1 ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ์ผ๋ก ๋๋์ด์ ธ ์์ต๋๋ค. ๊ฐ์ฅ ์ผ์ชฝ ์ ์ขํ๋ (1, 1)์ด๋ฉฐ, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์ขํ๋ (N, N)์ ํด๋นํฉ๋๋ค. ์ฌํ๊ฐ A๋ ์, ํ, ์ข, ์ฐ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ ์ ์์ผ๋ฉฐ, ์์ ์ขํ๋ ํญ์ (1, 1)์ ๋๋ค. ์ฐ๋ฆฌ ์์๋ ์ฌํ๊ฐ A๊ฐ ์ด๋ํ ๊ณํ์ด ์ ํ ๊ณํ์๊ฐ ๋์ฌ ์์ต๋๋ค.
๊ณํ์์๋ ํ๋์ ์ค์ ๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์ฌ L, R, U, D ์ค ํ๋์ ๋ฌธ์๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ์ ํ ์์ต๋๋ค. ๊ฐ ๋ฌธ์์ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
L: ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ด๋
R: ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ์ด๋
U: ์๋ก ํ ์นธ ์ด๋
D: ์๋๋ก ํ ์นธ ์ด๋
์ด๋ ์ฌํ๊ฐ A๊ฐ N * N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ์ ๋ฒ์ด๋๋ ์์ง์์ ๋ฌด์๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด (1, 1)์ ์์น์์ L ํน์ U๋ฅผ ๋ง๋๋ฉด ๋ฌด์๋ฉ๋๋ค. ๋ค์์ N = 5์ธ ์ง๋์ ๊ณํ์์ ๋๋ค.
# ์
๋ ฅ
5
R R R U D D
# ์ถ๋ ฅ
3 4
๋ณดํต ํ๋ ฌ์ ์ฌ์ฉํ ๋, (0, 0)๋ถํฐ ์ฌ์ฉํฉ๋๋ค. ๋ค๋ง, ๋ฌธ์ ์์ (1, 1)์์ ์์ํ๋ค๊ณ ๋ช ์ํ ๊ฒฝ์ฐ์๋ ๊ฐ์ฅ ์ฒซ ๋ฒ์งธ ์ธ๋ฑ์ค๋ ์ฌ์ฉํ์ง ์๋ ๋ฐฉ์์ ์ด์ฉํ๊ฑฐ๋, (1, 1)์ ์์ค์ฝ๋ ์์์ (0, 0)์ผ๋ก ์ฒ๋ฆฌํ์ฌ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ๋ ์์ต๋๋ค.
์ด ๋ฌธ์ ๋ ์๊ตฌ์ฌํญ๋๋ก ์ถฉ์คํ ๊ตฌํํ๋ฉด ๋๋ ๋ฌธ์ ์ ๋๋ค. ์ผ๋ จ์ ๋ช ๋ น์ ๋ฐ๋ผ์ ๊ฐ์ฒด๋ฅผ ์ฐจ๋ก๋๋ก ์ด๋์ํจ๋ค๋ ์ ์์ ์๋ฎฌ๋ ์ด์ ์ ํ์ผ๋ก๋ ๋ถ๋ฅ๋๋ฉฐ ๊ตฌํ์ด ์ค์ํ ๋ํ์ ์ธ ๋ฌธ์ ์ ํ์ ๋๋ค. ์ฝํ ์์๋ ์๋ฎฌ๋ ์ด์ ์ ํ, ๊ตฌํ ์ ํ, ์์ ํ์ ์ ํ์ ์๋ก ์ ์ฌํ ์ ์ด ๋ง์ต๋๋ค.
# N ์
๋ ฅ๋ฐ๊ธฐ
n = int(input())
x, y = 1, 1 # ํ์ฌ ์์น
plans = input().split() # R R R U D D
# L, R, U, D์ ๋ฐ๋ฅธ ์ด๋ ๋ฐฉํฅ
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]
move_types = ['L', 'R', 'U', 'D']
# ์ด๋๊ณํ ํ๋์ฉ ํ์ธํ๊ธฐ
for i in plans:
for j in range(len(move_types)):
if plan == move_types[i]:
# nx, ny ์ด๊ธฐํ ๋ถํ์
nx = x + dx[i]
ny = y + dy[i]
# ๊ณต๊ฐ์ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ ๋ฌด์
if nx < 1 or ny < 1 or nx > n or ny > n:
continue
# ์ด๋ ์ํ
x, y = nx, ny
print(x, y)