<p>You are given an integer array <code>nums</code>. The <em>value</em> of this array is defined as the sum of <code>|nums[i] - nums[i + 1]|</code> for all <code>0 &lt;= i &lt; nums.length - 1</code>.</p>

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

<p>Find maximum possible value of the final array.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [2,3,1,5,4]
<strong>Output:</strong> 10
<b>Explanation: </b>By reversing the subarray [3,1,5] the array becomes [2,5,1,3,4] whose value is 10.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [2,4,9,24,2,1,10]
<strong>Output:</strong> 68
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>2 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
	<li><code>-10<sup>5</sup> &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
	<li>The answer is guaranteed to fit in a 32-bit integer.</li>
</ul>

#include <vector>
#include <limits>
#include <algorithm>

inline const auto optimize = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    return 0;
}();

class Solution {
public:
    static int maxValueAfterReverse(const std::vector<int>& nums) {
        const int N = nums.size();
        int ans = 0;
        int maxi = std::numeric_limits<int>::lowest();
        int mini = std::numeric_limits<int>::max();
        int edge = 0;

        for (int i = 0; i < N - 1; i++) {
            const int a = nums[i];
            const int b = nums[i + 1];
            auto [c, d] = std::minmax(a, b);
            maxi = std::max(c, maxi);
            mini = std::min(d, mini);
            ans += d - c;

            int tmp1 = -(d - c) + std::abs(nums[0] - b);
            int tmp2 = -(d - c) + std::abs(nums.back() - a);
            int tmp = std::max(tmp1, tmp2);
            edge = std::max(edge, tmp);
        }

        return ans + std::max(edge, (maxi - mini) * 2);
    }
};
42700