Sequence Reconstruction Problem

Problem

Check whether the original sequence org can be uniquely reconstructed from the sequences in seqs. The org sequence is a permutation of the integers from 1 to n, with 1 ≤ n ≤ 104. Reconstruction means building a shortest common supersequence of the sequences in seqs (i.e., a shortest sequence so that all sequences in seqs are subsequences of it). Determine whether there is only one sequence that can be reconstructed from seqs and it is the org sequence.

Examples

Examples

Example 1

Input:
org: [1,2,3], seqs: [[1,2],[1,3]]
Output:


false

Explanation:

[1,2,3] is not the only one sequence that can be reconstructed, because [1,3,2] is also a valid sequence that can be reconstructed.

Example 2

Input:

org: [1,2,3], seqs: [[1,2]]

Output:


false

Explanation:

The reconstructed sequence can only be [1,2].

Example 3

Input:

org: [1,2,3], seqs: [[1,2],[1,3],[2,3]]

Output:


true

Explanation:

The sequences [1,2], [1,3], and [2,3] can uniquely reconstruct the original sequence [1,2,3].

Example 4

Input:

org: [4,1,5,2,6,3], seqs: [[5,2,6,3],[4,1,5,2]]

Output:


true

Solution

Method 1 – Topological Sort with Uniqueness Check

Intuition

We can model the problem as a directed graph and use topological sort. If at any point there is more than one node with in-degree zero, the reconstruction is not unique. We also need to check that the reconstructed sequence matches the original.

Approach

1. Build the graph and in-degree map from seqs.
2. Use a queue to perform topological sort:
   • At each step, if there is more than one node with in-degree zero, return False.
   • Otherwise, pop the node, add to result, and decrease in-degree of its neighbors.
3. At the end, check if the result matches org and all nodes are used.

Code

C++

class Solution {
public:
    bool sequenceReconstruction(vector<int>& org, vector<vector<int>>& seqs) {
        unordered_map<int, unordered_set<int>> g;
        unordered_map<int, int> indeg;
        for (auto& seq : seqs) {
            for (int i = 0; i < seq.size(); ++i) {
                if (!g.count(seq[i])) g[seq[i]] = {};
                if (!indeg.count(seq[i])) indeg[seq[i]] = 0;
                if (i > 0 && g[seq[i-1]].insert(seq[i]).second) indeg[seq[i]]++;
            }
        }
        if (g.size() != org.size()) return false;
        queue<int> q;
        for (auto& [k, v] : indeg) if (v == 0) q.push(k);
        vector<int> res;
        while (!q.empty()) {
            if (q.size() > 1) return false;
            int u = q.front(); q.pop();
            res.push_back(u);
            for (int v : g[u]) if (--indeg[v] == 0) q.push(v);
        }
        return res == org;
    }
};

Go

func sequenceReconstruction(org []int, seqs [][]int) bool {
    g := map[int]map[int]bool{}
    indeg := map[int]int{}
    for _, seq := range seqs {
        for i, v := range seq {
            if _, ok := g[v]; !ok { g[v] = map[int]bool{} }
            if _, ok := indeg[v]; !ok { indeg[v] = 0 }
            if i > 0 && !g[seq[i-1]][v] {
                g[seq[i-1]][v] = true
                indeg[v]++
            }
        }
    }
    if len(g) != len(org) { return false }
    q := []int{}
    for k, v := range indeg { if v == 0 { q = append(q, k) } }
    res := []int{}
    for len(q) > 0 {
        if len(q) > 1 { return false }
        u := q[0]; q = q[1:]
        res = append(res, u)
        for v := range g[u] {
            indeg[v]--
            if indeg[v] == 0 { q = append(q, v) }
        }
    }
    if len(res) != len(org) { return false }
    for i := range org {
        if res[i] != org[i] { return false }
    }
    return true
}

Java

import java.util.*;
class Solution {
    public boolean sequenceReconstruction(int[] org, List<List<Integer>> seqs) {
        Map<Integer, Set<Integer>> g = new HashMap<>();
        Map<Integer, Integer> indeg = new HashMap<>();
        for (List<Integer> seq : seqs) {
            for (int i = 0; i < seq.size(); ++i) {
                g.putIfAbsent(seq.get(i), new HashSet<>());
                indeg.putIfAbsent(seq.get(i), 0);
                if (i > 0 && g.get(seq.get(i-1)).add(seq.get(i))) indeg.put(seq.get(i), indeg.get(seq.get(i))+1);
            }
        }
        if (g.size() != org.length) return false;
        Queue<Integer> q = new LinkedList<>();
        for (int k : indeg.keySet()) if (indeg.get(k) == 0) q.offer(k);
        List<Integer> res = new ArrayList<>();
        while (!q.isEmpty()) {
            if (q.size() > 1) return false;
            int u = q.poll();
            res.add(u);
            for (int v : g.get(u)) if (indeg.put(v, indeg.get(v)-1) == 1) q.offer(v);
        }
        if (res.size() != org.length) return false;
        for (int i = 0; i < org.length; ++i) if (res.get(i) != org[i]) return false;
        return true;
    }
}

