Problem:
Score : 500 points

Problem Statement

Takahashi has come to a party as a special guest.
There are N ordinary guests at the party. The i-th ordinary guest has a power of A_i.

Takahashi has decided to perform M handshakes to increase the happiness of the party (let the current happiness be 0).
A handshake will be performed as follows:

Takahashi chooses one (ordinary) guest x for his left hand and another guest y for his right hand (x and y can be the same).

Then, he shakes the left hand of Guest x and the right hand of Guest y simultaneously to increase the happiness by A_x+A_y.

However, Takahashi should not perform the same handshake more than once. Formally, the following condition must hold:

Assume that, in the k-th handshake, Takahashi shakes the left hand of Guest x_k and the right hand of Guest y_k. Then, there is no pair p, q (1 \leq p < q \leq M) such that (x_p,y_p)=(x_q,y_q).

What is the maximum possible happiness after M handshakes?

Constraints

1 \leq N \leq 10^5

1 \leq M \leq N^2

1 \leq A_i \leq 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M
A_1 A_2 ... A_N

Output

Print the maximum possible happiness after M handshakes.

Sample Input 1

5 3
10 14 19 34 33

Sample Output 1

202

Let us say that Takahashi performs the following handshakes:

In the first handshake, Takahashi shakes the left hand of Guest 4 and the right hand of Guest 4.

In the second handshake, Takahashi shakes the left hand of Guest 4 and the right hand of Guest 5.

In the third handshake, Takahashi shakes the left hand of Guest 5 and the right hand of Guest 4.

Then, we will have the happiness of (34+34)+(34+33)+(33+34)=202.

We cannot achieve the happiness of 203 or greater, so the answer is 202.

Sample Input 2

9 14
1 3 5 110 24 21 34 5 3

Sample Output 2

1837

Sample Input 3

9 73
67597 52981 5828 66249 75177 64141 40773 79105 16076

Sample Output 3

8128170

Solution in Go (1.6) (judge verdict: Accepted)

package main

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

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 500001), 500000)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func getNextInt64(scanner *bufio.Scanner) int64 {
	i, _ := strconv.ParseInt(getNextString(scanner), 10, 64)
	return i
}

func getNextUint64(scanner *bufio.Scanner) uint64 {
	i, _ := strconv.ParseUint(getNextString(scanner), 10, 64)
	return i
}

func getNextFloat64(scanner *bufio.Scanner) float64 {
	i, _ := strconv.ParseFloat(getNextString(scanner), 64)
	return i
}

func main() {
	fp := os.Stdin
	wfp := os.Stdout

	if os.Getenv("MASPY") == "ますピ" {
		fp, _ = os.Open(os.Getenv("BEET_THE_HARMONY_OF_PERFECT"))
	}
	if os.Getenv("MASPYPY") == "ますピッピ" {
		wfp, _ = os.Create(os.Getenv("NGTKANA_IS_GENIUS10"))
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(wfp)

	n := getNextInt(scanner)
	m := getNextInt64(scanner)

	aa := make(I64, n)
	ss := make([]int64, n+1)
	for i := 0; i < n; i++ {
		aa[i] = getNextInt64(scanner)
	}

	sort.Sort(aa)
	for i := 0; i < n; i++ {
		ss[i+1] = ss[i] + aa[i]
	}

	var ans int64
	l := int64(-1)
	r := aa[0]<<1 + 1

	for l+1 < r {
		mid := (l + r) >> 1
		c := m
		for i := 0; i < n; i++ {
			ll := i - 1
			rr := n
			for ll+1 < rr {
				mm := (ll + rr) >> 1
				if aa[mm]+aa[i] < mid {
					rr = mm
					continue
				}
				ll = mm
			}
			if rr-i == 0 {
				continue
			}
			c -= int64(rr-i-1)<<1 + 1
		}
		if c < 0 {
			l = mid
			continue
		}
		r = mid
	}

	c := m
	for i := 0; i < n; i++ {
		ll := i - 1
		rr := n
		for ll+1 < rr {
			mm := (ll + rr) >> 1
			if aa[mm]+aa[i] <= l {
				rr = mm
				continue
			}
			ll = mm
		}
		if rr-i == 0 {
			continue
		}
		ans += (int64(rr-i-1)<<1)*aa[i] + (ss[rr]-ss[i])<<1
		c -= int64(rr-i-1)<<1 + 1
	}
	ans += c * l

	fmt.Fprintln(writer, ans)
	writer.Flush()
}

type I64 []int64

func (a I64) Len() int           { return len(a) }
func (a I64) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a I64) Less(i, j int) bool { return a[i] > a[j] }