Maximum Erasure Value

Maximum Erasure Value - Problem

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.

A subarray 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).

Input & Output

Example 1 — Basic Case

$ Input: nums = [4,2,4,5,6]

› Output: 17

💡 Note: The optimal subarray is [2,4,5,6] with all unique elements and sum = 2+4+5+6 = 17

Example 2 — Single Element

$ Input: nums = [5,2,1,2,5,2,1,2,5]

› Output: 8

💡 Note: The optimal subarray is [5,2,1] with sum = 5+2+1 = 8

Example 3 — All Unique

$ Input: nums = [1,2,3,4]

› Output: 10

💡 Note: All elements are unique, so we take the entire array: 1+2+3+4 = 10

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 18 G Google 12

The key insight is to use a sliding window with a hash set to maintain unique elements efficiently. The optimal approach uses two pointers that expand and contract the window, achieving O(n) time complexity while tracking the maximum sum of any subarray with unique elements.

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(n)

For each starting position, extend the subarray as long as all elements remain unique. Track the maximum sum found.

Sliding Window with Hash Set

⏱️ Time: O(n) Space: O(n)

Maintain a sliding window with two pointers. Expand right pointer to include new elements, contract left pointer when duplicates are found.

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: For each starting index i, initialize empty set and sum
Step 2: Extend from i to j, add element if not in set
Step 3: Stop when duplicate found, update maximum sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Try each starting index

Extend Window

Add elements while unique

Track Maximum

Update best sum found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

int solution(int* nums, int numsSize) {
    int maxSum = 0;
    
    for (int i = 0; i < numsSize; i++) {
        bool seen[100001] = {false};
        int currentSum = 0;
        
        for (int j = i; j < numsSize; j++) {
            if (seen[nums[j]]) {
                break;
            }
            seen[nums[j]] = true;
            currentSum += nums[j];
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
        }
    }
    
    return maxSum;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[10000];
    int size = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops for start (n) and end (n) positions, plus O(n) set operations

⚠ Quadratic Growth

Space Complexity

O(n)

Set to track unique elements in current subarray

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler