Java代码实现用队列解决骑士游历问题，并输出路径

骑士游历问题是指在一个 n x n 的棋盘上，骑士要从起点出发，按照特定的规则走到终点，要求每个格子只能走一次。可以使用BFS算法和队列来解决这个问题。

以下是Java代码实现：

import java.util.*;

public class KnightTour {

    public static int[][] moves = { {-2, -1}, {-1, -2}, {1, -2}, {2, -1}, {2, 1}, {1, 2}, {-1, 2}, {-2, 1} };

    public static void main(String[] args) {

        int n = 8; // n x n的棋盘
        int startX = 0; // 起点的x坐标
        int startY = 0; // 起点的y坐标
        int endX = 7; // 终点的x坐标
        int endY = 7; // 终点的y坐标
        int[][] board = new int[n][n]; // 棋盘，初始值都为0

        findPath(startX, startY, endX, endY, board);

    }

    public static void findPath(int startX, int startY, int endX, int endY, int[][] board) {
        Queue<int[]> queue = new LinkedList<>(); // 用队列存储搜索的路径
        queue.offer(new int[]{startX, startY});
        board[startX][startY] = 1; // 起点标记为已经访问

        while(!queue.isEmpty()) {
            int[] current = queue.poll();
            int x = current[0];
            int y = current[1];

            if(x == endX && y == endY) { // 到达终点
                printPath(board);
                return;
            }

            for(int[] move : moves) {
                int newX = x + move[0];
                int newY = y + move[1];

                if(newX >= 0 && newY >= 0 && newX < board.length && newY < board[0].length && board[newX][newY] == 0) { // 新位置在棋盘内且未访问过
                    board[newX][newY] = board[x][y] + 1; // 标记为已访问，并且记录步数
                    queue.offer(new int[]{newX, newY}); // 将新位置加入队列
                }
            }
        }

        System.out.println("无解");
    }

    public static void printPath(int[][] board) { // 输出路径
        for(int i = 0; i < board.length; i++) {
            for(int j = 0; j < board[0].length; j++) {
                System.out.print(board[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

这个代码实现了一个8x8的棋盘上的骑士游历问题。程序输出的结果是，每个格子的值代表骑士到达这个格子所经过的步数，如果无解则输出“无解”。