递增的三元子序列------2023/02/14

题目描述

递增的三元子序列

解题思路

错误思路：从实例中以为是连续的三个数成递增序列。此时思路，只要当前的数与前后数进行比较，满足递增关系即可。
关键点：如何跳出当前点与前后关系的判断。不断更新最小值和次小值？？

正确思路：使用暴力方法，严格使得下标成递增坐标，再考虑相对应的值是否递增，但是这也会出现时间限制。

优化暴力方法：当前数值的位置定位后，往前找是否有比它小的数值，往后找是否有比它大的数值，如果存在，直接输出。但时间效率不高。

贪心算法：维护最小值和次小值。给定最小值初始为第一个数，判断当前数（第二个位置开始）是否比最小值大，如果大赋值给次小值，如果当前数比次小值大，则直接返回。

代码实现

错误代码实现

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int len=nums.length;
        if(len<3)return false;
        for(int i=1;i<len-1;i++){
            if(nums[i]>nums[i-1]&&nums[i]<nums[i+1])
                return true;
        }
        return false;
    }
}

暴力法实现

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int len=nums.length;
        if(len<3)return false;
        for(int i=0;i<len;i++){
            for(int j=i+1;j<len;j++){
                for(int k=j+1;k<len;k++){
                    if(nums[i]<nums[j]&&nums[j]<nums[k]){
                        return true;
                    }
                }
            }
        }
        return false;
    }
}

暴力法优化一：针对输入全为1的数组，会超出时间限制。

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int len=nums.length;
        if(len<3)return false;
        for(int i=1;i<len-1;i++){
            int left=0;
            int right=len-1;
            while(left<i&&right>i){
                if(nums[left]>=nums[i])left++;
                if(nums[right]<=nums[i])right--;
                if(nums[left]<nums[i]&&nums[right]>nums[i])return true;
            }
        }
        return false;
    }
}

暴力优化实现二

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int len=nums.length;
        if(len<3)return false;
        Set set = new HashSet();
	    for (int x=0 ; x<len ; x++){
		    set.add(nums[x]);
	    }
        if(set.size()<3)return false;
        for(int i=1;i<len-1;i++){
            if(nums[i]==nums[i-1])continue;
            int left=0;
            int right=len-1;
            while(left<i&&right>i){
                if(nums[left]>=nums[i])left++;
                if(nums[right]<=nums[i])right--;
                if(nums[left]<nums[i]&&nums[right]>nums[i])return true;
            }
        }
        return false;
    }
}

贪心算法实现

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int len=nums.length;
        if(len<3)return false;
        Set set = new HashSet();
	    for (int x=0 ; x<len ; x++){
		    set.add(nums[x]);
	    }
        if(set.size()<3)return false;
        int first=nums[0];
        int second=nums[0];
        int tag=0;
        for(int i=1;i<len;i++){
            if(tag==1 && nums[i]>second)return true;
            if(nums[i]>first){
                second=nums[i];
                tag=1;
            }
            else{
                first=nums[i];
            }
        }
        return false;
    }
}

反思

针对用例，要对大量重复数做判断。此时用set进行筛选后再做判断。

时间性能上还有待提升。

考虑贪心算法后性能提升也不大。