最短路径Dijkstra算法 java

Dijkstra算法是一种用于求解单源最短路径的经典算法，其原理基于贪心策略。该算法以起始点为中心向外层层扩展，直到扩展到终点为止。在Java中，可以通过以下步骤实现Dijkstra算法：

1. 创建一个优先队列（PriorityQueue）来存储待访问的节点，并将起始节点加入队列。
2. 创建一个距离数组，用于存储起始节点到各个节点的最短距离。初始时，将起始节点的距离设为0，其他节点的距离设为无穷大。
3. 创建一个前驱数组，用于记录最短路径中的前驱节点。初始时，将所有节点的前驱节点设为null。
4. 不断从优先队列中取出待访问的节点，遍历该节点的所有邻居节点。
5. 对于每个邻居节点，计算经过当前节点到达该邻居节点的距离。如果这个距离比已经记录的最短距离要短，则更新最短距离和前驱节点，并将邻居节点加入优先队列。
6. 重复步骤4和步骤5，直到优先队列为空。
7. 最后，可以通过前驱数组构建出起始节点到其他节点的最短路径。

相关问题

最短路径dijkstra算法java

Dijkstra算法是一种用于解决带权重图中单源最短路径问题的贪心算法。这里所谓的单源最短路径，就是指在图中找到一个顶点，使得从该顶点出发到其他所有顶点的路径长度最短。

Dijkstra算法的基本思路是：对于给定的起点，首先将其标记为已访问，并设置起点到起点自身的距离为0。然后，遍历该起点能够到达的所有节点，并计算它们到起点的距离。选择距离最短的节点，标记为已访问，并将该节点作为中间节点，继续遍历其能够到达的所有节点，并更新它们到起点的距离。重复这个过程，直到所有节点都被标记为已访问。

以下是Dijkstra算法的Java实现：

import java.util.*;

public class DijkstraAlgorithm {
    private static int[][] graph;
    private static int[] dist;
    private static boolean[] visited;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入图的大小和边的数量
        int n = scanner.nextInt();
        int m = scanner.nextInt();

        // 初始化图
        graph = new int[n][n];
        for (int i = 0; i < m; i++) {
            int u = scanner.nextInt();
            int v = scanner.nextInt();
            int w = scanner.nextInt();
            graph[u - 1][v - 1] = w;
            graph[v - 1][u - 1] = w;
        }

        // 输入起点和终点
        int start = scanner.nextInt() - 1;
        int end = scanner.nextInt() - 1;

        // 初始化距离数组和访问数组
        dist = new int[n];
        visited = new boolean[n];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[start] = 0;

        // 开始遍历
        for (int i = 0; i < n; i++) {
            // 找到当前未访问节点中距离起点最近的节点
            int minDist = Integer.MAX_VALUE;
            int u = -1;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && dist[j] < minDist) {
                    minDist = dist[j];
                    u = j;
                }
            }
            if (u == -1) break;

            // 标记当前节点为已访问
            visited[u] = true;

            // 更新与当前节点相邻的节点的距离
            for (int v = 0; v < n; v++) {
                if (graph[u][v] > 0 && !visited[v] && dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v];
                }
            }
        }

        // 输出结果
        System.out.println(dist[end]);
    }
}

地铁最短路径dijkstra算法 java

好的，以下是地铁最短路径 Dijkstra 算法的 Java 代码实现：

import java.util.*;

public class Dijkstra {
    private static final int INF = Integer.MAX_VALUE; // 无穷大
    private static int[][] graph; // 地铁路线图
    private static int[] dist; // 起点到各站点的距离
    private static boolean[] visited; // 是否已经找到最短路径

    /**
     * dijkstra算法求起点到其他站点的最短距离
     * @param start 起点
     */
    public static void dijkstra(int start) {
        int n = graph.length;
        dist = new int[n];
        visited = new boolean[n];

        // 初始化距离数组
        for (int i = 0; i < n; i++) {
            dist[i] = INF;
        }
        dist[start] = 0;

        // 循环n次，每次找出一个顶点的最短路径
        for (int i = 0; i < n; i++) {
            int minDist = INF;
            int u = -1;
            // 找出当前未确定最短路径的距离最小的点
            for (int j = 0; j < n; j++) {
                if (!visited[j] && dist[j] < minDist) {
                    minDist = dist[j];
                    u = j;
                }
            }
            if (u == -1) {
                break; // 所有点均已找到最短路径
            }
            visited[u] = true;
            // 更新与u相邻的点的最短距离
            for (int v = 0; v < n; v++) {
                if (!visited[v] && graph[u][v] != INF && dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v];
                }
            }
        }
    }

    public static void main(String[] args) {
        // 以下为测试数据，实际使用时需要根据实际地铁路线图进行修改
        graph = new int[][]{
                {0, 4, 2, INF, INF},
                {4, 0, 1, 5, INF},
                {2, 1, 0, 1, INF},
                {INF, 5, 1, 0, 3},
                {INF, INF, INF, 3, 0}
        };
        dijkstra(0);
        System.out.println(Arrays.toString(dist)); // 输出起点到各站点的最短距离
    }
}

以上代码中，我们通过一个邻接矩阵来表示地铁路线图，其中 INF 表示两个站点之间没有直接连接。在 dijkstra 方法中，我们先初始化起点到各站点的距离为无穷大，然后以此找出距离起点最近的未确定最短路径的点，将其标记为已经确定最短路径，同时更新与该点相邻的点的最短距离。重复该过程，直到所有点均已找到最短路径，最终得到起点到各站点的最短距离数组。