使用Java采用队列式分支限界法实现单源最短路径问题解决算法

单源最短路径问题可以使用队列式分支限界法求解。该算法通过维护一个优先队列，来逐步扩展当前的最短路径，直到找到目标节点或者队列为空。

以下是使用Java实现该算法的代码：

import java.util.*;

public class ShortestPath {
    private int[][] graph;
    private int n;

    public ShortestPath(int[][] graph) {
        this.graph = graph;
        this.n = graph.length;
    }

    public List<Integer> solve(int source, int target) {
        Queue<State> queue = new PriorityQueue<>();
        queue.offer(new State(source, 0, new ArrayList<>(Arrays.asList(source))));

        while (!queue.isEmpty()) {
            State curr = queue.poll();

            if (curr.node == target) {
                return curr.path;
            }

            for (int i = 0; i < n; i++) {
                if (graph[curr.node][i] != 0) {
                    int newCost = curr.cost + graph[curr.node][i];
                    List<Integer> newPath = new ArrayList<>(curr.path);
                    newPath.add(i);
                    queue.offer(new State(i, newCost, newPath));
                }
            }
        }

        return null;
    }

    private static class State implements Comparable<State> {
        int node;
        int cost;
        List<Integer> path;

        public State(int node, int cost, List<Integer> path) {
            this.node = node;
            this.cost = cost;
            this.path = path;
        }

        @Override
        public int compareTo(State o) {
            return Integer.compare(cost, o.cost);
        }
    }
}

在上述代码中，ShortestPath类接收一个邻接矩阵表示的图作为构造函数的参数。solve方法接收源节点和目标节点的编号，返回最短路径。该方法使用优先队列实现队列式分支限界法。

State类表示状态，包含当前节点编号、到达当前节点的代价、以及到达当前节点的路径。在优先队列中，每个状态根据代价进行比较，优先级较高的状态先被取出。

在循环中，每次从队列中取出代价最小的状态进行扩展。对于当前节点能够到达的每个节点，计算到达新节点的代价，并将新状态加入优先队列。如果扩展到目标节点，则返回当前路径作为最短路径。如果队列为空，则表示无法到达目标节点，返回null。

可以使用以下代码测试上述实现：

public static void main(String[] args) {
    int[][] graph = new int[][]{
            {0, 1, 4, 0, 0},
            {0, 0, 2, 5, 0},
            {0, 0, 0, 0, 3},
            {0, 0, 0, 0, 1},
            {0, 0, 0, 0, 0}
    };
    ShortestPath solver = new ShortestPath(graph);
    List<Integer> path = solver.solve(0, 4);
    System.out.println(path); // [0, 1, 2, 4]
}

在上述代码中，使用一个邻接矩阵表示有向图，其中0表示两个节点之间没有边。调用ShortestPath类的solve方法，传入源节点0和目标节点4的编号，得到最短路径[0, 1, 2, 4]。