教你如何使用Tarjan模版（模版讲解和使用方法+例题）

最新推荐文章于 2022-07-22 08:51:57 发布
最新推荐文章于 2022-07-22 08:51:57 发布
阅读量247 收藏 1
点赞数
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littlegoldgold/article/details/107726873
版权

Tarjan的基本概率可以通过下面来了解
Tarjan讲解参考1
Tarjan讲解参考2
Tarjan讲解参考3
Tarjan模版：
定义变量解释：
tot用来保存当前遍历到的次序
DFN[i]表示i被遍历的次序（1，2，3，4…) 每个点的DFN都是独一无二的
LOW[i]表示i所在的强连通图中的点中最小的遍历次序，同一个强连通图中的点的LOW是相同的
cntp记录强连通图数量
pa[i]用来记录i点所在连通图（图按1，2，3，…标记）
stack[i]模拟栈的操作，用来保存同一连通图中的点

 #include<cstdio>
 #include<algorithm>
 #include<string.h>
 using namespace std;
 #define maxn 1001
 struct node {
     int v,next;
 }edge[maxn];
  int DFN[maxn],LOW[maxn];  
  int pa[maxn],cntp;  //记录各点所在的连通图 
 int stack[maxn],heads[maxn],visit[maxn],cnt,tot,index;
void add(int x,int y)
{
     edge[++cnt].next=heads[x];
     edge[cnt].v = y;
     heads[x]=cnt;
    return ;
 }
 void tarjan(int x)//代表第几个点在处理。递归的是点。
 {
     DFN[x]=LOW[x]=++tot;// 新进点的初始化。
     stack[++index]=x;//进站
     visit[x]=1;//表示在栈里
    for(int i=heads[x];i!=-1;i=edge[i].next)
     {
         if(!DFN[edge[i].v]) {//如果没访问过
            tarjan(edge[i].v);//往下进行延伸，开始递归
             LOW[x]=min(LOW[x],LOW[edge[i].v]);//递归出来，比较谁是谁的儿子／父亲，就是树的对应关系，涉及到强连通分量子树最小根的事情。
             if (LOW[edge[i].v] > DFN[x])   
            {
                //该部分主要用来处理桥，满足条件x到edge[i].v边为桥
                //桥处理操作可以写在这里面
            }
        }
        else if(visit[edge[i].v ]){  //如果访问过，并且还在栈里。
             LOW[x]=min(LOW[x],DFN[edge[i].v]);//比较谁是谁的儿子／父亲。就是链接对应关系
         }
     }
     if(LOW[x]==DFN[x]) //发现是整个强连通分量子树里的最小根。
    {
        cntp++;//这里可以记录强连通图个数
         do{
             visit[stack[index]]=0;
			 pa[stack[index]]=cntp;    //记录当前节点在哪一个强连通图中
             index--;
         }while(x!=stack[index+1]);//出栈，并且输出。
     }
     return ;
 }
 int main()
 {
     memset(heads,-1,sizeof(heads));
     memset(DFN,0,sizeof(DFN));
     memset(vis,0,sizeof(vis));
     int n,m;
     scanf("%d%d",&n,&m);
    int x,y;
     for(int i=1;i<=m;i++)
     {
         scanf("%d%d",&x,&y);
        add(x,y);
     }
    for(int i=1;i<=n;i++)
         if(!DFN[i])  tarjan(i);//当这个点没有访问过，就从此点开始。防止图没走完
    return 0;
 }

kuangbin求强连通图模版

