Longest Common Subpath

Longest Common Subpath - Problem

There is a country of n cities numbered from 0 to n - 1. In this country, there is a road connecting every pair of cities.

There are m friends numbered from 0 to m - 1 who are traveling through the country. Each one of them will take a path consisting of some cities. Each path is represented by an integer array that contains the visited cities in order. The path may contain a city more than once, but the same city will not be listed consecutively.

Given an integer n and a 2D integer array paths where paths[i] is an integer array representing the path of the i-th friend, return the length of the longest common subpath that is shared by every friend's path, or 0 if there is no common subpath at all.

A subpath of a path is a contiguous sequence of cities within that path.

Input & Output

Example 1 — Basic Case

$ Input: n = 5, paths = [[0,1,2,3,4],[2,3,4],[4,0,3,2,1,5]]

› Output: 1

💡 Note: The longest common subpath has length 1. City 4 appears in all three paths: at paths[0][4], paths[1][2], and paths[2][0]. No subpath of length 2 or more appears in all paths.

Example 2 — No Common Subpath

$ Input: n = 3, paths = [[0,1,2],[1,2,0],[2,0,1]]

› Output: 0

💡 Note: No subpath of length > 0 appears in all three paths due to different orderings

Example 3 — Single City Common

$ Input: n = 4, paths = [[0,1,2],[2,3],[1,2,3]]

› Output: 1

💡 Note: City 2 appears in all paths: paths[0][2], paths[1][0], paths[2][1]. So longest common subpath has length 1.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ m ≤ 10³
1 ≤ paths[i].length ≤ 10⁵
0 ≤ paths[i][j] < n
All paths[i] are distinct

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8 a Amazon 5

The key insight is to use binary search on the answer length combined with rolling hash for efficient subpath comparison. We binary search from 0 to minimum path length, and for each candidate length, use polynomial rolling hash to generate all subpaths and find intersection across all friend paths. Best approach is Binary Search + Rolling Hash with Time: O(L × m × log L), Space: O(L × m).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Binary Search with Rolling Hash

⏱️ Time: O(L × m × log L) Space: O(L × m)

Use binary search to find the maximum possible length, and for each candidate length, use rolling hash to efficiently check if any subpath of that length exists in all friend paths.

Brute Force

⏱️ Time: O(L⁴ × m) Space: O(L³)

For each possible length, generate all subpaths of that length from the first friend's path, then check if each subpath exists in all other friends' paths. Return the maximum length found.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(int** matrix, int matrixSize, int* matrixColSize, int* returnSize) {
    int* result = (int*)malloc(matrixSize * matrixColSize[0] * sizeof(int));
    *returnSize = 0;
    
    // Find minimum in each row
    int* rowMins = (int*)malloc(matrixSize * sizeof(int));
    for (int i = 0; i < matrixSize; i++) {
        rowMins[i] = matrix[i][0];
        for (int j = 1; j < matrixColSize[i]; j++) {
            if (matrix[i][j] < rowMins[i]) {
                rowMins[i] = matrix[i][j];
            }
        }
    }
    
    // Find maximum in each column
    int* colMaxs = (int*)malloc(matrixColSize[0] * sizeof(int));
    for (int j = 0; j < matrixColSize[0]; j++) {
        colMaxs[j] = matrix[0][j];
        for (int i = 1; i < matrixSize; i++) {
            if (matrix[i][j] > colMaxs[j]) {
                colMaxs[j] = matrix[i][j];
            }
        }
    }
    
    for (int i = 0; i < matrixSize; i++) {
        for (int j = 0; j < matrixColSize[i]; j++) {
            if (matrix[i][j] == rowMins[i] && matrix[i][j] == colMaxs[j]) {
                result[(*returnSize)++] = matrix[i][j];
            }
        }
    }
    
    free(rowMins);
    free(colMaxs);
    return result;
}

int main() {
    char input[10000];
    if (fgets(input, sizeof(input), stdin) == NULL) {
        printf("[]\n");
        return 0;
    }
    
    // Simple parsing - remove brackets and parse numbers
    int matrix[50][50];
    int matrixSize = 0;
    int matrixColSize[50];
    
    // Parse the input string manually
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find first [
    if (!*ptr) {
        printf("[]\n");
        return 0;
    }
    ptr++; // Skip [
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++; // Skip [
            int col = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
                    int num = 0;
                    int sign = 1;
                    if (*ptr == '-') {
                        sign = -1;
                        ptr++;
                    }
                    while (*ptr >= '0' && *ptr <= '9') {
                        num = num * 10 + (*ptr - '0');
                        ptr++;
                    }
                    matrix[matrixSize][col++] = sign * num;
                } else {
                    ptr++;
                }
            }
            matrixColSize[matrixSize] = col;
            matrixSize++;
            if (*ptr == ']') ptr++; // Skip ]
        } else {
            ptr++;
        }
    }
    
    // Convert to pointer array
    int** matrixPtr = (int**)malloc(matrixSize * sizeof(int*));
    for (int i = 0; i < matrixSize; i++) {
        matrixPtr[i] = matrix[i];
    }
    
    int returnSize;
    int* result = solution(matrixPtr, matrixSize, matrixColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(matrixPtr);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

8.2K Views

Medium Frequency

~45 min Avg. Time

267 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