视频讲解

前言

我与拓扑排序的故事

一开始接触是数据结构的课上、奈何那段时间沉迷玩游戏没有理解过代码。第二次是打卡群，一场力扣双周赛第二题是拓扑排序（我是暴力循环100次、哈希去重写的），群主发觉群员拓扑排序学的不行写拓扑专题。y总数组模拟数据结构、我看了还是不会啊🤣连续两天不会写、痛失20块。（我到现在也还不会y总的数组写法🤣。

后来寒假开始打卡群进行了一段时间的拓扑排序专题训练。（感谢群主、虽然他看不到）

下面就是蒟蒻总结的一点用STL实现拓扑排序的心得。

拓扑排序适用于什么场景

前提必须是有向无环图。题意与将图转换成线性排序有关

模板

直接上STL版的。数组模拟以后懂了再更新

//牢牢抓住入度为0的节点被视为新一轮的起点
while(q.size()) 
{
    //m 和 edge 哈希表   edge存节点的入度  m存节点之间单向的关系
    string tmp = q.front(); q.pop();
    for(auto &i : m[tmp]) //把该节点能到的所有的节点的入度减一
    {
        edge[i] --; 
        if(edge[i] == 0) //如果节点的入度变成了0将其视为新的起点
        {
            q.push(i);
            ans.push_back(i);
        }
    }
}

例题 点击题目跳转链接

一、从给定原材料中找到所有可以做出的菜

来源一场双周赛、是我印象中接触到的第一道拓扑排序。意义非凡，所以放到了第一个。

1.题目

你有 n 道不同菜的信息。给你一个字符串数组 recipes 和一个二维字符串数组 ingredients 。第 i 道菜的名字为 recipes[i] ，如果你有它 所有 的原材料 ingredients[i] ，那么你可以 做出 这道菜。一道菜的原材料可能是 另一道 菜，也就是说 ingredients[i] 可能包含 recipes 中另一个字符串。

同时给你一个字符串数组 supplies ，它包含你初始时拥有的所有原材料，每一种原材料你都有无限多。

请你返回你可以做出的所有菜。你可以以 任意顺序 返回它们。

注意两道菜在它们的原材料中可能互相包含。

示例 1：

输入：recipes = ["bread"], ingredients = [["yeast","flour"]], supplies = ["yeast","flour","corn"]
输出：["bread"]
解释：
我们可以做出 "bread" ，因为我们有原材料 "yeast" 和 "flour" 。

示例 2：

输入：recipes = ["bread","sandwich"], ingredients = [["yeast","flour"],["bread","meat"]], supplies = ["yeast","flour","meat"]
输出：["bread","sandwich"]
解释：
我们可以做出 "bread" ，因为我们有原材料 "yeast" 和 "flour" 。
我们可以做出 "sandwich" ，因为我们有原材料 "meat" 且可以做出原材料 "bread" 。

示例 3：

输入：recipes = ["bread","sandwich","burger"], ingredients = [["yeast","flour"],["bread","meat"],["sandwich","meat","bread"]], supplies = ["yeast","flour","meat"]
输出：["bread","sandwich","burger"]
解释：
我们可以做出 "bread" ，因为我们有原材料 "yeast" 和 "flour" 。
我们可以做出 "sandwich" ，因为我们有原材料 "meat" 且可以做出原材料 "bread" 。
我们可以做出 "burger" ，因为我们有原材料 "meat" 且可以做出原材料 "bread" 和 "sandwich" 。

示例 4：

输入：recipes = ["bread"], ingredients = [["yeast","flour"]], supplies = ["yeast"]
输出：[]
解释：
我们没法做出任何菜，因为我们只有原材料 "yeast" 。

提示：

n == recipes.length == ingredients.length
1 <= n <= 100
1 <= ingredients[i].length, supplies.length <= 100
1 <= recipes[i].length, ingredients[i][j].length, supplies[k].length <= 10
recipes[i], ingredients[i][j] 和 supplies[k] 只包含小写英文字母。
所有 recipes 和 supplies 中的值互不相同。
ingredients[i] 中的字符串互不相同。

