【CodeChef】KNGHTMOV（方案数DP）

题意：

考虑一张无限大的方格棋盘。我们有一个“骑士”，它必须从(0,0)格开始，按照如下规则，移动至(X,Y)格：每一步，它只能从(u,v)格移动至(u+Ax,v+Ay)或者(u+Bx,v+By)。注意，该规则可能不同于国际象棋中骑士的移动规则。

此外，棋盘上有K个障碍格，骑士不能进入这些格子。

你的任务是计算骑士有多少种到达指定位置的方案。我们认为两种方案不同，当且仅当它们的步数不同，或者存在某个i使得两种方案中，骑士在第i步到达的格子不同。注意，骑士在到达(X,Y)格后还可能继续移动。

对每组数据，输出移动方案数模1000000007（10^9+7）的值。如果有无穷多种方案，输出-1.

所有坐标的绝对值不超过500

(0,0)不是障碍格

(X,Y)不是障碍格

1<=T<=5

对于40%的数据，0<=K<=5

对于100%的数据，0<=K<=15

思路：

向量贡献部分的dp

dp[i][j]表示走i步，当前在位置j的方案数，因为所有向量都已经被压缩成了1维

 详细翻译题解：http://blog.csdn.net/wmdcstdio/article/details/48676173

 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<cmath>
 #include<iostream>
 #include<algorithm>
 #include<map>
 #include<set>
 #include<queue>
 #include<vector>
 using namespace std;
 typedef long long ll;
 typedef unsigned int uint;
 typedef unsigned long long ull;
 typedef pair<int,int> PII;
 typedef vector<int> VI;
 #define fi first
 #define se second
 #define MP make_pair
 #define N   1100000
 #define M   1100
 #define eps 1e-8
 #define MOD 1000000007
 #define pi  acos(-1)

 class Point
 {
     public:
     int x,y;
 };

 ll dp[M*+][M*+];
 bool vis[M*+][M*+];
 bool flag[M*+];
 ll fac[N],inv[N];
 Point b[],A,B,d;
 ll f[];
 int K;

 int read()
 {
    int v=,f=;
    char c=getchar();
    while(c<||<c) {if(c=='-') f=-; c=getchar();}
    while(<=c&&c<=) v=(v<<)+v+v+c-,c=getchar();
    return v*f;
 }

 void add(ll &a,ll &b)
 {
     if(a==-||b==-) a=-;
      else a=(a+b)%MOD;
 }

 bool depend(Point &a,Point &b) //线性相关
 {
     //printf("%d %d %d %d\n",a.x,b.y,a.y,b.x);
     return a.x*b.y==a.y*b.x;
 }

 bool operator < (Point &a,Point &b)
 {
     return a.x+a.y<b.x+b.y;
 }

 void swap_xy()
 {
     swap(A.x,A.y);
     swap(B.x,B.y);
     swap(d.x,d.y);
     for(int i=;i<=K;i++) swap(b[i].x,b[i].y);
 }

 int solve_depend()
 {
     //printf("YES\n");
     //printf("%d %d\n",d.x,d.y);
     if(!depend(A,d)||!depend(B,d)) return ;
     //A,B中可能有0
     if(!A.x&&!A.y&&!B.x&&!B.y)
     {
         if(!d.x&&!d.y) return -;
         return ;
     }
     if(!A.x)
     {
         if(A.y) swap_xy();
          else if(B.x) swap(A,B);
           else
           {
                   swap(A,B);
                   swap_xy();
           }
     }
     memset(dp,,sizeof(dp));
     memset(vis,,sizeof(vis));
     memset(flag,,sizeof(flag));
     for(int i=;i<=K;i++)
      if(depend(b[i],A)&&depend(b[i],B)) flag[b[i].x+M]=;
     if((!A.x&&!A.y)||(!B.x&&!B.y)) dp[][M]=-;
      else dp[][M]=;
     vis[][M]=true;
     ll ans=;
     for(int i=;i<M*;i++)
     {
         for(int j=-M;j<=M;j++)
         {
             int v=j+M;
             if(!flag[v])    //无障碍
             {
                 if(!vis[i][v]) continue;
                 if(j>||j<-||i>) dp[i][v]=-; //若能绕回dest必定有无数种,若回不来那-1也没用
                 if(v+A.x>=&&v+A.x<=*M)    //A
                 {
                     add(dp[i+][v+A.x],dp[i][v]);
                     vis[i+][v+A.x]=true;
                 }
                 if(A.x!=B.x&&v+B.x>=&&v+B.x<=*M) //B
                 {
                     add(dp[i+][v+B.x],dp[i][v]);
                     vis[i+][v+B.x]=true;
                 }
             }
         }
         add(ans,dp[i][d.x+M]);
     }
     return ans;
 }

 bool change(Point &p)
 {
     int k=A.y*B.x-A.x*B.y;
     int a=p.y*B.x-p.x*B.y;
     int b=p.x*A.y-p.y*A.x;
     //printf("%d %d %d\n",k,a,b);
     if(a%k||b%k) return false;
     p.x=a/k; p.y=b/k;
     return true;
 }

 ll C(int x,int y)
 {
     return fac[x]*inv[y]%MOD*inv[x-y]%MOD;
 }

 ll calc(Point &a,Point &b)
 {
     int x=b.x-a.x;
     int y=b.y-a.y;
     if(x<||y<) return ;
     return C(x+y,x);
 }

 int solve_independ()
 {
     if(!change(d)) return ;    //终点在变换后不是整点
     if(d.x<||d.y<) return ;     //终点在变换后不是整点
     int n=;
     for(int i=;i<=K;i++)     //障碍变换
      if(change(b[i]))
       if(b[i].x>=&&b[i].y>=) b[++n]=b[i];
     sort(b+,b+n+);     //障碍排序
     Point O=(Point){,};
     ll ans=calc(O,d);

     for(int i=;i<=n;i++)
     {
         f[i]=calc(O,b[i]);
         for(int j=;j<i;j++)
          f[i]=(f[i]-f[j]*calc(b[j],b[i])%MOD)%MOD;
         ans=(ans-f[i]*calc(b[i],d)%MOD)%MOD;
     }
     ans=(ans%MOD+MOD)%MOD;
     return ans;
 }

 int solve()
 {
     if(depend(A,B)) return solve_depend();
     else return solve_independ();
 }

 int main()
 {
     //freopen("1.in","r",stdin);
     //freopen("1.out","w",stdout);
     fac[]=;
     for(int i=;i<=N-;i++) fac[i]=fac[i-]*i%MOD;
     inv[]=inv[]=;
     for(int i=;i<=N-;i++) inv[i]=inv[MOD%i]*(MOD-MOD/i)%MOD;
     for(int i=;i<=N-;i++) inv[i]=inv[i-]*inv[i]%MOD;
     int cas;
     scanf("%d",&cas);
     while(cas--)
     {
         scanf("%d%d%d",&d.x,&d.y,&K);
         scanf("%d%d%d%d",&A.x,&A.y,&B.x,&B.y);
         for(int i=;i<=K;i++) scanf("%d%d",&b[i].x,&b[i].y);
         printf("%d\n",solve());
     }
     return ;
 }