【Leetcode】444. Sequence Reconstruction

题目地址：

https://leetcode.com/problems/sequence-reconstruction/

给定一个int数组$A$，再给定一个含有很多int序列的list，问$A$是否是list里所有序列的唯一父序列（序列$p$是序列$q$的父序列的含义是$q$是$p$子序列）。若不是父序列或者父序列不唯一都返回false。

可以用图论建模，将list里所有序列里的数抽象成顶点，如果某个序列里一个数$a$紧接着出现在另一个数$b$之前，那么就在$a$到$b$连一条边$a\to b$。这样，题目就转化为，判断$A$是否是这个有向图的唯一的拓扑排序。

拓扑排序可以用BFS来完成，基本流程是先用邻接表建图，顺便将每个顶点的入度求出来，然后开一个队列，将入度为$0$的顶点入队，每次从队中出数之前都要判断一下队列是否只有一个元素，若不然，则队列里的几个元素在拓扑排序中的顺序可以交换，所以拓扑排序不唯一，直接返回false；否则就将这个元素出队，并将这个元素的邻居的入度都减掉$1$，然后再把入度为$0$的点再入队，重复以上操作。最后判断一下拓扑排序的结果和$A$是否相同即可。代码如下：

import java.util.*;

public class Solution {
    public boolean sequenceReconstruction(int[] org, List<List<Integer>> seqs) {
        if (seqs == null || seqs.isEmpty()) {
            return false;
        }
        
        // indegrees存每个顶点的入度，key代表顶点编号，value代表入度
        Map<Integer, Integer> indegrees = new HashMap<>();
        // buildGraph函数用邻接表建图，并计算了每个顶点的入度存进了indegrees
        Map<Integer, List<Integer>> graph = buildGraph(seqs, indegrees);
        Queue<Integer> queue = new LinkedList<>();
        // 将入度为0的顶点入队
        for (Map.Entry<Integer, Integer> entry : indegrees.entrySet()) {
            if (entry.getValue() == 0) {
                queue.offer(entry.getKey());
            }
        }
        
        // 如果顶点数已经与序列长度不等了，那么org要么不是父序列，要么数字多了，不是最短的父序列，直接返回false
        if (org.length != indegrees.size()) {
            return false;
        }
        
        // 接下来进行拓扑排序，并将结果存进res
        List<Integer> res = new ArrayList<>();
        while (!queue.isEmpty()) {
        	// 如果队列元素个数超过了1，说明拓扑排序不唯一，直接返回false
            if (queue.size() != 1) {
                return false;
            }
            
            int cur = queue.poll();
            res.add(cur);
            if (graph.containsKey(cur)) {
                for (int next : graph.get(cur)) {
                    indegrees.put(next, indegrees.get(next) - 1);
                    if (indegrees.get(next) == 0) {
                        queue.offer(next);
                    }
                }
            }
        }
        
    	// 如果拓扑排序的结果和org长度不等，要么说明有环，不存在拓扑排序，要么说明org并不是拓扑排序；
    	// 两种情况都返回false
        if (org.length != res.size()) {
            return false;
        }
        
        // 接下来将拓扑排序结果与org比对，如果对不上则直接返回false
        for (int i = 0; i < org.length; i++) {
            if (org[i] != res.get(i)) {
                return false;
            }
        }
        
        return true;
    }
    
    private Map<Integer, List<Integer>> buildGraph(List<List<Integer>> seqs, Map<Integer, Integer> indegrees) {
        Map<Integer, List<Integer>> graph = new HashMap<>();
        for (List<Integer> seq : seqs) {
        	// 一定要判断一下序列长度是否为1，如果是1，下面for循环进不去，但还是要记录一下入度为0
            if (seq.size() == 1) {
                indegrees.putIfAbsent(seq.get(0), 0);
            }
            
            for (int i = 0; i < seq.size() - 1; i++) {
                graph.putIfAbsent(seq.get(i), new ArrayList<>());
                graph.get(seq.get(i)).add(seq.get(i + 1));
                indegrees.put(seq.get(i + 1), indegrees.getOrDefault(seq.get(i + 1), 0) + 1);
            }
        }
        
        return graph;
    }
}

时空复杂度$O({\sum }_{i=1}^k{n}_i)$，其中$n_i$表示seqs里的每个序列的长度。