tarjan - tarjan的几种用法

前言

tarjan是一种神奇的算法，

它可以在线性时间内求强联通分量/缩点/LCA/割点/割边/...

但由于博主咸鱼，暂时掌握不了这么多，

先讲讲其中最简单的一些。

---

概述

tarjan是以DFS为基础的算法。

在DFS的过程中会产生一棵树。

tarjan在DFS过程中要用到2个数组(其实还有一个栈)：

low[],节点i能够回溯到的最早位于栈中的节点;

dfn[],深度优先搜索遍历时节点i被搜索的次序。

在搜索过程中，对于任意节点a和与其相连的节点b，根据节点b是否在栈中来进行不同的操作：

if(b不是a的子树)low[a]=min(low[a],dfn[b]);
else low[a]=min(low[a],low[b]);

得到这2个数组，接下来就好办了。

缩点

就是找强联通分量。

在tarjan搜索的时候有一个栈，记录访问过的节点，

当dfn[i]==low[i]时，为i或i的子树可以构成一个强连通分量，可以开始弹栈。

由于该连通图中的dfn值和low值相等的节点是该连通分量中第一个被访问到的节点，

又根据栈的特性，则该节点在最里面。

所以能够通过不停的弹栈，直到弹出这个节点来找到该连通分量中所有的节点。

而在不停弹栈时要记录一下这些节点所在的强连通分量。

注意：tarjan之后的图已经不能用了用了不等于没缩点，因此缩点之后要重新连边

裸题：luogu 2746 https://www.luogu.org/problem/show?pid=2746

代码蒯上

#include<iostream>
#include<iomanip>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gotcha()
{
    register int _a=0;bool _b=1;register char _c=getchar();
    while(_c<'0' || _c>'9'){if(_c=='-')_b=0;_c=getchar();}
    while(_c>='0' && _c<='9')_a=_a*10+_c-48,_c=getchar();
    return _b?_a:-_a;
}
const int _ = 102,__ = 10002;
struct nextstar{int to,ne;nextstar(){to=ne=0;}}e[__];
int he[_]={0},ecnt=0;
void add(int fr,int to)
{
    e[++ecnt].to=to;
    e[ecnt].ne=he[fr];
    he[fr]=ecnt;
}
int co[_],cocnt,dfn[_]={0},low[_]={0},cnt=0,sta[_],rr=0,m,n;
bool in[_]={0},out[_]={0},ed[_]={0};
void tarjan(int now)
{
    dfn[now]=low[now]=++cnt;
    sta[++rr]=now;ed[now]=1;
    int i,j;
    for(i=he[now];i;i=e[i].ne)
    {
        j=e[i].to;
        if(!dfn[j])tarjan(j),low[now]=min(low[now],low[j]);
        else if(ed[j])low[now]=min(low[now],dfn[j]);
    }
    if(low[now]==dfn[now])
    {
        cocnt++,i=0;
        while(i!=now){i=sta[rr--];co[i]=cocnt;ed[i]=0;}
    }
}
int main()
{
    register int i,j,ans=0,ans2=0;
    n=gotcha();
    for(i=1;i<=n;i++)
    {
        j=gotcha();
        while(j!=0){add(i,j),j=gotcha();}
    }
    m=ecnt;
    for(i=1;i<=n;i++)if(!dfn[i])rr=0,tarjan(i);
    for(i=1;i<=n;i++)
        for(j=he[i];j;j=e[j].ne)
            if(co[i]!=co[e[j].to])out[co[i]]=1,in[co[e[j].to]]=1;
    if(cocnt==1){printf("%s","1\n0");return 0;}
    for(i=1;i<=cocnt;i++)
    {
        if(!in[i])ans++;
        if(!out[i])ans2++;
    }
    printf("%d\n%d",ans,max(ans,ans2));
    return 0;
}

---

割点/割边

若low[b]>=dfn[a],则a为割点。

节点b的子孙和节点a形成一个块。因为这说明b的子孙不能够通过其他边到达a的祖先，这样去掉a之后，图必然分裂为两个子图。

这样我们处理点a时，首先递归a的子节点b，然后从b回溯至a后，如果发现上述不等式成立，则找到了一个割点a，并且a和b的子树构成一个块。

注意：如果a是根节点要特判一下。即如果它的子树大于1棵，辣么它也是个割点。

若low[b]>dfn[a],则(a,b)为割边。

但是实际处理时可能有重边，因此需要。

我们记录每条边的标号与每个点的父亲到它的边的标号，

如果边(a,b)是b的父亲边，就不能用dfn[a]更新low[b]。这样如果遍历完b的所有子节点后，发现low[b]仍然=dfn[b]，说明u的父亲边(a,b)为割边。

因为博主咸鱼，只写了割点的裸题 luogu 3388,https://www.luogu.org/problem/show?pid=3388

有时间把割边的补上。

代码蒯上

#include<iostream>
#include<iomanip>
#include<cmath>
#include<map>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gotcha()
{
    register int _a=0;bool _b=1;register char _c=getchar();
    while(_c<'0' || _c>'9'){if(_c=='-')_b=0;_c=getchar();}
    while(_c>='0' && _c<='9')_a=_a*10+_c-48,_c=getchar();
    return _b?_a:-_a;
}
const int _ = 100002;
struct nextstar
{
    int to,ne;
    nextstar(){to=ne=0;}
}e[2*_];
int he[_]={0},ecnt=0;
void add(int fr,int to)
{
    e[++ecnt].to=to;
    e[ecnt].ne=he[fr];
    he[fr]=ecnt;
}
int dfn[_]={0},low[_]={0},cnt=0,fa[_],n,m;
bool cut[_]={0};
void trajan(int now)
{
    int i,j,in=0;
    dfn[now]=low[now]=++cnt;
    for(i=he[now];i;i=e[i].ne)
    {
        j=e[i].to;
        if(!dfn[j])
        {
            fa[j]=fa[now];
            trajan(j);
            low[now]=min(low[now],low[j]);
            if(low[j]>=dfn[now] && now!=fa[now])cut[now]=1;
            if(now==fa[now])in++;
        }
        low[now]=min(low[now],dfn[j]);
    }
    if(now==fa[now] && in>=2)cut[fa[now]]=1;
}
int main()
{
    register int i,j,k,ans=0;
    n=gotcha(),m=gotcha();
    for(i=1;i<=n;i++)fa[i]=i;
    for(i=1;i<=m;i++)
    {
        j=gotcha(),k=gotcha();
        add(j,k),add(k,j);
    }
    for(i=1;i<=n;i++)if(!dfn[i])trajan(i);
    for(i=1;i<=n;i++)if(cut[i])ans++;
    printf("%d\n",ans);
    for(i=1;i<=n;i++)if(cut[i])printf("%d ",i);
    return 0;
}

---

LCA

tarjan求LCA当然是离线的啦(想在线的出门右转学倍增)

tarjan求lca还要用并查集。

求lca(a,b)，当返回到节点i时，必然已经访问完了i的子树。此时将i的子树上的节点的父亲记为i。

这样递归下去，当a和b第一次被标记时，i就是它俩的最近公共祖先。

从根节点向下搜索时，搜索完一个节点时，与其父亲节点连(并查集的)边，放入并查集。

再判断a节点对应的要询问的节点是否已经被访问过。若已访问过，那么最近公共祖先就是b节点在并查集中的父亲。

想了解更多去 http://www.cnblogs.com/JVxie/p/4854719.html

裸题：luogu 3379 https://www.luogu.org/problem/show?pid=3379

代码蒯上

#include<iostream>
#include<iomanip>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gotcha()
{
    register int _a=0;bool _b=1;register char _c=getchar();
    while(_c<'0' || _c>'9'){if(_c=='-')_b=0;_c=getchar();}
    while(_c>='0' && _c<='9')_a=_a*10+_c-48,_c=getchar();
    return _b?_a:-_a;
}
inline void launch(int _a,bool _ret)
{
    int _num=0;char _c[15];
    while(_a)_c[++_num]=(_a%10)+48,_a/= 10;
    while(_num)putchar(_c[_num--]);if(_ret)putchar('\n');
}
const int _ = 500002;
struct nextstar
{
    int to,ne;
    nextstar(){to=ne=0;}
}e[2*_];
struct trouble
{
    int to,ne,num;
    trouble(){to=ne=num=0;}
}tr[2*_];
int h1[_]={0},h2[_]={0},ecnt=0,trcnt=0;
void add(int fr,int to)
{
    e[++ecnt].to=to;
    e[ecnt].ne=h1[fr];
    h1[fr]=ecnt;
}
void newtrouble(int fr,int to,int num)
{
    tr[++trcnt].to=to;
    tr[trcnt].num=num;
    tr[trcnt].ne=h2[fr];
    h2[fr]=trcnt;
}
int fa[_],ans[_]={0},root,m,n;
bool ed[_]={0};
int finder(int a){return a!=fa[a]?fa[a]=finder(fa[a]):a;}
void tarjan(int now)
{
    int i;ed[now]=1;
    for(i=h2[now];i;i=tr[i].ne)
        if(ed[tr[i].to])ans[tr[i].num]=finder(fa[tr[i].to]);
    for(i=h1[now];i;i=e[i].ne)if(!ed[e[i].to])tarjan(e[i].to),fa[e[i].to]=now;
}
int main()
{
    register int i,j,k;
    n=gotcha(),m=gotcha(),root=gotcha();
    for(i=1;i<=n;i++)fa[i]=i;
    for(i=1;i<n;i++)
    {
        j=gotcha(),k=gotcha();
        add(j,k),add(k,j);
    }
    for(i=1;i<=m;i++)
    {
        j=gotcha(),k=gotcha();
        newtrouble(j,k,i),newtrouble(k,j,i);
    }
    tarjan(root);
    for(i=1;i<=m;i++)launch(ans[i],1);//want to try it?
    return 0;
}

---

暂时先写这么多，

由于博主咸鱼，这东西不定期更新。