300. 最长递增子序列

题目描述：

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

 
示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4
示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1
 

提示：

1 <= nums.length <= 2500
-104 <= nums[i] <= 104
 

进阶：

你能将算法的时间复杂度降低到 O(n log(n)) 吗?

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-increasing-subsequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析：

        不考虑时间复杂度的情况下，这道题的标准做法是，dp[i]代表以nums[i]结尾的最大递增子序列的长度。遍历nums数组，来给对应的dp[i]赋值 ，可以看到，当面对数字nums[i]时，我们希望可以找到这样一个数k，满足k<nums[i]，而且dp[k]尽可能大，这样我们就可以把nums[i]作为k之后的下一个元素，来形成新的最大递增子序列。

        如何找k？不考虑时间复杂度，那我们就可以遍历dp[0]~dp[i-1]，肯定能找到符合标准的k。

        但是这样做时间复杂度为O(n*n)

        看题目要求，最好是在O(n log(n))时间复杂度下完成。我们可以想到，遍历nums数组的时间复杂度为O(n)，这是不可避免而且无法优化的。那就只能在寻找k的过程中动手脚了。之前是遍历dp[0]-dp[i-1]，时间复杂度为O(n)，如何降低到O(log(n))，最常见的，二分查找。因此，我们希望你能通过二分查找，找到数字k。但是二分查找有个条件，那就是数组必须是有序的，但显然，dp数组无法满足有序这个要求。

        思路到这里似乎卡住了。有哪几种解决办法呢？1.不用二分查找了，用其他的查找方法。来查一查其他的时间复杂度为O(log(n))的查找：红黑树、B和B+树。这些是针对于树的，不是针对数组的，显然不适合，那就只能用二分查找了。2.改变dp数组为有序的，这可能吗？如果我们还是这样定义dp数组：以nums[i]结尾的最大递增子序列的长度，那么显然不可能使得dp有序。因此，我们只能改变dp数组的定义。题解中选用了一种非常巧妙的方法，定义dp数组为：dp[i]代表长度为i+1的最大递增子序列的末尾元素。例如：dp={2,3,4}，代表长度为1的最大递增子序列末尾元素为2，代表长度为2的最大递增子序列末尾元素为3，代表长度为3的最大递增子序列末尾元素为4。

        这样的话，数组dp变成了递增数组（证明请看题解），那如何更新dp数组呢？分两种情况：

        1 nums[i]比dp数组中的所有元素都要大，我们假设此时dp数组长度为len。说明什么？说明了长度为len+1的最大递增子序列的末尾元素dp[len]，仍然没有nums[i]大，那么，nums[i]是否可以加在dp[len]后面，构成一个长度为len+2的新的最大递增子序列呢？答案当然是可以的。因此，我们更新dp[len+1]=nums[i]。

        2 nums[i]在dp数组中间的某个位置，假若，nums[i]满足：dp[j-1]<nums[i]<dp[j]。说明长度为j的最大递增子序列的末尾元素是dp[j-1]。在dp[j-1]后面加上一个元素dp[j]，则构成了一个长度为j+1的最大递增子序列。发现问题了没有？如果没有nums[i]，我们当然理所当然的把dp[j]加在dp[j-1]后面，但是现在有了一个更小的nums[i]，那为什么不把nums[i]加在dp[j-1]的后面呢？这样的话，我们就可以构成一个长度为j+1的新的最大递增子序列。而且如果nums后面的元素还包含dp[j]的话，dp[j]就可以加在nums[i]后面，形成一个更大的递增子序列。因此，我们把dp[j]更新为nums[i]是正确的。

        通过这样，我们就可以求解到完整的dp数组了，dp数组的长度len也就是最大递增子序列的长度。

详细的题解分析如下：

https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-dong-tai-gui-hua-2/

代码如下：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        // dp[i]代表长度为i+1的严格递增子序列的末尾最小元素
        // dp[i]单调递增（数学证明请看题解），可用于二分查找
        int dp[2505];
        int len=0;
        // 初始情况下dp[0]=nums[0]
        dp[len++]=nums[0];
        // 遍历nums数组来更新dp
        for(int i=1;i<nums.size();i++)
        {
            // 定义二分查找的边界
            int l=0,r=len-1;
            // 二分查找，找到nums[i]要更新的位置
            while(l<=r)
            {
                int middle=(r+l)/2;
                if(dp[middle]<nums[i])
                l=middle+1;
                else
                r=middle-1;
            }
            // 如果nums[i]比所有dp元素都大，则dp数组可以增加一位
            // 说明最大递增子序列的长度变为len，而nums[i]正是该长度为len的最大递增子序列的末尾元素
            if(l==len) dp[len++]=nums[i];
            // 如果nums[i]可以取代某个较大元素而成为新的末尾元素，则更新
            else dp[l]=nums[i];
      
        }
        // 最后返回最大递增子序列的长度len
        return len;
    }
};

附上O(n*n)的做法：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        // dp[i]代表以nums[i]结尾的最大子序列的长度
        int dp[2505];
        dp[0]=1;
        // 遍历nums数组更新dp
        for(int i=1;i<nums.size();i++)
        {
            int maxlength=0;
            // 从dp[0]~dp[i-1]中寻找合适的最大子序列长度
            for(int j=0;j<i;j++)
            if(dp[j]>maxlength&&nums[j]<nums[i])
            maxlength=dp[j];
            // 在之前最大子序列长度的基础上，再加1
            dp[i]=maxlength+1;
        }
        // 找到最大值并返回
        int max=0;
        for(int i=0;i<nums.size();i++)
        if(dp[i]>max)
        max=dp[i];

        return max;
    }
};