Problem:
大きさが異なる n 個のコップと 3 つのトレイ（お盆）A，B，C があり，それらのコップは 3 つのトレイの上にそれぞれ何個かずつ一山に重ねて置かれている．ただし，どのトレイにおいても，そのトレイの中で一番小さいコップが一番下に， 2 番目に小さいコップがその上に， 3 番目に小さいコップがその上にと，小さい順に伏せて重ねてある．例えば，下図の右側は， n = 5 個のコップがトレイ A，B，C にそれぞれ 2 個，0 個，3 個重ねて置かれている状態を示している．

このように，コップの初期状態が与えられたとき，次の規則 1 〜 3 を守りながら，すべてのコップを A または C のどちらかのトレイに移動させるには何回移動を行えばよいかを求めたい．

（規則 1） 1 回に 1 つのコップだけを移動させることができる．それは，そのトレイにあるコップの中で一番上のコップ（つまり，一番大きいコップ）である．

（規則 2）大きいコップの上に小さいコップを重ねてはいけない．

（規則 3）コップ 1 個の直接移動は，トレイ A から B，B から A，B から C，C から B のみが許され， A から C への直接移動や C から A への直接移動は許されない．

　n 個のコップの初期状態と整数 m が与えられたとき， m 回以内の移動で， A または C のどちらかのトレイにすべてのコップをまとめて重ねることができるかどうかを判定し，可能な場合には移動回数の最小値を，不可能な場合には -1 を出力するプログラムを作成しなさい．

　入力ファイルの 1 行目には， n と m がこの順に空白を区切り文字として書いてある． 1 ≦ n ≦ 15 であり， 1 ≦ m ≦ 15000000 である． 2 行目，3 行目，4 行目には， 1 から n までの整数を何個かずつ 3 つのグループに分けて，それぞれのグループ内で小さい順（昇順）に並べたものが書いてある．ただし，各行の先頭（それらの整数の前）には，それらの個数が書いてある． 2 行目に書かれている整数（先頭の 1 つを除く）はトレイ A の上に重ねられている各コップの大きさを表す．同様に， 3 行目に書かれている整数（先頭の 1 つを除く）はトレイ B の上に重ねられている各コップの大きさを表し， 4 行目に書かれている整数（先頭の１つを除く）はトレイ C の上に重ねられている各コップの大きさを表す．

入力例１

入力例２

入力例３

入力例４

3 10

4 20

2 5

3 3

0

2 1 2

2 1 2

0

1 1

1 3

0

1 1

2 2 3

1 4

0

2 2 3

　

出力例１

出力例２

出力例３

出力例４

9

3

0

-1

入力

入力は複数のデータセットからなる．n, m がともに 0 のとき入力が終了する．データセットの数は 5 を超えない．

出力

データセットごとに、移動回数または -1 を１行に出力する．

入力例

3 10
0
1 1
2 2 3
4 20
2 1 2
1 3
1 4
2 5
2 1 2
0
0
3 3
0
1 1
2 2 3
0 0

出力例

9
3
0
-1

各データセットの出力（移動回数または -1）の後に改行を入れること．

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in Scala (judge verdict: Accepted)

import scala.collection.mutable
import util.control.Breaks._

object Main extends App {
  case class State(a: Int, b: Int, c: Int)
  val cache = mutable.HashMap.empty[Int, Int]
  val stateCache = mutable.HashMap.empty[State, Boolean]
  def head (b: Int, n: Int): Int = cache.getOrElseUpdate(b, {
    var h = 1 << n-1
    breakable {
      while (h > 0) {
        if ((h & b) == h) break()
        h = h >> 1
      }
    }
    h
  })
  def readLine: Array[Int] = io.StdIn.readLine().split(' ').map(_.toInt)
  def solver(n: Int, m: Int): Unit = {
    val Array(_, as @ _*) = readLine
    val Array(_, bs @ _*) = readLine
    val Array(_, cs @ _*) = readLine
    val queue = mutable.Queue.empty[(State, Int)]
    val state: Array[Int] = for (x <- Array(as,bs,cs)) yield x.foldLeft(0)((acc, i) => acc | (1 << i - 1))
    queue.enqueue((State(state(0), state(1), state(2)), 0))
    var count = -1
    val goal = (1 << n) - 1
    def enq(ns: State, nc: Int): Unit =
      if (!stateCache.getOrElseUpdate(ns, false)) {queue.enqueue((ns, nc)); stateCache += (ns -> true)}

    breakable {
      while (queue.nonEmpty) {
        val (s, c) = queue.dequeue()

        if (c > m) break()
        if (s.a == goal || s.c == goal) {count = c; break()}

        val (h0, h1, h2) = (head(s.a, n), head(s.b, n), head(s.c, n))

        if (h0 > h1) enq(State(s.a ^ h0, h0 | s.b, s.c),c+1)
        else if (h1 > h0) enq(State(h1 | s.a, s.b ^ h1, s.c), c+1)
        if (h1 > h2) enq(State(s.a, s.b ^ h1, h1 | s.c), c+1)
        else if (h2 > h1) enq(State(s.a, h2 | s.b, s.c ^ h2), c+1)
      }
    }
    println(count)
  }
  breakable(
    while(true) {
      val Array(n, m) = readLine
      if (n == 0 || m == 0) break()
      else solver(n, m)
    }
  )
}