Bzoj4767 两双手

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 553  Solved: 160

Description

老W是个棋艺高超的棋手，他最喜欢的棋子是马，更具体地，他更加喜欢马所行走的方式。老W下棋时觉得无聊，便

决定加强马所行走的方式，更具体地，他有两双手，其中一双手能让马从(u,v)移动到(u+Ax,v+Ay)而另一双手能让

马从(u,v)移动到(u+Bx,v+By)。小W看见老W的下棋方式，觉得非常有趣，他开始思考一个问题：假设棋盘是个无限

大的二维平面，一开始马在原点(0,0)上，若用老W的两种方式进行移动，他有多少种不同的移动方法到达点(Ex,Ey

)呢？两种移动方法不同当且仅当移动步数不同或某一步所到达的点不同。老W听了这个问题，觉得还不够有趣，他

在平面上又设立了n个禁止点，表示马不能走到这些点上，现在他们想知道，这种情况下马有多少种不同的移动方

法呢？答案数可能很大，你只要告诉他们答案模(10^9+7)的值就行。

 

Input

第一行三个整数Ex,Ey,n分别表示马的目标点坐标与禁止点数目。

第二行四个整数Ax,Ay,Bx,By分别表示两种单步移动的方法，保证Ax*By-Ay*Bx≠0

接下来n行每行两个整数Sxi,Syi，表示一个禁止点。

|Ax|,|Ay|,|Bx|,|By| <= 500, 0 <= n,Ex,Ey <= 500

 

Output

仅一行一个整数，表示所求的答案。

 

Sample Input

4 4 1
0 1 1 0
2 3

Sample Output

40

HINT

 

Source

说起来，为什么是两双手不是两只手啊

数学问题 动规 向量 容斥

很明显，A、B两向量不共线的话，从起点到终点这一向量可以被A、B两向量唯一表示。

愉快地解个方程吧，设A用了X次，B用了Y次，终点为(Ex,Ey)

$ Ax * X + Bx * Y =Ex $

$ Ay * X + By * Y =Ey $

解出来就是代码里那个样子（逃）

总共X+Y步，假设从中选Y步使用B向量，那么剩下的步就是A向量，所以方案数总共有 $ G[i]=C_{X+Y}^{Y} $ 种

由于路上有障碍，所以需要减掉不合法的方案数。

对于每个障碍点i，枚举在它之前走过的点j，合法方案数 $ F[i]= G[i]-sum_{j=1}^{i-1}F[j]*g[j][i] $ ←g[j][i]表示从j到i（中间没有路障）的方案数

刚开始写了即时算步数并计算方案数，然而好像出现了微妙的容斥错误，最后一个点过不去。

