图的割点和割边

最新推荐文章于 2022-11-20 22:35:45 发布
最新推荐文章于 2022-11-20 22:35:45 发布
阅读量838 收藏 3
点赞数
分类专栏： 计算机基础 心得浅谈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nyist_yangguang/article/details/113732608
版权

割点（割顶）：在一个无向连通图中，如果删除了某个顶点后，图不再连通（即任意两点之间不能相互到达），该顶点称为割点（割顶）。

割边（桥）：在一个无向连通图中，如果删除某条边后，图不再连通，该边称为割边（桥）。

 

图的割点问题：

 

先用邻接矩阵走一波：

测试程序：

#include<stdio.h>
#include<iostream>
using namespace std;
int map[100][100];
int num[100];
int low[100];
int n,m;
int sum;
int root;
int flag[100];
void dis(int cur,int father)
{
    int child=0;
    sum++;
    num[cur]=sum;
    low[cur]=sum;

    for(int i=1; i<=n; i++)
    {
        if(map[cur][i]==1)
        {
            if(num[i]==0)
            {
                child++;
                dis(i,cur);
                low[cur]=min(low[cur],low[i]);
                if(cur!=root&&low[i]>=num[cur])
                    flag[cur]=1;
                if(cur==root&&child==2)
                    flag[cur]=1;
            }
            else if(i!=father)
            {
                low[cur]=min(low[cur],num[i]);
            }
        }


    }
}
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1; i<=m; i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        map[a][b]=1;
        map[b][a]=1;
    }
    root=1;
    dis(1,root);
    for(int i=1;i<=n;i++)
    {
        if(flag[i]==1)
            cout<<i<<endl;
    }
}

 

测试结果：

 

复杂度始终为 O(n^{^{2}})

 

使用邻接表来一波优化：

测试程序：(这个程序是错误的，但是错误的很有价值，hhh)

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
int first[100],next[100];
int u[100],v[100];
int n,m;
int sum;
int num[100],low[100];
int flag[100];
int root;
void dfs(int cur,int father)
{

    int child=0;
    sum++;
    num[cur]=sum;
    low[cur]=sum;


    int t=first[cur];
    while(t!=-1)
    {
            if(num[v[t]]==0)
            {
                child++;
                dfs(v[t],cur);
                low[cur]=min(low[cur],low[v[t]]);
                if(cur!=root && low[v[t]]>=num[cur])
                    flag[cur]=1;
                if(cur==root && child==2)
                    flag[cur]=1;
            }
            else if(v[t]!=cur)
            {
                low[cur]=min(low[cur],num[v[t]]);
            }
        t=next[t];
    }

}
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1; i<=2*m; i++)
    {
        first[i]=-1;
        next[i]=-1;
    }
    for(int i=1; i<=m; i++)
    {
        scanf("%d %d",&u[i],&v[i]);
        if(first[u[i]]==-1)
        {
            first[u[i]]=i;
        }
        else
        {
            next[i]=first[u[i]];
            first[u[i]]=i;
        }
        u[i+m]=v[i];
        v[i+m]=u[i];
        if(first[u[i+m]]==-1)
        {
            first[u[i+m]]=i+m;
        }
        else
        {
            next[i+m]=first[u[i+m]];
            first[u[i+m]]=i+m;
        }
    }
    root=1;
    dfs(root,1);




    for(int i=1; i<=n; i++)
    {
        if(flag[i]==1)
            cout<<i<<endl;
    }


}

测试结果：

 

 

