【Lintcode】605. Sequence Reconstruction

题目地址：

https://www.lintcode.com/problem/sequence-reconstruction/description

给定一个数组org，和一个数组的数组seqs，其中显然seqs里的数组可以组成所谓的最短父序列（父序列的意思是，seqs里任一序列是其子序列），最短父序列的存在性是显然的，但未必唯一，例如$[[1,2],[1,3]]$的父序列就有$[1,2,3]$和$[1,3,2]$。这里的题目问，org是不是seqs的序列的唯一的最短父序列。

思路是拓扑排序。我们将seqs里的所有序列视为图模型里的邻接表，显然任何一个这个图的拓扑排序都是其一个父序列，并且任一父序列也必然是一种拓扑排序。所有我们只需要判断这个图只有一个拓扑排序，并且这个拓扑排序正好是org即可。拓扑排序唯一等价于整个代码如下：

import java.util.*;

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) {
        // write your code here
        // nexts是邻接表，indegree记录每个顶点的入度
        Map<Integer, Set<Integer>> nexts = new HashMap<>();
        Map<Integer, Integer> indegree = new HashMap<>();
        
        // 先处理几个边界情况。
        // 如果org是空数组，并且seqs也是空数组，那返回true
        if (org.length == 0 && (seqs.length == 0 || (seqs.length == 1 && seqs[0].length == 0))) {
            return true;
        }
        // 否则，如果其一是空数组则返回false
        if (org.length == 0 || seqs.length == 0 || seqs[0].length == 0) {
            return false;
        }
    	
        for (int i : org) {
            indegree.put(i, 0);
            nexts.put(i, new HashSet<>());
        }
        
        for (int[] seq : seqs) {
        	// 如果seq第一个数越界了，直接返回false
            if (seq[0] <= 0 || seq[0] > org.length) {
                return false;
            }
            
            for (int i = 0; i < seq.length - 1; i++) {
            	// 每次循环先判断seq里的数有没有越界
                if (seq[i + 1] <= 0 || seq[i + 1] > org.length) {
                    return false;
                }
                
                if (nexts.get(seq[i]).add(seq[i + 1])) {
                    indegree.put(seq[i + 1], indegree.getOrDefault(seq[i + 1], 0) + 1);
                }
            }
        }
        
        Queue<Integer> queue = new LinkedList<>();
        // 先让入度为0的顶点全部入队
        for (Map.Entry<Integer, Integer> entry : indegree.entrySet()) {
            if (entry.getValue() == 0) {
                queue.offer(entry.getKey());
            }
        }
        
        int ind = 0;
        while (!queue.isEmpty()) {
        	// 如果queue的size不是1，说明此时有若干元素先后次序可以调换，
        	// 仍然可以得到合法的拓扑排序，此种情况返回false
            if (queue.size() != 1) {
                return false;
            }
            
            int cur = queue.poll();
            // 如果拓扑排序的长度超过了org，或者某一位和org不等了，直接返回false
            if (ind >= org.length || org[ind] != cur) {
                return false;
            }
            
            for (int next : nexts.get(cur)) {
                indegree.put(next, indegree.get(next) - 1);
                if (indegree.get(next) == 0) {
                    queue.offer(next);
                }
            }
            // 排序下一个位置
            ind++;
        }
        // 若未出现任何矛盾则返回true
        return true;
    }
}

时空复杂度$O(N+E)$。