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 <vector>
#include <list>
#include <set>
#include <queue>
#include <map>
#include <algorithm>
#include <functional>
#include <string>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <tuple>
using namespace std;

#define REP(i,p,n) for(ll i=p;i<ll(n);++i)
#define rep(i,n) REP(i,0,n)

using ll = long long int;
using pll = pair<ll, ll>;

static constexpr ll MOD = 1000000007;

inline ll mod(ll x)
{
    return x < 0 ? x + MOD : (x >= MOD ? x % MOD : x);
}

int main()
{
    ll N, K;
    cin >> N >> K;

    vector<ll> A, B;

    rep (i, N)
    {
        ll x;
        cin >> x;

        if (x < 0) { B.emplace_back(x); } else { A.emplace_back(x); }
    }

    sort(A.begin(), A.end(), greater<ll>());
    sort(B.begin(), B.end());

    const ll an = A.size();
    const ll bn = B.size();

    ll ai = 0, bi = 0, ans = 1;

    while (ai + bi < K)
    {
        if (bn <= bi)
        {
            ans = mod(ans * A[ai]);
            ++ai;
            continue;
        }

        if (an <= ai)
        {
            ans = mod(ans * B[bi]);
            ++bi;
            continue;
        }

        // B側の残りが残り1個
        if (bi + 1 == bn)
        {
            // A側が余ってる
            if (ai < an)
            {
                ans = mod(ans * A[ai]);
                ++ai;
                continue;
            }
            // A側が余ってない
            else
            {
                ans = mod(ans * B[bi]);
                ++bi;
                continue;
            }
        }

        const ll aa = ai < an - 1 ? mod(A[ai] * A[ai + 1]) : mod(A[ai]);
        const ll bb = mod(B[bi] * B[bi + 1]);

        // A側を採用する
        if (bb <= aa)
        {
            ans = mod(ans * aa);
            if (ai < an - 1) { ai += 2; } else { ai += 1; }
        }
        // B側を採用する
        else
        {
            ans = mod(ans * bb);
            bi += 2;
        }
    }

    // 頑張ってもB側を奇数取る場合は最小にする
    if ((bi % 2 == 1))
    {
        ll aj = 0, bj = 0;

        ans = 1;

        reverse(A.begin(), A.end());
        reverse(B.begin(), B.end());

        while (aj + bj < K)
        {
            if (an <= aj)
            {
                ans = mod(ans * B[bj]);
                ++bj;
                continue;
            }

            if (bn <= bj)
            {
                ans = mod(ans * A[aj]);
                ++aj;
                continue;
            }

            if (abs(A[aj]) < abs(B[bj]))
            {
                ans = mod(ans * A[aj]);
                ++aj;
            }
            else
            {
                ans = mod(ans * B[bj]);
                ++bj;
            }
        }
    }

    cout << ans << endl;

    return 0;
}