Tarjan

最新推荐文章于 2023-05-10 13:15:53 发布
最新推荐文章于 2023-05-10 13:15:53 发布
阅读量467 收藏 2
点赞数
分类专栏： 图论 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Emma2oo6/article/details/90759562
版权

有向图的强连通分量：

因为是复习，所以在此不进行算法赘述

算法介绍：https://www.cnblogs.com/mhpp/p/6751723.html

#include<iostream>
#include<vector>
#include<stack>
using namespace std;

vector<int> g[1001];
stack<int> s;
int n,m,scc[1001],x,y,low[1001],dfn[1001],ind,sccNum[1001],sccV;

void tarjan(int u){
    low[u]=dfn[u]=++ind;
    s.push(u);
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }else{
            if(!scc[v]){
                low[u]=min(low[u],dfn[v]);
            }
        }
    }
    if(low[u]==dfn[u]){
        sccV++;
        int v;
        do{
            v=s.top();
            s.pop();
            scc[v]=sccV;
            sccNum[sccV]++;
        }while(u!=v);
    }
}

int main(){
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        cin>>x>>y;
        g[x].push_back(y);
    }
    for(int i=1;i<=n;i++){
        if(dfn[i]==0)tarjan(i);
    }
    for(int i=1;i<=n;i++){
        if(sccNum[scc[i]]>1)cout<<"T"<<endl;
        else cout<<"F"<<endl;
    }
}

时间复杂度：

O(n+m) n为点数,m为边数

割点与桥：

定义：

  • 割点：无向连通图中，去掉一个顶点及和它相邻的所有边，图中的连通分量数增加，则该顶点称为割点

  • 桥（割边）：无向连通图中，去掉一条边，图中的连通分量数增加，则这条边，称为桥或者割边

割点与桥（割边）的关系：

1）有割点不一定有桥,有桥一定存在割点

2）桥一定是割点依附的边。

下图中顶点C为割点，但和C相连的边都不是桥

判定方法：

ps: v为u的子节点

  1. 如果low[v] >= dfn[u]：
    就说明 V 访问 U 的祖先顶点，必须通过 U ，所以 U 就是一个割点

  2. 如果low[v] > dfn[u]：
    就说明 V-U 是桥（类似上文）

双连通图：

边双连通图：一个图无桥

构造方法：

首先按桥缩点，形成的图一定是一棵树，有桥。

然后统计出树中度为1的节点的个数，即为叶节点的个数，记为leaf。

则至少在树上添加(leaf+1)/2条边，就能使树达到双连通，所以至少添加的边数就是(leaf+1)/2。

具体方法：

在两个最近公共祖先最远的叶节点之间连接一条边，这样这两个点到祖先的路径加这条边就形成了一个环。

以此类推，恰好需要执行(leaf+1)/2次操作。

//按桥缩点 (leaf+1)/2= 添最少的边能使无向图变成双连通图
#include<iostream>
#include<vector>
#include<stack>
using namespace std;
struct edge{
    int t,id;
};
vector<edge> g[5001];
stack<int> s;
int low[5001],dfn[5001],bcc[5001],deg[5001],bcc_num,n,m,x,y,ind,br,leaf;
bool net[5001][5001];
void tarjan(int u,int fa) {
    dfn[u]=low[u]=++ind;
    s.push(u);
    for(int i=0; i<g[u].size(); i++) {
        int v=g[u][i].t;
        if(!dfn[v]) {
            tarjan(v,g[u][i].id);
            low[u]=min(low[u],low[v]);
            if(low[v]>dfn[u]) {
                bcc_num++;
                br++;
                int k;
                do {
                    k=s.top();
                    s.pop();
                    bcc[k]=bcc_num;
                } while(k!=v);
            }
        } else {
            if(dfn[v]<dfn[u]&&fa/2!=g[u][i].id/2) {
                low[u]=min(low[u],dfn[v]);
            }
        }
    }
    if(fa==-1) {
        bcc_num++;
        while(!s.empty()) {
            int k=s.top();
            s.pop();
            bcc[k]=bcc_num;
        }
    }
}

int main() {
    cin>>n>>m;
    for(int i=0; i<m; i++) {
        cin>>x>>y;
        g[x].push_back((edge){y,i*2});
        g[y].push_back((edge){x,i*2+1});
    }
    for(int i=1; i<=n; i++) {
        if(!dfn[i])tarjan(i,-1);
    }
    for(int i=1; i<=n; i++) {
        for(int j=0; j<g[i].size(); j++) {
            int k=g[i][j].t;
            if(bcc[i]!=bcc[k]&&net[bcc[i]][bcc[k]]==false) {
                net[bcc[i]][bcc[k]]=true;
                net[bcc[k]][bcc[i]]=true;
                deg[bcc[i]]++;
                deg[bcc[k]]++;
            }
        }
    }
    for(int i=1; i<=bcc_num; i++) {
        if(deg[i]==1)leaf++;
    }
    cout<<br<<endl;
    cout<<(leaf+1)/2<<endl;
}

