[LeetCode] 862. Shortest Subarray with Sum at Least K 和至少爲K的最短子數組

Return the length of the shortest, non-empty, contiguous subarray of A with sum at least K.

If there is no non-empty subarray with sum at least K, return -1.

Example 1:

Input: A = [1], K = 1
Output: 1

Example 2:

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

Example 3:

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

Note:

1. 1 <= A.length <= 50000
2. -10 ^ 5 <= A[i] <= 10 ^ 5
3. 1 <= K <= 10 ^ 9

這道題給了咱們一個非空整數數組和一個正整數K，讓找出非空的子數組使得其和至少爲K，找不到的話返回 -1。這道題的難點在於數組中可能有負數，這樣的話子數組之和就不會隨着長度的增長而增長，從而貪婪算法可能會失效。固然，直接暴力搜索搜索全部的子數組是對 Hard 題目的不尊重，會被 OJ 教育。對於子數組之和的問題，十有八九是要創建累加和數組的，由於其能夠快速的計算任意區間和，但即使是有了累加和數組，遍歷全部區間和仍是會超時。用累加數組計算任意區間 [i, j] 的累加和是用 [0, j] 區間和減去 [0, i-1] 區間和獲得的，只有兩個區間和差值大於等於K的時候，纔會更新結果，全部小於K的區間差是不須要計算的。這樣的話，假如能使得全部區間和按照從小到大的順序排列，那麼當前區間和按順序減去隊列中的區間和，一旦差值小於K了，後面的區間和就不用再檢驗了，這樣就能夠節省不少運算。

思路有了，下面就來解題吧。這裏用一個最小堆，裏面放一個數對兒，由區間和跟其結束位置組成。遍歷數組中全部的數字，累加到 sum，表示區間 [0, i] 內數字和，判斷一下若 sum 大於等於K，則用 i+1 更新結果 res。而後用一個 while 循環，看 sum 和堆頂元素的差值，若大於等於K，移除堆頂元素並更新結果 res。循環退出後將當前 sum 和i組成數對兒加入最小堆，最後看若結果 res 仍是整型最大值，返回 -1，不然返回結果 res，參見代碼以下：

解法一：

class Solution {
public:
    int shortestSubarray(vector<int>& A, int K) {
        int n = A.size(), res = INT_MAX, sum = 0;
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
        for (int i = 0; i < n; ++i) {
            sum += A[i];
            if (sum >= K) res = min(res, i + 1);
            while (!pq.empty() && sum - pq.top().first >= K) {
                res = min(res, i - pq.top().second);
                pq.pop();
            }
            pq.push({sum, i});
        }
        return res == INT_MAX ? -1 : res;
    }
};

咱們也能夠不用最小堆，直接利用 TreeMap 的自動排序功能，創建區間和跟其結束位置之間的映射。首先創建累加和數組，而後遍歷累加和數組中的每個數字，在 TreeMap 中二分查找第一個大於 sums[i]-K 的 位置 pos，這樣全部前面較小的位置x，都有 sum[i]-x >= K 成立，這樣只要從開頭遍歷到 pos 位置，將每一個區間長度更新結果 res 便可。更新完成後，要將開頭到位置 pos 之間的映射所有刪掉，由於這些已經計算過了，就像上面解法中將堆頂元素移除的操做同樣，而後創建當前區間和跟結束位置i之間的映射，參見代碼以下：

解法二：

class Solution {
public:
    int shortestSubarray(vector<int>& A, int K) {
        int n = A.size(), res = INT_MAX;
        map<int, int> sumMap;
        vector<int> sums(n + 1);
        for (int i = 1; i <= n; ++i) sums[i] = sums[i - 1] + A[i - 1];
        for (int i = 0; i <= n; ++i) {
            auto pos = sumMap.upper_bound(sums[i] - K);
            for (auto it = sumMap.begin(); it != pos; ++it) {
                res = min(res, i - it->second);
            }
            sumMap.erase(sumMap.begin(), pos);
            sumMap[sums[i]] = i;
        }
        return res == INT_MAX ? -1 : res;
    }
};

上面兩種解法雖然均可以經過 OJ，但也僅僅是險過，來看一種時間和空間的擊敗率都很高的方法，這裏用到了雙向隊列 deque，這是一種兩頭都能操做的飛起的數據結構。雙向隊列不像優先隊列那樣自動排序，這樣就節省了排序的時間，咱們是按照數組原順序將數字下標加入雙向隊列的。在創建好累加和數組之和，遍歷其每一個累加和，而後用一個 while 循環，從雙向隊列的開頭開始遍歷，假如區間和之差大於等於K，就移除隊首元素並更新結果 res。以後這個 while 循環很是重要，能有這麼高的擊敗率，全要靠這個循環，這個是從雙向隊列的末尾開始往前遍歷，假如當前區間和 sums[i] 小於等於隊列末尾的區間和，則移除隊列末尾元素。這是爲啥呢？由於若數組都是正數，那麼長度越長，區間和必定越大，則 sums[i] 必定大於全部雙向隊列中的區間和，但因爲可能存在負數，從而使得長度變長，區間總和反而減小了，以前的區間和之差都沒有大於等於K，如今的更不可能大於等於K，這個結束位置能夠直接淘汰，不用進行計算。循環結束後將當前位置加入雙向數組便可，參見代碼以下：

解法三：

class Solution {
public:
    int shortestSubarray(vector<int>& A, int K) {
        int n = A.size(), res = INT_MAX;
        deque<int> dq;
        vector<int> sums(n + 1);
        for (int i = 1; i <= n; ++i) sums[i] = sums[i - 1] + A[i - 1];
        for (int i = 0; i <= n; ++i) {
            while (!dq.empty() && sums[i] - sums[dq.front()] >= K) {
                res = min(res, i - dq.front());
                dq.pop_front();
            }
            while (!dq.empty() && sums[i] <= sums[dq.back()]) {
                dq.pop_back();
            }
            dq.push_back(i);
        }
        return res == INT_MAX ? -1 : res;
    }
};

Github 同步地址:

https://github.com/grandyang/leetcode/issues/862

參考資料：

https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/

https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/discuss/143726/C%2B%2BJavaPython-O(N)-Using-Deque

https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/discuss/143768/C%2B%2B-solution-by-using-priority_queue

https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/discuss/153515/c%2B%2B-upper_bound-%2B-prefix-sum-easy-to-remember-and-impl-in-10mins

LeetCode All in One 題目講解彙總(持續更新中...)