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 Go (1.14.1) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

const Mod = 1e9 + 7

func main() {
	N, K := ReadInt(), ReadInt()
	A := ReadInts(N)
	var plusNums, minusNums []int
	for i := 0; i < N; i++ {
		if A[i] >= 0 {
			plusNums = append(plusNums, A[i])
		} else {
			minusNums = append(minusNums, A[i])
		}
	}

	canMakePlus := false
	if N == K {
		canMakePlus = len(minusNums)%2 == 0
	} else {
		if len(plusNums) > 0 {
			canMakePlus = true
		} else {
			if K%2 == 0 {
				canMakePlus = true
			}
		}
	}

	if !canMakePlus {
		sort.Slice(A, func(i, j int) bool {
			return Abs(A[i]) < Abs(A[j])
		})
		ans := 1
		for i := 0; i < K; i++ {
			ans = (Mod + (ans * A[i])) % Mod
		}
		fmt.Println(ans)
		return
	}

	sort.Sort(sort.Reverse(sort.IntSlice(plusNums)))
	sort.Ints(minusNums)
	ans := 1
	if K%2 == 1 {
		ans *= plusNums[0]
		plusNums = plusNums[1:]
	}
	pairedNums := []int{}
	for len(plusNums) >= 2 {
		pairedNums = append(pairedNums, plusNums[0]*plusNums[1]%Mod)
		plusNums = plusNums[2:]
	}
	for len(minusNums) >= 2 {
		pairedNums = append(pairedNums, minusNums[0]*minusNums[1]%Mod)
		minusNums = minusNums[2:]
	}
	sort.Sort(sort.Reverse(sort.IntSlice(pairedNums)))
	for i := 0; i < K/2; i++ {
		ans = ans * pairedNums[i] % Mod
	}
	fmt.Println(ans)
}

func Abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

var reader = bufio.NewReader(os.Stdin)

func Scan(a ...interface{}) {
	if _, err := fmt.Fscan(reader, a...); err != nil {
		panic(err)
	}
}
func ReadInt() (i int) { Scan(&i); return }
func ReadInts(n int) []int {
	v := make([]int, n)
	for i := 0; i < n; i++ {
		Scan(&v[i])
	}
	return v
}