A*算法求解8数码问题java的验证输入的完整代码

以下是使用A*算法求解八数码问题的Java代码，包括输入验证部分：

import java.util.Arrays;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Scanner;

public class EightPuzzleSolver {
    private static final int[] dx = {0, 0, 1, -1};
    private static final int[] dy = {1, -1, 0, 0};

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] board = new int[3][3];
        HashSet<String> visited = new HashSet<>();
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                board[i][j] = scanner.nextInt();
            }
        }
        if (!isValid(board)) {
            System.out.println("Invalid input!");
            return;
        }
        String start = Arrays.deepToString(board);
        String end = Arrays.deepToString(new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 0}});
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.offer(new Node(start, 0, heuristic(start, end), null));
        while (!pq.isEmpty()) {
            Node node = pq.poll();
            if (node.board.equals(end)) {
                printSolution(node);
                return;
            }
            if (!visited.contains(node.board)) {
                visited.add(node.board);
                int[][] curBoard = stringToBoard(node.board);
                int x = -1, y = -1;
                for (int i = 0; i < 3; i++) {
                    for (int j = 0; j < 3; j++) {
                        if (curBoard[i][j] == 0) {
                            x = i;
                            y = j;
                            break;
                        }
                    }
                }
                for (int i = 0; i < 4; i++) {
                    int nx = x + dx[i];
                    int ny = y + dy[i];
                    if (nx < 0 || ny < 0 || nx >= 3 || ny >= 3) {
                        continue;
                    }
                    int[][] newBoard = cloneBoard(curBoard);
                    newBoard[x][y] = newBoard[nx][ny];
                    newBoard[nx][ny] = 0;
                    String newBoardStr = Arrays.deepToString(newBoard);
                    if (!visited.contains(newBoardStr)) {
                        pq.offer(new Node(newBoardStr, node.g + 1, heuristic(newBoardStr, end), node));
                    }
                }
            }
        }
        System.out.println("No solution!");
    }

    private static int[][] cloneBoard(int[][] board) {
        int[][] newBoard = new int[3][3];
        for (int i = 0; i < 3; i++) {
            System.arraycopy(board[i], 0, newBoard[i], 0, 3);
        }
        return newBoard;
    }

    private static int[][] stringToBoard(String str) {
        int[][] board = new int[3][3];
        String[] parts = str.substring(1, str.length() - 1).split(", ");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                board[i][j] = Integer.parseInt(parts[i * 3 + j]);
            }
        }
        return board;
    }

    private static void printSolution(Node node) {
        if (node != null) {
            printSolution(node.parent);
            System.out.println(node.board);
            System.out.println();
        }
    }

    private static int heuristic(String board, String end) {
        int[][] curBoard = stringToBoard(board);
        int[][] endBoard = stringToBoard(end);
        int distance = 0;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (curBoard[i][j] != 0 && curBoard[i][j] != endBoard[i][j]) {
                    int x = (curBoard[i][j] - 1) / 3;
                    int y = (curBoard[i][j] - 1) % 3;
                    distance += Math.abs(x - i) + Math.abs(y - j);
                }
            }
        }
        return distance;
    }

    private static boolean isValid(int[][] board) {
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] < 0 || board[i][j] > 8 || set.contains(board[i][j])) {
                    return false;
                }
                set.add(board[i][j]);
            }
        }
        return true;
    }

    private static class Node implements Comparable<Node> {
        private final String board;
        private final int g;
        private final int h;
        private final Node parent;

        private Node(String board, int g, int h, Node parent) {
            this.board = board;
            this.g = g;
            this.h = h;
            this.parent = parent;
        }

        private int f() {
            return g + h;
        }

        public int compareTo(Node other) {
            return Integer.compare(f(), other.f());
        }
    }
}