【题解】晋升者计数 Promotion Counting [USACO 17 JAN] [P3605]

奶牛们又一次试图创建一家创业公司，还是没有从过去的经验中吸取教训。!牛是可怕的管理者！

【题目描述】

奶牛从 $1$ ~ $N(1≤N≤1e5)$ 进行了编号，把公司组织成一棵树，$1$号奶牛作为总裁（树的根节点）。除总裁以外的每头奶牛都有且仅有唯一的一个的上司（即它在树上的父结点）。每一头牛$i$都有一个不同的能力指数 $p(i)$，描述了她对其工作的擅长程度。如果奶牛 $i$ 是奶牛 $j$ 的父亲或祖先节点，那么奶牛 $j$ 即为 $i$ 的下属。

不幸地是，奶牛们发现经常有一个上司比她的下属能力低的情况，在这种情况下，上司应当考虑晋升她的一些下属。你的任务是对于公司的中的每一头奶牛 $i$，计算其满足 $p(j)>p(i)$ 的下属 $j$ 的数量。

【输入】

输入的第一行包括一个整数 $N$。

接下来的 $N$ 行表示每头奶牛的能力指数 $p(1),p(2)...p(N)$，接下来的 $N−1$ 行描述每头奶牛 $(2$ ~ $N)$ 的上司（父节点）的编号。

【输出】

输出包括 $N$ 行，输出的第 $i$ 行表示奶牛 $i$ 的下属中能力比奶牛 $i$ 高的数量。

【样例】

【数据规模】

$100\%$ $1 \leqslant N \leqslant 1e5,1 \leqslant p(i) \leqslant 1e9$

【分析】

不会线段树的先到隔壁去逛逛：线段树详解（全）

问题实质：求树上逆序对

解法一：树状数组 / 线段树 + dfs

对能力值开一个权值线段树$($范围较大 $1e9$，加一个离散化$)$。

对于每个节点 $i$，在线段树中查询数值大于 $a[i]$ 的数的个数，再对于点 $i$ 所有儿子节点的权值都进行一次【单点修改】操作，将它们都加入进去，再一次进行同样的查询，用其减去前面查询的结果就得到变化量 ∆，即刚刚加入的这个儿子所统领的树$($包括它自己$)$中能力大于 $p(i)$ 的牛的数量，即 $ans[i]$。树状数组可用同样的思路。

【Code】

（线段树）

#include<algorithm>

#include<cstdio>

#define pl p<<1//左段儿子的编号

#define pr p<<1|1//右段儿子的编号

#define Re register int

#define F(a,b) for(i=a;i<=b;++i)

const int N=1e5+3;

int x,i,n,t,Q[N],ip[N],ans[N],nex[N],head[N],tree[N<<2];

struct A{int x,i;bool operator<(A b)const{return x<b.x;};}a[N];

//【重载"<"运算符】自己动手,丰衣足食...

inline void add(Re x,Re y){Q[++t]=y,nex[t]=head[x],head[x]=t;}//数组维护一个链表

inline void in(Re &x){//【快读】自己动手,丰衣足食...

    x=0;char c=getchar();

    while(c<'0'||c>'9')c=getchar();

    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();

}

inline void change(Re p,Re x,Re L,Re R){

//【单点修改】每个人仅有一个能力值，所以是单点修改

	if(L==R){++tree[p];return;}//单点修改的边界:L==R

	Re mid=L+R>>1;

	if(x<=mid)change(pl,x,L,mid);//注意:单点修改中，进入递归函数的前提：x<=mid

	else change(pr,x,mid+1,R);//x>mid

	tree[p]=tree[pl]+tree[pr];//递归完子树后更新

}

inline int ask(Re p,Re l,Re r,Re L,Re R){//【区间查询】

	if(l<=L&&R<=r)return tree[p];//区间查询的边界: l<=L&&R<=r

	Re ans=0,mid=L+R>>1;

	if(l<=mid)ans+=ask(pl,l,r,L,mid);//注意区间查询中，进入递归函数的前提：l<=mid

	if(r>mid)ans+=ask(pr,l,r,mid+1,R);//r>mid

	return ans;

}

inline void dfs(Re x){//搜索遍历树

	ans[x]-=ask(1,ip[x]+1,n,1,n);//这里计算出的是其他节点的数据，要减去

	for(Re i=head[x];i;i=nex[i])dfs(Q[i]);//先让儿子更新线段树【单点修改】

	ans[x]+=ask(1,ip[x]+1,n,1,n);

	//查询大于当前这个点x的等级的一共有多少个【区间查询】，再减去原先的

	change(1,ip[x],1,n);//让当前这个点x的等级进行【单点修改】

}

int main(){

	in(n);

	F(1,n)in(a[i].x),a[i].i=i;

	std::sort(a+1,a+n+1);//【离散化】依据每个人的能力p(i)排出他们的等级

	F(1,n)ip[a[i].i]=i;//用ip[]记录下每个点的等级

	F(2,n)in(x),add(x,i);//链表建树，实现从根节点到儿子叶节点的遍历

	dfs(1);//从没有上司的根节点1开始遍历

	F(1,n)printf("%d\n",ans[i]);

}

（树状数组）

#include<algorithm>

#include<cstdio>

#define Re register int

#define F(a,b) for(i=a;i<=b;++i)

const int N=1e5+3;

int x,i,n,t,C[N],Q[N],ip[N],ans[N],nex[N],head[N];

struct A{int x,i;bool operator<(A b)const{return x<b.x;};}a[N];

