【LeetCode】LeetCode之删除并获得点数——动态规划、排序+动态规划

🔗【LeetCode】LeetCode之打家劫舍【暴力递归、动态规划、动态规划之优化空间的具体分析与实现】
🔗【LeetCode】LeetCode之打家劫舍Ⅱ——暴力递归+动态规划解决循环问题+DP空间优化

1.题目描述

给你一个整数数组 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

2.思路分析Ⅰ

根据题目求最大点数，我们首先能够想到的就是使用动态规划求解。通过迭代+记忆集能够解题。
思考该题你会发现，无论怎么想很难直接转换为动态规划求解，那么我们只有使用间接的方式【明面上看不出来】，那我们如何向动态规划的一般思路靠拢呢？

平常最常见的动态规划一般都是类似于这种dp[n]=max(dp[n-1]，dp[n-2]+a)；此时我们会发现题目中给定了一个类似的条件：删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素，但是后者是具体的值，而前者是下标。这也是一个问题！

根据上述过程分析，主要使用动态规划解题的一个问题是题目中的条件是具体的值-1、+1，而动态规划的一般方式是索引-a、+a。

怎么将值转换为索引呢？

很简单，构建一个新数组即可，将旧数组的每一个值充当新数组的索引。当然这个新数组的大小是要根据旧数组的最大值确定的。

那么新数组的索引存储什么呢？

如果某个数据只有一份，那么它在新数组中的索引和值是一致的。如果数据有n份，那么它的索引就是单个值，它的值是n*单个值。
比如[2，2，2]，那么它存储在索引为2的位置，值为6.

3.动态规划解题

下面的rob方法就和打家劫舍一样了：打家劫舍

    public int deleteAndEarn(int[] nums) {
        int maxNum = -1;
        for (int num : nums) { //求出原数组中的最大值
            maxNum = Math.max(maxNum, num);
        }
        int[] sums = new int[maxNum + 1];//根据最大值构建新数组
        for (int i = 0; i < nums.length; i++) {
            sums[nums[i]] += nums[i];
        }
        return rob(sums);
    }
	//rob打家劫舍解题思路一样
    public int rob(int[] sums) {
        int size = sums.length;
        int pre = sums[0];
        int suf = Math.max(pre, sums[1]);
        int maxEarn = suf;
        for (int i = 2; i < size; i++) {
            maxEarn = Math.max(pre + sums[i], suf);
            pre = suf;
            suf = maxEarn;
        }
        return maxEarn;
    }

复杂度分析

时间复杂度：O(n * m)m为nums数组中的最大值
空间复杂度：O(m)

4.思路分析Ⅱ

说到底本题不能直接使用动态规划的原因就是你无法保证前面操作的数据是否会对后续造成影响，比如说[2,3,4,1,6,7,1]，你如果要操作2，那么数组中的3和1都要进行删除，而这3和1是由于无法确定位置，我们很难在迭代过程中对其进行联系的。另外可以通过排序+划分子序列来完成

例如数组为[2,4,3,1,9]，那么它的执行流程为
1.排序：[1,2,3,4,9]
2.划分子序列 [最大间隔为1] – >[1,2,3,4]与[9]

4.排序+动态规划

注意到若 nums 中不存在某个元素 x，则选择任一小于 x 的元素不会影响到大于 x 的元素的选择。因此我们可以将nums 排序后，将其划分成若干连续子数组，子数组内任意相邻元素之差不超过 11。对每个子数组按照方法一的动态规划过程计算出结果，累加所有结果即为答案。

    public int deleteAndEarn3(int[] nums) {
        Arrays.sort(nums);
        List<Integer> list = new ArrayList<>();
        list.add(nums[0]);
        int result = 0;
        int size = 1;
        for (int i = 1; i < nums.length; i++) {
            int val = nums[i];
            if (val == nums[i - 1]) {
                list.set(size - 1, list.get(size - 1) + val);
            } else if (nums[i - 1] + 1 == val) {
                list.add(val);
                ++size;
            } else {
                result += rob3(list);
                list.clear();
                list.add(nums[i]);
                size = 1;
            }
        }
        result += rob3(list);
        return result;
    }

    private int rob3(List<Integer> list) {
        int size = list.size();
        if (size == 1) {
            return list.get(0);
        }
        int pre = list.get(0);
        int suf = Math.max(pre, list.get(1));
        int maxEarn = suf;
        for (int i = 2; i < size; i++) {
            maxEarn = Math.max(pre + list.get(i), suf);
            pre = suf;
            suf = maxEarn;
        }
        return maxEarn;
    }

复杂度分析：

时间复杂度：O(n*logn)，排序花费的时间
空间复杂度：O(n)