边双连通 练习

最新推荐文章于 2023-01-11 19:17:16 发布
最新推荐文章于 2023-01-11 19:17:16 发布
阅读量323 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24664053/article/details/51319178
版权

点双连通：
Poj 3177
题意：给一个无向连通图求最少加几条边 变为一个边双联通的图(两个农场之间奶牛可以选择不止一条路)

用tarjan将原来的边双连通块缩点，然后找到叶子节点ans ，
加的边数= (ans+1)/2 ;

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;

const int MAXN = 200010;//点数
const int MAXM = 2000010;//边数，因为是无向图，所以这个值要*2

struct Edge
{
    int to,next;
    bool cut;//是否是桥标记
    bool cong;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//  Belong数组表示边属于哪一个连通块
int Index,top;
bool Instack[MAXN];
//bool cut[MAXN];    //自然用来存割点
//int add_block[MAXN];  // 删除一个点后增加的连通块数
int bridge;//桥的数目
int block; //边双连通块数量

void addedge(int u,int v)
{
    edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut=false;
    head[u] = tot++;
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
//    int son=0;    //  统计某个点在搜索树中的儿子个数
    for(int i = head[u];i != -1;i = edge[i].next)
    {
        v = edge[i].to;
        if(v == pre )continue;
        if( !DFN[v] )
        {
//          son++;
            Tarjan(v,u);
            if( Low[u] > Low[v] )  Low[u] = Low[v];

            //一条边 (u,v)是桥，当且仅当(u,v)为树枝边(u,v都在栈里面),且满足DFN(u)<Low(v)
            if(Low[v] > DFN[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i^1].cut = true;   //因为是无向图，自然增加了两条边
            }
            //割点
            //一个顶点u是割点，当且仅当满足（1）或者(2);  （1）u为树根,且u有多于一个子树。
            //（2）u不为树根，且满足存在(u,v)为树枝边（u为v在搜索树中的父亲），使DFS(u)<=Low(v)
//            if(u!=pre && Low[v] >= DFN[u]){
//                 cut[u] =true;
//                 add_block[u]++;
//            }
        }
        else if( Instack[v] && Low[u] > DFN[v] )
            Low[u] = DFN[v];
    }
    //数根，分支数>1
//    if(u== pre && son>1 )  cut[u]=true;
//    if(u== pre)  add_block[u]=son-1;
    // 进行边双连通操作
    if(Low[u]==DFN[u]){
        block++;
        do
        {
            v= Stack[--top];
            Instack[v]=false;
            Belong[v]=block;
        }
        while(v!=u);
    }
}
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
int du[MAXN]; //缩点后形成的树，每个点的度数
void solve(int n){
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
//    memset(add_block,0,sizeof(add_block) );
//    memset(cut,false,sizeof(cut) );
    Index=top=block=bridge=0;
    for(int i=1;i<=n;i++)
        if(!DFN[i])
           Tarjan(i,0);
    int ans=0;
    memset(du,0,sizeof(du));
    for(int i=1;i<=n;i++)
        for(int j=head[i];j!=-1;j=edge[j].next){
            if(edge[j].cut){
                du[Belong[i]]++;
            }
        }
    for(int i=1;i<=block;i++)
        if(du[i]==1){ //子树中有一 条桥，所以为叶子节点
            ans++;
//           printf("edge= %d\n",i);
        }
    //找出叶子节点的个数ans，构造边双连通图 最少需要加边 （ans+1）/2
    //不会证明，可能是因为智商不够
    printf("%d\n",(ans+1)/2); //
}
int main(){
    int n,m;
    //freopen("1.txt","r",stdin);
    while(~scanf("%d %d",&n,&m)){
        init();
        int u,v;
        for(int i=0;i<m;i++){
            scanf("%d %d",&u,&v);
            addedge(u,v);
            addedge(v,u);
        }
        solve(n);
    }
    return 0;
}

Hdu 4612
题意: 求添加一条边之后，可以获得的最小的桥的数量
原文：Note that there could be more than one channel between two planets.

题目需要找到：找树的最长路（直径），因为我们只能添加一条边肯定只能形成一个环，所以要除掉最多的桥，边双联通缩点之后的树的直径 首位添加一条边，必然就能去掉最多的桥！

！！！！如何找树的直径:
树的直径（最长路） 的详细证明
主要是利用了反证法：
假设 s-t这条路径为树的直径，或者称为树上的最长路
方法1
现有结论，从任意一点u出发搜到的最远的点一定是s、t中的一点，然后在从这个最远点开始搜，就可以搜到另一个最长路的端点，即用两遍广搜就可以找出树的最长路
则dis(u,T)+dis(s,X)+dis(u,X)>dis(s,X)+dis(X,t)=dis(s,t)最长路不是s-t矛盾

方法2
树的直径的长度一定会是某个点的最长距离f[i]与次长距离g[i]之和。最后求出max{f[i]+g[i]}就可以了

这个题最麻烦的是这个重边的解决！！！ 我用双重map 居然会超内存是最骚的。
但看不懂那个并且&&:
因为
首先，如果是|| ，那么这个图会跑不了tarjan，因为这个桥这里会断掉

输进去的图只有重边是false，其他都是true，而在判断桥的时候，若产生重边，则 还是不太懂？

/*
 可以将所有的边双连通分支找出来;
 每一个连通分支里面的点（即将边双连通分支缩点）
 最后找出 变为边双连通图最少加几条边

 这个模板题目原型的 图 是联通的，我感觉并不适用于不连通图！  如果原图不连通还需要在思考
 */
#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;

const int MAXN = 200005;//点数
const int MAXM = 2000005;//边数，因为是无向图，所以这个值要*2

struct Edge
{
    int to,next;
    bool cut;//是否是桥标记
    bool chong;
}edge[MAXM];

int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN];
int Index,top;
bool Instack[MAXN];
int bridge;//桥的数目
int block; //边双连通块数量


