线段树和线段数组

线段树

第一部 概念引入

线段树是一种二叉树，也就是对于一个线段，我们会用一个二叉树来表示。比如说一个长度为4的线段，我们可以表示成这样：

这是什么意思呢？ 如果你要表示线段的和，那么最上面的根节点的权值表示的是这个线段 1 ∼ 4 的和。根的两个儿子分别表示这个线段中 1 ∼ 2 的和，与 3 ∼ 4的和。以此类推。

然后我们还可以的到一个性质：节点 i 的权值 = 她的左儿子权值 + 她的右儿子权值。因为 1 ∼ 4 的和就是等于 1 ∼ 2  的和与 2 ∼ 3的和的和。

根据这个思路，我们就可以建树了，我们设一个结构体 tree，tree[i].l 与 tree[i].r 分别表示这个点代表的线段的左右下标，tree[i].sum 表示这个节点表示的线段和。

我们知道，一颗从 1 开始编号的二叉树，结点 i 的左儿子和右儿子编号分别是 2 × i 和 2 × i + 1

再根据刚才的性质，得到式子：tree[ i ].sum = tree[ i ∗ 2 ].sum + tree[ i ∗ 2 + 1 ].sum 就可以建一颗线段树了！代码如下：

void build(int i,int l,int r){//递归建树
    tree[i].l=l;tree[i].r=r;
    if(l==r){//如果这个节点是叶子节点
        tree[i].sum=input[l];
        return ;
    }
    int mid=(l+r)>>1;
    build(i*2,l,mid);//分别构造左子树和右子树
    build(i*2+1,mid+1,r);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;//刚才我们发现的性质return ;
}

嗯，这就是线段树的构建

第二部 简单（无pushdown）的线段树

1、单点修改，区间查询

其实这一章开始才是真正的线段树，我们要用线段树干什么？答案是维护一个线段（或者区间），比如你想求出一个 1 ∼ 100区间中， 4 ∼ 67 这些元素的和，你会怎么做？朴素的做法是for(i=4;i<=67;i++) sum+=a[i]，这样固然好，但是算得太慢了。

我们想一种新的方法，先想一个比较好画图的数据，比如一个长度为 4的区间，分别是 1 、 2 、 3 、 4我们想求出第 1 ∼ 3 项的和。按照上一部说的，我们要建出一颗线段树，其中点权（也就是红色）表示和：

然后我们要求 1 ∼ 3的和，我们先从根节点开始查询，发现她的左儿子1-2这个区间和答案区间1~3有交集，那么我们跑到左儿子这个区间。

然后，我们发现这个区间 1 ∼ 2 被完全包括在答案区间 1 ∼ 3 这个区间里面，那就把她的值 3 返回。

我们回到了 1 ∼ 4 区间，发现她的右儿子 3 ∼ 4 区间和答案区间 1 ∼ 3 有交集，那么我们走到 3 ∼ 4 区间

到了 3 ∼ 4 区间，我们发现她并没有完全包含在答案区间 1 ∼ 3 里面，但发现她的左儿子 3 ∼ 3 区间和 1 ∼ 3 区间又交集，那么久走到 3 ∼ 3 区间

到了 3 ∼ 3 区间，发现其被答案区间完全包含，就返回她的值 3 一直到最开始

3∼3 区间的 3 + 1 ∼ 2 区间的 3 = 6 ，我们知道了 1 ∼ 3 区间和为 6。

有人可能会说你这样是不是疯了，我拿脚都能算出 1 + 2 + 3 = 6 ，为什么这么麻烦？！

因为这才几个数，如果一百万个数，这样时间会大大增快。

我们总结一下，线段树的查询方法：

1. 如果这个区间被完全包括在目标区间里面，直接返回这个区间的值

2. 如果这个区间的左儿子和目标区间有交集，那么搜索左儿子

3. 如果这个区间的右儿子和目标区间有交集，那么搜索右儿子

P3374 【模板】树状数组 1 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)https://www.luogu.com.cn/problem/P3374

写成代码，就会变成这样：

int search(int i,int l,int r){
    if(tree[i].l>=l && tree[i].r<=r)//如果这个区间被完全包括在目标区间
                                    里面，直接返回这个区间的值
        return tree[i].sum;
    if(tree[i].r<l || tree[i].l>r)  return 0;//如果这个区间和目标区间毫不相干，返回0
    int s=0;
    if(tree[i*2].r>=l)  s+=search(i*2,l,r);//如果这个区间的左儿子
                                    和目标区间又交集，那么搜索左儿子
    if(tree[i*2+1].l<=r)  s+=search(i*2+1,l,r);//如果这个区间的右儿子和
                                        目标区间又交集，那么搜索右儿子
    return s;
}

