[Codeforce526F]:Pudding Monsters（分治）

题目传送门

---

题目描述

由于各种原因，桐人现在被困在Under World（以下简称UW）中，而UW马上要迎来最终的压力测试——魔界入侵。
唯一一个神一般存在的Administrator被消灭了，靠原本的整合骑士的力量 是远远不够的。所以爱丽丝动员了UW全体人民，与整合骑士一起抗击魔族。
在UW的驻地可以隐约看见魔族军队的大本营。整合骑士们打算在魔族入侵前发动一次奇袭，袭击魔族大本营！
为了降低风险，爱丽丝找到了你，一名优秀斥候，希望你能在奇袭前对魔族 大本营进行侦查，并计算出袭击的难度。

经过侦查，你绘制出了魔族大本营的地图，然后发现，魔族大本营是一个$N \times N$的网格图，一共有N支军队驻扎在一些网格中（不会有两只军队驻扎在一起）。
在大本营中，每有一个$k \times k$(1≤k≤N)的子网格图包含恰好k支军队，我们袭 击的难度就会增加1点。
现在请你根据绘制出的地图，告诉爱丽丝这次的袭击行动难度有多大。

---

输入格式：

第一行，一个正整数N，表示网格图的大小以及军队数量。
接下来N行，每行两个整数，$X_i$，$Y_i$，表示第i支军队的坐标。
保证每一行和每一列都恰有一只军队,即每一个$X_i$和每一个$Y_i$都是不一样的。

---

输出格式：

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

---

样例：

样例输入：

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。

---

注意题中一句话，得语文者得天下：

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

（然而当时的我并没有看见……）

---

题解：

$O( N^5 )$：

考虑暴力枚举，$N^2$枚举左下角位置，$O(N)$枚举正方形边长，$N^2$暴力求和，与边长比较，统计答案。

期望得分：27分。

$O( N^4 )$：

考虑上面红色字的含义，即可把这道题转化为：给定N个书的一个排列，问这个序列中有多少个子区间的数恰好是连续的。

那么，我们就可以将$O( N^5 )$算法压一维，同样是$N^2$枚举左右端点位置，$O(N)$枚举正方形边长，但是暴力求和的时候只需要$O(N)$把这一段区间扫一遍即可。

期望得分：27分。

$O(N^3)$：

又不用考虑上面红色字的含义了，维护一下$O( N^5 )$算法的前缀和，就能将$N^2$暴力求和压掉，就做到了$O(N^3)$。

期望得分：27分。

$O(N^2)$：

又得考虑上面红色字的含义了，认真想一想，题目就转化成了：有多少种情况使得相邻的k个数中最大值和最小值的差为k-1。

那么，我们可以维护区间的最大值和最小值，然后进行处理，还是$N^2$枚举左右端点位置，但是直接用这段区间的最大值减去最小值，将它与k做比较，相同则ans++。

至于最大值最小值，可以在枚举左端点的时候清空，然后在枚举右端点的时候暴力更新；也可以使用ST算法，$N \log N$预处理，$O(1)$查询，其实没必要，主要是说一下这种思维。

期望得分：

　　暴力更新：64分。

　　ST算法：55分。

$O(N^2)Pro$：

考虑对$O(N^2)$算法进行优化，如果要满足当前长度为k的区间里所有的数都是连续的k个数，那么如果当前枚举右端点的时候扫到的点不是当前区间的最小值，而比它大1的数却在左端点左边，那么以后的一定都不能满足了，直接break掉，枚举下一个左端点就好了，这个点不是当前区间的最大值时同理。

期望得分：91分。

$O(N^2)Pro+$：

考虑卡常，使用register，fread快读。

期望得分：91分。

$O(N \log N)||O(N \log^2 N)$：

两种解法：分治和线段树。

在这里主要讲一下分治：

对于当前分治的区间[l,r]，设其中点为mid。

当前区间的答案即为：

$ans[l,r]=ans[l,mid]+ans[mid+1,r]+$跨过中点的合法方案数。

计算跨过中点的合法方案数时，分一下四种情况：

　　1.最大值和最小值都在左侧。

　　2.最大值和最小值都在右侧。

　　3.最小值在左侧，最大值在右侧。

　　4.最小值在右侧，最大值在左侧。

然后我们发现，情况1和情况3对称，情况2和情况4对称，所以下面我们只考虑情况1和情况3。

对于情况1，我们枚举左边界，然后可以计算出右边界的位置，再判断是否合法，统计答案，时间复杂度$O(N)$。

对与情况3，如果一个区间合法的话就一定满足：

　　$\max (a[mid+1]...a[r])- \min (a[l]...a[mid])=r-l$

移项得：

　　$\max (a[mid+1]...a[r]-r= \min (a[l]...a[mid])-l$

然后利用单调栈和桶来完成这些操作，代码实现较为复杂，时间复杂度$O(N)$。

考虑上二分区间的时候的$\log N$，总的时间复杂度即为$O(N \log N)$。

因为情况1和情况3对称，情况2和情况4对称，为了降低码长我们可以使用algorithm库里的reverse函数，在$\log N$的时间内翻转区间，时间复杂度为$O(N \log^2 N)$。

线段树的思路也是利用单调栈，用线段书进行区间修改和查询，统计答案，时间复杂度$O(N \log N)$。

期望得分：100分。

---

代码时刻：

$O( N^5 )$：

#include<bits/stdc++.h>
using namespace std;
int n,a[5001][5001];
int ans;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		a[x][y]=1;
	}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)//枚举端点
			for(int len=1;len<=min(n-i+1,n-j+1);len++)//枚举长度
			{
				int sum=0;
				for(int k=0;k<len;k++)
					for(int l=0;l<len;l++)//暴力统计答案
						if(a[i+k][j+l])sum++;
				if(sum==len)ans++;
			}
	printf("%d",ans);
	return 0;
}

$O( N^4 )$：

#include<bits/stdc++.h>
using namespace std;
int n,a[50001],ans;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		a[x]=y;
	}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)//枚举端点
			for(int len=1;len<=min(n-i+1,n-j+1);len++)//枚举长度
			{
				int sum=0;
				for(int pos=0;pos<len;pos++)//暴力统计答案
				{
					if(a[i+pos]<=j+len-1&&a[i+pos]>=j)sum++;
					if(sum>len)break;
				}
				if(sum==len)ans++;
			}
	printf("%d",ans);
	return 0;
}

$O(N^3)$：

#include<bits/stdc++.h>
using namespace std;
int ans;
int Map[5001][5001];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		Map[x][y]=1;
	}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			Map[i][j]=Map[i][j]+Map[i-1][j]+Map[i][j-1]-Map[i-1][j-1];//计算前缀和
	ans=n;
	for(int k=2;k<=n;k++)//枚举长度
		for(int i=0;i<=n-k;i++)
			for(int j=0;j<=n-k;j++)//枚举左右端点
				if(Map[i+k][j+k]-Map[i+k][j]-Map[i][j+k]+Map[i][j]==k)ans++;//统计答案
	printf("%d",ans);
	return 0;
}

$O(N^2)$：

暴力求最大值和最小值：

#include<bits/stdc++.h>
using namespace std;
int n;
int a[50001];
int ans;
int maxn,minn;
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		a[x]=y;
	}
	for(int i=1;i<=n;i++)//枚举左端点
	{
		maxn=0;
		minn=1<<30;//初始值
		for(int j=i;j<=n;j++)//枚举右端点
		{
			maxn=max(maxn,a[j]);
			minn=min(minn,a[j]);//更新最大值和最小值
			if(maxn-minn==j-i)ans++;//统计答案
		}
	}
	printf("%d",ans);
	return 0;
}

利用ST算法最大值和最小值：

#include<bits/stdc++.h>
using namespace std;
int n;
int maxn[50001][20],minn[50001][20];
int ans;
void st(int x)
{
    for(int i=1;i<=16;i++)
        for(int j=1;j+(1<<i)<=x+1;j++)
        {
            maxn[j][i]=max(maxn[j][i-1],maxn[j+(1<<(i-1))][i-1]);
            minn[j][i]=min(minn[j][i-1],minn[j+(1<<(i-1))][i-1]);
        }
}
pair<int,int> query(int l,int r)
{
    int k=log2(r-l+1);
    return make_pair(max(maxn[l][k],maxn[r-(1<<k)+1][k]),min(minn[l][k],minn[r-(1<<k)+1][k]));
}
int main()
{
	memset(minn,0x3f,sizeof(minn));
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		maxn[x][0]=minn[x][0]=y;//直接存入ST表
	}
	st(n);//ST表初始化
	for(int i=1;i<=n;i++)
		for(int j=i;j<=n;j++)
		{
			pair<int,int> flag=query(i,j);//取出当前区间的最大值和最小值
			if(flag.first-flag.second==j-i)ans++;//统计答案
		}
	printf("%d",ans);
	return 0;
}

