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 Java (OpenJDK 11.0.6) (judge verdict: Accepted)

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
	static class Number implements Comparable<Number>{
		long x;
		long absx;
		public Number(long v) {
			x = v;
			absx = Math.abs(v);
		}
		@Override
		public int compareTo(Number o) {
			return Long.compare(absx, o.absx);
		}
		@Override
		public String toString() {
			return x + " " + absx;
		}
	}
	static final long MOD = 1000000007;
	static long solve(long A[], int K){
		List<Number> ns = new ArrayList<Number>();
		for(long a : A){
			ns.add(new Number(a));
		}
		Collections.sort(ns);
		Collections.reverse(ns);
		int sign = 1;
		long ret = 1;
		int last_pos = -1;
		int last_neg = -1;
		for(int i = 0 ; i < K ; ++i){
			Number n = ns.get(i);
			ret = (ret * n.absx) % MOD;
			if(n.x > 0){
				last_pos = i;
			}else if(n.x == 0){
				sign = 0;
			}else{
				sign = - sign;
				last_neg = i;
			}
		}
		if(sign > 0){
			return ret;
		}
		if(sign == 0){
			return 0;
		}
		// last_neg >= 0
		int first_pos = -1;
		int first_neg = -1;
		for(int i = K ; i < ns.size() ; ++i){
			Number n = ns.get(i);
			if(n.x >= 0 && first_pos < 0){
				first_pos = i;
			}else if(n.x < 0 && first_neg < 0){
				first_neg = i;
			}
		}
		if(last_pos >= 0){
			if(first_pos >= 0 && first_neg >= 0){
				if(ns.get(first_pos).absx * ns.get(last_pos).absx >= ns.get(first_neg).absx * ns.get(last_neg).absx){
					ret = ns.get(first_pos).x;
					sign = 1;
					for(int i = 0 ; i < K ; ++i){
						if(i == last_neg){
							continue;
						}
						Number n = ns.get(i);
						ret = (ret * n.absx) % MOD;
					}
					return ret;					
				}else{
					ret = ns.get(first_neg).absx;
					sign = 1;
					for(int i = 0 ; i < K ; ++i){
						if(i == last_pos){
							continue;
						}
						Number n = ns.get(i);
						ret = (ret * n.absx) % MOD;
					}
					return ret;		
				}
			}
			if(first_pos >= 0){
				ret = ns.get(first_pos).x;
				sign = 1;
				for(int i = 0 ; i < K ; ++i){
					if(i == last_neg){
						continue;
					}
					Number n = ns.get(i);
					ret = (ret * n.absx) % MOD;
				}
				return ret;				
			}
			if(first_neg >= 0){
				ret = ns.get(first_neg).absx;
				sign = 1;
				for(int i = 0 ; i < K ; ++i){
					if(i == last_pos){
						continue;
					}
					Number n = ns.get(i);
					ret = (ret * n.absx) % MOD;
				}
				return ret;				
			}
			return getNeg(ns, K);
		}
		// 前は全部マイナス , 
		if(first_pos >= 0){
			ret = ns.get(first_pos).x;
			sign = 1;
			for(int i = 0 ; i < K ; ++i){
				if(i == last_neg){
					continue;
				}
				Number n = ns.get(i);
				ret = (ret * n.absx) % MOD;
			}
			return ret;				
		}
		return getNeg(ns, K);
	}
	static long getNeg(List<Number> ns, int K){
		Collections.sort(ns);
		long ret = 1;
		for(int i = 0 ; i < K ; ++i){
			ret = (ret * ns.get(i).absx) % MOD;
		}
		return MOD - ret;
	}
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int K = sc.nextInt();
		long A[] = new long[N];
		for(int i = 0 ; i < N ; ++i){
			A[i] = sc.nextLong();
		}
		System.out.println(solve(A, K));
	}
}