BZOJ 4003 (可并堆)

题面

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

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

分析

直接模拟,初始时候每个树上的节点都属于一个单独的可并堆(堆顶元素最小)

把每个骑士放到它出发节点的可并堆中,值为初始战斗力

DFS回溯的时候将子节点的可并堆和当前节点的可并堆合并

弹出所有战斗力小于防御值的节点

然后打标记区间更新,增加战斗力的值

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define maxn 300005
using namespace std;
inline void qread(int &x) {
	x=0;
	int sign=1;
	char c=getchar();
	while(c<'0'||c>'9') {
		if(c=='-') sign=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9') {
		x=x*10+c-'0';
		c=getchar();
	}
	x*=sign;
}
inline void qread(long long &x) {
	x=0;
	long long sign=1;
	char c=getchar();
	while(c<'0'||c>'9') {
		if(c=='-') sign=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9') {
		x=x*10+c-'0';
		c=getchar();
	}
	x*=sign;
}
inline void qprint(int x) {
	if(x<0) {
		putchar('-');
		qprint(-x);
	} else if(x==0) {
		putchar('0');
		return;
	} else {
		if(x/10>0) qprint(x/10);
		putchar(x%10+'0');
	}
}

struct edge {
	int from;
	int to;
	int next;
} E[maxn<<1];
int sz=1;
int head[maxn];
void add_edge(int u,int v) {
	sz++;
	E[sz].from=u;
	E[sz].to=v;
	E[sz].next=head[u];
	head[u]=sz;
}

struct left_tree {
	int l[maxn],r[maxn];
	int root[maxn];
	int dis[maxn];
	long long val[maxn];
	long long atag[maxn];//加法标记
	long long mtag[maxn];//乘法标记
	void add_tag(int x,long long addv,long long mulv) {//给某个节点打标记,简化代码
		if(x==0) return;
		val[x]=(val[x]*mulv)+addv;
		mtag[x]=mtag[x]*mulv;
		atag[x]=(atag[x]*mulv)+addv;
	}
	void push_down(int x) {
		add_tag(l[x],atag[x],mtag[x]);
		add_tag(r[x],atag[x],mtag[x]);
		atag[x]=0;
		mtag[x]=1;
	}
	int _merge(int x,int y) {
		if(!x||!y) return x+y;
		push_down(x);
		push_down(y);
		if(val[x]>val[y]) swap(x,y);
		r[x]=_merge(r[x],y);
		swap(l[x],r[x]);
		return x;
	}
	void merge(int x,int y) {
		root[x]=_merge(root[x],root[y]);
	}
	void insert(int x,long long v){
		val[x]=v;
		atag[x]=0;
		mtag[x]=1;
	}
	void del(int &x) {
		push_down(x);
		x=_merge(l[x],r[x]);
	}
} T;

int n,m;
long long h[maxn];
long long v[maxn];
int town[maxn],man[maxn];
int deep[maxn];
int is_mul[maxn];
int	start[maxn];
void dfs(int x,int fa) {
//	printf("%d\n",x);
	deep[x]=deep[fa]+1;
	for(int i=head[x]; i; i=E[i].next) {
		int y=E[i].to;
		if(y!=fa) {
			dfs(y,x);
			T.merge(x,y);
		}
	}
	while(T.root[x]&&T.val[T.root[x]]<h[x]) {
		town[x]++;
		man[T.root[x]]=deep[start[T.root[x]]]-deep[x];
		T.del(T.root[x]);
	}
	if(is_mul[x]) {
		T.add_tag(T.root[x],0,v[x]);
	} else {
		T.add_tag(T.root[x],v[x],1);
	}
}

int main() {
	qread(n);
	qread(m);
	for(int i=1; i<=n; i++) {
		qread(h[i]);
	}
	int fa,s,c;
	for(int i=2; i<=n; i++) {
		qread(fa);
		qread(is_mul[i]);
		qread(v[i]);
		add_edge(fa,i);
		add_edge(i,fa);
	}
	for(int i=1;i<=m;i++){
		qread(s);
		qread(c);
		start[i]=c;
		T.insert(i,s);
		T.root[c]=T._merge(T.root[c],i);
	}
	dfs(1,0);
	while(T.root[1]){
		man[T.root[1]]=deep[start[T.root[1]]];
		T.del(T.root[1]);
	}
	for(int i=1; i<=n; i++) {
		qprint(town[i]);
		putchar('\n');
	}
	for(int i=1; i<=m; i++) {
		qprint(man[i]);
		putchar('\n');
	}
}
posted @ 2019-03-20 22:09  birchtree  阅读(114)  评论(0编辑  收藏  举报