LeetCode第 862 题：和至少为K的最短子数组 (C++)

862. 和至少为 K 的最短子数组 - 力扣（LeetCode）

要求是连续的子数组，所以自然就想到了双指针法，也就是寻找一个连续的区间。但是细思之后没有理清左右边界移动的逻辑，遂弃。

参考：LeetCode #862，。这位同学举得例子很形象(尤其是折线图那个例子)，反正官方题解我是没看懂。。。

暴力解

反正先暴力解一下吧：

前缀和数组：构建数组sum[i]表示原数组前 i 个元素之和，比如sum[2] = A[0] + A[1] 。

例子3：

Input: A = [2,-1,2], K = 3
Output: 3

数组A对应的前缀和数组:
sum = [0, 2, 1, 3]

前缀和数组的作用是：

sum[j] - sum[i]表示第i + 1个元素到第 j个元素的和，使得区间和更容易获取。

有了数组sum之后，对它进行遍历，记录使得sum[j] - sum[i] >= K的i, j的值，那么区间大小就是j - i, 双重循环时间复杂度为$O(N^2)$。

class Solution {
public:
    int shortestSubarray(vector<int>& A, int K) {
        const int n = A.size() + 1;
        int sum[n];
        sum[0] = 0;
        int min_len = n; //min用于记录满足要求的子数组长度
        for(int i = 0; i < n-1; ++i){
            if(A[i] >= K)   return 1;
            sum[i + 1] = sum[i] + A[i];
        }
        // 遍历sum数组，i,j为下标
        for(int i = 0; i < n; ++i){
            // j < i+min：当子数组长度j-i已经超过当前最短值min时，停止遍历
            for(int j = i + 1; j < n && j-i < min_len; ++j){
                if(sum[j]-sum[i] >= K){
                    min_len = j-i;
                    break;
                }
            }
        }
        // 一直没找到满足要求的
        if(min_len == n) return -1;
        
        return min_len;
    }
};

虽然执行正确，但是提交失败了，超出时间限制，看来还得降低时间复杂度。

优化

遍历sum数组复杂度过高，看了题解后确实有优化空间，但是题解说的很晦涩，还是建议看LeetCode #862这个例子，这位同学的折线图理解很形象，可以自己画一下图方便理解。

说一下自己的理解，假设符合要求的最短子数组为s[0:x]，x为长度，该数组在sum数组中对应的边界为（beg, end)，也即该数组中的元素之和 = sum[end] - sum[beg]:

• s的最后一个元素不可能为负或者0，如果它为负，那么s[0:x-1] >= K成立,而且更短
• s的第一个元素也不可能为负或者0，如果它为负，那么s[1:x] >= K 成立，而且更短
• sum[beg]到sum[end]之间不存在sum[i] <= sum[beg], beg < i < end，因为这样的话(i, end)显然是更好的边界，理解为i是更好的起点。

也即是说符合要求的子数组起点和终点均为正数。那么上面的暴力法在遍历sum的过程中，如果i, j <= 0，就可以直接排除，而且如果在i, j之间如果找到比i更适合的起点q，那么下一次就可以将起点更新为q(i = q)，而不用每次++i。

不过仔细分析的话，会发现遍历的基本原则没有变化，时间复杂度还是$O(N^2)$。。。

而且这个题虽然有队列的标签，但是我们现在还没有用到。。

接着优化：
LeetCode #862这位哥哥的图：

上升的点序列也就是单调递增的意思，利用双端队列维护，push的时候对于破坏单调性的点直接舍弃（pop_back())
举个例子：
序列：1,4,-1,3
前缀和数组sum(下标从0开始)：0,1,5,4,7
单调序列是0-1-4-7 ，7与4的差值 >= 7与5的差值，而且7与4隔得更近（对应的子数组长度更短），因此队列push过程是这样的(假定K的值为5，结合下面代码):

push_back(0)
0 push_back(1)
0 1 push_back(5)
0 1 5 此时sum[end] - sum[dq.front()] = 5 >= K成立，pop_front(0), min_len=2,队列变为：
1 5 下一个循环 5 > 4 ,5会破坏单调性，pop_back(5)
1 下一个循环7进来，len = 3
min_len还是为2

class Solution {
public:
    int shortestSubarray(vector<int>& A, int K) {
        const int n = A.size() + 1;
        int sum[n];
        sum[0] = 0;
        int min_len = n; //min用于记录满足要求的子数组长度
        for(int i = 0; i < n-1; ++i){
            if(A[i] >= K)   return 1;
            sum[i + 1] = sum[i] + A[i];
        }
        
        deque<int> dq; //存储的是下标
        for(int end = 0; end < n; ++end){
            // 当前end更优
            while(!dq.empty() && sum[dq.back()] >= sum[end]){
                dq.pop_back(); //之前的end被淘汰
            }
            while(!dq.empty() && sum[end] - sum[dq.front()] >= K  ){
                int len = end - dq.front();
                dq.pop_front(); 
                if(min_len > len) min_len = len;
            }
            dq.push_back(end); //更新现在的end
        }
        
        if(min_len == n) return -1;  // 一直没找到满足要求的
        return min_len;
    }
};