线段树初步&&lazy标记
线段树
一.概述：
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。
对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。
使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。而未优化的空间复杂度为2N，因此有时需要离散化让空间压缩。
二.基本操作：
1.建树：主要思想，二分。关系如下：
设一个节点坐标为i，则其父亲节点为i/2，兄弟节点则为i/2*2或i/2*2+1;
由此建树：
struct aaa{
int value; // 结点对应区间的权值
int left,right; // 区间 [left,right]
}node[2005];
int father[2005]; // 每个点(当区间长度为0时，对应一个点)对应的结构体数组下标
void BuildTree(int i,int left,int right) // 为区间[left,right]建立一个以i为祖先的线段树，i为数组下标，我称作结点序号
node[i].left = left; // 写入第i个结点中的 左区间
node[i].right = right; // 写入第i个结点中的 右区间
node[i].value = 0; // 每个区间初始化为 0
if (left == right){ // 当区间长度为 0 时，结束递归
father[left] = i; // 能知道某个点对应的序号，为了更新的时候从下往上一直到顶
return;
}
// 该结点往 左孩子的方向 继续建立线段树，线段的划分是二分思想，类二分查找
// 这里将 区间[left,right] 一分为二了
BuildTree(i<<1, left, (int)floor( (right+left) / 2.0));
// 该结点往 右孩子的方向 继续建立线段树
BuildTree((i<<1) + 1, (int)floor( (right+left) / 2.0) + 1, right);
}
链接： floor函数：向下取整；如floor(9.999)=9;floor(-3.1)=-4;
a<<1=a*2;a<<=1则是将值赋予a；
2.单点更新：
一遍递归，到根停止。
void UpdataTree(int ri){ // 从下往上更新（注：这个点本身已经在函数外更新过了）
if (ri == 1)return; // 向上已经找到了祖先（整个线段树的祖先结点 对应的下标为1）
int fi = ri / 2; // ri 的父结点
int a = node[fi<<1].value; // 该父结点的两个孩子结点（左）
int b = node[(fi<<1)+1].value; // 右
node[fi].value = (a > b)?(a):(b); // 更新这个父结点（从两个孩子结点中挑个大的）
UpdataTree(ri/2); // 递归更新，由父结点往上找
}
链接：(a > b)?(a):(b)即if(a>b) return a;else return b;
另：
3.查询区间和（by fancy+sui）
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int N=100;
//这个是查询区间和的模板，最大值什么的自己脑补~（如果模板有什么问题的话去找***这个 是她写的2333333（雾）
// --你们认真负责的好学长~
struct node
{
int lc,rc,l,r,sum;
}t[2*N];
int root,tot;//tot为计数的节点，记录当前用到几号节点了，每次开新节点就++tot
int a[N];
void build(int x,int l,int r)
{
t[x].l=l; t[x].r=r;
if(l==r)
{
t[x].sum=a[l];
return;
}
int mid=(l+r)/2;
t[x].lc=++tot; build(t[x].lc,l,mid);
t[x].rc=++tot; build(t[x].rc,mid+1,r);
t[x].sum=t[t[x].lc].sum+t[t[x].rc].sum;
}
int query(int x,int l,int r)
{
if(l<=t[x].l&&t[x].r<=r) return t[x].sum;//若当前区间全有贡献，直接返回
int mid=(t[x].l+t[x].r)/2;
int ans=0;
if(l<=mid) ans+=query(t[x].lc,l,r);
if(mid<r) ans+=query(t[x].rc,l,r);
return ans;
}
void change(int x,int v,int d)
{
if(t[x].l==t[x].r)
{
t[x].sum=d;
return;
}
int mid=(t[x].l+t[x].r)/2;
if(v<=mid) change(t[x].lc,v,d);
if(mid<v) change(t[x].rc,v,d);
t[x].sum=t[t[x].lc].sum+t[t[x].rc].sum;//由两个儿子节点更新自己
}
int main()
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
root=++tot;
build(root,1,n);
for(int i=1,k,x,y;i<=m;i++)
{
scanf("%d%d%d",&k,&x,&y);
if(k==1) printf("%d\n",query(root,x,y));
if(k==2) change(root,x,y);
}
}
4.区间更新
区间更新是指更新某个区间内的叶子节点的值，因为涉及到的叶子节点不止一个，而叶子节点会影响其相应的非叶父节点，那么回溯需要更新的非叶子节点也会有很多，如果一次性更新完，操作的时间复杂度肯定不是O(lgn)，例如当我们要更新区间[0,3]内的叶子节点时，需要更新出了叶子节点3,9外的所有其他节点。为此引入了线段树中的延迟标记概念，这也是线段树的精华所在。
延迟标记：每个节点新增加一个标记，记录这个节点是否进行了某种修改(这种修改操作会影响其子节点)，对于任意区间的修改，我们先按照区间查询的方式将其划分成线段树中的节点，然后修改这些节点的信息，并给这些节点标记上代表这种修改操作的标记。在修改和查询的时候，如果我们到了一个节点p，并且决定考虑其子节点，那么我们就要看节点p是否被标记，如果有，就要按照标记修改其子节点的信息，并且给子节点都标上相同的标记，同时消掉节点p的标记。
举例说明：当我们要对区间[0,2]的叶子节点增加2，利用区间查询的方法从根节点开始找到了非叶子节点[0-2]，把它的值设置为1+2 = 3，并且把它的延迟标记设置为2，更新完毕；当我们要查询区间[0,1]内的最小值时，查找到区间[0,2]时，发现它的标记不为0，并且还要向下搜索，因此要把标记向下传递，把节点[0-1]的值设置为2+2 = 4，标记设置为2，节点[2-2]的值设置为1+2 = 3，标记设置为2（其实叶子节点的标志是不起作用的，这里是为了操作的一致性），然后返回查询结果：[0-1]节点的值4；当我们再次更新区间[0,1]（增加3）时，查询到节点[0-1],发现它的标记值为2，因此把它的标记值设置为2+3 = 5，节点的值设置为4+3 = 7；
其实当区间更新的区间左右值相等时（[i,i]），就相当于单节点更新，单节点更新只是区间更新的特例。
因此需要在线段树结构中加入延迟标记域，本文例子中我们加入标记与addMark，表示节点的子孙节点在原来的值的基础上加上addMark的值，同时还需要修改创建函数build 和 查询函数 query，修改的代码用红色字体表示，其中区间更新的函数为update，代码如下：（不建议看但还是粘在这里）
const int INFINITE = INT_MAX;
const int MAXNUM = 1000;
struct SegTreeNode
{
int val;
int addMark;//延迟标记
}segTree[MAXNUM];//定义线段树
void build(int root, int arr[], int istart, int iend)
{
segTree[root].addMark = 0;//----设置标延迟记域
if(istart == iend)//叶子节点
segTree[root].val = arr[istart];
else
{
int mid = (istart + iend) / 2;
build(root*2+1, arr, istart, mid);//递归构造左子树
build(root*2+2, arr, mid+1, iend);//递归构造右子树
//根据左右子树根节点的值，更新当前根节点的值
segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);
}
}
void pushDown(int root)
{
if(segTree[root].addMark != 0)
{
//设置左右孩子节点的标志域，因为孩子节点可能被多次延迟标记又没有向下传递
//所以是 “+=”
segTree[root*2+1].addMark += segTree[root].addMark;
segTree[root*2+2].addMark += segTree[root].addMark;
//根据标志域设置孩子节点的值。因为我们是求区间最小值，因此当区间内每个元
//素加上一个值时，区间的最小值也加上这个值
segTree[root*2+1].val += segTree[root].addMark;
segTree[root*2+2].val += segTree[root].addMark;
//传递后，当前节点标记域清空
segTree[root].addMark = 0;
}
}
int query(int root, int nstart, int nend, int qstart, int qend)
{
//查询区间和当前节点区间没有交集
if(qstart > nend || qend <<span style="font-family: 'Courier New' !important;"> nstart)
return INFINITE;
//当前节点区间包含在查询区间内
if(qstart <= nstart && qend >= nend)
return segTree[root].val;
//分别从左右子树查询，返回两者查询结果的较小值
pushDown(root); //----延迟标志域向下传递
int mid = (nstart + nend) / 2;
return min(query(root*2+1, nstart, mid, qstart, qend),
query(root*2+2, mid + 1, nend, qstart, qend));
}
void update(int root, int nstart, int nend, int ustart, int uend, int addVal)
{
//更新区间和当前节点区间没有交集
if(ustart > nend || uend <<span style="font-family: 'Courier New' !important;"> nstart)
return ;
//当前节点区间包含在更新区间内
if(ustart <= nstart && uend >= nend)
{
segTree[root].addMark += addVal;
segTree[root].val += addVal;
return ;
}
pushDown(root); //延迟标记向下传递
//更新左右孩子节点
int mid = (nstart + nend) / 2;
update(root*2+1, nstart, mid, ustart, uend, addVal);
update(root*2+2, mid+1, nend, ustart, uend, addVal);
//根据左右子树的值回溯更新当前节点的值
segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);
}
