2023牛客寒假算法基础集训营6 L-阿宁睡大觉

题目描述：

n行n列的地图，第i行有n−i+1个格子。每行的最后一个格子是美梦格子。有些格子是噩梦格子。

梦的开始，阿宁在第1行第1列。每次可以向下或向右走一格，最终到达一个美梦格子。路途中的噩梦格子不会走进去。

求有多少种路径从(1,1)走到美梦格子？

输入：

n,m(1<=n<=2e5,0<=m<=10)表示地图规模和噩梦格子的个数

下面m行x,y代表噩梦格子的坐标

输出：

有多少种路径从(1,1)走到美梦格子，由于答案过大，对1e9+7取模

Solution：

要求从(1,1)走到所有美梦格子的方案数，我们便需减去每个噩梦格子所影响的方案数，但是我们不能简单地减去从某个噩梦格子到所有美梦格子的方案数，因为在这种方案数中也可能走过噩梦格子，故此处我们采用容斥的办法，去枚举走过n个噩梦格子到所有美梦格子的方案数，由于是从（1,1）出发的，当n为偶数时，我们需要减去该种情况下的方案数，当n为奇数时则需要加上，同时，走法只有向下或者向右，故对于每一种方案我们需要判断是否存在一个点在另一个点的右上，如果存在则该方案数为0。

而对于任意两个点（x1,y1）,(x2,y2)，（x1<=x2,y1<=y2）之间的路径数，我们可以用组合数的方法，C（x2+y2-x1-y1,x2-x1）（此处可通过杨辉三角或者看成共走x2+y2-x1-y1步横着走x2-x1步的方案数有几种），而最后一个点到所以美梦格子的方案数即为2^(n-1-(xd+yd-2))。

C++code：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int>PII;
const int N = 2e5 + 10, mod = 1e9 + 7;

int n, m;
ll fact[N], infact[N];
//快速幂求逆元
ll qmi(ll t, ll k, ll p) {
    ll res = 1 % p;
    while (k) {
        if (k & 1)res = res % p * t % p;
        t = t % p * t % p;
        k >>= 1;
    }
    return res;
}
//初始化阶乘和阶乘逆元
void init() {
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i++) {
        fact[i] = fact[i - 1] * i % mod;
        infact[i] = infact[i - 1] * qmi(i, mod - 2, mod) % mod;
    }
}
//求组合数
ll C(ll a, ll b, ll p) {
    return fact[a] % p * infact[a - b] % p * infact[b] % p;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    init();
    cin >> n >> m;
    vector<PII>cor(m);
    for (auto& a : cor)cin >> a.first >> a.second;

    ll res = qmi(2, n - 1, mod);//(1,1)到所有美梦格子的方案数
    for (int i = 1; i < 1 << m; i++) {//枚举容斥的各种状态
        vector<PII>pla;
        pla.push_back({ 1,1 });
        int sign = 1;
        for (int j = 0; j < m; j++) {
            if (i >> j & 1) {
                pla.push_back(cor[j]);
                sign = -sign;
            }
        }
        sort(pla.begin(), pla.end());
        ll temp = qmi(2, n - pla[pla.size() - 1].first - pla[pla.size() - 1].second + 1, mod);//计算最后一个点到所有美梦格子的方案数
        for (int k = 1; k <= pla.size() - 1; k++) {//计算两两噩梦格子之间的方案数
            if (pla[k].second >= pla[k - 1].second) {
                ll a = pla[k].first - pla[k - 1].first;
                ll b = pla[k].second - pla[k - 1].second;
                temp = temp * C(a + b, a, mod) % mod;
            }
            else {
                temp = 0;
                break;
            }
        }
        res += (temp * sign);
    }
    res = (res % mod + mod) % mod;
    cout << res << endl;
    return 0;
}