POJ3468 顺便贴个学姐的线段树版

学姐的线段树，据说是国内常用版本...我的完全二叉树版线段树被嘲笑奇葩啊！！！你妹= =，写个线段树还被说奇葩

#include<iostream>
#include<cstdio>
#include<map>
#include<string.h>
using namespace std;

#define LL long long
#define MAXN 101010

LL sum[MAXN<<2],add[MAXN<<2],a[MAXN<<2];

void pushup(int rt){
	sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}

void pushdown(int rt,int len) {
	if (add[rt]) {
		add[rt<<1]+=add[rt];
		add[rt<<1|1]+=add[rt];
		sum[rt<<1]+=add[rt]*(len-(len>>1));
		sum[rt<<1|1]+=add[rt]*(len>>1);
		add[rt]=0;
	}
}

void build(int l,int r,int rt){
	add[rt]=0;
	if (l==r) {
		sum[rt]=a[l]; return ;
	}
	int mid=(l+r)>>1;
	build(l,mid,rt<<1);
	build(mid+1,r,rt<<1|1);
	pushup(rt);
}

void update(int x,int y,LL c,int l,int r,int rt) {
	if (x<=l&&y>=r) {
		add[rt]+=c; sum[rt]+=c*(r-l+1);
		return ;
	}
	int mid=(l+r)>>1;
	pushdown(rt,r-l+1);
	if (x<=mid) update(x,y,c,l,mid,rt<<1);
	if (y>mid) update(x,y,c,mid+1,r,rt<<1|1);
	pushup(rt);
}

LL query(int x,int y,int l,int r,int rt){
	if (x<=l&&y>=r)
		return sum[rt];
	int mid=(l+r)>>1;
	pushdown(rt,r-l+1);
	LL ans=0;
	if (x<=mid) ans+=query(x,y,l,mid,rt<<1);
	if (y>mid) ans+=query(x,y,mid+1,r,rt<<1|1);
	return ans;
}

int main(){
	int n,m,x,y,c;
	char buff[20];
	while (scanf("%d%d",&n,&m)!=EOF) {
		for (int i=1;i<=n;i++)
			scanf("%lld",&a[i]);
		build(1,n,1);
		while (m--) {
			scanf("%s%d%d",buff,&x,&y);
			if (buff[0]=='Q') printf("%lld\n",query(x,y,1,n,1));
			else {
				scanf("%d",&c);
				update(x,y,c,1,n,1);
			}
		}
	}
	return 0;
}

我自己的..国内罕见完全二叉树版本的线段树+区间更新。。。

区间更新及查询原理

若更新一个区间的值，必然要影响到其父节点和子节点得值。

进行区间更新的时候要新建一个标记数组，

对于要更新节点的父节点，我们直接把更新的影响更新到数据数组中，查询的时候如果覆盖父节点，就直接返回数据值，这个数值包含了其所有被更新的儿子所产生的影响。

对于要更新的节点的子节点，被完全覆盖的需要更新的节点只更新影响数组，在需要更新儿子节点的时候，把标记值作用于此节点并且把标记值向下传递。

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;


typedef long long ll;
const ll MAX_N=700000;
ll data[MAX_N];//every element ll the segment should be added
ll datb[MAX_N];//apart from data , the left sum
ll n;


void init(ll n_)
{
    memset(data,0,sizeof(data));
    memset(datb,0,sizeof(datb));
    n=1;
    while(n<n_)
    {
        n*=2;
    }
}


void update(int k,int x)
{
    k=k+(n-1);
    datb[k]+=x;
    while(k>1)
    {
        k/=2;
        datb[k]+=x;
    }
}


void add(ll a,ll b,ll k,ll l,ll r,ll x)//区间更新的时候懒标记和总体值2选1更新
{
    if(a<=l&&r<=b)
        data[k]+=x;//当有一段被整体更新的时候懒标记不再继续向下进行传递
    else if(a<=r&&l<=b)
    {
        datb[k]+=(min(r,b)-max(a,l)+1)*x;//不完全包含的时候增加包含字段的累加值，但不会增加懒标记
        add(a,b,k*2,l,(l+r)/2,x);
        add(a,b,k*2+1,(l+r)/2+1,r,x);
    }
}


ll query(ll a,ll b,ll k,ll l,ll r)
{
    if(b<l||a>r) return 0;
    if(a<=l&&r<=b)
    {
        return (r-l+1)*data[k]+datb[k];//完全包含的时候返回懒标记和数值
    }
    ll res=(min(b,r)-max(a,l)+1)*data[k];//本层的懒标记
    ll v1=query(a,b,k*2,l,(l+r)/2);
    ll v2=query(a,b,k*2+1,(l+r)/2+1,r);
    return res+v1+v2;
}


int main()
{
    int m,nn;
    while(scanf("%d%d",&nn,&m)!=EOF){
    init(nn);
    for(int i=1;i<=nn;i++)
    {
        ll ttn;
        scanf("%I64d",&ttn);
        update(i,ttn);
    }
    for(int i=1;i<=m;i++)
    {
        char c[2];
        ll a,b,x;
        scanf("%s",c);
        if(c[0]=='Q')
        {
            scanf("%I64d%I64d",&a,&b);
            printf("%I64d\n",query(a,b,1,1,n));
        }
        else
        {
            scanf("%I64d%I64d%I64d",&a,&b,&x);
            add(a,b,1,1,n,x);
        }
    }
    }
    return 0;
}