A Simple Problem with Integers（POJ-3468）

点我跳转原题

Description

You have N integers, A1, A2, … , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. 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 A1, A2, … , AN. -1000000000 ≤ Ai ≤ 1000000000.
Each of the next Q lines represents an operation. “C a b c” means adding c to each of Aa, Aa+1, … , Ab. -10000 ≤ c ≤ 10000.
“Q a b” means querying the sum of Aa, Aa+1, … , Ab.

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.

---

解题思路

每次进行add操作时候，用标记处理每次的add，控制不向下传递无意义的add，但是数据范围要注意会爆int，给标记，区间和，初始数据上long long即可，还有要注意(r-l+1)*c得数据范围会boom，要用上( 1ll )

AC代码

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
const int maxn = 100100;
typedef long long ll;
ll tree[maxn<<2];
ll lazy[maxn<<2];
ll CoderSilence[maxn];
void build(int p , int l , int r)
{
	lazy[p] = 0;//所有的节点暂时没有积压数据
	if( l == r )
	{
		tree[p] = CoderSilence[l];
		return ;
	}
	int mid = (l + r)>>1;
	build(p<<1,l,mid);
	build(p<<1|1,mid+1,r);
	tree[p] = tree[p<<1]+tree[p<<1|1];
}
void lazydown(int p , int cnt)
{
	//左右儿子的lazy加上父级的lazy
	lazy[p<<1]	 += lazy[p];
	lazy[p<<1|1] += lazy[p];

	//cnt一分为二，分为左右，且此时两边的lazy暂时不下放
	//还有多少lazy存在左子树和右子树
	tree[p<<1]	 += (cnt - (cnt>>1)) * lazy[p];	//左子树的点数 * lazy[p]
	tree[p<<1|1] += (cnt>>1) * lazy[p];			//右子树的点数 * lazy[p]

	//父级lazy清空
	lazy[p] = 0;
}
void adding(int p ,int l ,int r ,int a, int b ,int c)
{
	if(a <= l && r <= b)
	{//每个元素+c就是整个区间加上r-l+1个c
		tree[p] += (1ll)*(r-l+1)*c;
	//只是区间加上了但是区间下面的儿子没有加，没有放下去
		lazy[p] += c;//先积压着 不下放给儿子们
		return ;
	}
	//不是覆盖情况我们就要往下走
	lazydown(p,r-l+1);//往下走就必须传达下去lazy积压的数据
	//r-l+1 就是积压的数据要分给下面r-l+1个儿子
	int mid = (l+r)>>1;
	if( a <= mid )//如果在左边就在左儿子中找
	{
		adding(p<<1,l,mid,a,b,c);
	}
	if( b > mid )//如果在右边就去右儿子中找
	{
		adding(p<<1|1,mid+1,r,a,b,c);
	}
	//更新
	tree[p] = tree[p<<1]+tree[p<<1|1];
}
ll query(int p ,int l ,int r , int a , int b)
{
	if(a <= l && r <= b)
	{
		return tree[p];
	}
	int mid = (l+r)>>1;
	if( lazy[p] != 0 )//当前节点存在积压数据
	{
		lazydown(p,r-l+1);
	}
	if( b <= mid )
	{
		return query(p<<1,l,mid,a,b);
	}
	if( a > mid )
	{
		return query(p<<1|1,mid+1,r,a,b);
	}
	else
	{
		return (query(p<<1,l,mid,a,mid)+query(p<<1|1,mid+1,r,mid+1,b));
	}
}
int main()
{
	int n,t;
	scanf("%d %d",&n,&t);
	for(ll i = 1 ; i <= n ; i++)
	{
		scanf("%lld",&CoderSilence[i]);
	}
	build(1,1,n);
	while(t--)
	{
		char op[4];int a,b,c;
		scanf("%s",op);
		if(op[0] == 'Q')
		{
			scanf("%d %d",&a,&b);
			printf("%lld\n",query(1,1,n,a,b));
		}else if(op[0] == 'C')
		{
			scanf("%d %d %d",&a,&b,&c);
			adding(1,1,n,a,b,c);
		}
	}
	return 0;
}