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 eq 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$。

　　所以有了以下做法：

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

　　看起来$O(nsqrt{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)$
• 若$aleqslant b$，则$dp_{a}(u) geqslant dp_{b}(u)$。

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

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

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

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

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

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

　　总时间复杂度$O(nlog_{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 + 5, bzmax = 20;

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 = 1, 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 = 0;
    par[p] = fa;

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

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

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

    res += rt + 1;
    return rt + 1;
}

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(1, 0);
    dres = n;
    for (int i = 1; i <= n; i++)
        h[i] = 1;
    for (int k = n; k > 1; k--) {
        for (int i = 0; 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 0;
}