Kortit II

#include <array> // std::array
#include <iostream>

int mod_by = 1000000007;

int factorial(int n) {
    if (!n) { return 1; }
    int product = n;
    while (--n > 1) {
        product *= n;
        product %= mod_by;
    }
    return product;
}

int choose(int a, int b) {
    return (factorial(a) / (factorial(b) * factorial(a-b)));
}

int slow_ass_recursive_function(std::array<int, 2000> played_moves, int played_moves_size, std::array<int, 2000> moves_left, int moves_left_size,
        int p1_wins, int p2_wins, int p1_wins_running_total, int p2_wins_running_total) {
    
    //std::cout << "depth: " << p1_wins_running_total + p2_wins_running_total << '\n';
    //std::cout << "p1 wins: " << p1_wins << ", p2_wins: " << p2_wins;
    //std::cout << "\np1_wins_running_total: " << p1_wins_running_total << ", p2_wins_running_total: " << p2_wins_running_total << '\n';
    if (p1_wins_running_total > p1_wins || p2_wins_running_total > p2_wins) { /*std::cout << "returning 0!\n\n";*/ return 0; }
    if (moves_left_size == 0) { /*std::cout << "returning 1!\n\n";*/ return 1; }

    //std::cout << "looping!!\n\n";
    int total = 0;
    for (int idx = 0; idx < moves_left_size; idx++) {
        int move = moves_left[idx];
        if (move == played_moves_size-1) { continue; }
        //std::cout << "playing move " << move << '\n';

        std::array<int, 2000> played_moves_copy = played_moves;
        played_moves_copy[played_moves_size-1] = move;
        std::array<int, 2000> moves_left_copy = moves_left;
        moves_left_copy[idx] = moves_left_copy[moves_left_size-1];

        total += slow_ass_recursive_function(played_moves_copy, played_moves_size+1, moves_left_copy, moves_left_size-1, p1_wins, p2_wins,
                p1_wins_running_total + (move < played_moves_size-1), p2_wins_running_total + (move > played_moves_size-1));
        total %= mod_by;
    }
    return total;
}

int main() {
    int row_count;
    std::cin >> row_count;
    while (row_count--) {
        int n, p1_wins, p2_wins;
        std::cin >> n >> p1_wins >> p2_wins;
        int original_n = n;
        
        int draws = n - p1_wins - p2_wins;
        int ways_to_choose_drawing_numbers = choose(n, draws);
        
        n -= draws;

        if ((p1_wins + p2_wins > 0) && (p1_wins == 0 || p2_wins == 0)) {
            std::cout << "0\n";
            continue;
        }

        std::array<int, 2000> empty_array;
        std::array<int, 2000> begin_moves;
        for (int i = 0; i < n; i++) {
            begin_moves[i] = i;
        }
        //std::cout << "initial call\n";
        int ways_to_choose_other_numbers = slow_ass_recursive_function(
            empty_array, 0,
            begin_moves, n,
            p1_wins, p2_wins, 0, 0
        );
        //std::cout << "1: " << ways_to_choose_drawing_numbers << ", 2: " << ways_to_choose_other_numbers << ", 3: " << factorial(original_n)  << std::endl;
        std::cout << (((ways_to_choose_drawing_numbers * ways_to_choose_other_numbers) % mod_by) * factorial(original_n)) % (mod_by) << '\n';

    }
    std::cout.flush();
    
    return 0;
}

Test 1

Group: 1, 2, 3, 4, 5

Verdict: WRONG ANSWER

Test 2

Group: 2, 3, 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 3

Group: 3, 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 4

Group: 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 5

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 6

Group: 5

Verdict: TIME LIMIT EXCEEDED