模拟4题解 T3奇袭

T3奇袭

---

题目描述

由于各种原因，桐人现在被困在Under World（以下简称UW）中，而UW马上 要迎来最终的压力测试——魔界入侵。

唯一一个神一般存在的Administrator被消灭了，靠原本的整合骑士的力量 是远远不够的。所以爱丽丝动员了UW全体人民，与整合骑士一起抗击魔族。

在UW的驻地可以隐约看见魔族军队的大本营。整合骑士们打算在魔族入侵前 发动一次奇袭，袭击魔族大本营！

为了降低风险，爱丽丝找到了你，一名优秀斥候，希望你能在奇袭前对魔族 大本营进行侦查，并计算出袭击的难度。

经过侦查，你绘制出了魔族大本营的地图，然后发现，魔族大本营是一个N ×N的网格图，一共有N支军队驻扎在一些网格中（不会有两只军队驻扎在一起）。

在大本营中，每有一个k×k(1≤k≤N)的子网格图包含恰好k支军队，我们袭 击的难度就会增加1点。

现在请你根据绘制出的地图，告诉爱丽丝这次的袭击行动难度有多大。

输入

第一行，一个正整数N，表示网格图的大小以及军队数量。

接下来N行，每行两个整数,Xi,Yi，表示第i支军队的坐标。

保证每一行和每一列都恰有一只军队,即每一个Xi和每一个Yi都是不一样 的。

输出

一行，一个整数表示袭击的难度。

样例输入

5
1 1
3 2
2 4
5 5
4 3

样例输出

10

提示

【样例解释】
显然，分别以(2,2)和(4,4)为左上,右下顶点的一个子网格图中有3支军队，
这为我们的难度贡献了1点。
类似的子网格图在原图中能找出10个。
【数据范围】
对于30%的数据，N ≤ 100
对于60%的数据，N ≤ 5000
对于100%的数据，N ≤ 50000

---

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #define Re register
 using namespace std;
 int read()
 {
     int f=,x=;char ch=getchar();
     while(ch>''||ch<''){if(ch=='-')f=-;ch=getchar();}
     while(ch<=''&&ch>=''){x=(x<<)+(x<<)+ch-'';ch=getchar();}
     return f*x;
 }
 const int maxn=;
 int n,a[maxn],ans;
 int lmax[maxn],lmin[maxn],rmax[maxn],rmin[maxn],t[*maxn];
 void work(int l,int r,int mid)
 {
     lmax[mid]=lmin[mid]=a[mid];
     rmax[mid+]=rmin[mid+]=a[mid+];
     for(int i=mid-;i>=l;i--)
     {
         lmax[i]=max(lmax[i+],a[i]);
         lmin[i]=min(lmin[i+],a[i]);
     }
     for(int i=mid+;i<=r;i++)
     {
         rmax[i]=max(rmax[i-],a[i]);
         rmin[i]=min(rmin[i-],a[i]);
     }
     //both left
     for(int i=l;i<=mid;i++)
     {
         int j=i+lmax[i]-lmin[i];
         if(j>mid&&j<=r)
             if(lmax[i]>rmax[j]&&lmin[i]<rmin[j])   //由于左右两个区间必定不会有相等的元素，所以不用考虑等号
                 ans++;
     }
     //min is on left ,max is on right
     int L=mid+,R=mid+;
     while(L<=r&&lmax[l]>rmax[L])
     {
         t[rmax[L]-L+n]--;//走过的路径是不合法的
         L++;
     }
     while(R<=r&&lmin[l]<rmin[R])
     {
         t[rmax[R]-R+n]++;//走过的路径都是合法的
         R++;
     }
     for(int i=l;i<=mid;i++)//i从l向mid移动，lmin变大，lmax变小，使得LR能向左移动
     {
         while(L>mid+&&lmax[i]<rmax[L-])//当L==mid+1时，退出循环
         {
             L--;
             t[rmax[L]-L+n]++;
         }
         while(R>mid+&&lmin[i]>rmin[R-])
         {
             R--;
             t[rmax[R]-R+n]--;
         }
         if(t[lmin[i]-i+n]>)
             ans+=t[lmin[i]-i+n];
     }
     for(int i=mid+;i<=r;i++)
         t[rmax[i]-i+n]=;
 }
 void divide(int l,int r)
 {
     if(l==r)
     {
         ans++;
         return;
     }
     int mid=(l+r)>>;
     divide(l,mid);
     divide(mid+,r);
     work(l,r,mid);
     reverse(a+l,a+r+);
     if(((r-l)%)==) mid--;//1 2 3 4 5 交换后 5 4 3 2 1   仍然应该使123在一个区间所以 mid--;
     work(l,r,mid);
     reverse(a+l,a+r+);
 }
 int main()
 {
     n=read();
     for(int i=;i<=n;i++)
     {
         int x,y;
         x=read();y=read();
         a[x]=y;
     }
     divide(,n);
     printf("%d",ans);
 }

