单调栈 739. 每日温度 496. 下一个更大元素 I II III

栈具有先进后出的性质，单调栈就是利用一些巧妙的逻辑，使得栈内的元素都保持有序（单调递增或单调递减）

739. 每日温度

根据每日气温 列表，请重新生成一个列表，对应位置的输出是需要再等待多久温度才会升高超过该日的天数。
如果之后都不会升高，请在该位置用 0 来代替。
例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。
提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

解题思路

维护递减栈，后入栈的元素总比栈顶元素小。比对当前元素与栈顶元素的大小

• 若当前元素 < 栈顶元素：入栈
• 若当前元素 > 栈顶元素：弹出栈顶元素，记录两者下标差值即为所求天数

class Solution:
    def dailyTemperatures(self, T: List[int]) -> List[int]:
        res = [0] * len(T)
        min_stack = [] # 最小栈，维持一个递减的栈 ，栈记录的是天数
        for i in range(len(T)):
	        # 如果栈不为空，且当前元素大于栈顶元素
            while min_stack!=[] and T[i]>T[min_stack[-1]]:
                idx = min_stack.pop()
                res[idx] = i - idx 

            min_stack.append(i)

        return res

用栈记录天数和当天的气温

class Solution(object):
    def dailyTemperatures(self, T):
        """
        :type T: List[int]
        :rtype: List[int]
        """
        if len(T)==1:
            return [0]
        res = [0] * len(T)
        min_stack = [] # 最小栈，维持一个递减的栈
        for i in range(len(T)):
            if min_stack==[] or T[i]<=min_stack[-1][1]:
                min_stack.append((i, T[i]))

            else:
                while min_stack!=[] and T[i]>min_stack[-1][1]:
                    temp = min_stack.pop()
                    res[temp[0]] = i - temp[0]

                min_stack.append((i, T[i]))

        return res

496. 下一个更大元素 I

给定两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。
nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。
示例 1:
输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
    对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
    对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
    对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。
示例 2:
输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
    对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
    对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。
提示：
nums1和nums2中所有元素是唯一的。
nums1和nums2 的数组大小都不超过1000。

解题思路

先单独处理nums2，将nums2中每一个数的下一个最大元素都找出来，用哈希表保存；
然后对于nums1中的每一个元素再在哈希表中找对应的，不存在的就为-1

# 复杂版
class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        res = [-1] * len(nums1) 
        stack_map = {}
        stack = []
        for i in range(len(nums2)):
            if stack==[] or nums2[i]<=stack[-1]:
                stack.append(nums2[i])
            else:
                while stack!=[] and nums2[i]>stack[-1]:
                    temp = stack.pop()
                    stack_map[temp] = nums2[i]
                stack.append(nums2[i])

        for i in range(len(nums1)):
            if nums1[i] in stack_map:
                res[i] = stack_map[nums1[i]]

        return res

# 精简版
class Solution(object):
    def nextGreaterElement(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        stack, hash_map = [], {}
        for n in nums2:
            while stack!=[] and stack[-1]<n:
                hash_map[stack.pop()] = n 

            stack.append(n)
        return [hash_map.get(x, -1) for x in nums1]

503. 下一个更大元素 II

给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。
数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，
这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。
示例 1:
输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

解题思路

将两个数组拼接起来，其余地和前面一样

class Solution(object):
    def nextGreaterElements(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        单调栈
        """
        res = [-1] * len(nums)
        n = len(nums) 
        nums += nums
        min_stack = []
        for i in range(len(nums)):
            if min_stack==[] and i>=n:
                break
            while min_stack!=[] and nums[min_stack[-1]]<nums[i]:
                res[min_stack.pop()] = nums[i]

            # 如果这个还是第一个数组中的元素就可以入栈
            if i<n:
                min_stack.append(i)

        return res

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int len_num = nums.size();
        vector<int> res(len_num, -1);
        // nums.insert(nums.end(), nums.begin(), nums.end());
        vector<int> min_stack;
        for (int i=0; i<len_num*2; ++i) {
        	// 不用拼接数组，直接取余也可以
            while (!min_stack.empty() && nums[min_stack.back()]<nums[i%len_num]) {
                res[min_stack.back()] = nums[i%len_num];
                min_stack.pop_back();
            }
            if (i<len_num) min_stack.push_back(i);
        }
        return res;
    }
};

556. 下一个更大元素 III

给定一个32位正整数 n，你需要找到最小的32位整数，其与 n 中存在的位数完全相同，并且其值大于n。
如果不存在这样的32位整数，则返回-1。
示例 1:
输入: 12
输出: 21
示例 2:
输入: 21
输出: -1

解题思路

• 先从右往左遍历 找到第一个不是顺序排列的数字,而不是第一个比最右的数小的数，将所有顺序排列的都放到栈中。
• 找到了这个数之后再在栈中遍历,找到第一个比这个数大的数与其交换。

class Solution(object):
    def nextGreaterElement(self, n):
        """
        :type n: int
        :rtype: int
        """
        nums = list(map(int, str(n)))
        stack = [nums.pop()]
        # 从右往左找升序,
        while nums and stack[-1] <= nums[-1]:
            stack.append(nums.pop())
        if not nums: return -1
        i = len(nums)-1
        # 直到找到 第一个大于i的元素
        # print(stack)
        for j in range(len(stack)):
            if stack[j] > nums[-1]:
                stack[j], nums[-1] = nums[-1], stack[j]
                break
        nums += stack
        res = "".join(map(str,nums))
        return -1 if int(res)>(1<<31)-1 else res