割点 割边 连通分量 [模板]

无向图

割点(割顶,关节点)求点双联通分量

• 割点：对于无向图$G$，如果删除某个点$u$之后，连通分量数量增加(使图不再联通)，那么$u$就是割点。
• 点双联通图：对于一个联通无向图$G$，如果任意两条边都在一个简单环中(包括两个点的环)，即内部无割点，即任意两点至少存在两条“点不重复”的路径，那么$G$就是点双联通图。
• 点双联通分量：对于一个联通无向图$G$，点双联通的极大子图为点双联通分量，不同点联通分量会有公共点，且公共点一定是割顶。

如上图有下列点联通分量

• 割点判定：非根结点$u$，如果$u$存在一个儿子$v$，$v$满足它的后代都没有反向边连回$u$ 的祖先，那么$u$就是割点。即：$low(v)>=dfn(u)$ $low(v):v$和$v$的后代能连回的最小的结点的$dfn$
• 那么利用割点的判定性质，在$dfs$过程中，记录一下$low$，回溯到某个$v$时判断$u$是否为割点，用栈记录$v$的儿子节点，即可以取出联通分量。

点双code

如果需要记录边的话，栈里的存边，并把反边也入栈

/*   Author : Rshs
 *   Data : 2019-10-02-14.51
 */
#include<bits/stdc++.h>
using namespace std;
#define FI first
#define SE second
#define LL long long
#define MP make_pair
#define PII pair<int,int>
#define SZ(a) (int)a.size()
const double pai = acos(-1);
const double eps = 1e-10;
const LL mod = 1e9+7;
const int MXN = 1e6+5;
vector<int>g[MXN],bcc[MXN]; 
/*                点双分量         */
int dfn[MXN],iscut[MXN],dfs_clock,bcc_cnt;
/*先序序号   割点否     时间戳    点双数量*/
stack<int>sk;
/* 暂存儿子*/
int tarjan(int u,int fa){
    int lowu=dfn[u]=++dfs_clock;
    int child=0;//记录u的儿子数
    for(auto v:g[u]){
        if(!dfn[v]){
            sk.push(v);//搜索到就入栈
            child++;
            int lowv=tarjan(v,u);
            lowu=min(lowu,lowv);
            if(lowv>=dfn[u]){ //u是割点，u及v为根的子树是点双
                bcc_cnt++;
                iscut[u]=1;
                while(sk.top()!=v) bcc[bcc_cnt].push_back(sk.top()),sk.pop();
                bcc[bcc_cnt].push_back(sk.top()),sk.pop();
                bcc[bcc_cnt].push_back(u);

            }
        }
        else if(v!=fa&&dfn[v]<dfn[u]){//保证反向边，保证每条边只访问一次
            lowu=min(lowu,dfn[v]);  //连到了u的祖先(反向边
        }
    }
    if(fa<0&&child==1) iscut[u]=0; //处理根结点
    return lowu;
}
void bccGet(int n){
    for(int i=1;i<=n;i++)bcc[i].clear(),dfn[i]=iscut[i]=0;
    while(!sk.empty())sk.pop();
    for(int i=1;i<=n;i++) if(!dfn[i])tarjan(i,-1);
}
int main(){
    int n,m;cin>>n>>m;
    for(int i=1;i<=m;i++){
        int sa,sb;scanf("%d %d",&sa,&sb);
        g[sa].push_back(sb);g[sb].push_back(sa);
    }
    bccGet(n);
    cout<<bcc_cnt<<endl; 
    for(int i=1;i<=bcc_cnt;i++) {
        for(auto j:bcc[i])cout<<j<<' ';
        puts("");
    }
    vector<int>cut;
    for(int i=1;i<=n;i++)if(iscut[i])cut.push_back(i);
    cout<<cut.size()<<endl;
    for(auto i:cut)cout<<i<<' ';
    return 0;
}

割边(桥)求边双联通分量

• 桥：对于无向图$G$，如果删除某个边$e$之后，连通分量数量增加(使图不再联通)，那么$e$就是桥。
• 边双联通图：对于一个联通无向图$G$，只需要每条边都在任意一个简单环中，即无内部割边，即任意两点至少存在两条“边不重复”的路径，那么$G$就是边双联通图。
• 边双联通分量：对于一个联通无向图$G$，边双联通的极大子图为边双联通分量，除了桥以外每一条边都属于确切的一个边联通分量，即删掉桥后，每个联通分量对应原图的一个边双联通分量。

如上图有下列边联通分量

• 割点判定：非根结点$u$，如果$u$存在一个儿子$v$，$v$满足它的后代都没有反向边连回$u$ 的祖先或u，那么$u->v$就是桥。即：$low(v)>dfn(u)$ $low(v):v$和$v$的后代能连回的最小的结点的$dfn$
• 那么利用割点的判定性质，在$dfs$过程中，记录一下$low$，回溯到某个$v$时判断$u$是否为桥，最后把桥删掉，再染一遍色，就可以得到边双联通分量。

边双code

/*   Author : Rshs
 *   Data : 2019-10-02-14.51
 */
#include<bits/stdc++.h>
using namespace std;
#define FI first
#define SE second
#define LL long long
#define MP make_pair
#define PII pair<int,int>
#define SZ(a) (int)a.size()
const double pai = acos(-1);
const double eps = 1e-10;
const LL mod = 1e9+7;
const int MXN = 1e6+5;
struct no{
    int to,num;
};
vector<no>g[MXN];
vector<int>G[MXN];
int sa[MXN],sb[MXN];
int col[MXN]; //染色
int dfn[MXN],isbridge[MXN],dfs_clock,ebc_cnt;
/*先序序号   桥否[0,2*m-1]  时间戳   边双数量*/

int tarjan(int u,int fa){
    int lowu=dfn[u]=++dfs_clock;
    for(auto ii:g[u]){
        int v=ii.to,num=ii.num;
        if(!dfn[v]){
            int lowv=tarjan(v,u);
            lowu=min(lowu,lowv);
            if(lowv>dfn[u]){ //u->v是割边
                isbridge[num]=isbridge[num^1]=1;
            }
        }
        else if(v!=fa&&dfn[v]<dfn[u]){//保证反向边，保证每条边只访问一次
            lowu=min(lowu,dfn[v]);  //连到了u的祖先(反向边
        }
    }
    return lowu;
}

void colourDfs(int now,int colNum){
    col[now]=colNum;
    for(auto i:G[now]) {
        if(!col[i]) colourDfs(i,colNum);
    }
}

void ebcGet(int n,int m){
    for(int i=1;i<=n;i++) dfn[i]=col[i]=0;
    for(int i=0;i<=2*m;i++) isbridge[i]=0;
    for(int i=1;i<=n;i++) if(!dfn[i])tarjan(i,-1);
    for(int i=1;i<=m;i++){
        if(!isbridge[i*2-1]) {
            G[sa[i]].push_back(sb[i]);
            G[sb[i]].push_back(sa[i]);
        }
    }
    int colNum=1;
    for(int i=1;i<=n;i++) if(!col[i]) colourDfs(i,colNum++);
}
int main(){
    int n,m;cin>>n>>m;
    for(int i=1;i<=m;i++){
        scanf("%d %d",&sa[i],&sb[i]);
        g[sa[i]].push_back(no{sb[i],i*2-2});
        g[sb[i]].push_back(no{sa[i],i*2-1});
    }
    ebcGet(n,m);
    for(int i=1;i<=n;i++)cout<<col[i]<<' ';
    return 0;
}
/*
9 11
1 2 2 3 1 3 2 4 4 3
4 5
5 6 5 7 6 7
7 8 8 9
*/

有向图

联通分量 uoj 146

#include<iostream>
#include<cstring>
#include<algorithm>
#include<stack>
#include<vector>
#include<climits>
#include<cstdlib>
#include<queue>
using namespace std;
#define LL long long
const int max_n=200005;
 
vector<int>g[max_n];//原图
int dfn[max_n];//时间戳
int low[max_n];//同环指向前面的时间戳
int inst[max_n];//是否在栈
int tot;//顶点数
int color[max_n];  //染色
int col_num;    //连通数量
stack<int>s;
 
int ou[max_n];
 
void tarjan(int x){
    low[x]=dfn[x]=++tot;
    s.push(x);inst[x]=1;
    for(int i=0;i<(int)g[x].size();i++){
        int v=g[x][i];
        if(!dfn[v]){   //延展
            tarjan(v);
            low[x]=min(low[x],low[v]);
        }
        else if(inst[v]){ //在栈，更新
            low[x]=min(low[x],dfn[v]);
        }
    }
    if(low[x]==dfn[x]){  //x是连通分量里最小的low
        int now;
        ++col_num ;//染色
        do{         //清空
            now=s.top();s.pop();
            color[now]=col_num ;
            inst[now]=0 ;
        }while(x!=now);
    }
}
 
int main(){
    ios::sync_with_stdio(false);  cin.tie(0);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        int b;cin>>b;
        g[i].push_back(b);
    }
    for(int i=1;i<=n;i++) {
        if(!dfn[i])
            tarjan(i);
    }
    int ans=INT_MAX;
    sort(color+1,color+1+n);
    int x=1;
    for(int i=2;i<=n;i++){
        if(color[i]==color[i-1]) x++;
        else{if(x>1)ans=min(ans,x);x=1;}
    }
    if(x>1) ans=min(ans,x);
    cout<<ans;
    return 0;
}