inline void add(Re x,Re y){Q[++t]=y,nex[t]=head[x],head[x]=t;}

inline void in(Re &x){

    x=0;char c=getchar();

    while(c<'0'||c>'9')c=getchar();

    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();

}

inline void addx(Re x){while(x<=n)++C[x],x+=x&(-x);}

inline int ask(Re x){int ans=0;while(x)ans+=C[x],x-=x&(-x);return ans;}

inline void dfs(Re x){

    ans[x]-=ask(n)-ask(ip[x]);

    for(Re i=head[x];i;i=nex[i])dfs(Q[i]);

    ans[x]+=ask(n)-ask(ip[x]);

    addx(ip[x]);

}

int main(){

    in(n);

    F(1,n)in(a[i].x),a[i].i=i;

    std::sort(a+1,a+n+1);

    F(1,n)ip[a[i].i]=i;

    F(2,n)in(x),add(x,i);

    dfs(1);

    F(1,n)printf("%d\n",ans[i]);

}

解法二：线段树合并

对于 $N$ 个点每个点都开一个权值线段树。

对公司上司下属关系形成的树进行$dfs$遍历，对于每个节点 $i$ ，将它所有儿子的权值线段树合并到 $tree[pt[i]]($ 用 $pt[i]$ 表示节点 $i$ 所对应的权值线段树的根节点编号$)$，然后在 $tree[pt[i]]$ 中查询数值大于 $a[i]$ 的数的个数即为 $ans[i]$。

【Code】

#include<algorithm>

#include<cstdio>

#define pl tr[p].lp//左段儿子的编号

#define pr tr[p].rp//右段儿子的编号

#define Re register int

#define F(a,b) for(i=a;i<=b;++i)

const int N=1e5+3;

int x,i,n,t,cnt,Q[N],pt[N],ip[N],ans[N],nex[N],head[N];

struct QAQ{int g,lp,rp,L,R;}tr[N*18];//这里的空间消耗要注意，开太小死活过不了

struct A{int x,i;bool operator<(A b)const{return x<b.x;};}a[N];

//【重载"<"运算符】自己动手,丰衣足食...

inline void add(Re x,Re y){Q[++t]=y,nex[t]=head[x],head[x]=t;}//数组维护一个链表

inline void in(Re &x){//【快读】自己动手,丰衣足食...

    x=0;char c=getchar();

    while(c<'0'||c>'9')c=getchar();

    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();

}

inline void change(Re p,Re x){//【单点修改】(虽然在这道题中没什么用)

    Re L=tr[p].L,R=tr[p].R;//把编号为p的这个区间所覆盖的范围L,R提出来

    if(L==R){++tr[p].g;return;}//单修的递归边界:L==R

    Re mid=L+R>>1;

    if(x<=mid)change(pl,x);//注意:单修中进入递归函数的前提：x<=mid

    else change(pr,x);//x>mid

    tr[p].g=tr[pl].g+tr[pr].g;//递归完子树后更新

}

inline void creat(Re &p,Re x,Re L,Re R){//建立线段树

    tr[p=++cnt].L=L,tr[p].R=R;//动态开点，并记录新编号子树所覆盖的区间范围L,R

    if(L==R){tr[p].g=1;return;}//建立线段树时是一个点一个点的建，所以边界类似于单修

    Re mid=L+R>>1;

    if(x<=mid)creat(pl,x,L,mid);//递归进入前提也类似于单修

    else creat(pr,x,mid+1,R);

    tr[p].g=tr[pl].g+tr[pr].g;//递归完子树后更新

}

inline int merge(Re p,Re q){//【线段树合并】

    if(!p)return q;if(!q)return p;

    //当需要合并的点的其中一个编号为0时 (即为空)，返回另一个编号

    tr[p].g+=tr[q].g,p;//把q合并到p上面去

    pl=merge(pl,tr[q].lp);//分别合并左子树,右子树

    pr=merge(pr,tr[q].rp);

    return p;

}

inline int ask(Re p,Re l,Re r){//【区间查询】

    if(!p)return 0;

    Re L=tr[p].L,R=tr[p].R;

    if(l<=L&&R<=r)return tr[p].g;//区间查询的边界: l<=L&&R<=r

    Re ans=0,mid=L+R>>1;

    if(l<=mid)ans+=ask(pl,l,r);//注意区间查询中，进入递归函数的前提：l<=mid

    if(r>mid)ans+=ask(pr,l,r);//r>mid

    return ans;

}

inline void dfs(Re x){//搜索遍历树

    for(Re i=head[x];i;i=nex[i]){

        dfs(Q[i]);//先完善儿子的线段树

        merge(pt[x],pt[Q[i]]);//把儿子合并进来

    }

    ans[x]=ask(pt[x],ip[x]+1,n);

    //查询大于当前这个点x的等级的一共有多少个【区间查询】，再减去原先的

}

int main(){

    in(n);

    F(1,n)in(a[i].x),a[i].i=i;

    std::sort(a+1,a+n+1);//【离散化】依据每个人的能力p(i)排出他们的等级

    F(1,n)ip[a[i].i]=i,creat(pt[a[i].i],i,1,n);

    //用ip[]记录下每个点的等级,并建立线段树

    //【注意】：进入建树时的编号是原本输入时的编号即a[i].i

    F(2,n)in(x),add(x,i);//链表建搜索树，实现从根节点到儿子叶节点的遍历

    dfs(1);//从没有上司的根节点1开始遍历

    F(1,n)printf("%d\n",ans[i]);

}