leetcode 300. Longest Increasing Subsequence（最长递增子序列）

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.

找出最长的升序子序列，可以不连续

思路：
(1) O(N²)的dp
dp[i] 代表从0到i的子序列中，最长升序子序列的长度
然后根据dp[i] 推 dp[i + 1]

上例：
                            10 9 2 5 3 7
升序子序列长度：1
9 < 10:                 1   1

i = 2时，指向2，2要和i之前的每个元素都比较，看能接在哪个元素后面，可以看到2< 10, 2<9，不能构成升序，所以dp[2] = 1
i = 3时，指向5，5和10，9，2都比较，发现5 > 2，所以5接在2的后面, dp[3] = dp[2] + 1

                            10 9 2 5 3 7
升序子序列长度：1   1  1 2 2

i = 5时，指向7， 7>2，所以dp[5] = dp[2] + 1 = 2
7 > 5, 所以dp[5] = max{ dp[5], dp[3] + 1} = 3
依次类推

但是因为最长子序列可能出现在中间，所以最后是返回dp中最大的元素

    int lengthOfLIS(vector<int>& nums) {
        if (nums.size() <= 1) {
            return nums.size();
        }
        
        int len = 1;
        
        auto dp = vector<int>(nums.size(), 1);
        
        for (int i = 1; i < nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
        }
        return *max_element(dp.cbegin(), dp.cend());
    }

java版本

//9ms
    public int lengthOfLIS(int[] nums) {
        if(nums == null || nums.length == 0) {
            return 0;
        }
        
        int n = nums.length;
        int result = 1;
        int[] dp = new int[n];
        dp[0] = 1;
        
        for(int i = 1; i < n; i++) {
            int maxLen = 0;
            for(int j = 0; j < i; j++) {
                if(nums[j] < nums[i]) {
                    maxLen = Math.max(dp[j], maxLen);
                }
            }
            dp[i] = maxLen + 1;
            result = Math.max(dp[i], result);
        }
        
        return result;
    }

(2) O(nlogn) binary search
上面的dp方法每走到一个元素，都要遍历它之前所有的以便判断出接在哪个元素后面
而这个方法是直接搜索到目的index
定义一个list，保存升序子序列
开始时在list中保存第一个元素，然后遍历后面的元素，搜索它们在list中的位置，
如果在list中存在，那么直接替换掉查找到的元素

如果在list中不存在：

1. 需要插入在index=0（比现有第一个数字小），那么换掉index=0处的数字，因为保存更小的数字有利于扩展更长的子序列
2. 需要插入在最后（比现有所有数字大），那么直接在list后面插入
3. 需要插入在中间，那么要换掉index指向的数字，为什么不直接插入，举个例子
   5，2，18，101，10
   刚开始list中是5，然后2比5小，把5换成2，list: [2]，然后18比2大，插入到后面，list: [2, 18], 101时，list: [2, 18, 101], 最后是18，检测到index=1，如果直接插入18前面，就会变成[2,10,18,101], 来者不拒的结果是把不属于升序列长度内的数字也纳入进来，加大了升序列的长度。而要做的是换掉index指向的元素，即list: [2, 10, 101]

顺便说一下java中的Collections.binarySearch(list, number)方法，如果能在list中找到number，那么它返回的index是>=0的，而如果找不到，它会找到需要插入的位置，比如需要插在list的末尾处，即list.size()处，但是这时候index会是负值，index = list.size() - 1，也就是说index = 应插入的位置（负的） - 1，那么 正数的应插入的位置= - (index + 1) = -1 - index

//1ms
    public int lengthOfLIS(int[] nums) {
        if(nums == null || nums.length == 0) {
            return 0;
        }
        
        int n = nums.length;
        List<Integer> ends = new ArrayList<>();
        ends.add(nums[0]);
        
        for(int i = 1; i < n; i++) {
            int index = Collections.binarySearch(ends, nums[i]);
            if(index < 0) {
                //找不到元素时，index会是负值，需要做变换
                index = -1 - index;
            }
            
            if(index == 0) {
                ends.set(0, nums[i]); //换掉最小的元素
            } else if(index == ends.size()){
                ends.add(index, nums[i]); //插入最大的元素到末尾
            } else {
                ends.set(index, nums[i]); //换掉中间的元素
            }
        }
        
        return ends.size();
    }

如果追求O(1)的memory，可以直接在原数组中替换掉元素

//cpp 4ms
    int lengthOfLIS(vector<int>& nums) {
	   if (nums.size() <= 1) {
          return (int)nums.size();
       }
     
       int len = 0;
       for (int i=0; i<nums.size(); i++) {      
          auto it = lower_bound(nums.begin(), nums.begin()+len+1, nums[i]);        
          *it = nums[i];        
          len = max(len, (int)(it - nums.begin()));
       }
    
       return len+1;
    }