Problem:
Score : 500 points

Problem Statement

Given are N integers A_1,\ldots,A_N.

We will choose exactly K of these elements. Find the maximum possible product of the chosen elements.

Then, print the maximum product modulo (10^9+7), using an integer between 0 and 10^9+6 (inclusive).

Constraints

1 \leq K \leq N \leq 2\times 10^5

|A_i| \leq 10^9

Input

Input is given from Standard Input in the following format:

N K
A_1 \ldots A_N

Output

Print the maximum product modulo (10^9+7), using an integer between 0 and 10^9+6 (inclusive).

Sample Input 1

4 2
1 2 -3 -4

Sample Output 1

12

The possible products of the two chosen elements are 2, -3, -4, -6, -8, and 12, so the maximum product is 12.

Sample Input 2

4 3
-1 -2 -3 -4

Sample Output 2

1000000001

The possible products of the three chosen elements are -24, -12, -8, and -6, so the maximum product is -6.

We print this value modulo (10^9+7), that is, 1000000001.

Sample Input 3

2 1
-1 1000000000

Sample Output 3

1000000000

The possible products of the one chosen element are -1 and 1000000000, so the maximum product is 1000000000.

Sample Input 4

10 10
1000000000 100000000 10000000 1000000 100000 10000 1000 100 10 1

Sample Output 4

999983200

Be sure to print the product modulo (10^9+7).

Solution in Ruby (2.7.1) (judge verdict: Wrong Answer)

MOD = 10 ** 9 + 7
n, k = gets.split.map(&:to_i)
nums = gets.split.map(&:to_i)
$minus_nums = []
$plus_nums = []
nums.each do |num|
  if num > 0
    $plus_nums << num
  elsif num < 0
    $minus_nums << num
  end
end

$minus_nums.sort!
$plus_nums.sort!.reverse!

if $minus_nums.reject { |num| num == 0 }.size + $plus_nums.reject { |num| num == 0 }.size < k
  puts 0
  exit
end

$minus_nums_size = $minus_nums.size
$plus_nums_size = $plus_nums.size
$used_minus = -1
$used_plus = -1
def multiply
  minus = 0
  if $minus_nums_size > $used_minus + 2
    minus = $minus_nums[$used_minus + 1] * $minus_nums[$used_minus + 2]
  end
  plus = 0
  if $plus_nums_size > $used_plus + 2
    plus = $plus_nums[$used_plus + 1] * $plus_nums[$used_plus + 2]
  end
  if $minus_nums_size == $used_minus + 2 && $plus_nums_size == $used_plus + 2
    $ans *= $minus_nums[$used_minus]
    $ans *= $plus_nums[$used_plus]
    $used_minus += 1
    $used_plus += 1
    $ans %= MOD
    return
  end
  if minus == 0 && plus == 0
    puts 0
    exit
  end
  if minus > plus
    $ans *= minus
    $ans %= MOD
    $used_minus += 2
  else
    $ans *= plus
    $ans %= MOD
    $used_plus += 2
  end
end

$ans = 1
if k.odd?
  if $plus_nums_size > 0
    $ans *= $plus_nums[0]
    $used_plus += 1
    k -= 1
  else
    puts $minus_nums.reverse[0...k].inject(1) { |res, num| res * num % MOD } % MOD
    exit
  end
end

until k == 0
  multiply
  k -= 2
end

puts $ans % MOD