图的割点vs图的割边（Tarjan算法）

图的割点vs图的割边（Tarjan算法）
割点含义：如果一个无向图中，删除某个顶点之后可以使任意两点之间不能相互到达，这个顶点即为割点。
割边含义：在一个无向连通图中，如果删除一条边使得任意两点无法互通，这条边就是割边。
前置知识：dfs序，即以dfs遍历图，每个点依次被访问到的次序。下面将会以dfs【】数组记录。
最早访问顺序：即一个图中，不通过父亲节点能够最早访问到的次序。即在不经过父亲节点，回朔时访问到的顶点的最早时间戳。下面以low【】数组记录。
求割点：

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
vector<int>q[N];//存图
vector<int>k;//存割点
int n,m;
int cnt=0;
int dfs[N],low[N];//dfs数组记录时间戳,low数组记录每个节点最早访问的次序
int root=1;//根节点
void solve(int now,int fa)
{
    int child=0;//用来记录当前顶点now的儿子个数
    dfs[now]=low[now]=++cnt;//记录时间戳
    for(int i=0;i<q[now].size();i++)
    {
        int to=q[now][i];
        if(to==fa)continue;
        if(dfs[to]==0)//如果当前节点未被访问
        {
            child++;
            solve(to,now);//继续搜索
            low[now]=min(low[now],low[to]);//当不能往下搜索的时候，求当前节点能访问到最早顶点的时间戳
            if(now!=root&&low[to]>=dfs[now])//如果当前节点不是根节点，且满足low[to]>=dfs[now]即为割点
            {
                   k.push_back(now);
            }
            if(now==root&&child==2)//如果当前节点是根节点，且有两个子树
            {
                k.push_back(now);
            }
        }
        else
        {
            low[now]=min(low[now],dfs[to]);//如果顶点to曾经被访问过，并且这个顶点不是now的父亲，更新
        }
    }
}
int main()
{
    cin>>n>>m;
    int x,y;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y;
        q[x].push_back(y);
        q[y].push_back(x);
    }
    solve(1,root);
    for(int i=0;i<k.size();i++)
    {
        cout<<k[i]<<endl;
    }
}

求割边：

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
vector<int>q[N];//存图
int n,m;
int cnt=0;
int p=0;
int dfs[N],low[N];//dfs数组记录时间戳,low数组记录每个节点最早访问的次序
int root=1;//根节点
struct node
{
    int start,to;
}e[N];//存割边
void solve(int now,int fa)
{
    dfs[now]=low[now]=++cnt;//记录时间戳
    for(int i=0;i<q[now].size();i++)
    {
        int to=q[now][i];
        if(to==fa)continue;
        if(dfs[to]==0)//如果当前节点未被访问
        {
            solve(to,now);//继续搜索
            low[now]=min(low[now],low[to]);//当不能往下搜索的时候，求当前节点能访问到最早顶点的时间戳
            if(low[to]>dfs[now])//如果满足low[to]>dfs[now]，now->to即为割边
            {
                e[++p].start=now;
                e[p].to=to;
            }
        }
        else
        {
            low[now]=min(low[now],dfs[to]);//如果顶点to曾经被访问过，并且这个顶点不是now的父亲，更新
        }
    }
}
int main()
{
    cin>>n>>m;
    int x,y;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y;
        q[x].push_back(y);
        q[y].push_back(x);
    }
    solve(1,root);
    for(int i=1;i<=p;i++)//打印割边
    {
        cout<<e[i].start<<" "<<e[i].to<<endl;
    }
}

两段代码只有一处不同：

割点： if(now!=root&&low[to]>=dfs[now])
割边： if(low[to]>dfs[now])

就是差个等号，low[to]>=dfs[now]代表的是点to是不可能在不经过父亲节点now而回到祖先（包括父亲），所以now是割点，相等则表示还可以回到父亲，而low[to]>dfs[now]表示连回父亲的路都找不到了，也没有另外一条路能回到父亲，那么now-to这条边就是割边。

重点理解：

这是未访问过的顶点的最早时间戳求法： low[now]=min(low[now],low[to]);
这是访问过的顶点的最早时间戳求法： low[now]=min(low[now],dfs[to]);

为什么访问过的顶点的最早时间戳求法要用min（low[now],dfs[to]）而不是min(low[now],low[to])
因为访问过的顶点你如果用min(low[now],low[to])去求解，就不能保证to的祖先不是now的父亲节点（注意是父亲节点而不是祖先），因为如果恰好to的祖先刚好是now 的父亲节点，
回朔时low[now]求出来就是他父亲的low值了，而如果把low换成dfs序则刚好保证如果to的祖先是now的父亲节点，那么now求出来的low值会刚好等于他父亲的dfs序，即now的父亲有可能就是割点。