2.分析题意

• 令原材料指向菜，题目就变成了一张“有向无环图”（为什么是原材料指向菜？想一想：有了食材才能做出菜）

• 统计所有菜的入度，当入度为0时菜变成了原材料

• 建立原材料到菜的边关系

3.参考源码

class Solution {
public:
    vector<string> findAllRecipes(vector<string>& recipes, vector<vector<string>>& ingredients, vector<string>& supplies) {
        //入度为0的被当作菜品
        unordered_map<string, int> edge; //存度
        unordered_map<string, vector<string>> m; //存边的关系
        int n = recipes.size();
        for(int i = 0; i < n; ++ i)
        {
            edge[recipes[i]] += ingredients[i].size(); //菜的入度
            for(auto & j : ingredients[i]) m[j].push_back(recipes[i]);
        }

        vector<string> ans;
        queue<string> q;
        for(auto &i : supplies) q.push(i);
        //牢牢抓住入度为0的节点被视为新一轮的起点
        while(q.size()) 
        {
            //m 和 edge 哈希表   edge存节点的入度  m存节点之间单向的关系
            string tmp = q.front(); q.pop();
            for(auto &i : m[tmp]) //把该节点能到的所有的节点的入度减一
            {
                edge[i] --; 
                if(edge[i] == 0) //如果节点的入度变成了0将其视为新的起点
                {
                    q.push(i);
                    ans.push_back(i);
                }
            }
        }
        return ans;
    }
};

二、有向图的拓扑序列

1.题目

给定一个 n 个点 m 条边的有向图，点的编号是 1 到 n，图中可能存在重边和自环。

请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 −1。

若一个由图中所有点构成的序列 A满足：对于图中的每条边 (x,y)，x 在 A 中都出现在 y 之前，则称 A是该图的一个拓扑序列。

输入格式

第一行包含两个整数 n 和 m。

接下来 m 行，每行包含两个整数 x 和 y，表示存在一条从点 x 到点 y 的有向边 (x,y)。

输出格式

共一行，如果存在拓扑序列，则输出任意一个合法的拓扑序列即可。

否则输出 −1。

数据范围

$1≤n,m≤10^5$

输入样例：

3 3
1 2
2 3
1 3

输出样例：

1 2 3

2.题目分析

裸的拓扑排序题。用拓扑排序处理一张图、什么样的情况是有环呢？入队列的结点数小于总的节点数

3.参考代码

#include <bits/stdc++.h>

using namespace std;

string topsort(unordered_map<int, int> &edge, unordered_map<int, vector<int>> &w, int n)
{
    for(int i = 1; i <= n; ++ i) edge[i];
    string ans;
    queue<int> q;
    for(auto &[x, y] : edge) 
        if(!y) 
        {
            q.push(x); //将入度为0的视为起点
            ans += to_string(x); ans += " ";
        }

    //依然是那句话  牢牢抓住入度为0的节点被视为起点
    int sum = q.size(); 
    while(q.size())
    {
        int f = q.front(); q.pop();
        for(auto i : w[f])
        {
            -- edge[i];
            if(!edge[i]) 
            {
                q.push(i);
                sum ++;
                ans += to_string(i); ans += " ";
            }
        }
    }

    if(n != sum) return "-1"; //入队列的结点数少于总数时一定存在环
    return ans;
}

int main()
{
    ios::sync_with_stdio(false);
    int n, m; cin >> n >> m;
    unordered_map<int, int> edge; //入度数
    unordered_map<int, vector<int>> w; //边的关系
    int x, y;
    for(int i = 0; i < m; ++ i) //不需要担心重复情况
    {
        cin >> x >> y;
        edge[y] ++;
        w[x].push_back(y);
    }
    cout << topsort(edge, w, n);
    return 0;
}

