LeetCode 300. Longest Increasing Subsequence（动态规划 + 二分查找）

Longest Increasing Subsequence

Medium

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

Example:
Input: [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.

Note:
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?

题意

求数组nums的最长上升子列，这里子列的定义不需要连续

思路

方法1、O(n^2) 动态规划

dp[i]: 以nums[i]结尾的最长上升子列长度
dp[i] = max(dp[j] + 1), for all j < i && nums[j] < nums[i]

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length, i = 0, j = 0;
        if (n <= 1) {
            return n;
        }
        int[] dp = new int[n];
        dp[0] = 1;
        for (i=1; i<n; ++i) {
            dp[i] = 1;
            for (j=0; j<i; ++j) {
                if (nums[i] > nums[j]) {
                    dp[i] = dp[j] + 1> dp[i]? dp[j] + 1: dp[i];
                }
            }
        }
        int ans = 0;
        for (int item: dp) {
            ans = item > ans? item: ans;
        }
        return ans;
    }
}

方法2、O(nlogn) 动态规划 + 二分查找

dp[i]: 长度为i + 1的上升子列的结尾元素的最小值
遍历nums的每个元素，逐个与dp数组比较，更新dp数组中的元素或增长dp数组
更新的算法是：对于nums中的元素target，找到dp中大于等于target的最小元素，更新之；若target大于dp中最后一个元素，则将target置于dp后面一个位置，并增长dp
最终dp数组的长度就是nums的最大上升子列的长度
易证dp是一个单调递增数列，因此更新算法的查找过程可以用O(logn)的时间复杂度完成

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length, len = 0;
        if (n <= 1) {
            return n;
        }
        int[] dp = new int[n];
        for (int num: nums) {
            int ind = rightIndex(dp, len, num);
            dp[ind] = num;
            if (ind == len) {
                ++len;
            }
        }
        return len;
    }
    
    /**
    * Binary search
    * Given an sorted array {@code arr} with valid length {@code len}, find the first position of elemnt in {@code arr} such that elemnt >= {@code target}
    */
    private int rightIndex(int[] arr, int len, int target) {
        if (len == 0) {
            return 0;
        }
        if (arr[len-1] < target) {
            return len;
        }
        int l = 0, r = len-1, mid = 0;
        while (l < r) {
            mid = (l + r) / 2;
            if (arr[mid] < target) {
                l = mid + 1;
            } else {
                r = mid;
            }
        }
        return r;
    }
}