Longest Common Subsequence Between Sorted Arrays

Longest Common Subsequence Between Sorted Arrays - Problem

Find the Longest Common Subsequence Among Multiple Sorted Arrays

You're given an array of integer arrays arrays where each arrays[i] is sorted in strictly increasing order. Your task is to return an integer array representing the longest common subsequence among all the arrays.

A subsequence is a sequence that can be derived from another sequence by deleting some elements (possibly none) without changing the order of the remaining elements. In this problem, we're looking for elements that appear in all arrays while maintaining their relative order.

Key Points:
• All input arrays are already sorted in strictly increasing order
• The result should contain elements that appear in ALL arrays
• Elements in the result should maintain their original order
• If no common elements exist, return an empty array

Input & Output

example_1.py — Basic Common Elements

$ Input: arrays = [[1,3,4], [1,4,7,9], [1,4]]

› Output: [1,4]

💡 Note: Elements 1 and 4 appear in all three arrays. Element 3 appears only in the first array, 7 and 9 only in the second array, so they're not included in the result.

example_2.py — Single Common Element

$ Input: arrays = [[2,3,6,8], [1,2,3,4,5,6], [2,3,4,6,8]]

› Output: [2,3,6]

💡 Note: Elements 2, 3, and 6 appear in all arrays. Element 8 appears in first and third arrays but not second. Element 1 and 5 appear only in second array.

example_3.py — No Common Elements

$ Input: arrays = [[1,2,3], [4,5,6], [7,8,9]]

› Output: []

💡 Note: No elements appear in all three arrays, so the result is an empty array.

Constraints

1 ≤ arrays.length ≤ 1000
1 ≤ arrays[i].length ≤ 1000
1 ≤ arrays[i][j] ≤ 10⁵
arrays[i] is sorted in strictly increasing order

Visualization

Tap to expand

Understanding the Visualization

Count Memberships

Count how many groups each person belongs to

Find Universal Members

Keep only those who belong to ALL groups

Preserve Order

List them in the order they appear in the first group

Key Takeaway

🎯 Key Insight: Use frequency counting with hash maps to efficiently find elements that appear exactly 'number of arrays' times, then preserve order by iterating through the first array!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses a hash map to count element frequencies across all arrays in O(n) time. Elements appearing in all arrays will have count equal to the number of arrays. We then iterate through the first array to maintain the original order and collect elements with the required count.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Element)	O(n * m * k)	O(1)	For each element in first array, check if it exists in all other arrays
Hash Map Counting (Optimal)	O(n)	O(k)	Count occurrences of each element and keep those appearing in all arrays

Brute Force (Check Each Element) — Algorithm Steps

Take the first array as reference
For each element in the first array, check all other arrays
Use binary search or linear search to find element in each array
If element exists in all arrays, add to result
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Reference Array

Choose first array as reference

Check Each Element

For each element, search in all other arrays

Binary Search

Use binary search since arrays are sorted

Collect Results

Add elements found in all arrays

Code -

solution.c — C

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

bool binarySearch(int* arr, int size, int target) {
    int left = 0, right = size - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return true;
        else if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return false;
}

int* longestCommonSubsequence(int** arrays, int* arraySizes, int numArrays, int* returnSize) {
    *returnSize = 0;
    if (numArrays == 0 || arraySizes[0] == 0) {
        return NULL;
    }
    
    int* result = malloc(arraySizes[0] * sizeof(int));
    int resultSize = 0;
    
    for (int i = 0; i < arraySizes[0]; i++) {
        int num = arrays[0][i];
        bool foundInAll = true;
        
        for (int j = 1; j < numArrays; j++) {
            if (!binarySearch(arrays[j], arraySizes[j], num)) {
                foundInAll = false;
                break;
            }
        }
        
        if (foundInAll) {
            result[resultSize++] = num;
        }
    }
    
    *returnSize = resultSize;
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

n arrays, m average elements per array, k searches per element

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

38.5K Views

Medium Frequency

~15 min Avg. Time

1.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 (Check Each Element) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler