题目描述

Farmer John has noticed that his cows often move between nearby fields. Taking this into account, he wants to plant enough grass in each of his fields not only for the cows situated initially in that field, but also for cows visiting from nearby fields.

Specifically, FJ’s farm consists of N fields (1 <= N <= 100,000), where some pairs of fields are connected with bi-directional trails (N-1 of them in total). FJ has designed the farm so that between any two fields i and j, there is a unique path made up of trails connecting between i and j. Field i is home to C(i) cows, although cows sometimes move to a different field by crossing up to K trails (1 <= K <= 20).

FJ wants to plant enough grass in each field i to feed the maximum number of cows, M(i), that could possibly end up in that field – that is, the number of cows that can potentially reach field i by following at most K trails. Given the structure of FJ’s farm and the value of C(i) for each field i, please help FJ compute M(i) for every field i.

给出一棵n个点的树，每个点上有C_i头牛，问每个点k步范围内各有多少头牛。

输入输出格式
输入格式：

•Line 1: Two space-separated integers, N and K.

•Lines 2..N: Each line contains two space-separated integers, i and j (1 <= i,j <= N) indicating that fields i and j are directly connected by a trail.

•Lines N+1..2N: Line N+i contains the integer C(i). (0 <= C(i) <= 1000)

输出格式：

•Lines 1..N: Line i should contain the value of M(i).

输入输出样例

输入样例#1：
6 2
5 1
3 6
2 4
2 1
3 2
1
2
3
4
5
6

输出样例#1：
15
21
16
10
8
11

说明

There are 6 fields, with trails connecting (5,1), (3,6), (2,4), (2,1), and (3,2). Field i has C(i) = i cows.

Field 1 has M(1) = 15 cows within a distance of 2 trails, etc.

【分析】
沉迷树形dp
挺不错的一道树形dp
由于既要统计每个节点的子树还要统计父亲来更新答案，所以需要特殊的算法
用dp[i][j][0]表示结点i的子树中与i距离<=j的结点权值之和（包括i结点权值）
用dp[i][j][1]表示对于该点父节点，不管该节点只管其它子节点时距离<=j-1的牛的个数
稍微用一点容斥来解决状态转移： dp[v][k][1]=dp[u][k-1][0]-dp[v][k-2][0]; (v是u的子节点)
最后对于每个节点，循环不断找父亲，统计牛的数量

【代码】

//2591 [Usaco 2012 Feb]Nearby Cows
#include<iostream>
#include<vector>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define ll long long
#define fo(i,j,k) for(int i=j;i<=k;i++)
using namespace std;
const int mxn=100005;
int ans[mxn],head[mxn],father[mxn];
int dp[mxn][22][2];  //0表示只管子树，1表示该点父节点中，不管该节点时只管其它子节点时附近牛的个数 
int n,m,cnt;
struct edge {int to,next;} f[mxn<<1];
inline void add(int u,int v)
{
    f[++cnt].to=v;f[cnt].next=head[u];head[u]=cnt;
}

inline void dfs(int u,int fa)
{
    int i,j,k,sum=0;
    father[u]=fa;
    fo(k,1,m) dp[u][k][0]=dp[u][0][0];
    for(i=head[u];i;i=f[i].next)
    {
        int v=f[i].to;
        if(v==fa) continue;
        dfs(v,u);
        fo(k,1,m) dp[u][k][0]+=dp[v][k-1][0];
    }
    for(i=head[u];i;i=f[i].next)
    {
        int v=f[i].to;
        if(v==fa) continue;
        dp[v][1][1]=dp[u][0][0]; 
        fo(k,2,m) dp[v][k][1]=dp[u][k-1][0]-dp[v][k-2][0];
    }
}
int main()
{
    int u,v;
    scanf("%d%d",&n,&m);
    fo(i,2,n)
    {
        scanf("%d%d",&u,&v);
        add(u,v),add(v,u);
    }
    fo(i,1,n) scanf("%d",&dp[i][0][0]);
    dfs(1,0);
    fo(i,1,n)  //枚举试点 
    {
        ans[i]=dp[i][m][0];
        int u=i,v;
        fo(j,1,m)
        {
            ans[i]+=dp[u][m-j+1][1];
            u=father[u];
            if(!u) break;
        }
    } 
    fo(i,1,n) printf("%d\n",ans[i]);
    return 0;
}