Kotlin

class Solution {
    fun sequenceReconstruction(org: IntArray, seqs: List<List<Int>>): Boolean {
        val g = mutableMapOf<Int, MutableSet<Int>>()
        val indeg = mutableMapOf<Int, Int>()
        for (seq in seqs) {
            for (i in seq.indices) {
                g.getOrPut(seq[i]) { mutableSetOf() }
                indeg.putIfAbsent(seq[i], 0)
                if (i > 0 && g[seq[i-1]]!!.add(seq[i])) indeg[seq[i]] = indeg[seq[i]]!! + 1
            }
        }
        if (g.size != org.size) return false
        val q = ArrayDeque<Int>()
        for ((k, v) in indeg) if (v == 0) q.add(k)
        val res = mutableListOf<Int>()
        while (q.isNotEmpty()) {
            if (q.size > 1) return false
            val u = q.removeFirst()
            res.add(u)
            for (v in g[u]!!) {
                indeg[v] = indeg[v]!! - 1
                if (indeg[v] == 0) q.add(v)
            }
        }
        if (res.size != org.size) return false
        for (i in org.indices) if (res[i] != org[i]) return false
        return true
    }
}

Python

class Solution:
    def sequenceReconstruction(self, org: list[int], seqs: list[list[int]]) -> bool:
        from collections import defaultdict, deque
        g = defaultdict(set)
        indeg = defaultdict(int)
        for seq in seqs:
            for i, v in enumerate(seq):
                if v not in g: g[v] = set()
                if v not in indeg: indeg[v] = 0
                if i > 0 and seq[i] not in g[seq[i-1]]:
                    g[seq[i-1]].add(seq[i])
                    indeg[seq[i]] += 1
        if len(g) != len(org): return False
        q = deque([k for k in indeg if indeg[k] == 0])
        res = []
        while q:
            if len(q) > 1: return False
            u = q.popleft()
            res.append(u)
            for v in g[u]:
                indeg[v] -= 1
                if indeg[v] == 0: q.append(v)
        return res == org

Rust

use std::collections::{HashMap, HashSet, VecDeque};
impl Solution {
    pub fn sequence_reconstruction(org: Vec<i32>, seqs: Vec<Vec<i32>>) -> bool {
        let mut g: HashMap<i32, HashSet<i32>> = HashMap::new();
        let mut indeg: HashMap<i32, i32> = HashMap::new();
        for seq in &seqs {
            for i in 0..seq.len() {
                g.entry(seq[i]).or_insert(HashSet::new());
                indeg.entry(seq[i]).or_insert(0);
                if i > 0 && g.get_mut(&seq[i-1]).unwrap().insert(seq[i]) {
                    *indeg.get_mut(&seq[i]).unwrap() += 1;
                }
            }
        }
        if g.len() != org.len() { return false; }
        let mut q: VecDeque<i32> = indeg.iter().filter(|&(_, &v)| v == 0).map(|(&k, _)| k).collect();
        let mut res = vec![];
        while !q.is_empty() {
            if q.len() > 1 { return false; }
            let u = q.pop_front().unwrap();
            res.push(u);
            for &v in g.get(&u).unwrap() {
                let e = indeg.get_mut(&v).unwrap();
                *e -= 1;
                if *e == 0 { q.push_back(v); }
            }
        }
        res == org
    }
}

TypeScript

class Solution {
    sequenceReconstruction(org: number[], seqs: number[][]): boolean {
        const g = new Map<number, Set<number>>();
        const indeg = new Map<number, number>();
        for (const seq of seqs) {
            for (let i = 0; i < seq.length; ++i) {
                if (!g.has(seq[i])) g.set(seq[i], new Set());
                if (!indeg.has(seq[i])) indeg.set(seq[i], 0);
                if (i > 0 && !g.get(seq[i-1])!.has(seq[i])) {
                    g.get(seq[i-1])!.add(seq[i]);
                    indeg.set(seq[i], indeg.get(seq[i])! + 1);
                }
            }
        }
        if (g.size !== org.length) return false;
        const q: number[] = [];
        for (const [k, v] of indeg) if (v === 0) q.push(k);
        const res: number[] = [];
        while (q.length) {
            if (q.length > 1) return false;
            const u = q.shift()!;
            res.push(u);
            for (const v of g.get(u)!) {
                indeg.set(v, indeg.get(v)! - 1);
                if (indeg.get(v) === 0) q.push(v);
            }
        }
        if (res.length !== org.length) return false;
        for (let i = 0; i < org.length; ++i) if (res[i] !== org[i]) return false;
        return true;
    }
}

Complexity

• ⏰ Time complexity: O(n + m), where n = length of org, m = total number of elements in seqs. We build the graph and do a topological sort.
• 🧺 Space complexity: O(n + m), for the graph and in-degree structures.