可以用java 代码给出写出路径导游算法的选择吗

当然可以，这里为您提供两种经典的路径导游算法Java代码实现：

1. Dijkstra算法

public class DijkstraAlgorithm {
    private int[] dist;  // 保存源点到各个顶点的最短距离
    private boolean[] visited;  // 保存顶点是否已经求出最短距离
    private int[][] graph;  // 图的邻接矩阵

    public DijkstraAlgorithm(int[][] graph) {
        this.graph = graph;
        int len = graph.length;
        dist = new int[len];
        visited = new boolean[len];
    }

    public void dijkstra(int start) {
        // 初始化
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[start] = 0;

        // 循环n次，每次求出一个顶点的最短距离
        for (int i = 0; i < graph.length; i++) {
            int minDist = Integer.MAX_VALUE;
            int minIndex = -1;

            // 找到未求出最短距离的顶点中距离start最近的一个顶点
            for (int j = 0; j < graph.length; j++) {
                if (!visited[j] && dist[j] < minDist) {
                    minDist = dist[j];
                    minIndex = j;
                }
            }

            // 更新minIndex的邻居节点到start的距离
            for (int j = 0; j < graph.length; j++) {
                if (!visited[j] && graph[minIndex][j] != 0) {
                    int newDist = dist[minIndex] + graph[minIndex][j];
                    if (newDist < dist[j]) {
                        dist[j] = newDist;
                    }
                }
            }

            // 标记minIndex已经求出最短距离
            visited[minIndex] = true;
        }
    }

    public int[] getDist() {
        return dist;
    }
}

2. A*算法

public class AStarAlgorithm {
    private int[][] graph;  // 图的邻接矩阵
    private int[] dist;  // 保存源点到各个顶点的估计距离
    private int[] h;  // 保存各个顶点到终点的估计距离
    private boolean[] visited;  // 保存顶点是否已经被访问过
    private PriorityQueue<Node> openList;  // 优先队列

    public AStarAlgorithm(int[][] graph, int[] h) {
        this.graph = graph;
        this.h = h;
        int len = graph.length;
        dist = new int[len];
        visited = new boolean[len];
        openList = new PriorityQueue<>((n1, n2) -> n1.getF() - n2.getF());
    }

    public void aStar(int start, int end) {
        // 初始化
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[start] = 0;
        visited[start] = true;
        openList.offer(new Node(start, h[start]));

        // 循环直到找到终点或openList为空
        while (!openList.isEmpty()) {
            Node node = openList.poll();
            int curr = node.getIndex();
            visited[curr] = true;

            if (curr == end) {
                return;
            }

            // 更新邻居节点到start的估计距离
            for (int i = 0; i < graph.length; i++) {
                if (!visited[i] && graph[curr][i] != 0) {
                    int newDist = dist[curr] + graph[curr][i];
                    if (newDist < dist[i]) {
                        dist[i] = newDist;
                        Node newNode = new Node(i, newDist + h[i]);
                        openList.offer(newNode);
                    }
                }
            }
        }
    }

    public int[] getDist() {
        return dist;
    }

    private static class Node {
        private int index;
        private int f;

        public Node(int index, int f) {
            this.index = index;
            this.f = f;
        }

        public int getIndex() {
            return index;
        }

        public int getF() {
            return f;
        }
    }
}

这两个算法的输入都是一个邻接矩阵，表示图的结构，输出是一个数组，保存每个顶点到源点的最短距离。需要根据具体的项目需求，结合GUI界面，进行相应的调用和数据处理。