Reverse Subarray To Maximize Array Value

Reverse Subarray To Maximize Array Value - Problem

You are given an integer array nums. The value of this array is defined as the sum of |nums[i] - nums[i + 1]| for all 0 <= i < nums.length - 1.

You are allowed to select any subarray of the given array and reverse it. You can perform this operation only once.

Find the maximum possible value of the final array.

Input & Output

Example 1 — Basic Case

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

› Output: 10

💡 Note: Reverse subarray [1,5] to get [2,3,5,1,4]. Value = |2-3| + |3-5| + |5-1| + |1-4| = 1 + 2 + 4 + 3 = 10

Example 2 — No Improvement

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

› Output: 54

💡 Note: The original array already gives maximum value. No reversal improves it.

Example 3 — Single Element

$ Input: nums = [5]

› Output: 0

💡 Note: Only one element, so no adjacent pairs exist. Value is 0.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 M Microsoft 8

The key insight is that reversing a subarray only changes the connections at the boundaries. The mathematical optimization approach calculates the value change directly without reconstructing arrays. Time: O(n²), Space: O(1)

Common Approaches

✓ Brute Force

⏱️ Time: O(n³) Space: O(1)

For each possible subarray, reverse it, calculate the total array value, and keep track of the maximum. This ensures we find the optimal solution by checking all possibilities.

Mathematical Optimization

⏱️ Time: O(n²) Space: O(1)

Instead of reconstructing arrays, we calculate how the total value changes when we reverse a subarray. The key insight is that only the connections at the boundaries change, so we can compute the delta directly.

Brute Force — Algorithm Steps

Try every possible subarray [i, j]
Reverse the subarray and calculate total value
Keep track of maximum value found

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Calculate initial value

Try Reversals

Test each subarray reversal

Find Maximum

Return best value found

Code -

solution.c — C

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

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

int calculateValue(int* arr, int n) {
    int total = 0;
    for (int i = 0; i < n - 1; i++) {
        total += abs_diff(arr[i], arr[i + 1]);
    }
    return total;
}

void reverse(int* arr, int start, int end) {
    while (start < end) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
}

int solution(int* nums, int n) {
    int maxValue = calculateValue(nums, n);
    int* temp = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Create copy and reverse subarray [i, j]
            memcpy(temp, nums, n * sizeof(int));
            reverse(temp, i, j);
            int currentValue = calculateValue(temp, n);
            if (currentValue > maxValue) {
                maxValue = currentValue;
            }
        }
    }
    
    free(temp);
    return maxValue;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int nums[1000];
    int n = 0;
    char* ptr = line + 1; // Skip '['
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
            nums[n++] = atoi(ptr);
            while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        }
        if (*ptr == ',') ptr++;
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subarrays × O(n) to calculate value each time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler