bzoj 3833 [Poi2014]Solar lamps 树套树 splay

首先由于所有灯的角度都是一样的，所以可以用坐标转换把一个点和点的覆盖区域转成平面直角坐标系里的点和一个点右上的区域。
然后这个问题可以转化为平面上一坨点，设一个点的答案为ans，求一个点左下的点中ans第k小的值。
树套树+二分？
这题$nlog^2$ 都卡得要死你TM跟我讲这个？

由于求的东西天生离线所以我们可以排序消掉一维坐标。
然后就是带修求前缀第k大。
树状数组套主席树？
这题$nlog$ 内存都卡的要死你TM跟我讲这个？

那么只能套一个平衡树。
不过如果把坐标套在外面还是直接$nlog^3$ 手动再见。
不过如果把ans套在外面可以直接在外层树上二分，里层套一个平衡树这样就可以$nlog^2$ 啦。
不过卡常+卡内存真是蛋疼啊啊啊啊。。。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define N 200010
#define M 4600000
#define ls l,mid,now<<1
#define rs mid+1,r,now<<1|1
#define which(x) ch[fa[x]][1]==x
#define pushup(x) size[x]=size[ch[x][0]]+size[ch[x][1]]+sum[x]
int n,type,cnt,t,tmp;
ll X[N],Y[N],X1[N],Y1[N],K[N];
int ch[M][2],val[M],size[M],fa[M],sum[M];
int pos[N],ans[N];
int cmp(int x,int y)
{
    if(X[x]!=X[y])return X[x]<X[y];
    return Y[x]<Y[y];
}
struct splay_tree
{
    int l,r,v1;
    void init(int &x)
    {
        x=++cnt;val[x]=0;size[x]=2;sum[x]=1;
        val[ch[x][1]=++cnt]=n+1;
        size[ch[x][1]]=1;fa[ch[x][1]]=x;
        sum[ch[x][1]]=1;
    }
    void pre(int x)
    {
        if(!x)return;
        if(val[x]<v1)
            l=x,pre(ch[x][1]);
        else pre(ch[x][0]);
    }
    void nex(int x)
    {
        if(!x)return;
        if(val[x]>v1)
            r=x,nex(ch[x][0]);
        else nex(ch[x][1]);
    }
    int find(int x)
    {
        if(!x)return 0;
        if(val[x]<=v1)
            return size[ch[x][0]]+sum[x]+find(ch[x][1]);
        return find(ch[x][0]);
    }
    void rotate(int x)
    {
        int y=fa[x],k=which(x);
        ch[y][k]=ch[x][k^1];
        ch[x][k^1]=y;
        ch[fa[y]][which(y)]=x;

        fa[x]=fa[y];fa[y]=x;
        fa[ch[y][k]]=y;
        pushup(y);pushup(x);
    }
    void splay(int x,int y,int &root)
    {       
        while(fa[x]!=y)
        {
            int t=fa[x];
            if(fa[t]==y)rotate(x);
            else
            {
                if(which(x)^which(t))rotate(x);
                else rotate(t);
                rotate(x);
            }
        }
        if(!y)root=x;
    }
    int query(int &x,int v)
    {
        v1=v;
        if(type)
        {
            pre(x);splay(l,0,x);
            nex(x);splay(r,l,x);
            return size[ch[r][0]];
        }
        return find(x)-1;
    }
    void insert(int &x,int v)
    {
        int tar=x,t1=x;
        while(t1)
        {
            if(val[t1]==v)
            {
                sum[t1]++;splay(t1,0,x);
                return;
            }
            if(val[t1]<v)tar=t1,t1=ch[t1][1];
            else tar=t1,t1=ch[t1][0];
        }
        ch[tar][v>val[tar]]=++cnt;
        fa[cnt]=tar;val[cnt]=v;
        sum[cnt]=size[cnt]=1;
        splay(cnt,0,x);
    }
}tr2;
struct seg_tree
{       
    int root[N<<2];
    void build(int l,int r,int now)
    {
        tr2.init(root[now]);
        if(l==r)return;
        int mid=(l+r)>>1;
        build(ls);build(rs);
    }
    int query(int l,int r,int now,int k)
    {
        if(l==r)return l;
        int t1=tr2.query(root[now<<1],Y[t]);
        int mid=(l+r)>>1;
        if(t1>=k)return query(ls,k);
        else return query(rs,k-t1);
    }
    void insert(int l,int r,int now,int v)
    {
        tr2.insert(root[now],v);
        if(l==r)return;
        int mid=(l+r)>>1;
        if(ans[t]<=mid)insert(ls,v);
        else insert(rs,v);
    }
}tr1;
char getc()
{
    static const int LEN = 4096;
    static char buf[LEN],*S=buf,*T=buf;
    if(S == T)
    {
        T = (S=buf)+fread(buf,1,LEN,stdin);
        if(S == T)return EOF;
    }
    return *S++;
}
int read()
{
    static char ch;
    static int D,type;
    type=0;
    while(!isdigit(ch=getc()))type|=(ch=='-');
    for(D=ch-'0'; isdigit(ch=getc());)
        D=(D<<3)+(D<<1)+(ch-'0');
    return type ? -D:D;
}
void print(int x)
{
    if(!x)return;
    print(x/10);
    putchar(x%10+'0');
}
int main()
{
    n=read();
    ll x1,x2,y1,y2;
    x1=read();y1=read();x2=read();y2=read();
    if(type=(x1*y2==x2*y1))x2=-y1,y2=x1;
    int tt= x1*y2-x2*y1>0 ? -1:1; 
    for(int i=1,x,y;i<=n;i++)
    {
        x=read();y=read();
        X1[i]=X[i]=(x2*y-y2*x)*tt;
        Y1[i]=Y[i]=(y1*x-x1*y)*tt;
    }
    sort(X1+1,X1+1+n);
    sort(Y1+1,Y1+1+n);
    int sx=unique(X1+1,X1+1+n)-X1-1;
    int sy=unique(Y1+1,Y1+1+n)-Y1-1;
    for(int i=1;i<=n;i++)
    {
        K[i]=read();
        X[i]=lower_bound(X1+1,X1+1+sx,X[i])-X1;
        Y[i]=lower_bound(Y1+1,Y1+1+sy,Y[i])-Y1;
        pos[i]=i;
    }
    sort(pos+1,pos+1+n,cmp);
    tr1.build(1,n,1);
    for(int i=1;i<=n;i++)
    {
        t=pos[i];
        if(tr2.query(tr1.root[1],Y[t])<K[t])ans[t]=t;
        else 
        {
            ans[t]=tr1.query(1,n,1,K[t]);
            ans[t]=min(ans[t],t);
        }
        tr1.insert(1,n,1,Y[t]);
    }
    for(int i=1;i<n;i++)
        print(ans[i]),putchar(' ');
    print(ans[n]);
    return 0;
}