Java带权图的最短路径算法-Dijkstra

最新推荐文章于 2024-04-08 10:43:37 发布
最新推荐文章于 2024-04-08 10:43:37 发布
阅读量1.8k 收藏 40
点赞数 45
分类专栏： 算法 文章标签： java 算法 图论 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cw_Herry/article/details/136904563
版权

文章目录

Java带权图的最短路径算法-Dijkstra

Dijkstra算法的核心思想是通过逐步逼近的方式，找出从起点到图中其他所有节点的最短路径。算法的基本步骤如下：

  1. 初始化：

    • 创建一个最短路径信息数组shortPath[x][3]，每一个一维数组含义为当前结点、该节点到此节点的最短路径、起始节点。
    • 初始化shortPath数组，shortPath[x][0]当前节点编号、shortPath[x][1]最短路径、shortPath[x][2]起始结点编号
    • 初始化优先队列，将起始节点的所有邻接点加入到优先队列中，结点信息使用Ownership类，属性值{time、nodeIndex、weight}。
    • 创建优先队列，优先队列按照结点的权重值优先出队 PriorityQueue。
    • 创建优先队列的比较器OwnershipCustomerComparator类，通过weight大小进行优先出队。

  2. 流程：

    1. 优先队列为空则退出
    2. 遍历优先队列，将队列中time版本对应的结点信息值写入shortPath中。每次拿到最新路径长度newWeight=matrix[up - 1][ownership.nodeIndex] + shortPath[up - 1][1]（起始节点最短路径+起始节点到当前节点一条边的权重），如果当前结点未被初始化则直接将newWeight写入shortPath数组中，如果当前节点已经被写过最短路径，则直接略过当前newWeight即可，这里有一个dtx变量，记录当前优先队列中结点是否被写如果shortPath，用于time（版本）。
    3. 遍历优先队列（需要出队），将权重最小的结点出队，将该节点下的所有邻接点拿出做以下操作步骤：
      1. 需要是出对节点的邻接点
      2. 邻接点在shortPath表中的最短路径未被初始化（还是无穷大），将结点信息写入，最短路径为出对节点权重+出对节点到达该邻接点的权重
      3. 查看该邻接点是否出现在优先队列中。在优先队列中则更新shortPath数组以及优先队列中该结点的权重以及起始节点的信息。
      4. 优先队列中没有，Math.min(newWeight, shortPath[i][1])，取最优路径写入

    在这里插入图片描述

    代码

    public static void ownership_graph() {
  DirectGraph graph = new DirectGraph(new String[]{"V1", "V2", "V3", "V4", "V5"}, true);
  graph.addEdge(1, 2, 10);
  graph.addEdge(1, 4, 30);
  graph.addEdge(1, 5, 90);
  graph.addEdge(2, 3, 50);
  graph.addEdge(3, 5, 10);
  graph.addEdge(4, 2, 10);
  graph.addEdge(4, 3, 20);
  graph.addEdge(4, 5, 60);
  int[][] shortPath = graph.dijkstraShortFinding(1);
  for (int i = 0; i < shortPath.length; i++) {
    System.out.printf("V1 -> V%d 的最短路径为: %d\n", i + 1, shortPath[i][1]);
  }
}

/**
 * 有向图
 * @author sean
 * @version 1.0
 * @date 2024-3-19 15:34
 */
public class DirectGraph {
    /**
     * 结点集合
     */
    private List<String> node;

    /**
     * true 有权图
     * false 无权图
     */
    private boolean weightFlag;

    /**
     * 邻接矩阵
     */
    private int[][] matrix;
  
    public DirectGraph(String[] nodes, boolean weightFlag) {
      node = new ArrayList<>(Arrays.asList(nodes));
      matrix = new int[node.size()][node.size()];
      this.weightFlag = weightFlag;
    }
  
  	/**
     * 有权图的最短路径
     * @param x 起始结点
     * @return 有权图最短路径 说明数组
     */
    public int[][] dijkstraShortFinding(int x) {
        if (this.weightFlag) {
            // 优先队列
            PriorityQueue<Ownership> queue = new PriorityQueue<>(new OwnershipCustomerComparator());
            for (int i = 0; i < matrix[x - 1].length; i++) {
                if (matrix[x - 1][i] != 0) {
                    queue.offer(new Ownership(1, i, matrix[x - 1][i]));
                }
            }
            // queue -> v1 v6
            int[][] shortPath = new int[node.size()][3];
            initOwnershipShortPath(shortPath);
            // 表示被访问过  表示到2的距离  表示目的节点编号从1开始
            shortPath[x - 1][1] = 0;
            shortPath[x - 1][2] = x;
            ownershipShortPath(shortPath, queue, x, 0);
            return shortPath;
        }
        return new int[node.size()][3];
    }
  	/**
     * 初始化有权数组
     * @param shortPath 最短路径数组
     */
    private void initOwnershipShortPath(int[][] shortPath) {
        for (int i = 0; i < shortPath.length; i++) {
            shortPath[i][0] = i + 1;
            shortPath[i][1] = -1;
            shortPath[i][2] = 0;
        }
    }
  
  /**
     * 有权图的最短路径
     * @param shortPath 最短路径数组
     * @param queue 按照权值的优先队列
     * @param up 起始节点
     * @param time 版本号 是否需要修改当前结点在 shortPath中的属性
     */
    private void ownershipShortPath(int[][] shortPath, PriorityQueue<Ownership> queue, int up, int time) {
        if (queue.isEmpty()) {
            return;
        }
        int dtx = 0;
        for (Ownership ownership : queue) {
            if (ownership.time != time + 1) {
                continue;
            }
            // 新的路径长度
            int newWeight = matrix[up - 1][ownership.nodeIndex] + shortPath[up - 1][1];
            // 总是拿到最优路径
            if (shortPath[ownership.nodeIndex][1] == -1) {
                shortPath[ownership.nodeIndex][1] = newWeight;
                shortPath[ownership.nodeIndex][2] = up;
            } else {
                if (shortPath[ownership.nodeIndex][1] >= newWeight) {
                    shortPath[ownership.nodeIndex][1] = newWeight;
                    shortPath[ownership.nodeIndex][2] = up;
                }
            }
            dtx = 1;
        }

        // 遍历优先队列
        while (!queue.isEmpty()) {
            // 删除的结点
            Ownership removeNode = queue.poll();
            // 该节点是否影响其他结点
            boolean flag = false;
            for (int i = 0; i < matrix[removeNode.nodeIndex].length; i++) {
                int newWeight = removeNode.weight + matrix[removeNode.nodeIndex][i];
                // 当前节点的邻接点 必要条件
                if (matrix[removeNode.nodeIndex][i] != 0) {
                    // 当前邻接点的最小距离 为 无穷大 就直接将当前路径长度放入
                    if (shortPath[i][1] == -1) {
                        queue.offer(new Ownership(removeNode.time + dtx, i, newWeight));
                        flag = true;
                        continue;
                    }
                    if (newWeight > shortPath[i][1]) {
                        continue;
                    }
                    // 优先队列中包含了当前结点  并且  路径为最优
                    if (queue.contains(new Ownership(i))) {
                        // 更新队列中结点的权值 和 最短路径数组中的属性
                        for (Ownership ownership : queue) {
                            if (ownership.nodeIndex == i) {
                                ownership.weight = newWeight;
                                shortPath[i][2] = removeNode.nodeIndex + 1;
                                shortPath[i][1] = ownership.weight;
                                break;
                            }
                        }
                    } else {
                        queue.offer(new Ownership(removeNode.time + dtx, i, newWeight));
                        flag = true;
                    }
                }
            }
            // 可影响其他结点 在进行 递归回溯
            if (flag) {
                ownershipShortPath(shortPath, queue, removeNode.nodeIndex + 1, time + 1);
            }
        }
    }
  
  	/**
     * 有点队列比较器
     */
    static class OwnershipCustomerComparator implements Comparator<Ownership>{
        @Override
        public int compare(Ownership o1, Ownership o2) {
            return o1.weight - o2.weight;
        }
    }

    /**
     * 结点信息
     */
    static class Ownership{
        int time;
        int nodeIndex;
        int weight;
      
        public Ownership(int nodeIndex, int weight) {
            this.nodeIndex = nodeIndex;
            this.weight = weight;
        }

        public Ownership(int time, int nodeIndex, int weight) {
            this.time = time;
            this.nodeIndex = nodeIndex;
            this.weight = weight;
        }

        public Ownership(int nodeIndex) {
            this.nodeIndex = nodeIndex;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Ownership ownership = (Ownership) o;
            return nodeIndex == ownership.nodeIndex;
        }
    }
}

    ## 结果
V1 -> V1 的最短路径为: 0
V1 -> V2 的最短路径为: 10
V1 -> V3 的最短路径为: 50
V1 -> V4 的最短路径为: 30
V1 -> V5 的最短路径为: 60

    初学图论算法，在B站看到有博主讲的思路，就模拟下来啦，感觉代码写的很多冗余，希望大佬指点，感谢🙇‍🙇‍

