左偏树 （p3261) 对我来说是一道进阶题

题意：有n座城池，m个人；

每座城池有一个耐久度；

每座城池有一个父亲城池（肯定会形成一棵树），还有flag base （这个看题意)

每个人有一个战力值和一个开始进攻的城池序号；

问：1.每个城池能够使将领死亡的死亡数 2.每个将领能够攻占的城池数量；

思路，这道题是一颗树，所以自然而然的想到用dfs传到根节点，再传回去这种做法；

那么在这种做法下，我们建立最小堆，对每一个节点建立一个最小堆，然后遍历的时候，将小于limit[]的将领弹出；

这个时候需要更新答案， 这个城池的将领死亡数量+1；这个将领攻占的城池数量；

然后   剩下的将领有一个val需要更新 这个时候我们不是直接更新，而是用一个懒惰节点去降低复杂度；

一步一步传给子节点更新；

 #include<cstdio>
 #include<algorithm>
 #include<math.h>
 #include<string.h>
 using namespace std;
 typedef long long ll;
 const ll maxn=3e5+;
 ll flag[maxn],base[maxn];      //城池的val更新方式
 ll ch[maxn][];   //子节点
 ll val[maxn],guishu[maxn];  //将领的战力值和第一个城池
 ll root[maxn];   //每一个城池的根节点；
 ll dep[maxn],dis[maxn];  //dep是用来计算将领的攻占城池数量的， dis是左偏树的深度；
 ll ans1[maxn],ans2[maxn]; //城池答案，将领答案；
 ll mul[maxn],add[maxn];  //懒惰标记
 ll limit[maxn]; //城池耐久值
 struct node  //邻接表
 {
     ll v,next;
 }G[maxn]; ll head[maxn];ll num=-;
 void build(ll u,ll v)
 {
     G[++num].v=v;G[num].next=head[u];head[u]=num;
 }
 void cov(ll x,ll c,ll j)
 {
     if(!x) return;
     val[x]*=c;val[x]+=j;  //这里有一个乘和一个加，自然是先乘后加； 这是根据下文这两句来确定的
     mul[x]*=c;   //这里的确定方式是将已经有的懒惰节点的值与本次加进来的懒惰节点更新；
                  //已经有的，自然那些要+的，也要乘上这次的数，然后再加上这次要加的数
                 //注：下次看这里看不懂的话，多看一下肯定会懂的
     add[x]*=c;add[x]+=j;
 }
 void pushdown(ll x)
 {  //左右儿子都得更新
     cov(ch[x][],mul[x],add[x]);
     cov(ch[x][],mul[x],add[x]);
     mul[x]=;add[x]=;
 }
 ll Merge(ll x,ll y)
 {
     if(!x||!y) return x+y;
     pushdown(x);pushdown(y);
     if(val[x]>val[y]) swap(x,y);
     ch[x][]=Merge(ch[x][],y);
     if(dis[ch[x][]]<dis[ch[x][]]) swap(ch[x][],ch[x][]);
     dis[x]=dis[ch[x][]]+;
     return x;
 }

 void dfs(ll u,ll fa)
 {
     dep[u]=dep[fa]+;
     for(ll i=head[u];i!=-;i=G[i].next){
         ll v=G[i].v;
         dfs(v,u);
         root[u]=Merge(root[u],root[v]);
     }
     while(root[u]&&val[root[u]]<limit[u]){
         pushdown(root[u]);
         ans1[u]++;
         ans2[root[u]]=dep[guishu[root[u]]]-dep[u];
         ll t=root[u];
         root[u]=Merge(ch[t][],ch[t][]);
     }
     if(flag[u]) cov(root[u],base[u],);
     else        cov(root[u],,base[u]);
 }
 int main()
 {
     ll n,m;
     memset(head,-,sizeof(head));
     scanf("%lld%lld",&n,&m);
     for(ll i=;i<=n;i++) scanf("%lld",&limit[i]);
     for(ll i=;i<=n;i++){
         ll u;
         scanf("%lld%lld%lld",&u,&flag[i],&base[i]);
         build(u,i);
     }
     for(ll i=;i<=m;i++){
         scanf("%lld%lld",&val[i],&guishu[i]);
         ll t=guishu[i];
         mul[i]=;
         if(!root[t]) root[t]=i;
         else root[t]=Merge(root[t],i);
     }
     dfs(,);
     while(root[]){
         pushdown(root[]);
         ans2[root[]]=dep[guishu[root[]]];
         root[]=Merge(ch[root[]][],ch[root[]][]);
     }
     for(ll i=;i<=n;i++) printf("%lld\n",ans1[i]);
     for(ll i=;i<=n;i++) printf("%lld\n",ans2[i]);
     return ;
 }