线段树入门+资料整理

线段树入门+资料整理

优秀博客

https://blog.csdn.net/zearot/article/details/48299459

https://blog.csdn.net/jk_chen_acmer/article/details/79347003 C题题解，专题训练一

https://www.cnblogs.com/jason2003/p/9676729.html 讲解线段树从入门到进阶

线段树开辟的空间一般是需要储存的数据的4倍。

作用

线段树使用了二分的思想（我自己认为），把区域进行不断的二分。

她能把一些对于区间（或者线段）的修改、维护，从$$O(N)$$的时间复杂度变成$$O(logN)$$。

• 当题目中出现求取一个区间内的和、最大值最小值，并且还会出现区间内的一个点多个点进行修改时，这个题目可能很有几率使用线段树。
• 当出现区间内连续区间维护的时候，线段树也可能解决。

目前常见的模板中，大体有两种形式：

1. 使用简单数组，在函数参数表表示边界，这样比较节省空间，但是函数参数变得比较多
2. 使用结构体数组，左右边界存储在了结构体中，这样使得函数的参数比较少，但是占用的存储空间比较多，但是目前来看，这个好像比较常用。

代码实现

基于结构体的实现

基本的 区间和 和 最值问题

# define ls (rt<<1)
# define rs (rt<<1|1)
typedef long long ll;
const int  maxn=1e5+7;
struct node{
	int l, r; 	//记录这个点作用的范围
	int sum;	//记录作用范围内的区间和，也可以改为区间内的最大值或最小值等等
	int lazy;	//可以展示存储需要的更新
}t[maxn<<2];
ll num[maxn];	//记录原始的数据
int n, m;
inline void up(int rt){//更新操作
	t[rt].sum=t[ls].sum+t[rs].sum;//这句话一般是需要根据上面结构体中的类型来进行相应的改变
    //t[rt].maxx=max(t[ls].maxx, t[rt].maxx);
}
void build(int rt, int l, int r){	//建立线段树的函数
	t[rt].l=l;
	t[rt].r=r;
	if(l==r){
		t[rt].sum=num[l];	//这里也可以使用cin或scanf来进行直接的输入
		return ; 	//注意，这句话不能省略
	}
	int  mid=(l+r)>>1;
	build(ls, l, mid);
	build(rs, mid+1, r);
	up(rt);
}
void down(int rt){	//该函数和结构体中的lazy变量相对应
	if(t[rt].lazy!=0){
		t[ls].lazy+=t[rt].lazy;
		t[ls].sum+=t[rt].lazy;
		
		t[rs].lazy+=t[rt].lazy;
		t[rs].sum+=t[rt].lazy;
		
		t[rt].lazy=0;
	}
}
void nodeupdate(int rt, int id, int v){	//进行点更新
	if(t[rt].l == t[rt].r ){
		t[rt].lazy+=v;	//要记得lazy的使用
		t[rt].sum+=v;
		return ;		//注意，这句话也不能省略
	}
	down(rt);			//在进入更小的范围前，需要先调用down函数来把lzay传下去
	int mid=(t[rt].l+t[rt].r)>>1;
	if(x<=mid) update(ls, x, v);
	else  update(rs, x, v);
	up(rt);				//点更新后，需要再次进行更新
}
void up_date(int rt, int L, int R, int x){	//进行区间加
    if(L <= t[rt].l && t[rt].r <= R){
        tre[rt].lazy += x;
        tre[rt].sum += x * (t[rt].r-t[rt].l+1);
        return;
    }
    pushdown(rt);
    int mid = (l+r)>>1;
    if(l<=mid)	up_date(rt<<1, L, R, x);
    if(mid<R)	up)date(rt<<1|1, L, R, x);
    up(rt);
    return ;
}
int query(int rt, int l, int r){	//进行区间查询，这里是查询区间和
	if(l <= t[rt].l && t[rt].r <= r){
		return t[rt].sum;
	}
	down(rt);
	int ans=0;
	int mid=(t[rt].l+t[rt].r)>>1;
	if(l<=mid) ans+=query(ls, l, r);
	if(r>mid) ans+=query(rs, l, r);
	return ans;
}
int main(){
    int n, m;//n个数，m个操作
    cin>>n>>m;
    for(int i=1; i<=n; i++)
        cin>>num[i];
    build(1, 1, n);	//建立线段树
    //……下面就是对区间的具体操作了
}

