2016多校训练Contest6: 1002 A Simple Chess hdu5794

Problem Description

There is a  n×m  board, a chess want to go to the position 
(n,m)  from the position  (1,1) .
The chess is able to go to position  (x2,y2)  from the position  (x1,y1) , only and if only  x1,y1,x2,y2  is satisfied that  (x2−x1)2+(y2−y1)2=5, x2>x1, y2>y1 .
Unfortunately, there are some obstacles on the board. And the chess never can stay on the grid where has a obstacle.
I want you to tell me, There are how may ways the chess can achieve its goal.

 

Input

The input consists of multiple test cases.
For each test case:
The first line is three integers,  n,m,r,(1≤n,m≤1018,0≤r≤100) , denoting the height of the board, the weight of the board, and the number of the obstacles on the board.
Then follow  r  lines, each lines have two integers,  x,y(1≤x≤n,1≤y≤m) , denoting the position of the obstacles. please note there aren't never a obstacles at position  (1,1) .

 

Output

For each test case,output a single line "Case #x: y", where x is the case number, starting from 1. And y is the answer after module  110119 .

 

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
  
  

似乎数据特别水。。只要把不可到达的点删掉然后2^k容斥就可以直接过了。。并不明白怎么造的数据

正常的做法的话。。

我们用f[i]维护到某个障碍前面不经过任何障碍的方案数

然后转移的时候算出1,1到i的次数，

枚举1到i-1所有的障碍，乘走过中间部分的方案数，把这些减去

最后r+1加入终点

ans就是f[r+1]

这样复杂度是r^2的。

1,1到x,y的方案数，我们考虑马的走法，可以换成先往右下走一格，然后往右或者往下走。

因为总步数一定，所以可以组合数求解

拖了个lucas模版

#include<map>
#include<cmath>
#include<queue>
#include<vector>
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
struct obstacles
{
	long long x,y;
	bool operator <(obstacles z) const
	{
		return x<z.x||x==z.x&&y<z.y;
	}
}a[1001];
long long f[1001];
long long mod=110119;
long long p1[1000001],p2[1000001];
inline long long PowMod(long long a,long long b)
{  
    long long ret=1;  
    while(b)
	{  
        if(b&1)
			ret=(ret*a)%mod;  
        a=(a*a)%mod;  
        b>>=1;  
    }  
    return ret;  
}  
long long fac[1000005];  
inline long long Get_Fact(long long p)
{  
    fac[0]=1;  
    for(int i=1;i<=p;i++)  
        fac[i]=(fac[i-1]*i)%p;  
}  
inline long long Lucas(long long n,long long m,long long p)
{  
    long long ret=1;  
    while(n&&m)
	{  
        long long a=n%mod,b=m%mod;  
        if(a<b) return 0;  
        ret=(ret*fac[a]*PowMod(fac[b]*fac[a-b]%p,p-2))%p;  
        n/=p;  
        m/=p;  
    }  
    return ret;  
} 
inline long long cale(int i,int j)
{
	long long n=a[j].x-a[i].x,m=a[j].y-a[i].y;
	if((m+n)%(long long)3!=0)
		return 0;
	long long step=(m+n)/(long long)3;
	n-=step;
	m-=step;
	if(n<0||m<0)
		return 0;
	return Lucas(n+m,m,mod);
}
inline bool check(int i,int j)
{
	if(a[i].x>a[j].x||a[i].y>a[j].y)
		return false;
	return true;
}
int main()
{
	Get_Fact(mod);
	int k=0;
	long long n,m;
	int r;
	while(scanf("%I64d%I64d%d",&n,&m,&r)!=EOF)
	{
		k++;		
		int i,j;
		for(i=1;i<=r;i++)
			scanf("%I64d%I64d",&a[i].x,&a[i].y);
		r++;
		a[i].x=n;
		a[i].y=m;
		sort(a+1,a+1+r);
		a[0].x=1;
		a[0].y=1;
		f[0]=1;
		for(i=1;i<=r;i++)
		{
			f[i]=cale(0,i);
			for(j=1;j<=i-1;j++)
			{
				if(check(j,i))
					f[i]-=f[j]*cale(j,i)%mod;
				while(f[i]<0)
					f[i]+=mod;
			}
		}
		printf("Case #%d: %I64d\n",k,f[r]);
	}
	return 0;
}