HDU4578 Transformation(裸线段树)

//先处理乘再处理加 
#include <cstdio>
using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mlson rt<<1
#define mrson rt<<1|1

const int maxn = 100005;
const int mod =  10007;

int n,m;
int sum[maxn<<2][4];
int len[maxn<<2];

struct node
{ 
  int la1,la2;   
}flag[maxn<<2];

void build(int l,int r,int rt)
{
    len[rt]=r-l+1;
    flag[rt].la1=0;
    flag[rt].la2=1;
    for(int i=0;i<4;++i) sum[rt][i]=0;
    if(l==r) return;
    int m=(l+r)>>1;
    build(lson);
    build(rson);
}

void push_up(int rt)
{
    for(int i=1;i<=3;++i) 
        sum[rt][i]=(sum[mlson][i]+sum[mrson][i])%mod;
}

void push_down(int rt)
{
        int c;  
        if(flag[rt].la2!=1)
        {
            c=flag[rt].la2;
            flag[mlson].la1=(flag[mlson].la1*c)%mod;
            flag[mrson].la1=(flag[mrson].la1*c)%mod;
            flag[mlson].la2=(flag[mlson].la2*c)%mod;
            flag[mrson].la2=(flag[mrson].la2*c)%mod;
            int k=c;
            for(int i=1;i<=3;++i)
            {
                sum[mlson][i]=(k*sum[mlson][i])%mod;
                sum[mrson][i]=(k*sum[mrson][i])%mod;
                k=(k*c)%mod;
            }
            flag[rt].la2=1;
        }
         if(flag[rt].la1!=0)
        {
            flag[mlson].la1=(flag[mlson].la1+flag[rt].la1)%mod;
            flag[mrson].la1=(flag[mrson].la1+flag[rt].la1)%mod;
            c=flag[rt].la1;
            sum[mlson][3]=(sum[mlson][3]+3*c*sum[mlson][2]+(3*c*c)%mod*sum[mlson][1]+(c*c)%mod*c%mod*len[mlson])%mod;
            sum[mlson][2]=(sum[mlson][2]+(c*c)%mod*len[mlson]+2*c*sum[mlson][1])%mod;
            sum[mlson][1]=(sum[mlson][1]+c*len[mlson])%mod;
            sum[mrson][3]=(sum[mrson][3]+3*c*sum[mrson][2]+(3*c*c)%mod*sum[mrson][1]+(c*c)%mod*c%mod*len[mrson])%mod;
            sum[mrson][2]=(sum[mrson][2]+(c*c)%mod*len[mrson]+2*c*sum[mrson][1])%mod;
            sum[mrson][1]=(sum[mrson][1]+c*len[mrson])%mod;
            flag[rt].la1=0;
        }
}

void update(int op,int c,int L,int R,int l,int r,int rt)
{
    if(L<=l&&R>=r)
    {
        if(op==1) 
        {   
            flag[rt].la1=(flag[rt].la1+c)%mod;
            sum[rt][3]=(sum[rt][3]+3*c*sum[rt][2]+(3*c*c)%mod*sum[rt][1]+(c*c)%mod*c%mod*len[rt])%mod;
            sum[rt][2]=(sum[rt][2]+(c*c)%mod*len[rt]+2*c*sum[rt][1])%mod;
            sum[rt][1]=(sum[rt][1]+c*len[rt])%mod;
        }
        if(op==2)
        {
            flag[rt].la1=(flag[rt].la1*c)%mod;
            flag[rt].la2=(flag[rt].la2*c)%mod;
            int k=c;
            for(int i=1;i<=3;++i)
            {
                sum[rt][i]=(k*sum[rt][i])%mod;
                k=(k*c)%mod;
            }
        }
        if(op==3)
        {
            flag[rt].la1=c;
            flag[rt].la2=0;
            int k=c;
            for(int i=1;i<=3;++i)
            {
                sum[rt][i]=(k*len[rt])%mod;
                k=(k*c)%mod;
            }
        }
        return;
    }
    push_down(rt);
    int m=(l+r)>>1;
    if(L<=m) update(op,c,L,R,lson);
    if(R>m) update(op,c,L,R,rson);
    push_up(rt);
}

int query(int p,int L,int R,int l,int r,int rt)
{
    if(L<=l&&R>=r)
    {
        return sum[rt][p];
    }
    push_down(rt);
    int res=0;
    int m=(l+r)>>1;
    if(L<=m) res=(res+query(p,L,R,lson))%mod;
    if(R>m)  res=(res+query(p,L,R,rson))%mod;
    return res%mod;
}

int main()
{
    int op,x,y,c;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0) break;
        build(1,n,1);
        for(int i=1;i<=m;++i)
        {
            scanf("%d%d%d%d",&op,&x,&y,&c);
            if(op==4) 
            {
                printf("%d\n",query(c,x,y,1,n,1));
            }
            else
            {
                update(op,c,x,y,1,n,1);
            }
        }
    }
    return 0;
}