静态点分治学习笔记

静态点分治学习笔记

点分治简介

点分治是树分治的一种。

这东西是典型的思想相对来说简单点，但是写起来巨复杂的算法，主要用于在（无根）树上解决路径相关的问题。

洛谷的模板题其实并不适合作为入门例题，我们用 P4178 Tree 做例题。

分治思想

我们不妨指令树的根为 $1$，那么树上的所有路径被分为两类：经过 $1$ 的、不经过 $1$ 的（如图）。

考虑对整棵树进行分治，我们先统计出所有经过 $1$ 的路径的信息，然后再对每棵子树统计它们的信息。

在例题中，我们就统计出子树内每个节点到子树根节点的距离，然后用树状数组或排序后双指针求得答案即可（详见后文），设子树大小为 $n$ 则每统计一次的时间复杂度为 $\mathcal{O}(n\log n)$。

对每一层统计的时间复杂度一般为 $\mathcal{O}(n)$ 或 $\mathcal{O}(n\log n)$，我们记为 $f(n)$（上面的例子中 $f(n)=\mathcal{O}(n\log n)$）。我们设最大的递归深度为 $g(n)$。不难得出时间复杂度为 $\mathcal{O}(f(n)g(n))$（考虑每一层每棵子树的点没有重复）。

目前来看 $g(n)=\mathcal{O}(n)$。$f(n)$ 是不好降低的，考虑降低 $g(n)$ 即递归深度。

树的重心

这其实是个前置知识，我稍微提两句。

对 $n$ 个点的无根树，设 $maxpart(u)$ 表示以节点 $u$ 为根，所有子树中点最多的数量。使 $maxpart(u)$ 取到最小值的点称为“重心”。

重心有一个性质：设 $u$ 为一个重心，则 $maxpart(u)\le\lfloor\frac{n}{2}\rfloor$。

找重心的方法就是一遍 dfs，记录子树大小和 $maxpart$。

void dfs_findroot(int u, int f, int SZ) {
    sz[u] = 1;
    int maxpart = 0;
    for(auto i : e[u]) {
        int v = get<0>(i), w = get<1>(i);
        if(v != f && !vis[v]) { // vis 的作用后面会提到
            dfs_findroot(v, u, SZ);
            sz[u] += sz[v];
            chkmax(maxpart, sz[v]);
        }
    }
    chkmax(maxpart, SZ-sz[u]);
    if(maxpart < rtsz) {
        rt = u;
        rtsz = maxpart;
    }
}

每次我们不找 $1$、$1$ 的儿子、$1$ 的儿子的儿子……当根节点，而是找当前分治到的这棵树的重心当根节点。

$f(n)$ 依然是 $\mathcal{O}(n)$ 或 $\mathcal{O}(n\log n)$ 不会变，$g(n)$ 的话根据 $maxpart(u)\le\lfloor\frac{n}{2}\rfloor$ 的性质，每一层点数会除以二，易知 $g(n)=\mathcal{O}(\log n)$。

于是 $T(n)=f(n)g(n)$，就变成了 $\mathcal{O}(n\log n)$ 或 $\mathcal{O}(n\log^2n)$ 了！例题中就是 $\mathcal{O}(n\log^2n)$。

统计答案

统计答案

讲了这么多，还没说怎么统计答案。

例题中有两种统计答案的方法。

第一种解法

我们设当前的根为 $rt$，处理 $d_u$ 为 $u$ 到 $rt$ 的距离。

从 $rt$ 的第一棵子树开始依次统计，对第 $i$ 棵子树的每个点 $u$，在第 $1\sim i-1$ 棵子树中找到所有满足 $d_u+d_v\le k$ 的点 $v$ 的个数累加。

具体地就是用一棵树状数组维护，下标是到根距离，值是到根距离是这么多的点的数量。

注意路径的一端可以是 $rt$。另外注意在回溯的时候清空树状数组。

$f(n)=\mathcal{O}(n\log k)$。

这种写法我（好像）没写过。

第二种解法

对当前分治到的树的所有节点按 $d_u$ 排序，此时 $d_u$ 单调递增，那么 $d_v\le k-d_u$ 这个上限单调递减，用双指针统计 $d_u+d_v\le k$ 的点数即可。

