Kortit II

input/code.cpp: In function 'int nums(int, int, std::unordered_set<int>*, int*)':
input/code.cpp:22:33: warning: comparison of integer expressions of different signedness: 'std::unordered_set<int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   22 |         if(previousNums->size() == setSize){
      |            ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~

#include <iostream>
#include <vector>
#include <unordered_set>

using namespace std;

long long factorial(int num){
    long long answer = 1;
    for(int i = num; i > 0; i--){
        answer *= i;
    }

    return answer;
}

int nums(int size, int depth, unordered_set<int>* previousNums, int* points){
    int successes = 0;
    for(int i = 1; i <= size; i++){
        if(i == depth) continue;
        int setSize = previousNums->size();
        previousNums->insert(i);
        if(previousNums->size() == setSize){
            continue;
        }

        if(i < depth) *points -= 1;

        if(*points > size - depth || 0 - *points > size - depth){
            previousNums->erase(i);
            if(i < depth) *points += 1;
            continue;
        }
        
        if(depth == size){
            if(*points == 0){
                successes++;            
            }
            
            previousNums->erase(i);
            if(i < depth) *points += 1;
            
            if(i == size){
                return successes;
            }

            continue;
        }
        
        successes += nums(size, depth + 1, previousNums, points);
        
        previousNums->erase(i);
        if(i < depth) *points += 1;
    }
    
    return successes;
}


struct testStruct{
    int n, player1Points, player2Points;

    public:
        testStruct(){
            n = 0;
            player1Points = 0;
            player2Points = 0;
        }
};


int binomialCoefficients(int n, int k) {
   if (k == 0 || k == n)
   return 1;
   return binomialCoefficients(n - 1, k - 1) + binomialCoefficients(n - 1, k);
}


int main(){

    int testCounts;
    cin >> testCounts;
 
    vector<testStruct> tests;
    for(int i = 0; i < testCounts; i++){
        testStruct test;
        cin >> test.n >> test.player1Points >> test.player2Points;
        tests.push_back(test);
    }

   //5!/(1!*(5-1)!) * 5! * 7

    for(testStruct test : tests){
        unordered_set<int> previous;

        if(test.player1Points == 0 || test.player2Points == 0){
            cout << 0 << endl;
            continue;
        }

        if(test.player1Points + test.player2Points > test.n){
            cout << 0 << endl;
            continue;
        }

        int points = test.player1Points;
        int successes = nums(test.player1Points + test.player2Points, 1, &previous, &points);

        cout << (factorial(test.n) * binomialCoefficients(test.n, (test.n - test.player1Points - test.player2Points)) * successes) % (1000000000 + 7) << endl;
    }
    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: 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