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

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

动态规划和递归都是通过将大问题分解为较小的子问题来解决问题。它们都可以用来解决具有重叠子问题和最优子结构特性的问题。

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

因此，递归方法相对更加自然而直观，所以在很多情况下，动态规划算法的设计可以从递归算法开始，然后通过添加记忆化（Memoizatio n）技术来优化递归算法，之后对递归算法的代码进行自底向上的迭代改进，得到动态规划代码。

记忆化搜索介绍：https://oi-wiki.org/dp/memo/

算法示例：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)
1
2
3
4
5
6
7
8
9
10
11

按照上述的递归方式可以得到最大金额，但我们在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:
        n=len(nums)
        @cache
        def dfs(i):
            if i==1:
                return nums[0]
            elif i==2:
                return max(nums[1],nums[0])
            else:
                return max(nums[i-1]+dfs(i-2),dfs(i-1))
        return dfs(n)
1
2
3
4
5
6
7
8
9
10
11
12

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

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

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

class Solution:
    def rob(self, nums: List[int]) -> int:
        n=len(nums)
        if n==1:
            return nums[0]
        ans=[0]*n
        ans[0]=nums[0]
        ans[1]=max(nums[0],nums[1])
        for i in range(2,n):
            ans[i]=max(nums[i]+ans[i-2],ans[i-1])
        return ans[n-1]
1
2
3
4
5
6
7
8
9
10
11

空间优化——滚动数组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
2
3
4
5
6

总结

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

算法练习一：LeetCode70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

递归+记忆化搜索

要求当前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)

1
2
3
4
5
6
7
8
9
10

递归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]
1
2
3
4
5
6
7
8

空间优化——滚动数组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
}
1
2
3
4
5
6
7
8
9
10

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

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

按照选或不选的思路分类讨论:

• 如果选即偷nums[0]，那么nums[1]和nums(n 一1]不能偷，问题变成从nums[2]到nums[n -2]的非环形版本，调用示例即198题的代码解决;
• 如果不选即不偷nums(0]，那么问题变成从naums[1]到numsn -1]的非环形版本，同样调用示例即198题的代码解决。

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 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14