Maximum Unique Subarray Sum After Deletion

Maximum Unique Subarray Sum After Deletion - Problem

You're given an integer array nums and have the power to delete any elements you want (but not all of them). Your goal is to find a contiguous subarray with all unique elements that has the maximum possible sum.

Think of it as a two-step optimization problem:

Step 1: Delete any elements from nums to remove duplicates strategically
Step 2: Find the contiguous subarray with maximum sum from the remaining elements

The key insight is that you want to keep the largest occurrence of each duplicate element and delete the smaller ones, then find the maximum subarray sum.

Example: If nums = [4,2,4,5,6], you can delete the first 4 to get [2,4,5,6], then the entire array forms a unique subarray with sum 17.

Input & Output

example_1.py — Basic Case

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

› Output: 17

💡 Note: The optimal subarray is [2,4,5,6] with sum 17. We delete the first 4 to avoid duplicates, then take the remaining contiguous elements.

example_2.py — All Unique

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

› Output: 8

💡 Note: The optimal subarray is [5,2,1] with sum 8. Even though we have many duplicates, the best unique subarray has sum 8.

example_3.py — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: With only one element, the maximum unique subarray sum is just that element itself.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴
The array will not be empty after deletions

Visualization

Tap to expand

Understanding the Visualization

Start Collection

Begin collecting treasures from the left, keeping track of what you've seen

Handle Duplicates

When you encounter a duplicate, abandon treasures up to and including the previous occurrence

Track Maximum

Always remember the highest value collection you've achieved

Continue Optimally

Keep extending your collection to the right while maintaining uniqueness

Key Takeaway

🎯 Key Insight: Instead of trying all possible deletions, we use a sliding window that automatically handles duplicates by moving the start pointer past the previous occurrence. This gives us the optimal solution in linear time!

Asked in

G Google 45 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal approach uses a sliding window technique with a hash map to track the last seen position of each element. This allows us to efficiently find the maximum sum subarray with all unique elements in O(n) time. The key insight is that when we encounter a duplicate, we can slide our window start to just after the previous occurrence of that element.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subarrays)	O(n³)	O(n)	Generate all possible subarrays and check which ones have unique elements
Sliding Window (Optimal)	O(n)	O(min(m,n))	Use sliding window with hash map to track last seen positions

Brute Force (Try All Subarrays) — Algorithm Steps

For each starting position i in the array
For each ending position j from i onwards
Check if subarray [i,j] has all unique elements using a set
If unique, calculate sum and update maximum
Continue until duplicate found or array ends

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin checking subarrays starting from index 0

Extend until duplicate

Keep extending the subarray until we find a duplicate element

Move to next start

Move to the next starting position and repeat

Code -

solution.c — C

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

int maximumUniqueSubarray(int* nums, int numsSize) {
    int maxSum = 0;
    
    for (int i = 0; i < numsSize; i++) {
        bool seen[10001] = {false}; // Assuming values <= 10000
        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() {
    int nums[1000];
    int size = 0;
    char input[5000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing
    char* token = strtok(input, "[,] \n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,] \n");
    }
    
    printf("%d\n", maximumUniqueSubarray(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for all subarrays × O(n) for uniqueness check

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) for the set to check uniqueness

⚡ Linearithmic Space

42.0K Views

High Frequency

~18 min Avg. Time

1.6K 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 (Try All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler