Tarjan算法详解

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

MZX大佬授课DAY2上午

tarjan是用来解决图的割边割点问题以及有向图的强连通分量（缩点）的问题的。

割边

割边是图论算法中一类很常见的问题：

定义

在一个连通图G中，假设有一条边e，去掉e后图G不再连通，那么e就是G的一条割边。换句话说，G是连通图，G-e不是连通图。

暴力算法

最暴力最暴力的算法就是每次都去掉一条边，然后进行dfs深度优先遍历。要进行n次dfs深度优先遍历。这显然效率是很低很低的。
这个时候一个叫Tarjan的男人站了出来。

tarjan算法求割边

tarjan算法是以dfs深度优先遍历算法为基础的。也就是说tarjan是对dfs的一个最优性剪枝。
在tarjan中，我们需要对每一个顶点维护两个值，dfn值和low值。
我们在dfs深度优先遍历的时候根据dfs遍历的顺序可以画出一颗dfs树（有n-1条边，这n-1条边称为树边，其余称为非树边）。我们dfs遍历的顺序编号就是dfn值，我们可以这样理解：dfn值就是一个时间戳，dfn[i]=1，就代表第i号结点是第1个被遍历到的。low值是某个节点通过非树边能够回溯到的dfn值最小的点。比如说low[8]=4；我们就能知道，8号点能通过非树边回溯到4号点。
这有什么用呢？
我们任意连接dfn上的一条非树边，发现有这样一个性质：总是祖孙结点相连的。这样的边称为返祖边。我们可以知道，如果一个点有返祖边与dfn值更小的点相连，那么它的父亲结点肯定不是割点（好好思考下，想通了再往下面看）。所以我们可以得出一个结论：在图中，如果存在一条树边(x,y)，而且x是y的父亲，存在low[y]>dfn[x]，那么(x,y)是割边。

先看一个例题

luogu炸铁路

分析

这道题目的大意就是要炸掉一条铁路，让这个交通系统变成两部分，这明显是一个裸的割边题目。我们这边拿这道题目作为一个模板题来讲解。

code

#include<bits/stdc++.h>
#define maxn 200
#define maxm 5200*2
using namespace std;
inline int read()
{
    int num=0;
    char c;
    bool flag=false;
    for(;c>'9'||c<'0';c=getchar())
    if(c=='-')
    flag=true;
    for(;c>='0'&&c<='9';num=num*10+c-48,c=getchar());
    return flag?-num:num;
}//快读
/*
这个代码风格……我已经被大佬们带掉了
怎么说呢，就是使用namespace
这个东西有啥好处呢，就是可以使整个代码的
结构变得很清晰
不信你看
*/
namespace graph//这部分是跟图论就有关系了
{
    int n,m,head[maxn],top=0;
    struct Hydra_ 
    {
        int dot_order,next_location;
    }a[maxm];//邻接表
    void insert(int x,int y)
    {
        top++;
        a[top].dot_order=y;
        a[top].next_location=head[x];
        head[x]=top;
    }//在邻接表中插入边
    void init()
    {
        n=read();
        m=read();
        for(int i=1;i<=m;i++)
        {
            int x=read();
            int y=read();
            insert(x,y);
            insert(y,x);
        }
    }//读入
}using namespace graph;//一定别忘了写这句

namespace Tarjan//接下来是tarjan
{
    struct edge
    {
        int from,to;
    }ans[maxm];//这是用来存储答案的一个边表
    int dfn[maxn],low[maxn],tot=0,num;
    void hy(int u,int fa)
    //dfs函数，u代表当前结点，fa代表当前结点的父亲
    {
        dfn[u]=low[u]=++tot;
        for(int i=head[u];i;i=a[i].next_location)
        //遍历链表，我们需要遍历的是所以非u，fa的边
        {
            int v=a[i].dot_order;
            if(v==fa)continue;
            /*所以这里如果v就是u的父亲，
            那么就是u，fa这条边了*/
            if(!dfn[v])
            //如果没有被访问过
            {
                hy(v,u);
                //先访问递归
                low[u]=min(low[u],low[v]);
                //就用v的low值更新u的low值。
            }
            else//如果被访问过了
            low[u]=min(low[u],dfn[v]);
            //那就用v的dfn值更新u的low值
            if(dfn[u]<low[v])
            //这里是判断是否是割边，这是
            {
                ++num;
                ans[num].from=min(u,v);
                ans[num].to=max(u,v);
                //把这条割边存进边表
            }
        }
    }
}using namespace Tarjan;

