Problem:
Problem B: The Last Ant

A straight tunnel without branches is crowded with busy ants coming and going. Some ants walk left to right and others right to left. All ants walk at a constant speed of 1 cm/s. When two ants meet, they try to pass each other. However, some sections of the tunnel are narrow and two ants cannot pass each other. When two ants meet at a narrow section, they turn around and start walking in the opposite directions. When an ant reaches either end of the tunnel, it leaves the tunnel.

The tunnel has an integer length in centimeters. Every narrow section of the tunnel is integer centimeters distant from the both ends. Except for these sections, the tunnel is wide enough for ants to pass each other. All ants start walking at distinct narrow sections. No ants will newly enter the tunnel. Consequently, all the ants in the tunnel will eventually leave it. Your task is to write a program that tells which is the last ant to leave the tunnel and when it will.

Figure B.1 shows the movements of the ants during the first two seconds in a tunnel 6 centimeters long. Initially, three ants, numbered 1, 2, and 3, start walking at narrow sections, 1, 2, and 5 centimeters distant from the left end, respectively. After 0.5 seconds, the ants 1 and 2 meet at a wide section, and they pass each other. Two seconds after the start, the ants 1 and 3 meet at a narrow section, and they turn around.

Figure B.1 corresponds to the first dataset of the sample input.

Figure B.1. Movements of ants

Input

The input consists of one or more datasets. Each dataset is formatted as follows.

n l
d1 p1
d2 p2
...
dn pn

The first line of a dataset contains two integers separated by a space. n (1 ≤ n ≤ 20) represents the number of ants, and l (n + 1 ≤ l ≤ 100) represents the length of the tunnel in centimeters. The following n lines describe the initial states of ants. Each of the lines has two items, di and pi, separated by a space. Ants are given numbers 1 through n. The ant numbered i has the initial direction di and the initial position pi. The initial direction di (1 ≤ i ≤ n) is L (to the
left) or R (to the right). The initial position pi (1 ≤ i ≤ n) is an integer specifying the distance from the left end of the tunnel in centimeters. Ants are listed in the left to right order, that is, 1 ≤ p1 < p2 < ... < pn ≤ l - 1.

The last dataset is followed by a line containing two zeros separated by a space.

Output

For each dataset, output how many seconds it will take before all the ants leave the tunnel, and which of the ants will be the last. The last ant is identified by its number. If two ants will leave at the same time, output the number indicating the ant that will leave through the left end of the tunnel.

Sample Input

3 6
R 1
L 2
L 5
1 10
R 1
2 10
R 5
L 7
2 10
R 3
L 8
2 99
R 1
L 98
4 10
L 1
R 2
L 8
R 9
6 10
R 2
R 3
L 4
R 6
L 7
L 8
0 0

Output for the Sample Input

5 1
9 1
7 1
8 2
98 2
8 2
8 3

Solution in Scala (judge verdict: Wrong Answer)

import scala.io.StdIn


object Main {
  def main(args: Array[String]): Unit = {
    while(true) {
      val num :: length :: _ = StdIn.readLine().split(" ").toList.map(_.toInt)
      if(num == 0) {
        return
      }

      l = length

      val ants = (1 to num) map { i =>
        val dir :: pos :: _ = StdIn.readLine().split(" ").toList
        (dir, pos.toInt)
      }
      println(solve(ants))
    }
  }
  var l: Int = 0

  def solve(ants: Seq[(String, Int)]): String = {
    val antsWithIndex = ants.zipWithIndex.map{ case ((di, po), id) => (di, po, id + 1) }
    val odds = antsWithIndex.filter(_._2 % 2 == 1)
    val evens = antsWithIndex.filter(_._2 % 2 == 0)

    val or = solve2(odds, 0)
    val er = solve2(evens, 0)

    if(or._1 > er._1) {
      s"${or._1} ${or._2}"
    } else {
      s"${er._1} ${er._2}"
    }
  }

  def solve2(ants: Seq[(String, Int, Int)], carry: Int):(Int, Int) = {
    if(ants.size == 0) { (-1, -1) }
    else if(ants.size == 1) {
      val a = ants.head
      val time = if(a._1 == "R") {
        l - a._2
      } else {
        a._2
      }
      (time + carry, a._3)
    } else if(ants.size == 2) {
      val a1 = ants(0)
      val a2 = ants(1)

      (a1._1, a2._1) match {
        case ("L", "L") =>
          (a2._2 + carry, a2._3)
        case ("R", "R") =>
          (l - a1._2 + carry, a1._3)
        case ("R", "L") =>
          val suc = (a2._2 - a1._2) / 2
          solve2( Seq(("L", a1._2 + suc, a1._3), ("R", a2._2 - suc, a2._3)), carry + suc)
        case _ =>
          (a1._2, l - a2._2) match {
            case (x1, x2) if x1 == x2 => (carry + x1, a1._3)
            case (x1, x2) if x1 < x2 => (carry + x2, a2._3)
            case (x1, x2) if x1 > x2 => (carry + x1, a1._3)
          }
      }
    }
    else if(ants.head._1 == "L") { solve2(ants.tail, carry) }
    else if (ants.last._1 == "R") { solve2(ants.init, carry) }
    else {
      val sl = ants.sliding(2)
      val coll = sl.flatMap{ s =>
        if(s(0)._1 == "R" && s(1)._1 == "L") {
          Some((s(1)._2 - s(0)._2) / 2)
        } else None
      }.min

      val suc = ants.flatMap{ case (di, po, in) =>
        val newpo = if(di == "R") { po + coll } else { po - coll }
        if(1 <= newpo && newpo <= l - 1) {
          Some((di, newpo, in))
        } else None
      }

      val flip = suc.map(_._2).groupBy(a => a).toList.filter(_._2.size > 1).map(_._1).toSet

      val next = suc.map {
        case x@(di, po, in) =>
          if(flip(po)) {
            val newdi = if(di == "R") "L" else "R"
            (newdi, po, in)
          } else x
      }

      solve2(next, carry + coll)
    }
  }
}