const int MAXN = 20010;//点数 
const int MAXM = 50010;//边数 
struct Edge{
	int to,next;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong 数组的值是 1 ∼ scc
int Index,top;
int scc;//强连通分量的个数
bool Instack[MAXN];
int num[MAXN];//各个强连通分量包含点的个数，数组编号 1 ∼ scc
//num 数组不一定需要，结合实际情况
void addedge(int u,int v){ 
	edge[tot].to = v;edge[tot].next = head[u];head[u] = tot++; 
}
void Tarjan(int u){
	int v; 
	Low[u] = DFN[u] = ++Index;
	Stack[top++] = u;
	Instack[u] = true;
	for(int i = head[u];i != -1;i = edge[i].next){
		v = edge[i].to;
		if( !DFN[v] ){
			Tarjan(v);
			if( Low[u] > Low[v] )Low[u] = Low[v];
		}
		else if(Instack[v] && Low[u] > DFN[v]) 
			Low[u] = DFN[v]; 
	} 
	if(Low[u] == DFN[u]){
		scc++; 
		do{ 
			v = Stack[−−top];
			Instack[v] = false;
			Belong[v] = scc;
			num[scc]++;
		}while( v != u);
	} 
}
void solve(int N){
	memset(DFN,0,sizeof(DFN));
	memset(Instack,false,sizeof(Instack));
	memset(num,0,sizeof(num));
	Index = scc = top = 0;
	for(int i = 1;i <= N;i++)
		if(!DFN[i])
			Tarjan(i);
}
void init(){
	tot = 0; 
	memset(head,−1,sizeof(head));
}

kuangbin求割点和桥模版：

/*
* 求无向图的割点和桥
* 可以找出割点和桥，求删掉每个点后增加的连通块
* 需要注意重边的处理，可以先用矩阵存，再转邻接表，或者进行判重
*/ 
const int MAXN = 10010;
const int MAXM = 100010;
struct Edge{
	int to,next;
	bool cut;//是否为桥的标记
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN];
int Index,top;
bool Instack[MAXN];
bool cut[MAXN];
int add_block[MAXN];//删除一个点后增加的连通块
int bridge;
void addedge(int u,int v){
	edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut = false ;
	head[u] = tot++;
}
void Tarjan(int u,int pre){
	int v;
	Low[u] = DFN[u] = ++Index;
	Stack[top++] = u;
	Instack[u] = true;
	int son = 0;
	int pre_cnt = 0; //处理重边，如果不需要可以去掉
	for(int i = head[u];i != -1;i = edge[i].next){
		v = edge[i].to;
		if(v == pre && pre_cnt == 0){pre_cnt++;continue;}
		if( !DFN[v] ){
			son++; 
			Tarjan(v,u);
			if(Low[u] > Low[v])Low[u] = Low[v];
			//桥 
			//一条无向边 (u,v) 是桥，当且仅当 (u,v) 为树枝边，且满足 DFS(u)<Low(v)。
			if(Low[v] > DFN[u]){
				bridge++;
				edge[i].cut = true;
				edge[i^1].cut = true;
			}
			//割点
			//一个顶点 u 是割点，当且仅当满足 (1) 或 (2) (1) u 为树根，且 u 有多于一个子树
			//(2) u 不为树根，且满足存在 (u,v) 为树枝边 (或称父子边,
			//即 u 为 v 在搜索树中的父亲)，使得 DFS(u)<=Low(v)
			if(u != pre && Low[v] >= DFN[u]){//不是树根
				cut[u] = true;
				add_block[u]++;
			}
		}
		else if( Low[u] > DFN[v])
			Low[u] = DFN[v];
	} 
	//树根，分支数大于 1
	if(u == pre && son > 1)cut[u] = true;
	if(u == pre)add_block[u] = son - 1;
	Instack[u] = false;
	top--;
}

①图的保存方式使用的是邻接表，可以改为vector数组保存，只需要将add和tarjan函数相应部分改变一下就好

割点
若从图中删除节点 x 以及所有与 x 关联的边之后，图将被分成两个或两个以上的不相连的子图，那么称 x 为图的割点。

桥
若从图中删除边 e 之后，图将分裂成两个不相连的子图，那么称 e 为图的桥或割边。

②tarjan可以用来求图的桥
割点主要操作位置在tarjan函数中

if (LOW[edge[i].v] > DFN[x])   
            {
                //该部分主要用来处理桥，满足条件edge[i].v到x之间为桥
                //桥处理操作可以写在这里面
            }

将需要对桥进行的操作写在里面即可
③tarjan可以用来求图的割点，使用到kuangbin模版

