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"
)

func main() {
	N, K := ReadInt(), ReadInt()
	A := ReadInts(N)
	var plusCount, minusCount int
	for i := 0; i < N; i++ {
		if A[i] > 0 {
			plusCount++
		} else if A[i] < 0 {
			minusCount++
		}
	}
	if K == N || (plusCount == 0 && K%2 == 1) {
		sort.Slice(A, func(i, j int) bool {
			return Abs(A[i]) < Abs(A[j])
		})
		p := 1
		for i := 0; i < K; i++ {
			p = ModMul(p, A[i])
		}
		fmt.Println(p)
		return
	}
	sort.Slice(A, func(i, j int) bool {
		return Abs(A[i]) > Abs(A[j])
	})
	p := 1
	pSign := 1
	lastMinus := 0
	lastPlus := 0
	for i := 0; i < K; i++ {
		p = ModMul(p, A[i])
		if A[i] == 0 {
			fmt.Println(0)
			return
		}
		if A[i] < 0 {
			pSign *= -1
			lastMinus = A[i]
		} else {
			lastPlus = A[i]
		}
	}
	if pSign == 1 {
		fmt.Println(p)
		return
	}

	nextMinus := 0
	nextPlus := 0
	for i := N - 1; i >= K; i-- {
		if A[i] > 0 {
			nextPlus = A[i]
		} else {
			nextMinus = A[i]
		}
	}

	if nextMinus != 0 && Abs(nextPlus*lastPlus) < Abs(lastMinus*nextMinus) {
		p = ModDiv(p, lastPlus)
		p = ModMul(p, nextMinus)
	} else {
		p = ModDiv(p, lastMinus)
		p = ModMul(p, nextPlus)
	}
	fmt.Println(p)
}

const Mod = int(1e9) + 7

func ModMul(a, b int) int  { return (Mod + a%Mod) * (Mod + b%Mod) % Mod }
func ModInverse(n int) int { return ModPow(n, Mod-2) }
func ModDiv(a, b int) int  { return a * ModInverse(b) }
func ModPow(a, b int) (x int) {
	for x = 1; b > 0; b >>= 1 {
		if b&1 == 1 {
			x = x * a % Mod
		}
		a = a * a % Mod
	}
	return
}

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 ReadString() (s string) { Scan(&s); return }
func ReadInts(n int) []int {
	v := make([]int, n)
	for i := 0; i < n; i++ {
		Scan(&v[i])
	}
	return v
}