线段树算法

什么是线段树？

以下内容来自百度

线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。

线段树能解决什么问题？

线段树可以在 O(logn) 的时间复杂度中解决暴力需要 O(n) 复杂度的，区间查询，区间修改，以及单点查询，单点修改。

一些定义：

1.区间查询：查询某个区间内的信息。例如，查询某个区间内的最大值、最小值、总和等等。

2.区间修改：对某个区间内的数值进行更新。例如，将某个区间内的数值都加上一个固定的值，或者将某个区间内的数值修改为一个新值。

3.单点修改：对于数组中某一个下标对应的值进行修改。例如，某个下标对应的值增加，赋值等等。

4.单点查询：对于数组中某一个下标对应的值进行查询。

线段树的建立

把 1-n 二分储存，比如：1-10 可以变成 1-5 和 6-10，而 1-5 又可以分成 1-2 和 3-5，6-10 可以分成 6-7 和 8-10……

因为层数只有 logn 层，所以时间复杂度从，n 变成了 logn

代码

void build(int p, int l, int r) {
    tree[p].l = l, tree[p].r = r; // 节点p代表区间[l,r]
    if (l == r) { //在最下面一层
        tree[p].data = a[l]; 
        return; 
    } 
    int mid = (l + r) / 2; // 二分
    build(p*2, l, mid); // 左子节点[l,mid]，编号p*2
    build(p*2+1, mid+1, r); // 右子节点[mid+1,r]，编号p*2+1
    tree[p].data = tree[p*2].data+tree[p*2+1].data; // 从下往上传递信息pushup
}

单点查询区间修改线段树

修改

节点在那边找那边。

end：寻找的下标。

k：更改的值。

void change(int p, int end, int k) {
    if (tree[p].l == tree[p].r) { tree[p].data = k; return; } // 找到节点,修改
    int mid = (tree[p].l + tree[p].r) / 2;
    if (x <= mid) change(p*2, end, k); // x属于左半区间
    else change(p*2+1, end, k); // x属于右半区间
    tree[p].data = tree[p*2].data + tree[p*2+1].data;// 从下往上更新信息
}

查询

分区查找

l,r：查找的区间。

int search(int l,int r,int p){
	if(l<=tree[p].l&&r>=tree[p].r) return tree[p].data;//找到了，返回
	if(l>tree[p].r||r<tree[p].l) return 0;//这里没有
	int s=0;
	if(tree[p*2].r>=l) s+=search(l,r,p*2);//保存查询到的答案
	if(tree[p*2+1].l<=r) s+=search(l,r,p*2+1);
	return s;//返回答案
}

完整代码

把 data 改成了 sum（求和）

不开 long long 见祖宗！

#include<bits/stdc++.h>
#define ll long long 不开 long long 见祖宗！
using namespace std;
struct node{
	ll l,r,sum;
};
node tree[400005];//记得开四倍空间~
ll a[100005],n,q;
void build(ll l,ll r,ll p){//建树
	tree[p].l=l,tree[p].r=r;
	if(l==r){
		tree[p].sum=a[p];
		return;
	}
	ll mid=(l+r)/2;
	build(l,mid,p*2);
	build(mid+1,r,p*2+1);
	tree[p].sum=tree[p*2].sum+tree[p*2+1].sum; 
}
void add(int en,int p,int k){//增加（修改）
    if(tree[p].l==tree[p].r){
        tree[p].sum+=k;
        return;
    }
    if(en<=tree[p*2].r)  add(p*2,en,k);
    else  add(p*2+1,en,k);
    tree[p].sum=tree[p*2].sum+tree[p*2+1].sum;
    return;
}
int search(ll l,ll r,ll p){//查询
	if(l<=tree[p].l&&r>=tree[p].r) return tree[p].sum;
	if(l>tree[p].r||r<tree[p].l) return 0;
	int s=0;
	if(tree[p*2].r>=l) s+=search(l,r,p*2);
	if(tree[p*2+1].l<=r) s+=search(l,r,p*2+1);
	return s;
}
int main(){
	cin>>n>>q;
	for(ll i=1;i<=n;i++) cin>>a[i];
	build(1,n,1);
	while(q--){
		int op,x,y,k;
		cin>>x>>y;
		if(op==1){
			cin>>k;
			change(x,y,1,k);
		}else{
			cout<<search(x,y,1)<<endl;
		}
	}
	return 0;
}

区间查询单点修改线段树

修改

和单点修改唯一的不同就是要把所有拥有满足条件的区间节点增加。

void add(ll l,ll r,ll p,ll k){
	if(l<=tree[p].l&&r>=tree[p].r){//给当前满足条件的区间增加
		tree[p].sum+=k;
		return;
	}
	int mid=(tree[p].l+tree[p].r)/2; 
	if(l<=mid) add(l,r,p*2,k);//左子树
	if(r>mid) add(l,r,p*2+1,k);//右子树
}

查询

和单点修改一样，只不过把修改变成了查询返回。

void search(ll l,ll p){
	ans+=tree[p].sum;//返回找到的答案
	if(tree[p].l==tree[p].r) return;//找错了
	int mid=(tree[p].l+tree[p].r)/2;
	if(l<=mid) search(l,p*2);//往左边找
	else search(l,p*2+1);//往右边找
}

区间查询区间修改线段树

看到这里，你有可能会疑惑：这不很简单吗？把前面的两部分拼在一起不就行了吗？其实不然。

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

这个时候，我们就需要懒标记了

我们只需要在查询的时候，如果我们要查的 2 节点在 1 ∼ 2 区间的里面，那我们就可以把 1 ∼ 2 区间标记的那个 + 1 给推给他的子节点就能顺利地加上了

区间修改时，我们有四种情况：

1.如果当前区间被完全覆盖在目标区间里，加上这个区间的sum+k*(tree[i].r-tree[i].l+1)

2.如果没有完全覆盖，则先下传懒标记，再进行操作。

3.如果这个区间的左儿子和目标区间有交集（tree[l]>=目标区间 l ），那么搜索左儿子。

4.如果这个区间的右儿子和目标区间有交集（tree[r]<=目标区间 r ），那么搜索右儿子。

当我们做完操作后，还是要和原来一样 pushup。

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

pushdown 就是持续把当前懒标记赋值给儿子节点

void pushdown(int p){
    if(tree[p].lazy!=0){
        tree[p*2].lazy+=tree[p].lazy;//左右儿子分别加上父亲的lazy
        tree[p*2+1].lazy+=tree[p].lazy;
        int mpd=(tree[p].l+tree[p].r)/2;
        tree[p*2].sum+=tree[p].lazy*(mid-tree[p*2].l+1);//左右分别求和加起来
        tree[p*2+1].sum+=tree[p].lazy*(tree[p*2+1].r-mid);
        tree[p].lazy=0;//父亲lazy用完了,归零
    }
    return ;
}

查询

没什么区别，只是多了一个懒标记下传

inline 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;
}

代码

#include<bits/stdc++.h>
using namespace std;
int n,m,ans,a[500010];
struct node{
    int l,r;
    int num;
}tree[2000010];
void build(int l,int r,int p){
    tree[p].num=0;
    tree[p].l=l;
    tree[p].r=r;
       if(l==r)
        return ;
    int mid=(r+l)/2;
    build(l,mid,p*2);
    build(mid+1,r,p*2+1);
}
void add(int p,int l,int r,int k){
    if(tree[p].l>=l && tree[p].r<=r){
        tree[p].num+=k;
        return ;
    }
    if(tree[p*2].r>=l) add(p*2,l,r,k);
    if(tree[p*2+1].l<=r) add(p*2+1,l,r,k);
}
void search(int p,int k){
    ans+=tree[p].num;
    if(tree[p].l==tree[p].r) return ;
    if(k<=tree[p*2].r) search(p*2,k);
    if(k>=tree[p*2+1].l) search(p*2+1,k);
}
int main(){
    int n,m;
    cin>>n>>m;
    build(1,n,1);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1;i<=m;i++){
        int op;
        scanf("%d",&op);
        if(op==1){
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(1,x,y,z);
        }
        if(op==2){
            ans=0;
            int x;
            scanf("%d",&x);
            search(1,x);
            printf("%d\n",ans+a[x]);
        }
    }
}