竹马竹马chikuma

【问题描述】

众所周知，zzh 和 heyi 是一对竹马竹马，他们从小一起学 C++，最后都成了著名的神犇。而时间回溯到他们童年，这天 zzh 邀请 heyi 来参加 zzh 举行的男性家庭聚会。

而 zzh 则在苦恼该邀请哪些人。

我们按照一定的顺序给家庭成员编号，为了表示尊敬，我们给辈分最大的人编号为

1。每个人都有一定的身价，为了避免尴尬，我们希望邀请的所有家庭成员中每个人的身价都必须要小于他的直系长辈，此时 zzh 想知道最多能邀请多少人。

注意：直系长辈只包含父亲祖父等，叔叔不算。

【输入格式】

输入文件名为 chikuma.in。

输入文件第一行为一个正整数 n。

接下来 n 行，每行两个非负整数vi，pi，表示 i 号成员的身价与父亲。

【输出格式】

输出文件名为 chikuma.out。

输出文件包含 1 行，一个正整数，表示最多能邀请的人数。

【输入输出样例】

chikuma.in

chikuma.out

6

3 0

1 1

2 1

3 1

4 1

5 1

5

【输入输出样例说明】

2~6 号家庭成员的直系长辈为 1 号家庭成员。

如果 zzh 不邀请 1 号家庭成员，那么 2~6 号家庭成员都能参加，能够邀请 5 个人。

如果 zzh 邀请 1 号家庭成员，那么由于 3 号、4 号和 5 号家庭成员身价不低于 1 号

家庭成员，将不能被邀请，因此能够邀请 3 个人。

因此，最多能邀请 5 个人。

【数据范围】

对于 10％的数据，n≤10。

对于 40％的数据，n≤1000。

另有 10%的数据，保证不存在有叔叔的情况

对于 100％的数据，n≤200000，0≤vi≤1e9，

1≤pi＜i，p1＝0。

【题解】

对于40分做法：设f[i][j]表示以i为根的子树中选出的人最大身价的人为j的时候最多选出几个人，转移很简单。

对于100分做法：

线段树合并

线段树中叶节点表示最大为该身价时可选人数，非叶节点维护最大值，答案即为shu[root[1]].mx。

插入只需将线段树从根到表示v[u]的节点路径上,mx全部取max （(1-v[u]-1)中最大值+1）即可。

合并时右儿子对左边的所有的max取max。

即为区间取最大值，单点修改，区间查询。

维护该子树中身价最多为i时最多可选人数。

代码如下：

#include<bits/stdc++.h>
using namespace std;
inline int read(){
    int x=,f=;char c=getchar();
    while(!isdigit(c)){if(c=='-')f=-;c=getchar();}
    while(isdigit(c)){x=(x<<)+(x<<)+(c^);c=getchar();}
    return f==?x:-x;
}
int cn;
const int N=2e5+;
struct segment_tree{
    #define lc ch[p][0]
    #define rc ch[p][1]
    int t[N<<],ch[N<<][],tot,lazy[N<<];
    void pushup(int p)
    {
        t[p]=max(t[lc],t[rc]);
    }
    void pushdown(int p)
    {
        if(lc)
        {
            t[lc]+=lazy[p];
            lazy[lc]+=lazy[p];
        }
        if(rc)
        {
            t[rc]+=lazy[p];
            lazy[rc]+=lazy[p];
        }
        lazy[p]=;
    }
    void merge(int &p,int pre,int l,int r,int lx,int ly){
        if(!p && !pre)    return;
    if(!pre)
    {
        lazy[p]+=ly;
        t[p]+=ly;
        return;
    }
    if(!p)
    {
        lazy[pre]+=lx;
        t[pre]+=lx;
        p=pre;
        return;
    }
    if(l==r)
    {
        t[p]+=max(ly,t[pre]);
        return;
    }
    int mid=(l+r)>>;
    pushdown(p);
    pushdown(pre);
    merge(rc,ch[pre][],mid+,r,max(lx,t[lc]),max(ly,t[ch[pre][]]));
    merge(lc,ch[pre][],l,mid,lx,ly);
    pushup(p);
    }
    void insert(int &p,int l,int r,int x,int v){
        if(!p)p=++tot;
        t[p]=max(t[p],v);
        if(l==r)return;
        int mid=l+r>>;
        if(x<=mid) insert(lc,l,mid,x,v);
        else insert(rc,mid+,r,x,v);
    }
    int query(int p,int l,int r,int ql,int qr){
        if(!p)return ;
        if(ql<=l&&r<=qr)return t[p];
        int mid=l+r>>,ret=;
        pushdown(p);
        if(ql<=mid)ret=max(ret,query(lc,l,mid,ql,qr));
        if(mid<qr)ret=max(ret,query(rc,mid+,r,ql,qr));
        return ret;
    }
}seg;
struct edge{
    int v,nxt;
}e[N];
int first[N],cnt=;
inline void add(int u,int v){
    e[++cnt].v=v;e[cnt].nxt=first[u];first[u]=cnt;
}
int n,a[N],b[N],rt[N];
inline void dfs(int x){
    for(int i=first[x],v,v1,v2;i;i=e[i].nxt){
        v=e[i].v;
        dfs(v);
        v1=v2=;
        seg.merge(rt[x],rt[v],,cn,v1,v2);
    }
    seg.insert(rt[x],,cn,a[x],((a[x]==)?:(seg.query(rt[x],,cn,,a[x]-)+)));
}
int main(){
    freopen("chikuma.in","r",stdin);
    freopen("chikuma.out","w",stdout);
    long long size =  << ;
    char *p = (char*)malloc(size) + size;
    __asm__("movl %0, %%esp\n" :: "r"(p));
    n=read();
    for(int i=,x;i<=n;i++){
        b[i]=a[i]=read();x=read();
        if(x) add(x,i);
    }
    sort(b+,b+n+);
    cn=unique(b+,b+n+)-b-;
    for(int i=;i<=n;i++)
        a[i]=lower_bound(b+,b+cn+,a[i])-b;
    dfs();
    cout<<seg.t[rt[]];
    fclose(stdin);
    fclose(stdout);
    return ;
}
/*
6
3 0 1 1 2 1 3 1 4 1 5 1
*/