算法【拓扑排序及其拓展】

最新推荐文章于 2024-11-07 23:24:07 发布
最新推荐文章于 2024-11-07 23:24:07 发布
阅读量786 收藏 14
点赞数 20
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W_O_Z/article/details/141846955
版权

拓扑排序：每个节点的前置节点都在这个节点之前。

要求：有向图、没有环

拓扑排序的顺序可能不只一种。拓扑排序也可以用来判断有没有环

1.在图中找到所有入度为0的点。

2.把所有入度为0的点在图中删掉，重点是删掉影响！继续找到入度为0的点并删掉影响。

3.直到所有点都被删掉，依次删除的顺序就是正确的拓扑排序结果。

4.如果无法把所有的点都删掉，说明有向图里有环。

下面我们看一些可以直接使用拓扑排序解决的题目。

题目一

测试链接：https://leetcode.cn/problems/course-schedule-ii

分析：对于这道题，就是一个拓扑排序的模板。代码如下。

class Solution {
public:
    int Head[2005] = {0};
    int Next[10000] = {0};
    int To[10000] = {0};
    int cnt = 1;
    int indegree[2005] = {0};
    void build(vector<vector<int>>& prerequisites){
        int length = prerequisites.size();
        for(int i = 0;i < length;++i){
            Next[cnt] = Head[prerequisites[i][1]+1];
            Head[prerequisites[i][1]+1] = cnt;
            To[cnt] = prerequisites[i][0]+1;
            ++cnt;
            ++indegree[prerequisites[i][0]];
        }
    }
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> ans;
        int len1 = 0;
        int len2 = 0;
        int temp;
        build(prerequisites);
        for(int i = 0;i < numCourses;++i){
            if(indegree[i] == 0){
                ans.push_back(i);
                ++len2;
            }
        }
        while (len2 != len1)
        {
            temp = len1;
            len1 = len2;
            for(int i = temp;i < len1;++i){
                for(int j = Head[ans[i]+1];j != 0;j = Next[j]){
                    if(--indegree[To[j]-1] == 0){
                        ans.push_back(To[j]-1);
                        ++len2;
                    }
                }
            }
        }
        if(len1 != numCourses){
            ans.clear();
        }
        return ans;
    }
};

其中，采用的是链式前向星建图；并未使用队列将答案暂时存储，而是直接遍历存储答案的数组实现入度的更新。

题目二

测试链接：https://www.luogu.com.cn/problem/U107394

分析：对于需要字典序最小的拓扑排序，可以使用优先队列，也就是堆暂时存储答案。代码如下。

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int Head[100002] = {0};
int Next[100002] = {0};
int To[100002] = {0};
int indegree[100002] = {0};
int ans[100002];
int cnt = 1;
int main(void){
    int n, m, u, v, index = 0;
    priority_queue<int, vector<int>, greater<int>> q;
    scanf("%d%d", &n, &m);
    for(int i = 0;i < m;++i){
        scanf("%d%d", &u, &v);
        Next[cnt] = Head[u];
        Head[u] = cnt;
        To[cnt] = v;
        ++cnt;
        ++indegree[v];
    }
    for(int i = 1;i <= n;++i){
        if(indegree[i] == 0){
            indegree[i] = -1;
            q.push(i);
        }
    }
    while (!q.empty())
    {
        ans[index++] = q.top();
        q.pop();
        for(int i = Head[ans[index-1]];i != 0;i = Next[i]){
            if(--indegree[To[i]] == 0){
                q.push(To[i]);
            }
        }
    }
    for(int i = 0;i < n;++i){
        printf("%d ", ans[i]);
    }
}

其中，采用链式前向星建图；使用优先队列暂时存储答案实现入度的更新并且使得最终答案的字典序最小。

题目三

测试链接：https://leetcode.cn/problems/Jf1JuT/

分析：对于这个题比较容易想到的是，如果a字典序小于b则a指向b，但是还需要一些细节处理。比如需要统计哪些小写字母出现了，需要一个exist数组；同时，对于字符串的比较需要分为几种情况；并且因为可能存在多次同一个指向，所以我们需要统计有效边的数目，用于最终判断拓扑排序是否完成；对于不可能出现的情况，直接返回空字符串。代码如下。

class Solution {
public:
    int graph[26][26] = {0};
    int indegree[26] = {0};
    bool exist[26] = {false};
    int numOfb;
    bool build(vector<string>& words){
        int length = words.size();
        for(int i = 0;i < length;++i){
            int len1 = words[i].size();
            for(int a = 0;a < len1;++a){
                exist[words[i][a] - 'a'] = true;
            }
            for(int j = i+1;j < length;++j){
                int len2 = words[j].size();
                int index = 0;
                while (index < len1 && index < len2 && words[i][index] == words[j][index])
                {
                    ++index;
                }
                if(index < len1 && index == len2){
                    return true;
                }
                if(index < len1){
                    if(graph[words[i][index] - 'a'][words[j][index] - 'a'] == 0){
                        graph[words[i][index] - 'a'][words[j][index] - 'a'] = 1;
                        ++indegree[words[j][index] - 'a'];
                        ++numOfb;
                    }
                }
            }
        }
        return false;
    }
    string alienOrder(vector<string>& words) {
        string ans;
        numOfb = 0;
        int len1 = 0, len2 = 0, temp;
        char ch;
        if(build(words)){
            return ans;
        }
        for(int i = 0;i < 26;++i){
            if(indegree[i] == 0 && exist[i] == true){
                indegree[i] = -1;
                ch = 'a' + i;
                ans += ch;
                ++len2;
            }
        }
        while (len2 != len1)
        {
            temp = len1;
            len1 = len2;
            for(int i = temp;i < len1;++i){
                for(int j = 0;j < 26;++j){
                    if(graph[ans[i] - 'a'][j] == 1){
                        --numOfb;
                        if(--indegree[j] == 0){
                            ++len2;
                            ch = 'a' + j;
                            ans += ch;
                        }
                    }
                }
            }
        }
        if(numOfb != 0){
            ans.clear();
        }
        return ans;
    }
};

其中，使用邻接矩阵建图；numOfb是有效边的数目；build方法初始化变量，返回值代表是否有不可能情况出现，出现返回true；直接在答案数组中遍历实现更新入度；最后通过有效边是否为0判断拓扑排序是否成功。

题目四

测试链接：https://leetcode.cn/problems/stamping-the-sequence

分析：对于这个题，可以考虑在下标i盖章，结果和最终目标有几个不一样，不一样的下标作为节点指向下标i代表的节点，遍历字符串建图成功。则入度为0的节点代表是最后盖下的，然后看一下这个下标盖章可以对相邻的下标盖章时修正多少个错误，也就是更新相邻下标代表节点的入度，这样进行拓扑排序。得到的答案数组逆序即是答案。代码如下。

class Solution {
public:
    vector<int> movesToStamp(string stamp, string target) {
        vector<int> ans;
        vector<int> indegree;
        int length_s = stamp.size();
        int length_t = target.size();
        indegree.assign(length_t - length_s + 1, length_s);
        vector<vector<int>> graph;
        vector<int> temp;
        for(int i = 0;i < length_t;++i){
            graph.push_back(temp);
        }
        vector<int> q;
        q.assign(length_t - length_s + 1, 0);
        int l = 0, r = 0;
        for(int i = 0;i <= length_t - length_s;++i){
            for(int j = 0;j < length_s;++j){
                if(target[i+j] == stamp[j]){
                    if(--indegree[i] == 0){
                        q[r++] = i;
                    
                    }
                }else{
                    graph[i+j].push_back(i);
                }
            }
        }
        vector<bool> visited;
        visited.assign(length_t, false);
        int size = 0;
        while (l < r)
        {
            int cur = q[l++];
            ans.push_back(cur);
            ++size;
            for(int i = 0;i < length_s;++i){
                if(!visited[cur+i]){
                    visited[cur+i] = true;
                    for(int next = 0;next < graph[cur+i].size();++next){
                        if(--indegree[graph[cur+i][next]] == 0){
                            q[r++] = graph[cur+i][next];
                        }
                    }
                }
            }
        }
        if(size != length_t - length_s + 1){
            ans.clear();
            return ans;
        }
        for(int i = 0, j = size-1;i < j;++i, --j){
            ans[i] = ans[i] ^ ans[j];
            ans[j] = ans[i] ^ ans[j];
            ans[i] = ans[i] ^ ans[j];
        }
        return ans;
    }
};

