package LiuShuMa; import java.util.*; public class Test { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); // 测试数据组数 while (n-- > 0) { int[] start = new int[6]; // 初始布局 int[] end = new int[]{1, 2, 3, 4, 5, 6}; // 目标布局 for (int i = 0; i < start.length; i++) { start[i] = scanner.nextInt(); } int ans = BFS(start, end); System.out.println(ans); } } static int BFS(int[] start, int[] end) { Queue<int[]> queue = new LinkedList<>(); // 队列存储布局 Map<String, Integer> dist = new HashMap<>(); // 记录初始布局到目标布局的距离 String startStr = Arrays.toString(start); // 初始布局转为字符串 queue.offer(start); dist.put(startStr, 0); while (!queue.isEmpty()) { int[] cur = queue.poll(); String curStr = Arrays.toString(cur); if (curStr.equals(Arrays.toString(end))) { // 当前布局与目标布局相等 return dist.get(curStr); } // α变换 int[] next1 = cur.clone(); next1[1] = cur[0]; next1[4] = cur[1]; next1[3] = cur[4]; next1[0] = cur[3]; String nextStr1 = Arrays.toString(next1); if (!dist.containsKey(nextStr1)) { queue.offer(next1); dist.put(nextStr1, dist.get(curStr) + 1); } // β变换 int[] next2 = cur.clone(); next2[2] = cur[1]; next2[5] = cur[2]; next2[4] = cur[5]; next2[1] = cur[4]; String nextStr2 = Arrays.toString(next2); if (!dist.containsKey(nextStr2)) { queue.offer(next2); dist.put(nextStr2, dist.get(curStr) + 1); } } return -1; // 没有符合条件的变换序列 } }给代码的每一行加注释

package LiuShuMa;  // 定义了一个包名为LiuShuMa
import java.util.*;  // 导入java.util包，包含了Scanner、Queue、LinkedList、Map、HashMap等类

public class Test {  // 定义了一个名为Test的公共类

    public static void main(String[] args) {  // 定义了一个公共静态方法main，参数为String类型数组args
        Scanner scanner = new Scanner(System.in);  // 创建一个Scanner对象，读取标准输入的数据
        int n = scanner.nextInt(); // 读取一个整数，表示测试数据组数
        while (n-- > 0) {  // 循环n次，每次处理一组测试数据
            int[] start = new int[6];  // 定义一个初始布局数组start，长度为6
            int[] end = new int[]{1, 2, 3, 4, 5, 6};  // 定义一个目标布局数组end，长度为6，初始化为{1, 2, 3, 4, 5, 6}
            for (int i = 0; i < start.length; i++) {  // 循环6次，读取初始布局
                start[i] = scanner.nextInt();
            }
            int ans = BFS(start, end);  // 调用BFS方法，计算从初始布局到目标布局的最小变换序列长度
            System.out.println(ans);  // 输出最小变换序列长度
        }
    }

    static int BFS(int[] start, int[] end) {  // 定义了一个静态方法BFS，返回值为int类型，参数为初始布局start和目标布局end
        Queue<int[]> queue = new LinkedList<>();  // 创建一个队列，用于存储布局，类型为整型数组
        Map<String, Integer> dist = new HashMap<>();  // 创建一个Map，用于记录初始布局到目标布局的距离，键为布局的字符串形式，值为距离
        String startStr = Arrays.toString(start);  // 将初始布局转为字符串
        queue.offer(start);  // 将初始布局加入队列
        dist.put(startStr, 0);  // 将初始布局与目标布局的距离初始化为0
        while (!queue.isEmpty()) {  // 当队列不为空时循环
            int[] cur = queue.poll();  // 取出队列中的一个布局
            String curStr = Arrays.toString(cur);  // 将当前布局转为字符串
            if (curStr.equals(Arrays.toString(end))) { // 当前布局与目标布局相等
                return dist.get(curStr);  // 返回当前布局与目标布局的距离
            }
            // α变换
            int[] next1 = cur.clone();  // 复制当前布局
            next1[1] = cur[0];  // 根据α变换规则更新next1数组
            next1[4] = cur[1];
            next1[3] = cur[4];
            next1[0] = cur[3];
            String nextStr1 = Arrays.toString(next1);  // 将next1数组转为字符串
            if (!dist.containsKey(nextStr1)) {  // 如果Map中不包含next1布局
                queue.offer(next1);  // 将next1布局加入队列
                dist.put(nextStr1, dist.get(curStr) + 1);  // 记录next1布局与目标布局的距离，并加1
            }
            // β变换
            int[] next2 = cur.clone();  // 复制当前布局
            next2[2] = cur[1];  // 根据β变换规则更新next2数组
            next2[5] = cur[2];
            next2[4] = cur[5];
            next2[1] = cur[4];
            String nextStr2 = Arrays.toString(next2);  // 将next2数组转为字符串
            if (!dist.containsKey(nextStr2)) {  // 如果Map中不包含next2布局
                queue.offer(next2);  // 将next2布局加入队列
                dist.put(nextStr2, dist.get(curStr) + 1);  // 记录next2布局与目标布局的距离，并加1
            }
        }
        return -1; // 没有符合条件的变换序列，返回-1
    }
}