BZOJ3932: [CQOI2015]任务查询系统 可持久化线段树

题意：一个长度为n时间轴，m个带权值的任务，每个任务是一段连续时间，n个询问，每次询问某时间正在进行的任务中前k大的权值之和。
数据规模100000。
每个时间创建一棵可持久化线段树，任务拆成一个加入和一个删除，建好一排树之后每次去里面查询就好。
叶子节点需要特判，这个试了很多方法也没法避免，况且这题里可能一个叶子中有多个，只需要取一部分，也就是sum/size*k。
然后好像真没什么特别的了。。。

#include<cstdio>
#include<algorithm>
#define gm 100002
using namespace std;
int n,m;
struct node
{
    size_t sz;
    long long sum;
    node *l,*r;
    char c;
    node():sz(),sum(),l(),r(),c(){}
    node(const node& x){*this=x;if(l) c|=1;if(r) c|=2;}
    inline void* operator new (size_t)
    {
        static node *s,*t;
        if(s==t) s=(node*)malloc(sizeof(node)<<16),t=s+(1<<16);
        return s++;
    }
};
struct tree
{
    node *rt;
    tree():rt(new node){}
    tree(const tree& ano):rt(new node(*ano.rt)){}
    inline void cast(int p,int v,int plus)
    {
        int l=1,r=m,mid;
        node *now=rt;
        while(l!=r)
        {
            now->sz+=plus;
            now->sum+=v;
            mid=l+r>>1;
            if(p<=mid)
            {
                if(!now->l) now->l=new node;
                else if(now->c&1) now->l=new node(*now->l),now->c^=1;
                now=now->l;
                r=mid;
            }
            else
            {
                if(!now->r) now->r=new node;
                else if(now->c&2) now->r=new node(*now->r),now->c^=2;
                now=now->r;
                l=mid+1;
            }
        }
        now->sz+=plus;
        now->sum+=v;
    }
    inline void insert(int pos,int val)
    {
        cast(pos,val,1);
    }
    inline void erase(int pos,int val)
    {
        cast(pos,-val,-1);
    }
    inline long long find_by_order(int k)
    {
        long long res=0;
        node *now=rt;
        while(now&&now->sz&&k)
        {
            if(!now->l&&!now->r)
            {
                res+=now->sum/now->sz*k;
                break;
            }
            size_t left=now->l?now->l->sz:0;
            if(left<=k)
            {
                res+=left?now->l->sum:0;
                k-=left;
                now=now->r;
            }
            else now=now->l;
        }
        return res;
    }
}*tm[gm];
struct event
{
    bool erase;
    int when;
    int val;
    bool operator < (const event &ano) const
    {
        return when<ano.when;
    }
}eve[gm<<1];
int top=0;
int br[gm];
long long pre=1;
int main()
{
    scanf("%d%d",&m,&n);
    for(int i=1,s,e,p;i<=m;++i)
    {
        scanf("%d%d%d",&s,&e,&p);
        eve[++top]=(event){0,s,p};
        eve[++top]=(event){1,e+1,p};
        br[i]=p;
    }
    sort(br+1,br+m+1);
    int* cr=unique(br+1,br+m+1);
    sort(eve+1,eve+top+1);
    tm[0]=new tree;
    for(int i=1,j=1;i<=n;++i)
    {
        tm[i]=new tree(*tm[i-1]);
        for(;j<=top&&eve[j].when<=i;++j)
        {
            if(eve[j].erase)
            tm[i]->erase(lower_bound(br,cr,eve[j].val)-br,eve[j].val);
            else
            tm[i]->insert(lower_bound(br,cr,eve[j].val)-br,eve[j].val);
        }
    }
    for(int i=1,x,a,b,c,k;i<=n;++i)
    {
        scanf("%d%d%d%d",&x,&a,&b,&c);
        k=(a*pre+b)%c+1;
        printf("%lld\n",pre=tm[x]->find_by_order(k));
    }
    return 0;
}