力扣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

思路

本题可以看做是打家劫舍问题的变形，以示例二为例，现将数组排序原数组不一定有序，[2,2,3,3,3,4]，在本题中如果小偷偷了3则不能偷2和4，在这里从前往后考虑，只考虑每个点前面的点，不考虑后面的，这样遍历结束就都考虑到了，先将数组去重后排序，并用counts数组的下标记录每个数字出现的次数，去重后为[2,3,4],在按这个顺序偷时，如果小偷偷了第一个3的话，不能偷2和4但是剩下的两个3可以继续偷，这样可以保证利益最大化。
这里dp[i]依然表示前面i个所获得的的最大价值，对应的数组为[2,3,4],对于dp[i]分两种情况考虑:
当dp[i] == dp[i -1] + 1 时偷与不偷选最大值
dp[i] = max(dp[i - 1],dp[i - 2] + dp[i] * counts[dpi])；
当dp[i] != dp[i - 1] + 1 时，一定可以偷所以将当前位置的兼价值和前面i - 1的最大价值相加即可：
dp[i] = dp[i - 1] + dp[i] * counts[dpi];

Java代码：

class Solution {
    public int deleteAndEarn(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        int[] counts = new int[10000];
        Set<Integer> set = new HashSet<>();

        for (int i = 0; i < nums.length; i++) {
            counts[nums[i]]++;
            set.add(nums[i]);
        }

        int all[] = new int[set.size()];

        int dp[] = new int[set.size()];

        int k = 0;
        for (Integer integer : set) {
            dp[k] = integer;
            all[k] = integer;
            k++;
        }
        Arrays.sort(dp);

        Arrays.sort(all);

        dp[0] = dp[0] * counts[dp[0]];
        if (all[1] == all[0] + 1) {
            dp[1] = Math.max(all[0] * counts[all[0]],all[1] * counts[all[1]]);
        } else {
            dp[1] = all[0] * counts[all[0]] + all[1] * counts[all[1]];
        }
        for (int i = 2; i < dp.length; i++) {
            if (all[i] == all[i - 1] + 1) {
                dp[i] = Math.max(dp[i - 1],dp[i] * counts[dp[i]] + dp[i - 2]);
            } else {
                dp[i] = dp[i - 1] + dp[i] * counts[dp[i]];
            }
        }


        return dp[dp.length - 1];
    }
}