LeetCode 334. Increasing Triplet Subsequence

原题链接在这里：https://leetcode.com/problems/increasing-triplet-subsequence/

题目：

Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array.

Formally the function should:

Return true if there exists i, j, k 
such that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 else return false.

Note: Your algorithm should run in O(n) time complexity and O(1) space complexity.

Example 1:

Input: [1,2,3,4,5]
Output: true

Example 2:

Input: [5,4,3,2,1]
Output: false

题解：

Could use dp to track up to index i, the length of longest subarray. 

For all j from 0 to i, if nums[j]<nums[i], then dp[i] = Math.max(dp[i], dp[j]+1). If dp[i] >= 3, then return true.

Time Complexity: O(n^2). n = nums.length.

Space: O(n).

AC Java: 

class Solution {
    public boolean increasingTriplet(int[] nums) {
        if(nums == null || nums.length < 3){
            return false;
        }
        
        int len = nums.length;
        int [] dp = new int[len];
        for(int i = 0; i<len; i++){
            dp[i] = 1;
            for(int j = 0; j<i; j++){
                if(nums[j]<nums[i]){
                    dp[i] = Math.max(dp[i], dp[j]+1);
                    if(dp[i] > 2){
                        return true;
                    }
                }
            }
        }
        
        return false;
    }
}

Could use first and second variables to maintain the first smallest and second smallest number.

For each number in nums array, if num <= first, update first. Else if num <= second, update second. Else, this means that there are 2 increasing numbers smaller than current number before. Thus return true.

Time Complexity: O(n).

Space: O(1).

AC Java:

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int first = Integer.MAX_VALUE;
        int second = Integer.MAX_VALUE;
        for(int num : nums){
            if(num <= first){
                first = num;
            }else if(num <= second){
                second = num;
            }else{
                return true;
            }
        }
        
        return false;
    }
}

类似Longest Increasing Subsequence.