๐ ๋ฌธ์ ํ์ํ๊ธฐ
- ์ ์ A๋ฅผ ์ ์ K๋ก ๋ง๋ค๊ธฐ ์ํด ๋ ๊ฐ์ง ์ฐ์ฐ๋ง ์ฌ์ฉ ๊ฐ๋ฅ
- ์ ์ A์ 1 ๋ํ๊ธฐ
- ์ ์ B์ 2 ๊ณฑํ๊ธฐ
- ์ ๋๊ฐ์ง ์ฐ์ฐ์ ํตํด ์ฃผ์ด์ง A๋ฅผ K๋ก ๋ง๋ค๊ธฐ ์ํ ์ต์ ์ฐ์ฐ ํ์ ๊ตฌํ๊ธฐ
- ๋ฒ์ : 1 ≤ A < K ≤ 1,000,000
์ฒ์ ๋ณด์๋ง์ ๋ ์ค๋ฅธ ๋ฐฉ๋ฒ์ ๋์ ๊ณํ๋ฒ(DP)๋ก ํ์ดํ๋ ๋ฐฉ๋ฒ์ด๋ค. A๊ฐ A๋ถํฐ K๊ฐ ๋๊ธฐ ์ ๊น์ง ๋๊ฐ์ง ์ฐ์ฐ์ ํตํด ๊ฐ ์๋ฅผ ๋ง๋ค ์ ์๋ ์ต์ ์ฐ์ฐ ํ์๋ฅผ ์ ์ฅํด๋๊ณ , ๊ทธ ์ ์ฅ๋ ๊ฐ์ ๋์ค์ ๋ค์ ํ์ฉํ๋ ๋ฐฉ์์ด๋ค.
์ ํ์์ ์๋์ ๊ฐ์ด ์ธ์ธ ์ ์๋ค.
- n์ด ํ์์ผ ๊ฒฝ์ฐ, dp[n] = dp[n-1]+1
- n์ด ์ง์์ผ ๊ฒฝ์ฐ, dp[n] = min(dp[n-1], dp[n//2])+1
A์์ K๊น์ง ์์ฐจ์ ์ผ๋ก ๊ฐ์ ๊ฐฑ์ ํด์ผํ๊ธฐ ๋๋ฌธ์ ์๊ฐ๋ณต์ก๋๋ O(K-A)๊ฐ ๋๋ค.
๐ ์ฝ๋ ์ค๊ณํ๊ธฐ
- A์ K๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค.
- dp ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๊ณ , ๋ฆฌ์คํธ์ ๋ชจ๋ ์์์ ๊ฐ์ K๋ก ์ด๊ธฐํ ํ๋ค.
- i๊ฐ A+1๋ถํฐ K์ผ๋๊น์ง, ์ ํ์์ ์ด์ฉํ์ฌ dp[i]๊ฐ์ ๊ตฌํ๋ค.
- dp[K]๋ฅผ ์ถ๋ ฅํ๋ค.
dp ๋ฆฌ์คํธ์ ์์ ๊ฐ์ K๋ก ์ด๊ธฐํ ํ ์ด์
K๋ ์ด ๋ฌธ์ ์์ ๊ฐ๋ฅํ ์ต๋ ์ฐ์ฐ๋ณด๋ค ๋ฌด์กฐ๊ฑด ํฐ ๊ฐ์ด๋ค. A์์ K๋ก ๊ฐ๊ธฐ ์ํด์ ์ต์ํ์ ์ฐ์ฐ์ด ํ์ํ๊ธฐ ๋๋ฌธ์ ์ด๊ธฐ๊ฐ์ผ๋ก K๋ฅผ ์ค์ ํ๋ฉด, ์ถํ์ ์ค์ ๊ณ์ฐํ ์ฐ์ฐ ํ์์ ๋น๊ตํ๋ ๊ณผ์ ์์ ๋ฌด์กฐ๊ฑด ๊ฐฑ์ ๋๊ฒ ๋๋ค. ์ฆ, dp[n] = K๋ผ๋ฉด, ์์ง ๊ณ์ฐ๋์ง ์์๋ค๋ ์๋ฏธ๋ฅผ ๊ฐ๊ฒ ๋๋ค.
๐ ์ ๋ต ์ฝ๋
A, K = map(int, input().split())
dp = [K]*(K+1) # dp[n] = A๋ฅผ n์ผ๋ก ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ต์ ์ฐ์ฐ ํ์
dp[A] = 0
for i in range(A+1, K+1):
dp[i] = dp[i-1] + 1
if i%2 == 0:
dp[i] = min(dp[i-1], dp[i//2]) + 1
print(dp[K])
728x90