bool mycmp(edge a,edge b)
{
    return a.from<b.from||(a.from==b.from&&a.to<b.to);
}//给边表排序的函数
int main()
{
    init();
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            hy(i,0);
    //这里是个坑，这是为了避免不连通的情况，坑了我很久啊
    sort(ans+1,ans+1+num,mycmp);
    for(int i=1;i<=num;i++)
        printf("%d %d\n",ans[i].from,ans[i].to);
    return 0;
}

割点

割点是图论算法中另外一个非常常见的问题。

定义

类比割边的定义，割点就是，在连通图G中，去掉了点a，让这个图不再连通，那么就是割点。也就是G是连通图，G-a不是连通图。

暴力算法

这类题目的暴力算法一样，就是把所有跟这个点有关系的边全部去掉，再dfs。太慢了。

tarjan求割点

tarjan求割点的方法和求割边的方式类同，都需要维护两个值：low值和dfn值。意义也基本相同。我们仍然构造一颗dfs树，如果一个点有一个儿子能通过非树边到达其他非子孙结点，那么这个点就不是割点。我们可以说，如果存在一条边(x,y)，x是y的父亲。如果low[y]<=dfn[x]那么说明x是割点。
需要一提的是，由于有向图都是单向边，所以非树边不一定是返祖边。可以连到兄弟子树的结点的边也是可以让这个结点不是割点的。最后要强调的是，只要有一个儿子结点满足上面的关系，那么这个点就是割点。因为至少有一个点被他阻断了呀。
思考一下根节点，根节点要怎么样才能是割点呢：度>=2。

再看一个例题

