Transformation

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

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 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

    307 7489 
  

Source

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

题目传送

这道题题意 1 加 d

2 乘 d

3 替换为 d

4 输出每个d次方和

用和的平方公式和的立方公式实现有难度

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#define MOD 10007
using namespace std;
const int MAX_N  = 100010;

long long sum1[MAX_N<<2],sum2[MAX_N<<2],sum3[MAX_N<<2];
long long addv[MAX_N<<2],mulv[MAX_N<<2],setv[MAX_N<<2];

void up(int p){
    sum1[p] = (sum1[p*2]+sum1[p*2+1])%MOD;
    sum2[p] = (sum2[p*2]+sum2[p*2+1])%MOD;
    sum3[p] = (sum3[p*2]+sum3[p*2+1])%MOD;
}
void down(int p,int l,int r){
    int mid = (l+r)>>1;
    if(setv[p]){
        setv[p*2] = setv[p*2+1] = setv[p];
        addv[p*2] = addv[p*2+1] = 0;
        mulv[p*2] = mulv[p*2+1] = 1;
        sum1[p*2] = (mid-l+1)*setv[p] %MOD;
        sum1[p*2+1] = (r-mid)*setv[p]%MOD;
        sum2[p*2] = sum1[p*2]*setv[p]%MOD;
        sum2[p*2+1] = sum1[p*2+1]*setv[p]%MOD;
        sum3[p*2] = sum2[p*2] *setv[p] %MOD;
        sum3[p*2+1] = sum2[p*2+1]*setv[p]%MOD;
        setv[p] = 0;
    }
    if(addv[p]||mulv[p]!=1){
        addv[p*2] = (addv[p*2]*mulv[p]+addv[p])%MOD;
        addv[p*2+1] = (addv[p*2+1]*mulv[p]+addv[p])%MOD;
        mulv[p*2] = mulv[p*2]*mulv[p]%MOD;
        mulv[p*2+1] = mulv[p*2+1]*mulv[p]%MOD;

        int _sum1 , _sum2 , _sum3 ;

        _sum1 = ( sum1[p << 1] * mulv[p] % MOD + addv[p] * ( mid - l + 1 ) % MOD ) % MOD ;
        _sum2 = ( mulv[p] * mulv[p] % MOD * sum2[p << 1] % MOD
            + 2 * addv[p] % MOD * mulv[p] % MOD * sum1[p << 1] % MOD
            + addv[p] * addv[p] % MOD * ( mid - l + 1 ) % MOD ) % MOD ;
        _sum3 = ( mulv[p] * mulv[p] % MOD * mulv[p] % MOD * sum3[p << 1] % MOD
            + 3 * mulv[p] % MOD * mulv[p] % MOD * addv[p] % MOD * sum2[p << 1] % MOD
            + 3 * mulv[p] % MOD * addv[p] % MOD * addv[p] % MOD * sum1[p << 1] % MOD
            + addv[p] * addv[p] % MOD * addv[p] % MOD * ( mid - l + 1 ) % MOD ) % MOD ;

        sum1[p*2] = _sum1;
        sum2[p*2] = _sum2;
        sum3[p*2] = _sum3;

        _sum1 = ( sum1[p << 1|1] * mulv[p] % MOD + addv[p] * ( r-mid ) % MOD ) % MOD ;
        _sum2 = ( mulv[p] * mulv[p] % MOD * sum2[p << 1|1] % MOD
            + 2 * addv[p] % MOD * mulv[p] % MOD * sum1[p << 1|1] % MOD
            + addv[p] * addv[p] % MOD * ( r-mid ) % MOD ) % MOD ;
        _sum3 = ( mulv[p] * mulv[p] % MOD * mulv[p] % MOD * sum3[p << 1|1] % MOD
            + 3 * mulv[p] % MOD * mulv[p] % MOD * addv[p] % MOD * sum2[p << 1|1] % MOD
            + 3 * mulv[p] % MOD * addv[p] % MOD * addv[p] % MOD * sum1[p << 1|1] % MOD
            + addv[p] * addv[p] % MOD * addv[p] % MOD * ( r-mid ) % MOD ) % MOD ;

        sum1[p*2+1] = _sum1;
        sum2[p*2+1] = _sum2;
        sum3[p*2+1] = _sum3;

        addv[p] = 0;
        mulv[p] = 1;
    }
}
void build (int p,int l,int r){
    sum1[p] = sum2[p] = sum3[p] = 0;
    addv[p] = setv[p] = 0;
    mulv[p] = 1;
    if(l==r) return;
    int mid = (l+r)>>1;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
}
void change ( int ch , int p , int l , int r , int x , int y , int v ) {
    if ( x <= l && r <= y ) {
        int len = r - l + 1 ;
        if ( 1 == ch ) {
            addv[p] = ( addv[p] + v ) % MOD ;
            int _sum1 , _sum2 , _sum3 ;
            _sum1 = ( sum1[p] + v * len ) % MOD ;
            _sum2 = ( sum2[p] + 2 * sum1[p] % MOD * v % MOD + v * v % MOD * len % MOD ) % MOD ;
            _sum3 = ( sum3[p] + 3 * v % MOD * v % MOD * sum1[p] % MOD
                + 3 * v % MOD * sum2[p] % MOD + v * v % MOD * v % MOD * len % MOD ) % MOD ;
            sum1[p] = _sum1 ;
            sum2[p] = _sum2 ;
            sum3[p] = _sum3 ;
        }
        if ( 2 == ch ) {
            mulv[p] = mulv[p] * v % MOD ;
            addv[p] = addv[p] * v % MOD ;
            sum1[p] = sum1[p] * v % MOD ;
            sum2[p] = sum2[p] * v % MOD * v % MOD ;
            sum3[p] = sum3[p] * v % MOD * v % MOD * v % MOD ;
        }
        if ( 3 == ch ) {
            setv[p] = v ;
            addv[p] = 0 ;
            mulv[p] = 1 ;
            sum1[p] = v * len % MOD ;
            sum2[p] = v * sum1[p] % MOD ;
            sum3[p] = v * sum2[p] % MOD ;
        }
        return ;
    }
    down(p,l,r);
    int mid = ( l + r ) >> 1 ;
    if ( x <= mid ) change(ch,p*2,l,mid,x,y,v);
    if ( mid <  y ) change(ch,p*2+1,mid+1,r,x,y,v);
    up ( p ) ;
}
int query(int p,int l,int r,int x,int y,int d){
    if(x<=l && r<=y){
        if(d==1) return sum1[p]%MOD;
        if(d==2) return sum2[p]%MOD;
        if(d==3) return sum3[p]%MOD;
    }
    int mid = (l+r)>>1;
    down(p,l,r);
    int ans = 0;
    if(x<=mid) ans = (ans+query(p*2,l,mid,x,y,d))%MOD;
    if(y>mid) ans = (ans+query(p*2+1,mid+1,r,x,y,d))%MOD;
    return (ans%MOD);
}
int main(){
    int n,m,choose;
    while(~scanf("%d%d",&n,&m)&&(n|m)){
        build(1,1,n);
        int b,c,d;
        while(m--){
            scanf("%d%d%d%d",&choose,&b,&c,&d);
            if(choose==4){
                printf("%d\n",query(1,1,n,b,c,d)%MOD);
            }
            else {
                change(choose,1,1,n,b,c,d);
            }
        }
    }
    return 0;
}

HDU 4578 线段树

Transformation

猜你喜欢