Kortit II

use std::io;
 
fn main() {
    let mut t_str = String::new();
    io::stdin().read_line(&mut t_str).unwrap();
    t_str = t_str.trim().to_string();
    let t: usize = t_str.parse().unwrap();
 
    let mut tests: Vec<[usize; 3]> = Vec::with_capacity(t);
 
    for test in 0..t {
        let mut test_str = String::new();
        io::stdin().read_line(&mut test_str).unwrap();
        test_str = test_str.trim().to_string();
 
        tests.push([0, 0, 0]);
        for (i, num) in test_str.split(' ').enumerate() {
            tests[test][i] = num.parse().unwrap();
        }
    }
 
    for test in tests {
        let mut amount = 0;
        if test[1]+test[2] > test[0] {
            println!("0");
            continue;
        }
        let evens = test[0]-test[1]-test[2];
        if (evens+test[1] == test[0] || evens+test[2] == test[0]) && (test[1]!=test[2]) {
            println!("0");
            continue;
        }
 
        let options = (1..=test[0]).collect();
        count(&options, test[0], &mut amount, evens, test[2], test[1]);
        let result = amount*factorial(test[0])%1000000007;
        println!("{}", result);
    }
}
 
pub fn factorial(num: usize) -> usize {
    let mut result = 1;
    for i in 2..=num {
        result *= i;
        result %= 1000000007;
    }
    return result;
}
 
fn count(options: &Vec<usize>, opponent: usize, amount: &mut usize, evens: usize, losses: usize, wins: usize) {
    if opponent == 1 {
        assert_eq!(options.len(), opponent);
        if evens == 1 && options.contains(&1) {
            *amount += 1;
        }
        else if wins == 1 && !options.contains(&1) {
            *amount += 1;
        }
        return;
    }
 
    if *options.last().unwrap() > opponent && wins == 0 {
        return;
    }
    if options[0] > opponent && (losses > 0 || evens > 0) {
        return;
    }
    
    for (i, c) in options.iter().enumerate() {
        if losses > 0 && *c < opponent {
            let mut copy = Vec::with_capacity(options.len()-1);
            copy.extend_from_slice(&options[0..i]);
            copy.extend_from_slice(&options[i+1..]);
            count(&copy, opponent-1, amount, evens, losses-1, wins);
        }
        else if wins > 0 && *c > opponent {
            let mut copy = Vec::with_capacity(options.len()-1);
            copy.extend_from_slice(&options[0..i]);
            copy.extend_from_slice(&options[i+1..]);
            count(&copy, opponent-1, amount, evens, losses, wins-1);
        }
        else if evens > 0 && *c == opponent {
            let mut copy = Vec::with_capacity(options.len()-1);
            copy.extend_from_slice(&options[0..i]);
            copy.extend_from_slice(&options[i+1..]);
            count(&copy, opponent-1, amount, evens-1, losses, wins);
        }
    }
}

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: 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