强连通分量(Tarjan算法)和缩点

一些定义

给定一张有向图，对于图中任意两个节点 xxx 和 yyy ，存在从 xxx 到 yyy 的路径，也存在从 yyy 到 xxx 的路径，则称该有向图为强连通图。

有向图的强连通子图被称为强连通分量SCC

显然，环一定是强连通图。因为如果在有向图中存在 xxx 到 yyy 的路径，且存在 yyy 到 xxx 的路径，那么 x,yx,yx,y 一定在同一个环中。

对于一个有向图，如果从 rootrootroot 可以到达图中所有的点，则称其为“流图”，而 rootrootroot 为流图的源点。

以 rootrootroot 为原点对流图深度优先遍历，每个点只访问一次，在过程中，所有发生递归的边 (x,y)(x, y)(x,y) 构成的一棵树叫做这个流图的搜索树。

在深度优先遍历时，对每个访问到的节点分别进行整数 1...n1...n1...n 标记，该标记被称为时间戳，记为 dfn[x]dfn[x]dfn[x] 。

流图中的每条有向边 (x,y)(x, y)(x,y) 必然是以下四种中的一种：

前向边，指搜索树中 xxx 是 yyy 的祖先节点
后向边，指搜索树中 yyy 是 xxx 的祖先节点
树枝边，指搜索树里的边，满足 xxx 是 yyy 的父节点。
其他边（好像也叫横叉边），指除了上面三种情况的边。且一定满足 dfn[y]<dfn[x]dfn[y]<dfn[x]dfn[y]<dfn[x]

Tarjan算法之强连通分量

Tarjan 算法基于有向图的深度优先遍历，能够在线性时间中求出一张有向图的各个强连通分量。

其核心思想就是考虑两点之间是否存在路径可以实现往返。

我们在后文中，都会结合搜索树（本身就是深度优先遍历的产物）来考虑，这样就可以在深度优先遍历的同时完成我们的目标。

对于各种边的分析：

对于流图，前向边作用不大，因为当前搜索树中一定存在 xxx 到 yyy 的路径。

后向边就很重要了，因为它一定可以和搜索树中 xxx 到 yyy 的路径组成环。

横叉边需要判断一下，如果这条横叉边能到达搜索树上 xxx 的祖先（显然，xxx 的祖先一定可以到达 xxx）。记这个祖先为 zzz，则这条横叉边一定能和它到 zzz 的路径，zzz 到 xxx 的路径组成环。

强连通分量的维护和栈的引入：

为了找到横叉边与后向边组成的环，我们考虑在深度优先遍历的同时维护一个栈。

当遍历到 iii 节点时，栈里一定有以下一些点：

搜索树上 iii 的所有祖先集合 jjj。若此时存在后向边 (i,j)(i, j)(i,j)，则 (i,j)(i, j)(i,j) 一定与 jjj 到 iii 的路径形成环。(后向边组成的环)
已经访问过的点 kkk，且满足从 kkk 出发一定能找到到 jjj 的路径。此时，iii 到 kkk 的路径，kkk 到 jjj 的路径，jjj 到 iii 的路径一定会形成环。（横叉边和后向边组成的环）

于是我们引入回溯值的概念。回溯值 low[x]low[x]low[x] 表示以下节点的最小时间戳：

该点在栈中。
存在一条从流图的搜索树中以 xxx 为根的子树为起点出发的有向边，以该点为终点。（也就是以它为起点能继续往下遍历到的点）

如果当前的 low[x]low[x]low[x] 表示的最小时间戳代表的点集全是2类点，则易得 low[x]=dfn[x]low[x]=dfn[x]low[x]=dfn[x] 时强连通分量存在，且 xxx 是此强连通分量的根（整个强连通分量中时间戳最小的节点）。

如果表示的点集存在1类点。则当前点一定属于强连通分量，且该强连通分量的根为整个强连通分量中时间戳最小的节点。

当我们判断了存在以当前点为根的强连通分量后，从栈中不断取出点，直到取出的点与当前点相等，我们就得到了整个强连通分量的信息。

整理更新回溯值的方法：

如果当前点第一次被访问，入栈，且low[x]=dfn[x]low[x]=dfn[x]low[x]=dfn[x] 。

遍历从xxx为起点的每一条边 (x,y)(x,y)(x,y) 。若 yyy 被访问过，且 yyy 在栈中，那么 low[x]=min(low[x],dfn[y])low[x]=min(low[x],dfn[y])low[x]=min(low[x],dfn[y])。若y没被访问过，先递归访问y，在回溯之后更新 low[x]=min(low[x],low[y])low[x]=min(low[x],low[y])low[x]=min(low[x],low[y]) 。

具体实现：

