关于tarjan算法的各种题型

于 2021-01-28 21:39:20 发布
阅读量103 收藏 1
点赞数
分类专栏： 知识点 图论 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49003264/article/details/113326301
版权
知识点 同时被 3 个专栏收录
23 篇文章 0 订阅
订阅专栏
图论
9 篇文章 0 订阅
订阅专栏
模板
2 篇文章 0 订阅
订阅专栏

tarjan算法

求强连通分量

强连通的定义是：有向图 G 强连通是指，G 中任意两个结点连通。

强连通分量（Strongly Connected Components，SCC）的定义是：极大的强连通子图。

题目链接：https://www.luogu.com.cn/problem/P2863

在这里插入图片描述题解：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n,m;
int cnt;//记录强联通分量的个数
int visitnum;//遍历的步数
int dfn[100010];//记录元素第一次被访问的步数
int low[100010];//包含i的强联通分量最早被访问的步数
int num[100010];//记录强联通分量里的点的个数
int belong[100010];//i从属的强联通分量的序号
int top;//栈中元素的个数
int stack[100010];//手打栈
int instack[100010];//判断元素是否在栈中
int head[100010];
struct node{
int to,next;
}edge[100010];//链式前向星存边

int read()//读入优化
{
    int x=0,w=1;char ch=getchar();
    while(ch>'9'||ch<'0') {if(ch=='-')w=-1;ch=getchar();}
    while(ch<='9'&&ch>='0') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*w;
}

void tarjan(int u)
{
    int v;
    visitnum++;
    dfn[u]=low[u]=visitnum;
    stack[++top]=u;//入栈
    instack[u]=1;//入栈
    for(int i=head[u];i;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v])//还没被访问过
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);//判断u是否为v的子节点
        }
        else if(instack[v])
        {
            low[u]=min(low[u],dfn[v]);
                       //其实这里的dfn[v]也能换成low[v] 但最好写dfn
        }
    }
    if(dfn[u]==low[u])//u为强联通分量的根
    {
        cnt++;
        do//退栈
        {
            num[cnt]++;
            v=stack[top--];
            belong[v]=cnt;
            instack[v]=0;
        }while(u!=v);
    }
}
int main()
{
    int ans=0;
    int p,q;
    n=read();m=read();
    for(int i=1;i<=m;i++)
    {
        p=read();q=read();
        edge[i].to=q;
        edge[i].next=head[p];
        head[p]=i;
    }
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i])//i没被访问过了
        {
            tarjan(i);
        }
    }
    for(int i=1;i<=cnt;i++)
    {
        if(num[i]>1)
        ans++;
    }
    printf("%d",ans);
}

求双连通分量

在这里插入图片描述
①点连通分量（BCC）

在一个无向图中，若任意两点间至少存在两条“点不重复”的路径，则说这个图是点双连通的（简称双连通,biconnected）

在一个无向图中，点双连通的极大子图称为点双连通分量（简称双连通分量,Biconnected Component,BCC）

模板

#include<cstdio>
#include<cctype>
#include<vector>
using namespace std;
struct edge
{
    int to,pre;
}edges[1000001];
int head[1000001],dfn[1000001],dfs_clock,tot;
int num;//BCC数量 
int stack[1000001],top;//栈 
vector<int>bcc[1000001];
int tarjan(int u,int fa)
{
    int lowu=dfn[u]=++dfs_clock;
    for(int i=head[u];i;i=edges[i].pre)
        if(!dfn[edges[i].to])
        {
            stack[++top]=edges[i].to;//搜索到的点入栈 
            int lowv=tarjan(edges[i].to,u);
            lowu=min(lowu,lowv);
            if(lowv>=dfn[u])//是割点或根 
            {
                num++;
                while(stack[top]!=edges[i].to)//将点出栈直到目标点 
                    bcc[num].push_back(stack[top--]);
                bcc[num].push_back(stack[top--]);//目标点出栈 
                bcc[num].push_back(u);//不要忘了将当前点存入bcc 
            }
        }
        else if(edges[i].to!=fa)
            lowu=min(lowu,dfn[edges[i].to]);
    return lowu;
}
void add(int x,int y)//邻接表存边 
{
    edges[++tot].to=y;
    edges[tot].pre=head[x];
    head[x]=tot;
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y),add(y,x);
    }
    for(int i=1;i<=n;i++)//遍历n个点tarjan 
        if(!dfn[i])
        {
            stack[top=1]=i;
            tarjan(i,i);
        }
    for(int i=1;i<=num;i++)
    {
        printf("BCC#%d: ",i);
        for(int j=0;j<bcc[i].size();j++)
            printf("%d ",bcc[i][j]);
        printf("\n");
    }
    return 0;
 }

②边强连通分量

与求割边的过程相同，详细代码见下面的求割边代码。

求割点

例题：https://www.luogu.com.cn/problem/P3388

在这里插入图片描述题解

#include<bits/stdc++.h>
using namespace std;
struct edge{
    int nxt,mark;
}pre[200010];
int n,m,idx,cnt,tot;
int head[100010],DFN[100010],LOW[100010];
bool cut[100010];
void add (int x,int y)
{
    pre[++cnt].nxt=y;
    pre[cnt].mark=head[x];
    head[x]=cnt;
}
void tarjan (int u,int fa)
{
    DFN[u]=LOW[u]=++idx;
    int child=0;
    for (int i=head[u];i!=0;i=pre[i].mark)
    {
        int nx=pre[i].nxt;
        if (!DFN[nx])
        {
            tarjan (nx,fa);
            LOW[u]=min (LOW[u],LOW[nx]);
            if (LOW[nx]>=DFN[u]&&u!=fa)
                cut[u]=1;
            if(u==fa)
                child++;
        }
        LOW[u]=min (LOW[u],DFN[nx]);
    }
    if (child>=2&&u==fa)
        cut[u]=1;
}
int main()
{
    memset (DFN,0,sizeof (DFN));
    memset (head,0,sizeof (head));
    scanf ("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        int a,b;
        scanf ("%d%d",&a,&b);
        add (a,b);
        add (b,a);
    }
    for (int i=1;i<=n;i++)
        if (DFN[i]==0)
            tarjan (i,i);
    for (int i=1;i<=n;i++)
        if (cut[i])
            tot++;
    printf ("%d\n",tot);
    for (int i=1;i<=n;i++)
        if (cut[i])
            printf ("%d ",i);
    return 0;
}

求割边

例题：https://www.luogu.com.cn/problem/P1656

在这里插入图片描述
题解：

#include <bits/stdc++.h>
using namespace std;
int maps[151][151];//邻接矩阵
struct Edge {
    int x,y;
} E[5001];//这是存答案的，用邻接表存，应该不用解释
int dfn[151],low[151],n,m,id,cnt,f[151];/*这些数组的含义：
dfn:
{
下标：点编号
内存的值：深度优先搜索时第几个遍历
}
low:
{
下标：点编号
内存的值：这个点能通过它的子孙到达的dfn值最小的点的dfn
}
f:
{
下标：点标号
内存的值：它遍历的上一个点
}
变量的含义：
n:结点个数
m:边个数
id:用于dfn标记
cnt:用于邻接表存图
*/
bool cmp(struct Edge a,struct Edge b) {
    if(a.x==b.x)return a.y<b.y;
    return a.x<b.x;
}//因题目要求，边要排序，要做这道题的人应该都知道cmp
void addEdge(int x,int y) {
    E[++cnt].x=x;
    E[cnt].y=y;
}//addedge函数，存入邻接表
void tarjan(int x) {
    int c=0,y;
    dfn[x]=low[x]=++id;
    for(register int i=1; i<=n; i++) {
        if(!maps[x][i])continue;//首先要有边
        y=i;//处理对象
        if(dfn[y]&&y!=f[x])low[x]=min(low[x],dfn[y]);//如果是它爸爸，割边就没有用了，好好理解
        if(!dfn[y]) {//如果找到祖先还有什么用呢
            f[y]=x;//不是祖先就认爸爸
            tarjan(y);//dfs过程
            low[x]=min(low[x],low[y]);//回溯时带着爸爸更新low
            if(low[y]>dfn[x])addEdge(x,y);//是割边，就加入吧
        }
    }
}//tarjan部分，证明在下面
int main() {
    int x,y;
    cin>>n>>m;
    for(register int i=1; i<=m; i++) {
        cin>>x>>y;
        maps[x][y]=maps[y][x]=1;//存边
    }
    for(register int i=1; i<=n; i++) {
        if(!dfn[i])tarjan(i);//tarjan
    }
    sort(E+1,E+cnt+1,cmp);//sort大法好
    for(register int i=1; i<=cnt; i++) {
        cout<<min(E[i].x,E[i].y)<<' '<<max(E[i].x,E[i].y)<<endl;//输出
    }
    return 0;//程序结束了
}

求缩点

缩点：顾名思义，就是将一些点缩成一个点的算法。

题目链接：https://www.luogu.com.cn/problem/P3387

在这里插入图片描述
题解：

#include<bits/stdc++.h>
using namespace std;

