Java学习第二十四天 图论（广度优先，深度优先，最小生成树，最短路径）二

最新推荐文章于 2023-10-22 02:31:35 发布
最新推荐文章于 2023-10-22 02:31:35 发布
阅读量130 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58070636/article/details/118343975
版权

 最短路径

Dijkstra和单源最短路径

带权图的最短路径

Dijkstra算法

不能处理负权边，不过大量应用不依赖负权边

import java.util.Arrays;

public class Dijkstra {

    private WeightedGraph G;
    private int s;
    private int[] dis;
    private boolean[] visited;

    public Dijkstra(WeightedGraph G, int s){

        this.G = G;

        G.validateVertex(s);
        this.s = s;

        dis = new int[G.V()];//开空间
        Arrays.fill(dis, Integer.MAX_VALUE);//为dis中所有元素幅值无穷大（int中最大值
        dis[s] = 0;//s离源的位置是0

        visited = new boolean[G.V()];//给visitied开空间，这里默认是false

        while(true){
            //1.找当前没有遍历的最短路节点，存到cur里
            int cur = -1, curdis = Integer.MAX_VALUE;
            for(int v = 0; v < G.V(); v ++)
                if(!visited[v] && dis[v] < curdis){//v的dis值小于当前找到的最小dis值
                    curdis = dis[v];
                    cur = v;
                }//第一个循环必然更新cur为s，此时的循环逻辑还未正式开始

            if(cur == -1) break;
            //2.确定当前最小dis值，就算源点到它的最短路径
            visited[cur] = true;
            //3.根据这个节点的最短路径大小，更新其他节点路径的大小
            for(int w: G.adj(cur))//遍历这个cur顶点的所有相邻顶点
                if(!visited[w]){//w的最短路径如果还未得到的话，通过这层循环，对还未得到最短路径的节点进行更新
                    if(dis[cur] + G.getWeight(cur, w) < dis[w])//s-cur加cur-w<s-w，意味着找到了更短路径
                        dis[w] = dis[cur] + G.getWeight(cur, w);//更新最小路径dis[w]
                }
        }
    }

    public boolean isConnectedTo(int v){

        G.validateVertex(v);
        return visited[v];
    }

    public int distTo(int v){

        G.validateVertex(v);
        return dis[v];
    }

    static public void main(String[] args){

        WeightedGraph g = new WeightedGraph("g.txt");
        Dijkstra dij = new Dijkstra(g, 0);
        for(int v = 0; v < g.V(); v ++)
            System.out.print(dij.distTo(v) + " ");
        System.out.println();
    }
}

输入

5 8
0 1 4
0 2 2
1 2 1
1 3 2
1 4 3
2 3 4
2 4 5
3 4 1

输出

0 3 2 5 6

时间复杂度：O(V^2)

优化

import java.util.Arrays;
import java.util.PriorityQueue;


public class Dijkstra {

    private WeightedGraph G;
    private int s;
    private int[] dis;
    private boolean[] visited;

    private class Node implements Comparable<Node>{

        public int v, dis;//顶点与dis

        public Node(int v, int dis){
            this.v = v;
            this.dis = dis;
        }

        @Override
        public int compareTo(Node another){
            return dis - another.dis;
        }
    }

    public Dijkstra(WeightedGraph G, int s){

        this.G = G;

        G.validateVertex(s);
        this.s = s;

        dis = new int[G.V()];
        Arrays.fill(dis, Integer.MAX_VALUE);
        dis[s] = 0;

        visited = new boolean[G.V()];

        PriorityQueue<Node> pq = new PriorityQueue<Node>();//存顶点序号与dis值
        pq.add(new Node(s, 0));//添加源点与其dis值
        while(!pq.isEmpty()){

            //1.找当前没有遍历的最短路节点，存到cur里
            int cur = pq.remove().v;

            if(visited[cur]) continue;//如果cur已经处理过了，就接着去弄下一个

            //2.确定当前最小dis值，就算源点到它的最短路径
            visited[cur] = true;
            //3.根据这个节点的最短路径大小，更新其他节点路径的大小
            for(int w: G.adj(cur))
                if(!visited[w]){
                    if(dis[cur] + G.getWeight(cur, w) < dis[w]){
                        dis[w] = dis[cur] + G.getWeight(cur, w);//优先队列不能动态更新
                        pq.add(new Node(w, dis[w]));//所以每更新一个w，往Node中添加一个节点，方便下一次比较
                    }
                }
        }
    }

