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.util.*;
import java.io.*;
public class Main
{
    public static void main(String args[])throws Exception
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw=new PrintWriter(System.out);
        final long m=(long)1e9+7;
        String str[]=br.readLine().split(" ");
        int n=Integer.parseInt(str[0]);
        int k=Integer.parseInt(str[1]);
        str=br.readLine().split(" ");
        long arr[]=new long[n];
        //int p=0,ne=0;
        for(int i=0;i<n;i++)
        arr[i]=Long.parseLong(str[i]);
        ArrayList<Long> pos=new ArrayList<>();
        ArrayList<Long> neg=new ArrayList<>();
        for(int i=0;i<n;i++)
        {
            if(arr[i]<0)
            neg.add(arr[i]);
            else
            pos.add(arr[i]);
        }
        if(k==1)
        {
            long ans=Long.MIN_VALUE;
            for(int i=0;i<n;i++)
            ans=Math.max(ans,arr[i]);
            pw.println(ans);
        }
        else if(k==n)
        {
            long ans=1;
            for(int i=0;i<n;i++)
            ans=(ans*arr[i])%m;
            pw.println((ans+m)%m);
        }
        else if(pos.size()==0)
        {
            long ans=1;
            if(k%2==0)
            {
                //Collections.sort(pos,Collections.reverseOrder());
                Collections.sort(neg);
                for(int i=0;i<k;i++)
                ans=(ans*neg.get(i))%m;
            }
            else
            {
                Collections.sort(neg,Collections.reverseOrder());
                for(int i=0;i<k;i++)
                ans=(ans*neg.get(i))%m;
            }
            pw.println((ans+m)%m);
        }
        else
        {
            Collections.sort(pos,Collections.reverseOrder());
            Collections.sort(neg);
            long ans=1;
            if(k%2!=0)
            {
                int temp=k-1;
                int i=0,j=0;
                while(temp>0&&(i+1)<pos.size()-1&&(j+1)<neg.size())
                {
                    if(pos.get(i)*pos.get(i+1)>neg.get(j)*neg.get(j+1))
                    {
                        ans*=(pos.get(i)*pos.get(i+1))%m;
                        ans%=m;
                        i+=2;
                    }
                    else
                    {
                        ans*=(neg.get(j)*neg.get(j+1))%m;
                        ans%=m;
                        j+=2;
                    }
                    temp-=2;
                }
                while(temp>0&&i+1<pos.size()-1)
                {
                    ans*=(pos.get(i)*pos.get(i+1))%m;
                    ans%=m;
                    i+=2;
                    temp-=2;
                }
                while(temp>0&&j+1<neg.size())
                {
                    ans*=(neg.get(j)*neg.get(j+1))%m;
                    ans%=m;
                    j+=2;
                    temp-=2;
                }
                ans=(ans*pos.get(i))%m;
                pw.println(ans);
            }
            else
            {
                int temp=k;
                int i=0,j=0;
                while(temp>0&&(i+1)<pos.size()&&(j+1)<neg.size())
                {
                    if(pos.get(i)*pos.get(i+1)>neg.get(j)*neg.get(j+1))
                    {
                        ans*=(pos.get(i)*pos.get(i+1))%m;
                        ans%=m;
                        i+=2;
                    }
                    else
                    {
                        ans*=(neg.get(j)*neg.get(j+1))%m;
                        ans%=m;
                        j+=2;
                    }
                    temp-=2;
                }
                while(temp>0&&i+1<pos.size())
                {
                    ans*=(pos.get(i)*pos.get(i+1))%m;
                  	ans%=m;  
                  	i+=2;
                    temp-=2;
                }
                while(temp>0&&j+1<neg.size())
                {
                    ans*=(neg.get(j)*neg.get(j+1))%m;
                    ans%=m;
                    j+=2;
                    temp-=2;
                }
                pw.println(ans);
            }
        }
        pw.flush();
        pw.close();
    }
}