feat: add solutions to lc problem: No.0862

No.0862.Shortest Subarray with Sum at Least K

Author: yanglbme

README.md

@@ -58,6 +58,7 @@
 -   [每日温度](/solution/0700-0799/0739.Daily%20Temperatures/README.md) - `单调栈`
 -   [滑动窗口最大值](/solution/0200-0299/0239.Sliding%20Window%20Maximum/README.md) - `单调队列`
 -   [满足不等式的最大值](/solution/1400-1499/1499.Max%20Value%20of%20Equation/README.md) - `单调队列`
+-   [和至少为 K 的最短子数组](/solution/0800-0899/0862.Shortest%20Subarray%20with%20Sum%20at%20Least%20K/README.md) - `单调队列`
 
 ### 3. 搜索
 

README_EN.md

@@ -56,6 +56,7 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
 -   [Daily Temperatures](/solution/0700-0799/0739.Daily%20Temperatures/README_EN.md) - `Monotonic Stack`
 -   [Sliding Window Maximum](/solution/0200-0299/0239.Sliding%20Window%20Maximum/README_EN.md) - `Monotonic Queue`
 -   [Max Value of Equation](/solution/1400-1499/1499.Max%20Value%20of%20Equation/README_EN.md) - `Monotonic Queue`
+-   [Shortest Subarray with Sum at Least K](/solution/0800-0899/0862.Shortest%20Subarray%20with%20Sum%20at%20Least%20K/README_EN.md) - `Monotonic Queue`
 
 ### 3. Search
 

solution/0800-0899/0862.Shortest Subarray with Sum at Least K/README.md

