Astar 2019 Quasi Binary Search Tree

题意

给一颗\(n\)个点的二叉树，每个点被标上了\(1\)到\(n\)中不同的标号

定义一棵树为伪二叉树当且仅当对于每个节点，其左子树所有节点的标号都小于它本身，右子树所有节点的标号都大于它本身；或是左子树所有节点的标号都大于它本身，右子树所有节点的标号都小于它本身

现在有一颗未标号的树，请为其标号使它成为一颗伪二叉树。如果有多组解，请输出字典序最小的解，即比较\(1\)号点的标号，再比较\(2\)号点的标号，以此类推

解法

先考虑这颗树是标准的二叉查找树的形式我们该如何对其进行标号：

我们能够发现这个问题是标准的分治求解形式

具体来说，就是从根节点开始遍历，并在根节点处填上其左子树大小加一的数

接下来就可以分别处理两颗子树，显然它们是互不影响的；

但是这道题给出的数并不是一颗标准的二叉查找树，而是一颗伪二叉树

所以当前遍历到的节点处既可以填左子树大小加一的数，也可以填右子树大小加一的数

如果暴力进行填数，复杂度是\(O(2^N)\)次方的，不能接受

此时我们可以发现题目的另一个限制：字典序最小

这个条件可以作为我们在填数时选择的依据

在转移时分类讨论一下即可，代码里有注释

代码

#include <cstdio>
#include <cstring>

using namespace std;

const int N = 1e5 + 10;
const int mod = 1e9 + 7;

int n, t, rt;
int ls[N], rs[N], mn[N], sz[N], deg[N];

int res[N];

inline int min(int x, int y) {
	return x < y ? x : y;	
}

inline int qpow(int x, int y) {
	int ret = 1;
	while (y) {
		if (y & 1)	ret = 1LL * ret * x % mod;
		x = 1LL * x * x % mod, y >>= 1;
	}
	return ret;
}

void dfs(int x) {	//预处理出子树大小与子树最小值 
	sz[x] = 1, mn[x] = x;
	if (ls[x])	
		dfs(ls[x]), sz[x] += sz[ls[x]], mn[x] = min(mn[x], mn[ls[x]]);
	if (rs[x])
		dfs(rs[x]), sz[x] += sz[rs[x]], mn[x] = min(mn[x], mn[rs[x]]);
}

void DFS(int x, int l, int r) {
	if (l == r)	return res[x] = l, void();
	if (ls[x] && rs[x]) { 				//若既有左儿子也有右儿子 
		int lc = sz[ls[x]], rc = sz[rs[x]];	
		if (mn[x] == x) {				//若当前节点就是其所在子树中最小值，贪心选取使它最小 
			if (lc < rc) {
				DFS(ls[x], l, l + lc - 1);
				DFS(rs[x], l + lc + 1, r);
				res[x] = l + lc;
			} else if (lc > rc) {
				DFS(ls[x], l + rc + 1, r);
				DFS(rs[x], l, l + rc - 1);
				res[x] = l + rc;
			} else {					//这里讨论的情况不能与下面的合并
				if (mn[ls[x]] < mn[rs[x]]) {
                	DFS(ls[x], l, l + sz[ls[x]] - 1);
                	DFS(rs[x], r - sz[rs[x]] + 1, r);
					res[x] = l + sz[ls[x]];
                } else {
					DFS(rs[x], l, l + sz[rs[x]] - 1);
					DFS(ls[x], l + sz[rs[x]] + 1, r);
					res[x] = l + sz[rs[x]];				  
			    }					
			}
		} else {
			if (mn[x] == mn[ls[x]]) {	//如果最小值在左子树，即选择让左子树更优 
				DFS(ls[x], l, l + lc - 1);
				DFS(rs[x], l + lc + 1, r);
				res[x] = l + lc;	
			}
			if (mn[x] == mn[rs[x]]) {	//否则选择让右子树最优 
				DFS(ls[x], l + rc + 1, r);
				DFS(rs[x], l, l + rc - 1);
				res[x] = l + rc;
			}
		}
	} else {	//如果仅有左/右儿子，讨论一下当前节点是否为最小值即可 
		if (ls[x]) {	 
			if (mn[x] == x)
				res[x] = l, DFS(ls[x], l + 1, r);
			else
				res[x] = r, DFS(ls[x], l, r - 1);
		}
		if (rs[x]) {
			if (mn[x] == x)
				res[x] = l, DFS(rs[x], l + 1, r);
			else 
				res[x] = r, DFS(rs[x], l, r - 1);
		}
	}
		
}

long long solve() {
	long long ret = 0;
	for (int i = 1; i <= n; ++i)
		ret = (ret + 1LL * (res[i] ^ i) * qpow(233, i) % mod) % mod;	
	return ret;
}

int main() {
	
	scanf("%d", &t);
	while (t--) {
		scanf("%d", &n);	
		for (int i = 1; i <= n; ++i)	
			deg[i] = 0;		
		for (int i = 1; i <= n; ++i)
			scanf("%d%d", ls + i, rs + i);
		for (int i = 1; i <= n; ++i)
			deg[ls[i]]++, deg[rs[i]]++;
		rt = 1;
		while (deg[rt])	++rt;
		
		dfs(rt);
		DFS(rt, 1, n);
		
		printf("%lld\n", solve());
	}
	
}