试图写一个算法来解决幻灯片难题，我一直有问题，我想我来这里寻求建议。这是普林斯顿算法第一部分的课程。
所以我会试着解释逻辑然后展示代码。基本上我有一个最小优先级的搜索节点队列。每个搜索节点都有一个棋盘、一个上一个棋盘、到达该棋盘的移动次数和曼哈顿优先级（移动次数+曼哈顿距离）
每次通过while（true）循环都会删除最小节点（最小优先级），并添加新节点，这些节点的前一个节点是被删除的节点，板是与被删除节点相邻的板（移动1个），并且比前一个节点移动1个。
最后，假设被删除的节点有解算板，然后通过循环解算节点的前几个节点找到最短路径。但这永远不会发生。我不知道我的逻辑是否有缺陷，或者我的代码是否有问题。但我已经想了很久，却一无所获。
我要提到的是，每个幻灯片都是2D数组，0对应于空白。
下面是节点类：

private class Node {
        Node previous;
        Board board;
        int moves;
        int priority;

        Node(Node previous, Board board, int moves) {
            this.previous = previous;
            this.board = board;
            this.moves = moves;
            priority = moves + board.manhattan();
        }
    }

这是我用来比较节点的比较器。如果一个节点的优先级较低，则该节点比另一个节点小。

// compares nodes based on their Manhattan priority
    private Comparator<Node> priority() {
        return (o1, o2) -> {
            return Integer.compare(o1.priority, o2.priority);
        };
    }

这是一个解算器构造器，用来解决幻灯片难题。目前假设这个难题是可以解决的。while（真）循环给了我很多问题，我不知道为什么。

// find solution to the initial board using A* algorithm
    public Solver(Board initial) {
        // define the first Node
        Node first = new Node(null, initial, 0);
        // enqueue neighbors into MinPQ
        MinPQ<Node> pq = new MinPQ<>(priority());
        for (Board board : first.board.neighbors()) {
            pq.insert(new Node(first, board, 1));
        }

        while (true) {
            // delete min node
            Node min = pq.delMin();
            // if it is the goal board, stop
            if (min.board.isGoal()) {
                break;
            }
            // add neighbors to pq
            for (Board board : min.board.neighbors()) {
                Node neighborNode = new Node(min, board, min.moves + 1);
                // don't add grandfather nodes
                if (!min.previous.board.equals(neighborNode.board)) {
                    pq.insert(neighborNode);
                }
            }
        }
    }