算法总结六：图论中五花八门的算法

最新推荐文章于 2022-10-21 18:06:45 发布
最新推荐文章于 2022-10-21 18:06:45 发布
阅读量379 收藏 1
点赞数
分类专栏： algorithm 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43879909/article/details/112798456
版权

区别：
一。几种算法
普通BFS
Dijkstra
Bellman-Ford
Floyd-Warshall

二。配套：如何构建一个图
adjacency list节省空间，搜索时间慢
map占用空间，搜索时间快
adjacency matrix占用空间，搜索时间快

=================
1.BFS主要适用于无权重向图中搜索出步骤最少的路径，当方向图存在权重时，不再适用；
2.Dijkstra主要用于有权重的方向图中搜索出最短、cost最小的路径，但不适合于有负权重的情况。
视频讲解
对于有环图，和BFS一样，标志好已处理的节点避免进入死循环，可以支持；
3.Bellman-Ford：负权重
4.Floyd-Warshall: 本质是动态规划，解决任意两点间的最短路径。
Floyd能不能处理负权边？？

=================
一。Dijkstra
1.1 定义

最短距离：
在这里插入图片描述

public class Dijkstra {
    /*
     * 参数adjMatrix:为图的权重矩阵，权值为-1的两个顶点表示不能直接相连
     * 函数功能：返回顶点0到其它所有顶点的最短距离，其中顶点0到顶点0的最短距离为0
     */
    public int[] getShortestPaths(int[][] adjMatrix) {
        int[] result = new int[adjMatrix.length];   //用于存放顶点0到其它顶点的最短距离
        boolean[] used = new boolean[adjMatrix.length];  //用于判断顶点是否被遍历
        used[0] = true;  //表示顶点0已被遍历
        for(int i = 1;i < adjMatrix.length;i++) {
            result[i] = adjMatrix[0][i];
            used[i] = false;
        }
    
        for(int i = 1;i < adjMatrix.length;i++) {
            int min = Integer.MAX_VALUE;    //用于暂时存放顶点0到i的最短距离，初始化为Integer型最大值
            int k = 0;
            for(int j = 1;j < adjMatrix.length;j++) {  //找到顶点0到其它顶点中距离最小的一个顶点
                if(!used[j] && result[j] != -1 && min > result[j]) {
                    min = result[j];
                    k = j;
                }
            }
            used[k] = true;    //将距离最小的顶点，记为已遍历
            for(int j = 1;j < adjMatrix.length;j++) {  //然后，将顶点0到其它顶点的距离与加入中间顶点k之后的距离进行比较，更新最短距离
                if(!used[j]) {  //当顶点j未被遍历时
                    //首先，顶点k到顶点j要能通行；这时，当顶点0到顶点j的距离大于顶点0到k再到j的距离或者顶点0无法直接到达顶点j时，更新顶点0到顶点j的最短距离
                    if(adjMatrix[k][j] != -1 && (result[j] > min + adjMatrix[k][j] || result[j] == -1))
                        result[j] = min + adjMatrix[k][j];
                }
            }
        }
        return result;
    }
    
    public static void main(String[] args) {
        Dijkstra test = new Dijkstra();
        int[][] adjMatrix = {{0,6,3,-1,-1,-1},
                {6,0,2,5,-1,-1},
                {3,2,0,3,4,-1},
                {-1,5,3,0,2,3},
                {-1,-1,4,2,0,5},
                {-1,-1,-1,3,5,0}};
        int[] result = test.getShortestPaths(adjMatrix);
        System.out.println("顶点0到图中所有顶点之间的最短距离为：");
        for(int i = 0;i < result.length;i++) 
            System.out.print(result[i]+" ");
    }
}

from：https://blog.csdn.net/a1439775520/article/details/96903328

1.2 讲解
掘金解答

1.3 leetcode练习
378. Kth Smallest Element in a Sorted Matrix

