基本线段树（标记下传lazy-tag思想）poj 2468 A Simple Problem with Integers

目前为止只做了两题，另外一题使用的也是lazy-tag思想。以前比赛使用线段树，本身线段树具有快速求和的功能（使用了二分），但是这样是过不了数据量大的题目。区间加减等问题比较头疼，HDU上做了一题

敌兵布阵，也是使用这种思想，不过敌兵布阵是单个数值加减，比较容易实现，这题A Simple Problem with Integers 为区间加减求和，刚入手线段树比较难，慢慢领悟了就是要做标记下传。

这题很好的体现了lazy_tag的思想，当要增加的区间覆盖当前区间，则直接打上标记返回，当下次查询这个区间儿子区间的时候，直接标记往下传。可以想象，这个标记表示的是这个区间表示的整个区间的标记是整个子树的性质，当你不需要用到这个区间的儿子区间的时候，你可以不把操作都做到底，而是要用到的时候再往下传！

具体看代码：

 

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
#define MAX 500000
struct node
{
    int l,r;
    __int64 val;               //增量
    __int64 num;               //总和
}tree[4*MAX];
__int64 num[MAX];
void build(int l,int r,int index)     //建树
{
    tree[index].l=l;
    tree[index].r=r;
    if(tree[index].l==tree[index].r)
    {
        tree[index].num=num[l-1];
        return ;
    }
    int mid=(l+r)/2;
    build(l,mid,2*index);
    build(mid+1,r,2*index+1);
    tree[index].num=tree[index*2].num+tree[index*2+1].num;           //每个节点和
}
void update(int l,int r,int c,int index)
{
    if(tree[index].l>=l&&tree[index].r<=r)
    {
        tree[index].num+=(tree[index].r-tree[index].l+1)*c;
        tree[index].val+=c;
        return ;
    }    
    else
    {
    if(tree[index].val)                   //最关键部分就是这个标记下传，将增加值val传给他的左右孩子
    {
        tree[index*2].num+=tree[index].val*(tree[index*2].r-tree[index*2].l+1);
        tree[index*2].val+=tree[index].val;
        tree[index*2+1].num+=tree[index].val*(tree[index*2+1].r-tree[index*2+1].l+1);
        tree[index*2+1].val+=tree[index].val;
        tree[index].val=0;
    }
        if(r>=tree[index*2+1].l)
            update(l,r,c,2*index+1);
        if(l<=tree[index*2].r)
            update(l,r,c,2*index);    

    tree[index].num=tree[index*2].num+tree[index*2+1].num;
}
}
__int64 query(int a,int b,int index)
{
    
    if(tree[index].l>=a&&tree[index].r<=b)
        return tree[index].num;
    if(tree[index].val)         //求和同样需要标记下传
    {
        tree[index*2].num+=tree[index].val*(tree[index*2].r-tree[index*2].l+1);
        tree[index*2].val+=tree[index].val;
        tree[index*2+1].num+=tree[index].val*(tree[index*2+1].r-tree[index*2+1].l+1);
        tree[index*2+1].val+=tree[index].val;
        tree[index].val=0;
    }
    int mid=(tree[index].l+tree[index].r)/2;
    __int64 max1=0,max2=0;
    if(mid<a)
        max1= query(a,b,2*index+1);
    else
        if(b<=mid)
            max1=query(a,b,2*index);
        else
        {
            max1=query(a,mid,2*index);
            max2=query(mid+1,b,2*index+1);
        }
        return max1+max2;
}
int main()
{
    int n,i,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(tree,0,sizeof(tree));    
        for(i=0;i<n;i++)
            scanf("%I64d",&num[i]);    
        build(1,n,1);    
        for(i=0;i<m;i++)
        {
            char st;
            cin>>st;
            if(st=='C')
            {
                int a,b,c;
                scanf("%d%d%d",&a,&b,&c);
                update(a,b,c,1);
            }
            else
            {
                int a,b;
                __int64 sum=0;
                scanf("%d%d",&a,&b);
                sum=query(a,b,1);
                printf("%I64d\n",sum);
            }
        }
        
    }
    return 0;
}

大抵就是这样了!

代码没简化，凑合着看吧！