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 <bits/stdc++.h>
using namespace std;

const long long MOD=1000000007;

int main(){
  int N,K; cin >> N >> K;
  vector<long long> A(N);
  int Nplus=0,Nzero=0,Nminus=0;
  for(int i=0; i<N; i++){
    cin >> A[i];
    if(A[i]>0) Nplus++;
    else if(A[i]==0) Nzero++;
    else Nminus++;
  }
  vector<long long> Aplus(Nplus),Aminus(Nminus);
  int tp=0,tm=0;
  for(int i=0; i<N; i++){
    if(A[i]>0){
      Aplus[tp]=A[i]; tp++;
    }else if(A[i]<0){
      Aminus[tm]=-A[i];
      tm++;
    }
  }
  int count=0,pcount=0,mcount=0;
  long long result=1;
  if(Nplus>=K || (K%2==0 && Nplus+(Nminus/2)*2>=K) || (K%2==1 && Nplus>0 && Nplus+(Nminus/2)*2>=K)){
    //+にできる
    //-から2個ずつなら持ってきてよい
    sort(Aplus.begin(),Aplus.end(),greater<long long>());
    sort(Aminus.begin(),Aminus.end(),greater<long long>());
    while(count<K){
      if(count+1==K){
        result*=Aplus[pcount]; result%=MOD;
        pcount++; count++;
      }else{
        if(pcount<Nplus-1 && mcount<Nminus-1){
          long long ptemp,mtemp;
          ptemp=Aplus[pcount]*Aplus[pcount];
          mtemp=Aminus[mcount]*Aminus[mcount];
          if(ptemp>mtemp){
            result*=Aplus[pcount]; result%=MOD;
            pcount++; count++;
          }else{
            result*=Aminus[mcount]; result%=MOD;
            mcount++; count++;
            result*=Aminus[mcount]; result%=MOD;
            mcount++; count++;
          }
        }else if(mcount>=Nminus-1){
          result*=Aplus[pcount]; result%=MOD;
          pcount++; count++;
        }else{
          result*=Aminus[mcount]; result%=MOD;
          mcount++; count++;
          result*=Aminus[mcount]; result%=MOD;
          mcount++; count++;
        }
      }
    }
  }else if(Nzero>0){
    //+にはできないが0にできるのでするしかない
    cout << 0 << endl;
  }else{
    //-にしかならない
    //絶対値最小を目指す
    vector<long long> Aabs(Nplus+Nminus);
    for(int i=0; i<Nplus; i++){
      Aabs[i]=Aplus[i];
    }
    for(int i=0; i<Nminus; i++){
      Aabs[i+Nplus]=Aminus[i];
    }
    sort(Aabs.begin(),Aabs.end());
    for(int i=0; i<K; i++){
      result*=Aabs[i];
      result%=MOD;
    }
    result=(MOD-result)%MOD;
  }
  
  cout << result << endl;
}