Codeforces559C/51nod1486【DP组合数】

dp[i][j] = dp[i-1][j] + dp[i][j-1]
eeemmmmmmmmm, 杨辉三角C(n+m-2)(n-1)

---

然后就是对于每个点求一下从左上角到他位置不经过一个不能走的点的方案数f[i]，那么就是从左上角到达(x, y)的方案减去所有在他左上方向那些点的f[j]*C(x-x’+1+y-y’+1-2, x-x’+1-1);
OK, 然后发现预处理逆元跑的好快啊！！！

#include <bits/stdc++.h>
using namespace std;
#define mem(a, b) memset(a, b, sizeof(a))
typedef long long LL;
const int Maxn = 2e3 + 10;
const LL mod = 1e9 + 7;

struct asd
{
    LL x, y;
} node[Maxn];
bool cmp(asd a, asd b)
{
    if(a.x == b.x) return a.y < b.y;
    return a.x < b.x;
}
LL dp[Maxn], f[200010], inv[200010];
LL cal(LL g, LL x)
{
    LL ans = 1;
    while(g)
    {
        if(g&1LL) ans = ans * x % mod;
        x = x * x % mod;
        g = g / 2LL;
    }
    return ans;
}
LL C(LL n, LL m)
{
    return f[n] * inv[m] % mod * inv[n-m] % mod;
}

int main()
{
    LL n, m, q;
    f[0] = inv[0] = 1LL;
    for(LL i=1; i<=200005; i++){
        f[i] = f[i-1] * i % mod;
        inv[i]=cal(mod-2LL, f[i]);
    }
    cin>>n>>m>>q;
    for(int i=1; i<=q; i++)
        scanf("%lld%lld",&node[i].x,&node[i].y);
    ++q;
    node[q].x = n, node[q].y = m;
    sort(node+1, node+q+1, cmp);
    for(int i=1; i<=q; ++i)
    {
        dp[i] = C(node[i].x+node[i].y-2LL, node[i].x-1LL);
        for(int j=1; j<i; j++)
            if(node[i].x >= node[j].x && node[i].y >= node[j].y)
                dp[i] = (dp[i] - dp[j] * C(node[i].x-node[j].x+node[i].y-node[j].y, node[i].x-node[j].x) % mod + mod) % mod;
    }
    printf("%I64d\n",dp[q]);
    return 0;
}
/*
100000 100000 4

50001 50001

50000 50000

50000 50001

50001 50000

*/