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 JavaScript (Node.js 12.16.1) (judge verdict: Wrong Answer)

const chunks = [];
process.stdin.on("data", (chunk) => {
  chunks.push(chunk);
});
process.stdin.on("end", () => {
  const data = Buffer.concat(chunks).toString("utf8").trim();
  const lines = data.split("\n");
  const [N, K] = parseLine(lines[0]);
  const A = parseLine(lines[1]);
  console.log(solve(N, K, A));
});

function parseLine(line) {
  return line.split(" ").map((item) => parseInt(item, 10));
}

function solve(N, K, A) {
  // Sort by abs desc
  A.sort((a, b) => Math.abs(b) - Math.abs(a));

  if (A[K - 1] === 0) return 0;

  let negative = false;
  let lastNegative = null;
  let lastPositive = null;
  for (let i = 0; i < K; i++) {
    const a = A[i];
    if (a < 0) {
      negative = !negative;
      lastNegative = i;
    }
    if (a > 0) {
      lastPositive = i;
    }
  }

  if (negative) {
    let firstPositive = null;
    let firstNegative = null;
    // Find the first positive number and replace it.
    // Find the first negative number and replace eit.
    for (let i = K; i < N; i++) {
      if (A[i] === 0) {
        return 0;
      }
      if (A[i] > 0) {
        firstPositive = i;
        break;
      }
    }
    for (let i = K; i < N; i++) {
      if (A[i] === 0) {
        return 0;
      }
      if (A[i] < 0) {
        firstNegative = i;
        break;
      }
    }

    let doNegaitve = firstNegative !== null;
    let doPositive = firstPositive !== null;
    if (doNegaitve && doNegaitve) {
      const a = Math.abs(A[lastPositive] * A[firstPositive]);
      const b = Math.abs(A[lastNegative] * A[firstNegative]);
      if (a <= b) {
        doPositive = false;
      } else {
        doNegaitve = false;
      }
    }

    if (doNegaitve) {
      const temp = A[firstNegative];
      A[firstNegative] = A[lastPositive];
      A[lastPositive] = temp;
      negative = false;
    } else if (doPositive) {
      const temp = A[firstPositive];
      A[firstPositive] = A[lastNegative];
      A[lastNegative] = temp;
      negative = false;
    } else {
      // Return the biggest negative number.
      A.sort((a, b) => Math.abs(a) - Math.abs(b));
      negative = true;
    }
  }

  const MOD = 1000000007;
  let mult = 1;
  for (let i = 0; i < K; i++) {
    mult = (mult * Math.abs(A[i])) % MOD;
  }
  if (negative) {
    return (mult + MOD) % MOD;
  } else {
    return mult;
  }
}