2024 ICPC 武汉邀请赛 E. Boomerang【动态维护树直径、LCA求树上两点距离】

最新推荐文章于 2024-10-31 21:08:49 发布

吵闹的人群保持笑容多冷静

最新推荐文章于 2024-10-31 21:08:49 发布

阅读量1.1k

点赞数 25

文章标签：算法图论

本文链接：https://blog.csdn.net/m0_73500785/article/details/138998466

版权

E. Boomerang

传送门：https://codeforces.com/gym/105143/problem/E

题意

给定一个 $n$ 个节点的树，根节点为 $r$ , 设时刻 $t$ 的点集 $\{v \; | \; dis(r, v) \leq t \}$ ，
其中 $d i s (u, v)$ 表示树上两点 $u$ 和 $v$ 间的唯一简单路径的边数。
再给定一个 $t_0$ ，对每个 $\in [1,n]$ ，你需要选择一个点 $r_0$ ，定义时刻 $t$ 的点集 $^\prime (r_0, t) = \{v \; | \; dis(r_0, v) \leq k(t−t_0) \}$ 。
找到一个最小的 $t$ ，使得 $\subseteq V ^\prime (r_0, t)$

即谣言在时刻 $0$ 从点 $r$ 开始传播，每个单位时间往外扩散一个点；而辟谣在时刻 $t_0 (t_0 > 0)$ 从任意点 $r_0$ 开始传播，传播速度为 $k$ 。
现在需要对于每个 $k$ ，找到最早的辟谣完全覆盖谣言时间点（ $r_0$ 任选）。

思路

注意到，当谣言传播到时刻 $t$ 时，这是一颗子树 $V (r, t)$ ，且所有节点距离 $r$ 的距离不超过 $t$ ，如果我们要在当前时刻覆盖所有的谣言的话，我们选择的那个开始辟谣的点 $r$ ，一定要最小化它到最远的点的距离，也就是说，我们 $r$ 一定选在子树 $V (r, t)$ 的直径的中点，此时距离最远的点最近，最大距离即为： $\lceil \frac{D}{2} \rceil$ ， $D$ 为子树 $V (r, t)$ 直径

我们从 $t_0$ 开始辟谣，那么此时辟谣了 $t - t_0$ 秒，而我们要覆盖所有的谣言点，那么起码需要的辟谣速度 $=\lceil \dfrac{\lceil \dfrac{D}{2} \rceil }{t - t_0} \rceil$ 。如果我们能从 $\rarr t = t_0 + n$ 枚举 $t$ ，获得当时的子树 $V (r, t)$ ，并算出那时候覆盖子树所需的最小的辟谣速度 $k$ ，我们就能对这些 $ans_k = min \{ t \mid k =\lceil \dfrac{\lceil \dfrac{D_t}{2} \rceil }{t - t_0} \rceil\}$ ，取 $min$ 值

注意到子树扩散过程中，计算出来的 $k$ 不一定覆盖 $[1, n]$ ，其实随着 $k$ 的增加， $an s [k]$ 是非递增的，道理很简单，如果在时刻 $t$ 我们选取速度 $k$ 可以覆盖这个时刻的子树的话，我们选取速度 $k + 1$ 只会更快覆盖这颗子树，所以我们只需要取 $ans_k = min \{ ans_k, ans_{k - 1} \}$

现在问题在于：如果动态加点，维护树的直径？注意到我们随着 $t$ 的增大，每次加入的点都是新扩散出去的，也就是当前子树的某些邻居点，类似于生成树。

因此我们有以下结论：

假设此时树的直径端点为 $,\; B$ ，直径为 $D$ ，新扩散加入一个点 $u$ 时，新的直径只有三种可能：

$\; D$
$\; dis(A,u)$
$\; dis(B,u)$

我们只需要用 $L C A$ 计算两点的距离即可

时间复杂度： $\log n)$

#include<bits/stdc++.h>
#define fore(i,l,r)	for(int i=(int)(l);i<(int)(r);++i)
#define fi first
#define se second
#define endl '\n'
#define ull unsigned long long
#define ALL(v) v.begin(), v.end()
#define Debug(x, ed) std::cerr << #x << " = " << x << ed;

const int INF=0x3f3f3f3f;
const long long INFLL=1e18;

typedef long long ll;

const int N = 200050;

std::vector<int> g[N];
int fa[N][20];
int dep[N];

void dfs(int u, int father){
    dep[u] = dep[father] + 1;
    fa[u][0] = father;
    for(int i = 1; (1 << i) <= dep[u]; ++i)
        fa[u][i] = fa[fa[u][i - 1]][i - 1];
    for(auto v : g[u])
        if(v ^ father)
            dfs(v, u);
}

int lca(int u, int v){
    if(dep[u] < dep[v]) std::swap(u, v);
    for(int i = 19; i >= 0; --i)
        if(dep[u] - (1 << i) >= dep[v])
            u = fa[u][i];
    if(u == v) return v;
    for(int i = 19; i >= 0; --i)
        if(fa[u][i] != fa[v][i]){
            u = fa[u][i];
            v = fa[v][i];
        }
    return fa[u][0];
}

int dis(int u, int v){
    int L = lca(u, v);
    return dep[u] + dep[v] - 2 * dep[L];
}

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int n;
    std::cin >> n;
    fore(i, 1, n){
        int u, v;
        std::cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    int r, t0;
    std::cin >> r >> t0;

    dfs(1, 0);

    std::vector<int> ans(n + 1, t0 + n);
    int A = r, B = r; //直径的两个端点
    int D = 0; //直径
    std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, 
                std::greater<std::pair<int, int>>> que;
    fore(i, 1, n + 1){
        if(i == r) continue;
        int d = dis(i, r);
        if(d <= t0){
            int d1 = dis(A, i), d2 = dis(B, i);
            if(D >= std::max(d1, d2)) continue;
            if(d1 > d2){
                D = d1;
                B = i;
            }
            else{
                D = d2;
                A = i;
            }
        }
        else que.push({d, i});
    }

    fore(t, t0 + 1, t0 + n + 1){
        while(!que.empty() && que.top().fi == t){
            auto [d, i] = que.top();
            que.pop();
            int d1 = dis(A, i), d2 = dis(B, i);
            // Debug(i, endl)
            if(D >= std::max(d1, d2)) continue;
            /* 更新直径 */
            if(d1 > d2){
                D = d1;
                B = i;
            }
            else{
                D = d2;
                A = i;
            }
        }
        int k = ((D + 1) / 2 + t - t0 - 1) / (t - t0);
        ans[k] = std::min(ans[k], t);
    }

    fore(i, 1, n + 1){
        ans[i] = std::min(ans[i], ans[i - 1]);
        std::cout << ans[i] << ' ';
    } 

    return 0;
}