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: Accepted)

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

// using System.Numerics;
using System.Runtime.CompilerServices;
using System.Diagnostics;
using ll=System.Int64;
using static Contest_E.Lib_IO;
using static Contest_E.Lib_Minifunc;



public static class Contest_E
{

	public static void Main() {
		checked{
			long n, k;
			Lib_IO.rm(out n, out k);
			ll[] a;
			ra(out a);

			bool bmax = true;
			List<ll> b = new List<ll>();
			List<ll> c = new List<ll>();
			foreach (var e in a)
			{
				if(0<e)b.Add(e);
				else if(e<0)c.Add(-e);
			}
			if(b.Count+c.Count<k){
				wm(0);
				return;
			}else if(b.Count+c.Count==k){
				if(c.Count%2==1){
					if(b.Count+c.Count<n){
						wm(0);
						return;
					}else{
						bmax = false;
					}
				}else{
					ll ans1 = 1;
					foreach (var e in b)
					{
						ans1 = (ans1*e)%MOD1; 
					}
					foreach (var e in c)
					{
						ans1 = (ans1*e)%MOD1; 
					}
					wm(ans1);
					return;					
				}
			}else{
				if(b.Count==0&&k%2==1){
					if(b.Count+c.Count<n){
						wm(0);
						return;
					}else{
						bmax = false;
					}			
				}
			}

			b.Sort();
			c.Sort();
			if(bmax){
				b.Reverse();
				c.Reverse();
			}

			Decimal[] digb = new decimal[b.Count+1];
			Decimal[] digc = new decimal[c.Count+1];
			ll[] valb = new ll[b.Count+1];
			ll[] valc = new ll[c.Count+1];
			valb[0] = 1;
			valc[0] = 1;
			List<ll> lst = new List<ll>();
			Decimal dig = INF1;
			if(bmax) dig = 0;
			for (int i = 1; i <= b.Count; i++)
			{
				digb[i] = digb[i-1] + Log(b[i-1]);
				valb[i] = (valb[i-1] * b[i-1])%MOD1;
			}
			for (int i = 1; i <= c.Count; i++)
			{
				digc[i] = digc[i-1] + Log(c[i-1]);
				valc[i] = (valc[i-1] * c[i-1])%MOD1;
			}
			if(bmax){
				for (int i = 0; i <= min(k,c.Count); i+=2)
				{
					if((k-i)<=b.Count&&dig<(digc[i]+digb[k-i])){
						lst.Clear();
						dig = digc[i]+digb[k-i];
						lst.Add((valc[i]*valb[k-i])%MOD1);
					}
				}
			}else{
				for (int i = 1; i <= min(k,c.Count); i+=2)
				{
					if((k-i)<=b.Count&&(digc[i]+digb[k-i])<dig){
						lst.Clear();
						dig = digc[i]+digb[k-i];
						lst.Add(MOD1-(valc[i]*valb[k-i])%MOD1);
					}
				}
			}




			Lib_IO.wm(bmax?lst.Max():lst.Min());
		}
	}

		public static decimal Log(decimal x) {
			if (x<=0.0m) throw new ArgumentException("Invalid x","x");
			decimal[] c = {0.33333333333333333333333333333333m,0.2m,0.14285714285714285714285714285714m,0.11111111111111111111111111111111m,0.090909090909090909090909090909091m,0.076923076923076923076923076923077m,0.066666666666666666666666666666667m,0.058823529411764705882352941176471m,0.052631578947368421052631578947368m,0.047619047619047619047619047619048m,0.043478260869565217391304347826087m,0.04m,0.037037037037037037037037037037037m,0.034482758620689655172413793103448m,0.032258064516129032258064516129032m,0.030303030303030303030303030303030m,0.028571428571428571428571428571429m,0.027027027027027027027027027027027m,0.025641025641025641025641025641026m,};
			int scale = 0;
			if(1.0m<x){
				while(1.4142135623730950488016887242097m<=x){
					x /= 2.0m;
					scale++;
				}
			}else if(x<1.0m){
				while(x<0.70710678118654752440084436210485m){
					x *= 2.0m;
					scale--;
				}
			}
			x = (x - 1.0m) / (x + 1.0m);
			decimal x2 = x*x;
			decimal dfL = 2.0m*x*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(x2*(+c[18])+c[17])+c[16])+c[15])+c[14])+c[13])+c[12])+c[11])+c[10])+c[9])+c[8])+c[7])+c[6])+c[5])+c[4])+c[3])+c[2])+c[1])+c[0])+1m);
			return dfL + 0.69314718055994530941723212145818m*(decimal)scale;	// log(x) = log(m) + e*log(2)  : sqrt(2)/2<=m<sqrt(2)
		}















