OI模板 Tarjan与连通性

$\text{Tarjan}$ 与连通性

补充（很重要）：

关于tarjan的一些大问题：

tarjan中low数组的一个问题：

if(!dfn[v]){
   tarjan(v);
   low[u] = min(low[u], low[v]);
} else low[u] = min(low[u], dfn[v]);

这里如果v是u的父亲，那么low[u]就能被dfn[v]更新。

如果求强连通分量和割点没什么问题，但在求割边的时候就有问题。

割边的判断法则是 low[v]>dfn[fa v]，但如果v能被fa v更新时，则low[v]至少=dfn[fa v]，就会出错。

所以在tarjan时要不要加上v==fa?continue这种话？

答：使用网络瘤存边用的成对变换，在边上打标记不去走。（thanks @z_z_y）

$\text{DFS}$ 生成树

有向图的 $\text{DFS}$ 生成树有 $2$ 类边：

• 树边：每次搜索找到一个没有访问过的节点就形成一条树边
• 非树边：分为返祖边、横叉边、前向边，差别为边连接的两个节点是否有祖孙关系。

$\text{Tarjan}$

在 $\text{Tarjan}$ 算法中维护了以下两个数组：

• $df{n}_u$：$\text{DFS}$ 时节点 $u$ 被遍历的顺序。
• $lo{w}_u$：$u$ 能够回溯到的最早的已经在栈中的节点。计算方法： l o w u = min ⁡ ( min ⁡ v ∈ S u b t r e e u { l o w v } , min ⁡ t ∈ S u b t r e e u , 有 边 ( t , v ) { l o w v } ) low_u=\min(\min\limits_{v\in Subtree_u}\{low_v\},\min\limits_{t\in Subtree_u,有边(t,v)}\{low_v\}) lowu​=min(v∈Subtreeu​min​{lowv​},t∈Subtreeu​,有边(t,v)min​{lowv​})。

按照 $\text{DFS}$ 序搜索，对于搜索到的一条边 $(u,v)$ 有：

• $v$ 未被访问，对 $v$ 进行 $\text{DFS}$，回溯时用 $lo{w}_v$ 更新 $lo{w}_u$。
• $v$ 被访问过，在栈中：用 $df{n}_v$ 更新 $lo{w}_u$。
• $v$ 被访问过，不在栈中：$v$ 已经搜索完毕，不用管。

框架

以下为 $\text{Tarjan}$ 算法框架，针对不同的问题会添加不同语句。

const int N = 1e6 + 10;
int dfn[N], low[N], dfncnt, st[N], in_st[N], top;
vector<int> G[N];

void tarjan(int u){
    dfn[u] = low[u] = ++ dfncnt;
    st[++top] = u, in_st[u] = 1;
    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(in_st[v]) {
            low[u] = min(low[u], dfn[v]);
        } 
    }
}

//code in main():
for(int i = 1; i <= n; ++ i) if(!dfn[i]) tarjan(i);

常见模型

强连通分量

有向图 $G$ 强连通：$G$ 中任意两个节点连通。

强连通分量（$\text{Strongly Connected Components,SCC}）$：极大的强连通子图。

对于一个强连通图，有且只有一个 $u$ 使得 $df{n}_u=lo{w}_u$，即该强连通分量中第一个被遍历到的点。

因此，在回溯过程中，判断 $df{n}_u=lo{w}_u$ 是否成立，若成立则栈中 $u$ 及其上方节点为一个 $SCC$。时间复杂度 $O(n+m)$。

const int N = 1e6 + 10;
int dfn[N], low[N], dfncnt, st[N], in_st[N], top;
int scc[N], scc_sz[N], scc_cnt;
vector<int> G[N];

void tarjan(int u){
    dfn[u] = low[u] = ++ dfncnt;
    st[++top] = u, in_st[u] = 1;
    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(in_st[v]) {
            low[u] = min(low[u], dfn[v]);
        } 
    }
    if(dfn[u] == low[u]){
        ++ scc_cnt;
        while(st[top] != u){
            scc[st[top]] = scc_cnt, ++ scc_sz[st[top]];
            in_st[st[top]] = 0, -- top;
        }
        scc[st[top]] = scc_cnt, ++ scc_sz[st[top]];
        in_st[st[top]] = 0, -- top;
    }
}

