tarjan,割边,桥,割点

这里是tarjan的基础知识,

求割点和割边



先来求割边,

#include <cstdio>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;

#define ls (t<<1)
#define rs ((t<<1)|1)
#define mid ((l+r)>>1)

#define mk make_pair
#define pb push_back
#define fi first
#define se second

#define MAXN 100001
struct edge {
    int v,nxt;
} e[MAXN*2];
int head[MAXN];
bool qiao[MAXN*2];
int dfn[MAXN],low[MAXN];
int n,m,cnt,num;
void add(int x,int y) {
    e[++cnt].v=y,e[cnt].nxt=head[x],head[x]=cnt;
}
void tarjan(int x,int fa) {
    dfn[x]=low[x]=++num;
    for (int i=head[x]; i; i=e[i].nxt) {
        int y=e[i].v;
        if (!dfn[y]) {
            tarjan(y,i);
            low[x]=min(low[x],low[y]);
            if (low[y]>dfn[x]) {
                qiao[i]=qiao[i^1]=1;
            }
        } else if(i!=(fa^1)) {
            low[x]=min(low[x],dfn[y]);
        }
    }
}

int main() {
    cin>>n>>m;
    cnt=1;
    for (int i=1,x,y; i<=m; i++) {
        cin>>x>>y;
        add(x,y),add(y,x);
    }
    for (int i=1; i<=n; i++) {
        if (!dfn[i]) {
            tarjan(i,0);
        }
    }
    for (int i=2; i<cnt; i+=2) {
        if (qiao[i]) {
            cout<<e[i^1].v<<" "<<e[i].v<<endl;
        }
    }
    return 0;
}

/*
6 7
1 2
1 3
2 3
2 4
4 5
4 6
5 6
*/

下面是割点

 1 #include <cstdio>
 2 #include <iostream>
 3 #include <bits/stdc++.h>
 4 using namespace std;
 5 typedef long long ll;
 6 typedef unsigned long long ull;
 7
 8 #define ls (t<<1)
 9 #define rs ((t<<1)|1)
10 #define mid ((l+r)>>1)
11
12 #define mk make_pair
13 #define pb push_back
14 #define fi first
15 #define se second
16
17 #define MAXN 100001
18 struct edge {
19     int v,nxt;
20 } e[MAXN*2];
21 int head[MAXN];
22 bool cut[MAXN];
23 int dfn[MAXN],low[MAXN];
24 int n,m,cnt,num,root;
25 void add(int x,int y) {
26     e[++cnt].v=y,e[cnt].nxt=head[x],head[x]=cnt;
27 }
28 void tarjan(int x) {
29     dfn[x]=low[x]=++num;
30     int flag=0;
31     for (int i=head[x]; i; i=e[i].nxt) {
32         int y=e[i].v;
33         if (!dfn[y]) {
34             tarjan(y);
35             low[x]=min(low[x],low[y]);
36             if (low[y]>=dfn[x]) {
37                 flag++;
38                 if (x!=root||flag>1) {
39                     cut[x]=1;
40                 }
41             }
42         }
43         else low[x]=min(low[x],dfn[y]);
44     }
45 }
46
47 int main() {
48     cin>>n>>m;
49     cnt=1;
50     for (int i=1,x,y; i<=m; i++) {
51         cin>>x>>y;
52         if (x==y) continue;
53         add(x,y),add(y,x);
54     }
55     for (int i=1; i<=n; i++) {
56         if (!dfn[i]) {
57             root=i;
58             tarjan(i);
59         }
60     }
61     for (int i=1; i<=n; i++) {
62         if (cut[i]) {
63             cout<<i<<" ";
64         }
65     }
66     cout<<"是个割点"<<endl;
67     return 0;
68 }
69
70 /*
71 6 6
72 1 2
73 1 3
74 2 3
75 2 4
76 2 5
77 4 5
78 */

原文地址:https://www.cnblogs.com/codemaker-li/p/9800832.html

时间: 2024-10-10 10:40:07

tarjan,割边,桥,割点的相关文章

Tarjan 割边(桥)

//Tarjan 割边 //当dfn[u]<low[v]时u与v之间的边为割边 #include<iostream> #include<cstdio> #include<cstring> #include<cstdlib> #include<cmath> #include<algorithm> using namespace std; int n,m,cnt,ans,head[10001]; int dot,dfn[10001]

Tarjan的学习笔记 求割边求割点

