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 <bits/stdc++.h>
#include <math.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define PI 3.14159265359
using namespace std;
using ll = long long;
using P = pair<int, int>;

const int mod = 1000000007;
struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
  mint pow(ll t) const {
    if (!t) return 1;
    mint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }
  
  mint inv() const {
    return pow(mod-2);
  }
  mint& operator/=(const mint a) {
    return (*this) *= a.inv();
  }
  mint operator/(const mint a) const {
    mint res(*this);
    return res/=a;
  }
};

int abs(int a) {
  return (a < 0) ? -a : a;
}

bool comp(int a, int b) {
  return abs(a) > abs(b);
}

int main() {
  int n, k;
  cin >> n >> k;
  vector<int> a(n);
  int mall = 0;
  rep(i, n) { cin >> a[i]; if (a[i] < 0) mall++; }

  mint ans = 1;
  if (mall == n && k % 2 == 1) {
    sort(a.begin(), a.end());
    reverse(a.begin(), a.end());
    rep(i, k) ans *= (a[i] + 1000000007);
    cout << ans.x << endl;
    return 0;
  }

  sort(a.begin(), a.end(), comp);

  int m = 0;
  rep(i, k) {
    ans *= (a[i] + 1000000007);
    if (a[i] < 0) m++;
  }

  bool flug = true;
  for (int i = k; i < n; i++) {
    if (a[i] > 0) flug = false;
  }

  if (m % 2 == 0 || n == k || ans.x == 0 || (m % 2 == 0 && flug)){
    cout << ans.x << endl;
  } else {
    ll pmin = 0, mmax = 0, mmin = 0, pmax = 0;
    for (int i = k - 1; i >= 0; i--) {
      if (a[i] > 0 && pmin == 0) {
        pmin = a[i];
      }
      if (a[i] < 0 && mmin == 0) {
        mmin = a[i];
      }
    }
    for (int i = k; i < n; i++) {
      if (a[i] < 0 && mmax == 0) {
        mmax = a[i];
      }
      if (a[i] > 0 && pmax == 0) {
        pmax = a[i];
      }
    }
    ll mm = mmax * mmin, pp = pmax * pmin;
    if (mm > pp) {
      ans = ans.x / (pmin + 1000000007) * (mmax + 1000000007);
    } else {
      ans = ans / (mmin + 1000000007) * (pmax + 1000000007);
    }
    cout << ans.x << endl;
  }

  return 0;
}
/*
*/