最长重复子数组-力扣

本题想到的解法是使用动态规划：

• dp[i][j] 表示nums1,nums2 第 i,j个元素 前的最大重复子数组的长度
• 递推公式 如果 nums1[i] == nums2[j], 那么说明匹配的两个元素，那么最长重复子数组的长度，就要去查看 i - 1, j - 1 时是否匹配，如果匹配，那 dp[i][j] = dp[i - 1][j - 1] + 1;
• 初始化 当两个数组都为空时，那么长重复子数组便是0，因此初始化 dp[0[0] = 0 即可
• 遍历顺序，根据递推公式，dp[i][j] 依赖dp[i - 1][j - 1] 的值，因此外层循环和内层循环都需要 从前往后进行遍历，但两个循环谁遍历nums1,谁遍历nums2 是可以交换的。

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

利用滚动数组对空间复杂度进行优化，dp[i][j]都是由dp[i - 1][j - 1]推出。那么压缩为一维数组，也就是dp[j]都是由dp[j - 1]推出。此时遍历B数组的时候，就要从后向前遍历，这样避免重复覆盖。当两个字符不相等的时候要有赋0的操作。

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        vector<int> dp(vector<int>(nums2.size() + 1, 0));
        int maxlen = 0;
        for (int i = 1; i <= nums1.size(); 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;
                if (dp[j] > maxlen) maxlen = dp[j];
            }
        }
        return maxlen;
    }
};