leetcode——132模式（单调栈）+疯狂补丁

---

前言

这道题我做的就是修修补补，其实就算我的第二个解法最后通过了101个测试例子，但是我还是怀疑是有bug的。
这个代码反复提交了有14遍，针对遇到的不同的问题，我在代码上打了有针对性的补丁，完整直接的思路是没有的。

---

欢迎各位大佬来找bug。。。。。。小弟求之不得，铭感五内

一、题目是什么？

题目点击这里

二、使用步骤

1.第一种极其暴力的解法

人家别人的暴力解法是o（n^2），我直接三个for循环，很快的，都不带动脑子……
代码如下：

class Solution {
public:
    bool find132pattern(vector<int>& nums) {
    int n=nums.size();
    if(n<3) return false;
    for(int i=0;i<n;i++){
        if(i+1<n){
            for(int j=i+1;j<n;j++){
            if(nums[i]<nums[j]){
                if(j+1<n){
                 for(int k=j+1;k<n;k++){
                 if(nums[i]<nums[k]&&nums[k]<nums[j])
                  return true;
                }
                }
            }
          
        }

        }
       
    }
    return false;
    }
};

提交的过程中，超时了，这大概是一个o（n^3）的解法，不过我觉得正确性是没什么可质疑的，简单直接

2.修修补补的第二个解法

代码如下：

class Solution {
public:
    bool find132pattern(vector<int>& nums) {
    int n=nums.size();
    if(n<3) return false;
    int i=0,temp;
    stack<int>s;
    s.push(nums[i]);
    i++;
    int front=nums[0];
    while(i<n&&!s.empty()){
        if(i==n-1){//n-1特殊情况，后面没有可以比较的元素了
            if(nums[i]>=s.top()) return false;
            else{
                while(!s.empty()&&nums[i]<=s.top()){
                    s.pop();
                }
                if(s.empty()) return false;
                else return true;
            }
        }
        if(i<n-1){//大餐开始了
            if(nums[i]>=s.top()) {
            s.push(nums[i]);
            i++;//维护一个单调递增的栈
            }
            else{//如果出现一个比栈顶元素小的元素
                temp=i;
                while(i<n-1&&nums[i]<nums[i+1]&&i<n-1){//判断另一个单调栈，
                    if(nums[i+1]<s.top()){
                        i++;
                    }
                    else{
                        break;
                    }
                }
                //单调不下去了
                if(i<n-1&&nums[i]>=nums[i+1]){
                    for(int j=i;j<n;j++){
                        if(nums[j]<s.top()&&nums[j]>front)
                         return true;
                    }
                }
                //出来有两种可能，一种i=n-1，一种比top（）大了
                while(!s.empty()&&s.top()>=nums[i]){
                    s.pop();
                }
                if(!s.empty()) return true;
                else{
                    front=nums[temp];
                    for(int j=temp;j<=i;j++)
                    s.push(nums[j]);
                    i++;
                }
            }
        }   

    }
    return false;

    
    }



};

先说说大概思路吧：

维护一个单调递增的栈s，相当于认为栈底 的是1，栈顶的是3，然后一旦遇到比3小的数（单调性被打破），执行以下操作：

从当前数开始，记最后找的元素为key，相当于维护了另一个隐形的单调递增的栈，分为3种情况：

1、一直单调递增到n-1，也就是尾端元素。这个时候啥也不说了，将key与栈内元素比较即可

2、单调递增到了一个比top大的元素那里，这个时候，这个元素之前的，就是key，将它和栈里面的元素比较。
如果符合132模式，返回；否则，将这个隐形的单调栈压栈。

3、他不单调了，这个就比较麻烦了，这个我一开始没怎么细想，结果出bug了……
出问题的测试例子是这个：[10,12,6,8,3,11]`。

我针对这个例子想了一个暴力方法：就是把top之后的元素，挨个与栈里面的1、3进行比较，看看存不存在132模式，如果存在，皆大欢喜；如果不存在，执行2操作。

---

3、官方解法

官方解法。。。

总结

有几个小技巧：
1、多个判断条件，把判断合法类型的放在前面。
不然容易出错，例如

 while(!s.empty()&&s.top()>=nums[i])
 
 if(i<n-1&&nums[i]>=nums[i+1])

判断栈是否为空，数组角标是否越界这种合法性方面的条件放在前面。如果顺序颠倒，会出现bug，我就吃了好几次这样的亏。

2、不知道大家怎么样，反正我找边界条件其实很费劲，那种合法性的啊，n-1，n-2这种其实一开始我根本想不到，都是测试的时候发现了问题，之后慢慢加的。。。但是我觉得这些条件也很重要。