给定一个长度为 n 的环形整数数组 nums ，返回 nums 的非空 子数组 的最大可能和 。

环形数组 意味着数组的末端将会与开头相连呈环状。形式上， nums[i] 的下一个元素是 nums[(i + 1) % n] ， nums[i] 的前一个元素是 nums[(i - 1 + n) % n] 。

子数组 最多只能包含固定缓冲区 nums 中的每个元素一次。形式上，对于子数组 nums[i], nums[i + 1], ..., nums[j] ，不存在 i <= k1, k2 <= j 其中 k1 % n == k2 % n 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-sum-circular-subarray
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

临接数组

class Solution {
    public int maxSubarraySumCircular(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int ans = Integer.MIN_VALUE;
        int dp = 0;
        for (int i = 0; i < arr.length; ++i) {
            dp = Math.max(dp, 0) + arr[i];
            ans = Math.max(ans, dp);
        }
        int[] rightMax = new int[arr.length];
        rightMax[arr.length - 1] = arr[arr.length - 1];
        int rightSum = arr[arr.length - 1];
        for (int i = arr.length - 2; i >= 0; --i) {
            rightSum += arr[i];
            rightMax[i] = Math.max(rightMax[i + 1], rightSum);
        }

        int leftSum = 0;
        for (int i = 0; i < arr.length - 2; ++i) {
            leftSum += arr[i];
            ans = Math.max(ans, leftSum + rightMax[i + 2]);
        }
        return ans;
    }
}

前缀和 + 双端队列

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;

class Solution {
    public int maxSubarraySumCircular(int[] arr) {
        int length = arr.length;

        int[] sum = new int[2 * length + 1];
        for (int i = 0; i < 2 * length; ++i)
            sum[i + 1] = sum[i] + arr[i % length];

        int ans = arr[0];
        Deque<Integer> deque = new LinkedList<>();
        deque.offer(0);

        for (int i = 1; i <= 2 * length; ++i) {
            if (i - deque.peekFirst() > length) {
                deque.pollFirst();
            }

            ans = Math.max(ans, sum[i] - sum[deque.peekFirst()]);

            while (!deque.isEmpty() && sum[i] <= sum[deque.peekLast()]) {
                deque.pollLast();
            }
            deque.offer(i);
        }

        return ans;
    }
}

kadane（符号）

import java.util.Arrays;

class Solution {

    public int kadane(int[] arr, int start, int end, int sign) {
        int dp = Integer.MIN_VALUE;
        int ans = dp;
        for (int i = start; i <= end; ++i) {
            dp = Math.max(dp, 0) + arr[i] * sign;
            ans = Math.max(ans, dp);
        }
        return ans;
    }

    public int maxSubarraySumCircular(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        if (arr.length == 1) {
            return arr[0];
        }
        int sum = Arrays.stream(arr).sum();
        return Math.max(kadane(arr, 0, arr.length - 1, 1),
                sum + Math.max(kadane(arr, 1, arr.length - 1, -1),
                        kadane(arr, 0, arr.length - 2, -1)));
    }
}

kadane（最小值）

import java.util.Arrays;

class Solution {

    private int kadane(int[] arr, int start, int end, boolean max) {
        int dp = max ? Integer.MIN_VALUE : Integer.MAX_VALUE;
        int ans = dp;
        for (int i = start; i <= end; ++i) {
            dp = (max ? Math.max(dp, 0) : Math.min(dp, 0)) + arr[i];
            ans = max ? Math.max(ans, dp) : Math.min(ans, dp);
        }
        return ans;
    }

    public int maxSubarraySumCircular(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        if (arr.length == 1) {
            return arr[0];
        }

        int sum = Arrays.stream(arr).sum();

        return Math.max(kadane(arr, 0, arr.length - 1, true),
                sum - Math.min(kadane(arr, 1, arr.length - 1, false),
                        kadane(arr, 0, arr.length - 2, false)));
    }
}