Maximum Pulse Value After One Subarray Rotation | Leetcode 4058 | Prefix Sum

class Solution {
    using ll = long long;
public:
    long long maxValue(vector<int>& nums) {
        int n=nums.size();
        if(n==1)    return nums[0];
        if(n==2)    return max(nums[0]-nums[1],nums[1]-nums[0]);
        
        ll total = 0;
        for(int i=0;i<n;++i){
            if(i&1) total -= nums[i];
            else    total += nums[i];
        }
        ll max_sum = max(total,total - 2LL*(nums[0]-nums[1]));
        ll max_even_prefix_sum = nums[0];
        ll max_odd_prefix_sum = max(0,nums[0]-nums[1]);

        ll sum = nums[0] - nums[1];
        for(int i=2;i<n;++i){
            if(i&1){//Odd-->Negative
                sum -= nums[i];
                max_sum = max(max_sum,total - 2LL*(sum - max_odd_prefix_sum));
                max_odd_prefix_sum = max(max_odd_prefix_sum, sum);
            }else{//Even-->Positive
                sum += nums[i];
                max_sum = max(max_sum,total - 2LL*(sum - max_even_prefix_sum));
                max_even_prefix_sum = max(max_even_prefix_sum, sum);
            }
        }
        return max_sum;
    }
};
/*
//JAVA
class Solution {
    public long maxValue(int[] nums) {
        int n = nums.length;

        if (n == 1) {
            return nums[0];
        }

        if (n == 2) {
            return Math.max(
                (long) nums[0] - nums[1],
                (long) nums[1] - nums[0]
            );
        }

        long total = 0;

        for (int i = 0; i < n; i++) {
            if ((i & 1) == 1) {
                total -= nums[i];
            } else {
                total += nums[i];
            }
        }

        long maxSum = Math.max(
            total,
            total - 2L * (nums[0] - nums[1])
        );

        long maxEvenPrefixSum = nums[0];
        long maxOddPrefixSum = Math.max(0L, (long) nums[0] - nums[1]);

        long sum = (long) nums[0] - nums[1];

        for (int i = 2; i < n; i++) {

            if ((i & 1) == 1) {
                // Odd -> Negative
                sum -= nums[i];

                maxSum = Math.max(
                    maxSum,
                    total - 2L * (sum - maxOddPrefixSum)
                );

                maxOddPrefixSum = Math.max(
                    maxOddPrefixSum,
                    sum
                );

            } else {
                // Even -> Positive
                sum += nums[i];

                maxSum = Math.max(
                    maxSum,
                    total - 2L * (sum - maxEvenPrefixSum)
                );

                maxEvenPrefixSum = Math.max(
                    maxEvenPrefixSum,
                    sum
                );
            }
        }

        return maxSum;
    }
}

#Python
class Solution:
    def maxValue(self, nums):
        n = len(nums)

        if n == 1:
            return nums[0]

        if n == 2:
            return max(
                nums[0] - nums[1],
                nums[1] - nums[0]
            )

        total = 0

        for i in range(n):
            if i & 1:
                total -= nums[i]
            else:
                total += nums[i]

        max_sum = max(
            total,
            total - 2 * (nums[0] - nums[1])
        )

        max_even_prefix_sum = nums[0]
        max_odd_prefix_sum = max(0, nums[0] - nums[1])

        sum_ = nums[0] - nums[1]

        for i in range(2, n):

            if i & 1:
                # Odd -> Negative
                sum_ -= nums[i]

                max_sum = max(
                    max_sum,
                    total - 2 * (sum_ - max_odd_prefix_sum)
                )

                max_odd_prefix_sum = max(
                    max_odd_prefix_sum,
                    sum_
                )

            else:
                # Even -> Positive
                sum_ += nums[i]

                max_sum = max(
                    max_sum,
                    total - 2 * (sum_ - max_even_prefix_sum)
                )

                max_even_prefix_sum = max(
                    max_even_prefix_sum,
                    sum_
                )

        return max_sum
*/