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;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;

namespace AtCoder
{
    class Program
    {
        static void Main(string[] args)
        {
            var num = ScanLong(2);
            var takeCount = (int)num[1];
            var nums = ScanLong((int)num[0]).OrderByDescending(Math.Abs).ToList();
            var firstArray = nums.Take(takeCount).ToList();

            if (firstArray.Count(x => x <= 0) % 2 != 0 && num[0] != num[1])
            {
                var daitai = nums.Skip(takeCount).First();
                if (daitai >= 0)
                {
                    var nuku = firstArray.Last(x => x <= 0);
                    firstArray.Remove(nuku);
                }
                else
                {
                    var nuku = firstArray.LastOrDefault(x => x >= 0);
                    if (nuku != 0)
                    {
                        firstArray.Remove(nuku);
                    }
                    else
                    {
                        firstArray.Remove(nums[0]);
                    }
                }
                firstArray.Add(daitai);
            }
            
            var mod = new Mod109();
            Console.WriteLine(mod.Multiplication(firstArray, true));
        }

        // 以下ユーティリティー
        static readonly StreamScanner Scanner = new StreamScanner(Console.OpenStandardInput());

        
        /// <summary> 数値読み込み </summary>
        private static List<long> ScanLong(int count = 0)
        {
            var scan = new List<long>();
            for (int i = 0; i < count; i++)
            {
                scan.Add(Scanner.Long());
            }

            return scan;
        }

        /// <summary> 一括出力 </summary>
        private static void OutAllLine(IEnumerable<dynamic> items)
        {
            var sb = new StringBuilder();
            foreach (var result in items)
            {
                sb.Append(result + "\n");
            }
            sb = sb.Remove(sb.Length - 1, 1);
            Console.WriteLine(sb);
        }

        /// <summary> 素数判定 </summary>
        public static bool IsPrime(int num)
        {
            if (num < 2) {return false;}
            if (num == 2) {return true;}
            if (num % 2 == 0) {return false;}

            double sqrtNum = Math.Sqrt(num);
            for (int i = 3; i <= sqrtNum; i += 2)
            {
                if (num % i == 0) { return false; }
            }
            return true;
        }
        
        public static IEnumerable<int> PrimeFactors(int n)
        {
            int i = 2;
            int tmp = n;

            while (i * i <= n) //※1
            {
                if(tmp % i == 0){
                    tmp /= i;
                    yield return i;
                }else{
                    i++;
                }
            }
            if(tmp != 1) yield return tmp;
        }
    }
    
    public class StreamScanner
    {
        public StreamScanner(Stream stream) { str = stream; }
        private readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;
        public bool IsEndOfStream { get { return isEof; } }
        private byte read()
        {
            if (isEof) throw new EndOfStreamException();
            if (ptr >= len) {
                ptr = 0;
                if ((len = str.Read(buf, 0, 1024)) <= 0)
                {
                    isEof = true;
                    return 0;
                }
            }
            return buf[ptr++];
        }
        public char Char() 
        {
            byte b = 0;
            do b = read();
            while (b < 33 || 126 < b);
            return (char)b; 
        }
        public string Scan()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read())
                sb.Append(b);
            return sb.ToString();
        }
        public long Long()
        {
            long ret = 0; byte b = 0; var ng = false;
            do b = read();
            while (b != '-' && (b < '0' || '9' < b));
            if (b == '-') { ng = true; b = read(); }
            for (; true; b = read())
            {
                if (b < '0' || '9' < b)
                    return ng ? -ret : ret;
                else ret = ret * 10 + b - '0';
            }
        }
        public int Integer() { return (int)Long(); }
        public double Double() { return double.Parse(Scan(), CultureInfo.InvariantCulture); }
    }

    public class Mod109
    {
        public const int _7 = 1000000007;
        public const int _9 = 1000000009;
        public const int _3 = 998244353;
        
        private readonly int ModValue;

        public Mod109(int modValue = Mod109._7)
        {
            ModValue = modValue;
        }
        
        /// <summary> 和 </summary>
        public long Addition(IEnumerable<long> nums)
        {
            return nums.Aggregate<long, long>(0, (current, num) => (current + num) % ModValue);
        }
        
        /// <summary> 積 </summary>
        public long Multiplication(IEnumerable<long> nums, bool isResultPositive = false)
        {
            return nums.Aggregate<long, long>(1, (current, num) =>
            {
                var value = (current * num) % ModValue;
                return value < 0 && isResultPositive ? (value + ModValue) : value;
            });
        }
    }
    
}