P5666 [CSP-S2019] 树的重心 题解

P5666 [CSP-S2019] 树的重心 题解

题目描述

小简单正在学习离散数学，今天的内容是图论基础，在课上他做了如下两条笔记：

1. 一个大小为 $n$ 的树由 $n$ 个结点与 $n-1$ 条无向边构成，且满足任意两个结点间有且仅有一条简单路径。在树中删去一个结点及与它关联的边，树将分裂为若干个子树；而在树中删去一条边（保留关联结点，下同），树将分裂为恰好两个子树。
2. 对于一个大小为 $n$ 的树与任意一个树中结点 $c$，称 $c$ 是该树的重心当且仅当在树中删去 $c$ 及与它关联的边后，分裂出的所有子树的大小均不超过 $\lfloor \frac{n}{2}\rfloor$（其中 $\lfloor x\rfloor$ 是下取整函数）。对于包含至少一个结点的树，它的重心只可能有 1 或 2 个。

课后老师给出了一个大小为 $n$ 的树 $S$，树中结点从 $1\sim n$ 编号。小简单的课后作业是求出 $S$ 单独删去每条边后，分裂出的两个子树的重心编号和之和。即：

$$\sum _{(u,v)\in E}\left(\sum _{\genfrac{}{}{0ex}{}{1\le x\le n}{且x号点是S_u^{\prime }的重心}}x+\sum _{\genfrac{}{}{0ex}{}{1\le y\le n}{且y号点是S_v^{\prime }的重心}}y\right)$$

上式中，$E$ 表示树 $S$ 的边集，$(u,v)$ 表示一条连接 $u$ 号点和 $v$ 号点的边。$S_u^{\prime }$ 与 $S_v^{\prime }$ 分别表示树 $S$ 删去边 $(u,v)$ 后，$u$ 号点与 $v$ 号点所在的被分裂出的子树。

小简单觉得作业并不简单，只好向你求助，请你教教他。

输入格式

本题包含多组测试数据。

第一行一个整数 $T$ 表示数据组数。

接下来依次给出每组输入数据，对于每组数据：

第一行一个整数 $n$ 表示树 $S$ 的大小。

接下来 $n-1$ 行，每行两个以空格分隔的整数 $u_i$，$v_i$，表示树中的一条边 $(u_i,v_i)$。

输出格式

共 $T$ 行，每行一个整数，第 $i$ 行的整数表示：第 $i$ 组数据给出的树单独删去每条边后，分裂出的两个子树的重心编号和之和。

输入输出样例 #1

输入 #1

2
5
1 2
2 3
2 4
3 5
7
1 2
1 3
1 4
3 5
3 6
6 7

输出 #1

32
56

说明/提示

【样例 1 解释】

对于第一组数据：

删去边 $(1,2)$，1 号点所在子树重心编号为 { 1 } \{1\} {1}，2 号点所在子树重心编号为 { 2 , 3 } \{2,3\} {2,3}。

删去边 $(2,3)$，2 号点所在子树重心编号为 { 2 } \{2\} {2}，3 号点所在子树重心编号为 { 3 , 5 } \{3,5\} {3,5}。

删去边 $(2,4)$，2 号点所在子树重心编号为 { 2 , 3 } \{2,3\} {2,3}，4 号点所在子树重心编号为 { 4 } \{4\} {4}。

删去边 $(3,5)$，3 号点所在子树重心编号为 { 2 } \{2\} {2}，5 号点所在子树重心编号为 { 5 } \{5\} {5}。

因此答案为 $1+2+3+2+3+5+2+3+4+2+5=32$。

【数据范围】

测试点编号	$n=$	特殊性质
$1\sim 2$	$7$	无
$3\sim 5$	$199$	无
$6\sim 8$	$1999$	无
$9\sim 11$	$49991$	A
$12\sim 15$	$262143$	B
$16$	$99995$	无
$17\sim 18$	$199995$	无
$19\sim 20$	$299995$	无

表中特殊性质一栏，两个变量的含义为存在一个 $1\sim n$ 的排列 $p_i(1\le i\le n)$，使得：

• A：树的形态是一条链。即 $\forall 1\le i<n$，存在一条边 $(p_i,p_{i+1})$。
• B：树的形态是一个完美二叉树。即 $\forall 1\le i\le \frac{n-1}{2}$ ，存在两条边 $(p_i,p_{2i})$ 与 $(p_i,p_{2i+1})$。

对于所有测试点：$1\le T\le 5,1\le u_i,v_i\le n$。保证给出的图是一个树。
时限 $4000$ ms，空限 $250$ MB

---

这道题是一道难度很大、质量很高的紫题。