void addedge(int u,int v,bool aa)
{
    edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut=false;edge[tot].chong=aa;
    head[u] = tot++;
}
void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
//    int son=0;    //  统计某个点在搜索树中的儿子个数
    for(int i = head[u];i != -1;i = edge[i].next)
    {
        v = edge[i].to;
        if(v == pre && edge[i].chong==0) continue;  //?为什么是&&？
        if( !DFN[v] )
        {
//            son++;
            Tarjan(v,u);
            if( Low[u] > Low[v] )  Low[u] = Low[v];

            //一条边 (u,v)是桥，当且仅当(u,v)为树枝边(u,v都在栈里面),且满足DFN(u)<Low(v)
            if(Low[v] > DFN[u] ) //且不能为重边
            {
                bridge++;
                edge[i].cut = true;
                edge[i^1].cut = true;   //因为是无向图，自然增加了两条边
            }
            //割点
            //一个顶点u是割点，当且仅当满足（1）或者(2);  （1）u为树根,且u有多于一个子树。
            //（2）u不为树根，且满足存在(u,v)为树枝边（u为v在搜索树中的父亲），使DFS(u)<=Low(v)
//            if(u!=pre && Low[v] >= DFN[u]){
//                 cut[u] =true;
//                 add_block[u]++;
//            }
        }
        else if( Instack[v] && Low[u] > DFN[v] )
            Low[u] = DFN[v];
    }
    //数根，分支数>1
