HDU-5794-A Simple Chess-容斥加数学推导加大组合数

题意：要从（1，1）点走到（n，m）点去。只能走马字，而且只能向右下走。地图上还有r个障碍点，不能通过这些点。问走到终点有多少种路径。

思路：首先画图，观察这些点的形状，容易观察，得到马能走的点是一个变形的杨辉三角。我们可以通过坐标转换，将原来坐标的点转换到新的杨辉三角坐标中。

转换公式：

当然要先判断这个点是不是有效点（能不能被马走到）

if((x-1)*2<(y-1)||(y-1)*2<(x-1)||(x+y)%3!=2) 都是无效点

原来的点(x,y)

现在的点（xx,yy）计算方法 （其中我的xx从0开始的yy从1开始的）

t=(x+y)/3;

yy=y-t;

xx=t;

然后就是对一个杨辉三角型进行处理

每个点(包括障碍和终点)从原点（0,1）（转化过了。。）走到的当前点的路径数为C(n,m-1)

先对障碍点进行排序

然后我们记录一个ans数组  ans[i]表示从原点不通过其他障碍到第i个障碍的路径数

容易得到ans[i]=无障碍路径数-ans[j]*(j到i的路径数)  （j<i）

最后， 到达终点的种数为 无障碍路径数-ans[i]*（i到终点的路径）  i<=lr 

组合数比较大要用一个模版

注意如果有障碍在终点上，答案是0

#include<bits/stdc++.h>
#define LL long long
using namespace std;
struct NODE {
long long x,y;
}c[111];
long long ans[111];

/**大组合数模版**/
const long long p = 110119;
long long PowMod (LL a,LL b,LL MOD){
LL ret=1;
while(b){
if(b&1) ret=(ret*a)%MOD;
a=(a*a)%MOD;
b>>=1;
}
return ret;
}
long long fac[p+10];
void init () {
fac[0]=1;
for(int i=1;i<=p;i++)
fac[i]=(fac[i-1]*i)%p;
}
long long C (LL n,LL m){
if (m > n)
return 0;
LL ret=1;
while(n&&m){
LL a=n%p,b=m%p;
if(a<b) return 0;
ret=(ret*fac[a]*PowMod(fac[b]*fac[a-b]%p,p-2,p))%p;
n/=p;
m/=p;
}
return ret;
}
/**大组合数模版**/

bool cmp(const NODE A,const NODE B) {
if(A.x==B.x) return A.y<B.y;
return A.x<B.x;
}
bool pan(long long x,long long y) { ///判断这个点是不是有效点
if((x-1)*2<(y-1)) return 0;
if((y-1)*2<(x-1)) return 0;
if((x+y)%3!=2) return 0;
return 1;
}
int main()
{
init();
int kase=0;
long long n,m;
int r;
while(scanf("%lld%lld%d",&n,&m,&r)!=EOF) {
int lr=0;
int fa=1;
for(int i=1;i<=r;i++) {
long long txx,tyy;
scanf("%lld%lld",&txx,&tyy);
if(txx==n&&tyy==m) { ///如果有障碍在终点上
fa=0;
}
if(pan(txx,tyy)&&(txx+tyy<n+m)) { ///排除那些在终点后面的障碍
lr++;
c[lr].x=txx;
c[lr].y=tyy;

}
}
if(fa==0||!pan(n,m)) {
printf("Case #%d: 0\n",++kase);
continue;
}
/**点转化**/
long long tt;
for(int i=1;i<=lr;i++) {
tt=(c[i].x+c[i].y)/3;
c[i].y=c[i].y-tt;
c[i].x=tt;
}
tt=(n+m)/3;
m=m-tt;
n=tt;

sort(c+1,c+lr+1,cmp);///障碍点排序
for(int i=1;i<=lr;i++) {
ans[i]=C(c[i].x,c[i].y-1);
for(int j=1;j<i;j++) {
if(c[i].y<c[j].y) continue;
if(c[i].x==c[j].x) continue;
ans[i]=(ans[i]-ans[j]*C(c[i].x-c[j].x,c[i].y-c[j].y)%p+p)%p;///计算路径数
}
}
long long tot=0;
tot=C(n,m-1);
for(int i=1;i<=lr;i++) {
if(m<c[i].y) continue;
tot=(tot-ans[i]*C(n-c[i].x,m-c[i].y)%p+p)%p;
}
printf("Case #%d: %lld\n",++kase,tot);
}
return 0;
}