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 Rust (1.42.0) (judge verdict: Accepted)

fn main() {
	let mut s = String::new();
	use std::io::Read;
	std::io::stdin().read_to_string(&mut s).unwrap();
	let mut s = s.split_whitespace();
	let n: usize = s.next().unwrap().parse().unwrap();
	let mut m: i64 = s.next().unwrap().parse().unwrap();
	let mut a = vec![0; 100001];
	for b in s.take(n).map(|a| a.parse::<usize>().unwrap()) {
		a[b] += 1;
	}
	let c = karatsuba(&a, &a);
	let mut ans = 0i64;
	for i in (0..c.len()).rev() {
		let cnt = std::cmp::min(c[i], m);
		ans += i as i64 * cnt;
		m -= cnt;
		if m == 0 {
			break;
		}
	}
	println!("{}", ans);
}

use crate::traits::consts::{Bool, False, True};
use std::ops::{Add, Mul, Sub};

pub fn karatsuba<T>(a: &[T], b: &[T]) -> Vec<T>
where
	T: Clone + num::Zero + Sub<Output = T> + Mul<Output = T> + std::fmt::Debug,
	for<'a> &'a T: Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Add<T, Output = T>,
{
	fn internal<T, Overwrite: Bool>(a: &[T], b: &[T], r: &mut [T], scratch: &mut [T]) -> usize
	where
		T: Clone + num::Zero + Sub<Output = T> + Mul<Output = T> + std::fmt::Debug,
		for<'a> &'a T: Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Add<T, Output = T>,
	{
		let (a, b) = if a.len() <= b.len() { (a, b) } else { (b, a) };
		if a.len() == 0 {
			return 0;
		}
		if b.len() < 24 {
			if Overwrite::VALUE {
				for r in r.iter_mut() {
					*r = T::zero();
				}
			}
			for i in 0..a.len() {
				for j in 0..b.len() {
					unsafe {
						*r.get_unchecked_mut(i + j) =
							r.get_unchecked(i + j) + a.get_unchecked(i) * b.get_unchecked(j);
					}
				}
			}
			a.len() + b.len() - 1
		} else {
			let k = (b.len() + 1) / 2;

			let (sc1, sc2) = scratch.split_at_mut(2 * k);
			let ac = internal::<T, True>(&a[0..std::cmp::min(k, a.len())], &b[0..k], sc1, sc2);
			if Overwrite::VALUE {
				unsafe {
					let l = std::cmp::min(ac, k);
					for i in 0..l {
						*r.get_unchecked_mut(i) = sc1.get_unchecked(i).clone();
						*r.get_unchecked_mut(i + k) = T::zero() - sc1.get_unchecked(i).clone();
					}
					if l == k {
						for i in k..ac {
							*r.get_unchecked_mut(i) = r.get_unchecked(i) + sc1.get_unchecked(i);
							*r.get_unchecked_mut(i + k) = T::zero() - sc1.get_unchecked(i).clone();
						}
					} else {
						for r in r[ac..k].iter_mut() {
							*r = T::zero();
						}
					}
					for r in r[k + ac..3 * k].iter_mut() {
						*r = T::zero();
					}
				}
				let bc = internal::<T, True>(&a[std::cmp::min(k, a.len())..], &b[k..], sc1, sc2);
				unsafe {
					let l = std::cmp::min(bc, k);
					for i in 0..l {
						*r.get_unchecked_mut(i + 2 * k) =
							r.get_unchecked(i + 2 * k) + sc1.get_unchecked(i);
						*r.get_unchecked_mut(i + k) = r.get_unchecked(i + k) - sc1.get_unchecked(i);
					}
					if l == k {
						for i in k..bc {
							*r.get_unchecked_mut(i + 2 * k) = sc1.get_unchecked(i).clone();
							*r.get_unchecked_mut(i + k) =
								r.get_unchecked(i + k) - sc1.get_unchecked(i);
						}
					}
				}
			} else {
				for i in 0..ac {
					unsafe {
						*r.get_unchecked_mut(i) = r.get_unchecked(i) + sc1.get_unchecked(i);
						*r.get_unchecked_mut(i + k) = r.get_unchecked(i + k) - sc1.get_unchecked(i);
					}
				}
				let bc = internal::<T, True>(&a[std::cmp::min(k, a.len())..], &b[k..], sc1, sc2);
				for i in 0..bc {
					unsafe {
						*r.get_unchecked_mut(i + 2 * k) =
							r.get_unchecked(i + 2 * k) + sc1.get_unchecked(i);
						*r.get_unchecked_mut(i + k) = r.get_unchecked(i + k) - sc1.get_unchecked(i);
					}
				}
			}

			unsafe {
				let l = b.len() - k;
				for i in 0..l {
					*scratch.get_unchecked_mut(i) = b.get_unchecked(i) + b.get_unchecked(i + k);
				}
				for (sc, e) in scratch[l..k].iter_mut().zip(b[l..k].iter()) {
					*sc = e.clone();
				}
			}

			if a.len() < k {
				let (src, sc) = scratch.split_at_mut(k);
				internal::<T, False>(a, src, &mut r[k..3 * k], sc);
			} else {
				unsafe {
					let l = a.len() - k;
					for i in 0..l {
						*scratch.get_unchecked_mut(i + k) =
							a.get_unchecked(i) + a.get_unchecked(i + k);
					}
					for (sc, e) in scratch[k + l..2 * k].iter_mut().zip(a[l..k].iter()) {
						*sc = e.clone();
					}
				}

				let (src, sc) = scratch.split_at_mut(2 * k);
				internal::<T, False>(&src[k..], &src[..k], &mut r[k..3 * k], sc);
			}

			a.len() + b.len() - 1
		}
	}
	if a.len() == 0 || b.len() == 0 {
		return Vec::new();
	}
	let n = std::cmp::max(a.len(), b.len()) + std::mem::size_of::<usize>() * 8;
	let mut v = vec![T::zero(); n * 4];
	let (r, scratch) = v.split_at_mut(2 * n);
	internal::<T, False>(a, b, r, scratch);
	v.truncate(a.len() + b.len() - 1);
	v
}

pub mod traits {
	pub mod consts {

		pub trait LiteralConstant {
			type Type;
			const VALUE: Self::Type;
		}

		macro_rules! impl_const {
			($trait:ident ,$struct:ident, $type:ty, $value:expr) => {
				pub struct $struct;
				impl $trait for $struct {}
				impl LiteralConstant for $struct {
					type Type = $type;
					const VALUE: $type = $value;
				}
			};
		}

		pub trait Bool: LiteralConstant<Type = bool> {}
		impl_const![Bool, True, bool, true];
		impl_const![Bool, False, bool, false];
	}
}