0
点赞
收藏
分享

微信扫一扫

构建数据工程师能力模型,实战八大企业级项目

构建数据工程师能力模型,实战八大企业级项目

download:http://www.51xuebc.com/thread-457-1-1.html

剑指 Offer II 115. 重建序列 : 拓扑排序结构题

这是 LeetCode 上的 剑指 Offer II 115. 重建序列 ,难度为 中等。

Tag : 「图论」、「拓扑排序」、「建图」、「图论 BFS」

给定一个长度为 n 的整数数组 nums ,其中 nums 是范围为 [1,n][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,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<=sequences[i][j]<=n1 <= sequences[i][j] <= n1<=sequences[i][j]<=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<Integer> 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<number>(N).fill(-1), e = new Array<number>(N).fill(0), ne = new Array<number>(N).fill(0), ind = new Array<number>(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<number>()

   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 道标题,局部是有锁题,我们将先把一切不带锁的标题刷完。

在这个系列文章里面,除了解说解题思绪以外,还会尽可能给出最为简约的代码。假如触及通解还会相应的代码模板。


举报

相关推荐

0 条评论