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

import java.awt.Point;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;

public class Main {
	
	public static void print(int[][] states, int[] sizes){
		for(int i = 0; i < 3; i++){
			System.out.print(sizes[i] + " :");
			for(int j = 0; j < sizes[i]; j++){
				System.out.print(" " + states[i][j]);
			}
			System.out.println();
		}
	}
	
	public static void translate(int from, int to, int[][] states, int[] sizes){
		//System.out.println("---------------------------------");
		//print(states, sizes);
		//System.out.println(from + " => " + to);
		
		sizes[from]--;
		states[to][sizes[to]] = states[from][sizes[from]];
		sizes[to]++;
		
	}
	
	public static boolean is_same(int[][] states, int[] sizes, int[][] p_states, int[] p_sizes){
		for(int i = 0; i < 3; i++){
			if(sizes[i] != p_sizes[i]){
				return false;
			}
			
			for(int j = 0; j < sizes[i]; j++){
				if(states[i][j] != p_states[i][j]){
					return false;
				}
			}
		}
		
		return true;
	}
	
	public static int ans = 0;
	public static boolean get_ans = false;
	
	public static int move(int depth, final int n, int from, int use, int to, int[][] states, int[] sizes, int[][] p_states, int[] p_sizes){
		int walk = 0;
		
		if(depth < n){
			walk += move(depth + 1, n, from, use, to, states, sizes, p_states, p_sizes);
		}
		
		//move
		//System.out.println(depth + "  : " + from + " => " + use);
		/*
		if(is_same(states, sizes, p_states, p_sizes)){
			ans = walk;
		}
		*/
		
		if(!get_ans && is_same(states, sizes, p_states, p_sizes)){
			get_ans = true;
		}
		
		translate(from, use, states, sizes);
		walk++;
		
		if(!get_ans){
			ans++;
		}
		
		/*
		if(is_same(states, sizes, p_states, p_sizes)){
			ans = walk;
		}
		*/
		
		if(depth < n){
			walk += move(depth + 1, n, to, use, from, states, sizes, p_states, p_sizes);
		}
		
		
		//move
		//System.out.println(depth + "  : " + use + " => " + to);
		/*
		if(is_same(states, sizes, p_states, p_sizes)){
			ans = walk;
		}
		*/
		
		if(!get_ans && is_same(states, sizes, p_states, p_sizes)){
			get_ans = true;
		}
		
		translate(use, to, states, sizes);
		walk++;
		
		if(!get_ans){
			ans++;
		}
		
		/*
		if(is_same(states, sizes, p_states, p_sizes)){
			ans = walk;
		}
		*/
		
		if(depth < n){
			walk += move(depth + 1, n, from, use, to, states, sizes, p_states, p_sizes);
		}
		
		/*
		if(is_same(states, sizes, p_states, p_sizes)){
			ans = walk;
		}
		*/
		
		return walk;
	}
	
	public static final int MAX = 16;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int[][] init_states = new int[3][MAX];
		int[]   init_sizes  = new int[3];
		int[][] p_states = new int[3][MAX];
		int[]   p_sizes  = new int[3];
		
		while(true){
			final int n = sc.nextInt();
			final int m = sc.nextInt();
			
			if(n == 0 && m == 0){
				break;
			}
			
			for(int i = 0; i < 3; i++){
				p_sizes[i] = sc.nextInt();
				
				for(int j = 0; j < p_sizes[i]; j++){
					p_states[i][j] = sc.nextInt();
				}
			}
			
			ans = 0;
			get_ans = false;
			init_sizes[0] = n; init_sizes[1] = 0; init_sizes[2] = 0;
			for(int i = 0; i < n; i++){
				init_states[0][i] = i + 1;
			}
			
			final int max = move(1, n, 0, 1, 2, init_states, init_sizes, p_states, p_sizes);
			
			int answer = Math.min(ans, max - ans);
			
			System.out.println(answer <= m ? answer : -1);
			
		}
	}
}