LeeCode 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) 的解决方案吗？

答案&测试代码：

cpp 复制代码

void testLeeCode496(void) { // LeeCode496.下一个更大元素I
    class Solution {
        public:
            vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
                // 用于存储 nums2 中每个元素的下一个更大元素
                unordered_map<int, int> nextGreaterNumMap;

                // 单调递减栈，存储元素值。 循环nums2的过程中，会把这个数暂时放入栈中。当后面找到答案时会弹出栈中。
                stack<int> stk;

                // 遍历 nums2，构建映射关系
                for (int num : nums2) {
                    // 当栈不为空，且当前元素大于栈顶元素时
                    // 说明当前元素是栈顶元素的"下一个更大元素"
                    while (!stk.empty() && num > stk.top()) {
                        int topVal = stk.top();
                        stk.pop();
                        nextGreaterNumMap[topVal] = num;
                    }
                    // 将当前元素压入栈。栈中的元素都是等待找到答案的。
                    stk.push(num);
                }

                vector<int> res(nums1.size(), -1);

                for (int i = 0; i < nums1.size(); ++i) {
                    // 如果 nums1[i] 在 Map 中有记录，说明它找到了下一个更大元素
                    // 如果没有记录，ans[i] 保持默认的 -1
                    if (nextGreaterNumMap.count(nums1[i])) {
                        res[i] = nextGreaterNumMap[nums1[i]];
                    }
                }

                return res;
            }
    };

    // test
    vector<int> nums1{4, 1, 2};
    vector<int> nums2{1, 3, 4, 2};
    Solution solution;
    vector<int> res = solution.nextGreaterElement(nums1, nums2);
    printf("结果:\n");
    for (int n : res) {
        printf("%d ", n);
    }
}

运行：

提交到LeeCode：

ok. 单调栈维护栈内元素的单调性‌（单调递增或单调递减）,主要用于解决‌"寻找最近的一个更大/更小元素"‌这类问题。