Transformation

Time Limit: 15000/8000 MS (Java/Others) Memory Limit: 65535/65536 K (Java/Others)
Total Submission(s): 2374 Accepted Submission(s): 558

Problem Description

Yuanfang is puzzled with the question below:
There are n integers, a₁, a₂, …, a_n. The initial values of them are 0. There are four kinds of operations.
Operation 1: Add c to each number between a_x and a_y inclusive. In other words, do transformation a_k<---a_k+c, k = x,x+1,…,y.
Operation 2: Multiply c to each number between a_x and a_y inclusive. In other words, do transformation a_k<---a_k×c, k = x,x+1,…,y.
Operation 3: Change the numbers between a_x and a_y to c, inclusive. In other words, do transformation a_k<---c, k = x,x+1,…,y.
Operation 4: Get the sum of p power among the numbers between a_x and a_y inclusive. In other words, get the result of a_x^p+a_x+1^p+…+a_y^p.
Yuanfang has no idea of how to do it. So he wants to ask you to help him.

Input

There are no more than 10 test cases.
For each case, the first line contains two numbers n and m, meaning that there are n integers and m operations. 1 <= n, m <= 100,000.
Each the following m lines contains an operation. Operation 1 to 3 is in this format: "1 x y c" or "2 x y c" or "3 x y c". Operation 4 is in this format: "4 x y p". (1 <= x <= y <= n, 1 <= c <= 10,000, 1 <= p <= 3)
The input ends with 0 0.

Output

For each operation 4, output a single integer in one line representing the result. The answer may be quite large. You just need to calculate the remainder of the answer when divided by 10007.

Sample Input

 
5 3 3 5 7 1 2 4 4 4 1 5 2 2 2 5 8 4 3 5 3 0 0 
  

Sample Output

7489

Source

2013ACM-ICPC杭州赛区全国邀请赛

题意：4种操作，1操作为把[x,y]区间的所有数同时加c，2操作为把[x,y]区间的所有数同时乘c，3操作为把[x,y]区间的所有数更新为c，4操作为查询[x,y]区间每个数的p次方和，p为1或2或3

思路：很裸的线段树题，但并不好写，维护3个变量sum1，sum2，sum3分别代表1次方和，2次方和，3次方和，add，mul，st代表前三种操作的lazy，初始值分别为0，1，-1，我们可以通过sum1推出sum2，根据sum2推出sum3，写写公式就推导出来了。在pushdown的时候我们要先处理st，然后在处理add和mul，先处理mul，后处理add，处理完st后需要把子区间的add，mul恢复为初始值，另外在处理mul时，也需要对add乘以要乘的数值。

#include <stdio.h>

#define lson num << 1
#define rson num << 1 | 1
#define maxn 100005
#define mod 10007

typedef long long ll;

struct NODE
{
    int l,r;
    ll add,mul,st;
    ll sum1,sum2,sum3;
}segTree[maxn << 2];

void pushup(int num)
{
    segTree[num].sum1 = (segTree[lson].sum1 % mod + segTree[rson].sum1 % mod) % mod;
    segTree[num].sum2 = (segTree[lson].sum2 % mod + segTree[rson].sum2 % mod) % mod;
    segTree[num].sum3 = (segTree[lson].sum3 % mod + segTree[rson].sum3 % mod) % mod;
}
void pushdown(int num)
{
    int llen = (segTree[lson].r - segTree[lson].l + 1);
    int rlen = (segTree[rson].r - segTree[rson].l + 1);

    if(segTree[num].st != -1){

        segTree[lson].st = segTree[num].st % mod;
        segTree[rson].st = segTree[num].st % mod;


        segTree[lson].sum1 = (segTree[lson].st % mod * llen) % mod;
        segTree[lson].sum2 = (segTree[lson].st % mod * segTree[lson].st % mod * llen) % mod;
        segTree[lson].sum3 = (segTree[lson].st % mod * segTree[lson].st % mod * segTree[lson].st % mod * llen) % mod;


        segTree[rson].sum1 = (segTree[rson].st % mod * rlen) % mod;
        segTree[rson].sum2 = (segTree[rson].st % mod * segTree[rson].st % mod * rlen) % mod;
        segTree[rson].sum3 = (segTree[rson].st % mod * segTree[rson].st % mod * segTree[rson].st % mod * rlen) % mod;

        segTree[num].st = -1;
        segTree[lson].add = 0;
        segTree[lson].mul = 1;
        segTree[rson].add = 0;
        segTree[rson].mul = 1;

    }
    if(segTree[num].mul != 1){

        ll c = segTree[num].mul;
        segTree[lson].add = (segTree[lson].add * c % mod) % mod;
        segTree[rson].add = (segTree[rson].add * c % mod) % mod;
        segTree[lson].mul = (segTree[lson].mul % mod * c % mod) % mod;
        segTree[rson].mul = (segTree[rson].mul % mod * c % mod) % mod;

        segTree[lson].sum1 = (segTree[lson].sum1 % mod * c % mod) % mod;
        segTree[lson].sum2 = (segTree[lson].sum2 % mod * c % mod * c % mod) % mod;
        segTree[lson].sum3 = (segTree[lson].sum3 % mod * c % mod * c % mod * c % mod) % mod;

        segTree[rson].sum1 = (segTree[rson].sum1 % mod * c % mod) % mod;
        segTree[rson].sum2 = (segTree[rson].sum2 % mod * c % mod * c % mod) % mod;
        segTree[rson].sum3 = (segTree[rson].sum3 % mod * c % mod * c % mod * c % mod) % mod;

        segTree[num].mul = 1;
    }
    if(segTree[num].add){
        ll c = segTree[num].add;
        segTree[lson].add = (segTree[lson].add + c % mod) % mod;
        segTree[rson].add = (segTree[rson].add + c % mod) % mod;

        segTree[lson].sum3 = (segTree[lson].sum3 + (3 * c % mod * segTree[lson].sum2 % mod) % mod + (3 *
                              c % mod * c % mod * segTree[lson].sum1 % mod) % mod +(
                              c % mod * c % mod * c % mod * llen % mod) % mod) % mod;
        segTree[lson].sum2 = (segTree[lson].sum2 + (2 * segTree[lson].sum1 % mod * c % mod) % mod +
                              (c % mod * c % mod * llen % mod) % mod)  % mod;
        segTree[lson].sum1 = (segTree[lson].sum1 + c % mod * llen % mod) % mod;

        segTree[rson].sum3 = (segTree[rson].sum3 + (3 * c % mod * segTree[rson].sum2 % mod) % mod + (3 *
                              c % mod * c % mod * segTree[rson].sum1 % mod) % mod +(
                              c % mod * c % mod * c % mod * rlen % mod) % mod) % mod;
        segTree[rson].sum2 = (segTree[rson].sum2 + (2 * segTree[rson].sum1 % mod * c % mod) % mod +
                              (c % mod * c % mod * rlen % mod) % mod)  % mod;
        segTree[rson].sum1 = (segTree[rson].sum1 + c % mod * rlen % mod) % mod;

        segTree[num].add = 0;
    }
}
void build(int num,int l,int r)
{
    segTree[num].l = l;
    segTree[num].r = r;
    segTree[num].add = 0;
    segTree[num].st = 0;
    segTree[num].mul = 1;
    if(l == r){
        segTree[num].sum1 = 0;
        segTree[num].sum2 = 0;
        segTree[num].sum3 = 0;
        return;
    }
    int mid = (segTree[num].l + segTree[num].r) >> 1;
    build(lson,l,mid);
    build(rson,mid + 1,r);
    pushup(num);
}
ll query(int num,int l,int r,int ty)
{
    if(segTree[num].l == l && segTree[num].r == r){
        if(ty == 1){
            return segTree[num].sum1;
        }
        else if(ty == 2){
            return segTree[num].sum2;
        }
        else{
            return segTree[num].sum3;
        }
    }
    pushdown(num);
    int mid = (segTree[num].l + segTree[num].r) >> 1;
    ll ans = 0;
    if(r <= mid){
        ans = (ans + query(lson,l,r,ty) % mod) % mod;
    }
    else if(l > mid){
        ans = (ans + query(rson,l,r,ty) % mod) % mod;
    }
    else{
        ans = (ans + query(lson,l,mid,ty) % mod) % mod;
        ans = (ans + query(rson,mid + 1,r,ty) % mod) % mod;
    }
    return ans;
}
void update(int num,int l,int r,int ty,ll val)
{
    if(segTree[num].l == l && segTree[num].r == r){
        if(ty == 1){
            segTree[num].sum3 = (segTree[num].sum3 + (3 * val % mod * segTree[num].sum2 % mod) % mod + (3 *
                              val % mod * val % mod * segTree[num].sum1 % mod) % mod +
                              val % mod * val % mod * val % mod * (r - l + 1) % mod) % mod;
            segTree[num].sum2 = (segTree[num].sum2 + (2 * segTree[num].sum1 % mod * val % mod) % mod +
                              (val % mod * val % mod * (r - l + 1) % mod) % mod) % mod;
            segTree[num].sum1 = (segTree[num].sum1 + val % mod * (r - l + 1) % mod) % mod;
            segTree[num].add = (segTree[num].add + val % mod) % mod;
        }
        else if(ty == 2){
            segTree[num].sum1 = (segTree[num].sum1 * val % mod) % mod;
            segTree[num].sum2 = (segTree[num].sum2 * val % mod * val % mod) % mod;
            segTree[num].sum3 = (segTree[num].sum3 * val % mod * val % mod * val % mod) % mod;
            segTree[num].mul = (segTree[num].mul * val % mod) % mod;
            segTree[num].add = (segTree[num].add * val % mod) % mod;
        }
        else{
            segTree[num].sum1 = (r - l + 1) * val % mod;
            segTree[num].sum2 = (r - l + 1) * val % mod * val % mod;
            segTree[num].sum3 = (r - l + 1) * val % mod * val % mod * val % mod;

            segTree[num].add = 0;
            segTree[num].mul = 1;
            segTree[num].st = val;
        }
        return;
    }
    pushdown(num);
    int mid = (segTree[num].l + segTree[num].r) >> 1;
    if(r <= mid){
        update(lson,l,r,ty,val);
    }
    else if(l > mid){
        update(rson,l,r,ty,val);
    }
    else{
        update(lson,l,mid,ty,val);
        update(rson,mid + 1,r,ty,val);
    }
    pushup(num);
}
int main(void)
{
    int n,m;
    while(scanf("%d%d",&n,&m) != EOF){
        if(n == 0 && m == 0){
            break;
        }
        build(1,1,n);
        int op,l,r,t;
        ll v;
        while(m--){
            scanf("%d",&op);
            if(op != 4){
                scanf("%d%d%lld",&l,&r,&v);
                update(1,l,r,op,v);
            }
            else{
                scanf("%d%d%d",&l,&r,&t);
                printf("%lld\n",query(1,l,r,t));
            }
        }
    }
    return 0;
}

HDU 4578 Transformation 线段树

Transformation

猜你喜欢