dp动规规划Day3

题目来源：dp专题：打家劫舍

198. 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

class Solution {
    public int rob(int[] nums) {
        //方法1：使用数组存储中间结果
        // int n=nums.length;
        // //特殊情况
        // if(n==1) return nums[0];
        // int[] dp=new int[n+1];
        // dp[0]=0;dp[1]=nums[0];
        // for (int i = 2; i <=n ; i++) {
        //     //状态方程分当前偷还是不偷，取max
        //     dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i-1]);
        // }
        // return dp[n];
        //方法2：由于只与前2个数有关因此可以优化空间复杂度
        int n=nums.length;
        if(n==1) return nums[0];
        int one=0;int two=nums[0];int res=0;
        for(int i=1;i<n;i++){
            res=Math.max(two,one+nums[i]);
            one=two;two=res;//不断转移one,two指标结果
        }
        return res;
    }
}

213. 打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
示例 1：
输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例 2：
输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 3
输入：nums = [0]
输出：0
提示：
1 <= nums.length <= 100
0 <= nums[i] <= 1000

class Solution {
    public int rob(int[] nums) {
        //特殊情况。
        if (nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        if (nums.length == 2) {
            return Math.max(nums[0], nums[1]);
        }
        int n = nums.length;
        //特殊情况是分为：0到n-1的情况 和  1到n的情况。
        return Math.max(dp(nums, 0, n-1), dp(nums, 1, n));
    }

    private int dp(int[] nums, int start, int end) {
        //利用双指针解法。
        // core 递推公式
        // dp[0] = nums[0], dp[1] = max(ums[0], nums[1])
        // 1, 2, 3
        // dp[2] = max(dp[1], dp[0] + nums[2])
        // dp[i] = max(dp[i-1], dp[i-2] + nums[i])
        int a = nums[start];
        int b = Math.max(nums[start], nums[start+1]);
        int ans = Math.max(a, b);
        for (int i = start + 2; i < end; i++) {
            ans = Math.max(b, a + nums[i]);
            a = b;
            b = ans;
        }
        return ans;
    }
}

740. 删除并获得点数

给你一个整数数组 nums ，你可以对它进行一些操作。
每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。
示例 1：
输入：nums = [3,4,2]
输出：6
解释：
删除 4 获得 4 个点数，因此 3 也被删除。
之后，删除 2 获得 2 个点数。总共获得 6 个点数。
示例 2：
输入：nums = [2,2,3,3,3,4]
输出：9
解释：
删除 3 获得 3 个点数，接着要删除两个 2 和 4 。
之后，再次删除 3 获得 3 个点数，再次删除 3 获得 3 个点数。
总共获得 9 个点数。
提示：
1 <= nums.length <= 2 * 104
1 <= nums[i] <= 104

class Solution {
    public static int deleteAndEarn(int[] nums) {
        if(nums.length==1){
            return nums[0];
        }
        //因为拿了n[i]以后那么就不能够拿n[i]+1和n[i]-1
        int max=0;
        //找到最大的值，然后创建一个比他大一的空间好计算
        for (int i = 0; i < nums.length; i++) {
            max=Math.max(nums[i],max);
        }
        int[] dp=new int[max+1];
        //记录对应的下标还有,下标index表示对应的数值nums[i]表示对应出现的次数
        for (int num : nums) {
            dp[num]++;
        }
        //由于有他们之间的时候不能够取值
        int pre=dp[1]*1;
        int currt=Math.max(pre,dp[2]*2);
        for (int i = 3; i <dp.length ; i++) {
            int temp=currt;
            currt=Math.max(pre+dp[i]*i,currt);
            pre=temp;
        }
        return currt;
    }
}