有人想旅行某个城市的六个地点，每个地点之间的路线权重值不一样（权重值类型为double），从任意地点出发，求最短路径并输出该路径经历城市的顺序，给出解题思路及相应java代码

这是一个典型的最短路径问题，可以使用 Dijkstra 算法或者 Floyd 算法求解。这里给出 Dijkstra 算法的实现。

Dijkstra 算法是一种贪心算法，每次从未访问的节点中选取距离起点最近的节点，然后根据该节点更新其他节点的距离。具体实现时，可以使用优先队列来维护未访问节点的距离。

以下是 Java 代码：

import java.util.*;

public class ShortestPath {
    private static final double INF = Double.MAX_VALUE; // 无穷大
    private int n; // 节点个数
    private double[][] graph; // 图的邻接矩阵
    private double[] dist; // 起点到各个节点的最短距离
    private int[] prev; // 记录最短路径中每个节点的前一个节点

    public ShortestPath(double[][] graph) {
        this.n = graph.length;
        this.graph = graph;
        this.dist = new double[n];
        Arrays.fill(dist, INF);
        this.prev = new int[n];
        Arrays.fill(prev, -1);
    }

    public List<Integer> getShortestPath(int start, int end) {
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.offer(new Node(start, 0));
        dist[start] = 0;

        while (!pq.isEmpty()) {
            Node node = pq.poll();
            int u = node.u;

            if (u == end) {
                break; // 已经找到最短路径
            }

            for (int v = 0; v < n; v++) {
                if (graph[u][v] != INF && dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v];
                    prev[v] = u;
                    pq.offer(new Node(v, dist[v]));
                }
            }
        }

        List<Integer> path = new ArrayList<>();
        int u = end;
        while (u != -1) {
            path.add(u);
            u = prev[u];
        }
        Collections.reverse(path);
        return path;
    }

    private static class Node implements Comparable<Node> {
        int u;
        double dist;

        public Node(int u, double dist) {
            this.u = u;
            this.dist = dist;
        }

        public int compareTo(Node other) {
            return Double.compare(dist, other.dist);
        }
    }
}

使用示例：

double[][] graph = {
    {0, 1, 2, INF, INF, INF},
    {1, 0, INF, 4, 3, INF},
    {2, INF, 0, INF, INF, 5},
    {INF, 4, INF, 0, 2, INF},
    {INF, 3, INF, 2, 0, 1},
    {INF, INF, 5, INF, 1, 0}
};
ShortestPath sp = new ShortestPath(graph);
List<Integer> path = sp.getShortestPath(0, 5);
System.out.println(path); // 输出 [0, 1, 4, 5]

以上代码实现了从 0 号节点出发到 5 号节点的最短路径问题，图的邻接矩阵为：

0  1  2  ∞  ∞  ∞
1  0  ∞  4  3  ∞
2  ∞  0  ∞  ∞  5
∞  4  ∞  0  2  ∞
∞  3  ∞  2  0  1
∞  ∞  5  ∞  1  0

其中，∞ 表示两个节点之间没有边。