无向图的割点，割边，点双连通，边双连通模板

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int maxm = 500010;
int num, p[maxn];
struct EDGE
{
    int u, v, next;
    bool cut;
    EDGE() {}
    EDGE(int u, int v, int next, bool cut): u(u), v(v), next(next), cut(cut) {}
} E[maxm];
void init()
{
    num = 0;
    memset(p, -1, sizeof(p));
}
void add(int u, int v)
{
    E[num] = EDGE(u, v, p[u], false);
    p[u] = num++;
}
stack<EDGE> S;
int dfn[maxn], low[maxn];
int index, bcc_cnt, bridge_cnt;
int bcc[maxn];///第i个点属于哪个点双连通
vector<int> Q[maxn];///Q[i]存第i个点双连通所有的点
vector<int> cnt[maxn];///cnt[i]存第i个点所属的点双连通
bool iscut[maxn];///是否为割点
int scc_cnt, Scc[maxn]; ///scc_cnt边双连通个数 Scc[i]表示第i个点属于哪个边双连通
void dfs(int u, int fa)
{
    dfn[u] = low[u] = ++index;
    int son = 0;
    for(int i = p[u]; ~i; i = E[i].next)
    {
        int v = E[i].v;
        if(!dfn[v])
        {
            son++;
            S.push(E[i]);
            dfs(v, u);
            low[u] = min(low[u], low[v]);
            if(low[v] > dfn[u]) ///桥
            {
                bridge_cnt++;
                E[i].cut = E[i ^ 1].cut = true;
            }
            if(low[v] >= dfn[u])
            {
                iscut[u] = true;
                bcc_cnt++;
                Q[bcc_cnt].clear();
                while(1)
                {
                    EDGE x = S.top();
                    S.pop();
                    if(bcc[x.u] != bcc_cnt) ///避免重复记录
                    {
                        Q[bcc_cnt].push_back(x.u);
                        bcc[x.u] = bcc_cnt;
                        cnt[x.u].push_back(bcc_cnt);
                    }
                    if(bcc[x.v] != bcc_cnt)
                    {
                        Q[bcc_cnt].push_back(x.v);
                        bcc[x.v] = bcc_cnt;
                        cnt[x.v].push_back(bcc_cnt);
                    }
                    if(x.u == u && x.v == v) break;
                }
            }
        }
        else if(dfn[v] < dfn[u] && v != fa)
        {
            S.push(E[i]);
            low[u] = min(low[u], dfn[v]);
        }
    }
    if(fa < 0 && son == 1) iscut[u] = false;
}
void solve(int u, int fa)
{
    Scc[u] = scc_cnt;
    for(int i = p[u]; ~i; i = E[i].next)
    {
        int v = E[i].v;
        if(v == fa || E[i].cut || Scc[v]) continue;
        solve(v, u);
    }
}
void Tarjan(int n)
{
    while(!S.empty()) S.pop();
    for(int i = 1; i <= n; i++)
    {
        dfn[i] = bcc[i] = Scc[i] = 0;
        iscut[i] = false;
        cnt[i].clear();
    }
    index = bcc_cnt = scc_cnt = bridge_cnt = 0;
    for(int i = 1; i <= n; i++)
        if(!dfn[i]) dfs(i, -1);
    ///接下来求边双连通
    for(int i = 1; i <= n; i++)
    {
        if(!Scc[i])
        {
            scc_cnt++;
            solve(i, -1);
        }
    }
}