@@ -50,22 +50,117 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：单调队列**
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def shortestSubarray(self, nums: List[int], k: int) -> int:
+        s = [0] + list(accumulate(nums))
+        ans = float('inf')
+        q = deque([0])
+        for i in range(1, len(s)):
+            while q and s[i] - s[q[0]] >= k:
+                ans = min(ans, i - q.popleft())
+            while q and s[i] <= s[q[-1]]:
+                q.pop()
+            q.append(i)
+        return -1 if ans == float('inf') else ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int shortestSubarray(int[] nums, int k) {
+        int n = nums.length;
+        long[] s = new long[n + 1];
+        for (int i = 0; i < n; ++i) {
+            s[i + 1] = s[i] + nums[i];
+        }
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(0);
+        int ans = Integer.MAX_VALUE;
+        for (int i = 1; i <= n; ++i) {
+            while (!q.isEmpty() && s[i] - s[q.peek()] >= k) {
+                ans = Math.min(ans, i - q.poll());
+            }
+            while (!q.isEmpty() && s[i] <= s[q.peekLast()]) {
+                q.pollLast();
+            }
+            q.offer(i);
+        }
+        return ans == Integer.MAX_VALUE ? -1 : ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int shortestSubarray(vector<int>& nums, int k) {
+        int n = nums.size();
+        vector<long long> s(n + 1);
+        for (int i = 0; i < n; ++i) s[i + 1] = s[i] + nums[i];
+        deque<int> q{{0}};
+        int ans = INT_MAX;
+        for (int i = 1; i <= n; ++i)
+        {
+            while (!q.empty() && s[i] - s[q.front()] >= k)
+            {
+                ans = min(ans, i - q.front());
+                q.pop_front();
+            }
+            while (!q.empty() && s[i] <= s[q.back()]) q.pop_back();
+            q.push_back(i);
+        }
+        return ans == INT_MAX ? -1 : ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func shortestSubarray(nums []int, k int) int {
+	n := len(nums)
+	s := make([]int, n+1)
+	for i, v := range nums {
+		s[i+1] = s[i] + v
+	}
+	q := []int{0}
+	ans := math.MaxInt32
+	for i := 1; i <= n; i++ {
+		for len(q) > 0 && s[i]-s[q[0]] >= k {
+			ans = min(ans, i-q[0])
+			q = q[1:]
+		}
+		for len(q) > 0 && s[i] <= s[q[len(q)-1]] {
+			q = q[:len(q)-1]
+		}
+		q = append(q, i)
+	}
+	if ans == math.MaxInt32 {
+		return -1
+	}
+	return ans
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0800-0899/0862.Shortest Subarray with Sum at Least K/README_EN.md

@@ -35,13 +35,106 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def shortestSubarray(self, nums: List[int], k: int) -> int:
+        s = [0] + list(accumulate(nums))
+        ans = float('inf')
+        q = deque([0])
+        for i in range(1, len(s)):
+            while q and s[i] - s[q[0]] >= k:
+                ans = min(ans, i - q.popleft())
+            while q and s[i] <= s[q[-1]]:
+                q.pop()
+            q.append(i)
+        return -1 if ans == float('inf') else ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int shortestSubarray(int[] nums, int k) {
+        int n = nums.length;
+        long[] s = new long[n + 1];
+        for (int i = 0; i < n; ++i) {
+            s[i + 1] = s[i] + nums[i];
+        }
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(0);
+        int ans = Integer.MAX_VALUE;
+        for (int i = 1; i <= n; ++i) {
+            while (!q.isEmpty() && s[i] - s[q.peek()] >= k) {
+                ans = Math.min(ans, i - q.poll());
+            }
+            while (!q.isEmpty() && s[i] <= s[q.peekLast()]) {
+                q.pollLast();
+            }
+            q.offer(i);
+        }
+        return ans == Integer.MAX_VALUE ? -1 : ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int shortestSubarray(vector<int>& nums, int k) {
+        int n = nums.size();
+        vector<long long> s(n + 1);
+        for (int i = 0; i < n; ++i) s[i + 1] = s[i] + nums[i];
+        deque<int> q{{0}};
+        int ans = INT_MAX;
+        for (int i = 1; i <= n; ++i)
+        {
+            while (!q.empty() && s[i] - s[q.front()] >= k)
+            {
+                ans = min(ans, i - q.front());
+                q.pop_front();
+            }
+            while (!q.empty() && s[i] <= s[q.back()]) q.pop_back();
+            q.push_back(i);
+        }
+        return ans == INT_MAX ? -1 : ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func shortestSubarray(nums []int, k int) int {
+	n := len(nums)
+	s := make([]int, n+1)
+	for i, v := range nums {
+		s[i+1] = s[i] + v
+	}
+	q := []int{0}
+	ans := math.MaxInt32
+	for i := 1; i <= n; i++ {
+		for len(q) > 0 && s[i]-s[q[0]] >= k {
+			ans = min(ans, i-q[0])
+			q = q[1:]
+		}
+		for len(q) > 0 && s[i] <= s[q[len(q)-1]] {
+			q = q[:len(q)-1]
+		}
+		q = append(q, i)
+	}
+	if ans == math.MaxInt32 {
+		return -1
+	}
+	return ans
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0800-0899/0862.Shortest Subarray with Sum at Least K/Solution.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int shortestSubarray(vector<int>& nums, int k) {
+        int n = nums.size();
+        vector<long long> s(n + 1);
+        for (int i = 0; i < n; ++i) s[i + 1] = s[i] + nums[i];
+        deque<int> q{{0}};
+        int ans = INT_MAX;
+        for (int i = 1; i <= n; ++i)
+        {
+            while (!q.empty() && s[i] - s[q.front()] >= k)
+            {
+                ans = min(ans, i - q.front());
+                q.pop_front();
+            }
+            while (!q.empty() && s[i] <= s[q.back()]) q.pop_back();
+            q.push_back(i);
+        }
+        return ans == INT_MAX ? -1 : ans;
+    }
+};

solution/0800-0899/0862.Shortest Subarray with Sum at Least K/Solution.go

@@ -0,0 +1,30 @@
+func shortestSubarray(nums []int, k int) int {
+	n := len(nums)
+	s := make([]int, n+1)
+	for i, v := range nums {
+		s[i+1] = s[i] + v
+	}
+	q := []int{0}
+	ans := math.MaxInt32
+	for i := 1; i <= n; i++ {
+		for len(q) > 0 && s[i]-s[q[0]] >= k {
+			ans = min(ans, i-q[0])
+			q = q[1:]
+		}
+		for len(q) > 0 && s[i] <= s[q[len(q)-1]] {
+			q = q[:len(q)-1]
+		}
+		q = append(q, i)
+	}
+	if ans == math.MaxInt32 {
+		return -1
+	}
+	return ans
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

solution/0800-0899/0862.Shortest Subarray with Sum at Least K/Solution.java

@@ -1,22 +1,22 @@
 class Solution {
-    public int shortestSubarray(int[] A, int K) {
-        int n = A.length;
-        int[] s = new int[n + 1];
+    public int shortestSubarray(int[] nums, int k) {
+        int n = nums.length;
+        long[] s = new long[n + 1];
         for (int i = 0; i < n; ++i) {
-            s[i + 1] = s[i] + A[i];
+            s[i + 1] = s[i] + nums[i];
         }
-        Deque<Integer> deque = new ArrayDeque<>();
-        deque.offer(0);
-        int res = Integer.MAX_VALUE;
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(0);
+        int ans = Integer.MAX_VALUE;
         for (int i = 1; i <= n; ++i) {
-            while (!deque.isEmpty() && s[i] - s[deque.peekFirst()] >= K) {
-                res = Math.min(res, i - deque.pollFirst());
+            while (!q.isEmpty() && s[i] - s[q.peek()] >= k) {
+                ans = Math.min(ans, i - q.poll());
             }
-            while (!deque.isEmpty() && s[i] <= s[deque.peekLast()]) {
-                deque.pollLast();
+            while (!q.isEmpty() && s[i] <= s[q.peekLast()]) {
+                q.pollLast();
             }
-            deque.offer(i);
+            q.offer(i);
         }
-        return res != Integer.MAX_VALUE ? res : -1;
+        return ans == Integer.MAX_VALUE ? -1 : ans;
     }
-}
+}

solution/0800-0899/0862.Shortest Subarray with Sum at Least K/Solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def shortestSubarray(self, nums: List[int], k: int) -> int:
+        s = [0] + list(accumulate(nums))
+        ans = float('inf')
+        q = deque([0])
+        for i in range(1, len(s)):
+            while q and s[i] - s[q[0]] >= k:
+                ans = min(ans, i - q.popleft())
+            while q and s[i] <= s[q[-1]]:
+                q.pop()
+            q.append(i)
+        return -1 if ans == float('inf') else ans