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;

typedef long long ll;

const int MOD = 1e9 + 7;

int main(){
	int n, k;
	cin >> n >> k;
	int neg = 0, pos = 0, zero = 0;
	vector<ll> posis, negs, a;
	for(int i = 0; i < n; i++){
		ll cur;
		cin >> cur;
		if(cur == 0){
			zero++;
		}else if(cur < 0){
			neg++;
			negs.push_back(-cur);
			a.push_back(cur);
		}else{
			pos++;
			posis.push_back(cur);
			a.push_back(cur);
		}
	}
	sort(a.begin(), a.end());
	sort(posis.begin(), posis.end());
	sort(negs.begin(), negs.end());
	ll sol = 1, count = 0;
	if(pos >= k - neg + (neg % 2) && pos > 0){
		int pos_pointer = posis.size() - 1, negs_pointer = negs.size() - 1;
		while(count < k){
			if(pos_pointer < 0 || (pos_pointer == 0 && count == k - 2)){
				sol = (sol * negs[negs_pointer]) % MOD;
				sol = (sol * negs[negs_pointer - 1]) % MOD;
				negs_pointer--;
				negs_pointer--;
				count++;
				count++;
				continue;
			}
			if(negs_pointer <= 0 || count == k - 1){
				sol = (sol * posis[pos_pointer]) % MOD;
				pos_pointer--;
				count++;
				continue;
			}
			ll cur_pos = posis[pos_pointer] * posis[pos_pointer - 1];
			ll neg_pos = negs[negs_pointer] * negs[negs_pointer - 1];
			if(cur_pos >= neg_pos){
				sol = (sol * posis[pos_pointer]) %  MOD;
				sol = (sol * posis[pos_pointer - 1]) %  MOD;
				pos_pointer -= 2;
				count += 2;
			}else{
				sol = (sol * negs[negs_pointer]) %  MOD;
				sol = (sol * negs[negs_pointer - 1]) %  MOD;
				negs_pointer -= 2;
				count += 2;
			}
		}
		cout << sol << '\n';
	}else if (pos + neg + zero >= k && zero > 0){
		cout << 0 << '\n';
	}else{
		for(ll i = 0; i < a.size(); i++){
			if(count == k) break;
			sol = ((sol * a[i])) % MOD;
			count++;
		}
		cout << (-sol + MOD) % MOD << '\n';
	}
}