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 Scala (2.11.7) (judge verdict: Wrong Answer)

object Main {
  def main(args: Array[String]): Unit = {
    val sc = new java.util.Scanner(System.in)

    val n = sc.nextInt()
    val m = sc.nextLong()
    val a = Array.fill(n)(sc.nextLong()).sorted(Ordering.Long.reverse)

    val qe = new QE(n, m, a)

    println(qe.ans)
  }
}

class QE(n: Int, m: Long, a: Array[Long]) {
  private val r = Array.fill(n)(0L)
  r(0) = a(0)
  for (i <- 1 until n) {
    r(i) = r(i - 1) + a(i)
  }
  private val vi = a.zipWithIndex.foldLeft(Map.empty[Long, Int])((acc, cur) =>
    acc + (cur._1 -> cur._2)
  )


  def findIndex(v: Long): Int = {
    def findIndex(left: Int, right: Int, v: Long): Int = {
      if (right - left > 1) {
        val mid = left + (right - left) / 2
        if (a(mid) >= v) {
          findIndex(mid, right, v)
        } else {
          findIndex(left, mid, v)
        }
      } else {
        if (a(right) >= v) {
          vi(a(right))
        } else if (a(left) < v) {
          vi(a(left)) - 1
        } else {
          vi(a(left))
        }
      }
    }

    findIndex(0, n - 1, v)
  }

  def findVal(): Long = {
    def findVal(left: Long, right: Long): Long = {
      if (right - left > 1) {
        val mid = left + (right - left) / 2

        var count = 0
        a.foreach { i =>
          findIndex(mid - i) match {
            case v if v >= 0 => {
              count = count + v + 1
            }
            case _ => {}
          }
        }
        if (count >= m) {
          findVal(mid, right)
        } else {
          findVal(left, mid)
        }
      } else left
    }

    findVal(0, Math.pow(10, 5).toInt * 2 + 1)
  }

  def search(): Long = findVal()

  def ans: Long = {
    val x = search()

    val ret = a.foldLeft((0L, 0L))((acc, cur) => {
      findIndex(x - cur) match {
        case i if i >= 0 => (acc._1 + r(i) + cur * (i + 1), acc._2 + i + 1)
        case _ => acc
      }
    })
    ret._1 + (m - ret._2) * x
  }
}