[Algorithm] ์ ํ ์ ํ (๋ฐฑ์ค - 11060)
๐ ๋ฌธ์
์ฌํ์ด๊ฐ 1×N ํฌ๊ธฐ์ ๋ฏธ๋ก์ ๊ฐํ์๋ค. ๋ฏธ๋ก๋ 1×1 ํฌ๊ธฐ์ ์นธ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , ๊ฐ ์นธ์๋ ์ ์๊ฐ ํ๋ ์ฐ์ฌ ์๋ค. i๋ฒ์งธ ์นธ์ ์ฐ์ฌ ์๋ ์๋ฅผ Ai๋ผ๊ณ ํ์ ๋, ์ฌํ์ด๋ Ai์ดํ๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ๋จ์ด์ง ์นธ์ผ๋ก ํ ๋ฒ์ ์ ํํ ์ ์๋ค. ์๋ฅผ ๋ค์ด, 3๋ฒ์งธ ์นธ์ ์ฐ์ฌ ์๋ ์๊ฐ 3์ด๋ฉด, ์ฌํ์ด๋ 4, 5, 6๋ฒ ์นธ ์ค ํ๋๋ก ์ ํํ ์ ์๋ค.
์ฌํ์ด๋ ์ง๊ธ ๋ฏธ๋ก์ ๊ฐ์ฅ ์ผ์ชฝ ๋์ ์๊ณ , ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋์ผ๋ก ๊ฐ๋ ค๊ณ ํ๋ค. ์ด๋, ์ต์ ๋ช ๋ฒ ์ ํ๋ฅผ ํด์ผ ๊ฐ ์ ์๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋ง์ฝ, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋์ผ๋ก ๊ฐ ์ ์๋ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ
- ์ฒซ์งธ ์ค์ N(1 ≤ N ≤ 1,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ Ai (0 ≤ Ai ≤ 100)๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
- ์ฌํ์ด๊ฐ ์ต์ ๋ช ๋ฒ ์ ํ๋ฅผ ํด์ผ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋ ์นธ์ผ๋ก ๊ฐ ์ ์๋์ง ์ถ๋ ฅํ๋ค. ๋ง์ฝ, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋์ผ๋ก ๊ฐ ์ ์๋ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
์ ์ถ๋ ฅ ์
์์ ์ ๋ ฅ | ์์ ์ถ๋ ฅ |
10 1 2 0 1 3 2 1 5 4 2 |
5 |
โ๏ธ ํ์ด
์ด ๋ฌธ์ ๋ ํ์ด๋ฐฉ๋ฒ์ด ๋ ๊ฐ์ง๊ฐ ์๊ฐ๋ฌ๋ค. ์ฒซ๋ฒ์งธ๋ DP์ด๊ณ , ๋ ๋ฒ์งธ๋ BFS์ด๋ค. ๋๋ DP๋ฅผ ์ด์ฉํด์ ํ์๋ค.
๋ฌธ์ ์ค๋ช ์ด ์ด์ง ํท๊ฐ๋ ธ๋๋ฐ ๋ค์ ํ๋ฒ ์ฝ์ด๋ณด๋ ์ดํด๊ฐ ์ ๋ฌ๋ค.(ํ์คํ๊ฒ ์ฝ์!!) ํท๊ฐ๋ ธ๋ ์ ์ด ํ์ฌ ์์น์์ ์ผ๋ง๋ ์ ํ๋ฅผ ํ ์ ์๋๊ฐ์๋ค. ๋ฌธ์ ์ "์ฌํ์ด๋ Ai์ดํ๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ๋จ์ด์ง ์นธ์ผ๋ก ํ ๋ฒ์ ์ ํํ ์ ์๋ค." ๋ผ๋ ์ง๋ฌธ์ด ์๋๋ฐ ์ด๊ฒ ํต์ฌ ํฌ์ธํธ์๋ค. ๋ง์ฝ ์ฒซ ๋ฒ์งธ ๋ฏธ๋ก์ ์์นํด ์๋ค๋ฉด A ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์ธ๋ฑ์ค์ ํด๋นํ๋ ์ ์ดํ๋งํผ ์ ํํ ์ ์๋ค.
DP ์ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค.
DP[i] = i ๋ฒ์งธ ๋ฏธ๋ก๊น์ง ๋๋ฌํ ์ ์๋ ์ต์ ์ ํ ํ์
๋ฐ๋ผ์ ํ์ฌ ์์น์์ A ๋ฐฐ์ด์ ์ธ๋ฑ์ค์ ํด๋นํ๋ ์ ์ดํ๋งํผ ๋ฐ๋ณต๋ฌธ์ ๋๋ฆฌ๋ฉฐ ์ต์๊ฐ์ ๊ฐฑ์ ์์ผ์ฃผ๋ฉด ๋๋ค. ์ฒ์ DP ๋ฐฐ์ด์ ๊ฐ ์์๋ ์ต์๊ฐ์ ์ฐพ์์ผ ํ๊ธฐ ๋๋ฌธ์ Infinity๋ก ์ด๊ธฐํํด์คฌ๋ค. ์ด๊ธฐ ์์น(1๋ฒ์งธ)๋ 0์ผ๋ก ์ด๊ธฐํํ๋ค.
๋ง์ฝ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ค๋ฉด ์ปค์ง๋ ๊ฐ์ด๊ธฐ ๋๋ฌธ์ breakํด์ ๋ ์ด์ ํ์ธํ์ง ์๊ณ ์ธ๋ฑ์ค๋ฅผ ์ด๊ณผํ์ง ์๋๋ค๋ฉด Math.min ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ์ ์๋ ์์น์ ์ ํ ํ์๊ฐ์ ๊ฐฑ์ ํ๋ค.
๋ง์ง๋ง์ผ๋ก ์ ์ผ ๋ ์์น(N)๊ฐ Infinity๋ผ๋ฉด ๊ฐ ์ ์๋ ์ํฉ์ด๋ฏ๋ก -1์ ์ถ๋ ฅํ๊ณ ์๋๋ผ๋ฉด DP[N]์ ์ถ๋ ฅํ๋ฉฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค.
โจ๏ธ ์ฝ๋
const fs = require('fs');
const filePath = process.platform === 'linux' ? '/dev/stdin' : './testcase/11060.txt';
let input = fs.readFileSync(filePath).toString().trim().split('\n');
const N = +input[0];
const arr = input[1].split(' ').map(Number);
const dp = new Array(N + 1).fill(Infinity);
dp[1] = 0;
for (let pos = 1; pos <= N; pos++) {
for (let dist = 1; dist <= arr[pos - 1]; dist++) {
if (pos + dist > N) break;
dp[pos + dist] = Math.min(dp[pos + dist], dp[pos] + 1);
}
}
console.log(dp[N] !== Infinity ? dp[N] : -1);