class Solution {
    public int kthSmallest(int[][] matrix, int k) {
        if(matrix==null || matrix.length==0){
            return -1;
        }
        int n=matrix.length;
        
        Set<List<Integer>> visited=new HashSet<>();
        int[][] dirs={{1,0},{-1,0},{0,1},{0,-1}};
        PriorityQueue<List<Integer>> minHeap=new PriorityQueue<List<Integer>>((e1,e2)-> e1.get(2)-e2.get(2));
             
        minHeap.offer(Arrays.asList(0,0,matrix[0][0]));   
        visited.add(Arrays.asList(0,0,matrix[0][0]));
    
        while(k>1){
            List<Integer> cur=minHeap.poll();  //exp
            for(int[] dir:dirs){
                int nextX=cur.get(0)+dir[0];
                int nextY=cur.get(1)+dir[1];
          
                if(nextX>=0 && nextX<n && nextY>=0 && nextY<n && visited.add(Arrays.asList(nextX,nextY,matrix[nextX][nextY]))){
                    minHeap.offer(Arrays.asList(nextX,nextY,matrix[nextX][nextY])); //gen                         
                }
            }
            k--;
        }
        return minHeap.poll().get(2);
    }
}

787. Cheapest Flights Within K Stops

class Pair {
	int city, cost;

	Pair(int city, int cost) {
		this.city = city;
		this.cost = cost;
	}
}

class City {
	int city, distFromSrc, costFromSrc;

	City(int city, int distFromSrc, int cost) {
		this.city = city;
		this.distFromSrc = distFromSrc;
		this.costFromSrc = cost;
	}
}

class Solution {

    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int K) {
    	// DFS
        if(n <= 0 || flights == null || flights.length == 0 || K < 0)
        	return -1;

        List<List<Pair>> graph = new ArrayList<>();
        this.buildGraph(graph, n, flights);

        Queue<City> pQueue = new PriorityQueue<>((City c1, City c2) -> c1.costFromSrc - c2.costFromSrc);
        pQueue.offer(new City(src, 0, 0));

        int totalCost = 0;

        while (!pQueue.isEmpty()) {
        	City top = pQueue.poll();

        	if (top.city == dst) {
        		return top.costFromSrc;
        	}

        	if (top.distFromSrc > K) {
        		continue;
        	}

        	List<Pair> neighbors = graph.get(top.city);
        	for (Pair neighbor: neighbors) {
        		pQueue.offer(new City(neighbor.city, top.distFromSrc + 1, top.costFromSrc + neighbor.cost));
        	}
        }

        return -1;
    }

    private void buildGraph(List<List<Pair>> graph, int n, int[][] flights) {
    	for (int i = 0; i < n; i++) {
    		graph.add(new ArrayList<>());
    	}

    	for (int[] flight: flights) {
    		graph.get(flight[0]).add(new Pair(flight[1], flight[2]));
    	}
    }
}

//不是走recursion
//是用recursion的思路，变换City！！！！！！

for (Pair neighbor: neighbors) {
	pQueue.offer(new City(neighbor.city, top.distFromSrc + 1, top.costFromSrc + neighbor.cost));
}

二。Bellman-Ford

2.1定义：
Bellman-Ford 算法是一种用于计算带权有向图中单源最短路径的算法。
V代表顶点数，E代表边数。
对图进行最多V-1次松弛操作，得到所有可能的最短路径。其优于迪科斯彻算法的方面是边的权值可以为负数、实现简单，缺点是时间复杂度过高，高达O(VE)。
掘金解答

思路上与Dijkstra algorithm最大的不同是Bellman-Ford每次都是从源点s重新出发进行"松弛"更新操作，
而Dijkstra则是从源点出发向外扩逐个处理相邻的节点，不会去重复处理节点，这边也可以看出Dijkstra效率相对更高点。

2.2 视频讲解https://www.bilibili.com/video/BV1gb41137u4
2.3 leetcode练习：
787. Cheapest Flights Within K Stops
//v-1轮，即中转v-1次，这里是中转K次
//use tmpDist array to store each iteration round result
//each time, only iterate one city… 0-1 0-2 skip 1-2.
//otherwise: without tempdist, will iterate 0-1,1-2, and 0-2
//when stop K=0, in one iteration, we still get 200 as result, which is wrong.
//it should be 500

class Solution {
    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int K) {
        int[] dist = new int[n];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[src] = 0;
        for (int i = 0; i <= K; i++) {
            int[] tmpDist = Arrays.copyOf(dist, dist.length);
            for (int[] edge : flights) {
                int u = edge[0];
                if (dist[u] == Integer.MAX_VALUE) continue;
                int v = edge[1];
                int w = edge[2];
                tmpDist[v] = Math.min(tmpDist[v], dist[u] + w);
            }
            dist = tmpDist;
        }
        return dist[dst] == Integer.MAX_VALUE ? -1 : dist[dst];
    }
}

