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 static System.Console;
using static System.Math;
using System.Numerics;
using System.Collections.Generic;
using System.Linq;


namespace AtCoder
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var n = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
            //var s = Console.ReadLine().Split(' ')
            var s = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
            long ans = 1;

            var m = new List<long>();
            var abs = new List<long>();
            int count = 0;
            long last = 0;
            for (int i = 0; i < n[0]; i++)
            {
                if (s[i] < 0)
                { m.Add(s[i]); }
                abs.Add(Abs(s[i]));
            }
            abs.Sort();
            for (int i = 0; i < n[1]; i++)
            {
                ans *= abs[n[0] - 1 - i] % (1000000007);
                if (ans > 1000000007)
                {
                    ans = ans % 1000000007;
                }
                if (m.Contains(abs[n[0] - 1 - i]))
                {
                    count++;
                    last = abs[n[0] - 1 - i] % (1000000007);
                }
            }
            if (count % 2 == 1)
            {
                ans /= last;
                long value = m[1];
                int i = n[0] - 2 - n[1];
                while (m.Contains(value))
                {
                    value = m[i];
                    i--;
                    if (i < 0)
                    {
                        break;
                    }
                }
                ans *= value % 1000000007;

            }




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



    }

    public static class MyMath
    {
        public static long Factorical(long n)
        { return n <= 1 ? 1L : n * Factorical(n - 1); }
        public static long Permutation(long n, long m)
        { return m == 0 ? 1L : (m == n) ? Permutation(n, m - 1) : n * Permutation(n - 1, m - 1); }
        public static long Combination(long n, long m)
        { return n - m > m ? Permutation(n, m) / Factorical(m) : Permutation(n, n - m) / Factorical(n - m); }
        public static long Gcd(long n, long m)
        { return n % m == 0 ? m : Gcd(m, n % m); }
        public static long Lcm(long n, long m)
        { return n * m / Gcd(n, m); }
        public static long Pow(long n, long m)
        { return (m == 1 || m == 0) ? 1L : n * Pow(n, m - 1); }
    }


}