leetcode300. 最长递增子序列！

传送门
题目： 给定一个无序的整数数组，找到其中最长上升子序列的长度。

输入: [10,9,2,5,3,7,101,18] 输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

1. 首先，这是子序列，不是子串！！
2. 这道题序列严格递增，[2,2] 输出是1

方法1.暴力动态规划

典型的动态规划题目，定义一个数组dp，其中dp[i]代表以第num[i]为结尾取得的最长长度，最后返回最大的那个dp[i]就行了，

所以这道题的重点在于怎么求得dp[i]。

1. 一开始我们先把dp全部元素都初始化为1，因为dp[i]无论如何最少的长度都是1（只有本身一个元素的序列）

2. 然后对于每个num[i]我们可以通过遍历num[0]~num[i-1]，
   如果在这个区间找到一个num[j]比num[i]小，那么开始比较dp[j]+1和dp[i]的大小，
   如果dp[j]+1>dp[i]则更新dp[i]，所以转移方程为:
   dp[i] = max(dp[j]+1,dp[i])

	int lengthOfLIS(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        vector<int> dp(nums.size());
        int ans = 1;
        for (int i = 0; i < nums.size(); ++i) {
			// 每一个dp默认是1，代表前面没有比他小的（没有进if）
			//或者在dp数组定义时，数值全部设置为1，就不用再这里赋值
            dp[i] = 1;   
            for (int j = 0; j < i; ++j){
                if (nums[j] < nums[i]) 
                    dp[i] = max(dp[i], dp[j] + 1);
            }
            ans = max(ans, dp[i]);
        }
        return ans;
    }

时间: n*n , 空间 n

方法2. 二分查找+动态规划

	public int lengthOfLIS(int[] nums) {
        if (nums.length < 2) return nums.length;
        int[] tail = new int[nums.length];
        tail[0] = nums[0];
        int tailIndex = 0; // fail最后一个有效位置的索引
        for (int i = 1; i < nums.length; ++i) {
            if (nums[i] > tail[tailIndex]) { //说明nums[i]比tail所有值都大,直接添加到尾
                tail[++tailIndex] = nums[i];
            } else { //tail中一定有数值比num[i]大，二分找第一个比nums[i]大的数，替换
                int start = 0, end = tailIndex;
                while (start < end) {
                    int mid = ((end - start) >> 1) + start;
                    if (nums[i] > tail[mid]) start = mid + 1;
                    else end = mid;
                }
                tail[start] = nums[i];
            }
        }
        return tailIndex + 1;
    }