Maximum Length of Repeated Subarray

Maximum Length of Repeated Subarray - Problem

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

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

A subarray is a contiguous sequence of elements within an array. For example, in the array [1,2,3,4], the subarrays include [1], [2,3], [3,4], [1,2,3], etc.

The goal is to find the longest common subarray between the two given arrays.

Input & Output

Example 1 — Basic Common Subarray

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

› Output: 3

💡 Note: The longest common subarray is [3,2,1] which appears in nums1 at indices 2-4 and in nums2 at indices 0-2. Length = 3.

Example 2 — Partial Match

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

› Output: 4

💡 Note: The longest common subarray is [0,0,0,0] which appears in nums1 at indices 0-3 and in nums2 at indices 1-4. Length = 4.

Example 3 — No Common Subarray

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

› Output: 0

💡 Note: There are no common elements between the arrays, so the maximum length is 0.

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
0 ≤ nums1[i], nums2[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to use dynamic programming to track the length of common subarrays ending at each position. Best approach uses a 2D DP table where dp[i][j] represents the length of the common subarray ending at nums1[i-1] and nums2[j-1]. Time: O(n×m), Space: O(n×m) or O(m) with optimization.

Common Approaches

✓ Brute Force

⏱️ Time: O(n²×m) Space: O(1)

For each starting position in nums1, compare subarrays of all lengths with all subarrays in nums2. This involves three nested loops to check every possible combination.

Dynamic Programming

⏱️ Time: O(n×m) Space: O(n×m)

Create a DP table where dp[i][j] represents the length of the common subarray ending at nums1[i-1] and nums2[j-1]. If elements match, extend the previous diagonal value by 1.

Space-Optimized DP

⏱️ Time: O(n×m) Space: O(m)

Since we only need the previous row to compute the current row in DP, we can optimize space by using just two 1D arrays and swapping them. This reduces space complexity from O(n×m) to O(m).

Brute Force — Algorithm Steps

For each position i in nums1
For each position j in nums2
Compare subarrays starting at i and j, extend as long as they match

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Starting Points

Choose position i in nums1 and j in nums2

Compare Elements

Extend while elements match

Track Maximum

Keep the longest match found

Code -

solution.c — C

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

int solution(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int maxLength = 0;
    
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            int length = 0;
            while (i + length < nums1Size && j + length < nums2Size && 
                   nums1[i + length] == nums2[j + length]) {
                length++;
            }
            if (length > maxLength) {
                maxLength = length;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nums1[1000], nums2[1000];
    int nums1Size = 0, nums2Size = 0;
    
    // Parse first array - skip '[' and ']'
    char* ptr = line1;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    char* token = strtok(ptr, ",]\n");
    while (token != NULL && nums1Size < 1000) {
        while (isspace(*token)) token++;
        if (*token && *token != ']') {
            nums1[nums1Size++] = atoi(token);
        }
        token = strtok(NULL, ",]\n");
    }
    
    // Parse second array
    ptr = line2;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    token = strtok(ptr, ",]\n");
    while (token != NULL && nums2Size < 1000) {
        while (isspace(*token)) token++;
        if (*token && *token != ']') {
            nums2[nums2Size++] = atoi(token);
        }
        token = strtok(NULL, ",]\n");
    }
    
    printf("%d\n", solution(nums1, nums1Size, nums2, nums2Size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²×m)

Two nested loops for starting positions (n×m), plus inner loop to compare elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for indices and counters

✓ Linear Space

125.0K Views

Medium Frequency

~25 min Avg. Time

2.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler