[CF1481F]AB Tree

题目

传送门 to CF

题目描述
一棵树，每个节点有字母 a 或 b，定义字符串 $s_i=s_{p_i}+c_i$，其中 + 为字符串的拼接，$p_i$ 为 $i$ 的父节点，$c_i$ 为 $i$ 节点上的字母。根节点 $s_1=c_1$ 。

现在请你寻找一个方案，使得恰好 $k$ 个节点是字母 a（剩余的 $n-x$ 个节点就是 b 呗），并且最小化不同的 $s_i(1\le i\le n)$ 的数量。

数据范围与提示
$n\le 10^5$ 。提示：$CF$ 的机子挺快，$\mathcal{O}(n\log n)$ 一般会开 $n\le 2\times 10^5$ 。

思路

想了很久，没有找到好的方法 $\mathtt{d}\mathtt{p}$ 。那么考虑先枚举答案，再看看有没有方案。

假设长度最大的字符串长度为 $l$，那么答案至少为 $l$ 。要做到这一点，需要每一层（同一深度的点）选择同一种字母。那么这里就是一个背包了。我甚至连这个背包都只会 $\mathcal{O}(n^2)$ 的……

事实上，这是一个部分背包，物品种类最多 $\sqrt{n}$ 种（因为所有物品的重量之和为 $n$，最坏是 $1+2+3+\cdots +\sqrt{n}$ 嘛）。所以这是 $\mathcal{O}(n^{\frac{3}{2}})$ 的。

继续，答案有没有可能为 $l+1$ 呢？即，只有某一层出现了不同的字符，非叶子节点字母相同。再即，选某几层，其节点数量为 $p(p\le k)$，再另外选一层，其叶子节点数量不小于 $k-p$ 。不妨设 $k\le n-k$ 。

这里留给读者一个弹性空间，可以自己想一想 $l+1$ 是否可行。

你会发现，上面这个东西好像并不容易证明。所以我想到这里也就终止了。可是题解告诉我们，$l+1$ 可以直接构造出来。

从上往下，一层一层填字母。设当前剩余的 a、b 字母个数分别为 $x,y$，那么当前一层的节点数量不超过 $\max (x,y)$ 时，直接填相同的。否则这一层必须不同。只需要证明，我们可以让非叶子节点选择同样的字符——因为接下来可以让剩余的这种字符在叶子节点上用尽。

设非叶子节点数量为 $l$，那么 $l$ 个节点至少有一个子节点，而节点总数是 $x+y$，所以 $2l\le x+y$ 。而 $\max (x,y)\ge \frac{x+y}{2}\ge l$，所以这 $l$ 个点可以涂同一个字符！不妨设选择了 a，由于 a 总数不足以把这一层填满，所以可以把剩下的 a 在这一层的叶子节点中用光。剩下的每一层当然都一样。

所以我们就构造出了 $l+1$ 的答案。根据我们的分析，这就是 $\mathrm{o}\mathrm{p}\mathrm{t}\mathrm{i}\mathrm{m}\mathrm{a}\mathrm{l}$ 的。时间复杂度 $\mathcal{O}(n\sqrt{n})$ 。

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long int_;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}

const int MaxN = 100005;
vector<int> G[MaxN];
int cnt[MaxN]; // for every depth
int dep[MaxN];
void getInfo(int x){
	++ cnt[dep[x]];
	for(int y : G[x]){
		dep[y] = dep[x]+1;
		getInfo(y);
	}
}

int *dp[MaxN], tmp[MaxN];
int buc[MaxN], n;
void getWay(int x,int y){
	if(!x) return ;
	getWay(x-1,y-tmp[x-1]*dp[x][y]);
	buc[tmp[x-1]] += dp[x][y];
}
char choice[MaxN];
void giveColor(){
	rep(i,0,n-1)
		if(buc[cnt[i]]){
			-- buc[cnt[i]];
			choice[i] = 'a';
		}
		else choice[i] = 'b';
	rep(i,1,n)
		putchar(choice[dep[i]]);
	putchar('\n');
}

int countLeaf(int x){
	int leaf = 0;
	rep(i,1,n)
		if(dep[i] == x)
			if(G[i].empty())
				++ leaf;
	return leaf;
}
void worstCase(int k){
	int rest = n, cut = 0, zxy = 0;
	char xjx; // choice on cut layer
	rep(i,0,n-1)
		if(k >= cnt[i]){
			choice[i] = 'a';
			k -= cnt[i];
			rest -= cnt[i];
		}
		else if(rest-k >= cnt[i]){
			choice[i] = 'b';
			rest -= cnt[i];
		}
		else{
			cut = i; // here it breaks
			int unleaf = cnt[i]-countLeaf(i);
			if(unleaf <= k){
				zxy = k-unleaf;
				xjx = 'a', k = 0;
			}
			else{
				zxy = rest-k-unleaf;
				xjx = 'b', k = rest-cnt[i];
			}
			rest -= cnt[i];
		}
	rep(i,1,n)
		if(dep[i] != cut)
			putchar(choice[dep[i]]);
		else if(!G[i].empty())
			putchar(xjx); // official
		else if(zxy) -- zxy, putchar(xjx);
		else putchar('a'+'b'-xjx);
	putchar('\n');
}

int main(){
	n = readint(); int k = readint();
	for(int i=2; i<=n; ++i)
		G[readint()].push_back(i);
	getInfo(1); // dep[1] = 0
	int L = *max_element(dep+1,dep+n+1);
	memcpy(tmp,cnt,(L+1)<<2);
	sort(tmp,tmp+L+1);
	dp[0] = new int[n+1];
	memset(dp[0]+1,-1,n<<2);
	int tot = dp[0][0] = 0;
	for(int l=0,r=0; l<=L; l=r){
		dp[++ tot] = new int[n+1];
		rep(i,0,n) // inherit
			if(~dp[tot-1][i])
				dp[tot][i] = 0;
			else dp[tot][i] = -1;
		while(r < n && tmp[r] == tmp[l])
			++ r; // [l,r) the same
		int *jb = dp[tot];
		for(int i=tmp[l]; i<=n; ++i)
			if(jb[i] == -1) // need transfer
			if(~jb[i-tmp[l]] && jb[i-tmp[l]] != r-l)
				jb[i] = jb[i-tmp[l]]+1;
	}
	unique(tmp,tmp+L+1); // what's true
	if(~dp[tot][k]){
		getWay(tot,k);
		printf("%d\n",L+1);
		giveColor();
		return 0; // optimal
	}
	printf("%d\n",L+2);
	worstCase(k);
	return 0;
}