POJ3468_A Simple Problem with Integers-CFANZ编程社区

A Simple Problem with Integers

Time Limit: 5000MS		Memory Limit: 131072K
Total Submissions: 60712		Accepted: 18509
Case Time Limit: 2000MS

Description

You have N integers, A₁, A₂, ... ,A_N. 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 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₊₁, ... , A_b. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of A_a, A_a₊₁, ... ,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.

题目大意：

给定Q (1 ≤ Q ≤ 100,000)个数A1,A2… AQ,
以及可能多次进行的两个操作:
1) 对某个区间Ai … Aj的每个数都加n(n可变）
2) 求某个区间Ai … Aj的数的和

思路：

很明显的线段树题，但是按普通方法对Ai … Aj的数都更新到叶子节点，很容易超时，对此，我们可以用一个暂时变量lnc，用来存储操作1)Ai … Aj每个数加的n。

如果增加时，如果要加的区间正好覆盖一个节点(区间)，则增加其节点的Inc值，不再往下走，否则要更新nSum(加上本次增量),再将增量往下传。这样更新的复杂度就是O(log(n))。

在查询时，如果待查区间不是正好覆盖一个节点，就将节点的Inc往下带，然后将Inc代表的所有增量累加到nSum上后将Inc清0，接下来再往下查询。 Inc往下带的过程也是区间分解的过程，复杂度也是O(log(n))。

版本一：北大ACM暑期培训时写的代码(含结构体、左右节点指针)

# include<iostream>
using namespace std;

struct CNode
{
  int L,R;
  CNode *pLeft, *pRight;
  long long nSum;
  long long lnc;
};

CNode Tree[200010];
int nCount = 0;//当前线段树建立了多少个节点 
int Mid(CNode *pRoot)
{
  return (pRoot->L + pRoot->R)/2;
}

void BuildTree(CNode *pRoot, int L, int R)
{
  pRoot->L = L;
  pRoot->R = R;
  pRoot->nSum = 0;
  pRoot->lnc = 0;
  if(L==R)
    return;
  nCount++;
  pRoot->pLeft = Tree + nCount; 
  nCount++;
  pRoot->pRight = Tree + nCount;
  BuildTree(pRoot->pLeft,L,(L+R)/2);
  BuildTree(pRoot->pRight,(L+R)/2+1,R);
}

void Insert(CNode *pRoot,int i,int v)
{
  if(pRoot->L == i && pRoot->R == i)
  {
    pRoot->nSum = v;
    return;
  }
  pRoot->nSum += v;
  if(i <= Mid(pRoot))
    Insert(pRoot->pLeft,i,v);
  else
    Insert(pRoot->pRight,i,v);
}

void Add(CNode *pRoot,int a,int b,long long c)
{
  if(pRoot->L ==a && pRoot->R == b)
  {
    pRoot->lnc += c;
    return;
  }
  pRoot->nSum += c*(b-a+1);
  if(b <= (pRoot->L+pRoot->R)/2)
    Add(pRoot->pLeft,a,b,c);
  else if(a >= (pRoot->L+pRoot->R)/2+1)
    Add(pRoot->pRight,a,b,c);
  else
  {
    Add(pRoot->pLeft,a,(pRoot->L+pRoot->R)/2,c);
    Add(pRoot->pRight,(pRoot->L+pRoot->R)/2+1,b,c);
  }
}

long long QuerynSum(CNode *pRoot,int a,int b)
{
  if(pRoot->L==a && pRoot->R==b)
  {
    return pRoot->nSum + (pRoot->R - pRoot->L + 1)*pRoot->lnc;
  }
  pRoot->nSum += (pRoot->R - pRoot->L + 1)*pRoot->lnc;
  Add(pRoot->pLeft,pRoot->L,Mid(pRoot),pRoot->lnc);
  Add(pRoot->pRight,Mid(pRoot)+1,pRoot->R,pRoot->lnc);
  pRoot->lnc = 0;
  
  if(b <= Mid(pRoot))
    return QuerynSum(pRoot->pLeft,a,b);
  else if(a >= Mid(pRoot)+1)
    return QuerynSum(pRoot->pRight,a,b);
  else
  {
    return QuerynSum(pRoot->pLeft,a,Mid(pRoot)) + QuerynSum(pRoot->pRight,Mid(pRoot)+1,b);
  }
}
int main()
{
  int n,q,a,b,c;
  char cmd[3];
  scanf("%d%d",&n,&q);
  nCount = 0;
  BuildTree(Tree,1,n);
  for(int i = 1; i <= n; i++)
  {
    scanf("%d",&a);
    Insert(Tree,i,a);
  }
  
  for(int i = 0; i < q; i++)
  {
    scanf("%s",cmd);
    if(cmd[0]=='C')
    {
      scanf("%d%d%d",&a,&b,&c);
      Add(Tree,a,b,c);
    }
    else
    {
      scanf("%d%d",&a,&b);
      printf("%I64d\n",QuerynSum(Tree,a,b));
    }
  }
  return 0;
}

版本二：自己参考版本一修改(带结构体、不带左右节点指针)

# include<iostream>
using namespace std;

const int MAXN = 100000;

struct Node
{
    int L,R;
    __int64 sumV,lnc;
    int Mid()
    {
        return (L+R)/2;
    }
};
Node tree[MAXN*4+10];

