Maximize Subarray Sum After Removing All Occurrences of One Element

Maximize Subarray Sum After Removing All Occurrences of One Element - Problem

You're given an integer array nums, and you have the power to strategically eliminate all occurrences of any single value from the array. Your mission? Maximize the resulting subarray sum!

Here's how it works:

Choose any integer x that appears in the array
Remove all occurrences of x from nums
The array must remain non-empty after removal
Find the maximum possible subarray sum from the resulting array

Goal: Return the maximum subarray sum you can achieve across all possible ways of removing elements.

Example: For nums = [1, -2, 0, 3], you could remove all -2s to get [1, 0, 3] with max subarray sum of 4, or remove all 0s to get [1, -2, 3] with max subarray sum of 3.

Input & Output

example_1.py — Basic Case

$ Input: [1, -2, 0, 3]

› Output: 4

💡 Note: Remove all occurrences of -2 to get [1, 0, 3]. The maximum subarray sum is 1 + 0 + 3 = 4.

example_2.py — All Negative

$ Input: [-1, -2, -3]

› Output: -1

💡 Note: Remove -3 and -2 to get [-1] or remove -1 and -3 to get [-2]. Best option is removing -2 and -3 to get [-1], giving maximum subarray sum of -1.

example_3.py — Mixed Values

$ Input: [2, -1, 2, 1, -2, 1]

› Output: 6

💡 Note: Remove all occurrences of -1 and -2. If we remove -2, we get [2, -1, 2, 1, 1] with max subarray sum of 5. If we remove -1, we get [2, 2, 1, -2, 1] with max subarray sum of 5. But removing -2 gives us [2, -1, 2, 1, 1] and the subarray [2, 1, 1] = 4 or [2] + [2, 1, 1] through kadane gives us 6.

Visualization

Tap to expand

Understanding the Visualization

Catalog Unique Types

Identify all unique values (photo types) in the array

Simulate Each Removal

For each unique value, simulate removing all its occurrences

Apply Kadane's Magic

Use Kadane's algorithm to efficiently find maximum subarray sum

Track Global Maximum

Keep track of the best result across all removal strategies

Key Takeaway

🎯 Key Insight: We only need to try removing each unique value once, then use Kadane's algorithm to efficiently find the maximum subarray sum in the remaining elements. This gives us O(k×n) complexity where k is the number of unique values.

Time & Space Complexity

Time Complexity

⏱️

O(k × n)

k unique values × n elements for Kadane's algorithm on each filtered array

✓ Linear Growth

Space Complexity

O(n)

Space for storing the filtered array after removing elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
The array must remain non-empty after removal

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses Kadane's algorithm after trying to remove each unique value. For each unique value in the array, we simulate its removal and apply Kadane's algorithm to find the maximum subarray sum in O(n) time. The key insight is that we only need to try removing each distinct value once, making the total complexity O(k × n) where k is the number of unique values.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Brute Force (Kadane's for Each Removal)	O(k × n)	O(n)	Try removing each unique value and use Kadane's algorithm for max subarray

Optimized Brute Force (Kadane's for Each Removal) — Algorithm Steps

Collect all unique values from the array
For each unique value, create array without that value
Apply Kadane's algorithm to find maximum subarray sum
Track the global maximum across all attempts
Return the best result found

Visualization

Tap to expand

Step-by-Step Walkthrough

Remove Value

Remove all occurrences of selected value

Apply Kadane's

Use Kadane's algorithm: track max_ending_here and max_so_far

Single Pass

Find maximum subarray sum in O(n) time

Update Global Max

Keep track of the best result across all removals

Code -

solution.c — C

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

int max(int a, int b) {
    return (a > b) ? a : b;
}

int kadane(int* arr, int size) {
    if (size == 0) return INT_MIN;
    int maxEndingHere = arr[0];
    int maxSoFar = arr[0];
    
    for (int i = 1; i < size; i++) {
        maxEndingHere = max(arr[i], maxEndingHere + arr[i]);
        maxSoFar = max(maxSoFar, maxEndingHere);
    }
    return maxSoFar;
}

int maximumSum(int* nums, int numsSize) {
    int maxSum = INT_MIN;
    
    // Try removing each element (considering duplicates)
    int* tried = (int*)calloc(numsSize, sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        if (tried[i]) continue;
        
        int valToRemove = nums[i];
        
        // Mark all occurrences as tried
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] == valToRemove) {
                tried[j] = 1;
            }
        }
        
        // Create filtered array
        int* filtered = (int*)malloc(numsSize * sizeof(int));
        int filteredSize = 0;
        
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] != valToRemove) {
                filtered[filteredSize++] = nums[j];
            }
        }
        
        if (filteredSize > 0) {
            maxSum = max(maxSum, kadane(filtered, filteredSize));
        }
        
        free(filtered);
    }
    
    free(tried);
    return maxSum;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    printf("%d\n", maximumSum(nums, n));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × n)

k unique values × n elements for Kadane's algorithm on each filtered array

✓ Linear Growth

Space Complexity

O(n)

Space for storing the filtered array after removing elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
The array must remain non-empty after removal

34.3K Views

Medium-High Frequency

~25 min Avg. Time

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

Optimized Brute Force (Kadane's for Each Removal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler