侦察守卫（树形dp）

题目链接
思路：因为d比较小，考虑对状态进行nd的转移。设置一下两种状态：
1.f[i][j]: i的子树中的关键点全部被覆盖，并且至少能沿着父节点覆盖j层。
2.g[i][j]: i的子树层次比j深的全部覆盖，j层以内的随意。
这些状态的性质有以下几点：
1.f[i][0]=g[i][0]
2.因为f[i][j]需要沿着父节点向上覆盖j层，那么下面j层必然是覆盖的，这就与g[i][j]成了一个互补关系。
于是便有一下四个转移：
设当前遍历的节点为u，其子节点为v
1.f[u][i]=min(f[u][i]+g[v][i],f[v][i+1]+g[u][i+1]);
向上覆盖i层可以其子节点向上覆盖i+1层，根据互补，只要其能保证子树i+1层以下被覆盖即可，另一种情况同理。两者取最小值。
2. f[u][i]=min(f[u][i],f[u][i+1]);
因为是至少，所以可能i+1层花费更小。
3.g[u][i]+=g[v][i-1];
子树距离i层全覆盖，只要保证其子节点的子树距离i-1层全覆盖。
4.g[u][i]=min(g[u][i],g[u][i-1]);
理由同2
初始值设置：
1.如果这个点是关键点，那么f[x][0]=g[x][0]=val[x]
因为这个点想要被覆盖必须得选中。
如果不是，则可以不选，为0.
2.当i从1到d时
f[x][i]=val[x]
因为想要向上覆盖，这个点必须得选，当然，最后这些都会被更新，就不一定选了，注意的是先更新f，再更新g，因为g[u][0] 不能通过更新得到，只能是等于f[u][0]。

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+9;
int val[maxn],f[maxn][25],g[maxn][25],key[maxn];
vector<int> e[maxn];
int n,d;
void add(int u,int v){
	e[u].push_back(v);
	e[v].push_back(u);
}
void init(){
	scanf("%d%d",&n,&d);
	for(int i=1;i<=n;i++){
		scanf("%d",&val[i]);
	}
	int m;
	scanf("%d",&m);
	for(int i=1;i<=m;i++){
		int x;
		scanf("%d",&x);
		key[x]=1;
	}
	for(int i=1;i<n;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		add(u,v);
	}
}
void dfs(int u,int p){
	if(key[u]) f[u][0]=g[u][0]=val[u];
	else f[u][0]=g[u][0]=0;
	for(int i=1;i<=d;i++) f[u][i]=val[u];
	f[u][d+1]=1e9;
	for(int k=0;k<e[u].size();k++){
		int v=e[u][k];
		if(v==p) continue;
		dfs(v,u);
		for(int i=d;i>=0;i--) f[u][i]=min(f[u][i]+g[v][i],f[v][i+1]+g[u][i+1]);
		for(int i=d;i>=0;i--) f[u][i]=min(f[u][i],f[u][i+1]);
		g[u][0]=f[u][0];
		for(int i=1;i<=d;i++) g[u][i]+=g[v][i-1];
		for(int i=1;i<=d;i++) g[u][i]=min(g[u][i],g[u][i-1]);
	} 	
}
void solve(){
	dfs(1,0);
	printf("%d",f[1][0]);
}
int main(){
	init();
	solve();
}