$O(N^2)Pro$：

#include<bits/stdc++.h>
using namespace std;
int n;
int a[50001],flag[50001];//flag存储对应位置
int ans;
int maxn,minn;
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		a[x]=y;
		flag[y]=x;
	}
	for(int i=1;i<=n;i++)
	{
		maxn=0;
		minn=1<<30;
		for(int j=i;j<=n;j++)
		{
			maxn=max(maxn,a[j]);
			minn=min(minn,a[j]);
			if((a[j]!=minn&&flag[a[j]-1]<i)||(a[j]!=maxn&&flag[a[j]+1]<i))break;//剪枝
			if(maxn-minn==j-i)ans++;
		}
	}
	printf("%d",ans);
	return 0;
}

$O(N^2)Pro+$：

#include<bits/stdc++.h>
using namespace std;
const int L(1<<20|1);
char buffer[L],*S,*T;
#define getchar() ((S==T&&(T=(S=buffer)+fread(buffer,1,L,stdin),S==T))?EOF:*S++)//调试时记得注释
int read()
{
    register int a=0,b=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')b=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){a=(a<<3)+(a<<1)+(ch-'0');ch=getchar();}
    return a*b;
}
int n;
int a[50001],flag[50001];
int ans;
int maxn,minn;
int main()
{
	register int n=read();
	for(register int i=1;i<=n;i++)
	{
		register int x=read(),y=read();
		a[x]=y;
		flag[y]=x;
	}
	for(register int i=1;i<=n;i++)
	{
		maxn=0;
		minn=1<<30;
		for(register int j=i;j<=n;j++)
		{
			maxn=max(maxn,a[j]);
			minn=min(minn,a[j]);
			if((a[j]!=minn&&flag[a[j]-1]<i)||(a[j]!=maxn&&flag[a[j]+1]<i))break;
			if(maxn-minn==j-i)ans++;
		}
	}
	printf("%d",ans);
	return 0;
}

$O(N \log^2 N)$：

#include<bits/stdc++.h>
using namespace std;
int n;
int a[50001];
int lmin[50001],lmax[50001],rmin[50001],rmax[50001],barrel[100001];//分别存储左区间最小值，左区间最大值，右区间最小值，右区间最大值，桶。
int ans;
int wzc(int l,int r,int mid)
{
	lmin[mid  ]=lmax[mid  ]=a[mid  ];
	rmin[mid+1]=rmax[mid+1]=a[mid+1];
    for(int i=mid-1;i>=l;i--)
    {
        lmin[i]=min(lmin[i+1],a[i]);
        lmax[i]=max(lmax[i+1],a[i]);
    }
    for(int i=mid+2;i<=r;i++)
    {
        rmin[i]=min(rmin[i-1],a[i]);
        rmax[i]=max(rmax[i-1],a[i]);
    }
    int flag=0,flag1=mid+1,flag2=mid+1;
    for(int i=l;i<=mid;i++)
    {
    	int miao=lmax[i]-lmin[i]+i;
    	if(miao<=r&&mid<miao&&rmax[miao]<lmax[i]&&lmin[i]<rmin[miao])flag++;//最大值和最小值在同侧
    }
    while(flag1<=r&&lmin[l]<rmin[flag1])
    	barrel[rmax[flag1]-flag1+50000]++,flag1++;//最小值在左侧
    while(flag2<=r&&rmax[flag2]<lmax[l])
    	barrel[rmax[flag2]-flag2+50000]--,flag2++;//最大值在右侧
    for(int i=l;i<=mid;i++)
    {
    	while(flag1>mid+1&&rmin[flag1-1]<lmin[i])
    		flag1--,barrel[rmax[flag1]-flag1+50000]--;
    	while(flag2>mid+1&&lmax[i]<rmax[flag2-1])
    		flag2--,barrel[rmax[flag2]-flag2+50000]++;
    	flag+=barrel[lmin[i]-i+50000]>0?barrel[lmin[i]-i+50000]:0;
    }
    for(int i=mid+1;i<=r;i++)barrel[rmax[i]-i+50000]=0;
    return flag;
}
void dfs(int l,int r)//二分区间
{
	if(l==r)return;
	int mid=(l+r)>>1;
	dfs(l,mid);
	dfs(mid+1,r);
	ans+=wzc(l,r,mid);
	reverse(a+l,a+r+1);//翻转
	ans+=wzc(l,r,mid-((r-l+1)&1));//注意mid位置在反转之后会发生改变
	reverse(a+l,a+r+1);//记得翻回来
	return;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		a[x]=y;
	}
	dfs(1,n);
	cout<<ans+n<<endl;//最后记得加n
	return 0;
}

