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

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Linq;

namespace contest_Csharp
{
    class Program
    {


        static void Main(string[] args)
        {
            var sw = new System.IO.StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(sw);

            var vals = Console.ReadLine().Split(' ').
                Select(x => int.Parse(x)).ToList();
            var N = vals[0];
            var K = vals[1];
            var A = Console.ReadLine().Split(' ').
                Select(x => long.Parse(x)).ToList();
            A.Sort();
            var Po = A.Where(x => x > 0).Reverse().ToList();
            var Ne = A.Where(x => x <= 0).ToList();

            var mod = (long)1e9 + 7;
            long ans = 1;

            if (A[N - 1] <= 0 && K % 2 == 1)
            {
                for (int s = 0; s < K; s++)
                {
                    ans = (ans * A[N - 1 - s]) % mod;
                }
                ans = (mod + ans) % mod;
            }
            else
            {
                int i = -1, p = 0, m = 0;
                while (i < K)
                {
                    i++;
                    if (i >= K)
                        break;
                    bool e=true,f=true;
                    try
                    {
                        e = Ne.Count() > m + 1 && i + 1 < K &&
                            (Po.Count() <= p + 1 || Ne[m] * Ne[m + 1] >= Po[p] * Po[p + 1]);
                    }
                    catch { break; }

                    if (e)
                    {

                        ans = (-ans * Ne[m]) % mod;
                        ans = (-ans * Ne[m + 1]) % mod;
                        i++;
                        if (i >= K)
                            break;
                        m += 2;
                    }
                    else
                    {

                        ans = (ans * Po[p]) % mod;
                        p++;

                    }



                }
            }





            Console.WriteLine(ans);
            Console.Out.Flush();
        }





    }
}