关于那几个 if 的条件一定要看清楚，最好背下来，以防考场上脑抽推错。

然后,我们怎么修改这个区间的单点，其实这个相对简单很多，你要把区间的第 dis 位加上 k 。

那么你从根节点开始，看这个 dis 是在左儿子还是在右儿子，在哪往哪跑，

然后返回的时候，还是按照tree[i].sum=tree[i*2].sum+tree[i*2+1].sum的原则，更新所有路过的点

如果不理解，我还是画个图吧，其中深蓝色是去的路径，浅蓝色是返回的路径，回来时候红色的+标记就是把这个点加上这个值。

把这个过程变成代码，就是这个样子：

void add(int i,int dis,int k){
    if(tree[i].l==tree[i].r){//如果是叶子节点，那么说明找到了
        tree[i].sum+=k;
        return ;
    }
    if(dis<=tree[i*2].r)  add(i*2,dis,k);//在哪往哪跑
    else  add(i*2+1,dis,k);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;//返回更新
    return ;
}

2、区间修改，单点查询

区间修改和单点查询，我们的思路就变为：如果把这个区间加上 k，相当于把这个区间涂上一个 k 的标记，然后单点查询的时候，就从上跑到下，把沿路的标记加起来就好。

这里面给区间贴标记的方式与上面的区间查找类似，原则还是那三条，只不过第一条：如果这个区间被完全包括在目标区间里面，直接返回这个区间的值变为了如果这个区间被完全包括在目标区间里面，加这个区间标记 k

P3368 【模板】树状数组 2 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)https://www.luogu.com.cn/problem/P3368

具体做法很像，这里贴上代码：

void modify(int p, int l, int r, int k) 
{
	if(tr[p].l >= l && tr[p].r <= r) {
		tr[p].num += k;
		return ;
	}
	int mid = tr[p].l + tr[p].r >> 1;
	if(l <= mid) modify(p << 1, l, r, k);
	if(r > mid) modify(p << 1 | 1, l, r, k);
}
/*
void add(int i,int l,int r,int k){
    if(tree[i].l>=l && tree[i].r<=r){//如果这个区间被完全包括在目标区间里面
                                    ，讲这个区间标记k
        tree[i].sum+=k;
        return ;
    }
    if(tree[i*2].r>=l)
        add(i*2,l,r,k);
    if(tree[i*2+1].l<=r)
        add(i*2+1,l,r,k);
}
*/

然后就是单点查询了，这个更好理解了，就是dis在哪往哪跑，把路径上所有的标价加上就好了：

void query(int p, int x)
{
	ans += tr[p].num;//一路加起来
	if(tr[p].l == tr[p].r) return;
	int mid = tr[p].l + tr[p].r >> 1;
	if(x <= mid) query(p << 1, x);
	else query(p << 1 | 1, x); 
}
/*
void search(int i,int dis){
    ans+=tree[i].sum;//一路加起来
    if(tree[i].l==tree[i].r)
        return ;
    if(dis<=tree[i*2].r)
        search(i*2,dis);
    if(dis>=tree[i*2+1].l)
        search(i*2+1,dis);
}
*/

区间修改，单点查询完整测试代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 7;

int n, m, s, t;
int ans;
int a[maxn];
struct segment_tree
{	
	struct node
	{
		int l, r;
		int num;
	}tr[maxn * 4];
	
	void build(int p, int l, int r)
	{
		tr[p] = {l, r, 0};
		if(l == r) {
			tr[p].num = a[l];
			return ;
		}
		int mid = l + r >> 1;
		build(p << 1, l, mid);
		build(p << 1 | 1, mid + 1, r);
	}		
	
	void modify(int p, int l, int r, int k) 
	{
		if(tr[p].l >= l && tr[p].r <= r) {
			tr[p].num += k;
			return ;
		}
		int mid = tr[p].l + tr[p].r >> 1;
		if(l <= mid) modify(p << 1, l, r, k);
		if(r > mid) modify(p << 1 | 1, l, r, k);
	}
	
	void query(int p, int x)
	{
		ans += tr[p].num;
		if(tr[p].l == tr[p].r) return;
		int mid = tr[p].l + tr[p].r >> 1;
		if(x <= mid) query(p << 1, x);
		else query(p << 1 | 1, x); 
	}
}ST;

