cdq分治模板

#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<math.h>
#include<iostream>
#include<string>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1,class T2>inline void gmax(T1 &a,T2 b){if(b>a)a=b;}
template <class T1,class T2>inline void gmin(T1 &a,T2 b){if(b<a)a=b;}
const int N=750+5,M=5e5+10,Z=1e9+7,ms63=1061109567;
int casenum,casei;
/*
算法介绍之cdq分治:

其实cdq分治的思想与应用都能被很简单地描述——它是用来解决各种区间段转移问题[x->y(x<y)]的。
我们用f[x]表示位置x转移之后的结果,用solve(l,r)来传递完全限制在[l,r]范围内的状态转移,并且转移a->b一定有a<b
那么对于solve(l,r)
1,如果l==r,没有后续转移,程序结束。
2,求出m=(l+r)>>1;
3,solve(l,m);
4,传递[l,m]对[m+1,r]的贡献。
5,solve(m+1,r);
这样cdq分治就做完啦
*/
int n,m;
int a[N][N];
int f[N][N];
int s[M];
void add(int &x,int y)
{
	x+=y;
	if(x>=Z)x-=Z;
}
void solve(int l,int r)
{
	if(l==r)return;
	int mid=(l+r)>>1;

	//步骤1,处理[l,mid]
	solve(l,mid);
	
	//步骤2,处理[l,mid]->(mid,r]的转移
	for(int i=l;i<=r;i++)for(int j=1;j<=m;j++)s[a[i][j]]=0;
	int all=0;
	//从左到右逐列枚举,以及逆拓扑序,保证了列的小于关系
	for(int j=1;j<=m;j++)
	{
		//行累加只在[l,mid]展开,行转移在(mid,r]收集,保证了行的小于关系
		for(int i=mid+1;i<=r;i++)add(f[i][j],(all-s[a[i][j]]+Z)%Z);
		for(int i=l;i<=mid;i++)
		{
			add(s[a[i][j]],f[i][j]);
			add(all,f[i][j]);
		}
	}
	
	//步骤3,处理(mid,r]
	solve(mid+1,r);
}
int main()
{
	while(~scanf("%d%d%*d",&n,&m))
	{
		for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)scanf("%d",&a[i][j]);
		MS(f,0);f[1][1]=1;
		solve(1,n);
		printf("%d\n",f[n][m]);
	}
	return 0;
}
/*
【题意】
给你一个n(750)*m(750)的棋盘,每个格子(i,j)都有一种颜色c[i][j],
颜色范围是[1,top]中的整数,top取值范围是[1,5e5]。
对于一次跳跃A(y1,x1)->B(y2,x2),我们说这次跳跃是合法的,要求必须有:
1,y2>y1
2,x2>x1
3,c[y1][x1]!=c[y2][x2];
我们想要求出从(1,1)经过若干次跳跃之后到达(n,m)的方案数,mod(1e9+7)

【类型】
CDQ分治

【分析】
首先,我们可以构想一个暴力DP:
用f[i][j]表示从(1,1)到(i,j)的方案数
那么f[i][j]=∑f[u][v],u<i&&v<j&&c[u][v]!=c[i][j]
时间复杂度为O(n^2 m^2),想要通过这题,这还差得远。

思考1,
我们观察到,这道题中,颜色的范围不是1e9,而是5e5。为什么呢?
我们发现,相比较1e9,5e5这个范围的数组是开得下的,于是我们可以做计数处理,有助于我们维护答案。
(ps:如果颜色属于1e9范围,因为颜色种类最多只有n*m,所以其实我们可以离散化)
如果我们用d[x]表示颜色为从(1,1)走到当前处理范围颜色为x的点的方案数,
并用一个大的变量tot统计从(1,1)走到当前处理范围所有点的方案数之和。
那么当我们走到一个颜色为x的点时,就可以直接使用 tot-d[x] 来更新到达这个点的方案数。
这个思想有一定的价值,但是因为题目给出的1,2两个限制条件。
具体要通过什么途径保证d[]中处理的所有点都在它之间呢?

思考2,
区间问题的实现,很多时候我们都要引入整段考虑的思想。
这其实也就是CDQ分治的思想与具体实现。
我们想要更新从(1,1)走到行[l,r]范围格点的方案数。
而line[l,r]每个格子更新的来源,有两方面。
1,line[1,l-1]
2,line[l,r]内部
我们假设在处理[l,r]时,所有line[1,l-1]对line[l,r]的贡献已经生效。
于是现在只需要考虑来自于line[l,r]内部的贡献。
并且定义过程solve(l,r),用于解决[l,r]内部贡献的转移。

具体如何实现?
回归到这道题——

1,如果l==r,那不会生成任何贡献,直接结束。
2,否则我们设m=(l+r)>>1;
接下来只要依次实现以下3个步骤,这道题就做完了。
(1),solve(l,m);
(2),从[l,m]向[m+1,r]转移贡献;
(3),solve(m+1,r);
于是,关键落在要如何实现(2)上——
此时,我们发现行关系已经是严格的小于关系,只需要使得列关系满足要求。如何使得?
因为问题不是在数轴上,而是在矩形中。
所以目前处理的区间是一个块,行数是[l,r],每行有m列。
我们现在是想要把[l,mid]的状态传递到[mid+1,r]。
发现只需要从左向右一列列枚举。
状态结果的传递在(mid,r])实现,状态来源的累计在[l,mid]实现。
就保证了行与列都是严格小于关系,这道题也就在O(nmlogn)的时间复杂度内解决了。

*/

你可能感兴趣的:(算法,ACM,ICPC,HDU,cdq分治)