1309 车的放置（组合计数--乘法原理和加法原理）

1. 问题描述：

有下面这样的一个网格棋盘，a，b，c，d 表示了对应边长度，也就是对应格子数。

当 a=b=c=d=2 时，对应下面这样一个棋盘：

要在这个棋盘上放 k 个相互不攻击的车，也就是这 k 个车没有两个车在同一行，也没有两个车在同一列，问有多少种方案。只需要输出答案 mod 100003 后的结果。

输入格式

共一行，五个非负整数 a，b，c，d，k。

输出格式

包括一个正整数，为答案 mod 100003 后的结果。

数据范围

0 ≤ a，b，c，d，k ≤ 1000

保证至少有一种可行方案。

输入样例：

2 2 2 2 2

输出样例：

38
来源：https://www.acwing.com/problem/content/description/1311/

2. 思路分析：

分析题目可以知道给出的其实是不规则的图形，不能够整体考虑，所以我们需要考虑能否将不规则的图形转换为规则的图形进行求解，我们可以将其分为上半部分与下部分来求解对应的方案数目，依次考虑每一部分的方案数目，两者相乘的结果就是最终的答案，最终可以得到下图中的式子，这样我们就可以通过求解组合数和排列数求解出最终的答案，由于数据规模较小我们可以预处理出对应的阶乘以及阶乘的逆元，因为mod = 100003为一个质数，所以根据费马小定理可以知道a ^ (p - 1) ≡ 1(mod p)，其中p是质数，则 a ^ (p - 2) * a ≡ 1 (mod p)，a ^ (p - 2)就是a关于p的逆元，所以可以使用快速幂来求解a关于p的逆元即可，核心是分析得到数学表达式的过程。

3. 代码如下：

from typing import List


class Solution:
    # 快速幂
    def quickPower(self, a: int, b: int, mod: int):
        res = 1
        while b:
            if b & 1:
                res = res * a % mod
            a = a * a % mod
            b >>= 1
        return res

    # 使用公式求解组合数
    def C(self, a: int, b: int, mod: int, fact: List[int], infact: List[int]):
        if a < b: return 0
        return fact[a] * infact[a - b] % mod * infact[b] % mod

    # 使用公式求解排列数
    def P(self, a: int, b: int, mod: int, fact: List[int], infact: List[int]):
        # 当a < b的时候方案数目为0
        if a < b: return 0
        return fact[a] * infact[a - b] % mod

    def process(self):
        a, b, c, d, k = map(int, input().split())
        # 组合数计算的时候边长最大是2000, a + c最大是2000
        N, mod = 2010, 100003
        fact, infact = [0] * N, [0] * N
        # 预处理阶乘以及对应的逆元(逆元为取模意义下的逆元)
        fact[0] = infact[0] = 1
        for i in range(1, N):
            fact[i] = fact[i - 1] * i % mod
            infact[i] = infact[i - 1] * self.quickPower(i, mod - 2, mod) % mod
        res = 0
        for i in range(k + 1):
            # 枚举上方可能的车的数量i, i = [0, k], 使用公式计算计算出对应的结果
            res = (res + self.C(b, i, mod, fact, infact) *
                   self.P(a, i, mod, fact, infact) % mod *
                   self.C(d, k - i, mod, fact, infact) % mod *
                   self.P(a + c - i, k - i, mod, fact, infact))% mod
        return res


if __name__ == '__main__':
    print(Solution().process())