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: Runtime Error)

import java.io._
import java.util.StringTokenizer
import scala.util.control.Breaks.{breakable,break}
import scala.collection.mutable.{Map, Stack, Queue, PriorityQueue, Set}

object Main extends App {
  val in = new InputReader(System.in)
  val pw = new PrintWriter(System.out)

  val N, M = in.next().toInt
  val _A = Array.fill[Int](N+1)(Int.MaxValue)
  for (i <- 1 to N) {
    _A(i) = in.next().toInt
  }

  //
  val A = _A.sorted.reverse

  val accs = new Array[Long](N+1)
  accs(1) = A(1)
  for (i <- 2 to N)
    accs(i) = A(i) + A(i-1)

  // 条件を満たす最大の値を返す
  def bs(_min: Int, _max: Int, i: Int, m: Int): Int = {
    def check(t: Int): Boolean = {
      A(t) + A(i) >= m
    }

    def func(min: Int, max: Int): Int = {
      val mid: Int = (max + min) / 2;
      (max - min) match {
        case 0 | 1 =>
          check(max) match {
            case true  => max
            case false => min
          }
        case _ =>
          (check(mid)) match {
            case true  => func(mid, max)
            case false => func(min, mid)
          }
      }
    }

    func(_min, _max)
  }

  // 条件を満たす最大の値を返す
  def binarySearch(_min: Int, _max: Int): Int = {
    def check(m: Int): Boolean = {
      var res = 0
      for (i <- 1 to N) {
        val b = bs(0, N, i, m)
        res += b
      }
      res >= M
    }

    def func(min: Int, max: Int): Int = {
      val mid: Int = (max + min) / 2;
      (max - min) match {
        case 0 | 1 =>
          check(max) match {
            case true  => max
            case false => min
          }
        case _ =>
          (check(mid)) match {
            case true  => func(mid, max)
            case false => func(min, mid)
          }
      }
    }

    func(_min, _max)
  }

  val maxPair = binarySearch(1, 1e5.toInt * 2)
  var ans = 0L
  for (i <- 1 to N) {
    val ind = bs(0, N, i, maxPair)
    ans += accs(ind) + A(i) * ind
  }
  
  println(ans)
}

object Sub {
  def print2DimArray[A](mat: Array[Array[A]]): Unit = {
    mat.foreach(lin => println(lin.toList))
  }
}

class InputReader(stream: InputStream) {
  private[this] val reader = new BufferedReader(new InputStreamReader(stream))
  private[this] var tokenizer: StringTokenizer = new StringTokenizer(reader.readLine())
  def next(): String = {
    while (!tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(reader.readLine())
    }
    tokenizer.nextToken()
  }
}