【代码随想录day43】【C++复健】300.最长递增子序列；674. 最长连续递增序列； 718. 最长重复子数组

300.最长递增子序列

又忘了这个题怎么想了，后来偷看了解析才看懂，dp数组必须表示“以该节点为结尾的”递增子序列。只有按照这样定义，dp数组才有意义，才能递推得动，否则我想了半天也想不出来怎么写一个递推关系。

偷看解析后就很好写了，不过还是稍微写麻烦了点，这两个循环是可以合并的，下次注意。

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

674. 最长连续递增序列

本题相对来说（个人感觉）比上一题好做，因为本题的递归含义并不像上一道题那样难想。所以也是几乎一遍就做出来了。

出现了两个小问题：

1 在比较的时候把if(nums[i] > nums[i-1])写成了if(dp[i] >dp[i-1])

2 一开始result定义写的是0，但这会导致比如在[2,2,2,2,2]这样的数组中，一次都没执行循环的情况下，返回0，但正确的值应该是1才对。

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

718. 最长重复子数组

想到了用二维dp，各种思路也比较接近正确答案，但因为定义的dp数组少了一行一列，所以很多地方都需要特殊处理，还很容易出错：

1 i=0和j=0的情况都要单独列出来，单独进行处理，并且此时也要更新最大值，因为最大值是有可能出在这里的。

2 i和j的顺序，下标从0还是1开始，都很容易搞混。

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        vector<vector<int>> dp(m, vector<int> (n));
        int result = 0;
        for(int i=0; i<m; i++){
            if(nums1[i] == nums2[0]){
                dp[i][0] = 1;
            }
            if(dp[i][0] > result){
                result = dp[i][0];
            }
        }
        for(int j=0; j<n; j++){
            if(nums1[0] == nums2[j]){
                dp[0][j] = 1;
            }
            if(dp[0][j] > result){
                result = dp[0][j];
            }
        }
        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                if(nums1[i] == nums2[j]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }
                if(dp[i][j] > result){
                    result = dp[i][j];
                }
            }
        }
        return result;
    }
};

所以后来用m+1和n+1又试了一下，结果还是遇到了问题，在这里：

if (nums1[i - 1] == nums2[j - 1]) {  // 注意这里需要使用 i-1 和 j-1

没使用i-1和j-1进行比较，导致算不出正确答案来，总是小1个。

此外，这里的i<=m和j<=n第一遍也没写出来，当然也有可能是我半道修改的，没想起来。这种半道修改的情况其实很容易出现一些细节考虑不周，或者一些地方换了会产生不一致，却没有想到的情况出现。

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        
        // dp 数组需要多分配一行一列来处理边界条件
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));  // 初始化为0
        
        int result = 0;

        // 遍历所有元素并更新 dp 数组
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {  // 注意这里需要使用 i-1 和 j-1
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    result = max(result, dp[i][j]);  // 更新最大值
                }
            }
        }

        return result;  // 返回最长公共子数组的长度
    }
};