Codeforces 955F Heaps - 动态规划

题目传送门

　　传送点I

　　传送点II

　　传送点III

题目大意

　　给定一棵以1为根的树，定义$dp_{k}(u)$表示在$u$的子树内存在的深度最大的满k叉树的深度，求$\sum_{u = 1}^{n}\sum_{k = 1}^{n}dp_{k}(u)$。

　　以某个点$x$为根存在一棵深度$m$的满$k$叉树是指，它满足下面任意一条：

1. $m = 1$。
2. 当$m \neq 1$时，$x$存在$k$个子节点，分别以它们为根存在一棵深度为$m - 1$的满$k$叉树。

　　先讲讲我的挂掉的做法。

　　因为是满$k$叉树，所以$dp_{k}(u)\leqslant \log_{k}n, k > 1$，由此推出当$k \geqslant \sqrt{n}$时，$dp_{k}(u) \leqslant 2$。

　　所以有了以下做法：

• 当$1\leqslant k < \sqrt{n}$时，我们进行$O(n)$的动态规划。设$f_{u}$表示以点$u$为根，存在的深度最大的满$k$叉树的深度。转移取子节点中第$k$大的$f$值在加1，不存在就是1。当然这里找$k$大要用 nth_element 。
• 当$k \geqslant \sqrt{n}$时，直接通过度数计算。

　　看起来$O(n\sqrt{n})$非常地优秀，题解也说。

　　然而实际上：

　　因为$dp_{k}(u) \leqslant \log_{k}n$，所以当$k > 1$的时候$dp_{k} \leqslant \log_{2}n$。然后反转值和下标，考虑什么时候取每个值。

　　我们同样注意到$dp_{k}$的某些不严格单调的性质。

• 如果$u$是$v$的父节点，那么$dp_{k}(u) \geqslant dp_{k}(v)$
• 若$a\leqslant b$，则$dp_{a}(u) \geqslant dp_{b}(u)$。

　　设$h_{k, i}$表示以$i$为根存在的最深的满$k$叉树的深度。

　　如果某个$h$值被增大，那么我就沿着它的父节点向上跳去更新$dp$值，直到某个点已经不能更新。这样能够保证这一部分时间复杂度是$O(n\log n)$。

　　因为要将值增大，那就从大到小考虑每个$k$。

　　同时我们设$f_{i, j}$表示使得$h_{k}(i) \geqslant j$ 成立的最大的$j$。

　　转移很简单，我们找最大的$k$，使得子节点中第$k$大的$f_{s, j - 1}\geqslant k$。这个可以排个序然后直接扫。

　　然后用刚刚的方法更新$\Delta answer$，然后就做完了。

　　总时间复杂度$O(n\log_{2}^{2} n)$。

Code

 /**
  * Codeforces
  * Problem#955F
  * Accepted
  * Time: 327ms
  * Memory: 66900k
  */
 #include <bits/stdc++.h>
 #ifndef WIN32
 #define Auto "%lld"
 #else
 #define Auto "%I64d"
 #endif
 using namespace std;
 typedef bool boolean;
 #define ll long long
 #define pii pair<int, int>
 #define fi first
 #define sc second

 const int N = 3e5 + , bzmax = ;

 int n;
 int h[N];
 int f[N][bzmax];
 int buf[N], par[N];
 vector<pii> upd[N];
 vector<int> g[N];
 ll res;
 int dres;

 inline void init() {
     scanf("%d", &n);
     for (int i = , u, v; i < n; i++) {
         scanf("%d%d", &u, &v);
         g[u].push_back(v);
         g[v].push_back(u);
     }
 }

 int dp(int p, int fa) {
     int rt = ;
     par[p] = fa;

     for (int i = ; i < (signed) g[p].size(); i++) {
         int e = g[p][i];
         if (e ^ fa)
             rt = max(rt, dp(e, p));
     }

     f[p][] = n;
     for (int t = ; t < bzmax; t++) {
         int tp = ;
         for (int i = ; i < (signed) g[p].size(); i++) {
             int e = g[p][i];
             if ((e ^ fa) && f[e][t - ])
                 buf[++tp] = f[e][t - ];
         }

         sort(buf + , buf + tp + , greater<int>());

         for (int i = tp; i && !f[p][t]; i--)
             if (buf[i] >= i)
                 f[p][t] = i;
         if (f[p][t] > )
             upd[f[p][t]].push_back(pii(p, t));
     }

     res += rt + ;
     return rt + ;
 }

 void update(int p, int v) {
     while (p) {
         if (v <= h[p])
             break;
         dres += v - h[p];
         h[p] = v, p = par[p];
     }
 }

 inline void solve() {
     dp(, );
     dres = n;
     for (int i = ; i <= n; i++)
         h[i] = ;
     for (int k = n; k > ; k--) {
         for (int i = ; i < (signed) upd[k].size(); i++)
             update(upd[k][i].fi, upd[k][i].sc);
         res += dres;
     }
     printf(Auto, res);
 }

 int main() {
     init();
     solve();
     return ;
 }