最長重複子數組（暴力/動態規劃/滑窗法）

給兩個整數數組 A 和 B ，返回兩個數組中公共的、長度最長的子數組的長度。

示例 1:

輸入:
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

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。

//三重for循環超時
public class Main {

	public static void main(String[] args) {
		int k = 4;
//		int[] A = {0,1,1,1,1};
		int[] A = {1,2,3,2,1};
//		int[] A = {0,0,0,0,0,0,1,0,0,0};
//		int[] B = {1,0,1,0,1};
		int[] B = {3,2,1,4,7};
//		int[] B = {0,0,0,0,0,0,0,1,0,0};
		System.out.println(findLength(A, B) );
	}
    public static int findLength(int[] A, int[] B) {
    	int ans = Integer.MIN_VALUE;
    	int tmp = 0;
    	for (int i=0; i<A.length; i++) {
    		for (int j=0; j<B.length; j++) {
    			tmp = 0;
    			int k = i;
    			for (int t = j; t<B.length; t++) {
        			if (k < A.length) {
        				if (A[k] == B[t]) {
            				k++;
            				tmp++;
            				if (tmp > ans) {
            					ans = tmp;
            				}
            			} else {
            				tmp = 0;
            			}

        			}    				
    			}   			    		
    		}
    	}
    	if (ans == Integer.MIN_VALUE) {
    		ans = 0;
    	}
    	return ans;
    }
}

 

//暴力優化，卡時間過測試點
public class Main {

	public static void main(String[] args) {
		int k = 4;
//		int[] A = {0,1,1,1,1};
//		int[] A = {1,2,3,2,1};
		int[] A = {0,0,0,0,0,0,1,0,0,0};
//		int[] B = {1,0,1,0,1};
//		int[] B = {3,2,1,4,7};
		int[] B = {0,0,0,0,0,0,0,1,0,0};
		System.out.println(findLength(A, B) );
	}
    public static int findLength(int[] A, int[] B) {
    	int ans = Integer.MIN_VALUE;
    	int tmp = 0;
    	for (int i=0; i<A.length; i++) {
    		for (int j=0; j<B.length; j++) {
    			tmp = 0;
    			if (A[i] == B[j]) {
    				int k = i;
    				int t = j;
                                //優化
    				while (k < A.length && t < B.length && A[k] == B[t]) {
        				k++;
        				t++;
        				tmp++;
        				if (tmp > ans) {
        					ans = tmp;
        				}    				
        			}
    			}
				if (ans >= A.length-i) { //優化
					return ans;
				}    			
    		}
    	}
    	if (ans == Integer.MIN_VALUE) {
    		ans = 0;
    	}
    	return ans;
    }
}

//DP動態規劃
public class Main {

	public static void main(String[] args) {
		int k = 4;
//		int[] A = {0,1,1,1,1};
//		int[] A = {1,2,3,2,1};
		int[] A = {0,0,0,0,0,0,1,0,0,0};
//		int[] B = {1,0,1,0,1};
//		int[] B = {3,2,1,4,7};
		int[] B = {0,0,0,0,0,0,0,1,0,0};
		System.out.println(findLength(A, B) );
	}
    public static int findLength(int[] A, int[] B) {
    	int ans = 0;
    	int dp[][] = new int[A.length+1][B.length+1];
    	for (int i=1; i<=A.length; i++) {
    		for (int j=1; j<=B.length; j++) {
    			if (A[i-1] == B[j-1]) {
    				dp[i][j] = dp[i-1][j-1] + 1;
    			}
    			ans = Math.max(ans, dp[i][j]);
    		}
    	}
    	return ans;
    }
}

//滑窗法
public class Main {

	public static void main(String[] args) {
		int k = 4;
//		int[] A = {0,1,1,1,1};
//		int[] A = {1,2,3,2,1};
		int[] A = {0,0,0,0,0,0,1,0,0,0};
//		int[] B = {1,0,1,0,1};
//		int[] B = {3,2,1,4,7};
		int[] B = {0,0,0,0,0,0,0,1,0,0};
		System.out.println(findLength(A, B) );
	}
    public static int findLength(int[] A, int[] B) {
    	int ans = 0;
    	int a = A.length;
    	int b = B.length;
    	for (int i=0; i<a; i++) {
    		int len = Math.min(b, a-i);    //確定同時開始的位置
    		int tmp = maxLength(A, B, i, 0, len);
    		ans = Math.max(ans, tmp);
    	}
    	
    	for (int i=0; i<b; i++) {
    		int len = Math.min(a, b-i);    //確定同時開始的位置
    		int tmp = maxLength(A, B, 0, i, len);
    		ans = Math.max(ans, tmp);
    	}
    	return ans;
    }
    
    public static int maxLength(int[] A, int[] B, int addA, int addB, int len){
    	int ret = 0;
    	int sum = 0;
    	for (int i=0; i<len; i++) {
    		if (A[i+addA] == B[i+addB]) {
    			sum++;
    		} else {
    			sum = 0;
    		}
    		ret = Math.max(sum, ret);
    	}
    	return ret;
    }
}