leetcode 高效制胜5 堆栈

20. 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例 1：

输入：s = “()”
输出：true
示例 2：

输入：s = “()[]{}”
输出：true
示例 3：

输入：s = “(]”
输出：false
示例 4：

输入：s = “([)]”
输出：false
示例 5：

输入：s = “{[]}”
输出：true

提示：

1 <= s.length <= 104
s 仅由括号 ‘()[]{}’ 组成

class Solution {
public:
    bool isValid(string s) {
        stack<char> Stack;
        for(int i=0;i<s.size();i++){
            if(s[i]=='('||s[i]=='['||s[i]=='{'){
                Stack.push(s[i]);
            }else if(s[i]==')'){
                if(!Stack.empty()&&Stack.top()=='('){
                    Stack.pop();
                }else return false;
            }else if(s[i]==']'){
                if(!Stack.empty()&&Stack.top()=='['){
                    Stack.pop();
                }else return false;
            }else{
                if(!Stack.empty()&&Stack.top()=='{'){
                    Stack.pop();
                }else return false;
            }
        }
        return Stack.empty();
    }
};

1. 括号匹配是使用栈解决的经典问题

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 。

提示：

1 <= nums1.length <= nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 104
nums1和nums2中所有整数 互不相同
nums1 中的所有整数同样出现在 nums2 中

进阶：你可以设计一个时间复杂度为 O(nums1.length + nums2.length) 的解决方案吗？

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int>nextNums(10001,-1);
        stack<int>stack;

        int n=nums2.size();
        stack.push(nums2[n-1]);
        for(int i=n-2;i>=0;i--){
            while(!stack.empty()&&nums2[i]>stack.top()){
                stack.pop();
            }
            if(!stack.empty())nextNums[nums2[i]]=stack.top();
            stack.push(nums2[i]);
        }
        for(int i=0;i<nums1.size();i++){
            nums1[i]=nextNums[nums1[i]];
        }
        return nums1;
    }
};

1. 感觉这个题有点意思
2. 可以用哈希优化一下空间
3. 我是反着写的，正着写也可以。都是递减序列

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> myStack;             //单调栈
        unordered_map<int, int> myMap;  //哈希
        for(auto num: nums2){
            while(!myStack.empty() && num > myStack.top()){  //如果当前栈顶比它小
                myMap[myStack.top()] = num;    //栈顶元素右边第一个大的元素就是它
                myStack.pop();                 //把栈顶弹走
            }
            myStack.push(num);       //加入栈，等待一个比它大的元素把它弹走
        }
        for(auto &num: nums1){          //遍历nums1
            auto it = myMap.find(num);
            num = it == myMap.end() ? -1 : it->second; //把nums1换成对应元素
        }
        return nums1;
    }
};

作者：MGA_Bronya
链接：https://leetcode-cn.com/problems/next-greater-element-i/solution/496-xia-yi-ge-geng-da-yuan-su-i-ha-xi-da-9r6t/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

456. 132 模式（！！！）

给你一个整数数组 nums ，数组中共有 n 个整数。132 模式的子序列 由三个整数 nums[i]、nums[j] 和 nums[k] 组成，并同时满足：i < j < k 和 nums[i] < nums[k] < nums[j] 。

如果 nums 中存在 132 模式的子序列 ，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [1,2,3,4]
输出：false
解释：序列中不存在 132 模式的子序列。
示例 2：

输入：nums = [3,1,4,2]
输出：true
解释：序列中有 1 个 132 模式的子序列： [1, 4, 2] 。
示例 3：

输入：nums = [-1,3,2,0]
输出：true
解释：序列中有 3 个 132 模式的的子序列：[-1, 3, 2]、[-1, 3, 0] 和 [-1, 2, 0] 。

提示：

n == nums.length
1 <= n <= 2 * 105
-109 <= nums[i] <= 109

class Solution {
public:
    bool find132pattern(vector<int>& nums) {
        stack<int> myStack;
        
        int k=INT_MIN;
        for(int i=nums.size()-1;i>=0;i--){
            if(nums[i]<k)return true;
            while(!myStack.empty()&&nums[i]>myStack.top()){
                if(k<myStack.top()){
                    k=myStack.top();
                }
                myStack.pop();
            }
            myStack.push(nums[i]);
        }
        

        return false;
    }
};

2. 单调栈，单调栈，单调，怎么把数据搞得单调就是解题的关键了
3. 上面的解法是先利用从后往前单调递减，得到(j,k)，并得到小于j的最大的数k。然后找i就只需要和k比较了，所以k越大越好。

枚举j的

class Solution {
public:
    bool find132pattern(vector<int>& nums) {
        vector<int> mi;
        stack<int> stk;
        // mi 维护 nums[i] 左侧的最小值
        // mi 是有单调性的，只减不增
        for(int i = 0; i < nums.size(); i++)
        {
            if(!i)mi.push_back(nums[i]);
            else mi.push_back(min(nums[i],mi[i-1]));
        }
        // stk 维护 nums[i] 右侧比 mi[i] 大的值
        for(int i = nums.size()-1; i >= 0; i--) {
            if(nums[i] > mi[i]) {
                // 先在nums[i]的右边找到一个比mi[i]大的元素
                // 如果栈顶比m[i]小，之后肯定也不会再用到了，所以丢掉
                // (因为mi往左走肯定越来越大)
                // 为什么栈是从左到右单调递增的：
                // 栈顶坐标 > i，mi[i]坐标小于 i，如果i的值比栈顶大，
                // 那直接就返回了
                while(stk.size() && stk.top() <= mi[i])
                    stk.pop();
                // 比较它与nums[i]的大小
                if(stk.size()&&stk.top()<nums[i])return  true;
                stk.push(nums[i]);
            }
        }
        return false;
    }
};