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 <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define DEBUG 1
using namespace std;
constexpr int kMod = 1000000007;
typedef long long LL;
typedef pair<LL, bool> P;

template<typename T>
istream& operator >> (istream& is, vector<T>& vs){
  for(T& v: vs) is >> v;
  return is;
}

int main() {
  LL N, K; cin >> N >> K;
  vector<LL> A(N); cin >> A;
  vector<LL> pos, neg;
  LL zero_cnt = 0;
  for (int i = 0; i < N; ++i) {
    if      (A[i] > 0) pos.push_back(A[i]);
    else if (A[i] < 0) neg.push_back(A[i]);
    else            ++zero_cnt;
  }
  sort(pos.rbegin(), pos.rend());
  sort(neg.begin(), neg.end());

  int pos_cnt = pos.size();
  int neg_cnt = neg.size();
  if (pos_cnt + neg_cnt < K) {
    cout << 0 << endl;
    return 0;
  }

  LL x = K - (min(K, (LL)neg_cnt) / 2) * 2;
  bool negative = (x > pos_cnt);
  if (!negative) {
    priority_queue<P> que;
    for (LL v : A) {
      if (v > 0) que.push({v, true});
      if (v < 0) que.push({-v, false});
    }

    LL sum = 1;
    LL nv = 1;
    for (int i = 0; i < K;) {
      auto [v, b] = que.top(); que.pop();
      if (b) {
        sum = (sum * v) % kMod;
        ++i;
      } else {
        if (nv != 1) {
          i += 2;
          LL x = nv * v % kMod;
          sum = (sum * x) % kMod;
          nv = 1;
        } else {
          nv = v;
        }
      }
    }
    cout << sum << endl;
  } else {
    priority_queue<LL, vector<LL>, greater<LL>> que;
    for (LL v : A) que.push(abs(v));
    LL sum = 1;
    for (int i = 0; i < K; ++i) {
      LL v = que.top(); que.pop();
      sum = (sum * v) % kMod;
    }
    cout << (kMod - sum) % kMod << endl;
  }
}