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 <iostream>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n) - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
const ll MOD = 1e9 + 7;

ll power(int x, int y) {
    if (y == 0) return 0;
    if (y == 1) return x;
    ll p = power(x, y >> 1);
    if (y & 1) return p * p % MOD * x % MOD;
    else return p * p % MOD;
}

ll inv(ll n) {
    return power(n, MOD - 2);
}

ll N, K, A[200000];

int main() {
    cin >> N >> K;
    bool all_minus = true;
    REP(i, N) {
        cin >> A[i];
        if (A[i] > 0) all_minus = false;
    }
    sort(A, A + N, [](auto const& lhs, auto const& rhs) { return abs(lhs) > abs(rhs); });
    bool minus = false;
    ll last_minus = -1, last_plus = -1;
    ll ans = 1;
    REP(i, K) {
        if (A[i] < 0) {
            ans = ans * -A[i] % MOD;
            minus = !minus;
            last_minus = i;
        } else if (A[i] > 0) {
            ans = ans * A[i] % MOD;
            last_plus = i;
        }
    }
    if (!minus) {
        cout << ans << endl;
        return 0;
    }
    if (all_minus) {
        ans = 1;
        REP(i, K) ans = ans * -A[N - i - 1] % MOD;
        cout << (MOD - ans) % MOD << endl;
        return 0;
    }

    ll next_minus = -1, next_plus = -1;
    FOR(i, K, N) {
        if (A[i] < 0 && next_minus == -1) next_minus = i;
        if (A[i] > 0 && next_plus == -1) next_plus = i;
    }

    if (next_plus != -1 && next_minus != -1) {
        if (A[next_plus] * A[last_plus] > A[next_minus] * A[last_minus]) {
            cout << ans * inv(-A[last_minus]) % MOD * A[next_plus] << endl;
        } else {
            cout << ans * inv(A[last_plus]) % MOD * (-A[next_minus]) << endl;
        }
    } else if (next_plus != -1) {
        cout << ans * inv(-A[last_minus]) % MOD * A[next_plus] << endl;
    } else if (next_minus != -1) {
        cout << ans * inv(A[last_plus]) % MOD * (-A[next_minus]) << endl;
    } else {
        if (N == K) {
            int a = 1 / 0;
            cout << (MOD - ans) % MOD << endl;
        }
        else cout << 0 << endl;
    }
    return 0;
}