线段树及其应用

1. 单点修改，区间查询

#include <iostream>

using namespace std;
const int maxn = 100000007;
const int int_max = 100000007;
int data[maxn];

//初始化线段树，线段树的节点共有2^n - 1个
void init(int n_)
{
    int n = 1;
    n =<< n_;
    for(int i = 0;i < n * 2 - 1)//节点共有2 * n - 1 个
    {
        data[i] = int_max;
    }
}

//单点修改
void updata(int k,int a)
{
    //叶子节点
    k += n - 1;
    data[k] = a;
    //向上更新
    while(k)
    {
        k = (k - 1) / 2;//从0开始编号
        data[k] = min(data[2 * k + 1],data[2 * k + 2]);
    }
}

//区间查询
//求[a,b)的最小值
//后面的参数是为了计算方便传入的
//k是节点的编号，从0开始，[l,r）表示节点对应的区间
//在外部调用时用query(a,b,0,0,n)
int query(int a,int b,int k,int l,int r)
{
    if(r <= a || b <= l)return int_max;
    else if(a <= l && r <= b)return data[k];
    else
    {
        int vl = query(a,b,k * 2 + 1,l,(l + r) / 2);
        int vr = query(a,b,k * 2 + 2,(l + r) / 2,r);
        return min(vl,vr);
    }
}

2. 区间修改，单点查询

hoj 1556

#include<iostream>
#include<cstdio>
#include<cstring>
#define inl inline
#define LL long long
const int MAXN=5e5+5;
LL a[MAXN],adds[4*MAXN];
LL n,ans;
inl void change(LL num,LL l,LL r,LL x,LL y,LL v)
{
	if(y<l||x>r) return;
	if(l>=x&&y>=r)
	{
		adds[num]+=v;				//增加懒惰标记
		return;
	}
	LL mid=(l+r)>>1;
	change(num<<1,l,mid,x,y,v);
    change(num<<1|1,mid+1,r,x,y,v);
}
//单点查询
inl LL work1(LL num,LL l,LL r,LL x)
{
	if(l==r&&l==x) return adds[num];	//叶子节点
	LL mid=(l+r)>>1,tmp;
	if(x<=mid) tmp=work1(num<<1,l,mid,x);//左子树懒惰标记
	else tmp=work1(num<<1|1,mid+1,r,x);	 //右子树懒惰标记
	return tmp+adds[num];
}
int main()
{
	LL x,y;
	scanf("%d", &n);
	while(n != 0){
        memset(a, 0, sizeof(a));
        memset(adds, 0, sizeof(adds));
        for(int i = 0; i < n; i++){
            scanf("%lld%lld", &x, &y);
            change(1,1,n,x,y,1);    //每个区间上增加一个气球
        }
        for(int x = 1; x <= n; x++){//计算每个点的值
            ans=work1(1,1,n,x)+a[x];
            if(x != n)printf("%lld ",ans);
            else printf("%lld\n", ans);
        }
        scanf("%d", &n);
	}
	return 0;
}

3.区间修改，区间查询

#include <iostream>
#include <cstring> 
using namespace std;
const long long maxn = 1e5;
long long a[maxn+5],sum[maxn*4+5],tag[maxn*4+5];

//树上的每个节点都是其管辖区间的和 
void op(long long k){
    sum[k] = sum[k*2]+sum[k*2+1];
}

//建树过程 
void build(long long l,long long r,long long k){
    if(l>r)
        return;
    if(l==r){
        sum[k] = a[l];
        tag[k] = 0;
        return;
    }
    long long mid = (l+r)/2;
    build(l,mid,k*2);
    build(mid+1,r,k*2+1);
    op(k);
}

//下放标记到左右结点 
void pushdown(long long lenl,long long lenr,long long k){
    if(tag[k]){
        tag[k*2] = tag[k];
        tag[k*2+1] = tag[k];
        sum[k*2] = tag[k]*lenl;
        sum[k*2+1] = tag[k]*lenr;
        tag[k] = 0;
    }
}

//区间修改 
void change(long long l,long long r,long long pl,long long pr,long long k,long long val){
    if(l>r||pl>r||pr<l) //剪枝 
        return;
    if(l>=pl&&r<=pr){  //查询区间覆盖当前区间 
        sum[k] = val*(r-l+1); //当前结点的sum值需要修改为其覆盖结点之和 
        tag[k] = val;  //对当前节点的修改进行标记，等到查询时再push下去 
        return;
    }
    //查询区间没有覆盖当前区间 
    long long mid = (l+r)/2;  //继续二分查找子区间 
    pushdown(mid-l+1,r-mid,k);  //二分之前需要将当前结点的懒标记push下去，因为子节点一定会用到 
    change(l,mid,pl,pr,k*2,val);  //修改左区间 
    change(mid+1,r,pl,pr,k*2+1,val);  //修改右区间 
    op(k); //修改后求和 
}