#region BaseModule


public static class Lib_Minifunc{
	[MethodImpl(256)] public static void swap1<T>(ref T a, ref T b) { T t = a; a = b; b = t; }
	[MethodImpl(256)] public static void swap2<T>(ref T a, ref T b) where T : IComparable { if (a.CompareTo(b)==1) swap1(ref a, ref b); }  // b の方が小さければ交換
	[MethodImpl(256)] public static bool chmin<T>(ref T a, T b) where T : IComparable { if (a.CompareTo(b)== 1) { a = b; return true; } return false; }  // b の方が小さければ a を更新
	[MethodImpl(256)] public static bool chmax<T>(ref T a, T b) where T : IComparable { if (a.CompareTo(b)==-1) { a = b; return true; } return false; }  // b の方が大きければ a を更新
	[MethodImpl(256)] public static bool inside(long i, long n) => (0<=i&&i<n);
	[MethodImpl(256)] public static bool inside(long x, long y, long w, long h) => (inside(x,w)&&inside(y,h));
	[MethodImpl(256)] public static T min<T>(params T[] a) where T : IComparable => a.Min();
	[MethodImpl(256)] public static T max<T>(params T[] a) where T : IComparable => a.Max();
	[MethodImpl(256)] public static long mod(long a, long m=MOD1) { var v = a%m; return (v<0?v+m:v); }
	[MethodImpl(256)] public static long ceiling(long a, long b) => (a%b==0?a/b:a/b+1);	// 整数商の切り上げ
	[MethodImpl(256)] public static P<T,U> initp<T,U>(T a,U b) => new P<T,U>(a,b);
	[MethodImpl(256)] public static P<T,U,V> initp<T,U,V>(T a,U b,V c) => new P<T,U,V>(a,b,c);
	[MethodImpl(256)] public static P<T,U,V,W> initp<T,U,V,W>(T a,U b,V c,W d) => new P<T,U,V,W>(a,b,c,d);
	[MethodImpl(256)] public static bool initd<T,U>(Dictionary<T,U> d, T k) { if(d.ContainsKey(k)) { return false; } else { d[k] = default(U); return true; } }
	public static T[] inita<T>(long len1) where T : new() { var m = new T[len1]; for (int i=0;i<m.Length;i++) m[i] = new T(); return m; }
	public static T[][] initm<T>(long len1,long len2,T val) where T : struct { var m = new T[len1][]; for (int i=0;i<m.Length;i++) m[i] = Enumerable.Repeat(val,(int)len2).ToArray(); return m; }
	public static T[][][] initm<T>(long len1,long len2,long len3,T val) where T : struct { var m = new T[len1][][]; for (int i=0;i<m.Length;i++) m[i] = initm(len2,len3,val); return m; }
	public const long MOD1 = 1000000007; // 10^9+7
	public const double EPS1 = 1e-8;
	public const long INF1 = 1000000000000000;  // 10^15
}

public struct P<T,U>
{
	public T A; public U B;
	public P(T a,U b) { A = a; B = b; }
	public static implicit operator KeyValuePair<T,U>(P<T,U> a) => new KeyValuePair<T,U>(a.A,a.B);
	public static implicit operator P<T,U>(KeyValuePair<T,U> a) => new P<T,U>(a.Key,a.Value);
}
public struct P<T,U,V>
{
	public T A; public U B; public V C;
	public P(T a,U b,V c) { A = a; B = b; C = c; }
}
public struct P<T,U,V,W>
{
	public T A; public U B; public V C; public W D;
	public P(T a,U b,V c,W d) { A = a; B = b; C = c; D = d; }
}

