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 Java (OpenJDK 11.0.6) (judge verdict: Wrong Answer)

import java.io.*;
import java.util.*;
import java.util.function.*;

final class Solver {
	void solve(Supplier<String> sc) {
		int N = Integer.parseInt(sc.get());
		int K = Integer.parseInt(sc.get());
		int[] A = new int[N];
		Arrays.setAll(A, $ -> Integer.parseInt(sc.get()));
		Arrays.sort(A);

		int minus = 0;
		int plus = 0;
		for (int value : A) {
			if (value > 0) {
				plus += 1;
			} else if (value < 0) {
				minus += 1;
			}
		}

		if (plus == 0 && K % 2 != 0) {
			Integer[] abs = new Integer[N];
			Arrays.setAll(abs, i -> A[i]);
			Arrays.sort(abs, Comparator.comparingInt(Math::abs));

			int heaven = 1;
			for (int i = 0; i < K; i++) {
				heaven = mul(heaven, abs[i]);
			}
			System.out.println(heaven);
			return;
		}


		int result = 1;
		int count = 0;
		int r = A.length - 1;
		minpul:for (int l = 0; l < A.length - 1; l += 2) {
			if (count >= K - 1) break;

			int minus1 = A[l];
			int minus2 = A[l + 1];

			long mulmin = (long) minus1 * minus2;
			while (true) {
				if (r <= l || r - 1 <= l + 1) break minpul;

				if (count >= K - 1) break minpul;

				int plus1 = A[r];
				int plus2 = A[r - 1];

				long mulpul = (long) plus1 * plus2;
				if (mulmin < mulpul){
					result = mul(result, mod(mulpul));
					count += 2;
					r -= 2;
				} else {
					break;
				}
			}

			result = mul(result, mod(mulmin));
			count += 2;
		}

		for (int i = r; i >= 0; i--) {
			if (count >= K) break;

			result = mul(result, A[i]);
			count += 1;
		}

		System.out.println(result);
	}

	static final int MOD = 1000000007;

	int mod(long val) {
		return Math.floorMod(val, MOD);
	}

	int add(long a, long b) {
		return mod(a + b);
	}

	int sub(long a, long b) {
		return add(a, -b);
	}

	int mul(long a, long b) {
		return mod(a * b);
	}

	int pow(long a, long n) {
		int res = 1;
		for (; n > 0; n /= 2) {
			if (n % 2 == 1) res = mul(res, a);
			a = mul(a, a);
		}
		return res;
	}
}

class Main {
	public static void main(String... args) {
		System.setOut(new PrintStream(new BufferedOutputStream(System.out)));
		var reader = new BufferedReader(new InputStreamReader(System.in));
		new Solver().solve(new Supplier<>() {
			StringTokenizer line;

			public String get() {
				while (line == null || !line.hasMoreTokens()) try {
					line = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new UncheckedIOException(e);
				}
				return line.nextToken();
			}
		});
		System.out.flush();
	}
}