//    if(u== pre && son>1 )  cut[u]=true;
//    if(u== pre)  add_block[u]=son-1;
    // 进行边双连通操作
    if(Low[u]==DFN[u]){
        block++;
        do
        {
            v= Stack[--top];
            Instack[v]=false;
        }
        while(v!=u);
    }
}
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
int dis[MAXN];
int  vis[MAXN];
void bfs(int u){
    vis[u]=1;
    for(int i = head[u];i != -1;i = edge[i].next){
        int v=edge[i].to;
        if(vis[v]) continue;

        if(edge[i].cut){
            dis[v]=dis[u]+1;
            bfs(v);
        }
        else{ //讲道理这里应该处理一下
            dis[v]=dis[u];
            bfs(v);
        }
    }
}
void solve(int n){
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(dis,0,sizeof(dis));
    memset(vis,0,sizeof(vis));
//    memset(add_block,0,sizeof(add_block) );
//    memset(cut,false,sizeof(cut) );
    Index=top=block=bridge=0;
    for(int i=1;i<=n;i++)
        if(!DFN[i])
           Tarjan(i,0);
    bfs(1);
    int sta;
//    printf("bri=%d \n",bridge);
    int maxn=dis[1];
    for(int i=1;i<=n;i++){
//        printf("%d ",dis[i]);
        if(dis[i]>maxn){
            sta=i;
            maxn=dis[i];
        }
    }
    memset(dis,0,sizeof(dis));
    memset(vis,0,sizeof(vis));
    bfs(sta);
    maxn=dis[1];
    for(int i=1;i<=n;i++){
        if(dis[i]>maxn){
            maxn=dis[i];
        }
    }
    printf("%d\n",bridge-maxn);
}
struct Node
{
    int u,v;
}node[MAXM];
bool cmp(Node a,Node b)
{
    if(a.u != b.u)return a.u<b.u;
    else return a.v<b.v;
}
int main(){
    int n,m;
    //freopen("1.txt","r",stdin);
    while(~scanf("%d %d",&n,&m) &&(n||m) ){
        init();
        int u,v;
        for(int i=0;i<m;i++){
            scanf("%d %d",&u,&v);
            if(v<u) swap(u,v);
            node[i].u=u;
            node[i].v=v;
        }
        sort(node,node+m,cmp);
        for(int i = 0;i < m;i++){
            if(i == 0 || (node[i].u!=node[i-1].u || node[i].v != node[i-1].v)) {
                 if(i < m-1 && (node[i].u==node[i+1].u && node[i].v == node[i+1].v)){
                       addedge(node[i].u,node[i].v,true);
                       addedge(node[i].v,node[i].u,true);
                 }
                 else{
                       addedge(node[i].u,node[i].v,false);
                       addedge(node[i].v,node[i].u,false);
                }
           }
        }
        solve(n);
    }
    return 0;
}
yuhaoyuan……
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
边双联通分量
ACTerminate的博客
11-02 994
首先什么是边双联通分量？ 边双连通分量是指，在“无向图”中删除任意一条边依旧联通的联通块 之前讲过强连通分量，这里边双联通分量的做法也需要利用tarjan算法获得边双联通分量。 对于边双联通分量中还有一个概念，就是桥。 桥指的是 删除该边图不再连通。 对应的另一个概念是 割点 割点的的是 如果除去此节点和与其相关的边，图不再连通。 对于以下的图 我们跑一边tarja
双连通分量
10-16 6603
[点连通度与边连通度]       在一个无向连通图中，如果有一个顶点集合，删除这个顶点集合，以及这个集合中所有顶点相关联的边以后，原图变成多个连通块，就称这个点集为割点集合。一个图的点连通度的定义为，最小割点集合中的顶点数。         类似的，如果
边双连通
cj1064789374的博客
01-09 336
边双连通 边双连通分量（图）：去掉任一边，剩下点依然连通……每个点度数都要为2，不存在桥 点双连通分量（图）：去掉任一点，乘下点依然连通……不存在割点 poj3352(边双连通分量) 题意：给一个无向连通图，至少添加几条边使得去掉图中任意一条边不改变图的连通性（即使得它变为边双连通图）。 思路：tarjan求双连通分量，然后缩点，缩点后的图是一个树形图，在其中寻找度为1的节点，设有x个，答案就...
HDU - 2242（边双连通）
scau_cdx的博客
05-01 384
题目： 众所周知，HDU的考研教室是没有空调的，于是就苦了不少不去图书馆的考研仔们。Lele也是其中一个。而某教室旁边又摆着两个未装上的空调，更是引起人们无限YY。 一个炎热的下午，Lele照例在教室睡觉的时候，竟然做起了空调教室的美梦。 Lele梦到学校某天终于大发慈悲给某个教室安上了一个空调。而且建造了了M条通气管道，让整个教学楼的全部教室都直接或间接和空调教室连通上，构成了教室群，于是...
无向图边双连通分量
weixin_34248705的博客
08-31 81
第一遍DFS找出所有桥，第二遍DFS，给边连通分量标号。 模板： #include <bits/stdc++.h> using namespace std; const int maxn = 20005; int dfn[maxn],low[maxn],tot; vector<int> g[maxn]; bool isB[maxn][ma...
数据结构练习题
03-03
### 数据结构练习题知识点解析 #### 一、简答题知识点解析 **1. 什么是有根的有向图？** - **定义**：有根的有向图是指一个有向图，其中一个特定的节点被指定为根节点。在这个图中，每条边都有方向，指向表明了...
2015年数据结构练习题
04-16
本篇内容主要围绕2015年的数据结构考研练习题，涉及了链表、单链表、双链表、循环链表、循环双链表等核心概念及其操作。 1. **顺序表与链表的比较**： - 顺序表：存储空间连续，访问速度快，插入和删除操作需要...
数据结构各章练习
05-28
- 树的基本概念，如节点、边、根、子树、分支等。 - 二叉树的性质，如高度、完全二叉树和满二叉树的概念。 - 二叉树的遍历方法：前序、中序和后序遍历，以及层次遍历。 - 树的查找、插入和删除操作，以及平衡树...
ENSP静态路由配置练习
最新发布
03-06
我们将通过一个名为"ENSP静态路由配置练习"的实践场景，学习如何在华为路由器上配置静态路由，以及如何检查和验证其有效性。 首先，了解静态路由的基本配置命令。在华为路由器上，配置静态路由的命令是： ```shell...
边双连通分支模板
maze_illusion的博客
09-03 242
int tol,head[maxn]; struct edge { int to,next; bool cut; }es[maxm]; void addedge( int u , int v ) { es[tol].to = v; es[tol].next = head[u]; es[tol].cut = false; head[u] = tol+...
边双连通分支
From2016cxg
08-01 287
/* 求边双连通分支：跑一遍求割点与桥的Tarjan得到该图的割点和桥，去掉桥，其余连通分支就是边连通分支了，边连通分支数是桥数+1。 边连通分支就是去掉最少两条边才能将该图划分为两个部分的图，桥就是一个图被去掉一条边就能变成两个子图的那一条边， 构造边双连通分支： 把双连通子图收缩为一个点，形成一个树，需要加边数量是（leaf+1）
我的 边双连通 模板
cyhbyw的专栏
04-04 698
题目：http://poj.org/problem?id=3352 题意：一个连通的无向图，至少需要添加多少条边才能变成边双连通的。 分析：Tarjan缩点之后是一棵树，最终的答案就是树中的叶子节点的数量加1除以2。 题目：http://poj.org/problem?id=3352 题意：一个连通的无向图，至少需要添加多少条边才能变成边双连通的。 分析：Tarjan缩点之后是一棵树，最
[POJ3177]Redundant Paths 边双连通分量 做题笔记
mhlwsk的博客
03-08 845
题目来源：http://poj.org/problem?id=3177 解题思路：http://www.cnblogs.com/frog112111/p/3367039.html 分析：在同一个边双连通分量中，任意两点都有至少两条独立路可达，所以同一个边双连通分量里的所有点可以看做同一个点。 缩点后，新图是一棵树，树的边就是原无向图的桥。 现在问题转化为：在树中至少添加多少
POJ3352 Road Construction——边双连通分量（tarjan+缩点）
lllllan
08-25 305
点这里 题意： 给定一个无向图G，图中没有重边。问添加几条边才能使无向图变成边双连通图。 题解： 缩点。 方法参考双连通分量。 过程中犯的错： ans计数： 程序里tarjan函数里有一行批成注释代码，那是错误的。 #include<iostream> #include<algorithm> #include<vector> using namespace std; const int N = 1e3 + 10; int n, m, dfn, low[N]; v
边双连通分量
WQhuanm的博客
01-11 787
相对于在单向图的强连通分量，双连通分量是在无向图中，无向图有一个特点，可以以任何一个点为根节点建dfs树割边（桥）：删去一条边，会增加图中的强连通分量（即可以使原来连通的部分变成两半（不连通））割点 ：同理割边，不过是删边如果删去一条边，仍然无法使不连通，说明是边双连通，点就是点双连通边，点写法几乎一致，此处介绍边双连通。
割点、桥、点双连通、边双连通、强连通 题目
fsdcyr
04-30 587
强连通： HDU2767.Proving Equivalences http://acm.hdu.edu.cn/showproblem.php?pid=2767 UVA11324.The Largest Clique http://www.bnuoj.com/v3/problem_show.php?pid=19742 点双连通： HDU3394.Railway http://acm.hdu.e
无向图的双连通块(点的双连通)&&边的双连通算法
weixin_30617737的博客
07-23 176
无向图的双连通块 题目描述 给出一个无向图，求其中双连通块的个数以及其中最大的双连通块。 输入 第1行：2个整数n和m，n表示图的结点个数，m表示图中边的数量 (1<=n<=100000, 1<=m<=1000000) 接下来m行，每行2个整数，表示一条边 输出 第1行：1个整数，表示整个图中双连通块的数量 第2行：1个整数，表示整个图中...
tarjan--边双连通分量
灰色的人的博客
03-01 1012
引入 所谓边双联通分量，其实有点像割边+强联通分量，做法是： 1求出桥 2dfs一遍，并且不经过桥，这样刚好把图分成了几个边双联通分量。 例题 [USACO06JAN]冗余路径Redundant Paths 分析 我们先用tarjan求出边双连通分量，那么每个边双连通分量中任意两点一定不止一条路（没有桥）， 那么如果两个点不在同一个边双连通分量里呢？ 这时我们就需要建边了，而在哪个边双连通分量里...
poj3352(边双连通分量)
yypurpose的博客
02-06 501
Road Construction Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 12818   Accepted: 6479 Description It's almost summer time, and that means that it's almo
计算机网络基础练习题及答案解析
1. ping命令是网络诊断中常用的工具，它的作用是通过发送ICMP回显请求报文来测试两台主机之间的连通性。选项B正确地解释了ping192.168.0.2的作用。 2. 拨号接入因特网通常需要调制解调器（Modem），它能够将数字...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值