HDU5242：Game（树上贪心）

最新推荐文章于 2018-05-16 21:51:07 发布

junior19

最新推荐文章于 2018-05-16 21:51:07 发布

阅读量699

点赞数

CC 4.0 BY-SA版权

分类专栏：贪心

本文链接：https://blog.youkuaiyun.com/junior19/article/details/71081283

贪心专栏收录该内容

23 篇文章

订阅专栏

本文介绍了一道算法题目，玩家需要控制多个角色通过一棵树形结构的游戏场景，目标是寻找路径使得经过的所有不同场景的价值总和最大。文章提供了详细的解题思路及代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Game

Time Limit: 3000/1500 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1465 Accepted Submission(s): 477

Problem Description

It is well known that Keima Katsuragi is The Capturing God because of his exceptional skills and experience in ''capturing'' virtual girls in gal games. He is able to play

k games simultaneously.

One day he gets a new gal game named ''XX island''. There are

n scenes in that game, and one scene will be transformed to different scenes by choosing different options while playing the game. All the scenes form a structure like a rooted tree such that the root is exactly the opening scene while leaves are all the ending scenes. Each scene has a value , and we use

wi as the value of the

i -th scene. Once Katsuragi entering some new scene, he will get the value of that scene. However, even if Katsuragi enters some scenes for more than once, he will get

wi for only once.

For his outstanding ability in playing gal games, Katsuragi is able to play the game

k times simultaneously. Now you are asked to calculate the maximum total value he will get by playing that game for

k times.

Input

The first line contains an integer

T (

T≤20 ), denoting the number of test cases.

For each test case, the first line contains two numbers

n,k(1≤k≤n≤100000) , denoting the total number of scenes and the maximum times for Katsuragi to play the game ''XX island''.

The second line contains

n non-negative numbers, separated by space. The

i -th number denotes the value of the

i -th scene. It is guaranteed that all the values are less than or equal to

231−1 .

In the following

n−1 lines, each line contains two integers

a,b(1≤a,b≤n) , implying we can transform from the

a -th scene to the

b -th scene.

We assume the first scene(i.e., the scene with index one) to be the opening scene(i.e., the root of the tree).

Output

For each test case, output ''Case #t:'' to represent the

t -th case, and then output the maximum total value Katsuragi will get.

Sample Input

Sample Output

  
   Case #1: 10
Case #2: 11

Source

The 2015 ACM-ICPC China Shanghai Metropolitan Programming Contest

题意：给一颗N个节点的树，有N-1条有向边，每个点有一个权值，从1号点放k个人走到叶子结点，求覆盖路径的最大权值和。

思路：先反向建树，求出每个点到根节点的权值和，可以保证这是一条无分岔的路。然后从大到小排序，从权值和大的点开始覆盖道路，最后再排序取前k大的路即可。

# include <iostream>
# include <cstdio>
# include <cstring>
# include <algorithm>
# define ll long long
using namespace std;
const int maxn = 1e5;
int cnt, cas=1;
ll val[maxn+3], ne[maxn+3], vis[maxn+3], road[maxn+3], id[maxn+3];

struct node
{
    int to, next;
}a[maxn+3];

void add_edge(int u, int v)
{
    a[cnt].to = v;
    a[cnt].next = ne[u];
    ne[u] = cnt++;
}

ll dfs(int u)//所有点到根节点的权值和。
{
    if(vis[u]) return road[u];
    vis[u] = 1;
    road[u] = val[u];
    for(int i=ne[u]; i!=-1; i=a[i].next)
    {
        int v = a[i].to;
        road[u] += dfs(v);
    }
    return road[u];
}

ll dfs2(int u)
{
    if(vis[u]) return 0;
    vis[u] = 1;
    ll tmp = val[u];
    for(int i=ne[u]; i!=-1; i=a[i].next)
    {
        int v = a[i].to;
        tmp += dfs2(v);
    }
    return tmp;
}

bool cmp(int x, int y)
{
    return road[x] > road[y];
}

int main()
{
    int t, n, k, a, b;
    scanf("%d",&t);
    while(t--)
    {
        cnt = 0;
        memset(ne, -1, sizeof(ne));
        scanf("%d%d",&n,&k);
        for(int i=1; i<=n; ++i)
            scanf("%lld",&val[i]);
        for(int i=1; i<n; ++i)
        {
            scanf("%d%d",&a,&b);
            add_edge(b, a);
        }
        memset(vis, 0, sizeof(vis));
        memset(road, 0, sizeof(road));
        for(int i=1; i<=n; ++i)
        {
            id[i] = i;
            road[i] = dfs(i);
        }
        sort(id+1, id+1+n, cmp);
        memset(vis, 0, sizeof(vis));
        memset(road, 0, sizeof(road));
        for(int i=1; i<=n; ++i)
        {
            int now = id[i];
            road[i] = dfs2(now);
        }
        sort(road+1, road+1+n, greater<ll>());
        ll ans = 0;
        for(int i=1; i<=k; ++i)
            ans += road[i];
        printf("Case #%d: %lld\n",cas++, ans);
    }
    return 0;
}