数据结构 on 分而治之

树状数组及典型例题

Sun, 13 Jul 2025 11:40:00 +0800

BIT 中 Binary 是形容 Index 的，不是形容 Tree 的。

树状数组

树状数组是一种支持单点修改和区间查询的代码量较小的数据结构。树状数组能解决的问题是线段树能解决的问题的子集，也就是说树状数组能解决的问题线段树一定能解决，线段树能解决的问题树状数组不一定能解决。

常规情况下用树状数组的前提条件：存储的信息和运算方法要支持结合律和可差分。

可差分：有逆运算。

当然，例如 $\max$ 等不可差分运算，树状数组只能支持前缀查询。

引入

举个例子，我们想知道 $a[1] + a[2] + \cdots + a[7]$ 的前缀和。

普通的做法是：直接将 $7$ 个数求和。

树状数组的做法是：将一段前缀 $[1, n]$ 分割成不超过 $\log n$ 段区间，并通过一些预处理使得每段区间的和都可以 $O(1)$ 地求出。于是，我们就成功地缩减了问题规模。

管辖区间

下图展示了树状数组的工作原理：

不难发现，$c[i]$ 管辖 $[i - lowbit(i) + 1, i]$ 这段区间。

lowbit(x) 是指 x 在二进制下最低的 1 及其后面的 0，根据二进制反码相关知识可以推导出较为简单的计算方法：lowbit(x) = x & -x。

前缀（区间）查询

为了不重不漏的拆分前缀区间，每次向前“跳”的时候一定是要“跳”到当前区间的左端点的左一位作为新区间的右端点，根据刚刚提到的管辖区间可得新右端点应为 $i - lowbit(i)$。

int query(int x) {
    int res = 0;
    for (int i = x; i >= 1; i -= lowbit(i)) res += c[i]; // 此处运算方法根据题意替换；看个人习惯，for循环可写作while循环
    return res;
}

注意第 3 行不要写成 i -= lowbit(x)

根据前缀和的原理，只要运算方法是可差分的，可以前缀查询就是可以区间查询。

单点修改

在进行单点修改时，只需遍历所有管辖 $a[i]$ 的 $c[x]$。由于 $c[i]$ 被 $c[i + lowbit(i)]$ 直接管辖，我们就可以直接通过这种方式来遍历所有需要修改的 $c[x]$。

1
2
3

void update(int x, int val) {
    for (int i = x; i <= n; i += lowbit(i)) c[i] += val; // 根据题意替换；可写作while循环
}

建树

最简单的方法是直接替换成 $n$ 次单点修改，复杂度 $O(n \log n)$。

也可以 $\Theta (n)$ 建树，方法很多，这里介绍一种：

既然 $c[i]$ 表示的区间是 $[i - lowbit(i) + 1, i]$，我们就可以 $\Theta (n)$ 建立一个前缀和数组，再通过前缀和求区间和的方法写入 $c$ 数组。

复杂度分析

时间复杂度：

建树：$\Theta (n)$ 或 $O(n \log n)$
修改：$O(\log n)$
查询：$O(\log n)$

空间复杂度：$O(n)$

参考代码

P3374 【模板】树状数组 1

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 5e5 + 10;

LL a[N], c[N];
int n, m;

inline int lowbit(int x) { return x & -x; }

void update(int x, LL val) {
    while (x <= n) {
        c[x] += val;
        x += lowbit(x);
    }
}

LL query(int x) {
    LL res = 0;
    while (x > 0) {
        res += c[x];
        x -= lowbit(x);
    }
    return res;
}

int main() {
    cin >> n >> m;
	for (int i = 1; i <= n; i ++ ) cin >> a[i], update(i, a[i]);

    while (m -- ) {
        int op;
        cin >> op;
        if (op == 1) {
            int x; LL k;
            cin >> x >> k;
            update(x, k);
        } else if (op == 2) {
            int x, y;
            cin >> x >> y;
            cout << query(y) - query(x - 1) << endl;
        }
    }
    return 0;
}

Luogu P3368. 树状数组 2

P3368 【模板】树状数组 2

题意

区间修改，单点查询。

分析

我们可以通过差分算法将区间修改转化为单点修改，同时单点查询变为区间查询，树状数组秒了。

