Kortit II

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
 
const int MOD = 1000000007;
 
vector<vector<int>> Eulerian;
vector<ll> factorial, inv_factorial;
vector<vector<ll>> binomial;
 
void precompute_eulerian(int max_n) {
    Eulerian.assign(max_n + 1, vector<int>(max_n + 1, 0));
    Eulerian[0][0] = 1;
    for (int i = 1; i <= max_n; i++) {
        for (int j = 0; j <= i - 1; j++) {
            if (j == 0) {
                Eulerian[i][j] = 1;
            } else {
                Eulerian[i][j] = ((ll)(i - j) * Eulerian[i - 1][j - 1] % MOD +
                                  (ll)(j + 1) * Eulerian[i - 1][j] % MOD) % MOD;
            }
        }
    }
}
 
ll power_mod(ll a, ll b, ll mod_val) {
    ll res = 1;
    a %= mod_val;
    while (b > 0) {
        if (b & 1LL) {
            res = res * a % mod_val;
        }
        a = a * a % mod_val;
        b >>= 1LL;
    }
    return res;
}
 
void precompute_factorials(int n_max) {
    factorial.assign(n_max + 1, 1LL);
    inv_factorial.assign(n_max + 1, 1LL);
    for (int i = 1; i <= n_max; ++i) {
        factorial[i] = factorial[i - 1] * i % MOD;
    }
    inv_factorial[n_max] = power_mod(factorial[n_max], MOD - 2, MOD);
    for (int i = n_max - 1; i >= 0; i--) {
        inv_factorial[i] = inv_factorial[i + 1] * (i + 1) % MOD;
    }
}
 
void precompute_binomial(int max_n) {
    binomial.assign(max_n + 1, vector<ll>(max_n + 1, 0));
    for (int i = 0; i <= max_n; ++i) {
        binomial[i][0] = 1;
        for (int j = 1; j <= i; ++j) {
            binomial[i][j] = (binomial[i - 1][j - 1] + binomial[i - 1][j]) % MOD;
        }
    }
}
 
void precompute_D_E(int max_n, vector<vector<ll>>& D_E) {
        for (int m = 0; m <= max_n; m++) {
        for (int b = 0; b <= m; b++) {
            ll total = 0;
            if (Eulerian[m][b] == 0) continue;
            for (int k = 0; k <= m; k++) {
                ll Cmk = binomial[m][k];
                if (b > m - k || m - k < 0) {
                    continue;
                }
                ll Ak = Eulerian[m - k][b];                
                if (k & 1) {
                    total = (total + MOD - (Cmk * Ak % MOD)) % MOD;                    
                } else {
                    total = (total + (Cmk * Ak) % MOD) % MOD;                    
                }
            }
            D_E[m][b] = total;
        }           
    }
} 
 
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);    
 
    int T;
    cin >> T;
 
    vector<tuple<int, int, int>> tests(T);
    int max_n = 0;
    for (auto &x : tests) {
        cin >> get<0>(x) >> get<1>(x) >> get<2>(x);
        max_n = max(max_n, get<0>(x));
    }
 
    precompute_factorials(max_n);
    precompute_eulerian(max_n);
    precompute_binomial(max_n);
    
    
    vector<vector<ll>> D_E(max_n + 1, vector<ll>(max_n + 1, 0LL));
    precompute_D_E(max_n, D_E);
 
    for (auto &x : tests) {
        int n, a, b;
        tie(n, a, b) = x;
        int c = n - a - b;
        if (c < 0 || c > n || a < 0 || b < 0) {
            cout << "0\n";
            continue;
        }
 
        ll C_nc = binomial[n][c];
        ll f = (n - c >= 0 && b <= (n - c)) ? D_E[n - c][b] : 0LL;
        ll total = factorial[n] * C_nc % MOD;
        total = total * f % MOD;
        cout << total << "\n";
    }
    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: TIME LIMIT EXCEEDED

Test 6

Group: 5

Verdict: TIME LIMIT EXCEEDED