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());
    }
    
}