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

public int[] nextGreaterElement(int[] nums1, int[] nums2) {
    //nums1是nums2的子集，我们可以先生成一个数组保存nums2每个对应元素右侧首个比他大的值
    //我们遍历数组，一旦遇上不单调递减的元素就一定求得某部分元素的结果，去掉这些有结果的元素
    // 此时队列还是单调非递减----想到了单调递减栈：求附近最值问题，每次pop出去的元素的右侧首个更大值就是此时要入栈的元素，
    // 最终如果栈中还有元素，那么他们右侧没有更大值，置为-1--这部分是O(N)

    //还需要找到nums1元素在nums2中的位置，可以用map
    HashMap<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums2.length; i++) {
        map.put(nums2[i], i);
    }

    ArrayDeque<Integer> stack = new ArrayDeque<>();
    int[] arr = new int[nums2.length];
    int[] res = new int[nums1.length];
    for (int i = 0; i < nums2.length; i++) {
        while (!stack.isEmpty() && nums2[stack.peek()] < nums2[i]){
            Integer pop = stack.pop();
            arr[pop] = nums2[i];
        }
        stack.push(i);
    }
    while (!stack.isEmpty()){
        Integer pop = stack.pop();
        arr[pop] = -1;
    }
    for (int i = 0; i < nums1.length; i++) {
        res[i] = arr[map.get(nums1[i])];
    }
    return res;
}