树上差分详解

EQUINOX1

于 2024-09-27 20:26:05 发布

阅读量503

点赞数 11

分类专栏：数据结构与算法文章标签：算法树上问题

本文链接：https://blog.csdn.net/EQUINOX1/article/details/142601747

版权

数据结构与算法专栏收录该内容

95 篇文章 6 订阅

订阅专栏

零、前言

关于差分：

差分数组详解，一维二维差分-CSDN博客

关于LCA：

LCA算法-倍增算法_lca倍增算法-CSDN博客

LCA算法-Tarjan算法_lca数组-CSDN博客

树链剖分——重链剖分，原理剖析，代码详解-CSDN博客

一、树上差分

1.1 问题引入

多次对树上的一些点/边做加法操作，然后询问某个点或某条边经过操作后的值。

1.2 点差分

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

例如，初态树上的各点点权为 0，现对路径(x, y)上的点均做 +1操作，等价于

d[x] += 1, d[y] += 1, d[lca] -= 1, d[fa(lca)] -= 1

进行深搜递归，自底向上计算节点差分值的子树和(还原)，恰好使得路径(x, y)上的点权均为 1，同时消除了对 lca 之上的节点的影响。

1.3 边差分

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

例如，初态树上的各边边权为 0，现对路径(x, y)上的边均做 +1操作。对边权的操作比较困难，通常把边权下移给节点，变成点权操作。等价于

d[x] += 1, d[y] += 1, d[lca] -= 2

进行深搜递归，自底向上计算节点差分值的子树和(还原)恰好使得路径(x, y)上的边权均为 1，同时消除了对 lca 之上的边的影响,

1.4 利用dfs序差分恢复

2.3 中利用 dfs 差分恢复被卡常了，事实上我们可以用 dfs序来进行差分恢复

假如我们得到了dfs序递增的节点序列：seq[]，seq[i] 的 dfn = i

那么可以如此恢复：

for (int i = n - 1; ~i; -- i)
	if (seq[i])	// 节点从0开始
		diff[fa[seq[i]]] += diff[seq[i]];

二、OJ练习

2.1 暗之连锁

原题链接

U143800 暗之连锁 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

思路分析

板子题，直接写就行

AC代码

#include <bits/stdc++.h>

// #define DEBUG

using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;

constexpr int inf32 = 1E9 + 7;
constexpr i64 inf64 = 1E18 + 7;

constexpr int B = 20;

