51nod1486 大大走格子

n<=100000 * m<=100000的网格求不经过给定的h<=2000个点，从左上角到右下角只向右或向下走的方案数。

先来看不经过一个点：

要绕过这个点到右下角，可以先到该点右上角，再下来，或者到该点左下角，再往右。更一般的，是到该点右下角的总方案，减去经过该点的方案数。

如果这个点坐标(n,m)，那么到右下角，方案数就是S(n+1,m+1)-S(n,m)，其中S(i,j)=C(i+j,j)，是到点(i,j)的所有方案数，自行推导。

那如果有多个点呢？我们需要不重复、不遗漏地统计“经过某个点的所有方案”。由于只向右向下，所以统计经过点(i,j)的方案时，必须保证不经过(x,y),x<=i,y<=j的所有点。

那么就按x排序再按y排序所有点，令f(i)表示到点i，不经过任何i左上方的点的方案数，则f(i)=S(Xi-1,Yi-1)-f(j)*S(Xi-Xj,Yi-Yj)，其中Xj<=Xi,Yj<=Yi。先走合法方案到某个点，后面乱走到点i，这样统计方案一定不重复，因为f(j)表示的方案一定不含经过点k，Xk<=Xj,Yk<=Yj的方案，所以f(j)转移过来的方案都没经过他左上方的所有点，这样即使k的方案中可能有经过j，也不会重复。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
//#include<assert.h>
//#include<iostream>
using namespace std;

int n,m,h;
#define maxh 2011
int f[maxh];
struct Point
{
    int x,y;
    bool operator < (const Point &b) const
    {return x<b.x || (x==b.x && y<b.y);}
}a[maxh];
#define maxn 200011
int fac[maxn],inv[maxn];
const int mod=1e9+7;
int powmod(int a,int b)
{
    int ans=1;
    for (;b;a=1ll*a*a%mod,b>>=1) if (b&1) ans=1ll*ans*a%mod;
    return ans;
}
void pre(int n)
{
    fac[0]=1;for (int i=1;i<=n;i++) fac[i]=1ll*fac[i-1]*i%mod;
    inv[n]=powmod(fac[n],mod-2);for (int i=n-1;i>=0;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
}
int C(int n,int m) {return 1ll*fac[n]*inv[n-m]%mod*inv[m]%mod;}
int S(int n,int m) {return C(n+m,n);}
int main()
{
    scanf("%d%d%d",&n,&m,&h);
    for (int i=1;i<=h;i++) scanf("%d%d",&a[i].x,&a[i].y);
    sort(a+1,a+1+h);
    a[++h].x=n;a[h].y=m;
    pre(n+m+2);
    f[1]=S(a[1].x-1,a[1].y-1);
    for (int i=2;i<=h;i++)
    {
        f[i]=S(a[i].x-1,a[i].y-1);
        for (int j=1;j<i;j++)
            if (a[i].y>=a[j].y) f[i]-=1ll*f[j]*S(a[i].x-a[j].x,a[i].y-a[j].y)%mod,
            f[i]+=f[i]<0?mod:0;
    }
    printf("%d
",f[h]);
    return 0;
}