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: Runtime Error)

#include "iostream"
#include "cstdio"
#include "algorithm"
#include "vector"
using namespace std;
const long long  mod=1e9+7;
typedef long long ll;
int N,K;
vector<ll> pos,neg;
vector<ll> ans;
void input(){
    scanf("%d%d",&N,&K);
    for(int i = 0 ;i < N; ++i){
        ll tmp;
        scanf("%lld",&tmp);
        if(tmp >= 0) pos.push_back(tmp);
        else neg.push_back(tmp);
    }
}
void calc(){
    ll ret = 1;
    sort(pos.begin(),pos.end());
    sort(neg.begin(),neg.end());
    int i = pos.size()-1;
    int j = 0,cnt = 0;
    if(neg.size() == 0){
        while(cnt < K){
            ans.push_back(pos[i]);
            --i;
            ++cnt;
        }
        return;
    }else if(pos.size() == 0){
        if(K & 1){
            for(int  k = neg.size() -1; cnt < K; --k){
                ans.push_back(neg[k]);
                ++cnt;
            }
        }else{
            for(int k = 0 ; cnt < K; ++k){
                ans.push_back(neg[k]);
                ++cnt;
            }
        }
        return;
    }
    if(K % 2){
        ans.push_back(pos[i]);
        --i;
        cnt = 1;
    }
    //printf(" i = %d j = %d/n",i,j);
    while(cnt < K && i >= 1 && j < neg.size() -1){
        if(pos[i] * pos[i-1] >= neg[j] * neg[j +1]){
            ans.push_back(pos[i]);
            ans.push_back(pos[i-1]);
            cnt += 2;
            i-=2;
        }else{
            ans.push_back(neg[j]);
            ans.push_back(neg[j+1]);
            cnt += 2;
            j+=2;
        }
    }
    while(cnt < K){
        while(i == 0){
            if(j < neg.size() -1 && neg[j] * neg[j + 1] >= pos[i]){
                ans.push_back(neg[j]);
                ans.push_back(neg[j + 1]);
                j += 2;
                cnt +=2;
            }else{
                ans.push_back(pos[i]);
                ++cnt;
                --i;
            }
        }
        while(cnt < K){
            ans.push_back(neg[j]);
            ++j;
            ++cnt;
        }
    }
}
int main(){
    input();
    calc();
    long long  res=1;
    for(int i=0;i<ans.size();i++)
    	res=res*ans[i]%mod;
    if(res<0)  res=(res%mod+mod)%mod;
    printf("%lld\n",res);
    return 0;
}