三、拓扑顺序

思路：入度为0的点视为起点，某一点的入度不为0又先出现的话一定不是拓扑排序。

裸题。不再赘述题面

参考代码

#include <bits/stdc++.h>

using namespace std;

bool check(vector<int> &a, unordered_map<int, int> &edge, unordered_map<int, vector<int>> &w)
{
    unordered_map<int, int> g = edge;
    for(int &i : a)
    {
        for(int &j : w[i])
            -- g[j];
        if(g[i]) return false; //出现入度大于1的节点  那就不是拓扑排序
    }
    return true;
}

int main()
{
    ios::sync_with_stdio(false);
    int n, m; cin >> n >> m;
    unordered_map<int, int> edge;//度
    unordered_map<int, vector<int>> w;//边

    //创建度与边的关系
    int x, y;
    for(int i = 0; i < m; ++ i)
    {
        cin >> x >> y;
        edge[y] ++;
        w[x].push_back(y);
    }

    int T; cin >> T;
    for(int i = 0; i < T; ++ i)
    {
        vector<int> a(n);
        for(int i = 0; i < n; ++ i) cin >> a[i];
        if(!check(a, edge, w)) cout << i << ' ';
    }
    return 0;
}

四、食物链

1.题目

如图所示为某生态系统的食物网示意图，据图回答此题。

现在给你 n 个物种和 m 条能量流动关系，求其中的食物链条数。

物种的名称为从 1 到 n 编号。m 条能量流动关系形如

a1 b1
a2 b2
a3 b3
......
am−1 bm−1
am bm

其中 ai bi 表示能量从物种 ai 流向物种 bi，注意单独的一种孤立生物不算一条食物链。

输入格式

第一行两个整数 n和 m。接下来 m 行每行两个整数 ai,bi 描述 m条能量流动关系。

数据保证输入数据符号生物学特点，且不会有重复的能量流动关系出现。

输出格式

一个整数，即食物网中的食物链条数。

数据范围

$1≤n≤10^5,0≤m≤2×10^5,$
保证答案在 int 范围内。

输入样例：

10 16
1 2
1 4
1 10
2 3
2 5
4 3
4 5
4 8
6 5
7 6
7 9
8 5
9 8
10 6
10 7
10 9

输出样例：

9

2.题目分析

• 依然是拓扑排序。出度为0的结点是终点

• 常规板子 外加数组记录条数

• 单独的一种孤立生物不算一条食物链。所以求和时要在非第一次入队、入度减为0、没有出度的节点中计算

3. 参考代码

#include <bits/stdc++.h>

using namespace std;

int topsort(unordered_map<int, int> &edge, unordered_map<int, vector<int>> &w, 
unordered_map<int, int> &sum, vector<bool> &b, int n)
{
    int ans = 0;
    queue<int> q;
    for(auto &[x, y] : edge) 
        if(!y) 
        {
            q.push(x);
            sum[x] = 1;
        }

    while(q.size())
    {
        int f = q.front(); q.pop();
        for(auto &i : w[f])
        {
            -- edge[i];
            sum[i] += sum[f];
            if(!edge[i]) //单独的一种孤立生物不算一条食物链。
            {
                q.push(i);
                if(!b[i]) ans += sum[i];
            }
        }
    }

    return ans;
}

int main()
{
    ios::sync_with_stdio(false);
    vector<bool> b;
    unordered_map<int, int> edge, sum; //度 链的数
    unordered_map<int, vector<int>> w;
    int n, m; cin >> n >> m;
    b.resize(n + 1);

    for(int i = 1; i <= n; ++ i) edge[i];
    int x, y;
    for(int i = 0; i < m; ++ i)
    {
        cin >> x >> y;
        edge[y] ++;
        w[x].push_back(y);
        b[x] = true; //记录有出度的  没有出度的为终点
    }

    cout << topsort(edge, w, sum, b, n);

    return 0;
}