feat: update solutions to lc/lcof2 problems

* lc No.0496 & lcof2 No.038.Next Greater Element I

Author: yanglbme

lcof2/剑指 Offer II 038. 每日温度/README.md

@@ -45,6 +45,8 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：单调栈**
+
 单调栈常见模型：找出每个数左/右边**离它最近的**且**比它大/小的数**。模板：
 
 ```python
@@ -64,14 +66,29 @@ for i in range(n):
 ```python
 class Solution:
     def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
-        res = [0] * len(temperatures)
+        ans = [0] * len(temperatures)
         stk = []
         for i, t in enumerate(temperatures):
             while stk and temperatures[stk[-1]] < t:
                 j = stk.pop()
-                res[j] = i - j
+                ans[j] = i - j
+            stk.append(i)
+        return ans
+```
+
+```python
+class Solution:
+    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
+        n = len(temperatures)
+        stk = []
+        ans = [0] * n
+        for i in range(n - 1, -1, -1):
+            while stk and temperatures[stk[-1]] <= temperatures[i]:
+                stk.pop()
+            if stk:
+                ans[i] = stk[-1] - i
             stk.append(i)
-        return res
+        return ans
 ```
 
 ### **Java**
@@ -82,16 +99,36 @@ class Solution:
 class Solution {
     public int[] dailyTemperatures(int[] temperatures) {
         int n = temperatures.length;
-        int[] res = new int[n];
+        int[] ans = new int[n];
         Deque<Integer> stk = new ArrayDeque<>();
         for (int i = 0; i < n; ++i) {
             while (!stk.isEmpty() && temperatures[stk.peek()] < temperatures[i]) {
                 int j = stk.pop();
-                res[j] = i - j;
+                ans[j] = i - j;
             }
             stk.push(i);
         }
-        return res;
+        return ans;
+    }
+}
+```
+
+```java
+class Solution {
+    public int[] dailyTemperatures(int[] temperatures) {
+        int n = temperatures.length;
+        Deque<Integer> stk = new ArrayDeque<>();
+        int[] ans = new int[n];
+        for (int i = n - 1; i >= 0; --i) {
+            while (!stk.isEmpty() && temperatures[stk.peek()] <= temperatures[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                ans[i] = stk.peek() - i;
+            }
+            stk.push(i);
+        }
+        return ans;
     }
 }
 ```
@@ -105,18 +142,36 @@ class Solution {
 public:
     vector<int> dailyTemperatures(vector<int> &temperatures) {
         int n = temperatures.size();
-        vector<int> res(n);
+        vector<int> ans(n);
         stack<int> stk;
         for (int i = 0; i < n; ++i)
         {
             while (!stk.empty() && temperatures[stk.top()] < temperatures[i])
             {
-                res[stk.top()] = i - stk.top();
+                ans[stk.top()] = i - stk.top();
                 stk.pop();
             }
             stk.push(i);
         }
-        return res;
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> dailyTemperatures(vector<int> &temperatures) {
+        int n = temperatures.size();
+        vector<int> ans(n);
+        stack<int> stk;
+        for (int i = n - 1; ~i; --i)
+        {
+            while (!stk.empty() && temperatures[stk.top()] <= temperatures[i]) stk.pop();
+            if (!stk.empty()) ans[i] = stk.top() - i;
+            stk.push(i);
+        }
+        return ans;
     }
 };
 ```
@@ -125,17 +180,35 @@ public:
 
 ```go
 func dailyTemperatures(temperatures []int) []int {
-	res := make([]int, len(temperatures))
+	ans := make([]int, len(temperatures))
 	var stk []int
 	for i, t := range temperatures {
 		for len(stk) > 0 && temperatures[stk[len(stk)-1]] < t {
 			j := stk[len(stk)-1]
-			res[j] = i - j
+			ans[j] = i - j
 			stk = stk[:len(stk)-1]
 		}
 		stk = append(stk, i)
 	}
-	return res
+	return ans
+}
+```
+
+```go
+func dailyTemperatures(temperatures []int) []int {
+	n := len(temperatures)
+	ans := make([]int, n)
+	var stk []int
+	for i := n - 1; i >= 0; i-- {
+		for len(stk) > 0 && temperatures[stk[len(stk)-1]] <= temperatures[i] {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			ans[i] = stk[len(stk)-1] - i
+		}
+		stk = append(stk, i)
+	}
+	return ans
 }
 ```
 

lcof2/剑指 Offer II 038. 每日温度/Solution.cpp

@@ -2,17 +2,17 @@ class Solution {
 public:
     vector<int> dailyTemperatures(vector<int> &temperatures) {
         int n = temperatures.size();
-        vector<int> res(n);
+        vector<int> ans(n);
         stack<int> stk;
         for (int i = 0; i < n; ++i)
         {
             while (!stk.empty() && temperatures[stk.top()] < temperatures[i])
             {
-                res[stk.top()] = i - stk.top();
+                ans[stk.top()] = i - stk.top();
                 stk.pop();
             }
             stk.push(i);
         }
-        return res;
+        return ans;
     }
 };

lcof2/剑指 Offer II 038. 每日温度/Solution.go

@@ -1,13 +1,13 @@
 func dailyTemperatures(temperatures []int) []int {
-	res := make([]int, len(temperatures))
+	ans := make([]int, len(temperatures))
 	var stk []int
 	for i, t := range temperatures {
 		for len(stk) > 0 && temperatures[stk[len(stk)-1]] < t {
 			j := stk[len(stk)-1]
-			res[j] = i - j
+			ans[j] = i - j
 			stk = stk[:len(stk)-1]
 		}
 		stk = append(stk, i)
 	}
-	return res
+	return ans
 }

lcof2/剑指 Offer II 038. 每日温度/Solution.java

@@ -1,15 +1,15 @@
 class Solution {
     public int[] dailyTemperatures(int[] temperatures) {
         int n = temperatures.length;
-        int[] res = new int[n];
+        int[] ans = new int[n];
         Deque<Integer> stk = new ArrayDeque<>();
         for (int i = 0; i < n; ++i) {
             while (!stk.isEmpty() && temperatures[stk.peek()] < temperatures[i]) {
                 int j = stk.pop();
-                res[j] = i - j;
+                ans[j] = i - j;
             }
             stk.push(i);
         }
-        return res;
+        return ans;
     }
 }

lcof2/剑指 Offer II 038. 每日温度/Solution.py

@@ -1,10 +1,10 @@
 class Solution:
     def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
-        res = [0] * len(temperatures)
+        ans = [0] * len(temperatures)
         stk = []
         for i, t in enumerate(temperatures):
             while stk and temperatures[stk[-1]] < t:
                 j = stk.pop()
-                res[j] = i - j
+                ans[j] = i - j
             stk.append(i)
-        return res
+        return ans

solution/0400-0499/0496.Next Greater Element I/README.md

@@ -57,8 +57,6 @@
 
 **方法一：单调栈**
 
-先对将 nums2 中的每一个元素，求出其下一个更大的元素。随后对于将这些答案放入哈希映射（HashMap）中，再遍历数组 nums1，并直接找出答案。对于 nums2，可以使用单调栈来解决这个问题。
-
 单调栈常见模型：找出每个数左/右边**离它最近的**且**比它大/小的数**。模板：
 
 ```python
@@ -69,6 +67,10 @@ for i in range(n):
     stk.append(i)
 ```
 
+对于本题，先对将 $nums2$ 中的每一个元素，求出其下一个更大的元素。随后对于将这些答案放入哈希表 $m$ 中，再遍历数组 $nums1$，并直接找出答案。对于 $nums2$，可以使用单调栈来解决这个问题。
+
+时间复杂度 $O(M+N)$，其中 $M$ 表示 $nums1$ 的长度，$N$ 表示 $nums2$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -87,6 +89,20 @@ class Solution:
         return [m.get(v, -1) for v in nums1]
 ```
 
+```python
+class Solution:
+    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        m = {}
+        stk = []
+        for v in nums2[::-1]:
+            while stk and stk[-1] <= v:
+                stk.pop()
+            if stk:
+                m[v] = stk[-1]
+            stk.append(v)
+        return [m.get(x, -1) for x in nums1]
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -112,6 +128,30 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
+        Deque<Integer> stk = new ArrayDeque<>();
+        Map<Integer, Integer> m = new HashMap<>();
+        for (int i = nums2.length - 1; i >= 0; --i) {
+            while (!stk.isEmpty() && stk.peek() <= nums2[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                m.put(nums2[i], stk.peek());
+            }
+            stk.push(nums2[i]);
+        }
+        int n = nums1.length;
+        int[] ans = new int[n];
+        for (int i = 0; i < n; ++i) {
+            ans[i] = m.getOrDefault(nums1[i], -1);
+        }
+        return ans;
+    }
+}
+```
+
 ### **JavaScript**
 
 ```js
@@ -133,6 +173,28 @@ var nextGreaterElement = function (nums1, nums2) {
 };
 ```
 
+```js
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+var nextGreaterElement = function (nums1, nums2) {
+    let stk = [];
+    let m = {};
+    for (let v of nums2.reverse()) {
+        while (stk && stk[stk.length - 1] <= v) {
+            stk.pop();
+        }
+        if (stk) {
+            m[v] = stk[stk.length - 1];
+        }
+        stk.push(v);
+    }
+    return nums1.map(e => m[e] || -1);
+};
+```
+
 ### **C++**
 
 ```cpp
@@ -157,6 +219,25 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
+        stack<int> stk;
+        unordered_map<int, int> m;
+        for (int i = nums2.size() - 1; ~i; --i)
+        {
+            while (!stk.empty() && stk.top() <= nums2[i]) stk.pop();
+            if (!stk.empty()) m[nums2[i]] = stk.top();
+            stk.push(nums2[i]);
+        }
+        vector<int> ans;
+        for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1);
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -182,6 +263,31 @@ func nextGreaterElement(nums1 []int, nums2 []int) []int {
 }
 ```
 
+```go
+func nextGreaterElement(nums1 []int, nums2 []int) []int {
+	stk := []int{}
+	m := map[int]int{}
+	for i := len(nums2) - 1; i >= 0; i-- {
+		for len(stk) > 0 && stk[len(stk)-1] <= nums2[i] {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			m[nums2[i]] = stk[len(stk)-1]
+		}
+		stk = append(stk, nums2[i])
+	}
+	var ans []int
+	for _, v := range nums1 {
+		val, ok := m[v]
+		if !ok {
+			val = -1
+		}
+		ans = append(ans, val)
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts