数口罩

题目描述

有 \(n\) 名学生排成了一列长队，每名学生都戴口罩，口罩的式样共有 \(m\) 种。每一名学生都比较关心排在他前面的学生中，有多少人带的口罩式样和他是相同的。设 \(a_i\)
表示在第 \(i\) 名学生前的 \(i-1\) 名学生中，有 \(a_i\) 名学生戴的口罩式样与他一模一样，请问有多少种不同的排队方案，能够使得与给定数据一致？输出答案对 \(10^9 + 7\) 取模，若不可能出现输入的情况，则输出 0

限制：

• \(1 \leqslant n \leqslant 10^5\)
• \(1 \leqslant m \leqslant 100\)

算法分析

记 \(C[i]\) 表示恰染了 \(i\) 次的同种颜色的颜色数量

考察以下这个例子：

\( A = [0, 0, 1, 0, 1, 1, 2] \)

一开始没有染色，所以 \(C[0] = 3\)
对于第一个口罩，可以染的颜色有 \(3\) 种，所以可以把 \(3\) 乘进答案里，此时 \(C[0] = 2\)，\(C[1] = 1\)；
对于第二个口罩，可以染的颜色有 \(2\) 种，所以可以把 \(2\) 乘进答案里，此时 \(C[0] = 1\)，\(C[1] = 2\)；
对于第三个口罩，可以染的颜色有 \(2\) 种，所以可以把 \(2\) 乘进答案里，此时 \(C[0] = 1\)，\(C[1] = 1\)，\(C[2] = 1\)；
对于第四个口罩，可以染的颜色有 \(1\) 种，所以可以把 \(1\) 乘进答案里，此时 \(C[0] = 0\)，\(C[1] = 2\)，\(C[2] = 1\)；
对于第五个口罩，可以染的颜色有 \(2\) 种，所以可以把 \(2\) 乘进答案里，此时 \(C[0] = 0\)，\(C[1] = 1\)，\(C[2] = 2\)；
对于第六个口罩，可以染的颜色有 \(1\) 种，所以可以把 \(1\) 乘进答案里，此时 \(C[0] = 0\)，\(C[1] = 0\)，\(C[2] = 3\)；
对于第七个口罩，可以染的颜色有 \(3\) 种，所以可以把 \(3\) 乘进答案里，此时 \(C[0] = 0\)，\(C[1] = 0\)，\(C[2] = 2\)，\(C[3] = 1\).

所以最后的答案就是 \(3 \times 2 \times 2 \times 1 \times 2 \times 1 \times 3 = 72\)

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;
using ll = long long;

//const int mod = 998244353;
const int mod = 1000000007;
struct mint {
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod) {}
    mint operator-() const {
        return mint(-x);
    }
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        return mint(*this) += a;
    }
    mint operator-(const mint a) const {
        return mint(*this) -= a;
    }
    mint operator*(const mint a) const {
        return mint(*this) *= a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }

    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return *this *= a.inv();
    }
    mint operator/(const mint a) const {
        return mint(*this) /= a;
    }
};
istream& operator>>(istream& is, mint& a) {
    return is >> a.x;
}
ostream& operator<<(ostream& os, const mint& a) {
    return os << a.x;
}

int main() {
    int n, m;
    cin >> n >> m;

    vector<int> a(n);
    rep(i, n) cin >> a[i];

    vector<int> c(n);
    c[0] = m;
    mint ans = 1;
    rep(i, n) {
        if (!c[a[i]]) {
            puts("0");
            return 0;
        }
        ans *= c[a[i]];
        c[a[i]]--;
        c[a[i] + 1]++;
    }

    cout << ans << '\n';

    return 0;
}