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: Accepted)

#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use {
    proconio::{marker::*, *},
    std::{cmp::*, collections::*, mem::*},
};

#[fastout]
fn main() {
    input! {
        n:usize,k:usize,
        mut a:[i64;n],
    }
    let mut neg = Vec::new();
    let mut pos = Vec::new();
    let mut zeros = 0;
    a.sort_by_key(|x| x.abs());
    for &x in a.iter() {
        if x < 0 {
            neg.push(x);
        } else if x >= 0 {
            pos.push(x);
        }
        if x == 0 {
            zeros += 1;
        }
    }
    if k > n - zeros {
        println!("{}", 0);
        return;
    }

    if k == n {
        let mut ret = 1;
        for x in a.iter() {
            ret *= x;
            ret %= MOD;
            ret = (ret + MOD) % MOD;
        }
        println!("{}", ret);
        return;
    }
    if a.iter().all(|&x| x < 0) && k % 2 == 1 {
        let mut ret = 1i64;
        for x in a.iter().take(k) {
            ret *= x;
            ret %= MOD;
            ret = (ret + MOD) % MOD;
        }
        println!("{}", ret);
        return;
    }
    let mut ret = 1;
    let mut rest = k;
    while rest > 0 {
        if pos.len() >= 1
            && (rest == 1
                || neg.len() < 2
                || pos[pos.len() - 1] * *pos.get(pos.len() - 2).unwrap_or(&&1)
                    >= neg[neg.len() - 1] * neg[neg.len() - 2])
        {
            ret *= pos.pop().unwrap();
            ret %= MOD;
            rest -= 1;
        } else {
            ret *= neg.pop().unwrap();
            ret %= MOD;
            ret *= neg.pop().unwrap();
            ret %= MOD;
            rest -= 2;
        }
    }

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

const MOD: i64 = 1000000007;
const MMOD: i64 = MOD * MOD;
const INF: i64 = 1 << 55;