Maximum Subarray Sum After One Operation - Practice Coding Problems

Maximum Subarray Sum After One Operation - Problem

Imagine you have an array of integers and a special power: you can square exactly one element to potentially boost your maximum subarray sum!

Given an integer array nums, you must perform exactly one operation where you replace any element nums[i] with nums[i] * nums[i] (its square). Your goal is to find the maximum possible sum of any contiguous subarray after this operation.

Key Points:

You must square exactly one element (no more, no less)
The subarray must be non-empty
You want to maximize the sum after the operation

Example: For [2, -1, -4, -3], squaring the -4 gives [2, -1, 16, -3], and the maximum subarray sum becomes 16.

Input & Output

example_1.py — Basic Case

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

› Output: 16

💡 Note: We can square the element -4 to get 16. The modified array becomes [2, -1, 16, -3]. The maximum subarray is [16] with sum 16.

example_2.py — Longer Subarray

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

› Output: 4

💡 Note: We can square one of the -1 elements to get 1. For example, squaring the second element gives [1, 1, 1, 1, -1, -1, 1]. The maximum subarray is [1, 1, 1, 1] with sum 4.

example_3.py — Single Element

$ Input: [-1]

› Output: 1

💡 Note: We must square the only element -1 to get 1. The maximum (and only) subarray sum is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
You must perform exactly one squaring operation

Visualization

Tap to expand

Understanding the Visualization

Track Two Scenarios

At each day, track the best portfolio return if you've already used your boost, and the best if you haven't used it yet.

Decision at Each Step

For each new day, decide whether to extend your current portfolio or start fresh, and whether to use your boost on this day.

Optimal Substructure

The best portfolio ending at day i depends on the best portfolios ending at day i-1, creating optimal substructure.

Find Maximum

The answer is the maximum 'with boost used' value seen across all days.

Key Takeaway

🎯 Key Insight: By tracking two states (with/without boost used) at each position, we efficiently find the optimal subarray that maximizes the sum after exactly one squaring operation in linear time.

Asked in

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

The optimal solution uses dynamic programming with two states: tracking the maximum subarray sum ending at each position both with and without using the squaring operation. This achieves O(n) time and O(1) space complexity by cleverly maintaining state transitions.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track best subarray sums with and without using the squaring operation
Brute Force (Try All Positions & Subarrays)	O(n²)	O(n)	Square each element and find maximum subarray for each modified array

Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp arrays: no_op[i] = max sum ending at i without operation, with_op[i] = max sum ending at i with operation used
For each position, update no_op[i] = max(nums[i], no_op[i-1] + nums[i])
Update with_op[i] considering: extend previous with_op subarray, or use operation at current position
with_op[i] = max(with_op[i-1] + nums[i], no_op[i-1] + nums[i]*nums[i], nums[i]*nums[i])
Track maximum value seen in with_op array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

Set up no_op and with_op for first element

Process Each Element

Update both states based on current element

Track Maximum

Keep track of best with_op value seen

Return Result

Return the maximum with_op value

Code -

solution.c — C

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

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

int max3(int a, int b, int c) {
    return max(max(a, b), c);
}

int maxSumAfterOperation(int* nums, int n) {
    if (n == 1) {
        return nums[0] * nums[0];
    }
    
    // no_op: max subarray sum ending at i without using operation
    // with_op: max subarray sum ending at i with operation used
    int noOp = nums[0];
    int withOp = nums[0] * nums[0];  // Must use operation at least once
    int result = withOp;
    
    for (int i = 1; i < n; i++) {
        // Update with_op first (depends on old no_op value)
        int newWithOp = max3(
            withOp + nums[i],  // extend previous with_op subarray
            noOp + nums[i] * nums[i],  // use operation at current position
            nums[i] * nums[i]  // start new subarray with operation here
        );
        
        // Update no_op
        noOp = max(nums[i], noOp + nums[i]);
        
        withOp = newWithOp;
        result = max(result, withOp);
    }
    
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    while (scanf("%d", &nums[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    printf("%d\n", maxSumAfterOperation(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only need to track previous state values, can optimize to constant space

✓ Linear Space

28.9K Views

Medium Frequency

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler