长链剖分

因为重链剖分叫重女儿所以长链剖分叫长女儿。 参考资料。

O(nlogn)-O(1)求k级祖先，O(logn)求lca(也就是二分答案之后求k级祖先判定...)。

O(n)统计以深度为下标的信息。

性质1，总链长是O(n)数量级的。

写法跟树剖类似。

---

 应用1：求k级祖先。

此处需要性质2：k级祖先所在长链，链长大于k。

预处理出每个链头上下长度为链长的信息。

值得注意的地方：len如果是最深深度，链长就是len - d。

母亲的d比女儿要小......经常写反。

模板题

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>

const int N = 300010;

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

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

int e[N], n, father[N][20], son[N], len[N], d[N], top[N], pw[N];
std::vector<int> fa[N], af[N];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS_1(int x, int f) { /// get d father son len
    father[x][0] = f;
    d[x] = d[f] + 1;
    len[x] = d[x];
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) {
            continue;
        }
        DFS_1(y, x);
        len[x] = std::max(len[x], len[y]);
        if(len[y] > len[son[x]]) {
            son[x] = y;
        }
    }
    return;
}

void DFS_2(int x, int f) { /// get top fa
    top[x] = f;
    if(son[x]) {
        DFS_2(son[x], f);
    }
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == father[x][0] || y == son[x]) continue;
        DFS_2(y, y);
    }
    return;
}

inline void prework() {
    for(int i = 2; i <= n; i++) pw[i] = pw[i >> 1] + 1;
    for(int j = 1; j <= pw[n]; j++) {
        for(int i = 1; i <= n; i++) {
            father[i][j] = father[father[i][j - 1]][j - 1];
        }
    }
    for(int x = 1; x <= n; x++) {
        if(top[x] != x) continue;
        int up = x, down = x;
        for(int i = 0; i <= len[x] - d[x]; i++) {
            fa[x].push_back(up);
            af[x].push_back(down);
            up = father[up][0];
            down = son[down];
        }
    }
    return;
}

inline int ask(int x, int k) {
    if(!k) return x;
    if(k >= d[x] || k < 0) return 0;
    int t = pw[k];
    x = father[x][t];
    if(!x) return 0;
    k -= (1 << t);
    int y = top[x];
    if(d[x] - d[y] >= k) {
        return af[y][d[x] - d[y] - k];
    }
    return fa[y][k - d[x] + d[y]];
}

int main() {
    int m;
    read(n);
    for(int i = 1, x, y; i < n; i++) {
        read(x); read(y);
        add(x, y); add(y, x);
    }
    DFS_1(1, 0);
    DFS_2(1, 1);
    prework();
    read(m);
    int lastans = 0;
    for(int i = 1, x, y; i <= m; i++) {
        read(x); read(y);
        lastans = ask(x ^ lastans, y ^ lastans);
        printf("%d\n", lastans);
    }
    return 0;
}

例题：BZOJ4381 Odwiedziny

对询问的步长根号分块。大于的暴力跳，小于的预处理出来，然后减去2 * lca即可。注意边界。(我居然1A了...写的check都没用到)

#include <bits/stdc++.h>

typedef long long LL;
const int N = 50010;

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

int e[N], n, T, father[N][20], pw[N], b[N], c[N], d[N], len[N], top[N], son[N];
std::vector<int> fa[N], af[N];
LL val[N], Val[N][300];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS_1(int x, int f) { /// get father d len son
    father[x][0] = f;
    d[x] = d[f] + 1;
    len[x] = d[x];
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) continue;
        DFS_1(y, x);
        len[x] = std::max(len[x], len[y]);
        if(len[y] > len[son[x]]) {
            son[x] = y;
        }
    }
    return;
}

void DFS_2(int x, int f) { /// get top
    top[x] = f;
    if(son[x]) DFS_2(son[x], f);
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == father[x][0] || y == son[x]) continue;
        DFS_2(y, y);
    }
    return;
}

inline int getKfa(int x, int k) {
    if(!k) return x;
    if(k < 0 || k >= d[x]) return 0;
    int t = pw[k];
    x = father[x][t];
    k -= (1 << t);
    int y = top[x];
    if(k <= d[x] - d[y]) {
        return af[y][d[x] - d[y] - k];
    }
    return fa[y][k - d[x] + d[y]];
}

void DFS_3(int x) {
    int y = father[x][0];
    for(int i = 1; i <= T; i++) {
        Val[x][i] = Val[y][i] + val[x];
        y = father[y][0];
    }
    for(int i = e[x]; i; i = edge[i].nex) {
        y = edge[i].v;
        if(y == father[x][0]) continue;
        DFS_3(y);
    }
    return;
}

