当前位置：首页 > article >正文

图的割点、割边(Tarjan算法)

article 2025/1/2 3:34:40

深度优先搜索的利用。

在一个无向连通图中，如果删掉某个顶点后，图不再连通（即任意两点之间不能互相到达），我们称这样的顶点为割点。

在一个无向连通图中，如果删掉某条边后，图不在连通，这就是割边。

我们来看一个例子：

重要城市

我们已经掌握了敌人的城市地图，为了在战争中先发制人决定向敌人的某个城市上空投放炸弹，来切断敌人城市之间的通讯和补给，城市地图如下。

肉眼可见，删除二号顶点后，图便不在连通。那么我们如何设计程序来判断呢？

最直接的方法是遍历每一个顶点，判断该点删除后，其它顶点是否连通，用邻接表存储，时间复杂度为 $O(N(N+M))$ 。

现在要讲的Tarjan算法，在朴素算法的基础上优化，可以把时间复杂度降低到 $O(N+M)$ 。

Tarjan算法(图的割点)

Tarjan算法相较于朴素方法，我认为就是在深度搜索的时候已经处理了哪些是割点（因为遍历的时候肯定会遇到割点），而不需要再遍历n个顶点去删除所以它的时间复杂度去除了外面的 $N$ 变成了 $O(N+M)$ 。

为了突出Tarjan算法部分，我们先用邻接矩阵来写这道题，时间复杂度为 $O(N^2)$ 。

所以最主要的就是深度搜索部分，我们先来想一下朴素方法的深度搜索，其实就是构成了一个生成树（每一个无向连通图都有生成树）

本图的一个生成树如上所示，num数组来记录每个顶点的时间戳（每个结点的右上角，表示第几个被访问到），如num[3]=2,表示顶点3第二个被访问。

正如前面所说遍历的时候肯定会遇到割点，如果生成树上的一个子结点在图中不经过它的父结点就不能访问已经遍历过的其它结点，那么它的父节点就肯定是割点了。（根节点没有父节点，时间戳最小，需要另外判断）

下面这个难题就转变了，如果判断子节点不经过父节点访问其它节点。这里我们用一个low数组来存储一个节点在不经过父节点的情况下能访问到最远结点的时间戳。

对于某个顶点u，如果至少一个顶点v（即顶点的儿子），使得 $low[v]>=num[u]$ (两个数组都是存的时间戳)，那么u点为割点。

对于本例，5号顶点的儿子只有6号结点，且low[6]的值为3，而5号顶点的时间戳为num[5]为5，low[6]<num[5],可以回到祖先，因此5号结点不是割点。 2号顶点的时间戳为num[2]为3，low[5]=3，low[5]==num[2],不可以回到祖先，因此2号结点不是割点。

完整代码：（详细理解深度搜索部分）

#include<stdio.h>
int n,m;/*顶点数和边数*/
int root;/*根结点*/
int e[9][9]={0};/*邻接矩阵*/
int num[9]={0},low[9]={0},flag[9]={0};
/*num记录时间戳，low记录不经过父节点到达的最远时间戳
flag记录是否为割点*/

int min(int a,int b)
{
    return a<b ? a:b;
}

void dfs(int cur,int father,int index)
{
    int child=0;
    index++;
    num[cur]=index;
    low[cur]=index;
    for (int i = 1; i <= n; i++)
    {
        if (e[cur][i]==1)
        {
            if (num[i]==0)/*i顶点没有杯访问过*/
            {
                child++;/*子结点+1*/
                dfs(i,cur,index);/*继续往下遍历*/
                low[cur]=min(low[cur],low[i]);/*包含通过子节点访问的最早时间戳*/
                if (cur!=root && low[i]>= num[cur])
                /*当前结点不为根结点，子节点不能不通过父节点访问到之前的结点，该点为割点*/
                /*不能为根结点是因为low[i]最小为root*/
                {
                    flag[cur]=1;
                }
                else if(cur==root && child>=2)/*为根结点，且在生成树中（不是图），有两个儿子*/
                /*生成树中有两个儿子肯定是割点，没有两个儿子也有可能是割点*/
                    flag[cur]=1;
            }
            else if (i!=father)/*访问到的不是父节点，代表可以绕过了父节点*/
            {
                low[cur]=min(low[cur],num[i]);
            }     
        }
    }
    return ;
}

int main()
{
    int x,y;
    scanf("%d %d",&n,&m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d",&x,&y);
        e[x][y]=1;
        e[y][x]=1;/*无向图*/
    }
    root = 1;
    dfs(1,root,0);

    for (int i = 1; i <= n; i++)
    {
        if (flag[i]==1)
        {
            printf("%d ",i);
        }
    }
     
    return 0;
}

输入格式:

输入m+1行，第一行两个数n和m，n表示n个顶点，m表示m条边。接下来的m行，每行形如“a b”，用来表示一条边。

输出格式:

输出一行，一个数表示花费的最少银子数。

输入样例：

6 7

1 4

1 3

4 2

3 2

2 5

2 6

5 6

输出样例：

2

图的割边

如下图所示，左边的图没有割边，右边的图有割边：

图的割边其实子需要修改上面代码中的一个部分将 $low[v]>=num[u]$ 改为 $low[v]>num[u]$ ，即到达的顶点不包括其父结点和已经遍历的时间戳小于父结点的结点，这就证明该子节点与父节点相连的边为割边。

由于割边不需要额外判断是否为根节点，故判断那一部分可以删除。

完整代码（注意输出部分）：

#include<stdio.h>
int n,m;/*顶点数和边数*/
int root;/*根结点*/
int e[9][9]={0};/*邻接矩阵*/
int num[9]={0},low[9]={0};
/*num记录时间戳，low记录不经过父节点到达的最远时间戳*/

int min(int a,int b)
{
    return a<b ? a:b;
}

void dfs(int cur,int father,int index)
{
    index++;
    num[cur]=index;
    low[cur]=index;
    for (int i = 1; i <= n; i++)
    {
        if (e[cur][i]==1)
        {
            if (num[i]==0)/*i顶点没有杯访问过*/
            {
                dfs(i,cur,index);/*继续往下遍历*/
                low[cur]=min(low[cur],low[i]);/*包含通过子节点访问的最早时间戳*/
                if (low[i] > num[cur])
                {
                    printf("%d-%d\n",cur,i);
                }
            }
            else if (i != father)/*访问到的不是父节点，代表可以绕过了父节点*/
            {
                low[cur]=min(low[cur],num[i]);
            }     
        }
    }
    return ;
}

int main()
{
    int x,y;
    scanf("%d %d",&n,&m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d",&x,&y);
        e[x][y]=1;
        e[y][x]=1;/*无向图*/
    }
    root = 1;
    dfs(1,root,0);    
    return 0;
}