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() {
    abc173e()
}

private const val BASE_NUMBER = 1_000_000_007L

fun abc173e() {
    // 最大値を求める→　絶対値の大きい順に選ぶ　→　マイナスが奇数個の場合はマイナスが偶数個になるように選ぶ
    // どうあがいてもマイナスになる場合、逆に絶対値の小さい順に選ぶ
    // 全組み合わせを試す余裕はない
    var containMinus = false
    var containZero = false
    val (n, k) = readLine()!!.split(" ").map { it.toInt() }
    val isOdd = k % 2 == 1
    val plusValue = mutableListOf<Long>()
    val minusValue = mutableListOf<Long>()
    for (l in readLine()!!.split(" ").map { it.toLong() }) {
        if (l == 0L) {
            containZero = true
        }
        if (l > 0L) {
            plusValue.add(l)
        } else {
            minusValue.add(l)
        }
    }
    if (containZero && plusValue.size + minusValue.size < k) {
        // ゼロを選ばざるを得ない場合は0になるので答えもゼロ
        println(0)
        return
    }
    var total = 0L
    val sortedPlus = plusValue.sortedDescending()
    val sortedMinus = minusValue.sorted()
    if (minusValue.isEmpty()) {
        // 負の値がない→plusの最大値からk個選べば良い
        total = sortedPlus[0]
        for (i in 1 until k) {
            total = total * sortedPlus[i] % BASE_NUMBER
        }
        println(total)
    } else if (plusValue.isEmpty()) {
        // 負の値しかない
        if (isOdd) {
            // マイナスしかなく奇数個選ばなければならないなら答えはマイナスになるので、絶対値が小さい順に選ぶ
            if (containZero) {
                // プラスの値がなく、0があるなら最大値は0になる(そうでなければマイナスの値にしかならないので)
                println(0)
                return
            }
            total = sortedMinus.last() * -1
            val lastIndex = sortedMinus.lastIndex
            for (i in 1 until k) {
                total = total * sortedMinus[lastIndex - i] * -1 % BASE_NUMBER
            }
            total *= -1
            println(if (total < 0) total + BASE_NUMBER else 0)
        } else {
            // kが偶数個なら絶対値の大きい順に選ぶのが最適
            total = sortedMinus[0]
            for (i in 1 until k) {
                total = total * sortedMinus[i] * -1 % BASE_NUMBER
            }
            println(total)
        }
    } else {
        // 最もややこしいケースで、とりあえず絶対値が大きい順に選んでみる
        // その結果、マイナスになるのであれば、最後に選んだマイナスとプラスの次点を入れ替える
        // プラスの次点がない場合はプラスの最小とマイナスの次点を入れ替える
        var p = 0
        var m = 0
        var plusTotal = 1L
        var minusTotal = 1L
        var prevPlus = 0L
        var prevMinus = 0L
        var sign = 1L
        if (k > sortedPlus.size && k % 2 == 1 && !containZero) {
            // どうしてもマイナスから値を選ばざるを得ず、かつ奇数個マイナスを選ぶことになる場合
        }
        for (i in 0 until k) {
            val plusValue = if (p < sortedPlus.size) sortedPlus[p] else 0L
            val minusValue = if (m < sortedMinus.size) sortedMinus[m] * -1 else 0L
            if (plusValue > minusValue) {
                prevPlus = plusTotal
                plusTotal = plusTotal * sortedPlus[p] % BASE_NUMBER
                p++
            } else {
                prevMinus = minusTotal
                minusTotal = minusTotal * minusValue % BASE_NUMBER
                sign *= -1L
                m++
            }
        }
        total = plusTotal * minusTotal * sign % BASE_NUMBER
        if (total < 0) {
            // 最後に使ったマイナスを次点のプラスに入れ替えるのと、最後のプラスを次点のマイナスに入れ替えるの2パターンが考えらる
            // つまり次点のそれぞれの値のうち、絶対値の大きい方を選ぶ
            if (sortedPlus.size + sortedMinus.size == k) {
                // そもそもどちらにも次点が存在しない場合はこれ以上変えようがない
                total += BASE_NUMBER
            } else {
                val nextPlus = if (p < sortedPlus.size) sortedPlus[p] else 0L
                val nextMinus = if (m < sortedMinus.size) sortedMinus[m] * -1 else 0L
                if (nextPlus > nextMinus) {
                    // 次点のプラスの方が大きい＝最後のマイナスの代わりに次点のプラスを使う
                    minusTotal = prevMinus
                    plusTotal = plusTotal * nextPlus % BASE_NUMBER
                } else {
                    // 次点のマイナスの方が大きい＝最後のプラスの代わりに次点のマイナスを使う
                    plusTotal = prevPlus
                    minusTotal = minusTotal * nextMinus % BASE_NUMBER
                }
                total = plusTotal * minusTotal % BASE_NUMBER
            }
        }
        println(total)
    }
}