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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;

public class PriorityQueue<TKey, TValue>
{
    SortedDictionary<TKey, HashSet<TValue>> dict = new SortedDictionary<TKey, HashSet<TValue>>();
    Dictionary<TValue, TKey> rDict = new Dictionary<TValue, TKey>();
    int count = 0;

    public int Count
    {
        get
        {
            return count;
        }
    }

    public void Enqueue(TKey key, TValue value)
    {
        HashSet<TValue> set;
        if (!dict.TryGetValue(key, out set))
        {
            set = new HashSet<TValue>();
            dict[key] = set;
        }

        if (set.Add(value))
        {
            rDict[value] = key;
            count++;
        }
    }

    public KeyValuePair<TKey, TValue> Dequeue()
    {
        var queue = dict.First();
        if (queue.Value.Count <= 1)
        {
            dict.Remove(queue.Key);
        }

        var val = queue.Value.First();
        queue.Value.Remove(val);
        count--;
        rDict.Remove(val);
        return new KeyValuePair<TKey, TValue>(queue.Key, val);
    }

    public KeyValuePair<TKey, TValue> Peek()
    {
        var queue = dict.First();
        var val = queue.Value.First();
        return new KeyValuePair<TKey, TValue>(queue.Key, val);
    }

    public void ChangePriority(TKey newKey, TValue value)
    {
        ChangePriority(rDict[value], newKey, value);
    }

    public void ChangePriority(TKey prevKey, TKey newKey, TValue value)
    {
        var set = dict[prevKey];
        set.Remove(value);
        if (set.Count == 0)
        {
            dict.Remove(prevKey);
        }
        count--;

        Enqueue(newKey, value);
    }

    public bool ContainsValue(TValue val)
    {
        return rDict.ContainsKey(val);
    }
}

public class Solution
{
    static int Search(int ok, int ng)
    {
        while (Math.Abs(ok - ng) > 1)
        {
            var mid = (ok + ng) / 2;
            if (Check(mid))
            {
                ok = mid;
            }
            else
            {
                ng = mid;
            }
        }
        return ok;
    }

    static int[] Count;
    static int[] A;
    static long M;

    static bool Check(int x)
    {
        return A.Sum(a => (long)Count[Math.Max(x - a, 0)]) >= M;
    }

    public static void Main()
    {
        var vals = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        var N = (int)vals[0];
        M = vals[1];
        A = Console.ReadLine().Split(' ').Select(int.Parse).OrderByDescending(v => v).ToArray();

        var max = A.First() * 2 + 1;
        var cur = 0;
        var p = 0;
        Count = new int[max];
        for (int i = max - 1; i >= 0; i--)
        {
            while (p < N && A[p] == i)
            {
                cur++;
                p++;
            }
            Count[i] = cur;
        }

        var x = Search(1, max);
        var assigns = A.Select(a => Count[Math.Max(x - a, 0)]).ToArray();
        var ex = assigns.Sum(v => (long)v) - M;
        if (ex > 0)
        {
            var queue = new PriorityQueue<int,int>();
            for (int i = 0; i < N; i++)
            {
                var index = assigns[i]-1;
                if (index >= 0)
                {
                    queue.Enqueue(A[i] + A[index], i);
                }
            }
            while(ex > 0)
            {
                var kv = queue.Dequeue();
                var i = kv.Value;
                var index = assigns[i] - 1;
                assigns[i]--;
                if (index > 0)
                {
                    queue.Enqueue(A[i] + A[index-1], i);
                }
                ex--;
            }
        }

        long sum = 0;
        var SumAcc = new long[N + 1];
        for (int i = 0; i < N; i++)
        {
            sum += A[i];
            SumAcc[i+1] = sum;
        }

        var maxScore = Enumerable.Range(0, N).Sum(i => A[i] * assigns[i] + (long)SumAcc[assigns[i]]);
        Console.WriteLine(maxScore);
    }
}