Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

プログラミングコンテスト II

白虎大学では毎年プログラミングコンテストを開催しています。コンテストは全てのチームの得点が 0の状態から開始し、解答状況に応じて得点が加算されていきます。このコンテストでは、得点の高い順に順位付けが行われます。チームの総数を N としたとき、チームには 1 から N の番号がそれぞれ割り当てられています。得点が同じ場合は番号がより小さい方が上位になります。

白虎大学では、コンテストを盛り上げるために観戦用のランキングシステムを開発しています。開発チームの一員であるあなたは、このシステムの一部であるプログラムの作成を任されています。

与えられた命令に従って、得点の更新と、指定された順位のチームの番号と得点を報告するプログラムを作成せよ。

Input

入力は以下の形式で与えられる。

N C
command1
command2
:
commandC

１行目にチーム数 N (2 ≤ N ≤ 100000) と命令の数 C (1 ≤ C ≤ 100000)が与えられる。続く C 行に、１行ずつ命令が与えられる。各命令は以下の形式で与えられる。

0 t p

または

1 m

最初の数字が0のとき更新命令、1のとき報告命令を表す。更新命令では指定された番号 t (1 ≤ t ≤ N) のチームに、整数で与えられる得点 p (1 ≤ p ≤ 109) を加算する。報告命令では指定された順位 m (1 ≤ m ≤ N) のチームの番号と得点を報告する。ただし、報告命令は少なくとも１回現れるものとする。

Output

各報告命令に対して、指定された順位のチームの番号と得点を空白区切りで１行に出力する。

Sample Input 1

3 11
0 2 5
0 1 5
0 3 4
1 1
1 2
1 3
0 3 2
1 1
0 2 1
1 2
1 3

Sample Output 1

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

Sample Input 2

5 2
1 1
1 2

Sample Output 2

1 0
2 0

Solution in Scala (judge verdict: Accepted)

import scala.util.Random

object Main extends App {

  import scala.io.StdIn._
  import scala.math._

  val rand = new Random()
  val Array(n, c) = readLine.trim.split(' ').map(_.toInt)
  val team = Array.tabulate(n){id ⇒ Team(id + 1, 0L)}
  var treap = team.foldLeft(Leaf:Treap[Team]){case (treap, team) ⇒ treap.insert(team, rand.nextDouble())}
  for (_ ← 0 until c){
    val command = readLine.trim.split(' ').map(_.toInt)
    command match {
      case Array(0, t, p) ⇒
        val current = team(t - 1)
        treap = treap.erase(current)
        team(t - 1) = Team(t, current.score + p)
        treap = treap.insert(team(t - 1), rand.nextDouble())
      case Array(1, m) ⇒
        println(
          treap.findNth(m).get.let{t ⇒ s"${t.id} ${t.score}"}
        )
      case _ ⇒ ???
    }
  }
  case class Team(id: Int, score:Long) extends Ordered[Team] {
    override def compare(that: Team): Int = if (score == that.score) id.compare(that.id) else that.score.compare(score)
  }
  sealed trait Treap[+T] {
    def size: Int
    def findNth(rank: Int): Option[T]
    def insert[TT >: T <: Ordered[TT]](value: TT, priority: Double): Treap[TT]
    def erase[TT >: T <: Ordered[TT]](value: TT): Treap[T]
  }
  case class Node[T <: Ordered[T]](value: T, priority: Double, left: Treap[T], right: Treap[T]) extends Treap[T] {
    override val size: Int = left.size + right.size + 1

    override def findNth(rank: Int): Option[T] = {
      if (left.size >= rank) left.findNth(rank)
      else if (left.size + 1 == rank) Some(value)
      else right.findNth(rank - left.size - 1)
    }

    override def insert[TT >: T <: Ordered[TT]](value: TT, priority: Double): Treap[TT] = {
       value.compare(this.value) match {
        case 0 ⇒ throw new Error(s"$value is already exists")
        case 1 ⇒ right.insert(value, priority) match {
          case Node(v, p, l, r) if p > this.priority ⇒ Node(v, p, Node(this.value, this.priority, left, l), r)
          case r ⇒ Node(this.value, this.priority, left, r)
        }
        case _ ⇒ left.insert(value, priority) match {
          case Node(v, p, l, r) if p > this.priority ⇒ Node(v, p, l, Node(this.value, this.priority, r, right))
          case l ⇒ Node(this.value, this.priority, l, right)
        }
      }
    }

    override def erase[TT >: T <: Ordered[TT]](value: TT): Treap[T] = {
      value.compare(this.value) match {
        case 0 ⇒ (left, right) match {
          case (Node(lv, lp, ll, lr), r@Node(_, rp, _, _)) if lp > rp ⇒ Node(lv, lp, ll, Node(this.value, this.priority, lr, r).erase(value))
          case (l@Node(_, lp, _, _), Node(rv, rp, rl, rr)) if lp < rp ⇒ Node(rv, rp, Node(this.value, this.priority, l, rl).erase(value), rr)
          case (Leaf, r) ⇒ r
          case (l, Leaf) ⇒ l
        }
        case 1 ⇒ Node(this.value, this.priority, left, right.erase(value))
        case _ ⇒ Node(this.value, this.priority, left.erase(value), right)
      }
    }

    override def toString: String = (if (left.isInstanceOf[Node[_]]) left.toString + "," else "") + value.toString + (if (right.isInstanceOf[Node[_]]) "," + right.toString else "")
  }
  case object Leaf extends Treap[Nothing] {
    override val size: Int = 0
    override def findNth(rank: Int): Option[Nothing] = None
    override def insert[TT >: Nothing <: Ordered[TT]](value: TT, priority: Double): Treap[TT] = Node(value, priority, Leaf, Leaf)
    override def erase[TT >: Nothing <: Ordered[TT]](value: TT): Treap[Nothing] = Leaf
  }

  implicit class Extenion[T](val value :T){
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
    def let[R](func: T ⇒ R): R = func(value)
  }
}
/*


 */