public static class Lib_IO
{
	class Prt : System.IO.StreamWriter
	{
		public override IFormatProvider FormatProvider { get { return System.Globalization.CultureInfo.InvariantCulture; } }
		public Prt(System.IO.Stream s) : base(s,new UTF8Encoding(false,true)) {}
		public Prt(System.IO.Stream s,Encoding e) : base(s,e) {}
	}
	static Prt sw = new Prt(Console.OpenStandardOutput());
	static char[] sp = new char[] {' '};
	[MethodImpl(256)] static bool eq<T,U>() => typeof(T).Equals(typeof(U));
	[MethodImpl(256)] static T ct<T,U>(U a) => (T)Convert.ChangeType(a,typeof(T));
	[MethodImpl(256)] static T cv<T>(string s) =>
		eq<T,int>()	? ct<T,int>(int.Parse(s))
	  : eq<T,long>()   ? ct<T,long>(long.Parse(s))
	  : eq<T,double>() ? ct<T,double>(double.Parse(s,System.Globalization.CultureInfo.InvariantCulture))
	  : eq<T,char>()   ? ct<T,char>(s[0])
					   : ct<T,string>(s);
	public static string[] rm<T>(out T a) {
		var z = Console.ReadLine().Split(sp,StringSplitOptions.RemoveEmptyEntries); 
		a = cv<T>(z[0]);
		return z;
	}
	public static string[] rm<T,U>(out T a,out U b) {
		var z = rm<T>(out a); 
		b = cv<U>(z[1]);
		return z;
	}
	public static string[] rm<T,U,V>(out T a,out U b,out V c) {
		var z = rm<T,U>(out a,out b); 
		c = cv<V>(z[2]);
		return z;
	}
	public static string[] rm<T,U,V,W>(out T a,out U b,out V c,out W d) {
		var z = rm<T,U,V>(out a,out b,out c); 
		d = cv<W>(z[3]);
		return z;
	}
	public static string[] rm<T,U,V,W,X>(out T a,out U b,out V c,out W d,out X e) {
		var z = rm<T,U,V,W>(out a,out b,out c,out d); 
		e = cv<X>(z[4]);
		return z;
	}
	public static string[] rm<T,U,V,W,X,Y>(out T a,out U b,out V c,out W d,out X e,out Y f) {
		var z = rm<T,U,V,W,X>(out a,out b,out c,out d,out e); 
		f = cv<Y>(z[5]);
		return z;
	}
	public static string[] ra<T>(out T[] a) {		
		var z = Console.ReadLine().Split(sp,StringSplitOptions.RemoveEmptyEntries);
		a = z.Select(cv<T>).ToArray();
		return z;
	}
	public static string[][] rl<T>(long n,out T[] a) {
		a = new T[n];
		var y = new string[n][];
		for(int i=0;i<n;i++) y[i] = rm(out a[i]);
		return y;
	}
	public static string[][] rl<T,U>(long n,out P<T,U>[] a) {
		a = new P<T,U>[n];
		var y = new string[n][];
		for(int i=0;i<n;i++) {
			T o; U p;
			y[i] = rm(out o,out p);
			a[i] = new P<T,U>(o,p);
		}
		return y;
	}
	public static string[][] rl<T,U,V>(long n,out P<T,U,V>[] a) {
		a = new P<T,U,V>[n];
		var y = new string[n][];
		for(int i=0;i<n;i++) {
			T o; U p; V q;
			y[i] = rm(out o,out p,out q);
			a[i] = new P<T,U,V>(o,p,q);
		}
		return y;
	}
	public static string[][] rl<T,U,V,W>(long n,out P<T,U,V,W>[] a) {
		a = new P<T,U,V,W>[n];
		var y = new string[n][];
		for(int i=0;i<n;i++) {
			T o; U p; V q; W r;
			y[i] = rm(out o,out p,out q,out r);
			a[i] = new P<T,U,V,W>(o,p,q,r);
		}
		return y;
	}
	public static string[][] rx<T>(long n,out T[][] a) {
		a = new T[n][];
		var y = new string[n][];
		for(int i=0;i<n;i++) y[i] = ra(out a[i]);
		return y;
	}

	static void wwp(Action act){
		sw.AutoFlush = false;
		Console.SetOut(sw);
		act();
		Console.Out.Flush();
		sw.AutoFlush = true;
		Console.SetOut(sw);
	}
	[MethodImpl(256)] static string wfm(Type t) =>t.Equals(typeof(double)) ? "{0:F10}" : "{0}";
	public static void wm(params object[] a) {
		wwp(()=>{
			for(int i=0;i<a.Length-1;i++) Console.Write(wfm(a[i].GetType())+" ",a[i]);
			Console.WriteLine(wfm(a[a.Length-1].GetType()),a[a.Length-1]);
		});
	}
	public static void wa<T>(IList<T> a) { wxa(new IList<T>[]{a}, " "); }
	public static void wl<T>(IList<T> a) {
		wwp(()=>{
			var f = wfm(typeof(T));
			foreach(T x in a) Console.WriteLine(f,x);
		});
	}
	static void wxa<T>(IList<IList<T>> a, string s) {
		wwp(()=>{
			var f = wfm(typeof(T));
			var g = f + s;
			foreach(var b in a) {
				for(int i=0;i<b.Count-1;i++) Console.Write(g,b[i]);
				Console.WriteLine(f,b[b.Count-1]);
			}
		});
	}
	public static void wx<T>(IList<IList<T>> a) { wxa(a, " "); }
	public static void wg<T>(IList<IList<T>> a) { wxa(a, ""); }
}

#endregion



}