[ABC290G] Edge Elimination 题解

[ABC290G] Edge Elimination 题解

题意描述

给定一颗满 $K$ 叉树，深度为 $D$，即整棵树有 $1+K+K^2+\cdots +K^D$ 个节点。

现在你可以选定若干条边并将其删除（也可以选择不删），删除后将得到一个森林，求使森林中存在一棵树的节点数为 $X$ 的最小删除边数。

简要分析

删去某一条边可以转化为删去某一颗子树。

因为所给出的树是一颗满 $K$ 叉树，所以一次操作即为删去 $\frac{k^{x+1}-1}{k-1}$ 个点 （等比数列求和公式） ，其中 $x$ 为所删去子树的深度。

所以我们要删去 $n-x$ 个点，其中 $n$ 为树的节点总数，即 $n=\frac{k^{d+1}-1}{k-1}$。

不难发现，每次操作可以删去一个可以删去的最大子树的所有等价子树。

例如：

如果想要得到一个节点数为 $5$ 的树，也就是需要删除 $10$ 个点，那么可以先删去以 $2$ 为根的树，剩余 $8$ 个点。

随后再删去以 $6$ 为根的子树，即可得到答案 $2$。

Bug 1

事实上，这种贪心策略是错误的，在删去一颗子树时，事实上是分离出这颗子树，这个子树仍然有可能对答案产生贡献。

我们只需在递归时加上一处特判即可。

Bug 2

对于刚开始执行操作时，我们仍有漏洞尚未处理

仍是看上面的图，我想要得到一颗节点数为 $2$ 的子树，按照上述策略我们删除的过程是这样的：

1. 删去以 $2$ 为根的子树，剩余节点数为 $8$。
2. 删去以 $6,7$ 为根的子树，剩余节点数为 $2$。

操作次数为 $3$ ，然而我们可以先删去以 $7$ 为根的子树，最后把目光放到以 $7$ 为根的子树当中，删去以 $14$ 为根的子树，即可得到更优的答案 $2$。

注意改变目光时的剩余节点数的变化。

因此，在初次调用递归函数时，我们可以从能包容下 $x$ 个点的最小子树开始递归。

Optimisation 1

不难发现，递归函数的执行次数为 $O(2^{ans})$，其中 $ans$ 为最终答案。

所以我们需要剪枝。

不难想到，使用最优性剪枝，记录得到的最优答案，如果当前操作数大于得到的最优答案时直接停止递归即可。

于是我们就得到了一个 $O(ans)$ 的做法，最慢的点跑了 $11\mathrm{ms}$，平均每个点在 $2\mathrm{ms}$ 左右。

总结

此题是一道难度评级为 $2407$ 的 $G$ 题，放在这个位置十分合适。

且是一道较为清新的思维题。

初始的题意转化并不难想，思维难度集中在 的发现以及修复部分。
末尾的优化也是常规操作，实现部分闭眼瞎写能过。

不过我看在榜大佬的代码十分简洁，而我却封装了 $n$ 个函数。

代码实现

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
#include <map>
#include <queue>
#include <set>

using namespace std;

typedef __int128 ll;
//typedef long long ll;
const ll maxn = 1e5 + 7;
const ll INF = 1e9 + 7, MOD = 998244353;

inline ll read() {
    char cCc;
    ll xXx = 0, wWw = 1;
    while (cCc < '0' || cCc > '9')
        (cCc == '-') && (wWw = -wWw), cCc = getchar();
    while (cCc >= '0' && cCc <= '9')
        xXx = (xXx << 1) + (xXx << 3) + (cCc ^ '0'), cCc = getchar();
    xXx *= wWw;
    return xXx;
}

inline void write(ll xXx) {
    if (xXx < 0)
        putchar('-'), xXx = -xXx;
    if (xXx > 9ll)
        write(xXx / 10ll);
    putchar(xXx % 10ll + '0');
}

ll d, k, x, ans, n;

ll kissme(ll di, ll zhi) {
    if (zhi == 0)return 1ll;
    ll _x = kissme(di, zhi >> 1);
    if (zhi & 1)return _x * _x * di;
    return _x * _x;
}

ll finalfind(ll x, ll opt) {
    ll l = 0, r = d + 1;
    while (l <= r) {
        ll mid = (l + r) >> 1;
        ll jie = kissme(k, mid + 1);
        ll jie2 = jie * k;
        jie--, jie2--;
        jie /= (k - 1), jie2 /= (k - 1);
        if (jie <= x && x < jie2)return mid + opt;
        else if (jie > x)r = mid - 1;
        else l = mid + 1;
    }
}

ll dfs(ll _x, ll step) {
    if (!_x)return step;
    if (step > ans)return 1e18;
    ll a = finalfind(_x, 0);
    if (a == 0)
        return step + _x;
    ll cur = (kissme(k, a + 1) - 1) / (k - 1);

    if (cur >= x)
        return min(dfs(cur - x, step + 1), dfs(_x % cur, step + (_x / cur)));
    return dfs(_x % cur, step + (_x / cur));
}

void solve() {
    d = read(), k = read(), x = read();
    ans = 1e18;
    n = (kissme(k, d + 1) - 1) / (k - 1);
    ll a = finalfind(x, 0), a2 = finalfind(n - x, 0);
    if (x == 0 || x == n)cout << "0\n";
//    else if (x == 1 || (n - x) == 1)cout << "1\n";
    else if ((kissme(k, a + 1) - 1) / (k - 1) == x || (kissme(k, a2 + 1) - 1) / (k - 1) == (n - x)) cout << "1\n";
    else {
//        cout << min(dfs(n - x, 0), dfs(x, 0)) << '\n';
//        write(min(dfs(n - x, 0), dfs(x, 0)));
        ll a1 = finalfind(x, 1);
        ll cur = (kissme(k, a1 + 1) - 1) / (k - 1);
        if (cur >= x) {
            ans = dfs(cur - x, 1);
            write(min(ans, dfs(n - x, 0)));
        } else write(ans = dfs(n - x, 0));
        putchar('\n');
    }
}

int main() {
//    freopen("test.in","r",stdin);
//    freopen("test.out","w",stdout);
    ll T = read();
    while (T--)solve();
    return 0;
}

——$\mathcal{C}laude\mathcal{Z}.$