inline void prework() {
    for(int i = 2; i <= n; i++) pw[i] = pw[i >> 1] + 1;
    for(int j = 1; j <= pw[n]; j++) {
        for(int i = 1; i <= n; i++) {
            father[i][j] = father[father[i][j - 1]][j - 1];
        }
    }
    for(int x = 1; x <= n; x++) {
        if(top[x] != x) continue;
        int up = x, down = x;
        for(int i = 0; i <= len[x] - d[x]; i++) {
            fa[x].push_back(up);
            af[x].push_back(down);
            up = father[up][0];
            down = son[down];
        }
    }
    DFS_3(1);
    return;
}

inline void check() {
    for(int x = 1; x <= n; x++) {
        printf("x = %d top = %d len = %d d = %d \nfather : ", x, top[x], len[x], d[x]);
        for(int i = 0; i <= pw[n]; i++) {
            printf("%d ", father[x][i]);
        }
        printf("\nVal : ");
        for(int i = 1; i <= T; i++) {
            printf("%d ", Val[x][i]);
        }
        printf("\nKfa : ");
        for(int i = 0; i <= d[x]; i++) {
            printf("%d ", getKfa(x, i));
        }
        printf("\n\n");
    }
    return;
}

inline int lca(int x, int y) {
    if(d[x] > d[y]) std::swap(x, y);
    int t = pw[n];
    while(t >= 0 && d[x] < d[y]) {
        if(d[father[y][t]] >= d[x]) {
            y = father[y][t];
        }
        t--;
    }
    if(x == y) return x;
    t = pw[n];
    while(t >= 0 && father[x][0] != father[y][0]) {
        if(father[x][t] != father[y][t]) {
            x = father[x][t];
            y = father[y][t];
        }
        t--;
    }
    return father[x][0];
}

int main() {
    scanf("%d", &n);
    T = sqrt(n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &val[i]);
    }
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
    }
    DFS_1(1, 0);
    DFS_2(1, 1);
    prework();

    for(int i = 1; i <= n; i++) scanf("%d", &b[i]);
    for(int i = 1; i < n; i++) scanf("%d", &c[i]);

    for(int i = 1; i < n; i++) {
        int x = b[i], y = b[i + 1], z = lca(x, y);
        int step = (d[x] + d[y] - 2 * d[z]) % c[i];
        LL ans = 0;
        if(step) {
            ans += val[y];
            y = getKfa(y, step);
        }
        if(c[i] > T) { /// bf
            while(d[x] > d[z]) {
                ans += val[x];
                x = getKfa(x, c[i]);
            }
            while(d[y] > d[z]) {
                ans += val[y];
                y = getKfa(y, c[i]);
            }
            if(x == z) ans += val[z];
        }
        else {
            step = (d[x] - d[z]) % c[i];
            if(!step) ans -= val[z];
            int up = getKfa(x, ((d[x] - d[z]) / c[i] + 1) * c[i]);
            ans += (Val[x][c[i]] - Val[up][c[i]]);
            if(d[y] >= d[z]) {
                up = getKfa(y, ((d[y] - d[z]) / c[i] + 1) * c[i]);
                ans += (Val[y][c[i]] - Val[up][c[i]]);
            }
        }
        printf("%lld\n", ans);
    }

    return 0;
}

---

应用2：统计信息。

关于内存分配：开一个N的数组就行了。把一条链上每个点的起始位置分配成连续的即可。注意不要越界了。

例题：CF1009F。注意合并的时候要更新答案。合并短女儿(?)链长的长度。

#include <bits/stdc++.h>

const int N = 2000010;

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

int e[N], top[N], len[N], d[N], fa[N], son[N], n;
int f[N], op[N], num, ans[N];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS_1(int x, int f) {
    fa[x] = f;
    d[x] = d[f] + 1;
    len[x] = d[x];
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) {
            continue;
        }
        DFS_1(y, x);
        len[x] = std::max(len[x], len[y]);
        if(len[y] > len[son[x]]) {
            son[x] = y;
        }
    }
    return;
}

void DFS_2(int x, int f) {
    top[x] = f;
    op[x] = ++num;
    if(son[x]) DFS_2(son[x], f);
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == fa[x] || y == son[x]) continue;
        DFS_2(y, y);
    }
    return;
}

void update(int x, int y) {
    if(f[op[x] + ans[x]] < f[op[x] + ans[y] + 1]) {
        ans[x] = ans[y] + 1;
    }
    else if(f[op[x] + ans[x]] == f[op[x] + ans[y] + 1]) {
        ans[x] = std::min(ans[x], ans[y] + 1);
    }
    return;
}

