[Luogu P2860] [BZOJ 1718] [USACO06JAN]冗余路径Redundant Paths

洛谷传送门

BZOJ传送门

题目描述

为了从$F(1\le F\le 5000)$个草场中的一个走到另一个，贝茜和她的同伴们有时不得不路过一些她们讨厌的可怕的树．奶牛们已经厌倦了被迫走某一条路，所以她们想建一些新路，使每一对草场之间都会至少有两条相互分离的路径，这样她们就有多一些选择．

每对草场之间已经有至少一条路径．给出所有$R(F-1\le R\le 10000)$条双向路的描述，每条路连接了两个不同的草场，请计算最少的新建道路的数量, 路径由若干道路首尾相连而成．两条路径相互分离，是指两条路径没有一条重合的道路．但是，两条分离的路径上可以有一些相同的草场． 对于同一对草场之间，可能已经有两条不同的道路，你也可以在它们之间再建一条道路，作为另一条不同的道路．

注：给定的路径如有重复的算为一条！！

输入输出格式

输入格式

第一行两个正整数$n,m$。

以下$m$行， 每行两个正整数$a_i,b_i$， 表示编号为$a_i$和$b_i$的草场之间有一条无向边。

输出格式

一行一个整数， 表示最少需要添加的路径数。

输入输出样例

输入样例#1：

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

输出样例#1：

2

解题分析

先缩边双， 同一个边双内肯定是满足条件的。

然后这个图就变成了一棵树。 发现问题在叶节点上面： 我们肯定需要连接两个叶节点使其可以在一个环内。

那么这个下限是多少？ 实际上设叶节点个数为$k$， 答案就是$\lceil \frac{k}{2}\rceil$。

这是因为我们总可以找到一个点作为根节点， 使其最大的一棵子树大小$\le \lceil \frac{k}{2}\rceil$。

然后我们就可以保证存在至少一种方案， 每次选取的两个点连成环之后会经过这个根节点， 这样再缩边双后就等于消去了两个叶节点。

代码如下：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <map>
#include <algorithm>
#define R register
#define IN inline
#define W while
#define gc getchar()
#define ll long long
#define MX 10050
template <class T>
IN void in(T &x)
{
	x = 0; R char c = gc;
	for (; !isdigit(c); c = gc);
	for (;  isdigit(c); c = gc)
	x = (x << 1) + (x << 3) + c - 48;
}
template <class T> IN T max(T a, T b) {return a > b ? a : b;}
template <class T> IN T min(T a, T b) {return a < b ? a : b;}
int n, m, tot, cnt, top, col, ecnt;
struct E {int from, to;} e[MX];
IN bool operator < (const E &x, const E &y)
{return x.from == y.from ? x.to < y.to : x.from < y.from;}
struct Edge {int to, nex;} edge[MX << 1];
int head[MX], dfn[MX], low[MX], bel[MX], sta[MX], deg[MX];
IN void add(R int from, R int to)
{edge[++cnt] = {to, head[from]}, head[from] = cnt;}
std::map <E, bool> mp;
void DFS(R int now, R int fa)
{
	dfn[now] = low[now] = ++tot;
	sta[++top] = now;
	for (R int i = head[now]; i; i = edge[i].nex)
	{
		if (edge[i].to == fa) continue;
		if (!dfn[edge[i].to])
		{
			DFS(edge[i].to, now);
			low[now] = min(low[now], low[edge[i].to]);
		}
		else low[now] = min(low[now], dfn[edge[i].to]);
	}
	if (dfn[now] == low[now])
	{
		bel[now] = ++col;
		W (sta[top] ^ now) bel[sta[top--]] = col;
		--top;
	}
}
int main(void)
{
	in(n), in(m); int foo, bar, ans = 0;
	for (R int i = 1; i <= m; ++i)
	{
		in(foo), in(bar);
		if (foo > bar) std::swap(foo, bar);
		if (mp[{foo, bar}]) continue;
		mp[{foo, bar}] = true;
		add(foo, bar), add(bar, foo), e[++ecnt] = {foo, bar};
	}
	for (R int i = 1; i <= n; ++i) if (!dfn[i]) DFS(i, 0);
	for (R int i = 1; i <= ecnt; ++i)
	if (bel[e[i].from] ^ bel[e[i].to]) ++deg[bel[e[i].from]], ++deg[bel[e[i].to]];
	for (R int i = 1; i <= col; ++i) if (deg[i] == 1) ++ans;
	printf("%d", ans + 1 >> 1);
}