Maximum Segment Sum After Removals - Practice Coding Problems

Maximum Segment Sum After Removals - Problem

Imagine you have an array of positive integers and need to perform a series of strategic removals. Each time you remove an element, the array splits into separate segments (contiguous sequences), and you need to track which segment has the largest sum.

The Challenge: You're given two arrays of equal length n:

nums - the original array of positive integers
removeQueries - indices specifying which elements to remove in order

For each removal operation, you need to:

Remove the element at the specified index
Calculate the sum of each remaining contiguous segment
Find the maximum segment sum

Goal: Return an array where each element represents the maximum segment sum after performing the corresponding removal operation.

Note: Each index will only be removed once, and segments are defined as contiguous sequences of positive integers.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,5,6,1], removeQueries = [0,3,2,4,1]

› Output: [14,7,2,1,0]

💡 Note: Remove index 0: [X,2,5,6,1] → segments [2,5,6,1] → max sum 14. Remove index 3: [X,2,5,X,1] → segments [2,5],[1] → max sum 7. Remove index 2: [X,2,X,X,1] → segments [2],[1] → max sum 2. Remove index 4: [X,2,X,X,X] → segments [2] → max sum 1. Remove index 1: [X,X,X,X,X] → no segments → max sum 0.

example_2.py — Single Element

$ Input: nums = [3], removeQueries = [0]

› Output: [0]

💡 Note: After removing the only element, no segments remain, so maximum sum is 0.

example_3.py — Two Elements

$ Input: nums = [4,5], removeQueries = [1,0]

› Output: [4,0]

💡 Note: Remove index 1: [4,X] → segments [4] → max sum 4. Remove index 0: [X,X] → no segments → max sum 0.

Constraints

n == nums.length == removeQueries.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ removeQueries[i] < n
All values in removeQueries are unique

Visualization

Tap to expand

Understanding the Visualization

Initial Array

Start with complete array [1,2,5,6,1], total sum = 15

Remove Index 0

Break at position 0: [X|2,5,6,1], largest piece = 14

Remove Index 3

Break at position 3: [X|2,5|X|1], largest piece = 7

Reverse Process

Union-Find works backwards: start empty, add elements, merge adjacent segments efficiently

Key Takeaway

🎯 Key Insight: Reversing the problem transforms expensive split operations into efficient union operations, reducing complexity from O(n²) to O(n α(n))

Asked in

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

The optimal solution uses Union-Find with reverse processing. Instead of removing elements and splitting segments, we process queries in reverse order - adding elements back and merging adjacent segments. This transforms expensive split operations into efficient union operations, achieving O(n α(n)) time complexity where α is the inverse Ackermann function (practically constant).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Simulate Each Removal	O(n²)	O(n)	Simulate each removal and recalculate all segment sums from scratch
Union-Find with Reverse Processing (Optimal)	O(n α(n))	O(n)	Process removals in reverse order using Union-Find to efficiently merge segments

Brute Force - Simulate Each Removal — Algorithm Steps

Mark elements to be removed using a boolean array
For each query, mark the corresponding index as removed
Scan the array to find all contiguous segments of non-removed elements
Calculate the sum of each segment and track the maximum
Store the result for this query

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Array: [1,2,5,6,1], Remove queries: [0,3,2,4,1]

Remove index 0

Array: [X,2,5,6,1], Segments: [2,5,6,1], Max sum: 14

Remove index 3

Array: [X,2,5,X,1], Segments: [2,5], [1], Max sum: 7

Continue process

Keep removing and recalculating until all elements removed

Code -

solution.c — C

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

long long* maximumSegmentSum(int* nums, int numsSize, int* removeQueries, int* returnSize) {
    *returnSize = numsSize;
    long long* result = (long long*)malloc(numsSize * sizeof(long long));
    bool* removed = (bool*)calloc(numsSize, sizeof(bool));
    
    for (int q = 0; q < numsSize; q++) {
        removed[removeQueries[q]] = true;
        long long maxSum = 0;
        int i = 0;
        
        while (i < numsSize) {
            if (!removed[i]) {
                long long currentSum = 0;
                while (i < numsSize && !removed[i]) {
                    currentSum += nums[i];
                    i++;
                }
                if (currentSum > maxSum) {
                    maxSum = currentSum;
                }
            } else {
                i++;
            }
        }
        
        result[q] = maxSum;
    }
    
    free(removed);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n queries, we scan the entire array of length n to find segments

⚠ Quadratic Growth

Space Complexity

O(n)

Need array to track removed elements and space for the result

⚡ Linearithmic Space

23.5K Views

Medium-High Frequency

~35 min Avg. Time

847 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 - Simulate Each Removal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler