算法训练营（day47）

动态规划理论基础

动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的。

举个例子：有N件物品和一个最多能背重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

动态规划中 dp[j] 是由 dp[j-weight[i]] 推导出来的，然后取 max(dp[j], dp[j - weight[i]] + value[i])。

动态规划的解题步骤

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

198. 打家劫舍

题目链接：https://leetcode.cn/problems/house-robber/description/

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

解题思路

解题过程：动态规划

按照动规五部曲来分析：

  1. 确定dp数组（dp table）以及下标的含义

​ dp[j]表示容量为j的背包，最多可以背最大重量为dp[j]

​ 本题的 dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额

  1. 确定递推公式

    决定 dp[i] 的因素就是第i房间偷还是不偷。

  • 如果偷第i房间，那么 dp[i] = dp[i - 2] + nums[i] ，即：第 i-1 房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为 dp[i-2] 加上第i房间偷到的钱。

  • 如果不偷第i房间，那么 dp[i] = dp[i - 1] ，即考虑 i-1房，（注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点）

​ 所以递推公式是：**dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])**

  1. dp数组的初始化

​ 递推公式的基础就是dp[0] 和 dp[1]

1
2
3
int[] dp = new int[nums.length];
dp[0] = nums[0];
dp[1] = Math.max(dp[0], nums[1]);
  1. 确定遍历顺序

​ dp[i] 是根据 dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历！

1
2
3
for(int i = 2; i < nums.length; i++){
       dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
   }
  1. 推导dp数组

详细代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
    public int rob(int[] nums) {
        if(nums == null || nums.length == 0){
            return 0;
        }
        if(nums.length == 1){
            return nums[0];
        }

        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        dp[1] = Math.max(dp[0], nums[1]);

        for(int i = 2; i < nums.length; i++){
            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[nums.length - 1];
    }
}

213. 打家劫舍 II

题目链接：https://leetcode.cn/problems/house-robber-ii/description/

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

解题思路

解题过程：动态规划

按照动规五部曲来分析：

  1. 确定dp数组（dp table）以及下标的含义

​ dp[j]表示容量为j的背包，最多可以背最大重量为dp[j]

​ 本题的 dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额

  1. 确定递推公式

    对于一个数组，成环的话主要有如下三种情况：

  • 情况一：考虑不包含首尾元素

  • 情况二：考虑包含首元素，不包含尾元素

  • 情况三：考虑包含尾元素，不包含首元素

    所以递推公式是：**dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])**

  1. dp数组的初始化

​ 递推公式的基础就是dp[0] 和 dp[1]

1
2
3
int[] dp = new int[nums.length];
dp[0] = nums[0];
dp[1] = Math.max(dp[0], nums[1]);
  1. 确定遍历顺序

​ dp[i] 是根据 dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历！

1
2
3
for(int i = 2; i < nums.length; i++){
       dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
   }

​ 将上面的递推公式以及方法抽离，实现：

1
2
3
4
5
6
7
8
9
public int robAction(int[] nums, int start, int end){
       int x = 0, y = 0, z = 0;			//初始化
       for(int i = start; i < end; i++){	//遍历顺序
           y = z;
           z = Math.max(y, x + nums[i]);	//递归公式
           x = y;
       }
       return z;
   }
  1. 推导dp数组

详细代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution {
    public int rob(int[] nums) {
        if(nums == null || nums.length == 0){
            return 0;
        }
        if(nums.length == 1){
            return nums[0];
        }
        return Math.max(robAction(nums, 0, nums.length - 1), robAction(nums, 1, nums.length));	//比较情况二和三谁大
    }
    public int robAction(int[] nums, int start, int end){
        int x = 0, y = 0, z = 0;
        for(int i = start; i < end; i++){
            y = z;
            z = Math.max(y, x + nums[i]);
            x = y;
        }
        return z;
    }
}

337. 打家劫舍 III

题目链接：https://leetcode.cn/problems/house-robber-iii/description/

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。

解题思路

解题过程：递归三部曲 + 动态规划五部曲

  1. 确定递归函数的参数和返回值

​ 我们需要求一个节点 偷与不偷 的两个状态所得到的金钱，那么返回值就是一个长度为2的数组（本题dp）

  1. 确定终止条件

​ 在遍历的过程中，如果遇到空节点的话就返回（dp数组的初始化）

1
2
3
if(root == null){
       return res;
   }
  1. 确定遍历顺序

​ 首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算

  • 通过递归左节点，得到左节点偷与不偷的金钱。
  • 通过递归右节点，得到右节点偷与不偷的金钱。
1
2
int[] left = robAction(root.left);
int[] right = robAction(root.right);
  1. 确定单层递归的逻辑

  • 如果是偷当前节点，那么左右孩子就不能偷 res[1] = root.val + left[0] + right[0];

  • 如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的 res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);

  • 最后当前节点的状态即：Math.max(不偷当前节点得到的最大金钱，偷当前节点得到的最大金钱)

  1. 推导dp数组

详细代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int rob(TreeNode root) {
        int[] res = robAction(root);
        return Math.max(res[0], res[1]);
    }
    public int[] robAction(TreeNode root){
        int[] res = new int[2];
        if(root == null){
            return res;
        }

        int[] left = robAction(root.left);
        int[] right = robAction(root.right);

        res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        res[1] = root.val + left[0] + right[0];

        return res;
    }
}