连通图板子

最新推荐文章于 2021-09-22 19:51:18 发布
最新推荐文章于 2021-09-22 19:51:18 发布
阅读量193 收藏 2
点赞数
分类专栏： ACM_新模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxy160/article/details/79089842
版权

一.tarjan算法求一个图有几个连通图。

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=1e5;
int n,m;
struct node
{
    int v,nex;
} e[maxn];
int first[maxn];
int tot,top,ans,din;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    top=0;
    ans=0;
    din=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
}
void edge(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {

        v=e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(in[v]&&low[u]>dfn[v])
        {
            low[u]=dfn[v];
        }
    }
    if(dfn[u]==low[u])
    {
        ans++;
        do
        {
            v=Stack[--top];
            in[v]=0;
        }
        while(v!=u);
    }
}
void scc()
{
    for(int i=1; i<=n; i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&(n+m))
    {
        init();
        for(int i=0; i<m; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            edge(u,v);
        }

        scc();
    }
    return 0;
}

二.tarjan有向图缩点

1.求至少选几个点作为起点走遍全图（也就是这几个点走的路加起来走遍全图）？
2.求最小加多少边能使图变成强连通图？

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=105;
int n,m;
struct node
{
    int v,nex;
} e[maxn*maxn];
int first[maxn];
int tot,top,ans,din;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
int belong[maxn],out[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    top=0;
    ans=0;
    din=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
}
void edge(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {

        v=e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(in[v]&&low[u]>dfn[v])
        {
            low[u]=dfn[v];
        }
    }//printf("sdfa\n");
    if(dfn[u]==low[u])
    {
        ans++;
        do
        {
            v=Stack[--top];
            in[v]=0;
            belong[v]=ans;
            //printf("%d ",v);
        }
        while(v!=u);
        //printf("\n");
    }
}
void scc()
{
    for(int i=1; i<=n; i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    if(ans==1)
    {
        printf("1\n0\n");
        return ;
    }
    mem(in,0);
    mem(out,0);
    int ans1=0,ans2=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=first[i];j!=-1;j=e[j].nex)
        {
            int v=e[j].v;
            //printf("    %d %d\n",i,v);
            if(belong[i]!=belong[v])
            {
                in[belong[v]]++;
                out[belong[i]]++;
            }
        }
    }
    for(int i=1;i<=ans;i++)
    {
        //printf("%d \n",in[i]);
        if(in[i]==0) ans1++;
        if(out[i]==0) ans2++;
    }
    printf("%d\n%d\n",ans1,max(ans1,ans2));
}
int main()
{
    while(~scanf("%d",&n))
    {
        init();
        for(int i=1;i<=n;i++)
        {
            while(1)
            {
                int v;
                scanf("%d",&v);
                if(v==0)
                    break;
                //printf("      %d %d\n",i,v);
                edge(i,v);
            }
        }
        scc();
    }
    return 0;
}

三.tarjan无向图割点

如果想知道k这个割点把图割成了几部分，就并查集搞一下。

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=200;
int n,m;
struct node
{
    int v,nex;
} e[maxn*maxn];
int first[maxn];
int tot,top,ans,din;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
int son,flag[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    top=0;
    din=0;
    son=0;
    ans=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
    mem(flag,0);
}
void edge(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {

        v=e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
            //printf("       %d %d\n",low[u],low[v]);
            if(u!=1&&low[v]>=dfn[u])
            {

                flag[u]=1;
            }
            else if(u==1)
                son++;
        }
        else if(in[v]&&low[u]>dfn[v])
        {
            //printf("       %d %d\n",u,v);
            low[u]=dfn[v];
        }
    }//printf("sdfa\n");
    if(dfn[u]==low[u])
    {
        ans++;
        do
        {
            v=Stack[--top];
            in[v]=0;
            //belong[v]=ans;
            //printf("%d ",v);
        }
        while(v!=u);
        //printf("\n");
    }
}