发现多统计了一些，就是可能 $u,v$ 在同一个子树内，它们之间路径不经过 $rt$ 但也被统计了，考虑进行容斥，我们在递归点分治每棵子树前把答案减掉子树内部 $d_u+d_v\le k$ 的点数即可。

$f(n)=\mathcal{O}(n\log n)$。

void dfs_dis(int u, int f) {
    d.push_back(dis[u]);
    for(auto i : e[u]) {
        int v = get<0>(i), w = get<1>(i);
        if(v != f && !vis[v]) {
            dis[v] = dis[u] + w;
            dfs_dis(v, u);
        }
    }
}
int calc(int u) {
    d.clear();
    dfs_dis(u, 0);
    sort(d.begin(), d.end());
    int sz = d.size();
    int L = 0, R = sz - 1, ans = 0;
    while(L < R) {
        while(L < R && d[L] + d[R] > k) --R;
        ans += R - L;
        ++L;
    }
    return ans;
}
int divid(int u, int SZ) {
    rtsz = SZ;
    dfs_findroot(u, 0, SZ);
    u = rt;
    dis[u] = 0;
    vis[u] = 1; // 标记这个点被分治过，相当于把整棵树从这个点断开得到若干棵子树，在 dfs_findroot 和 dfs_dis 时不能经过这个点
    int ans = calc(u); // 统计整棵树的答案
    for(auto i : e[u]) {
        int v = get<0>(i), w = get<1>(i);
        if(!vis[v]) {
            ans -= calc(v); // 容斥，减掉算多了的答案
            ans += divid(v, d.size());
        }
    }
    return ans;
}

完整代码

//By: Luogu@rui_er(122461)
#include <bits/stdc++.h>
#define rep(x,y,z) for(int x=y;x<=z;x++)
#define per(x,y,z) for(int x=y;x>=z;x--)
#define debug printf("Running %s on line %d...\n",__FUNCTION__,__LINE__)
#define fileIO(s) do{freopen(s".in","r",stdin);freopen(s".out","w",stdout);}while(false)
using namespace std;
typedef long long ll;
const int N = 4e4+5;

int n, k, dis[N], sz[N], vis[N], rt, rtsz;
vector<int> d;
vector<tuple<int, int> > e[N]; 
template<typename T> void chkmin(T& x, T y) {if(x > y) x = y;}
template<typename T> void chkmax(T& x, T y) {if(x < y) x = y;}
void dfs_findroot(int u, int f, int SZ) {
    sz[u] = 1;
    int maxpart = 0;
    for(auto i : e[u]) {
        int v = get<0>(i), w = get<1>(i);
        if(v != f && !vis[v]) {
            dfs_findroot(v, u, SZ);
            sz[u] += sz[v];
            chkmax(maxpart, sz[v]);
        }
    }
    chkmax(maxpart, SZ-sz[u]);
    if(maxpart < rtsz) {
        rt = u;
        rtsz = maxpart;
    }
}
void dfs_dis(int u, int f) {
    d.push_back(dis[u]);
    for(auto i : e[u]) {
        int v = get<0>(i), w = get<1>(i);
        if(v != f && !vis[v]) {
            dis[v] = dis[u] + w;
            dfs_dis(v, u);
        }
    }
}
int calc(int u) {
    d.clear();
    dfs_dis(u, 0);
    sort(d.begin(), d.end());
    int sz = d.size();
    int L = 0, R = sz - 1, ans = 0;
    while(L < R) {
        while(L < R && d[L] + d[R] > k) --R;
        ans += R - L;
        ++L;
    }
    return ans;
}
int divid(int u, int SZ) {
    rtsz = SZ;
    dfs_findroot(u, 0, SZ);
    u = rt;
    dis[u] = 0;
    vis[u] = 1;
    int ans = calc(u);
    for(auto i : e[u]) {
        int v = get<0>(i), w = get<1>(i);
        if(!vis[v]) {
            ans -= calc(v);
            ans += divid(v, d.size());
        }
    }
    return ans;
}

int main() {
    scanf("%d", &n);
    rep(i, 1, n-1) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        e[u].push_back(make_tuple(v, w));
        e[v].push_back(make_tuple(u, w));
    }
    scanf("%d", &k);
    printf("%d\n", divid(1, n));
    return 0;
}