Sequence Reconstruction - Practice Coding Problems

Sequence Reconstruction - Problem

Sequence Reconstruction is a fascinating problem that challenges you to determine if a given sequence is the unique shortest supersequence for a set of subsequences.

You're given:
• An integer array nums of length n where nums is a permutation of integers [1, n]
• A 2D array sequences where each sequences[i] is a subsequence of nums

Your task is to determine if nums is both the shortest possible and the only supersequence that contains all given subsequences.

Think of it as a puzzle: given several incomplete clues about the order of elements, can you uniquely determine the complete sequence? For example, if sequences = [[1,2],[1,3]], both [1,2,3] and [1,3,2] work as shortest supersequences, so the answer is false. But if sequences = [[1,2],[1,3],[1,2,3]], only [1,2,3] works uniquely!

Input & Output

example_1.py — Basic Unique Case

$ Input: nums = [1,2,3], sequences = [[1,2],[1,3]]

› Output: false

💡 Note: Both [1,2,3] and [1,3,2] are valid shortest supersequences. Since nums is not the unique shortest supersequence, return false.

example_2.py — Constrained Unique Case

$ Input: nums = [1,2,3], sequences = [[1,2],[1,3],[2,3]]

› Output: true

💡 Note: The sequences force the order: 1→2, 1→3, and 2→3. This uniquely determines [1,2,3] as the only possible shortest supersequence.

example_3.py — Invalid Reconstruction

$ Input: nums = [4,1,5,2,6,3], sequences = [[5,2,6,3],[4,1,5,2]]

› Output: false

💡 Note: The given sequences don't provide enough constraints to uniquely determine nums as the only shortest supersequence.

Constraints

1 ≤ nums.length ≤ 10⁴
nums.length == n
nums is a permutation of all integers in range [1, n]
1 ≤ sequences.length ≤ 10⁴
1 ≤ sequences[i].length ≤ 10⁴
All values in sequences[i] are in range [1, n]
sequences[i] are subsequences of nums

Visualization

Tap to expand

Understanding the Visualization

Build Dependency Graph

From sequences like [1,2] and [2,3], create edges 1→2 and 2→3

Count Prerequisites

Calculate in-degree for each node (how many dependencies it has)

Process in Order

At each step, exactly one item should be ready (in-degree 0)

Verify Uniqueness

If multiple items are ready simultaneously, reconstruction isn't unique

Key Takeaway

🎯 Key Insight: A sequence reconstruction is unique if and only if at each step of topological sorting, exactly one node has in-degree 0. Multiple nodes with in-degree 0 means multiple valid orderings exist.

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses topological sorting with Kahn's algorithm. Build a directed graph from sequence constraints, then verify that reconstruction is unique by ensuring exactly one node has in-degree 0 at each step. This approach runs in O(n + m×s) time where n is array length, m is number of sequences, and s is average sequence length.

Common Approaches

Approach	Time	Space	Notes
✓ Topological Sort (Optimal)	O(n + m × s)	O(n + E)	Use topological sorting to verify unique reconstruction in one pass
Brute Force Validation	O(n! × m × s)	O(n)	Generate all possible permutations and validate each against the sequences

Topological Sort (Optimal) — Algorithm Steps

Build adjacency list and in-degree count from all sequences
Validate that sequences cover all adjacent pairs in nums
Perform topological sort using Kahn's algorithm
At each step, ensure exactly one node has in-degree 0
Verify the reconstructed sequence matches nums

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create directed graph from sequence constraints

Calculate In-degrees

Count incoming edges for each node

Process Queue

At each step, exactly one node should have in-degree 0

Verify Uniqueness

If multiple nodes have in-degree 0, reconstruction is not unique

Code -

solution.c — C

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

#define MAX_N 1000

typedef struct {
    int* data;
    int front, rear, size;
} Queue;

Queue* createQueue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (int*)malloc(MAX_N * sizeof(int));
    q->front = q->rear = q->size = 0;
    return q;
}

void enqueue(Queue* q, int val) {
    q->data[q->rear++] = val;
    q->size++;
}

int dequeue(Queue* q) {
    q->size--;
    return q->data[q->front++];
}

bool sequenceReconstruction(int* nums, int numsSize, int** sequences, int* sequenceSizes, int sequenceCount) {
    int n = numsSize;
    bool graph[MAX_N][MAX_N] = {false};
    int inDegree[MAX_N] = {0};
    
    // Build graph
    for (int i = 0; i < sequenceCount; i++) {
        for (int j = 0; j < sequenceSizes[i] - 1; j++) {
            int from = sequences[i][j], to = sequences[i][j + 1];
            if (!graph[from][to]) {
                graph[from][to] = true;
                inDegree[to]++;
            }
        }
    }
    
    // Verify all adjacent pairs in nums are covered
    for (int i = 0; i < n - 1; i++) {
        if (!graph[nums[i]][nums[i + 1]]) {
            return false;
        }
    }
    
    // Topological sort
    Queue* queue = createQueue();
    for (int i = 1; i <= n; i++) {
        if (inDegree[i] == 0) {
            enqueue(queue, i);
        }
    }
    
    int result[MAX_N];
    int resultSize = 0;
    
    while (queue->size > 0) {
        if (queue->size != 1) return false;
        
        int current = dequeue(queue);
        result[resultSize++] = current;
        
        for (int i = 1; i <= n; i++) {
            if (graph[current][i]) {
                inDegree[i]--;
                if (inDegree[i] == 0) {
                    enqueue(queue, i);
                }
            }
        }
    }
    
    if (resultSize != n) return false;
    
    for (int i = 0; i < n; i++) {
        if (nums[i] != result[i]) return false;
    }
    
    free(queue->data);
    free(queue);
    return true;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m × s)

n for processing nodes, m sequences with average length s for building graph

✓ Linear Growth

Space Complexity

O(n + E)

n for in-degree array, E for adjacency list edges

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Topological Sort (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler