9.5 考试 第三题 奇袭题解（codeforce 526f）

问题 C: 奇袭

时间限制: 1 Sec  内存限制: 256 MB

题目描述

由于各种原因，桐人现在被困在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

　　这道题当时看一眼还以为又是一个带权并查集的大坑，然后发现我只猜对了一半，这确实是个坑，不过貌似与带权并查集没啥关系。

　　开始的时候先打了一个n^3 log(n^2)的树状数组暴力期望目测30分，然后又打了一个严格n^2的单调队列暴力55分（虽然我期望60），考完后惊喜的发现加了一些剪枝的n^2可以水到91分……

　　这道题正解是线段树或分治，由于线段树打发我不会，我就只讲分治了。

　　我们可以发现这道题有一个极其优美的性质即每行每列只有一个敌人也就意味着我们没有必要去管那些没有敌人的位置。然后让我们分析一下时间复杂度，他的最大解是1250025000（所有敌人排成一个对角线），显然直接枚举每一个解都会炸也就是说所有复杂度大于等于O（合法方块数量）的都挂了。这道题也显然没有O(1)做法，那我们该咋搞呢？

　　我们可以发现，他是一个区间解，我们可以尝试一下分治这个本身时间复杂度为log n的想法，我们可以把每一个区间的解分成三个来源，左区间的解，右区间的解，区间跨过终点的解。很明显这三个不会重复，而且前两个直接就可以得到，难点在第三个来源上，对于第三个来源，我们又可以分为四种情况，区间最大值最小值在左侧（右侧），区间最大值在左（右），最小值在右（左），前两种我们可以通过类似于前缀后缀最大最小值的思想枚举左或右区间端点，然后O(1)的得到区间另一个端点，通过前后缀最大最小值是否合法判断是否算到答案之中，对于后两种就是本代码的核心了。

　　我们先以最小值在左最大值在右为例讲解，首先满足要求的区间一定是这样的：

　　max(a[mid +1]...a[right]) - min(a[left]...a[mid]) = right - left

　　通过移项可知

　　max(a[mid +1]...a[right]) - right = min(a[left]...a[mid]) - left

　　然后我们可以发现等式两边就没有直接联系了，借助天天爱跑步的思路，桶，我们存下每一个rmax[i]-i的值然后枚举左端点就可以了。值得注意的是rmax,rmin,lmin,lmax，都是具有优美的单调性质的，我们可以利用这一点再剪一下枝，同时，由于桶的存在，我们也就避免了一个个的去统计所有解，明显加快了时间。

　　对于最大值在左侧最小值在右侧我们只要转换一下就好了：

　　max(a[mid +1]...a[right]) + right = min(a[left]...a[mid]) + left

