LeetCode862. Shortest Subarray with Sum at Least 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

思路

本來以為用dp來做,看了下答案,解法中並沒有。使用的解法是滑動窗口,將問題重新定義為和A的前綴和有關,定義

P[i] = A[0] + A[1] + ... + A[i-1]

我們想要求的便是最小的 y-x,y>x 並且P[y] - P[x] >= K

Motivated by that equation, let opt(y) be the largest x such that P[x] <= P[y] - K. We need two key observations:

  • If x1 < x2 and P[x2] <= P[x1], then opt(y) can never be x1, as if P[x1] <= P[y] - K, then P[x2] <= P[x1] <= P[y] - K but y - x2 is smaller. This implies that our candidates x for opt(y) will have increasing values of P[x].

  • If opt(y1) = x, then we do not need to consider this x again. For if we find some y2 > y1 with opt(y2) = x, then it represents an answer of y2 - x which is worse (larger) than y1 - x.

opt(y)是使得當 P[x] <= P[y] - K 時 x 能取到的最大值。

1. 如果有 x1<x2 並且 P[x2]<=P[x1],那么opt(y)一定不是 x1,因為如果有P[x1] <= P[y] - K,那么 P[x2] <= P[x1] <= P[y] - K,但是 y - x2 is smaller。這表明對於opt(y)的候選x應該是在使P(x)遞增的區間去找。要注意這里的P[x1]指的是從0到X1的數組元素之和,不是單單指一個x1位置上元素的值。

2. 如果opt(y1)=x, 那么不需要再次考慮x。因為如果我們找到某些y2>y1並且opt(y2)=x,那么這表明這個解答 y2-x 是比之前的解答 y1-x 是更壞的答案。

Calculate prefix sum B of list A.
B[j] - B[i] represents the sum of subarray A[i] ~ A[j-1]
Deque d will keep indexes of increasing B[i].
For every B[i], we will compare B[i] - B[d[0]] with K.

    public int shortestSubarray(int[] A, int K) { int N = A.length, res = N + 1; int[] B = new int[N + 1];    // 下面利用數組A重新構造了數組B,滿足B[i+1]-B[j]=A[i]+A[i-1].....+A[j]
        for (int i = 0; i < N; i++) B[i + 1] = B[i] + A[i]; Deque<Integer> d = new ArrayDeque<>(); for (int i = 0; i < N + 1; i++) {   while (d.size() > 0 && B[i] - B[d.getFirst()] >= K) res = Math.min(res, i - d.pollFirst()); // 雙端隊列存的是索引
            while (d.size() > 0 && B[i] <= B[d.getLast()]) d.pollLast(); // Deque d keep indexes of increasing B[i]
 d.addLast(i); } return res <= N ? res : -1; }

上面的出入隊列順序是這樣的:首先對於每個索引i,對應的是B[i],將這個索引作為y位置來考慮,因為雙端隊列保持的索引是的B[i]是遞增的,為了從最大處逼近K,我們從隊頭依次取索引出來計算:

B[i] - B[d.getFirst()]

如果比K大,那么則要找這其中距離索引i最近的那一個:

res = Math.min(res, i - d.pollFirst());

然后是隊列要keep indexes of increasing B[i],索引判斷當前的B[i]是否大於隊列尾部的索引處的

B[i] <= B[d.getLast()

如果不能構成遞增,根據之前的分析,當前y所在的位置i的最優解opt(y)一定不會是在前面遞增的部分取,所以隊列要從后往前一個個彈出隊尾直至能和B[i]構成遞增序列。


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2020 ITdaan.com