Kortit II

#include <bits/stdc++.h>
 
#define MODE 1
 
#if MODE
#define debug(x) cout << #x << ": " << (x) << endl
#define log(x) cout << (x) << endl
#define test(x) x
#else
#define debug(x)
#define log(x)
#define test(x)
#endif
 
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define fi first
#define se second
#define X real()
#define Y imag()
 
using namespace std;
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using P = complex<ll>;
 
template<typename S, typename T = S> void chmin(S &s, T t) {s = s < t ? s : t;}
template<typename S, typename T = S> void chmax(S &s, T t) {s = s > t ? s : t;}
 
const ll M = 1000000007; // 998244353
 
struct mint {
    int v;
    mint() {}
    mint(long long v) : v(0 <= v && v < M ? v : (v % M + M) % M) {}
    
    mint operator+(mint oth) {
        return v + oth.v < M ? v + oth.v : v + oth.v - M;
    }
    
    mint operator-(mint oth) {
        return v - oth.v >= 0 ? v - oth.v : v - oth.v + M;
    }
    
    mint operator*(mint oth) {
        return (long long) v * oth.v % M; 
    }
    
    mint pow(ll e) {
        if (e == 0) return mint(1);
        mint a = this->pow(e/2);
        a *= a;
        if (e & 1) return a * (*this);
        return a;
    }
    
    mint inv() {
        return this->pow(M-2);
    }
    
    mint operator/(mint oth) {
        return (*this) * oth.inv();
    }
    
    mint operator+=(mint oth) {
        (*this) = (*this) + oth;
        return *this;
    }
    
    mint operator-=(mint oth) {
        (*this) = (*this) - oth;
        return *this;
    }
    
    mint operator*=(mint oth) {
        (*this) = (*this) * oth;
        return *this;
    }
    
    mint operator/=(mint oth) {
        (*this) = (*this) / oth;
        return *this;
    }
    
    mint operator++() {
        return *this += 1;
    }
    
    mint operator++(int) {
        return (*this += 1) - 1;
    }
    
    mint operator--() {
        return *this -= 1;
    }
    
    mint operator--(int) {
        return (*this -= 1) + 1;
    }
    
    mint operator+(int oth) {
        return *this + mint(oth);
    }
    
    mint operator-(int oth) {
        return *this - mint(oth);
    }
    
    mint operator*(int oth) {
        return *this * mint(oth);
    }
    
    mint operator/(int oth) {
        return *this / mint(oth);
    }
    
    mint operator+=(int oth) {
        return *this += mint(oth);
    }
    
    mint operator-=(int oth) {
        return *this -= mint(oth);
    }
    
    mint operator*=(int oth) {
        return *this *= mint(oth);
    }
    
    mint operator/=(int oth) {
        return *this /= mint(oth);
    }
};
 
mint inv(mint i) { return i.inv(); }
mint pow(mint b, ll e) { return b.pow(e); }
 
mint operator+(int a, mint oth) {
    return mint(a) + oth;
}
 
mint operator-(int a, mint oth) {
    return mint(a) - oth;
}
 
mint operator*(int a, mint oth) {
    return mint(a) * oth;
}
 
mint operator/(int a, mint oth) {
    return mint(a) / oth;
}
 
std::ostream &operator<<(std::ostream &os, mint i) {
    os << i.v;
    return os;
}
 
std::istream &operator>>(std::istream &is, mint &i) {
    is >> i.v;
    return is;
}
 
struct factorial {
    int n;
    vector<mint> f, i;
    
    factorial() {}
    factorial(int n) : n(n) {
        f.resize(n+1);
        i.resize(n+1);
        f[0] = 1;
        for (int j = 1; j <= n; ++j) f[j] = j * f[j-1];
        i[n] = 1 / f[n];
        for (int j = n-1; j >= 0; --j) i[j] = (j+1) * i[j+1];
    }
    
    mint ncr(int n, int k) {
        if (0 > k || k > n) return 0;
        return f[n] * i[k] * i[n-k];
    }
    
    mint npr(int n, int k) {
        if (0 > k || k > n) return 0;
        return f[n] * i[n-k];
    }
};
 
const int N = 2020;
factorial F(N);
 
mint dp[N][N];
 
void init() {
    dp[0][0] = 1;
    for (int i = 1; i < N; ++i) {
        for (int j = 1; j < N; ++j) {
            dp[i][j] = i * dp[i][j-1] + j * dp[i-1][j] + (i + j - 1) * dp[i-1][j-1];
        }
    }
}
 
void solve() {
    int n, a, b;
    cin >> n >> a >> b;
    
    cout << dp[a][b] * F.ncr(n, a+b) * F.f[n] << '\n';
}
 
int main() {
    cin.tie(0) -> sync_with_stdio(0);
    
    init();
    
    int t = 0;
    if (t == 0) cin >> t;
    while (t--) solve();
    
    return 0;
}

Test 1

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 2

Group: 2, 3, 4, 5

Verdict: ACCEPTED

Test 3

Group: 3, 4, 5

Verdict: ACCEPTED

Test 4

Group: 4, 5

Verdict: ACCEPTED

Test 5

Group: 5

Verdict: ACCEPTED

Test 6

Group: 5

Verdict: ACCEPTED