1 邻接矩阵建图

#include<bits/stdc++.h>
using namespace std;
#define MAXN 200005
#define X 114514
int n;//一共有n个点
//强连通分量相关定义int dfn[MAXN],low[MAXN];//时间戳以及回溯值（最小时间戳）
struct node
{int mx;//集团中点权的最大值int sum;//缩点后的边权和//其他信息根据具体题目具体设置
}sccc[MAXN];//储存最后求出的各个强连通分量的信息
int key[MAXN];//key[i]表示i在编号为key[i]的强连通分量中
int num=0;//时间戳
int scc=0;//强连通分量个数
stack <int> s;
int visit[MAXN];//记录是否在栈中//vector <int> original_mp[MAXN];//原始图void tarjan(int x)
{low[x]=dfn[x]=++num;s.push(x);visit[x]=1;for(auto y:original_mp[x])//遍历原始图{if(dfn[y]==0){tarjan(y);low[x]=min(low[x],low[y]);}else if(visit[y]==1){low[x]=min(low[x],dfn[y]);}}if(dfn[x]==low[x])//维护这个强连通分量{scc++;int now=-1;while(x!=now){now=s.top();s.pop();visit[now]=0;key[now]=scc;sccc[scc].mx=X;sccc[scc].sum=X;//...其他信息根据具体题目具体分析，这里只是举例维护的方法}}
}void init()
{scc=0;num=0;for(int i=1;i<=n;i++){key[i]=i;dfn[i]=0;low[i]=0;visit[i]=0;//sccc[i].clear(); 要不要清除，怎么清除，根据具体题目来}
}void solve()
{init();for(int i=1;i<=n;i++){if(dfn[i]==0)//如果当前点没被遍历过，跑一遍Tarjantarjan(i);}
}

2 邻接表建图

#include<bits/stdc++.h>
using namespace std;
#define MAXN 200005//点数
#define MAXM 500005//边数
#define X 114514
int n,m;//点和边的数量
//邻接表相关定义
struct Edge
{int to,next;
}edge[MAXM];
int head[MAXN],tot;
////强连通分量相关定义
int low[MAXN],dfn[MAXN],key[MAXN],visit[MAXN];
stack <int> s;
int scc=0;//强连通分量个数
int num=0;//时间戳个数
struct node
{int mx;//集团中点权的最大值int sum;//缩点后的边权和//其他信息根据具体题目具体设置
}sccc[MAXN];//储存最后求出的各个强连通分量的信息int siz[MAXN];//各个强连通分量包含点的个数，不一定需要
//void init()
{tot=0;for(int i=0;i<=m;i++) head[i]=-1;scc=0;num=0;for(int i=1;i<=n;i++){key[i]=i;dfn[i]=0;low[i]=0;visit[i]=0;//sccc[i].clear(); 要不要清除，怎么清除根据具体题目来}
}void tarjan(int x)
{low[x]=dfn[x]=++num;//更新时间戳s.push(x);visit[x]=1;//入栈for(int i=head[x];i!=-1;i=edge[i].next)//遍历原始图{int y=edge[i].to;if(dfn[y]==0){tarjan(y);low[x]=min(low[x],low[y]);}else if(visit[y]==1){low[x]=min(low[x],dfn[y]);}}if(low[x]==dfn[x])//维护当前强连通分量{scc++;int now=-1;while(now!=x){now=s.top();s.pop();visit[now]=0;//出栈标记//维护当前强连通分量内节点信息key[now]=scc;sccc[scc].mx=X;sccc[scc].sum=X;}}
}void solve()
{init();for(int i=1;i<=n;i++){if(dfn[i]==0)tarjan(i);}
}

缩点

缩点其实就是指的把环看成一个点来进行后面的图论算法。而把环看成的这个点的点权在题目中会具体说明。

比较常见的缩点后的点权是整个环路中所有点的点权和。

如下图：

1 -> 2 -> 4 -> 5 -> 2 -> 3

显然上图存在环路，在经过缩点后，我们可以将它变成这样：

1 -> 2(val[2]+val[4]+val[5]) -> 3

具体实现：

#include<bits/stdc++.h>
using namespace std;
#define MAXN 200005//点
int n;//点
int key[MAXN];//之前定义的，表示这个点位于哪个强连通分量
vector <int> original_mp[MAXN];//原图
vector <int> mp[MAXN];//缩点后的图void solve()
{for(int i=1;i<=n;i++){for(auto j:original_mp[i]){if(key[i]==key[j]) continue;//如果这条边的两端同属于一个强连通分量，放弃连边mp[key[i]].emplace_back(key[j]);//将两个点对应的强连通分量的编号相连，加入新图。//显然，单个点也属于一个强连通分量}}
}