//区间查询 
long long query(long long l,long long r,long long ql,long long qr,long long k){
    if(l>r||ql>r||qr<l) //剪枝
        return 0;
    if(l>=ql&&r<=qr) 				//查询区间覆盖当前区间 
        return sum[k];  			
    //查询区间没有完全覆盖当前区间
    long long mid = (l+r)>>1,ans = 0;
    pushdown(mid-l+1,r-mid,k);  	//push当前结点的懒标记 
    if(mid>=l)
        ans+=query(l,mid,ql,qr,k<<2); 		 //左区间查找 
    if(mid<r)
        ans+=query(mid+1,r,ql,qr,(k<<2)|1);  //右区间查找 
    return ans;
}

int main(){
    long long N,Q;
    scanf("%lld",&N);
    memset(a,0,sizeof(a));
    memset(sum,0,sizeof(sum));
    memset(tag,0,sizeof(tag));
    for(long long i=1;i<=N;i++){
        scanf("%lld",&a[i]);
    }
    build(1,N,1);
    scanf("%lld",&Q);
    long long type,l,r,val;
    for(long long i=0;i<Q;i++){
        scanf("%lld %lld %lld",&type,&l,&r);
        if(type==0){
            printf("%lld\n",query(1,N,l,r,1));
        }else{
            scanf("%lld",&val);
            change(1,N,l,r,1,val);
        }
    }
} 

例题

1.hoj 1337

#include<bits/stdc++.h>
#define MAX 200000
using namespace std;
int a,b,ans,n,m,x,val,maxx;
char op;
struct node
{
    int l,r,w,f;
}tree[4*MAX+5];

//建树
void build(int l,int r,int k)
{
    tree[k].l=l;
    tree[k].r=r;
    if(tree[k].l==tree[k].r)
    {
        scanf("%d",&tree[k].w);
        return;
    }
    int mid=(l+r)/2;
    build(l,mid,k*2);
    build(mid+1,r,k*2+1);
    tree[k].w=max(tree[k*2].w,tree[k*2+1].w);
}

//单点修改
void rep(int k)
{
    if(tree[k].l==tree[k].r)
    {
        tree[k].w=val;
        return;
    }
    
    int mid=(tree[k].l+tree[k].r)/2;
    if(x<=mid)rep(k*2);
    else rep(k*2+1);
    
    tree[k].w=max(tree[k*2].w,tree[k*2+1].w);
}

//区间查询 
void askin(int k)
{
    if(a<=tree[k].l&&tree[k].r<=b)
    {
        maxx=max(maxx,tree[k].w);
        return;
    }

    int mid=(tree[k].l+tree[k].r)/2;
    if(a<=mid)askin(k*2);
    if(b>mid)askin(k*2+1);
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        build(1,n,1);
        for(int i=1;i<=m;i++)
        {
            getchar();
            op=getchar();
            if(op=='Q')
            {
                scanf("%d%d",&a,&b);
                maxx=-1;
                askin(1);
                printf("%d\n",maxx);
            }
            else if(op=='U') 
            {
                scanf("%d%d",&x,&val);
                rep(1);
            }
        }
    }
    return 0;
}

2.白皮书板题

#include<iostream>
#include<math.h>

using namespace std;

const int maxn = 1000 + 5;
int N,C;
int L[maxn];
int S[maxn],A[maxn];

//线段树维护的数据
double vx[maxn],vy[maxn];       //个节点的向量
double ang[maxn];               //各节点的角度

//为查询角度变化而保存的当前角度的数组
double pre[maxn];

//初始化线段树,只有高度没有长度
//k是节点编号，l，r表示节点对应的是[l,r]区间
void init(int k,int l,int r)
{
    ang[k] = vx[k] = 0.0;
    if(r - l <= 1)          //因为是左开右闭区间
    {
        //叶子节点
        vy[k] = L[1];
    }
    else{
        int chl = k * 2 + 1;
        int chr = k * 2 + 2;
        init(chl,l,(l + r)/ 2);
        init(chr,(l + r) / 2,r);
        vy[k] = vy[chl] + vy[chr];
    }
}

//把s和s + 1之间的角度变为ang;
//v是节点的编号，l,r表示当前访问的区间是[l,r);
void change(int s,double a,int v,int l,int r)
{
    if(s <= l)return ;
    else if(s < r){
        int chl = v * 2 + 1;
        int chr = v * 2 + 2;
        int m = (l + r) / 2;
        change(s,a,chl,l,m);
        change(s,a,chr,m,r);
        if(s <= m)ang[v] += a;

        double s = sin(ang[v]),c = cos(ang[v]);
        vx[v] = vx[chl] + (c * vx[chr] - s * vy[chr]);
        vy[v] = vy[chl] + (s * vx[chr] - s * vy[chr]);
    }
}

void solve()
{
    init(0,0,N);
    for(int i = 1;i < N;i++)pre[i] = 3.1415926;
    for(int i = 0;i < C;i++)
    {
        int s = S[i];
        double a = A[i] / 360 * 2 * 3.1415926;
        change(s,a - pre[s],0,0,N);
        pre[s] = a;
        cout<<vx[0]<<vy[0]<<endl;
    }
}
int main()
{
    cin>>N>>C;
    int i = 0;
    while(N--){
        cin>>L[i++];
    }
    i = 0;
    while(C--){
        cin>>S[i++]>>A[i++];
    }
    solve();
}

3.hoj 1556

代码见区间修改，单点查询。