Reverse Subarray To Maximize Array Value - Practice Coding Problems

Reverse Subarray To Maximize Array Value - Problem

You're given an integer array nums and need to maximize its "value" by strategically reversing exactly one subarray.

The value of an array is calculated as the sum of absolute differences between all adjacent elements: |nums[i] - nums[i + 1]| for all valid indices.

Your task: Select any contiguous subarray and reverse it to achieve the maximum possible array value. You can perform this operation exactly once.

Example: For array [2, 3, 1, 5, 4], reversing subarray [3, 1, 5] gives [2, 5, 1, 3, 4] with value |2-5| + |5-1| + |1-3| + |3-4| = 3 + 4 + 2 + 1 = 10

Input & Output

example_1.py — Basic Case

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

› Output: 10

💡 Note: Reverse the subarray [3,1,5] to get [2,5,1,3,4]. The new array value is |2-5| + |5-1| + |1-3| + |3-4| = 3 + 4 + 2 + 1 = 10, which is the maximum possible.

example_2.py — No Improvement Possible

$ Input: nums = [2,4,9,24,2,1,10]

› Output: 68

💡 Note: The original array already has the maximum value. Reversing any subarray would either keep the value the same or decrease it. Original value: |2-4| + |4-9| + |9-24| + |24-2| + |2-1| + |1-10| = 2 + 5 + 15 + 22 + 1 + 9 = 54. After optimal reversal, we can achieve 68.

example_3.py — Two Element Array

$ Input: nums = [1,2]

› Output: 1

💡 Note: With only two elements, the array value is |1-2| = 1. Reversing the entire array gives [2,1] with value |2-1| = 1. No improvement possible.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
0 ≤ nums[i] ≤ 10⁵
You must reverse exactly one subarray (can be single element)

Visualization

Tap to expand

Understanding the Visualization

Calculate Baseline

Start with the original array and calculate its total value as the sum of all adjacent differences

Analyze Boundaries

For each possible subarray [i,j], determine what connections would change if we reversed it

Compute Delta

Calculate the net gain/loss: (new boundary connections) - (old boundary connections)

Find Optimum

Choose the reversal that gives the maximum positive change, or keep original if no improvement exists

Key Takeaway

🎯 Key Insight: When reversing a subarray, only the boundary connections change - internal relationships maintain the same absolute differences. This allows us to calculate the impact mathematically without actually performing the reversal, reducing complexity from O(n³) to O(n²).

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses mathematical analysis to avoid actually reversing subarrays. Key insight: reversing a subarray only changes the boundary connections, not internal ones. We calculate the potential gain for each possible subarray reversal in O(n²) time by analyzing how the boundary changes affect the total value, achieving significant improvement over the O(n³) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Optimization (Optimal)	O(n²)	O(1)	Analyze boundary changes mathematically without actually reversing subarrays
Brute Force (Try All Subarrays)	O(n³)	O(1)	Try reversing every possible subarray and find the maximum value

Mathematical Optimization (Optimal) — Algorithm Steps

Calculate the original array value
For each possible subarray [i,j], calculate the change in value
The change equals: |nums[i-1] - nums[j]| + |nums[i] - nums[j+1]| - |nums[i-1] - nums[i]| - |nums[j] - nums[j+1]|
Find the maximum positive change
Return original value plus maximum change

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Boundaries

When reversing subarray [i,j], only connections at positions i-1→i, i→i+1, j→j+1, j-1→j change

Calculate Changes

New connections become i-1→j and i→j+1, removing i-1→i and j→j+1

Compute Gain

Find Maximum

Test all possible boundary pairs to find maximum gain

Code -

solution.c — C

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

int maxValueAfterReverse(int* nums, int numsSize) {
    int n = numsSize;
    if (n <= 1) return 0;
    
    // Calculate original value
    int originalValue = 0;
    for (int i = 0; i < n - 1; i++) {
        originalValue += abs(nums[i] - nums[i + 1]);
    }
    
    int maxGain = 0;
    
    // Try all possible subarrays [i, j]
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int gain = 0;
            
            // Calculate change at left boundary
            if (i > 0) {
                gain += abs(nums[i - 1] - nums[j]) - abs(nums[i - 1] - nums[i]);
            }
            
            // Calculate change at right boundary
            if (j < n - 1) {
                gain += abs(nums[i] - nums[j + 1]) - abs(nums[j] - nums[j + 1]);
            }
            
            if (gain > maxGain) {
                maxGain = gain;
            }
        }
    }
    
    return originalValue + maxGain;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all O(n²) possible subarrays, but each check is O(1)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Mathematical Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler