
๐ป ๋ฌธ์ ์ ์
ํฌ๊ธฐ๊ฐ N×M์ธ ํ๋ ฌ A์ M×K์ธ B๋ฅผ ๊ณฑํ ๋ ํ์ํ ๊ณฑ์ ์ฐ์ฐ์ ์๋ ์ด N×M×K๋ฒ์ด๋ค. ํ๋ ฌ N๊ฐ๋ฅผ ๊ณฑํ๋๋ฐ ํ์ํ ๊ณฑ์ ์ฐ์ฐ์ ์๋ ํ๋ ฌ์ ๊ณฑํ๋ ์์์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๊ฒ ๋๋ค.
์๋ฅผ ๋ค์ด, A์ ํฌ๊ธฐ๊ฐ 5×3์ด๊ณ , B์ ํฌ๊ธฐ๊ฐ 3×2, C์ ํฌ๊ธฐ๊ฐ 2×6์ธ ๊ฒฝ์ฐ์ ํ๋ ฌ์ ๊ณฑ ABC๋ฅผ ๊ตฌํ๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด์.
- AB๋ฅผ ๋จผ์ ๊ณฑํ๊ณ C๋ฅผ ๊ณฑํ๋ ๊ฒฝ์ฐ (AB)C์ ํ์ํ ๊ณฑ์ ์ฐ์ฐ์ ์๋ 5×3×2 + 5×2×6 = 30 + 60 = 90๋ฒ์ด๋ค.
- BC๋ฅผ ๋จผ์ ๊ณฑํ๊ณ A๋ฅผ ๊ณฑํ๋ ๊ฒฝ์ฐ A(BC)์ ํ์ํ ๊ณฑ์ ์ฐ์ฐ์ ์๋ 3×2×6 + 5×3×6 = 36 + 90 = 126๋ฒ์ด๋ค.
๊ฐ์ ๊ณฑ์ ์ด์ง๋ง, ๊ณฑ์ ์ ํ๋ ์์์ ๋ฐ๋ผ์ ๊ณฑ์ ์ฐ์ฐ์ ์๊ฐ ๋ฌ๋ผ์ง๋ค.
ํ๋ ฌ N๊ฐ์ ํฌ๊ธฐ๊ฐ ์ฃผ์ด์ก์ ๋, ๋ชจ๋ ํ๋ ฌ์ ๊ณฑํ๋๋ฐ ํ์ํ ๊ณฑ์ ์ฐ์ฐ ํ์์ ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
๐ก ์ ๊ทผ ๋ฐ ์ค๊ณ
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ์๋ค. ์ฃผ์ด์ง ํ๋ ฌ์ ํฌ๊ธฐ ๋ฐฐ์ด์์, ํด๋น ๋ฐฐ์ด์ ์ธ๋ฑ์ค ๋งํผ ๊น์ง ์ฐ์ฐํ์์ ๋ ์ต์๊ฐ์ DPํ ์ด๋ธ์ ์ ์ฅํ๋ ๋ฐฉ์์ ์๊ฐํ์๋ค.
N = 3, arr = [[5, 3], [3, 2], [2, 6]] ์ผ๋ ์ต์ข ์ ์ผ๋ก dp[0][2]์ ์ฐ๋ฆฌ๊ฐ ์ถ๋ ฅํด์ผํ ์ต์๊ฐ์ด ์ ์ฅ๋ ๊ฒ์ด๋ค.
dp[0][2] = min(dp[0][0] + dp[1][2] + ํ๋ ฌ๊ณฑ ์ฐ์ฐ ํ์, dp[0][1] + dp[2][2] + ํ๋ ฌ๊ณฑ ์ฐ์ฐ ํ์) ⇒ $min(A \cdot (BC), (AB) \cdot C)$ ์ผ๋ก ํํํ ์ ์๋ค.
โ๏ธ ์๊ณ ๋ฆฌ์ฆ ํ์ด
INF = 2**31
dp = [[INF] * N for _ in range(N)]
for i in range(N):
dp[i][i] = 0
DPํ ์ด๋ธ์ INF ๊ฐ์ผ๋ก ์ด๊ธฐํ ํด์ค๋ค. dp[i][i] ๋ถ๋ถ์ ์๊ธฐ์์ ํ๋ ฌ๊ณฑ ์ฐ์ฐ์ด๋ฏ๋ก 0์ ๋ฃ์ด์ค๋ค.
for i in range(1, N):
for j in range(N-i):
for k in range(j, j+i):
temp = dp[j][k] + dp[k+1][j+i] + (matrix[j][0] * matrix[k][1] * matrix[j+i][1])
dp[j][j+i] = min(dp[j][j+i], temp)
3์ค ๋ฐ๋ณต๋ฌธ์ ํตํด DP ๋ก์ง์ ๊ตฌํํ ์ ์์๋ค.
i : dp๋ฅผ ๊ตฌํ ๋ฒ์๋ฅผ ์ง์
j : ๊ตฌํ๊ณ ์ถ์ dp์ ์์ ์ธ๋ฑ์ค
k : ์๋ธ ํ๋ ฌ๋ก ์ชผ๊ฐค ๊ธฐ์ค์
dp[0][2]์์ k=1์ด๋ฉด dp[0][1] + dp[2][2] k=0์ด๋ฉด dp[0][0] + dp[1][2]
matrix[j][0] * matrix[k][1] * matrix[j+i][1] : ํ๋ ฌ ์ฐ์ฐ ํ์. ์ฆ, [5, 3], [3, 2] ๋ ๊ฐ์ ํ๋ ฌ์ ์ฐ์ฐํ๋ค๊ณ ํ์์ ๋, dp[0][1] = ~~~ + (5 * 3 * 2) ๊ฐ ๋๋ค.
๐๏ธ ์ต์ข ์ ์ถ ์ฝ๋ (PyPy3 ์ ์ถ)
# 11049 ํ๋ ฌ ๊ณฑ์
์์
import sys
input = sys.stdin.readline
INF = 2**31
N = int(input())
matrix = []
for _ in range(N):
matrix.append(list(map(int, input().split())))
dp = [[INF] * N for _ in range(N)]
for i in range(N):
dp[i][i] = 0
for i in range(1, N):
for j in range(N-i):
for k in range(j, j+i):
temp = dp[j][k] + dp[k+1][j+i] + (matrix[j][0] * matrix[k][1] * matrix[j+i][1])
dp[j][j+i] = min(dp[j][j+i], temp)
print(dp[0][N-1])
๐ญ ์ค๋์ ํ๊ณ
-
'Coding-Test > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Python] 1766 ๋ฌธ์ ์ง (0) | 2026.03.26 |
|---|---|
| [Python] 2342 Dance Dance Revolution (0) | 2026.03.20 |
| [Python] 16947 ์์ธ ์งํ์ฒ 2ํธ์ (0) | 2026.03.19 |
| [Python] 2613 ์ซ์๊ตฌ์ฌ (0) | 2026.03.18 |
| [Python] 16946 ๋ฒฝ ๋ถ์๊ณ ์ด๋ํ๊ธฐ 4 (0) | 2026.03.17 |