[SDWC2018 Day1]网格

前言

学了容斥与二项式反演，也该写写题了

题目介绍

题目网址

题意简介

现在有个人，要用$M$步从$(0,0)$跳到$(T_x,T_y)$，每次只能向右上方跳（即坐标值只能加），不能在原地跳
给出一些限制：给出$K$个限制$k_i$，表示两个坐标不能同时加$k_i$。给出一个数$G$，保证所有$k_i$都是$G$的倍数，求方案数（模$10^9+7$）

数据范围

$T_x,T_y\le 10^6,M_x\le T_x,M_y\le T_y$
$R\le 1000,10000\le G\le 50000,K\le 50$

题解

$K=0$

先考虑$K=0$的情况
两个维度，都是$10^6$级别的，一起做一定不好做
然后发现除了“两维不能同时停在原地”这个限制以外，两维是独立的
考虑对于一维，我们已知其长度$T$以及单步最大距离$M$
求不违反规则恰好走$x$步的方案数
直接$dp$复杂度是$\Theta (TMR)$的，显然不行
我们发现至少违反$a$次规则恰好走$R$步的方案数很好求
设$calc(a)$为至少违反$a$次规则的方案数，我们发现可以选$a$步，让这些步一开始就有$M+1$的值，那么其无论再加多少都一定是违反规则的
那么就得出$calc(a)$的式子：$$calc(a)=\left(\genfrac{}{}{0ex}{}{R}{a}\right)\left(\genfrac{}{}{0ex}{}{T-(M+1)\ast a+R-1}{R-1}\right)$$
预处理组合数后计算$calc(a)$单次$\Theta (1)$
考虑容斥，容易发现我们要求的答案就是$$\sum _{i=0}^R(-1{)}^{i}calc(i)$$
所以对于一维的答案的复杂度是$\Theta (R)$的，那么我们把两维都求出来
我们发现，两维的乘积的结果并不是我们想要的恰好$R$步，而是至多$R$步
所以我们如果要合并，我们不能直接相乘
给定$T,M$,设$L(R)$为给至多走$R$步的方案数，$E(R)$为恰好走$R$步的方案数
$$L(R)=\sum _{i=0}^R\left(\genfrac{}{}{0ex}{}{R}{i}\right)E(i)$$
二项式反演
$$E(R)=\sum _{i=0}^R(-1{)}^{R-i}(\genfrac{}{}{0ex}{}{R}{i})L(i)$$
然后发现求一次$E(R)$是$\Theta (R^2)$的，比较优越

$K̸=0$

然后我们考虑有$K$限制的情况
我们发现我们要求的是不违反限制的情况，但是并不好求
又发现，至少违反$n$次数的情况很好统计
同样考虑容斥，$g(x)$为至少违反$x$次的方案数，容易发现我们要求的就是$$\sum _{i=0}^{\infty }(-1{)}^{i}g(i)$$
我们先来思考$i$的范围，由于$k_i$都是$G$的倍数，而$G\ge 10000$，所以$i$的取值范围是$\Theta (\frac{T}{G})=\Theta (100)$的
考虑$dp$来统计$g$，定义$f_{i,j}$为至少违反$j$次、$\sum k=j\ast G$的方案数，容易发现第二维也是$\Theta (100)$的
$f_{i,j}$对答案的贡献系数即$T_x-j\ast G,T_y-j\ast G,x-i$步并且没有任何限制的答案，通过前面$K=0$的部分的分析可以得知这部分的复杂度是$\Theta (Mx)$的，总复杂度大概是$\Theta (1000\ast 1000\ast 100\ast 100)$的
貌似能过？？而且跑的飞快
当然我们要科学的复杂度，只要预处理$L(x)$即可，我们发现$T$的取值因为$j$的不同只有$\Theta (100)$组，步数是$\Theta (R)$的，一次处理是$\Theta (R)$的
所以总复杂度为$\Theta (\frac{T}{G}{R}^2)$大约$10^8$左右，再加上根本跑不满，所以很容易就过了

代码

