剑指 Offer II 115. 重建序列（中等 图 bfs 数组 拓扑排序）

剑指 Offer II 115. 重建序列

请判断原始的序列 org 是否可以从序列集 seqs 中唯一地 重建 。

序列 org 是 1 到 n 整数的排列，其中 1 ≤ n ≤ 104。重建 是指在序列集 seqs 中构建最短的公共超序列，即 seqs 中的任意序列都是该最短序列的子序列。

示例 1：

输入: org = [1,2,3], seqs = [[1,2],[1,3]]
输出: false
解释：[1,2,3] 不是可以被重建的唯一的序列，因为 [1,3,2] 也是一个合法的序列。
示例 2：

输入: org = [1,2,3], seqs = [[1,2]]
输出: false
解释：可以重建的序列只有 [1,2]。
示例 3：

输入: org = [1,2,3], seqs = [[1,2],[1,3],[2,3]]
输出: true
解释：序列 [1,2], [1,3] 和 [2,3] 可以被唯一地重建为原始的序列 [1,2,3]。
示例 4：

输入: org = [4,1,5,2,6,3], seqs = [[5,2,6,3],[4,1,5,2]]
输出: true

提示：

1 <= n <= 104
org 是数字 1 到 n 的一个排列
1 <= segs[i].length <= 105
seqs[i][j] 是 32 位有符号整数

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ur2n8P
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

与前面的拓扑排序题相比，本题的所有节点的入度最大为 1，也就是说在 bfs 遍历的时候，队列中的元素个数最多为 1。
1、构造图。对 seqs 中的元素进行遍历，用一个哈希表储存所有节点及邻接点，同时用另一个哈希表存储所有节点的入度。
2、bfs。先用队列存储度为 0 的节点（应该只有一个），接着进行 bfs 遍历，理论上队列的长度一直为 1 直到节点全部遍历，所以 while 循环的退出条件可以是队列的长度不为 1。在遍历节点的过程中用动态数组存储遍历的节点。
3、将上一步中的动态数组的节点顺序与 org 进行比较，如果相同则返回 true 否则返回 false。

题解（Java）

class Solution {
    public boolean sequenceReconstruction(int[] org, List<List<Integer>> seqs) {
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        Map<Integer, Integer> record = new HashMap<>();

        for (List<Integer> seq : seqs) {
            for (int num : seq) {
                if (num < 1 || num > org.length) {
                    return false;
                }

                graph.putIfAbsent(num, new HashSet<>());
                record.putIfAbsent(num, 0);
            }

            for (int i = 1; i < seq.size(); i++) {
                int num1 = seq.get(i - 1);
                int num2 = seq.get(i);
                if (!graph.get(num1).contains(num2)) {
                    graph.get(num1).add(num2);
                    record.put(num2, record.get(num2) + 1);
                }
            }
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int key : record.keySet()) {
            if (record.get(key) == 0) {
                queue.offer(key);
            }
        }

        List<Integer> list = new LinkedList<>();
        while (queue.size() == 1) {
            int i = queue.poll();
            list.add(i);
            for (int next : graph.get(i)) {
                record.put(next, record.get(next) - 1);
                if (record.get(next) == 0) {
                    queue.offer(next);
                }
            }
        }

        int[] ans = new int[list.size()];
        ans = list.stream().mapToInt(i->i).toArray();
        return Arrays.equals(ans, org);
    }
}