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 1.8.0) (judge verdict: Wrong Answer)

import java.util.*;
import java.io.*;
public class Main {
	static int[] array;
	public static void main(String[] args) throws Exception{
		int num = 1000000007;

		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
 		StringTokenizer st = new StringTokenizer(bf.readLine());
 		int n = Integer.parseInt(st.nextToken());
 		int k = Integer.parseInt(st.nextToken());
 		ArrayList<Long> positives = new ArrayList<Long>();
 		ArrayList<Long> negatives = new ArrayList<Long>();
 		StringTokenizer st1 = new StringTokenizer(bf.readLine());
 		long prod =1;
 		for(int i = 0;i<n;i++){
 			long number = Long.parseLong(st1.nextToken());
 			if (number < 0)
 				negatives.add(number);
 			else{
 				positives.add(number);
 			}
 		}
 		Collections.sort(positives);
 		Collections.sort(negatives);
 		if (k == n){
 			prod =1;
 			for(long j : positives){
 				prod*= j;
 				prod = (prod%num+num)%num;
 			}
 			for(long j : negatives){
 				prod*= j;
 				prod = (prod%num+num)%num;
 			}
 			out.println(prod);
 		}
 		else if (positives.size() == 0){
 			if (k%2 == 0){
 				prod = 1;
 				for(int i = 0;i<k;i++){
 					prod*=negatives.get(i);
 					prod = (prod%num+num)%num;
 				}
 				out.println(prod);
 			}
 			else if (k%2 == 1){
 				prod = 1;
 				for(int i = negatives.size()-1;i>=negatives.size()-k;i--){
 					prod*=negatives.get(i);
 					prod = (prod%num+num)%num;
 				}
 				out.println(prod);
 			}
 		}
 		else{
 			prod = 1;
 			int indexpositive = 0;
 			int indexnegative = 0;
 			if (k%2 == 0){
 				if (positives.size()%2 ==0){
 					prod = 1;
 					if (k < positives.size()){
 						for(int i = positives.size()-1;i>=positives.size()-k;i--){
 							prod*=positives.get(i);
 							prod = (prod%num+num)%num;
 						}
 						indexpositive = positives.size();
 						indexnegative = -1;
 						
 					}
 					else{
 						for(int i = positives.size()-1;i>=0;i--){
 							prod*=positives.get(i);
 							prod = (prod%num+num)%num;
 						} 	
 						for(int i=0;i<k-positives.size();i++){
 							prod*=negatives.get(i);
 							prod = (prod%num+num)%num;
 						}
 						
 						indexpositive = positives.size();
 						indexnegative = -1+(k-positives.size());
 					}
 				}
 				else if (positives.size()%2 == 1){
 					prod =1 ;
 					if (k < positives.size()){
 						for(int i =positives.size()-1;i>=positives.size()-k;i--){
 							prod = prod*positives.get(i);
 	 						prod = (prod%num+num)%num;
 						}
 						
 						indexpositive = positives.size();
 						indexnegative = -1;
 					}
 					else{
 						for(int i =1;i<positives.size();i++){
 							prod = prod*positives.get(i);
 	 						prod = (prod%num+num)%num;
 						}
 						for(int i =0;i<k-(positives.size()-1);i++){
 							prod = prod*negatives.get(i);
 	 						prod = (prod%num+num)%num;
 						}
 						
 						
 						indexpositive = positives.size();
 						indexnegative = -1+(k-(positives.size()-1));
 					}
 				}
 			}
 			else{
 				if (positives.size()%2 == 0){
 					if (k < positives.size()){
 						for(int i =positives.size()-1;i>=positives.size()-k;i--){
 							prod = prod*positives.get(i);
 	 						prod = (prod%num+num)%num;
 						}
 						
 						indexpositive = positives.size();
 						indexnegative = -1;
 					}
 					else{
 						for(int i =1;i<positives.size();i++){
 							prod = prod*positives.get(i);
 	 						prod = (prod%num+num)%num;
 						}
 						for(int i =0;i<(k-(positives.size()-1));i++){
 							prod = prod*negatives.get(i);
 	 						prod = (prod%num+num)%num;
 						}
 						
 						indexpositive = positives.size();
 						indexnegative = -1 + (k-(positives.size()-1));
 						
 					}
 				}
 				else if (positives.size()%2 == 1){
 					if (k < positives.size()){
 						for(int i =positives.size()-1;i>=positives.size()-k;i--){
 							prod = prod*positives.get(i);
 	 						prod = (prod%num+num)%num;
 						}
 						indexpositive = positives.size();
 						indexnegative = -1;
 					}
 					else{
 						for(int i =0;i<positives.size();i++){
 							prod = prod*positives.get(i);
 	 						prod = (prod%num+num)%num;
 						}
 						for(int i = 0;i<k-positives.size();i++){
 							prod = prod*negatives.get(i);
 							prod = (prod%num+num)%num;
 						}
 						indexpositive = positives.size();
 						indexnegative = -1+(k-positives.size());
 					}
 				}
 			}
 			
 			

 			while(indexpositive > k%2+1 && indexnegative < negatives.size()-2){
 				long prod1 = positives.get(indexpositive-1)*positives.get(indexpositive-2);
 				long prod2 = negatives.get(indexnegative+1)*negatives.get(indexnegative+2);
 				if (prod2 > prod1){
 					prod*=prod2;
 					prod = (prod%num+num)%num;
 					prod*=power(prod1, num-2, num);
 					prod = (prod%num+num)%num;
 				}
 				else{
 					break;
 				}
 				indexpositive-=2;
 				indexnegative+=2;
 			}
 			out.println(prod);
 		}
 		out.close();
 		
 		
 		
 		
 	}
	public static int power(long x, long y, long mod){
		long ans = 1;
		while(y>0){
			if (y%2==1)
				ans = (ans*x)%mod;
			x = (x*x)%mod;
			y/=2;
		}
		return (int)(ans);
	}
}
 	
 
//StringJoiner sj = new StringJoiner(" "); 
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is