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

#include<stdio.h>
#define ull unsigned long long int 
ull max(ull,ull);
ull find_mod(ull);
ull *a;
int main()
{
   int n,k;
  scanf("%d %d",&n,&k);
  int i=0,j;
  a=(ull *)malloc(n*sizeof(ull));
  for(i=0;i<n;i++)
    scanf("%llu",&a[i]);
  mergesort(a,0,n-1);
  ull leftprod[n],rightprod[n];
  leftprod[0]=a[0]%1000000007;
  for(i=1;i<n;i++)
   leftprod[i]=(a[i]*leftprod[i-1])%1000000007;
  rightprod[n-1]=a[n-1]%1000000007;
  for(i=n-2;i>=0;i--)
   {
     rightprod[i]=(a[i]*rightprod[i+1])%1000000007;
   }
  ull max_prod=leftprod[k-1]%1000000007;
  max_prod=max(max_prod,rightprod[n-k])%1000000007;
  i=1;
  j=k-1;
 while(i<=k-1)
  {
    max_prod=max(max_prod,(leftprod[i-1]*rightprod[n-j])%1000000007)%1000000007;
   i++;
   j--;  
  }
 printf("%llu\n",find_mod(max_prod));
return 0;
}
ull find_mod(ull n)
{
  if(n<0) return 1000000007-((-1*n)%1000000007);
return n%1000000007;
}

void mergesort(ull *a,int l,int r)
{
  if(l<r)
  {
    int m=l+(r-l)/2;
    mergesort(a,l,m);
    mergesort(a,m+1,r);
    merge(a,l,m,r);
  }
}

void merge(ull *a,int l,int m,int r)
{
  int i,j,k;
  int n1=m-l+1;
  int n2=r-m;
  ull L[n1],R[n2];
  
  for(i=0;i<n1;i++)
   {
   L[i]=a[l+i];
   }
  for(i=0;i<n2;i++)
  {
   R[i]=a[m+1+i];
  }
 i=0;
 j=0;
 k=l;
 while(i<n1&&j<n2)
  {
    if(L[i]<=R[j])
    {
     a[k]=L[i];
      i++;
    }
   else
     {
    a[k]=R[j];
     j++;
     }
   k++;
  }
 while(i<n1)
   {
   a[k++]=L[i++];
   }
 while(j<n2)
  {
  a[k++]=R[j++];
  }

}

ull max(ull i,ull j)
{
 return i>j?i:j;
}