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: Runtime Error)

N, K = gets.split.map(&:to_i)
M = 1000000007
positives = []
negatives = []
zeros = []
A = gets.split.map(&:to_i)
A.sort_by! {|k| k > 0 ? k : -k }
A.each do |a|
  if a > 0
    positives << a
  elsif a < 0
    negatives << a
  else
    zeros << a
  end
end
positives.reverse!
negatives.reverse!

if positives.size + negatives.size < K
  puts 0
  exit
end

posisize = positives.size
negasize = K - positives.size
if negasize > 0 and negasize%2==1 and !(positives.size > 0 and negasize < negatives.size)
  # negative case
  unless zeros.empty?
    puts 0
  else
    ans=1
    0.upto(K-1) do |i|
      ans = (ans * A[i]) % M
    end
    puts ans
  end
else
  if negasize%2 == 1
    negasize += 1
    posisize -= 1
  end

  # fix
  while posisize >= 2 &&
        negasize + 2 <= negatives.size &&
        positives[posisize-1]*positives[posisize-2] < negatives[negasize]*negatives[negasize+1]
    posisize -= 2
    negasize += 2
  end

  ans=1
  0.upto(posisize-1) do |i|
    ans = (ans * positives[i]) % M
  end
  0.upto(negasize-1) do |i|
    ans = (ans * negatives[i]) % M
  end
  puts ans
end