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 proconio::{input, fastout};

const MOD: isize = 1_000_000_007;

#[fastout]
fn main() {
    input! {
        n: usize,
        k: usize,
        aa: [isize; n],
    }


    let mut sorted = vec![];

    for a in aa {
        match a {
            a if a > 0 => {
                sorted.push((a, 1));
            },
            a if a < 0 => {
                sorted.push((-a, -1));
            }
            a => {
                sorted.push((a, 0));
            },
        }
    }

    sorted.sort();

    let mut plus_count = 0;
    let mut minus_count = 0;
    let mut zero_count = 0;
    for &(_, sign) in sorted.iter() {
        match sign {
            1 => {
                plus_count += 1;
            },
            -1 => {
                minus_count += 1;
            },
            0 => {
                zero_count += 1;
            },
            _ => {},
        }
    }


    let even_minus_count = 
        if minus_count % 2 == 1 {
            minus_count - 1
        } else {
            minus_count
        };

    if plus_count + even_minus_count < k && zero_count > 0{
        println!("0");
        return;
    }

    if plus_count + even_minus_count >= k  && k % 2 == 0{
        sorted.reverse();
        let mut ans = 1;

        let mut count = 0;
    
        for &(x, sign) in sorted.iter() {
            if count == k {
                break;
            }
            if sign == -1 {
                if minus_count > 0 {
                    ans *= x;
                    ans %= MOD;
                    minus_count -= 1;
                    count += 1;
                }
            } else {
                ans *= x;
                ans %= MOD;
                count += 1;
            }
        }
        println!("{}", ans);
        return;
    }

    let mut ans = 1;
    for &(x, sign) in sorted.iter().take(k) {
        ans *= x;
        ans %= MOD;
    }

    ans = MOD - ans;
    println!("{}", ans);
}