๋ฌธ์ ๋งํฌ
https://www.acmicpc.net/problem/1699
๋ฌธ์ ํ์ด IDEA
์ฐ์ dp ๋ฌธ์ ๋ฅผ ๋ง๋๋ฉด, ๊ท์น์ ํ์ ํ๊ธฐ ์ฝ๊ฒ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์๊ธฐ๋ก ์จ๋ณธ๋ค.
์ด๋ ๊ฒ ์์ฑํด๋ณด์๋ค. ๋ฌธ์ ์ ๊ท์น์ด ๋ณด์ผ๋ฏ, ๋ณด์ด์ง ์์๋ค. dp ๋ฐฐ์ด์ 1์ผ๋ ํญ์ ์ 1, 2์ผ๋ ํญ์ ์ 2, 3์ผ๋ ํญ์ ์ 3, 4์ผ๋ ํญ์ ์ 1.. ์ด๋ ๊ฒ ๋ฃ์ผ๋ ค๊ณ ํ๋ ๊ฑด ์๊ฒ ๋ค. ๊ทผ๋ฐ ์ด์ ์ด๋ป๊ฒ ์ ํ์์ ๋ง๋ค์ด์ผํ ๊น?
์ฐ์ ๋๋ ์๋์ ๊ฐ์ ๋ณ์๋ค๊ณผ ๋ฐฐ์ด์ ๋ง๋ค๊ฒ์ด๋ค.
- ์ ๋ ฅ๋ฐ์ n , ํญ์ ์๋ฅผ ๋ฃ์ด๋๋ ๋ฐฐ์ด dp, ํ์ฌ์ ์๋ฅผ ์ง์นญํ๋ i, ์ ๊ณฑ๊ทผ์ผ๋ก ๊ฒฝ์ฐ์์๋ฅผ ๋ฐ์ ธ๋ณผ j
let n = Int(readLine()!)!
var dp = Array(repeating: 0, count: n+1)
์ด์ ๊ท์น์ ์ฐพ์๋ณด์. ์ ์์๋ค ์ค์์ ์ ๋นํ 2์ ๊ณฑ๊ทผ๊ณผ 1์ ๊ณฑ๊ทผ์ด ์์ฌ์๋ 6์ ์์๋ก ๋ค์ด๋ณด์. 6์ 2์ ๊ณฑ + 1์ ๊ณฑ + 1์ ๊ณฑ์ผ๋ก 3๊ฐ์ ํญ์ผ๋ก ์ด๋ฃจ์ด์ ธ์๋ค.
2์ ๊ณฑ์ dp[4] ์ผ๋ ๊ตฌ์ฑ๋๋ ํญ์ด๊ณ , 1์ ๊ณฑ+1์ ๊ณฑ์ dp[2] ๊ฐ ๊ตฌ์ฑ๋ ๋ ๋ํ๋๋ ํญ์ด๋ค. ์ด๊ฒ์ ๋ฐํ์ผ๋ก ๊ตฌํ ์ ์๋ ์ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค.
- dp[6] = dp[4] + dp[2] = dp[2^2] + dp[2]
๋ง์ฝ 6์ด๋ผ๋ฉด, 3^2 ์ ํญ์ ์ด๋ฃฐ ์ ์๋ค ์ด์ ์ ํ์ฉํ์ฌ ์์ ์ธ์๋ณด๋ฉด, dp[6]์ ์ด๊ธฐํํ ๋ 6 > 2^2 ๊ฐ ๋์ด์ผํ๋ค.์ด๋ฅผ if ์กฐ๊ฑด๋ฌธ์ผ๋ก ๋ฃ๊ณ , 6์ i๋ก, ์ ๊ณฑ๊ทผ์ ํํํ๋ 2๋ฅผ j ๋ก ๋ฃ์ด๋ณด์.
for i in 1..<n+1 {
dp[i] = i
for j in 1..<i+1{
// ์ ๊ณฑ์๊ฐ ํ์ฌ i ๋ณด๋ค ์ปค์ง๋ฉด break
if i < j*j {
break
}
if dp[i] > dp[i-(j*j)] {
dp[i] = dp[i-(j*j)] + 1
}
}
}
dp[i] = i ๋ฅผ ๋ฃ๋ ์ด์ ๋, ์ต๋๋ก ์ด๋ฃจ์ด์ง ์ ์๋ ํญ์ ์ผ๋จ ๋ฃ์ด์ฃผ๋ ๊ฒ์ด๋ค. ์ฐ๋ฆฌ์ ๋ชฉํ๋ ์ด์ฐจํผ ์ต์ ๊ฐ์ ๊ตฌํ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ์ต๋๋ก ์ด๋ฃจ์ด์ง ์ ์๋ ํญ์ ๋ฃ์ด์ค ํ, ๋์ค์ dp[i]๋ฅผ ์ด๊ธฐํ ํด์ฃผ๋ ๋ฐฉ์์ผ๋ก ์งํํ๋ค. (dp[6] = 6 ์ด ๋๋๋ฐ, 1^2์ 6๋ฒ ๋ํ๋ ๊ฒ์ด ์ต๋ ํญ์ ๊ฐ์์ด๋ค.)
๊ทธ๋ฆฌ๊ณ ์์์ ์์๋ก ๋ค์๋ 6 < 3^2 ์ ์ฒซ๋ฒ์ฌ if ๋ฌธ์ผ๋ก ๋ํ๋๋ค. 6์ 3์ ์ ๊ณฑ ์ด์์ผ๋ก ์ด๋ฃจ์ด์ง ์ ์๊ธฐ ๋๋ฌธ์, j๋ก 3์ ๋ง๋๋ ์๊ฐ for๋ฌธ์ ํ์ถํ๊ฒ ๋ง๋ค์๋ค.
๋ง์ง๋ง if ๋ฌธ์ด ํต์ฌ์ด๋ค. ์ฌ๊ธฐ์ dp[i] > dp[i-(j*j)] ๋ฅผ ๋ณด์. ์ ์ด์กฐ๊ฑด์ด ๋์๋๊ฐ? ์ฐ๋ฆฌ๋ dp[6]์ ์ด๋ฃจ๋ ์ต์๊ฐ์ ์ฐพ์์ผ ํ๊ธฐ๋๋ฌธ์, ์์ ํญ์ ๊ฐ์๊ฐ ๋์ค๋ฉด ์ง์์ ์ผ๋ก ์ด๊ธฐํ ํด์ฃผ์ด์ผ ํ๋ค. ๊ทธ๋์ ํ์ฌ์ dp[i]๊ฐ ๋ ํฌ๋ฉด ์ด๊ธฐํํ๋ ๊ณผ์ ์ ๊ฑฐ์น๋ ๊ฒ์ด๋ค.
์ด ๋ชจ๋ ์์ค๋ฅผ ํฉ์น ์์ค์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
์์ค์ฝ๋
let n = Int(readLine()!)!
var dp = Array(repeating: 0, count: n+1)
for i in 1..<n+1 {
dp[i] = i
for j in 1..<i+1{
// ์ ๊ณฑ์๊ฐ ํ์ฌ i ๋ณด๋ค ์ปค์ง๋ฉด break
if i < j*j {
break
}
if dp[i] > dp[i-(j*j)] {
dp[i] = dp[i-(j*j)] + 1
}
}
}
print(dp[n])