tarjan打法博大精深,有向图强连通,无向图点双连通、边双连通、割点、割边~~学得寡人头大,今天整理整理,明天继续干 ~(*^*)~
有向图求强连通:
//强连通是对于有向图而言的,无需考虑某个边的重复访问
//单个点也是一个强连通分量,要根据题目的意思对结果进行特判
//dfs自上而下,而强连通的分离自下而上,故用栈这个数据结构来存储
int mystack[maxv], dfn[maxv], low[maxv], indx, top;
int belong[maxv], scc_cnt; //所属的强连通的编号
bool in_stack[maxv];
void tarjan(const int& q)
{
dfn[q] = low[q] = ++indx; //时间戳
mystack[++top] = q;
in_stack[q] = true;
for(int i = head[q]; i; i = e[i].next){
if(!dfn[e[i].to]){
tarjan(e[i].to);
low[q] = min(low[q], low[e[i].to]);
}else if(in_stack[e[i].to]){
low[q] = min(low[q], dfn[e[i].to]);
}else
continue;
}
int v = 0;
if(dfn[q] == low[q]){
scc_cnt += 1;
do{
v = mystack[top--];
in_stack[v] = false;
belong[v] = scc_cnt;
}while(q != v);
}
return;
}
接下来的操作都是对于无向图,由于无向图的双向性,以下的方法都要避免一条无向边的多次访问,标记点或是标记边。
无向图求割点:
- 标记点 因为重边对割点无影响
割点是对于无向图而言的,note that 重边对于割点的判断没有影响,故重边都看作一条边!
由于无向图的边双向,为了防止某条边的重复访问,引入一个root
root的作用:
1)root是第一个调用tarjan()函数的点的编号,此时root是dfs搜索树的根。对于根是否是割点--至少有两个子树的根是割点,所以对于根类型,我们要统计它的子树个数。有许多人都是直接统计子树最后再判断是否是根,我觉得那样逻辑不太清楚~也是因为这个他人的代码我理解了大半天~
2)在搜索过程中root用于标记当前访问点的上一个节点,所以在访问dfn[nv]!=0的点时,即之前访问过的点时,若root == nv说明这条边之前访问过,只是边是双向仍然可以通回,所以对于这个nv点就没必要进行访问。所以仅当(root != nv)我们才进行low[u] = min(low[u], dfn[nv])的判断。但这种因用法人而异,有的人不这么写,而是直接将每次root固定函数内递归时仍然为tarjan(nv, root),这样也没问题,因为root == u的情况只出现 在根节点,所以递归传入的"root"是root或是u问题不大,只是既然都写多了个参数还是好好利用利用吧~
割点的判断:
1)u是根节点:当u有>=2个子树时,u是割点
2)u不是根节点:当u存在下一个子节点nv无论如何最多只能回溯到u或者u的子节点时,也可以说是nv无法回溯到u的严格祖先时,u是割点
稍微解释下,nv要访问u的祖先们只能通过u,说明u为nv回溯的必经之点。注意这里已经考虑过重边的问题,同样建议纸上模拟模拟,理解更深哦~
*我们求的是割点,所以不需要栈什么之类的
尤其注意区分时间戳dfn【】,于最早回溯编号low【】
int dfn[mav], low[maxv], indx;
bool is_cut[maxv];
void tarjan_v(int u, int root){ //u root 相当于一条边的两端
dfn[u] = low[u] = ++indx;
int subtree = 0;
for(int i = head[u]; i; i = e[i].next)
{
int nv = e[i].to;
if(!dfn[nv])
{
tarjan(nv, u);
low[u] = min(low[u], low[nv]); //最小能够到达的节点
if(u != root && low[nv] >= dfn[u])//非根节点且其节点为根节点的子树中任意节点最多回溯到其本身,只要存在一个即可!
{ //注意是nv的最早能回溯到的编号low【】与u的时间戳dfn【】(dfs第一次遍历到的次序)相比较!
is_cut[u] = true;
}
if(u == root) //是根节点则统计子树
subtree +=1;
}else if(nv != root)
low[u] = min(low[u], dfn[nv]);
}
if(u == root && subtree >= 2)//是根节点,且有两个子树
is_cut[u] = true;
return;
}
无向图求边双连通
边双连通类似有向图的“强连通”:标记边 因为重边会影响边双连通的判断
- 某个极大子图中去掉任意一条边都不会改变此图的连通性,则该极大子图为边双连通分量。
- 若某极大子图为边双连通分量 <==> 该图上任意两点至少有两条所有边完全不同的路径相连(例如一个环上两点,既可以顺时针来,也可以逆时针来)
- 简而言之--不存在桥(割边)的极大子图为边双连通分量
求法也几乎与有向图中的强连通类似:只是要考虑双向边重复访问的,即两点间有多条双向边的问题。由于两点间可能有多条边,相比单向图的强连通球法我们引入多一个参数--eid,这代表到达u这个点刚经过的边,着重讲讲防止重复遍历一条边:
以链式向前星的存图方式为例。首先了解一下与1异或这个小技巧,对于偶数与1异或相当于+1,对于奇数与1异或相当于-1,存双向边本质上是存了两个反向的单向边,所以恰好是成对存储的(如果你用其他神仙操作不成对存,那在下就告辞聊)。为了方便我们将边的编号从2开始编号,这样一条双向边的编号就是一对<偶数,奇数>,这样我们就恰好可以利用与1异或的性质来根据当前的编号判断当前边是否是访问过的eid边的成对的另一条边。所以这就是为何有那句 if(i == (1^eid)) continue;
对于其他存图方式则依据这种原理利用其他方法判断即可
注意图中的每个点只可能属于一个边双连通分量,等会讲点双连通分量,注意区分!!
int dfn[maxv], low[maxv], indx;
int belong[maxv], bcc_cnt;
int mystack[maxv], top;
void tarjan( int u, int eid){ //经过eid这条边到达的u点
dfn[u] = low[u] = ++indx;
mystack[++top] = u;
in_stack[u] = true;
for(int i = head[u]; i; i = e[i].next)
{
if(i == (1^eid)) continue; //i边是到达u访问过的,是与eid成对的双向边的单向边之一
int nv = e[i].to;
if(!dfn[nv])
{
tarjan(nv, i);
low[u] = Min(low[u], low[nv]);
}else if(in_stack[nv]){
low[u] = Min(low[u], dfn[nv]);
}else
continue;
}
if(low[u] == dfn[u]){
++bcc_cnt;
int tmp = 0;
do{
tmp = mystack[top--];
in_stack[tmp] = false;
belong[tmp] = bcc_cnt; //缩点(将该连通分量上的点同一用一个编号表示)
}while(u != tmp);
}
return;
}
无向图求点双连通
参考自:https://www.cnblogs.com/LiHaozhe/p/9527136.html
点双连通:标记点 因为重边不影响割点或是树根的判断,故再多重边都当作一边处理,弄清这里的逻辑哦~
- 对于无向图中,任意两点至少存在两条点完全不同的路径相连,则该图点双连通。
- 简而言之,无割点的图是点双连通图。
三个重要的性质:
1)bcc中无割点
2)若两个bcc有公共点,则该公共点为两个bcc组成的图的割点
3)每一个割点至少属于两个bcc,非割点只属于一个bcc。(注意由于割点的定义,形如 a--b 也称作以个点双连通,做题时注意题目要求特判。
由于割点会同时属于多个bcc,所以有很多其他博主都用栈存边的方式来查找,这里介绍一种仍然存点的方式。这里的u和root与求割点中的意义相同。给一个结论每个bcc都在其最先发现的点(必是割点或dfs树根)的子树中。所以,关键是找到割点或树根,找到割点、树根就找到了点连通分量,所以主要操作与找割点很像,唯一不同在于无需将树根(root == u)的情况另外考虑,只需要满足(low[nv] >= dfn[u])就可以,因为此时要么是割点,要么是树根。之后将该子树与当前节点加入到bcc中。
*要注意得到点双连通分量后出栈时,出到根/割点之前就停止,这是用存点的方法求点双连通的一个关键点,因为割点必然属于多个点双连通分量,若一下子全部出栈会造成其他点连通点的缺失,这里建议在纸上自己模拟一次,理解了才不容易犯错!
int dfn[maxv], low[maxv], indx;
int mystack[maxv], top;
int bcc[maxv], bcc_cnt;
void tarjan_bcc_v(int u, int root) //root u 相当于一条边的两端点
{
dfn[u] = low[u] == ++indx;
for(int i = head[u]; i; i = e[i].next)
{
int nv = e[i].to;
if(!dfn[nv])
{
mystack[++top] = nv; //搜索到的点入栈
tarjan(nv, u);
low[u] = min[low[u], low[nv]];
if(low[nv] >= dfn[u]){ //是割点或根
bcc_cnt += 1;
int tmp = mystack[top--];
while(tmp != nv)
{
bcc[bcc_cnt].push_back(tmp);
tmp = mystack[top--];
}//一直出栈到割点之前
bcc[bcc_cnt].push_back(tmp);
bcc[bcc_cnt].push_back(u); //虽然加入到了一个bcc中,当前割点仍然在栈中
}
}else if(nv != root)
low[u] = min(low[u], dfn[nv]);
}
return;
}
无向图求割边(桥)
嗯,对的,割边最后讲,因为有两种求法:
1)先将无向图用边双连通的方法缩点处理,得到一个新图,此时所有新点间的边都是桥
2)在tarjan中若low[nv] > dfn[u],则u与v间相连的边是桥,因为nv最早能够回溯到的点在u之后,所以u与nv间的边不可或缺。
法一:在进行边双连通操作时查找
void tarjan(int u, int eid){ dfn[u] = low[u] = ++indx;for(int i = head[u]; i; i = e[i].next)
{ if(i == (1^eid)) continue; int nv = e[i].to; if(!dfn[nv]) { tarjan(nv, i); low[u] = Min(low[u], low[nv]); if(low[nv] > dfn[u]){ // 只要存在一个则是桥 **编号为i这条边是桥(怎么保存,看题目而定吧)**
} }else if(in_stack[nv]) low[u] = Min(low[u], dfn[nv]); else continue; }return; }
法二:缩点后在新图上查找
void tarjan(int u, int eid){ dfn[u] = low[u] = ++indx; mystack[++top] = u; in_stack[u] = true; for(int i = head[u]; i; i = e[i].next){ if(i == (1^eid)) continue; int nv = e[i].to; if(!dfn[nv]) { tarjan(nv, i); low[u] = Min(low[u], low[nv]); }else if(in_stack[nv]) low[u] = Min(low[u], dfn[nv]); else continue; } if(low[u] == dfn[u]){ bcc_cnt += 1; int tmp = 0; do{ tmp = mystack[top--]; in_stack[tmp] = false; belong[tmp] = bcc_cnt; //缩点 }while(tmp != u); } return; } void find_minBridge(){ for(int u = 1; u<=n; ++u){ for(int t = head[u]; t; t = e[t].next){ int nv = e[t].to; if(belong[u] != belong[nv]){//两点间的边是桥 u与nv之间的边t是桥
} } } return; }
emm, last but not least,点双连通一定是边双连通,边双连通不一定是点双连通。