POJ 1741 点分治

题意

传送门 POJ 1741 Tree

题解

以 $p$ 为根的树上长度为 $k$ 的路径分为两种其情况：经过 $p$ 的路径；不经过 $p$ 的路径。递归求解，每一层求解经过当前子树根节点的答案。将树上节点按照与根节点的距离排序，则可由用左右指针扫描数组统计满足求和不大于 $k$ 的路径 $(u-p,p-v)$ 对数量。考虑 $DFS$ 的时间戳，子树节点位置的编号是相邻的，那么可以预先统计同一棵子树上的路径对数，最后用整棵树的路径对数减去它，就得到了经过根节点的满足条件的路径数。

由于信息需要自顶而下统计，考虑点分治，每次选取树的重心进行分解，递归求解子树。总时间复杂度 $O(N{\log }^{2}N)$。

#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 10005, maxe = maxn << 1;
int N, K, res, tot, ds[maxn], sz[maxn];
int E, head[maxn], to[maxe], nxt[maxe], cost[maxe];
bool del[maxn];

inline int read()
{
    int x = 0;
    char c = 0;
    for (; c < '0' || c > '9'; c = getchar())
        ;
    for (; c >= '0' && c <= '9'; c = getchar())
        x = (x << 1) + (x << 3) + c - '0';
    return x;
}

inline void add(int x, int y, int z) { to[++E] = y, cost[E] = z, nxt[E] = head[x], head[x] = E; }

void find(int &mx, int &p, int n, int x, int f)
{
    sz[x] = 1;
    int m = 0;
    for (int i = head[x]; i; i = nxt[i])
    {
        int y = to[i];
        if (!del[y] && y != f)
            find(mx, p, n, y, x), sz[x] += sz[y], m = max(m, sz[y]);
    }
    m = max(m, n - sz[x]);
    if (m < mx)
        mx = m, p = x;
}

void dfs(int x, int f, int s, int d)
{
    sz[x] = 1, ds[++tot] = d;
    for (int i = head[x]; i; i = nxt[i])
    {
        int y = to[i];
        if (!del[y] && y != f)
            dfs(y, x, s, d + cost[i]), sz[x] += sz[y];
    }
}

inline int cal(int l, int r)
{
    sort(ds + l, ds + r--);
    int res = 0;
    for (;;)
    {
        while (l < r && ds[l] + ds[r] > K)
            --r;
        if (l >= r)
            break;
        res += r - l, ++l;
    }
    return res;
}

void solve(int n, int x)
{
    int mx = n, p = 0;
    find(mx, p, n, x, 0);
    ds[tot = 1] = 0, del[p] = 1;
    int pre = 2, tmp = 0;
    for (int i = head[p]; i; i = nxt[i])
    {
        int y = to[i];
        if (!del[y])
            dfs(y, 0, y, cost[i]), tmp += cal(pre, pre + sz[y]), pre += sz[y];
    }
    res += cal(1, n + 1) - tmp;
    for (int i = head[p]; i; i = nxt[i])
    {
        int y = to[i];
        if (!del[y])
            solve(sz[y], y);
    }
}

int main()
{
    while ((N = read()) | (K = read()))
    {
        E = res = 0;
        memset(head, 0, sizeof(head));
        for (int i = 1, u, v, l; i < N; ++i)
            u = read(), v = read(), l = read(), add(u, v, l), add(v, u, l);
        memset(del, 0, sizeof(del));
        solve(N, 1);
        printf("%d\n", res);
    }
    return 0;
}