原文链接 https://www.cnblogs.com/cly-none/p/9845046.html
题意：给出一棵\\(n\\)个结点的树，在第\\(i\\)个结点上有\\(a_i\\)个权值为\\(v_i\\)的物品。\\(1\\)号结点是根结点。你需要选出若干个物品（设选了\\(t\\)个），满足：
- 如果选了结点\\(i\\)上的物品，那么\\(i\\)到根的链上每个结点都至少要选一个物品。
- 设有选取物品的结点的最大深度为\\(h\\)，那么\\(t \\leq h + k\\)，\\(k\\)为一个给定的常数。
在此基础上，你需要最大化所选的物品的权值和。
\\(n \\leq 2 \\times 10^4, \\, k \\leq 5 \\times 10^5, \\, n \\times k \\leq 2.5 \\times 10^7\\)
显然，最终做法的复杂度应该是\\(O(nk)\\)的。
但这个问题比较复杂，直接想比较困难。因此，我们先考虑问题的简化版。
问题1
当第二个条件改为\\(t \\leq k\\)时，怎么做？
对于这种一个结点的决策影响其子树的问题，我们可以对dfs序倒过来dp。确切地说，考虑当前是\\(i\\)，那么\\(i\\)的子树就是\\(dfn_i\\)之后的一段连续区间。那么，把dfs序倒过来后，结点\\(i\\)就有两种可能：
- 选了\\(i\\)上的物品。就是一个多重背包，从\\(dp_{dfn_i + 1}\\)上更新过来。
- 不选\\(i\\)上的物品。那\\(i\\)子树中的所有物品都不能选。从\\(dp_{dfn_i + sz_i}\\)上更新过来。
用单调队列优化多重背包后，就能做到\\(O(nk)\\)。
然而，回过头来，我们依旧对\\(t \\leq h + k\\)感到棘手。尝试按常规方法dp对\\(k+h-t\\)记录答案，但没有用。这个限制其实就在于，选出一条一段是根结点的链，链上每个点都取一个不计入\\(t\\)的物品。我们设这条链除\\(1\\)外的端点为\\(x\\)。考虑\\(\\forall i, \\, a_i = 1\\)的部分分。那么，假如我们已经确定了\\(x\\)，则剩下的答案就是删去\\(1\\)到\\(x\\)的链，对剩下的森林做问题1的结果。
因此，我们可以考虑下面这个问题：
问题2
预处理：对于所有\\(x\\)，删去\\(x\\)到根的路径后剩下的森林的问题1的答案。
博主认为，这个问题的解法相当有趣，也挺难想到的。
考虑剩下的森林的一半就是在dfs序上，从\\(dfn_i + 1\\)到\\(n\\)的一段区间（包括了\\(i\\)的子树）。这个部分我们在dp时就已经把答案求出来了。然而，另一部分在dfs序上既不是一段后缀，也不是连续的区间。\\([1,dfn_i-1]\\)中还混入了\\(i\\)的所有祖先。
因此，我们把这棵树左右翻转，把剩下森林的两半交换位置。也就是，再生成一个dfs序，但每个结点反序访问它的孩子结点。这样，我们就把森林的另一部分也表示为了dfs序的一个后缀。值得注意的是，\\(i\\)的子树不能算两次，所以这个后缀应该是[dfn_i + sz_i,n]。
这样，我们做出两个dfs序，对每个做问题1的dp，就能解决此问题。
然后就是处理\\(a_i \\neq 1\\)的情况。上面的算法会错误，就在于\\(x\\)到根的路径上的结点，可能选了多个物品。那么，我们就对每个结点\\(i\\)建一个辅助点\\(i\'\\)，存放了\\(a_i - 1\\)个原来在\\(i\\)上的物品。这样，对于任何一个非辅助结点，它到根的路径上所有点都只有一个物品。
这样就能把最终问题转化为问题1，\\(O(nk)\\)地解决本题。
#include <bits/stdc++.h>
using namespace std;
const int N = 40010, K = 500010, SIZE = 51000010;
int n,k,val[N],num[N],dfn[N],sz[N],fa[N],cnt,dis[N],ans,rec[N],spadp[SIZE],spag[SIZE];
vector<int> ch[N];
int *dp[N],*g[N];
void dfs(int pos) {
sz[pos] = 1;
for (int i = 0 ; i < (int)ch[pos].size() ; ++ i) {
dfs(ch[pos][i]);
sz[pos] += sz[ch[pos][i]];
}
dfn[rec[pos] = ++cnt] = pos;
}
void fsd(int pos) {
dis[pos] += val[pos];
for (int i = (int)ch[pos].size() - 1 ; i >= 0 ; -- i) {
dis[ch[pos][i]] = dis[pos];
fsd(ch[pos][i]);
}
dfn[++cnt] = pos;
}
void update(int las,int cur) {
static int q[K],l,r;
l = 1, r = 0;
q[++r] = 0;
for (int i = 1 ; i <= k ; ++ i) {
while (l <= r && i - q[l] > num[dfn[cur]])
++ l;
if (l <= r)
dp[cur][i] = dp[las][q[l]] + val[dfn[cur]] * (i - q[l]);
else dp[cur][i] = 0;
while (l <= r && dp[las][i] > dp[las][q[r]] + val[dfn[cur]] * (i - q[r]))
-- r;
q[++r] = i;
}
}
void init() {
ans = 0;
for (int i = 0 ; i <= 2 * n ; ++ i) {
ch[i].clear();
dp[i] = spadp + i * (k + 1);
g[i] = spag + i * (k + 1);
memset(dp[i],0,sizeof(int) * (k + 1));
memset(g[i],0,sizeof(int) * (k + 1));
}
dis[1] = 0;
}
int main() {
int T;
scanf("%d",&T);
while (T --) {
scanf("%d%d",&n,&k);
init();
for (int i = 1 ; i <= n ; ++ i)
scanf("%d%d%d",&fa[i],&num[i],&val[i]);
for (int i = 2 ; i <= n ; ++ i)
ch[fa[i]].push_back(i);
for (int i = 1 ; i <= n ; ++ i) {
ch[i].push_back(i+n);
val[i+n] = val[i];
num[i+n] = num[i] - 1;
num[i] = 1;
}
cnt = 0;
dfs(1);
for (int i = 1 ; i <= 2 * n ; ++ i) {
update(i-1,i);
for (int j = 1 ; j <= k ; ++ j)
dp[i][j] = max(dp[i][j],dp[i - sz[dfn[i]]][j]), dp[i][j] = max(dp[i][j],dp[i][j-1]);
}
for (int i = 1 ; i <= 2 * n ; ++ i)
for (int j = 1 ; j <= k ; ++ j)
g[i][j] = dp[i][j];
cnt = 0;
fsd(1);
for (int i = 1 ; i <= 2 * n ; ++ i) {
update(i-1,i);
for (int j = 1 ; j <= k ; ++ j)
dp[i][j] = max(dp[i][j],dp[i - sz[dfn[i]]][j]), dp[i][j] = max(dp[i][j],dp[i][j-1]);
}
for (int i = 1 ; i <= 2 * n ; ++ i) {
if (dfn[i] > n) continue;
int p = rec[dfn[i]] - sz[dfn[i]];
for (int j = 0 ; j <= k ; ++ j)
ans = max(ans,dis[dfn[i]] + dp[i-1][j] + g[p][k-j]);
}
printf("%d\\n",ans);
}
return 0;
}
小结：一道对dfs序上dp进行拓展的好题。当一个问题分成了性质相同的两半，而前者容易解决，后者难以解决的问题时，寻找方式来交换这两部分的位置，最后合并。这个思路应该记住。