极客专栏打包-实时更新

download：极客专栏打包-实时更新

剑指 Offer II 115. 重建序列 : 拓扑排序结构题
这是 LeetCode 上的剑指 Offer II 115. 重建序列，难度为中等。
Tag : 「图论」、「拓扑排序」、「建图」、「图论 BFS」
给定一个长度为 n 的整数数组 nums ，其中 nums 是范围为 1，n[1，n] 的整数的排列。还提供了一个 2D 整数数组 sequences，其中 sequences[i] 是 nums 的子序列。
检查 nums 能否是独一的最短超序列。最短超序列是长度最短的序列，并且一切序列 sequences[i] 都是它的子序列。关于给定的数组 sequences，可能存在多个有效的超序列。

例如，关于 sequences = [[1,2],[1,3]] ，有两个最短的超序列，[1,2,3] 和 [1,3,2] 。
而关于 sequences = [[1,2],[1,3],[1,2,3]]，独一可能的最短超序列是 [1,2,3] 。[1,2,3,4] 是可能的超序列，但不是最短的。

假如 nums 是序列的独一最短超序列，则返回 true ，否则返回 false 。
子序列是一个能够经过从另一个序列中删除一些元素或不删除任何元素，而不改动其他元素的次第的序列。
示例 1：
输入：nums = [1,2,3], sequences = [[1,2],[1,3]]

输出：false

解释：有两种可能的超序列：[1,2,3]和[1,3,2]。
序列 [1,2] 是[1,2,3]和[1,3,2]的子序列。
序列 [1,3] 是[1,2,3]和[1,3,2]的子序列。
由于 nums 不是独一最短的超序列，所以返回false。
复制代码
示例 2：
输入：nums = [1,2,3], sequences = [[1,2]]

输出：false

解释：最短可能的超序列为 [1,2]。
序列 [1,2] 是它的子序列：[1,2]。
由于 nums 不是最短的超序列，所以返回false。
复制代码
示例 3：
输入：nums = [1,2,3], sequences = [[1,2],[1,3],[2,3]]

输出：true

解释：最短可能的超序列为[1,2,3]。
序列 [1,2] 是它的一个子序列：[1,2,3]。
序列 [1,3] 是它的一个子序列：[1,2,3]。
序列 [2,3] 是它的一个子序列：[1,2,3]。
由于 nums 是独一最短的超序列，所以返回true。
复制代码
提示：

n==nums.lengthn == nums.lengthn==nums.length
1<=n<=1041 <= n <= 1041<=n<=104
nums 是 1,n[1,n] 范围内一切整数的排列
1<=sequences.length<=1041 <= sequences.length <= 10^41<=sequences.length<=104
1<=sequences[i].length<=1041 <= sequences[i].length <= 1041<=sequences[i].length<=104
1<=sum(sequences[i].length)<=1051 <= sum(sequences[i].length) <= 10^51<=sum(sequences[i].length)<=105
1<=sequencesi<=n1 <= sequencesi <= n1<=sequencesi<=n
sequences 的一切数组都是独一的
sequences[i] 是 nums 的一个子序列

