关于leetcode第718题求长度最长的公共子数组的解析

1.题目描述

给两个整数数组 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

链接：https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray。

2.解析

解答思路主要有，暴力法、滑动窗口法

2.1 暴力法

最直接的办法就是采用暴力法，两次for循环，滞后再用while循环。时间复杂度比较高 大概是 o(n)^3。
代码如下：

    public int findLength(int[] A, int[] B) {
        if(null==A||null==B||0==A.length||0==B.length){
            return 0;
        }
        int max = 0;
        for(int i=0;i<A.length;i++){
            for(int j=0;j<B.length;j++){
                int num = 0;
                while(i+num<A.length&&j+num<B.length&&A[i+num]==B[j+num]){
                    num ++;
                }
                if(max < num){
                    max = num;
                }
            }
        }
        return max;
    }

提交leetcode之后果然妥妥超时

image.png

2.2 滑动窗口法

回顾下整个流程，可以理解为两个数组，固定其中之一，然后另外一个数组从左到右逐步滑动，每次移动一个数字，之后比较相等值出现的次数。此过程可以在excel上表示为如下图：

image.png

也可参考某大神制作的gif：

pic.gif

算法如下：

    public int findLength(int[] A,int[] B){
        int[] slid = A;
        int[] fix = B;
        //将较大的数组固定，较小的数组滑动
        if(A.length < B.length){
            fix = B;
            slid = A;
        }
        int max = 0;
        //滑动的总次数为两个数组只和减1
        int total = fix.length+slid.length-1;
        for(int i=0;i<total;i++){
            int fStart = 0;
            int sStart = 0;
            int len = 0;
            //当滑动数组没有超出固定数组的长度的时候，固定数组的起始位置为0，滑动数组起始位置和重合部分的长度要进行计算。
            if(i<fix.length){
                sStart = fix.length - i - 1;
                len = i + 1;
            }else {
            //当滑动数组超过固定数组之后，那么此时则滑动数组的起始位置为0而固定数组的起始位置要重新计算
                len = slid.length - (i + 1 - fix.length);
                fStart = i + 1 - fix.length;

            }
            int maxlen = maxLength(fix,slid,fStart,sStart,len);
            max = Math.max(max,maxlen);
        }
        return max;
    }

//从两个数组的起始位置计算重合数组的长度
    public int maxLength(int[] A,int[] B,int a,int b,int len){
        int max = 0;
        int count = 0;
        for(int i=0;i<len;i++){
            if(A[a+i]==B[b+i]){
                count++;
                max = Math.max(max,count);
            }else {
                count = 0;
            }
        }
        return max;
    }

此种解法提交成功

image.png

2.3 动态规划

还可以进一步想到的就是将两个数组分别放到横轴和纵轴上，此时可以发现，相同子数组即是与其左上角连线都为1的点。

image.png

那么可以推导除，如果存在这么一个子数组，那么其左上角的点构成的连续长度肯定比加上这个点构成的连续长度少1。可以用如下公式表示：
在新组成的二维数组ad中，连续子数组上的点dp[i][j]=dp[i-1][j-1]+1

image.png

那么很容易想到了动态规划，之后如果存在一个点就加1，之后将最大的值得出。

public int findLength(int[] A,int[] B){
                int m = A.length;
        int n = B.length;
        int [][] dp = new int [m][n];
        int result = 0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(A[i]==B[j]){
                    if(i-1>=0&&j-1>=0) {
                        dp[i][j] = dp[i - 1][j - 1] + 1;
                        result = Math.max(result, dp[i][j]);
                    }else {
                        dp[i][j] = 1;
                    }
                }
            }
        }
        return result;
    }

提交结果也能通过。

image.png