死活调不对，不得已换成了一开始就离散化出到达每个点需要步数的写法

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#define LL long long
using namespace std;
const int mod=1e9+7;
const int mxn=1200000;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct point{
    int x,y;
    bool operator < (const point b)const{return x<b.x;}
}s[mxn];
int n,Ex,Ey;
int ax,ay,bx,by;
int SA,SB;
LL fac[mxn];
LL inv[mxn];
void init(){
    fac[1]=1;inv[1]=1;
    fac[0]=1;inv[0]=1;
    for(int i=2;i<mxn;i++){
        fac[i]=(LL)fac[i-1]*i%mod;
        inv[i]=((-mod/i)*inv[mod%i]%mod+mod)%mod;
    }
    for(int i=2;i<mxn;i++) inv[i]=inv[i]*inv[i-1]%mod;
//  for(int i=1;i<=100;i++)printf("i:%d %lld
",i,inv[i]);
    return;
}
bool GST(int u,int v){
    int x0=s[v].x-s[u].x;
    int y0=s[v].y-s[u].y;
    int a=x0*ay-y0*ax,b=bx*ay-by*ax;
    if(a%b)return 0;else SA=a/b;
    a=x0*by-y0*bx,b=ax*by-ay*bx;
    if(a%b)return 0;else SB=a/b;
    return 1;
     
/*  int tmp=y0*ax-x0*ay;
    int t2=ax*by-ay*bx;
    if(tmp%t2)return 0;
    else SB=tmp/t2;
    tmp=y0*bx-x0*by;
    t2=bx*ay-by*ax;
    if(tmp%t2)return 0;
    else SA=tmp/t2;
    return 1;*/
}
inline LL calc(int n,int m){
    if(n<m)return 0;
    return fac[n]*inv[m]%mod*inv[n-m]%mod;
}
LL f[mxn];
void solve(){
    int i,j;
//  printf("%d %d %d %d
",ax,ay,bx,by);
    for(i=1;i<=n;i++){
        if(!GST(0,i))continue;
//      printf("x:%d y:%d
",s[i].x,s[i].y);
//      printf("SA:%d SB:%d
",SA,SB);
        f[i]=calc(SA+SB,SA);
        for(j=1;j<i;j++){
//          if(s[j].x<=s[i].x && s[j].y<=s[i].y){
                if(!GST(j,i))continue;
//              printf("j%d:SA:%d SB:%d %lld
",j,SA,SB,calc(SA+SB,SA));
                f[i]=(f[i]-(f[j]*calc(SA+SB,SA))%mod+mod)%mod;
//          }
        }
//      printf("f[%d]:%lld
",i,f[i]);
    }
    printf("%lld
",f[n]);
    return;
}
int main(){
//  freopen("in.txt","r",stdin);
    init();
    int i,j;
    Ex=read();Ey=read();n=read();
    ax=read();ay=read();bx=read();by=read();
    for(i=1;i<=n;i++){
        s[i].x=read(),s[i].y=read();
/*      if(s[i].x>Ex || s[i].y>Ey){
            i--;n--;
        }*/
    }
    ++n;s[n].x=Ex,s[n].y=Ey;
    if(!GST(0,n)){
        printf("0
");return 0;
    }
    sort(s+1,s+n);
    solve();
    return 0;
}

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#define LL long long
using namespace std;
const int mod=1e9+7;
const int mxn=1200000;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct point{
    int x,y;bool ban;
    bool operator < (const point b)const{
        return (x<b.x)||(x==b.x && y==b.y);
    }
}s[mxn];
int n,Ex,Ey;
int ax,ay,bx,by;
int SA,SB;
LL fac[mxn];
LL inv[mxn];
void init(){
    fac[1]=1;inv[1]=1;
    fac[0]=1;inv[0]=1;
    for(int i=2;i<mxn;i++){
        fac[i]=(LL)fac[i-1]*i%mod;
        inv[i]=((-mod/i)*inv[mod%i]%mod+mod)%mod;
    }
    for(int i=2;i<mxn;i++) inv[i]=inv[i]*inv[i-1]%mod;
    return;
}
bool ban[mxn];
bool GST(int u,int v){
    int x0=s[v].x-s[u].x;
    int y0=s[v].y-s[u].y;
/*    int a=x0*ay-y0*ax,b=bx*ay-by*ax;
    if(a%b)return 0;else SA=a/b;
    a=x0*by-y0*bx,b=ax*by-ay*bx;
    if(a%b)return 0;else SB=a/b;
    return 1;*/
    int tmp=y0*ax-x0*ay;
    int t2=ax*by-ay*bx;
    if(tmp%t2)return 0;
    else SB=tmp/t2;
    tmp=y0*bx-x0*by;
    t2=bx*ay-by*ax;
    if(tmp%t2)return 0;
    else SA=tmp/t2;
    return 1;
}
inline LL calc(int n,int m){
    if(n<m)return 0;
    return fac[n]*inv[m]%mod*inv[n-m]%mod;
}
LL f[mxn];
void solve(){
    int i,j;
    for(i=1;i<=n;i++){
        f[i]=calc(s[i].x+s[i].y,s[i].x);
        for(j=1;j<i;j++){
            if(s[j].x<=s[i].x && s[j].y<=s[i].y){
                f[i]=(f[i]-(f[j]*calc(s[i].x-s[j].x+s[i].y-s[j].y,s[i].x-s[j].x))%mod+mod)%mod;
            }
        }
//        printf("f[%d]:%lld
",i,f[i]);
    }
    printf("%lld
",f[n]);
    return;
}
int main(){
//    freopen("in.txt","r",stdin);
    init();
    int i,j;
    Ex=read();Ey=read();n=read();
    ax=read();ay=read();bx=read();by=read();
    for(i=1;i<=n;i++){
        s[i+1].x=read(),s[i+1].y=read();
    }
    ++n;s[1].x=Ex,s[1].y=Ey;
    if(!GST(0,1)){
        printf("0
");return 0;
    }
    s[1].x=SA;s[1].y=SB;
    int cnt=1;
    for(i=2;i<=n;i++){
        if(!GST(0,i))continue;
        s[++cnt].x=SA;s[cnt].y=SB;
        if(s[cnt].x>s[1].x || s[cnt].x>s[1].y)cnt--;
    }
    n=cnt;
    sort(s+1,s+n+1);
    solve();
    return 0;
}