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: Wrong Answer)

import java.io.*;
import java.util.*;
public class Main
{
  public static void main(String args[])
  {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long mod=1000000007;
    long a[]=new long[n];
    int k=sc.nextInt();
    ArrayList<Long> pos=new ArrayList<>();
    ArrayList<Long> neg=new ArrayList<>();
    for( int i=0;i<n;i++)
    {
      a[i]=sc.nextLong();
      if(a[i]<0)
      {
        neg.add(a[i]);
      }
      else 
        pos.add(a[i]);
    }
    
    Collections.sort(neg);
    if(neg.size()==n)
    {
      int y=0;long prod=1l;
      for( int i=n-1;i>=0;i--)
      {
        if(y==k)
          break;
        prod=prod%mod*neg.get(i)%mod;
        prod%=mod;
        y++;
      }
      System.out.println((prod+mod)%mod);
    }
    else{
    Collections.sort(pos,Collections.reverseOrder());
    int p=-1;
    int q=-1;
    int count=0;
    while((p+1)<neg.size()&&(q+1)<pos.size())
    {
      if(Math.abs(neg.get(p+1))>Math.abs(pos.get(q+1)))
      {
        count++;
        p++;
      }
      else
      {
        count++;
        q++;
      }
      if(count==k)
      {
        break;
      }
   }
    while((p+1)<neg.size())
    {
       if(count==k)
        break;
      count++;
      p++;
    }
     while((q+1)<pos.size())
    {
       if(count==k)
        break;
      count++;
      q++;
    }
    if(p%2==0)
    {
      if((q+1)<pos.size())
      {
        q++;
        p--;
      }
    }
    long ans=1l;
    for( int i=0;i<=p;i++)
    {
      ans=(ans%mod)*(neg.get(i)%mod);
      ans%=mod;
    }
     for( int i=0;i<=q;i++)
    {
      ans=(ans%mod)*(pos.get(i)%mod);
      ans%=mod;
    }
    
     
     
    
    System.out.println((ans+mod)%mod);
    }
  }
}