Bzoj4237 cdq分治+树状数组+单调栈

二维平面在某区域内点的问题，要么树套树，kdtree，要么就是cdq分治了。
然而这题树套树和kdtree都不是很好搞的样子，于是我们就只能cdq分治了。
首先把点按照横坐标x排序，在每一层我们需要算出右边的点和左边的点组成的点对的贡献。
我们先把这些点按照纵坐标降序排列。
考虑我们按照纵坐标从大到小扫描到的每一个点。
如果他是右边的点，需要横坐标比他上面的点大才能直接加入，否则他会挡住其右上方的点，使其无法成为答案。
于是单调栈维护一下就好了。
对于左边的点，他能构成答案的纵坐标区间，一定要在他本身纵坐标以上且其右上方的点的最低纵坐标以下才行。
所以这个，我们可以用树状数组以横坐标x为下标维护纵坐标y的后缀min(什么你说树状数组只能维护前缀？后缀坐标转化为n-x[i]+1不就成前缀了？)。
然后就是查询，由于我懒得考虑二分的细节了，所以又用另外一个树状数组维护右面的点在纵坐标y上的区间和。
详见下面的图。

注意这题保证横纵坐标没有重复，所以对拍写maker的时候注意不要出重复坐标，否则网上的代码谁跟谁跑的都不一样，别问我怎么知道的。
然后给一组数据：
5
3 1
1 3
2 5
4 2
5 4
答案是4。
最后上代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#define lli long long int
using namespace std;
const int maxn=2e5+1e2;
const int inf=0x3f3f3f3f;

struct Node {
    int x,y;
    friend bool operator < (const Node &a,const Node &b) {
        return a.x < b.x;
    }
}ns[maxn];

int x[maxn],y[maxn];
int id[maxn],stk[maxn],top;
int n;
lli ans;

struct BinaryIndexTreeA {
    int dat[maxn];
    #define lowbit(x) (x&-x)
    BinaryIndexTreeA() { memset(dat,0x3f,sizeof(dat)); }
    inline void update(int pos,int x) {
        while( pos <= n ) dat[pos] = min( dat[pos] , x ) , pos += lowbit(pos);
    }
    inline int query(int pos) {
        int ret = inf;
        while( pos ) ret = min( ret , dat[pos] ) , pos -= lowbit(pos);
        return ret;
    }
    inline void reset(int pos) {
        while( pos <= n ) dat[pos] = inf , pos += lowbit(pos);
    }
}bx;
struct BinaryIndexTreeB {
    lli dat[maxn];
    #define lowbit(x) (x&-x)
    inline void update(int pos,int x) {
        while( pos <= n ) dat[pos] += x , pos += lowbit(pos);
    }
    inline lli query(int pos) {
        lli ret = 0;
        while( pos ) ret += dat[pos], pos -= lowbit(pos);
        return ret;
    }
    inline void reset(int pos) {
        while( pos <= n ) dat[pos] = 0 , pos += lowbit(pos);
    }
}by;

inline bool cmp(int a,int b) {
    return y[a] < y[b];
}
inline void solve(int l,int r) {
    if( l == r ) return;
    const int mid = ( l + r ) >> 1;
    for(int i=l;i<=r;i++) id[i] = i;
    sort(id+l,id+r+1,cmp);
    top = 0;
    for(int i=r;i>=l;i--) {
        const int p = id[i];
        if( p > mid ) {
            while( top && x[stk[top]] > x[p] ) by.update(y[stk[top--]],-1);
            stk[++top] = p;
            by.update(y[p],1);
        } else {
            int mxy = bx.query(n-x[p]+1);
            mxy = min( mxy , n );
            ans += by.query(mxy) - by.query(y[p]-1);
            bx.update(n-x[p]+1,y[p]);
        }
    }
    for(int i=r;i>=l;i--) {
        const int p = id[i];
        if( p > mid ) by.reset(y[p]);
        else bx.reset(n-x[p]+1);
    }
    solve(l,mid);
    solve(mid+1,r);
}

inline void refac(int* sou) {
    static int srt[maxn],len;
    memcpy(srt+1,sou+1,sizeof(int)*n);
    sort(srt+1,srt+1+n);
    len = unique(srt+1,srt+1+n) - srt - 1;
    for(int i=1;i<=n;i++) sou[i] = lower_bound(srt+1,srt+1+len,sou[i]) - srt;
}
inline void ncpy(int ope) {
    if( ope == 1 ) {
        for(int i=1;i<=n;i++)
            ns[i].x = x[i] , ns[i].y = y[i];
    } else if( !~ope ) {
        for(int i=1;i<=n;i++)
            x[i] = ns[i].x , y[i] = ns[i].y;
    }
}

int main() {
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d%d",x+i,y+i);
    
    refac(x) , refac(y);
    ncpy(1) , sort(ns+1,ns+1+n) , ncpy(-1);
    solve(1,n);
    
    printf("%lld
",ans);
    
    return 0;
}