边双连通分量

定义

在一张联通的无向图中，对于任意两点 \(u\) 和 \(v\)​，删去两点之间任意一条边，都无法使其不连通（即连通数不变），我们就说这两点是边双连通。

对于一个无向图中的 极大 边双连通的子图，我们称这个子图为一个 边双连通分量。

根据 【笔记 / 模板】割点和桥 中可知，如果一张图是一个边双连通分量，那么这张图中必然不存在桥（割边），我们可以使用 Tarjan 求解割边的方法得到一张图的所有边双连通分量。

解法一

先用 Tarjan 预处理出图中所有的桥，再用 DFS 跑一边即可。

int id[N], dcc_cnt;
vector<vector<int>> vec;

void tarjan(int ver, int edge)
{
    dfn[ver] = low[ver] = ++ timestamp;
    for (int i = h[ver]; ~i; i = ne[i])
    {
        int to = e[i];
        if (i == (edge ^ 1)) continue;
        if (!dfn[to])
        {
            tarjan(to, i);
            low[ver] = min(low[ver], low[to]);
            if (low[to] > dfn[ver])
                bridge[i] = bridge[i ^ 1] = true;
        }
        else low[ver] = min(low[ver], dfn[to]);
    }
}

void dfs(int ver, int dcc_cnt)
{
    id[ver] = dcc_cnt, vec.back().push_back(ver);
    for (int i = h[ver]; ~i; i = ne[i])
    {
        int to = e[i];
        if (id[to] || bridge[i]) continue;
        dfs(to, dcc_cnt);
    }
}

解法二

因为无向图的特性，如果一个分量中的所有点的 low 值一样，那么说明它们都可以最早回溯到同一个点，这也是说明了它们属于同 DFS 生成树上的同一个强连通分量，等价于无向图上的同一个边双连通分量。

此时，\(dfn\) 值最小的一个点，就属于在这个连通分量上的根。我们采取类似强连通分量的方法将遍历的点依次加入栈中，最后弹出即可。

而由于无向图的特性，不会存在横叉边，代码更加简单。

void tarjan(int ver, int edge)
{
	dfn[ver] = low[ver] = ++ timestamp;
	stk[++ top] = ver;
	for (int i = h[ver]; ~i; i = ne[i])
	{
		if (i == (edge ^ 1)) continue;
		int to = e[i];
		if (!dfn[to])
		{
			tarjan(to, i);
			low[ver] = min(low[ver], low[to]);
		}
		else low[ver] = min(low[ver], dfn[to]);
	}
	
	if (low[ver] == dfn[ver])
	{
		int temp = 0;
		dcc_cnt ++, vec.push_back(vector<int>());
		do { 
			temp = stk[top --];
			vec.back().push_back(temp);
		} while (temp != ver);
	}
}

点双连通分量

定义

在一张联通的无向图中，对于任意两点 \(u\) 和 \(v\)，删去任意其中一点都无法使其不连通（即连通数不变），我们就说这两点是点双连通。

对于一个无向图中的 极大 点双连通的子图，我们称这个子图为一个 点双连通分量。

解法过程

与边双连通分量不同的是，一个点可能在多个不同的点双联同分量之中出现，而根据定义可知，这个点一定是割点（或者树根）。

• 如果是割点，那么它一定是点双连通分量的根。
• 如果为树根，并且有大于一个子树时，它是割点；否则就是一个点双的根（孤立点自身也可看作点双）。

采取类似求割点的方法，同时特判孤立点。

void tarjan(int ver, int root)
{
    dfn[ver] = low[ver] = ++ timestamp;
    stk[++ top] = ver;

    if (ver == root && h[ver] == -1)	// 特判孤立点
    {
        ++ dcc_cnt;
        vec.push_back(vector<int>());
        vec.back().push_back(ver);
    }

    for (int i = h[ver]; ~i; i = ne[i])
    {
        int to = e[i];
        if (!dfn[to])
        {
            tarjan(to, root);
            low[ver] = min(low[ver], low[to]);
            if (low[to] >= dfn[ver]) 
            {
                ++ dcc_cnt, vec.push_back(vector<int>());
                int temp = 0;
                do {
                    temp = stk[top --];
                    vec.back().push_back(temp);
                } while (temp != to);
                vec.back().push_back(ver);
            }
        }
        else low[ver] = min(low[ver], dfn[to]);
    }
}