现有一两行三列的表格如下： A B C D E F 把1、2、3、4、5、6六个数字分别填入A、B、C、D、E、F格子中，每个格子一个数字且各不相同。每种不同的填法称为一种布局。如下： 1 3 5 2 4 6 布局1 2 5 6 4 3 1 布局2 定义α变换如下：把A格中的数字放入B格，把B格中的数字放入E格，把E格中的数字放入D格，把D格中的数字放入A格。 定义β变换如下：把B格中的数字放入C格，把C格中的数字放入F格，把F格中的数字放入E格，把E格中的数字放入B格。 问：对于给定的布局，可否通过有限次的α变换和β变换变成下面的目标布局： 1 2 3 4 5 6 输入：本题有多个测例，第一行为输入测例的个数n，下面是n行测例，每个测例的输入是1到6这六个数字的一个排列，空格隔开，表示初始布局ABCDEF格中依次填入的数字。 输出：每个输出占一行。输出转换到目标格局需要变换的最少次数。（若不能转换则输出-1）用java实现

以下是Java代码实现，其中使用了BFS算法：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        while (n-- > 0) {
            int[] start = new int[6];
            for (int i = 0; i < 6; i++) {
                start[i] = scanner.nextInt();
            }
            int[] end = new int[]{1, 2, 3, 4, 5, 6};
            int res = bfs(start, end);
            System.out.println(res);
        }
    }

    private static int bfs(int[] start, int[] end) {
        Set<String> visited = new HashSet<>();
        Queue<int[]> queue = new LinkedList<>();
        Map<String, Integer> distance = new HashMap<>();
        queue.offer(start);
        visited.add(Arrays.toString(start));
        distance.put(Arrays.toString(start), 0);
        while (!queue.isEmpty()) {
            int[] curr = queue.poll();
            if (Arrays.equals(curr, end)) {
                return distance.get(Arrays.toString(curr));
            }
            List<int[]> neighbors = getNeighbors(curr);
            for (int[] neighbor : neighbors) {
                String neighborStr = Arrays.toString(neighbor);
                if (!visited.contains(neighborStr)) {
                    visited.add(neighborStr);
                    queue.offer(neighbor);
                    distance.put(neighborStr, distance.get(Arrays.toString(curr)) + 1);
                }
            }
        }
        return -1;
    }

    private static List<int[]> getNeighbors(int[] state) {
        List<int[]> neighbors = new ArrayList<>();
        // alpha transformation
        int[] alphaTransformed = new int[]{state[1], state[5], state[2], state[0], state[4], state[3]};
        neighbors.add(alphaTransformed);
        // beta transformation
        int[] betaTransformed = new int[]{state[0], state[2], state[3], state[4], state[1], state[5]};
        neighbors.add(betaTransformed);
        return neighbors;
    }
}