【NOIp模拟赛】兔子

【问题描述】

在一片草原上有N个兔子窝，每个窝里住着一只兔子，有M条路径连接这些窝。更特殊地是，至多只有一个兔子窝有3条或更多的路径与它相连，其它的兔子窝只有1条或2条路径与其相连。换句话讲，这些兔子窝之前的路径构成一张N个点、M条边的无向连通图，而度数大于2的点至多有1个。

兔子们决定把其中K个兔子窝扩建成临时避难所。当危险来临时，每只兔子均会同时前往距离它最近的避难所躲避，路程中花费的时间在数值上等于经过的路径条数。为了在最短的时间内让所有兔子脱离危险，请你安排一种建造避难所的方式，使最后一只到达避难所的兔子所花费的时间尽量少。

 

【输入】

         第一行有3个整数N，M，K，分别表示兔子窝的个数、路径数、计划建造的避难所数。

接下来M行每行三个整数x,y，表示第x个兔子窝和第y个兔子窝之间有一条路径相连。任意两个兔子窝之间至多只有1条路径。

 

【输出】

一个整数，表示最后一只到达避难所的兔子花费的最短时间。

 

【输入输出样例1】

rabbit.in	rabbit.out
5 5 2 1 2 2 3 1 4 1 5 4 5	1

         见选手目录下的rabbit / rabbit1.in与rabbit / rabbit1.out

 

【输入输出样例1说明】

         在第2个和第5个兔子窝建造避难所，这样其它兔子窝的兔子最多只需要经过1条路径就可以到达某个避难所。

 

【输入输出样例2】

         见选手目录下的rabbit / rabbit2.in与rabbit / rabbit2.out

 

【数据规模与约定】

         对于30%的数据，N≤15，K≤4；

         对于60%的数据，N≤100；

         对于100%的数据，1≤K≤N≤1,000，1≤M≤1,500

分析

30分，暴力搜索，只要枚举避难所的地址就行了。

100分，乍一看无从下手，题目上说“至多只有一个兔子窝有3条或更多的路径与它相连”，我觉得题目描述有点问题，题目上说是至多有1个，而按照题解里面是必有一个，但不管怎么样这一个就是切入点。假如设这个点为A点，那么我们可以枚举A点的兔子去的避难所，那么这个点就可以不管了。其它点的入读都是小于等于2的，这就是说如果把这个点去掉剩下的要么是环要么是链，这样就可以计算避难所的 个数了。二分枚举一下最短时间，看最短时间的避难所个数是否<=题目上给的个数。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1000+5;
const int maxm=1500+5;
inline int read()
{
    int x=0,f=1; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1; ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}
int n,m,num,k,root,cnt,tmp;
int head[maxn],du[maxn];
bool vis[maxn];
struct node
{
    int next,to;
}e[maxm<<1];
struct road
{
    int len;
    bool circle;
}d[maxn];
inline void add(int from,int to)
{
    e[++num].next=head[from];
    e[num].to=to;
    head[from]=num;
}
void dfs(int x)
{
    vis[x]=1; d[cnt].len++;
    for(int i=head[x];i;i=e[i].next)
    {
        if(!vis[e[i].to]) dfs(e[i].to);
        if(e[i].to==root&&x!=tmp) d[cnt].circle=1;
    }
}
int calc(int len,int x)
{
    if(len<=0) return 0;
    return (len-1)/(x*2+1)+1;
}
bool pd(int x)
{
    int minn=n;
    for(int i=1;i<=cnt;i++)
    {
        for(int j=0;j<=d[i].len&&j<=x;j++)
        {
            int tot=0;
            if(!d[i].circle) tot=calc(d[i].len-j-x,x);
            else tot=calc(d[i].len-j-x+(j-x),x);
            tot++;
            for(int p=1;p<=cnt;p++)
            if(p!=i)
            {
                if(!d[p].circle) tot+=calc(d[p].len+(j-x),x);
                else tot+=calc(d[p].len+2*(j-x),x);
            }
            minn=min(minn,tot);
        }
    }
    return minn<=k;
}
int main()
{
    freopen("rabbit.in","r",stdin);
    freopen("rabbit.out","w",stdout);
    n=read(); m=read(); k=read();
    int x,y;
    for(int i=1;i<=m;i++)
    {
        x=read(); y=read();
        add(x,y); add(y,x);
        du[x]++; du[y]++;
    }
    for(int i=1;i<=n;i++)
        if(du[i]>2){root=i; break;}
    vis[root]=1;
    for(int i=head[root];i;i=e[i].next)
    if(!vis[e[i].to])
    {
        tmp=e[i].to;//这是一个比较坑爹的地方，用来判环，
//本来一个vis数组就可以完成判环，但是如果这条链只有一个节点，也会被认为是环
        cnt++;
        d[cnt].circle=0;
        d[cnt].len=0;
        dfs(e[i].to);
    }
    int l=0,r=n,ans;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(pd(mid)){ans=mid; r=mid-1;}
        else l=mid+1;
    }
    printf("%d\n",ans);
    return 0;
}