力扣：打家劫舍 I & 变形题

题目描述

---

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
力扣：198. 打家劫舍

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

题目分析

经典的动态规划问题
1、状态定义
dp[i]: 考虑下标 i (包括 i) 以内的房间 ， 最多可以偷窃的金额
2、状态转移
决定 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] 取最大值，即 dp[i] = max(dp[i - 2] + nums[i] , dp[i - 1]);

3、 初始化
从递推公式 dp[i] = max(dp[i - 2] + nums[i] , dp[i - 1]) ; 可以看出，递推公式的基础就是 dp[0] 和 dp[1] ，根据 dp[i] 的定义 ， dp[0] = 0 , dp[1] = nums[0]
4、遍历顺序
dp[i] 是由 dp[i - 1] 和 dp[i - 2] 推导出来的， 因此从前向后遍历。
5、返回值
从前向后打家劫舍，因此返回 dp[nums.length] 的值

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 0) return 0;
        int len = nums.length;
        int[] dp = new int[len + 1];
        dp[0] = 0;  dp[1] = nums[0];
        for(int i = 2 ; i <= len ; i ++){
            dp[i] = Math.max(dp[i - 1] , dp[i - 2] + nums[i - 1]);
        }
        return dp[len];
    }
}

优化： 因为 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关， 因此不需要开辟数组，通过两个变量替换

int pre = nums[0], cur = nums[1];
for (int i = 2; i < nums.length ; i++) {
      int temp = cur;
      cur = Math.max(pre + nums[i], cur);
      pre = temp;
}

变形题

---

给你一个整数数组 nums ，你可以对它进行一些操作。
每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须 删除所有等于 nums[i] - 1 和 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的 最大点数。
力扣：740. 删除并获得点数

输入：nums = [2,2,3,3,3,4]
输出：9
解释：
删除 3 获得 3 个点数，接着要删除两个 2 和 4 。
之后，再次删除 3 获得 3 个点数，再次删除 3 获得 3 个点数。
总共获得 9 个点数。

题目分析：
第一时间没有考虑到动态规划，更没有想到 打家劫舍 ， 看了题解后 ， 才发现是真的妙啊 ！！！
根据题意，在选择了元素 x 后，该元素以及所有等于 x − 1 或 x + 1 的元素会从数组中删去。若还有多个值为 x 的元素，由于所有等于 x − 1 或 x + 1 的元素已经被删除，我们可以直接删除 x 并获得其点数。因此若选择了 x ，所有等于 x 的元素也应一同被选择，以尽可能多地获得点数。
记元素 x 在数组中出现的次数为 cx​ ，我们可以用一个数组 sum 记录数组 nums 中所有相同元素之和，即 sum[x] = x ⋅ cx ​。若选择了 x ，则可以获取 sum[x] 的点数，且无法再选择 x − 1 和 x + 1。在统计完 sum 数组后 ， 就和上面的 打家劫舍 是一样的

class Solution {
    public int deleteAndEarn(int[] nums) {
        int maxVal = 0;
        for(int num : nums){
            maxVal = Math.max(maxVal , num);
        }
        int[] sum = new int[maxVal + 1]; 
        for(int num : nums){
            sum[num] += num;
        }
        return rob(sum);
    }

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

优化：同上