LA 3902 网络

原是不会的，看了蓝皮书的分析，后自己实现了这个想法。
（不知怎的，连不上LA网站，所以这份代码是没有验证过。）
首先，我们知道将无根树转化为有根数是有利于解题的。而且容易发现服务器能覆盖到的用户都是可以忽略的（注意：非用户不忽略）。即本题可以转换成覆盖去掉服务器s能够覆盖到的用户之外的全部用户，最少需要多少服务器。

首先看深度最深的叶子节点，找到一个节点放置服务器，使之能覆盖该叶子节点（我们希望这个节点距离叶子节点足够远，想想为什么？）。

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int N=1005;
vector<int> depth[N],node[N];
int t;
int n,s,k;
int parent[N];
int num;
bool cover[N];
void init()
{
    num=0;
    memset(parent,-1,sizeof(parent));
    memset(cover,0,sizeof(cover));
    for(int i=0;i<n;i++)
    {
        node[i].clear();
        depth[i].clear();
    }
}
void DFS(int s,int f,int step)
{
    parent[s]=f;
    int len=node[s].size();
    if(step<=k&&len==1) cover[s]=1;
    if(len==1) depth[step].push_back(s);
    for(int i=0;i<len;i++)
    {
        if(node[s][i]!=f)
            DFS(node[s][i],s,step+1);
    }
}
void DFS2(int s,int f,int step)
{
    if(step>k) return;
    if(node[s].size()==1)
    {
        cover[s]=1;
        return;
    }
    int n=node[s].size();
    for(int i=0;i<n;i++)
    {
        if(node[s][i]!=f)
            DFS2(node[s][i],s,step+1);
    }
}
int solve()
{
    for(int i=n-1;i>k;i--)
    {
        int len=depth[i].size();
        for(int j=0;j<len;j++)
        {
            if(!cover[depth[i][j]])
            {
                int b=parent[depth[i][j]];
                int t=1;
                while(t<k&&parent[b]!=-1)
                {
                    t++;
                    b=parent[b];
                }
                num++;
                DFS2(b,-1,0);
            }
        }
    }
    return num;
}
int main()
{
    freopen("in.txt","r",stdin);
    cin>>t;
    while(t--)
    {
        cin>>n>>s>>k;
        init();
        for(int i=0;i<n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            node[a].push_back(b);
            node[b].push_back(a);
        }
        DFS(s,-1,0);
        cout<<solve()<<endl;
    }
    return 0;
}