题目地址:
https://www.lintcode.com/problem/sequence-reconstruction/description
给定一个数组org,和一个数组的数组seqs,其中显然seqs里的数组可以组成所谓的最短父序列(父序列的意思是,seqs里任一序列是其子序列),最短父序列的存在性是显然的,但未必唯一,例如 [ [ 1 , 2 ] , [ 1 , 3 ] ] [[1, 2], [1, 3]] [[1,2],[1,3]]的父序列就有 [ 1 , 2 , 3 ] [1,2,3] [1,2,3]和 [ 1 , 3 , 2 ] [1,3,2] [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 ) O(N+E) O(N+E)。