点双连通图：一个图无割点

//求割点及每个割点把图分成几部分 
#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
vector<int> g[1001];
int dfn[1001],low[1001],cp[1001],n,s,t,ind,c=1;
bool flag;
void init(){
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(cp,0,sizeof(cp));
    for(int i=1;i<=1000;i++)g[i].clear();
    ind=0;
    flag=false;
    c++;
    n=0;
}

void tarjan(int u,int fa){
    dfn[u]=low[u]=++ind;
    int child=0;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(!dfn[v]){
            child++;
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(low[v]>=dfn[u])cp[u]++;
        }else{
            if(dfn[v]<dfn[u]&&v!=fa){
                low[u]=min(low[u],dfn[v]);
            }
        }
    }
    if(fa<0&&child==1)cp[u]=0;
}

void work(){
    if(flag==false)return;
    for(int i=1;i<=n;i++){
        if(!dfn[i])tarjan(i,-1);
    }
    cout<<"Network #"<<c<<endl;
    bool spf=false;
    for(int i=1;i<=n;i++){
        if(cp[i]!=0){
            if(i==1)cp[i]--;
            cout<<"  SPF node "<<i<<" leaves "<<cp[i]+1<<" subnets"<<endl;
            spf=true;
        }
    }
    if(spf==false){
        cout<<"  No SPF nodes"<<endl;
    }
    cout<<endl;
}

int main(){
    while(cin>>s){
        if(s==0){
            work();
            init();
            continue;   
        }
        cin>>t;
        flag=true;
        g[s].push_back(t);
        g[t].push_back(s);  
        n=max(n,s);
        n=max(n,t); 
    }
}

//找点双——栈里存点 
#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
const int N=5e4+10;
const int M=3e5+10;
struct Edge{int v,nxt;}edge[M<<1];
int cnt,head[N],n,m;
int dfn[N],low[N],ind,s[N],top;
vector<int> dcc[N];int num;
void addedge(int u,int v){
	edge[++cnt].v=v;edge[cnt].nxt=head[u];head[u]=cnt;
}
void tarjan(int u,int fa){
	dfn[u]=low[u]=++ind;
	s[++top]=u;
	if(fa==-1&&!head[u]){//孤立点
        dcc[++num].push_back(u);
        return;
    }
	for(int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].v;
		if(!dfn[v]){
			tarjan(v,u);
			low[u]=min(low[u],low[v]);
			if(low[v]>=dfn[u]){
				num++;
				int x=0;
				do{
					x=s[top--];
					dcc[num].push_back(x); 
				}while(x!=v);
				dcc[num].push_back(u);//u加到点双里,但不出栈 
			}
		}
		else if(dfn[v]<dfn[u]&&v!=fa){
			low[u]=min(low[u],dfn[v]);
		}
	}
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int u,v;scanf("%d%d",&u,&v);
		addedge(u,v);
		addedge(v,u);
	}
	for(int i=1;i<=n;i++)
		if(!dfn[i]) tarjan(i,-1);
	for(int i=1;i<=num;i++){
		for(int j=0;j<dcc[i].size();j++) printf("%d ",dcc[i][j]);
		puts("");
	}
	return 0;
} 

