LA_3902 - Network

最新推荐文章于 2020-12-24 08:32:13 发布

原创最新推荐文章于 2020-12-24 08:32:13 发布 · 443 阅读

0 ·

CC 4.0 BY-SA版权

Tree 同时被 2 个专栏收录

16 篇文章

订阅专栏

Graph

14 篇文章

订阅专栏

本文介绍了一种解决树状网络服务覆盖问题的算法。该算法通过将无向树转换为有向树，并从最深的叶节点开始计算放置服务节点来最小化所需的服务器数量。文中还提供了详细的代码实现。

題意：
一個樹狀網絡，指定一個服務器s,一個距離k，與服務器相距爲k的節點都能被服務到，問服務整個網絡最少要增加多少臺服務器
分析：
這個網絡是無向的，轉成有向的比較好處理，題目給定了一個服務器，可以以這個點爲Root，把這個樹狀網絡變爲有向，然而比較優先的策略是從深度最深的葉子節點開始算距離爲k的位置放置一個服務器，然後更新覆蓋點，這裏只需要處理葉子節點，爲什麼？ 因爲，如果葉子節點能被覆蓋的話，那麼非葉子節點要麼是服務器要麼已經被覆蓋了
Code:

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

#define MAXN    1000 + 10

int parent[MAXN], visit[MAXN];
vector<int> vertex[MAXN], depth[MAXN];

void conversion(int u, int p, int dep)
{
        visit[u] = 1;
        parent[u] = p;
        
        //is leaf
        if( 1 == vertex[u].size() && p == vertex[u][0] ) {
                depth[dep].push_back(u);
        }
        for(int i = 0; i < vertex[u].size(); i ++) {
                int v = vertex[u][i];
                if( visit[v] ) {
                        continue;
                }
                conversion(v, u, dep+1);
        }
}

inline void dfs(int u, int p, int k)
{
        visit[u] = 1;
        if( !k ) {
                return;
        }
        for(int i = 0; i < vertex[u].size(); i ++) {
                int v = vertex[u][i];
                if( p == v ) {
                        continue;
                }
                dfs(v, u, k-1);
        }
}

int cal(int n, int k, int s)
{
        int sum = 0;
        memset(visit, 0, sizeof(int)*(n+1));
        for(int d = n-1; d > k; d --)  {        //already have a server.
                for(int i = 0; i < depth[d].size(); i ++) {
                        int u = depth[d][i];
                        if( visit[u] ) {
                                continue;
                        }
                        int pu = u;
                        for(int j = 1; j <= k; j ++) {
                                pu = parent[pu];
                        }
                        dfs(pu, -1, k);
                        sum += 1;
                }
        }
        return sum;
}

int main(int argc, char **argv)
{
#ifndef ONLINE_JUDGE
        freopen("test.in", "r", stdin);
#endif
        int n, s, u, v, k, cas;
        scanf("%d", &cas);
        for( ; cas; cas --) {
                scanf("%d %d %d", &n, &s, &k);
                
                // init
                for(int i = 1; i <= n; i ++) {
                        visit[i] = 0;
                        depth[i].erase(depth[i].begin(), depth[i].end());
                        vertex[i].erase(vertex[i].begin(), vertex[i].end());
                }
                
                for(int i = 1; i < n; i ++) {
                        scanf("%d %d", &u, &v);
                        vertex[u].push_back(v);
                        vertex[v].push_back(u);
                }
               
                
                //conversion undirect tree to direct tree
                conversion(s, -1, 0);
                
                printf("%d\n", cal(n, k, s));
                
        }
        return 0;
}