Monster Hunter(2020南京M)

Posted 2021-10-19 Jozky86

Monster Hunter(2020南京M)

题意：

给你一颗树，树上每个节点都是一个hpi 血量的怪物。打败每个怪物所需要的能量值为hpi + 所 有 存 活 的 直 接 子 节 点 的 hpj 。每次必须要消灭父节点后才能消灭子节点。此外你还有m个魔咒，每个魔咒可以不耗费能量且可以消灭任意一个存活的怪物（无论其父亲节点是否存在）。问你m=0，1，2，3…，n时的最低总能量花费分别为多少。

题解：

不难看出树形dp
那我们可以设状态为：dp[i][j]:表示i的子树还剩j个点的最小花费(其他i-j相当于用魔咒消灭)
我们现在可以考虑转移，发现不好转移，因为这个子树根节点第i个点也有可能被删除，所以我们再加一维，dp[i][j][0/1]:表示i的子树还剩j个点的最小花费，且第i个点是否被消灭(0表示被消灭，1表示未消灭)
这样就可以转移了：
u是v的父亲节点，用v更新u
可以得到转移方程：

for(int i=siz[u];i>=0;i--){
    for(int j=0;j<=min(i,siz[v]);j++){
        dp[u][i][0]=min(dp[u][i][0],dp[u][i-j][0]+dp[v][j][1]);//u不保存，v保存
        dp[u][i][0]=min(dp[u][i][0],dp[u][i-j][0]+dp[v][j][0]);//
        dp[u][i][1]=min(dp[u][i][1],dp[u][i-j][1]+dp[v][j][0]);//
        dp[u][i][1]=min(dp[u][i][1],dp[u][i-j][1]+dp[v][j][1]+hp[v]);// u，v都保存时要算上v的hp值

    }
}

就是分别讨论u和v是0，1的情况，一共四个情况，分别更新
这样能过81.58%的数据，T了

我们分析一下复杂度，相当于用以u为根的子树中所有点，与以v为根的子树中所有点两两匹配，这样会有重复，因为以v为根的子树也在以u为根的子树里，这样会重复计算siz[v]部分。这样的话，重复计算部分有${\sum }_{i=1}^{n}siz[i]$,铁超时，总复杂度是$(2n^2)$(队友说的，等会证明再更新),会被卡常

---

如何可以避免重复部分？我们改变写法，将dp[i]=dp[i-j]+dp[j]改为dp[i+j]=dp[i]+dp[j]，i枚举的是以u为根的子树，除以v为根的子树之外的节点，j枚举的是以v为根的子树的节点，这样枚举，恰好使得任意两点被枚举到，不会多，不会漏，这样是$O(n^2)$
图片出处

代码：

#include <bits/stdc++.h>
#include <unordered_map>
#define debug(a, b) printf("%s = %d\\n", a, b);
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;
clock_t startTime, endTime;
//Fe~Jozky
const ll INF_ll= 1e18;
const int INF_int= 0x3f3f3f3f;
void read(){};
template <typename _Tp, typename... _Tps> void read(_Tp& x, _Tps&... Ar)
{
    x= 0;
    char c= getchar();
    bool flag= 0;
    while (c < '0' || c > '9')
        flag|= (c == '-'), c= getchar();
    while (c >= '0' && c <= '9')
        x= (x << 3) + (x << 1) + (c ^ 48), c= getchar();
    if (flag)
        x= -x;
    read(Ar...);
}
template <typename T> inline void write(T x)
{
    if (x < 0) {
        x= ~(x - 1);
        putchar('-');
    }
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
void rd_test()
{
#ifdef ONLINE_JUDGE
#else
    startTime = clock ();
    freopen("data.in", "r", stdin);
#endif
}
void Time_test()
{
#ifdef ONLINE_JUDGE
#else
    endTime= clock();
    printf("\\nRun Time:%lfs\\n", (double)(endTime - startTime) / CLOCKS_PER_SEC);
#endif
}
#define int long long 
int n;
const int maxn=2e3+9;
vector<int>vec[maxn];
int hp[maxn];
int dp[maxn][maxn][2];
int siz[maxn];
void dfs(int u,int fa){
	dp[u][0][0]=0;
	dp[u][1][1]=hp[u];
	for(auto v:vec[u]){
		dfs(v,u);
		for(int i=siz[u]-siz[v];i>=0;i--){
			for(int j=0;j<=siz[v];j++){
				dp[u][i+j][0]=min(dp[u][i+j][0],dp[u][i][0]+dp[v][j][1]);//u不保存，v保存 
				dp[u][i+j][0]=min(dp[u][i+j][0],dp[u][i][0]+dp[v][j][0]);//
				dp[u][i+j][1]=min(dp[u][i+j][1],dp[u][i][1]+dp[v][j][0]);//
				dp[u][i+j][1]=min(dp[u][i+j][1],dp[u][i][1]+dp[v][j][1]+hp[v]);// u，v都保存时要算上v的hp值 
//				dp[u][i][2]=dp[u][i-j][1]+dp[v][j][w]+(w==0?0:w[v])//
			}
		}
	}
}
void dfs1(int u,int fa){
	siz[u]=1;
	for(auto v:vec[u]){
		if(v==fa)continue;
		dfs1(v,u);
		siz[u]+=siz[v]; 
	}
}
void solve(){
	read(n);
	for(int i=0;i<=n;i++){
		for(int j=0;j<=n;j++){
			dp[i][j][0]=dp[i][j][1]=1e18;
		}
	}
	for(int i=1;i<=n;i++)vec[i].clear();
	for(int i=2;i<=n;i++){
		int u;
		read(u);
		vec[u].push_back(i);
	}
	for(int i=1;i<=n;i++){
		read(hp[i]);
	}
	dfs1(1,0);
	dfs(1,0);
	for(int i=0;i<=n;i++){
		printf("%lld ",min(dp[1][n-i][0],dp[1][n-i][1]));
	}
	printf("\\n");
}
signed main()
{
    rd_test();
	int t;
	read(t);
	while(t--){
		solve();
	}
    //Time_test();
}