feat: add solutions to lc problem: No.0239

No.0239.Sliding Window Maximum

Author: yanglbme

solution/0200-0299/0239.Sliding Window Maximum/README.md

@@ -49,7 +49,17 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：单调队列**
+**方法一：优先队列（大根堆）**
+
+我们可以使用优先队列（大根堆）来维护滑动窗口中的最大值。
+
+先将前 $k-1$ 个元素加入优先队列，接下来从第 $k$ 个元素开始，将新元素加入优先队列，同时判断堆顶元素是否滑出窗口，如果滑出窗口则将堆顶元素弹出。然后我们将堆顶元素加入结果数组。
+
+时间复杂度 $O(n \times \log k)$，空间复杂度 $O(k)$。其中 $n$ 为数组长度。
+
+**方法二：单调队列**
+
+这道题也可以使用单调队列来解决。时间复杂度 $O(n)$，空间复杂度 $O(k)$。
 
 单调队列常见模型：找出滑动窗口中的最大值/最小值。模板：
 
@@ -70,6 +80,20 @@ for i in range(n):
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```python
+class Solution:
+    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
+        q = [(-v, i) for i, v in enumerate(nums[:k - 1])]
+        heapify(q)
+        ans = []
+        for i in range(k - 1, len(nums)):
+            heappush(q, (-nums[i], i))
+            while q[0][1] <= i - k:
+                heappop(q)
+            ans.append(-q[0][0])
+        return ans
+```
+
 ```python
 class Solution:
     def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
@@ -90,6 +114,27 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+class Solution {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]);
+        int n = nums.length;
+        for (int i = 0; i < k - 1; ++i) {
+            q.offer(new int[] {nums[i], i});
+        }
+        int[] ans = new int[n - k + 1];
+        for (int i = k - 1, j = 0; i < n; ++i) {
+            q.offer(new int[] {nums[i], i});
+            while (q.peek()[1] <= i - k) {
+                q.poll();
+            }
+            ans[j++] = q.peek()[0];
+        }
+        return ans;
+    }
+}
+```
+
 ```java
 class Solution {
     public int[] maxSlidingWindow(int[] nums, int k) {
@@ -113,46 +158,47 @@ class Solution {
 }
 ```
 
-### **JavaScript**
+### **C++**
 
-```js
-/**
- * @param {number[]} nums
- * @param {number} k
- * @return {number[]}
- */
-var maxSlidingWindow = function (nums, k) {
-    let ans = [];
-    let q = [];
-    for (let i = 0; i < nums.length; ++i) {
-        if (q && i - k + 1 > q[0]) {
-            q.shift();
-        }
-        while (q && nums[q[q.length - 1]] <= nums[i]) {
-            q.pop();
+```cpp
+class Solution {
+public:
+    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
+        priority_queue<pair<int, int>> q;
+        int n = nums.size();
+        for (int i = 0; i < k - 1; ++i) {
+            q.push({nums[i], -i});
         }
-        q.push(i);
-        if (i >= k - 1) {
-            ans.push(nums[q[0]]);
+        vector<int> ans;
+        for (int i = k - 1; i < n; ++i) {
+            q.push({nums[i], -i});
+            while (-q.top().second <= i - k) {
+                q.pop();
+            }
+            ans.emplace_back(q.top().first);
         }
+        return ans;
     }
-    return ans;
 };
 ```
 
-### **C++**
-
 ```cpp
 class Solution {
 public:
     vector<int> maxSlidingWindow(vector<int>& nums, int k) {
         deque<int> q;
         vector<int> ans;
         for (int i = 0; i < nums.size(); ++i) {
-            if (!q.empty() && i - k + 1 > q.front()) q.pop_front();
-            while (!q.empty() && nums[q.back()] <= nums[i]) q.pop_back();
+            if (!q.empty() && i - k + 1 > q.front()) {
+                q.pop_front();
+            }
+            while (!q.empty() && nums[q.back()] <= nums[i]) {
+                q.pop_back();
+            }
             q.push_back(i);
-            if (i >= k - 1) ans.push_back(nums[q.front()]);
+            if (i >= k - 1) {
+                ans.emplace_back(nums[q.front()]);
+            }
         }
         return ans;
     }
@@ -162,9 +208,38 @@ public:
 ### **Go**
 
 ```go
-func maxSlidingWindow(nums []int, k int) []int {
-	var q []int
-	var ans []int
+func maxSlidingWindow(nums []int, k int) (ans []int) {
+	q := hp{}
+	for i, v := range nums[:k-1] {
+		heap.Push(&q, pair{v, i})
+	}
+	for i := k - 1; i < len(nums); i++ {
+		heap.Push(&q, pair{nums[i], i})
+		for q[0].i <= i-k {
+			heap.Pop(&q)
+		}
+		ans = append(ans, q[0].v)
+	}
+	return
+}
+
+type pair struct{ v, i int }
+
+type hp []pair
+
+func (h hp) Len() int { return len(h) }
+func (h hp) Less(i, j int) bool {
+	a, b := h[i], h[j]
+	return a.v > b.v || (a.v == b.v && i < j)
+}
+func (h hp) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
+func (h *hp) Push(v interface{}) { *h = append(*h, v.(pair)) }
+func (h *hp) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
+```
+
+```go
+func maxSlidingWindow(nums []int, k int) (ans []int) {
+	q := []int{}
 	for i, v := range nums {
 		if len(q) > 0 && i-k+1 > q[0] {
 			q = q[1:]
@@ -181,6 +256,33 @@ func maxSlidingWindow(nums []int, k int) []int {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var maxSlidingWindow = function (nums, k) {
+    let ans = [];
+    let q = [];
+    for (let i = 0; i < nums.length; ++i) {
+        if (q && i - k + 1 > q[0]) {
+            q.shift();
+        }
+        while (q && nums[q[q.length - 1]] <= nums[i]) {
+            q.pop();
+        }
+        q.push(i);
+        if (i >= k - 1) {
+            ans.push(nums[q[0]]);
+        }
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```