【LeetCode】496. 下一个更大元素 I（简单）——代码随想录算法训练营Day58

题目链接：496. 下一个更大元素 I

题目描述

nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。

给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。

示例 1：

输入：nums1 = [4,1,2], nums2 = [1,3,4,2].
输出：[-1,3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：
- 4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
- 1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。
- 2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。

示例 2：

输入：nums1 = [2,4], nums2 = [1,2,3,4].
输出：[3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：
- 2 ，用加粗斜体标识，nums2 = [1,2,3,4]。下一个更大元素是 3 。
- 4 ，用加粗斜体标识，nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1 。

提示：

• 1 <= nums1.length <= nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 104
• nums1和nums2中所有整数 互不相同
• nums1 中的所有整数同样出现在 nums2 中

进阶：你可以设计一个时间复杂度为 O(nums1.length + nums2.length) 的解决方案吗？

文章讲解：代码随想录

视频讲解：单调栈，套上一个壳子就有点绕了| LeetCode:496.下一个更大元素_哔哩哔哩_bilibili

题解1：暴力法

思路：使用哈希表存储 nums1 中的元素及其下标，然后双层 for 循环遍历 nums2 找出存在于 nums1 中的元素并找出其下一个更大元素。

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var nextGreaterElement = function(nums1, nums2) {
    const res = [];
    const map = nums1.reduce((pre, item, index) => (pre[item] = index) >= 0 && pre, {});
    for (let i = 0; i < nums2.length; i++) {
        if (map[nums2[i]] !== undefined) {
            let temp = -1;
            for (let j = i + 1; j < nums2.length; j++) {
                if (nums2[j] > nums2[i]) {
                    temp = nums2[j];
                    break;
                }
            }
            res[map[nums2[i]]] = temp;
        }
    }
    return res;
};

分析：时间复杂度为 O(n²)，空间复杂度为 O(n)。

题解2：单调栈

思路：使用哈希表存储 nums1 中的元素及其下标，遍历 nums2 并构建一个从栈底到栈顶单调递减的栈，弹出元素时判断此元素是否在 nums1 中，如果在则收集答案。

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var nextGreaterElement = function(nums1, nums2) {
    const res = [];
    let stack = [];
    const map = nums1.reduce((pre, item, index) => (pre[item] = index) >= 0 && pre, {});
    for (let i = 0; i < nums2.length; i++) {
        while (stack.length > 0 && nums2[stack[stack.length - 1]] < nums2[i]) {
            const index = stack.pop();
            if (map[nums2[index]] !== undefined) {
                res[map[nums2[index]]] = nums2[i];
            }
        }
        stack.push(i);
    }
    while (stack.length > 0) {
        res[map[nums2[stack.pop()]]] = -1;
    }
    return res;
};

分析：时间复杂度为 O(m + n)，空间复杂度为 O(m + n)。

收获

练习使用单调栈求解问题的思路，熟悉单调栈的使用场景。