leetcode -[动态规划、二分查找] - （300）最长递增子序列LIS

1、问题描述

给定一个无序的数组，求数组中最长递增子序列的最大长度。
一个数组可能由多个递增子序列，求这些子序列中的最大长度。

输入：[10,9,2,3,1,7,18]
输出：4
解释：最长的递增子序列为[2,3,7,18],其长度为4.

2、解题思路

特殊输入：数组为空的情况。
解决这道问题由以下两种方法：
方法1：动态规划。
分析：数组$nums$的最长递增子序列可能以$nums[j](j=0,1,2,...,len-1)$结尾，且一定是这$len$个递增子序列的长度最大的那个。
(1) 状态定义
$dp[i]$表示$nums[i]$结尾的最长递增子序列的长度。

(2) 状态转移
考虑$dp[i]$和$dp[j](j=0,1,2,...,len-1)$之间的关系，当$nums[j]<nums[i]$，以$nums[i]$结尾的最长递增子序列的长度等于以$nums[j]$结尾的最最长递增子序列的长度加1，即
$dp[i]=max\{dp[j]+1\}$ 其中，$j=\{1,2,..,i-1\}\&\&nums[j]<nums[i]$

(3) 确定起始
只有开头一个元素时，以该元素结尾的最长递增子序列的长度为1，即$dp[0]=1$。

(4)确定结束
$dp[0],dp[1],...,dp[len-1]$中的最大值即为该数组的最长递增子序列的长度。

3、代码实现

class Solution {
     
public:
    int lengthOfLIS(vector<int>& nums) {
     
        int len = nums.size();
        if(len == 0){
     
            return 0;
        }
        vector<int> dp(len, 0);
        dp[0] = 1;
        for(int i = 1; i < len; i++){
     
            int maxdpj = -1;
            for(int j = 0; j < i; j++){
     
                if(nums[j] < nums[i]){
     
                    maxdpj = max(maxdpj, dp[j]);
                }
            }
            if(maxdpj == -1){
     
                dp[i] = 1;
            }
            else{
     
                dp[i] = maxdpj + 1;
            }
            // cout<<"dp["<
        }
        
        int maxlis = -1;
        for(int i = 0; i < len; i++){
     
            maxlis = max(maxlis, dp[i]);
        }
        return maxlis;

    }
};