联合省选D2T1 迷宫守卫 题解
没有参加省选 qwq。
简要题意：给定一棵满二叉树，共有 \(2^n\) 个叶子节点，每个叶子节点有一个值 \(q_x\) ，保证所有叶子节点的值构成一个 \(1\sim 2^n\) 的排列。每个非叶子节点有一个花费 \(w_x\)，可以花费 \(w_x\) 的价值操作当前节点，使得遍历到当前点时只可以先访问左子树，再访问右子树。否则可以任意选择一棵子树优先遍历，再遍历另一棵子树。
按照叶子节点遍历的先后可以得到 \(q\) 的一个排列。
现在有两人在树上博弈，甲希望字典序越大，并有 \(k\) 元可以随机操作一些节点，乙知道甲的操作，并希望字典序越小。
求最终的排列。
Solution
看到字典序最小，有一个很通用的套路，就是保证第一位尽量小，因为无论如何后面多小都没有用。
我们先考虑怎么做到排列第一位最小。
站在先用最暴力的方法，考虑枚举法。我们假设已经得到第 \(1\) 位大小是 \(x\) 。考虑为什么 \(x\) 能成为第一位，明显地，因为甲把权值小于等于 \(x\) 的节点全部堵死了，去不了。这时候，\(x\)是最优节点。
换个思路考虑，我们把所有叶子结点权值 \(q_x\) 小于等于 \(x\) 的都打上一个标记，表示这个点不能到达。然后计算出堵住这些节点的花费最小值 \(v\) 是否大于钱数 \(k\)。如果大于，说明堵不住，这时候 \(x\) 是可行的。
我们考虑从小到大枚举这些节点，枚举到第一个可行的就是答案，容易证明从小到大枚举花费一定是递增的，因为要保证堵住原先节点的同时堵住新节点。
现在考虑如何求得堵住这些点的最小花费，不难发现，对于任意点 \(u\) ，有两种方法：
- 同时堵住 \(u\) 的左子树和右子树
- 堵住 \(u\) 的左子树的同时给 \(x\) 打上标记
这个问题可以使用 dp 。定义 \(f_u\) 表示堵住 \(u\) 子树的最小花费，如果一个叶子节点 \(x\) 是要求被堵住的，我们设 \(f_x=inf\) 即可 那么容易求得 \(f_u=\min(f_{lson}+f_{rson},f_{lson}+w_u)\)
同时，我们每次对叶子节点 \(x\) 打上标记 ，只有 \(x\) 到根的路径改变了状态，我们只需改变这些状态即可。
根据上面这些，我们在 \(O(2^n)\) 的时间内确定了第一个数。
那么怎么求第二个数呢？
其实，根据上面的推理，我们已经确定了第一个数在根节点的哪棵子树内，这时，我们惊奇的发现，这个子树内的推理和根节点的推理是完全一致的！直接递归处理即可！
不对，好像忽略了一个点，还没有确定给这棵子树多少费用。
假设第一个数在左子树，那么前半部分的排列一定在左子树内，我们只需要把保证合法的最少费用抠出来给右子树，其它都给左子树即可。
怎么保证合法呢？不就是右子树堵住 \(1\sim x-1\) 的前提下的最小花费嘛。这个我们在求 \(f_u\) 时就已经预处理好了，但是是更新 \(x\) 点的上一次。同时还有一种情况就是取了当前节点，直接先不往右子树走了。我们先把这些最小花费从 \(k\) 中扣出来，遍历右子树时再加回去不就保证不会透支了嘛！qwq
我们把左子树遍历完后，加上之前抠出来的预算，就得到了右节点的钱 \(k_r\)。这个时候再次考虑要不要取当前节点，如果右节点堵住 \(1\sim x-1\) 的钱比 \(k_r\) 小，那么取当前节点一定不优。因为保证条件的情况下取了当前节点就是浪费钱，可以理解为在够钱时取不取当前节点遇到的是相同的子问题。
但是如果堵住的钱比 \(k_r\) 大，那么这个点就必须取了，因为不取就不满足堵住 \(1\to x-1\) 的条件了。
同时第一个数在右子树同理，讨论左子树即可。但是就没有取当前节点的情况了。走右子树当前节点一定是不取的。
对于子树，我们通过同样方式讨论即可。最后到达叶子节点输出即可。
看起来这个做法太暴力了，但仔细想一想却不是这样。
暴力取出每个点是 \(O(n2^n)\) 的，考虑每个点取到的条件是枚举到了当前节点的祖先，而满二叉树祖先个数和树高数相同的。
暴力求 dp 是 \(O(n^22^n)\) 的。考虑每个点都会跳到祖先一次，所以每个点跳跃次数就是祖先深度和。
在从小到大枚举目前最优值时，直接把所有数扔出来 sort 一下就行了，比较还有一个时间复杂度比它大的 dp。
总体时间复杂度是 \(O(n^22^n)\) 的。一般不特意卡跑不满。
code
#include<bits/stdc++.h>
#define N 152005
#define ll long long
#define inf 1e18
#define ls(x) x<<1
#define rs(x) x<<1|1
#define fa(x) x/2
using namespace std;
int g;
int n,m,p[N],pos[N];
ll k,w[N],f[N];
int L[N],R[N];
int stk[N],top;
void getf(int now,int topf)
{
f[now]=inf;
now=fa(now);
while(now^topf)
{
f[now]=f[ls(now)]+min(f[rs(now)],w[now]);
now=fa(now);
}
}
void clr(int now,int topf)
{
while(now) f[now]=0,now=fa(now);
}
void calc(int now)
{
if(now>=m)
{
printf("%d ",p[now-m+1]);
return;
}
top=0;
for(int i=L[now];i<=R[now];i++) stk[++top]=p[i-m+1];//暴力求得树内每个数
sort(stk+1,stk+1+top);
int ps=0,wson=0;
ll lv=0,rv=0;
for(int i=1;i<=top;i++)
{
getf(m+pos[stk[i]]-1,fa(now));//求得 dp 数组
if(f[now]>k)
{
ps=i;
break;
}
lv=f[ls(now)],rv=f[rs(now)];//在合法时的左右子树费用
}
for(int i=1;i<=ps;i++)
clr(m+pos[stk[i]]-1,fa(now));//清空 dp 数组
if(pos[stk[ps]]+m-1<=R[ls(now)]) wson=0; //判断去左/右子树
else wson=1;
if(!wson)//要跳左子树
{
k-=min(w[now],rv);
calc(ls(now));
k+=min(w[now],rv);
if(k<rv) k-=w[now];
calc(rs(now));
}
else//要跳右子树
{
k-=lv;
calc(rs(now));
k+=lv;
calc(ls(now));
}
}
int main()
{
scanf("%d",&g);
while(g--)
{
scanf("%d%lld",&n,&k);
m=(1ll<<n);
for(int i=1;i<=m-1;i++)
scanf("%lld",&w[i]),f[i]=0;
for(int i=1;i<=m;i++)
scanf("%d",&p[i]),pos[p[i]]=i,f[i+m-1]=0,L[i+m-1]=R[i+m-1]=i+m-1;
for(int i=m-1;i>=1;i--) L[i]=L[ls(i)],R[i]=R[rs(i)];
calc(1);
printf("\n");
}
return 0;
}
一开始在跳节点时思考错了，认为在当前节点和堵住右子树之间选择小的减去，想了三四个小时都不明白哪错了。
一开始没想到 dp 数组在线求，写的是主席树爆空间，喜提 RE ，时间复杂度还是同阶的……不在满二叉树上跳祖先而主席树上跳，我可真是太聪明了。
