【LeetCode 算法】Maximum Sum Circular Subarray 环形子数组的最大和-单调队列

Maximum Sum Circular Subarray 环形子数组的最大和

问题描述：

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

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

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

$$\begin{gathered} n==nums.length \\ 1<=n<=3\ast 10^4 \\ -3\ast 10^4<=nums[i]<=3\ast 10^4 \end{gathered}$$

分析

基于上一篇的优先队列，可以很明显的看出时间复杂度很高，在该问题规模下，是非常有可能TLE的，虽然在昨天的提交中还可以勉强AC，但是理论上这个时间复杂度是不太理想的，和之前的$O(N)$的时间复杂度更是无法比。

所以补一个 单调队列的思路。

目标同样是要找在固定下标i左侧的最小前缀和。
优先队列的处理关键是排序，而单调队列是基于更加巧妙的队列维护。

如果在下标$i$的左侧存在一个下标j处的前缀和是最小的。
此时子数组$[j,i]$就是一个以i为右端点的最大和的子数组。
如果此时 下标$i$的前缀和$presu{m}_i$大于下标$j$的前缀和$presu{m}_j$,即 $presu{m}_i>presu{m}_j$.那么$presu{m}_i$ 就不可能和$i$右侧的其他下标$presu{m}_x$构成更大的子数组和，所以这个情况下，$presu{m}_i$ 不需要被考虑。

反之，$presu{m}_i<=presu{m}_j$,此时的 $presu{m}_i$ 相比较$presu{m}_j$可以与右侧的$presu{m}_x$构造更大的子数组和，那么$presu{m}_i$ 就应该被考虑，

所以在队列的尾部，用$presu{m}_i$与队尾的$presum$进行比较，如果发现$presu{m}_i$更加小或者相等，就可以将队尾元素出队。直到遇到比$presu{m}_i$更小的或者队列空了。

代码

单调队列

class Solution {
    public int maxSubarraySumCircular(int[] nums) {
        int n = nums.length,sum =0,ans = Integer.MIN_VALUE;
        // idx --- val
        Deque<int[]> dq = new ArrayDeque();
        dq.offerLast(new int[]{0,0});
        for(int i=0;i<2*n-1;i++){
            sum += nums[i%n];
            while(!dq.isEmpty()
            &&(i-dq.peekFirst()[0])>n-1){
                dq.pollFirst();
            }
            if(dq.peekFirst()[0]==n)break;
            if(!dq.isEmpty()){
                ans = Math.max(ans,sum -dq.peekFirst()[1]);
            }
            while(!dq.isEmpty()&&dq.peekLast()[1]> sum){
                dq.pollLast();
            }
            dq.offerLast(new int[]{i,sum});
        }
        return ans;
    }
} 

时间复杂度$O(N)$

空间复杂度$O(N)$

Tag

Array

Monotonic Queue