题解：P14435 [JOISC 2013] 收拾吉祥物 / Mascots

\(\displaystyle{\large\textcolor{#00A0DE}{蓝是水的颜色}}\)，所以我们来水一下这道蓝题的题解。

题目传送门

题意理解

我们首先给出一个 \(R\times C\) 的方格图，在其中任意 \(n\) 坐标中初始放着物品，我们依次选定坐标放入物品，使这个过程中出现有且仅有一个矩形的次数最多。

在锁定这个最多次数以后，我们需要求出满足这个次数的方案个数。

题意分析

\(\mathcal {Step\ 1}\)：贪心规划放点策略

首先我们要使矩形次数最多，先要采取贪心的策略。对于初始化给出的散点，我们要让他们变成有且仅有一个的矩形还不够，为了我们后续的健康，所以我们要求出一个包裹这些散点的最小矩形凸壳，这是显而易见的。

接下来对于这个小矩形，我们要对他进行拓展，拓展到一个大小为 \(R\times C\) 的大矩形。这时要进行矩形出现次数最大化，我们贪心地想，每次选取这个小矩形的一条边进行扩展，扩展出一个 长或宽只差 1 的矩形，就成为了最优解。

对于这个策略可以反证法来证明，在这里我们只举一个反例就可以理解了，我们现在矩形的右边扩展边填满部分，再将上面的扩展边填充部分，最后结果向斜向上扩展了一层，但是小确幸却只增加了 \(1\) ，得不偿失。我们要是先专心扩展最右边，再扩展最上面，就得到了 \(2\) 的小确幸。

\(\mathcal {Step\ 2}\)：多重集排列求解方案个数

这里是重中之重！

一、 DP

我们先割裂地看这个问题，不去考虑这个矩形的位置，先看它的形状，我们不难发现我们可以只考虑两种操作：纵向和横向操作，二元的操作比四元的操作简单太多了，并且确实只需要横或纵的扩展就可以达到 \(R\times C\)。

接着我们把这个从 \(h\times w\) 扩展到 \(R\times C\) 的总问题扩展到若干个子问题，发现每个子问题之间是差不多无后效性的，二维表研究组合方案个数？这个好耳熟，不就是 \(\operatorname {DP(Dynamic\ Programming)}\) 吗？为什么要把它的全名写出来，因为 \(“Dynamic”\) 为动态, \(“Programming”\) 指一种表格法。

我们锁定这个原矩形的右上端点在新坐标系的 \((0,0)\) 处，我们要扩展到 \((H,W)\) 处，而 \(H=R-h,W=C-w\)。单次扩展的方案数为 \((length!)\)。我们就可以写出动态转移方程式：

\[\displaystyle{\Large{dp_{i,j}=w_{now}!\times dp_{i-1,j}\ +\ h_{now}!\times dp_{i,j-1} }} \]

这个方程的意义理解是：

当前的矩形方案数等于纵向的方案数加边上方案数加横向来的方案数乘边上方案数。

最后也是轻轻松松打下第一部分的想法。

二、多重集求排列

多重集排列是什么？可以吃吗？
首先这是一个数学工具，肯定不可以吃。
多重集排列不同于多元单重排列，我们每个元素都有给定个数 \(k_i\)，对于这些元素进行排列组合的计算难度就要大一些，不过有趣的计算方式是，我们可以还是将他们看成 \(\sum k_i\) 个元素，并且进行排列组合，然后把它们每个元素种类割裂开来，筛除不合法的方案，也就是除以 \(\prod k_i!\)。

多重集的公式是什么？
对于当前的二元集，我们设他们的元素个数分别为 \(k_1,k_2\)，则方案个数为：

\[\displaystyle{\Large{\frac{(k_1+k_2)!}{k_1!\ k_2!}}}\\ \ \\ \displaystyle{\Large{P_{cur\_direction}=(k_1+k_2)!\times (k_1!)^{-1}\times (k_2!)^{-1}}} \]

这里的 \((k!)^{-1}\) 表示阶乘的逆。后面一个式子因为这不是数学竞赛而是信息竞赛，我们不能直接甩两个阶乘到分母上，我们利用费马小定理求出阶乘的逆就好了。

为什么需要多重集排列？
扩展过程中，同方向的不同类型扩展（如“向上”和“向下”）的顺序会产生不同的放置方案，但同类扩展（如两次“向上”）的顺序不影响（因为都是向同一方向扩展，最终矩形相同，但放置顺序不同仍算不同方案）。“填充”这个事件的方案和“扩展顺序”这个事件的方案是独立事件，对于单个扩展方向，我们做一次二元多重集求排列，意在算出正逆向的扩展顺序对当前方向方案个数的影响，由于事件是独立的，所以他的影响是个乘积。

例如：

• 行扩展需要 \(2\) 步： \(1\) 次向上和 \(1\) 次向下。
• 可能的顺序有：先向上再向下，或先向下再向上。这两种是不同的扩展顺序，对应不同的放置方案，因此需要计算这类顺序的总数。

实现

流程大致为：

• 初始化阶乘和逆阶乘；
• 求初始矩形凸壳，统计其中加点个数求出其阶乘；
• DP 求出扩展方案个数；
• 多重集排列求出扩展顺序方案个数；
• 加加乘乘算出答案；
• 十年 OI 一场空，不开——见祖宗，不取模也见祖宗。

\(\mathbb{CODE}\)

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    int R, C, N;
    cin >> R >> C;
    cin >> N;

    // 计算初始矩形的边界
    int xmin = R, xmax = 1;  // 行方向边界
    int ymin = C, ymax = 1;  // 列方向边界
    for (int i = 0; i < N; ++i) {
        int x, y;
        cin >> x >> y;
        xmin = min(xmin, x);
        xmax = max(xmax, x);
        ymin = min(ymin, y);
        ymax = max(ymax, y);
    }

    // 初始矩形的高度和宽度
	// 初始矩形内的空格数（需要填充的数量）
	// 行方向总扩展步数 H = 向上扩展数 + 向下扩展数
	// 列方向总扩展步数 W = 向左扩展数 + 向右扩展数
    int h0 = xmax - xmin + 1;
    int w0 = ymax - ymin + 1;
    int res = h0 * w0 - N;
    int H = R - h0;
    int W = C - w0;

    // 计算行方向的上下扩展数（up = xmin-1，down = H - up）
	// 计算列方向的左右扩展数（left = ymin-1，right = W - left）
    int up = xmin - 1;
    int down = H - up;
    int left = ymin - 1;
    int right = W - left;

    // 预处理阶乘和逆阶乘
    int maxn=max({res,H,W,R,C});
    vector<long long> fact(maxn + 1);
    vector<long long> inv_fact(maxn + 1);

    // 计算阶乘
    fact[0] = 1;
    for (int i = 1; i <= maxn; ++i) {
        fact[i] = fact[i - 1] * i % MOD;
    }

    // 计算逆阶乘
    inv_fact[maxn] = 1;
    long long base = fact[maxn];
    int exp = MOD - 2;
    while (exp) {
        if (exp & 1) inv_fact[maxn] = inv_fact[maxn] * base % MOD;
        base = base * base % MOD;
        exp >>= 1;
    }
    for (int i = maxn - 1; i >= 0; --i) {
        inv_fact[i] = inv_fact[i + 1] * (i + 1) % MOD;
    }

    //dp[a][b] 表示完成a次行扩展和b次列扩展的总排列数
    vector<vector<long long>> dp(H + 1, vector<long long>(W + 1, 0));
    dp[0][0] = fact[res];  // 初始状态

    for (int a = 0; a <= H; ++a) {
        for (int b = 0; b <= W; ++b) {
            if (a == 0 && b == 0) continue;
			long long val = 0;
			
            // 若可从行扩展转移（上一步是第a-1次行扩展）
            if (a > 0) {
                int current_width = w0 + b;  // 当前宽度 = 初始宽度 + 列扩展次数
                val = (val + dp[a - 1][b] * fact[current_width]) % MOD;
            }
            // 若可从列扩展转移（上一步是第b-1次列扩展）
            if (b > 0) {
                int current_height = h0 + a;  // 当前高度 = 初始高度 + 行扩展次数
                val = (val + dp[a][b - 1] * fact[current_height]) % MOD;
            }
            dp[a][b] = val;
        }
    }

    // 计算行扩展的多重集排列数：H! / (up! * down!)
	// 计算列扩展的多重集排列数：W! / (left! * right!)
    long long term1 = fact[H] * inv_fact[up] % MOD;
    term1 = term1 * inv_fact[down] % MOD;
    
    long long term2 = fact[W] * inv_fact[left] % MOD;
    term2 = term2 * inv_fact[right] % MOD;

    // 总方案数 = dp[H][W] * 行排列数 * 列排列数
    long long ans = dp[H][W] * term1 % MOD;
    ans = ans * term2 % MOD;

    cout << ans << endl;
    return 0;
}