#include<cstdio>
#include<cctype>
#include<algorithm>
namespace fast_IO
{
    const int IN_LEN=10000000,OUT_LEN=10000000;
    char ibuf[IN_LEN],obuf[OUT_LEN],*ih=ibuf+IN_LEN,*oh=obuf,*lastin=ibuf+IN_LEN,*lastout=obuf+OUT_LEN-1;
    inline char getchar_(){return (ih==lastin)&&(lastin=(ih=ibuf)+fread(ibuf,1,IN_LEN,stdin),ih==lastin)?EOF:*ih++;}
    inline void putchar_(const char x){if(oh==lastout)fwrite(obuf,1,oh-obuf,stdout),oh=obuf;*oh++=x;}
    inline void flush(){fwrite(obuf,1,oh-obuf,stdout);}
}
using namespace fast_IO;
#define getchar() getchar_()
#define putchar(x) putchar_((x))
//#include<ctime>
#define rg register
typedef long long LL;
template <typename T> inline T max(const T a,const T b){return a>b?a:b;}
template <typename T> inline T min(const T a,const T b){return a<b?a:b;}
template <typename T> inline void mind(T&a,const T b){a=a<b?a:b;}
template <typename T> inline void maxd(T&a,const T b){a=a>b?a:b;}
template <typename T> inline T abs(const T a){return a>0?a:-a;}
template <typename T> inline void swap(T&a,T&b){T c=a;a=b;b=c;}
//template <typename T> inline void swap(T*a,T*b){T c=a;a=b;b=c;}
template <typename T> inline T gcd(const T a,const T b){if(!b)return a;return gcd(b,a%b);}
template <typename T> inline T lcm(const T a,const T b){return a/gcd(a,b)*b;}
template <typename T> inline T square(const T x){return x*x;};
template <typename T> inline void read(T&x)
{
    char cu=getchar();x=0;bool fla=0;
    while(!isdigit(cu)){if(cu=='-')fla=1;cu=getchar();}
    while(isdigit(cu))x=x*10+cu-'0',cu=getchar();
    if(fla)x=-x;
}
template <typename T> inline void printe(const T x)
{
    if(x>=10)printe(x/10);
    putchar(x%10+'0');
}
template <typename T> inline void print(const T x)
{
    if(x<0)putchar('-'),printe(-x);
    else printe(x);
}
const LL mod=1000000007;
inline void md(LL&x){if(x>=mod)x-=mod;}
LL fac[1000001],inv[1000001];
inline LL pow(LL x,LL y)
{
	LL res=1;
	for(;y;y>>=1,x=x*x%mod)if(y&1)res=res*x%mod;
	return res;
}
inline LL C(LL x,LL y){return fac[x]*inv[y]%mod*inv[x-y]%mod;}
inline void init()
{
	fac[0]=1;
	for(rg int i=1;i<=1000000;i++)fac[i]=fac[i-1]*i%mod;
	inv[1000000]=pow(fac[1000000],mod-2);
	for(rg int i=1000000;i>=1;i--)inv[i-1]=inv[i]*i%mod;
}
int T,Tx,Ty,Mx,My,R,G;
int K,k[51];
LL f[101][101],g[101];
LL calc[101][1001];
inline LL solve(const int x,const int step) 
{
	LL res=0;
	for(rg int i=0;i<=step;i++)
	{
		if((i&1)==(step&1))md(res+=calc[x][i]*C(step,i)%mod);
		else md(res+=mod-calc[x][i]*C(step,i)%mod);
	}
	return res;
}
int main()
{
	init();
	read(Tx),read(Ty),T=min(Tx,Ty),read(Mx),read(My),read(R),read(G);
	for(rg int i=0;G*i<=T;i++)
	{
		const int tx=Tx-G*i,ty=Ty-G*i;
		for(rg int j=R;j>=0;j--)
		{
			if(j*Mx<tx||j*My<ty)break;
			LL valx=0,valy=0;
			for(rg int step=0;step<=j&&(Mx+1)*step<=tx;step++)
				if(step&1)md(valx+=mod-C(j,step)*C(tx-(Mx+1)*step+j-1,j-1)%mod);
				else md(valx+=C(j,step)*C(tx-(Mx+1)*step+j-1,j-1)%mod);
			for(rg int step=0;step<=j&&(My+1)*step<=ty;step++)
				if(step&1)md(valy+=mod-C(j,step)*C(ty-(My+1)*step+j-1,j-1)%mod);
				else md(valy+=C(j,step)*C(ty-(My+1)*step+j-1,j-1)%mod);
			calc[i][j]=valx*valy%mod;
		}
	}
	read(K);
	for(rg int i=1;i<=K;i++)read(k[i]);
	std::sort(k+1,k+K+1);
	K=std::unique(k+1,k+K+1)-k-1;
	for(rg int i=1;i<=K;i++)k[i]/=G;
	f[0][0]=1,g[0]=solve(0,R);
    for(rg int i=1;G*i<=T;i++)
    	for(rg int j=0;G*j<=T;j++)
    	{
    		for(rg int kind=1;kind<=K;kind++)
    			if(k[kind]<=j)
    				md(f[i][j]+=f[i-1][j-k[kind]]);
    		md(g[i]+=solve(j,R-i)*f[i][j]%mod);
    	}
    LL ans=0;
    for(rg int i=0;G*i<=T;i++)
		if(i&1)md(ans+=mod-g[i]*C(R,i)%mod);
		else md(ans+=g[i]*C(R,i)%mod);
	print(ans);
	return flush(),0;
}

总结

这道题的非常巧妙，多次运用容斥与反演的技巧，值得深思
致谢：感谢yx2003在本题上对我的指导