    public boolean isConnectedTo(int v){

        G.validateVertex(v);
        return visited[v];
    }

    public int distTo(int v){

        G.validateVertex(v);
        return dis[v];
    }

    static public void main(String[] args){

        WeightedGraph g = new WeightedGraph("g.txt");
        Dijkstra dij = new Dijkstra(g, 0);
        for(int v = 0; v < g.V(); v ++)
            System.out.print(dij.distTo(v) + " ");
        System.out.println();
    }
}

时间复杂度O(ElogE)

求解最短路径：pre数组

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.PriorityQueue;


public class Dijkstra {

    private WeightedGraph G;
    private int s;
    private int[] dis;
    private boolean[] visited;
    private int[] pre;

    private class Node implements Comparable<Node>{

        public int v, dis;

        public Node(int v, int dis){
            this.v = v;
            this.dis = dis;
        }

        @Override
        public int compareTo(Node another){
            return dis - another.dis;
        }
    }

    public Dijkstra(WeightedGraph G, int s){

        this.G = G;

        G.validateVertex(s);
        this.s = s;

        dis = new int[G.V()];
        Arrays.fill(dis, Integer.MAX_VALUE);

        pre = new int[G.V()];
        Arrays.fill(pre, -1);//pre默认值是-1

        dis[s] = 0;
        pre[s] = s;//源点上一个顶点是它自己
        visited = new boolean[G.V()];

        PriorityQueue<Node> pq = new PriorityQueue<Node>();
        pq.add(new Node(s, 0));
        while(!pq.isEmpty()){

            int cur = pq.remove().v;

            if(visited[cur]) continue;

            visited[cur] = true;
            for(int w: G.adj(cur))
                if(!visited[w]){
                    if(dis[cur] + G.getWeight(cur, w) < dis[w]){
                        dis[w] = dis[cur] + G.getWeight(cur, w);
                        pq.add(new Node(w, dis[w]));
                        pre[w] = cur;//确认最短路径后，确认前一个点
                    }
                }
        }
    }

    public boolean isConnectedTo(int v){

        G.validateVertex(v);
        return visited[v];
    }

    public int distTo(int v){

        G.validateVertex(v);
        return dis[v];
    }

    public Iterable<Integer> path(int t){//可迭代的一个对象

        ArrayList<Integer> res = new ArrayList<>();//开空间
        if(!isConnectedTo(t)) return res;//是否可达t

        int cur = t;//从t开始不断往回找，获得路径
        while(cur != s){
            res.add(cur);
            cur = pre[cur];
        }
        res.add(s);

        Collections.reverse(res);
        return res;
    }

    static public void main(String[] args){

        WeightedGraph g = new WeightedGraph("g.txt");
        Dijkstra dij = new Dijkstra(g, 0);
        for(int v = 0; v < g.V(); v ++)
            System.out.print(dij.distTo(v) + " ");
        System.out.println();

        System.out.println(dij.path(3));
    }
}

Bellman-Ford算法

有方向性

松弛操作

不同松弛顺序，值有不同

但最多V-1轮，无负权环时一定得到固定解

import java.util.Arrays;

public class BellmanFord {

    private WeightedGraph G;
    private int s;
    private int[] dis;
    private boolean hasNegCycle = false;

    public BellmanFord(WeightedGraph G, int s){

        this.G = G;

        G.validateVertex(s);
        this.s = s;

        dis = new int[G.V()];
        Arrays.fill(dis, Integer.MAX_VALUE);//为dis数组赋初始值
        dis[s] = 0;

        //V-1轮的松弛操作
        for(int pass = 1; pass < G.V(); pass ++){
            for(int v = 0; v < G.V(); v ++)//遍历所有顶点
                for(int w: G.adj(v))//遍历所有顶点的相邻顶点
                    if(dis[v] != Integer.MAX_VALUE && dis[v] + G.getWeight(v, w) < dis[w])//松弛操作
                        dis[w] = dis[v] + G.getWeight(v, w);
        }

        //再做一次松弛操作，判断是否含负权环
        for(int v = 0; v < G.V(); v ++)
            for(int w : G.adj(v))
                if(dis[v] != Integer.MAX_VALUE && dis[v] + G.getWeight(v, w) < dis[w])
                    hasNegCycle = true;
    }

    public boolean hasNegativeCycle(){
        return hasNegCycle;
    }

    public boolean isConnectedTo(int v){
        G.validateVertex(v);
        return dis[v] != Integer.MAX_VALUE;
    }

    //返回去v的最短路径
    public int distTo(int v){
        G.validateVertex(v);
        if(hasNegCycle) throw new RuntimeException("exist negative cycle.");
        return dis[v];
    }

    static public void main(String[] args){

        WeightedGraph g = new WeightedGraph("g.txt");
        BellmanFord bf = new BellmanFord(g, 0);
        if(!bf.hasNegativeCycle()){
            for(int v = 0; v < g.V(); v ++)
                System.out.print(bf.distTo(v) + " ");
            System.out.println();
        }
        else
            System.out.println("exist negative cycle.");

        WeightedGraph g2 = new WeightedGraph("g2.txt");
        BellmanFord bf2 = new BellmanFord(g2, 0);
        if(!bf2.hasNegativeCycle()){
            for(int v = 0; v < g2.V(); v ++)
                System.out.print(bf2.distTo(v) + " ");
            System.out.println();
        }
        else
            System.out.println("exist negative cycle.");
    }
}


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class BellmanFord {

    private WeightedGraph G;
    private int s;
    private int[] dis;
    private int[] pre;
    private boolean hasNegCycle = false;

    public BellmanFord(WeightedGraph G, int s){

        this.G = G;

        G.validateVertex(s);
        this.s = s;

        dis = new int[G.V()];
        Arrays.fill(dis, Integer.MAX_VALUE);
        dis[s] = 0;

        pre = new int[G.V()];
        Arrays.fill(pre, -1);

        for(int pass = 1; pass < G.V(); pass ++){
            for(int v = 0; v < G.V(); v ++)
                for(int w: G.adj(v))
                    if(dis[v] != Integer.MAX_VALUE &&
                       dis[v] + G.getWeight(v, w) < dis[w]){ dis[w] = dis[v] + G.getWeight(v, w);
                        pre[w] = v;//跟新完幅值
                    }
        }

        for(int v = 0; v < G.V(); v ++)
            for(int w : G.adj(v))
                if(dis[v] != Integer.MAX_VALUE &&
                   dis[v] + G.getWeight(v, w) < dis[w])
                    hasNegCycle = true;
    }

    public boolean hasNegativeCycle(){
        return hasNegCycle;
    }

    public boolean isConnectedTo(int v){
        G.validateVertex(v);
        return dis[v] != Integer.MAX_VALUE;
    }

    public int distTo(int v){
        G.validateVertex(v);
        if(hasNegCycle) throw new RuntimeException("exist negative cycle.");
        return dis[v];
    }

    public Iterable<Integer> path(int t){//返回最短路径

        ArrayList<Integer> res = new ArrayList<Integer>();
        if(!isConnectedTo(t)) return res;

        int cur = t;
        while(cur != s){
            res.add(cur);
            cur = pre[cur];
        }
        res.add(s);

        Collections.reverse(res);
        return res;
    }

    static public void main(String[] args){

        WeightedGraph g = new WeightedGraph("g.txt");
        BellmanFord bf = new BellmanFord(g, 0);
        if(!bf.hasNegativeCycle()){
            for(int v = 0; v < g.V(); v ++)
                System.out.print(bf.distTo(v) + " ");
            System.out.println();

            System.out.println(bf.path(3));
        }
        else
            System.out.println("exist negative cycle.");

        WeightedGraph g2 = new WeightedGraph("g2.txt");
        BellmanFord bf2 = new BellmanFord(g2, 0);
        if(!bf2.hasNegativeCycle()){
            for(int v = 0; v < g2.V(); v ++)
                System.out.print(bf2.distTo(v) + " ");
            System.out.println();
        }
        else
            System.out.println("exist negative cycle.");
    }
}

