题目传送门


题目描述

  为了从F个草场中的一个走到另一个,贝茜和她的同伴们有时不得不路过一些她们讨厌的可怕的树.奶牛们已经厌倦了被迫走某一条路,所以她们想建一些新路,使每一对草场之间都会至少有两条相互分离的路径,这样她们就有多一些选择。
  每对草场之间已经有至少一条路径.给出所有R条双向路的描述,每条路连接了两个不同的草场,请计算最少的新建道路的数量, 路径由若干道路首尾相连而成.两条路径相互分离,是指两条路径没有一条重合的道路.但是,两条分离的路径上可以有一些相同的草场. 对于同一对草场之间,可能已经有两条不同的道路,你也可以在它们之间再建一条道路,作为另一条不同的道路。


输入格式

第1行输入F和R,接下来R行,每行输入两个整数,表示两个草场,它们之间有一条道路。


输出格式

最少的需要新建的道路数。


样例

样例输入:

7 7
1 2
2 3
3 4
2 5
4 5
5 6
5 7

样例输出:

2


数据范围与提示

图中实线表示已有的道路,虚线表示新建的两条道路。

现在可以检验一些路径,比如:

草场1和草场2:1→2和1→6→5→2。

草场1和草场4:1→2→3→4和1→6→5→4。

草场3和草场7:3→4→7和3→2→5→7。

         事实上,每一对草场之间都连接了两条分离的路径。

1≤F≤5000,F-1≤R≤10000。

注意会有重边!!!


题解

看到这道题,马上想到了塔尖,缩e-DCC。

然后答案即为得到的$\frac{这棵树上的叶子节点的个数+1}{2}$,利用性质,连边为1的点即为叶子节点,统计答案即可。

代码细节较多,建议尝试自己根据自己的理解手打。

当然也有大神缩v-DCC,直接A掉。

还有这么一种解法,塔尖之后不用重新建图,而是直接判断在一条边两端的点low的值是否相同,如果不同那么就让度数+1。(他们的塔尖通过在一开始直接判断e.to是否等于father,如果相等直接continue)。

但是这样并不正确!!!

考虑这道题会有重边,所以如果low[x]≠low[y],但是它们还可能属于一个强联通分量。

不过如果你使用了可以规避重边的方法,那么就没有问题。

综上所述,板子要理解,并能灵活运用!!!


代码时刻

e-DCC

#include<bits/stdc++.h>
using namespace std;
struct rec
{
int from;
int nxt;
int to;
}e[200010],wzc[200010];
int head[5010],cnt=1;
int headw[5010],cntw=1;
int F,R;
int dfn[5010],low[5010],tot;
bool bridge[200010];
int c[5010],dcc;
int ans[5010];
int sum;
bool vis[5010];
void add(int x,int y)
{
e[++cnt].nxt=head[x];
e[cnt].from=x;
e[cnt].to=y;
head[x]=cnt;
}
void tarjan(int x,int in_edge)//判断桥
{
dfn[x]=low[x]=++tot;
for(int i=head[x];i;i=e[i].nxt)
{
if(!dfn[e[i].to])
{
tarjan(e[i].to,i);
low[x]=min(low[x],low[e[i].to]);
if(dfn[x]<low[e[i].to])
bridge[i]=bridge[i^1]=1;
}
else if(i!=(in_edge^1))
low[x]=min(low[x],dfn[e[i].to]);
}
}
void dfs(int x)//求e-DCC
{
c[x]=dcc;
for(int i=head[x];i;i=e[i].nxt)
{
if(c[e[i].to]||bridge[i])continue;
dfs(e[i].to);
}
}
int main()
{
scanf("%d%d",&F,&R);
for(int i=1;i<=R;i++)
{
int x,y;
scanf("%d%d",&x,&y);
add(x,y);
add(y,x);
}
for(int i=1;i<=F;i++)
if(!dfn[i])tarjan(i,0);
for(int i=1;i<=F;i++)
if(!c[i])
{
++dcc;
dfs(i);
}
for(int i=2;i<=cnt;i++)//开始计算答案
if(c[e[i].from]!=c[e[i].to])ans[c[e[i].from]]++;
for(int i=1;i<=dcc;i++)
if(ans[i]==1)sum++;
printf("%d",(sum+1)/2);
return 0;
}

v-DCC

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
int const maxn=5010;
struct node{int st,to,nxt;}l[4*maxn];
vector<int>v[maxn];
int n,m,head[maxn],tot,num,in[maxn*2],ans;
int dfn[maxn],low[maxn],stack[maxn],bl[maxn*2],id[maxn*2],cut[maxn*2],top,now,cnt,rt;
void add1(int x,int y)
{
l[++tot].to=y;
l[tot].st=x;
l[tot].nxt=head[x];
head[x]=tot;
}
void tarjan(int x)//割点
{
dfn[x]=low[x]=++now,stack[++top]=x;
if(x==rt&&head[x]==0)
{
v[++cnt].push_back(x);
bl[x]=cnt;
return ;
}
int flag=0;
for(int i=head[x];i;i=l[i].nxt)
{
int y=l[i].to;
if(!dfn[y])
{
tarjan(y);
low[x]=min(low[x],low[y]);
if(low[y]>=dfn[x])
{
flag++;
if(x!=rt||flag>1) cut[x]=1;
cnt++;int z;
do{
z=stack[top--];
v[cnt].push_back(z);
bl[z]=cnt;
}while(y!=z);
v[cnt].push_back(x);
}
}
else low[x]=min(low[x],dfn[y]);
}
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1,x,y;i<=m;i++)
{
scanf("%d%d",&x,&y);
add1(x,y),add1(y,x);
}
for(int i=1;i<=n;i++) if(!dfn[i]) rt=i,tarjan(i);
num=cnt;
for(int i=1;i<=n;i++) if(cut[i]) id[i]=++num;
for(int i=1;i<=cnt;i++)
for(int j=0;j<v[i].size();j++)
if(cut[v[i][j]]) in[i]++;
for(int i=1;i<=cnt;i++) if(in[i]==1) ans++;
printf("%d",(ans+1)/2);
return 0;
}