[扭曲锣鼓 割点模板题(https://www.luogu.org/problem/show?pid=3388)

分析

裸模板题！！tarjan上。

code

#include<bits/stdc++.h>
#define maxn 100100
using namespace std;
inline int read()
{
    int num=0;
    char c;
    bool flag=false;
    for(;c>'9'||c<'0';c=getchar())
    if(c=='-')
    flag=true;
    for(;c>='0'&&c<='9';num=num*10+c-48,c=getchar());
    return flag?-num:num;
}//快读
/*
还是那个套路。namespace
*/
namespace graph
{
    int n,m,head[maxn],top=0;
    struct WE
    {
        int dot_order,next_location;
    }a[maxn*2];//邻接表
    void insert(int x,int y)
    {
        top++;
        a[top].dot_order=y;
        a[top].next_location=head[x];
        head[x]=top;
    }//插入
    void init()
    {
        n=read();
        m=read();
        for(int i=1;i<=m;i++)
        {
            int x=read();
            int y=read();
            insert(x,y);
            insert(y,x);
        }
    }//读入数据
}using namespace graph;

namespace Tarjan//tarjan算法
{
    int dfn[maxn],low[maxn],father[maxn];
    /*
    dfn、low的意义见上。father表示这个点
    在哪个集合里面。为了搞多个连通块的问题。
    */
    bool ans[maxn];//用来标记某点是不是割点
    int tot=0;
    void hy(int x)//深度优先遍历
    {
        int degree=0;
        dfn[x]=low[x]=++tot;//初始化dfn和low相等
        for(int i=head[x];i;i=a[i].next_location)
        //遍历邻接表
        {
            int y=a[i].dot_order;
            if(!dfn[y])
            {
                father[y]=father[x];
                //他俩有边相连，所以在一个连通块里面
                hy(y);
                //继续遍历
                low[x]=min(low[x],low[y]);
                //用y的low值来更新x的low值
                if(low[y]>=dfn[x]&&x!=father[x])
                    ans[x]=true;
                //判断是否为割点（非根节点的情况）
                if(x==father[x])
                    degree++;
                //如果它是根节点，父亲是自己，那么度+1
            }
            low[x]=min(low[x],dfn[y]);
            // 用y的dfn值更新x的low值
        }
        if(x==father[x]&&degree>=2)
            ans[x]=true;
        //如果它是根节点，而且度数>=2,那么它是割点
    }
}using namespace Tarjan;

int main()
{
    init();
    for(int i=1;i<=n;i++)
        father[i]=i;
    //默认父亲是自己
    memset(ans,false,sizeof(ans));
    for(int i=1;i<=n;i++)
        if(!dfn[i])hy(i);
    //为了解决多个连通块的问题
    int num=0;
    for(int i=1;i<=n;i++)
        if(ans[i])num++;
    //统计割点数量
    printf("%d\n",num);
    for(int i=1;i<=n;i++)
        if(ans[i])printf("%d ",i);
    //打印割点编号
    return 0;
}

强连通分量和缩点

强连通分量是有向图中的一类很常见的问题。弄得我痛不欲生！！！

定义

有向图中一个连通分量如果满足这样的性质：其中任意两个点都是能够互相通过路径到达的，而且整个分量没有出度，那么这个连通分量就是强连通分量。

暴力算法

我给恩撒。这里写图片描述
我才不写暴力呢。

优秀的tarjan

tarjan求强连通分量是需要一个栈来维护一个被遍历到的序列，这要碰到dfn[I]=low[I]的就把所有的它以上进栈的全部弹出，这就是个强连通分量了。这个推导的话我推荐一个blog
大佬博客。关于强连通分量的证明

例题

luogu消息扩散

分析

不多说了
统计强连通分量个数。缩点。统计入度为0的强连通分量。

code

#include<bits/stdc++.h>
#define maxn 100100
#define maxm 500200*2
using namespace std;
inline int read()
{
    int num=0;
    bool flag=true;
    char c;
    for(;c>'9'||c<'0';c=getchar())
    if(c=='-')
    flag=false;
    for(;c>='0'&&c<='9';num=num*10+c-48,c=getchar());
    return flag ? num : -num;
}

namespace graph
{
    int n,m,head[maxn],top1;
    struct RNG
    {
        int dot_order,next_location;
    }a[maxm];
    bool tr[maxm];
    struct edge
    {
        int x,y;
    }e[maxm];
    void insert(int x,int y)
    {
        top1++;
        a[top1].dot_order=y;
        a[top1].next_location=head[x];
        head[x]=top1;
    }
    void init()
    {
        n=read();
        m=read();
        for(int i=1;i<=m;i++)
        {
            e[i].x=read();
            e[i].y=read();
            insert(e[i].x,e[i].y);
        }
    }
}using namespace graph; 

namespace Tarjan
{
    int stack[maxm],dfn[maxn],low[maxn],tot;
    bool flag[maxn];
    int w[maxm];
    int top=0,number=0;
    void hy(int x)
    {
        dfn[x]=low[x]=++tot;
        stack[++top]=x;
        flag[x]=true;
        for(int i=head[x];i;i=a[i].next_location)
        {
            int y=a[i].dot_order;
            if(!dfn[y])
            {
                hy(y);
                low[x]=min(low[x],low[y]);
            }
            else
            if(dfn[y]<low[x]&&flag[y])
                low[x]=dfn[y];
        }
        if(dfn[x]==low[x])
        {
            number++;
            int r;
            do
            {
                r=stack[top--];
                flag[r]=false;
                w[r]=n+number;
            }while(x!=r);
/*
跟上面的代码不一样对的地方，
如果碰到一个low和dfn相等的点，
就弹出所有的栈中比它后入栈的点作为
一个强连通分量
*/
        }
    }
}
using namespace Tarjan;
int main()
{
    init();
    for(int i=1;i<=n;i++)
    if(!dfn[i])
    {
        top=0;
        hy(i);
    }
    int ans=0;
    for(int i=1;i<=m;i++)
    {
        if(!tr[w[e[i].y]]&&w[e[i].x]!=w[e[i].y])
        {
            tr[w[e[i].y]]=true;
            ans++;
        }
    }
    printf("%d",number-ans);
    return 0; 
}
千杯湖底沙.
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Tarjan算法介绍
huangdanning的博客（.cpp）
07-24 1041
Tarjan算法介绍： Tarjan算法是图论中的一种算法，用作于无向图的联通性 它可以做什么？ 根据 Robert Tarjan 的名字命名的算法Tarjan算法可以在线性时间内求出无向图的割点与桥，再进一步的求出双联通分量，也在数据结构上做出了贡献。 做法基础 Tarjan算法基于图的深度优先遍历上（没错！就是与深度优先搜索（DFS）一样的东西） （如果没学过这...
Tarjan算法
Shlfa
09-19 321
定义在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。Tarjan算法可以用于求一张有向图的最大强联通分量基本参数对于一张有向图上图来自byvoid大牛进行dfs搜索后会出现一棵df
Tarjan 算法
百般回首曾经的相遇，留下的只是一缕残忆
01-16 118
Tarjan 基础 强连通：在有向图中，两个顶点可以互相到达，则称两点强连通，如果每两个顶点都可以强连通则为强连通图。 强连通分量：非强连通图的极大强连通子图，即非强连通图中的是强连通的子图。 目的 求有向图中强连通分量。 简介 Tarjan 算法是用来求强连通分量的，它是一种基于DFS（深度优先搜索）的算法，每个强连通分量为搜索树中的一棵子树。并且运用了数据结构栈。 先引入两个非常重要的数组：d...
Tarjan算法详解（AcWing 1174 受欢迎的牛）
昂昂累世士的博客
07-13 2993
题目描述： 每一头牛的愿望就是变成一头最受欢迎的牛。 现在有 N 头牛，编号从 1 到 N，给你 M 对整数 (A,B)，表示牛 A 认为牛 B 受欢迎。 这种关系是具有传递性的，如果 A 认为 B 受欢迎，B 认为 C 受欢迎，那么牛 A 也认为牛 C 受欢迎。 你的任务是求出有多少头牛被除自己之外的所有牛认为是受欢迎的。 输入格式 第一行两个数 N,M； 接下来 M 行，每行两个数 A,B，意思是 A 认为 B 是受欢迎的（给出的信息有可能重复，即有可能出现多个 A,B）。 输出格式 输出被除自己之外的
tarjan算法总结 (强连通分量+缩点+割点)，看这一篇就够了~
热门推荐
csyifanZhang的博客
04-08 1万+
文章目录一、tarjan求强连通分量1：算法流程2：模板二、tarjan缩点1：相关定义2：算法流程三、tarjan求割点、桥1、什么是割点2.割点怎么求？割点tarjan模板3.什么是桥4：桥怎么求四、双联通分量（for 无向图） tarjan可以做什么？ 根据 Robert Tarjan 的名字命名的算法Tarjan算法可以在线性时间内求出无向图的割点与桥，再进一步的求出双联通分量，也在数据结...
浅谈 Tarjan 算法
William_Wang_的博客
06-07 3080
无向图中，若删去一条边会使得这个图的极大连通分量数增加，则该边被称为桥。也可以理解为无向图的一个连通块中，若删除一条边会使得至少两点之间无法相互到达，该边被称为桥。无向图中，若删去一个点会使得这个图的极大连通分量数增加，这个点被称为割点。也可以理解为无向图的一个连通块中，若删除一个点会使得至少两点之间无法相互到达，该点被称为割点。注意，强连通分量（SCC，Strongly Connected Components）是在单向图中的。强联通子图，定义为：在单向图中，该子图上的任意两点之间能互相到达。
C++Tarjan算法实现.zip
08-20
《C++实现Tarjan算法详解》 Tarjan算法，全称为Robert Tarjan的强连通分量算法，是图论中的一个经典算法，主要用于找出有向图中的强连通分量。在C++编程中，它能有效地处理复杂的图结构问题，尤其是在分析网络流、...
Tarjan算法 讲解
12-10
### Tarjan算法详解 #### 一、Tarjan算法概述 **Tarjan算法**是一种用于解决图论中**强连通分量**问题的经典算法。它由罗伯特·塔扬（Robert Tarjan）于1972年提出，并且由于其高效性，在计算机科学领域得到了广泛...
Tarjan 的 LCA 算法
03-19
**Tarjan的LCA算法详解** 最近公共祖先（Lowest Common Ancestor，简称LCA）是图论中的一个重要概念，特别是在树形结构中。在树中，两个节点的最近公共祖先指的是距离根节点最近的那个同时是这两个节点的祖先的节点...
Tarjan及2-SAT讲课PPT
10-20
《Tarjan算法与2-SAT详解》 Tarjan算法，源于著名计算机科学家Robert Tarjan，是一种在图论中广泛使用的高效算法，尤其在处理强连通分量的问题上展现出强大的能力。本文将深入探讨Tarjan算法的核心思想及其在2-SAT...
Tarjan算法超超超详解（ACM/OI）（强连通分量/缩点）（图论）（C++）
qaqwqaqwq的博客
08-24 9615
深入浅出的Tarjan算法手把手讲解！看完就会！
Tarjan 算法学习笔记
m0_72410588的博客
05-10 1006
支持度（Support）是指数据集DDD中包含某个项集XXX的记录所占的比例。SuppXfreqX∣D∣SuppX∣D∣freqX​其中freqXfreq(X)freqX表示包含XXX的记录数，∣D∣|D|∣D∣表示数据集DDD中记录的总数。置信度（Confidence）是指数据集DDD中包含项集XXX的记录中同时包含另一个项集YYY的比例。
强连通分量-tarjan算法缩点
c__chong的博客
06-05 2843
强连通分量：在有向图G中，如果两个顶点u,v间（u->v）有一条从u到v的有向路径，同时还有一条从v到u的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量。简单点说就是：如果一个有向图中，存在一条回路，所有的结点至少被经过一次，这样的图为强连通图。在强连图图的基础上加入一些点和路径，使得当前的图不在强连通，称原来的强连通的部分为强连通分量。
tarjan算法（相关概念、Tarjan求最大强连通分量、割点、求桥、缩点）
Jiguoyuanyic的博客
07-09 1480
无向图 G 的最大连通子图称为 G 的连通分量。注：这里的最大连通子图的含义为：此图为 G 的连通子图，将 G 的任意一个点加到盖子图中之后，此子图将不再连通。比如这一张图中，很显然，我用三种颜色圈起来的部分都是原图的连通分量。（其实可以十分形象的理解成每一个连通分量都是一个连通块）回想到以前的“亲戚”一题，就是让我们去求在这个无向图中，询问的两个点是不是在同一个连通分量中。值得注意的一点，一个连通图的连通分量就是他本身。
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
最新发布
weixin_65180740的博客
07-24 866
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
hopcroft-tarjan
12-02
Hopcroft-Tarjan算法是一种用于有限状态自动机最小化的算法。该算法由John Hopcroft和Robert Tarjan于1973年提出。它的主要思想是将状态分为不可达状态和可达状态，并通过遍历状态间的转移关系来合并不可达状态，从而实现状态的最小化。 Hopcroft-Tarjan算法是一种高效的最小化算法，时间复杂度为O(nlogn)，其中n为状态的数量。相比于其他最小化算法，Hopcroft-Tarjan算法在实际应用中表现更加优越，尤其适合处理大规模状态机的最小化问题。 该算法的核心思想是利用等价关系将状态划分为等价类，并通过不断地合并等价类来达到最小化状态机的目的。其整个过程可以分为以下几个步骤：首先将状态划分为不可达状态和可达状态；然后利用等价关系划分状态为等价类；接着通过合并等价类来达到状态机最小化的目的。 Hopcroft-Tarjan算法在编译器、自然语言处理、模式匹配等领域有着广泛的应用。由于其高效的时间复杂度和优越的性能，它成为了最小化有限状态自动机的首选算法之一。 总而言之，Hopcroft-Tarjan算法是一种高效的状态机最小化算法，其核心思想是利用等价关系将状态划分为等价类，并通过合并等价类来达到最小化状态机的目的。在实际应用中，该算法表现出了良好的性能，得到了广泛的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值