UVALive 3902打卡

算法竞赛入门经典训练指南打卡

题目链接：UVALive 3902

思路

首先，我们可以将其转化为树状

可以看出我们只需要查看它的深度最大的节点，选择它的k级祖先，然后每放置一台服务器，进行dfs，将可以覆盖的节点全部覆盖掉
然后循环查找寻找深度最大的节点，放置服务器，覆盖这个操作即可
具体细节看代码注释

代码如下：

#include <iostream>
#include <vector>
#include <cstring>
using namespace std ;

const int max_n = 1010 ;
int n , s , k ;
vector<int> gr[max_n] , nodes[max_n] ;
vector<int> fa(max_n) ;
bool covered[max_n] ;

void dfs(int u , int f , int d){
    fa[u] = f ;
    int nc = gr[u].size() ;
    if(nc == 1 && d > k)
        nodes[d].push_back(u) ;     //与VOD服务器距离大于k且是叶子节点的记录下来，放入nodes[d]中
    for(int i = 0 ; i < nc ; ++ i){
        int v = gr[u][i] ;      //否则遍历与它相连的所有服务器/客户端
        if(v != f)      //如果不是他的父亲元素。则说明是它的子节点，继续深搜
            dfs(v , u , d + 1) ;
    }
}

void dfs2(int u , int f , int d){
    covered[u] = true ;     //则该处被覆盖
    int nc = gr[u].size() ;
    for(int i = 0 ; i < nc ; ++ i){
        int v = gr[u][i] ;
        if(v != f && d < k)     //将距离新服务器距离小于K的地方覆盖
            dfs2(v , u , d + 1) ;
    }
}

int solve(){
    int ans = 0 ;
    memset(covered , 0 ,sizeof(covered)) ;
    for(int d = n - 1 ; d > k ; -- d)		//从深度最大的节点开始找起
        for(int i = 0 ; i < nodes[d].size() ; ++ i){
            int u = nodes[d][i] ;
            if (covered[u])
                continue ;      //如果该处已经别覆盖了则不管
            int v = u ;
            for(int j = 0 ; j < k ; ++ j)
                v = fa[v] ;     //找打它的k级祖先，级最远可以向上到达的服务器
            dfs2(v , -1 , 0) ;      //在该处放置VOD服务器使该处可以被覆盖
            ans ++ ;    //需要放置的服务器数量+1
        }
    return ans ;
}

int main(){
   int t ;
   cin >> t ;
   while (t --){
       cin >> n >> s >> k ;
       for(int i = 1 ; i <= n ; ++ i){
           gr[i].clear() ;
           nodes[i].clear() ;
       }
       for(int i = 0 ; i < n - 1 ; ++ i){
           int a , b ;
           cin >> a >> b ;
           gr[a].push_back(b) ;
           gr[b].push_back(a) ;
       }
       dfs(s , -1 , 0) ;        //从已经放置好的VOD服务器开始，该服务器为根节点，没有父级（-1）。深度为0
       cout << solve() << endl ;
   }
    return 0 ;
}