๐๋ฌธ์
โ๊ตฌ์
์ด ๋ฌธ์ ๋ "1, 2, 3 ๋ํ๊ธฐ" ๋ฌธ์ ์๋ฆฌ์ฆ์ค 7๋ฒ์งธ ๋ฌธ์ ๋ค. ์์ ํ์ด๋ณธ "1, 2, 3 ๋ํ๊ธฐ" ๋ฌธ์ ๋ ๋ชจ๋ Dynamic Programming ์๊ณ ๋ฆฌ์ฆ ์ ํ์ด์๊ธฐ ๋๋ฌธ์ ๋น์ทํ๊ฒ ์ ๊ทผ์ ํด๋ณด๋ คํ๋ค. ํ์ง๋ง, ์ฌํ ํ์ด๋ณธ DP ๋ฌธ์ ๋ ํผ๋ณด๋์น์์ด์ฒ๋ผ ๋จ์ํ N๋ฒ์งธ์ DP ๊ฐ์ ๊ตฌํ๋ฉด ๋๋ ๋ฌธ์ ์๋๋ฐ ์ด ๋ฌธ์ ๊ฐ์ ๊ฒฝ์ฐ๋ T๊ฐ์ ํ ์คํธ ์ผ์ด์ค๊ฐ์๊ฐ ์ฃผ์ด์ง๊ณ , ๊ทธ ์๋๋ก T๊ฐ์ n, m ์ ์์ด ์๋ค. ์ฆ, ์ฌํ ํ์ด๋ณธ DP ๋ฌธ์ ๋ n ๊ณผ m ์ด ์ฃผ์ด์ง๋๊ฒ ์๋ n ์ด ์ฃผ์ด์ ธ์ n๋ฒ์งธ DP ๊ฐ์ ๊ตฌํ๋ฉด ๋๋ ๋ฌธ์ ์๋๋ฐ, ์ด๋ฒ์๋ 1, 2 ,3 ์ ์ด์ฉํด ๋ง๋ค ์ ์๋ n์ ๊ฐฏ์ + 1, 2, 3 ์ซ์ m ๊ฐ๋ฅผ ์ฌ์ฉํด์ n์ด ๋๋๋ก ํ๋ ๋ฌธ์ ์ธ๊ฒ์ด๋ค. ์ด๋ป๊ฒ ์ ๊ทผํ๋ฉด ์ข์์ง ์๊ฐํ๋ค๊ฐ ๋ฌธ๋ฉ ์๋ ์ DP ์ ํจํด์ ์ข๋ ์ฝ๊ฒ ํ์ ํ๋ ๋ฐฉ๋ฒ์ Chat GPT ์๊ฒ ๋ฌผ์ด๋ณธ ๊ฒฐ๊ณผ ํ๋ฅผ ์ฌ์ฉํด์ ๊ฐ๊ฐ์ ์ผ์ด์ค๋ง๋ค ์ด๋ค ๊ฐ์ ๊ฐ๋์ง๋ฅผ ํ์ ํด์ ๊ทธ ๊ฐ์ ๋น๊ตํด ํจํด์ ํ์ ํ ํ ์ ํ์์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ด ์๊ฐ๋ฌ๋ค. ์ด๊ฒ์ ํ์ฉํด ๊ฐ๊ฐ์ ์ผ์ด์ค๋ง๋ค ์ด๋ค ๊ฐ์ ๊ฐ๋์ง ํ๋ก ๋จผ์ ์์ฑํด๋ณด๊ธฐ๋ก ํ๋ค.
ํจํดํ์ ์ ์ํ ํ ์์ฑ
N \ M | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
2 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
3 | 1 | 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
4 | 0 | 3 | 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
5 | 0 | 2 | 6 | 4 | 1 | 0 | 0 | 0 | 0 | 0 |
6 | 0 | 1 | 7 | 10 | 5 | 1 | 0 | 0 | 0 | 0 |
7 | 0 | 0 | 6 | 16 | 15 | 6 | 1 | 0 | 0 | 0 |
8 | 0 | 0 | 3 | 19 | 30 | 21 | 7 | 1 | 0 | 0 |
9 | 0 | 0 | 1 | 16 | 45 | 50 | 28 | 8 | 1 | 0 |
10 | 0 | 0 | 0 | 10 | 30 | 90 | 77 | 36 | 9 | 1 |
ํ๋ก ์์ฑํด์ ๊ฐ๊ฐ์ ์ผ์ด์ค ๋ณ ๊ฐ์ ์ ๋ฆฌํ ๊ฒฐ๊ณผ
- N ๊ณผ M ์ด ๊ฐ์ ๊ฒฝ์ฐ → 1๊ฐ ( N = 2, M = 2 → 1, 1 ์ ์กฐํฉ๋ง ๊ฐ๋ฅ)
- N ์ด 4๋ณด๋ค ์๊ณ M ์ด 1์ธ ๊ฒฝ์ฐ → 1๊ฐ (1, 2, 3 ์ ์กฐํฉ์ด๊ธฐ ๋๋ฌธ)
- N ์ด 3 ์ธ ๊ฒฝ์ฐ N - 1 ์์ญ์์ M - 1, M - 2 ์นธ์ ํฉ์ด N, M ์ ๊ฐ์ด ๋จ
- M ์ด 1๋ณด๋ค ํฐ ๊ฒฝ์ฐ N - 1 ์์ญ์์ M - 1, M - 2, M - 3 ์นธ์ ํฉ์ N, M ์ ๊ฐ์ด ๋จ
์ 4๊ฐ์ ์กฐ๊ฑด์ ๋ฐํ์ผ๋ก ์ฝ๋๋ฅผ ์์ฑํด๋ณด๊ธฐ๋ก ํ๋ค.
์ฝ๋.
const [T, ...arr] = require('fs').readFileSync('./input.txt', 'utf-8').trim().split('\n');
const nums = arr.map(e => e.split(' ').map(Number));
const maxN = [...nums].sort((a, b) => b[0] - a[0])[0][0];
// N ์ค ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ตฌํ์ฌ maxN ์ ํ ๋น
const maxM = [...nums].sort((a, b) => b[1] - a[1])[0][1];
// M ์ค ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ตฌํ์ฌ maxM ์ ํ ๋น
const dp = Array.from({ length: maxN }, () => new Array(maxM).fill(0n));
const DIV_NUM = 1000000009n;
const solution = (n, m) => {
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (i === j) {
dp[i][j] = 1n;
break;
}
else if (i < 3 && j === 0) dp[i][j] = 1n;
else if (i === 2) dp[i][j] = (dp[i - 1][j - 1] + dp[i - 2][j - 1]) % DIV_NUM;
else if (j > 0) dp[i][j] = (dp[i - 1][j - 1] + dp[i - 2][j - 1] + dp[i - 3][j - 1]) % DIV_NUM;
}
}
}
solution(maxN, maxM);
const result = new Array(+T);
nums.forEach((e, i) => result[i] = dp[e[0] - 1][e[1] - 1]);
console.log(result.join('\n'));
๋ฐฑ์ค ์์ ์ ๋ ฅ 1์ ๊ธฐ์ค์ผ๋ก ์ดํด๋ณด๋ฉด T ๊ฐ 3 ์ฆ, ํ ์คํธ ์ผ์ด์ค๊ฐ 3๊ฐ ์๊ณ ๊ฐ๊ฐ์ ์ผ์ด์ค๋ ์ฌ๋ก ๋ค๋ฅธ(๊ฐ์ ๊ฐ์ด ์กด์ฌํ ์๋ ์์)
n ๊ณผ m ์ ๊ฐ๋๋ค. ๋จ์ํ ๊ฐ๊ฐ์ ์ผ์ด์ค๋ฅผ solution ํจ์์ ์ธ์๋ก ๋๊ฒจ์ค์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐ ํ ์ ์์ง๋ง, ๊ฐ๊ฐ์ ์ผ์ด์ค์์ n๊ณผ m ์ ๊ฐ๊ฐ์ ์ต๋๊ฐ์ maxN, maxM ์ผ๋ก ์ค์ ํ์ฌ ๊ทธ ๊ฐ์ผ๋ก dp (maxN * maxM ๊ณต๊ฐ์ ๊ฐ๊ณ , 0์ด ํ ๋น๋์ด์๋ ๋ฐฐ์ด) ๋ฐฐ์ด์ ์์ฑํด์ฃผ๊ณ solution ํจ์์ maxN, maxM ์ ์ธ์๋ก ์ ๋ฌํ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ค.
์ถ๋ ฅ
์์ ์ฝ๋๋ก ์ฃผ์ด์ง ์ผ์ด์ค (4, 2), (7, 5), (10, 6) ์ผ๋์ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ ์์๋ค.
4 2 → 3
7 5 → 15
10 6 → 90
๐ฅ๋ฐฐ์ด ์
์ด๋ฒ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉด์ ์ด์ ์๋ ํผ๋ณด๋์น ์์ด์ DP ๋ฅผ ํ์ฉํ๋ ๋ฌธ์ ์ ๊ฐ์ด ๋จ์ํ DP ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฒ์ ์ต์ํด ๋ชจ๋ DP ๋ฌธ์ ์ ๊ทผ๋ฒ์ ๋จ์ํ ๊ตฌ์กฐ๋ก ์๊ฐํ๊ณ ์ ๊ทผํ๋๋ฐ 2์ฐจ์ ๋ฐฐ์ด์ ํ์ฉํ๋ฉด์ ์ข๋ ์์ฉ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ๋ ์ข ๋ ๋ค์ํ ์ ๊ทผ๋ฒ์ ์๊ฐํด๋ณผ ์์๊ฒ ๋์๋ค. ํ์ง๋ง, ์ด ๋ฌธ์ ์ ๊ฒฝ์ฐ if ์กฐ๊ฑด๋ฌธ ๋ถ๊ธฐ๋ฅผ ๋ง์ด ์์ฉํด์ ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง๋ ๋ฌธ์ ๊ฐ ์๋ค.
ํผ๋ณด๋์น ์์ด์ DP๋ก ํด๊ฒฐํ ๋ ์ด๊ธฐ๊ฐ์ ์ค์ ํ๋ฏ ์ด ๋ฌธ์ ์๋ ์ด๊ธฐ๊ฐ์ ์ค์ ํ ์ ์๋ ๋ถ๋ถ์ ๋ฐ๋ก ์ค์ ํด ์กฐ๊ฑด ๋ถ๊ธฐ๋ฅผ ์ค์ด๋ ๋ฐฉ๋ฒ์ ๋ชจ์ํด ๊ฐ์ ์ ํด๋ด์ผํ ๊ฑฐ ๊ฐ๋ค.
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ๋ฐฑ์ค 3107 IPv6 (0) | 2025.04.08 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ๋ฒ๋ธ์ ๋ ฌ(Bubble sort) (1) | 2025.01.09 |
[์๊ณ ๋ฆฌ์ฆ] ๋ฐฑ์ค 14651 ๊ฑท๋ค๋ณด๋ ์ ์ฒ์ญ ์ผ (Large) (0) | 2025.01.02 |
[์๊ณ ๋ฆฌ์ฆ] ๋ฐฑ์ค 1904 01ํ์ผ (1) | 2024.12.26 |
[์๊ณ ๋ฆฌ์ฆ] ๋ฐฑ์ค 1003 ํผ๋ณด๋์น ํจ์ (1) | 2024.12.12 |