题目传送门

题目大意

给出一个 \(n\) 个点的树，每个点有权值，从中选出一些点，使得满足大根堆的性质。（即一个点的祖先节点如果选了那么该点的祖先节点的权值一定需要大于该点权值）

问能选出来的大根堆的最大大小。\(n\le 2\times 10^5\)

跟尧姐一起想的。

首先不难想到 dp，我们可以设 \(f_{u,i}\) 表示 \(u\) 子树内选出顶点权值 \(\le i\) 的大根堆的最大大小。我们可以列出转移式：

\[f_{u,i}=\max\{\sum_{v\in son_u} f_{v,i},\sum_{v\in son_u} f_{v,i-1}+1\}
\]

然后我们发现这个东西似乎可以线段树合并转移。具体来说我们每次先把儿子的线段树合并起来，然后计算以当前节点为根的大根堆的最大大小。

不难发现，我们需要实现区间取 \(\max\)，单点查询。这个东西如果要硬上的话似乎是不好搞的，因为线段树合并似乎不支持懒标记（此处存疑）。

接着思考，可以发现的是，我们每次修改的一定是一段区间，而且如果能够修改肯定是区间 \(+1\)。于是，我们就可以维护差分数组，然后在线段树上二分找到修改的端点即可。

时间复杂度 \(\Theta(n\log n)\)，空间复杂度 \(\Theta(n\log n)\)。

#include <bits/stdc++.h>
using namespace std;

#define Int register int
#define INF 0x7f7f7f7f
#define MAXN 200005

template <typename T> inline void read (T &t){t = 0;char c = getchar();int f = 1;while (c < '0' || c > '9'){if (c == '-') f = -f;c = getchar();}while (c >= '0' && c <= '9'){t = (t << 3) + (t << 1) + c - '0';c = getchar();} t *= f;}
template <typename T,typename ... Args> inline void read (T &t,Args&... args){read (t);read (args...);}
template <typename T> inline void write (T x){if (x < 0){x = -x;putchar ('-');}if (x > 9) write (x / 10);putchar (x % 10 + '0');}

vector <int> G[MAXN];
int n,uni,res,f[MAXN],rt[MAXN],tmp[MAXN],value[MAXN];

struct Segment{
#define MAXM MAXN*100
    int cnt,son[MAXM][2],sum[MAXM];
    void modify (int &x,int l,int r,int pos,int val){
        if (!x) x = ++ cnt;sum[x] += val;
        if (l == r) return ;
        int mid = (l + r) >> 1;
        if (pos <= mid) modify (son[x][0],l,mid,pos,val);
        else modify (son[x][1],mid + 1,r,pos,val);
    }
    int query (int x,int l,int r,int ql,int qr){
        if (!x) return 0;
        if (ql > qr) return 0;
        if (l >= ql && r <= qr) return sum[x];
        int mid = (l + r) >> 1,res = 0;
        if (ql <= mid) res += query (son[x][0],l,mid,ql,qr);
        if (qr > mid) res += query (son[x][1],mid + 1,r,ql,qr);
        return res;
    }
    int Merge (int x,int y){
        if (!x || !y) return x + y;
        sum[x] += sum[y];
        son[x][0] = Merge (son[x][0],son[y][0]);
        son[x][1] = Merge (son[x][1],son[y][1]);
        return x;
    }
    int find (int x,int l,int r,int t){
        if (!x) return r;
        if (l == r) return l;
        int mid = (l + r) >> 1;
        if (t < sum[son[x][0]]) return find (son[x][0],l,mid,t);
        else return find (son[x][1],mid + 1,r,t - sum[son[x][0]]);
    }
}Tree; 

void dfs (int u){
    f[u] = 1;
    for (Int v : G[u]){
        dfs (v);
        rt[u] = Tree.Merge (rt[u],rt[v]);
    }
    f[u] = Tree.query (rt[u],1,uni,1,value[u] - 1) + 1;
    Tree.modify (rt[u],1,uni,value[u],1);
    int pos = Tree.find (rt[u],1,uni,f[u]);
    if (Tree.query (rt[u],1,uni,1,pos) > f[u]) -- pos;
    if (pos < uni) Tree.modify (rt[u],1,uni,pos + 1,-1);
}

signed main(){
    read (n);
    for (Int i = 1,fa;i <= n;++ i) read (value[i],fa),G[fa].push_back (i),tmp[i] = value[i];
    sort (tmp + 1,tmp + n + 1),uni = unique (tmp + 1,tmp + n + 1) - tmp - 1;
    for (Int i = 1;i <= n;++ i) value[i] = lower_bound (tmp + 1,tmp + uni + 1,value[i]) - tmp;
    dfs (1);write (Tree.query (rt[1],1,uni,1,uni)),putchar ('\n');
    return 0;
}

by @自为风月马前卒

本质上来说是个贪心？？？

可以发现的是，在大根堆大小相同的时候，我们肯定想要顶点的权值尽可能小，这样就对后面合并更优。

于是，我们可以考虑把当前点与子树进行合并，我们如果子树内有比当前点更大的值，我们发现答案不会变，直接替换 set 中比它与它相邻的树即可。否则直接加进来即可。

时间复杂度 \(\Theta(n\log^2n)\)，空间复杂度 \(\Theta(n)\)。

#include<bits/stdc++.h>
#define sit multiset<int>::iterator
using namespace std;
const int MAXN = 2e5 + 10;
inline int read() {
    char c = getchar(); int x = 0, f = 1;
    while(c < '0' || c > '9') {if(c == '-') f = -1; c = getchar();}
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}
vector<int> v[MAXN];
multiset<int> s[MAXN];
int N, val[MAXN];
void dfs(int x, int fa) {
    for(int i = 0; i < v[x].size(); i++) {
        int to = v[x][i];
        if(to == fa) continue;
        dfs(to, x);
        if(s[to].size() > s[x].size()) swap(s[to], s[x]);
        for(sit it = s[to].begin(); it != s[to].end(); it++)
            s[x].insert(*it);
        s[to].clear();
    }
    sit it = s[x].lower_bound(val[x]);
    if(it != s[x].end()) s[x].erase(it);
    s[x].insert(val[x]);
}
main() {
    N = read();
    for(int i = 1; i <= N; i++) {
        val[i] = read();
        int x = read();
        v[i].push_back(x); v[x].push_back(i);
    }
    dfs(1, 0);
    printf("%d", s[1].size());
    return 0;
}