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;

using ll = long long;
const int MOD = 1e9 + 7, MAX_N = 200009;

int main() {
    int N, K;  cin >> N >> K;
    vector<ll> P, M;
    for (int i = 0; i < N; ++i) {
        ll a;  cin >> a;
        if (a >= 0) P.push_back(a);
        else if (a < 0) M.push_back(-a);
    }
    sort(P.begin(), P.end(), greater<ll>());
    sort(M.begin(), M.end(), greater<ll>());
    // DUMP(P, M);

    if (P.empty() && K % 2) {
        ll ans = 1;
        for (int i = 0; i < K; ++i) ans = ans * M[M.size() - 1 - i] % MOD;
        cout << (-ans + MOD) % MOD << endl;
        return 0;
    }

    ll ans = 1, ans_tmp;
    int i = 0, j = 0, sign = 0, sign_tmp;
    for (int _ = 0; _ < K; ++_) {
        // DUMP(make_tuple(_, i, j));
        if (_ == K - 1) {
            ans_tmp = ans;
            sign_tmp = sign;
        }

        if (i < P.size() && j < M.size()) {
            if (P[i] > M[j]) ans = ans * P[i++] % MOD;
            else {
                ans = ans * M[j++] % MOD;
                sign = 1 - sign;
            }
        }
        else if (i == P.size() && j < M.size()) {
            ans = ans * M[j++] % MOD;
            sign = 1 - sign;
        }
        else if (i < P.size() && j == M.size()) {
            ans = ans * P[i++] % MOD;
        }
    }
    // DUMP(ans, sign);

    if (sign == 0) {
        cout << ans << endl;
    }
    else if (sign == 1) {
        ll ans_1 = -1, ans_2 = -1;
        if (i < P.size()) ans_2 = (ans_tmp + P[i] + MOD) % MOD;
        if (j < M.size()) ans_1 = (ans_tmp + M[j] + MOD) % MOD;

        if (max(ans_1, ans_2) >= 0) cout << max(ans_1, ans_2) << endl;
        else cout << (-ans + MOD) % MOD << endl;
    }
}