P4577 [FJOI2018] 领导集团问题 （整体 dp）

P4577 [FJOI2018] 领导集团问题

2024.11.14

整体 dp

容易想到用 dp 求解问题。$w_i$ 只关心大小关系，先离散化了。

一个节点的选择只关心子树中选的最小的点。但其实我们并不需要最小的点具体到底是多少，所以只需要用一个状态框住值域就好了。

于是自然就设 $f_{u,i}$ 表示在 $u$ 子树中选了若干点，点权都 $\ge i$ 的最大点集。转移也是子树信息合并。用线段树合并实现 dp。

如果这题能够注意到值域的包含在这题意味着信息的单调性。那么转移就是一段后缀。区间修改又可以用差分转换为单点修改，维护的信息就变为前缀和。实现起来就更简单了。

先将权值离散化到 $[1,m]$。

考虑朴素的树形 dp，设 $f_{u,i}$ 表示在 $u$ 子树中选了若干点，点权都 $\ge i$ 的最大点集。转移分为是否选 $u$ 点：

不选 $u$ 点，对于 $i\in [1,m]$，$f_{u,i}=\sum f_{v,i}$

选 $u$ 点，对于 $i\in [1,a_u]$，$f_{u,i}=max(f_{u,i},\sum f_{v,a_u}+1)$

前者由于状态中为 $\ge i$，所以就是一个单点加；后者是区间修改 $max$。这些操作都是线段树合并操作，考虑整体 dp，前者 merge 操作时覆盖，后者区间覆盖 $max$，也可以线段树维护标记。但是在动态开点线段树上区间修改较复杂，在这题有更好的办法。

可以发现 $f_{u,i}\ge f_{u,i+1}$，也就是序列是从左到右单调递减的，再看第二个操作，$f_{u,a_u}$ 一定会加 $1$，然后就是覆盖一段 $[p,a_u]$ 权值都是 $f_{u,a_u}$ 的极大区间，并且改变的量为 $1$。考虑一个 trick，维护 $g_{u,i}=f_{u,i}-f_{u,i+1}$。区间覆盖就变成只需要修改 $p-1$ 和 $a_u$ 两个点的差分值即可（区间 $[p,a_u]$ 的差分值都是 $0$）。考虑 $p$ 的求法，只需要在线段树二分即可，单次 $O(\log n)$。

复杂度 $O(n\log n)$。

#include <bits/stdc++.h>
#define pii std::pair<int, int>
#define fi first
#define se second
#define pb push_back
typedef long long i64;
const int N = 2e5 + 10;
int n, cnt, tot, num, ans;
int a[N], b[N];
int h[N];
struct node {
	int to, nxt;
} e[N << 1];
void add(int u, int v) {
	e[++cnt].to = v;
	e[cnt].nxt = h[u];
	h[u] = cnt;
}
struct seg {
	int ls, rs, sm;
} t[N * 40];
void gtag(int u, int v) {if(u) t[u].sm += v;}
void pushup(int u, int ls, int rs) {
	t[u].sm = 0;
	if(ls) t[u].sm = t[ls].sm;
	if(rs) t[u].sm += t[rs].sm;
}
void ins(int &u, int l, int r, int x, int y) {
	if(!x) return;
	if(!u) u = ++tot;
	if(l == r) {
		gtag(u, y);
		return; 
	}
	int mid = (l + r) >> 1;
	if(x <= mid) ins(t[u].ls, l, mid, x, y);
	else ins(t[u].rs, mid + 1, r, x, y);
	pushup(u, t[u].ls, t[u].rs);
}
int query(int u, int l, int r, int L, int R) {
	if(!u) return 0;
	if(L <= l && r <= R) {
		return t[u].sm;
	}
	int mid = (l + r) >> 1, ret = 0;
	if(L <= mid) ret += query(t[u].ls, l, mid, L, R);
	if(R > mid) ret += query(t[u].rs, mid + 1, r, L, R);
	return ret;
}
void mg(int p1, int p2, int l, int r) {
	if(l == r) {
		t[p1].sm += t[p2].sm;
		return;
	}
	int mid = (l + r) >> 1;
	if(t[p1].ls && t[p2].ls) mg(t[p1].ls, t[p2].ls, l, mid);
	else if(t[p2].ls) t[p1].ls = t[p2].ls;
	if(t[p1].rs && t[p2].rs) mg(t[p1].rs, t[p2].rs, mid + 1, r);
	else if(t[p2].rs) t[p1].rs = t[p2].rs;
	pushup(p1, t[p1].ls, t[p1].rs);
}
int find(int u, int l, int r, int v) {
	if(!u) return 0;
	if(l == r) {
		if(t[u].sm < v) return l - 1;
		return l;
	}
	int mid = (l + r) >> 1;
	if(v <= t[t[u].rs].sm) return find(t[u].rs, mid + 1, r, v); 
	else return find(t[u].ls, l, mid, v - t[t[u].rs].sm);
}
void dfs(int u, int fa) {
	for(int i = h[u]; i; i = e[i].nxt) {
		int v = e[i].to;
		if(v == fa) continue;
		dfs(v, u);
		mg(u, v, 1, num);
	}
	int sum = query(u, 1, num, a[u], num), p = find(u, 1, num, sum + 1);
	ins(u, 1, num, a[u], 1), ins(u, 1, num, p, -1);
}
void Solve() {
	std::cin >> n;

	tot = n;
	for(int i = 1; i <= n; i++) {
		std::cin >> a[i];
		b[++num] = a[i];
	}
	std::sort(b + 1, b + num + 1);
	num = std::unique(b + 1, b + num + 1) - b - 1;
	for(int i = 1; i <= n; i++) {
		a[i] = std::lower_bound(b + 1, b + num + 1, a[i]) - b;
	}
	for(int i = 2; i <= n; i++) {
		int u;
		std::cin >> u;
		add(u, i), add(i, u);
	}

	dfs(1, 0);
	std::cout << query(1, 1, num, 1, num) << "\n";
}
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
	Solve();

	return 0;
}