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 Kotlin (1.0.0) (judge verdict: Accepted)

import java.math.*

fun main(args: Array<String>) {
    val (N, M) = readInputLine().split(" ").map { it.toLong() }
    val AArr = readInputLine().split(" ").map { it.toLong() }.sortedDescending().toLongArray()
    val Amax = AArr[0]

    // パワーがi以上の人数
    // カウント人数配列のインデックスA_kの値を加算後、上から累積和を取ることで求められる
    val powCnt = LongArray(Amax.toInt() * 2 + 1)

    for (A in AArr) {
        powCnt[A.toInt()]++
    }

    for (i in Amax.toInt() - 1 downTo 0) {
        powCnt[i] += powCnt[i + 1]
    }

    // M以上の回数増やせる幸福度X最大値の二分探索
    // 左手のパワーを固定すれば、先に求めた配列からO(1)で求められ、左手がN人いるため1回あたりO(N)で求められる
    var l = 0L
    var r = Amax * 2L + 1L

    while (r - l > 1L) {
        val m = (l + r) / 2L
        val cnt = AArr.fold(0L) { acc, A -> acc + powCnt[Math.max(0L, m - A).toInt()] }
        if (cnt >= M) {
            l = m
        } else {
            r = m
        }
    }

    // 答えを求める
    // 幸福度Xを増やせるパターンがMより多い可能性があるため、X + 1増やせるパターンの個数を求め、M - その個数分だけ最後に足すことにする
    var already = 0L
    var ans = 0L

    // Aの降順累積和
    // 幸福度X + 1での総和を求める際、先のpowCntをインデックスとすれば各左手について総和が求められる
    // ただし、カウントは0を取る場合があるため、1から使用することにする
    val sumArr = LongArray(N.toInt() + 1)
    for (i in 0 until N.toInt()) {
        sumArr[i + 1] = sumArr[i] + AArr[i]
    }

    for (A in AArr) {
        val cnt = powCnt[Math.max(0L, r - A).toInt()]
        ans += A * cnt + sumArr[cnt.toInt()]
        already += cnt
    }

    ans += l * (M - already)

    println(ans)
}

fun readInputLine(): String {
    return readLine()!!
}