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 C# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;

namespace abc173
{
    class Program
    {
        class AbsRevComparer : IComparer<int>
        {
            int IComparer<int>.Compare(int x, int y)
            {
                return Math.Abs(y).CompareTo(Math.Abs(x));
            }
        }
        static long keyNum = (long)(Math.Pow(10, 9) + 7);
        static int[] ReadNumList()
        {
            var line = Console.ReadLine().Split(' ');
            var numList = new int[line.Length];
            for (var i = 0; i < line.Length; ++i)
            {
                numList[i] = int.Parse(line[i]);
            }
            return numList;
        }
        static void Main(string[] args)
        {
            var nk = Console.ReadLine().Split(' ');
            var n = int.Parse(nk[0]);
            var k = int.Parse(nk[1]);
            var aList = ReadNumList();
            Array.Sort(aList, new AbsRevComparer());

            var minusCount = 0;
            var lastPlusIndex = -1;
            var lastMinusIndex = -1;
            var nextPlusIndex = -1;
            var nextMinusIndex = -1;
            for (var i = 0; i < k; ++i)
            {
                if (aList[i] < 0)
                {
                    ++minusCount;
                    lastMinusIndex = i;
                }
                else
                {
                    lastPlusIndex = i;
                }
            }
            if (minusCount % 2 == 0)
            {
                lastPlusIndex = -1;
                lastMinusIndex = -1;
            }
            else
            {
                for (var i = k; i < n; ++i)
                {
                    if (aList[i] >= 0)
                    {
                        nextPlusIndex = i;
                        break;
                    }
                }
                for (var i = k; i < n; ++i)
                {
                    if (aList[i] < 0)
                    {
                        nextMinusIndex = i;
                        break;
                    }
                }
                // case: all minus
                if (nextPlusIndex < 0)
                {
                    var totalm = 1L;
                    for (var i = 0; i < k; ++i)
                    {
                        totalm = (totalm * aList[n - i - 1]) % keyNum;
                    }
                    totalm += keyNum;
                    Console.WriteLine(totalm);
                    return;
                }
            }
            // multiply 0 to k exclude lastMinus append addPlus
            var total = 1L;
            for (var i = 0; i < k; ++i)
            {
                if (i != lastMinusIndex && i != lastPlusIndex)
                {
                    total = (total * aList[i]) % keyNum;
                }
            }
            if (lastMinusIndex >= 0)
            {
                if (lastPlusIndex >= 0)
                {
                    var minusMul = (long)aList[lastMinusIndex] * (nextMinusIndex >= 0 ? aList[nextMinusIndex] : -1);
                    var plusMul = (long)aList[lastPlusIndex] * aList[nextPlusIndex];
                    total = (total * Math.Max(minusMul, plusMul)) % keyNum;
                }
                else
                {
                    // all 0 to k is minus
                    total = (total * aList[nextPlusIndex]) % keyNum;
                }
            }
            if (total < 0)
            {
                total += keyNum;
            }
            Console.WriteLine(total);
        }
    }
}