### 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`

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

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; }```

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

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

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