拓扑排序/ - 技术栈

解决拓扑排序问题：

1、根据依赖关系，构建邻接表、和入度数组

2、选取入度为 0 的数据，根据邻接表，减小依赖它的数据的入度

3、找出新入度为 0 的数据，重复第 2 步

4、直至所有数据的入度为 0，得到排序，如果还有数据的入度没有变到 0，说明存在环形依赖

和传统BFS 不一样的地方：

传统BFS：把出列节点的下一层子节点推入 queue，不加甄别

拓扑排序：实施甄别和监控，新入度为 0 的先推入 queue

个人模板

cpp 复制代码

vector<int> TopologicalSorting(int numCourses, vector<vector<int>>& prerequisites) {
    // 定义存储
    vector<vector<int>> edages; // 记录节点：出度节点
    edages.resize(numCourses);
    vector<int> res;    // 返回答案
    vector<int> degree(numCourses); // 记录每个节点的入度数
    // 更新节点关系和入度数
    for (int i = 0; i < prerequisites.size(); ++i) {
        edages[prerequisites[i][1]].emplace_back(prerequisites[i][0]);
        degree[prerequisites[i][0]] += 1;
    }
    // 添加入度节点为0的进入双端队列
    deque<int> de;
    for (int i = 0; i < numCourses; ++i) {
        if (degree[i] == 0) {   // 入度为0
            de.push_back(i);
        }
    }
    // 取出入度为0的节点并更新其他节点的入度
    while (!de.empty()) {
        int node = de.front();
        res.emplace_back(node); // 添加至答案
        de.pop_front();
        for (int d = 0; d < edages[node].size(); ++d) {
            degree[edages[node][d]] -= 1; // 入度数减1
            if (degree[edages[node][d]] == 0) { // 入度数为0时添加至队列
                de.push_back(edages[node][d]);
            }
        }
    }
    return res.size();
}

210. 课程表 II

cpp 复制代码

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        // 定义存储
        vector<vector<int>> edages; // 记录节点：出度节点
        edages.resize(numCourses);
        vector<int> res;    // 返回答案
        vector<int> degree(numCourses); // 记录每个节点的入度数
        // 更新节点关系和入度数
        for (int i = 0; i < prerequisites.size(); ++i) {
            edages[prerequisites[i][1]].emplace_back(prerequisites[i][0]);
            degree[prerequisites[i][0]] += 1;
        }
        // 添加入度节点为0的进入双端队列
        deque<int> de;
        for (int i = 0; i < numCourses; ++i) {
            if (degree[i] == 0) {   // 入度为0
                de.push_back(i);
            }
        }
        // 取出入度为0的节点并更新其他节点的入度
        while (!de.empty()) {
            int node = de.front();
            res.emplace_back(node); // 添加至答案
            de.pop_front();
            for (int d = 0; d < edages[node].size(); ++d) {
                degree[edages[node][d]] -= 1; // 入度数减1
                if (degree[edages[node][d]] == 0) { // 入度数为0时添加至队列
                    de.push_back(edages[node][d]);
                }
            }
        }
        return res.size() == numCourses ? res : vector<int>();
    }
};

444. 序列重建

验证原始的序列 org 是否可以从序列集 seqs 中唯一地重建。

序列 org 是 1 到 n 整数的排列，其中 1 ≤ n ≤ 104。

重建是指在序列集 seqs 中构建最短的公共超序列。（即使得所有 seqs 中的序列都是该最短序列的子序列）。

确定是否只可以从 seqs 重建唯一的序列，且该序列就是 org 。

复制代码

示例 1：
输入：
org: [1,2,3], seqs: [[1,2],[1,3]]
输出：
false
解释：
[1,2,3] 不是可以被重建的唯一的序列，因为 [1,3,2] 也是一个合法的序列。
 
示例 2：
输入：
org: [1,2,3], seqs: [[1,2]]
输出：
false
解释：
可以重建的序列只有 [1,2]。
 
示例 3：
输入：
org: [1,2,3], seqs: [[1,2],[1,3],[2,3]]
输出：
true
解释：
序列 [1,2], [1,3] 和 [2,3] 可以被唯一地重建为原始的序列 [1,2,3]。

示例 4：
输入：
org: [4,1,5,2,6,3], seqs: [[5,2,6,3],[4,1,5,2]]
输出：
true

269. 火星词典

现有一种使用字母的全新语言，这门语言的字母顺序与英语顺序不同。您有一个单词列表（从词典中获得的），该单词列表内的单词已经按这门新语言的字母顺序进行了排序。需要根据这个输入的列表，还原出此语言中已知的字母顺序。

复制代码

示例：

输入:
[
"wrt",
"wrf",
"er",
"ett",
"rftt"
]

输出: "wertf"