Maximum Segment Sum After Removals - Leetcode Solution

Problem Statement: You are given an integer array nums. You can choose exactly one element from nums to remove. Return the maximum resulting sum of the remaining elements.

Input: nums = [1,-2,0,3] Output: 4 Explanation: We can remove -2, the sum of the remaining elements is 1 + 0 + 3 = 4.

Solution: To solve this problem, we can use the concept of Kadane's algorithm. We can find the maximum segment sum of the given array without removing any element and store it in a variable named "maxSum". Now, we need to remove one element from the array. So, we need to consider all the elements of the array and check the maximum segment sum after removing that element. The maximum of all such sums would be our answer.

So, we can iterate through the array and remove each element one-by-one. Then, we can apply the Kadane's algorithm on the modified array to find the maximum segment sum. We can store the maximum segment sum for each removed element and return the maximum of all such sums.

Algorithm:

1. Initialize maxSum = 0
2. Apply Kadane's algorithm to find the maximum segment sum of the array and store it in maxSum.
3. Iterate through each element i of the array nums: a. Remove the element i from the array nums and store it in temp. b. Apply Kadane's algorithm to find the maximum segment sum of the modified array and store it in currSum. c. Store the maximum of currSum and 0 in the variable maxTemp. d. Add maxTemp to the variable ans. e. Restore the removed element i to its original position in nums.
4. Return ans.

Code:

class Solution {
public:
    int maxSumAfterRemoval(vector<int>& nums) {
        int maxSum = 0;
        int n = nums.size();
        
        // find maximum segment sum of given array using Kadane's algorithm
        int currSum = 0;
        for(int i=0; i<n; i++) {
            currSum += nums[i];
            maxSum = max(maxSum, currSum);
            currSum = max(currSum, 0);
        }
        
        int ans = maxSum;
        
        // iterate through each element and remove it to find maxSumAfterRemoval
        for(int i=0; i<n; i++) {
            int temp = nums[i];
            nums.erase(nums.begin() + i);
            
            currSum = 0;
            int maxTemp = 0;
            for(int j=0; j<(n-1); j++) {
                currSum += nums[j];
                maxTemp = max(maxTemp, currSum);
                currSum = max(currSum, 0);
            }
            
            ans = max(ans, maxTemp);
            nums.insert(nums.begin() + i, temp);
        }
        
        return ans;
    }
};

Complexity Analysis:

• Time Complexity: O(n^2) since we are iterating through the array twice. The first iteration is to find the maximum segment sum of the given array using Kadane's algorithm and the second iteration is to remove each element one-by-one and find the maximum segment sum of the modified array.
• Space Complexity: O(1) as we are not using any extra space except variables to store the current sum, maximum sum, temporary sum, and answer.

1