这两种实现都正确，实质相同

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #define Re register
 using namespace std;
 int read()
 {
     int f=,x=;char ch=getchar();
     while(ch>''||ch<''){if(ch=='-')f=-;ch=getchar();}
     while(ch<=''&&ch>=''){x=(x<<)+(x<<)+ch-'';ch=getchar();}
     return f*x;
 }
 const int maxn=;
 int n,a[maxn],ans;
 int lmax[maxn],lmin[maxn],rmax[maxn],rmin[maxn],t[*maxn];
 void work(int l,int r,int mid)
 {
     lmax[mid]=lmin[mid]=a[mid];
     rmax[mid+]=rmin[mid+]=a[mid+];
     for(int i=mid-;i>=l;i--)
     {
         lmax[i]=max(lmax[i+],a[i]);
         lmin[i]=min(lmin[i+],a[i]);
     }
     for(int i=mid+;i<=r;i++)
     {
         rmax[i]=max(rmax[i-],a[i]);
         rmin[i]=min(rmin[i-],a[i]);
     }
     //both left
     for(int i=l;i<=mid;i++)
     {
         int j=i+lmax[i]-lmin[i];
         if(j>mid&&j<=r)
             if(lmax[i]>rmax[j]&&lmin[i]<rmin[j])   //由于左右两个区间必定不会有相等的元素，所以不用考虑等号，下面同理
                 ans++;
     }
     //min is on left ,max is on right
     int L=mid+,R=mid+;
     for(int i=mid;i>=l;i--)//i从mid向l移动，lmin变小，lmax变大，使得LR能向向右移动
     {
         while(L<=r&&lmax[i]>rmax[L])//属于不合法的部分
         {
             t[rmax[L]-L+n]--;
             L++;
         }
         while(R<=r&&lmin[i]<rmin[R])//
         {
             t[rmax[R]-R+n]++;//合法的
             R++;
         }
         if(t[lmin[i]-i+n]>)
             ans+=t[lmin[i]-i+n];
     }
     for(int i=mid+;i<=r;i++)
         t[rmax[i]-i+n]=;
 }
 void divide(int l,int r)
 {
     if(l==r)
     {
         ans++;
         return;
     }
     int mid=(l+r)>>;
     divide(l,mid);
     divide(mid+,r);
     work(l,r,mid);
     reverse(a+l,a+r+);
     if(((r-l)%)==) mid--;//1 2 3 4 5 交换后 5 4 3 2 1   仍然应该使123在一个区间所以 mid--;
     work(l,r,mid);
     reverse(a+l,a+r+);
 }
 int main()
 {
     n=read();
     for(int i=;i<=n;i++)
     {
         int x,y;
         x=read();y=read();
         a[x]=y;
     }
     divide(,n);
     printf("%d",ans);
 }