jzoj 1951.【2011集训队出题】布娃娃 平衡树

Description

Input

　　输入为标准输入。 　　输入的第一行有一个整数n，代表布娃娃的个数。 　　输入的第二行有16个用空格隔开的整数，分别代表Padd, Pfirst, Pmod, Pprod, Cadd, Cfirst, Cmod, Cprod, Ladd, Lfirst, Lmod, Lprod, Radd, Rfirst, Rmod, Rprod。

Output

　　输出为标准输出。 　　输出一个整数，代表所有布娃娃谜团答案的和除以19921228的余数。

Sample Input

3

2 3 4 3 1 4 5 2 3 6 9 1 1 2 3 4

Sample Output

4

Data Constraint

对于20%的数据1<=n<=1,000。

对于40%的数据1<=n<=6,000。

对于100%的数据1<=n<=100,000，16个参数均为1到100,000,000中的整数。

大意：
有i个区间，每个区间[l,r]有一个权值c，对于i个询问i,p,问所有包含p的区间中，权值第i大的的权值是多少，输出所有答案的和并取模。

分析：
我们可以枚举一数轴上的点，记录该点的所有区间，然后求值。显然只有临界点li,ri,以及询问点pi有用，可以排序离散一下。

然后我们这么想，对于一个li,相当于加入往数组里加如一个数ci，ri相当与把对应的ci删掉，p则求现在数组里的第i大数，可以证明，数组里的区间都符合包含p。

显然不可能直接数组维护，肯定是一种数据结构。考虑到要加入，查询第k大，删除，可以使用权值线段树（树状数组），以及平衡树，于是我去打了一个平衡树。

一开始发现自己构造数据就出了问题，然后又是删除打错……调了挺久的。

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#define fo(i,a,b) for (int i = a;i <= b;i ++)

using namespace std;
typedef long long LL;

const int maxn = 100005;
const int P = 19921228;
int N,M,tot,ans,T;
int padd,pfirst,pmod,pprod,cadd,cfirst,cmod,cprod;
int ladd,lfirst,lmod,lprod,radd,rfirst,rmod,rprod;
LL p[maxn],c[maxn],l[maxn],r[maxn];
int left[maxn],right[maxn],size[maxn],key[maxn];

struct Node
{
    int x,z;
    char y;
    Node(){}
    Node(int _x,char _y,int _z){x = _x, y = _y,z = _z;}
}A[maxn*3];

inline bool cmp(const Node &a,const Node &b)
{
    return ((a.x < b.x) || (a.x == b.x && a.y < b.y));
}

void left_rotate(int &t)
{
    int k = right[t];
    right[t] = left[k];
    left[k] = t;
    size[k] = size[t];
    size[t] = size[left[t]] + size[right[t]] + 1;
    t = k;
}

void right_rotate(int &t)
{
    int k = left[t];
    left[t] = right[k];
    right[k] = t;
    size[k] = size[t];
    size[t] = size[left[t]] + size[right[t]] + 1;
    t = k;
}

void maintain(int &t,bool flag)
{
    if (!flag)
    {
        if (size[left[left[t]]] > size[right[t]])
            right_rotate(t);
        else if (size[right[left[t]]] > size[right[t]])
            left_rotate(left[t]), right_rotate(t);
        else return;
    } else
    {
        if (size[right[right[t]]] > size[left[t]])
            left_rotate(t);
        else if (size[left[right[t]]] > size[left[t]])
            right_rotate(right[t]), left_rotate(t);
        else return;
    }
    maintain(left[t],0);
    maintain(right[t],1);
    maintain(t,0);
    maintain(t,1);
}

void Insert(int &t,int v)
{
    if (!t)
    {
        t = ++ tot;
        left[t] = right[t] = 0;
        size[t] = 1;
        key[t] = v;
        return;
    }
    size[t] ++;
    if (v >= key[t]) Insert(right[t],v);
    else Insert(left[t],v);
    maintain(t,v >= key[t]);
}

int Delete(int &t,int v)
{
    size[t] --;
    if ((v == key[t]) || (v < key[t] && !left[t]) || (v > key[t] && !right[t]))
    {
        int ret = key[t];
        if (!left[t] || !right[t]) t = left[t] + right[t];
        else key[t] = Delete(left[t],key[t]+1);
        return ret;
    } else
    {
        if (v < key[t]) return Delete(left[t],v);
        else return Delete(right[t],v);
    }
}

int Select(int t,int k)
{
    if (k == size[left[t]]+1) return key[t];
    if (k <= size[left[t]]) return Select(left[t],k);
    else return Select(right[t],k-size[left[t]]-1);
}

void Construct()
{
    p[1] = pfirst % pmod;
    fo(i,2,N) p[i] = (LL)(p[i-1] * pprod % pmod + (LL)(padd + i) % pmod) % pmod;
    c[1] = cfirst % cmod;
    fo(i,2,N) c[i] = (LL)(c[i-1] * cprod % cmod + (LL)(cadd + i) % cmod) % cmod;
    l[1] = lfirst % lmod;
    fo(i,2,N) l[i] = (LL)(l[i-1] * lprod % lmod + (LL)(ladd + i) % lmod) % lmod;
    r[1] = rfirst % rmod;
    fo(i,2,N) r[i] = (LL)(r[i-1] * rprod % rmod + (LL)(radd + i) % rmod) % rmod;
    fo(i,1,N) if (l[i] > r[i]) swap(l[i],r[i]);
}

void Initialize()
{
    scanf("%d",&N);
    scanf("%d%d%d%d",&padd,&pfirst,&pmod,&pprod);
    scanf("%d%d%d%d",&cadd,&cfirst,&cmod,&cprod);
    scanf("%d%d%d%d",&ladd,&lfirst,&lmod,&lprod);
    scanf("%d%d%d%d",&radd,&rfirst,&rmod,&rprod);
    Construct();
    fo(i,1,N)
    {
        A[++M] = Node(l[i],'L',c[i]);
        A[++M] = Node(r[i],'R',c[i]);
        A[++M] = Node(p[i],'P',i);
    }
}

void Work()
{
    sort(A+1,A+1+M,cmp);
    fo(i,1,M)
    {
        if (A[i].y == 'L') Insert(T,A[i].z);
        if (A[i].y == 'R') Delete(T,A[i].z);
        if (A[i].y == 'P')
            if (size[T] >= A[i].z) ans = (ans + Select(T,size[T]-A[i].z+1)) % P;
    }
    printf("%d\n",ans);
}

int main()
{
    Initialize();
    Work();
}