mimiboss
关注
  • 45
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
十六、Java数据结构与算法 - 图
AsiaLYF
05-08 743
数据结构与算法-图
java实现Dijkstra算法
呆萌小新@渊洁的博客
06-03 6847
解决的问题: 求解单源最短路径,即各个节点到达源点的最短路径或权值 考察其他所有节点到远点的最短路径和长度 局限性: 无法解决权值为负数的情况参数:Dijkstra算法步骤: (1）初始化: 顶点集S: 顶点A到自已的最短路径长度为0。只包含源点，即S={A} 顶点集U: 包含除v0外的其他顶点. 即U={B,C,D,E,F} dist[]: 源点还不能到达的节点,其权值为∞path[]: 记录当前节点的前驱节点下标(源点还不能到达的节点为-1)(2）从U中选取一个节点，它是源点A到然后把加入S中（此.
Java数据结构算法-图形算法
最新发布
小橘子的博客
04-08 2956
深度优先搜索是一种用于遍历或搜索树或图的算法。这个算法会尽可能深地搜索树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。广度优先搜索是另一种用于遍历或搜索树或图的算法。这个算法从根节点（或任意节点）开始，探索最近的节点，然后进一步探索下一层的节点，依此类推。
2021年大厂Java岗面试必问，数据结构之图（内含Java代码实现）
m0_60607609的博客
09-04 355
深度优先搜索类似i走迷宫，一条路走到黑，如果发现这条路走不通，就在前一个路口继续向前走。就像下面这样（图片节选自《算法第四版》） 那么算法中，我们需要解决什么问题呢？我们可以通过adj函数得到结点的相邻结点，但是如果我们如何保证结点已经被我们访问过了，我们就需要一个标志mark，这个标志代表着这个结点是否已经被访问过。（HashSet这种数据结构也可以做到这种事情）。步骤如下: 将被访问的结点标记为已访问 递归地访问它的所有没有被标记过的邻居结点 /** * 无向图的深度优先搜索 *
Java基础语法：Dijkstra算法
qq_44579321的博客
03-12 245
Dijksta算法
Dijkstra算法实现（java）
weixin_43698993的博客
02-08 4638
一、Dijkstra算法介绍   Dijkstra（迪杰斯特拉）算法是求解单源最短路径的经典算法，其原理也是基于贪心策略的。 二、Dijkstra算法原理   Dijkstra算法设置一个集合SSS记录已求得的最短路径的顶点，初始时把源点v0v_{0}v0​放入SSS，集合SSS每并入一个新顶点viv_{i}vi​，都要修改源点v0v_{0}v0​到集合V−SV-SV−S中顶点当前的最短路径长度值。   在构造的过程中还设置了两个辅助数组： （1）dist[]：记录从源点v0v_{0}v0​到其他各顶点当
最短路径算法的改进与实现
04-22
带权图的多种算法（有向图，无向图，Dijkstra算法，到每个顶点的最短距离，佛洛依德算法(Floyd)，找出每对顶点的最短路径，带权重无向图最小生成树，prim算法，Kruskal算法求最小生成树）java实现，有注释，简单轻松...
带权图的多种算法（有向图，无向图，Dijkstra算法，到每个顶点的最短距离算法，佛洛依德算法(Floyd)，找出每对顶点的最短路径，带权重无向图最小生成树，prim算法，Kruskal算法求最小生成树）java实现，有注释
03-04
带权图的多种算法（有向图，无向图，Dijkstra算法，到每个顶点的最短距离，佛洛依德算法(Floyd)，找出每对顶点的最短路径，带权重无向图最小生成树，prim算法，Kruskal算法求最小生成树）java实现， 有注释，简单...
单源最短路径.docx
07-04
【单源最短路径问题】是指在给定的有向带权图中，找到从一个指定的源点出发到其他所有节点的最短路径。这是一个经典的图论问题，在计算机科学和网络路由等领域有着广泛的应用。 **算法思想：Dijkstra算法** ...
java算法全卷（包括基本算法和图算法）
10-03
java算法全卷（包括基本算法和图算法）
Java图遍历算法一例
12-07
java图遍历应用一例： 题目：用1、2、2、3、4、5这六个数字，用java写一个函数，打印出所有不同的排列，如：512234、412345等，要求："4"不能在第三位，"3"与"5"不能相连。
图的基本算法集合(Java)(最短路径与最小生成树)
XiAoRayL的博客
11-21 1183
图的基本算法集合(最短路径与最小生成树) 1.最短路径算法(DFS 弗洛伊德 迪杰斯特拉 Bellman-Ford) 1.1DFS 两点最短路径 其实不只是深度优先搜索，广度优先搜索也可以解决此类问题，这里拿DFS作为介绍，在解决最短路径的问题上，DFS和BFS是差不太多的 思路：从起始节点开始访问所有的与起始节点相邻的边，然后继续搜索直到达到我们想要的cur节点同时维护一个最短路径变量得到答案。 import java.util.Scanner; public class Map { stat
迪杰斯特拉（Dijkstra）算法JAVA实现
m0_64427937的博客
04-29 3599
迪杰斯特拉算法JAVA代码实现
图解迪杰斯特拉（Dijkstra）算法（Java语言实现）
qq_40554133的博客
02-20 3743
概述 感觉迪杰斯特拉好难，才学会的这个算法，所以写下博客加深理解。 Dijkstra算法是从一个顶点到其余各顶点的最短路径算法，解决的是带权图中最短路径问题。Dijkstra算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 Dijkstra算法将图中的节点集分为： 1.最短路径计算完成的节点集S 2.最短路径未计算完成的节点集T 首先选择一个起点，然后每次将从T中挑选“起点->...
JAVA:实现Dijkstra迪杰斯特拉算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-09 402
JAVA:实现Dijkstra迪杰斯特拉算法(附完整源码)
Java版高级数据结构算法 - Dijkstra迪杰斯特拉算法
大秦坑王的专栏
05-10 562
Dijkstra算法是典型的单源最短路径算法，用于计算带权图中一个节点到其它所有节点的最短路径，主要特点是以起始点为中心向外层层扩张，直到扩展到重点为止。 算法描述 Dijkstra算法的思想是，设G=(V,E)是一个带权有向图，把图中顶点集合V分成两...
图的最短路径java_带权图的最短路径算法(Dijkstra)实现
06-01
好的，以下是带权图的最短路径算法——Dijkstra算法的Java实现： ```java import java.util.*; public class DijkstraAlgorithm { private static final int MAX = Integer.MAX_VALUE; public static void dijkstra(int[][] graph, int src) { int n = graph.length; int[] dist = new int[n]; boolean[] visited = new boolean[n]; // 初始化dist数组和visited数组 for (int i = 0; i < n; i++) { dist[i] = MAX; visited[i] = false; } dist[src] = 0; for (int i = 0; i < n - 1; i++) { // 找到dist值最小的点 int u = minDistance(dist, visited); visited[u] = true; // 更新u的邻接点的dist值 for (int v = 0; v < n; v++) { if (!visited[v] && graph[u][v] != 0 && dist[u] != MAX && dist[u] + graph[u][v] < dist[v]) { dist[v] = dist[u] + graph[u][v]; } } } // 输出最短路径 printSolution(dist); } private static int minDistance(int[] dist, boolean[] visited) { int min = MAX; int minIndex = -1; for (int v = 0; v < dist.length; v++) { if (!visited[v] && dist[v] <= min) { min = dist[v]; minIndex = v; } } return minIndex; } private static void printSolution(int[] dist) { System.out.println("Vertex \t Distance from Source"); for (int i = 0; i < dist.length; i++) { System.out.println(i + " \t\t " + dist[i]); } } public static void main(String[] args) { int[][] graph = {{0, 2, 0, 6, 0}, {2, 0, 3, 8, 5}, {0, 3, 0, 0, 7}, {6, 8, 0, 0, 9}, {0, 5, 7, 9, 0}}; dijkstra(graph, 0); } } ``` 以上代码中，我们首先定义了一个`MAX`常量表示整数的最大值。然后，我们通过`dijkstra()`方法实现Dijkstra算法。在该方法中，我们首先初始化一个`dist`数组和一个`visited`数组，分别用于存储各个节点的距离和是否已经访问过。然后，我们将起始节点的距离设为0，其余节点的距离设为`MAX`。 接下来，我们在循环中找到`dist`值最小的未访问过的节点，将其标记为已访问，并更新其邻接点的距离。在循环结束后，我们将输出最短路径，即输出各个节点距离起点的距离。 最后，我们通过`main()`方法测试了上面的代码，输出的结果为： ``` Vertex Distance from Source 0 0 1 2 2 3 3 6 4 8 ``` 这说明从节点0到各个节点的最短路径分别为0、2、3、6和8。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值