hdu4267 A Simple Problem with Integers

A Simple Problem with Integers

Time Limit: 5000/1500 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2571 Accepted Submission(s): 837

Problem Description

Let A1, A2, ... , AN be N elements. You need to deal with two kinds of operations. One type of operation is to add a given number to a few numbers in a given interval. The other is to query the value of some element.

Input

There are a lot of test cases.

The first line contains an integer N. (1 <= N <= 50000)

The second line contains N numbers which are the initial values of A1, A2, ... , AN. (-10,000,000 <= the initial value of Ai <= 10,000,000)

The third line contains an integer Q. (1 <= Q <= 50000)

Each of the following Q lines represents an operation.

"1 a b k c" means adding c to each of Ai which satisfies a <= i <= b and (i - a) % k == 0. (1 <= a <= b <= N, 1 <= k <= 10, -1,000 <= c <= 1,000)

"2 a" means querying the value of Aa. (1 <= a <= N)

Output

For each test case, output several lines to answer all query operations.

Sample Input

4
1 1 1 1
14
2 1
2 2
2 3
2 4
1 2 3 1 2
2 1
2 2
2 3
2 4
1 1 4 2 1
2 1
2 2
2 3
2 4

Sample Output

1
1
1
1
1
3
3
1
2
3
4
1

这题好卡内存，发现用结构比直接用数组要省很多啊，结果搞的我卡了不知道多少次啊！分析一下题，一看，就知道是要用线段树，但是和别的不一样，就是，它是单点更新，

为什么是单点更新呢？因为在一个区间上，并不是没一个都要更新！但这一点，对于线段树来说，就是非常不利的了，因为，线段树就是要成段更新，如果是，一个点一个点，

那么线段树便失去了作用，那么还有什么意义呢？所以，我们要用一个数组，先保存所有要更新的信息，也就是（i-a）%k==0转化成(i%k)==l%k;因为l%k是很快可以算出来的，我在在要更新区间上，把这个相应的数组加累加起来，也就是把所有的(l%k)加起来，到了最后查询的时候只把，(i%k),的加起来，这样，不但满足了题意，也用了延时标记，把点连成了线，最后要查询的时候，再把所有的和加起来并更新，就可以了！很好线段树了！

#include <string.h>
#include <iostream>
#include <stdio.h>
using namespace std;
#define MAXN 50005
#define lnum num<<1
#define rnum num<<1|1

struct node
{
    int color,prime,listadd[55];
}tree[4*MAXN];
#define inf 0
int modleft[11][11];
void build(int num ,int l,int r)
{
    memset(tree[num].listadd,0,sizeof(tree[num].listadd));
    tree[num].color=0;
    int mid=(l+r)>>1;
    if(l>=r)
    {
        scanf("%d",&tree[num].prime);
        return ;
    }
    build(lnum,l,mid);
    build(rnum,mid+1,r);
}
void pushdown(int num)
{
    int i;
     if(tree[num].color!=inf)
    {

            tree[lnum].color=tree[num].color;
            tree[rnum].color=tree[num].color;
            tree[num].color=inf;//还原标记

            for(i=0;i<55;i++)
            {

                tree[lnum].listadd[i]+=tree[num].listadd[i];
                tree[rnum].listadd[i]+=tree[num].listadd[i];
                tree[num].listadd[i]=0;

            }
    }
}
void update(int s,int e,int a,int b,int num,int amk,int k,int c )
{
    int i;

    if(a<=s&&b>=e)
    {
        tree[num].color=k;//需要更新
        tree[num].listadd[modleft[k][amk]]+=c;
        return ;
    }
    pushdown(num);
  int mid=(s+e)>>1;
  if(mid>=a)
  update(s,mid,a,b,lnum,amk,k,c);
  if(mid<b)
  update(mid+1,e,a,b,rnum,amk,k,c);
}
int query(int s,int e,int num,int x)//充分利用这个延时标记
{
    int i;

    if(s>=e)
    {
        int temp=tree[num].prime;
        for(i=1;i<=10;i++)
        {
            temp+=tree[num].listadd[modleft[i][x%i]];
            tree[num].listadd[modleft[i][x%i]]=0;
        }
        tree[num].prime=temp;//更新为新的值
        return temp;
    }
    pushdown(num);
    int mid=(s+e)>>1;
    if(x>mid)
        return query(mid+1,e,rnum,x);
    else
    {
        return query(s,mid,lnum,x);
    }
}
int main()
{
    int asknum,num12,x,a,b,n,k,c;
    int i,j,cnt=0;
    for(i=1;i<=10;i++)
        for(j=0;j<i;j++)
        {
            modleft[i][j]=cnt++;//省了一半的空间
        }
    while(scanf("%d",&n)!=EOF)
    {
        build(1,1,n);

        scanf("%d",&asknum);
        while(asknum--)
        {

           scanf("%d",&num12);
           if(num12==1)
           {
              scanf("%d%d%d%d",&a,&b,&k,&c);

              update(1,n,a,b,1,a%k,k,c);
           }
           else{
              scanf("%d",&x);
              printf("%d\n",query(1,n,1,x));
           }

        }
    }
    return 0;
}