739. Daily Temperatures 496. Next Greater Element I

739. Daily Temperatures

Given an array of integers temperatures represents the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the ith day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead.

 Using stack[-1] not direct using stack. pop()

Monotonic stack:

Time complexity: O(n)

Space complexity: O(n)

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        result = [0] * len(temperatures)
        stack = []

        for i in range(len(temperatures)):
            if not stack:
                stack.append(i)    
            else:
                while stack and temperatures[i] > temperatures[stack[-1]]:  #必须要加前面stack的判断，因为if只能保证第一次不为空
                    pre = stack.pop()
                    result[pre] = i - pre 
                stack.append(i)

        return result

optimal:

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        answer = [0]*len(temperatures)
        stack = []
        for i in range(len(temperatures)):
            while stack and temperatures[i] > temperatures[stack[-1]]:
                answer[stack[-1]] = i - stack[-1]
                stack.pop()
            stack.append(i)
        return answer

violent:

Time complexity: O(n^2)

Space complexity: O(n)

omit

496. Next Greater Element I

The next greater element of some element x in an array is the first greater element that is to the right of x in the same array.

You are given two distinct 0-indexed integer arrays nums1 and nums2, where nums1 is a subset of nums2.

For each 0 <= i < nums1.length, find the index j such that nums1[i] == nums2[j] and determine the next greater element of nums2[j] in nums2. If there is no next greater element, then the answer for this query is -1.

Return an array ans of length nums1.length such that ans[i] is the next greater element as described above.

Monotonic stack:

Time complexity: O(n)

Space complexity O(m)

During the traversal of nums2, we have to determine whether nums2[i] has appeared in nums1 or not, because in the end, it is the subscripts of the elements of nums1 that have to be used to update the results array.

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        result = [-1]*len(nums1)
        stack = [0]
        for i in range(1,len(nums2)):
            # 情况一情况二
            if nums2[i]<=nums2[stack[-1]]:
                stack.append(i)
            # 情况三
            else:
                while len(stack)!=0 and nums2[i]>nums2[stack[-1]]:
                    if nums2[stack[-1]] in nums1:
                        index = nums1.index(nums2[stack[-1]])
                        result[index]=nums2[i]
                    stack.pop()                 
                stack.append(i)
        return result

stack + hashmap:

Time complexity: O(n)

Space complexity: O(m + n)

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        stack = []
        hashmaps = dict() # {}
        for num in nums2:
            while stack and num > stack[-1]:
                tmp = stack.pop()
                hashmaps[tmp] = num
            stack.append(num)
        res = []
        for num in nums1:
            res.append(hashmaps.get(num,-1))
        return res