334. Increasing Triplet Subsequence

Task:

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.

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

Examples:
Given [1, 2, 3, 4, 5],
return true.

Given [5, 4, 3, 2, 1],
return false.

Some questions:

What's the range of n? 

What's the range of the elements in the array?

Solution:

At the first glance, I think out an idea that we can enumerate i,j,k, then check whether arr[i],arr[j],arr[k] meet the condition. This algorithm runs in O(n^3) time complexity and O(1) space complexity.

I think this algorithm is not good enough.

After several minutes, I think out a better solution. The main idea is using two arrays pre[],suf[]. 

pre[i] indicates whether there is a element which is smaller than the i-th element in front of the i-th element.

suf[i] indicates whether there is a element which is larger than the i-th element at the back of the i-th element.

then we check whether there is an index i whose pre[i] and suf[i] are both true.

This algorithm runs in O(n) time complexity and O(n) space complexity. The space complexity still not meet the restriction.

So I have to think out a better solution. After a long period, I finally think out a feasible algorithm.

The main idea is maintaining two variables index_single, index_pair. Scan the array from left to right, index_single means the position of the minimum element in front of current element, index_pair means the position of minimum second element of the pair whose first element is smaller second element. Ｔhen update these two variables step by step.

This algorithm runs in O(n) time complexity and O(1) space complexity which meet the restriction.

class Solution {
public:
    bool increasingTriplet(vector<int>& nums) {
        int i=0;//index for scan.
        int ind1=-1,ind2=-1;//index_single,index_pair.
        int n=nums.size();
        for(i=0;i<n;i++)//iterator elements from left to right.
        {
            if(ind2!=-1)//judge whether there is a triple which is end with nums[i] meeting the conditions.
            {
                if(nums[i]>nums[ind2])return true;
            }
            
            if(ind1!=-1)//update index_pair
            {
                if(nums[i]>nums[ind1])
                {
                    if(ind2==-1)ind2=i;
                    else if(nums[i]<nums[ind2])ind2=i;
                }
            }
            
            if(ind1==-1||nums[i]<nums[ind1])ind1=i;//update index_single.
        }
        
        return false;
    }
};