
๐ป ๋ฌธ์ ์ ์

๋ค์ ๋ชจ์์ DDR์ด ์๋ค.
์ฒ์์ ๊ฒ์ด๋จธ๋ ๋ ๋ฐ์ ์ค์์ ๋ชจ์ผ๊ณ ์๋ค.(๊ทธ๋ฆผ์์ 0์ ์์น) ๊ทธ๋ฆฌ๊ณ ๊ฒ์์ด ์์ํ๋ฉด, ์ง์์ ๋ฐ๋ผ ์ผ์ชฝ ๋๋ ์ค๋ฅธ์ชฝ ๋ฐ์ ์์ง์ธ๋ค. ํ์ง๋ง ๊ทธ์ ๋ ๋ฐ์ด ๋์์ ์์ง์ด์ง๋ ์๋๋ค.
์ด ๊ฒ์์๋ ์ด์ํ ๊ท์น์ด ๋ ์๋ค. ๋ ๋ฐ์ด ๊ฐ์ ์ง์ ์ ์๋ ๊ฒ์ด ํ๋ฝ๋์ง ์๋ ๊ฒ์ด๋ค. (๋ฌผ๋ก ๊ฒ์ ์์์์๋ ์์ธ์ด๋ค) ๋ง์ฝ, ํ ๋ฐ์ด 1์ ์์น์ ์๊ณ , ๋ค๋ฅธ ํ ๋ฐ์ด 3์ ์์น์ ์์ ๋, 3์ ์ฐ์์ผ๋ก ๋๋ฌ์ผ ํ๋ค๋ฉด, 3์ ์์น์ ์๋ ๋ฐ๋ก ๋ฐ๋ณตํด์ผ ๋๋ฌ์ผ ํ๋ค๋ ๊ฒ์ด๋ค.
์ค์์ ์๋ ๋ฐ์ด ๋ค๋ฅธ ์ง์ ์ผ๋ก ์์ง์ผ ๋, 2์ ํ์ ์ฌ์ฉํ๊ฒ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค๋ฅธ ์ง์ ์์ ์ธ์ ํ ์ง์ ์ผ๋ก ์์ง์ผ ๋๋ 3์ ํ์ ์ฌ์ฉํ๊ฒ ๋๋ค. (์๋ฅผ ๋ค๋ฉด ์ผ์ชฝ์์ ์๋ ์๋๋ก ์ด๋ํ ๋์ ์ด์ผ๊ธฐ์ด๋ค.) ๊ทธ๋ฆฌ๊ณ ๋ฐ๋ํธ์ผ๋ก ์์ง์ผ๋๋ 4์ ํ์ ์ฌ์ฉํ๊ฒ ๋๋ค. (์์ชฝ์์ ์๋์ชฝ์ผ๋ก, ๋๋ ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ผ๋ก). ๋ง์ฝ ๊ฐ์ ์ง์ ์ ํ๋ฒ ๋ ๋๋ฅธ๋ค๋ฉด, ๊ทธ๋๋ 1์ ํ์ ์ฌ์ฉํ๊ฒ ๋๋ค.
๐ก ์ ๊ทผ ๋ฐ ์ค๊ณ
๋ ๋ฐ์ ์์น ์ํ๋ฅผ ๋ชจ๋ ๊ณ ๋ คํ๋ฉด์ DP๋ก ์ ๊ทผํ์๋ค.
1 → 2 → 1 ์์๋ก ๋ฐํ์ ๋ฐ๋๋ค๊ณ ํ์์ ๋, 1์ ์ผ๋ฐ, 2๋ฅผ ์ค๋ฅธ๋ฐ๋ก ๋ฐ์์ ๋, ๋ง์ง๋ง 1์ ์ผ๋ฐ๋ก ๋ฐ์์ง, ์ค๋ฅธ๋ฐ๋ก ๋ฐ์์ง์ ๋ฐ๋ผ ๋น์ฉ์ด ๋ฌ๋ผ์ง๊ฒ ๋๋ค. ๋ฐ๋ผ์ ๊ทธ๋ฆฌ๋ ์ ๊ทผ์ด ์๋, DP๋ก ์ ๊ทผํด์ผ ํ๋ค.
DP ํ ์ด๋ธ์ dp[i][l][r] ์ฒ๋ผ ์ธ์ธ ์ ์๋ค. i๋ฒ์งธ๊น์ง์ ๋ช ๋ น์์, ์ผ๋ฐ์ ์์น l๊ณผ ์ค๋ฅธ๋ฐ์ ์์นr ์ผ๋ ์ต์ ๋น์ฉ์ ์ ์ฅํ๋ค.
โ๏ธ ์๊ณ ๋ฆฌ์ฆ ํ์ด
def cost(a, b):
if a == 0:
return 2
if a == b:
return 1
if abs(a-b) == 2:
return 4
return 3
ํ์ฌ์ ์์น์์ ๋ค์ ์์น๋ก ๋ฐ์ ์ฎ๊ธธ ๋ ๋ฐ์ํ๋ ๋น์ฉ์ ์ ์ํ ํจ์์ด๋ค.
# ํ์ฌ ๋๋ฌ์ผํ๋ ์์น
curr = arr[i]
# ์ผ๋ฐ ์ด๋
dp[i+1][curr][r] = min(
dp[i+1][curr][r],
cur + cost(l, curr)
)
# ์ค๋ฅธ๋ฐ ์ด๋
dp[i+1][l][curr] = min(
dp[i+1][l][curr],
cur + cost(r, curr)
)
์ด์ ์ ์ํ์์, ํ์ฌ ๋๋ฌ์ผํ๋ ์์น๋ฅผ ์ด๋ ๋ฐ๋ก ๋๋ฅผ์ง ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์ ์ฅํ์ฌ ์ต์๊ฐ์ ๋น๊ตํ๋ค.
์ต์ข ์ ์ผ๋ก ๋ง์ง๋ง ์ํ์ ์ ์ฅ๋ ๊ฐ๋ค ์ค ์ต์๊ฐ์ ๊ตฌํ๋ฉด ๋๋ค.
๐๏ธ ์ต์ข ์ ์ถ ์ฝ๋
# 2342 Dance Dance Revolution
import sys
# input = sys.stdin.readline
def cost(a, b):
if a == 0:
return 2
if a == b:
return 1
if abs(a-b) == 2:
return 4
return 3
arr = list(map(int, input().split()))
arr.pop()
INF = 10**9
n = len(arr)
dp = [[[INF] * 5 for _ in range(5)] for _ in range(n+1)]
dp[0][0][0] = 0
for i in range(n):
curr = arr[i]
for l in range(5):
for r in range(5):
cur = dp[i][l][r]
if cur == INF:
continue
# ์ผ๋ฐ ์ด๋
dp[i+1][curr][r] = min(
dp[i+1][curr][r],
cur + cost(l, curr)
)
# ์ค๋ฅธ๋ฐ ์ด๋
dp[i+1][l][curr] = min(
dp[i+1][l][curr],
cur + cost(r, curr)
)
ans = INF
for l in range(5):
for r in range(5):
ans = min(ans, dp[n][l][r])
print(ans)
๐ญ ์ค๋์ ํ๊ณ
-
'Coding-Test > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Python] 16724 ํผ๋ฆฌ ๋ถ๋ ์ฌ๋์ด (0) | 2026.03.26 |
|---|---|
| [Python] 1766 ๋ฌธ์ ์ง (0) | 2026.03.26 |
| [Python] 11049 ํ๋ ฌ ๊ณฑ์ ์์ (0) | 2026.03.20 |
| [Python] 16947 ์์ธ ์งํ์ฒ 2ํธ์ (0) | 2026.03.19 |
| [Python] 2613 ์ซ์๊ตฌ์ฌ (0) | 2026.03.18 |