Longest Common Subpath - Practice Coding Problems

Longest Common Subpath - Problem

Imagine a country with n cities numbered from 0 to n-1, where every city is connected to every other city by roads. You have m friends who are each traveling through this country, taking different routes.

Each friend's journey is represented as an array of cities they visit in order. For example, if a friend visits cities [1, 3, 2, 4], they go from city 1 to 3, then to 2, then to 4. A friend might visit the same city multiple times during their journey, but won't visit the same city twice in a row.

Your task is to find the longest common subpath that all friends share during their travels. A subpath is a contiguous sequence of cities within a path.

Goal: Return the length of the longest subpath that appears in every friend's journey, or 0 if no such common subpath exists.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The longest common subpath is [2,3] which has length 2. All three friends visit cities 2 and 3 consecutively in their journeys.

example_2.py — No Common Subpath

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

› Output: 0

💡 Note: Each friend visits only one city, and they all visit different cities. There is no common subpath shared by all friends.

example_3.py — Single City Common

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

› Output: 1

💡 Note: Both friends visit cities 0, 1, 2, 3, and 4, but in reverse order. The longest common subpath is any single city they both visit, so the answer is 1.

Visualization

Tap to expand

Understanding the Visualization

Collect all travel data

Each friend provides their complete travel route as a sequence of cities visited

Binary search on route length

Instead of checking every possible route length, we intelligently narrow down using binary search

Generate route signatures

For each candidate length, we create unique 'fingerprints' (hashes) for all possible route segments

Find common signatures

We keep only the route signatures that appear in EVERY friend's journey

Optimize the search

If we find a common route of length k, we try to find longer ones; otherwise, we try shorter ones

Key Takeaway

🎯 Key Insight: By using binary search on the length and rolling hash for efficient comparison, we can find the longest common travel route in optimal time, just like finding the longest shared journey among friends' road trips!

Time & Space Complexity

Time Complexity

⏱️

O(n * m³ * L³)

n paths, each of length m, checking all subpaths of all lengths L

✓ Linear Growth

Space Complexity

O(L)

Space to store current subpath being checked

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
2 ≤ m ≤ 10³ (m is the number of friends)
1 ≤ paths[i].length ≤ 10⁵
0 ≤ paths[i][j] < n
Important: The same city will not appear consecutively in a path
1 ≤ sum(paths[i].length) ≤ 10⁵

Asked in

G Google 85 a Amazon 72 f Meta 68 ⊞ Microsoft 45

The optimal solution uses binary search on the answer combined with rolling hash to efficiently check for common subpaths. The key insight is that if a common subpath of length k exists, we should look for longer ones; otherwise, we should look for shorter ones. This monotonic property allows us to binary search on the length while using polynomial rolling hash to avoid expensive string comparisons, achieving O(m * L * log(L)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subpaths)	O(n * m³ * L³)	O(L)	Generate all possible subpaths and check if they exist in every friend's path
Binary Search + Rolling Hash (Optimal)	O(m * L * log(L))	O(m * L)	Binary search on answer length, use rolling hash to efficiently check subpaths

Brute Force (Check All Subpaths) — Algorithm Steps

Start with the maximum possible subpath length
Generate all subpaths of current length from first friend's path
For each subpath, check if it exists in all other friends' paths
If found, return current length; otherwise, try shorter length
Continue until length becomes 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with longest possible length

Begin checking subpaths from maximum possible length

Generate all subpaths

Create all subpaths of current length from first friend's path

Check against all paths

For each subpath, verify it exists in every friend's journey

Return first match

When we find a common subpath, return its length

Code -

solution.c — C

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

bool containsSubpath(int* path, int pathLen, int* subpath, int subLen) {
    if (subLen > pathLen) return false;
    for (int i = 0; i <= pathLen - subLen; i++) {
        bool match = true;
        for (int j = 0; j < subLen; j++) {
            if (path[i + j] != subpath[j]) {
                match = false;
                break;
            }
        }
        if (match) return true;
    }
    return false;
}

int longestCommonSubpath(int n, int** paths, int* pathLengths, int numPaths) {
    int maxLen = pathLengths[0];
    for (int i = 1; i < numPaths; i++) {
        if (pathLengths[i] < maxLen) {
            maxLen = pathLengths[i];
        }
    }
    
    for (int length = maxLen; length > 0; length--) {
        int* firstPath = paths[0];
        for (int start = 0; start <= pathLengths[0] - length; start++) {
            bool foundInAll = true;
            for (int i = 1; i < numPaths; i++) {
                if (!containsSubpath(paths[i], pathLengths[i], &firstPath[start], length)) {
                    foundInAll = false;
                    break;
                }
            }
            
            if (foundInAll) return length;
        }
    }
    
    return 0;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m³ * L³)

n paths, each of length m, checking all subpaths of all lengths L

✓ Linear Growth

Space Complexity

O(L)

Space to store current subpath being checked

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
2 ≤ m ≤ 10³ (m is the number of friends)
1 ≤ paths[i].length ≤ 10⁵
0 ≤ paths[i][j] < n
Important: The same city will not appear consecutively in a path
1 ≤ sum(paths[i].length) ≤ 10⁵

58.3K Views

High Frequency

~35 min Avg. Time

1.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

Brute Force (Check All Subpaths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler