leetcode718.最长重复子数组

一.题目描述

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

示例：

输入：
A: [1,2,3,2,1]
B: [3,2,1,4,7]
输出：3
解释：
长度最长的公共子数组是 [3, 2, 1] 。

提示：

1 <= len(A), len(B) <= 1000
0 <= A[i], B[i] < 100

二.题目解析

1.暴力法

public int findLength1(int[] nums1, int[] nums2) {
        /*暴力法.时间复杂度O(mn)
        * */
        int res = 0;
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                // 遇到相同项
                if (nums1[i] == nums2[j]) {
                    // 重复子数组长度初始化为1
                    int subLen = 1;
                    //同时向后遍历看后边元素是否相同
                    while (i + subLen < nums1.length && j + subLen < nums2.length && nums1[i + subLen] == nums2[j + subLen]) { //新的一项也相同
                        subLen++;
                    }
                    res = Math.max(subLen, res);
                }
            }
        }
        return res;
    }

2.动态规划

public int findLength2(int[] nums1, int[] nums2) {
        /*动态规划法.dp[i][j]表示第一个数组 nums1 前 i+1 个元素
        和数组 nums2 前 j+1 个元素组成的最长公共子数组(相当于子串)的长度。
            1   2   3   2   1  num1数组
        3   0   0   1   0   0
        2   0   1   0   2   0
        1   1   0   0   0   3
        4   0   0   0   0   0
        7   0   0   0   0   0
        nums2数组
        连续的公共部分就是去找一条或多条能从【左上】连到【右下】的线。取这些线长度的最大值
        时间复杂度O(mn)，空间复杂度O(mn)
         * */
        int[][] dp = new int[nums1.length][nums2.length];
        int res = 0;
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                if(nums1[i] == nums2[j]){
                    //当前元素可以构成公共子数组，所以还要加上它们的前一个元素构成的最长公共子数组的长度
                    //考虑i=0和j=0的边界情况，此时dp数组越界
                    dp[i][j] = i > 0 && j > 0 ? dp[i-1][j-1] + 1 : 1;
                }else {
                    //当前元素不能成为公共子数组里的一员
                    dp[i][j] = 0;
                }
                res = Math.max(res,dp[i][j]);
            }
        }
        return res;
    }

3.动态规划的空间优化1

public int findLength3(int[] nums1, int[] nums2) {
        /*动态规划法.还可以进行空间优化
        dp[i][j]只依赖于dp[i-1][j-1],我们可以只维护两列数据即可，类似于滚动数组
        时间复杂度O(mn)，空间复杂度O(n)
        ----------------------→→→
      |      1   2   3   [2   1]  num1数组
      |  3   [0   0]   1   0   0
      |  2   [0   1]   0   2   0
      |  1   [1   0]   0   0   3
      |  4   [0   0]   0   0   0
      |  7   [0   0]   0   0   0
      ↓
  nums2数组
         * */
        int res = 0;
        int[][] dp = new int[2][nums2.length];
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                if(nums1[i] == nums2[j]){
                    //状态转移方程
                    dp[i % 2][j] = i > 0 && j > 0 ? dp[(i - 1) % 2][j - 1] + 1 : 1;
                }else {
                    //当前元素不能成为公共子数组里的一员
                    dp[i % 2][j] = 0;
                }
                res = Math.max(res,dp[i % 2][j]);
            }
        }
        return res;
    }

4.动态规划的空间优化2

public int findLength4(int[] nums1, int[] nums2) {
        /*动态规划法.还可以进行空间优化
        dp[i][j]只依赖于dp[i-1][j-1],我们可以只维护一列数据即可，j的遍历倒序即可
        遍历过程中不断更新这一列的数据
        ----------------------→→→
      ↑      1   2   3   [2   1]  num1数组
      |  3   [0]  [0]   1   0   0
      |  2   [0]  [1]   0   2   0
      |  1   [1]  [0]   0   0   3
      |  4   [0]  [0]   0   0   0
      |  7   [0]  [0]   0   0   0

  nums2数组
         * */
        int res = 0;
        int[] dp = new int[nums2.length];
        for (int i = 0; i < nums1.length; i++) {
            //如果是正序遍历的话，假如此时位置上一行上一列对角线上的值为0，
            // 如果此轮遍历dp[j-1]=1，便会覆盖dp[j-1]即原对角线上的值变为1，那么dp[j]的计算依赖于dp[j-1]就会出现错误
            //倒序遍历保证先更新的dp[j]的值不会影响dp[j-1]的值
            for (int j = nums2.length - 1; j >= 0 ; j--) {
                if(nums1[i] == nums2[j]){
                    dp[j] = i > 0 & j > 0 ? dp[j-1] + 1 : 1;
                }else {
                    dp[j] = 0;
                }
                res = Math.max(res,dp[j]);
            }
        }
        return res;
    }