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

#include <bits/stdc++.h>
using namespace std;
 
typedef long long ll;
 
const int MOD = 1000000007;
const int MAX_N = 2000;
 
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;
}
 
vector<ll> factorial;
vector<ll> inv_factorial;
 
void precompute_factorials(int n_max) {
    factorial.assign(n_max + 1, 1LL);
    for(int i=1; i<=n_max; ++i){
        factorial[i] = factorial[i-1] * i % MOD;
    }
    inv_factorial.assign(n_max +1, 1LL);
    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);
 
    vector<vector<ll>> Eulerian(max_n +1, vector<ll>(max_n +1, 0LL));
    Eulerian[0][0] =1;
    for(int n=1;n<=max_n;n++){
        for(int k=0;k<=n-1;k++){            
            ll term1 = (k+1) * Eulerian[n-1][k] % MOD;
            ll term2 = (n -k) * (k >0 ? Eulerian[n-1][k-1] : 0LL) % MOD;
            Eulerian[n][k] = (term1 + term2) % MOD;
        }
    }
 
    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){
            cout << "0\n";
            continue;
        }
        if(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";
    }
}

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