496. Next Greater Element I

You are given two arrays (without duplicates) nums1 and nums2 where nums1’s elements are subset of nums2. Find all the next greater numbers for nums1’s elements in the corresponding places of nums2.

The Next Greater Number of a number x in nums1 is the first greater number to its right in nums2. If it does not exist, output -1 for this number.

Example 1:

Input: nums1 = [4,1,2], nums2 = [1,3,4,2].
Output: [-1,3,-1]
Explanation:
    For number 4 in the first array, you cannot find the next greater number for it in the second array, so output -1.
    For number 1 in the first array, the next greater number for it in the second array is 3.
    For number 2 in the first array, there is no next greater number for it in the second array, so output -1.

Example 2:

Input: nums1 = [2,4], nums2 = [1,2,3,4].
Output: [3,-1]
Explanation:
    For number 2 in the first array, the next greater number for it in the second array is 3.
    For number 4 in the first array, there is no next greater number for it in the second array, so output -1.

Note:

1. All elements in nums1 and nums2 are unique.
2. The length of both nums1 and nums2 would not exceed 1000.

思路： 一开始没思路，写了三层for循环，第一层循环findNums，第二层找nums里与findNums相等的位置，第三层找第一个greater值。O(n3)可能会超时吧，代码如下：

class Solution(object):

    def nextGreaterElementOn3(self, findNums, nums):
        arr = []
        for i in findNums:
            length = len(nums)
            for j in range(0, length):
                if i == nums[j]:
                    for k in range(j, length):
                        if nums[k] > i:
                            arr.append(nums[k])
                            break            
                        if k == length - 1:
                            arr.append(-1)
                            break
        return arr 

看了博客。大神们的思路是，构建一个栈，用来存储nums里的元素。当遍历nums时，如果当前元素大于栈顶，则出栈直到栈顶大于等于当前元素或栈为空。对于出栈的每个元素，用一个map记录元素与greater的映射对，（python里是dict），按照大神们的思路重写一下：

class Solution(object):
    def nextGreaterElement(self, findNums, nums):
        """
        :type findNums: List[int]
        :type nums: List[int]
        :rtype: List[int]
        """
        if not findNums or not nums:
            return []

        dict = {}
        stack = []
        stack.append(nums[0])
        size = len(nums)
        for i in range(1, size):
            while len(stack) > 0 and nums[i] > stack[len(stack) - 1]:
                dict[stack.pop()] = nums[i]
            stack.append(nums[i])

        arr = []
        for i in findNums:
            if i in dict.keys():
                arr.append(dict.get(i))          
            else:
                arr.append(-1)    
        return arr 

比刚刚快了一点，因为只需遍历一遍nums即可，减少了一层循环。但是时间上还是不理想。
随后看了大神的代码，同样的思路也是Python写的，简短了许多。

class Solution(object):
    def nextGreaterElement(self, findNums, nums):
        """
        :type findNums: List[int]
        :type nums: List[int]
        :rtype: List[int]
        """
        d = {}
        st = []
        ans = []

        for x in nums:
            while len(st) and st[-1] < x:
                d[st.pop()] = x
            st.append(x)

        for x in findNums:
            ans.append(d.get(x, -1))
        return ans

看看人家的时间，深深地受挫中。。。