有向图中的最短路径

最新推荐文章于 2024-02-23 10:00:00 发布
最新推荐文章于 2024-02-23 10:00:00 发布
阅读量3.2k 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 有向图最短路径
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haiboself/article/details/52108555
版权
性质：
     1：图是有向的。2：并不是所有顶点都可达。3：负权会使问题边复杂。 4: 最短路径没有环。最短路径不唯一。
表示加权有向图的基本类：
   package WeiDigraph;
//加权由向图的边
public class DirectedEdge {
    private final int v;
    private final int w;
    private final double weight;

    public DirectedEdge(int v,int w,double weight){
        this.v = v; this.w = w; this.weight = weight;
    }

    public String toString(){
        return String.format("%d->%d %.2f",v,w,weight);
    }

    public int form() {
        return v;
    }

    public int to() {
        return w;
    }

    public double getWeight() {
        return weight;
    }
}
import java.util.ArrayList;
//加权有向图
public class EdgeWeightedDigraph {
    private final int v;
    private int E;
    private ArrayList<ArrayList<DirectedEdge>> adj;

    public EdgeWeightedDigraph(int V){
        this.v = V;
        this.E = 0;

        adj = new ArrayList<>();
        for(int i=0;i<V;i++){
            adj.add(new ArrayList<DirectedEdge>());
        }
    }

    public void addEdge(DirectedEdge e){
        adj.get(e.form()).add(e);
        E++;
    }

    public ArrayList<DirectedEdge> adj(int v){
        return adj.get(v);
    }

    //返回所有边 
    public ArrayList<DirectedEdge> edges(){
        ArrayList<DirectedEdge> bag = new ArrayList<>();
        for(int i=0;i<v;i++){
            for(DirectedEdge e : adj.get(i))
                bag.add(e);
        }

        return bag;
    }
}

单源最短路径：
    松弛技术 
       边的松弛：放松边v-->w意味着：检查从s到w的最短路径是否是先从s到v，然后再由v到w。如果是，则根据情况更新数据结构的内容。
        顶点的松弛 ：实现会放松从一个给定顶点指出的所有边。

    Dijkstra算法: (可以有环,不饿处理负权)类似与Prim算法,将图分为两部分,T:已经找到最短路径的定点 W: 还未找到最短路径的顶点.
        每次选择W中离起点最近的顶点加入T, 直到所有起点可达的顶点都被加入到T中.

import java.util.PriorityQueue;
import NoWeight.*;
//迪杰特斯拉单源最短路径算法算法,权值不能为负
public class DijkstraSP {
    private DirectedEdge[] edgeTo;
    private double[] disTo;
    private PriorityQueue<ToPoint> pq;

    public DijkstraSP(EdgeWeightedDigraph G,int s){
        edgeTo = new DirectedEdge[G.getV()];
        disTo = new double[G.getV()];
        pq = new PriorityQueue<>(G.getV());

        for(int i=0;i<G.getV();i++)
            disTo[i] = Double.POSITIVE_INFINITY;
        disTo[s] = 0.0;

        pq.add(new ToPoint(s,0.0));
        while(!pq.isEmpty())
            relax(G,pq.poll().v);
    }

    private void relax(EdgeWeightedDigraph G, int v) {//每次对新加入的节点进行松弛,保证树到非树顶点为当前情况下的最短
        for(DirectedEdge e : G.adj(v)){                //路径
            int w = e.to();
            if(disTo[w] > disTo[v] +e.getWeight()){
                disTo[w] = disTo[v] + e.getWeight();
                edgeTo[w] = e;

                pqContains(w);//如果横切边中已经有到顶点w的横切边,删除,以便插入新的到w权值更小的横切边 
                pq.add(new ToPoint(w,e.getWeight()));
            }
        }
    }

    //判断横切边是否已经有到顶点w的横切边,有则删除
    private void pqContains(int w) {
        for(ToPoint ele : pq){
            if (ele.v == w) {
                pq.remove(ele);
                return;
            }
        }
    }
}
给定两点间的最短路径:
     无环加权有向图的最短路径算法: 只要将顶点的放松和拓扑排序结合起来,就可以解决无环加权有向图中的最短路径问题.  按照拓扑顺序放松顶点即可.
    求无环加权有向图中的最长路径 : 将原始的图中的所有的边的权值取反即可. 这样求出的最短路径就是原图的最长路.
     import Digraph.Digraph;