其中，采用邻接表建图。

除了以上的题目，还可以利用拓扑排序的过程，上游节点逐渐推送消息给下游节点。下面我们通过一些题目加深理解。

题目五

测试链接：https://www.luogu.com.cn/problem/P4017

分析：这个利用拓扑排序可以传递一些信息，从最开始入度为0的节点代表走到这些节点，有一条食物链。这些节点指向的下一节点，将这些节点的食物链数统计相加，直到传到最终节点，更新答案。代码如下。

#include <iostream>
using namespace std;
#define MOD 80112002
int n;
int m;
int Head[5002] = {0};
int Next[500002] = {0};
int To[500002] = {0};
int cnt = 1;
int indegree[5002] = {0};
int numsOfget[5002] = {0};
int q[5002] = {0};
int main(void){
    int A, B;
    int ans = 0;
    scanf("%d%d", &n, &m);
    for(int i = 0;i < m;++i){
        scanf("%d%d", &A, &B);
        Next[cnt] = Head[A];
        Head[A] = cnt;
        To[cnt] = B;
        ++indegree[B];
        ++cnt;
    }
    int l = 0, r = 0;
    for(int i = 1;i <= n;++i){
        if(indegree[i] == 0){
            numsOfget[i] = 1;
            q[r++] = i;
        }
    }
    while (l < r)
    {
        int cur = q[l++];
        for(int next = Head[cur];next != 0;next = Next[next]){
            numsOfget[To[next]] = (numsOfget[To[next]] + numsOfget[cur]) % MOD;
            if(--indegree[To[next]] == 0){
                q[r++] = To[next];
            }
        }
        if(Head[cur] == 0){
            ans = (ans + numsOfget[cur]) % MOD;
        }
    }
    printf("%d", ans);
}

其中，采用链式前向星建图；取余部分采用了加法同余原理。

题目六

测试链接：https://leetcode.cn/problems/loud-and-rich/

分析：这个题可以考虑，如果i比j更有钱，则i指向j。同时初始化答案数组下标和值相等，然后开始拓扑排序。节点入度为0时代表答案确定。同时，对于入度为0的节点的指向节点，更新指向节点的答案，也就是传递信息。将指向节点的答案值和传递过来的答案值进行比较，更新答案。拓扑排序完成即可得到答案。代码如下。

class Solution {
public:
    int Head[501] = {0};
    int Next[124750] = {0};
    int To[124750] = {0};
    int cnt = 1;
    int q[501] = {0};
    int indegree[501] = {0};
    void build(vector<vector<int>>& richer){
        int length = richer.size();
        for(int i = 0;i < length;++i){
            Next[cnt] = Head[richer[i][0]+1];
            Head[richer[i][0]+1] = cnt;
            To[cnt] = richer[i][1]+1;
            ++indegree[richer[i][1]];
            ++cnt;
        }
    }
    vector<int> loudAndRich(vector<vector<int>>& richer, vector<int>& quiet) {
        build(richer);
        int n = quiet.size();
        vector<int> ans;
        for(int i = 0;i < n;++i){
            ans.push_back(i);
        }
        int l = 0, r = 0;
        for(int i = 0;i < n;++i){
            if(indegree[i] == 0){
                q[r++] = i;
            }
        }
        while (l < r)
        {
            int cur = q[l++];
            for(int next = Head[cur+1];next != 0;next = Next[next]){
                ans[To[next]-1] = quiet[ans[To[next]-1]] < quiet[ans[cur]] ? ans[To[next]-1] : ans[cur];
                if(--indegree[To[next]-1] == 0){
                    q[r++] = To[next]-1;
                }
            }
        }
        return ans;
    }
};

其中，采用链式前向星建图；主题和拓扑排序一样，只在while循环中有更新答案的代码。

题目七

测试链接：https://leetcode.cn/problems/parallel-courses-iii/