题面翻译：给出一棵树，断开任何一条边都会形成两棵子树，这两棵子树有不同的重心。设断开边 $p_i$ 后，两棵树的重心编号和为 $an{s}_i$，求所有 $an{s}_i$ 的总和。

---

SOL

先考虑断开每条边，暴力求出两棵子树的重心，时间复杂度为 $O(n^2)$ 以上，显然会超时。

我们知道，一棵树的重心一定在它的重儿子所在的子树上，于是我们先做一遍 DFS 求出每个节点所在子树的大小和它的重儿子、轻儿子，之后用倍增数组 $so{n}_{i,j}$ 表示节点 $i$ 往它的重儿子走 $2^j$ 步后走到的节点。

然后再做一遍 DFS 来依次剪断每一条边，设剪掉的边为 $p_{now,i}$ 。剪断一条边后，如果发现 $so{n}_{now,0}$ 是 $i$ 就把 $so{n}_{now,0}$ 换成 $now$ 的轻儿子。还要 $so{n}_{now,0}$ 与当前点上方的子树比较，取子树大小大的那一棵子树为重儿子。然后要重新求当前节点的倍增数组。

剪掉一条边后， $si{z}_{now}$ 变为 $n-a_i$ ，然后求子树 $now$ 的重心 $x$ ，只需要不断地往 $now$ 重儿子跳，如果发现跳到一个点后这个点所在子树的大小超过 $si{z}_{now}÷2$ ，说明重心肯定在这棵子树上，否则就不能跳。

除此之外，要判断 $x$ 上方的节点数是否超过 $si{z}_{now}÷2$ ，然后一棵树可能有两个重心，再判断 $so{n}_{x,0}$ 上方的节点数是否超过同样的值。

做完之后，别忘记多组数据、开 long long ！！！

---

CODE

#include<iostream>
#include<vector>
#define int long long
using namespace std;
int t;
int n,siz[300005],hvson[300005][21],ltson[300005],ans;
vector <int> tree[300005];
/*
siz[x] -> x的子树大小
hvson[x][i] -> x跳到第2^i个重儿子所在的节点
ltson[x] -> x的轻儿子（次重儿子）
*/
void dfs(int now,int fath)//求出siz、hvson、ltson
{
    siz[now] = 1;
    hvson[now][0] = 0;
    for(auto i : tree[now])
    {
        if(i == fath) continue;
        dfs(i,now);
        siz[now] += siz[i];
        if(siz[i] > siz[hvson[now][0]]) ltson[now] = hvson[now][0],hvson[now][0] = i;
        else if(siz[i] > siz[ltson[now]]) ltson[now] = i;
    }
    return;
}
void rmq(int now = 0)//倍增，缺省值，当未声明now时将now设为0
{
    for(int j = 1;j <= 20;j++)
    {
        if(now) hvson[now][j] = hvson[hvson[now][j - 1]][j - 1];
        else
        {
            for(int i = 1;i <= n;i++) hvson[i][j] = hvson[hvson[i][j - 1]][j - 1];
        }
    }
}
void getans(int now)//计算答案
{
    int x = now;
    for(int i = 20;i >= 0;i--)
    {
        if(siz[hvson[x][i]] > siz[now] / 2) x = hvson[x][i];//倍增
    }
    if(!x) x = now;
    ans += x;
    if(siz[now] - siz[hvson[x][0]] <= siz[now] / 2 && hvson[x][0] != x) ans += hvson[x][0];//判断双重心
    return;
}
void solve(int a,int b)//递归求解
{
    int k = hvson[a][0],tp = siz[a];
    for(auto i : tree[a])
    {
        if(i == b) continue;
        if(i == k)//重儿子被剪掉
        {
            if(siz[ltson[a]] > n - tp) hvson[a][0] = ltson[a];
            else hvson[a][0] = b;//当上方节点更多，重儿子变为父节点
        }
        else
        {
            if(siz[k] < n - tp) hvson[a][0] = b;
            else hvson[a][0] = k;
        }
        siz[a] = n - siz[i];
        rmq(a);//重构倍增数组
        getans(a);
        getans(i);
        solve(i,a);
    }
    //还原
    siz[a] = tp;
    hvson[a][0] = k;
    rmq(a);
    return;
}
signed main()
{
    cin >> t;
    while(t--)
    {
        cin >> n;
        for(int i = 1;i <= n;i++) tree[i].clear();//初始化
        ans = 0;
        for(int i = 1;i < n;i++)
        {
            int a,b;
            cin >> a >> b;
            tree[a].push_back(b);
            tree[b].push_back(a);
        }
        dfs(1,0);
        rmq();
        solve(1,0);
        cout << ans << '\n';
    }
}