Kortit II

mod_by = 10**9 + 7

def factorial(n)
  (1..n).reduce(1, :*)
end

def choose(a, b)
  # a choose b
  (factorial(a) / (factorial(b) * factorial(a-b))).to_i
end

def recursive_get_ways(chosen_nums, choices, p1_wins)
  if choices.empty?
    p1_wins_calc = 0
    chosen_nums.each_with_index do |num, ind|
      if num > ind + 1
        p1_wins_calc += 1
      end
    end
    if p1_wins == p1_wins_calc
#      p "found!"
#      p chosen_nums
      return 1
    else
      return 0
    end

  else
    total = 0
    choices.each do |choice|
      # optimize by avoiding draws
      if choice == chosen_nums.length + 1
        next
      end
      total += recursive_get_ways(chosen_nums + [choice], choices - [choice], p1_wins)
    end
    return total
  end
end

row_count = gets.chomp.to_i
rows = []
row_count.times do
  rows.append(gets.chomp.split(" ").map(&:to_i))
end

rows.each do |row|
  n = row[0]
  original_n = n
  p1_wins = row[1]
  p2_wins = row[2]
  p1_moves = []
  p2_moves = []

  if p1_wins + p2_wins > n
    puts(0)
    next
  end

  draws = n - p1_wins - p2_wins
  
  # we need to choose "draws" from n
  # ways_to_draw = n choose draws
  # this gives us the number of possible choices of numbers to draw with
  # in the end you should multiply this with ways_to_choose_other_numbers and multiply it by its factorial (unique orderings of the solution)
  ways_to_choose_drawing_numbers = choose(n, draws)
  
  n -= draws
  
  if (p1_wins + p2_wins > 0) && (p1_wins == 0 || p2_wins == 0)
    puts(0)
    next
  end

  ways_to_choose_other_numbers = recursive_get_ways([], (0...n).to_a, p1_wins)

  # code here
  # note: we can fix p1 moves to be [0...n] since the permutations of the final moves are already accounted for
  # brute-force: n! (too slow. 24000 for first part and others are no easier)
  # too many....
  # brute force not enough
  # we can (maybe) assume the first moves[p2_wins] are p2 wins and the last moves[p1_wins] are p1 wins
  # 
  
  puts(
    (ways_to_choose_drawing_numbers * ways_to_choose_other_numbers * factorial(original_n)) % (mod_by)
  )
end

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