再来修正后的程序：

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
int first[100],next[100];
int u[100],v[100];
int n,m;
int sum;
int num[100],low[100];
int flag[100];
int root;
void dfs(int cur,int father)
{

    int child=0;
    sum++;
    num[cur]=sum;
    low[cur]=sum;


    int t=first[cur];
    while(t!=-1)
    {
            if(num[v[t]]==0)
            {
                child++;
                dfs(v[t],cur);
                low[cur]=min(low[cur],low[v[t]]);
                if(cur!=root && low[v[t]]>=num[cur])
                    flag[cur]=1;
                if(cur==root && child==2)
                    flag[cur]=1;
            }
            else if(v[t]!=cur)
            {
                low[cur]=min(low[cur],num[v[t]]);
            }
        t=next[t];
    }

}
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1; i<=2*m; i++)
    {
        first[i]=-1;
        next[i]=-1;
    }
    for(int i=1; i<=m; i++)
    {
        scanf("%d %d",&u[i],&v[i]);

    }
    for(int i=m+1;i<=2*m;i++)
    {
         v[i]=u[i-m];
         u[i]=v[i-m];
    }
    for(int i=1;i<=2*m;i++)
    {
        next[i]=first[u[i]];
        first[u[i]]=i;
    }
    root=1;
    dfs(root,1);




    for(int i=1; i<=n; i++)
    {
        if(flag[i]==1)
            cout<<i<<endl;
    }


}

测试结果：

 

使用邻接表优化以后：时间复杂度为O(n+m)

 

 

 

 

图的割边问题：

测试程序：

​​#include<stdio.h>
#include<iostream>
using namespace std;
int map[100][100];
int num[100];
int low[100];
int n,m;
int sum;
int root;
int flag[100];
void dis(int cur,int father)
{
    int child=0;
    sum++;
    num[cur]=sum;
    low[cur]=sum;

    for(int i=1; i<=n; i++)
    {
        if(map[cur][i]==1)
        {
            if(num[i]==0)
            {
                child++;
                dis(i,cur);
                low[cur]=min(low[cur],low[i]);
                if(cur!=root&&low[i]>num[cur])
                    cout<<cur<<"---"<<i<<endl;
                if(cur==root&&child==2)
                    cout<<cur<<"---"<<i<<endl;
            }
            else if(i!=father)
            {
                low[cur]=min(low[cur],num[i]);
            }
        }


    }
}
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1; i<=m; i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        map[a][b]=1;
        map[b][a]=1;
    }
    root=1;
    dis(1,root);
}

测试结果：

很明显，没有割边。

换个有割边的：

 

这个程序同样可以使用邻接表进行优化：

测试程序：

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
int first[100],next[100];
int u[100],v[100];
int n,m;
int sum;
int num[100],low[100];
int flag[100];
int root;
void dfs(int cur,int father)
{

    int child=0;
    sum++;
    num[cur]=sum;
    low[cur]=sum;


    int t=first[cur];
    while(t!=-1)
    {
            if(num[v[t]]==0)
            {
                child++;
                dfs(v[t],cur);
                low[cur]=min(low[cur],low[v[t]]);
                if(cur!=root && low[v[t]]>=num[cur])
                    cout<<cur<<" --- "<<v[t]<<endl;
                if(cur==root && child==2)
                    cout<<cur<<" --- "<<v[t]<<endl;
            }
            else if(v[t]!=cur)
            {
                low[cur]=min(low[cur],num[v[t]]);
            }
        t=next[t];
    }

}
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1; i<=2*m; i++)
    {
        first[i]=-1;
        next[i]=-1;
    }
    for(int i=1; i<=m; i++)
    {
        scanf("%d %d",&u[i],&v[i]);

    }
    for(int i=m+1;i<=2*m;i++)
    {
         v[i]=u[i-m];
         u[i]=v[i-m];
    }
    for(int i=1;i<=2*m;i++)
    {
        next[i]=first[u[i]];
        first[u[i]]=i;
    }
    root=1;
    dfs(root,1);




}

测试结果：

 

 

 

使用邻接表优化以后：时间复杂度为O(n+m)

