基本概念
线段树(segment tree),擅长处理区间，一般是用一棵完美二叉树实现。树中每一个节点都维护这一个区间，其中根节点维护的是整个区间。
基础包括：
- 单点修改
- 区间修改
- lazy标记
- 区间查询
代码实现
声明区域
static long segment_tree[]=new long[4*N-1]; //完美二叉树实现线段树
static long lazy[]=new long[4*N-1];
static int N; //元素的个数
如果不知道为什么数组的长度要设置为4*N-1,请到文章的底部。
单点修改
单点修改，比如修改点i，让点i加上5。那么从根节点开始遍历，直到找到i，让value[i]+=5，然后回溯之前的点，让之前的点也跟着+5。
怎样遍历呢，只需要判断该节点的两个子儿子包含点i，深搜就行了。
代码奉上：
//added为被加值 index为要更新的点 L表示为当前区间的左端点 R表示为当前区间的右端点 node为当前节点的下标
static void update(int added,int index,int L ,int R,int node)//单点更新
{
if(L==R) //L==R说明该节点是叶子节点，到底了。也就是查到点i了
{
segment_tree[node]=segment_tree[node]+added;
return;
}
int mid=(L+R)>>1;
if(index<=mid)
update(added,index,L,mid,node<<1); //node<<1 就是node*2 用位运算速度更快
else
update(added,index,mid+1,R,node<<1|1); //node<<1|1 就是node*2+1 |是或运算
segment_tree[node]=segment_tree[node<<1]+segment_tree[node<<1|1]; //深搜完，将父节点的值也更新了
}
区间修改
区间修改是最常见的线段树的操作，比如让[1,10]这个区间的点都加5。单点修改的话，修改一个值就要回溯在修改父节点的所有值。这样反反复复需要将父节点都修改十次，其实大可不必。
区间修改的规则：
- 如果修改的区间全部覆盖当前区间，则直接修改当前的节点。也就是
(R-L+1)*added，然后打上lazy标记。这里引出一个新的概念lazy标记，先记着这个规则，后面会解释。 - 如果修改的区间不是全部覆盖当前区间，则我们将lazy标记下传。然后就遍历他的两个儿子。
//added 为被加值 l和r为被加的区间端点 L表示为当前区间的左端点 R表示为当前区间的右端点 node为当前节点的下标
static void update_range(int added,int l,int r,int L,int R,int node )
{
if(l<=L&&r>=R) //如果要更新的区间全部覆盖了当前区间
{
lazy[node]+=added; //添加lazy标记，先不下传lazy标记
segment_tree[node]+=(R-L+1)*added;
return;
}
push_down(node,L,R); //下传lazy标记
int mid=(L+R)>>1;
if(mid>=l) update_range(added, l, r, L, mid, node<<1); //判断左孩子包括要修改的区间吗
if(mid<r) update_range(added, l, r, mid+1, R, node<<1|1); //mid<r的原因是mid是左孩子的右端，mid+1是右孩子的左端
segment_tree[node]=segment_tree[node<<1]+segment_tree[node<<1|1]; //更新父节点
}
lazy标记
关于lazy标记其实就是优化多次区间修改。上面说了区间修改其实是优化了单点修改，他优化要修改的区间的父节点修改的次数。lazy标记也是类似的逻辑，比如说你要让[0,3]都加上5，执行完之后又来了一个操作让[0,3]都加上5。其实可以两次操作合成一次对吧，lazy标记就是这个作用，先暂时记住你对这个区间的操作，然后下次你又要对这个区间操作的时候无论你是加是减，直接对lazy数组操作就行，下面的不用管。什么时候下传呢，如果要查询他的子节点的值的时候，下传lazy标记或者要对他的子节点操作，也下传lazy标记。就比如当要查询[0,1]这个区间的时候，你就的下传。又或者要对[0,1]区间加上一个值，也要下传。
到这里，如果你还是没明白lazy标记的意义，那么就看一下视频吧。视频讲的很好，其实我也是看了视频才明白的。其他博主写的也很抽象哈哈哈哈，其实我现在明白，但是我讲不明白，只可意会，我不会言传。https://www.bilibili.com/video/BV1yF411p7Bt?share_source=copy_web
当你明白了lazy标记的含义其实代码也很简单了，就不多说了，有注释。
static void push_down(int node,int L,int R) //下传lazy标记
{
if(lazy[node]!=0) //如果有标记则执行
{
int mid=(L+R)>>1;
lazy[node<<1]+=lazy[node]; //下传给左儿子
lazy[node<<1|1]+=lazy[node]; //下传给右儿子
segment_tree[node<<1]+=lazy[node]*(mid-L+1); //将左儿子的值更新
segment_tree[node<<1|1]+=lazy[node]*(R-mid); //将右儿子的值更新
lazy[node]=0; //清除该节点的lazy标记
}
}
区间查询
查询没什么好说的xdm，需要注意的是，如果要去遍历一个节点的孩子，那么一定要先下传lazy标记，就是不管他有没有，你都要用pushdown()函数，不论你是去修改还是查询。单点修改不用奥，因为单点修改他回溯的时候将父节点的值也顺带修改了，就是没涉及到lazy标记。
static long query(int l,int r,int L,int R,int node)
{
if(l<=L&&r>=R)
return segment_tree[node]; //当所查找的区间覆盖当前区间时
push_down(node,L,R);
int mid=(L+R)>>1;
long sum=0;
if(mid>=l) sum+=query(l,r,L,mid,node<<1);
if(mid<r) sum+=query(l,r,mid+1,R,node<<1|1);
return sum;
}
区间乘法
类似于区间加法，但是这个只是一个题中只有乘法的情况。
static void update_range(int multiplied,int l,int r,int L,int R,int node )
{
if(l<=L&&r>=R) //如果要更新的区间全部覆盖了当前区间
{
lazy[node]*=multiplied; //添加lazy标记，先不下传lazy标记
segment_tree[node]*=multiplied;
return;
}
push_down(node,L,R); //下传lazy标记
int mid=(L+R)>>1;
if(mid>=l) update_range(multiplied, l, r, L, mid, node<<1); //判断左孩子包括要修改的区间吗
if(mid<r) update_range(multiplied, l, r, mid+1, R, node<<1|1); //mid<r的原因是mid是左孩子的右端，mid+1是右孩子的左端
segment_tree[node]=segment_tree[node<<1]+segment_tree[node<<1|1]; //更新父节点
}
区间加法+区间乘法混合
乘法和加法是都放在一个lazy数组是不好实现的。我们另用一个数组来存放乘法。
更改的核心是：当遇到乘法时，mul数组和lazy数组的值都会发生改变。lazy[node]*=mul[node]；当下传lazy标记和mul标记的时候，更新儿子的值时要保证先乘后加
public class test
{
static long segment_tree[]=new long[4*N];
static long lazy[]=new long[4*n];
static long mul[]=new long[4*n];
}
static void push_down(int node,int L,int R) //下传lazy标记和mul标记
{
if(lazy[node]!=0||mul[node]!=1) //如果有标记则执行
{
int mid=(L+R)>>1;
segment_tree[node<<1]=(segment_tree[node<<1]*mul[node]%mod+lazy[node]*(mid-L+1))%mod;
segment_tree[node<<1|1]=(segment_tree[node<<1|1]*mul[node]%mod+lazy[node]*(R-mid))%mod;
mul[node<<1]=mul[node]*mul[node<<1]%mod; //mul标记直接相乘传递
mul[node<<1|1]=mul[node]*mul[node<<1|1]%mod;
lazy[node<<1]=lazy[node<<1]+lazy[node]; //传递lazy标记直接加过去就行
lazy[node<<1|1]=lazy[node<<1|1]+lazy[node];
lazy[node]=0; //清除当前区间的lazy标记
mul[node]=1; //清除当前区间的mul标记
}
}
//num 为被加值或者乘数 l和r为被加的区间端点 L表示为当前区间的左端点 R表示为当前区间的右端点 node为当前节点的下标 flag为true代表为乘法操作 flag为false代表这是加法操作
static void update_range(int l,int r,int L,int R,int node,int num,boolean flag)
{
if(l<=L&&r>=R) //如果要更新的区间全部覆盖了当前区间
{
if(flag) //如果是乘法
{
lazy[node]*=num; //添加lazy标记，先不下传lazy标记
mul[node]*=num; //添加mul标记，先不下传mul标记
segment_tree[node]*=num;
}
else
{
lazy[node]+=num; //添加lazy标记，先不下传lazy标记
segment_tree[node]+=(R-L+1)*num;
}
return;
}
push_down(node,L,R);
int mid=(L+R)>>1;
if(mid>=l) update_range(l, r, L, mid, node<<1,num,flag);
if(mid<r) update_range( l, r, mid+1, R, node<<1|1,num,flag);
//mid<r的原因是mid是左孩子的右端，mid+1是右孩子的左端
segment_tree[node]=segment_tree[node<<1]+segment_tree[node<<1|1]; //两个孩子更新了，当前节点别忘了更新
}
static long query(int l,int r,int L,int R,int node)
{
if(l<=L&&r>=R)
return segment_tree[node]; //当所查找的区间覆盖当前区间时，直接返回值就行
push_down(node,L,R);
int mid=(L+R)>>1;
long sum=0;
if(mid>=l) sum=sum+query(l,r,L,mid,node<<1);
if(mid<r) sum=sum+query(l,r,mid+1,R,node<<1|1);
return sum;
}
}
关于为什么分配4*N个数组空间
实战题目
蓝桥杯算法提高：Sequence
题目：
对于一个包含n个元素的序列A[0],A[1],A[2],A[3]……A[n - 1]可以进行一下三种操作
A l r d:使A[l],A[l+1],A[l+2]……A[r]均+d(保证a≤b)
M l r d:使A[l],A[l+1],A[l+2]……A[r]均×d(保证a≤b)
Q l r:查询A[l]+A[l+1]+A[l+2]+……+A[r]的和
序列中每一个数的初始值为0
输入格式
第一行输入两个整数n,m表示序列的长度为n,有m次操作。
之后输入m行，每行一个操作。
输出格式
对于每次查询输出一行一个整数表示查询的结果，由于结果可能过大，输出其对10007取模的结果即可。
样例输入
5 6
A 2 4 2
M 0 4 5
Q 1 3
M 1 2 3
Q 0 3
Q 1 4
样例输出
10
40
50
数据规模和约定
n ≤ 100000.
m ≤ 20000.
d ≤ 1000
AC代码
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main
{
static int mod=10007;
static long segment_tree[];
static long lazy[];
static long mul[];
private static int N;
public static void main(String[] args) {
Scanner in =new Scanner(System.in);
N = in.nextInt();int M=in.nextInt();
segment_tree=new long[4*N-1];
lazy=new long[4*N-1];
mul=new long[4*N-1];
ArrayList<Long> tt=new ArrayList<Long>();
Arrays.fill(segment_tree, 0);
Arrays.fill(mul, 1);
String t;
for(int i=0;i<M;i++)
{
t=in.next();
if(t.equals("A"))
update_range(in.nextInt(),in.nextInt(),0,N-1,1,in.nextInt(),false);
else if(t.equals("M"))
update_range(in.nextInt(),in.nextInt(),0,N-1,1,in.nextInt(),true);
else
tt.add(query(in.nextInt(), in.nextInt(),0,N-1, 1));
}
for(int i=0;i<tt.size();i++)
System.out.println(tt.get(i));
}
static void push_down(int node,int L,int R) //下传lazy标记
{
if(lazy[node]!=0||mul[node]!=1) //如果有标记则执行
{
int mid=(L+R)>>1;
segment_tree[node<<1]=(segment_tree[node<<1]*mul[node]%mod+lazy[node]*(mid-L+1))%mod;
segment_tree[node<<1|1]=(segment_tree[node<<1|1]*mul[node]%mod+lazy[node]*(R-mid))%mod;
mul[node<<1]=mul[node]*mul[node<<1]%mod;
mul[node<<1|1]=mul[node]*mul[node<<1|1]%mod;
lazy[node<<1]=(lazy[node<<1]*mul[node]%mod+lazy[node])%mod;
lazy[node<<1|1]=(lazy[node<<1|1]*mul[node]%mod+lazy[node]%mod);
lazy[node]=0;
mul[node]=1;
}
}
//added 为被加值 l和r为被加的区间端点 L表示为当前区间的左端点 R表示为当前区间的右端点 node为当前节点的下标
static void update_range(int l,int r,int L,int R,int node,int num,boolean flag)
{
if(l<=L&&r>=R) //如果要更新的区间全部覆盖了当前区间
{
if(flag) //如果是乘法
{
lazy[node]=lazy[node]*num%mod;
mul[node]=mul[node]*num%mod;
segment_tree[node]=segment_tree[node]*num%mod;
}
else
{
lazy[node]=(lazy[node]+num)%mod; //添加lazy标记，先不下传lazy标记
segment_tree[node]=(segment_tree[node]+(R-L+1)*num%mod)%mod;
}
return;
}
push_down(node,L,R);
int mid=(L+R)>>1;
if(mid>=l) update_range(l, r, L, mid, node<<1,num,flag);
if(mid<r) update_range( l, r, mid+1, R, node<<1|1,num,flag); //mid<r的原因是mid是左孩子的右端，mid+1是右孩子的左端
segment_tree[node]=(segment_tree[node<<1]+segment_tree[node<<1|1])%mod;
}
static long query(int l,int r,int L,int R,int node)
{
if(l<=L&&r>=R)
return segment_tree[node]; //当所查找的区间覆盖当前区间时
push_down(node,L,R);
int mid=(L+R)/2;
long sum=0;
if(mid>=l) sum=(sum+query(l,r,L,mid,node<<1))%mod;
if(mid<r) sum=(sum+query(l,r,mid+1,R,node<<1|1))%mod;
return sum;
}
}
如果觉得写的还行的话，点个赞评论支持一下呗！