[Usaco2017 Jan]Promotion Counting 线段树合并模板/dfs序

两种做法，因为是求整个子树的值域问题所以可以按dfs序把进点和出点的数量作差#include<bits/stdc++.h>
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
#include<iostream>
#include<math.h>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<iomanip>
#include<bitset>
using namespace std; //

#define ll long long
#define ull unsigned long long
#define pb push_back
#define FOR(a) for(int i=1;i<=a;i++)
#define sqr(a) (a)*(a)
#define dis(a,b) sqrt(sqr(a.x-b.x)+sqr(a.y-b.y))
ll qp(ll a,ll b,ll mod){
ll t=1;while(b){if(b&1)t=t*a%mod;b>>=1;a=a*a%mod;}return t;
}
struct DOT{ll x;ll y;};
inline void read(int &x){int k=0;char f=1;char c=getchar();for(;!isdigit(c);c=getchar())if(c=='-')f=-1;for(;isdigit(c);c=getchar())k=k*10+c-'0';x=k*f;}
const int dx[4]={0,0,-1,1};
const int dy[4]={1,-1,0,0};
const int inf=0x3f3f3f3f;
const ll Linf=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;;

const int maxn=1e5+34;

int v[maxn];

int nodecnt,root;
int val[maxn],happen[maxn],l[maxn],r[maxn],rnd[maxn],size[maxn];

void maintain(int x){size[x]=size[l[x]]+size[r[x]]+happen[x];}
void rturn(int &k){int t=l[k];l[k]=r[t];r[t]=k;maintain(k);maintain(t);k=t;}
void lturn(int &k){int t=r[k];r[k]=l[t];l[t]=k;maintain(k);maintain(t);k=t;}
void insert1(int &x,int v){ //按大小
if(!x){
x=++nodecnt;
l[x]=r[x]=0;
val[x]=v;happen[x]=size[x]=1;rnd[x]=rand();return;
}
size[x]++;
if(val[x]==v)happen[x]++;
else if(v<val[x]){
insert1(l[x],v);
if(rnd[l[x]]<rnd[x])rturn(x);
}else{
insert1(r[x],v);
if(rnd[r[x]]<rnd[x])lturn(x);
}
}
void del(int &x,int v){
if(!x)return;
if(val[x]==v){
if(happen[x]>1){happen[x]--;size[x]--;return;}
if(!l[x]||!r[x])x=l[x]+r[x];
else if(rnd[l[x]]<rnd[r[x]]){rturn(x);del(x,v);}
else{lturn(x);del(x,v);}
}else{
size[x]--;
if(v<val[x])del(l[x],v);
else del(r[x],v);
}
}
int rnk(int x,int v){
if(!x)return 0;
if(val[x]==v)return size[l[x]]+happen[x];
else if(v<val[x])return rnk(l[x],v);
else return size[l[x]]+happen[x]+rnk(r[x],v);
}
int kth(int x,int k){
if(!x)return 0;
if(k<=size[l[x]])return kth(l[x],k);
else if(k>size[l[x]]+happen[x])
return kth(r[x],k-size[l[x]]-happen[x]);
else return val[x];
}
int ans;
void pre(int x,int v){
if(!x)return;
if(v>val[x])ans=x,pre(r[x],v);
else pre(l[x],v);
}
void suf(int x,int v){
if(!x)return;
if(v<val[x])ans=x,suf(l[x],v);
else suf(r[x],v);
}

vector<int>G[maxn];
int Ans[maxn];

void dfs(int x){
insert1(root,v[x]);
int t1=nodecnt-rnk(root,v[x]);
for(int i=0;i<G[x].size();i++){
dfs(G[x][i]);
}
int t2=nodecnt-rnk(root,v[x]);
Ans[x]=t2-t1;

}

int main(){
int n;scanf("%d",&n);
FOR(n)scanf("%d",&v[i]);
for(int i=2,x;i<=n;i++){
scanf("%d",&x);
G[x].pb(i);
}
dfs(1);
for(int i=1;i<=n;i++)printf("%d\n",Ans[i]);
}
一开始没看到各点权不同把平衡树的求rank改了下
-------------------------------------------------------------------------------------------------------------
4000
------------------------------------------

另一种做法是每个点做一个权值线段树，然后把这些权值线段树合并起来
由于线段树只要参数固定生成形状就固定，所以一开始是n个log长的链，每个节点代表一个区间，节点权是出现次数
合并的时候因为大家结构一样所以就左边+左边，右边+右边
空间时间都是nlogn
#include<bits/stdc++.h>
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
#include<iostream>
#include<math.h>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<iomanip>
#include<bitset>
using namespace std; //

#define ll long long
#define ull unsigned long long
#define pb push_back
#define FOR(a) for(int i=1;i<=a;i++)
#define sqr(a) (a)*(a)
#define dis(a,b) sqrt(sqr(a.x-b.x)+sqr(a.y-b.y))
ll qp(ll a,ll b,ll mod){
ll t=1;while(b){if(b&1)t=t*a%mod;b>>=1;a=a*a%mod;}return t;
}
struct DOT{ll x;ll y;};
inline void read(int &x){int k=0;char f=1;char c=getchar();for(;!isdigit(c);c=getchar())if(c=='-')f=-1;for(;isdigit(c);c=getchar())k=k*10+c-'0';x=k*f;}
const int dx[4]={0,0,-1,1};
const int dy[4]={1,-1,0,0};
const int inf=0x3f3f3f3f;
const ll Linf=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;;

const int maxn=2e6+34;

int n,a[maxn],b[maxn];
vector<int>G[maxn];

int seg;
int tree[maxn],lson[maxn],rson[maxn];

int root[maxn],ans[maxn];

void pushup(int rt){tree[rt]=tree[lson[rt]]+tree[rson[rt]];}
void build(int &rt,int l,int r,int pos){
rt=++seg;
if(l==r){
tree[rt]=1;return;
}
int m=l+r>>1;
if(pos<=m)build(lson[rt],l,m,pos);
else build(rson[rt],m+1,r,pos);
pushup(rt);
}
int query(int rt,int l,int r,int a,int b){
if(a<=l&&b>=r)return tree[rt];
int m=l+r>>1;
int ret=0;
if(a<=m)ret+=query(lson[rt],l,m,a,b);
if(b>m)ret+=query(rson[rt],m+1,r,a,b);
return ret;
}
int merge(int x,int y){
if(!x)return y;if(!y)return x;
lson[x]=merge(lson[x],lson[y]);
rson[x]=merge(rson[x],rson[y]);
pushup(x);
return x;
}

void dfs(int u){
for(int i=0;i<G[u].size();i++){
int v=G[u][i];
dfs(v);
root[u]=merge(root[u],root[v]);
}
ans[u]=query(root[u],1,n,a[u]+1,n);
}

int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
b[i]=a[i];
}
sort(b+1,b+1+n);
int tot=unique(b+1,b+1+n)-b-1;

for(int i=1;i<=n;i++){
a[i]=lower_bound(b+1,b+1+tot,a[i])-b;
}
for(int i=2;i<=n;i++){
int x;scanf("%d",&x);
G[x].pb(i);
}
for(int i=1;i<=n;i++){
build(root[i],1,n,a[i]);
}
dfs(1);
for(int i=1;i<=n;i++){
printf("%d\n",ans[i]);
}
}