手把手教学拓扑排序

手把手教学拓扑排序

在图论中，**拓扑排序（Topological Sorting） 是一个有向无环图（DAG, Directed Acyclic Graph）**的所有顶点的线性序列。且该序列必须满足下面两个条件：

1. 每个顶点出现且只出现一次。
2. 若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。

有向无环图（DAG）才有拓扑排序，非DAG图没有拓扑排序一说。

拓扑排序一般适用于有依赖关系的有向图中，同时也可以用来检测有向图是否有环

过程

1. 建图

2. 记录每一个点的入度

3. 把没有入度的点加入队列，看后面的依赖更新入度

4. 重复3直到队列为空

Tip: 无入度的点其实就是没有依赖关系的点，就是不需要其他条件就能访问得到

建图

图的话我自己一般有三种实现形式

• 实现自己的图类

• map<int,vector<int>>的形式进行存储

• 或者用邻接表的形式vector<list<int>>

算法的流程

自己图类的实现

class Graph {
 public:
  Graph(int n) {
    n_ = n;
    lst_.resize(n, list<int>());
    degree_.resize(n, 0);
  }

  void add(int v, int u) {
    lst_[v].push_back(u);
    ++degree_[u];
  }

 private:
  vector<list<int>> lst_;  // 邻接表
  vector<int> degree_;     // 入度
};

例题

简单版本

207. 课程表

难度中等916

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

• 例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。

请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。

示例 2：

输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

提示：

• 1 <= numCourses <= 105
• 0 <= prerequisites.length <= 5000
• prerequisites[i].length == 2
• 0 <= ai, bi < numCourses
• prerequisites[i] 中的所有课程对 互不相同

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        int n=prerequisites.size();
        vector<int> degree(numCourses,0); // 初始化入度为0
        // 用邻接表建图
        vector<list<int>> mp(numCourses);

        for(int i=0;i<n;i++) {
            mp[prerequisites[i][1]].push_back(prerequisites[i][0]);
            degree[prerequisites[i][0]]++;
        }

        // 开始拓扑排序
        queue<int> que;
        int count = 0;
        // 记录过了多少点
        for(int i=0;i<degree.size();i++) {
            if(degree[i]==0) {
                que.push(i);
            }
        }

        while(!que.empty()) {
            // 队列不可以是空的
            int val = que.front();
            que.pop();
            count++;
            auto vec = mp[val];
            for(auto i=vec.begin();i!=vec.end();i++) {
                degree[*i]--;  // 更新入度
                if(degree[*i]==0) {  // 入度为0加入队列
                    que.push(*i);
                }
            }
        }
        if(count==numCourses) { // 无环
            return true;
        }

        return false; // 有环


    }
};

851. 喧闹和富有

难度中等184

有一组 n 个人作为实验对象，从 0 到 n - 1 编号，其中每个人都有不同数目的钱，以及不同程度的安静值（quietness）。为了方便起见，我们将编号为 x 的人简称为 "person x "。

给你一个数组 richer ，其中 richer[i] = [ai, bi] 表示 person ai 比 person bi 更有钱。另给你一个整数数组 quiet ，其中 quiet[i] 是 person i 的安静值。richer 中所给出的数据 逻辑自洽（也就是说，在 person x 比 person y 更有钱的同时，不会出现 person y 比 person x 更有钱的情况 ）。

现在，返回一个整数数组 answer 作为答案，其中 answer[x] = y 的前提是，在所有拥有的钱肯定不少于 person x 的人中，person y 是最安静的人（也就是安静值 quiet[y] 最小的人）。

示例 1：

输入：richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]
输出：[5,5,2,5,4,5,6,7]
解释： 
answer[0] = 5，
person 5 比 person 3 有更多的钱，person 3 比 person 1 有更多的钱，person 1 比 person 0 有更多的钱。
唯一较为安静（有较低的安静值 quiet[x]）的人是 person 7，
但是目前还不清楚他是否比 person 0 更有钱。
answer[7] = 7，
在所有拥有的钱肯定不少于 person 7 的人中（这可能包括 person 3，4，5，6 以及 7），
最安静（有较低安静值 quiet[x]）的人是 person 7。
其他的答案也可以用类似的推理来解释。

示例 2：

输入：richer = [], quiet = [0]
输出：[0]

提示：

• n == quiet.length
• 1 <= n <= 500
• 0 <= quiet[i] < n
• quiet 的所有值 互不相同
• 0 <= richer.length <= n * (n - 1) / 2
• 0 <= ai, bi < n
• ai != bi
• richer 中的所有数对 互不相同
• 对 richer 的观察在逻辑上是一致的

class Solution {
public:
    vector<int> loudAndRich(vector<vector<int>>& richer, vector<int>& quiet) {
        degree_.resize(quiet.size(),0);
        vector<list<int>> graph_(quiet.size());
        /* 
            首先建图
         */
        for(auto v : richer) {
            // cout<<v[0]<<" "<<v[1]<<endl;
            graph_[v[0]].push_back(v[1]); // 代表的是有钱的指向没钱的
            degree_[v[1]]++;
        }

        vector<int> ans(quiet.size(),-1);
        for(int i=0;i<ans.size();i++) {
            ans[i] = i;
        }
        // 开始进行遍历
        // 首先找到入度为0的点，且如果入度为1那么结果就是自己
        queue<int> que;
        for(int i=0;i<degree_.size();i++) {
            if(degree_[i]==0) {
                que.push(i);
            }
        }

        while(!que.empty()) {
            int index = que.front();
            que.pop();
            // cout<<"index: "<<index<<endl;
            for(auto v : graph_[index]) {
                // cout<<"v: "<<v<<endl;
                if(quiet[ans[v]]>quiet[ans[index]]) {
                    ans[v]=ans[index];
                }
                degree_[v]--;
                if(degree_[v]==0) {
                    que.push(v);
                }
            }

        }

        return ans;
    }

   

    private:
    vector<int> degree_; // 记录入度
    // vector<list<int>> graph_;
};