UVALive6443_Alien Abduction Again

题意为给你若干个三次函数，以及每一个函数所分布的区间，由于每个函数的所有的系数都是整数，所以最后的函数在整数点处的值也是整数。

现在每次可以插入函数或者询问区间，现在要求每次询问区间后，所有的函数在这个区间的函数值的和。

其实一个函数在这个区间的分布，就可以看成是四个函数分别在这个区间分布了。

这样对于单一的函数，我们可以用线段树来维护了，每次查询和更新的操作都是在O(log(n))的复杂度内实现的。

注意不要写挫，另注：UVA的服务器真的很快，果断赞啊。

#include <iostream>
#include <cstdio>
#include <cstring>
#define maxn 1000100
#define M 1000000007
typedef long long ll;
using namespace std;

ll f[][maxn],ans;
ll n,m,l0,r0,x3,x2,x1,x0,l1,R1,R2;
char s[];

void mod(ll& ppp) { if (ppp<) ppp+=M; }

ll get(ll id ,ll pos)
{
    if (pos<) return ;
    return f[id][pos];
}

struct tree{
    ll col[*maxn+],sum[*maxn+];
    void PushDown(ll rt,ll l,ll r,ll id)
    {
        if (col[rt]==) return;
        ll mid=(l+r)/;
        sum[*rt]+=col[rt]*(f[id][mid]-get(id,l-));
        sum[*rt+]+=col[rt]*(f[id][r]-get(id,mid));
        sum[*rt]%=M,sum[*rt+]%=M;
        col[*rt]+=col[rt],col[*rt+]+=col[rt];
        col[*rt]%=M,col[*rt+]%=M;
        mod(col[*rt]),mod(col[*rt+]);
        mod(sum[*rt]),mod(sum[*rt+]);
        col[rt]=;
    }

    void update(ll rt,ll l,ll r,ll L,ll R,ll id,ll v)
    {
        if (L<=l && R>=r)
        {
            col[rt]+=v;
            sum[rt]+=v*(f[id][r]-get(id,l-));
            col[rt]%=M,sum[rt]%=M;
            mod(col[rt]),mod(sum[rt]);
            return;
        }
        PushDown(rt,l,r,id);
        ll mid=(l+r)>>;
        if (L<=mid) update(*rt,l,mid,L,R,id,v);
        if (R> mid) update(*rt+,mid+,r,L,R,id,v);
        sum[rt]=(sum[*rt]+sum[*rt+])%M;
        mod(sum[rt]);
    }

    ll query(ll rt,ll l,ll r,ll L,ll R,ll id)
    {
        if (L<=l && R>=r) return sum[rt];
        PushDown(rt,l,r,id);
        ll mid=(l+r)/;
        ll tot=;
        if (L<=mid) tot=query(*rt,l,mid,L,R,id);
        if (R> mid) tot+=query(*rt+,mid+,r,L,R,id);
        return tot%M;
    }
}t[];

ll power(ll x,ll y)
{
    ll tot=;
    while (y)
    {
        if (y&) tot=(tot*x)%M;
        x=(x*x)%M;
        y>>=;
    }
    return tot;
}

void init_f()
{
    f[][]=;
    for (ll i=; i<; i++)
    {
        for (ll j=; j<maxn; j++)
            f[i][j]=(f[i][j-]+power(j,i))%M;
    }
}

void init_tree()
{
    for (ll i=; i<; i++)
    {
        memset(t[i].col,,sizeof t[i].col);
        memset(t[i].sum,,sizeof t[i].sum);
    }
}

int main()
{
    init_f();
    ll T,cas=;
    scanf("%lld",&T);
    while (T--)
    {
        printf("Case #%lld:\n",++cas);
        init_tree();
        scanf("%lld",&n);
        while (n--)
        {
            scanf("%s",s);
            if (s[]=='p')
            {
                scanf("%lld%lld%lld%lld%lld%lld",&l0,&r0,&x3,&x2,&x1,&x0);
                t[].update(,,maxn,l0,r0,,x3);
                t[].update(,,maxn,l0,r0,,x2);
                t[].update(,,maxn,l0,r0,,x1);
                t[].update(,,maxn,l0,r0,,x0);
            }
            else if (s[]=='t')
            {
                scanf("%lld%lld%lld%lld%lld%lld",&l0,&r0,&x3,&x2,&x1,&x0);
                ans=;
                ans+=t[].query(,,maxn,l0,r0,),mod(ans);
                ans%=M;
                ans+=t[].query(,,maxn,l0,r0,),mod(ans);
                ans%=M;
                ans+=t[].query(,,maxn,l0,r0,),mod(ans);
                ans%=M;
                ans+=t[].query(,,maxn,l0,r0,),mod(ans);
                ans%=M;
                printf("%lld\n",ans);
                R1=(ans*l0)%;
                R2=(ans*r0)%;
                l0=min(R1,R2),r0=max(R1,R2);
                t[].update(,,maxn,l0,r0,,x3);
                t[].update(,,maxn,l0,r0,,x2);
                t[].update(,,maxn,l0,r0,,x1);
                t[].update(,,maxn,l0,r0,,x0);
            }
        }
    }
    return ;
}