Floyed算法

求解所有点对最短路径--求解出图的直径--所有点对最短路径中的最大值

都是一个意思

v-b的最短路径+b-a的最短路径小于v-a的最短路径，跟新dis[v][a]

import java.util.Arrays;

public class Floyed {

    private WeightedGraph G;
    private int[][] dis;
    private boolean hasNegCycle = false;

    public Floyed(WeightedGraph G){

        this.G = G;
        //初始化过程
        dis = new int[G.V()][G.V()];
        for(int v = 0; v < G.V(); v ++)
            Arrays.fill(dis[v], Integer.MAX_VALUE);

        for(int v = 0; v < G.V(); v ++){//不是所有的距离都幅正无穷，如果v-w相连，赋dis为 边的权值
            dis[v][v] = 0;
            for(int w: G.adj(v))
                dis[v][w] = G.getWeight(v, w);
        }

        for(int t = 0; t < G.V(); t ++)//遍历中间寻找任意两点间的最短路径多经过的点
            for(int v = 0; v < G.V(); v ++)//遍历两点间最短路径的两个端点是谁
                for(int w = 0; w < G.V(); w ++)
                    if(dis[v][t] != Integer.MAX_VALUE && dis[t][w] != Integer.MAX_VALUE
                       && dis[v][t] + dis[t][w] < dis[v][w])//防止整型溢出
                        dis[v][w] = dis[v][t] + dis[t][w];
        //判断是否有负权环
        for(int v = 0; v < G.V(); v ++)
            if(dis[v][v] < 0)
                hasNegCycle = true;
    }

    public boolean hasNegativeCycle(){
        return hasNegCycle;
    }

    public boolean isConnectedTo(int v, int w){
        G.validateVertex(v);
        G.validateVertex(w);
        return dis[v][w] != Integer.MAX_VALUE;
    }

    public int distTo(int v, int w){//返回两点最短路径
        G.validateVertex(v);
        G.validateVertex(w);
        return dis[v][w];
    }

    static public void main(String[] args){

        WeightedGraph g = new WeightedGraph("g.txt");
        Floyed floyed = new Floyed(g);
        if(!floyed.hasNegativeCycle()){
            for(int v = 0; v < g.V(); v ++){
                for(int w = 0; w < g.V(); w ++)
                    System.out.print(floyed.distTo(v, w) + " ");
                System.out.println();
            }
        }
        else
            System.out.println("exist negative cycle.");

        WeightedGraph g2 = new WeightedGraph("g2.txt");
        Floyed floyed2 = new Floyed(g2);
        if(!floyed2.hasNegativeCycle()){
            for(int v = 0; v < g.V(); v ++){
                for(int w = 0; w < g.V(); w ++)
                    System.out.print(floyed2.distTo(v, w) + " ");
                System.out.println();
            }
        }
        else
            System.out.println("exist negative cycle.");
    }
}