void BuildTree(int root, int L, int R)
{
    tree[root].L = L;
    tree[root].R = R;
    tree[root].sumV = 0;
    tree[root].lnc = 0;
    if(L==R)
        return;
    BuildTree(root*2+1,L,(L+R)/2);
    BuildTree(root*2+2,(L+R)/2+1,R);
}

void InsertTree(int root, int i, int v)
{
    if(tree[root].L == i && tree[root].R == i)
    {
        tree[root].sumV = v;
        return;
    }
    tree[root].sumV += v;
    if(i <= tree[root].Mid())
        InsertTree(root*2+1,i,v);
    else
        InsertTree(root*2+2,i,v);
}

void Add(int root, int a, int b,__int64 c)
{
    if(tree[root].L==a && tree[root].R==b)
    {
        tree[root].lnc += c;
        return;
    }
    tree[root].sumV += c*(b-a+1);
    if(b <= tree[root].Mid())
        Add(root*2+1,a,b,c);
    else if(a >= tree[root].Mid()+1)
        Add(root*2+2,a,b,c);
    else
    {
        Add(root*2+1,a,tree[root].Mid(),c);
        Add(root*2+2,tree[root].Mid()+1,b,c);
    }
}

__int64 QuerysumV(int root, int a, int b)
{
    if(tree[root].L==a && tree[root].R==b)
    {
        return tree[root].sumV + (tree[root].R-tree[root].L+1)*tree[root].lnc;
    }
    tree[root].sumV += (tree[root].R-tree[root].L+1)*tree[root].lnc;
    Add(root*2+1,tree[root].L,tree[root].Mid(),tree[root].lnc);
    Add(root*2+2,tree[root].Mid()+1,tree[root].R,tree[root].lnc);
    tree[root].lnc = 0;

    if(b <= tree[root].Mid())
        return QuerysumV(root*2+1,a,b);
    else if(a >= tree[root].Mid()+1)
        return QuerysumV(root*2+2,a,b);
    else
    {
        return QuerysumV(root*2+1,a,tree[root].Mid()) + QuerysumV(root*2+2,tree[root].Mid()+1,b);
    }
}
int main()
{
    int n,q,a,b,c;
    char cmd[10];
    scanf("%d%d",&n,&q);
    int i;
    BuildTree(0,1,n);
    for(i = 1; i <= n; i++)
    {
        scanf("%d",&a);
        InsertTree(0,i,a);
    }
    for(i = 0; i < q; i++)
    {
        scanf("%s",cmd);
        if(cmd[0]=='C')
        {
            scanf("%d%d%d",&a,&b,&c);
            Add(0,a,b,c);
        }
        else
        {
            scanf("%d%d",&a,&b);
            printf("%I64d\n",QuerysumV(0,a,b));
        }
    }

    return 0;
}

版本三：参考HH大神模板写的(不带结构体、不带左右节点指针)

# include<stdio.h>
# include<iostream>
# include<algorithm>
using namespace std;
const int MAXN = 100010;

__int64 sum[MAXN<<2],add[MAXN<<2];
void pushup(int root)
{
    sum[root] = sum[root<<1] + sum[root<<1|1];
}

void pushdown(int root,int len)
{
    if(add[root])
    {
        add[root<<1] += add[root];
        add[root<<1|1] += add[root];
        sum[root<<1] += (add[root]*(len-(len>>1)));
        sum[root<<1|1] += (add[root]*(len>>1));
        add[root] = 0;
    }
}
void build(int root,int L,int R)
{
    add[root] = 0;
    if(L == R)
    {
        scanf("%I64d", &sum[root]);
        return;
    }
    int mid = (L+R)>>1;

    build(root<<1,L,mid);
    build(root<<1|1,mid+1,R);

    pushup(root);
}

void updata(int root,int L,int R,int s,int e,__int64 v)
{
    if(s<=L && e>=R)
    {
        add[root] += v;
        sum[root] += (__int64)(v*(R-L+1));
        return;
    }
    pushdown(root,R-L+1);

    int mid = (L+R)>>1;

    if(s <= mid)
        updata(root<<1,L,mid,s,e,v);
    if(e > mid)
        updata(root<<1|1,mid+1,R,s,e,v);

    pushup(root);
}

__int64 query(int root,int L,int R,int s,int e)
{
    if(s<=L && e>=R)
        return sum[root];

    pushdown(root,R-L+1);

    __int64 res = 0;
    int mid = (L+R)>>1;
    if(s <= mid)
        res += query(root<<1,L,mid,s,e);
    if(e > mid)
        res += query(root<<1|1,mid+1,R,s,e);

    return res;
}
int main()
{
    int N,Q,s,e,a,b;
    __int64 v;
    char cmd[10];
    scanf("%d%d", &N,&Q);
    build(1,1,N);
    while(Q--)
    {
        scanf("%s",cmd);
        if(cmd[0]=='Q')
        {
            scanf("%d%d",&s,&e);
            printf("%I64d\n",query(1,1,N,s,e));
        }
        else if(cmd[0]=='C')
        {
            scanf("%d%d%I64d",&a,&b,&v);
            updata(1,1,N,a,b,v);
        }
    }
    return 0;
}