์•Œ๊ณ ๋ฆฌ์ฆ˜/์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ฐœ๋…

[์•Œ๊ณ ๋ฆฌ์ฆ˜] ๊ตฌํ˜„(Implementation) / ํ–‰๋ ฌ, ์‹œ๋ฎฌ๋ ˆ์ด์…˜ ๋ฌธ์ œ ์ ‘๊ทผ ๋ฐฉ๋ฒ•!

์ธํฌ๋งˆํ‹ฑ 2025. 5. 16. 16:43

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)