博主图论比较弱,搜了模版也不会用... 所以决心学习以下tarjan算法. 割点和割边的概念不在赘述,tarjan能在线性时间复杂度内求出割边. 重要的概念:时间戟,就是一个全局变量clock记录访问结点的时间.一个无向图dfs会形成一个森林,当图只有一个连通分量时,就只有一棵树. 由于在无向图中,除了树边,其他都是反向边.可以画个图感受一下,可以反证的,如果有其他类型的边,那么dfs先沿着那些边跑图的,那么那些边就不存在. 如果结点是树根,那么它是割点的充要条件就是它有两个子结点. 定理 对于

(转)Tarjan应用:求割点/桥/缩点/强连通分量/双连通分量/LCA(最近公共祖先)

本文转载自:http://hi.baidu.com/lydrainbowcat/item/f8a5ac223e092b52c28d591c 作者提示:在阅读本文之前,请确保您已经理解并掌握了基本的Tarjan算法,不会的请到http://hi.baidu.com/lydrainbowcat/blog/item/42a6862489c98820c89559f3.html阅读.   基本概念:   1.割点:若删掉某点后,原连通图分裂为多个子图,则称该点为割点. 2.割点集合:在一个无向连通图中,如

Tarjan应用:求割点/桥/缩点/强连通分量/双连通分量/LCA(最近公共祖先)【转】【修改】

基本概念: 1.割点:若删掉某点后,原连通图分裂为多个子图,则称该点为割点. 2.割点集合:在一个无向连通图中,如果有一个顶点集合,删除这个顶点集合,以及这个集合中所有顶点相关联的边以后,原图变成多个连通块,就称这个点集为割点集合. 3.点连通度:最小割点集合中的顶点数. 4.割边(桥):删掉它之后,图必然会分裂为两个或两个以上的子图. 5.割边集合:如果有一个边集合,删除这个边集合以后,原图变成多个连通块,就称这个点集为割边集合. 6.边连通度:一个图的边连通度的定义为,最小割边集合中的边数.

Tarjan求桥和割点

//Tarjan 求桥和割点 Tarjan(u,fa) { DFN[u]=LoW[u]=++time; Cu=grey; for each e=(u,v) { Tarjan(v,u); if(Cv=white) { low[u]=min(low[u],low[v]); }else { low[u]=min(low[u],DFN[v]); } } }

hihoCoder 1183 连通性一&#183;割边与割点(Tarjan求割点与割边)

#1183 : 连通性一·割边与割点 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 还记得上次小Hi和小Ho学校被黑客攻击的事情么,那一次攻击最后造成了学校网络数据的丢失.为了避免再次出现这样的情况,学校决定对校园网络进行重新设计. 学校现在一共拥有N台服务器(编号1..N)以及M条连接,保证了任意两台服务器之间都能够通过连接直接或者间接的数据通讯. 当发生黑客攻击时,学校会立刻切断网络中的一条连接或是立刻关闭一台服务器,使得整个网络被隔离成两个独立的部分. 举个

tarjan算法(强连通分量 + 强连通分量缩点 + 桥 + 割点 + LCA)

这篇文章是从网络上总结各方经验 以及 自己找的一些例题的算法模板,主要是用于自己的日后的模板总结以后防失忆常看看的, 写的也是自己能看懂即可. tarjan算法的功能很强大, 可以用来求解强连通分量,缩点,桥,割点,LCA等,日后写到相应的模板题我就会放上来. 1.强连通分量(分量中是任意两点间都可以互相到达) 按照深度优先遍历的方式遍历这张图. 遍历当前节点所出的所有边.在遍历过程中: ( 1 ) 如果当前边的终点还没有访问过,访问. 回溯回来之后比较当前节点的low值和终点的low值.将较小

hihoCoder_#1183_连通性一&#183;割边与割点

#1183 : 连通性一·割边与割点 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 还记得上次小Hi和小Ho学校被黑客攻击的事情么,那一次攻击最后造成了学校网络数据的丢失.为了避免再次出现这样的情况,学校决定对校园网络进行重新设计. 学校现在一共拥有N台服务器(编号1..N)以及M条连接,保证了任意两台服务器之间都能够通过连接直接或者间接的数据通讯. 当发生黑客攻击时,学校会立刻切断网络中的一条连接或是立刻关闭一台服务器,使得整个网络被隔离成两个独立的部分. 举个

HDU 4738 Caocao&#39;s Bridges tarjan求桥

Caocao's Bridges Problem Description Caocao was defeated by Zhuge Liang and Zhou Yu in the battle of Chibi. But he wouldn't give up. Caocao's army still was not good at water battles, so he came up with another idea. He built many islands in the Chan