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

n<=5000个点m<=10000条边的无向图,求最少加几条边使它变成边双联通图,就是任意两点间都有至少2条边不相交的路径。

tarjan缩点,答案是叶子节点数/2向上取整。

不过要注意这里的“叶子节点数”是指度数为1的点,并不是最后那棵树以某个点为根的叶子节点树。如果找叶子点数一定要以某个点为根,就会像我一样WA两次然后发现缩点后只有一个点时答案为0。

 1 #include<stdio.h>
 2 #include<string.h>
 3 #include<algorithm>
 4 #include<cstdlib>
 5 #include<math.h>
 6 //#include<iostream>
 7 using namespace std;
 8
 9 int n,m;
10 #define maxn 5011
11 #define maxm 20011
12 struct Edge{int to,next;};
13 struct Graph
14 {
15     Edge edge[maxm];
16     int first[maxn],le;int n;
17     Graph() {memset(first,0,sizeof(first));le=2;}
18     void in(int x,int y)
19     {
20         Edge &e=edge[le];
21         e.to=y;e.next=first[x];first[x]=le++;
22     }
23     void insert(int x,int y)
24     {
25         in(x,y);
26         in(y,x);
27     }
28     int low[maxn],dfn[maxn],Time,sta[maxn],top,bel[maxn],tot;bool insta[maxn];
29     void tarjan(int x,int fa)
30     {
31         low[x]=dfn[x]=++Time;
32         sta[++top]=x;insta[x]=1;
33         for (int i=first[x];i;i=edge[i].next)
34         {
35             Edge &e=edge[i];
36             if (!dfn[e.to]) tarjan(e.to,i),low[x]=min(low[x],low[e.to]);
37             else if ((i^1)!=fa && insta[e.to]) low[x]=min(low[x],dfn[e.to]);
38         }
39         if (low[x]==dfn[x])
40         {
41             tot++;
42             while (sta[top]!=x) bel[sta[top]]=tot,insta[sta[top--]]=0;
43             bel[x]=tot,insta[sta[top--]]=0;
44         }
45     }
46     void tarjan()
47     {
48         Time=tot=top=0;
49         memset(dfn,0,sizeof(dfn));
50         memset(insta,0,sizeof(insta));
51         for (int i=1;i<=n;i++) if (!dfn[i]) tarjan(i,0);
52     }
53     int dfs(int x,int fa)
54     {
55         int ans=0;
56         bool flag=1;
57         for (int i=first[x];i;i=edge[i].next)
58         {
59             Edge &e=edge[i];
60             if (e.to!=fa) ans+=dfs(e.to,x),flag=0;
61         }
62         ans+=flag;
63         return ans;
64     }
65     int ye()
66     {
67         int root=1;
68         for (int i=1;i<=n;i++) if (edge[first[i]].next) {root=i;break;}
69         return dfs(root,0);
70     }
71 }g,tg;
72 void build()
73 {
74     tg.n=g.tot;
75     for (int i=1;i<=g.n;i++)
76         for (int j=g.first[i];j;j=g.edge[j].next)
77         {
78             Edge &e=g.edge[j];
79             if (g.bel[i]!=g.bel[e.to]) tg.in(g.bel[i],g.bel[e.to]);
80         }
81 }
82 int x,y;
83 int main()
84 {
85     scanf("%d%d",&n,&m);g.n=n;
86     for (int i=1;i<=m;i++) scanf("%d%d",&x,&y),g.insert(x,y);
87     g.tarjan();
88     build();
89     printf("%d\n",tg.n==1?0:(tg.ye()+1)/2);
90     return 0;
91 }

时间: 2024-11-02 10:14:36

BZOJ1718: [Usaco2006 Jan] Redundant Paths 分离的路径的相关文章

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

tarjan求边双连通分量, 然后就是一棵树了, 可以各种乱搞... ------------------------------------------------------------------------------- #include<cstdio> #include<cstring> #include<algorithm> using namespace std; const int maxn = 5009; struct edge { int to; b

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

1718: [Usaco2006 Jan] Redundant Paths 分离的路径 Time Limit: 5 Sec  Memory Limit: 64 MB链接:https://www.lydsy.com/JudgeOnline/problem.php?id=1718 Description In order to get from one of the F (1 <= F <= 5,000) grazing fields (which are numbered 1..F) to an

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

Description 给出一个无向图,求将他构造成双连通图所需加的最少边数. Sol Tarjan求割边+缩点. 求出割边,然后缩点. 将双连通分量缩成一个点,然后重建图,建出来的就是一棵树,因为每一条边都是桥. 然后每次合并这棵树上的叶节点两点距离LCA最远的点,这样就会形成一个环,是双连通的,然后进行(ans+1)/2次操作就可以了. 其实就是(叶节点个数+1)/2 Code #include<cstdio> #include<vector> #include<iost

Redundant Paths 分离的路径(边双连通分量)

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

【BZOJ1718】&amp;&amp;【POJ3177】Redundant Paths

1718: [Usaco2006 Jan] Redundant Paths 分离的路径 Time Limit: 5 Sec  Memory Limit: 64 MBSubmit: 452  Solved: 239[Submit][Status][Discuss] Description In order to get from one of the F (1 <= F <= 5,000) grazing fields (which are numbered 1..F) to another f

洛谷P2860 [USACO06JAN]冗余路径Redundant Paths

题目描述 In order to get from one of the F (1 <= F <= 5,000) grazing fields (which are numbered 1..F) to another field, Bessie and the rest of the herd are forced to cross near the Tree of Rotten Apples. The cows are now tired of often being forced to t

Luogu2860 [USACO06JAN]冗余路径Redundant Paths

\(\verb|Luogu2860 [USACO06JAN]冗余路径Redundant Paths|\) 给定一个连通无向图,求至少加多少条边才能使得原图变为边双连通分量 \(1\leq n\leq5000,\ n-1\leq m\leq10^4\) tarjan 边双无疑不用考虑,于是就可以边双缩点成一棵树 令现在要连的边为 \((u,\ v)\) ,点集 \(\{u->lca(u,\ v),\ v->lca(u,\ v)\}\) 将会变为一个新的点双,可以将他们看为一个新的点 可以贪心地连

冗余路径 Redundant Paths e-DCC缩点

冗余路径 Redundant Paths 题目传送 sol: 如果两点间存在至少两条不重复的路径,这说明他们两点在同一个边双连通分量(不存在割边). 那么可以进行e-DCC的缩点,得到一棵树. 对于这棵树广泛意义上的叶子节点(度数为1)而言,都还至少需要一条边连向他. 那么可以贪心的一次连两个叶子节点,答案显然就是\(cnt+1>>1\). #include<bits/stdc++.h> #define IL inline #define RG register #define D

[USACO06JAN]冗余路径Redundant Paths(缩点)

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