2. 程式人生 > 實用技巧 >樹上差分學習筆記

樹上差分學習筆記

阿新 • • 發佈：2021-01-01

引入

1172. 祖孫詢問

Code：板子

P3379 【模板】最近公共祖先（LCA）

Code：又一道板子

P3258 [JLOI2014]松鼠的新家

樹上差分板子，讓每個點到下一個點之間的路徑

Code：差分板子

P3128 [USACO15DEC]Max Flow P

Code：也是差分板子

總結一下樹上差分：

分為點差分和邊差分，一個是統計路徑上點上資訊，一個是統計路徑上邊上資訊，舉個例子：路徑點數路徑邊數

  • 點差分：在兩個兒子處加1，在lca處減1，在lca的父親處減1

  • 邊差分：在兩個兒子處加1，在lca處減2

重點：“減還是加”？“統計從上到下還是子樹資訊？”

第一個問題上面已經說到，第二個問題：將差分變為真實值是統計子樹資訊，此時每個點的單點答案已經正確（例如：一個點被覆蓋的次數），也就是，完成了“區間修改，單點查詢”

如果還想查詢一條鏈的資訊，就要從上到下統計資訊，然後在lca處容斥即可（分點差分和邊差分），也就是“區間修改，區間查詢”

實戰

商人 5.0

要用到上面所說的“區間修改，區間查詢”

Code

Code1：
#include <bits/stdc++.h>
using namespace std;
const int MA = 1 << 23;
char buf[MA], *p1 = buf, *p2 = buf;
#define gc()                                                            \
    (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MA, stdin), p1 == p2) \
         ? EOF                                                          \
         : *p1++)
inline int read() {
    int f = 0, r = 1;
    char ch = gc();
    while (!isdigit(ch)) {
        if (ch == '-') r = -1;
        ch = gc();
    }
    while (isdigit(ch)) {
        f = (f << 1) + (f << 3) + (ch ^ 48);
        ch = gc();
    }
    return f * r;
}
const int N = 40005;
int n, m, root, fa[N][20], dep[N], q[N];
vector<int> son[N];
inline void get_fa_bfs() {
    memset(dep, 0x3f, sizeof dep);
    int hh = 0, tt = 0;
    dep[0] = 0, dep[root] = 1, q[0] = root;
    while (hh <= tt) {
        int x = q[hh++];
        for (int i = 0; i < son[x].size(); ++i) {
            int y = son[x][i];
            if (dep[y] < dep[x] + 1) continue;
            dep[y] = dep[x] + 1, fa[y][0] = x, q[++tt] = y;
            for (int k = 1; (1 << k) <= n; ++k)
                fa[y][k] = fa[fa[y][k - 1]][k - 1];
        }
    }
}
inline int lca(int U, int V) {
    if (dep[U] < dep[V]) swap(U, V);
    for (int k = 15; ~k; --k)
        if (dep[fa[U][k]] >= dep[V]) U = fa[U][k];
    if (U == V) return U;
    for (int k = 15; ~k; --k)
        if (fa[U][k] != fa[V][k]) U = fa[U][k], V = fa[V][k];
    return fa[U][0];
}
signed main() {
    n = read();
    for (int i = 1, u, v; i <= n; ++i) {
        u = read(), v = read();
        if (v == -1)
            root = u;
        else
            son[u].push_back(v), son[v].push_back(u);
    }
    get_fa_bfs();
    m = read();
    for (int i = 1, u, v; i <= m; ++i, putchar('\n'))
        u = read(), v = read(),
        putchar(lca(u, v) == u ? '1' : (lca(u, v) == v ? '2' : '0'));
    return 0;
}
Code2：
#include <bits/stdc++.h>
using namespace std;
const int MA = 1 << 23;
char buf[MA], *p1 = buf, *p2 = buf;
#define gc()                                                            \
    (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MA, stdin), p1 == p2) \
         ? EOF                                                          \
         : *p1++)
inline int read() {
    int ff = 0, rr = 1;
    char ch = gc();
    while (!isdigit(ch)) {
        if (ch == '-') rr = -1;
        ch = gc();
    }
    while (isdigit(ch)) {
        ff = (ff << 1) + (ff << 3) + (ch ^ 48);
        ch = gc();
    }
    return ff * rr;
}
void print(int x) {
    if (x < 0) putchar('-'), x = -x;
    if (x > 9) print(x / 10);
    putchar(x % 10 + '0');
}
const int N = 500005;
int n, m, root, fa[N][25], dep[N], q[N];
vector<int> son[N];
inline void get_fa_bfs() {
    memset(dep, 0x3f, sizeof dep);
    int hh = 0, tt = 0;
    dep[root] = 1, dep[0] = 0, q[0] = root;
    while (hh <= tt) {
        int x = q[hh++];
        for (int i = 0; i < son[x].size(); ++i) {
            int y = son[x][i];
            if (dep[y] < dep[x] + 1) continue;
            dep[y] = dep[x] + 1, fa[y][0] = x, q[++tt] = y;
            for (int k = 1; (1 << k) <= n; ++k)
                fa[y][k] = fa[fa[y][k - 1]][k - 1];
        }
    }
}
inline int lca(int U, int V) {
    if (dep[U] < dep[V]) swap(U, V);
    for (int k = 15; ~k; --k)
        if (dep[fa[U][k]] >= dep[V]) U = fa[U][k];
    if (U == V) return U;
    for (int k = 15; ~k; --k)
        if (fa[U][k] != fa[V][k]) U = fa[U][k], V = fa[V][k];
    return fa[U][0];
}
signed main() {
    n = read(), m = read(), root = read();
    for (int i = 1, u, v; i < n; ++i)
        u = read(), v = read(), son[u].push_back(v), son[v].push_back(u);
    get_fa_bfs();
    for (int i = 1, u, v; i <= m; ++i, putchar('\n'))
        u = read(), v = read(), print(lca(u, v));
    return 0;
}
Code3：
#include <bits/stdc++.h>
using namespace std;
const int MA = 1 << 23;
char buf[MA], *p1 = buf, *p2 = buf;
#define gc()                                                            \
    (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MA, stdin), p1 == p2) \
         ? EOF                                                          \
         : *p1++)
inline int read() {
    int ff = 0, rr = 1;
    char ch = gc();
    while (!isdigit(ch)) {
        if (ch == '-') rr = -1;
        ch = gc();
    }
    while (isdigit(ch)) {
        ff = (ff << 1) + (ff << 3) + (ch ^ 48);
        ch = gc();
    }
    return ff * rr;
}
void print(int x) {
    if (x < 0) putchar('-'), x = -x;
    if (x > 9) print(x / 10);
    putchar(x % 10 + '0');
}
const int N = 300005;
int n, fa[N][20], dep[N], q[N], a[N], point[N];
vector<int> son[N];
inline void get_fa_bfs() {
    memset(dep, 0x3f, sizeof dep);
    int hh = 0, tt = 0;
    dep[0] = 0, dep[1] = 1, q[0] = 1;
    while (hh <= tt) {
        int x = q[hh++];
        for (int i = 0; i < son[x].size(); ++i) {
            int y = son[x][i];
            if (dep[y] < dep[x] + 1) continue;
            dep[y] = dep[x] + 1, fa[y][0] = x, q[++tt] = y;
            for (int k = 1; (1 << k) <= n; ++k)
                fa[y][k] = fa[fa[y][k - 1]][k - 1];
        }
    }
}
inline int lca(int U, int V) {
    if (dep[U] < dep[V]) swap(U, V);
    for (int k = 19; ~k; --k)
        if (dep[fa[U][k]] >= dep[V]) U = fa[U][k];
    if (U == V) return U;
    for (int k = 19; ~k; --k)
        if (fa[U][k] != fa[V][k]) U = fa[U][k], V = fa[V][k];
    return fa[U][0];
}
void get_sum_dfs(int x, int F) {
    for (int i = 0; i < son[x].size(); ++i) {
        int y = son[x][i];
        if (y == F) continue;
        get_sum_dfs(y, x);
        point[x] += point[y];
    }
}
signed main() {
    n = read();
    for (int i = 1, u, v; i <= n; ++i) a[i] = read();
    for (int i = 1, u, v; i < n; ++i)
        u = read(), v = read(), son[u].push_back(v), son[v].push_back(u);
    get_fa_bfs();
    for (int i = 2; i <= n; ++i)
        ++point[a[i - 1]], ++point[a[i]], --point[lca(a[i - 1], a[i])],
            --point[fa[lca(a[i - 1], a[i])][0]];
    get_sum_dfs(1, 0);
    for (int i = 2; i <= n; ++i) --point[a[i]];
    for (int i = 1; i <= n; ++i, putchar('\n')) print(point[i]);
    return 0;
}
Code4：
#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
vector <int> G[N];
int n, m, ans, point[N];
int dep[N], fa[N][25], q[N];

inline void get_fa_bfs() {
    memset(dep, 0x3f, sizeof dep);
    int hh = 0, tt = 0;
    q[0] = 1, dep[0] = 0, dep[1] = 1;
    while (hh <= tt) {
        int x = q[hh ++];
        for (int i = 0; i < G[x].size(); ++i) {
            int y = G[x][i];
            if (dep[y] < dep[x] + 1) continue;
            dep[y] = dep[x] + 1;
            fa[y][0] = x, q[++ tt] = y;
            for (int k = 1; (1 << k) <= n; ++k)
                fa[y][k] = fa[fa[y][k - 1]][k - 1];
        }
    }
}