int main()
{
    while(~scanf("%d",&n)&&n)
    {
        init();
        int u,v;
        while(scanf("%d",&u)&&u)
        {
            while(getchar()!='\n')
            {
                scanf("%d",&v);
                //printf("       %d %d\n",u,v);
                edge(u,v);
                edge(v,u);
            }
        }


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

四.无向连通图求桥

注意去重边

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=10005;
int n,m;
struct node2
{
    int x,y;
} ee[maxn*maxn];
int cmp(node2 a,node2 b)
{
    if(a.x==b.x)
        return a.y<b.y;
    else
        return a.x<b.x;
}
struct node
{
    int v,nex;
} e[maxn*maxn];
int first[maxn];
int tot,top,ans,din,cnt;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
int son,flag[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    top=0;
    din=0;
    son=0;
    ans=0;
    cnt=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
    mem(flag,0);
}
void edge(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u,int vv)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {

        v=e[i].v;
        if(i==(vv^1)) continue;
        if(!dfn[v])
        {
            tarjan(v,i);
            low[u]=min(low[u],low[v]);
            //printf("       %d %d\n",low[v],dfn[u]);
            if(low[v]>dfn[u])
            {
                ee[cnt].x=v;
                ee[cnt].y=u;
                if(v>u)
                    swap(ee[cnt].x,ee[cnt].y);
                cnt++;
            }
        }
        else if(in[v]&&low[u]>dfn[v])
        {
            //printf("       %d %d\n",u,v);
            low[u]=dfn[v];
        }
    }//printf("sdfa\n");
}

int main()
{
    int tt=1;
    while(~scanf("%d",&n))
    {
        if(n==0)
        {
            printf("0 critical links\n\n");
            continue;
        }
        init();
        int u,v,k;
        for(int i=0; i<n; i++)
        {
            scanf("%d (%d)",&u,&k);
            for(int j=0; j<k; j++)
            {
                scanf("%d",&v);
                int flag=0;
                for(int j=first[u]; j!=-1; j=e[j].nex)
                {
                    int qq=e[j].v;
                    if(qq==v)
                    {
                        flag=1;
                        break;
                    }
                }
                if(flag==1) continue;
                //printf("%d %d\n",u,v);
                edge(u,v);
                edge(v,u);
            }
        }
        for(int i=0; i<n; i++)
        {
            if(!dfn[i])
                tarjan(i,-1);
        }
        sort(ee,ee+cnt,cmp);
        printf("%d critical links\n",cnt);
        for(int i=0; i<cnt; i++)
        {
            printf("%d - %d\n",ee[i].x,ee[i].y);
        }
        printf("\n");
    }
    return 0;
}

五：双联图：一个有桥的连通图，如何把它通过加边变成边双连通图

这里有几个点需要注意
1.为什么无向图缩点需要变成有向图缩点？
无向图两两之间的点可以到达，无法跑回边的话，就跑不到父节点以上的节点了，那么肯定是桥了。
2.为什么不能跑回边，而不是跑父节点？
本来是个无向图单连通，但是你阻止了父节点跑回去，那就不是无向图单连通了。
但是这个题去重也对，嗯。。。数据弱

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=10005;

struct node
{
    int u,v,nex;
} e[maxn*maxn];
int first[maxn];
int tot;
int n,m;
int ans,din,top;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
int belong[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    din=1;
    ans=0;
    top=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
    mem(belong,0);
}
void edge(int u,int v)
{
    e[tot].u=u;
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u,int id)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {
        v=e[i].v;
        if(i==(id^1))
            continue;
        if(!dfn[v])
        {
            tarjan(v,i);
            low[u]=min(low[u],low[v]);
        }
        else if(in[v])
        {
            low[u]=min(low[u],low[v]);
        }
    }
    if(dfn[u]==low[u])
    {
        ans++;
        do
        {
            v=Stack[--top];
            in[v]=0;
            belong[v]=ans;
            //printf("%d\n",ans);
        }
        while(v!=u);
    }
}
void scc()
{
    for(int i=1; i<=n; i++)
    {
        if(!dfn[i])
            tarjan(i,-1);
    }
    //printf("%d\n",ans);
    int sum=0;
    int k=0;
    int aa[maxn],gg[maxn];
    mem(aa,0);
    mem(gg,0);
    for(int i=0; i<tot; i+=2)
    {
        int u=e[i].u;
        int v=e[i].v;
        if(belong[u]!=belong[v])
        {
            //printf("%d %d\n",belong[u],belong[v]);
            aa[belong[u]]++;
            aa[belong[v]]++;
        }
    }
    for(int i=1; i<=ans; i++)
    {
        if(aa[i]==1) sum++;
    }
    printf("%d\n",(sum+1)/2);
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=0; i<m; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
//            int flag=0;
//            for(int j=first[u]; j!=-1; j=e[j].nex)
//            {
//                int to=e[j].v;
//                if(v==to)
//                {
//                    flag=1;
//                    break;
//                }
//            }
//            if(flag==1) continue;
            edge(u,v);
            edge(v,u);
        }
        scc();
    }
}
zz你的名字
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
总结一下最短路径的贝尔曼-福特算法(Bellman-Ford)及用队列优化(spfa)
zxy160的博客
01-17 4725
转发的一二货的：http://blog.csdn.net/riba2534/article/details/54575050 他是从《啊哈算法》上学的，本来想总结一下，一看跟他一模一样，then，，，，，，关于贝尔曼福特算法,假设有n个顶点，我们只需要遍历n-1轮就可以了，因为在一个含n个顶点的图中，任意两点之间的最短路径最多含有n-1条边, 什么原理，我就不讲了，网上大牛博客很多，我在这里上一
连通图
这是一个很懒（handsome）的人，所以什么也没有留下
03-24 304
连通图 Time Limit:1000MS  Memory Limit:65536K Total Submit:156 Accepted:88 Description 判断一个图是否为一个边通图 Input n 顶点 (n 边 Output 1 表示连通 0 表示不边通 Sample Input 5 1 2 2 3 5 4 0 0
nyoj42——连通图加欧拉(连通图板子）dfs
weixin_30609331的博客
03-06 61
一笔画问题 时间限制：3000ms | 内存限制：65535KB 难度：4 描述 zyc从小就比较喜欢玩一些小游戏，其中就包括画一笔画，他想请你帮他写一个程序，判断一个图是否能够用一笔画下来。 规定，所有的边都只能画一次，不能重复画。 输入第一行只有一个正整数N(N<=10)表示测试数据的组数。每组测试数据的第一行有两个正整数P,Q(P<=10...
连通图板子合集(以Tarjan为主)
Anxdada -- 我等风来也等你
07-17 525
//解释下low和dfn在dfs树中的意义, dfn[v]是在dfs中v是第几个遍历的点, low[v]表示v以及v所有的后代直接指出去的边可以到达的dfn值最小的点的dfn值. 1: 强联通/边双联通 注意 : 单点也算是一个强联通/边双联通分量 a. 强联通: 处于一个强联通分量的点之间可以相互到达 首先只有在有向图中才有强联通. (因为大部分用来缩点, 所以用的vector存图, 重...
连通性板子
Suryxin's blogs
09-22 78
可达性 有向图 边双缩点模版题 Redundant Paths 无向图 边双缩点 [HAOI2006]受欢迎的牛 有向图 边双缩点 嗅探器 无向图 割点 Network of Schools 有向图，缩点，问形成强连通要几条边 Cow Ski Area 不建图，滑雪题 割点 int tot; int head[MAX]; struct ran{ int to, nex; }tr[MAX]; void add(int u, int v){ tr[++tot].to = v; tr[.
EGO1板子上写的图像膨胀模块
最新发布
04-25
在二值图像中，膨胀操作通过结构元素（通常为一个小的模板）与图像像素进行卷积，将像素的白色区域扩展到邻近的黑色区域，从而增加物体轮廓的连通性。这个过程对于去除噪声、连接分离的像素群以及增强边缘有着显著...
prufer + 对拍(自用)
03-29
Prüfer序列是一种将无环连通图（即树）转化为序列的方法，序列长度为n-2。构建Prüfer序列的基本步骤是每次从度数最小的顶点出发，找到与其相连的度数较大的顶点，并将这个大顶点的编号记录到序列中，重复此过程...
led和mos管的PCB图
03-27
5. 电气规则检查（ERC）和设计规则检查（DRC）：通过软件工具检查设计的电气连通性和物理约束，防止潜在错误。 最后，实际的PCB设计过程中，还需要结合电路原理图，确保PCB板与电路设计的一致性。通过反复迭代和...
嵌入式linux中单步调试程序的方法(图文详细说明)
04-29
- 确保虚拟机和目标板之间的网络连通，可以通过ping命令测试通信是否正常。 - 在QtCreator中，使用Debug模式编译程序，这会生成调试信息。 - 调试阶段，选择[调试]->[开始调试]->[Attach to Running Debug Server...
【开源】智能高频焊台制作（原理图、PCB、程序源码及制作流程）-电路方案
04-21
M8--PIN6和编码器的线短路，需要飞线连通。 功率板错误: 1、R9不用直接短路 2、全桥D5的丝印正负标识反了。 3、VR1 7812 的丝印方向反了，实际散热片的位置要靠板子的边沿。 已知的问题: 1、现在原定使用的外部TL431...
BBP算法板子
zxy160的博客
11-07 1926
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=6217 百度BBP解释：https://wenku.baidu.com/view/716dbac708a1284ac85043bf.html 板子，不会，别问我#include <cstdio> #include<iostream> using namespace std; typedef long
LCA，有向图求两点间距离，无向图求两点间距离，倍增
zxy160的博客
01-20 877
LCA就是求公共祖先。优质博客推荐 但是不推荐它的伪代码，感觉思路没错，但是有点问题。 我随手写了一个，有错欢迎之处 int get(int u) { if(f[u]==u) return u; else f[u]=get(f[u]); } void dfs(int u,int pre) { //vis[u]=1;//位置1 for(int i=first...
KMP，找出s字符串在T字符中的位置，或有几个
zxy160的博客
01-25 682
优质博客推荐 hdu1711 #include #include #define mem(a,b) memset(a,b,sizeof(a)) int a[1000005]; int b[10005]; int nex[10005]; int n,m; void KMP() { mem(nex,0); nex[0]=-1; int i=0,k=-1; whi
java大数a+b
zxy160的博客
03-16 670
hdu1000 import java.util.Scanner;//输入 import java.math.BigInteger;//大整数类 import java.math.BigDecimal;//大浮点数类 public class Main { public static void main(String[] args) { Scanner s=new S...
逆序数 poj2299 Ultra-QuickSort
zxy160的博客
03-22 528
Ultra-QuickSort Time Limit: 7000MS Memory Limit: 65536K Total Submissions: 59643 Accepted: 22101 Description In this problem, you have to analyze a particular sorting algorithm. The al
网络流算法板子
zxy160的博客
01-13 406
最大流：EK，FF，Dinic，ISAP。因为实现方法几乎差不多，记住最优的即可。 Dinic #include #include #include #include #include #include using namespace std; const int maxn=1000; const int inf=0x3f3f3f3f; #define LL long long stru
poj1847Tram （迪杰斯特拉和弗洛伊得）
zxy160的博客
01-17 378
Tram network in Zagreb consists of a number of intersections and rails connecting some of them. In every intersection there is a switch pointing to the one of the rails going out of the intersection. W
java大数a-b
zxy160的博客
03-16 360
百炼2736 import java.util.Scanner;//输入 import java.math.BigInteger;//大整数类 import java.math.BigDecimal;//大浮点数类 public class Main { public static void main(String[] args) { Scanner s=new Sc...
c++ 连通图与强连通图
11-18
连通图是指一个无向图中，任意两个顶点之间都存在一条路径的图。也就是说，从图中的任意一个顶点出发，可以通过边的连续遍历到图中的其他所有顶点。换句话说，在连通图中，任意两个顶点都是通过路径相连的。 而强...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值