拓扑排序 + 结构
为了便当，我们令 sequences 为 ss。
依据题意，假如我们可以应用一切的 ss[i]ss[i]ss[i] 结构出一个独一的序列，且该序列与 nums 相同，则返回 True，否则返回 False。
将每个 ss[i]ss[i]ss[i] 看做对 ss[i]ss[i]ss[i] 所包含点的前后关系约束，我们能够将问题转换为拓扑排序问题。
应用一切 ss[i]ss[i]ss[i] 结构新图：关于 ss[i]=[A1,A2,...,Ak]ss[i] = [A_1, A_2, ..., A_k]ss[i]=[A1,A2,...,Ak]，我们将其转换为点 A1A_1A1 -> A2A_2A2 -> ... -> AkA_kAk 的有向图，同时统计每个点的入度状况。
然后在新图上跑一遍拓扑排序，结构对应的拓扑序列，与 nums 停止比照。
完成上，由于拓扑排序过程中，出点的次第即为拓扑序，因而我们并不需求完好保管整个拓扑序，只需运用一个变量 loc 来记载当前拓扑序的下标，将出点 ttt 与 nums[loc]nums[loc]nums[loc] 做比拟即可。
在拓扑序过程中若有 ttt 不等于 nums[loc]nums[loc]nums[loc]（结构出来的计划与 nums 不同）或某次拓展过程中发现队列元素不止 111 个（此时可能的缘由有 :「起始入度为 000 的点不止一个或存在某些点基本不在 ssssss 中」或「单次拓展新产生的入度为 000 的点不止一个，即拓扑序不独一」），则直接返回 False，
Java 代码：
class Solution {

int N = 10010, M = N, idx;
int[] he = new int[N], e = new int[M], ne = new int[M], in = new int[N];
void add(int a, int b) {
    e[idx] = b;
    ne[idx] = he[a];
    he[a] = idx++;
    in[b]++;
}
public boolean sequenceReconstruction(int[] nums, int[][] ss) {
    int n = nums.length;
    Arrays.fill(he, -1);
    for (int[] s : ss) {
        for (int i = 1; i < s.length; i++) add(s[i - 1], s[i]);
    }
    Deque d = new ArrayDeque<>();
    for (int i = 1; i <= n; i++) {
        if (in[i] == 0) d.addLast(i);
    }
    int loc = 0;
    while (!d.isEmpty()) {
        if (d.size() != 1) return false;
        int t = d.pollFirst();
        if (nums[loc++] != t) return false;
        for (int i = he[t]; i != -1; i = ne[i]) {
            int j = e[i];
            if (--in[j] == 0) d.addLast(j);
        }
    }
    return true;
}

}
复制代码
TypeScript 代码：
const N = 10010, M = N
const he: number[] = new Array(N).fill(-1), e = new Array(N).fill(0), ne = new Array(N).fill(0), ind = new Array(N).fill(0);
let idx = 0
function add(a: number, b: number): void {

e[idx] = b
ne[idx] = he[a]
he[a] = idx++
ind[b]++

}
function sequenceReconstruction(nums: number[], ss: number[][]): boolean {

he.fill(-1); ind.fill(0)
idx = 0
const n = nums.length
for (const s of ss) {
    for (let i = 1; i < s.length; i++) add(s[i - 1], s[i])
}
const stk: number[] = new Array()
let head = 0, tail = 0
for (let i = 1; i <= n; i++) {
    if (ind[i] == 0) stk[tail++] = i
}
let loc = 0
while (head < tail) {
    if (tail - head > 1) return false
    const t = stk[head++]
    if (nums[loc++] != t) return false
    for (let i = he[t]; i != -1; i = ne[i]) {
        const j = e[i]
        if (--ind[j] == 0) stk[tail++] = j
    }
}
return true

};
复制代码

时间复杂度：建图复杂度为 O(∑i=0n−1ss[i].length)O(\sum_{i = 0}^{n - 1}ss[i].length)O(∑i=0n−1ss[i].length)；跑拓扑排序的复杂度为 O(n+∑i=0n−1ss[i].length)O(n + \sum_{i = 0}^{n - 1}ss[i].length)O(n+∑i=0n−1ss[i].length)。整体复杂度为 O(n+∑i=0n−1ss[i].length)O(n + \sum_{i = 0}^{n - 1}ss[i].length)O(n+∑i=0n−1ss[i].length)
空间复杂度： O(n+∑i=0n−1ss[i].length)O(n + \sum_{i = 0}^{n - 1}ss[i].length)O(n+∑i=0n−1ss[i].length)

最后
这是我们「刷穿 LeetCode」系列文章的第剑指 Offer II 115 篇，系列开端于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道标题，局部是有锁题，我们将先把一切不带锁的标题刷完。
在这个系列文章里面，除了解说解题思绪以外，还会尽可能给出最为简约的代码。假如触及通解还会相应的代码模板。

极客专栏打包-实时更新

download：极客专栏打包-实时更新

你可能感兴趣的:(rust)