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 Python (3.8.2) (judge verdict: Wrong Answer)

import sys
import itertools
import operator

sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N, K = map(int, input().split())
A = list(map(int, input().split()))

pos = [a for a in A if a > 0]
neg = [a for a in A if a < 0]
LP = len(pos)
LN = len(neg)
zer = N - LP - LN

MOD = 10 ** 9 + 7


def solve():
    global N, K, pos, neg, LP, LN, zer, MOD
    # ZERO
    if LP + LN < K:
        return 0

    # 全部使い切るとき
    if LP + LN == K and LP != 0:
        ans = 1
        for n in pos:
            ans *= n
            ans %= MOD
        for n in neg:
            ans *= n
            ans %= MOD

        return ans

    # negative にしかならない
    # 正がなくて、負の数を奇数回使う
    if LP == 0 and K % 2 == 1:
        if zer > 0:
            return 0
        else:
            neg.sort(reverse=True)
            ans = 1
            for n in neg:
                if K == 0:
                    break
                ans *= n
                ans %= MOD
                K -= 1

            return ans

    # positiveにできるなら
    # 2個ずつ比較
    pos.sort()
    neg.sort(reverse=True)

    ans = 1

    while K > 0 and len(neg) >= 2 and len(pos) >= 2:
        # 2個を比べる
        p = pos[-1] * pos[-2]
        n = neg[-1] * neg[-2]

        if n >= p:
            neg.pop()
            neg.pop()

            ans *= n
            ans %= MOD
            K -= 2
        else:
            ans *= pos[-1]
            ans %= MOD
            pos.pop()

            K -= 1

    # あとK個使う必要がある
    if K > 0:
        # negが1個以下
        if len(neg) <= 1:
            # posから取る
            for p in pos:
                ans *= p
                ans %= MOD
                K -= 1
                if K == 0:
                    break
        # posが1個以下
        else:
            while K >= 2:
                ans *= neg[-1]
                ans %= MOD
                ans *= neg[-2]
                ans %= MOD
                K -= 2
                neg.pop()
                neg.pop()

            if K == 1:
                ans *= pos[-1]
                ans %= MOD

    return ans


print(solve())