int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; ++ i) {
	    scanf("%d", &a[i]);
	}
	ST.build(1, 1, n);
    for (int i = 1; i <= m; ++ i) {
        int c;
        scanf("%d", &c);
        if(c == 1) {
            int x, y, z;
            scanf("%d%d%d", &x, &y, &z);
            ST.modify(1, x, y, z);
        }
        else {
            ans = 0;
            int x;
            scanf("%d", &x);
            ST.query(1, x);
            printf("%d\n", ans);
        }
    }
	return 0;
}
/*
int main()
{
	n = 100;
	for (int i = 1; i <= n; ++ i) {
		a[i] = i;
	}
	ST.build(1, 1, n);
	m = 10;
	for (int i = 1; i <= m; ++ i) {
		int l = 1, r = 100;
		ST.modify(1, l, r, 10000);
		ans = 0;
		// query(p, x), p = 1, x 为想要查询的点的下标
		ST.query(1, 50); // 单点查询 下标为 50 的点的值，ans = 50 + 10000 * i
		cout << i << " " << ans << '\n';
		ans = 0;
		ST.query(1, 100); // 单点查询 ans = 100 + 10000 * i
		cout << i << " " << ans << '\n'; 
	}
	return 0;
}
*/

第三部 进阶线段树

区间修改、区间查询，你可能会认为，把上一章里面的这两个模块加在一起就好了，然后你就会发现你大错特错。

因为如果对于 1 ∼ 4 这个区间，你把 1 ∼ 3 区间 + 1，相当于把节点 1 ∼ 2 2和 3标记，但是如果你查询 2 ∼ 4时，你会发现你加的时候，把没有标记的 2 节点和没有标记的 3 ∼ 4 节点加上去，结果当然是错的。

那么我们应该怎么办？这时候 pushdown 的作用就显现出来了。

你会想到，我们只需要在查询的时候，如果我们要查的 2 节点在 1 ∼ 2 区间的里面，那我们就可以把 1 ∼ 2 区间标记的那个 + 1  给推下去这样就能顺利地加上了。
怎么记录这个标记呢？我们需要记录一个“懒标记” lazytage，来记录这个区间

设 当前结点对应区间[l, r]，待更新区间[a, b]

　当 a ≤ l ≤ r ≤ b，即 [l, r]∈[a,b]时，不再向下更新，仅更新当前结点，并在该结点加上懒标记，当必须得更新/查询该结点的左右子结点时，再利用懒标记的记录向下更新（pushdown)——懒标记也要向下传递，然后移除该结点的懒标记。

区间修改的时候，我们按照如下原则：

1. 如果当前区间被完全覆盖在目标区间里，讲这个区间的 sum+k*(tree[i].r-tree[i].l+1)
2. 如果没有完全覆盖，则先下传懒标记
3. 如果这个区间的左儿子和目标区间有交集，那么搜索左儿子
4. 如果这个区间的右儿子和目标区间有交集，那么搜索右儿子

然后查询的时候，将这个懒标记下传就好了，下面图解一下：

如图，区间 1 ∼ 4  分别是 1 、 2 、 3 、 4我们要把 1 ∼ 3 区间 + 1 。因为 1 ∼ 2 区间被完全覆盖，所以将其 + 2 ，并将紫色的 lazytage+1，3 区间同理

注意我们处理完这些以后，还是要按照tree[i].sum=tree[i*2].sum+tree[i*2+1].sum的原则返回，代码如下：

void add(int i,int l,int r,int k)
{
    if(tree[i].r<=r && tree[i].l>=l)//如果当前区间被完全覆盖在目标区间里
                            ，加这个区间的sum+k*(tree[i].r-tree[i].l+1)
    {
        tree[i].sum+=k*(tree[i].r-tree[i].l+1);
        tree[i].lz+=k;//记录lazytage
        return ;
    }
    push_down(i);//向下传递
    if(tree[i*2].r>=l)
        add(i*2,l,r,k);
    if(tree[i*2+1].l<=r)
        add(i*2+1,l,r,k);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
    return ;
}

其中的pushdown，就是把自己的lazytage归零，并给自己的儿子加上，并让自己的儿子加上k*(r-l+1)

void push_down(int i)
{
    if(tree[i].lz!=0)
    {
        tree[i*2].lz+=tree[i].lz;//左右儿子分别加上父亲的lz
        tree[i*2+1].lz+=tree[i].lz;
        int mid=(tree[i].l+tree[i].r)/2;
        tree[i*2].sum+=tree[i].lz*(mid-tree[i*2].l+1);//左右分别求和加起来
        tree[i*2+1].sum+=tree[i].lz*(tree[i*2+1].r-mid);
        tree[i].lz=0;//父亲lz归零
    }
    return ;
}

 查询的时候，和上一章的几乎一样，就是也要像修改一样加入pushdown，这里用图模拟一下。我们要查询 2 ∼ 4区间的和，这是查询前的情况，所有紫色的代表lazytage

然后，我们查到区间 1 ∼ 2 时，发现这个区间并没有被完全包括在目标区间里，于是我们就pushdown，lazytage下传，并让每个区间 sum 加上 ( r−l ) * lazytage。

然后查到 2 ∼ 2  区间，发现被完全包含，所以就返 3，再搜索到 3 ∼ 4区间，发现被完全包含，那么直接返回 8 ，最后 3 + 8 = 11  就是答案

这里是代码实现：

 int search(int i,int l,int r){
    if(tree[i].l>=l && tree[i].r<=r)
        return tree[i].sum;
    if(tree[i].r<l || tree[i].l>r)  return 0;
    push_down(i);
    int s=0;
    if(tree[i*2].r>=l)  s+=search(i*2,l,r);
    if(tree[i*2+1].l<=r)  s+=search(i*2+1,l,r);
    return s;
}

线段树2

线段树维护的信息类型

父范围上的某个信息，可以用O（1）的时间，从子范围的信息加工得到

满足的信息比如：累加和，最大值，最小值；不满足的信息比如：某范围上出现次数最多的数

线段树的经典功能，如下操作单次调用的时间复杂度为O（log n）

1. 范围查询，包括范围内累加和、最大值、最小值

2. 范围修改，包括范围内每个数都增加、重置

线段树的范围修改功能，想做到单次调用时间复杂度为O（log n）的要求：

一段范围上统一进行了某次修改，可以用O（1）的时间，就把这段范围维护的信息加工出来

满足的情况，比如：这段范围所有的数字都加 v ，累加和可以快速的加工出来

不满足的情况，比如：这段范围上每个数字都逆序，累加和不能快速的加工出来

建树和查询

1. 线段树开始下标可以为1，也可以为0，下标1开始是经典的设定

2. 线段树需要在初始化时，就指定范围的规模[ 1 ~ n ]，一旦确定不能更改

3. 任何一个大范围[l ~ r]，严格从中点mid，拆分成左范围[l ~ mid], 右范围[mid+1 ~ r]

4. 每个范围的信息，填写在独立的，连续数组sum中

5. 如果父范围把信息填写在sum[i]，那么左范围填在sum[i * 2]，右范围填写在sum[i * 2 + 1]

6. 范围[l ~ r]和 i 值是对应的，是由公式限制的，由递归参数维护，无需去记录对应的关系

如果线段树的范围是 1 ~ n，那么记录信息的数组必要开4 * n

# include <stdio.h>

int n = 100;
int sum[100*4]; //建立的线段树的长度必须是原始数组长度的四倍
int arr[100]; // 原始数组

//建树操作 
void build(int l, int r, int i)
{
	if (l == r)
		sum[i] = arr[l];
		
	int mid = (l + r) / 2;
	build(l, mid, i*2);
	build(mid+1, r, i*2+1);
	
	sum[i] = sum[i*2] + sum[i*2+1];
}

//懒信息的下发
// ln：表示左侧有几个数字
// rn：表示右侧有几个数字 
void down(int i, int ln, int rn)
{
	if (add[i] != 0)
	{
		add[i*2] = add[i*2] + add[i];
		add[i*2+1] = add[i*2+1] + add[i];
		sum[i*2] = sum[i*2] + add[i]*ln;
		sum[i*2+1] = sum[i*2+1] + add[i]*rn;
		
		add[i] = 0;
	}
} 

//查询操作
// jobl，jobr表示目标范围
// l，r 表示当前的范围 
int query(int jobl, int jobr, int l, int r, int i)
{
	if (jobl >= l && jobr <= r)
		//当前范围已经在目标范围内，不需要继续向下查询，直接返回ans 
		return sum[i];
	int mid = (l + r) / 2;
    down(i, mid-l+1, r-mid);
	int ans = 0;
	if (jobl <= mid)
		ans = ans + query(jobl, jobr, l, mid, i*2);
	if (jobr > mid)
		ans = ans + query(jobl, jobr, mid+1, r, i*2+1);
	
	return ans;
}

线段树范围修改操作

范围内每个数字都增加：void add(jobl，jobr，jobv，l，r，i)

前三个是任务参数，表示jobl ~ jobr范围上，每个数增加jobv，递归过程中，这三个参数永远固定

后三个是范围参数，表示当前来到线段树的l ~ r范围上，信息存储位置是 i

思路

开始时调用add(jobl，jobr，jobv，l，r，i)，范围增加的递归过程，懒更新！

懒更新：就是这个范围所有的数字都会加jobv，用add数组存储

思路

1. 如果发现任务范围（jobl，jobr）把当前范围（l，r）全覆盖了，不再向下传递任务，懒住！

add[i] = add[i] + jobv; sum[i] = sum[i] + jobv * (r - l + 1)

2. 如果任务范围不能把当前范围全包，把该范围上积攒的懒信息，只往下发一层，down过程

然后决定当前任务是否要去往，左范围，右范围，继续调用子递归

子递归完成后，利用左右范围的sum信息，把当前范围的sum[i]信息修改。up过程

3. 退出当前递归过程

//懒信息的下发
// ln：表示左侧有几个数字
// rn：表示右侧有几个数字 
void down(int i, int ln, int rn)
{
	if (add[i] != 0)
	{
		add[i*2] = add[i*2] + add[i];
		add[i*2+1] = add[i*2+1] + add[i];
		sum[i*2] = sum[i*2] + add[i]*ln;
		sum[i*2+1] = sum[i*2+1] + add[i]*rn;
		
		add[i] = 0;
	}
} 

void up(int i)
{
	sum[i] = sum[2*i] + sum[2*i+1];
}

//范围修改，jobl ~ jobr范围上每个数字增加jobv 
void add(int jobl, int jobr, int jobv, int l, int r, int i)
{
	if (jobl <= l && jobr >= r)
	{
		add[i] = add[i] + jobv; //懒更新
		
		sum[i] = sum[i] + (l-r+1)*jobv;
	} 
	else
	{
		int mid = (l + r) / 2;
		down(i, mid-l+1, r-mid);
		if (jobl <= mid)
			add(jobl, jobr, jobv, l, mid, 2*i);
		if (jobr > mid)
			add(jobl, jobr, jobv, mid+1, r, 2*i+1);
		
		up(i);
	}
}

线段树的经典题目

题目一

本题还是范围查询，求累加和，只是对范围修改进行的改变

因此我们要对懒信息的处理进行改变

我们定义三个数组

int sum[] ：用于存储累加和

int change[] ：用于存储懒信息，表示某一段要重置为多少

bool update[] ：用于记录某一段是否进行了重置

代码：

# include <stdio.h>
# include <string.h>

//线段树支持范围重置，范围查询
//维护累加和

int num[100];
int sum[100*4];//要大于等于原数组长度的4倍
int change[100*4];
bool update[100*4];

void lazy(int i, int v, int n)
{
	sum[i] = v * n;
	change[i] = v;
	update[i] = true;
}

void up(int i)
{
	sum[i] = sum[i*2] + sum[i*2+1];
}

void down(int i, int ln, int rn)
{
	if (update[i] == true)
	{
		lazy(i*2, change[i], ln);
		lazy(i*2+1, change[i], rn);
		update[i] =false;
	}
}

void build(int l, int r, int i)
{
	if (l == r)
		sum[i] = num[l];
	else 
	{
		int mid = (l + r) / 2;
		build(l, mid, i*2);
		build(mid+1, r, 2*i+1);
		sum[i] = sum[i*2] + sum[i*2+1];
	}
}

void update(int jobl, int jobr, int jobv, int l, int r, int i)
{
	if (l >= jobl && r <= jobr)
		lazy(i, jobv, r-l+1);
	else 
	{
		int mid = (l + r) / 2;
		down(i, mid-l+1, r-mid);
		if (jobl <= mid)
			update(jobl, jobr, jobv, l, mid, i*2);
		if (jobv > mid)
			update(jobl, jobr, jobv, mid+1, r, i*2+1);
	}
	up(i);
}

int query(int jobl, int jobr, int l, int r, int i)
{
	if (jobl <= l && jobr >= r)
		return sum[i];
	int mid = (l + r) / 2;
	down(i, mid-l+1, r-mid);
	int ans = 0;
	if (jobl <= mid)
	{
		ans = ans + query(jobl, jobr, l, mid, i*2);
	}
	if (jobr > mid)
		ans = ans + query(jobl, jobr, mid+1, r, i*2+1);
	return ans;
}

题目二

第二题的代码和第一题相似，所以直接贴出代码

# include <stdio.h>

int num[100];
int maxx[100*4];
int add[100*4];

void up(int i)
{
	maxx[i] = max(maxx[i*2], maxx[i*2+1]);
}

void lazy(int i, int v)
{
	maxx[i] = maxx[i] + v;
	add[i] = add[i] + v; 
}

void down(int i)
{
	if (add[i] != 0)
	{
		lazy(i*2, add[i]);
		lazy(i*2+1, add[i]);
		add[i] = 0;
	}
}

void build(int l, int r, int i)
{
	if (l == r)
		maxx[i] = num[l];
	else 
	{
		int mid = (l + r) / 2;
		build(l, mid, i*2);
		build(mid+1, r, 2*i+1);
		maxx[i] = max(maxx[i*2], maxx[i*2+1]);
	}
}

void update(int jobl, int jobr, int jobv, int l, int r, int i)
{
	if (l >= jobl && r <= jobr)
		lazy(i, jobv);
	else 
	{
		int mid = (l + r) / 2;
		down(i);
		if (jobl <= mid)
			update(jobl, jobr, jobv, l, mid, i*2);
		if (jobv > mid)
			update(jobl, jobr, jobv, mid+1, r, i*2+1);
	}
	up(i);
}

题目三

 

本题需要同时支持范围更新、范围增加的操作

因此要进行多种修改操作之间的优先级整理

以本题来说，如下事实很明显

1. 一段范围的更新操作会彻底取消之前的增加操作

2. 一段范围的增加操作不会取消之前的更新操作，而是在之前更新操作的基础上进行增加

这两点在懒更新时需要得到体现

线段数组（树状数组）

树状数组主要用于数组的单点修改&&区间求和

树状数组：用一组数组表示一颗树

树状数组相比于二叉树删除了一些节点，但是为什么要删除呢？这就和树状数组的一些性质（lowbit）有关了，不懂没关系，继续往下看.

树状数组讲解

前置知识—lowbit(x)运算

lowbit(x) = x&(-x)

问题引入

以下将上图变为线段数组

树状数组结构分析

假设最开始的元素为最后一层的元素：8,6,1,4,5,5,1,1,3,2,1,4,9,0,7,4

每一层表示下面这一层两个数的和。

因此可以得到该图

观察这个表，我们可以发现很多数据是根本不会被使用的

比如当我们计算前两个，前三个数的和的时候，我们是直接使用14， 14+1

当我们计算前四个，前五个数的和的时候，我们是直接使用14+5， 19+5

我们发现该数字不会被使用

因此我们可以将其直接删除

在这些数据中，像这个数字一样没用的数据还有很多

每一层的第偶数个数字都是没用的，因此我们就可以删去

变为以下情况：

然后我们再把所有的数据放入一个数组中

发现该数组的长度正好为原始数据的长度

该数组就是树状数组

数组中的每一个元素，都对应下面的每一个区间

而下面的每一个区间表示的是原数组的某个区间和

求和时，我们只需要找到对应的区间，将这些区间相加即可得到答案

修改某个数据时，我们也只需要向上找到包含它的区间进行修改

树状数组的原理

面时树状数组的结构图，t[x]保存以 x 为根的子树中，叶子节点值的和,

原数组为a[ ]

那么原数组前4项的和 t[4] = t[2] + t[3] + a[4] = t[1] + a[2] + t[3] + a[4] = a[1] + a[2] + a[3] + a[4]

看似没有什么特点，别着急往下看

len表示该层的区间长度

我们发现：

序号为 i 的正好是长度为 lowbit(i)，并且是 i 为结尾的序列

例如 a[6] 这个序列的长度为2，正好为 lowbit(6)，并且结尾的序号正好为 6

我们通过观察节点的二进制数，进一步发现，

树状数组中节点 x 的父节点为：x + lowbit(x),例如 t[2] 的父节点为 t[4] = t[2 + lowbit(2)]

单点修改，区间查询

所以我们在单点修改的同时，更新父节点就变得尤为简单，，例如我们对a[1]+k，那么祖先节点t[1],t[2],t[4],t[8]都需要+k更新(因为t[] 表示前缀和)，此时我们就可以用 lowbit 操作实现

代码

int add_dandian(int x,int k)
{
	for(int i=x;i<=n;i+=lowbit(i))
	t[i]+=k;
}

那么单点修改实现了，如何实现区间查询呢？

例如：我们需要计算前6数的和

那么 lowbit(6)等于 2 说明表示有 a[6] 表示一个长度为2，并且结尾序列为6的和

因此我们只要算6 - lowbit(6) + a[6] 就行了

然后以此往下计算

代码：

int com(int x)
{
	if (x == 0)
		return 0;
	return com(x - lowbit(x)) + a[x];
}

代码：

int mod = 1e9 + 7;
int n;

	//树状数组模板（分治法） :常用来求区间和或者区间个数   算法时间复杂度logn
	int tr1[100] = {0};
	//求x的最低位1的二进制
	int lowbit(int x) {  //x最后一个1截断的后半段二进制  如lowbit(10100)=100;
		return x & -x;   
	}
	//更新索引为x的值，更新+c;
	void add(int x, int c) {  
		while (x <= 6) {  //循环包含x的节点，自底向上
			tr1[x]=(tr1[x] + c) % mod;
			x += lowbit(x); //更新时向前
		}
	 }
	//计算1-x的区间和
	int sum(int x) {
		int res = 0;
		while (x)  //
		{
			res = (tr1[x] + res) % mod;
			x -= lowbit(x);//更新时向后
		}
		return res;
	}
	//闭合区间和
	int sum1(int x,int y){
		int res = 0;
		res = sum(y) - sum(x - 1);
		return res;
	}

树状数组2

定义

树状数组维护信息的类型：

树状数组一般用来维护可差分信息