inline int lca(int U, int V) {
    if (dep[U] < dep[V]) swap(U, V);
    for (int k = 21; ~k; --k)
        if (dep[fa[U][k]] >= dep[V]) U = fa[U][k];
    if (U == V) return U;
    for (int k = 21; ~k; --k)
        if (fa[U][k] != fa[V][k]) U = fa[U][k], V = fa[V][k];
    return fa[U][0];
}

void get_sum_dfs(int x, int F) {
    for (int i = 0; i < G[x].size(); ++i) {
        int y = G[x][i];
        if (y == F) continue;
        get_sum_dfs(y, x);
        point[x] += point[y];
    }
    ans = max(ans, point[x]);
}

signed main() {
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);

    cin >> n >> m;
    for (int i = 1, x, y; i < n; ++i) {
        cin >> x >> y;
        G[x].push_back(y), G[y].push_back(x);
    }
    get_fa_bfs();
    for (int i = 1, x, y; i <= m; ++i) {
        cin >> x >> y;
        int t = lca(x, y);
        ++ point[x], ++ point[y];
        -- point[t], -- point[fa[t][0]];
    }
    get_sum_dfs(1, 1);
    cout << ans;

    return 0;
}
Code5：
#include <bits/stdc++.h>
using namespace std;
const int MA = 1 << 23;
char buf[MA], *p1 = buf, *p2 = buf;
#define gc()                                                            \
    (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MA, stdin), p1 == p2) \
         ? EOF                                                          \
         : *p1++)
inline int read() {
    int ff = 0, rr = 1;
    char ch = gc();
    while (!isdigit(ch)) {
        if (ch == '-') rr = -1;
        ch = gc();
    }
    while (isdigit(ch)) {
        ff = (ff << 1) + (ff << 3) + (ch ^ 48);
        ch = gc();
    }
    return ff * rr;
}
void print(int x) {
    if (x < 0) putchar('-'), x = -x;
    if (x > 9) print(x / 10);
    putchar(x % 10 + '0');
}
const int N = 200005;
int n, m, point[N], edge[N], fa[N][20], dep[N], q[N], u[N], v[N], d[N];
vector<int> son[N];
inline void get_fa_bfs() {
    memset(dep, 0x3f, sizeof dep);
    int hh = 0, tt = 0;
    dep[0] = 0, dep[1] = 1, q[0] = 1;
    while (hh <= tt) {
        int x = q[hh++];
        for (int i = 0; i < son[x].size(); ++i) {
            int y = son[x][i];
            if (dep[y] < dep[x] + 1) continue;
            dep[y] = dep[x] + 1, fa[y][0] = x, q[++tt] = y;
            for (int k = 1; (1 << k) <= n; ++k)
                fa[y][k] = fa[fa[y][k - 1]][k - 1];
        }
    }
}
inline int lca(int U, int V) {
    if (dep[U] < dep[V]) swap(U, V);
    for (int k = 19; ~k; --k)
        if (dep[fa[U][k]] >= dep[V]) U = fa[U][k];
    if (U == V) return U;
    for (int k = 19; ~k; --k)
        if (fa[U][k] != fa[V][k]) U = fa[U][k], V = fa[V][k];
    return fa[U][0];
}
void get_sum_dfs(int x, int F) {
    for (int i = 0; i < son[x].size(); ++i) {
        int y = son[x][i];
        if (y == F) continue;
        get_sum_dfs(y, x);
        point[x] += point[y], edge[x] += edge[y];
    }
}
void get_ans_dfs(int x, int F) {
    for (int i = 0; i < son[x].size(); ++i) {
        int y = son[x][i];
        if (y == F) continue;
        point[y] += point[x], edge[y] += edge[x];
        get_ans_dfs(y, x);
    }
}
signed main() {
    n = read(), m = read();
    for (int i = 1, U, V; i < n; ++i)
        U = read(), V = read(), son[U].push_back(V), son[V].push_back(U);
    get_fa_bfs();
    for (int i = 1; i <= m; ++i)
        d[i] = lca(u[i] = read(), v[i] = read()), ++point[u[i]], ++point[v[i]],
        --point[d[i]], --point[fa[d[i]][0]], --edge[u[i]], --edge[v[i]],
        edge[d[i]] += 2;
    get_sum_dfs(1, 0), get_ans_dfs(1, 0);
    point[0] = edge[0] = 0;
    for (int i = 1; i <= m; ++i, putchar('\n'))
        print(point[u[i]] + point[v[i]] - point[d[i]] - point[fa[d[i]][0]] +
              edge[u[i]] + edge[v[i]] - edge[d[i]] * 2 - 1);
    return 0;
}
Code6：

相關推薦

樹上差分學習筆記