除了，可以进行和 和 最值的求取外，还可以处理区间连续性问题。如下：

//HDU1540的实现代码，题意：求满足要求连续的区间长度
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
using namespace std;
const int maxn = 50000+10;
int n,m;
int s[maxn],top;//s为模拟栈
struct node
{
    int l,r;
    int ls,rs,ms;//ls,左端最大连续区间，rs右端最大连续区间，ms区间内最大连续区间
} a[maxn<<2];
 
void init(int l,int r,int i)
{
    a[i].l = l;
    a[i].r = r;
    a[i].ls = a[i].rs = a[i].ms = r-l+1;
    if(l==r) return ;
	int mid = (l+r)>>1;
	init(l,mid,i*2);
	init(mid+1,r,2*i+1);
}
 
void insert(int i,int t,int x)
{
    if(a[i].l == a[i].r)
    {
        if(x==1)
            a[i].ls = a[i].rs = a[i].ms = 1;//修复
        else
            a[i].ls = a[i].rs = a[i].ms = 0;//破坏
        return ;
    }
    int mid = (a[i].l+a[i].r)>>1;
    if(t<=mid)
        insert(2*i,t,x);
    else
        insert(2*i+1,t,x);
    a[i].ls = a[2*i].ls;//左区间
    a[i].rs = a[2*i+1].rs;//右区间
    a[i].ms = max(max(a[2*i].ms,a[2*i+1].ms),a[2*i].rs+a[2*i+1].ls);//父亲区间内的最大区间必定是，左子树最大区间，右子树最大区间，左右子树合并的中间区间，三者中最大的区间值
    if(a[2*i].ls == a[2*i].r-a[2*i].l+1)//左子树区间满了的话，父亲左区间要加上右孩子的左区间
        a[i].ls += a[2*i+1].ls;
    if(a[2*i+1].rs == a[2*i+1].r-a[2*i+1].l+1)//同理
        a[i].rs += a[2*i].rs;
}
 
int query(int i,int t)
{
    if(a[i].l == a[i].r || a[i].ms == 0 || a[i].ms == a[i].r-a[i].l+1)//到了叶子节点或者该访问区间为空或者已满都不必要往下走了
        return a[i].ms;
    int mid = (a[i].l+a[i].r)>>1;
    if(t<=mid)
    {
        if(t>=a[2*i].r-a[2*i].rs+1)//因为t<=mid，看左子树，a[2*i].r-a[2*i].rs+1代表左子树右边连续区间的左边界值，如果t在左子树的右区间内，则要看右子树的左区间有多长并返回
            return a[i<<1].rs+a[i<<1|1].ls;
        else
            return query(2*i,t);//如果不在左子树的右边界区间内，则只需要看左子树
    }
    else
    {
        if(t<=a[2*i+1].l+a[2*i+1].ls-1)//同理
            return a[i<<1].rs+a[i<<1|1].ls;
        else
            return query(2*i+1,t);
    }
}
 
int main()
{
    int i,j,x;
    char ch[2];
    while(~scanf("%d%d",&n,&m))
    {
        top = 0;
        init(1,n,1);
        while(m--)
        {
            scanf("%s",ch);
            if(ch[0] == 'D')
            {
                scanf("%d",&x);
                s[top++] = x;
                insert(1,x,0);
            }
            else if(ch[0] == 'Q')
            {
                scanf("%d",&x);
                printf("%d
",query(1,x));
            }
            else
            {
                if(x>0)
                {
                    x = s[--top];
                    insert(1,x,1);
                }
            }
        }
    }
    return 0;
}