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;

void precompute_eulerian(int max_n) {
    Eulerian.assign(max_n + 1, vector<int>(max_n + 1, 0));
    
    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] = ((long long)(i - j) * Eulerian[i - 1][j - 1] % MOD +
                                        (long long)(j + 1) * Eulerian[i - 1][j] % MOD) % MOD;
            }
        }
    }
}

int eulerian(int n, int m) {
    if (n < 0 || m < 0 || m >= n) return 0;
    return Eulerian[n][m];
}

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;
    }
}

ll comb(int n, int k) {
    if (k < 0 || k > n) return 0;
    return factorial[n] * inv_factorial[k] % MOD * inv_factorial[n - k] % MOD;
}

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);  

    vector<vector<ll>> D_E(max_n + 1, vector<ll>(max_n + 1, 0LL));
    for (int m = 0; m <= max_n; m++) {
        for (int b = 0; b <= m; b++) {
            ll total = 0;
            for (int k = 0; k <= m; k++) {
                ll Cmk = comb(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;
        }           
    }
    
    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 = comb(n, c);
        ll D = (n - c >= 0 && b <= (n - c)) ? D_E[n - c][b] : 0LL;
        ll total = factorial[n] * C_nc % MOD;        
        total = total * D % MOD;
        cout << total << "\n";
    }
    return 0;
}

Test 1

Group: 1, 2, 3, 4, 5

Verdict: WRONG ANSWER

Test 2

Group: 2, 3, 4, 5

Verdict: WRONG ANSWER

Test 3

Group: 3, 4, 5

Verdict: WRONG ANSWER

Test 4

Group: 4, 5

Verdict: WRONG ANSWER

Test 5

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 6

Group: 5

Verdict: TIME LIMIT EXCEEDED