Leetcode.334. 递增的三元子序列__从暴力到贪心/双向查找

334. 递增的三元子序列

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

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

示例 1：

输入：nums = [1,2,3,4,5]
输出：true
解释：任何 i < j < k 的三元组都满足题意
示例 2：

输入：nums = [5,4,3,2,1]
输出：false
解释：不存在满足题意的三元组
示例 3：

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

提示：

1 <= nums.length <= 5 * 105
-231 <= nums[i] <= 231 - 1

思考1：暴力

• 最直观的做法肯定是直接三个for暴力查找，但会超时；

/*通过32*/
class Solution {
    public boolean increasingTriplet(int[] nums) {
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                for(int k=j+1;k<nums.length;k++){
                    if(nums[i] < nums[j] && nums[j] < nums[k]){
                        return true;
                    }
                }
            }
        }

        return false;
    }
}

思考2：稍微优化暴力

• 即在进入第三层for时先判断一下，并且先用一个集合Set对nums数组进行去重，看去重后的集合大小是否大于3；

class Solution {
    public boolean increasingTriplet(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for(int num : nums){
            set.add(num);
        }
        if(set.size()<3){
            return false;
        }
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i] >= nums[j]){
                    continue;
                }
                for(int k=j+1;k<nums.length;k++){
                    if(nums[i] < nums[j] && nums[j] < nums[k]){
                        return true;
                    }
                }
            }
        }

        return false;
    }
}

思考3：贪心思想（部分贪心）

我们可以定义两个指针，用来指向三元子序列的前两个元素，第一个元素为pre指向，第二个元素为mid指向。
明确在哪里贪心：

• 为了能够找到递增的三元子序列，我们一定希望三元子序列的最左方元素pre尽可能的又小又靠左边，因此我们遍历nums开始找第一个元素，我们初始将pre指向nums的第一个元素，接着在mid没有指向的情况下，一旦碰到小于pre的，我们就更改pre指向这个更小的元素（因为此时的元素更小，且由于左方此时也没有确定mid指向，因此不会因为此时这个指向的改变而错失找到递增的三元子序列的机会）；
• 如果碰到大于pre的元素，我们就先将mid指向它，接着判断一下在此时这个mid和pre的情况下，我们能否找到最后一个元素使其符号题意，如果找到了直接返回true，否则将mid归位继续寻找；

class Solution {
    public boolean increasingTriplet(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for(int num : nums){
            set.add(num);
        }
        if(set.size()<3){
            return false;
        }
        int pre = -1;
        int mid = -1;
        for(int i=0;i<nums.length;i++){
            if(i==0){
                pre = i;
                continue;
            }
            if(pre!=-1 && mid==-1 &&nums[i]>nums[pre]){
                mid = i;
                for(int j=mid+1;j<nums.length;j++){
                    if(nums[j] > nums[mid] && nums[mid] > nums[pre]){
                        return true;
                    }
                }
                mid = -1;
            }
            else if(nums[i] <= nums[pre] && mid==-1){
                pre = i;
            }
        }

        return false;
    }
}

思考四：贪心思想（完全贪心）

其实再度理解题目发现，我们只是要寻找看有没有这个递增三元子序列，因此我们不必真正的去维护一个递增三元子序列，只要能够判断有无即可。

且如果设置两个指针指向前两个元素，首先根据部分贪心思想确定好pre后，根据pre我们能确定一个mid，而在mid确定完毕后，其实pre就被解放了出来，因此我们可以继续先用pre进行”探路“，看是否有更小的元素作为pre，有就保存起来，而mid因为也被确定了，所以一旦碰到大于mid的直接返回true即可，且pre在保存新的元素后同样会对mid进行一个更新。因此这里其实相当于保存了两个状态，一前一后，一老一旧进行逐步查找，因此刚好不会漏掉所有可能的情况。

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int pre = Integer.MAX_VALUE;
        int mid = Integer.MAX_VALUE;

        for(int num : nums){
            if(num <= pre){
                pre = num;
            }else if(num <= mid){
                mid = num;
            }else{
                return true;
            }
        }

        return false;
    }
}

思考5：双向查找

• 我们只要能够得到任意一个元素的左边的最小元素和右边的最大元素，那么就可以与他们进行比较来直接判断能否形成递增三元子序列。

class Solution {
    public boolean increasingTriplet(int[] nums) {
        if (nums.length < 3) {
            return false;
        }

        int[] lMin = new int[nums.length];  //左边的最小
        int[] rMax = new int[nums.length];  //右边的最大

        lMin[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            lMin[i] = Math.min(lMin[i-1], nums[i]);
        }
    
        rMax[nums.length-1] = nums[nums.length-1];
        for(int i=nums.length-2;i>=0;i--) {
            rMax[i] = Math.max(rMax[i+1], nums[i]);
        }
        for(int i=1;i<nums.length-1;i++) {
            if(nums[i]>lMin[i-1] && nums[i] < rMax[i+1]) {
                return true;
            }
        }
        return false;
    }
}