描述

判断是否序列 org 能唯一地由 seqs 重构得出. org 是一个由从1 到 n 的正整数排列而成的序列，1 ≤ n ≤ 10^4。 重构表示组合成 seqs 的一个最短的父序列 (意思是，一个最短的序列使得所有 seqs 里的序列都是它的子序列).
判断是否有且仅有一个能从 seqs 重构出来的序列，并且这个序列是org。

样例

给定 org = [1,2,3], seqs = [[1,2],[1,3]]
返回 false
解释:
[1,2,3] 并不是唯一可以被重构出的序列，还可以重构出 [1,3,2]
给出 org = [1,2,3], seqs = [[1,2]]
返回 false
解释:
能重构出的序列只有 [1,2].
给定 org = [1,2,3], seqs = [[1,2],[1,3],[2,3]]
返回 true
解释:
序列 [1,2], [1,3], 和 [2,3] 可以唯一重构出 [1,2,3].
给定org = [4,1,5,2,6,3], seqs = [[5,2,6,3],[4,1,5,2]]
返回 true

思路

用 seqs 进行拓扑排序得到数组，判断 org 是否是唯一解

代码

public class Solution {
    /**
     * @param org a permutation of the integers from 1 to n
     * @param seqs a list of sequences
     * @return true if it can be reconstructed only one or false
     */
    public boolean sequenceReconstruction(int[] org, int[][] seqs) {
        Map<Integer, Set<Integer>> map = new HashMap<Integer, Set<Integer>>();
        Map<Integer, Integer> indegree = new HashMap<Integer, Integer>();
        
        // 给 org 中每个元素进行 map 和度的初始化
        for (int num : org) {
            map.put(num, new HashSet<Integer>());
            indegree.put(num, 0);
        }

        int n = org.length;
        int count = 0;
        // seq 是 seqs 的一维数组
        for (int[] seq : seqs) {
            count += seq.length;
            // seq[0] 和 seq[1] ... seq[n] 要分开写，因为 i - 1 在 i = 0 时会越界
            if (seq.length >= 1 && (seq[0] <= 0 || seq[0] > n)) {
                return false;
            }

            // seq 有两个以上元素时
            for (int i = 1; i < seq.length; i++) {
                // seq 中元素不符合 org 中要求
                if (seq[i] <= 0 || seq[i] > n) {
                    return false;
                }
                // 检查 seq[i] 和 seq[i - 1] 间有没有映射，没有建立个映射
                // 实际上就是去重复，然后添加 hash 并且统计度
                if (map.get(seq[i - 1]).add(seq[i])) {
                    indegree.put(seq[i], indegree.get(seq[i]) + 1);
                }
            }
        }

        // 所有 seq 的长度加一起应该大于等于 n，seq 中可能存在重复元素
        if (count < n) {
            return false;
        }
        
        // bfs  
        // 度为 0 的加入队列
        Queue<Integer> q = new ArrayDeque<Integer>();
        for (int key : indegree.keySet()) {
            if (indegree.get(key) == 0) {
                q.add(key);
            }
        }
        
    // 用 seqs 进行拓扑排序得到新的组合序列，和org每个位置一一对比
        int cnt = 0;
        
        
        // 因为是唯一构成，所以每个元素的先序应该只有一个，即度为1
        // 只有每次queue中只有一个元素的时候，产生的序列才是唯一的
        while (q.size() == 1) {
            int ele = q.poll();
            for (int next : map.get(ele)) {
                indegree.put(next, indegree.get(next) - 1);
                if (indegree.get(next) == 0) {
                    q.add(next);
                }
            }
            // 判断新的序列每个位置和 org 相不相等
            if (ele != org[cnt]) {
                return false;
            }
            cnt++;
        }
        
    // 判断新构造的数组元素总数和 org 相不相等
        // 可能会出现新构造的数组是 org 的子集或者 org 是新构造的数组的子集
        return cnt == org.length;
    }
}