【左偏树+延迟标记+拓扑排序】BZOJ4003-城池攻占

【题目大意】

有n个城市构成一棵树，除1号城市外每个城市均有防御值h和战斗变化参量a和v。

现在有m个骑士各自来刷副本，每个其实有一个战斗力s和起始位置c。如果一个骑士的战斗力s大于当前城市的防御值h,则可攻破这个城市，并前往它的管辖地（即树上的父亲），同时，战斗力s发生如下变化：

①如被攻占城市a=0，则s+=v；

②如果a=0,s*=v。

输出：每个骑士能够攻占的城市数量，以及每个城市有多少个骑士牺牲了。

【思路】

昨天写了一遍这道题，当时用的是DFS，今天用拓扑重写一遍。思路如下：

从下往上拓扑排序，左偏树里存放骑士。当前节点上的左偏树相当于可以存活到当前城市的所有骑士的集合，存放在一个小顶堆中。显然，如果较小的骑士能攻破，那么较大的一定能。那么每次，如果堆顶小于当前城市的防御值，则弹出。每个城市攻占结束后，更新一下所有骑士们的战斗力。

左偏树和其它树型结构一样，都可以使用延迟标记。做法和线段树差不多。

延迟标记有三个，lazycnt,lazyadd,lazymul，分别表示攻占城市数的增加和战斗力的增加。更新操作时，将左右孩子的cnt和lazycnt均加上当前的lazycnt。如果当前a=0，则将左右孩子的key和lazyadd加上当前的lazyadd；如果当前a=1，则将左右孩子的key、lazymul和lazyadd均乘以当前的lazymul。

延迟标记在两个地方需要往下推：

①在堆顶元素弹出后。

②在merge中将较小根的右子树和较大根的左子树合并的时候。（！！！）

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #define L Ltree[Ltree[x].lson]
 #define R Ltree[Ltree[x].rson]
 using namespace std;
 typedef long long ll;
 const int MAXN=+;
 struct node
 {
     ll key;
     int dis,pos,cnt;
     ll lazyadd,lazymul;int lazycnt;//懒惰标记
     int lson,rson;
 };
 int n,m;
 ll h[MAXN],v[MAXN];//防御力，战斗变化量，
 int city[MAXN],knight[MAXN],f[MAXN],a[MAXN],out[MAXN],rt[MAXN];
 //每个城市牺牲的骑士数，每个骑士攻破的城市数量,管辖地，战斗变化参数，每个节点的出度（拓扑排序使用），到达每个节点位置时的堆顶元素
 node Ltree[MAXN];//左偏树
 queue<int> que;//树由下至上拓扑排序的队列 

 void update(int root,int flag,ll delta)
 {
     Ltree[root].lazycnt++;
     Ltree[root].cnt++;
     if (flag)
     {
         Ltree[root].lazyadd*=delta;
         Ltree[root].lazymul*=delta;
         Ltree[root].key*=delta;
     }
     else
     {
         Ltree[root].lazyadd+=delta;
         Ltree[root].key+=delta;
     }
 }

 void pushdown(int x)
 {
     if (Ltree[x].lazycnt)
     {
         L.cnt+=Ltree[x].lazycnt;
         R.cnt+=Ltree[x].lazycnt;
         L.lazycnt+=Ltree[x].lazycnt;
         R.lazycnt+=Ltree[x].lazycnt;
         Ltree[x].lazycnt=;
     }
     if (Ltree[x].lazymul!=)
     {
         L.key*=Ltree[x].lazymul;
         R.key*=Ltree[x].lazymul;
         L.lazyadd*=Ltree[x].lazymul;
         R.lazyadd*=Ltree[x].lazymul;
         L.lazymul*=Ltree[x].lazymul;
         R.lazymul*=Ltree[x].lazymul;
         Ltree[x].lazymul=;
     }
     if (Ltree[x].lazyadd)
     {
         L.key+=Ltree[x].lazyadd;
         R.key+=Ltree[x].lazyadd;
         L.lazyadd+=Ltree[x].lazyadd;
         R.lazyadd+=Ltree[x].lazyadd;
         Ltree[x].lazyadd=;
     }
 }

 int merge(int x,int y)
 {
     if (!x||!y)
     {
         return(x+y);
     }
     if (Ltree[x].key>Ltree[y].key) swap(x,y);
     pushdown(x);
     //!!!这里要pushdown!!这里千万不要忘记pushdown！
     Ltree[x].rson=merge(Ltree[x].rson,y);
     int &l=Ltree[x].lson,&r=Ltree[x].rson;
     if (Ltree[l].dis<Ltree[r].dis) swap(l,r);
     if (r==) Ltree[x].dis=;
         else Ltree[x].dis=Ltree[r].dis+;
     return x;
 }

 void init()
 {
     scanf("%d%d",&n,&m);
     memset(rt,,sizeof(rt));
     for (int i=;i<=n;i++) scanf("%lld",&h[i]);
     for (int i=;i<=n;i++)
     {
         scanf("%d%d%lld",&f[i],&a[i],&v[i]);
         out[f[i]]++;
     }
     Ltree[].dis=-;
     for (int i=;i<=m;i++)
     {
         ll s;int c;
         scanf("%lld%d",&s,&c);
         Ltree[i]=(node){s,,i,,,,};
         rt[c]=merge(rt[c],i);
     }
 }

 void Topology()
 {
     queue<int> que;
     for (int i=;i<=n;i++) if (!out[i]) que.push(i);
     while (!que.empty())
     {
         int u=que.front();que.pop();
         int& root=rt[u];
         int father=f[u];
         while (root && (h[u]>Ltree[root].key))//如果堆顶元素小于城市的防御力，即该骑士会牺牲，则不断弹出
         {
             knight[Ltree[root].pos]=Ltree[root].cnt;
             city[u]++;
             pushdown(root);
             root=merge(Ltree[root].lson,Ltree[root].rson);
         }
         update(root,a[u],v[u]);
         rt[father]=merge(rt[father],root);
         out[father]--;
         if (!out[father]) que.push(father);
     }

     while (rt[])//处理所有能够抵达根节点的所有骑士
     {
         knight[rt[]]=Ltree[rt[]].cnt;
         pushdown(rt[]);
         rt[]=merge(Ltree[rt[]].lson,Ltree[rt[]].rson);
     }
 }

 void printans()
 {
     for (int i=;i<=n;i++) printf("%d\n",city[i]);
     for (int j=;j<=m;j++) printf("%d\n",knight[j]);
 }

 int main()
 {
     init();
     Topology();
     printans();
     return ;
 }