　　然后同理。

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #define N 50005
 using namespace std;
 +];
 int lmin[N],rmin[N],lmax[N],rmax[N];
 int work2(int l,int r,int mid)
 {
     lmin[mid]=lmax[mid]=a[mid];
     rmin[mid+]=rmax[mid+]=a[mid+];
     ;i>=l;i--)
     {
         lmin[i]=min(lmin[i+],a[i]);
         lmax[i]=max(lmax[i+],a[i]);
     }
     ;i<=r;i++)
     {
         rmin[i]=min(rmin[i-],a[i]);
         rmax[i]=max(rmax[i-],a[i]);
     }
     ;
     for(int i=l;i<=mid;i++)
     {
         int to=i+lmax[i]-lmin[i];
         if(to<=r&&to>mid&&rmax[to]<lmax[i]&&lmin[i]<rmin[to]) ans++;
     }
     ;i<=r;i++)
     {
         int to=i-rmax[i]+rmin[i];
         if(to>=l&&to<=mid&&rmax[i]>lmax[to]&&rmin[i]<lmin[to]) ans++;
     }
     ,q=mid+;
     while(p<=r&&rmin[p]>lmin[l])  //min is on the left
     {
         t[rmax[p]-p+N]++;
         p++;
     }
     while(q<=r&&rmax[q]<lmax[l])  //max is on the right
     {
         t[rmax[q]-q+N]--;
         q++;
     }
     for(int i=l;i<=mid;i++)
     {
         &&rmin[p-]<lmin[i])
         {
             p--;
             t[rmax[p]-p+N]--;
         }
         &&rmax[q-]>lmax[i])
         {
             q--;
             t[rmax[q]-q+N]++;
         }
         )
             ans+=t[lmin[i]-i+N];
     }
     ;i<=r;i++)t[rmax[i]-i+N]=;
     p=mid,q=mid;
     while(p>=l&&lmin[p]>rmin[r])//min is on the right
     {
         t[lmax[p]+p+N]++;
         p--;
     }
     while(q>=l&&lmax[q]<rmax[r]) //max is on the left
     {
         t[lmax[q]+q+N]--;
         q--;
     }
     for(int i=r;i>mid;i--)
     {
         ]<rmin[i])
         {
             p++;
             t[lmax[p]+p+N]--;
         }
         ]>rmax[i])
         {
             q++;
             t[lmax[q]+q+N]++;
 
         }
         )
         {
             ans+=t[rmin[i]+i+N];
         }
     }
     for(int i=l;i<=mid;i++)
     {
         t[lmax[i]+i+N]=;
     }
     return ans;
 }
 int work(int l,int r)
 {
     ;
     ;
     ,r);
 
     ans+=work2(l,r,mid);
     return ans;
 }
 int main()
 {
     scanf("%d",&n);
     ;i<=n;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         a[x]=y;
     }
     //cout<<endl;
     printf(,n));
     ;
 }

　　其实还有一个黑科技 reverse函数将整个区间左右调换，省了不少代码量，只是复杂度多了一个log n。

　

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #define N 50005
 using namespace std;
 +];
 int lmin[N],rmin[N],lmax[N],rmax[N];
 int work2(int l,int r,int mid)
 {
     lmin[mid]=lmax[mid]=a[mid];
     rmin[mid+]=rmax[mid+]=a[mid+];
     ;i>=l;i--)
     {
         lmin[i]=min(lmin[i+],a[i]);
         lmax[i]=max(lmax[i+],a[i]);
     }
     ;i<=r;i++)
     {
         rmin[i]=min(rmin[i-],a[i]);
         rmax[i]=max(rmax[i-],a[i]);
     }
     ;
     for(int i=l;i<=mid;i++)
     {
         int to=i+lmax[i]-lmin[i];    //max,min is on the left
         if(to<=r&&to>mid&&rmax[to]<lmax[i]&&lmin[i]<rmin[to]) ans++;
     }
     ,q=mid+;
     while(p<=r&&rmin[p]>lmin[l])    //min is on the left
     {
         t[rmax[p]-p+N]++;
         p++;
     }
     while(q<=r&&rmax[q]<lmax[l])    //max is on the right
     {
         t[rmax[q]-q+N]--;
         q++;
     }
     for(int i=l;i<=mid;i++)
     {
         &&rmin[p-]<lmin[i])
         {
             p--;
             t[rmax[p]-p+N]--;
         }
         &&rmax[q-]>lmax[i])
         {
             q--;
             t[rmax[q]-q+N]++;
         }
         )
             ans+=t[lmin[i]-i+N];
     }
     ;i<=r;i++)t[rmax[i]-i+N]=;
     return ans;
 }
 int work(int l,int r)
 {
     ;
     ;
     ,r);
     ans+=work2(l,r,mid);
     reverse(a+l,a+r+);
     ans+=work2(l,r,mid-((r-l+)%));
     reverse(a+l,a+r+);
     return ans;
 }
 int main()
 {
     scanf("%d",&n);
     ;i<=n;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         a[x]=y;
     }
     printf(,n));
     ;
 }