例题：Luogu P2341 [USACO03FALL][HAOI2006]受欢迎的牛 G

给一张有向图，求图中所有满足 $\prod _{i=1,i\ne u}^n[存在一条从i到u的路径]=1$ 的节点个数。

$1\le n\le 10^4,1\le m\le 5\ast 10^4$。

答案为该图中唯一一个出度为 $0$ 的强连通分量的节点数。

强连通分量-缩点

将一个强连通分量缩成一个点进行计算。

注意：连接二点强连通分量时需注意此两点是否在同一强连通分量！

for(int i = 1; i <= n; ++ i)
    for(int j = 0; j < G[i].size(); ++ j)
        if(scc[G[i][j]] != scc[i])//
        ++ ind[scc[G[i][j]]], ++ oud[scc[i]];

例题：Luogu P3387 【模板】缩点

给一张点带权有向图，求一条路径，使得路径经过的点权值和最大（重复经过的点只算一次）。

$1\le n\le 10^4,1\le m\le 10^5$。

把这张图的所有强连通分量进行缩点，形成一张 $DAG$，每个节点的点权为对应强连通分量所有点点权和。之后在这张 $DAG$ 上跑最长路即可。

例题：Luogu P2812 校园网络【[USACO]Network of Schools加强版】

给一张有向图，求两个问题：

1. 至少选几个点开始搜索能使整个图都能被遍历到；
2. 至少加几条边才能是整个图变成强连通图。

$1\le n\le 10^4,1\le m\le 5\ast 10^6$。

对于问题1，求出缩点后入度为 $0$ 的节点数；对于问题2，求出缩点后入度为 $0$ 的节点数和出度为 $0$ 的节点数的最小值。

注意：如果整个图已经是一个强连通图，则问题2特判为 $0$。

$\text{2-SAT}$ 问题

有 $n$ 个变量 $a_{1,2,...,n}$，每个变量都是 $\text{bool}$ 类型，现有 $m$ 个要求，每个要求形如：若 $a_i$ 为 $p$，则 $a_j$ 一定为 $q$（ p , q ∈ { 0 , 1 } p,q\in\{0,1\} p,q∈{0,1}）。

把每个变量拆成两个点 $a_{i,true},a_{i,false}$。对于每个要求，连接 $a_{i,p}->a_{j,q},a_{j,p}->a_{i,q}$，即若 $a_i=p$ 则 $a_j=q$。此时对最终的图进行强连通分量缩点。每一个强连通分量中的点值都是一样的。

若 $a_{i,true},a_{i,false}$ 在同一强连通分量中，则无解。否则 $a_i$ 值取深度大的那个（若用 $\text{Tarjan}$ 求强连通分量，则是强连通分量编号小的那一个）。

for(int i = 1; i <= n*2; ++ i) if(!dfn[i]) tarjan(i);
for(int i = 1; i <= n; ++ i){
    if(scc[i] == scc[i+n]){
		puts("IMPOSSIBLE");
		return 0;
	}
}
puts("POSSIBLE");
for(int i = 1; i <= n; ++ i){
	printf("%d ", scc[i] < scc[i+n]);
}

割点 / 割顶

对于一个无向图，如果把一个点删除后这个图的极大连通分量数增加了，那么这个点就是这个图的割点（又称割顶）。

判定方法：

• 若 $u$ 不是搜索树的根节点，则 $u$ 是割点当且仅当存在一个 $u$ 的子节点 $v$ 使得 $df{n}_u\le lo{w}_v$。
• 若 $u$ 是搜索树的根节点，则 $u$ 是割点需存在两个 $u$ 的子节点 $v_1,v_2$ 满足 $df{n}_u\le lo{w}_{v_1},lo{w}_{v_2}$。

这时候可能有个问题：若 $u$ 是搜索树的根节点，那么 $df{n}_u=1$，$u$ 所有的子节点都满足上述条件！所以只要有 $2$ 个或以上儿子的根节点就一定是割点吗？肯定不是的，因为这里的儿子节点指搜索树上该节点的儿子，而非原图上的儿子。

