bzoj 4237 稻草人 - CDQ分治 - 单调栈

题目传送门

　　传送点I

　　传送点II

题目大意

　　平面上有$n$个点。问存在多少个矩形使得只有左下角和右上角有点。

　　考虑枚举左下角这个点。然后看一下是个什么情况：

　　嗯对，是个单调栈。但不可能暴力去求每个点右侧和上方的点的单调栈。

　　注意到如果给单调栈设个上界，那么顶多会削掉一些点，不会发生大的改变。

　　考虑CDQ分治，然后按照$y$从大到小排序。枚举左边的点然后不断把右边纵坐标大于它的点加入单调栈。（把横坐标比它大的全弹掉）

　　然后还需要考虑一个问题：

　　

　　绿色点上方的点不能选。

　　如何找到这个上界？对左边开一个单调栈。然后在单调栈上二分。然后在右边的单调栈上二分可以找到有多少点不能选。

　　（今天考这道题，怀疑自己是zz，左边写一个线段树找上界，右边二分了两次）

Code

/**
 * bzoj
 * Problem#4237
 * Accepted
 * Time: 7540ms
 * Memory: 8332k
 */ 
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
#define ll long long
const signed int inf = (signed) (~0u >> 1);

typedef class IO {
    public:
        int sta;
        
}IO;

int __tp = 30;
char __buf[30];

#define digit(_x) ((_x) >= '0' && (_x) <= '9')
#define pick(_x) ((_x) = getchar()) 

IO& operator >> (IO& io, int& u) {
    char x;
    while (~(x = getchar()) && !digit(x));
    for (u = x - '0'; x = getchar(), digit(x); u = u * 10 + x - '0');
    return io;
}

IO in;

template<typename T>
void alloc(T*& p, int siz) {
    p = new T[(siz + 1)];
}

typedef class Point {
    public:
        int x, y;

        boolean operator < (Point b) const {
            if (y ^ b.y)    return y > b.y;
            return x < b.x;
        }
}Point;

int n;
ll res = 0;
int *buf;
Point *ps, *bp;
Point *pt, *vt;

inline void init() {
    in >> n;
    alloc(vt, n);
    alloc(ps, n), alloc(bp, n);
    alloc(buf, n), alloc(pt, n);
    for (int i = 1; i <= n; i++)
        in >> ps[i].x >> ps[i].y;
}

inline void discrete() {
    for (int i = 1; i <= n; i++)
        buf[i] = ps[i].x;
    sort(buf + 1, buf + n + 1);
    for (int i = 1; i <= n; i++)
        ps[i].x = lower_bound(buf + 1, buf + n + 1, ps[i].x) - buf;
    for (int i = 1; i <= n; i++)
        buf[i] = ps[i].y;
    sort(buf + 1, buf + n + 1);
    for (int i = 1; i <= n; i++)
        ps[i].y = lower_bound(buf + 1, buf + n + 1, ps[i].y) - buf;
}

int search(Point* pt, int tp, int y) {
    int l = 1, r = tp;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (pt[mid].y <= y)
            r = mid - 1;
        else
            l = mid + 1;
    }
    return r + 1;
}

void dividing(int l, int r, int ql, int qr) {
    if (l == r || ql > qr)
        return ;
    int mid = (l + r) >> 1;
    int pl = l - 1, pr = r + 1;
    for (int i = ql; i <= qr; i++)
        if (ps[i].x <= mid)
            bp[++pl] = ps[i];
        else
            bp[--pr] = ps[i];
    reverse(bp + pr, bp + qr + 1);
    for (int i = ql; i <= qr; i++)
        ps[i] = bp[i];

    int tp = 0, tp1 = 1;
    vt[1] = (Point) {inf, inf};
    for (int i = l; i <= pl; i++) {
        while (pr <= r && ps[pr].y > ps[i].y) {
            while (tp && pt[tp].x >= ps[pr].x)
                tp--;
            pt[++tp] = ps[pr], pr++;
        }
        int l = 1, r = tp1;
        while (l <= r) {
            int mid = (l + r) >> 1;
            if (vt[mid].x >= ps[i].x)
                l = mid + 1;
            else
                r = mid - 1;
        }
        res += tp - search(pt, tp, vt[l - 1].y) + 1;
        while (tp1 && vt[tp1].x <= ps[i].x)
            tp1--;
        vt[++tp1] = ps[i];
    }
    
    dividing(l, mid, ql, pl);
    dividing(mid + 1, r, pl + 1, qr);
}

inline void solve() {
    sort(ps + 1, ps + n + 1);
    dividing(1, n, 1, n);
    printf(Auto, res);
}

int main() {
    init();
    discrete();
    solve();
    return 0;
}