import Digraph.Topological;

// 无环加权有向图的最短路径算法: 只要将顶点的放松和拓扑排序结合起来,就可以解决无环加权有向图中的最短路径问题.
public class AcyclicSP {
    private DirectedEdge[] edgeTo;
    private double[] distTo;

    public AcyclicSP(EdgeWeightedDigraph G,int s){
        edgeTo = new DirectedEdge[G.getV()];
        distTo = new double[G.getV()];

        for(int i=0;i<G.getV();i++){
            distTo[i] = Double.POSITIVE_INFINITY;
        }
        distTo[s] = 0;

        Topological top = new Topological(G);

        for(int v  : top.order())
            relax(G,v);
    }

    //顶点放松    
    private void relax(EdgeWeightedDigraph G, int v) {
        for(DirectedEdge edge : G.adj(v)){
            int w = edge.to();
            if(distTo[w] > distTo[v] + edge.getWeight()){
                distTo[w] = distTo[v] + edge.getWeight();
                edgeTo[w] = edge;
            }
        }
    }

}
并行任务调度:
     优先级线之下的并行任务调度: 建立一个加权有向无环图, 然后用求最长路径算法解决.
      相对于最后期限下的并行任务调度是一个加权有向图中的最短路径问题.

 含有负权重的图中的最短路径:
    加权有向图中的负权重环是一个总权重为负的环. 在负权重环存在的情况下,最短路径问题没有意义,因为可以构造任意短的路径.
     所以定义的算法应该:
        (1)对于起点不可达的顶点，最短路径为正无穷。
        (2)对于起点不可达但路径上某顶点属于一个负权环的顶点，最短路径为负无穷；
        (3)对于其他顶点，计算最短路径树。

    Bellman-Ford算法：以任意顺序放松有向图的所有边，重复V轮。
    基于队列的Bellman-Ford算法： 只有上一轮中的distTo[]发生变化的顶点指出的边才能够改变其他distTo[]元素的值。 在将所有边放松V轮之后当且仅当队列非空时有向图中才存在从起点可达的负权重环。
import java.util.LinkedList;
//  Bellman-Ford算法：以任意顺序放松有向图的所有边，重复V轮。
//基于队列的Bellman-Ford算法;
public class BellmanFordSP {
    private double[] distTo;    //从起点到某个顶点的路径长度
    private DirectedEdge[] edgeTo;    //从起点到某个顶点的最后一条边
    private boolean[] onQ;    //该顶点是否在队列中
    private LinkedList<Integer> queue;    //正在被放松的顶点
    private int cost;    //relax()的调用次数
    private Iterable<DirectedEdge> cycle; //edgeTo[]中是否有负环权重

    public BellmanFordSP(EdgeWeightedDigraph G,int s){
        distTo = new double[G.getV()];
        edgeTo = new DirectedEdge[G.getV()];
        onQ = new boolean[G.getV()];
        queue = new LinkedList<>();

        for(int i=0;i<G.getV();i++){
            distTo[i] = Double.POSITIVE_INFINITY;
        }
        distTo[s] = 0.0;

        queue.add(s);
        onQ[s] = true;

        while(!queue.isEmpty() && !hasNegativeCycle()){
            int v = queue.pollFirst();
            onQ[v] = false;
            relax(G,v);
        }
    }

    //放松边
    private void relax(EdgeWeightedDigraph G, int v) {
        for(DirectedEdge e : G.adj(v)){
            int w = e.to();
            if(distTo[w] > distTo[v] + e.getWeight()){//只有上一轮中的distTo[]发生变化的顶点指出的边才能够改变其他distTo[]元素的值
                distTo[w] = distTo[v] + e.getWeight();
                edgeTo[w] = e;

                if(!onQ[w]){
                    queue.add(w);
                    onQ[w] = true;
                }
            }
            if(cost++ % G.getV() == 0)//存在负权环在将所有边放松V轮之后当且仅当
                //队列非空时有向图中才存在从起点可达的负权重环。
                findNegativeCycle();
        }
    }

    //找出负权环,用distTo[]构造一个加权有向图，然后找出其中的环
    private void findNegativeCycle() {
        int V = edgeTo.length;
        EdgeWeightedDigraph spt = new EdgeWeightedDigraph(V);

        for(int v=0;v<V;v++){
            if(edgeTo[v] != null)
                spt.addEdge(edgeTo[v]);
        }

        EdgeWeightedCycleFinder cf = new EdgeWeightedCycleFinder(spt);

        cycle = cf.cycle();
    }

    //是否存在负权环
    private boolean hasNegativeCycle() {
        return cycle != null;
    }
}
import java.util.LinkedList;
//  Bellman-Ford算法：以任意顺序放松有向图的所有边，重复V轮。
//基于队列的Bellman-Ford算法;
public class BellmanFordSP {
    private double[] distTo;    //从起点到某个顶点的路径长度
    private DirectedEdge[] edgeTo;    //从起点到某个顶点的最后一条边
    private boolean[] onQ;    //该顶点是否在队列中
    private LinkedList<Integer> queue;    //正在被放松的顶点
    private int cost;    //relax()的调用次数
    private Iterable<DirectedEdge> cycle; //edgeTo[]中是否有负环权重

    public BellmanFordSP(EdgeWeightedDigraph G,int s){
        distTo = new double[G.getV()];
        edgeTo = new DirectedEdge[G.getV()];
        onQ = new boolean[G.getV()];
        queue = new LinkedList<>();

        for(int i=0;i<G.getV();i++){
            distTo[i] = Double.POSITIVE_INFINITY;
        }
        distTo[s] = 0.0;

        queue.add(s);
        onQ[s] = true;

        while(!queue.isEmpty() && !hasNegativeCycle()){
            int v = queue.pollFirst();
            onQ[v] = false;
            relax(G,v);
        }
    }

    //放松边
    private void relax(EdgeWeightedDigraph G, int v) {
        for(DirectedEdge e : G.adj(v)){
            int w = e.to();
            if(distTo[w] > distTo[v] + e.getWeight()){//只有上一轮中的distTo[]发生变化的顶点指出的边才能够改变其他distTo[]元素的值
                distTo[w] = distTo[v] + e.getWeight();
                edgeTo[w] = e;

                if(!onQ[w]){
                    queue.add(w);
                    onQ[w] = true;
                }
            }
            if(cost++ % G.getV() == 0)//存在负权环在将所有边放松V轮之后当且仅当
                //队列非空时有向图中才存在从起点可达的负权重环。
                findNegativeCycle();
        }
    }

    //找出负权环,用distTo[]构造一个加权有向图，然后找出其中的环
    private void findNegativeCycle() {
        int V = edgeTo.length;
        EdgeWeightedDigraph spt = new EdgeWeightedDigraph(V);

        for(int v=0;v<V;v++){
            if(edgeTo[v] != null)
                spt.addEdge(edgeTo[v]);
        }

        EdgeWeightedCycleFinder cf = new EdgeWeightedCycleFinder(spt);

        cycle = cf.cycle();
    }

    //是否存在负权环
    private boolean hasNegativeCycle() {
        return cycle != null;
    }
}

登徒梦
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最短路径算法---有向图
weixin_41563161的博客
03-01 7000
最短路径算法---有向图、 算法实现思路 拓扑排序，其实就是寻找一个入度为0的顶点，该顶点是拓扑排序中的第一个顶点序列，将之标记删除，然后将与该顶点相邻接的顶点的入度减1，再继续寻找入度为0的顶点，直至所有的顶点都已经标记删除或者图中有环。 从上可以看出，关键是寻找入度为0的顶点。 一种方式是遍历整个图中的顶点，...
图的最短路径
乘风破浪Now 的博客
08-24 704
最短路径的常用解法有迪杰斯特拉算法（Dijkstra Algorithm）、弗洛伊德算法（Floyd-Warshall Algorithm）和贝尔曼福特算法（Bellman-Ford Algorithm）。其中，Floyd算法是多源最短路径算法，即求任意点到任意点的最短路径，而Dijkstra算法和Bellman-Ford算法是单源最短路径算法，即单个点到单个点的最短路径。这三种算法还有一点不同，...
有向图的最短路径算法(Dijkstra+BellmanFord+Floyd)
cj1561435010的博客
03-13 7864
一、最短路径简介        所谓最短路径问题是指：如果从图中某一顶点（源点）到达另一顶点（终点）的路径可能不止一条，如何找到一条路径使得沿此路径上各边的权值总和（称为路径长度）达到最小。        路径规划就是最短路径的典型应用。 二、Dijk...
简单介绍迪杰斯拉Dijkstra算法步骤
Mintary的博客
11-12 2149
将所有顶点分成两个集合， 一个是已选顶点集合，一个是未选顶点集合。并通过不断更新三个列表结点信息，实现这两个集合间的不断转化。第一个列表(Nodes Visited)存储结点是否已被访问的信息，已被访问为True未被访问为False,初始状态都是False,从起点出发到每个结点的距离信息存放在第二个列表(Distance)中，初始状态都为无穷大。第三个列表存储每个结点被访问时的父系结点信息(Parent).两点确定一条边，-1表示一条不存在的边。 Update，当向已选顶点集合中加入一个新的结点则在未选
求有向图的最短路径
sensern的博客
11-25 2394
递归 深度搜索 最短路 图
【数据结构】图——最短路径
努力进大厂的小码娄
02-23 2866
迪杰斯特拉算法是基于贪心算法设计，解决非负数权值的路径问题。贝尔曼福特算法是暴力求解，能求解出带负权值的路径，能判断负权环路。是一个时间复杂度为o(N^3)的算法。要进行K次松弛调整。费洛伊徳算法是动态规划的思想，将路径分为i->k k->j的思想。同样要进行K轮次的更新。复杂度为0(N^3)。能够求解任意俩顶点的最短路径。
最短路径(加权有向图)
一名小白的博客
08-28 4629
最短路径 1. 最短路径定义以及性质 定义： 在一副加权有向图中，从顶点s到顶点t的最短路径是所有从顶点s到顶点t的路径中总权重最小的那条路径。 性质： 路径具有方向性。 权重不一定等于距离。权重可以是距离、时间、花费等内容，权重最小指的是成本最低。 只考虑连通图。一副图中并不是所有的顶点都是可达的，如果s和t不可达，那么它们之间也就不存在最短路径，所以只考虑连通图。 最短路径不一定是唯一的。从一个顶点到达另外一个顶点的权重最小的路径可能会有很多条，所以只需要找出一条即可。 最短路径树： 给定一副加权
python实现有向图单源最短路径迪杰斯特拉 算法
09-27
迪杰斯特拉（Dijkstra）算法是一种用于寻找有向图中单源最短路径的经典算法，由荷兰计算机科学家艾兹格·迪杰斯特拉在1956年提出。在这个算法中，我们从一个源节点开始，逐步扩展最短路径到其他节点，直到到达所有...
有向图中简单路径计数及最短路径最长路径的输出
11-16
在这个问题中，我们将深入探讨如何在有向图中计算简单路径的数量，以及如何找到图中的最短路径和最长路径。 首先，我们需要理解有向图的基本概念。有向图是由节点（也称为顶点）和有向边组成的。每条边都有明确的...
zuiduanlujing.rar_图中最短路径
09-19
这个问题定义为：给定一个带权重的有向图，以及一个特定的起点（源点），我们需要找出从这个源点到图中所有其他顶点的最短路径。这里的“最短”通常指的是路径的权重之和最小，权重可以代表距离、成本、时间等。 ...
matlib.zip_dijkstra_图的最短路径_有向图_有向图 最短路径
09-21
总之，Dijkstra算法是解决有向图最短路径问题的重要工具，其MATLAB实现可以帮助我们快速地在这样的图中找到最优路径。对于学习和研究图论、网络科学或者优化问题的人员来说，理解和掌握这个算法是非常有价值的。
java 无向图所有最短路径算法的实现
04-19
最短路径问题是一个经典的问题，寻找无向图中的最短路径有着广泛的应用，比如路由选择、网络优化等。本项目以Java语言实现了求解无向图所有最短路径的算法。 1. **Dijkstra算法** Dijkstra算法是最常用的单源最短...
LeetCode基础-图-有向图-最短路径
gnimgnot
11-09 7535
最短路径：从图中的一个顶点到另一个顶点的成本最小的路径。 单点最短路径：在加权有向图中，给出一个起点 s，找到是否有一条到顶点 v 的路径，如果有，找出权重最小的那条。最短路径的性质： 路径是有向的。 权重不定表示距离。 并不是所有顶点都是可达的。 负权重会使问题变复杂。 最短路径一般都是简单的（不含零权重边的环）。 最短路径不定是唯一的。 可能存在平行边和自环。平行边中权重最小的才会被选中。也
0401概述-最短路径-加权有向图-数据结构和算法(Java)
gaogzhen的博客
04-25 1453
0401概述-最短路径-加权有向图-数据结构和算法(Java)
数据结构与算法——图最短路径
热门推荐
程序员吴师兄的博客
04-16 1万+
1 引言  最短路径问题一直是图论研究的热点问题。例如在实际生活中的路径规划、地图导航等领域有重要的应用。关于求解图的最短路径方法也层出不穷，本篇文章将详细讲解图的最短路...
算法——有向图的最短路径算法
weixin_45927758的博客
06-20 3375
建议学习最短路径算法时，观看这个视频 https://www.bilibili.com/video/BV1q4411M7r9?from=search&seid=9662298119837732890 Dijkstra算法 //有向图 #include<iostream> #include<vector> #include<queue> #include<climits> using namespace std; //边表节点 typedef .
有向图最短路径的Dijsktra算法
qq_58158487的博客
01-11 994
1)包含任务或问题描述和分析 如果存在一条从i到j的最短路径(Vi.....Vk,Vj)，Vk是Vj前面的一顶点。那么(Vi...Vk)也必定是从i到k的最短路径。为了求出最短路径，Dijkstra就提出了以最短路径长度递增，逐次生成最短路径的算法。譬如对于源顶点V0，首先选择其直接相邻的顶点中长度最短的顶点Vi，那么当前已知可得从V0到达Vj顶点的最短距离dist[j]=min{dist[j],dist[i]+matrix[i][j]}。根据这种思路， 假设存在G=<V,E>，源顶点为V0
数据结构-考研难点代码突破（C++实现有向图最短路径算法（Dijkstra，Floyd-Warshall算法）图解操作细节（引自C语言中文网））
dodamce的博客
01-03 2406
在表 1 的基础上，将顶点 1 作为 “中间顶点”，计算从各个顶点出发途径顶点 1 再到达其它顶点的权值，如果比表 1 中记录的权值更小，证明两个顶点之间存在更短的路径，对表 1 进行更新。当图是带权图时，把从一个顶点a到图中其余任意一个顶点x的一条路径（可能不止一条）所经过边上的权值之和，定义为该路径的带权路径长度，把带权路径长度最短的那条路径称为最短路径.初始化默认值（无穷）3-2-1：权值为 1 + 2 = 3，表 1 中 3-1 的权值为 ∞，3 < ∞；
无向图dfs判断是否有环和是否二分图
静无需言
07-12 5169
1:判断无向图是否有环: 如果图g有环，用dfs遍历图g，会访问到已经访问过的顶点。 2:判断无向图是否为二分图：利用gfs遍历图给图上色（2种颜色），然后判断上色顶点间是否冲突。若冲突，则为非二分图。 package Graph; import java.util.ArrayList; import java.util.LinkedList; public class Gra
python有向图最短路径
最新发布
05-11
在Python中，可以使用networkx库来实现有向图的最短路径。这个库提供了一些基本的图形算法，包括最短路径算法。可以使用Dijkstra算法或者Bellman-Ford算法来计算最短路径。下面是一个使用Dijkstra算法计算最短路径的示例代码： ```python import networkx as nx # 创建有向图 G = nx.DiGraph() G.add_edges_from([(1, 2, {'weight': 1}), (1, 3, {'weight': 4}), (2, 3, {'weight': 2}), (2, 4, {'weight': 5}), (3, 4, {'weight': 1})]) # 计算最短路径 shortest_path = nx.shortest_path(G, source=1, target=4, weight='weight') print(shortest_path) ``` 在这个示例中，我们创建了一个有向图，然后使用`shortest_path`函数计算从节点1到节点4的最短路径。这个函数返回一个最短路径列表，其中包含路径上的所有节点。如果没有从源节点到目标节点的路径，则会引发`NetworkXNoPath`异常。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值