void solve() {
    int n, k;
    std::cin >> n >> k;

    std::vector<std::vector<int>> adj(n);

    for (int i = 1, u, v; i < n; ++ i) {
        std::cin >> u >> v;
        -- u, -- v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    std::vector<std::array<int, B>> f(n, std::array<int, B>{});
    std::vector<int> d(n), w(n);


    auto dfs = [&](auto &&self, int u, int p) -> void{
        if (u) {
            f[u][0] = p;
            for (int i = 1; i < B; ++ i) {
                assert(0 <= f[u][i - 1] && f[u][i - 1] < n);
                f[u][i] = f[f[u][i - 1]][i - 1];
            }
        }

        for (int v : adj[u]) {
            if (v == p) continue;
            d[v] = d[u] + 1;

            self(self, v, u);
        }
    };

    dfs(dfs, 0, -1);

    auto LCA = [&](int u, int v) -> int {
        if (d[u] < d[v]) std::swap(u, v);
        for (int i = B - 1; ~i; -- i)
            if (d[f[u][i]] >= d[v])
                u = f[u][i];

        if (u == v)
            return u;

        for (int i = B - 1; ~i; -- i)
            if (f[u][i] != f[v][i]) {
                u = f[u][i];
                v = f[v][i];
            }

        return f[u][0];
    }; 

    for (int i = 0, s, t; i < k; ++ i) {
        std::cin >> s >> t;
        -- s, -- t;
        ++ w[s], ++ w[t];
        int lca = LCA(s, t);
        -- w[lca];
        if (lca)
            -- w[f[lca][0]];
    }

    auto dfs1 = [&](auto &&self, int u, int p) -> void{
        for (int v : adj[u])
            if (v != p) {
                self(self, v, u);
                w[u] += w[v];
            }
    };

    dfs1(dfs1, 0, -1);

    std::cout << *max_element(w.begin(), w.end()) << '\n';
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

#ifdef DEBUG
    int cur = clock();
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif

    int t = 1;
    // std::cin >> t;

    while (t--) {
        solve();
    }
#ifdef DEBUG
    std::cerr << "run-time: " << clock() - cur << '\n';
#endif
    return 0;
}

2.2 松鼠的新家

原题链接

[P3258 JLOI2014] 松鼠的新家 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

思路分析

考虑先将树上差分将<a[i], a[i + 1]> 的所有路径都 + 1

dfs1 求完子树和后，我们发现 a[1, n] 都会重复+1，我们将其再-1即可

AC代码

#include <bits/stdc++.h>

// #define DEBUG

using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;

constexpr int inf32 = 1E9 + 7;
constexpr i64 inf64 = 1E18 + 7;

constexpr int B = 20;

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n);
    for (int i = 0; i < n; ++ i) {
        std::cin >> a[i];
        -- a[i];
    }

    std::vector<std::vector<int>> adj(n);
    for (int i = 1, u, v; i < n; ++ i) {
        std::cin >> u >> v;
        -- u, -- v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    std::vector<int> d(n);

    std::vector<std::array<int, B>> f(n, std::array<int, B>{});

    auto dfs = [&](auto &&self, int u, int p) -> void {
        if (u) {
            f[u][0] = p;
            for (int i = 1; i < B; ++ i) {
                f[u][i] = f[f[u][i - 1]][i - 1];
            }
        }

        for (int v : adj[u]) {
            if (v == p) continue;
            d[v] = d[u] + 1;

            self(self, v, u);
        }
    };

    dfs(dfs, 0, -1);

    auto LCA = [&](int u, int v) -> int {
        if (d[u] < d[v]) std::swap(u, v);
        for (int i = B - 1; ~i; -- i)
            if (d[f[u][i]] >= d[v])
                u = f[u][i];

        if (u == v)
            return u;

        for (int i = B - 1; ~i; -- i)
            if (f[u][i] != f[v][i]) {
                u = f[u][i];
                v = f[v][i];
            }

        return f[u][0];
    }; 

    std::vector<int> w(n);

    for (int i = 0; i + 1 < n; ++ i) {
        ++ w[a[i]], ++ w[a[i + 1]];
        int lca = LCA(a[i], a[i + 1]);
        -- w[lca];
        if (lca)
            -- w[f[lca][0]];
    }

    auto dfs1 = [&](auto &&self, int u, int p) -> void{
        for (int v : adj[u])
            if (v != p) {
                self(self, v, u);
                w[u] += w[v];
            }
    };

    dfs1(dfs1, 0, -1);

    for (int i = 1; i < n; ++ i)
        -- w[a[i]];

    for (int i = 0; i < n; ++ i) {
        std::cout << w[i] << '\n';
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

#ifdef DEBUG
    int cur = clock();
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif

    int t = 1;
    // std::cin >> t;

    while (t--) {
        solve();
    }
#ifdef DEBUG
    std::cerr << "run-time: " << clock() - cur << '\n';
#endif
    return 0;
}

2.3 运输计划

原题链接

[P2680 NOIP2015 提高组] 运输计划 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

思路分析

树上差分 + 二分

考虑所有计划并发同时执行，那么如果 t 时刻可行，T > t 时刻仍然可行

具有单调性，选择二分

给定答案x，如何check？

如果时间大于 x 的计划数目为 cnt，这cnt个计划最大时间为ma，存在合法虫洞 <=> <u, v, w> 被这cnt 个计划覆盖并且 ma - w <= x

如何获得被cnt个计划都覆盖的边？——树上差分

注意：本题卡常，如果像我一样不喜欢开全局变量，喜欢使用STL的话，注意二分上下界以及用 dfs 序倒着累加 diff 来替代dfs

AC代码

#include <bits/stdc++.h>

// #define DEBUG

using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;

constexpr int inf32 = 1E9 + 7;
constexpr i64 inf64 = 1E18 + 7;

constexpr int B = 20;

struct Edge{
    int v, w;
};

void solve() {
    int n, m;
    std::cin >> n >> m;

    std::vector<std::vector<int>> g(n);
    std::vector<Edge> e;

    auto addEdge = [&](int u, int v, int w) {
        g[u].push_back(e.size());
        e.emplace_back(v, w);
        g[v].push_back(e.size());
        e.emplace_back(u, w);
    };

    for (int i = 1, u, v, w; i < n; ++ i) {
        std::cin >> u >> v >> w;
        -- u, -- v;
        addEdge(u, v, w);
    }

    std::vector<int> d(n), acc(n), o(n), seq(n);
    std::vector<std::array<int, B>> f(n, std::array<int, B>{});

    int dfn = 0;
    auto dfs = [&](auto &&self, int u, int p) -> void {
        seq[dfn ++] = u;
        if (u) {
            f[u][0] = p;
            for (int i = 1; i < B; ++ i) {
                f[u][i] = f[f[u][i - 1]][i - 1];
            }
        }

        for (int i : g[u]) {
            auto [v, w] = e[i];
            if (v == p) continue;
            d[v] = d[u] + 1;
            acc[v] = acc[u] + w;
            o[v] = w;

            self(self, v, u);
        }
    };

    dfs(dfs, 0, -1);

    auto LCA = [&](int u, int v) -> int {
        if (d[u] < d[v]) std::swap(u, v);
        for (int i = B - 1; ~i; -- i)
            if (d[f[u][i]] >= d[v])
                u = f[u][i];

        if (u == v)
            return u;

        for (int i = B - 1; ~i; -- i)
            if (f[u][i] != f[v][i]) {
                u = f[u][i];
                v = f[v][i];
            }

        return f[u][0];
    }; 

    std::vector<int> diff(n);
    std::vector<std::tuple<int, int, int, int>> path;

    for (int i = 0, u, v; i < m; ++ i) {
        std::cin >> u >> v;
        -- u, -- v;
        int lca = LCA(u, v);
        diff[lca] -= 2;
        path.emplace_back(u, v, acc[u] + acc[v] - acc[lca] * 2, lca);
    }

    auto check = [&](int x) -> bool{
        diff.assign(n, 0);
        int cnt = 0, ma = 0;
        for (auto &[u, v, len, lca]: path)
            if (len > x) {
                ++ cnt;
                ma = std::max(ma, len);
                ++ diff[u], ++ diff[v];
                diff[lca] -= 2;
            }
        
        for (int i = n - 1; ~i; -- i)
            if (seq[i])
                diff[f[seq[i]][0]] += diff[seq[i]];

        for (int i = 0; i < n; ++ i) {
            if (diff[i] == cnt && ma - o[i] <= x) {
                return true;
            }
        }
        return false;
    };

    int lo = *std::max_element(o.begin(), o.end()), hi = 0;
    for (auto &[u, v, len, lca] : path)
        hi = std::max(hi, len + 1);
    lo = hi - lo - 1;

    while (lo < hi) {
        int x = (lo + hi) / 2;
        if (check(x)) hi = x;
        else lo = x + 1;
    }

    std::cout << lo << '\n';
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

#ifdef DEBUG
    int cur = clock();
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif

    int t = 1;
    // std::cin >> t;

    while (t--) {
        solve();
    }
#ifdef DEBUG
    std::cerr << "run-time: " << clock() - cur << '\n';
#endif
    return 0;
}