void DFS(int x) { /// DP
    f[op[x]]++;
    ans[x] = 0;
    if(son[x]) {
        DFS(son[x]);
        update(x, son[x]);
    }
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == fa[x] || y == son[x]) continue;
        DFS(y);
        for(int j = 0; j <= len[y] - d[y]; j++) {
            f[op[x] + j + 1] += f[op[y] + j];
            if(f[op[x] + j + 1] > f[op[x] + ans[x]]) {
                ans[x] = j + 1;
            }
            else if(f[op[x] + j + 1] == f[op[x] + ans[x]]) {
                ans[x] = std::min(ans[x], j + 1);
            }
        }
        update(x, y);
    }
    return;
}

int main() {
    scanf("%d", &n);
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
    }
    DFS_1(1, 0);
    DFS_2(1, 1);
    DFS(1);
    for(int i = 1; i <= n; i++) printf("%d\n", ans[i]);
    return 0;
}

还可以OSU on tree来做。

BZOJ3252: 攻略

正解是DFS序，不过有个长链剖分的蛇皮怪做法.....首先转化成k个不相交的竖链。

本质都是贪心的取链删链。可以用DFS序维护每个点的收益，删链的时候暴力跳，每个点只会被跳到一次。

长链剖分就直接选链长前k大即可......

#include <bits/stdc++.h>

typedef long long LL;
const int N = 200010;

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

int top[N], son[N], fa[N], e[N];
LL val[N], d[N], len[N];
std::priority_queue<LL> Q;

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS_1(int x, int f) {
    len[x] = d[x];
    fa[x] = f;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) continue;
        d[y] = d[x] + val[y];
        DFS_1(y, x);
        len[x] = std::max(len[x], len[y]);
        if(len[y] > len[son[x]]) {
            son[x] = y;
        }
    }
    return;
}

void DFS_2(int x, int f) {
    top[x] = f;
    if(son[x]) DFS_2(son[x], f);
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == fa[x] || y == son[x]) continue;
        DFS_2(y, y);
    }
    return;
}

int main() {
    int n, k;
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; i++) scanf("%lld", &val[i]);
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
    }

    d[1] = val[1];
    DFS_1(1, 0);
    DFS_2(1, 1);

    for(int x = 1; x <= n; x++) {
        if(top[x] == x) Q.push(len[x] - d[fa[x]]);
    }
    LL ans = 0;
    for(int i = 1; i <= k; i++) {
        if(!Q.size()) break;
        ans += Q.top();
        Q.pop();
    }

    printf("%lld\n", ans);
    return 0;
}

BZOJ3522: Hotel

这是水水版，但是n²DP居然卡我空间...转移顺序很毒，要memcpy。

#include <bits/stdc++.h>

#define forson(x, i) for(int i = e[x]; i; i = edge[i].nex)
#define rep(i, a, b) for(int i = a; i <= b; i++)

typedef long long LL;
const int N = 5010;

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

int e[N], d[N], len[N];
int f[N][N], g[N][N], t1[N], t2[N];
LL ans;

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS(int x, int fa) {
    d[x] = d[fa] + 1;
    f[x][0] = 1;
    len[x] = d[x];
    forson(x, i) {
        int y = edge[i].v;
        if(y == fa) continue;
        DFS(y, x);
        len[x] = std::max(len[x], len[y]);
        /// DP ????
        memcpy(t1, f[x], sizeof(f[x]));
        memcpy(t2, g[x], sizeof(g[x]));
        for(int j = len[y] - d[y]; j >= 0; j--) {
            ans += t1[j] * g[y][j + 1];
            ans += t2[j + 1] * f[y][j];
            //printf("ans += %lld * %lld \n", t1[j], g[y][j + 1]);
            //printf("ans += %lld * %lld \n", t2[j + 1], f[y][j]);
            //printf("ans = %lld \n", ans);
            g[x][j + 1] += f[y][j] * t1[j + 1]; /// merge f -> g
            f[x][j + 1] += f[y][j]; /// f -> f
            g[x][j] += g[y][j + 1]; /// g -> g
        }
        /*printf("x = %d  y = %d \n", x, y);
        rep(j, 0, len[x]) {
            printf("%d  f %lld  g %lld \n", j, f[x][j], g[x][j]);
        }
        puts("");*/
    }
    return;
}

int main() {
    //freopen("in.in", "r", stdin);
    //freopen("my.out", "w", stdout);

    //printf("%d \n", sizeof(f) * 2 / 1048576);
    int n;
    scanf("%d", &n);
    rep(i, 1, n - 1) {
        int x, y;
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
    }
    DFS(1, 0);
    printf("%lld\n", ans);
    return 0;
}

有一种做法是枚举中间点。

用指针实现的长链剖分。注意这个倒着的g数组空间不好精确开......多开点就完事了。

#include <bits/stdc++.h>
 
#define forson(x, i) for(int i = e[x]; i; i = edge[i].nex)
 
typedef long long LL;
const int N = 200010;
 
struct Edge {
    int nex, v;
}edge[N << 1]; int tp;
 
int e[N], d[N], len[N], fa[N], numf, numg, son[N], top[N], lm[N];
LL F[N << 1], G[N << 2], *f[N], *g[N];
LL ans;
 
inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}
 
/* the old DFS ELF ELF elf Asphodelus minori August yuzu-soft KID Key Leaf aquasoft kenoQ ASPHODELUS Restoration Hesitation Snow Moving Go On AlphaBeta Distrily Island
void DFS(int x, int fa) {
    d[x] = d[fa] + 1;
    f[x][0] = 1;
    len[x] = d[x];
    forson(x, i) {
        int y = edge[i].v;
        if(y == fa) continue;
        DFS(y, x);
        len[x] = std::max(len[x], len[y]);
        /// DP ????
        memcpy(t1, f[x], sizeof(f[x]));
        memcpy(t2, g[x], sizeof(g[x]));
        for(int j = len[y] - d[y]; j >= 0; j--) {
            ans += t1[j] * g[y][j + 1];
            ans += t2[j + 1] * f[y][j];
            g[x][j + 1] += f[y][j] * t1[j + 1]; /// merge f -> g
            f[x][j + 1] += f[y][j]; /// f -> f
            g[x][j] += g[y][j + 1]; /// g -> g
        }
    }
    return;
}
*/
 
void DFS_1(int x, int father) {
    d[x] = d[father] + 1;
    fa[x] = father;
    len[x] = d[x];
    forson(x, i) {
        int y = edge[i].v;
        if(y == father) continue;
        DFS_1(y, x);
        len[x] = std::max(len[x], len[y]);
        if(len[y] > len[son[x]]) {
            son[x] = y;
        }
    }
    lm[x] = len[x] - d[x];
    return;
}
 
void DFS_2(int x, int father) {
    top[x] = father;
    f[x] = F + (++numf);
    g[x] = G + (++numg);
    //g[x] = G + numf;
    if(son[x]) {
        DFS_2(son[x], father);
    }
    forson(x, i) {
        int y = edge[i].v;
        if(y == fa[x] || y == son[x]) continue;
        numg += lm[y];
        DFS_2(y, y);
    }
 
    return;
}
 
inline void out(int x) {
    for(int i = 0; i <= len[x] - d[x]; i++) {
        printf("f %d %d = %d \n", x, i, f[x][i]);
    }
    for(int i = 0; i <= lm[x]; i++) {
        printf("g %d %d = %d \n", x, i, g[x][-i]);
    }
    return;
}
 
void DFS(int x) {
    f[x][0] = 1;
    if(son[x]) DFS(son[x]);
    ans += g[x][0];
 
    //printf("%d -- > %d \n", x, son[x]);
    //out(x);
 
    forson(x, i) {
        int y = edge[i].v;
        if(y == fa[x] || y == son[x]) continue;
        DFS(y);
        /// merge
        for(int i = 0; i <= len[x] - d[x] && i < lm[y]; i++) {
            ans += f[x][i] * g[y][-(i + 1)];
        }
        for(int i = 0; i <= len[y] - d[y] && i < lm[x]; i++) {
            ans += g[x][-(i + 1)] * f[y][i];
        }
        for(int i = 0; i <= len[y] - d[y] && i < lm[x] && i < len[x] - d[x]; i++) {
            g[x][-(i + 1)] += f[x][i + 1] * f[y][i]; /// i < d[x]
            //if(x == 5 && i + 1 == 2) printf("1111111111111111111");
        }
        for(int i = 0; i <= lm[x] && i < lm[y]; i++) {
            g[x][-(i)] += g[y][-(i + 1)]; /// i < d[x]
            //if(x == 5 && i == 2) printf("g %d %d = %lld \n", x, i, g[x][-i]);
            //if(x == 5 && i == 2) printf("222222222222222");
        }
        for(int i = 0; i <= len[y] - d[y] && i < len[x] - d[x]; i++) {
            f[x][i + 1] += f[y][i]; ///
        }
 
        //printf("%d -> %d \n", x, y);
        //out(x);
    }
    return;
}
 
int main() {
 
    int n;
    scanf("%d", &n);
    for(int i = 1; i < n; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
    }
    DFS_1(1, 0);
    numg = N;
    DFS_2(1, 1);
    DFS(1);
    printf("%lld\n", ans);
    return 0;
}