算法——迪克斯特拉算法

最新推荐文章于 2024-08-13 17:15:43 发布
最新推荐文章于 2024-08-13 17:15:43 发布
阅读量1.5w 收藏 76
点赞数 24
分类专栏： 算法 算法 文章标签： 算法 迪克斯特拉算法 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37598011/article/details/98957393
版权

迪克斯特拉算法主要分四个步骤：

  1. 找到“最便宜”的节点（可在最短时间内到达的节点）。
  2. 更新该节点的邻居节点的开销。
  3. 重复这个过程，直到对图中每个节点都做了。
  4. 计算最终路径。

这个算法的核心理念是：找到图中最便宜的节点，并确保没有到该节点更便宜的路径。 （所以需要注意的是如果你的图包含负权边，就不能用这个算法，因为这会导致已经处理过的节点更新。）

假设我现在有上面的一张图，计算A->F的最小权重。

步骤一：

从A可以到B,C,F。相应的权重为：

A->B8
A->C10
A->F100

步骤二：

由步骤一得出由A->B为当前的最便宜节点，然后找到它相邻的节点：

B->D10
B->E70

由此可以更新A->D和A->E的权重：

A->D18
A->E78

步骤三：

重复这个操作：

C->E:

C->E30

更新最短权重：

A->D18
A->E40

A->F:

A->F100

当前最短权重为：

A->D18
A->E40
A->F100

由D->F可以得到65，A->D为18，更新权重表：

A->E40
A->F83

由E->F可以得到45，A->E为40，更新权重表：

A->F83

步骤4：

最后就可以得到它的最小权重路径：A->B->D->F:83

代码实现：

import java.util.*;

class Node {
    String name;
    int val;
    Map<String, Node> map;

    public Node(String name, int val) {
        this.name = name;
        this.val = val;
    }

    public Node(String name) {
        this.name = name;
        this.val = val;
    }

    public Node() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public Map<String, Node> getMap() {
        return map;
    }

    public void setMap(Map<String, Node> map) {
        this.map = map;
    }

    public static void main(String[] args) {
        Node A = new Node("A");


        //构建A
        Map<String, Node> map = new HashMap<>();
        map.put("B", new Node("B", 8));
        map.put("F", new Node("F", 100));
        map.put("C", new Node("C", 10));
        A.setMap(map);
        //构建B
        Node B = A.getMap().get("B");
        map = new HashMap<>();
        map.put("D", new Node("D", 10));
        map.put("E", new Node("E", 70));
        B.setMap(map);
        //构建C
        Node C = A.getMap().get("C");
        map = new HashMap<>();
        map.put("E", new Node("E", 30));
        C.setMap(map);
        //构建D
        Node D = A.getMap().get("B").getMap().get("D");
        map = new HashMap<>();
        map.put("F", new Node("F", 65));
        D.setMap(map);
        //构建BE
        Node BE = A.getMap().get("B").getMap().get("E");
        map = new HashMap<>();
        map.put("F", new Node("F", 45));
        BE.setMap(map);
        //构建CE
        Node CE = A.getMap().get("C").getMap().get("E");
        map = new HashMap<>();
        map.put("F", new Node("F", 45));
        CE.setMap(map);

        //记录存值
        Map<String, Integer> DateMap = new HashMap<>();
        //队列
        List<Node> list = new ArrayList<>();
        //获取A节点下的所有节点
        getListNode(list, A);
        //记录A节点下的值（可能A-F就是最短路径）
        int count = list.size();
        //只要列表不为空
        while (list.size() > 0) {
            //每次减一
            --count;
            Node node = list.get(0);
            //获取这个这个节点的子节点
            List<Node> chiNode = new ArrayList<>();
            getListNode(chiNode, node);
            //只记录A到子节点值
            if (DateMap.get("A" + node.getName()) == null && count >= 0) {
                DateMap.put("A" + node.getName(), node.getVal());
            } else if (count >= 0) {
                if (DateMap.get("A" + node.getName()) > node.getVal()) {
                    DateMap.put("A" + node.getName(), node.getVal());
                }
            }
            if (!chiNode.isEmpty()) {
                for (Node n : chiNode) {
                    if (DateMap.get("A" + n.getName()) != null) {
                        if (DateMap.get("A" + n.getName()) > (DateMap.get("A" + node.getName()) + n.getVal())) {
                            DateMap.put("A" + n.getName(), (DateMap.get("A" + node.getName()) + n.getVal()));
                        }
                    } else {
                        //添加值
                        DateMap.put("A" + n.getName(), DateMap.get("A" + node.getName()) + n.getVal());
                        DateMap.put(node.getName() + n.getName(), n.getVal());
                    }
                }
            }
            //获取这个节点下的子节点
            getListNode(list, node);
            //删除
            list.remove(0);
        }
        System.out.println(DateMap.get("AF"));
    }

    public static void getListNode(List<Node> list, Node node) {
        Map<String, Integer> map = new HashMap<>();
        if (node.getMap() != null) {
            //获取这个节点的所有子节点
            for (String name : node.getMap().keySet()) {
                map.put(name, node.getMap().get(name).getVal());
            }
            //排序
            List<Map.Entry<String, Integer>> arrayList = new ArrayList<>(map.entrySet());
            Collections.sort(arrayList, new Comparator<Map.Entry<String, Integer>>() {
                @Override
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }
            });
            //添加节点到末尾
            for (Map.Entry<String, Integer> entry : arrayList) {
                list.add(node.getMap().get(entry.getKey()));
            }
        }
    }


}

再来一个图试试：

import java.util.*;

class Node {
    String name;
    int val;
    Map<String, Node> map;

    public Node(String name, int val) {
        this.name = name;
        this.val = val;
    }

    public Node(String name) {
        this.name = name;
        this.val = val;
    }

    public Node() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public Map<String, Node> getMap() {
        return map;
    }

    public void setMap(Map<String, Node> map) {
        this.map = map;
    }

    public static void main(String[] args) {
        Node A = new Node("A");

        //构建A
        Map<String, Node> map = new HashMap<>();
        map.put("B", new Node("B", 10));
        map.put("D", new Node("D", 20));
        map.put("C", new Node("C", 10));
        A.setMap(map);
        //构建B
        Node B = A.getMap().get("B");
        map = new HashMap<>();
        map.put("F", new Node("F", 5));
        map.put("E", new Node("E", 20));
        B.setMap(map);
        //构建C
        Node C = A.getMap().get("C");
        map = new HashMap<>();
        map.put("F", new Node("F", 20));
        C.setMap(map);
        //构建D
        Node D = A.getMap().get("D");
        map = new HashMap<>();
        map.put("E", new Node("E", 30));
        map.put("G", new Node("G", 100));
        D.setMap(map);

        //构建BE
        Node BE = A.getMap().get("B").getMap().get("E");
        map = new HashMap<>();
        map.put("G", new Node("G", 50));
        BE.setMap(map);
        //构建BF
        Node BF = A.getMap().get("B").getMap().get("F");
        map = new HashMap<>();
        map.put("G", new Node("G", 20));
        BF.setMap(map);

        //构建CF
        Node CF = A.getMap().get("C").getMap().get("F");
        map = new HashMap<>();
        map.put("G", new Node("G", 20));
        CF.setMap(map);

        //构建CE
        Node DE = A.getMap().get("D").getMap().get("E");
        map = new HashMap<>();
        map.put("G", new Node("G", 30));
        DE.setMap(map);


        //记录存值
        Map<String, Integer> DateMap = new HashMap<>();
        //队列
        List<Node> list = new ArrayList<>();
        //获取A节点下的所有节点
        getListNode(list, A);
        //记录A节点下的值（可能A-F就是最短路径）
        int count = list.size();
        //只要列表不为空
        while (list.size() > 0) {
            //每次减一
            --count;
            Node node = list.get(0);
            //获取这个这个节点的子节点
            List<Node> chiNode = new ArrayList<>();
            getListNode(chiNode, node);
            //只记录A到子节点值
            if (DateMap.get("A" + node.getName()) == null && count >= 0) {
                DateMap.put("A" + node.getName(), node.getVal());
            } else if (count >= 0) {
                if (DateMap.get("A" + node.getName()) > node.getVal()) {
                    DateMap.put("A" + node.getName(), node.getVal());
                }
            }
            if (!chiNode.isEmpty()) {
                for (Node n : chiNode) {
                    if (DateMap.get("A" + n.getName()) != null) {
                        if (DateMap.get("A" + n.getName()) > (DateMap.get("A" + node.getName()) + n.getVal())) {
                            DateMap.put("A" + n.getName(), (DateMap.get("A" + node.getName()) + n.getVal()));
                        }
                    } else {
                        //添加值
                        DateMap.put("A" + n.getName(), DateMap.get("A" + node.getName()) + n.getVal());
                        DateMap.put(node.getName() + n.getName(), n.getVal());
                    }
                }
            }
            //获取这个节点下的子节点
            getListNode(list, node);
            //删除
            list.remove(0);
        }
        System.out.println(DateMap.get("AG"));
    }

    public static void getListNode(List<Node> list, Node node) {
        Map<String, Integer> map = new HashMap<>();
        if (node.getMap() != null) {
            //获取这个节点的所有子节点
            for (String name : node.getMap().keySet()) {
                map.put(name, node.getMap().get(name).getVal());
            }
            //排序
            List<Map.Entry<String, Integer>> arrayList = new ArrayList<>(map.entrySet());
            Collections.sort(arrayList, new Comparator<Map.Entry<String, Integer>>() {
                @Override
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }
            });
            //添加节点到末尾
            for (Map.Entry<String, Integer> entry : arrayList) {
                list.add(node.getMap().get(entry.getKey()));
            }
        }
    }


}



        Node A = new Node("A");

        //构建A
        Map<String, Node> map = new HashMap<>();
        map.put("B", new Node("B", 5));
        map.put("C", new Node("C", 2));
        A.setMap(map);
        //构建B
        Node B = A.getMap().get("B");
        map = new HashMap<>();
        map.put("D", new Node("D", 4));
        map.put("E", new Node("E", 2));
        B.setMap(map);
        //构建C
        Node C = A.getMap().get("C");
        map = new HashMap<>();
        map.put("E", new Node("E", 7));
        map.put("B", new Node("B", 8));
        C.setMap(map);

        //构建BE
        Node BE = A.getMap().get("B").getMap().get("E");
        map = new HashMap<>();
        map.put("F", new Node("F", 1));
        BE.setMap(map);
        Node BD = A.getMap().get("B").getMap().get("D");
        map = new HashMap<>();
        map.put("F", new Node("F", 3));
        map.put("E", new Node("E", 6));
        BD.setMap(map);
        Node BDE = A.getMap().get("B").getMap().get("D").getMap().get("E");
        map = new HashMap<>();
        map.put("F", new Node("F", 1));
        BDE.setMap(map);

        //构建CF
        Node CE = A.getMap().get("C").getMap().get("E");
        map = new HashMap<>();
        map.put("F", new Node("F", 1));
        CE.setMap(map);
        Node CB = A.getMap().get("C").getMap().get("B");
        map = new HashMap<>();
        map.put("D", new Node("D", 4));
        map.put("E", new Node("E", 2));
        CB.setMap(map);
        Node CBD = A.getMap().get("C").getMap().get("B").getMap().get("D");
        map = new HashMap<>();
        map.put("F", new Node("F", 3));
        map.put("E", new Node("E", 6));
        CBD.setMap(map);
        Node CBDE = A.getMap().get("C").getMap().get("B").getMap().get("D").getMap().get("E");
        map = new HashMap<>();
        map.put("F", new Node("F", 1));
        CBDE.setMap(map);
        Node CBE = A.getMap().get("C").getMap().get("B").getMap().get("E");
        map = new HashMap<>();
        map.put("F", new Node("F", 1));
        CBE.setMap(map);

 

OK~迪克斯特拉算法的实现！！！！

