Maximum Erasure Value - Practice Coding Problems

Maximum Erasure Value - Problem

You have an array of positive integers and need to find the most valuable subarray you can "erase" - but there's a catch! The subarray must contain only unique elements (no duplicates).

Your score is the sum of all elements in the erased subarray. Your goal is to find the maximum possible score by choosing the optimal contiguous subarray.

Example: Given [4,2,4,5,6], you could erase [4,2] (score = 6), [2,4,5,6] (score = 17), or [4,5,6] (score = 15). The maximum score is 17.

Think of it as a sliding window problem where you want to find the longest valid window with the highest sum!

Input & Output

example_1.py — Python

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

› Output: 17

💡 Note: The optimal subarray is [2,4,5,6] with sum 2+4+5+6=17. We can't include the first 4 because then we'd have duplicate 4s.

example_2.py — Python

$ Input: [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. Any longer subarray would contain duplicates.

example_3.py — Python

$ Input: [1]

› Output: 1

💡 Note: With only one element, that element forms the only possible subarray with sum 1.

Visualization

Tap to expand

Understanding the Visualization

Expand Window

Move right pointer to include new elements in the window

Check Duplicates

Use hash map to detect if current element creates a duplicate in window

Shrink Window

When duplicate found, move left pointer past the previous occurrence

Track Maximum

Continuously update the maximum sum across all valid windows

Key Takeaway

🎯 Key Insight: Instead of restarting from scratch when we find duplicates, we can efficiently slide our window by moving the left boundary past the duplicate element, achieving linear time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited at most twice (once by right pointer, once by left pointer)

✓ Linear Growth

Space Complexity

O(n)

Hash map to store element positions, worst case stores all elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴
All elements are positive integers

Asked in

A Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses a sliding window approach with a hash map to track element positions. When duplicates are found, we efficiently shrink the window from the left, achieving O(n) time complexity. This is much better than the brute force O(n²) approach that checks all possible subarrays.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subarrays)	O(n²)	O(n)	Check every possible subarray and find the maximum sum among valid ones
Sliding Window with Hash Map (Optimal)	O(n)	O(n)	Use sliding window technique with hash map to track element positions

Brute Force (Try All Subarrays) — Algorithm Steps

For each starting index i from 0 to n-1
Use a set to track seen elements in current subarray
Expand from i while elements are unique
Calculate sum and update maximum
Reset set for next starting position

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin checking subarray starting at position 0

Expand while unique

Add elements to subarray as long as they're unique

Record maximum sum

Update global maximum if current sum is larger

Move to next start

Repeat process starting from next position

Code -

solution.c — C

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

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

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(line, "[],\n ");
    
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", maximumUniqueSubarray(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting positions, we potentially check up to n elements

⚠ Quadratic Growth

Space Complexity

O(n)

Set to store unique elements in current subarray

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴
All elements are positive integers

125.0K Views

High Frequency

~18 min Avg. Time

2.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler