κ° μ§μ λΉ¨κ°, μ΄λ‘, νλμΌλ‘ μΉ νλ λΉμ©μ΄ μ£Όμ΄μ‘μ λ, μΈμ ν μ§λ€μ΄ κ°μ μμ΄ λμ§ μλλ‘ νλ©΄μ λͺ¨λ μ§μ μΉ νλ μ΅μ λΉμ©μ ꡬνλ λ¬Έμ -> DP ν
μ΄λΈμ 2μ°¨μ 리μ€νΈλ‘ μ μνμ¬ ν μ μλ€. νμ΄λμ νλ‘κ·Έλλ° ν
μ΄λΈ μ μ:dp[i][j]: iλ²μ§Έ μ§μ jμμΌλ‘ μΉ νλ μ΅μ λΉμ© (j = 0: λΉ¨κ°, 1: μ΄λ‘, 2: νλ)μ νμ μ€μ :dp[i][0] = cost[i][0] + min(dp[i-1][1], dp[i-1][2]) (iλ²μ§Έ μ§μ λΉ¨κ°μΌλ‘ μΉ νλ κ²½μ°)dp[i][1] = cost[i][1] + min(dp[i-1][0], dp[i-1][2]) (iλ²μ§Έ μ§μ μ΄λ‘μΌλ‘ μΉ νλ κ²½μ°)dp[i][2] = cost[i][2] + min(dp[i-1][0], dp[i-1][1]) (iλ²μ§Έ ..
DP
λ¬Έμ μ€λͺ
μμ°μ ( n )μ΄ μ£Όμ΄μ§ λ, ( n )μ μ΅μ κ°μμ μ κ³±μ ν©μΌλ‘ νννλ λ°©λ²μ μ°Ύλ νλ‘κ·Έλ¨μ μμ±νλ λ¬Έμ μ΄λ€. λΌκ·Έλμ£Όλ 1770λ
μ λͺ¨λ μμ°μλ λ· νΉμ κ·Έ μ΄νμ μ κ³±μμ ν©μΌλ‘ ννν μ μλ€κ³ μ¦λͺ
νμλ€. μλ₯Ό λ€μ΄, 26μ ( 5^2 + 1^2 )λ‘ ννν μ μκ³ , ( 4^2 + 3^2 + 1^2 )λ‘λ ννν μ μλ€. μ΄ λ¬Έμ μμλ ( n )μ μ΅μ κ°μμ μ κ³±μ ν©μΌλ‘ ννν λ κ·Έ μ΅μ κ°μλ₯Ό ꡬν΄μΌ νλ€. νμ΄ μ€λͺ
μ΄ λ¬Έμ λ λμ κ³νλ²(Dynamic Programming)μ μ¬μ©νμ¬ ν΄κ²°ν μ μλ€. def min_squares(n): # dp[i]λ iλ₯Ό μ΅μ κ°μμ μ κ³±μ ν©μΌλ‘ νννλ λ°©λ²μ κ°μλ₯Ό μ μ₯ dp = [float('inf')] *..
μ£Όμ΄μ§ μΌκ°ν κ·Έλ¦Όμ 보면, μμ μΌκ°νμ ν©μΌλ‘ λ€μ μΌκ°νμ΄ μ±μμ§λ€.-> DP μ£Όμ΄μ§ κ·Έλ¦Όμ κ·Έλ €λ³΄λ©° μκ°ν΄λ³΄λ©΄, μ νμμ μ΄λ ΅μ§ μκ² μ°Ύμ μ μλ€.N12345678P(N)11122345P(8) = P(7) + P(3)P(7) = P(6) + P(2)P(6) = P(5) + P(1-> P(N) = P(N-1) + P(N-5)μ΄λ€. νμ΄dp = [0] * 101dp[1] = dp[2] = dp[3] = 1dp[4] = dp[5] = 2for i in range(6, 101): dp[i] = dp[i-1] + dp[i-5]t = int(input()) # ν
μ€νΈ μΌμ΄μ€ κ°μfor _ in range(t): n = int(input()) print(dp[n])
λ¬Έμ μμ½κ° κ³λ¨μλ μΌμ ν μ μκ° μ°μ¬ μμ - κ·Έ μ μ μ»μ1. ν κ³λ¨ / λ κ³λ¨μ© μ€λ₯Ό μ μλ€2. μ°μλ μΈ κ°μ κ³λ¨μ λͺ¨λ λ°μμλ μ λλ€3. λ§μ§λ§ λμ°© κ³λ¨μ λ°λμ λ°μμΌ νλ€κ° κ³λ¨μ μ°μ¬ μλ μ μκ° μ£Όμ΄μ§ λ μ΄ μ μμ μ΅λκ° νμ΄DPλ‘ ν μ μλ€. 'λ§μ§λ§ λμ°© κ³λ¨μ λ°λμ λ°μμΌ νλ€' λΌλ 쑰건 -> λμ°©μ§λΆν° μκ°νλ μ κ·Όμ΄ λ μ½λ€. nλ²μ§Έ κ³λ¨μ μ¬λΌμ€κΈ° μν΄μλ λ κ°μ§ κ²½μ°κ° μλ€.1. n-1λ²μ§Έ κ³λ¨μμ μ€λ κ²½μ°dp[n] = dp[n-3] + stairs[n-1] + stairs[n]2. n-2λ²μ§Έ κ³λ¨μμ μ€λ κ²½μ°dp[n] = dp[n-2] + stairs[n]-> μ΄ μ€μμ λ ν° μκ° dp[n]μ΄ λλ€. dp[n-3]μ΄ μκΈ° λλ¬Έμ 1, 2, 3λ²..
2×n ν¬κΈ°μ μ§μ¬κ°νμ μ±μ°λ λ°©λ²μ μ nμ΄ 1μΌ λλ 1, nμ΄ 2μΌ λλ κ°λ‘ λκ°, μΈλ‘ λκ°λ‘ 2κ°μ§ ( =, || )nμ΄ 3μΌ λλ nμ΄ 2μΌ λ + nμ΄ 1μΌ λnμ΄ 4μΌ λλ nμ΄ 3μΌ λ + nμ΄ 2μΌ λ-> μ νμ : μ§μ¬κ°ν κ°λ‘μ κΈΈμ΄κ° NμΈ κ²½μ°λ n-1 κ²½μ°μ μ + n-2 κ²½μ°μ μλ₯Ό λν κ° n = int(input())def tiling(n): if n == 1: return 1 if n == 2: return 2 dp = [0] * (n + 1) dp[1] = 1 dp[2] = 2 for i in range(3, n+1): dp[i] = (dp[i-1] + dp[i-2]) % 10007 ..
λμ νλ‘κ·Έλλ°(Dynamic Programming)μ μ¬μ©νμ¬ 0κ³Ό 1λ‘ μ΄λ£¨μ΄μ§ νΉμ μμ΄μ μμ±νκ³ , μ£Όμ΄μ§ μμ΄μ κ° μ«μλ€ μ€ 0κ³Ό 1μ κ°μλ₯Ό ꡬν μ μλ€. νΌλ³΄λμΉ nμμ 0 νΈμΆνμ = (νΌλ³΄λμΉ n-1μμ 0 νΈμΆνμ) + (νΌλ³΄λμΉ n-2μμ 0 νΈμΆ νμ)νΌλ³΄λμΉ nμμ 1 νΈμΆνμ = (νΌλ³΄λμΉ n-1μμ 1 νΈμΆνμ) + (νΌλ³΄λμΉ n-2μμ 1 νΈμΆ νμ)μ΄λ―λ‘ μ νμcount_zero[i] = count_zero[i-1] + count_zero[i-2]count_one[i] = count_one[i-1] + count_one[i-2]μ΄λ° μ νμμ μκ°ν μ μλ€. t = int(input()) # ν
μ€νΈ μΌμ΄μ€μ μ μ
λ ₯def count_ways(n): count_z..
νμ΄ 1: DPμ΄ λ¬Έμ λ₯Ό μν κ°μ₯ ν¨μ¨μ μΈ λ°©λ²μ DPλ₯Ό μ¬μ©νλ κ²μ΄λ€. μ΄κΈ°κ°μ΄κΈ°κ° dp[1] = 1, dp[2] = 2, dp[3] = 4(dp[2]λ 1+1, 2λ‘ 2κ°μ§, p[3]μ 1+1+1, 1+2, 2+1, 3μΌλ‘ 4κ°μ§) μ νμ4μΌ λ dp[3]+1, dp[2]+2, dp[1]+3μ κ°μ΄ ꡬν μ μλ€. --> nμ dp[n-1]+3, dp[n-2]+2, dp[n-3]+3--> λ°©λ²μ μ dp[n] = dp[n-1] + dp[n-2] + dp[n-3] 1, 2, 3μ ν©μΌλ‘ λνλ΄λ λ°©λ²μ μμμ ν λ² κ³μ°ν κ°μ μ¬μ¬μ©ν¨μΌλ‘μ¨ μ€λ³΅ κ³μ°μ λ°©μ§νκ³ , μκ° λ³΅μ‘λλ₯Ό μ€μΌ μ μλ€.def count_ways(n): # nμ 1, 2, 3μ ν©μΌλ‘ λνλΌ μ μλ λ°©λ²μ μλ₯Ό μ μ₯..
subproblem μ€λ³΅, λ°λ³΅μ°μ° λ§μ -> DP νμ΄1 (Bottom-up)n = int(input())dp = [0] * (n+1)for i in range(2, n+1): dp[i] = dp[i-1] + 1 if i % 3 == 0: dp[i] = min(dp[i//3]+1, dp[i]) if i % 2 == 0: dp[i] = min(dp[i//2]+1, dp[i]) print(i, ": ", dp[i])if n νμ΄2 (Top-Down) - Recursion Errordef min_operations(n, dp): if n 0: # μ΄λ―Έ κ³μ°λ κ°μ΄ μλ€λ©΄ κ·Έ κ°μ λ°ν return dp[n] dp[n] = mi..
κ²ΉμΉλ νμ λ¬Έμ (Subproblem)λ₯Ό ν΄κ²°νκ³ κ·Έ κ²°κ³Όλ₯Ό μ μ₯ν΄ λκ°λ λ°©μμΌλ‘ μ΅μ ν λ¬Έμ λ€ νΉμ§1. μμ νμλ¬Έμ λ€μ΄ λ°λ³΅μ μΌλ‘ λ°μνλ©°, μ΄λ€μ ν΄κ²° κ²°κ³Όκ° μ¬νμ©λ μ μμ λ 2. Optimal Substructure(μ΅μ λΆλΆκ΅¬μ‘°)μ κ°μΆ λ¬Έμ . ν° λ¬Έμ μ μ΅μ ν΄κ° μμ λ¬Έμ μ μ΅μ ν΄λ₯Ό ν΅ν΄ ꡬν μ μμ λ 3. μ€λ³΅λ κ³μ°μ μ΅μνν μ μλ ꡬ쑰. κ°μ νμ λ¬Έμ λ₯Ό λ°λ³΅ν΄μ ν΄κ²°ν΄μΌ ν λ νμλ¬Έμ κ° λ
립μ , μ€μ¬κ°λ©΄μ ν΄κ²° -> Divide & Conquer νμλ¬Έμ κ° μ€μ²©λ¨, λ°λ³΅ν΄μΌ ν¨ -> Dynamic Programming DPλ‘ ν΄κ²°νλ λνμ μΈ λ¬Έμ λ€longest common subsequenceKnapsack problemRod cutting problemshortest ..