feat: C++, Python, Java solution for LeetCode 3578

solutions/3578. Count Partitions With Max-Min Difference at Most K/3578.cpp

@@ -0,0 +1,50 @@
+#include <vector>
+#include <deque>
+
+using namespace std;
+
+class Solution {
+public:
+    int countPartitions(vector<int>& nums, int k) {
+        int n = nums.size();
+        int MOD = 1e9 + 7;
+
+        vector<int> dp(n + 1, 0);
+        dp[0] = 1;
+
+        vector<int> prefixSum(n + 2, 0);
+        prefixSum[1] = 1;
+
+        deque<int> maxDq;
+        deque<int> minDq;
+        int j = 0;
+
+        for (int i = 1; i <= n; ++i) {
+            int val = nums[i - 1];
+
+            while (!maxDq.empty() && nums[maxDq.back()] <= val) {
+                maxDq.pop_back();
+            }
+            maxDq.push_back(i - 1);
+
+            while (!minDq.empty() && nums[minDq.back()] >= val) {
+                minDq.pop_back();
+            }
+            minDq.push_back(i - 1);
+
+            while (nums[maxDq.front()] - nums[minDq.front()] > k) {
+                if (maxDq.front() == j) maxDq.pop_front();
+                if (minDq.front() == j) minDq.pop_front();
+                j++;
+            }
+
+            int count = (prefixSum[i] - prefixSum[j]);
+            if (count < 0) count += MOD;
+
+            dp[i] = count;
+            prefixSum[i + 1] = (prefixSum[i] + count) % MOD;
+        }
+
+        return dp[n];
+    }
+};

solutions/3578. Count Partitions With Max-Min Difference at Most K/3578.java

@@ -0,0 +1,45 @@
+class Solution {
+    public int countPartitions(int[] nums, int k) {
+
+        int n = nums.length;
+        int MOD = 1_000_000_007;
+
+        int[] dp = new int[n + 1];
+        dp[0] = 1;
+
+        int[] prefixSum = new int[n + 2];
+        prefixSum[1] = 1;
+
+        java.util.Deque<Integer> maxDq = new java.util.ArrayDeque<>();
+        java.util.Deque<Integer> minDq = new java.util.ArrayDeque<>();
+        int j = 0;
+
+        for (int i = 1; i <= n; i++) {
+            int val = nums[i - 1];
+
+            while (!maxDq.isEmpty() && nums[maxDq.peekLast()] <= val) {
+                maxDq.pollLast();
+            }
+            maxDq.offerLast(i - 1);
+
+            while (!minDq.isEmpty() && nums[minDq.peekLast()] >= val) {
+                minDq.pollLast();
+            }
+            minDq.offerLast(i - 1);
+
+            while (nums[maxDq.peekFirst()] - nums[minDq.peekFirst()] > k) {
+                if (maxDq.peekFirst() == j) maxDq.pollFirst();
+                if (minDq.peekFirst() == j) minDq.pollFirst();
+                j++;
+            }
+
+            int count = (prefixSum[i] - prefixSum[j]);
+            if (count < 0) count += MOD;
+
+            dp[i] = count;
+            prefixSum[i + 1] = (prefixSum[i] + count) % MOD;
+        }
+
+        return dp[n];
+    }
+}

solutions/3578. Count Partitions With Max-Min Difference at Most K/3578.py

@@ -0,0 +1,41 @@
+from collections import deque
+from typing import List
+
+class Solution:
+    def countPartitions(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        MOD = 10**9 + 7
+
+        dp = [0] * (n + 1)
+        dp[0] = 1
+
+        prefix_sum = [0] * (n + 2)
+        prefix_sum[1] = 1
+
+        max_dq = deque()
+        min_dq = deque()
+        j = 0
+
+        for i in range(1, n + 1):
+            val = nums[i - 1]
+
+            while max_dq and nums[max_dq[-1]] <= val:
+                max_dq.pop()
+            max_dq.append(i - 1)
+
+            while min_dq and nums[min_dq[-1]] >= val:
+                min_dq.pop()
+            min_dq.append(i - 1)
+
+            while nums[max_dq[0]] - nums[min_dq[0]] > k:
+                if max_dq[0] == j:
+                    max_dq.popleft()
+                if min_dq[0] == j:
+                    min_dq.popleft()
+                j += 1
+
+            count = (prefix_sum[i] - prefix_sum[j]) % MOD
+            dp[i] = count
+            prefix_sum[i + 1] = (prefix_sum[i] + count) % MOD
+
+        return dp[n]