从零开始的码农生活01
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java中visit函数_Java设计模式(三) Visitor(訪问者)模式及多分派场景应用
weixin_42524824的博客
02-24 1023
基本概念Visitor封装一些作用于数据结构中的各元素的操作，不同的操作能够借助新的visitor实现。减少了操作间的耦合性訪问者能够将数据结构和对数据的操作解耦，使得添加对数据结构的操作不须要取改动数据结构，也不必去改动原有的操作，而运行时再定义新的Visitor时闲着即可了(在操作加入上易拓展)模式中角色分工Visitor:抽象訪问者，在重载的visit函数中声明訪问者能够訪问的对象。Conc...
大数据算法学习笔记(2)-平面图的直径算法
JiajunBernoulli的博客
04-26 1110
问题 给定平面上的m个顶点以及矩阵D，D[i][j]为第i个点到第j个点的距离；距离是对称的，且满足三角不等式(这样才能保证算法的近似比为2)。 算法步骤 1.任给k<m(只看某一行) 2.选择使得Dkl最大的l(只看某一行) 3.输出Dkl与k，l 算法代码 Java import java.util.Random; public class PlanarGraphDiameter {...
Java实现之迪杰斯特拉(Dijkstra)算法
qq_64580912的博客
11-27 1975
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个结点到其他结点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。
如何理解最短路径中的“松弛”操作
HELLOW，文浩
08-21 9684
这是图算法的第五篇文章：图解：最短路径之如何理解“松弛”or“放松”？ 最短路径问题的目的是找到从一个顶点到达另一个顶点的成本最小的路径。最短路径算法被广泛地应用于解决各种复杂的问题，比如在地图中寻找两个地点之间的最短路径，如何在网络连接中为路由器寻找最短的传输路径等等。为了实现最短路径算法，人们发明了一系列的算法，比如：Dijkstra算法与Bellman-Ford算法。但是这些算法都基于一个被称为放松的基本操作 relaxtion,有些人称为松弛，我就直接简单翻译为放松了，别管怎么叫，理解就行 在
JAVA算法大全.docx
06-25
第十五章和第十六章则进一步讨论了高级排序算法（如归并排序、堆排序、计数排序）和图论算法（如最短路径和最小生成树），这些是处理大量数据和复杂关系时不可或缺的工具。 通过阅读《JAVA算法大全》，读者不仅可以...
第十五届蓝桥杯大赛知识点大纲
最新发布
01-17
5. 图论算法：深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Prim或Kruskal）、最短路径（Dijkstra或Floyd-Warshall）。 三、数据结构： 1. 数组、链表、栈、队列：理解它们的基本操作和应用。 2. 树：...
图论02-【无权无向】-图的深度优先遍历DFS
啊枫
10-22 828
但是出栈的顺序是反过来的，2先出栈进入pre容器，最后才是1出栈进入pre容器。因为非递归使用的是的栈，把0压栈之后，0出栈并进入pre容器进行记录。如果图中存在多个联通分量，使用循环进行DFS;随后是跟0相连的顶点都入栈，入栈的顺序是。因此两种方法遍历出来的顺序会不一样。
算法（第4版） Chapter 4.1 无向图
weixin_33738555的博客
01-15 184
Algorithms Fourth EditionWritten By Robert Sedgewick & Kevin WayneTranslated By 谢路云Chapter 4 Section 1 无向图 以下内容修改自http://www.cnblogs.com/skyivb...http://www.cnblogs....
java设计模式-访问者模式visit
sidihuo的专栏
02-06 2907
一般场景：一个数据结构可以被多种不同对象访问操作； 类比：医院开的方子，可以被划价员计算医药费，可以被药房抓药，。。。 demo：  抽象访问者：Visitor.Java public abstract class Visitor { protected String name; public void setName(String name) {
java 爬虫使用Bloom Filter 算法实现Visited表
diu_brother的博客
03-13 1181
在生活中，包括在设计计算机软件时，经常要判断一个元素是否在一个集合中，最直接的办法就是将全部元素都存在计算机中，遇到一个新元素，将它与集合中的元素比较即可。一般来讲，计算机中的集合是使用哈希表来存储的。它的好处是快速而准确，缺点是费存储空间。当集合比较小时，这个问题不显著，但当集合非常巨大时，哈希表存储效率低的问题就体现出来了。 一种称为布隆过滤器的数学工具，它只需要哈希表的1/8到1/4的大小就
Java学习第二十三天 图论（广度优先，深度优先，最小生成树，最短路径）一
weixin_58070636的博客
06-28 571
图的表示 图的遍历 深度优先：连通性路径，二分图的检测，环的检测，fllodfill 广度优先：无权图的最短路径 使用图论对问题建模 欧拉路径 哈密尔顿路径 状态压缩 桥 割点 有向图算法： DAG 环检测 拓扑排序 强连通分量 最小生成树： Kruskal Prim 最短路径： Dijkstra Floyed Bellman-Ford 网络流： 最大流-最小割 Ford-Fulkerson 图的表示 图的分类 无向图 Undirected Graph 有向.
bfs导航算法java,Java实现利用广度优先遍历(BFS)计算最短路径的方法
weixin_33404102的博客
03-10 461
本文实例讲述了Java实现利用广度优先遍历(BFS)计算最短路径的方法。分享给大家供大家参考。具体分析如下：我们用字符串代表图的顶点(vertax)，来模拟学校中Classroom, Square, Toilet, Canteen, South Gate, North Gate几个地点，然后计算任意两点之间的最短路径。如下图所示：如，我想从North Gate去Canteen, 程序的输出结果应为...
图的深度优先遍历和广度优先遍历、最小生成树、最短路径、拓扑排序、关键路径
Caesar2334的博客
11-22 2369
弗洛伊德算法的原理有点复杂：首先他要求得是所有任意两条边之间的最短路径，因为是有向图，所有有向路径有两倍的数量，比如0-1，1-0这样的，那么有向最短路径之间可能会有中间节点，那那些中间节点会使得上述的有向路径距离最短呢，所以就需要依次的将各个顶点当做是中间节点，对这些有向路径进行迭代，看看那个中间节点造成的有向路径是最短的，这样就好了。AOV网（有向），这个是活动在顶点上的网，即顶点表示的是活动，而边界表示的是活动的次序。的，有两种算法，一种是Prime算法，一种是kruskal算法，两者的区别在于，
图
爱胡椒的小白兔呢
03-20 272
一、无向图Graph数据类型： import java.util.Scanner; public class Graph { private final int V; private int E; private Bag[] adj; public Graph(int v) { this.V = v; this.E = 0; adj = (Bag[])new Bag[
java二维数组找最短路径问题-美团面试
qq_38583464的博客
04-05 2110
**题目：**首先输入一个（n,k）的值，其中n构成一个n*n的二维数字，而二维数字具体的参数则是1-k某一具体的值。问题是要找到遍历1…k这些所有值经过的最短路径。但是如果输入的二维数组缺少从0-k的某个值时，那么就没有最短路径。路径的求法是：比如aij和bij的路径是|ai-bi|+|aj-bj|。 思路： 1、输入部分就不多说了，做好之后建议输入输出测试一下，方便只有的调试。 2、关于找出最短路径的问题，刚开始想可以用回溯用递归，加上没有最短路径的问题，结果思路就很乱。于是就选择最简单最直接的这种方法
算法-18-无向图（深度+广度优先搜索）
Yo.o
03-03 2387
目录 1、定义 1.1、特殊的图 1.2、术语 2、无向图的数据结构 2.1、数据结构API 2.2、代码 3、深度优先搜索 3.1、深度优先搜索代码 3.2、深度优先搜索路径代码 4、广度优先搜索---寻找最短路径 4.1、代码 5、连通分量 5.1、代码 6、检查图中是否有环 7、二分图（二分颜色） 1、定义 图是由一组顶点和一组能够将两个顶点相连的边组成的...
java sdk 图论算法_图论的各种基本算法
weixin_28676397的博客
02-27 429
来源：Mr.Riddler's Puzzleblog.mrriddler.com/2016/11/14/算法余晖/本篇主要涉及到图论的基本算法，不包含有关最大流的内容。图论的大部分算法都是由性质或推论得出来的，想朴素想出来确实不容易。二分图(Is-Bipartite)一个图的所有顶点可以划分成两个子集，使所有的边的入度和出度顶点分别在这两个子集中。这个问题可以转换为上篇提到过的图的着色问题，只要看...
图论算法详解：最小生成树与最短路径
"本文主要介绍了图论中的四种经典算法，包括最小生成树算法、最短路径算法、拓扑排序算法和关键路径算法。重点讲解了最小生成树算法，特别是生成树的概念及其在连通无向图和有向图中的应用。生成树不唯一，根据不同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值