	//桥 
			//一条无向边 (u,v) 是桥，当且仅当 (u,v) 为树枝边，且满足 DFS(u)<Low(v)。
			if(Low[v] > DFN[u]){
				bridge++;
				edge[i].cut = true;
				edge[i^1].cut = true;
			}
			//割点
			//一个顶点 u 是割点，当且仅当满足 (1) 或 (2) (1) u 为树根，且 u 有多于一个子树
			//(2) u 不为树根，且满足存在 (u,v) 为树枝边 (或称父子边,
			//即 u 为 v 在搜索树中的父亲)，使得 DFS(u)<=Low(v)
			if(u != pre && Low[v] >= DFN[u]){//不是树根
				cut[u] = true;
				add_block[u]++;
			}

④tarjan判断强连通图的数量和处理各个点所在的强连通图
cntp保存强连通图数量
pa[i]保存i点所在的强连通图

if(LOW[x]==DFN[x]) //发现是整个强连通分量子树里的最小根。
    {
        cntp++;//这里可以记录强连通图个数
         do{
             visit[stack[index]]=0;
			 pa[stack[index]]=cntp;    //记录当前节点在哪一个强连通图中
             index--;
         }while(x!=stack[index+1]);//出栈，并且输出。
     }

例题：
①tarjan算法求桥问题
HDU - 4738 Caocao’s Bridges
题目链接

#include<iostream>
#include<cstdio>
#include<string.h>
#include<vector>
#include<string>
#include<math.h>
#include<algorithm>
using namespace std;
const int MAXN = 1100;//点数 
const int MAXM = 50010;//边数 
#define inf 0x3f3f3f
int n,m;
int cost[MAXN][MAXN];
vector<int> eg[MAXN];
int idx;
int dfn[MAXN],low[MAXN],parent[MAXN],res;
void tarjan(int u)
{
    int child = 0;
    low[u] = dfn[u] = ++idx;
    for (int v : eg[u])
    {
        if (!dfn[v])
        {
            parent[v] = u;
            tarjan(v);
            low[u] = min(low[u], low[v]);
            if (low[v] > dfn[u])
            {
                res=min(res,cost[u][v]);
            }
        }
        else if (v!= parent[u])
            low[u]=min(low[u],dfn[v]);
    }
}
void init()
{
    res = inf;
    idx = 0;
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(parent,-1,sizeof(parent));
    memset(cost,0, sizeof(cost));
}
int main()
{
    int n, m, x, y, w;
    while (~scanf("%d%d",&n,&m))
    {
		if(n==0&&m==0)
			break;
        init();
        for (int i = 0; i < m; i++)
        {
            scanf("%d%d%d",&x,&y,&w);
            eg[x].push_back(y);
            eg[y].push_back(x);
            if (cost[x][y] != 0)
                cost[x][y]=cost[y][x]=inf;
            else
                cost[x][y]=cost[y][x]=w;
        }
        int i;
		tarjan(1);
        for (i =2; i <= n; i++)
            if(!dfn[i]){   //如果超过两个连通图时
                cout<<0<<endl;
                break;
            }
        if (i== n+1)
        {
            if (res==inf)
                cout << -1 << endl;
            else if (res == 0)
                cout << 1 << endl;
            else
                cout << res << endl;
        }
        for(int i=1;i<= n;i++)
            eg[i].clear();
    }
	return 0;
}

②tarjan算法处理强连通图问题
CodeForces - 427C Checkposts
题目链接

#include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<string.h>
 using namespace std;
const int maxn=1e5+10;
const int mod=1e9+7;
#define ll long long
 struct node {
     int v,next;
 }edge[3*maxn];
 int pa[maxn],minv[maxn],num[maxn],c[maxn]; 
 int DFN[maxn],LOW[maxn];
 int stack[maxn],heads[maxn],visit[maxn],cnt,tot,index,cntp;
void add(int x,int y)
{
     edge[++cnt].next=heads[x];
     edge[cnt].v = y;
     heads[x]=cnt;
    return ;
 }
 void tarjan(int x)//代表第几个点在处理。递归的是点。
 {
     DFN[x]=LOW[x]=++tot;// 新进点的初始化。
     stack[++index]=x;//进站
     visit[x]=1;//表示在栈里
    for(int i=heads[x];i!=-1;i=edge[i].next)
     {
         if(!DFN[edge[i].v]) {//如果没访问过
            tarjan(edge[i].v);//往下进行延伸，开始递归
             LOW[x]=min(LOW[x],LOW[edge[i].v]);//递归出来，比较谁是谁的儿子／父亲，就是树的对应关系，涉及到强连通分量子树最小根的事情。
        }
        else if(visit[edge[i].v]){  //如果访问过，并且还在栈里。
             LOW[x]=min(LOW[x],DFN[edge[i].v]);//比较谁是谁的儿子／父亲。就是链接对应关系
         }
     }
     if(LOW[x]==DFN[x]) //发现是整个强连通分量子树里的最小根。
    {
        cntp++;//这里可以记录强连通图个数
         do{
             visit[stack[index]]=0;
			 pa[stack[index]]=cntp;    //记录当前节点在哪一个强连通图中
             index--;
         }while(x!=stack[index+1]);//出栈，并且输出。
     }
     return ;
 }
 int main()
 {
     memset(heads,-1,sizeof(heads));
     int n,m;
     scanf("%d",&n);
	 for(int i=1;i<=n;i++) minv[i]=1e9;
	 for(int i=1;i<=n;i++)
		 scanf("%d",&c[i]);
	 scanf("%d",&m);
    int x,y;
     for(int i=1;i<=m;i++)
     {
         scanf("%d%d",&x,&y);
         add(x,y);
     }
    for(int i=1;i<=n;i++)
         if(!DFN[i])  tarjan(i);//当这个点没有访问过，就从此点开始。防止图没走完
	for(int i=1;i<=n;i++){
		minv[pa[i]]=min(minv[pa[i]],c[i]);
	}
	for(int i=1;i<=n;i++){
		if(c[i]==minv[pa[i]]){
			num[pa[i]]++;
		}
	}
	ll ans=0;
	ll ant=1;
	for(int i=1;i<=cntp;i++){
			ans+=minv[i];
			ant*=num[i];
			ant%=mod;
	}
	cout<<ans<<" "<<ant<<endl;
    return 0;
 }

HDU3062 Party
题目+讲解

Buyi.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Tarjan算法模板
05-25
C++实现Tarjan算法的一个简单模板，求有向图的强连通分量。时间复杂度为O(N+M)。
算法模板题系列（2）：tarjan缩点
qq_54017368的博客
10-19 181
模板，个人自用
tarjan模板完整版
weixin_30834783的博客
08-11 108
https://www.luogu.org/problem/P2863 #include<cstdio> #include<vector> using namespace std; int dfn[10005],low[10005],stack[10005],scc[10005],num[10005],vis[10005]; int clock,scc_cnt,t...
tarjan模板
The wheel of Fortune
07-14 199
推荐一下前辈的博客 https://blog.csdn.net/qq_34374664/article/details/77488976 https://blog.csdn.net/mengxiang000000/article/details/51672725 这是介绍强连通分量的 https://blog.csdn.net/qq_16234613/article/de...
POJ3352】Road Construction tarjan 边-双连通分量模板题
lunch__的博客
08-17 326
题目链接 这怕是pojpojpoj除了A+B&amp;amp;nbsp;ProblemA+B&amp;amp;nbsp;ProblemA+B\ Problem最良心的题了 边双比点双好求多了 因为有个很棒的性质就是lowlowlow相同的点都在一个边双里，因为一个边双上面肯定是桥边，而桥边上面的点dfsdfsdfs时间戳一定小于下面的点，所以下面的点就成了一个边双，缩完点后发现是一棵树，让树变成边双的最小代价就是叶子节点数+...
tarjan:使用Tarjan算法在Go中进行图形循环检测
05-06
Tarjan是使用Tarjan算法的图循环检测功能。 该算法获取输入图并生成一个切片，其中每个项目都是一个高度连接的顶点的切片。 输入图采用地图的形式，其中键是图形顶点，值是一个切片的for的边。 算法说明： : ...
连通图tarjan算法动画讲解呕心沥血之作
02-01
tarjan算法呕心沥血之作，动画演示，步步清晰可见，详细的描述了tarjan算法的工作过程，比网上的单纯的图片更加容易理解。
Tarjan算法 讲解
12-10
Tarjan算法的图文讲解，非常详细易懂。 强连通分量算法
无向图缩点：tarjan点双与边双缩点(模板)
01-20
e-DCC边双缩点：(用之前记得init) cnt1是从2开始的 const int N=1e4+100; const int M=1e5+100; struct Egde { int to,next; }edge1[M],edge2[M];...int head1[N],head2[N],low[N],dfn[N],c[N],num,cnt1,cnt2,dcc,n,m...
有向图缩点：tarjan强连通缩点(模板)
01-20
SCC强连通缩点：(用之前记得init) const int N=1e4+100; const int M=1e5+100; struct Egde { int to,next; }edge1[M],edge2[M];...int head1[N],head2[N],low[N],dfn[N],c[N],Stack[N],num,cnt,cnt2,cnt1,dcc,n,m,top...
Tarjan模板【洛谷P2921】
KIKO_caoyue的博客
11-12 261
传送门：https://www.luogu.org/problemnew/show/P2921 上代码先占坑，我去打打NOIP2018(滑稽) 好了好了回来了，NOIP太难了，做不动。 Tarjan是用来求强连通分量的算法。应用十分广泛。 Tarjan算法就不证明了，有兴趣的可以去网上看大神们的各种证明。(主要是我也不会证明啊) 随便讲讲Tarjan怎么写的吧。 low[]和dfn[]...
POJ 2186：Popular Cows Tarjan模板题
weixin_34392843的博客
08-03 113
Popular Cows Time Limit:2000MS Memory Limit:65536K Total Submissions:25945 Accepted:10612 Description Every cow's dream is to become the most popular co...
强连通tarjan模版
热门推荐
九野的博客
08-14 1万+
#include #include #include #include #include #include #include #include #define N 1000 #define INF 1152921504606846976 #define R(x) x<<1|1 #define L(x) x<<1 #define Mid(x,y) (x+y)>>1 #define ll int u
图的连通性问题之tarjan算法
cax1165
07-08 2265
Tarjan算法一种由Robert Tarjan提出的求解有向图强连通分量的线性时间的算法。 Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。 定义dfn(u)为节点u搜索的次序编号，low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。 当dfn(u)
HDU1269迷宫城堡（Tarjan模板题）
Rain
04-03 820
题目大意： 问一个图是不是强连通的。 Tarjan模板+详细解释： #include #include #include #include using namespace std; const int maxn = 10010; const int maxm = 100010; int n, m; int cnt, tol, scnt, top; int head[maxn], st
tarjan——模板
hejx0412的博客
07-22 157
话不多说直接上代码。
给出一个由=使用Tarjan缩点算法的实例
最新发布
05-14
以下是一个使用Tarjan缩点算法的实例： 假设有一个有向图G，其中有四个节点和五条边，如下所示： ``` 1 -> 2 2 -> 3 3 -> 1 3 -> 4 ``` 使用Tarjan缩点算法可以将图G缩成一个新的图G'，其中每个强连通分量（SCC）...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Buyi.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值