[BZOJ4317][Atm的树][LCA+点分治]

[BZOJ4317][Atm的树][LCA+点分治]

题目大意：

求大小为$N$一棵无根树上每个点和其它所有点树上路径中第$K$长的路径。

思路：

这种树上路径统计问题应该一眼就能看出是树分治裸题吧。。。但是即使是裸的，代码量依然大得吓人（所以LCA倍增数组开小了一位刚好溢出调了好久。）

先对树点分一遍，对每个重心所管辖的所有子节点连接重心的路径都维护到重心上的权值线段树（线段树要动态开不然会炸），还要预处理出点分树。

设$p[i]$为$i$节点点分树上的父亲,$dist(i,j)$为树上两点之前的长度，$D$为当前路径长度，$sum(i,k)$为以$i$节点为根长度$<=k$的路径数量。

然后对于每个节点$x$，二分答案$D$后，从$x$开始往点分树的父亲上跑，每经过一个节点就统计：

$$sum(x, D)-sum(p[x],D-dist(x,p[x]))$$

哎呀就是一个简单的容斥啦

然后把$D$更新为$D-dist(x,p[x])$，$x$更新为$p[x]$，一直爬到点分树根节点为止。

二分，爬点分树，线段树区间统计和的复杂度都是$logn$，所以总时间复杂度是$O(n log^3n)$。

代码：

#include <cstdio>
const int Maxn = 100010;
typedef long long ll;
inline ll Max(const ll &a, const ll &b) {
    return a > b ? a : b;
}
inline int Min(const ll &a, const ll &b) {
    return a < b ? a : b;
}
inline void swap(ll &a, ll &b) {
    static ll c;
    c = a;
    a = b;
    b = c;
}

ll n, k;
ll head[Maxn], sub;
struct Edge {
    ll to, nxt, v;
    Edge(void) {}
    Edge(const ll &to, const ll &nxt, const ll &v) : to(to), nxt(nxt), v(v) {}
} edge[Maxn << 1];
inline void add(ll a, ll b, ll v) {
    edge[++sub] = Edge(b, head[a], v), head[a] = sub;
}
ll siz[Maxn], son[Maxn], root, S, rt[Maxn][2], p[Maxn];
bool vis[Maxn];

namespace IO {
    inline char get(void) {
        static char buf[1000000], *p1 = buf, *p2 = buf;
        if (p1 == p2) {
            p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
            if (p1 == p2) return EOF;
        }
        return *p1++;
    }
    inline void read(ll &x) {
        x = 0; static char c;
        for (; !(c >= '0' && c <= '9'); c = get());
        for (; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = get());
    }
    inline void write(ll x) {
        if (!x) return (void)puts("0");
        if (x < 0) putchar('-'), x = -x;
        static short s[12], t;
        while (x) s[++t] = x % 10, x /= 10;
        while (t) putchar('0' + s[t--]);
        putchar('\n');
    }
};
namespace Q {
#define Maxw 1000000
    ll s[Maxw], ls[Maxw], rs[Maxw], sz;
    inline void insert(ll &o, ll l, ll r, ll V) {
        if (!o) o = ++sz;
        s[o]++;
        if (l == r) return;
        int mid = (l + r) >> 1;
        if (mid >= V) insert(ls[o], l, mid, V);
        else insert(rs[o], mid + 1, r, V);
    }
    inline int query(ll o, ll l, ll r, ll L, ll R) {
        if (l >= L && r <= R) {
            return s[o];
        }
        if (!s[o]) return 0;
        int mid = (l + r) >> 1, ret = 0;
        if (mid >= L) ret += query(ls[o], l, mid, L, R);
        if (mid < R) ret += query(rs[o], mid + 1, r, L, R);
        return ret;
    }
#undef Maxw
};
namespace LCA {
    ll ff[Maxn][21], dep[Maxn], len[Maxn];
    inline void dfs1(ll u, ll fa) {
        ff[u][0] = fa;
        for (ll i = 1; i <= 20; i++) {
            ff[u][i] = ff[ff[u][i - 1]][i - 1];
        }
        for (ll i = head[u], v; i; i = edge[i].nxt) {
            v = edge[i].to;
            if (v == fa) continue;
            dep[v] = dep[u] + 1;
            len[v] = len[u] + edge[i].v;
            dfs1(v, u);
        }
    }
    inline ll lca(ll x, ll y) {
        if (dep[x] < dep[y]) swap(x, y);
        ll tmp = dep[x] - dep[y];
        for (int k = 0, j = 1; j <= tmp; j <<= 1, k++)
            if (tmp & j) x = ff[x][k];
        while (x != y) {
            ll j = 0;
            while (ff[x][j] != ff[y][j]) j++;
            if (j) j--;
            x = ff[x][j], y = ff[y][j];
        }
        return x;
    }
    inline ll dist(ll x, ll y) {
        return len[x] + len[y] - (len[lca(x, y)] << 1);
    }
};

inline void getroot(ll u, ll fa) {
    siz[u] = 1;
    for (ll i = head[u], v; i; i = edge[i].nxt) {
        v = edge[i].to;
        if (v == fa || vis[v]) continue;
        getroot(v, u);
        siz[u] += siz[v];
        son[u] = Max(son[u], siz[v]);
    }
    son[u] = Max(son[u], S - siz[u]);
    if (son[u] < son[root]) root = u;
}
inline void runpath(ll r, ll u, ll fa, ll type, ll dist) {
    Q::insert(rt[r][type], 0, n, dist);
    //printf("root[%d][%d] += dist[%d] (%d)\n", root, type, u, dist);
    for (ll i = head[u], v; i; i = edge[i].nxt) {
        v = edge[i].to;
        if (v == fa || vis[v]) continue;
        runpath(r, v, u, type, dist + edge[i].v);
    }
}
inline void solve(ll x) {
    vis[x] = 1; runpath(x, x, 0, 0, 0);
    for (ll i = head[x], v; i; i = edge[i].nxt) {
        v = edge[i].to;
        if (vis[v]) continue;
        S = siz[v]; root = 0;
        getroot(v, 0);
        p[root] = x;
        runpath(root, v, x, 1, edge[i].v);
        solve(root);
    }
}
inline bool check(ll x, ll mid) {
    ll now = mid, ret = 0;
    for (ll i = x; i; i = p[i]) { /// i | p[i] ?
        ret += Q::query(rt[i][0], 0, n, 0, now);
        now -= LCA::dist(i, p[i]);
        ret -= Q::query(rt[i][1], 0, n, 0, now);
    }
    return (ret - 1) >= k;
}
#define INF (1 << 30) 
int main(void) {
    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    IO::read(n), IO::read(k);
    for (ll i = 1, a, b, v; i < n; i++) {
        IO::read(a), IO::read(b), IO::read(v);
        add(a, b, v); add(b, a, v);
    }
    S = son[0] = n, root = 0;
    LCA::dfs1(1, 0);
    getroot(1, 0);
    solve(root);
    for (ll i = 1; i <= n; i++) {
        ll L = 0, R = INF, mid;
        while (L < R - 1) {
            mid = (L + R) >> 1;
            if (check(i, mid)) R = mid;
            else L = mid;
        }
        IO::write(R);
    }
    return 0;
}

#undef INF

完。

By g1n0st