代码随想录算法训练营第43天 | LeetCode300.最长递增子序列、LeetCode674.最长连续递增子序列、LeetCode718.最长重复子数组-CSDN博客

本文链接：https://blog.csdn.net/m0_68237332/article/details/142128762

LeetCode300.最长递增子序列

LeetCode674.最长连续递增子序列

1. 贪心算法

2. 动态规划

LeetCode718.最长重复子数组

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

思路：这里比上面的稍微要难一点。

因为前面是在一个数组上进行操作，这里变成了两个数组。

所以我们这里使用了dp[i][j]表示以下标i-1结束的nums1，以及以下标j-1结束的nums2的最长子数组长度。

我们可以很容易知道，dp[i][j]与dp[i-1][j-1]的状态有关，如果说nums1[i-1]等于了nums[j-1],那么就会有dp[i-1][j-1](以下标i-2结束的nums1，以及以下标j-2结束的nums2的最长子数组长度)加上1，所以其实也比较好做了。

上面递推公式中有dp[i-1][j-1]，那么循环下标就得从1开始了，但是下标为0的地方需要进行初始化，因为后面会用到，那么结合具体情景来看的话，如果说nums1[0]等于了nums2[0],那么dp[1][1]=dp[0][0]+1,所以这里dp[0][0]初始化为0合适，因为这样的话刚好最长子数组为1。

    int findLength(vector<int>& nums1, vector<int>& nums2) {
        //dp[i][j]表示对于以下标i-1结尾的nums1,和以下标j-1结尾的nums2的最长子数组长度
        //注意这里的相同的子数组是求的连续的，不是非连续的
        vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
        int result = 0;
        for(int i = 1; i < nums1.size() + 1; i ++){
            for(int j = 1; j < nums2.size() + 1; j ++){
                if(nums1[i - 1] == nums2[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1] + 1;//当nums1[i-1]与nums2[j-1]相等时，就等于dp[i-1][j-1]的基础上加1
                }
                if(dp[i][j] > result) result = dp[i][j];//及时记录下最大数组长度
            }
        }
        return result;
    }

时间复杂度：O(n*m)

空间复杂度：O(n*m)

当然还可以使用一维滚动数组来实现上面的代码，进行空间消耗的一个优化。

这里需要注意的有两点

一是对于这个一维数组的更新的遍历顺序需要从后往前遍历,因为dp[j]的更新会受到dp[j-1]状态的影响，如果正向遍历，会造成一些值重复叠加，显然结果是不对的，因此从后往前遍历就是为了避免重复累加；

二是在nums1[i-1]与nums2[j-1]不相等时，需要及时更新dp[j]为0，因为这是一个一维数组，如果不更新为0,保留了之前的状态，那么就会在后面结算的时候出现使用dp[j-1]更新dp[j]的时候出现错误。本身如果不相等，那么说明最长子数组长度就该为0，对于一维数组来说，状态值是不断在更新，不得不进行一些值的改变，因为相同位置的值在下一次到达时可能就会覆盖成新的值；而相较于二维数组来说，不存在覆盖一说，每个地方都存储了之前的值，空间也足够，所以不需要覆盖。

    int findLength(vector<int>& nums1, vector<int>& nums2) {
        //使用滚动一维数组来记录并且不断更新状态
        vector<int> dp(nums2.size() + 1, 0);
        int result = 0;
        for(int i = 1; i < nums1.size() + 1; i ++){
            for(int j = nums2.size(); j > 0; j --){//注意这里的顺序是倒序，防止重复叠加
                if(nums1[i - 1] == nums2[j - 1]){
                    dp[j] = dp[j - 1] + 1;
                }else{
                    dp[j] = 0;//这里在不匹配的时候记得重置为0，否则可能会出现错误答案
                }
                if(dp[j] > result) result = dp[j];//及时更新dp[j]
            }
        }
        return result;
    }

时间复杂度：O(n*m)

空间复杂度：O(m)

当然了，还可以将dp[i][j]表示以下标i结束的nums1，以及以下标j结束的nums2的最长子数组长度。

这样也是可以的，但是需要进行额外的初始化操作，比如nums1[0]与nums2[j]相等了，那么最大子数组长度就该初始化为1，同理对于nums1[i]与nums2[0]相等的时候也是这样的。

还需要注意的是for循环的遍历一定要从i=0,j=0开始，不能从i=1，j=1开始。因为一旦这样开始，就会导致result没有办法更新所有的情况存在的状态值，导致最后返回的是个错误值。详细的解释可以看一看下面代码中注释的地方，这样就应该能明白为什么一定要使得i、j都从0开始了。

    int findLength(vector<int>& nums1, vector<int>& nums2) {
        //这里使用dp[i][j]表示以下标i结尾的nums1，和以下标j结尾的nums2的最大子数组长度
        vector<vector<int>> dp(nums1.size(), vector<int>(nums2.size(), 0));
        //初始化，对dp[i][0]以及dp[0][j]的状态值进行判断并且初始化
        for(int i = 0; i < nums1.size(); i ++) if(nums1[i] == nums2[0]) dp[i][0] = 1;
        for(int j = 0; j < nums2.size(); j ++) if(nums2[j] == nums1[0]) dp[0][j] = 1;

        int result = 0;//记录最终结果
        for(int i = 0; i < nums1.size(); i ++){
            for(int j = 0; j < nums2.size(); j ++){
                //注意这里的判断是需要将i=0以及j=0排除掉的
                //那为什么不直接使i、j都从1开始呢，这样就不用判断了，
                //因为如果从1开始，就会使得result不能将所有结果全部更新，会跳过i=0或者j=0时的最长子数组长度
                //比如直观的一个例子就是假设有这样两个数组[1,2,3,4],[1,5,6,7]
                //从1开始的话，最后的result为0,显然正确答案应该是1，出现这样的状况就是因为跳过了使用i=0,j=0的状态对result更新的情况，最终导致结果的错误
                //当然还有可能是这样的数组[1,2,3,2,8],[5,6,1,4,7],都是应该使得i=0或者j=0，但是贸然将i和j都从1开始所造成的情况考虑不周全的状况
                //因此这里必然是从0开始，虽然第一个判断进不去，但是可以进入第二个循环，尝试更新result
                if(nums1[i] == nums2[j] && i >0 && j > 0){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                if(dp[i][j] > result) result = dp[i][j];
            }
        }
        return result;
    }

时间复杂度：O(n*m)

空间复杂度：O(n*m)

感谢你的阅读，希望我的文章能够给你帮助，如果有帮助，麻烦点赞加收藏，或者点点关注，非常感谢。

如果有什么问题欢迎评论区讨论！