蛇皮皮蛋
关注
专栏目录
算法之狄克斯特拉算法
Gaodes的博客
08-25 272
【算法定义】 是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪克斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 【算法图示】 【程序设计】 /********************************************************************************* *Function: Di...
c语言实现迪克斯特拉算法
qq_41516983的博客
03-27 3686
#用c语言实现迪克斯特拉算法 求最短路已有成熟的算法，如迪克斯特拉算法，其思想就是从按距离从近到远，依次求得到各个顶点的最短距离。 首先，构建结构体，其代码如下： struct Dijkstra { int w[Maxsize][Maxsize]; //权重距离矩阵 int l[Maxsize]; //依次求得各点到起点的最短距离 int s;
7、迪克斯特拉算法
weixin_34220834的博客
04-30 230
7、狄克斯特拉算法 　　　　加权图——提高或降低某些边的权重。 　　　　广度优先搜索——找出的是段数最少的路径。如果你要找出最快的路径，可使用另一种算法——狄克斯特拉算法（Dijkstra's algorithm）。 　　　　狄克斯特拉算法用于每条边都有关联数字的图，这些数字称为权重（weight）。 　　　　带权重的图称为加权图（weighted graph），不带权重的图称为非加权图（...
Dijkstra算法(附代码理解)
最新发布
LIUMAO99的博客
08-13 907
在每一步中，算法都会选择一个尚未被访问的顶点，该顶点到源点的距离是已知的最短路径长度，然后更新与其直接相连的未被访问顶点的最短路径估计值.与其他算法结合：在需要处理大规模图或有特殊需求的场景下，可以考虑将Dijkstra算法与其他算法结合使用，例如A*搜索算法，通过引入启发式信息来提高效率。遍历当前顶点的所有邻接顶点，计算经过当前顶点到达邻接顶点的距离，如果该距离小于邻接顶点当前的最短路径估计值，则更新该估计值。图的稠密度：在稀疏图中，算法性能较好，因为邻接列表的使用减少了不必要的访问。
迪克斯特拉算法
qq_18230813的博客
07-31 2210
求最短路已有成熟的算法：迪克斯特拉（Dijkstra）算法，其基本思想是按距从近到远为顺序，依次求得到的各顶点的最短路和距离，直至（或直至的所有顶点），算法结束。为避免重复并保留每一步的计算信息（因此效率并不高），采用了标号算法。下面是该算法。 算法结束时，从u0到各顶点v的距离由的最后一次的标号给出。在v进入si之前的标号l(v)叫T标号，v进入si时的标号l(v)叫P标号。算法就
matlab迪克斯特拉算法的程序.zip
04-18
迪克斯特拉算法是计算机科学中的一个重要算法，用于在加权无环图中寻找从一个特定源节点到所有其他节点的最短路径。这个算法由艾兹格·迪克斯特拉在1956年提出，是解决单源最短路径问题的有效方法。在MATLAB中实现...
Dijkatra_matlab；迪克斯特拉算法_
09-29
迪克斯特拉算法（Dijkstra's Algorithm）是一种用于在加权图中寻找单源最短路径的算法，由荷兰计算机科学家艾兹格·迪克斯特拉提出。在MATLAB环境中，我们可以利用其强大的矩阵运算能力来高效实现这个算法。下面我们...
算法图解-迪克斯特拉算法
Pathfinder B.Lodestar的博客
10-28 1672
迪克斯特拉算法步骤： 1.找出“最便宜”的节点，即可在最短时间内到达的节点 2.更新该节点的邻居节点的开销（以便于之后的循环） 3.重复这个过程，直至对图中的每个节点都这样做了 4.计算最终路径 注意点： 1.计算非加权图中的最短路径，可以使用广度优先搜索。计算加权图中的最短路径，可使用迪克斯特拉算法。 2.迪克斯特拉算法只适用于有向无环图 3.如果有负权边，那么就不能使用迪克斯特拉算法，这个时候...
迪克斯特拉算法讲解
07-03
一个经典算法，对大家很有用吧Dijkstra算法是典型最短路算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。
地杰特斯拉算法
04-25
地杰特斯拉算法程序示例，备注详细，编程语言简单实用
狄克斯特拉(Dijkstra)算法详解
热门推荐
Wopelo的博客
06-26 3万+
最近在看《算法图解》，其中第七章狄克斯特拉算法个人感觉并没有讲的清楚，比如看完7.1节给人的感觉是狄克斯特拉算法会遍历图中的每一条边，后续狄克斯特拉不适用负权边的说法就站不住脚了。后续在查阅诸多资料之后，总结文章一篇，尽可能以通俗易懂且思路清晰的方式来讲解狄克斯特拉算法。...
狄克斯特拉算法
X_gyzs的博客
04-24 344
一、简介 是从一个顶点到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止 二、步骤 (1) 找出“最便宜”的节点，即可在最短时间内到达的节点。 (2) 更新该节点的邻居的开销，其含义将稍后介绍。 (3) 重复这个过程，直到对图中的每个节点都这样做了。 (4) 计算最终路径。 三、图解 上图中包括5个节点，箭头表示方向，线上的数字表示消耗时间。 首先根据上图做出一个初始表(父节点代表从哪个节点到达该节点)： 然后从“起点”开始，
迪克斯特拉算法是不是遗传算法
06-21
迪克斯特拉(Dijkstra's Algorithm)是一种用于...简单来说，迪克斯特拉算法是用来求解单源最短路径问题，而遗传算法则是用于解决全局优化问题如组合优化、机器学习中的参数搜索等。两者在应用场景和算法原理上完全不同。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值