C++ 程序设计：重建序列（LeetCode：444）

给定一个长度为 n 的整数数组 nums ，其中 nums 是范围为 [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.length
1 <= n <= 104
nums 是 [1, n] 范围内所有整数的排列
1 <= sequences.length <= 104
1 <= sequences[i].length <= 104
1 <= sum(sequences[i].length) <= 105
1 <= sequences[i][j] <= n
sequences 的所有数组都是 唯一 的
sequences[i] 是 nums 的一个子序列

思路：太久没刷题啦，看到题目一眼没啥思路，感觉只能暴力...（我真是太蠢了...）

言归正传，其实仔细想想，我们可以通过sequences集合寻找突破口，对于sequences[i]，其本质上可看作一个有向图，相邻两个元素之间为一条有向边。若干个序列其实就是若干个有向图，我们要做的就是判断这些有向图组成的nums数组是否唯一。

可以根据有向图之间的连接关系记录每个元素的入度，并将问题转化为一个拓扑排序的问题。按照拓扑排序的思想，首先需要做的是将所有入度为0的点加入队列中。对于该题而言，可以发现，如果当前入度为0的点不唯一的话，则构造出的nums一定不唯一。这里的证明比较直观，因为你当前入度为0的点有多个，呢不就代表nums数组中起始元素可以不唯一啦？

之后按照拓扑排序的操作重复执行即可，在过程中同样需要判断一次拓扑排序后队列的元素个数是否为1（即入度为0的点唯一），如果不唯一则直接返回false。当队列为空时，说明组成的nums唯一，则返回true。

class Solution {
public:
    bool sequenceReconstruction(vector<int>& nums, vector<vector<int>>& sequences) {
        int n = nums.size();
        vector<int> ingrees(n + 1);
        vector<unordered_set<int>> edgees(n + 1);
        for (vector<int> arr : sequences) {
            for (int i = 1; i < arr.size(); ++i) {
                int last = arr[i - 1], now = arr[i];
                if (!edgees[last].count(now)) {
                    edgees[last].insert(now);
                    ++ingrees[now];
                }
            }
        }
        queue<int> q;
        for (int i = 1; i <= n; ++i) {
            if (!ingrees[i]) {
                q.push(i);
            }
        }
        while (!q.empty()) {
            if (q.size() > 1)
                return false;
            int now = q.front(); q.pop();
            for (int v : edgees[now]) {
                --ingrees[v];
                if (!ingrees[v])
                    q.push(v);
            }
        }
        return true;
    }
};