300. Longest Increasing Subsequence

Given an unsorted array of integers, find the length of longest increasing subsequence.

For example,
Given [10, 9, 2, 5, 3, 7, 101, 18],
The longest increasing subsequence is [2, 3, 7, 101], therefore the length is 4. Note that there may be more than one LIS combination, it is only necessary for you to return the length.

Your algorithm should run in O(n2) complexity.

Follow up: Could you improve it to O(n log n) time complexity?

Title:

Find the longest increasing subsequence.

Ideas:

1. Dynamic programming

Initially, each element is separate, and its length is 1. Then traverse the array, for nums[i]>nums[j], i>j, then len[i]=max(len[i], len[j]+1), and finally the largest len is the longest length. The time complexity is O(n^2)

2. Dichotomy

In this approach, we scan the array from left to right. We also make use of a $d p$ array initialized with all 0's. This $d p$ array is meant to store the increasing subsequence formed by including the currently encountered element. While traversing the $n u m s$ array, we keep on filling the $d p$ array with the elements encountered so far. For the element corresponding to the $j^{th}$ index ( $n u m s [j]$ ), we determine its correct position in the $d p$ array(say $i^{th}$ index) by making use of Binary Search(which can be used since the $d p$ array is storing increasing subsequence) and also insert it at the correct position. An important point to be noted is that for Binary Search, we consider only that portion of the $d p$ array in which we have made the updations by inserting some elements at their correct positions(which remains always sorted). Thus, only the elements upto the $i^{th}$ index in the $d p$ array can determine the position of the current element in it. Since, the element enters its correct position( $i$ ) in an ascending order in the $d p$ array, the subsequence formed so far in it is surely an increasing subsequence. Whenever this position index $i$ becomes equal to the length of the LIS formed so far( $l e n$ ), it means, we need to update the $l e n$ as $l e n = l e n + 1$ .

Note: $d p$ array does not result in longest increasing subsequence, but length of $d p$ array will give you length of LIS.

Consider the example:

input: [0, 8, 4, 12, 2]

dp: [0]

dp: [0, 8]

dp: [0, 4]

dp: [0, 4, 12]

dp: [0 , 2, 12] which is not the longest increasing subsequence, but length of $d p$ array results in length of Longest Increasing Subsequence.

Code:

class Solution {
    public int lengthOfLIS(int[] nums) {
        int []len=new int[nums.length];
        // if(nums.length==0)
        //     return 0;
        // for(int i=0;i<nums.length;i++)
        // len [i] = 1;
        // int max_len=1;
        // for(int i=1;i<nums.length;i++)
        // {
        //     for(int j=0;j<i;j++)
        //     {
        //         if(nums[i]>nums[j])
        // len [i] = Math.max (len [i], len [j] +1);
        //     }
        // max_len = Math.max (len [i], max_len);
        // }
        // return max_len;
        
        int l=0;
        for(int num:nums)
        {
            int i=Arrays.binarySearch(len,0,l,num);
            if(i<0)
                i=-(i+1);
            len [i] = num;
            if(l==i)
                l++;
        }
        return l;
    }
}

PS: Java's binarySearch function can refer to https://www.cnblogs.com/qingergege/p/5658292.html. I have to say that it is much more convenient than C++, hhhh, it is actually lazy. laughing out loud