const int maxn=10000+15;
int n,m,sum,tim,top,s;
int p[maxn],head[maxn],sd[maxn],dfn[maxn],low[maxn];//DFN(u)为节点u搜索被搜索到时的次序编号(时间戳)，Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号 
int stac[maxn],vis[maxn];//栈只为了表示此时是否有父子关系 
int h[maxn],in[maxn],dist[maxn];
struct EDGE
{
	int to;int next;int from;
}edge[maxn*10],ed[maxn*10];
void add(int x,int y)
{
	edge[++sum].next=head[x];
	edge[sum].from=x;
	edge[sum].to=y;
	head[x]=sum;
}
void tarjan(int x)
{
	low[x]=dfn[x]=++tim;
	stac[++top]=x;vis[x]=1;
	for (int i=head[x];i;i=edge[i].next)
	{
		int v=edge[i].to;
		if (!dfn[v]) {
		tarjan(v);
		low[x]=min(low[x],low[v]);
	}
	    else if (vis[v])
	    {
	    	low[x]=min(low[x],low[v]);
		}
	}
	if (dfn[x]==low[x])
	{
		int y;
		while (y=stac[top--])
		{
			sd[y]=x;
			vis[y]=0;
			if (x==y) break;
			p[x]+=p[y];
		}
	}
}
int topo()
{
	queue <int> q;
	int tot=0;
	for (int i=1;i<=n;i++)
	if (sd[i]==i&&!in[i])
	{
		q.push(i);
        dist[i]=p[i];
	 } 
	while (!q.empty())
	{
		int k=q.front();q.pop();
		for (int i=h[k];i;i=ed[i].next)
		{
			int v=ed[i].to;
			dist[v]=max(dist[v],dist[k]+p[v]);
			in[v]--;
			if (in[v]==0) q.push(v);
		}
	}
    int ans=0;
    for (int i=1;i<=n;i++)
    ans=max(ans,dist[i]);
    return ans;
}
int main()
{
	scanf("%d%d",&n,&m);
	for (int i=1;i<=n;i++)
	scanf("%d",&p[i]);
	for (int i=1;i<=m;i++)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		add(u,v);
	}
	for (int i=1;i<=n;i++)
	if (!dfn[i]) tarjan(i);
	for (int i=1;i<=m;i++)
	{
		int x=sd[edge[i].from],y=sd[edge[i].to];
		if (x!=y)
		{
			ed[++s].next=h[x];
			ed[s].to=y;
			ed[s].from=x;
			h[x]=s;
			in[y]++;
		}
	}
	printf("%d",topo());
	return 0;
}
daisy~111
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
无向图 点连通tarjan算法 求割点 + 求BCC以及BCC里面的点 + 求去掉每个点后图中BCC数目 【总结】
世界很大
07-09 1921
看了好久，终于把点——双联通看懂了。 题目：给定一个有N个点M条边组成的无向图，求无向图中的割点以及去掉该点后分成的BCC数目，若不存在割点输出No SPF nodes。 思路： tarjan算法： 用low[]表示从该点或它的子孙出发 通过回边可以到达的最低深度优先数 更新low[u]有三点：均在tarjan中实现 1，u本身的深度优先数dfn[u] 2，u的子女中最
图的连通性问题之tarjan算法
cax1165
07-08 2305
Tarjan算法一种由Robert Tarjan提出的求解有向图强连通分量的线性时间的算法。 Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。 定义dfn(u)为节点u搜索的次序编号，low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。 当dfn(u)
kosaraju 和 tarjan算法详解(强连通分量）
qq_43842119的博客
09-18 1279
定 义  在有向图G中，如果任意两个不同的顶点相互可达，则称该有向图是强连通的。 有向图G的极大强连通子图称为G的强连通分支。  转置图的定义：将有向图G中的每一条边反向形成的图称为G的转置GT 。（注意到原图和GT 的强连通分支是一样的）Korasaju算法 1.深度优先遍历G，算出每个结点u的结束时间f[u],起点如何选择无所谓。 每个结点的结束时间和开始时间是dfs序，开始时...
全网最!详!细!Tarjan算法讲解。
AC_Dreameng
07-17 1万+
Tarjan算法讲解的博客网上找到三篇比较好的,现在都转载了,个人只研究了第一篇,正如博主所说,讲的标比较详细,清晰,剩下两篇也可以看一下. 以下内容转自:http://www.cnblogs.com/uncle-lu/p/5876729.html 全网最详细tarjan算法讲解，我不敢说别的。反正其他tarjan算法讲解，我看了半天才看懂。我写的这个，读完一遍，发现原来tarjan这
关于tarjan算法的一些知识点（主要是我经常忘记可以用来干什么）
qq_41510496的博客
06-22 288
首先当然是找强联通分量（不解释）。缩点（也是不解释）求割点（割点什么是割点呢；就是在一个连通图中删除一个点就导致真个图不连通了，那么这个点就叫做割点）。一道裸题（PrayerOJ1435）：点击打开链接这篇东西讲的很好：点击打开链接...
Tarjan算法精讲
05-07
更精细的追踪每一个步骤，力求完全剖析算法。
Tarjan 算法论文 DEPTH-FIRST SEARCH AND LINEAR GRAPH ALGORITHMS.pdf
04-10
Tarjan 算法论文 DEPTH-FIRST SEARCH AND LINEAR GRAPH ALGORITHMS.pdf
关于 tarjan 算法
02-28
关于tarjan算法的代码，自己写的，和大家分享，希望大家能多多指教
关于tarjan算法
02-28
关于C(m,n)算法的代码，自己写的，和大家分享，希望大家能多多指教
Tarjan 的强连通分量算法的Python实现
06-08
Tarjan 的算法将一个有向（可能是循环的！）图作为输入，并以拓扑顺序返回其强连通分量作为输出 循环依赖 在各种情况下，依赖关系可能是循环的，并且必须同时执行一组相互依赖的操作。同时执行成本高昂的情况并不...
tarjan算法讲解
echo space
08-08 1590
具体算法介绍 参考 http://www.byvoid.com/blog/scc-tarjan/ 首先明确几个概念。 强连通图。在一个强连通图中，任意两个点都通过一定路径互相连通。比如图一是一个强连通图，而图二不是。因为没有一条路使得点4到达点1、2或3。 强连通分量。在一个非强连通图中极大的强连通子图就是该图的强连通分量。比如图三中子图{1,2,3,5}是一个强连通分量，子图{4}是一个强
有向图强连通分量的Tarjan算法
乐吾天
08-30 1332
有向图强连通分量]在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分别是两
Tarjan算法求解强连通分量（SCC）
Feynman1999的博客
08-14 1545
强连通分量有向图强连通分量：在有向图G中，如果两个顶点vi,vj间（vi>vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量(strongly connected components)。 Tarjan算法求解思路 首先，
Tarjan算法小结
口丁乙orz各位菊苣口下留情orz口丁乙
08-12 348
Tarjan算法小结 作用 两种，一种是找有向图的强连通分量。另一种是找无向图的割点、桥边。 其中强连通分量是指分量中的任意两点都能够找到路径和另一个点联通。 割点是指去掉该点后连通图就失去了联通性，桥边同理。 思路 求强连通分量 一次DFS，设置两个数组，一个是时间戳（我写的timestamp，因为工程上基本都叫这个，然而我看到别人的教程基本用的是dfn），一个是low(...
强连通图的算法
热门推荐
justlovetao的专栏
08-09 2万+
有向图强连通分量的Tarjan算法 [有向图强连通分量] 在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(stron
Tarjan-CV/BCC/SCC算法学习笔记
HAHA1011111的博客
09-10 550
DFS性质的应用——利用Tarjan算法求割顶、BCC、SCC 整理自《算法竞赛入门经典——训练指南》以及网络 DFS (depth first search)深度优先搜索算法 dfs森林：按照dfs的执行顺序，将图的所有边重新梳理，分为四个类别：前向边、反向边、交叉边和树边。在无向图中不存在交叉边，前向边与后向边等价。 关键变量： pre[u]：记录u点被访问到的次序。 pre[u...
Tarjan算法详解
刘伟的博客
10-16 1万+
       在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。如下图中，强连通分量有：{1,2,3,4}，{5}，{6}       Tarjan算法是基于对图深度优先搜索的算法...
tarjan算法题目练习(长期更新)
一个蒟蒻的博客
09-26 547
P2002 消息扩散 题目描述 有n个城市，中间有单向道路连接，消息会沿着道路扩散，现在给出n个城市及其之间的道路，问至少需要在几个城市发布消息才能让这所有n个城市都得到消息。 tarjan缩点(因为一个强连通分量内的点只要又一个传到了其他点都传到了，所以可以缩成一个点)，然后重新建图，统计out[i]为0的点的数量 #include <iostream> #include <a...
Tarjan算法
菜鸟成长ing
11-03 590
#include #include int DFN[105]; //dfn[i]表示dfs时达到顶点i的时间 int Low[10005]; //low[i]表示i所能直接或间接达到时间最小的顶点。 bool map[105][105]; bool mark[105]; int stack[105]; int ti
Tarjan算法和Kosaraju算法
最新发布
11-10
Tarjan算法和Kosaraju算法都是求解有向图强连通分量的算法，它们的时间复杂度都为O(N+M)，其中N为图中节点数，M为图中边数。 Tarjan算法的基本思想是通过DFS遍历图中的节点，并在遍历的过程中维护一个栈，用于存储...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值