● 300.最长递增子序列

1.dp数组含义。dp[i]：以nums[i]为结尾的递增子序列的最大长度。

注意一定是以nums[i]结尾，如果dp[i]定义错误的话，暴力也不知道咋整。

2.递推公式。这道题与背包的单词划分比较像，一个单层循环是弄不出来的，外层循环i，内层循环j。即当前下标i的递增子序列长度，其实和i之前的下表j的子序列长度有关系。准确的说，i的递增子序列长度就是由[0,i-1]范围内的子序列长度得到的，要取他们中的一个最大值。分析如下：

如果nums[i]比nums[j]小或者相等，那么就不能把nums[i]拼到nums[j]结尾的序列上，即不能根据dp[j]得到dp[i]，因为dp[i]一定是nums[i]为结尾的递增子序列的最大长度，nums[i]要比这个序列中的其他元素都大。

所以递推公式只考虑nums[i]比nums[j]大的情况，一开始，j=i-1，这个序列里面只有i自己，所以dp[i]=1，然后从后往前依次比较要不要加入j的子序列，有可能i加入j的这个子序列后长度更大，长度是dp[j]+1；也有可能加入后长度没变大，所以保持原样。

所以dp[i]应该取这两个的较大值：dp[i]=max(dp[j]+1,dp[i]);

代码随想录：注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是我们要取dp[j] + 1的最大值（从后往前依次比较取得的）。

公式结合例子更好理解，举例：

nums = [10,9,2,5,3,7,101,18]

到元素3的时候，dp[4]一开始是1，意味着这个子序列只有自己；与5比较比5小，不能把自己拼到5的子序列后面，即不能由dp[3]得到，跳过；与2比较，可以拼到2后面，取max为2；比9大；比10大。所以dp[4]=2。

3.初始化。dp[i]的最大长度，一开始只有它自己一个元素组成一个序列，所以均初始化为1。

4.遍历顺序。根据递推公式过程，i从左到右，j从右到左。

5.打印。

代码如下。仍然注意dp数组的含义，最后不是返回dp[nums.size()-1]，而是返回dp中的最大值。

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

● 674. 最长连续递增序列

这道题和上一道题的区别是：递增序列是连续的，那么不需要内层循环遍历[i-1,0]，因为nums[i]只能拼接到nums[i-1]上面，即根据dp[i-1]得到dp[i]，再前面的dp元素跟i扯不上关系。

所以一层循环就能实现，也不用比较max值。

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);
        int maxlen=1;
        for(int i=1;i<nums.size();++i){
            if(nums[i]>nums[i-1]){
                dp[i]=dp[i-1]+1;
                maxlen=max(maxlen,dp[i]);
            }
        }
        return maxlen;
    }
};

● 718. 最长重复子数组

1.dp数组含义。

根据上面两道题，dp[i]数组含义也是以下标i元素为结尾的所要求的特定序列的长度，根据i前面的dp得到i的dp。

因为两个数字，所以dp数组得变成二维：dp[i][j]：以nums1[i-1]或者说以nums2[j-1]元素结束的公共子序列的最大长度，其实就是两个子数组（2个子数组分别是：nums1前i个；nums2前j个）的公共后缀的最长长度。所以是两层循环，遍历nums1的前1个到前n1个，其中又遍历nums2的前1个到前n2个，最后返回过程中的比较得出的最大长度maxlen。

所以这个结论一定要贯穿过程中：从数组1  i-1下标、数组2  j-1下标开始，挨个从右往左倒着比较，有dp[i][j]个元素是相同的。如123,103：dp[3][3]=1。

2.递推公式。

根据上面的那个结论，dp[i][j]说明nums1[i-1]==nums2[j-1]，而且nums1的i-2前面和nums2的j-2前面还有dp[i][j]-1长度的元素是相同的。根据定义：nums1的i-2前面和nums2的j-2前面的公共后缀最长长度是dp[i-1][j-1]。

所以if(nums1[i-1]==nums2[j-1]) dp[i][j]-1=dp[i-1][j-1]。即dp[i][j] = dp[i - 1][j - 1] + 1;

3.初始化。

dp[i][j]中i、j有一个0都是无意义的，所以直接初始化为0。

这就是为什么dp数组下标相对于nums下标+1的原因，偏移1个可以直接初始化为0，如果不偏移，dp[i][j]是nums1前i+1个和nusm2前j+1个子数组的公共后缀最长长度，那么第1行和第1列需要挨个判断，相等的话为1，不相等为0。而且偏移一个也是好理解的：nums1前i个；nums2前j个的2个子数组。

4.遍历顺序。两层循环要统计出所有子数组的情况，所以两个数组 要从0到size()-1，又dp数组下标相对于nums下标+1，所以i从1到nums1.size()，j从1到nums2.size()。

5.打印。

代码：

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int n1=nums1.size();
        int n2=nums2.size();
        int maxlen=0;
        vector<vector<int>> dp(n1+1,vector<int>(n2+1,0));
        for(int i=1;i<=n1;++i){
            for(int j=1;j<=n2;++j){
                if(nums1[i-1]==nums2[j-1])//可以 以nums1[i-1]/nums2[j-1]作为结尾，递推
                {
                    dp[i][j]=dp[i-1][j-1]+1;
                    maxlen=max(maxlen,dp[i][j]);
                }
            }
        }
        return maxlen;
    }
};