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 Kotlin (1.3.71) (judge verdict: Wrong Answer)

fun main() {
    val mod = 1000000007L
    val (n, k) = readInts()
    val a = readInts().map { it.toLong() }
    val positives = a.filter { it > 0L }.sorted().reversed()
    val zeros = a.filter { it == 0L }
    val negatives = a.filter { it < 0L }.sorted()

    fun mapNumToMod(num: Long): Long {
        val times = kotlin.math.abs(num / mod) + 1
        return (times * mod + num) % mod
    }

    fun addNums(source: List<Long>, destination: MutableList<Long>, from: Int, to: Int): Int {
        destination.addAll(source.subList(from, to))
        return to - from
    }

    if (positives.isEmpty() && zeros.isEmpty()) {
        val prod = negatives.reversed().subList(0, k).map {
            mapNumToMod(it)
        }.reduce { acc, num ->
            (acc * num) % mod
        }
        println(prod)
    } else if (positives.isEmpty()) println(0)
    else if (n - zeros.size < k) println(0)
    else {
        val combined = mutableListOf<Long>()
        var pos = 0
        var neg = 0
        if (k % 2 == 1) {
            combined.add(positives[pos])
            pos++
        }
        while (combined.size < k) {
            if (pos + 2 <= positives.size && neg + 2 <= negatives.size) {
                if (positives[pos] * positives[pos + 1] >= negatives[neg] * negatives[neg + 1]) {
                    pos += addNums(positives, combined, pos, pos + 2)
                } else neg += addNums(negatives, combined, neg, neg + 2)
            } else if (pos + 2 <= positives.size) pos += addNums(positives, combined, pos, pos + 2)
            else if (neg + 2 <= negatives.size) neg += addNums(negatives, combined, neg, neg + 2)
            else {
                if (pos < positives.size) pos += addNums(positives, combined, pos, pos + 1)
                else if (neg < negatives.size) neg += addNums(negatives, combined, neg, neg + 1)
            }
        }

        if (neg % 2 == 1 && zeros.isNotEmpty()) println(0)
        else println(combined.map { mapNumToMod(it) }.reduce { acc, num -> (acc * num) % mod })
//        println(combined)
    }

}

// Input Reader
private fun readLn() = readLine()!!

private fun readStrings() = readLn().trim().split(" ")
private fun readInts() = readStrings().map { it.toInt() }