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 Rust (1.42.0) (judge verdict: Runtime Error)

#![allow(non_snake_case)]
use std::cmp::Reverse;
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let modNum = 100_000_000_0 + 7;
    let n: usize = read();
    let mut k: i64 = read();
    let mut plus: Vec<i64> = Vec::with_capacity(n);
    let mut minus: Vec<i64> = Vec::with_capacity(n);

    for _ in 0..n {
        let i: i64 = read();
        if i > 0 {
            plus.push(i);
        } else {
            minus.push(i);
        }
    }
    plus.sort();
    minus.sort_by_key(|&x| Reverse(x));
    let mut minusStart = minus.len();
    let mut plusStart = plus.len();
    while k > 1 {
        match (minusStart, plusStart) {
            (1, 1) => {
                minusStart = 0;
                plusStart = 0;
            }
            (0, _) => {
                plusStart -= 2;
            }
            (_, 0) => {
                minusStart -= 2;
            }
            (m, p) => {
                if minus[m - 1] * minus[m - 2] > plus[p - 1] * minus[p - 2] {
                    minusStart -= 2;
                } else {
                    plusStart -= 2;
                }
            }
        }
        k -= 2;
    }

    if k == 1{
        if plusStart > 0 {
            plusStart -= 1;
        } else if minusStart > 1 && plusStart < plus.len(){
            plusStart += 1;
            minusStart -= 2;
        } else {
            minus.reverse();
            minusStart -= 1;
        }
    }

    let mut ans = 1;
    for i in plusStart..plus.len() {
        ans = (ans * plus[i]) % modNum;
    }
    for i in minusStart..minus.len() {
        ans = (ans * minus[i]) % modNum;
    }
    while ans < 0 {
        ans += modNum;
    }

    print!("{}", ans);
}