//找点双——栈里存边
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int N=1010;
const int M=100010;
struct Edge{
	int u,v,nxt;
}edge[M<<2];
int n,m,cnt,head[N];
int ind,low[N],dfn[N],num,bn[N];
int s[M],top;
int no[N][N],odd[N],col[N];
vector<int> dcc[N];
void init(){
	memset(bn,0,sizeof(bn));
    memset(no,0,sizeof(no));
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(odd,0,sizeof(odd));
    memset(head,0,sizeof(head));
    cnt=0,ind=0,num=0,top=0;
}
void addedge(int u,int v){
	edge[++cnt].u=u;edge[cnt].v=v;edge[cnt].nxt=head[u];head[u]=cnt;
}
void tarjan(int u,int fa){
    low[u]=dfn[u]=++ind;
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].v;
        if(!dfn[v]){
            s[++top]=i;//先压栈再遍历
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(low[v]>=dfn[u]){
                num++;
                dcc[num].clear();
                int x;
                do{
                	x=s[top--];
                	if(bn[edge[x].u]!=num){
                		dcc[num].push_back(edge[x].u);
						bn[edge[x].u]=num;
					}
                    if(bn[edge[x].v]!=num){
                    	dcc[num].push_back(edge[x].v);
						bn[edge[x].v]=num;
					}
				}while(x!=i);
            }
        }
        else if(dfn[v]<dfn[u]&&v!=fa){
            s[++top]=i; 
            low[u]=min(low[u],dfn[v]);
        }
    }
}
int dfs(int u,int k){
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].v;
        if(bn[v]!=k) continue;  
        if(col[v]==-1){  
            col[v]=col[u]^1;  
            if(!dfs(v,k)) return 0;
        }
        else if(col[v]==col[u]) return 0;
    }
    return 1;
}
int main(){
    while(1){
        init();
        scanf("%d%d",&n,&m);
        if(!n&&!m) break;
        for(int i=1;i<=m;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            if(!x&&!y) break;
            no[x][y]=1;no[y][x]=1;
        }
        for(int i=1;i<=n;i++){
        	for(int j=1;j<=n;j++){
                if(i==j||no[i][j]) continue;
                addedge(i,j);
            }
		}
        for(int i=1;i<=n;i++)
            if(!dfn[i]) tarjan(i,0);
        for(int i=1;i<=num;i++){
            for(int j=0;j<dcc[i].size();j++)
                col[dcc[i][j]]=-1,bn[dcc[i][j]]=i;
            col[dcc[i][0]]=1;
            if(!dfs(dcc[i][0],i)){
                for(int j=0;j<dcc[i].size();j++) odd[dcc[i][j]]=1;
            }
        }
        int ans=n;
        for(int i=1;i<=n;i++)
            if(odd[i]) ans--;
        cout<<ans<<endl;
    }
    return 0;
}
Edward The Bunny
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tarjan算法讲义
07-14
Tarjan 算法是图论中非常实用 / 常用的算法之一，能解决强连通分量，双连通分量，割点和桥，求最近公共祖先（LCA）等问题。 关于 Tarjan 算法，笔者将用一系列文章系统介绍 Tarjan 算法的原理以及其主要解决的问题...
Tarjan算法精讲
05-07
更精细的追踪每一个步骤，力求完全剖析算法。
Tarjan 算法学习笔记
m0_72410588的博客
05-10 968
支持度（Support）是指数据集DDD中包含某个项集XXX的记录所占的比例。SuppXfreqX∣D∣SuppX∣D∣freqX​其中freqXfreq(X)freqX表示包含XXX的记录数，∣D∣|D|∣D∣表示数据集DDD中记录的总数。置信度（Confidence）是指数据集DDD中包含项集XXX的记录中同时包含另一个项集YYY的比例。
Tarjan算法超超超详解（ACM/OI）（强连通分量/缩点）（图论）（C++）
qaqwqaqwq的博客
08-24 8423
深入浅出的Tarjan算法手把手讲解！看完就会！
图的连通性问题之tarjan算法
cax1165
07-08 2331
Tarjan算法一种由Robert Tarjan提出的求解有向图强连通分量的线性时间的算法。 Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。 定义dfn(u)为节点u搜索的次序编号，low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。 当dfn(u)
Robert E. Tarjan——杰出计算机科学家
とある黄鱼のOIブログ
10-17 1468
身为OI/ACM选手，怎能没有听过Tarjan的大名？最近公共祖先的Tarjan算法离线求LCA；强连通分量的极优算法Tarjan（比后来研究出的Kosaraju算法平均快30%）先让我们膜拜一下Tarjan大佬。 早年生涯还在高中的时候，Tarjan获得了IBM穿孔卡核验员。1964年在暑假科学项目学习天文学时第一次使用真正的电脑。 他在1969年获得了加州理工学院的数学学士学位。在斯坦福大学
全网最详细解释tarjan算法
ahelloyou的博客
08-20 3547
tarjan算法 tarjan算法是为了计算强连通分量的 强连通分量也就是在有向图当中，能够双方都能够到达对方的点集 视频链接 代码实现 #include <bits/stdc++.h> using namespace std; int times = 1; // 时间搓 stack<int> st; // 栈 vector<int> dfn; // 访问的时间点 vector<int> low; // 能够回溯到的最小时间点 vecto
Tarjan 的 LCA 算法
03-19
c++写的Tarjan 的 LCA 算法，最近公共祖先算法，可供算法学习参考
Tarjan.ppt
08-01
Tarjan割点割边，强联通分量讲解
Tarjan 的强连通分量算法的Python实现
06-08
Tarjan 的算法将一个有向（可能是循环的！）图作为输入，并以拓扑顺序返回其强连通分量作为输出 循环依赖 在各种情况下，依赖关系可能是循环的，并且必须同时执行一组相互依赖的操作。同时执行成本高昂的情况并不...
Tarjan算法 详解+心得
weixin_30593261的博客
07-11 429
　　Tarjan算法是由Robert Tarjan（罗伯特·塔扬，不知有几位大神读对过这个名字） 发明的求有向图中强连通分量的算法。 　　预备知识：有向图，强连通。 　　有向图：由有向边的构成的图。需要注意的是这是Tarjan算法的前提和条件。 　　强连通：如果两个顶点可以相互通达，则称两个顶点 强连通(strongly connected)。如果有向图G的每两个顶点都 强连通，称G是一个强...
Tarjan算法超详细讲解(割点割边强连通)
汪阿少的博客
02-06 6461
本文出自我的掘金博客, 欢迎大家访问传送门 今天我主要介绍Tarjan算法在割点割边以及强连通分量中的应用以及缩点技巧 按照老规矩, 先上两道模板题 【模板】强连通分量 【模板】割点（割顶） 割点割边 一, 离散数学中的定义: 割点: 无向连通图中，去掉一个顶点及和它相邻的所有边，图中的连通分量数增加，则该顶点称为割点。 割边: 无向联通图中，去掉一条边，图中的连通分量数增加，则这条边，称为...
Tarjan算法
weixin_39393640的博客
03-14 1206
Tarjan算法 Tarjan算法是一个很著名的算法，其主要的目的是用来求有向图的强连通分量，什么是强连通分量呢？ 简单点说就是存在一个点v1v_1v1​能到点v2v_2v2​，且v2v_2v2​也能到v1v_1v1​，那么v1,v2v_1, v_2v1​,v2​就构成一个强连通分量; 具体的定义参见百度。 Tarjan算法步骤 Tarjan算法采用的深度优先遍历的方式(DFS)，需要两个数组df...
Tarjan算法的应用---缩点与割点
weixin_60360239的博客
01-28 1108
Tarjan主要基于深搜，其中有两个非常关键的标记数组，分别是dfn和low，同时引入概念时间戳tt，也就是到达这个点的时间，实际上就是搜索到的次序，dfn记录每个点的时间戳，即第一次访问到的号次，low也就是能到达的最早的时间戳，下面分析。
Tarjan算法详细讲解
木牛的博客
07-06 9458
Tarjan算法讲解的博客网上找到三篇比较好的,现在都转载了,个人只研究了第一篇,正如博主所说,讲的标比较详细,清晰,剩下两篇也可以看一下. 卿学姐视频讲解https://www.bilibili.com/video/av7330663/ 以下内容转自:http://www.cnblogs.com/uncle-lu/p/5876729.html 全网最详细tarjan算法讲解，我不敢说别的。反正其他tarjan算法讲解，我看了半天才看懂。我写的这个，读完一遍，发现原来tarjan这么简单！ ...
Tarjan算法（Robert Tarjan提出的求解有向图强连通分量的线性时间的算法）
qq_46000584的博客
08-21 269
在舍友和同学的帮助下，终于初步理解了用于求强连通分量的Tarjan算法（一种由Robert Tarjan提出的求解有向图强连通分量的线性时间的算法）。Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。 强连通的定义:有向图G强连通,那么G中的任意两个节点可以相互到达 强连通分量的定义是：极大的强连通子图。 DFS 生成树与强连通分量之间的关系：如果结点 u是某个强连通分量在搜索
Tarjan 算法&模板
weixin_30421525的博客
09-14 198
Tarjan 算法 一.算法简介 Tarjan 算法一种由Robert Tarjan提出的求解有向图强连通分量的算法，它能做到线性时间的复杂度。 我们定义： 如果两个顶点可以相互通达，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量(strongly connected compo...
tarjan算法总结
十分残念的博客
07-18 2073
概念（有向图中）：1）在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通。2）如果有向图G的每两个顶点都强连通，则称G是一个强连通图。3）非强连通图有向图的极大强连通子图，称为强连通分量。tarjan算法：通过递归和栈操作，找强连通子图，并进行缩点设每个点的DFS序为dfn[u]，当递归到第u个点，发现下一个点v已经被遍历过，且dfn[u]&lt;dfn[v]，这两个点一定在一个强连通...
hopcroft-tarjan
最新发布
12-02
Hopcroft-Tarjan算法是一种用于有限状态自动机最小化的算法。该算法由John Hopcroft和Robert Tarjan于1973年提出。它的主要思想是将状态分为不可达状态和可达状态，并通过遍历状态间的转移关系来合并不可达状态，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值