比如：累加和，累乘积等

不可差分信息：最大值，最小值等

不可差分信息一般不用树状数组维护，会选择用线段树维护，因为线段树维护的方式更方便

大多数情况下，线段树可以替代树状数组，两者的时间复杂度不多，都为log（n）

线段树

优势：用法全面，维护信息多

劣势：代码多，使用空间大

树状数组

优势：代码少，使用空间少

劣势：维护信息的类型少

原始数组和树状数组的下标一定从1开始！

单点修改，区间查询模版

假设原数组为上图所示

下方以2^0长度为一组，2^1为一组，2^3,为一组，2^4为一组（组的长度可以改变）

那么我们建立一个树状数组

长度和原数组相同

并且

树状数组里的值维持以该值的下标为右边界，在原数组能寻找的最长的组的状态。

例如：我们要求原数组的累加和

则树状数组中下标所维持原数组中的元素

因此树状数组的值为：

那么我们要如何求出树状数组中下标所维持的范围？

当树状数组的某个下标为 x1

先转为 x1 的二进制数

把它二进进制数最右侧的1拿掉，再 + 1，变为x2

因此该树状数组的下标维持原数组中从 x2 ~ x1 下标的状态

例如：

树状数组中的 3 下标

它的二进制数为 00011;

把它二进进制数最右侧的1拿掉，再 + 1，变为00011；

因此该树状数组的下标维持原数组中从 00011 ~ 00011（3~3）下标的状态

查询操作

通过查询树状数组中下标维持的范围来求出答案

代码：

// 返回 1~i 范围累加和 
int sum(int r)
{
	int ans = 0;
	while (r > 0)
	{
		ans = ans + tree[i];
		r = r - lowbit(r);
	}
	return ans;
}


// 返回 l ~ r 范围累加和 
int range(int l, int r)
{
	return sum(r) - sum(l-1);
}

添加操作

add（i，+v）对原数组中的 i 下标加 + v

因为树状数组中的值表示的是某一段区间，所以我们要对所有含有 i 下标的区间都 + v

方法：

先将 i 转化为的二进制数

不断加上二进制数中最右侧的1

在此过程中产生的值就是对应树状数组的下标

然后对其 + v

例如：

1的二进制数为00001

第一次操作变为00010，所以将树状数组a[2]+v

第二次操作变为00100，所以将树状数组a[4]+v

第三次操作变为01000，所以将树状数组a[8]+v

第四次操作变为10000，所以将树状数组a[16]+v

代码：

void add(int i, int v)
{
	while (i <= n)
	{
		tree[i] = tree[i] + v;
		i = i + lowbit(i);
	}
}

范围增加，单点查询模版

这种方法往往被线段树替代，但是树状数组代码很少，更容易写

利用差分进行处理

树状数组不维护原数组的信息，维护原数组的差分信息

# include <stdio.h>

//树状数组不维护原数组的信息，维护原数组的差分信息
//注意下标一定从1开始，不从0开始 
int tree[100];

int n; //表示该数列的个数 
int m; //表示操作的总个数 

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

void add(int i, int v)
{
	while(i <= n)
	{
		tree[i] = tree[i] + v;
		i = i + lowbit(i);
	}
}

//返回1-i上的累加和
int sum(int x)
{
	int ans = 0;
	while (x > 0)
	{
		ans = ans + tree[x];
		x = x - lowbit(x);
	}
	return ans;
}

int main()
{
	scanf("%d %d", &n, &m);
	for (int i=1; i<=n; ++i)
	{
		int v; //读取原数组中的数字 
		scanf("%d", &v);
		add(i, v); //将原数组中的数字加入在树状数组中 
		add(i+1, -v);
	}
	for (int i=1; i<=m; ++i)
	{
		int op;
		scanf("%d", &op);
		if (op == 1)
		{
			scanf("%d %d %d", &l, &r, &v);
			add(l, v);
			add(r+1, -v); 
		}
		else
		{
			int index;
			scanf("%d", &index);
			int k = sum(index); //单点查询 
		}
	 } 
}

范围增加、范围查询模版

这种方法往往被线段树替代，但是树状数组代码很少，更容易写

利用差分进行处理

树状数组不维护原数组的信息，维护原数组的差分信息

因此表达式就是：

那么我们就可以建立两个树状数组

一个树状数组维护原始数组的差分数组 ：Di

一个树状数组维护原数组的差分加工信息：（i - 1） * Di

代码：

# include<stdio.h>

//下标从1开始 
//维护原始数组的差分信息：Di 
int info1[100];

//维护原始数组的差分加工信息：(i - 1)*Di 
int info2[100]; 

int n;//原数组的长度 
int m;//操作次数 

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

