✅DAY32 动态规划DP | 509. 斐波那契数 | 70. 爬楼梯 | 746. 使用最小花费爬楼梯

一、动态规划

Dynamic Programming DP，是一种将复杂问题分解为子问题并通过保存子问题的解来避免重复计算的算法思想。它通常用于解决具有最优子结构和重叠子问题性质的优化问题。

二、解题步骤

1. 确定状态（State）：

• 定义状态变量，表示问题的某个阶段。例如，dp[i] 表示第 i 阶段问题的最优解。

2. 定义状态转移方程（State Transition）：

• 找到子问题与父问题之间的关系，写出递推公式。

3. 初始化（Initialization）：

• 给定最小的子问题结果（边界条件）。是为0还是1 

4. 确定遍历顺序（Iteration Order）：

• 根据状态转移方程的依赖关系，确定遍历的顺序。

5. 返回结果（Result）：

• 通常是最后一个状态变量，或者整个状态数组中满足条件的值。

三、常见题型

***背包问题，打家劫舍，股票问题，子序列问题

（1）序列问题

        1. 最长递增子序列（LIS）：

        • 状态转移：dp[i] = max(dp[j] + 1)，其中 0 <= j < i 且 nums[j] < nums[i]。

        2. 最长公共子序列（LCS）：

        • 状态转移：dp[i][j] = dp[i-1][j-1] + 1（如果字符相同）。

（2）背包问题

        1 背包问题：

        • 状态转移：dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])

        2. 完全背包问题：

        • 状态转移：dp[i][j] = max(dp[i-1][j], dp[i][j-weight[i]] + value[i])

（3）区间问题

        1. 戳气球问题：

        • 状态转移：dp[i][j] = max(dp[i][k] + dp[k][j] + nums[i]*nums[k]*nums[j])

        2. 括号生成问题：

        • 状态转移：基于左右括号数量。

（4）路径问题

        1. 最小路径和：

        • 状态转移：dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]

        2. 独特路径：

        • 状态转移：dp[i][j] = dp[i-1][j] + dp[i][j-1]

509. 斐波那契数

解题思路：最代表的DP题，[i] = [i-1] + [i-2]

class Solution:
    def fib(self, n: int) -> int:
        if n <= 1: return n
        dp = [0] * (n+1)
        dp[0], dp[1] = 0, 1
        for i in range(2, n+1):
            dp[i] = dp[i-1] + dp[i-2]
        
        return dp[n]

递归：

class Solution:
    def fib(self, n: int) -> int:
        if n <= 1: return n
        return self.fib(n-1) + self.fib(n-2)

70. 爬楼梯

解题思路：要点是n为正整数，dp[0]的含义应该为0，返回dp[n]直接对应有n步

class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 1: return n
        dp = [0] * (n+1)

        dp[1], dp[2] = 1, 2
        for i in range(3, n+1):
            dp[i] = dp[i-2] + dp[i-1]
        
        return dp[n]

746. 使用最小花费爬楼梯

dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1] (已有+新花费)

dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2] (已有+新花费)

dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        dp = [0] * (len(cost) +1)
        dp[0], dp[1] = 0, 0 
        for i in range(2, len(cost)+1):
            dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
        
        return dp[len(cost)]