# [300. Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/)
# 思路
给定一个数组，求最长递增子序列的长度。

## 思路一、O(n^2)
很明显是一个动态规划题，我们可以用dp[i]表示以nums[i]为结尾的最长子序列的长度。这样更新dp[i]的转移方程就为
```
for all j in [0, i-1]:
  if nums[i] >= nums[j]:
    dp[i] = max(dp[i], dp[j] + 1)
```
从转移方程可以看出有两层循环，所以时间复杂度为O(n^2)。

## 思路二、O(nlogn)
思路一比较好想，O(nlogn)的就不太好想了，可参考[这里](https://segmentfault.com/a/1190000003819886)，讲得比较清楚。

核心思路就是：
> 维护一个长度可变的数组tails, tails[i]表示长度为i+1的所有递增子序列中最小的那个末尾元素，这样更新完毕后tails的长度即结果。

下面举个[例子](https://segmentfault.com/a/1190000003819886)说明: 
在`1,3,5,2,8,4,6`这个例子中，当到6时，我们一共可以有四种长度的递增子序列，在每种子序列中我们取末尾元素最小的，那么这四个序列分别是
```
1
1,2
1,3,4
1,3,5,6
```
为什么要选末尾元素最小的呢，是因为在长度一定的情况下，末尾元素最小的是未来最有可能成为最长序列的候选人。这样，每来一个新的数，
我们便按照以下规则更新这些序列：
1. 如果nums[i]比所有序列的末尾都大，或等于最大末尾，说明有更长的递增序列产生，我们把最长的序列复制一遍，并加上这个nums[i]。
2. 如果nums[i]比所有序列的末尾都小，说明长度为1的序列可以更新了，更新为这个更小的末尾。
3. 如果在中间，则更新那个末尾数字刚刚大于等于自己的那个序列，说明那个长度的序列可以更新了。

比如这时，如果再来一个9，那就是第1种情况，更新序列为
```
1
1,2
1,3,4
1,3,5,6
1,3,5,6,9
```

如果再来一个3，那就是第3种情况，更新序列为
```
1
1,2
1,3,3
1,3,5,6
```
如果再来一个0，那就是第2种情况，更新序列为
```
0
1,2
1,3,3
1,3,5,6
```

前两种都很好处理，O(1)就能解决，主要是第三种情况，实际上我们观察直到6之前这四个不同长度的升序序列，他们末尾是递增的，
所以可以用二分搜索来找到适合的更新位置。


# C++
## 思路一
``` C++
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if(n <= 1) return n;
        vector<int>dp(n, 1);
        
        int res = 1;
        for(int i = 1; i < n; i++){
            // j >= 0 可优化成 j >= dp[i]-1
            for(int j = i-1; j >= 0; j--)
                if(nums[i] > nums[j])
                    dp[i] = max(dp[i], dp[j] + 1);
            
            res = max(res, dp[i]);
        }
        return res;
    }
};
```

## 思路二
``` C++
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if(n <= 1) return n;
        
        vector<int>tails;
        tails.push_back(nums[0]);
        for(int i = 1; i < n; i++){
            if(nums[i] > tails.back()) tails.push_back(nums[i]);
            else{
                tails[lower_bound(tails.begin(), tails.end(), nums[i]) - tails.begin()] = nums[i];
                // 上面这句等价于下面注释部分
                // int low = 0, high = tails.size() - 1;
                // while(low < high){
                //     int mid = low + (high - low) / 2;
                //     if(tails[mid] < nums[i]) low = mid + 1;
                //     else high = mid;
                // }
                // tails[low] = nums[i];
            }
        }
        return tails.size();
    }
};
```