动态规划基础part01

动态规划，英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。

解题步骤：

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

LeetCode509.斐波那契数

题目链接：[509. 斐波那契数]

"""
1. 确定dp数组以及下标的含义：dp[i]就表示第i个斐波那契数
2. 确定递推公式：题目中已经给出dp[i] = dp[i-1] + dp[i-2]
3. dp数组初始化：dp[0] = 0, dp[1] = 1
4. 遍历顺序：从2开始遍历至n
5. 举例推导
"""
class Solution:
    def fib(self, n: int) -> int:
        if n < 2:
            return n
        dp = [0] * (n+1)
        dp[0] = 0
        dp[1] = 1

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

        return dp[n]

   
# 当然本题比较简单，可以不用维护一个n+1长度的数组，仅使用两个变量维护，空间复杂度降为O（1）
class Solution:
    def fib(self, n: int) -> int:
        if n < 2:
            return n
        pre1, pre2 = 0, 1

        for _ in range(2, n + 1):
            cur = pre1 + pre2
            pre1, pre2 = pre2, cur

        return pre2

LeetCode70.爬楼梯

题目链接：[70. 爬楼梯]

思路：到达第n阶有两种方式，从第n-1阶跳1个台阶或者从第n-2阶跳2个台阶，所以到达第n阶总方式就是到达第n-1阶的方式加上第n-2阶的方式，状态转移方程与斐波那契数列相似

"""
1. 确定dp数组以及下标的含义：dp[i]就表示到达第i阶的总方式
2. 确定递推公式：根据上述思路，dp[i] = dp[i-1] + dp[i-2]
3. dp数组初始化：dp[0]=0（这里其实可以不用考虑dp[0]的初始化）, dp[1] = 1,dp[2]=2
4. 遍历顺序：从3开始遍历至n
5. 举例推导
"""
class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 2:
            return n

        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]

        return dp[n]
  
# 类似的，与斐波那契一样，本题可以不用维护一个n+1长度的数组，仅使用两个变量维护，空间复杂度降为O（1）
class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 2:
            return n

        pre1 = 1
        pre2 = 2
        for i in range(3, n+1):
            cur = pre1 + pre2
            pre1, pre2 = pre2, cur

        return pre2

LeetCode746.使用最小花费爬楼梯

题目链接：[746. 使用最小花费爬楼梯]

思路如下：思路与[70. 爬楼梯]类似，就是dp数组含义需要变化，这里需要注意的是，楼梯顶部不是len(cost)，而是len(cost) + 1

"""
1. 确定dp数组以及下标的含义：dp[i]就表示到达第i阶的最小花费
2. 确定递推公式：根据上述思路，dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2])
3. dp数组初始化：dp[0]=0, dp[1] = 0，0或者1阶可以直接到达，无需花费
4. 遍历顺序：从2开始遍历至n
5. 举例推导
"""
class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        if n <= 1:
            return 0

        dp = [0] * (n+1)
        dp[0] = 0
        dp[1] = 0

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

# 同样可以仅使用两个变量维护，空间复杂度降为O（1）    
class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        if n <= 1:
            return 0

        pre1 = 0
        pre2 = 0

        for i in range(2, n+1):
            dpi = min(pre2 + cost[i-1], pre1 + cost[i-2])
            pre1, pre2 = pre2, dpi
        return pre2