程序猿的探索之路
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
图论判别图G是否为割点割边
12-20
使用c++去实现对图G割点割边的识别，输入G（V）之间的关系从而输出割点
割点与割边
Locke的博客
03-24 1019
◇◆◇概念◇◆◇ 联通块：任意两个点之间存在至少一条路径可以到达对方的一个点集。 说白了就是某一块里面的点是连起来的。 割边：割掉某一条边能使整个图分为两个联通块的边，又称关键边（桥）。 割点：割掉某一个点（这意味着失去所有连向这个点的边）使整个图分为两个联通块的点。 ◇◆◇目标◇◆◇ 找出一个无向图中的割点、割边 ◇◆◇怎么找◇◆◇ 先在这里插入两个概念。 在我们DFS的时候，...
图的割点（解释及实现）
qq_44423388的博客
11-20 1867
在一个无向连通图中，如果删除某个顶点后，图不再连通（任意两顶点之间不能相互到达），我们称这样的顶点为割点。
图的割点/割边
萌新也要搞算法
03-12 4105
割点：对于一个连通图，删去某些点（删去一个点即把该店和与该点相邻接的边都删去），得到的图将不再连通，而删去该点集的任意子集该图依然连通，则其称为该图的一个割集，若该集合只有一个点组成，则称其为割点。割边：对于一个连通图删去某些边（删去一条边仅删去该条边即可），得到的图将不再连通，而删去改边集的任意子集，该图依然连通，则称其为该图的边割集，若该集合只有一条边组成，则称其为割边，又称桥。算法实现：首先...
图论（二）：图的割点(cut vertex)与连通度(connectivity)
Machine Learning with Tutors
02-18 7176
在无向连通图中，删除一个顶点v及其相连的边后，原图从一个连通分量变成了两个或多个连通分量，则称顶点v为割点，同时也称关节点(Articulation Point)。一个没有关节点的连通图称为重连通图(biconnected graph)。若在连通图上至少删去k 个顶点才能破坏图的连通性，则称此图的连通度为k。关节点和重连通图在实际中较多应用。显然，一个表示通信网络的图的连通度越高，其系统越可靠，无论是哪一个站点出现故障或遭到外界破坏，都不影响系统的正常工作；
割点与割边的关系图论
zwl_qiu的博客
05-31 2206
割点与割边可以通过以下两种图来辨别： 1）有环图。在环那一点，是存在割点而不存在割边的。 2）非连通图（注意：非连通图仍可为简单图）。在非liantongtu
点割集、边割集、割点、桥、连通度、双连通分支定义1
08-08
点割集：V是一些顶点的集合，如果删除V中的所有顶点之后，G不再连通，但是对于V的任何真子集V1，删除V1后G仍然连通，则称V是点割集。边割集：E是一些边的集合，
图的边割的矩阵判别法 (2008年)
05-14
对以往文献给出的割边的关联矩阵判别法进行了分析,结果表明,按照代宏霞文章枟图的割点的矩阵判别的推广枠中给出的图G- S的关联矩阵的定义,不能处理某些特殊的图,因此对图G - S的关联矩阵给出新定义,并将上述文献的...
无向图的割点(POJ 2117)
08-19
这道题的目的是求如去除某个点，能把图分成多少个子图，求这样子图的最大数。...其实就是求割点，然后看每个割点能把图分成多少个子图，当然原图不一定是连通的。 割点的求法各个书籍上都有，其实就是用DFS进行遍历。
【模板】割点判定
K1385170的博客
03-11 306
引理：若图中一个点是割点，则满足： 若该点不是搜索树的根节点：以该点为根的搜索子树中任意节点的 low[] 值均大于等于该点的时间戳 dfn[]。 若该点是搜索树的根节点，则必须有两个或两个以上的搜索子树上的节点满足第一条性质。 割点的定义：将该点删去后，新生成的图（不包括删去的顶点）会分为两个或两个以上的不连通子图。 代码如下 #include <bits/stdc++.h&...
乱炖 | 最小生成树、割点割边、最大二分匹配
Yesterday You Said Tomorrow.
03-29 577
目录图的最小生成树 Kruskal再谈-图的最小生成树 Prim图的割点如何求割点？图的割边如何求割边？二分图附加考题（主元素问题） 图的最小生成树 Kruskal 思路：让边的总长度之和最短，首先选择最短的边，其次选择次短的……，直到选择了n-1条边为止。（注意选边不能造成回路） 难实现的是：判断两个顶点是否已经连通。（可以使用广搜或者深搜，但这样效率低）可以使用已经学习的并查集，把所有的顶点放...
Tarjan算法：求解无向连通图图的割点（关节点）与桥（割边）
weixin_30246221的博客
07-16 1363
1. 割点与连通度 在无向连通图中，删除一个顶点v及其相连的边后，原图从一个连通分量变成了两个或多个连通分量，则称顶点v为割点，同时也称关节点(Articulation Point)。一个没有关节点的连通图称为重连通图(biconnected graph)。若在连通图上至少删去k 个顶点才能破坏图的连通性，则称此图的连通度为k。 关节点和重连通图在实际中较多应用。显然，一个表示通信网络的图...
判断给定的顶点是否是给定无向图的【割点】
weixin_44405344的博客
03-10 1331
割点的定义是，如果删除该顶 点后会使该无向图的连通分量（连通块）个数变多，那么就称该顶点为该无向图的割点。 求无向图的连通块个数的基本思路是，开一个 vis 数组表示顶点是否已访问，然后遍历所有 顶点，如果当前顶点还没有被访问，那么就访问该顶点所在的连通块，将该连通块中的所有顶 点都标记为已访问。而遍历连通块也只需要一个简单的 DFS 就能解决，书上 10.3 图的遍历这个 小节已经写得很清楚了。...
割点（Tarjan算法）
dengshouzi7943的博客
06-07 845
本文可转载，转载请注明出处：www.cnblogs.com/collectionne/p/6847240.html。本文未完，如果不在博客园（cnblogs）发现此文章，请访问以上链接查看最新文章。 前言：之前翻译过一篇英文的关于割点的文章（英文原文、翻译），但是自己还有一些不明白的地方，这里就再次整理了一下。有兴趣可以点我给的两个链接。 割点的概念 在无向连通...
DFS应用——找出无向图的割点
PacosonSWJTU的博客
11-23 2052
【0】README0.1） 本文总结于 数据结构与算法分析， 源代码均为原创， 旨在 理解 “DFS应用于找割点” 的idea 并用源代码加以实现； 0.2） 必须要事先 做个specification的是，对于给定图的除开起始vertex的那些 vertexes，都可以通过我们的 rules（见下文）找出割点，即对于根（start），我们需要做个special 的test，参见main函数中最后
求割点（邻接表无向图）C~
Unyielding will
08-13 636
邻接表 求割点
图论学习--3 图的连通度（思维导图）割点 割边 块 连通度 连通度的性质
或左的博客
08-21 7179
图的连通度 割边，割点，块 割边 图G删除e之后，连通分支变多 若G连通，删去割边之后，G不连通 定理1：e是G的割边当且仅当e不在G的任何圈中 由此可推论：e是连通图G的某圈中，则G-e仍然连通 必要性：反证，假设e在圈中，对于G-e，任意取两个点x,y。对于G，因为连通，所以存在x,y的路P，1）P不含e，则P也是G-e中一条路2）P含e，因为e在圈中，则C-e是可以和P组成一条心的路。综上，不管怎样，G-e都连通，这和e是割边矛盾，故e不在圈中 充分性：显然啦，若e不是割边，则G-e连通，从而.
拓扑排序、割点与割边、强连通分量
最新发布
07-23
割点和割边的存在可以影响到图的连通性，因此在网络设计、通信等领域有着重要的应用。 3. 强连通分量（Strongly Connected Component）： 强连通分量是指在有向图中，如果对于图中任意两个顶点u和v，存在从u到v和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿的探索之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值