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

use std::fmt;
use std::io::stdin;
use std::io::BufRead;
use std::str;
use std::str::FromStr;
use std::vec::Vec;
use std::collections::{VecDeque, HashSet};

fn main() {
    let stdin = stdin();
    let mut scan = InputScanner::new(stdin.lock(),256);

    let mut answer:Vec<i64> = Vec::new();

    loop {
        let n:usize = scan.next();
        let m:usize = scan.next();

        if n == 0 || m == 0 {
            break;
        }

        let abc = {
            let mut abc = Vec::new();

            for _ in 0..3 {
                let n: usize = scan.next();
                abc.push((0..n).map(|_| scan.next::<usize>()).collect::<Vec<usize>>());
            }
            abc
        };

        let mut queue = VecDeque::new();
        let mut s:HashSet<(u16,u16,u16)> = HashSet::new();

        let (ha,hb,hc) = calc_hash(&abc[0],&abc[1],&abc[2]);

        queue.push_back((ha,hb,hc));
        s.insert((ha,hb,hc));

        let mut count = 0;
        let mut found = false;

        'search: while queue.len() > 0 && count <= m {
            let mut current = queue.drain(0..).collect::<VecDeque<_>>();

            while let Some((ha,hb,hc)) = current.pop_front() {
                let abc = abc_from_hash(ha,hb,hc);

                if abc[0].len() == n || abc[2].len() == n {
                    found = true;
                    break 'search;
                }

                for &(i,d) in &[(0,1),(1,-1),(1,1),(2,-1)] {
                    let i = i as i64;

                    if abc[i as usize].len() > 0 {
                        let top = abc[i as usize][abc[i as usize].len()-1];

                        if abc[(i+d) as usize].len() == 0 || abc[(i+d) as usize][abc[(i+d) as usize].len()-1] < top {
                            let mut abc = abc.iter().map(|c| c.clone()).collect::<Vec<Vec<usize>>>();

                            abc[i as usize].pop();
                            abc[(i+d) as usize].push(top);

                            let h = calc_hash(&abc[0],&abc[1],&abc[2]);
                            if !s.contains(&h) {
                                s.insert(h);
                                queue.push_back(h);
                            }
                        }
                    }
                }
            }
            count += 1;
        }

        if found {
            answer.push(count as i64);
        } else {
            answer.push(-1);
        }
    }

    println!("{}",answer.into_iter().map(|a| format!("{}",a)).collect::<Vec<String>>().join("\n"));
}
fn calc_hash(a:&Vec<usize>,b:&Vec<usize>,c:&Vec<usize>) -> (u16,u16,u16) {
    let mut ha:u16 = 0;
    let mut hb:u16 = 0;
    let mut hc:u16 = 0;

    for n in a {
        ha |= 1 << *n;
    }

    for n in b {
        hb |= 1 << *n;
    }

    for n in c {
        hc |= 1 << *n;
    }

    (ha,hb,hc)
}
fn abc_from_hash(ha:u16,hb:u16,hc:u16) -> Vec<Vec<usize>> {
    let mut abc:Vec<Vec<usize>> = Vec::new();
    abc.push(Vec::new());

    let mut ha = ha;

    while ha > 0 {
        abc[0].push(ha.trailing_zeros() as usize);
        ha = ha & (ha - 1);
    }

    abc.push(Vec::new());

    let mut hb = hb;

    while hb > 0 {
        abc[1].push(hb.trailing_zeros() as usize);
        hb = hb & (hb - 1);
    }

    abc.push(Vec::new());

    let mut hc = hc;

    while hc > 0 {
        abc[2].push(hc.trailing_zeros() as usize);
        hc = hc & (hc - 1);
    }

    abc
}
struct InputScanner<R: BufRead> {
	reader: R,
	buf: Vec<u8>, // Should never be empty
	pos: usize,   // Should never be out of bounds as long as the input ends with '\n'
}
impl<R: BufRead> InputScanner<R> {
	fn new(reader: R, capacity: usize) -> Self {
		InputScanner {
			reader: reader,
			buf: Vec::with_capacity(capacity),
			pos: 0,
		}
	}

	#[inline]
	fn next<T: FromStr>(&mut self) -> T
	where
		T::Err: fmt::Debug,
	{
		if self.buf.is_empty() {
			self._read_next_line();
		}
		let mut start = None;
		loop {
			match (self.buf[self.pos], start.is_some()) {
				(b' ', true) | (b'\n', true) | (b'\r', true) => break,
				(_, true) | (b' ', false) => self.pos += 1,
				(b'\n', false) | (b'\r', false) => self._read_next_line(),
				(_, false) => start = Some(self.pos),
			}
		}
		let target = &self.buf[start.unwrap()..self.pos];
		unsafe { str::from_utf8_unchecked(target) }.parse().unwrap()
	}

	#[inline]
	fn _read_next_line(&mut self) {
		self.pos = 0;
		self.buf.clear();
		if self.reader.read_until(b'\n', &mut self.buf).unwrap() == 0 {
			panic!("Reached EOF");
		}
	}
}