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: Wrong Answer)

#include<iostream>
#include<map>
#include<set>
#include<unordered_set>
#include<unordered_map>
#include<vector>
#include<cstring>
#include<sstream>
#include<algorithm>
//#include<bits/stdc++.h>
#include<cstdio>
using namespace std;

#define MOD 1000000007

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    int n, k;
    cin >> n >> k;

    long long a[n];
    vector<long long> pos, neg;

    for (int i = 0; i < n; i++) {
        cin >> a[i];

        if (a[i] >= 0) pos.push_back(a[i]);
        else neg.push_back(a[i]);
    }

    sort(pos.rbegin(), pos.rend());
    sort(neg.begin(), neg.end());

    long long res = 1;

    if (n == k) {
        for (int i = 0; i < k; i++) {
            res *= a[i];
            while (res < 0) res += MOD;
            res %= MOD;
        }

        cout << res << endl;
        return 0;
    } else if (pos.size() == 0) {
        sort(neg.rbegin(), neg.rend());
        for (int i = 0; i < k; i++) {
            res *= neg[i];
            while (res < 0) res += MOD;
            res %= MOD;
        }

        cout << res << endl;

        return 0;
    }

    int i = 0, j = 0;
    while (k) {
        if (k == 1) {
            if (i < pos.size()) {
                res *= pos[i++];
            } else {
                res *= neg[j++];
            }

            --k;
        } else if (i < pos.size() && j < neg.size()) {
            long long x1 = pos[i], x2 = (i+1) < pos.size() ? pos[i+1] : 1;
            long long y1 = neg[j], y2 = (j+1) < neg.size() ? neg[j+1] : 1;

            if ((x1*x2) > (y1*y2)) {
                res *= x1;
                res %= MOD;
                ++ i;
                k --;
            } else {
                res *= (y1*y2)%MOD;
                res %= MOD;

                if (y2 != 1) {
                    j += 2;
                    k -= 2;
                }
                else {
                    ++ j;
                    -- k;
                }
            }
        } else {
            while (i < pos.size() && k) {
                res *= pos[i++];
                res %= MOD;
                k --;
            }

            while (j < neg.size() && k) {
                res *= neg[j++];
                while (res < 0) res += MOD;
                res %= MOD;
                k --; 
            }
        }
    }

    cout << res << endl;
    
    return 0;
}