Sequence Reconstruction

Sequence Reconstruction - Problem

You are given an integer array nums of length n where nums is a permutation of the integers in the range [1, n]. You are also given a 2D integer array sequences where sequences[i] is a subsequence of nums.

Check if nums is the shortest possible and the only supersequence. The shortest supersequence is a sequence with the shortest length and has all sequences[i] as subsequences.

There could be multiple valid supersequences for the given array sequences. For example, for sequences = [[1,2],[1,3]], there are two shortest supersequences, [1,2,3] and [1,3,2]. While for sequences = [[1,2],[1,3],[1,2,3]], the only shortest supersequence possible is [1,2,3].

Return true if nums is the only shortest supersequence for sequences, or false otherwise.

A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Unique Sequence

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

› Output: true

💡 Note: The sequences force a unique ordering: 1 must come first (from [1]), then 2, then 3 (from [1,2,3]). Only [1,2,3] satisfies all constraints.

Example 2 — Multiple Valid Orderings

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

› Output: false

💡 Note: Both [1,2,3] and [1,3,2] satisfy the constraints. Since there are multiple valid shortest supersequences, return false.

Example 3 — Invalid Coverage

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

› Output: false

💡 Note: The sequences don't provide enough constraints to uniquely determine the order between all elements.

Constraints

1 ≤ n ≤ 10⁴
nums is a permutation of [1, n]
1 ≤ sequences.length ≤ 10⁴
1 ≤ sequences[i].length ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 a Amazon 28

Use topological sorting to determine if there's a unique ordering. Build a directed graph from sequences, then check if topological sort produces exactly one valid path. The key insight is that uniqueness requires having exactly one node with indegree 0 at each step. Time: O(V + E), Space: O(V + E)

Common Approaches

✓ Brute Force Validation

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

First validate that all given sequences are subsequences of nums, then check if any other permutation could work. This approach checks all constraints but doesn't efficiently determine uniqueness.

Topological Sort

⏱️ Time: O(V + E) Space: O(V + E)

Create a directed graph from the sequences where an edge from A to B means A must come before B. Then perform topological sort to check if there's exactly one valid ordering.

Brute Force Validation — Algorithm Steps

Step 1: Verify all sequences are subsequences of nums
Step 2: Check if constraints force unique ordering

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

nums=[1,2,3], sequences=[[1,2],[1,3]]

Validate

Check each sequence is subsequence of nums

Result

Basic validation complete

Code -

solution.c — C

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

static int graph[10001][10001];
static int graphSize[10001];
static int indegree[10001];
static int result[10001];
static int nums[10001];
static int sequences[1000][1000];
static int sequencesColSize[1000];

bool solution(int* numsArr, int numsSize, int sequencesSize) {
    int n = numsSize;
    if (n == 0) {
        return sequencesSize == 0;
    }
    
    // Reset arrays
    memset(graphSize, 0, sizeof(graphSize));
    memset(indegree, 0, sizeof(indegree));
    
    // Check if all elements in sequences are valid
    bool allNums[10001] = {false};
    bool covered[10001] = {false};
    
    for (int i = 0; i < numsSize; i++) {
        allNums[numsArr[i]] = true;
    }
    
    for (int i = 0; i < sequencesSize; i++) {
        for (int j = 0; j < sequencesColSize[i]; j++) {
            int num = sequences[i][j];
            if (!allNums[num]) {
                return false;
            }
            covered[num] = true;
        }
    }
    
    // All elements must be covered by sequences
    for (int i = 0; i < numsSize; i++) {
        if (!covered[numsArr[i]]) {
            return false;
        }
    }
    
    // Initialize indegree for all numbers
    for (int i = 0; i < numsSize; i++) {
        indegree[numsArr[i]] = 0;
    }
    
    // Add edges based on sequence constraints
    for (int i = 0; i < sequencesSize; i++) {
        for (int j = 0; j < sequencesColSize[i] - 1; j++) {
            int from = sequences[i][j];
            int to = sequences[i][j+1];
            
            // Check if edge already exists
            bool exists = false;
            for (int k = 0; k < graphSize[from]; k++) {
                if (graph[from][k] == to) {
                    exists = true;
                    break;
                }
            }
            
            if (!exists) {
                graph[from][graphSize[from]++] = to;
                indegree[to]++;
            }
        }
    }
    
    // Topological sort with uniqueness check
    int queue[10001];
    int queueSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (indegree[numsArr[i]] == 0) {
            queue[queueSize++] = numsArr[i];
        }
    }
    
    int resultSize = 0;
    
    while (queueSize > 0) {
        // If more than one node has indegree 0, ordering is not unique
        if (queueSize > 1) {
            return false;
        }
        
        int curr = queue[0];
        // Shift queue
        for (int i = 0; i < queueSize - 1; i++) {
            queue[i] = queue[i + 1];
        }
        queueSize--;
        
        result[resultSize++] = curr;
        
        for (int i = 0; i < graphSize[curr]; i++) {
            int neighbor = graph[curr][i];
            indegree[neighbor]--;
            if (indegree[neighbor] == 0) {
                queue[queueSize++] = neighbor;
            }
        }
    }
    
    // Check if we processed all nodes and got the exact sequence
    if (resultSize != n) {
        return false;
    }
    
    for (int i = 0; i < n; i++) {
        if (result[i] != numsArr[i]) {
            return false;
        }
    }
    
    return true;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to '['
    while (*p && *p != '[') p++;
    if (!*p) return;
    p++; // skip '['
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endptr;
        int num = (int)strtol(p, &endptr, 10);
        if (endptr != p) {
            arr[(*size)++] = num;
            p = endptr;
        } else {
            p++;
        }
    }
}

void parse2DArray(const char* str, int* seqCount) {
    *seqCount = 0;
    const char* p = str;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (!*p) return;
    p++; // skip outer '['
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '[') {
            // Parse inner array
            p++; // skip inner '['
            sequencesColSize[*seqCount] = 0;
            
            while (*p && *p != ']') {
                // Skip whitespace and commas
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']' || *p == '\0') break;
                
                // Parse number
                char* endptr;
                int num = (int)strtol(p, &endptr, 10);
                if (endptr != p) {
                    sequences[*seqCount][sequencesColSize[*seqCount]++] = num;
                    p = endptr;
                } else {
                    p++;
                }
            }
            
            if (*p == ']') p++; // skip inner ']'
            (*seqCount)++;
        } else {
            p++;
        }
    }
}

int main() {
    char line1[100000], line2[100000];
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int numsSize;
    parseArray(line1, nums, &numsSize);
    
    int sequencesSize;
    parse2DArray(line2, &sequencesSize);
    
    bool result = solution(nums, numsSize, sequencesSize);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Check each sequence against nums, where m is total elements in sequences

✓ Linear Growth

Space Complexity

O(1)

Only using variables for validation

✓ Linear Space

32.4K Views

Medium Frequency

~25 min Avg. Time

1.2K 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 Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler