[LeetCode] 1695. Maximum Erasure Value

You are given an array of positive integers nums and want to erase a subarray containing unique elements. The score you get by erasing the subarray is equal to the sum of its elements.

Return the maximum score you can get by erasing exactly one subarray.

An array b is called to be a subarray of a if it forms a contiguous subsequence of a, that is, if it is equal to a[l],a[l+1],...,a[r] for some (l,r).

Example 1:

Input: nums = [4,2,4,5,6]
Output: 17
Explanation: The optimal subarray here is [2,4,5,6].

Example 2:

Input: nums = [5,2,1,2,5,2,1,2,5]
Output: 8
Explanation: The optimal subarray here is [5,2,1] or [1,2,5].

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 104

删除子数组的最大得分。

给你一个正整数数组 nums ，请你从中删除一个含有 若干不同元素 的子数组。删除子数组的 得分 就是子数组各元素之 和 。

返回 只删除一个 子数组可获得的 最大得分 。

如果数组 b 是数组 a 的一个连续子序列，即如果它等于 a[l],a[l+1],...,a[r] ，那么它就是 a 的一个子数组。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-erasure-value
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路是滑动窗口，而且跟 第三题 很接近。这里我们找的是一个子数组的和，子数组的数字们都是互不相同的，我们用 hashset 来检查窗口内部的元素是否有重复。

时间O(n)

空间O(n)

Java实现

class Solution {
    public int maximumUniqueSubarray(int[] nums) {
        int start = 0;
        int end = 0;
        int sum = 0;
        int res = 0;
        int len = nums.length;
        HashSet<Integer> set = new HashSet<>();
        while (end < len) {
            if (!set.contains(nums[end])) {
                sum += nums[end];
                set.add(nums[end]);
                end++;
                res = Math.max(res, sum);
            } else {
                sum -= nums[start];
                set.remove(nums[start]);
                start++;
            }
        }
        return res;
    }
}

 

这里我再提供一个用数组当做 hashset 的实现，思路是一样的，但是运行速度快很多。

class Solution {
    public int maximumUniqueSubarray(int[] nums) {
        int start = 0;
        int end = 0;
        int len = nums.length;
        int sum = 0;
        int res = 0;
        int[] set = new int[10001];
        while (end < len) {
            if (set[nums[end]] == 0) {
                sum += nums[end];
                set[nums[end]] = 1;
                end++;
                res = Math.max(res, sum);
            } else {
                sum -= nums[start];
                set[nums[start]] = 0;
                start++;
            }
        }
        return res;
    }
}

 

这道题也可以用前缀和的思路实现。首先需要创建一个长度为 len + 1 的数组记录input数组的前缀和。也是需要左右两个指针，一开始右指针往前走，并同时将当前数字 nums[end] 及其下标的对应关系记录在hashmap里。当我们遇到一个 nums[end] 存在于 hashmap 的时候，我们需要开始挪动 start 指针，一直挪动到覆盖掉 nums[end] 第一次出现的 index + 1 为止。一个需要考虑的corner case是如果整个数组都没有重复数字，目标子数组的和就是整个数组的和。这也就是为什么这道题计算前缀和的部分跟别的题稍有不同的原因之一。

Java实现

class Solution {
    public int maximumUniqueSubarray(int[] nums) {
        int len = nums.length;
        int[] sums = new int[len + 1];
        // sums[0] = nums[0];
        for (int i = 0; i < len; i++) {
            sums[i + 1] = sums[i] + nums[i];
        }

        int res = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        int start = 0;
        int end = 0;
        while (end < len) {
            if (map.containsKey(nums[end])) {
                res = Math.max(res, sums[end] - sums[start]);
                int lastIndex = map.get(nums[end]);
                while (start < lastIndex + 1) {
                    map.remove(nums[start]);
                    start++;
                }
            }
            map.put(nums[end], end);
            end++;
        }
        // corner case, when end pointer keeps moving until the end of the array
        res = Math.max(res, sums[end] - sums[start]);
        return res;
    }
}

 

相关题目

3. Longest Substring Without Repeating Characters

1695. Maximum Erasure Value

sliding window相关题目

LeetCode 题目总结