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 PyPy3 (7.3.0) (judge verdict: Wrong Answer)

import sys
from bisect import bisect_left, bisect_right
from collections import deque
def input(): return sys.stdin.readline().strip()
mod = 10**9+7

def main():
    N, K = map(int, input().split())
    A = list(map(int, input().split()))
    A.sort()
    idx1 = bisect_left(A, 0)
    idx2 = bisect_right(A, 0)
    A_minus = A[:idx1]
    A_zero = idx2 - idx1
    A_plus = A[idx2:]

    if N - A_zero < K:
        print(0)
        return
    if N - idx2 == 0 and K % 2 == 0:
        ans = 1
        for i in range(K):
            ans *= A[i]
            ans %= mod
        print(ans)
        return
    if N - idx2 == 0 and K % 2 != 0:
        ans = 1
        for i in range(K):
            ans *= A[N - i - 1]
            ans %= mod
        print(ans)
        return

    pos_idx = max(0, (N - idx2) - K)
    neg_idx = 0
    while pos_idx < N - idx2 - 1 and neg_idx < idx1 - 1:
        x = A_plus[pos_idx] * A_plus[pos_idx + 1]
        y = A_minus[neg_idx] * A_minus[neg_idx + 1]
        if x < y:
            pos_idx += 2
            neg_idx += 2
        else:
            break

    ans = 1
    for i in range(pos_idx, N - idx2):
        ans *= A_plus[i]
        ans %= mod
    for i in range(neg_idx):
        ans *= A_minus[i]
        ans %= mod
    print(ans)


if __name__ == "__main__":
    main()