K - Transformation-hdu 4578（多操作混合区间更新）线段树

题意：有四种操作

1，  区间 [l, r] 的值都加上 C

2，  区间 [l, r] 的值都乘上 C

3，  区间 [l, r] 的值都变为C

4，  求区间 [l, r]所有数的p次方的和

分析：是比较麻烦的区间操作，设计四种操作，更新的时候无法更新到底部，不过仔细思考可以想到这都是对区间进行的操作，所以会造成一部分的区间值相等，所以只需要更新到相等区间部分就行了，而且注意有第三种操作的时候，第二和第一种操作可以去掉，操作的优先性是3>2>1,。

WA了一次，因为操作三进行的的时候没有把前两种操作去除

*************************************************************************

#include<algorithm>
#include<stdio.h>
using namespace std;

#define lson u<<1
#define rson u<<1|1

const int MAXN = 1e5+5;
const int mod = 1e4+7;

struct node
{///num表示这个区间的数（区间里面的值都相等，不相等时候为0），mul记录乘的次数，add表示需要加的数
    int l, r, num, mul, add, cover;///cover 等于0的时候表示区间的值不相同，等于1表示区间进行覆盖操作，等于2表示区间的值相同
    int m(){return (l+r)>>1;}
    int len(){return r-l+1;}
}a[MAXN<<2];

void Up(int u)
{
    if( a[lson].cover && a[rson].cover )
    if( a[lson].num == a[rson].num )
        a[u].num = a[lson].num, a[u].cover = 2;
}
void Down(int u)
{
    if(a[u].l != a[u].r)
    {
        if( a[u].cover == 1 )
        {
            a[lson].cover = a[rson].cover = 1;
            a[lson].num = a[rson].num = a[u].num;
            a[lson].add = a[rson].add = 0;
            a[lson].mul = a[rson].mul = 1;

            a[u].cover = 2, a[u].mul = 1, a[u].add = 0;
        }
        if( a[u].mul > 1 )
        {
            (a[lson].mul *= a[u].mul)%=mod, (a[rson].mul *= a[u].mul)%=mod;
            (a[lson].num *= a[u].mul)%=mod, (a[rson].num *= a[u].mul)%=mod;
            (a[lson].add *= a[u].mul)%=mod, (a[rson].add *= a[u].mul)%=mod;

            a[u].mul = 1;
        }

        if( a[u].add )
        {
            (a[lson].add += a[u].add)%=mod, (a[rson].add += a[u].add)%=mod;
            (a[lson].num += a[u].add)%=mod, (a[rson].num += a[u].add)%=mod;

            a[u].add = 0;
        }
    }
}
void Build(int u, int l, int r)
{
    a[u].add = 0, a[u].cover = 2, a[u].mul = 1;
    a[u].num = 0, a[u].l = l, a[u].r = r;

    if(l == r)
        return ;

    Build(lson, l, a[u].m());
    Build(rson, a[u].m()+1, r);
}
void Insert(int u, int l, int r, int op, int val)
{
    if(a[u].l == l && a[u].r == r && a[u].cover)
    {
        if(op == 3)
            a[u].add=0, a[u].cover = 1, a[u].mul = 1, a[u].num = val;
        else if(op == 2)
            (a[u].mul *= val)%=mod, (a[u].add *= val)%=mod, (a[u].num *= val)%=mod;
        else
            (a[u].add += val)%=mod, (a[u].num += val)%=mod;

        return ;
    }

    Down(u); a[u].cover = 0;

    if(r <= a[u].m())
        Insert(lson, l, r, op, val);
    else if(l > a[u].m())
        Insert(rson, l, r, op, val);
    else
    {
        Insert(lson, l, a[u].m(), op, val);
        Insert(rson, a[u].m()+1, r, op, val);
    }

    Up(u);
}
int  Query(int u, int l, int r, int p)
{

    if(a[u].l == l && a[u].r == r && a[u].cover)
    {
        int ans = 1;
        while(p--) (ans *= a[u].num)%=mod;
        ans = (ans * a[u].len())%mod;

        return ans;
    }

    Down(u);

    if(r <= a[u].m())
        return Query(lson, l, r, p);
    else if(l > a[u].m())
        return Query(rson, l, r, p);
    else
    {
        int lsum = Query(lson, l, a[u].m(), p);
        int rsum = Query(rson, a[u].m()+1, r, p);

        return (lsum+rsum) % mod;
    }
}

int  main()
{
    int N, M;

    while(scanf("%d%d", &N, &M), N+M)
    {
        int u, v, op, c;

        Build(1, 1, N);

        while(M--)
        {
            scanf("%d%d%d%d", &op, &u, &v, &c);

            if(op != 4)
                Insert(1, u, v, op, c);
            else
                printf("%d\n", Query(1, u, v, c));
        }
    }

    return 0;
}