HDU-5794 A Simple Chess

题目描述

棋子在\(n*m\)棋盘上可以走马步（横走\(1\)竖走\(2\)或横走\(2\)竖走\(1\)）

只能往格子坐标增大的方向跳，且棋盘中会有一些障碍物

问棋子从\(（1,1）\)走到\(（n,m）\)有几种方案mod(\(110119\))

Input

输入包含多组数据

第一行三个整数\(n,m,r,(1<=n,m<=1e18,0<=r<=100),\)

接下来\(r\)行，每行两个整数\(x,y,(1<=x<=n,1<=y<=m),\)

表示障碍物位置\((1,1)\)上不会有障碍物

Output

对于每组测试数据，输出一行"Case #x: y"，x是组数,y是答案

Sample Input

1 1 0
3 3 0
4 4 1
2 1
4 4 1
3 2
7 10 2
1 2
7 1

Sample Output

Case #1: 1
Case #2: 0
Case #3: 2
Case #4: 1
Case #5: 5

​ 容斥\(dp\)+\(lucas\)定理。

题目要我们求出不碰到任意障碍物的方案数，直接求这个方案数是十分麻烦的。

我们可以转换成从起点出发到第\(i\)个障碍物不碰到任意障碍物的方案数。

我们先把在\((n,m)\)处放置一个障碍物，再把所有的障碍物按照\(x\)排序。

我们定义\(dp[i]\)表示从起点出发到第\(i\)个障碍物不碰到任意障碍物的方案数。

\(calc[x1,y1,x2,y2]\)表示从\(x1,y1\)到第\(x2,y2\)个障碍物的方案数。

排序好之后，我们对于第\(i\)个障碍物:

\(dp[i]=calc[1,1,x_i,y_i]-\sum calc(x_j,y_j,x_i,y_i)*dp[j]，（j=起点到第i的路径上的障碍）\)。

现在我们就是要求出\(calc(x1,y1,x2,y2)\)。

---

首先设\(X=x2-x1，Y=y2-y1\)，横走\(1\)竖走\(2\)走了\(a\)步，或横走\(2\)竖走\(1\)走了\(b\)步。

所以我们有\(a+2*b=X\)和\(b+2*a=Y\)。

我们可以解出\(a,b\)，若\(a,b\)​无整数解则无法从\((x1,y1)\)到\((x2,y2)\)。

解出了\(a,b\)后答案就是\(C(a+b,a)\)了。

只是\(a,b\)比较大，而我们发现模数\(110119\)是一个质数。

所以我们可以利用\(lucas\)定理。

---

\(lucas\)定理：当\(p\)为质数时，\(C(a,b)\%p=C(a/p,b/p)*C(a\%p,b\%p)\%p\)。

代码如下

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>

using namespace std;

#define int long long
#define reg register
#define Raed Read
#define clr(a,b) memset(a,b,sizeof a)
#define Mod(x) (x>=mod)&&(x-=mod)
#define debug(x) cerr<<#x<<" = "<<x<<endl;
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)>(b)?(b):(a))
#define rep(a,b,c) for(reg int a=(b),a##_end_=(c); a<=a##_end_; ++a)
#define ret(a,b,c) for(reg int a=(b),a##_end_=(c); a<a##_end_; ++a)
#define drep(a,b,c) for(reg int a=(b),a##_end_=(c); a>=a##_end_; --a)
#define erep(i,G,x) for(int i=(G).Head[x]; i; i=(G).Nxt[i])
#pragma GCC target("avx,avx2,sse4.2")
#pragma GCC optimize(3)

inline int Read(void) {
	int res=0,f=1;
	char c;
	while(c=getchar(),c<48||c>57)if(c=='-')f=0;
	do res=(res<<3)+(res<<1)+(c^48);
	while(c=getchar(),c>=48&&c<=57);
	return f?res:-res;
}

template<class T>inline bool Min(T &a, T const&b) {
	return a>b?a=b,1:0;
}
template<class T>inline bool Max(T &a, T const&b) {
	return a<b?a=b,1:0;
}

const int N=105,M=1e5+5,mod=110119;

bool MOP1;

struct node {
	int x,y;
	bool operator<(node _)const {
		if(x==_.x)return y<_.y;
		return x<_.x;
	}
} A[N];

int dp[N];

bool MOP2;

int Fac[mod+5],Inv[mod+5],V[mod+5];

int C(int a,int b) {
	if(a<b||b<0)return 0;
	if(a<mod&&b<mod)return 1ll*Fac[a]*((1ll*Inv[a-b]*Inv[b])%mod)%mod;
	return (1ll*C(a%mod,b%mod)*C(a/mod,b/mod)%mod)%mod;
}

inline int calc(int x,int y) {
	int tot=x+y;
	if(tot%3)return 0;
	int a=x-tot/3,b=y-tot/3;
	return C(a+b,a);
}

inline void _main(void) {
	int Case=0,n,m,k;
	Fac[0]=Inv[0]=Fac[1]=V[1]=Inv[1]=1ll;
	ret(i,2,mod) {
		Fac[i]=(1ll*Fac[i-1]*i)%mod;
		V[i]=1ll*(mod-mod/i)*V[mod%i]%mod;
		Inv[i]=(1ll*Inv[i-1]*V[i])%mod;
	}
	while(~scanf("%lld %lld %lld",&n,&m,&k)) {
		int f=0;
		rep(i,1,k) {
			A[i]=(node)<%Read(),Read()%>;
			if(A[i].x==n&&A[i].y==m)f=1;
		}
		A[++k]=(node)<%n,m%>,sort(A+1,A+k+1);
		clr(dp,0);
		rep(i,1,k) {
			dp[i]=calc(A[i].x-1,A[i].y-1);
			ret(j,1,i)if(A[j].y<=A[i].y) {
				int res=(dp[j]*calc(A[i].x-A[j].x,A[i].y-A[j].y))%mod;
				dp[i]=((dp[i]-res)%mod+mod)%mod;
			}
		}
		printf("Case #%lld: %lld\n",++Case,dp[k]);
	}

}

signed main() {
	_main();
	return 0;
}