import edu.princeton.cs.algs4.MinPQ; //导入依赖的package包/类
public Solver(Board initial) {
    if (initial == null) throw new IllegalArgumentException();

    MinPQ<SearchNode> pq = new MinPQ<>();
    pq.insert(new SearchNode(initial, 0, null));

    Board twin = initial.twin();
    MinPQ<SearchNode> tpq = new MinPQ<>();
    tpq.insert(new SearchNode(twin, 0, null));

    SolutionObj sol = solve(pq, tpq);
    this.moves = sol.moves;
    this.isSolvable = sol.isSolvable;
    this.solution = buildSolution(sol.solution);
}
 

import edu.princeton.cs.algs4.MinPQ; //导入依赖的package包/类
private SolutionObj solve(MinPQ<SearchNode> pq, MinPQ<SearchNode> tpq) {
    SearchNode node = pq.min(), tnode = pq.min();

    while(!node.board.isGoal() || !tnode.board.isGoal()) {
        node = pq.delMin();
        tnode = tpq.delMin();

        for (Board neighbor: node.board.neighbors()) {
            if (neighbor.isGoal()) {
                node = new SearchNode(neighbor, node.moves+1, node);
                return new SolutionObj(node, node.moves, true);
            }
            else if (node.previous == null || !node.previous.board.equals(neighbor))
                pq.insert(new SearchNode(neighbor, node.moves+1, node));
        }
        for (Board tneighbor: tnode.board.neighbors()) {
            if (tneighbor.isGoal()) {
                return new SolutionObj(null, -1, false);
            }
            else if (tnode.previous == null || !tnode.previous.board.equals(tneighbor))
                tpq.insert(new SearchNode(tneighbor, tnode.moves+1, tnode));
        }
    }

    if (node.board.isGoal()) { return new SolutionObj(node, node.moves, true); }
    else                     { return new SolutionObj(null, -1, false); }
}
 

import edu.princeton.cs.algs4.MinPQ; //导入依赖的package包/类
public static void main(String[] args) {
    int M = Integer.parseInt(args[0]);
    MinPQ<Transaction> pq = new MinPQ<>();

    while (StdIn.hasNextLine()) {
        String line = StdIn.readLine();
        Transaction item = new Transaction(line);

        pq.insert(item);
        if (pq.size() > M) pq.delMin();
    }
}
 

import edu.princeton.cs.algs4.MinPQ; //导入依赖的package包/类
private boolean solveAStar(SearchNode init) {
/* Solve the sliding puzzle game using the A* algorithm:
 * Put the root node in the priority queue. Then, while the solution
 * isn't found:
 * -> dequeue the node with the minimum priority (calculated with manhattan / hamming)
 * -> check if the node is the goal node, if it is, return the final path.
 * -> if it's not, enqueue every neighbor if the current node in the pq
 *    if the neighbor is different than the current node.
 * -> return to the loop
 */
    SearchNode sn;
    boolean watch;
    pq = new MinPQ<>();
    pq.insert(init);
    moves = 0;
    while (true) {
        sn = pq.delMin();
        if(sn.b.isGoal())
            return createPath(sn);
        watch = true;
        for(Board neighB : sn.b.neighbors()) {
            if(watch && neighB.equals(sn.b))
                watch = false;
            else
                pq.insert(new SearchNode(neighB, sn.nMovs + 1, sn));
        }
    }
}
 

import edu.princeton.cs.algs4.MinPQ; //导入依赖的package包/类
public Solver(Board initial) {
	MinPQ<Node> minPQ = new MinPQ<Node>();
	MinPQ<Node> minPQTwin = new MinPQ<Node>();
	minPQ.insert(new Node(initial, 0, null));
	minPQTwin.insert(new Node(initial.twin(), 0, null));
	resBoards.enqueue(initial);
	
	if(initial.isGoal()) {
		isSolverable = true;		
		return;
	}
	else if(initial.twin().isGoal()){
		isSolverable = false;
		return;
	}
	
	while(true){
		Node node = minPQ.delMin();
		if(node.board.isGoal()) {
			isSolverable = true;
			while(node.previous != null) {
				node = node.previous;
				resBoards.enqueue(node.board);
			}
			return;
		}else{
			node.move++;
			Iterable<Board> neighbors = node.board.neighbors();
    		for(Board b : neighbors) {
    			if(node.previous != null && b.equals(node.previous.board));
    			else
    				minPQ.insert(new Node(b, node.move, node));
    		}
		}
		
		Node nodeTwin = minPQTwin.delMin();
		if(nodeTwin.board.isGoal()){
			isSolverable = false;
			return;
		}
		else{
			nodeTwin.move++;
			Iterable<Board> neighborsTwin = nodeTwin.board.neighbors();
    		for(Board bt : neighborsTwin){
    			if(nodeTwin.previous != null && bt.equals(nodeTwin.previous.board));
    			else
    				minPQTwin.insert(new Node(bt, nodeTwin.move++, nodeTwin));
    		}
		}	
	}
}