Kortit II

#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