$O(N \log N)$：

#include<bits/stdc++.h>
using namespace std;
int n;
int a[50001];
int lmin[50001],lmax[50001],rmin[50001],rmax[50001],barrel[200001];//桶要稍微开打点
int ans;
int wzc(int l,int r,int mid)
{
	lmin[mid  ]=lmax[mid  ]=a[mid  ];
	rmin[mid+1]=rmax[mid+1]=a[mid+1];
    for(int i=mid-1;i>=l;i--)
    {
        lmin[i]=min(lmin[i+1],a[i]);
        lmax[i]=max(lmax[i+1],a[i]);
    }
    for(int i=mid+2;i<=r;i++)
    {
        rmin[i]=min(rmin[i-1],a[i]);
        rmax[i]=max(rmax[i-1],a[i]);
    }
    int flag=0,flag1=mid+1,flag2=mid+1;
    for(int i=l;i<=mid;i++)
    {
    	int miao=lmax[i]-lmin[i]+i;
    	if(miao<=r&&mid<miao&&rmax[miao]<lmax[i]&&lmin[i]<rmin[miao])flag++;
    }
    for(int i=mid+1;i<=r;i++)
    {
    	int miao=rmin[i]-rmax[i]+i;
    	if(miao>=l&&mid>=miao&&rmax[i]>lmax[miao]&&lmin[miao]>rmin[i])flag++;
    }
    while(flag1<=r&&lmin[l]<rmin[flag1])
    	barrel[rmax[flag1]-flag1+50000]++,flag1++;
    while(flag2<=r&&rmax[flag2]<lmax[l])
    	barrel[rmax[flag2]-flag2+50000]--,flag2++;
    for(int i=l;i<=mid;i++)
    {
    	while(flag1>mid+1&&rmin[flag1-1]<lmin[i])
    		flag1--,barrel[rmax[flag1]-flag1+50000]--;
    	while(flag2>mid+1&&lmax[i]<rmax[flag2-1])
    		flag2--,barrel[rmax[flag2]-flag2+50000]++;
    	flag+=barrel[lmin[i]-i+50000]>0?barrel[lmin[i]-i+50000]:0;
    }
    for(int i=mid+1;i<=r;i++)barrel[rmax[i]-i+50000]=0;
    flag1=flag2=mid;
    while(flag1>=l&&lmin[flag1]>rmin[r])
    	barrel[lmax[flag1]+flag1+50000]++,flag1--;//最小值在右侧
    while(flag2>=l&&rmax[r]>lmax[flag2])
    	barrel[lmax[flag2]+flag2+50000]--,flag2--;//最大值在左侧
    for(int i=r;i>mid;i--)
    {
    	while(flag1<mid&&rmin[i]>lmin[flag1+1])
    		flag1++,barrel[lmax[flag1]+flag1+50000]--;
    	while(flag2<mid&&lmax[flag2+1]>rmax[i])
    		flag2++,barrel[lmax[flag2]+flag2+50000]++;
    	flag+=barrel[rmin[i]+i+50000]>0?barrel[rmin[i]+i+50000]:0;
    }
    for(int i=l;i<=mid;i++)barrel[lmax[i]+i+50000]=0;
    return flag;
}
void dfs(int l,int r)
{
	if(l==r)return;
	int mid=(l+r)>>1;
	dfs(l,mid);
	dfs(mid+1,r);
	ans+=wzc(l,r,mid);
	return;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		a[x]=y;
	}
	dfs(1,n);
	printf("%d",ans+n);
	return 0;
} 

---

rp++