Maximize Adjacent Difference With One Reversal

Given an integer array values, define its score as the sum of abs(values[i] - values[i + 1]) over every adjacent pair.
You may reverse at most one contiguous subarray. Return the maximum score obtainable after the optional reversal.

Function
maximizeArrayScore(values: int[]) → long

Examples
Example 1
values = [2,3,1,5,4]
return = 10
The original score is 8. Reversing the subarray [3,1,5] produces [2,5,1,3,4], whose score is 10.
Example 2
values = [1,2,3,4]
return = 5
Reversing [2,3] produces [1,3,2,4], with score 2 + 1 + 2 = 5.

Constraints
1 <= values.length <= 10^5
-10^9 <= values[i] <= 10^9

Reversing values[i..j] leaves every interior adjacent difference unchanged, since abs is symmetric. Only two edges change: abs(a[i-1]-a[i]) and abs(a[j]-a[j+1]) become abs(a[i-1]-a[j]) and abs(a[i])-a[j+1]) respectively. So you want the best gain over all i<j. Handle boundaries separately: reversing a prefix ending at j gains abs(a[0]-a[j+1]) - abs(a[j]-a[j+1]), and a suffix starting at i gains abs(a[i-1]-a[n-1]) - abs(a[i-1]-a[i]). For the interior case, use the classic max/min trick over pairs, tracking the max of min(a[k],a[k+1]) and the min of max(a[k],a[k+1]). The gain is 2*(maxOfMins - minOfMaxes) if positive. The pitfall is int overflow, so use 64-bit, and forgetting n=1 or n=2 where the answer is just the original score. If you freeze live, StealthCoder can cover you, but know the boundary cases cold.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.