分析：这个题和前面的食物链的题很像，可以求出所有食物链中所需时间最长的数这个就是答案。即还是通过拓扑排序传递的信息，就是前面的节点向后面的节点传递了最大时间。代码如下。

class Solution {
public:
    int Head[50002] = {0};
    int Next[50002] = {0};
    int To[50002] = {0};
    int cnt = 1;
    int indegree[50002] = {0};
    int cost[50002] = {0};
    int q[50002] = {0};
    int build(vector<vector<int>>& relations, vector<int>& time, int n){
        int length = relations.size();
        for(int i = 0;i < length;++i){
            Next[cnt] = Head[relations[i][0]];
            Head[relations[i][0]] = cnt;
            To[cnt] = relations[i][1];
            ++cnt;
            ++indegree[relations[i][1]];
        }
        int index = 0;
        for(int i = 1;i <= n;++i){
            cost[i] = time[i-1];
            if(indegree[i] == 0){
                q[index++] = i;
            }
        }
        return index;
    }
    int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {
        int r = build(relations, time, n);
        int ans = 0;
        int l = 0;
        while (l < r)
        {
            int cur = q[l++];
            for(int next = Head[cur];next != 0;next = Next[next]){
                cost[To[next]] = cost[To[next]] > cost[cur] + time[To[next]-1] ? cost[To[next]] : cost[cur] + time[To[next]-1];
                if(--indegree[To[next]] == 0){
                    q[r++] = To[next];
                }
            }
            if(Head[cur] == 0){
                ans = ans > cost[cur] ? ans : cost[cur];
            }
        }
        return ans;
    }
};

其中，采用链式前向星建图；主体代码和前面食物链的题一样，只是传递的信息不一样。

题目八

测试链接：https://leetcode.cn/problems/maximum-employees-to-be-invited-to-a-meeting/

分析：这个题可以考虑大环和小环，小环代表两个人互为喜欢，然后两个人各有一个喜欢链，即很多人链式喜欢，最后到这两个人。对于这个小环的最大人数就是这两个人形成的喜欢链的人数之和，而这张圆形的桌子可以存在多个小环。大环就是喜欢的人成环时人数大于2。这时只能算成环的人数，而不能加上喜欢链，并且桌子上只能存在一个大环。所以最终答案是所有小环人数之和和最大大环人数相比，取最大值。代码如下。

class Solution {
public:
    int nums[100002];
    int indegree[100002] = {0};
    int q[100002] = {0};
    bool visited[100002] = {false};
    int maximumInvitations(vector<int>& favorite) {
        int n = favorite.size();
        int l = 0, r = 0;
        int small = 0, big = 0;
        for(int i = 0;i < n;++i){
            ++indegree[favorite[i]];
            nums[i] = 1;
        }
        for(int i = 0;i < n;++i){
            if(indegree[i] == 0){
                q[r++] = i;
                visited[i] = true;
            }
        }
        while (l < r)
        {
            int cur = q[l++];
            int love = favorite[cur];
            nums[love] = nums[love] > 1+nums[cur] ? nums[love] : 1+nums[cur];
            if(--indegree[love] == 0){
                q[r++] = love;
                visited[love] = true;
            }
        }
        for(int i = 0;i < n;++i){
            if(indegree[i] != 0 && visited[i] == false){
                if(i == favorite[favorite[i]]){
                    small += (nums[i] + nums[favorite[i]]);
                    visited[i] = true;
                    visited[favorite[i]] = true;
                }else{
                    int temp = favorite[i];
                    int num = 1;
                    visited[temp] = true;
                    while (i != temp)
                    {
                        temp = favorite[temp];
                        visited[temp] = true;
                        ++num;
                    }
                    big = big > num ? big : num;
                }
            }
        }
        return small > big ? small : big;
    }
};

其中，采用链式前向星建图；先通过拓扑排序将环搞出来，然后依次判断环的类型以及更新答案；visited数组代表节点是否被访问。

