所有节点对最短路径-Floyd-Warshall算法

算法——所有节点对的最短路径:Floyd-Warshall算法、Johnson算法 所有节点对的最短路径 前言 前面介绍了单源最短路径问题,本文是介绍所有节点对的最短路径问题,首先我们会想到用前面所介绍的知识来求解该问题,根据不同类型的图可以用一下几种方法求解: 1、  若无权重的图,则可以使用|V|次BFS,时间复杂度是O[V*(V+E)]; 2、  若为非负权重边的图,则可以使用|V|次Dijkstra算法,不同的优先队列实现得到不同的时间复杂度:①线性数组,O(V3 阅读详情

发布一个k8s部署视频:https://edu.youkuaiyun.com/course/detail/26967

课程内容:各种k8s部署方式。包括minikube部署,kubeadm部署,kubeasz部署,rancher部署,k3s部署。包括开发测试环境部署k8s,和生产环境部署k8s。

腾讯课堂连接地址https://ke.qq.com/course/478827?taid=4373109931462251&tuin=ba64518

第二个视频发布  https://edu.youkuaiyun.com/course/detail/27109

腾讯课堂连接地址https://ke.qq.com/course/484107?tuin=ba64518

介绍主要的k8s资源的使用配置和命令。包括configmap,pod,service,replicaset,namespace,deployment,daemonset,ingress,pv,pvc,sc,role,rolebinding,clusterrole,clusterrolebinding,secret,serviceaccount,statefulset,job,cronjob,podDisruptionbudget,podSecurityPolicy,networkPolicy,resourceQuota,limitrange,endpoint,event,conponentstatus,node,apiservice,controllerRevision等。

第三个视频发布:https://edu.youkuaiyun.com/course/detail/27574

详细介绍helm命令,学习helm chart语法,编写helm chart。深入分析各项目源码,学习编写helm插件
————————————————------------------------------------------------------------------------------------------------------------------

 

package com.data.struct;

import java.util.Random;

public class FloydWarshall {
	private Node [][]graphic;
	public FloydWarshall(int v,int e){
		graphic=new Node[v][v];
		for(int i=0;i<e;i++){
			int v1=new Random().nextInt(v);
			int v2=new Random().nextInt(v);
			Node node=new Node();
			node.w=new Random().nextInt(v)+1;
			node.start=v1;
			node.end=v2;
			graphic[v1][v2]=node;
		}
		for(int i=0;i<v;i++){
			if(graphic[i][i]==null){
				Node node=new Node();
				node.w=0;
				node.start=i;
				node.end=i;
				graphic[i][i]=node;
			}else{
				graphic[i][i].w=0;
			}
		}
		
	}
	
	public Node[][] floydWarshall(){
		Node [][][]f=new Node[graphic.length][graphic.length][graphic.length];
		f[0]=graphic;
		for(int k=1;k<graphic.length;k++){
			f[k]=new Node[graphic.length][graphic.length];
			for(int i=0;i<graphic.length;i++){
				for(int j=0;j<graphic.length;j++){
					Node node=new Node();
					node.w=Integer.MAX_VALUE;
					node.start=i;
					node.end=j;
					if(f[k-1][i][j]!=null&&f[k-1][i][k]!=null&&f[k-1][k][j]!=null){
						node.w=Math.min(f[k-1][i][j].w, f[k-1][i][k].w+f[k-1][k][j].w);
					}else if(f[k-1][i][j]!=null&&(f[k-1][i][k]==null||f[k-1][k][j]==null)){
						node.w=f[k-1][i][j].w;
					}else if(f[k-1][i][j]==null&&f[k-1][i][k]!=null&&f[k-1][k][j]!=null){
						node.w=f[k-1][i][k].w+f[k-1][k][j].w;
					}else {
						node=null;
					}
					f[k][i][j]=node;
				}
			}
		}
		return f[graphic.length-1];
	}
	public void print(){
		System.out.println("origranal:");
		for(int i=0;i<graphic.length;i++){
			for(int j=0;j<graphic.length;j++){
				if(graphic[i][j]!=null){
					System.out.print(graphic[i][j].w+" ");
				}else{
					System.out.print(" "+" ");
				}
			}
			System.out.println();
		}
		
		Node [][] l=floydWarshall();
		System.out.println("result:");
		for(int i=0;i<l.length;i++){
			for(int j=0;j<l.length;j++){
				if(l[i][j]!=null){
					System.out.print(l[i][j].w+" ");
				}else{
					System.out.print(" "+" ");
				}
			}
			System.out.println();
		}
	}
	
	private class Node{
		private int w;
		private int start;
		private int end;
	}
	public static void main(String[] args) {
		FloydWarshall f=new FloydWarshall(5,20);
		f.print();

	}

}
路径打印:

 
package com.data.struct; import java.util.Iterator; import java.util.Random; import java.util.TreeSet; public class FloydWarshall { private Node [][]graphic; private Node [][][]f; private TreeSet<Integer>[][] paths; public FloydWarshall(int v,int e){ graphic=new Node[v][v]; for(int i=0;i<e;i++){ int v1=new Random().nextInt(v); int v2=new Random().nextInt(v); Node node=new Node(); node.w=new Random().nextInt(v)+1; node.start=v1; node.end=v2; graphic[v1][v2]=node; } for(int i=0;i<v;i++){ if(graphic[i][i]==null){ Node node=new Node(); node.w=0; node.start=i; node.end=i; graphic[i][i]=node; }else{ graphic[i][i].w=0; } } f=new Node[graphic.length][graphic.length][graphic.length]; paths=new TreeSet[graphic.length][graphic.length]; } public Node[][] floydWarshall(){ //Node [][][]f=new Node[graphic.length][graphic.length][graphic.length]; f[0]=graphic; for(int k=1;k<graphic.length;k++){ f[k]=new Node[graphic.length][graphic.length]; for(int i=0;i<graphic.length;i++){ for(int j=0;j<graphic.length;j++){ Node node=new Node(); node.w=Integer.MAX_VALUE; node.start=i; node.end=j; if(f[k-1][i][j]!=null&&f[k-1][i][k]!=null&&f[k-1][k][j]!=null){ if(f[k-1][i][j].w< f[k-1][i][k].w+f[k-1][k][j].w){ node.w=f[k-1][i][j].w; node.parent=f[k-1][i][j]; }else{ node.w= f[k-1][i][k].w+f[k-1][k][j].w; node.parent=f[k-1][k][j]; } }else if(f[k-1][i][j]!=null&&(f[k-1][i][k]==null||f[k-1][k][j]==null)){ node.w=f[k-1][i][j].w; node.parent=f[k-1][i][j]; }else if(f[k-1][i][j]==null&&f[k-1][i][k]!=null&&f[k-1][k][j]!=null){ node.w=f[k-1][i][k].w+f[k-1][k][j].w; node.parent=f[k-1][k][j]; }else { node=null; } f[k][i][j]=node; } } } return f[graphic.length-1]; } public void pirntPath(){ for(int i=0;i<f[graphic.length-1].length;i++){ for(int j=0;j<f[graphic.length-1][i].length;j++){ if(f[graphic.length-1][i][j]!=null&&i!=j){ System.out.print("("+f[graphic.length-1][i][j].start+","+f[graphic.length-1][i][j].end+")"+":"+f[graphic.length-1][i][j].start+"->"); TreeSet<Integer> path=new TreeSet<Integer>(); path.add(f[graphic.length-1][i][j].start); paths[i][j]=path; Node p=f[graphic.length-1][i][j].parent; Node node=f[graphic.length-1][i][j]; int lever=graphic.length-3; if(p!=null){ if(p.parent==null){ System.out.print("("+node.start+","+p.start+")"+"=>"); }else{ recuisivePrintPath(p,lever,i,j); } } if(!path.contains(f[graphic.length-1][i][j].end)){ System.out.print(f[graphic.length-1][i][j].end); } System.out.println(); } } } } public void recuisivePrintPath(Node node,int level,int i,int j){ Node p=node.parent; TreeSet<Integer>path= paths[i][j]; if(f[level][node.start][p.start].parent!=null){ recuisivePrintPath(f[level][node.start][p.start],level-1,i,j); if(node.start!=p.start){ if(!path.contains(p.start)){ path.add(p.start); System.out.print(p.start+"->"); } } }else{ if(node.start!=p.start&&p.start!=p.end){ if(!path.contains(p.start)){ path.add(p.start); System.out.print(p.start+"->"); } } } Node n=f[level][p.start][p.end]; if(n.parent!=null&&n.parent.start!=n.parent.end){ recuisivePrintPath(n,level-1,i,j); } } public void print(){ System.out.println("origranal:"); for(int i=0;i<graphic.length;i++){ for(int j=0;j<graphic.length;j++){ if(graphic[i][j]!=null){ System.out.print(graphic[i][j].w+" "); }else{ System.out.print(" "+" "); } } System.out.println(); } Node [][] l=floydWarshall(); System.out.println("result:"); for(int i=0;i<l.length;i++){ for(int j=0;j<l.length;j++){ if(l[i][j]!=null){ System.out.print(l[i][j].w+" "); }else{ System.out.print(" "+" "); } } System.out.println(); } } private class Node{ private int w; private int start; private int end; private Node parent; } public static void main(String[] args) { FloydWarshall f=new FloydWarshall(5,20); f.print(); f.pirntPath(); } } 

 

 


 

 

 

 

Floyd-Warshall算法解决所有节点对最短路径问题 在本文中,我们深入探讨了Floyd-Warshall算法,这是解决所有节点对最短路径问题的经典算法。我们从算法原理、代码实现、空间复杂度优化、时间复杂度分析以及并行化优化等方面对其进行了全面的讨论。首先,我们介绍了Floyd-Warshall算法的原理,它利用动态规划的思想来逐步优化节点之间的路径长度,从而找到所有节点对之间的最短路径。然后,我们给出了Python的代码实现,通过邻接矩阵表示图,并利用三重循环来实现算法的核心部分。 阅读详情

相关推荐

使用floyd-warshall算法求解cube0交换函数和shuffle混洗函数构成混洗交换网,计算网络直径,两节点最短路径。

计算机系统结构教程(第二版)习题99.9(2) 用Cube0和构成混洗交换网(每步只能使用Cube0 和shuffle 一次),网络直径是多少?从5号处理机发送数据到7号处理机,最短路径要经过几步?请列出经过的处理机编号。构造交换网 for (i = 0; i &lt; 32; i++){ j = i ^ 0x0001; distance[i][j] = 1; distance[j][...

lying_byr的博客 2372

图算法之无权最短路径 - 基于Neo4j实现

1. 简介 本文基于Neo4j 3.5版本,采用嵌入式的方法开发,neo4j本身其实已经实现了最短路径算法,本文虽然基于neo4j实现,但是更多的是做算法思想的记录,同时本文讲解的最短路径为无权最短路径。 无权最短路径与带权最短路径不同,带权最短路径可能权重最小的路径并不是路径最短的路径。而无权最短路径,仅按路径长短来衡量,所以求最短路径最合适的方法为广度遍历。 一般网上描述的找最短路径的方法为,从起始点开始广度遍历,找到终止点时停止,这个方法并不是性能最高的方法,本文要说明的是从起始点和终止点双向开始进

玖涯博客 2475

Floyd-Warshall算法:用于解决所有节点对之间的最短路径问题

Floyd-Warshall算法是一种动态规划算法,用于解决图中所有节点对之间的最短路径问题。Floyd-Warshall算法是一种动态规划算法,用于解决图中所有节点对之间的最短路径问题。该Floyd-Warshall算法:解决所有节点对之间的最短路径问题。在上面的示例代码中,我们首先定义了一个4x4的图形矩阵,并将边的权重值存储在该矩阵中。在上面的示例代码中,我们首先定义了一个4x4的图形矩阵,并将边的权重值存储在该矩阵中。Floyd-Warshall算法:用于解决所有节点对之间的最短路径问题。

BugHunterX的博客 211

Neo4j命令语句知识计算(Neo4j Cypher Manual精选总结)最短路径搜索算法

AUraDB、查询语句、Syntax、Clauses、graph.db找不到

懒惰是科技进步的原始动力 1535

dijkstra最短路径算法的R语言实现

dijkstra算法的R语言实现。输入为邻接矩阵和权重矩阵。如果没有权重,则认为权重矩阵为邻接矩阵。输出为从源节点到网络其他节点的最短距离和最短路径。如果有多条最短路,可以选择同时输出多条路。

用邻接矩阵表示的图的Floyd算法的源程序

多核并行算法、用邻接矩阵表示的图的Floyd算法的源程序

neo4j 最短路径规划

1、用快速算法检索最短路径 match (n) ,(n1),p=shortestPath((n)-[r]-(n1)) where all (r in rels where exists(r.role)) return p 因为没有断言需要查看所有路径 2、使用穷举搜索 match (n),(n1),p=shortestPath ((n)-[*]-(n1)) where leng...

pan15125284的博客 2575

单源最短路径Leetcode-golang-algorithms:在Golang中实现的算法和数据结构,附有解释和进一步阅读的链接

单源驱动路径Leetcode Golang算法和数据结构以及LeetCode算法问题的Go解决方案 该存储库包含许多流行算法和数据结构的基于 Golang 的示例。 每个算法和数据结构都有自己单独的自述文件,其中包含相关解释和进一步阅读的链接(包括视频)。 用其他语言阅读: 数据结构 数据结构是在计算机中组织和存储数据的一种特殊方式,以便可以有效地访问和修改数据。 更准确地说,数据结构是数据值、它们之间的关系以及可应用于数据的功能或操作的集合。 B - 初级, A - 高级 B B B B B B - 最大和最小堆版本 B A A A A A A - 带有最小/最大/总和范围查询示例 A (二叉索引树) A (有向和无向) A A 算法 算法是如何解决一类问题的明确规范。 它是一组精确定义操作序列的规则。 B - 初级, A - 高级 按主题分类的算法 数学 B - 设置/获取/更新/清除位,乘以/除以二,使负等。 B B - 经典和封闭式版本 B (试分法) B - 计算最大公约数 (GCD) B (LCM) B - 找到任何给定限制内的所有质数 B - 检查数字是否为 2 的幂(朴

neo4j结合gds实现最短路径算法

gds最短路径

weixin_43632687的博客 2659

解决Visual C++2008安装失败,error 1935

重装系统后Visual C++没了,其他都能装上但VC2008会报这个error 1935。鉴于我把网上所有的解决方法排了一遍错,我也不知道是哪一步起效,所以就都放上来了。特别注意:报error 1935的错误原因可能不尽相同,比如我的报错开头为An error occurred,结尾为HRESULT:0x80070005。80070005 拒绝访问通常是权限问题,安装Visual C++无法写入文件夹或注册表(直接跳转第7步)

weixin_44427808的博客 1万+

Cadence仿真实战:从零构建高精度带隙基准电压源

本文是一份详细的Cadence仿真实战指南,指导读者从零开始构建高精度带隙基准电压源。文章首先解释了带隙基准电压源稳定输出电压的原理,然后逐步演示了在Cadence Virtuoso环境中如何搭建测试电路、测量关键温度系数、计算并搭建核心电路,并通过参数扫描和迭代调优来驯服温度漂移,最终实现低漂移的基准电压输出。

weixin_29207533的博客 244

Neo4j 图算法:最短路径与社区发现

基于贪心策略,适用于带权重的有向图,时间复杂度为 $O(|E| + |V|\log|V|)$$g(n)$ 为起点到 $n$ 的实际代价,$h(n)$ 为 $n$ 到终点的预估代价。其中 $A_{ij}$ 为邻接矩阵,$k_i$ 为节点 $i$ 的度,$m$ 为总边数。用于查找图中两点间的最短连接路径,适用于路由规划、社交关系挖掘等场景。用于识别图中紧密连接的子图(社区),适用于社交网络分析、推荐系统等。基于邻居标签投票机制,时间复杂度 $O(|E|)$。其中 $|V|$ 为节点数,$|E|$ 为边数。

2501_93894124的博客 521

如何免费访问和使用Gemini API?

Gemini Ultra具有最先进的性能,在几个指标上超过了GPT-4的性能。它是第一个在大规模多任务语言理解基准测试中超越人类专家的模型,该基准测试57个不同学科的世界知识和解决问题的能力。Gemini是谷歌迄今为止开发的最先进、最庞大的AI模型。它为多模态而建,理解并处理不同类型的数据,比如文本、代码、音频、图像和视频。下面我们将加载Masood Aslami的图像,并用它来测试Gemini Pro Vision的多模态性。有了Gemini可以为查询提供图像、音频和文本,获得几乎完美的答案。

java_cjkl的博客 1万+

第25章《所有节点对的最短路径》: Floyd-Warshall算法,python实现

最短路径 本节讨论有向图G=(V,E)G=(V,E)G=(V,E)上所有节点对最短路径问题的一种动态规划算法。 对于图G=(V,E)G=(V,E)G=(V,E)的所有节点对最短路径问题,一条最短路径的所有子路径都是最短路径。 Floyd-Warshall算法 我们使用一种不同的动态规划公式来解决所有节点对最短路径问题。所产生的算法称为Floyd-Warshall算法。Floyd-Warshall算法对带权重的无向图和有向图都起作用,但是图中不能有环中各边权重之和为负数的环路。 假设有一个graph图如下:

BGoodHabit的博客 958

RT-Thread网络编程:基于STM32F407的TCP客户端实现(含完整代码解析)

本文详细介绍了在STM32F407平台上,基于RT-Thread操作系统和LWIP协议栈实现工业级可靠TCP客户端的完整过程。内容涵盖底层ETH驱动配置、Socket编程、连接保活与断线重连机制、数据收发协议设计以及资源管理,提供了可应用于实际项目的健壮代码框架与调试技巧。

weixin_29184371的博客 494

YOLOv8改进,YOLOv8添加可变性卷积DCNv2

DCNv2对原始的DCNv1进行了改进,可变形卷积网络的卓越性能源于其适应对象几何变化的能力。通过对其自适应行为的检查,虽然对其神经特征的空间支持比常规的ConvNets更接近于对象结构,但这种支持可能远远超出感兴趣区域,导致特征受到不相关图像内容的影响。为了解决这个问题,我们提出了一种可变形卷积网的重新表述,通过提高建模能力和更强的训练,提高了其专注于相关图像区域的能力。通过更全面地集成网络中的可变形卷积,并引入扩展变形建模范围的调制机制,增强了建模能力。

在职AI算法工程师,擅长计算机视觉,YOLO目标检测、分割等,擅长web、pyqt界面可视化,好内容持续更新中,来这里跟大家一起学习,共同进步 3607

【算法导论】【Floyd-Warshall 算法】每对节点之间的最短路径

所有结点对的最短路径问题 目录 所有结点对的最短路径问题 计算最短路径权重 - Floyd 算法 邻接矩阵 最短路径的结构 所有结点对最短路径问题的一个递归解 自底向上计算最短路径权重 打印所有最短路径 前驱矩阵 打印最短路径 参考 问题:有一个带权有向图 G = (V, E),V 为图的顶点集合,E 为边的集合,权重函数为 w:E → R,该函数将边映射到

ideaqjx的博客 9467

【Proteus仿真】74HC595+74LS154驱动显示16X16点阵

【Proteus仿真】74HC595+74LS154驱动显示16X16点阵

perseverance51博客 2893

Floyd-Warshall 算法-- 最短路径(适合节点密集的图)

由于此算法时间复杂度为O(V³),大多数情况下不如迪杰斯特拉算法的,迪杰斯特拉算法适合于节点疏散的图。 示例图如下:  Step 1 创建节点与边的最短路径结果表(直接可达关系),数值表示距离,INF表示不可达   1 2 3 4 1 0 8 INF 1 2 INF 0 1 INF 3 4 INF 0 INF 4 INF 2 9

我的英文站点:https://iorilan.medium.com/ 3763

MathType公式使用技巧汇总——Mathtype怎么在word中编辑公式?论文中公式有哪技巧?有哪些注意事项?论文中的公式怎么写?

如果word中到公式编号(2-1)中间的符号如下图........ .......类似与省略号的,这是手动打的空格,公式和编号的位置都是手动敲空格操作的,这种就只是使用MathType写了公式而已,格式上还是很不方便的。**如果要修改公示,直接双击文档中的公式,就会自动弹出MathType公式编辑窗口,进行修改。如果要修改公示,直接双击文档中的公式,就会自动弹出MathType公式编辑窗口,进行修改。而第二种,是公式里面带的括号符号,他是可以随着公式结构自适应变化的。这时需要将公式插入到一行文字的某处,

程序员,他们想的是什么?他们想的永远都是技术,他们崇尚的也永远都是技术。 5万+

uniapp [全端兼容] - 实现接入集成高德地图搜索地址及选择位置功能,搜索框检索选择地点并返回经纬度及详细省市区县街道地址,用户搜索历史及清空历史记录,选择地址自动获取周边位置列表/地图移动选点

uni-app,高德地图,h5移动端网页,微信小程序,支付宝小程序,Android安卓,苹果ios,app,nvue,Uniapp高德地图,在地图上选择或搜索指定地点,打开地图选择位置,关联地址搜索,输入地址返回附近地址列表,uniApp高德地图地址搜索,搜索框历史记录,关键字搜索,周边查询,搜索位置,uniapp对接高德实现搜索出现地址以及保存搜索记录,集成高德地图,实现精准位置选点功能,获取当前定位城市,如何实现搜索功能,获取省份城市区街道详细地址经纬度,移动选点标记位置,在地图上进行选择位置选点、搜索

🏆 前端领域优质创作者 1万+

Floyd-Warshall算法---求解任意两节点的最短路径

算法描述:简称Floyd算法,是一种基于DP(Dynamic Programming)的最短路径算法,时间复杂度是O(V^3)。 精简版一般形式:void Floyd() { int i,j,k; for(k=1;k<=n;k++) for(i=1;i<=n;i++) for(j=1;j<=n;j++)

爱橙子的OK绷的专栏 1132

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

C语言 最短路径 弗洛伊德(Floyd)算法

弗洛伊德算法是一种解决图中多源最短路径问题的算法,可以求出图中任意两个节点之间的最短路径长度。该算法的时间复杂度为,空间复杂度为。需要指出的是,虽然弗洛伊德算法能够解决任意两个节点之间的最短路径问题,但在某些情况下可能不是最优解。因此,在实际使用中,需要根据具体需求选择合适的算法。总之,弗洛伊德算法作为图论领域中的经典算法,其思想和方法都值得我们深入学习和掌握,以便能够更好地应对实际问题。

m0_73070900的博客 5271

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Floyd-Warshall(弗洛伊德)算法求所有节点对的最短路径问题

参考博客http://www.cnblogs.com/skywang12345/p/3711526.html 1.基本定义 class MatrixUDG { #define MAX 100 #define INF (~(0x1<<31)) // 无穷大(即0X7FFFFFFF) private: char mVexs[MAX]

Ethan的博客 1647

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

上一篇: 所有节点对的最短路径
下一篇: 有向图的传递闭包
hxpjava1
博客等级 码龄19年 1365粉丝 511原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hxpjava1

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值