参考代码

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 5e5 + 10;

LL a[N], s[N];
LL c[N];
int n, m;

inline int lowbit(int x) { return x & -x; }

void update(int x, LL val) {
    while (x <= n) {
        c[x] += val;
        x += lowbit(x);
    }
}

LL query(int x) {
    LL res = 0;
    while (x > 0) {
        res += c[x];
        x -= lowbit(x);
    }
    return res;
}

int main() {
    cin >> n >> m;
	
	for (int i = 1; i <= n; i ++ ) cin >> a[i];
	for (int i = 1; i <= n; i ++ ) s[i] = a[i] - a[i - 1];
    for (int i = 1; i <= n; i ++ ) {
        update(i, s[i]);
    }

    while (m -- ) {
        int op;
        cin >> op;
        if (op == 1) {
            LL x, y, k;
            cin >> x >> y >> k;
            update(x, k);
            update(y + 1, -k);
        } else if (op == 2) {
            int x;
            cin >> x;
            cout << query(x) << endl;
        }
    }
    return 0;
}

哈希表

Thu, 21 Apr 2022 21:24:00 +0800

UPD: 2025-07-13

功能

add(8);
add(9);
find(10); // false
find(8); // true

实现

首先，写一个散列函数。

1
2
3

int get(int x) {
    return (x % N + N) % N; // 解决负数问题
}

接着，就出现了问题，散列值可能发生碰撞，如何解决呢？

拉链法

每个散列值存一个链表（结构就很像链式前向星了）。

代码如下：

#include <cstring>
#include <iostream>

using namespace std;

const int N = 100003;

int h[N], e[N], ne[N], idx;

void insert(int x) {
    int k = (x % N + N) % N;
    e[idx] = x;
    ne[idx] = h[k];
    h[k] = idx ++ ;
}

bool find(int x) {
    int k = (x % N + N) % N;
    for (int i = h[k]; i != -1; i = ne[i])
        if (e[i] == x)
            return true;

    return false;
}

int main() {
    int n;
    scanf("%d", &n);

    memset(h, -1, sizeof h);

    while (n -- ) {
        char op[2];
        int x;
        scanf("%s%d", op, &x);

        if (*op == 'I') {
            insert(x);
        } else {
            if (find(x)) puts("Yes");
            else puts("No");
        }
    }

    return 0;
}

开放寻址法

通过让 $N$ 增大减少碰撞。并在每次碰撞发生时向后找空位（这是放的时候）。代码如下：

#include <cstring>
#include <iostream>

using namespace std;

const int N = 200003, null = 0x3f3f3f3f;

int h[N];

int find(int x) {
    int t = (x % N + N) % N;
    while (h[t] != null && h[t] != x)
    {
        t ++ ;
        if (t == N) t = 0;
    }
    return t;
}

int main() {
    memset(h, 0x3f, sizeof h);

    int n;
    scanf("%d", &n);

    while (n -- ) {
        char op[2];
        int x;
        scanf("%s%d", op, &x);
        if (*op == 'I') {
            h[find(x)] = x;
        } else {
            if (h[find(x)] == null) puts("No");
            else puts("Yes");
        }
    }

    return 0;
}

循环队列

Tue, 19 Apr 2022 15:25:00 +0800

UPD: 2023-10-21 UPD: 2025-07-13

循环队列

功能

节省空间。

普通队列用过的空间不能用了，循环队列可以重复利用。

`1`	`push(1); pop(); push(2); pop();`

实际比赛中根本用不到（现在这年头还有谁手写数据结构啊），直接用 STL queue。

代码

#include <iostream>

using namespace std;

// 队列长度，可以自己修改。
const int N = 10;

// 队列
struct Queue {
    int q[N];
    int hh = 1, tt = 0;

    void push(int x) {
        q[( ++ tt) % N] = x;
        if (hh / N && tt / N) {
            hh -= (int)min(hh / N, tt / N) * N;
            tt -= (int)min(hh / N, tt / N) * N;
        }
    }

    void pop() {
        hh ++ ;
    }

    int front() {
        return q[hh % N];
    }

    int back() {
        return q[tt % N];
    }

    bool empty() {
        return hh > tt;
    }

    int size() {
        return tt - hh + 1;
    }
};