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

You are given an integer array nums. You can do the following operation on the array at most once:

Choose any integer x such that nums remains non-empty on removing all occurrences of x.
Remove all occurrences of x from the array.

Return the maximum subarray sum across all possible resulting arrays.

A subarray is a contiguous part of an array.

Input & Output

Example 1 — Remove Negative Elements

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

› Output: 4

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

Example 2 — Remove Positive Elements

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

› Output: 2

💡 Note: We can remove -3 to get [1, -4, 2] (max sum = 2), or remove -4 to get [1, -3, 2] (max sum = 2), or remove 1 to get [-3, -4, 2] (max sum = 2). Best result is 2.

Example 3 — All Elements Same

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

› Output: 15

💡 Note: Cannot remove all 5s (array must remain non-empty). Original array has max subarray sum of 5+5+5+5 = 20. But we must remove at least one occurrence. Actually, we don't have to remove any element, so answer is 20. Wait - re-reading: we can do the operation "at most once", meaning 0 or 1 times. So answer is 20.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
The resulting array must be non-empty

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is that we want to remove elements that either break up positive sequences or contribute large negative values. The optimal approach tries removing each unique element and finds the maximum subarray sum using Kadane's algorithm. Time: O(n³) brute force, Space: O(n)

Common Approaches

✓ Brute Force - Try All Removals

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

Try removing each unique element from the array, then apply Kadane's algorithm to find the maximum subarray sum in each resulting array. Also consider not removing any element.

Optimized with Prefix/Suffix Sums

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

Pre-compute prefix and suffix maximum subarray sums. For each unique element, efficiently calculate the maximum subarray sum after removal using the precomputed values.

Brute Force - Try All Removals — Algorithm Steps

Get all unique values in the array
For each unique value, create array without it
Apply Kadane's algorithm to find max subarray sum
Return the maximum among all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with the input array

Try Each Value

For each unique element, create array without it

Find Max Subarray

Apply Kadane's algorithm to each resulting array

Code -

solution.c — C

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

static int nums[100005];
static int filtered[100005];
static int unique_vals[100005];

int kadane(int* arr, int n) {
    if (n == 0) return INT_MIN;
    int maxSum = arr[0];
    int currSum = arr[0];
    for (int i = 1; i < n; i++) {
        currSum = (arr[i] > currSum + arr[i]) ? arr[i] : currSum + arr[i];
        maxSum = (currSum > maxSum) ? currSum : maxSum;
    }
    return maxSum;
}

int solution(int* nums, int n) {
    // Start with original array (0 operations)
    int maxResult = kadane(nums, n);
    
    // Get unique values
    int uniqueCount = 0;
    for (int i = 0; i < n; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (unique_vals[j] == nums[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            unique_vals[uniqueCount++] = nums[i];
        }
    }
    
    // Try removing each unique value (1 operation)
    for (int i = 0; i < uniqueCount; i++) {
        int val = unique_vals[i];
        int filteredSize = 0;
        
        for (int j = 0; j < n; j++) {
            if (nums[j] != val) {
                filtered[filteredSize++] = nums[j];
            }
        }
        
        if (filteredSize > 0) {
            int currentMax = kadane(filtered, filteredSize);
            if (currentMax > maxResult) {
                maxResult = currentMax;
            }
        }
    }
    
    return maxResult;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int n = 0;
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++; // Skip '['
    
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']' || *ptr == '\0') break;
        
        int sign = 1;
        if (*ptr == '-') {
            sign = -1;
            ptr++;
        }
        
        int num = 0;
        while (*ptr >= '0' && *ptr <= '9') {
            num = num * 10 + (*ptr - '0');
            ptr++;
        }
        nums[n++] = sign * num;
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) unique values × O(n) to create new array × O(n) Kadane's algorithm

⚠ Quadratic Growth

Space Complexity

O(n)

Extra space to store modified arrays and unique values set

⚡ Linearithmic Space

23.8K Views

Medium Frequency

~25 min Avg. Time

850 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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Removals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler