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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            int N = sc.nextInt();
            int K = sc.nextInt();
            long[] A = new long[N];
            for (int i = 0; i < N; i++) {
                A[i] = sc.nextLong();
            }

            long mod = (long) (1e9 + 7);

            Arrays.sort(A);

            if (A[N - 1] < 0) {
                long m = 1L;
                for (int i = 0; i < K; i++) {
                    m *= A[N - 1 - i];
                    m %= mod;
                }
                System.out.println((m + mod) % mod);
                return;
            }

            ArrayList<P> Ps = new ArrayList<P>();

            for (int i = 0; i < N; i++) {
                if (i + 1 < N && A[i] < 0 && A[i + 1] < 0) {
                    Ps.add(new P(A[i], 1));
                    Ps.add(new P(A[i + 1], 1));
                    Ps.add(new P(A[i] * A[i + 1], 2));
                    i++;
                    continue;
                }
                Ps.add(new P(A[i], 1));
            }

            Collections.sort(Ps, new Comparator<P>() {
                @Override
                public int compare(P o1, P o2) {
                    if (o1.number == o2.number) {
                        if (o1.value > o2.value) {
                            return -1;
                        }
                        if (o1.value < o2.value) {
                            return 1;
                        }
                        return 0;
                    }

                    if (o1.number < o2.number) {
                        if (o1.value * o1.value > o2.value) {
                            return -1;
                        }
                        if (o1.value * o1.value < o2.value) {
                            return 1;
                        }
                        return 0;
                    }

                    if (o1.number > o2.number) {
                        if (o1.value > o2.value * o2.value) {
                            return -1;
                        }
                        if (o1.value < o2.value * o2.value) {
                            return 1;
                        }
                        return 0;
                    }

                    return 0;
                }
            });

            long m = 1L;
            int k = 0;
            for (int i = 0; i < Ps.size(); i++) {
                if (k + Ps.get(i).number <= K) {
                    m *= Ps.get(i).value % mod;
                    m %= mod;
                    k += Ps.get(i).number;
                }
            }

            System.out.println((m + mod) % mod);
        }
    }
}

class P {
    long value;
    int number;

    public P(long value, int number) {
        super();
        this.value = value;
        this.number = number;
    }
}