Maximum Length of Repeated Subarray - Practice Coding Problems

Maximum Length of Repeated Subarray - Problem

Array Binary Search Dynamic Programming Sliding Window Rolling Hash Hash Function Medium

Maximum Length of Repeated Subarray

Given two integer arrays nums1 and nums2, find the maximum length of a contiguous subarray that appears in both arrays.

A subarray is a contiguous sequence of elements within an array. For example, in array [1,2,3,4], the subarrays include [1,2], [2,3,4], but not [1,3] since it's not contiguous.

Your task is to find the longest such common subarray and return its length. If no common subarray exists, return 0.

Example:
If nums1 = [1,2,3,2,1] and nums2 = [3,2,1,4,7], the longest common subarray is [3,2,1] with length 3.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]

› Output: 3

💡 Note: The repeated subarray with maximum length is [3,2,1], which appears at indices [2,3,4] in nums1 and [0,1,2] in nums2.

example_2.py — No Common Subarray

$ Input: nums1 = [1,2,3], nums2 = [4,5,6]

› Output: 0

💡 Note: There are no common elements between the arrays, so no common subarray exists.

example_3.py — Single Element Match

$ Input: nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]

› Output: 5

💡 Note: Both arrays are identical, so the entire array [0,0,0,0,0] is the longest common subarray with length 5.

Visualization

Tap to expand

Understanding the Visualization

Setup Comparison Grid

Create a table to track matching lengths at each position pair

Fill Matching Positions

When elements match, extend the previous diagonal match by 1

Track Maximum Length

Keep track of the longest sequence found so far

Return Result

The maximum value represents the longest common subarray

Key Takeaway

🎯 Key Insight: Dynamic Programming transforms the problem from checking all possible subarray pairs O(n²m) into a single pass through a comparison table O(nm), leveraging the fact that matching subarrays can be extended from previous matches.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Single pass through both arrays, checking each position pair once

✓ Linear Growth

Space Complexity

O(n × m)

2D DP table storing results for all position combinations

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
0 ≤ nums1[i], nums2[i] ≤ 100
Follow up: Optimize to use only O(min(m,n)) space

Asked in

G Google 42 a Amazon 35 f Facebook 28 ⊞ Microsoft 22

The optimal solution uses Dynamic Programming with O(n×m) time complexity. Create a 2D table where dp[i][j] represents the length of common subarray ending at positions i-1 and j-1. When elements match, extend the previous diagonal length by 1.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n × m)	O(n × m)	Build a 2D table to track lengths of common subarrays ending at each position

Dynamic Programming (Optimal) — Algorithm Steps

Create a 2D DP table of size (n+1) × (m+1)
Initialize all values to 0
For each position (i,j), if nums1[i-1] == nums2[j-1], set dp[i][j] = dp[i-1][j-1] + 1
Track the maximum value seen in the DP table

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP table

Create (n+1)×(m+1) table filled with zeros

Fill matching positions

When elements match, add 1 to diagonal predecessor

Track maximum

Keep track of the maximum value seen so far

Return result

Maximum value represents longest common subarray

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int findLength(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    // DP table: dp[i][j] = length of common subarray ending at nums1[i-1], nums2[j-1]
    int** dp = (int**)calloc(nums1Size + 1, sizeof(int*));
    for (int i = 0; i <= nums1Size; i++) {
        dp[i] = (int*)calloc(nums2Size + 1, sizeof(int));
    }
    int maxLen = 0;
    
    for (int i = 1; i <= nums1Size; i++) {
        for (int j = 1; j <= nums2Size; 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];
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i <= nums1Size; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return maxLen;
}

int main() {
    int nums1[] = {1,2,3,2,1};
    int nums2[] = {3,2,1,4,7};
    printf("%d\n", findLength(nums1, 5, nums2, 5));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Single pass through both arrays, checking each position pair once

✓ Linear Growth

Space Complexity

O(n × m)

2D DP table storing results for all position combinations

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
0 ≤ nums1[i], nums2[i] ≤ 100
Follow up: Optimize to use only O(min(m,n)) space

67.2K Views

High Frequency

~22 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler