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++ (Clang 10.0.0) (judge verdict: Runtime Error)

#include <algorithm>
#include <array>
#include <cmath>
#include <functional>
#include <iostream>
#include <set>
#include <string>
#include <utility>
#include <vector>

int main()
{
    const long long mod = 1000000007ll;
    int n, k;

    int posi = 0;
    int nega = 0;
    std::cin >> n >> k;
    std::vector<long long> a(n);
    std::vector<long long> ns, ps;
    for (int i = 0; i < n; i++) {
        auto& e = a.at(i);
        std::cin >> e;
        if (e < 0) {
            nega++;
        } else if (e > 0) {
            posi++;
        }
    }

    long long ans = 1;
    bool ism = false;
    if ((posi + nega) < k) {
        std::cout << "0\n";
    } else if (n == k) {
        int ef = 1;
        for (auto& e : a) {
            if (e < 0)
                ef *= -1;
            ans *= std::abs(e) % mod;
            ans %= mod;
        }
        if (ef < 0) {
            ans = mod - ans;
        }
    } else if (posi == 0 && k % 2 == 1) {
        std::sort(a.begin(), a.end(), [](const auto& a, const auto& b) -> bool { return std::abs(a) < std::abs(b); });
        for (int i = 0; i < k; i++) {
            ans *= (-a.at(i)) % mod;
            ans %= mod;
        }
        ans = mod - ans;
    } else {
        std::sort(a.begin(), a.end(), [](const auto& a, const auto& b) -> bool { return std::abs(a) > std::abs(b); });
        bool one = true;
        for (int i = 0; i < n; i++) {
            auto& e = a.at(i);
            if (e < 0) {
                if (ns.size() > 0 && ns.back() < 0) {
                    ns.at((ns.size() - 1) / 2) *= e;
                    one = false;
                } else {
                    ns.push_back(e);
                    one = true;
                }
            } else if (e > 0) {
                ps.push_back(e);
            }
        }

        int n_i = 0, p_i = 0;
        for (int i = 0; i < k; i++) {
            if (n_i < ns.size() && !(one && n_i == (ns.size() - 1))) {
                if (ns.at(n_i) > ps.at(p_i)) {
                    ans *= ns.at(n_i) % mod;
                    ans %= mod;
                    i++;
                    n_i++;
                    continue;
                }
            }
            ans *= ps.at(p_i) % mod;
            ans %= mod;
            p_i++;
        }
    }
    std::cout << ans << "\n";
    return 0;
}