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 Haskell (GHC 7.10.3) (judge verdict: Time Limit Exceeded)

import qualified Data.Text as T
import qualified Data.Text.IO as T
import qualified Data.Text.Read as T
import Data.List (sortBy, unfoldr)
import qualified Data.Vector.Unboxed as V
import Data.Maybe (isNothing, fromJust)

main :: IO ()
main = do
  (n : m : _) <- map unsafeSignedDecimal . T.words <$> T.getLine :: IO [Int]
  as <- V.fromList . sortBy (flip compare) . map unsafeSignedDecimal . T.words <$> T.getLine :: IO (V.Vector Int)
  let
    hs = map f [0..(pred n)]
      where
        f :: Int -> PH Int
--        f l = foldl (flip insert) empty . map (\i -> as V.! i + as V.! (l - i)) $ [0..l]
        f l = foldl (flip insert) empty $ let y = as V.! l in ([0..(pred l)] >>= \i -> let x = as V.! i + y in [x, x]) ++ [2 * y]
--    bs = scanl step (2 * (as V.! 0), empty) $ hs
    bs = unfoldr view . foldl merge empty $ hs
      where
        step (x, h0) h = fromJust . view $ merge h0 h
--  print . sum . take m . map fst $ bs
  print . sum . take m $ bs

data PH' a = PH' a [PH' a]

newtype PH a = PH {unPH :: Maybe (PH' a)}

ph :: b -> (PH' a -> b) -> PH a -> b
ph d f = maybe d f . unPH

singleton' :: a -> PH' a
singleton' = flip PH' []

merge' :: Ord a => PH' a -> PH' a -> PH' a
merge' u@(PH' x us) v@(PH' y vs)
  | x < y
    = PH' y (u : vs)
  | otherwise
    = PH' x (v : us)

view' :: Ord a => PH' a -> (a, Maybe (PH' a))
view' (PH' x us) = (x, v)
  where
    v = case us of
      [] -> Nothing
      u : [] -> Just u
      u : u' : us' -> Just . (($) <$> maybe id merge' . snd <*> fst) . foldl step (merge' u u', Nothing) $ us'
      where
        step (v', Nothing) u = (v', Just u)
        step (v', Just u) u' = (merge' v' (merge' u u'), Nothing)

empty :: PH a
empty = PH Nothing

isEmpty :: PH a -> Bool
isEmpty = ph True (const False)

singleton :: a -> PH a
singleton = PH . Just . singleton'

insert :: Ord a => a -> PH a -> PH a
insert = merge . singleton

merge :: Ord a => PH a -> PH a -> PH a
merge = ph id (((PH . Just) .) . (ph <$> id <*> merge'))

view :: Ord a => PH a -> Maybe (a, PH a)
view = ph Nothing (Just . fmap PH . view')

unsafeSignedDecimal :: T.Text -> Int
unsafeSignedDecimal s = case T.signed T.decimal s of
  Right (n, _) -> n