const int N = 1e6 + 10;
int dfn[N], low[N], dfncnt, root;
vector<int> G[N];
bool iscut[N];

void tarjan(int u){
    dfn[u] = low[u] = ++ dfncnt;
    for(int flg = 0, i = 0; i < G[u].size(); ++ i){
        int v = G[u][i];
        if(!dfn[v]){
            tarjan(v), low[u] = min(low[u], low[v]);
            if(low[v] >= dfn[u]){
                ++ flg;
                if(u != root || flg > 1) iscut[u] = true;
            }
        } else low[u] = min(low[u], dfn[v]);
    }
}

//code in main():
for(int i = 1; i <= n; ++ i) if(!dfn[i]) root = i, tarjan(i);

割边 / 桥

对于一个无向图，如果把一条边删除后这个图的极大连通分量数增加了，那么这条边就是这个图的割边（又称桥）。

判定方法：

• 搜索树上存在一个 $u$ 和 $u$ 的子节点 $v$ 满足 $df{n}_u<lo{w}_v$，则 $(u,v)$ 为割边。

由于遍历的是无向图，所以从 $u$ 出发时一定能遍历到 $f{a}_u$。根据 $low$ 的计算方法，不能用 $df{n}_{f{a}_u}$ 更新 $lo{w}_u$；但是若 $(u,f{a}_u)$ 有重边，则可以通过其他的边使用 $df{n}_{f{a}_u}$ 更新 $lo{w}_u$（其他的边不在搜索树上）。此时不能使用记录 $fa$ 的方法。

一个好的解决方法：将无向图的每一条边看做双向边记录在链式前向星的 $2k,2k+1$ 位置，并在递归时记录“递归进入每一个节点的边的编号”（链式前向星中存储的下标位置）。若沿着编号为 $i$ 的边进入节点 $u$，则忽略从 $u$ 出发的编号为 $i\text{ xor }1$ 的边。

边双连通分量

概念：

边双连通图：不存在割边的无向图。

边双连通分量（$\text{e-DCC}$）：一个无向图的极大边双连通子图。

求法：

求出无向图中所有桥，把桥都删除后图分成若干连通块，每个连通块是一个 $\text{e-DCC}$。

边双连通分量缩点后形成森林。

点双连通分量

概念：

点双连通图：不存在割点的无向图

点双连通分量（$\text{v-DCC}$）：一个无向图的极大点双连通子图。

定理：

一张无向图是“点双连通图”，当且仅当满足一下两个条件其一：

1. 图中顶点数 $\le 2$；
2. 图中任意两点都同时包含在至少一个简单环中。

割边不属于任何 $\text{e-DCC}$，割点可能属于多个 $\text{v-DCC}$。

求法：

在 $\text{Tarjan}$ 进行过程中维护一个栈：

• 当一个节点第一次被访问时入栈。
• 当割点判定法则 $df{n}_u\le lo{w}_v$ 成立时，无论 $u$ 是否为根，执行：从栈顶不断弹出节点，直至 $v$ 被弹出。此时所有弹出的节点与 $u$ 一起构成一个 $\text{v-DCC}$。

const int N = 1e6 + 10;
int dfn[N], low[N], dfncnt, st[N], top, root;
vector<int> v_DCC[N]; int cnt;
vector<int> G[N];

void tarjan(int u){
    dfn[u] = low[u] = ++ dfncnt;
    st[++top] = u;
    if(u == root && G[u].size() == 0){
        v_DCC[++cnt].push_back(u);
        return;
    }
    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]);
            if(low[v] >= dfn[u]){
                ++ cnt; int t;
                do { t = st[top--]; v_DCC[cnt].push_back(t);
                } while(t != v);
                v_DCC[cnt].push_back(u);
            }
        } else low[u] = min(low[u], dfn[v]);
    }
}

//code in main():
for(int i = 1; i <= n; ++ i) if(!dfn[i]) root = i, tarjan(i);

点双连通分量缩点：

设图中共有 $p$ 个割点和 $t$ 个 $\text{v-DCC}$，建立一张包含 $p+t$ 个节点的新图，把每个 $v-DCC$ 和每个割点都作为新图中的节点，并在每个割点与包含它的所有 $\text{v-DCC} 连边，形成森林。