rp++

[BZOJ1718]:[Usaco2006 Jan] Redundant Paths 分离的路径(塔尖)的更多相关文章

  1. BZOJ1718 [Usaco2006 Jan] Redundant Paths 分离的路径

    给你一个无向图,问至少加几条边可以使整个图变成一个双联通分量 简单图论练习= = 先缩点,ans = (度数为1的点的个数) / 2 这不是很好想的么QAQ 然后注意位运算的优先级啊魂淡!!!你个sb ...

  2. BZOJ1718: [Usaco2006 Jan] Redundant Paths 分离的路径【边双模板】【傻逼题】

    LINK 经典傻逼套路 就是把所有边双缩点之后叶子节点的个数 //Author: dream_maker #include<bits/stdc++.h> using namespace s ...

  3. BZOJ 1718: [Usaco2006 Jan] Redundant Paths 分离的路径( tarjan )

    tarjan求边双连通分量, 然后就是一棵树了, 可以各种乱搞... ----------------------------------------------------------------- ...

  4. [Usaco2006 Jan] Redundant Paths 分离的路径

    1718: [Usaco2006 Jan] Redundant Paths 分离的路径 Time Limit: 5 Sec  Memory Limit: 64 MBSubmit: 1132  Solv ...

  5. BZOJ 1718: [Usaco2006 Jan] Redundant Paths 分离的路径

    Description 给出一个无向图,求将他构造成双连通图所需加的最少边数. Sol Tarjan求割边+缩点. 求出割边,然后缩点. 将双连通分量缩成一个点,然后重建图,建出来的就是一棵树,因为每 ...

  6. 【BZOJ】1718: [Usaco2006 Jan] Redundant Paths 分离的路径

    [题意]给定无向连通图,要求添加最少的边使全图变成边双连通分量. [算法]Tarjan缩点 [题解]首先边双缩点,得到一棵树(无向无环图). 入度为1的点就是叶子,两个LCA为根的叶子间合并最高效,直 ...

  7. bzoj 1718: [Usaco2006 Jan] Redundant Paths 分离的路径【tarjan】

    首先来分析一下,这是一张无向图,要求没有两条路联通的点对个数 有两条路连通,无向图,也就是说,问题转化为不在一个点双连通分量里的点对个数 tarjan即可,和求scc还不太一样-- #include& ...

  8. 【bzoj1718】Redundant Paths 分离的路径

    1718: [Usaco2006 Jan] Redundant Paths 分离的路径 Time Limit: 5 Sec  Memory Limit: 64 MBSubmit: 964  Solve ...

  9. Redundant Paths 分离的路径【边双连通分量】

    Redundant Paths 分离的路径 题目描述 In order to get from one of the F (1 <= F <= 5,000) grazing fields ...

随机推荐

  1. Java第二周总结报告

    第二周的学习,开始正式实践进行Java的学习. 本周做了什么? 了解的Java的一些基本知识,如Java变量,数据类型和运算符等.Java变量对不同的数据类型最好采用不同的命名规则,合理的命名有利于提 ...

  2. python-day13(正式学习)

    闭包函数 闭包 闭包:闭是封闭(函数内部函数),包是包含(该内部函数对外部作用域而非全局作用域的变量的引用).闭包指的是:函数内部函数对外部作用域而非全局作用域的引用. 额...这里提示一下闭包!=自 ...

  3. Vue常用修饰符

    Vue提供了事件修饰符用于DOM的事件处理,常用的事件修饰符有以下几个: (1). stop:阻止冒泡(通俗讲就是阻止事件向上级DOM元素传递) 点击内层div的结果: 点击外层div的结果: 修改代 ...

  4. git 版本回退方法

    ORIG_HEAD 某些操作,例如 merage / reset 会把 merge 之前的 HEAD 保存到 ORIG_HEAD 中,以便在 merge 之后可以使用 ORIG_HEAD 来回滚到合并 ...

  5. window环境安装composer

    今天在下载symfony2的框架的时候,发现要用到composer,因为之前笔者完全没有接触过composer,所以研究了很久之后,才终于安装完成 由于网上有各种资料介绍如何安装composer的,但 ...

  6. 常用插件html

    1.上传模板,插件 https://github.com/kartik-v/bootstrap-fileinput 2.

  7. python中英文翻译模块

    从一种语言到另一种语言的文本翻译在各种网站中越来越普遍. 帮助我们执行此操作的python包称为translate. 可以通过以下方式安装此软件包. 它提供主要语言的翻译. 官网:https://py ...

  8. [project X] tiny210(s5pv210)上电启动流程(BL0-BL2)(转)

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明.本文链接:https://blog.csdn.net/ooonebook/article/det ...

  9. 上传图片,正在加载,loading

    https://blog.csdn.net/yansong_8686/article/details/50361573

  10. 通过shell监控网页是否正常,然后促发邮件告警

    最近在网上找了下通过shell编写一个脚本来监控网页是否正常,如果不正常则促发邮件告警,修复后有一个修复的通知邮件:但一直没有找到全面的,所以自己研究了下,写了一个linux对接邮箱和通过shell写 ...