void add(int* tree, int i, int v)
{
	while (i <= n)
	{
		tree[i] = tree[i] + v;
		i = i + lowbit(i);
	}
}

//1 - i的累加和 
int sum(int* tree, int i)
{
	int ans = 0;
	while (i > 0)
	{
		ans = ans + tree[i];
		i = i - lowbit(i);
	}
}

//原始数组中[l...r]每个数值 + v 
void alladd(int l, int r, int v)
{
	add(info1, l, v);
	add(info1, r+1, -v);
	add(info2, l, (l - 1) * v);
	add(info2, r+1, -(r * v));
}

//原始数组中[l...r]范围上的累加和 
int range(int l, int r)
{
	return sum(info1, r)*r - sum(info1, l-1)*(l-1) - ( sum(info2, r) - sum(info2, l-1) );
}

int main()
{
	scanf("%d %d", &n, &m);
	for (int i=1; i<=n; ++i)
	{
		int cur;
		scanf("%d", &cur);
		add(i, i, cur);
	}
	int l, r, v;
	for (int i=1; i<=m; ++i)
	{
		int op;
		scanf("%d", &op);
		if (op == 1)
		{
			scanf("%d %d %d", &l, &r, &v);
			add(l, r, v);
		}
		else
		{
			scanf("%d %d", &l, &r);
			printf("%d", range(l, r));
		}
	}
}

二维数组上的单点增加，范围查询

一维数组上构建树状数组，只在一个维度上展开

本题是在两个维度上展开

树状数组一定从下标1开始 
int tree[100][100];

查询：

利用二位前缀和的方法

代码：

//从（1,1）到（x，y）这个部分的累加和 
int sum(int x, int y)
{
	int ans = 0;
	for (int i=x; i>0; i=i-lowbit(i))
		for (int j=y; j>0; j=j-lowbit(j))
			ans = ans + tree[i][j];
	
	return ans; 
}

//实际二维数组的位置是（x，y）
//树状数组上的位置是（x+1，y+1） 
int allsum(int a, int b, int c, int d)
{
	return sum(c+1, d+1) - sum(a, d+1) - sum(c+1, b) + sum(a, b);
}

添加：

//和一维类似 
void (int x, int y, int v)
{
	for (int i=x; i<=n; i=i+lowbit(i))
		for (int j=y; j<=m; j=j+lowbit(j))
			tree[i][j] = tree[i][j] + v;
}

二维数组上范围增加，范围查询

利用二维差分

查询：

因此我们只要求出sum(1, 1, n, m)就行了

我们要对上述的式子进行化简

假设一个数组为n = 8， m = 6

如图为差分数组

四个嵌套过于复杂

因此我们可以分析在差分数组中，一个格子会被调用了几次

假设我们要求sum(1, 1, 6, 8)，我们计算一下D[4][3]被调用了几次

因此我们可以发现只有在计算打钩的格子的累加和时，才用调用D[4][3]

因此我们可以得出最终的表达式

代码：

//维护信息: d[i][j]
int info1[100][100];

//维护信息: d[i][j] * i
int info2[100][100];

//维护信息: d[i][j] * j 
int info3[100][100];

//维护信息: dp[i][j] * i * j
int info4[100][100];

int n, m;

//从（1，1）左上角，以（x，y）为右下角计算sum 
int sum(int x, int y)
{
	int ans = 0;
	for (int i=x; i>0: i=i-lowbit(i))
		for(int j=y; j<=n; j=j-lowbit(y))
			ans = ans + (n+1)*(m+1)*info1[i][j] - (y+1)*info2[i][j] - (x+1)*info3[i][j] + info4[i][j];
}

int range(int a, int b, int c, int d)
{
	return sum(c, d) - sum(a-1, d) - sum(c, b-1) + sum(a-1, b-1);
}

添加：

//维护信息: d[i][j]
int info1[100][100];

//维护信息: d[i][j] * i
int info2[100][100];

//维护信息: d[i][j] * j 
int info3[100][100];

//维护信息: dp[i][j] * i * j
int info4[100][100];


int n, m;

void add(int x, int y, int v)
{
	int v1 = v;
	int v2 = x*v;
	int v3 = y*v;
	int v4 = x*y*v;
	for (int i=x; i<=n; i=i+lowbit(x))
		for(int j=y; j<=n; j=j+lowbit(y))
		{
			info1[i][j] = info1[i][j] + v1;
			info2[i][j] = info2[i][j] + v2;
			info3[i][j] = info3[i][j] + v3;
			info4[i][j] = info4[i][j] + v4;
			
		}
}

void alladd(int a, int b, int c, int d, int v)
{
	add(a, b, v);
	add(a, d+1, -v);
	add(c+1, b, -v);
	add(c+1, d+1, v);
}