Maximum Subarray Sum with One Deletion - Practice Coding Problems

Maximum Subarray Sum with One Deletion - Problem

Given an array of integers, find the maximum sum of a contiguous subarray where you can optionally delete at most one element to maximize the sum.

Think of it this way: you want to select a contiguous portion of the array (a subarray) and then have the option to remove one troublesome element from it to get the highest possible sum. The resulting subarray must still contain at least one element.

Goal: Return the maximum possible sum after applying this strategy.

Example: For array [1, -2, 0, 3], you could take the entire array and delete -2 to get sum 1 + 0 + 3 = 4, or just take [3] for sum 3. The maximum is 4.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: We can take the entire array [1, -2, 0, 3] and delete -2 to get [1, 0, 3] with sum = 4. This is better than any subarray without deletion.

example_2.py — No Deletion Needed

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

› Output: 3

💡 Note: The best strategy is to take the subarray [3] without any deletion. Deleting one element from longer subarrays doesn't improve the sum.

example_3.py — All Negative Except One

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

› Output: -1

💡 Note: Since all elements are negative, we must take at least one element. The best choice is any single element, giving us -1.

Constraints

1 ≤ arr.length ≤ 10⁵
-10⁴ ≤ arr[i] ≤ 10⁴
The resulting subarray must be non-empty after deletion

Visualization

Tap to expand

4Achieved by: [1, -2, 0, 3] → delete -2 → [1, 0, 3]Sum: 1 + 0 + 3 = 4Optimal pathTime: O(n) | Space: O(n) → can be optimized to O(1)

Understanding the Visualization

Initialize base case

First element: noDelete[0] = arr[0], oneDelete[0] = 0

Process each element

For each position, calculate both DP states based on previous optimal values

Update maximum

Track the best result seen so far from either state

Return optimal

The answer is the maximum value across all positions and both states

Key Takeaway

🎯 Key Insight: Use two DP states to track optimal subarrays with and without deletion, building solutions incrementally in linear time.

Asked in

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

The optimal solution uses dynamic programming with two states: tracking the maximum subarray sum with no deletions and with at most one deletion. The key insight is that at each position, we can either extend our previous optimal subarrays or start fresh, while maintaining both deletion scenarios simultaneously in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subarrays)	O(n³)	O(1)	Try every possible subarray and every possible deletion within each subarray
Dynamic Programming (Optimal)	O(n)	O(n)	Track maximum subarray sum with and without deletion at each position

Brute Force (Try All Subarrays) — Algorithm Steps

For each starting index i from 0 to n-1
For each ending index j from i to n-1
Calculate sum of subarray[i:j+1] without deletion
Try deleting each element k where i ≤ k ≤ j and calculate sum
Keep track of maximum sum across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Try all subarrays

Generate every possible contiguous subarray

For each subarray

Calculate sum without deletion

Try all deletions

Try removing each element and calculate new sum

Track maximum

Keep the highest sum found so far

Code -

solution.c — C

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

int maximumSum(int* arr, int n) {
    int maxSum = INT_MIN;
    
    // Try all possible subarrays
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Sum without deletion
            int currentSum = 0;
            for (int k = i; k <= j; k++) {
                currentSum += arr[k];
            }
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
            
            // Try deleting each element in current subarray
            if (j > i) {
                for (int k = i; k <= j; k++) {
                    int sumWithDeletion = currentSum - arr[k];
                    if (sumWithDeletion > maxSum) {
                        maxSum = sumWithDeletion;
                    }
                }
            }
        }
    }
    
    return maxSum;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: start position, end position, and deletion position

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track current and maximum sums

✓ Linear Space

42.0K Views

Medium-High Frequency

~22 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler