From 9a2bbcac6859d6b7101a2e332d0c27e3d56efef5 Mon Sep 17 00:00:00 2001 From: yanglbme Date: Thu, 21 Nov 2024 13:20:37 +0800 Subject: [PATCH] feat: update solutions to lc problem: No.0496 No.0496.Next Greater Element I --- .../0496.Next Greater Element I/README.md | 292 +++++------------- .../0496.Next Greater Element I/README_EN.md | 288 ++++++----------- .../0496.Next Greater Element I/Solution.cpp | 19 +- .../0496.Next Greater Element I/Solution.go | 30 +- .../0496.Next Greater Element I/Solution.java | 24 +- .../0496.Next Greater Element I/Solution.js | 15 +- .../0496.Next Greater Element I/Solution.py | 14 +- .../0496.Next Greater Element I/Solution.rs | 26 +- .../0496.Next Greater Element I/Solution.ts | 15 +- .../0496.Next Greater Element I/Solution2.cpp | 15 - .../0496.Next Greater Element I/Solution2.go | 22 -- .../Solution2.java | 21 -- .../0496.Next Greater Element I/Solution2.js | 19 -- .../0496.Next Greater Element I/Solution2.py | 11 - .../0496.Next Greater Element I/Solution2.rs | 19 -- 15 files changed, 250 insertions(+), 580 deletions(-) delete mode 100644 solution/0400-0499/0496.Next Greater Element I/Solution2.cpp delete mode 100644 solution/0400-0499/0496.Next Greater Element I/Solution2.go delete mode 100644 solution/0400-0499/0496.Next Greater Element I/Solution2.java delete mode 100644 solution/0400-0499/0496.Next Greater Element I/Solution2.js delete mode 100644 solution/0400-0499/0496.Next Greater Element I/Solution2.py delete mode 100644 solution/0400-0499/0496.Next Greater Element I/Solution2.rs diff --git a/solution/0400-0499/0496.Next Greater Element I/README.md b/solution/0400-0499/0496.Next Greater Element I/README.md index 88ce5651baae0..d321f2b53c511 100644 --- a/solution/0400-0499/0496.Next Greater Element I/README.md +++ b/solution/0400-0499/0496.Next Greater Element I/README.md @@ -72,19 +72,13 @@ tags: ### 方法一：单调栈 -单调栈常见模型：找出每个数左/右边**离它最近的**且**比它大/小的数**。模板： +我们可以从右往左遍历数组 $\textit{nums2}$，维护一个从栈顶到栈底单调递增的栈 $\textit{stk}$，并且用哈希表 $\textit{d}$ 记录每个元素的下一个更大元素。 -```python -stk = [] -for i in range(n): - while stk and check(stk[-1], i): - stk.pop() - stk.append(i) -``` +遍历到元素 $x$ 时，如果栈不为空且栈顶元素小于 $x$，我们就不断弹出栈顶元素，直到栈为空或者栈顶元素大于等于 $x$。此时，如果栈不为空，栈顶元素就是 $x$ 的下一个更大元素，否则 $x$ 没有下一个更大元素。 -对于本题，先对将 `nums2` 中的每一个元素，求出其下一个更大的元素。随后对于将这些答案放入哈希表 $m$ 中，再遍历数组 `nums1`，并直接找出答案。对于 `nums2`，可以使用单调栈来解决这个问题。 +最后我们遍历数组 $\textit{nums1}$，根据哈希表 $\textit{d}$ 得到答案。 -时间复杂度 $O(M+N)$，其中 $M$ 和 $N$ 分别为数组 `nums1` 和 `nums2` 的长度。 +时间复杂度 $O(m + n)$，空间复杂度 $O(n)$。其中 $m$ 和 $n$ 分别为数组 $\textit{nums1}$ 和 $\textit{nums2}$ 的长度。 @@ -93,13 +87,15 @@ for i in range(n): ```python class Solution: def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]: - m = {} stk = [] - for v in nums2: - while stk and stk[-1] < v: - m[stk.pop()] = v - stk.append(v) - return [m.get(v, -1) for v in nums1] + d = {} + for x in nums2[::-1]: + while stk and stk[-1] < x: + stk.pop() + if stk: + d[x] = stk[-1] + stk.append(x) + return [d.get(x, -1) for x in nums1] ``` #### Java @@ -108,17 +104,21 @@ class Solution: class Solution { public int[] nextGreaterElement(int[] nums1, int[] nums2) { Deque stk = new ArrayDeque<>(); - Map m = new HashMap<>(); - for (int v : nums2) { - while (!stk.isEmpty() && stk.peek() < v) { - m.put(stk.pop(), v); + int m = nums1.length, n = nums2.length; + Map d = new HashMap(n); + for (int i = n - 1; i >= 0; --i) { + int x = nums2[i]; + while (!stk.isEmpty() && stk.peek() < x) { + stk.pop(); + } + if (!stk.isEmpty()) { + d.put(x, stk.peek()); } - stk.push(v); + stk.push(x); } - int n = nums1.length; - int[] ans = new int[n]; - for (int i = 0; i < n; ++i) { - ans[i] = m.getOrDefault(nums1[i], -1); + int[] ans = new int[m]; + for (int i = 0; i < m; ++i) { + ans[i] = d.getOrDefault(nums1[i], -1); } return ans; } @@ -132,16 +132,21 @@ class Solution { public: vector nextGreaterElement(vector& nums1, vector& nums2) { stack stk; - unordered_map m; - for (int& v : nums2) { - while (!stk.empty() && stk.top() < v) { - m[stk.top()] = v; + unordered_map d; + ranges::reverse(nums2); + for (int x : nums2) { + while (!stk.empty() && stk.top() < x) { stk.pop(); } - stk.push(v); + if (!stk.empty()) { + d[x] = stk.top(); + } + stk.push(x); } vector ans; - for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1); + for (int x : nums1) { + ans.push_back(d.contains(x) ? d[x] : -1); + } return ans; } }; @@ -150,25 +155,27 @@ public: #### Go ```go -func nextGreaterElement(nums1 []int, nums2 []int) []int { +func nextGreaterElement(nums1 []int, nums2 []int) (ans []int) { stk := []int{} - m := map[int]int{} - for _, v := range nums2 { - for len(stk) > 0 && stk[len(stk)-1] < v { - m[stk[len(stk)-1]] = v + d := map[int]int{} + for i := len(nums2) - 1; i >= 0; i-- { + x := nums2[i] + for len(stk) > 0 && stk[len(stk)-1] < x { stk = stk[:len(stk)-1] } - stk = append(stk, v) + if len(stk) > 0 { + d[x] = stk[len(stk)-1] + } + stk = append(stk, x) } - var ans []int - for _, v := range nums1 { - val, ok := m[v] - if !ok { - val = -1 + for _, x := range nums1 { + if v, ok := d[x]; ok { + ans = append(ans, v) + } else { + ans = append(ans, -1) } - ans = append(ans, val) } - return ans + return } ``` @@ -176,15 +183,16 @@ func nextGreaterElement(nums1 []int, nums2 []int) []int { ```ts function nextGreaterElement(nums1: number[], nums2: number[]): number[] { - const map = new Map(); - const stack: number[] = [Infinity]; - for (const num of nums2) { - while (num > stack[stack.length - 1]) { - map.set(stack.pop(), num); + const stk: number[] = []; + const d: Record = {}; + for (const x of nums2.reverse()) { + while (stk.length && stk.at(-1)! < x) { + stk.pop(); } - stack.push(num); + d[x] = stk.length ? stk.at(-1)! : -1; + stk.push(x); } - return nums1.map(num => map.get(num) || -1); + return nums1.map(x => d[x]); } ``` @@ -195,162 +203,26 @@ use std::collections::HashMap; impl Solution { pub fn next_greater_element(nums1: Vec, nums2: Vec) -> Vec { - let mut map = HashMap::new(); - let mut stack = Vec::new(); - for num in nums2 { - while num > *stack.last().unwrap_or(&i32::MAX) { - map.insert(stack.pop().unwrap(), num); - } - stack.push(num); - } - nums1 - .iter() - .map(|n| *map.get(n).unwrap_or(&-1)) - .collect::>() - } -} -``` - -#### JavaScript - -```js -/** - * @param {number[]} nums1 - * @param {number[]} nums2 - * @return {number[]} - */ -var nextGreaterElement = function (nums1, nums2) { - let stk = []; - let m = {}; - for (let v of nums2) { - while (stk && stk[stk.length - 1] < v) { - m[stk.pop()] = v; - } - stk.push(v); - } - return nums1.map(e => m[e] || -1); -}; -``` - - - - - - - -### 方法二 - - - -#### Python3 - -```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 - -```java -class Solution { - public int[] nextGreaterElement(int[] nums1, int[] nums2) { - Deque stk = new ArrayDeque<>(); - Map m = new HashMap<>(); - for (int i = nums2.length - 1; i >= 0; --i) { - while (!stk.isEmpty() && stk.peek() <= nums2[i]) { - stk.pop(); + let mut stk = Vec::new(); + let mut d = HashMap::new(); + for &x in nums2.iter().rev() { + while let Some(&top) = stk.last() { + if top <= x { + stk.pop(); + } else { + break; + } } - if (!stk.isEmpty()) { - m.put(nums2[i], stk.peek()); + if let Some(&top) = stk.last() { + d.insert(x, top); } - stk.push(nums2[i]); + stk.push(x); } - 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; - } -} -``` - -#### C++ -```cpp -class Solution { -public: - vector nextGreaterElement(vector& nums1, vector& nums2) { - stack stk; - unordered_map 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 ans; - for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1); - return ans; - } -}; -``` - -#### Go - -```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 -} -``` - -#### Rust - -```rust -impl Solution { - pub fn next_greater_element(nums1: Vec, nums2: Vec) -> Vec { nums1 - .iter() - .map(|target| { - let mut res = -1; - for num in nums2.iter().rev() { - if num == target { - break; - } - if num > target { - res = *num; - } - } - res - }) - .collect::>() + .into_iter() + .map(|x| *d.get(&x).unwrap_or(&-1)) + .collect() } } ``` @@ -364,18 +236,16 @@ impl Solution { * @return {number[]} */ var nextGreaterElement = function (nums1, nums2) { - let stk = []; - let m = {}; - for (let v of nums2.reverse()) { - while (stk && stk[stk.length - 1] <= v) { + const stk = []; + const d = {}; + for (const x of nums2.reverse()) { + while (stk.length && stk.at(-1) < x) { stk.pop(); } - if (stk) { - m[v] = stk[stk.length - 1]; - } - stk.push(v); + d[x] = stk.length ? stk.at(-1) : -1; + stk.push(x); } - return nums1.map(e => m[e] || -1); + return nums1.map(x => d[x]); }; ``` diff --git a/solution/0400-0499/0496.Next Greater Element I/README_EN.md b/solution/0400-0499/0496.Next Greater Element I/README_EN.md index 13c6f1706675b..333e574f3c536 100644 --- a/solution/0400-0499/0496.Next Greater Element I/README_EN.md +++ b/solution/0400-0499/0496.Next Greater Element I/README_EN.md @@ -68,7 +68,15 @@ tags: -### Solution 1 +### Solution 1: Monotonic Stack + +We can traverse the array $\textit{nums2}$ from right to left, maintaining a stack $\textit{stk}$ that is monotonically increasing from top to bottom. We use a hash table $\textit{d}$ to record the next greater element for each element. + +When we encounter an element $x$, if the stack is not empty and the top element of the stack is less than $x$, we keep popping the top elements until the stack is empty or the top element is greater than or equal to $x$. At this point, if the stack is not empty, the top element of the stack is the next greater element for $x$. Otherwise, $x$ has no next greater element. + +Finally, we traverse the array $\textit{nums1}$ and use the hash table $\textit{d}$ to get the answer. + +The time complexity is $O(m + n)$, and the space complexity is $O(n)$. Here, $m$ and $n$ are the lengths of the arrays $\textit{nums1}$ and $\textit{nums2}$, respectively. @@ -77,13 +85,15 @@ tags: ```python class Solution: def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]: - m = {} stk = [] - for v in nums2: - while stk and stk[-1] < v: - m[stk.pop()] = v - stk.append(v) - return [m.get(v, -1) for v in nums1] + d = {} + for x in nums2[::-1]: + while stk and stk[-1] < x: + stk.pop() + if stk: + d[x] = stk[-1] + stk.append(x) + return [d.get(x, -1) for x in nums1] ``` #### Java @@ -92,17 +102,21 @@ class Solution: class Solution { public int[] nextGreaterElement(int[] nums1, int[] nums2) { Deque stk = new ArrayDeque<>(); - Map m = new HashMap<>(); - for (int v : nums2) { - while (!stk.isEmpty() && stk.peek() < v) { - m.put(stk.pop(), v); + int m = nums1.length, n = nums2.length; + Map d = new HashMap(n); + for (int i = n - 1; i >= 0; --i) { + int x = nums2[i]; + while (!stk.isEmpty() && stk.peek() < x) { + stk.pop(); } - stk.push(v); + if (!stk.isEmpty()) { + d.put(x, stk.peek()); + } + stk.push(x); } - int n = nums1.length; - int[] ans = new int[n]; - for (int i = 0; i < n; ++i) { - ans[i] = m.getOrDefault(nums1[i], -1); + int[] ans = new int[m]; + for (int i = 0; i < m; ++i) { + ans[i] = d.getOrDefault(nums1[i], -1); } return ans; } @@ -116,16 +130,21 @@ class Solution { public: vector nextGreaterElement(vector& nums1, vector& nums2) { stack stk; - unordered_map m; - for (int& v : nums2) { - while (!stk.empty() && stk.top() < v) { - m[stk.top()] = v; + unordered_map d; + ranges::reverse(nums2); + for (int x : nums2) { + while (!stk.empty() && stk.top() < x) { stk.pop(); } - stk.push(v); + if (!stk.empty()) { + d[x] = stk.top(); + } + stk.push(x); } vector ans; - for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1); + for (int x : nums1) { + ans.push_back(d.contains(x) ? d[x] : -1); + } return ans; } }; @@ -134,25 +153,27 @@ public: #### Go ```go -func nextGreaterElement(nums1 []int, nums2 []int) []int { +func nextGreaterElement(nums1 []int, nums2 []int) (ans []int) { stk := []int{} - m := map[int]int{} - for _, v := range nums2 { - for len(stk) > 0 && stk[len(stk)-1] < v { - m[stk[len(stk)-1]] = v + d := map[int]int{} + for i := len(nums2) - 1; i >= 0; i-- { + x := nums2[i] + for len(stk) > 0 && stk[len(stk)-1] < x { stk = stk[:len(stk)-1] } - stk = append(stk, v) + if len(stk) > 0 { + d[x] = stk[len(stk)-1] + } + stk = append(stk, x) } - var ans []int - for _, v := range nums1 { - val, ok := m[v] - if !ok { - val = -1 + for _, x := range nums1 { + if v, ok := d[x]; ok { + ans = append(ans, v) + } else { + ans = append(ans, -1) } - ans = append(ans, val) } - return ans + return } ``` @@ -160,15 +181,16 @@ func nextGreaterElement(nums1 []int, nums2 []int) []int { ```ts function nextGreaterElement(nums1: number[], nums2: number[]): number[] { - const map = new Map(); - const stack: number[] = [Infinity]; - for (const num of nums2) { - while (num > stack[stack.length - 1]) { - map.set(stack.pop(), num); + const stk: number[] = []; + const d: Record = {}; + for (const x of nums2.reverse()) { + while (stk.length && stk.at(-1)! < x) { + stk.pop(); } - stack.push(num); + d[x] = stk.length ? stk.at(-1)! : -1; + stk.push(x); } - return nums1.map(num => map.get(num) || -1); + return nums1.map(x => d[x]); } ``` @@ -179,162 +201,26 @@ use std::collections::HashMap; impl Solution { pub fn next_greater_element(nums1: Vec, nums2: Vec) -> Vec { - let mut map = HashMap::new(); - let mut stack = Vec::new(); - for num in nums2 { - while num > *stack.last().unwrap_or(&i32::MAX) { - map.insert(stack.pop().unwrap(), num); - } - stack.push(num); - } - nums1 - .iter() - .map(|n| *map.get(n).unwrap_or(&-1)) - .collect::>() - } -} -``` - -#### JavaScript - -```js -/** - * @param {number[]} nums1 - * @param {number[]} nums2 - * @return {number[]} - */ -var nextGreaterElement = function (nums1, nums2) { - let stk = []; - let m = {}; - for (let v of nums2) { - while (stk && stk[stk.length - 1] < v) { - m[stk.pop()] = v; - } - stk.push(v); - } - return nums1.map(e => m[e] || -1); -}; -``` - - - - - - - -### Solution 2 - - - -#### Python3 - -```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 - -```java -class Solution { - public int[] nextGreaterElement(int[] nums1, int[] nums2) { - Deque stk = new ArrayDeque<>(); - Map m = new HashMap<>(); - for (int i = nums2.length - 1; i >= 0; --i) { - while (!stk.isEmpty() && stk.peek() <= nums2[i]) { - stk.pop(); + let mut stk = Vec::new(); + let mut d = HashMap::new(); + for &x in nums2.iter().rev() { + while let Some(&top) = stk.last() { + if top <= x { + stk.pop(); + } else { + break; + } } - if (!stk.isEmpty()) { - m.put(nums2[i], stk.peek()); + if let Some(&top) = stk.last() { + d.insert(x, top); } - 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; - } -} -``` - -#### C++ - -```cpp -class Solution { -public: - vector nextGreaterElement(vector& nums1, vector& nums2) { - stack stk; - unordered_map 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]); + stk.push(x); } - vector ans; - for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1); - return ans; - } -}; -``` - -#### Go - -```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 -} -``` -#### Rust - -```rust -impl Solution { - pub fn next_greater_element(nums1: Vec, nums2: Vec) -> Vec { nums1 - .iter() - .map(|target| { - let mut res = -1; - for num in nums2.iter().rev() { - if num == target { - break; - } - if num > target { - res = *num; - } - } - res - }) - .collect::>() + .into_iter() + .map(|x| *d.get(&x).unwrap_or(&-1)) + .collect() } } ``` @@ -348,18 +234,16 @@ impl Solution { * @return {number[]} */ var nextGreaterElement = function (nums1, nums2) { - let stk = []; - let m = {}; - for (let v of nums2.reverse()) { - while (stk && stk[stk.length - 1] <= v) { + const stk = []; + const d = {}; + for (const x of nums2.reverse()) { + while (stk.length && stk.at(-1) < x) { stk.pop(); } - if (stk) { - m[v] = stk[stk.length - 1]; - } - stk.push(v); + d[x] = stk.length ? stk.at(-1) : -1; + stk.push(x); } - return nums1.map(e => m[e] || -1); + return nums1.map(x => d[x]); }; ``` diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution.cpp b/solution/0400-0499/0496.Next Greater Element I/Solution.cpp index 5f7136337d3d2..9683cba75971e 100644 --- a/solution/0400-0499/0496.Next Greater Element I/Solution.cpp +++ b/solution/0400-0499/0496.Next Greater Element I/Solution.cpp @@ -2,16 +2,21 @@ class Solution { public: vector nextGreaterElement(vector& nums1, vector& nums2) { stack stk; - unordered_map m; - for (int& v : nums2) { - while (!stk.empty() && stk.top() < v) { - m[stk.top()] = v; + unordered_map d; + ranges::reverse(nums2); + for (int x : nums2) { + while (!stk.empty() && stk.top() < x) { stk.pop(); } - stk.push(v); + if (!stk.empty()) { + d[x] = stk.top(); + } + stk.push(x); } vector ans; - for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1); + for (int x : nums1) { + ans.push_back(d.contains(x) ? d[x] : -1); + } return ans; } -}; \ No newline at end of file +}; diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution.go b/solution/0400-0499/0496.Next Greater Element I/Solution.go index 7e8a40807cf0f..603aa300050a6 100644 --- a/solution/0400-0499/0496.Next Greater Element I/Solution.go +++ b/solution/0400-0499/0496.Next Greater Element I/Solution.go @@ -1,20 +1,22 @@ -func nextGreaterElement(nums1 []int, nums2 []int) []int { +func nextGreaterElement(nums1 []int, nums2 []int) (ans []int) { stk := []int{} - m := map[int]int{} - for _, v := range nums2 { - for len(stk) > 0 && stk[len(stk)-1] < v { - m[stk[len(stk)-1]] = v + d := map[int]int{} + for i := len(nums2) - 1; i >= 0; i-- { + x := nums2[i] + for len(stk) > 0 && stk[len(stk)-1] < x { stk = stk[:len(stk)-1] } - stk = append(stk, v) + if len(stk) > 0 { + d[x] = stk[len(stk)-1] + } + stk = append(stk, x) } - var ans []int - for _, v := range nums1 { - val, ok := m[v] - if !ok { - val = -1 + for _, x := range nums1 { + if v, ok := d[x]; ok { + ans = append(ans, v) + } else { + ans = append(ans, -1) } - ans = append(ans, val) } - return ans -} \ No newline at end of file + return +} diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution.java b/solution/0400-0499/0496.Next Greater Element I/Solution.java index ee2f5deb0eef6..bcb89a46277e3 100644 --- a/solution/0400-0499/0496.Next Greater Element I/Solution.java +++ b/solution/0400-0499/0496.Next Greater Element I/Solution.java @@ -1,18 +1,22 @@ class Solution { public int[] nextGreaterElement(int[] nums1, int[] nums2) { Deque stk = new ArrayDeque<>(); - Map m = new HashMap<>(); - for (int v : nums2) { - while (!stk.isEmpty() && stk.peek() < v) { - m.put(stk.pop(), v); + int m = nums1.length, n = nums2.length; + Map d = new HashMap(n); + for (int i = n - 1; i >= 0; --i) { + int x = nums2[i]; + while (!stk.isEmpty() && stk.peek() < x) { + stk.pop(); } - stk.push(v); + if (!stk.isEmpty()) { + d.put(x, stk.peek()); + } + stk.push(x); } - int n = nums1.length; - int[] ans = new int[n]; - for (int i = 0; i < n; ++i) { - ans[i] = m.getOrDefault(nums1[i], -1); + int[] ans = new int[m]; + for (int i = 0; i < m; ++i) { + ans[i] = d.getOrDefault(nums1[i], -1); } return ans; } -} \ No newline at end of file +} diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution.js b/solution/0400-0499/0496.Next Greater Element I/Solution.js index f25d539e765ce..36fc760c93de4 100644 --- a/solution/0400-0499/0496.Next Greater Element I/Solution.js +++ b/solution/0400-0499/0496.Next Greater Element I/Solution.js @@ -4,13 +4,14 @@ * @return {number[]} */ var nextGreaterElement = function (nums1, nums2) { - let stk = []; - let m = {}; - for (let v of nums2) { - while (stk && stk[stk.length - 1] < v) { - m[stk.pop()] = v; + const stk = []; + const d = {}; + for (const x of nums2.reverse()) { + while (stk.length && stk.at(-1) < x) { + stk.pop(); } - stk.push(v); + d[x] = stk.length ? stk.at(-1) : -1; + stk.push(x); } - return nums1.map(e => m[e] || -1); + return nums1.map(x => d[x]); }; diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution.py b/solution/0400-0499/0496.Next Greater Element I/Solution.py index 44040ba42ebc7..ebd8a65e04f9a 100644 --- a/solution/0400-0499/0496.Next Greater Element I/Solution.py +++ b/solution/0400-0499/0496.Next Greater Element I/Solution.py @@ -1,9 +1,11 @@ class Solution: def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]: - m = {} stk = [] - for v in nums2: - while stk and stk[-1] < v: - m[stk.pop()] = v - stk.append(v) - return [m.get(v, -1) for v in nums1] + d = {} + for x in nums2[::-1]: + while stk and stk[-1] < x: + stk.pop() + if stk: + d[x] = stk[-1] + stk.append(x) + return [d.get(x, -1) for x in nums1] diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution.rs b/solution/0400-0499/0496.Next Greater Element I/Solution.rs index 93580e00fd289..57b025735850b 100644 --- a/solution/0400-0499/0496.Next Greater Element I/Solution.rs +++ b/solution/0400-0499/0496.Next Greater Element I/Solution.rs @@ -2,17 +2,25 @@ use std::collections::HashMap; impl Solution { pub fn next_greater_element(nums1: Vec, nums2: Vec) -> Vec { - let mut map = HashMap::new(); - let mut stack = Vec::new(); - for num in nums2 { - while num > *stack.last().unwrap_or(&i32::MAX) { - map.insert(stack.pop().unwrap(), num); + let mut stk = Vec::new(); + let mut d = HashMap::new(); + for &x in nums2.iter().rev() { + while let Some(&top) = stk.last() { + if top <= x { + stk.pop(); + } else { + break; + } } - stack.push(num); + if let Some(&top) = stk.last() { + d.insert(x, top); + } + stk.push(x); } + nums1 - .iter() - .map(|n| *map.get(n).unwrap_or(&-1)) - .collect::>() + .into_iter() + .map(|x| *d.get(&x).unwrap_or(&-1)) + .collect() } } diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution.ts b/solution/0400-0499/0496.Next Greater Element I/Solution.ts index 6678ad8521b66..c77c1d2bb4240 100644 --- a/solution/0400-0499/0496.Next Greater Element I/Solution.ts +++ b/solution/0400-0499/0496.Next Greater Element I/Solution.ts @@ -1,11 +1,12 @@ function nextGreaterElement(nums1: number[], nums2: number[]): number[] { - const map = new Map(); - const stack: number[] = [Infinity]; - for (const num of nums2) { - while (num > stack[stack.length - 1]) { - map.set(stack.pop(), num); + const stk: number[] = []; + const d: Record = {}; + for (const x of nums2.reverse()) { + while (stk.length && stk.at(-1)! < x) { + stk.pop(); } - stack.push(num); + d[x] = stk.length ? stk.at(-1)! : -1; + stk.push(x); } - return nums1.map(num => map.get(num) || -1); + return nums1.map(x => d[x]); } diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution2.cpp b/solution/0400-0499/0496.Next Greater Element I/Solution2.cpp deleted file mode 100644 index 8fd148a48d791..0000000000000 --- a/solution/0400-0499/0496.Next Greater Element I/Solution2.cpp +++ /dev/null @@ -1,15 +0,0 @@ -class Solution { -public: - vector nextGreaterElement(vector& nums1, vector& nums2) { - stack stk; - unordered_map 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 ans; - for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1); - return ans; - } -}; \ No newline at end of file diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution2.go b/solution/0400-0499/0496.Next Greater Element I/Solution2.go deleted file mode 100644 index e4c138babc9d7..0000000000000 --- a/solution/0400-0499/0496.Next Greater Element I/Solution2.go +++ /dev/null @@ -1,22 +0,0 @@ -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 -} \ No newline at end of file diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution2.java b/solution/0400-0499/0496.Next Greater Element I/Solution2.java deleted file mode 100644 index fd585b1ad1a5b..0000000000000 --- a/solution/0400-0499/0496.Next Greater Element I/Solution2.java +++ /dev/null @@ -1,21 +0,0 @@ -class Solution { - public int[] nextGreaterElement(int[] nums1, int[] nums2) { - Deque stk = new ArrayDeque<>(); - Map 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; - } -} \ No newline at end of file diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution2.js b/solution/0400-0499/0496.Next Greater Element I/Solution2.js deleted file mode 100644 index 7fd49e49310dd..0000000000000 --- a/solution/0400-0499/0496.Next Greater Element I/Solution2.js +++ /dev/null @@ -1,19 +0,0 @@ -/** - * @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); -}; diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution2.py b/solution/0400-0499/0496.Next Greater Element I/Solution2.py deleted file mode 100644 index ce7da164957c2..0000000000000 --- a/solution/0400-0499/0496.Next Greater Element I/Solution2.py +++ /dev/null @@ -1,11 +0,0 @@ -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] diff --git a/solution/0400-0499/0496.Next Greater Element I/Solution2.rs b/solution/0400-0499/0496.Next Greater Element I/Solution2.rs deleted file mode 100644 index 8ac2d1be7f398..0000000000000 --- a/solution/0400-0499/0496.Next Greater Element I/Solution2.rs +++ /dev/null @@ -1,19 +0,0 @@ -impl Solution { - pub fn next_greater_element(nums1: Vec, nums2: Vec) -> Vec { - nums1 - .iter() - .map(|target| { - let mut res = -1; - for num in nums2.iter().rev() { - if num == target { - break; - } - if num > target { - res = *num; - } - } - res - }) - .collect::>() - } -}