图的单源最短路径问题

已于 2024-05-07 22:39:33 修改
阅读量372 收藏 9
点赞数 5
分类专栏： 编程题刷题录 文章标签： 算法
于 2024-03-09 20:41:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62525547/article/details/136590135
版权

目录

一、简述

二、前置配置

三、迪杰斯特拉算法

四、改进的迪杰斯特拉算法

五、贝尔曼福特算法

一、简述

        图是一种比较常用的数据结构，将问题转换成图相关的思路也是比较常用的。

        图的单源最短路径问题，也就是图中某一个节点到图中其他节点的最短路径大小，常用的算法就是迪杰斯特拉算法和贝尔曼福特算法，两者是从不同的角度来对这个问题进行分析的，但是迪杰斯特拉算法并不适用于有负权重的情况，而贝尔曼福特算法则是应用范围更广泛，能解决带有负权重问题的场景。

二、前置配置

        边类：

package graph;

/**
 * 边类
 */
public class Edge {
    Vertex vertex;
    int weight;

    public Edge() {
    }

    public Edge(Vertex vertex) {
        this.vertex = vertex;
    }

    public Edge(Vertex vertex, int weight) {
        this.vertex = vertex;
        this.weight = weight;
    }

    public Vertex getVertex() {
        return vertex;
    }

    public void setVertex(Vertex vertex) {
        this.vertex = vertex;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

        结点类：

package graph;

import java.util.List;

/**
 * 顶点类
 */
public class Vertex {
    String name;
    List<Edge> edges;
    boolean flag;//是否被访问过
    int inDegree;//结点的入度

    int status;//状态, 0-未访问过， 1-正在访问，用于检测环，2-已经访问过

    int dist=Integer.MAX_VALUE;//距离

    Vertex pre=null;

    public Vertex() {
    }

    public Vertex(String name, List<Edge> edges) {
        this.name = name;
        this.edges = edges;
    }

    public Vertex(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public List<Edge> getEdges() {
        return edges;
    }

    public void setEdges(List<Edge> edges) {
        this.edges = edges;
    }
}

三、迪杰斯特拉算法

        迪杰斯特拉算法是从节点出发来完成单源最短路径问题的，我们可以将整个图分为两个区域，一个区域就是已经找到从源点到该点的最短路径，另一个区域则是未找到的。

        从已经找到的区域到未找到的区域的所有相连节点的边，从中取最小值，并将该边所对应的未找到区域的结点加入到已经找到找到的区域，并更改其最短路径。

        最后，通过将所有联通的结点的最短路径找到，即可结束。

        代码：

package graph;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Dijkstra {
    public static void main(String[] args) {
        Vertex v1=new Vertex("v1",new LinkedList<>());
        Vertex v2=new Vertex("v2",new LinkedList<>());
        Vertex v3=new Vertex("v3",new LinkedList<>());
        Vertex v4=new Vertex("v4",new LinkedList<>());
        Vertex v5=new Vertex("v5",new LinkedList<>());
        Vertex v6=new Vertex("v6",new LinkedList<>());

        v1.edges.add(new Edge(v3,9));
        v1.edges.add(new Edge(v2,7));
        v1.edges.add(new Edge(v6,14));

        v2.edges.add(new Edge(v4,15));

        v3.edges.add(new Edge(v4,11));
        v3.edges.add(new Edge(v6,2));

        v4.edges.add(new Edge(v5,6));

        v6.edges.add(new Edge(v5,9));

        List<Vertex> graph=new ArrayList<>();
        graph.add(v1);
        graph.add(v2);
        graph.add(v3);
        graph.add(v4);
        graph.add(v5);
        graph.add(v6);

        dijkstra(graph,v1);
    }

    private static void dijkstra(List<Vertex> graph,Vertex vertex) {
        ArrayList<Vertex> list=new ArrayList<>(graph);
        vertex.dist=0;
        while(!list.isEmpty()){
            //选取当前顶点(距离最小的顶点)
            Vertex curr=chooseMinDistVertex(list);
            //更新当前顶点邻居距离
            updateNeighboursDist(curr,list);
            //移除当前节点
            list.remove(curr);
        }
        for (Vertex vertex1 : graph) {
            System.out.println(vertex1.name+"  "+vertex1.dist +"  "+(vertex1.pre==null?"null":vertex1.pre.name));
        }
    }

    private static void updateNeighboursDist(Vertex curr, ArrayList<Vertex> list) {
        for (Edge edge : curr.edges) {
            Vertex n=edge.vertex;
            if(list.contains(n)){
                int dist= curr.dist+edge.weight;
                if(dist<n.dist){
                    n.dist=dist;
                    n.pre=curr;
                }
            }
        }
    }

    private static Vertex chooseMinDistVertex(ArrayList<Vertex> list) {
        Vertex min=list.get(0);
        for(int i=0;i<list.size();i++){
            if(list.get(i).dist<min.dist){
                min=list.get(i);
            }
        }
        return min;
    }
}

四、改进的迪杰斯特拉算法

        我们发现每次寻找最小值的时候都需要遍历整个集合，时间复杂度为O(n)，因此，我们可以用优先队列来解决，优先队列会自动将优先级别高的排在前面，所以，我们只需要将其设置为边的权重越小优先级越高即可，每次只需要取出队首元素即可，时间复杂度为O(1)。

        代码：

package graph;

import java.util.*;

/**
 * 第二种算法的实现：采用优先级队列，减少选取最小距离时的时间复杂度，使用优先级队列直接获取头部元素
 * 时间复杂度得到了改善
 */
public class DijkstraTwo {
    public static void main(String[] args) {
        Vertex v1=new Vertex("v1",new LinkedList<>());
        Vertex v2=new Vertex("v2",new LinkedList<>());
        Vertex v3=new Vertex("v3",new LinkedList<>());
        Vertex v4=new Vertex("v4",new LinkedList<>());
        Vertex v5=new Vertex("v5",new LinkedList<>());
        Vertex v6=new Vertex("v6",new LinkedList<>());

        v1.edges.add(new Edge(v3,9));
        v1.edges.add(new Edge(v2,7));
        v1.edges.add(new Edge(v6,14));

        v2.edges.add(new Edge(v4,15));

        v3.edges.add(new Edge(v4,11));
        v3.edges.add(new Edge(v6,2));

        v4.edges.add(new Edge(v5,6));

        v6.edges.add(new Edge(v5,9));

        List<Vertex> graph=new ArrayList<>();
        graph.add(v1);
        graph.add(v2);
        graph.add(v3);
        graph.add(v4);
        graph.add(v5);
        graph.add(v6);

        dijkstra(graph,v1);
    }

    private static void dijkstra(List<Vertex> graph,Vertex vertex) {
        PriorityQueue<Vertex> queue=new PriorityQueue<>(Comparator.comparing(v->v.dist));//优先级队列,按照距离来升序排列
        for (Vertex vertex1 : graph) {
            queue.offer(vertex1);
        }
        vertex.dist=0;
        while(!queue.isEmpty()){
            //选取当前顶点(距离最小的顶点)
            Vertex curr=queue.peek();
            //更新当前顶点邻居距离
            updateNeighboursDist(curr,queue);
            //移除当前节点
            queue.poll();
            curr.flag=true;
        }
        for (Vertex vertex1 : graph) {
            System.out.println(vertex1.name+"  "+vertex1.dist +"  "+(vertex1.pre==null?"null":vertex1.pre.name));
        }
    }

    private static void updateNeighboursDist(Vertex curr, PriorityQueue<Vertex> queue) {
        for (Edge edge : curr.edges) {
            Vertex n=edge.vertex;
            if(queue.contains(n)){
                int dist= curr.dist+edge.weight;
                if(dist<n.dist){
                    n.dist=dist;
                    n.pre=curr;
                    queue.offer(n);
                }
            }
        }
    }
}

五、贝尔曼福特算法

        贝尔曼福特算法是以边为元素来考虑的，每次从所有边中，找出最小的，并尝试更改边两边结点的最短距离，如果小于原先值就修改，否则就不变。

        算法需要执行（边数-1）次，每次对所有的边上的进行尝试更改。

        代码：

package graph;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * 迪杰斯特拉算法不适合存在负值边的情况，
 * 而贝尔曼福特算法能够解决这种问题，是以边为元素来处理的
 */
public class BellmanFord {
    public static void main(String[] args) {
        Vertex v1=new Vertex("v1",new LinkedList<>());
        Vertex v2=new Vertex("v2",new LinkedList<>());
        Vertex v3=new Vertex("v3",new LinkedList<>());
        Vertex v4=new Vertex("v4",new LinkedList<>());
        Vertex v5=new Vertex("v5",new LinkedList<>());
        Vertex v6=new Vertex("v6",new LinkedList<>());

        v1.edges.add(new Edge(v3,9));
        v1.edges.add(new Edge(v2,7));
        v1.edges.add(new Edge(v6,14));

        v2.edges.add(new Edge(v4,15));

        v3.edges.add(new Edge(v4,11));
        v3.edges.add(new Edge(v6,2));

        v4.edges.add(new Edge(v5,6));

        v6.edges.add(new Edge(v5,9));

        List<Vertex> graph=new ArrayList<>();
        graph.add(v1);
        graph.add(v2);
        graph.add(v3);
        graph.add(v4);
        graph.add(v5);
        graph.add(v6);

        bellmanFord(graph,v1);
    }

    private static void bellmanFord(List<Vertex> graph, Vertex v1) {
        v1.dist=0;
        int size=graph.size();
        for(int i=0;i<size-1;i++){//循环边数-1次，找出除了根节点外的其他节点
            //遍历所有的边
            for (Vertex s : graph) {
                for (Edge edge : s.edges) {
                    //处理每一条边
                    Vertex e = edge.vertex;
                    if(s.dist!=Integer.MAX_VALUE && s.dist+edge.weight<e.dist){
                        e.dist=s.dist+edge.weight;
                    }
                }
            }
        }
        for (Vertex vertex : graph) {
            System.out.println(vertex.name+" "+vertex.dist);
        }
    }
}
顾城猿
关注
专栏目录
图的单源最短路径（Dijkstra算法）
ChanCherry的博客
05-17 1733
Dijkstra算法思想 带权图的最短路径 从某顶点（源点）出发到另一顶点（目的点）的路径中，有一条各边（或弧）权值之和最小的路径称为最短路径。 从单源点到其余各点的最短路径——迪杰斯特拉算法（Dijkstra） 每一对顶点之间的最短路径——弗洛伊德算法（Floyd） Dijkstra算法 基本思想：依最短路径的长度递增的次序求得各条路径。 路径长度最短的最短路径的特点：在这条路径上，必定只含一条弧，并且这条弧的权值最小。（设为v0→vK） 下一条路径长度次短的最短路径的特点： 它只可能有两种情况：或者
最短路径问题——单源最短路径问题
m0_56945100的博客
08-24 422
根据结点的拓扑排序次序来对有向无环图进行边的松弛操作（由于无环，则负环路肯定不存在）。每次松弛从当前结点出发的所有边。伪代码：邻接表存储：；邻接矩阵存储：。
其它高阶数据结构③_图的最短路径（三种算法思想+代码实现）
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
05-16 971
其它高阶数据结构③_图的最短路径（三种算法思想+代码实现）（Dijkstra算法（迪杰斯特拉算法）+Bellman-Ford（贝尔曼-福特算法）+Floyd-Warshall（弗洛伊德算法））
【数据结构/C语言版】【图】单源最短路径 Dijkstra
智子的博客
12-09 821
Dijkstra 迪杰斯特拉算法 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法(单源最短路)。 迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 朴素Dijkstra时间复杂度o(n^2)。 优先队列优化Dijkstra时间复杂度为 o(m log n)。 测试数据 1 6 8 1 2 3 4 5 6 1 3 10 1 5 30
无权图单源最短路径问题
calm_encode的博客
11-30 944
一 概述 无权图：即表示图中的边是没有权重的，或者是所有的边权重为同一个正数。 单源：以一个顶点为初始顶点出发，求解该顶点到其他顶点的最短路径。 最短路径：定义从顶点u到顶点v的最短路径d(u，v)为从u到v的任何路径中边数最少的路径。如果从某一顶点u到顶点v没有通路时，则d(u，v) =∞。 二 无权图单源最短路径问题求解过程 先看一个问题：找到从顶点1到顶点5的路径 直观的可以发现图中的路径有1-2-5和1-2-4-5两条路径。其中最短路径为1-2-5。 根据广度优先算法中遍历的都是.
单源最短路径问题
a18173352623的博客
12-11 801
给定一个带权有向图G=(V,E)，其中每条边的权是非负数。给定V中的一个顶点a，成为源。现在要计算从源到所有其他个顶点的最短路径长度，这里路径长度指的是各边权之和。这个问题通常被称作单源最短路径问题。如下图所示，每一边都有一非负权值。求图G中从源点a到t的最短路径。 因为是求单源问题，可以使用四种方法进行求解。 算法的基本思路： 分支界限法主要思想在于，将一个问题分成树状，每次选择最优的一个枝叶。比如单源问题便是每次选择最短路径作为基点去不断更新其他路径。 如何书写代码：朴素版的Dijkstra
用java单源最短路径问题_单源最短路径-贪心算法
weixin_29476357的博客
02-24 566
单源最短路径，关于这个问题的贪心算有点不好理解，分析后续补充，代码也需要后续优化，便于理解package test;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;/*** Created by saishangmingzhu on 2018/12/3.* ...
c语言单源最短路径问题实验报告,单源最短路径问题Dijkstra算法的c语言实现
weixin_42510608的博客
05-18 1326
求单源最短路径是图论中比较基本的问题，通常的Dijkstra算法是按阶段进行的，每个节点标有处理和未处理状态的标记，设立一个数组，每个数组中第i个元素为源节点到第i个节点的最短路径(当然，该数组的初值是依照图赋的，邻接节点赋对应边的权值，其他节点赋无穷大)。在Dijkstra算法的每一个阶段，将未处理的节点放入一个集合S，扫描S中距离最小的一个节点v，将v置为处理状态。然后在剩下的所有未处理节点中...
贪心算法解决单源最短路径问题
cqn2bd2b的博客
12-13 2079
参考教材：算法设计与分析（第3版） 王晓东 编著 清华大学出版社贪心算法总是做出在当前看来最好的选择，也就是说贪心算法并不从整体最优考虑，它所做出的选择只是在某种意义上的局部最优选择。贪心算法的基本要素 1. 贪心选择性质 指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。 这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。 2. 最优子结构性质 当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。 拿单源最短路径当例子，从顶点5到顶点1的最短路径
基于贪心法求解单源最短路径问题.docx
06-03
"基于贪心法求解单源最短路径问题" 本资源是关于基于贪心法求解单源最短路径问题的实验报告，包括实验内容、算法设计、算法描述、算法正确性证明、算法分析、算法实现与测试等部分。 实验目的：理解贪心法的核心...
分支限界法求解单源最短路径.zip
12-21
单源最短路径问题是从一个指定的起点到图中所有其他顶点的最短路径问题，这个问题在图论和计算机科学中有广泛的应用，例如网络路由优化、物流配送路线规划等。 分支限界法通常包括以下几个关键组件： 1. **搜索...
python实现有向图单源最短路径迪杰斯特拉 算法
09-27
迪杰斯特拉（Dijkstra）算法是一种用于寻找有向图中单源最短路径的经典算法，由荷兰计算机科学家艾兹格·迪杰斯特拉在1956年提出。在这个算法中，我们从一个源节点开始，逐步扩展最短路径到其他节点，直到到达所有...
java实现单源最短路径
08-26
"java实现单源最短路径" java实现单源最短路径是使用java...java实现单源最短路径是一种常用的图算法，能够快速计算单源最短路径，适合大规模图的计算。但是，需要注意计算复杂度较高的问题。 "java实现单源最短路径
动态规划求单源最短路径.doc
11-23
算法设计与分析课内实验——动态规划求单源最短路径。文档很齐全，包括算法分析过程和源代码（java语言eclipse环境）
【C++算法】8.双指针_四数之和
hlyd520的博客
10-04 602
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 408
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
c语言练习题2(字符串和函数的使用)
最新发布
m0_74859128的博客
10-10 115
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 825
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值