还有糕手
关注
【数据结构与算法基础】拓扑排序与AOV网络
wayne_lee_lwc的博客
12-04 1317
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
拓扑排序的扩展
小菜鸡的博客
10-19 701
拓扑排序的扩展
算法.图论-建图/拓扑排序及其拓展
2301_81486828的博客
09-12 877
拓扑排序的存在条件是在一个有向且无环图中的排序, 拓扑排序在某种程度上反应的是一件事的执行的先后顺序, 请看下图这张图中, 黑色的字符表示节点的名称, 蓝色的数字指的是该位置的入度是多少, 上面我们提到过, 拓扑排序的过程可以视为完成某一件事的先后顺序, 假设我们最终想要完成的任务是f, 那我们下面的字符的序列也就是完成最终事件的顺序拓扑排序不是唯一的, 比如下面的图在这张图中, 先完成a还是先完成b都是可以的, 所以产生的拓扑排序的情况就有两种,
拓扑排序的原理及其实现
oy_1024的博客
11-22 813
本文将从以下几个方面介绍拓扑排序： 拓扑排序的定义和前置条件和离散数学中偏序/全序概念的联系典型实现算法 Kahn算法基于DFS的算法 解的唯一性问题实际例子 取材自以下材料： http://en.wikipedia.org/wiki/Topological_sorting http://en.wikipedia.org/wiki/Hamiltonian_path 定义和...
算法基础系列第三章——万字精编手把手教你壁咚拓扑排序，让ta乖乖听话~
weixin_52621323的博客
12-11 1909
图文并茂详细讲解拓扑排序及其在算法竞赛中出现的形式，手把手教你壁咚她，咚~
《王道》数据结构笔记整理2022
热门推荐
池鱼
08-21 23万+
数据结构第一章绪论1.1数据结构的基本概念1.2数据结构的三要素1.3算法的基本概念1.4算法的时间复杂度1.5算法的空间复杂度 第一章绪论 1.1数据结构的基本概念 1.数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。 2.数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。 3.数据对象:数
背包问题及其拓展
m0_64378422的博客
11-10 407
背包问题及其拓展
拓扑排序算法解析及其在工程中的实际应用
拓扑排序算法概述 拓扑排序算法在工程领域中有着广泛的应用，是一种重要的排序算法。通过对图中节点之间的依赖关系进行排序，可以有效地解决任务调度、软件开发、项目管理等实际问题。本章将介绍拓扑排序算法的...
图的拓扑排序及其实际应用
# 1. 简介 ## 1.1 什么是图的拓扑排序 图的拓扑排序是图论中的经典算法之一，它解决了有向无环图（DAG）中节点的线性排序问题。...接下来，我们将深入了解拓扑排序的基本概念及其实际应用。 # 2
DFS在拓扑排序算法中的实际应用
- 1.1 什么是拓扑排序算法 - 1.2 DFS算法在拓扑排序中的作用 - 1.3 本文主要内容概述 # 2. DFS算法原理 深度优先搜索（Depth First Search, DFS）是一种常用的图遍历算法，其基本原理是从图中的某一顶点（起始点）...
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 369
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 2109
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
二分查找习题篇(上)
最新发布
zoelinkailuo的博客
11-07 959
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
数组类算法【leetcode】
随便写写
11-07 336
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 866
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
【刷题】优选算法
林宇恒的博客
11-06 485
如图，我们先算出最左边(1)和最右边(7)围起来的容量，然后，7不动，1继续和7的左边3，8，4...遍历算出容量，你会发现底是不断缩短的，同时高一直都是1，因为高只有两种情况，比它小或和它相等，所以1和7左边的值算出来的容量都是比1和7的容量小的，因为底在不断变小同时高可能不变也可能变小。根据两个实例和鸽巢原理可以发现不断的平方和最终都会形成环，所以我们可以联想到用快慢指针，慢指针走一步，快指针走两步，最终会在环相遇，判断相遇时是否为1。第一个实例是快乐数，因为会变为1且不断是1的循环。
【LeetCode】【算法】416. 分割等和子集
passer__jw767的博客
11-06 319
LeetCode 416. 分割等和子集
C++实现拓扑排序算法
"拓扑排序算法的C++实现" 拓扑排序是图论中的一个概念，主要用于有向无环图（DAG，Directed Acyclic Graph）的排序问题。它的基本思想是从图中选择一个没有前驱（即入度为0）的节点，将其输出，并从图中删除该节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

还有糕手

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值