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 >> );

 typedef class IO {
     public:
         int sta;

 }IO;

 int __tp = ;
 char __buf[];

 #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 - ''; x = getchar(), digit(x); u = u *  + x - '');
     return io;
 }

 IO in;

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

 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 = ;
 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 = ; i <= n; i++)
         in >> ps[i].x >> ps[i].y;
 }

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

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

 void dividing(int l, int r, int ql, int qr) {
     if (l == r || ql > qr)
         return ;
     int mid = (l + r) >> ;
     int pl = l - , pr = r + ;
     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 + );
     for (int i = ql; i <= qr; i++)
         ps[i] = bp[i];

     int tp = , tp1 = ;
     vt[] = (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 = , r = tp1;
         while (l <= r) {
             int mid = (l + r) >> ;
             if (vt[mid].x >= ps[i].x)
                 l = mid + ;
             else
                 r = mid - ;
         }
         res += tp - search(pt, tp, vt[l - ].y) + ;
         while (tp1 && vt[tp1].x <= ps[i].x)
             tp1--;
         vt[++tp1] = ps[i];
     }

     dividing(l, mid, ql, pl);
     dividing(mid + , r, pl + , qr);
 }

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

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