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: Wrong Answer)

use std;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace()
        .map(|e| e.parse().ok().unwrap()).collect()
}

fn e_multiplication_4() {
    let nk = read_vec::<usize>();
    let n = nk[0];
    let k = nk[1];
    let mut a = read_vec::<i64>();
    let (mut s, mut t): (Vec<i64>, Vec<i64>) = a.iter().partition(|&e| *e >= 0);
    const DIV: i64 = 1000000007;
    s.sort();
    t.sort();
    a.sort_by_key(|e| e.abs());

    let is_certainly_negative = s.len() == 0 && k % 2 == 1;

    let ans: i64 = if n == k {
        a.iter()
            .fold(1, |acc, e| (acc * e).rem_euclid(DIV))
    } else if is_certainly_negative {
        a.iter()
            .take(k)
            .fold(1, |acc, e| (acc * e).rem_euclid(DIV))
    } else {
        let init = if k % 2 == 1 { s.pop().unwrap() } else { 1 };
        let mut products: Vec<i64> = vec![];
        let mut s_products = s.rchunks(2).map(|e| e.iter().product()).collect();
        let mut t_products = t.rchunks(2).map(|e| e.iter().product()).collect();
        products.append(&mut s_products);
        products.append(&mut t_products);
        products.sort_by_key(|&e| std::cmp::Reverse(e));
        (
            init * products.iter()
                .take(k / 2)
                .map(|e| e.rem_euclid(DIV))
                .fold(1, |acc, e| (acc * e).rem_euclid(DIV))
        ).rem_euclid(DIV)
    };

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

fn main() {
    e_multiplication_4();
}