引入 1172. 祖孫詢問 Code：板子 P3379 【模板】最近公共祖先（LCA） Code：又一道板子

樹上差分 學習筆記

前置知識：差分 例題：P2367 語文成績 序列維護區間加，最後詢問序列最小值。

「學習筆記」樹上差分

問了 阿醜 兩道題的詢問操作部分，發現我兩次問的東西是一模一樣的東西：樹上差分。

圖論專題-學習筆記：樹上差分

目錄 1. 前言 2. 詳解 2.1 點上差分 2.2 邊上差分 2.3 例題 3. 總結 1. 前言 樹上差分，是一種難度不高，思維量也不大的演算法，應用範圍比較窄但是快。

演算法淺談之樹上差分

先放一道例題[USACO15DEC]Max Flow P 題目大意 給你一棵\\(n\\)個點的樹，有\\(k\\)條管道，每條管道有個起始點和終結點。從起始點到終結點的路徑上每個經過的點權值都要\\(+1\\)

P3258 [JLOI2014]松鼠的新家(樹上差分板子)

樹上差分！！！ 這是一道模板題的稍微改編 首先，啥是樹上差分 就和名字一樣，書上的差分

洛谷 P3258 [JLOI2014]松鼠的新家（樹上差分）

題目連結：https://www.luogu.com.cn/problem/P3258 對點差分： sa[u]++; sa[v]++; sa[lca(u,v)]--; sa[f[lca(u,v)][0]]--;

樹鏈剖分學習筆記（未完）

樹鏈剖分是在維護靜態樹上關於鏈的問題的好工具，感性的認識，就是把樹問題重新轉換為序列問題合併

LCA_樹上差分_洛谷_P1600天天愛跑步

題目:洛谷P1600 天天愛跑步 推薦一個寫的很好很好很好*n的題解 #include<iostream>

重鏈剖分 學習筆記

最好先看一遍OIwiki。 重鏈剖分是樹鏈剖分的一種，其他的還有長鏈剖分等。 主要的思想是將樹拆成許多鏈，對於每個鏈分別維護資訊，然後合併資訊以解決一些樹上問題。

雨天的尾巴「線段樹合併+樹上差分」

雨天的尾巴「線段樹合併+樹上差分」 題目描述(簡化版) \\(N\\) 個點，形成一個樹狀結構。有 %M$ 次發放，每次選擇兩個點 \\(x,y\\) 對於 \\(x\\) 到 \\(y\\) 的路徑上（含 \\(x,y\\))每個點發一袋 \\(Z\\) 型別的物品

hdu5452 樹上差分

hdu5452 Minimum Cut 傳送門 題意 有一個包含\\(n(2\\leq n\\leq 20000)\\)個點，\\(m(n-1\\leq m\\leq 200000)\\)條邊的無向圖，其中前\\(n-1\\)條邊是樹邊。刪除一些邊，並且其中只能包含一條樹邊，使得圖不連通，

長鏈剖分學習筆記

洛穀日報 作為樹鏈剖分中的一種，長鏈剖分遠沒有重鏈剖分和實鏈剖分常用，於是僅作簡單瞭解。

【樹上差分+樹狀陣列】bzoj 1103 大都市meg

Description 在經濟全球化浪潮的影響下,習慣於漫步在清晨的鄉間小路的郵遞員Blue Mary也開始騎著摩托車傳遞郵件了。不過，她經常回憶起以前在鄉間漫步的情景。昔日，鄉下有依次編號為1..n的n個小村莊，某些村莊之間

樹鏈剖分學習筆記

前言 書上只講了重鏈剖分，菜雞也只會這一種，想看其他的是別想了。 點權樹剖

[CF191C] Fools and Roads - LCA,樹上差分

Description 有一顆 \\(n\\)個節點的樹，\\(k\\) 次旅行，問每一條邊被走過的次數。

一道codeforces題目引發的差分學習

Codeforces Round #688 (Div. 2) 題目：B. Suffix Operations 題意：給定一個長為n的陣列a，你可以進行兩種操作：1).字尾+1;2)字尾-1； 問需要最少多少步操作你才能使得陣列中元素全部相等，並且首先你可以改變

【CF8389】Alyona and a tree 樹上差分 + 二分

技術標籤：樹形結構acm技巧二分搜尋 樹上差分 題目連結概述分析程式碼 題目連結

abc187 --E - Through Path（樹上差分）/ 樹鏈剖分+線段樹

技術標籤：訓練樹結構 題目描述： 給你一棵樹每個點的初始權值為0 N-1條邊，每條邊連線a[i] - b[i] 然後給你q個操作（兩種）

CF570D Tree Requests 樹上差分/dsu on tree

判斷能否構成迴文很簡單，出現次數為偶數的不用管，出現次數為奇數的最多有一個