「Luogu P3261 && LOJ 2107」城池攻占

小铭铭最近获得了一副新的桌游，游戏中需要用 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。注意每个骑士是单独计算的。也就是说一个骑士攻击一座城池，不管结果如何，均不会影响其他骑士攻击这座城池的结果。

现在的问题是，对于每个城池，输出有多少个骑士在这里牺牲；对于每个骑士，输出他攻占的城池数量。

Luogu

分析

这题我们用小根堆的左偏树维护。

先将城池建树，然后对每一个骑士都建一个左偏树，再把同一个城池出发的骑士先合并，接着 dfs 一遍，将一个点的左偏树与它节点的左偏树合并，然后将不合法的骑士移除，同时统计这个点的答案，而骑士的答案我们可以它出发的点的深度减去这个点的深度来得出。

对于修改操作，打标记就好了，操作和线段树的一样，给每一棵左偏树的顶点打上标记，每次操作都 pushdown 一下，更新标记的话，在踢出不合法的骑士后再更新。

注意，这题要开 long long

代码

//=========================
//  author:hliwen
//  date:2020.1.18
//=========================
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 300003
#define il inline
#define re register
#define DEBUG puts("ok")
#define tie0 cin.tie(0),cout.tie(0)
#define fastio ios::sync_with_stdio(false)
#define File(x) freopen(x".in","r",stdin);freopen(x".out","w",stdout)
using namespace std;
typedef long long ll;

template <typename T> inline void read(T &x) {
	T f = 1; x = 0; char c;
    for (c = getchar(); !isdigit(c); c = getchar()) if (c == '-') f = -1;
    for ( ; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    x *= f;
}

int n, m, rt;
int ans[N], tot[N], heap[N], dep[N];
int to[N], nxt[N], head[N], cnt;
int ls[N], rs[N];
ll atg[N], ttg[N], v[N], s[N], h[N];
int a[N], c[N], dis[N];

void insert(int u, int v) {
	to[++cnt] = v, nxt[cnt] = head[u], head[u] = cnt;
}

void pushdown(int x) {
	if (atg[x] == 0 && ttg[x] == 1) return;
	if (ls[x]) {
		atg[ls[x]] *= ttg[x], atg[ls[x]] += atg[x];
		ttg[ls[x]] *= ttg[x];
		s[ls[x]] *= ttg[x], s[ls[x]] += atg[x];
	}
	if (rs[x]) {
		atg[rs[x]] *= ttg[x], atg[rs[x]] += atg[x];
		ttg[rs[x]] *= ttg[x];
		s[rs[x]] *= ttg[x], s[rs[x]] += atg[x];
	}
	atg[x] = 0, ttg[x] = 1;
}

int merge(int x, int y) {
	if (!x || !y) return x + y;
	pushdown(x), pushdown(y);
	if (s[x] > s[y]) swap(x, y);
	rs[x] = merge(rs[x], y);
	if (dis[ls[x]] < dis[rs[x]]) swap(ls[x], rs[x]);
	dis[x] = dis[rs[x]] + 1;
	return x;
}

int pop(int x) {
	pushdown(x);
	return merge(ls[x], rs[x]);
}

int dfs(int u, int fa) {
	for (int i = head[u]; i; i = nxt[i]) {
		int v = to[i];
		if (v == fa) continue;
		heap[u] = merge(heap[u], dfs(v, u));
	}
	while (heap[u] && s[heap[u]] < h[u]) {
		tot[u]++, ans[heap[u]] = dep[c[heap[u]]] - dep[u];
		heap[u] = pop(heap[u]);
	}
	if (a[u]) {
		s[heap[u]] *= v[u];
		atg[heap[u]] *= v[u] , ttg[heap[u]] *= v[u];
	}
	else {
		s[heap[u]] += v[u];
		atg[heap[u]] += v[u];
	}
	return heap[u];
}

int main() {
	int x;
	read(n), read(m);
	for (int i = 1; i <= n; ++i) read(h[i]);
	dep[1] = 1, dep[0] = -1;
	for (int i = 2; i <= n; ++i) {
		read(x), read(a[i]), read(v[i]);
	    insert(x, i);
		dep[i] = dep[x] + 1;
	}
	for (int i = 1; i <= m; ++i) {
		read(s[i]), read(c[i]);
		ttg[i] = 1;
		heap[c[i]] = merge(heap[c[i]], i);
	}
	dfs(1, 0);
	while (heap[1]) {
		ans[heap[1]] = dep[c[heap[1]]] - dep[1] + 1;
		heap[1] = pop(heap[1]);
	}
	for (int i = 1; i <= n; ++i) printf("%d\n", tot[i]);
	for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
	return 0;
}