HHHOJ #1252. 「NOIP 2023 模拟赛 20230716 B」打怪兽 思考--zhengjun

赛时卡了很久，没想出来怎么做。

随便乱搞了个优先级队列，过拍直接走人，然后成为了唯一的 100 分，无语了。

完事后发现这样做确实是对的，而且好写，简单讲一下。

首先需要能够判断打两个怪 $i,j$ 的优先级：

• $a_i\le b_i,a_j\le b_j$，则优先攻击 $a$ 较小的那个；

• $a_i > b_i,a_j > b_j$，则优先攻击 $b$ 较大的那个；

• 否则，优先攻击 $a\le b$ 的那个。

由于有拓扑序的限制，所以考虑从下往上解决问题。

假设已经知道了 $u$ 的儿子 $v_1,v_2,\cdots,v_k$ 的攻击序列，且儿子的攻击序列均已有序。

那么显然，$u$ 只需要把所有的攻击序列归并一下就完事了。

但是，此时需要在序列的最开头加入 $u$，可能会破坏原来的顺序。

记 $u$ 表示的怪为 $x$，儿子归并后序列的第一项表示的怪为 $y$。

若 $y<x$，说明攻击完 $x$ 时，可以继续攻击比 $x$ 还要优的怪。

这里有个隐含条件：攻击 $x$ 代表着 $x$ 已经是现有中最优的怪，而 $y$ 比 $x$ 优，所以攻击完 $x$ 后一定会攻击 $y$。

那么我们不妨直接合并这两个怪，并把 $y$ 移出原序列。

继续重复上述步骤直到 $x$ 可以满足序列的单调性为止。

时间复杂度：$O(n\log n)/O(n\log ^2 n)$，取决于写的是可并堆还是启发式合并。

代码

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
const int N=1e5+10;
int n,m;
struct zj{
	ll a,b;
	zj operator + (const zj &x)const{
		if(x.a>b)return {a+x.a-b,x.b};
		return {a,b+x.b-x.a};
	}
	bool operator < (const zj &x)const{
		int t1=a<=b,t2=x.a<=x.b;
		if(t1^t2)return t1;
		if(t1)return a<x.a;
		return b>x.b;
	}
}a[N];
struct tree{
	zj x;
	int ls,rs,dis;
}t[N];
void merge(int &x,int y){
	if(!x||!y){
		x|=y;return;
	}
	if(t[y].x<t[x].x)swap(x,y);
	merge(t[x].rs,y);
	if(t[t[x].ls].dis<t[t[x].rs].dis)swap(t[x].ls,t[x].rs);
	t[x].dis=t[t[x].rs].dis+1;
}
void pop(int &x){
	int r1=t[x].ls,r2=t[x].rs;
	merge(x=r1,r2);
}
int root[N];
vector<int>to[N];
void dfs(int u,int fa=0){
	for(int v:to[u])if(v^fa){
		dfs(v,u);
		merge(root[u],root[v]);
	}
	for(;root[u]&&t[root[u]].x<a[u];pop(root[u])){
		a[u]=a[u]+t[root[u]].x;
	}
	t[u]={a[u],0,0,1},merge(root[u],u);
}
int main(){
	freopen("monster.in","r",stdin);
//	freopen("monster.out","w",stdout);
	scanf("%d",&n);
	for(int i=2;i<=n;i++)scanf("%lld%lld",&a[i].a,&a[i].b);
	for(int i=1,u,v;i<n;i++){
		scanf("%d%d",&u,&v);
		to[u].push_back(v),to[v].push_back(u);
	}
	dfs(1);
	zj ans={0,0};
	for(;root[1];pop(root[1]))ans=ans+t[root[1]].x;
	cout<<ans.a;
	return 0;
}