【bzoj4003】[JLOI2015]城池攻占 可并堆

题目描述

小铭铭最近获得了一副新的桌游，游戏中需要用 m 个骑士攻占 n 个城池。

这 n 个城池用 1 到 n 的整数表示。除 1 号城池外，城池 i 会受到另一座城池 fi 的管辖，其中 fi <i。也就是说，所有城池构成了一棵有根树。这 m 个骑士用 1 到 m 的整数表示，其中第 i 个骑士的初始战斗力为 si，第一个攻击的城池为 ci。每个城池有一个防御值 hi，如果一个骑士的战斗力大于等于城池的生命值，那么骑士就可以占领这座城池；否则占领失败，骑士将在这座城池牺牲。占领一个城池以后，骑士的战斗力将发生变化，然后继续攻击管辖这座城池的城池，直到占领 1 号城池，或牺牲为止。除 1 号城池外，每个城池 i 会给出一个战斗力变化参数 ai;vi。若 ai =0，攻占城池 i 以后骑士战斗力会增加 vi；若 ai =1，攻占城池 i 以后战斗力会乘以 vi。注意每个骑士是单独计算的。也就是说一个骑士攻击一座城池，不管结果如何，均不会影响其他骑士攻击这座城池的结果。现在的问题是，对于每个城池，输出有多少个骑士在这里牺牲；对于每个骑士，输出他攻占的城池数量。

输入

第 1 行包含两个正整数 n;m，表示城池的数量和骑士的数量。

第 2 行包含 n 个整数，其中第 i 个数为 hi，表示城池 i 的防御值。

第 3 到 n +1 行，每行包含三个整数。其中第 i +1 行的三个数为 fi;ai;vi，分别表示管辖这座城池的城池编号和两个战斗力变化参数。

第 n +2 到 n + m +1 行，每行包含两个整数。其中第 n + i 行的两个数为 si;ci，分别表示初始战斗力和第一个攻击的城池。

输出

输出 n + m 行，每行包含一个非负整数。其中前 n 行分别表示在城池 1 到 n 牺牲的骑士数量，后 m 行分别表示骑士 1 到 m 攻占的城池数量。

样例输入

5 5
50 20 10 10 30
1 1 2
2 0 5
2 0 -10
1 0 10
20 2
10 3
40 4
20 4
35 5

样例输出

2
2
0
0
0
1
1
3
1
1

---

题解

带修改的可并堆

维护一个小根堆，每个城池的root指向骑士，从下至上依次合并及删除。

每个骑士攻破的城池数就是原节点深度减去失败节点深度。

关键就在于修改，其实也不难。

双标记的处理：先乘后加，乘的时候把儿子标记也乘一下。

每次merge时需要pushdown。

还有，删除点时需要判断是否为空，若为空则需要跳出。

细节：注意deep[0]要等于deep[1]-1，因为如果有骑士攻破了城池1，则失败节点应视为0，深度就是deep[1]-1。

还要注意删除最小节点（pop）操作时，标记需要下传。

#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 300010
using namespace std;
typedef long long ll;
int head[N] , to[N] , type[N] , next[N] , cnt , root[N] , l[N] , r[N] , d[N] , deep[N] , from[N] , kill[N] , atk[N];
ll val[N] , h[N] , key[N] , tadd[N] , tmul[N];
void add(int x , int y , int a , ll b)
{
	to[++cnt] = y;
	type[cnt] = a;
	val[cnt] = b;
	next[cnt] = head[x];
	head[x] = cnt;
}
void pushdown(int x)
{
	if(!x) return;
	if(tmul[x] != 1)
	{
		key[l[x]] *= tmul[x] , tadd[l[x]] *= tmul[x] , tmul[l[x]] *= tmul[x];
		key[r[x]] *= tmul[x] , tadd[r[x]] *= tmul[x] , tmul[r[x]] *= tmul[x];
		tmul[x] = 1;
	}
	if(tadd[x])
	{
		key[l[x]] += tadd[x] , tadd[l[x]] += tadd[x];
		key[r[x]] += tadd[x] , tadd[r[x]] += tadd[x];
		tadd[x] = 0;
	}
}
int merge(int x , int y)
{
	if(!x) return y;
	if(!y) return x;
	pushdown(x) , pushdown(y);
	if(key[x] > key[y]) swap(x , y);
	r[x] = merge(r[x] , y);
	if(d[l[x]] < d[r[x]]) swap(l[x] , r[x]);
	d[x] = d[r[x]] + 1;
	return x;
}
void dfs(int x)
{
	int i;
	for(i = head[x] ; i ; i = next[i])
	{
		deep[to[i]] = deep[x] + 1 , dfs(to[i]);
		if(type[i]) key[root[to[i]]] *= val[i] , tadd[root[to[i]]] *= val[i] , tmul[root[to[i]]] *= val[i];
		else key[root[to[i]]] += val[i] , tadd[root[to[i]]] += val[i];
		root[x] = merge(root[x] , root[to[i]]);
	}
	while(root[x] && key[root[x]] < h[x])
		kill[x] ++ , atk[root[x]] = x , pushdown(root[x]) , root[x] = merge(l[root[x]] , r[root[x]]);
}
int main()
{
	int n , m , i , x , a;
	ll b;
	scanf("%d%d" , &n , &m);
	for(i = 1 ; i <= n ; i ++ ) scanf("%lld" , &h[i]);
	for(i = 2 ; i <= n ; i ++ ) scanf("%d%d%lld" , &x , &a , &b) , add(x , i , a , b);
	for(i = 1 ; i <= m ; i ++ ) tmul[i] = 1 , scanf("%lld%d" , &key[i] , &from[i]) , root[from[i]] = merge(root[from[i]] , i);
	d[0] = -1 , deep[1] = 1;
	dfs(1);
	for(i = 1 ; i <= n ; i ++ ) printf("%d\n" , kill[i]);
	for(i = 1 ; i <= m ; i ++ ) printf("%d\n" , deep[from[i]] - deep[atk[i]]);
	return 0;
}