poj_3468 A Simple Problem with Integers

A Simple Problem with Integers

Time Limit: 5000MS	Memory Limit: 131072K
Total Submissions: 31675	Accepted: 8989
Case Time Limit: 2000MS

题目链接：http://poj.org/problem?id=3468

Description

You have N integers, A₁, A₂,... ,A_N. You need to deal with two kinds of operations. Onetype of operation is to add some given number to each number in a giveninterval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤N,Q≤ 100000.
The second line contains N numbers, the initial values of A₁,A₂, ... ,A_N. -1000000000 ≤ A_i≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of A_a,A_a+1, ... ,A_b. -10000 ≤ c≤ 10000.
"Q a b" means querying the sum of A_a,A_a+1, ... ,A_b.

Output

You need to answer all Q commands in order. One answer in a line.

Sample Input

10 5

1 2 3 4 5 6 7 8 9 10

Q 4 4

Q 1 10

Q 2 4

C 3 6 3

Q 2 4

Sample Output

4

55

9

15

Hint

The sums may exceed the range of 32-bit integers.

Source

POJMonthly--2007.11.25, Yang Yi

 

解题思路：

         这个题目是一个典型的线段树的题目，里面有两个操作1：更新区间，2：查询区间，需要注意的是更新区间必须包含更新点的操作，实现建立线段树，在更新的区间的操作中涉及到懒操作，即更新完一个区间后，没有马上更新这个区间的子节点，而是先做记号，等到执行查询操作的时候在判断这个区间是否标记其子节点的更新，如果有的话就更新其子节点的值，这个题目要注意的是题目输入输出数据量比较大，用整型不能满足要求，而要用64位的长整型才可以。

 

代码：

#include <iostream>
#include<stdio.h>
using namespace std;

const __int64 maxn=100002;
__int64 sum[maxn*4]={0};//这个要初始化为0
__int64 col[maxn*4]={0};//标记每个节点，初始化为0
//将子节点的数据传到根节点
void PushUp(__int64 rt)
{//存放节点的总和
    sum[rt]=sum[rt*2]+sum[rt*2+1];
}
//将m个值做标记
void PushDownAdd(__int64 rt,__int64 m)
{
    //如果该点做了标记
    if(col[rt])
    {
        //那么为该点的孩子节点也做标记
		col[rt*2]+=col[rt];
		col[rt*2+1]+=col[rt];
       // col[rt*2]=col[rt*2+1]=col[rt];
        //并修改该点孩子节点的值
        sum[rt*2]+=(m-m/2)*col[rt];
        sum[rt*2+1]+=(m/2)*col[rt];
        col[rt]=0;//取消该点的标记
    }
}

//将m个值做标记
void PushDownValue(__int64 rt,__int64 m)
{
    //如果该点做了标记
    if(col[rt])
    {
        //那么为该点的孩子节点也做标记
        col[rt*2]=col[rt*2+1]=col[rt];
        //并修改该点孩子节点的值
        sum[rt*2]=(m-m/2)*col[rt];
        sum[rt*2+1]=(m/2)*col[rt];
        col[rt]=0;//取消该点的标记
    }
}

//递归创建数，并且更新到根节点，sum保存了这个线段的值
void build(__int64 l,__int64 r,__int64 rt)
{
    if(l==r)
    {
		cin>>sum[rt];
        return;
    }
    __int64 m=(l+r)/2;
    build(l,m,rt*2);
    build(m+1,r,rt*2+1);
    PushUp(rt);
}

//在l到r区间中查找left到right区间的和
__int64 query(__int64 left,__int64 right,__int64 l,__int64 r,__int64 rt)
{

    if(l==left && r==right)
    {
        return sum[rt];
    }
	PushDownAdd(rt,r-l+1);
    __int64 mid=(r+l)/2;
    __int64 ret=0;
    if(right<=mid)//在左孩子
	{
        ret+=query(left,right,l,mid,rt*2);
	}
    else if(left>=mid+1)//在右孩子
        ret+=query(left,right,mid+1,r,rt*2+1);
    else//一半在左孩子一半在右孩子
    {
        //先查找left到mid区间的和，在计算mid+1到right区间的和
        ret+=query(left,mid,l,mid,rt*2);
        ret+=query(mid+1,right,mid+1,r,rt*2+1);
    }
    return ret;
}
//在l到r区间中更新left到right区间的值加上add，并且更新它父亲的值
void updateAdd(__int64 left,__int64 right,__int64 add,__int64 l,__int64 r,__int64 rt)
{
    //要更新的这个区间在l到r区间内
    if(left<=l && r<=right)
    {//只在该点做修改，其他点就不在修改，只是做标记
        col[rt]+=add;//在该点做标记---标记累加
        sum[rt]+=add*(r-l+1);//该点的值做修改
        return;
    }
    //修改该点的孩子的值
    PushDownAdd(rt,r-l+1);
    __int64 m=(l+r)/2;
    if(left<=m)
        updateAdd(left,right,add,l,m,rt*2);
    if(right>m)
        updateAdd(left,right,add,m+1,r,rt*2+1);
    PushUp(rt);//更改rt节点的总和
}


//在l到r区间中更新left到right区间的值为add，并且更新它父亲的值
void updateValue(__int64 left,__int64 right,__int64 value,__int64 l,__int64 r,__int64 rt)
{
    //要更新的这个区间在l到r区间内
    if(left<=l && r<=right)
    {//只在该点做修改，其他点就不在修改，只是做标记
        col[rt]=value;//在该点做标记
        sum[rt]=value*(r-l+1);//该点的值做修改
        return;
    }
    //修改该点的孩子的值
    PushDownValue(rt,r-l+1);
    __int64 m=(l+r)/2;
    if(left<=m)
        updateValue(left,right,value,l,m,rt*2);
    if(right>m)
        updateValue(left,right,value,m+1,r,rt*2+1);
    PushUp(rt);//更改rt节点的总和
}

int main()
{
	int N,Q;
    char ch;
    __int64 a,b;
	__int64 c;
    scanf("%d%d",&N,&Q);
	build(1,N,1);
    while(Q--)
    {
		cin>>ch;
        if(ch=='Q')
        {
            scanf("%lld%lld",&a,&b);
            printf("%lld\n",query(a,b,1,N,1));
        }
        else if(ch=='C')
        {
            scanf("%lld%lld%lld",&a,&b,&c);
            updateAdd(a,b,c,1,N,1);
        }
    }
    return 0;
}