Leetcode 334 递增的三元子序列

题目链接：334. 递增的三元子序列

给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。

如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。

输入：nums = [2,1,5,0,4,6]
输出：true
解释：三元组 (3, 4, 5) 满足题意，因为 nums[3] == 0 < nums[4] == 4 < nums[5] == 6
 

提示：

1 <= nums.length <= 5 * 10^5
-2^31 <= nums[i] <= 2^31 - 1

题解：

1. 常规暴力枚举 i, j, k,三个嵌套循环，判断 nums[i] < nums[j] < nums[k]，时间复杂度 O（n^3）

2.使用单调栈处理，时间复杂度 O（n），空间复杂度O（n）, 单调栈没有接触过的，可以去搜一下看看

        栈里面维护一个键值对pair<int, int> ,第一个int是数组下标，第二个int是数组对应的值

        首先从左往右遍历数组，维护一个单调递减的栈， 可以得到每一个位置 i ，右侧是否有比它值大的，如果有mCount数组值加一。 

        然后从右往左遍历数组，维护一个单调递增的栈， 可以得到每一个位置 i ，左侧是否有比它值小的，如果有mCount数组值加一。

         最后遍历mCount数组，是否有值等于2，有，说明有这样的三元数值队

class Solution {
public:
    bool increasingTriplet(vector<int>& nums) {
        vector<int> mCount(nums.size());
        stack<pair<int,int>> mStack;
        for(int i = 0; i < nums.size(); ++i){
            while(!mStack.empty() && mStack.top().second < nums[i]){
                ++mCount[mStack.top().first];
                mStack.pop();
            }
            mStack.push(make_pair(i, nums[i]));
        }

        while(mStack.size())
            mStack.pop();

        for(int i = nums.size() - 1; i >= 0; --i){
            while(!mStack.empty() && mStack.top().second > nums[i]){
                ++mCount[mStack.top().first];
                mStack.pop();
            }
            mStack.push(make_pair(i, nums[i]));
        }
        for(auto count : mCount){
            if(count == 2)
                return true;
        }
        return false;
    }
};

3.大概思路，从左往右遍历数组，遍历的过程中维护一个最小值firstVal，首先找到第一个比 firstVal大的值记录到 secondVal 中，然后继续往后遍历，判断如果当前值 curVal 比 minVal 大， 然后再与sminVal比较大小，如果比sminVal 大 说明找到了一组，如果小于等于sminVal, 则更新sminVal=curVal, 继续遍历处理。时间复杂度O（n）,空间复杂度O（1）

for   循环遍历nums数组中的 {

        1. 如果 curVal 大于 firstVal

                如果secondVal 未初始化，设置secondVal = curVal, 找到一个二元数值对（firstVal, secondVal）

                如果secondVal已经初始化，判断 curVal 与 secondVal 大小关系，如果 curVal > secondVal, 找到了一个三元数值对（firstVal, secondVal, curVal）,结束；如果 curVal <= secondVal, 设置secondVal = curVal,  二元数值对得到更新（firstVal, secondVal），secondVal 是以往找到的二元数值队中值最小的一个

        2. 维护当前最小值firstVal

}

class Solution {
public:
    bool increasingTriplet(vector<int>& nums) {
        if(nums.size() >= 3){
            //bFind 是否找到一个严格递增数值对，firstVal 当前已经遍历过的最小值，secondVal 记录比 firstVal 大的值
            bool bFind = false;
            int firstVal = nums[0];
            int secondVal = -1;

            for(auto & curVal : nums){
                if(curVal > firstVal){
                    if(bFind){
                        if(curVal > secondVal)
                            return true;
                        secondVal = curVal;
                    }
                    else{
                        bFind = true;
                        secondVal = curVal;
                    }
                }
                //维护最小值
                if(firstVal > curVal)
                    firstVal = curVal;
            }
        }
        
        return false;
    }
};