洛谷T438955 不同路径问题题解组合数

最新推荐文章于 2024-05-09 21:25:10 发布

bbc_ouo

最新推荐文章于 2024-05-09 21:25:10 发布

阅读量751

点赞数 18

分类专栏：新生训练赛题解文章标签： c++ 算法

本文链接：https://blog.csdn.net/bbc_plus/article/details/137238410

版权

新生训练赛题解专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Lackofgod走迷宫

题目描述

$L a c k o f g o d$ 身处一个 $n * m$ 的迷宫内，他初始位于 $(1, 1)$ 处，迷宫的终点位于 $(n, m)$ ， $L a c k o f g o d$ 每次只能往右或往下移动一步，即从 $(x, y)$ 移动到 $(x + 1, y)$ 或 $(x, y + 1)$ ，迷宫里存在 $k$ 个障碍物， $L a c k o f g o d$ 不能走到迷宫外，也不能撞到障碍物，请告诉他有多少种方案可以走到迷宫终点，答案对 $10^9+7$ 取模

输入格式

第一行输入三个整数 $n, m, k$ ，表示迷宫的大小以及障碍物的个数

接下来 $k$ 行，每行输入两个整数 $x_i,y_i$ ，表示第 $i$ 个障碍物的位置，保证起点和终点不存在障碍物，保证任意两个障碍物不重叠

$1\le n,m \le 10^6$ ， $n*m\ge2$ ， $0\le k\le min(n*m-2,20)$

$1\le x_i\le n$ , $1\le y_i\le m$

输出格式

一行输出一个整数 $an s$ ，表示走到迷宫终点的方案数（ $mod\ 10^9+7$ ）

样例 #1

样例输入 #1

3 4 2
2 2
2 3

样例输出 #1

原题链接

洛谷T438955——传送门

思路

求迷宫不同路径条数，最先想到的是dp递推，但是我们发现本题的n和m很大，用O(n*m)的递推算法显然是会超时的，所以就得放弃另辟蹊径。经过~~千辛万苦的~~观察，我们发现障碍物的个数最多20个，所以可以通过不经过障碍物的方案数==不考虑障碍物的方案数-经过障碍物的方案数这个等式来计算得到答案。显然根据学习可知，求迷宫内一个点到另一个点的方案数可采用求组合数的方式，即从点A(x1,y1)到点B(x2,y2)的(x1≤x2且y1≤y2)方案数为C(x2-x1+y2-y1,x2-x1)，即从(x2-x1)次向下走和(y2-y1)次向右走中选择(x2-x1)次向下走。
不考虑障碍物的方案数：C(n-1+m-1,n-1)
经过障碍物的方案数：设dp_i表示不经过其他障碍物，到达第i个障碍物的方案数。所以dp_i就等于到达第i个障碍物的方案数减去 ∑(经过该障碍物前面某个障碍物再到达第i个障碍物的方案数)(详见代码)。最后，经过障碍物的方案数就等于 ∑(dp_i乘以从该障碍物到终点的方案数)。显然，这就需要对读入的障碍物的坐标进行排序。
注意，在这计算过程中用到了减法取模运算，所以结果有可能是个负数，需要判断为负数时加上模数。~~我就是因为这点被卡了半天。~~

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// 因为组合数的分母最大取到n+m-2，所以N要开到2e6
const int N = 2e6 + 6;
const int MOD = 1e9 + 7;
int fact[N], invf[N];
// 快速幂
int qpow(int a, int b, int p)
{
    int res = 1;
    while (b)
    {
        if (b & 1)
            res = (1ll * res * a) % p;
        a = (1ll * a * a) % p;
        b /= 2;
    }
    return res % p;
}
// 对组合数进行初始化
void init(int n)
{
    fact[0] = 1;
    for (int i = 1; i <= n; i++)
        fact[i] = (1ll * fact[i - 1] * i) % MOD;
    invf[n] = qpow(fact[n], MOD - 2, MOD);
    for (int i = n - 1; i >= 0; i--)
        invf[i] = (1ll * invf[i + 1] * (i + 1)) % MOD;
}
// 求组合数，其中用到乘法逆元
int C(int a, int b, int p)
{
    return (ll)fact[a] * invf[b] % p * invf[a - b] % p;
}
// 结构体存储障碍物坐标
struct node
{
    int x, y;
};
// 障碍物按纵坐标排序，纵坐标相同按横坐标排序
bool cmp(node a, node b)
{
    if (a.x == b.x)
    {
        return a.y < b.y;
    }
    else
    {
        return a.x < b.x;
    }
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    // 初始化组合数的函数调用，勿忘
    init(2e6 + 5);

    int n, m, k;
    cin >> n >> m >> k;
    // 障碍物数组
    vector<node> obstacle(k);
    for (int i = 0; i < k; i++)
    {
        cin >> obstacle[i].x >> obstacle[i].y;
    }
    // 排序
    sort(obstacle.begin(), obstacle.end(), cmp);
    // dp数组
    ll dp[26] = {0};
    // 求dpi
    for (int i = 0; i < k; i++)
    {
        int xi = obstacle[i].x;
        int yi = obstacle[i].y;
        // 不考虑前面障碍物到达该障碍物的方案数
        dp[i] = C(xi - 1 + yi - 1, xi - 1, MOD);
        // 减去经过前面障碍物到达该障碍物的方案数
        for (int j = 0; j < i; j++)
        {
            int xj = obstacle[j].x;
            int yj = obstacle[j].y;
            // 如果yi小于yj，说明第j个障碍物不在第i个障碍物前面，需要continue
            if (yi < yj)
                continue;
            dp[i] = (dp[i] - (ll)dp[j] * C(xi - xj + yi - yj, xi - xj, MOD) % MOD) % MOD;
        }
    }
    // 不考虑障碍物到达终点的方案数
    ll ans = C(n - 1 + m - 1, n - 1, MOD);
    // 减去经过障碍物到达终点的方案数
    for (int i = 0; i < k; i++)
    {
        int xi = obstacle[i].x;
        int yi = obstacle[i].y;
        ans = (ans - (ll)dp[i] * C(n - xi + m - yi, n - xi, MOD) % MOD) % MOD;
    }
    // 特判取模相减后ans<0的情况
    if (ans < 0)
        ans += MOD;

    cout << ans;

    return 0;
}