三。Floyd-Warshall

3.1 Floyd-Warshall是解决任意两点间的最短路径的一种算法，

3.2 视频讲解：https://www.bilibili.com/video/BV1LE411R7CS/

a）如图：存在【0,1,2,3】 4个点，两点之间的距离就是边上的数字，如果两点之间，没有边相连，则无法到达，为无穷大。
b）要让任意两点（例如从顶点a点到顶点b）之间的路程变短，只能引入第三个点（顶点k），并通过这个顶点k中转即a->k->b，才可能缩短原来从顶点a点到顶点b的路程。那么这个中转的顶点k是0~n中的哪个点呢？

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

作者：Halburt 链接：https://juejin.cn/post/6844903833382944781

Public class Solution{
public static int MAX = Integer.MAX_VALUE;
    //    距离矩阵
    public int[][] dist;
    //    路径Path矩阵
    public int[][] path;

    public FloydDemo(int size) {
        this.path = new int[size][size];
        this.dist = new int[size][size];
    }

    public static void print(int[][] arrs) {
        System.out.println("------------------------");
        for (int[] arr : arrs) {
            for (int a : arr) {
                if (a == FloydDemo.MAX) {
                    System.out.print("∞ ");
                } else {
                    System.out.print(a + " ");
                }
            }
            System.out.println();
        }
        System.out.println("------------------------");
    }

    public void floyd(int[][] matrix) {
//        matrix和path length不一致可处理异常
        int size = matrix.length;
        //初始化 dist 和 path
        for(int i = 0;i< size;i++){
            for(int j = 0;j < size; j++){
                path[i][j]=-1;
                dist[i][j]=matrix[i][j];
            }
        }
//        核心算法
        for(int k = 0 ; k < size ; k++){
            for(int i = 0;i < size;i++){
                for(int j = 0 ;j < size;j++){
                    if(i == j){
                        continue;
                    }
//                判断如果 ik距离可达且 kj距离可达 且 i和j的距离是否大于 i-> k 与 k->j的距离和
                    if( dist[i][k] != MAX &&  dist[k][j] != MAX  &&  dist[i][j] > (dist[i][k] + dist[k][j]) ){
                        //System.out.println("路径{" + i +"->" + j +"}在点"+k +"处可中转(原先中转点为"+path[i][j]+")，距离由"+ dist[i][j]+"缩短为"+(dist[i][k] + dist[k][j]));
                        path[i][j]= k;
                        dist[i][j]= dist[i][k] + dist[k][j];
                    }else{
                        //System.out.println("路径{" + i +"->" +j +"}在点"+k +"中转不合适");
                    }
                }
            }
        }
    }
}

743. Network Delay Time
huahua

public class Solution {
    public int networkDelayTime(int[][] times, int N, int K) {
        int INF = 0x3f3f3f3f;
        int[][] g = new int[N + 1][N + 1];
        // 初始化图,注意,一开始距离是初始化为INF的，而不是像 spfa初始化成-1
        // spfa初始化成-1只是为了判断是否为邻居，这里初始化为INF是因为要取min的
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                g[i][j] = i == j ? 0 : INF;
            }
        }
        for (int[] t : times) {
            g[t[0]][t[1]] = t[2];
        }
        // 使用K节点来松弛i->j的最短路径（大白话就是利用k作为中间节点）
        for (int k = 1; k <= N; k++) {
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    // 判断语句可以不用写，具体得看题目
                    // if (k != i && k != j && g[i][k] != INF && g[k][j] != INF) {
                        g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]);
                    // }
                }
            }
        }
        // g[a][b]表示a到b的最短距离
        // 拿结果
        int res = 0;
        for (int distance : g[K]) {
            res = Math.max(res, distance);
        }
        return res == INF ? -1 : res;
    }
}

3.3 leetcode练习：
1334. Find the City With the Smallest Number of Neighbors at a Threshold Distance

