Problem:
Score : 400 points

Problem Statement

There are N pieces of sushi. Each piece has two parameters: "kind of topping" t_i and "deliciousness" d_i.
You are choosing K among these N pieces to eat.
Your "satisfaction" here will be calculated as follows:

The satisfaction is the sum of the "base total deliciousness" and the "variety bonus".

The base total deliciousness is the sum of the deliciousness of the pieces you eat.

The variety bonus is x*x, where x is the number of different kinds of toppings of the pieces you eat.

You want to have as much satisfaction as possible.
Find this maximum satisfaction.

Constraints

1 \leq K \leq N \leq 10^5

1 \leq t_i \leq N

1 \leq d_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
t_1 d_1
t_2 d_2
.
.
.
t_N d_N

Output

Print the maximum satisfaction that you can obtain.

Sample Input 1

5 3
1 9
1 7
2 6
2 5
3 1

Sample Output 1

26

If you eat Sushi 1,2 and 3:

The base total deliciousness is 9+7+6=22.

The variety bonus is 2*2=4.

Thus, your satisfaction will be 26, which is optimal.

Sample Input 2

7 4
1 1
2 1
3 1
4 6
4 5
4 5
4 5

Sample Output 2

25

It is optimal to eat Sushi 1,2,3 and 4.

Sample Input 3

6 5
5 1000000000
2 990000000
3 980000000
6 970000000
6 960000000
4 950000000

Sample Output 3

4900000016

Note that the output may not fit into a 32-bit integer type.

Solution in Scala (2.11.7) (judge verdict: Accepted)

object Main {
  def main(args: Array[String]): Unit = {
    val s = new Main()
    s.solve()
    s.out.flush()
  }
}

class Main {
  import java.io._
  import java.util.StringTokenizer
  import java.util.Arrays.sort

  import scala.collection.mutable
  import scala.util.Sorting
  import math.{abs, max, min}
  import mutable.{ArrayBuffer, ListBuffer}
  import scala.reflect.ClassTag

  val MOD = 1000000007
  val out = new PrintWriter(System.out)

  def solve(): Unit = {
    import java.util.Comparator
    val N, K = ni()
    case class Sushi(t: Int, d: Int)
    val A = Array.ofDim[Sushi](N)
    REP(N) { i =>
      A(i) = Sushi(ni() - 1, ni())
    }

    // 美味しい順
    sort(A, new Comparator[Sushi] {
      override def compare(o1: Sushi, o2: Sushi): Int = {
        if (o1.d == o2.d) Integer.compare(o1.t, o2.t)
        else Integer.compare(o2.d, o1.d)
      }
    })

    val used = Array.ofDim[Boolean](N)

    // ScalaのStackが糞すぎる
    val tops = new Stack[Sushi](N)
    val remains = mutable.Queue[Sushi]()
    REP(N) { i =>
      if (!used(A(i).t) && tops.length < K) {
        used(A(i).t) = true
        tops += A(i)
      } else {
        remains += A(i)
      }
    }

    debug(tops.mkString(","))
    debug(remains.mkString(","))

    var sum = 0L
    var x = tops.length.toLong
    REP(tops.length) { i =>
      sum += tops(i).d
    }
    REP(K - tops.length) { i =>
      sum += remains.dequeue().d
    }

    sum += x * x
    var ans = sum

    while(tops.nonEmpty && remains.nonEmpty) {
      val rem = tops.pop()
      val add = remains.dequeue()
      // 同じ種類のものがより美味しいってことはありえないので種類チェックの必要がない
      if (add.d < rem.d) {
        out.println(ans)
        return
      }
      sum -= rem.d + x * x
      x -= 1
      sum += add.d + x * x

      debug(s"x:$x sum:$sum")

      ans = max(ans, sum)
    }

    out.println(ans)
  }

  class Stack[A: ClassTag](n: Int) {
    private val as = Array.ofDim[A](n)
    var p = 0

    def +=(a: A): Unit = {
      as(p) = a
      p += 1
    }

    def pop(): A = {
      p -= 1
      as(p)
    }

    def peek: A = as(p - 1)

    def apply(i: Int): A = as(i)

    def length: Int = p
    def isEmpty: Boolean = length == 0
    def nonEmpty: Boolean = !isEmpty

    def mkString(delimiter: String = ""): String = as.take(p).mkString(delimiter)
  }

  class Queue[A: ClassTag](n: Int) {
    private val as = Array.ofDim[A](n)
    var p = 0

    def +=(a: A): Unit = {
      as(p) = a
      p += 1
    }

    def pop(): A = {
      p -= 1
      as(p)
    }

    def peek: A = as(p - 1)

    def apply(i: Int): A = as(i)

    def length: Int = p
    def isEmpty: Boolean = length == 0
    def nonEmpty: Boolean = !isEmpty

    def mkString(delimiter: String = ""): String = as.take(p).mkString(delimiter)
  }

  private val oj = System.getenv("ATCODER_DEBUG") == null

  def DEBUG(f: => Unit): Unit = {
    if (!oj){ f }
  }

  def debug(as: Array[Boolean]): Unit = DEBUG {
    debug(as.map(x => if(x) "1" else "0").mkString)
  }

  def debug(as: Array[Int]): Unit = DEBUG {
    debug(as.mkString(" "))
  }

  def debug(as: Array[Long]): Unit = DEBUG {
    debug(as.mkString(" "))
  }

  def debug(s: => String): Unit = DEBUG {
    System.err.println(s)
  }

  def debugL(num: => Long): Unit = DEBUG {
    System.err.println(num)
  }

  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = _

    def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next().toInt
    def nextLong(): Long = next().toLong
    def nextChar(): Char = next().charAt(0)
  }
  val sc = new InputReader(System.in)
  def ni(): Int = sc.nextInt()
  def nl(): Long = sc.nextLong()
  def nc(): Char = sc.nextChar()
  def ns(): String = sc.next()
  def ns(n: Int): Array[Char] = ns().toCharArray
  def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)
  def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
    val A1, A2 = Array.ofDim[Int](n)
    REP(n) { i =>
      A1(i) = ni() + offset
      A2(i) = ni() + offset
    }
    (A1, A2)
  }
  def nm(n: Int, m: Int): Array[Array[Int]] = {
    val A = Array.ofDim[Int](n, m)
    REP(n) { i =>
      REP(m) { j =>
        A(i)(j) = ni()
      }
    }
    A
  }
  def nal(n: Int): Array[Long] = map(n)(_ => nl())
  def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n) (_ => ns(m))
  def REP(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while(i < N) { f(i); i += 1 }
  }
  def REP_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while(i >= offset) { f(i); i -= 1 }
  }
  def TO(from: Int, to: Int)(f: Int => Unit): Unit = {
    REP(to - from + 1, from) { i =>
      f(i)
    }
  }

  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    REP(n)(i => res(i) = f(i + offset))
    res
  }


  def sumL(as: Array[Int]): Long = {
    var s = 0L
    REP(as.length)(i => s += as(i))
    s
  }

  def cumSum(as: Array[Long]) = {
    val cum = Array.ofDim[Long](as.length + 1)
    REP(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}