Monotonic queue

Author: caipengbo

src/datastructure/monotonicqueue/FrogJump2.java

@@ -0,0 +1,54 @@
+package datastructure.monotonicqueue;
+
+import java.util.Arrays;
+
+/**
+ * Title: 跳台阶 Desc: A Frog jumps K steps at most. It costs `A[i]` to stays at
+ * `i`. Return the min cost to get to `N-1` from `0` Created by Myth on
+ * 01/14/2020 in VSCode
+ */
+
+public class FrogJump2 {
+    
+    public int jump(int[] costs, int K) {
+        int n = costs.length;
+        int[] dp = new int[n];
+        Arrays.fill(dp, Integer.MAX_VALUE);
+        for (int i = 0; i <= K && i < n; i++) {
+            dp[i] = costs[i];
+        }
+
+        for (int i = K+1; i < n; i++) {
+            for (int j = 1; j <= K; j++) {
+                dp[i] = Math.min(dp[i], dp[i-j]+costs[i]);
+            }
+        }
+        System.out.println(Arrays.toString(dp));
+        return dp[n-1];
+
+    }
+    /** 使用单调栈优化
+from collections import deque
+def min_cost(A, K):
+    Q = deque([(0, A[0])])
+    for i in range(1, len(A)):
+        
+        # keep sliding width == K steps
+        while Q and Q[0][0] < i - K:
+            Q.popleft()
+            
+        # remove inferior elements at the tail
+        while Q and Q[-1][1] > A[i] + Q[0][1]:
+            Q.pop()
+
+        Q.append((i, A[i] + Q[0][1]))
+    return Q[-1][1]
+     * 
+     */
+    public static void main(String[] args) {
+        int[] costs = {0, 3, 2, 7, 1, 4};
+        FrogJump2 frogJump2 = new FrogJump2();
+        frogJump2.jump(costs, 2);
+    }
+
+}

src/datastructure/monotonicqueue/P862ShortestSubarrayWithSumAtLeastK.java

@@ -0,0 +1,48 @@
+package datastructure.monotonicqueue;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * Title: 862. 和至少为 K 的最短子数组 
+ * Desc:
+ * 209题（双指针）的进阶版，其中数字可以为负数，这样我们就不知道下一个数会使总和大还是小了，就不能用双指针的做法.
+ * 
+ * 返回 A 的最短的非空连续子数组的长度，该子数组的和至少为 K 。如果没有和至少为 K 的非空子数组，返回 -1 。 
+ * Created by Myth on 01/14/2020 in VSCode
+ */
+
+public class P862ShortestSubarrayWithSumAtLeastK {
+    // 单纯 前缀和（TLE）
+    public int shortestSubarray_Old(int[] A, int K) {
+        int n = A.length;
+        int[] preSum = new int[n+1];  // 前缀和
+        int ret = n+1;
+        for (int i = 1; i <= n; i++) {
+            preSum[i] = preSum[i-1] + A[i-1];
+            for (int j = 0; j < i; j++) {
+                if (preSum[i] - preSum[j] >= K) ret = Math.min(ret, i-j);  
+            }
+        }
+        return ret == n+1 ? -1 : ret;
+    }
+    // 优化
+    public int shortestSubarray(int[] A, int K) {
+        int n = A.length;
+        int[] preSum = new int[n+1];
+        int ret = n+1;
+        Deque<Integer> deque = new ArrayDeque<>();  // 递增队列
+        for (int i = 0; i < n; i++) {
+            preSum[i+1] = preSum[i] + A[i];
+        }
+        for (int i = 0; i <= n; i++) {
+            while (deque.size() > 0 && preSum[i] - preSum[deque.getFirst()] >=  K)
+                ret = Math.min(ret, i - deque.pollFirst());
+            // 使用递增队列 才能保证
+            while (deque.size() > 0 && preSum[deque.getLast()] >= preSum[i])
+                deque.pollLast();
+            deque.addLast(i);
+        }
+        return ret == n+1 ? -1 : ret;
+    }
+}