class Solution {
    public int findTheCity(int n, int[][] edges, int distanceThreshold) {
        int[][] distance = new int[n][n];
        for(int[] ele: distance){
            Arrays.fill(ele, Integer.MAX_VALUE);
        }
        
        for(int i=0;i<n;i++){
            distance[i][i] = 0;
        }
        
        for(int[] ele: edges){
            distance[ele[0]][ele[1]] = ele[2];
            distance[ele[1]][ele[0]] = ele[2];
        }
        
        for(int k=0;k<n;k++){
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    if(distance[i][k]!=Integer.MAX_VALUE && distance[j][k]!=Integer.MAX_VALUE){
                          if(distance[i][j] > distance[i][k] + distance[j][k]){
                              distance[i][j] = distance[i][k] + distance[j][k];
                              
                          }
                    }
                }
            }
        }

        
        
        int min = Integer.MAX_VALUE;
        int res = -1;
        for(int i=0;i<n;i++){
            int count = 0;
            for(int j=0;j<n;j++){
                if(distance[i][j] <= distanceThreshold){
                    count++;
                }
            }
            
            if(count <= min){
                res = i;
                min = count;
            }
        }
        
        return res;
    }
}
大树莓
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法】BFS刷题总结
繁凡さん的博客
12-22 499
姊妹篇（DFS）
[BFS]-宽搜算法总结
邂逅黛玛姑娘
12-29 2611
总结一下宽搜中的一些问题，当然还不全面，以后再补充~ 问题一：怎么记录步数/层数？ 从教主的代码那里学来的方法。int 一个变量t，令t=xx.size();，再while（t--）就可以记录步数或者层数了。 如下： int bfs(******) { * 略 * while(!xx.empty()) { t=xx.size(
BFS算法小结
hai200103的博客
08-08 315
BFS算法小结----出自南昌理工学院ACM集训队 算法的基本思路 广度优先搜索类似于树的层次遍历过程。它需要借助一个队列来实现。如图2-1-1所示，要想遍历从v0到v6的每一个顶点，我们可以设v0为第一层，v1、v2、v3为第二层，v4、v5为第三层，v6为第四层，再逐个遍历每一层的每个顶点。 具体过程如下： 1.准备工作：创建一个visited数组（标记数组），用来记录已被访问过的顶点；创建一个队列，用来存放每一层的顶点；初始化图G。 2.从图中的v0开始访问，将的visited[v0]数组的值设置为t
BFS与DFS常见算法总结
ycllycll的博客
10-07 475
关于BFS于DFS一般用于在图论中来遍历图（树是一个特殊的图），最难的就在于我们常常不知道这是一个可以用BFS、DFS来解决的一个问题，因为通常题目都表达得很隐晦，需要我们取转化取构建一个图，难度较大。同时可能也需要结合Stack与Queue这两种数据结构来解决问题，或者能用BFS、DFS解决的问题有时候其实是可以用动态规划来解决的。 题目中有最短路，最小步数什么的关键字也...
BFS学习总结
code
04-15 4202
BFS学习总结          给你一个n*m的网格迷宫，迷宫中有些格子不能走，其他的格子都能走。然后给你起点与终点，问你从起点走到终点最少需要多少步？          上面的问题就是一个典型的BFS问题，对于这类问题来说，只要你掌握了这类问题的关键思想，其实他们都是可以用类似的思路来做的。建议先做两道BFS简单题，体会一下。          你可以把BFS问题想象成：从一个父亲(起点
图论算法软件图论算法软件
06-02
在提供的压缩包“图论算法软件”中，可能包含了上述各种图论算法的实现，用户可以通过查看和运行这些代码来学习和实践图论算法。这样的资源对于学习和研究图论以及相关领域的人来说是非常宝贵的。
图论算法软件Graph.exe
最新发布
02-03
Graph.exe是一个图论算法软件，用于执行各种图论算法。它可以用来解决图论问题，如最短路径、最小生成树、网络流等。用户可以输入图的结构和权重，然后选择所需的算法进行计算，最后得到相应的结果。该软件可以帮助...
图论算法理论实现_图论及其_图论算法_图论_图论知识_
09-30
图论是数学的一个分支，主要研究点（顶点）与线（边）组成的结构，它在计算机科学中有着广泛的应用，特别是在算法设计上。本文将深入探讨图论的基本概念、重要算法及其在实际问题中的应用。 一、图论基础 1. 图的...
图论算法及其MATLAB实现（完整版）
04-30
《图论算法及其MATLAB实现》是一本深入探讨图论算法与其实现的书籍，尤其强调了使用MATLAB这一强大的...无论你是计算机科学的学生，还是在相关领域工作的专业人士，都将从这本《图论算法及其MATLAB实现》中受益匪浅。
算法刷题提高阶段-图论2
12-24
在算法学习的过程中，图论是不可或缺的一个重要领域，它广泛应用于网络设计、数据通信、物流优化等诸多场景。在这个“算法刷题提高阶段-图论2”的主题中，我们将重点探讨图论中的一个重要概念——单源最短路问题。 ...
ACM算法设计-BFS(广度搜索)-DFS入门(深度搜索)详解
08-07
更好的理解和学会运用深sou去做一些题目
图论几大重点算法
dzk1112的博客
07-28 603
#include<bits/stdc++.h> #include<algorithm> #define N 1000 #define MAX 65535 using namespace std; int arc[N][N]; int num;//顶点数 int n;//边数 int low_price=0; void MiniSpanTree_Prim(){ int min,i,j,k; int adjvex[N];/* 保存相关顶点下标 */ int
训练第二周之BFS算法（广度优先搜索）
a747979985的博客
07-21 2033
本篇参考自rapheal的【算法入门】广度/宽度优先搜索(BFS)，觉得写得超级赞，大家去他那里相信会有很多收获。基本简介：每次将集合中的元素经过一些改动，分层生成当前状态的子状态（通常还删除父情况），添加到集合（队列）中，以实现遍历或搜索等目的的算法。一般可以用它做什么呢？一个最直观经典的例子就是走迷宫，我们从起点开始，找出到终点的最短路程，很多最短路径算法就是基于广度优先的思想成立的。据图说明：
简单易懂BFS
小二笙的博客
03-01 366
广度优先搜索，又称宽度优先搜索，简称bfsbfsbfs。与深度优先搜索不同的是，广度优先搜索会先将与起始距离较近的点搜索完毕，再继续搜索较远的点，而深搜却是沿一个分支搜到最后 bfsbfsbfs从起点开始，优先搜索离起点最近的点，然后由这个最近的点扩展其他稍近的点，这样一层一层的扩展，就像水波扩散一样。 bfsbfsbfs需要借助队列来实现： 1.初始的时候把起始点放入队列中，并标记起点访问 2...
总结自己应用广度优先搜索(BFS)中的错误（记POJ 1376 Robot结题过程）
perry_xiao的专栏
08-16 964
学习BFS之后以 POJ 1376 Robot(http://poj.org/problem?id=1376)作为练习，开始以为该题难度还好，但结果错了两天。特别郁闷的是竟然一直找不出错在什么地方，因为运行网上的题解在图较小的情况下没找出区别，最后碰运气花了个把小时在改图测试数据
floyd算法求解地铁路线问题
nepu_bin的博客
04-29 1672
题目描述Description 假设有两条地铁线路，1 号线为直线线路，2 号线为环线线路， 假设 1 号线的各个站点名称分别为 “A” “B” “C” “D” “E”“F” “G” “H” 2号线的各个站点名称分别为"C" “I” “J” “K” “F” “L” “M” “N”; 另外，假设地铁都是双向运行的。 现给出两个地铁站名分别作为起点和终点，请给出从起点到终点至少需要多少站。 假如各个地铁站之间的距离不是相等的，相邻地铁站之间的距离保存在另 外一个数组中，应如何计算两个地铁站之间的最近距离。 在
用大白话聊聊分布式系统
dazer的专栏
06-27 344
用大白话聊聊分布式系统
算法笔记十一 —— 图论
南瑾与春风的博客
10-21 529
图论 邻接矩阵 邻接表 图的遍历 DFS BFS
图论学习笔记——最短路
计算机小白努力学习
05-06 482
背景 最短路问题是重要的最优化问题之一，也是图论研究中的一个经典算法问题,它不仅直接应用于解决生产实践中的众多问题，如管道的铺设、线路的安排、厂区的选址和布局、设备等,而且也经常被作为一种基本工具,用于解决其他的最优化问题以及预测和决策问题。 赋权图 定义：对简单图G的没一边e赋予一个实数，记为（e），称为边e的权，二没变均赋予权的图称为赋权图。 （，）—路的边权之和称为该路的长，而，间路...
ACM竞赛算法总结：图论、网络流与数据结构
"该资源是一份关于ACM算法竞赛的模板集合，主要涵盖了图论、网络流和数据结构等多个领域的经典算法，适用于解决各种算法竞赛中的问题。" 在这份ACM算法模板中，包含了以下几个核心知识点： 1. **Graph图论**： - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值