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

type As [][]int

func (a As) Len() int {
	return len(a)
}

func (a As) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}

func (a As) Less(i, j int) bool {
	return a[i][1] > a[j][1]
}

const mod = int(1e9 + 7)

func main() {
	var n, k int
	fmt.Scan(&n, &k)
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	as := make(As, n)
	var spc, smc int
	for i := range as {
		sc.Scan()
		a, _ := strconv.Atoi(sc.Text())
		as[i] = []int{a, abs(a)}
		if a >= 0 {
			spc++
		} else {
			smc++
		}
	}
	mode := true
	pk := k
	if k%2 == 1 {
		if spc > 0 {
			spc--
			pk--
		} else {
			mode = false
		}
	}
	if mode && (smc-smc%2)+(spc-spc%2) < pk {
		mode = false
	}

	m := make(map[int]int)
	if mode {
		sort.Sort(as)

		pmin := int(1e9 + 1)
		mmin := int(1e9 + 1)
		var mc int
		for i := 0; i < k; i++ {
			m[as[i][0]]++
			if as[i][0] >= 0 {
				if as[i][1] < pmin {
					pmin = as[i][1]
				}
			} else {
				mc++
				if as[i][1] < mmin {
					mmin = as[i][1]
				}
			}
		}
		if mc%2 == 1 {
			pmax := -1
			mmax := -1
			for i := k; i < n; i++ {
				if as[i][0] >= 0 {
					if as[i][1] > pmax {
						pmax = as[i][1]
					}
				} else {
					if as[i][1] > mmax {
						mmax = as[i][1]
					}
				}
			}
			if pmin*pmax > mmin*mmax {
				if pmax > -1 && mmin < 1e9+1 {
					m[-mmin]--
					m[pmax]++
				}
			} else {
				if mmax > -1 && pmin < 1e9+1 {
					m[pmin]--
					m[-mmax]++
				}
			}
		}
	} else {
		sort.Sort(sort.Reverse(as))

		for i := 0; i < k; i++ {
			m[as[i][0]]++
		}
	}
	ans := 1
	for key, val := range m {
		for i := 0; i < val; i++ {
			ans *= key
			ans %= mod
			if ans < 0 {
				ans += mod
			}
		}
	}
	fmt.Println(ans)
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}