算法套路十三——动态规划DP入门

动态规划和递归都是通过将大问题分解为较小的子问题来解决问题。它们都可以用来解决具有重叠子问题和最优子结构特性的问题。在很多情况下，动态规划算法的设计可以从递归算法开始，然后通过添加记忆化（Memoization）技术来优化递归算法。

• 递归是一种自顶向下的方法，它从原始问题开始，递归地将问题分解为较小的子问题dfs(i)——dfs(i)代表的是从第i个状态开始进行递归求解能够得到的最终结果。直到子问题可以直接解决。递归可能会导致大量的重复计算，因为它没有记录已经解决的子问题的解对递归不理解的话可以前往算法套路七——二叉树递归进行学习
• 动态规划是一种自底向上的方法，它从最小的子问题开始，逐步解决较大的子问题，直到解决原始问题。动态规划通过存储已经解决的子问题的解（通常使用表格或数组）来避免重复计算，从而提高了算法的效率。

算法示例：LeetCode198. 打家劫舍

递归

首先考虑直接用递归解决该题，
求偷窃到的最高金额，可以按照选或不选的思路，按照以下步骤：

1. ans1记录不偷当前房屋的最大金额即dfs(i + 1)
2. ans2记录不偷当前房屋的最大金额即dfs(i + 2) + nums[i]
3. 返回ans1与ans2的较大值
4. 边界情况：当i>=len时表示无房屋可偷返回0
5. 所求值： dfs(0)表示从第0个房屋开始偷窃能够获得的最大金额

class Solution:
    def rob(self, nums: List[int]) -> int:
        def dfs(i)-> int:
            if i >= len(nums):
                return 0
            # 不偷当前房屋
            ans1 = dfs(i + 1)
            # 偷当前房屋
            ans2 = dfs(i + 2) + nums[i]
            return max(ans1, ans2)
        return dfs(0)

按照上述的递归方式可以得到最大金额，但我们在LeetCode上会发现该方法超出时间限制。

如上图所示，我们对于选2这个分支计算了两次，那么如果房屋个数n更多，我们就会重复计算多次，这样会浪费大量的时间，故超出时间限制。

如果我们在第一次计算时，使用数组记录选择2的最大金额来保存计算结果，这样就可以避免重复计算，而这就是动态规划的精髓：递归搜索+保存计算结果=记忆化搜索。

动态规划递归

1. 递归函数定义：dfs(i)函数表示从第i个房屋开始偷窃能够获得的最大金额
2. 状态转移方程：ans1记录不偷当前房屋的最大金额即dfs(i + 1)，ans2记录不偷当前房屋的最大金额即dfs(i + 2) + nums[i]，dfs(i)为ans1与ans2的较大值即状态转移方程：dfs(i) =max (dfs(i - 1), dfs(i-2)+ nums[i])
3. 边界条件：当i>=len时表示无房屋可偷返回0
4. 所求值： dfs(0)表示从第0个房屋开始偷窃能够获得的最大金额。

class Solution:
    def rob(self, nums: List[int]) -> int:
    # python的@cache装饰器可以用来寄存函数对已处理参数的结果，以便遇到相同参数可以直接给出答案。
        @cache
        def dfs(i: int) -> int:
            if i >len(nums)-1: return 0
            return max(dfs(i + 1), dfs(i + 2) + nums[i])
        return dfs(0)

递归dfs()1:1 转换成迭代dp[]数组

如果一个动态规划问题可以用自底向上的方法求解，那么它通常可以从递归转换为迭代。
递归到迭代的转换是通过以下步骤实现的：

1. 分析递归解法中的状态转移方程。在上述动态规划代码片段中，状态转移方程为：dfs(i) = max(dfs(i - 1), dfs(i - 2) + nums[i])。
2. 使用一个数组 dp[] 来存储子问题的解。数组的长度为len(nums) + 2，这是为了处理边界情况。
3. 使用迭代的方式，自底向上计算子问题的解，如从前往后遍历数组，根据状态转移方程计算每个子问题的解，并将结果存储在数组中如本题我们可以通过 for i, x in enumerate(nums): dp[i + 2] = max(dp[i + 1],dp[i] + x)来迭代记录，与状态转移方程对比，我们可以发现改变的只将dfs全部换为了f[]数组记录，其次就是i的起始值会变化。

class Solution:
    def rob(self, nums: List[int]) -> int:
        dp = [0] * (len(nums) + 2)
        for i, x in enumerate(nums):
            dp[i + 2] = max(dp[i + 1], dp[i] + x)
        return dp[-1]

空间优化——滚动数组dp[i]转换为有限变量f0与f1

因为递推函数dp[i + 2] = max(dp[i + 1], dp[i] + x) 只依赖于前两个值dp[i + 1]和dp[i] + x)，因此我们可以用f0与f1来循环记录中间结果。
当动态规划问题具有这种“滚动数组”特性时，通常可以通过使用有限数量的变量来减少空间复杂度。

class Solution:
    def rob(self, nums: List[int]) -> int:
        f0 = f1 = 0
        for i, x in enumerate(nums):
            f0, f1 = f1, max(f1, f0 + x)
        return f1

总结

如果不是很熟悉动态规划，在进行做题时可以采用示例的思路，首先思考只考虑递归该如何解决该题，之后1:1转换为迭代dp[]数组做动态规划，最后考虑是否可以进行空间优化。

算法练习一：LeetCode70. 爬楼梯

动态规划递归

要求当前n层有多少种方法，每次可以走1或2台阶，即我们可以得出递推函数为dfs(i) =dfs(i - 1)+dfs(i-2)，dfs(i)代表的是从第i个阶梯开始爬楼梯能够到达顶部的不同方法数。当 n 等于 1 或 2 时，直接返回 1 或 2。否则，递归调用 climbStairs(n-1) 和 climbStairs(n-2)，并将它们的结果相加。

class Solution:
    @cache
    def climbStairs(self, n: int) -> int:
        if n == 1:
            return 1
        elif n == 2:
            return 2
        else:
            return self.climbStairs(n-1) + self.climbStairs(n-2)

递归dfs()1:1 转换成迭代dp[]数组

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

空间优化——滚动数组dp[i]转换为有限变量f0与f1

由示例可知本题可以直接进行空间优化

func climbStairs(n int) int {
    if n==1{
        return 1
    }
    f0,f1:=1,2
    for i:=2;i<n;i++{
        f0,f1=f1,f0+f1
    }
    return f1
}

算法练习二：LeetCode213. 打家劫舍 II

func rob1(nums []int, start, end int) int {
    f0, f1 := 0, 0
    for i := start; i < end; i++ {
        f0, f1 = f1, max(f1, f0+nums[i])
    }
    return f1
}

func rob(nums []int) int {
    n := len(nums)
    return max(nums[0]+rob1(nums, 2, n-1), rob1(nums, 1, n))
}
func max(a, b int) int { if b > a { return b }; return a }