Description

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 ≤ 10⁴. 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.

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

UPDATE (2017/1/8):
The seqs parameter had been changed to a list of list of strings (instead of a 2d array of strings). Please reload the code definition to get the latest changes.

Solution

很tricky的一道题。首先注意org是1到n的一个permutation，说明里面不能存在重复元素。
For org to be uniquely reconstructible from seqs we need to satisfy 2 conditions:

Every sequence in seqs should be a subsequence in org. This part is obvious.
Every 2 consecutive elements in org should be consecutive elements in some sequence from seqs. Why is that? Well, suppose condition 1 is satisfied. Then for 2 any consecutive elements x and y in org we have 2 options.
We have both xand y in some sequence from seqs. Then (as condition 1 is satisfied) they must be consequtive elements in this sequence.
There is no sequence in seqs that contains both x and y. In this case we cannot uniquely reconstruct org from seqs as sequence with x and y switched would also be a valid original sequence for seqs.
So this are 2 necessary criterions. It is pretty easy to see that this are also sufficient criterions for org to be uniquely reconstructible (there is only 1 way to reconstruct sequence when we know that condition 2 is satisfied).

To implement this idea I have idxs hash that maps item to its index in org sequence to check condition 1. And I have pairs set that holds all consequitive element pairs for sequences from seqs to check condition 2 (I also consider first elements to be paired with previous undefined elements, it is necessary to check this).

题目中如果org是seqs的唯一reconstructible seq，需要满足以下几个条件：

• seqs中的所有seq都是org的subsequence。可以遍历seq检查前后的index是否满足条件即可，注意处理重复元素。
• org中的每两个连续的元素对都必须出现在seqs中的某些seq中，这样才能保证org是唯一的！判断这个条件其实不难，用一个boolean[] pairs数组辅助，pairs[i]代表(org[i - 1], org[i])是否存在在seqs中。注意要考虑i == 0的情况，否则下面这个test case: [1], []，会Fail。

class Solution {
    public boolean sequenceReconstruction(int[] org, List<List<Integer>> seqs) {
        int n = org.length;
        Map<Integer, Integer> val2Idx = new HashMap<>();
        boolean[] pairs = new boolean[n];
        
        for (int i = 0; i < org.length; ++i) {
            val2Idx.put(org[i], i);
        }
        
        for (List<Integer> seq : seqs) {
            for (int i = 0; i < seq.size(); ++i) {
                if (!val2Idx.containsKey(seq.get(i))) {
                    return false;
                }
                
                int preIdx = i > 0 ? val2Idx.get(seq.get(i - 1)) : -1;  // important!
                int idx = val2Idx.get(seq.get(i));
                
                if (preIdx >= idx) {    // obey order or duplicate chars
                    return false; 
                }      
                if (preIdx + 1 == idx) {    // mark pair exists
                    pairs[idx] = true;
                }
            }
        }
        
        for (int i = 0; i < org.length; ++i) {
            if (!pairs[i]) {
                return false;
            }
        }
        
        return true;
    }
}