floyd算法

最新推荐文章于 2023-03-13 21:49:48 发布
最新推荐文章于 2023-03-13 21:49:48 发布
阅读量403 收藏
点赞数
分类专栏： 算法 C语言 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38139533/article/details/126683393
版权

floyd算法

源码

#define _CRT_SECURE_NO_WARNINGS //处理scanf报错问题
#include <stdio.h>
#include <windows.h>

#define DEBUG_SWITCH 1
#if DEBUG_SWITCH
#define DEBUG_INFO(format, ...) printf("LINE: %d: "format"\n", __LINE__, ##__VA_ARGS__)
#else
#define DEBUG_INFO(format, ...) 
#endif

#define TRUE  1
#define FALSE 0

#define UINT64_MAX (0XFFFFFFFFFFFFFFFF)
#define UINT32_MAX (0XFFFFFFFF)
#define UINT16_MAX (0XFFFF)
#define UINT8_MAX  (0XFF)

typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned long int uint32_t;
typedef unsigned long long int uint64_t;

#define GET_ARR_SIZE(arr,type) (sizeof(arr)/sizeof(type))
#define GET_ARR_2D_DATA(ARR, X, Y, X_MAX, Y_MAX) ARR[((((X) < (X_MAX) ? (X) : (X_MAX))) * (Y_MAX)) + ((Y) < (Y_MAX) ? (Y) : (Y_MAX))]
#define INF (UINT64_MAX >> 2)

typedef struct intrm_struct
{
	uint64_t consume;
	uint64_t pre_node;
}intrm_def;

typedef struct floyd_struct
{
	intrm_def *matrix_addr;
	uint64_t node_num;
	uint64_t (*node_index)(uint64_t node_index);
	uint64_t (*get_consume)(struct floyd_struct *data, uint64_t start_node, uint64_t end_node);
	void (*callback_path)(struct floyd_struct *data);
	void (*callback_path_output)(struct floyd_struct *data, uint64_t start_node, uint64_t end_node, uint64_t *path_node, uint64_t *path_node_num);
}floyd_def;

void floyd_path(floyd_def *data)
{
	for (uint64_t k = 1; k <= data->node_num; ++k)
	{
		for (uint64_t i = 1; i <= data->node_num; ++i)
		{
			for (uint64_t j = 1; j <= data->node_num; ++j)
			{
				if (GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(j), data->node_num, data->node_num).consume >
					(GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(k), data->node_num, data->node_num).consume 
						+ GET_ARR_2D_DATA(data->matrix_addr, data->node_index(k), data->node_index(j), data->node_num, data->node_num).consume))
				{
					GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(j), data->node_num, data->node_num).consume = 
						GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(k), data->node_num, data->node_num).consume 
						+ GET_ARR_2D_DATA(data->matrix_addr, data->node_index(k), data->node_index(j), data->node_num, data->node_num).consume;
					GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(j), data->node_num, data->node_num).pre_node = k;
				}
			}
		}
	}
}

void floyd_path_output(floyd_def *data, uint64_t start_node, uint64_t end_node, uint64_t *path_node, uint64_t *path_node_num)
{
	uint64_t k = GET_ARR_2D_DATA(data->matrix_addr, data->node_index(start_node), data->node_index(end_node), data->node_num, data->node_num).pre_node;
	path_node[(*path_node_num)++] = end_node;
	while (k != start_node)
	{
		path_node[(*path_node_num)++] = k;
		k = GET_ARR_2D_DATA(data->matrix_addr, data->node_index(start_node), data->node_index(k), data->node_num, data->node_num).pre_node;
	}
	path_node[(*path_node_num)++] = start_node;
}

uint64_t node_index(uint64_t node_index)
{
	return (node_index - 1);
}

uint64_t get_consume(floyd_def *data, uint64_t start_node, uint64_t end_node)
{
	return (GET_ARR_2D_DATA(data->matrix_addr, data->node_index(start_node), data->node_index(end_node), data->node_num, data->node_num).consume);
}

#define NODE_NUM 6
#define EDGE_NUM 9
#define MATRIX_SIZE (NODE_NUM * NODE_NUM)

int main()
{
	static intrm_def matrix[MATRIX_SIZE];

	uint64_t path_node_num = 0;
	uint64_t path_node[NODE_NUM] = { 0 };
	floyd_def floyd_data;
	floyd_data.matrix_addr = matrix;
	floyd_data.node_num = NODE_NUM;
	floyd_data.callback_path = floyd_path;
	floyd_data.callback_path_output = floyd_path_output;
	floyd_data.node_index = node_index;
	floyd_data.get_consume = get_consume;

	for (uint64_t x = 0; x < NODE_NUM; x++)
	{
		for (uint64_t y = 0; y < NODE_NUM; y++)
		{
				GET_ARR_2D_DATA(matrix, x, y, NODE_NUM, NODE_NUM).consume = (x == y) ? 0 : INF;
				GET_ARR_2D_DATA(matrix, x, y, NODE_NUM, NODE_NUM).pre_node = 1 + x;
		}
	}
	
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(1), floyd_data.node_index(2), NODE_NUM, NODE_NUM).consume = 1;
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(1), floyd_data.node_index(3), NODE_NUM, NODE_NUM).consume = 12;
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(2), floyd_data.node_index(3), NODE_NUM, NODE_NUM).consume = 9;
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(2), floyd_data.node_index(4), NODE_NUM, NODE_NUM).consume = 3;
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(3), floyd_data.node_index(5), NODE_NUM, NODE_NUM).consume = 5;
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(4), floyd_data.node_index(3), NODE_NUM, NODE_NUM).consume = 4;
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(4), floyd_data.node_index(5), NODE_NUM, NODE_NUM).consume = 13;
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(4), floyd_data.node_index(6), NODE_NUM, NODE_NUM).consume = 15;
	GET_ARR_2D_DATA(matrix, floyd_data.node_index(5), floyd_data.node_index(6), NODE_NUM, NODE_NUM).consume = 4;

	for (uint64_t x = 0; x < NODE_NUM; x++)
	{
		for (uint64_t y = 0; y < NODE_NUM; y++)
		{
			printf("[%2lld] ", (GET_ARR_2D_DATA(matrix, x, y, NODE_NUM, NODE_NUM).consume >= INF) ? UINT64_MAX : GET_ARR_2D_DATA(matrix, x, y, NODE_NUM, NODE_NUM).consume);
		}
		printf("\r\n");
	}
	printf("---------------------------\r\n");

	floyd_data.callback_path(&floyd_data);

	for (uint64_t x = 0; x < NODE_NUM; x++)
	{
		for (uint64_t y = 0; y < NODE_NUM; y++)
		{
			printf("[%2lld] ", (GET_ARR_2D_DATA(matrix, x, y, NODE_NUM, NODE_NUM).consume >= INF) ? UINT64_MAX : GET_ARR_2D_DATA(matrix, x, y, NODE_NUM, NODE_NUM).consume);
		}
		printf("\r\n");
	}
	printf("---------------------------\r\n");

	for (uint64_t x = 0; x < NODE_NUM; x++)
	{
		for (uint64_t y = 0; y < NODE_NUM; y++)
		{
			printf("[%2lld] ", (GET_ARR_2D_DATA(matrix, x, y, NODE_NUM, NODE_NUM).pre_node >= INF) ? UINT64_MAX : GET_ARR_2D_DATA(matrix, x, y, NODE_NUM, NODE_NUM).pre_node);
		}
		printf("\r\n");
	}
	printf("---------------------------\r\n");

	for (uint64_t i = 1; i <= NODE_NUM; ++i)
	{
		path_node_num = 0;
		floyd_path_output(&floyd_data, 1, i, path_node, &path_node_num);
		printf("%lld -> %lld consume:%lld  path:",(uint64_t)1, i, floyd_data.get_consume(&floyd_data, 1, i));
		for (uint64_t j = path_node_num; j > 0; j--)
		{
			printf("[%d]", path_node[j - 1]);
		}
		printf("\r\n");
	}
}

使用

句柄说明

typedef struct intrm_struct
{
	uint64_t consume;  //经过该节点的消耗/距离
	uint64_t pre_node; //上一节点
}intrm_def; //中转点(邻接矩阵节点)

typedef struct floyd_struct
{
	intrm_def *matrix_addr; //邻接矩阵
	uint64_t node_num;		//节点数量
	uint64_t (*node_index)(uint64_t node_index);//节点和矩阵下标索引转换接口
	uint64_t (*get_consume)(struct floyd_struct *data, uint64_t start_node, uint64_t end_node);//获取从某节点到某节点的消耗/距离
	void (*callback_path)(struct floyd_struct *data);//floyd算法
	void (*callback_path_output)(struct floyd_struct *data, uint64_t start_node, uint64_t end_node, uint64_t *path_node, uint64_t *path_node_num);//获取从某节点到某节点的路径,倒序
}floyd_def; //floyd句柄

定义floyd句柄并初始化


void floyd_path(floyd_def *data)
{
	for (uint64_t k = 1; k <= data->node_num; ++k)
	{
		for (uint64_t i = 1; i <= data->node_num; ++i)
		{
			for (uint64_t j = 1; j <= data->node_num; ++j)
			{
				if (GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(j), data->node_num, data->node_num).consume >
					(GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(k), data->node_num, data->node_num).consume 
						+ GET_ARR_2D_DATA(data->matrix_addr, data->node_index(k), data->node_index(j), data->node_num, data->node_num).consume))
				{
					GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(j), data->node_num, data->node_num).consume = 
						GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(k), data->node_num, data->node_num).consume 
						+ GET_ARR_2D_DATA(data->matrix_addr, data->node_index(k), data->node_index(j), data->node_num, data->node_num).consume;
					GET_ARR_2D_DATA(data->matrix_addr, data->node_index(i), data->node_index(j), data->node_num, data->node_num).pre_node = k;
				}
			}
		}
	}
}

void floyd_path_output(floyd_def *data, uint64_t start_node, uint64_t end_node, uint64_t *path_node, uint64_t *path_node_num)
{
	uint64_t k = GET_ARR_2D_DATA(data->matrix_addr, data->node_index(start_node), data->node_index(end_node), data->node_num, data->node_num).pre_node;
	path_node[(*path_node_num)++] = end_node;
	while (k != start_node)
	{
		path_node[(*path_node_num)++] = k;
		k = GET_ARR_2D_DATA(data->matrix_addr, data->node_index(start_node), data->node_index(k), data->node_num, data->node_num).pre_node;
	}
	path_node[(*path_node_num)++] = start_node;
}

uint64_t node_index(uint64_t node_index)
{
	return (node_index - 1);
}

uint64_t get_consume(floyd_def *data, uint64_t start_node, uint64_t end_node)
{
	return (GET_ARR_2D_DATA(data->matrix_addr, data->node_index(start_node), data->node_index(end_node), data->node_num, data->node_num).consume);
}

int main()
{
#define NODE_NUM 6
#define EDGE_NUM 9
#define MATRIX_SIZE (NODE_NUM * NODE_NUM)
	floyd_def floyd_data;
	floyd_data.matrix_addr = matrix;
	floyd_data.node_num = NODE_NUM;
	floyd_data.callback_path = floyd_path;
	floyd_data.callback_path_output = floyd_path_output;
	floyd_data.node_index = node_index;
	floyd_data.get_consume = get_consume;
}

初始化邻接矩阵数据

在这里插入图片描述

GET_ARR_2D_DATA(matrix, floyd_data.node_index(1), floyd_data.node_index(2), NODE_NUM, NODE_NUM).consume = 1;
GET_ARR_2D_DATA(matrix, floyd_data.node_index(1), floyd_data.node_index(3), NODE_NUM, NODE_NUM).consume = 12;
GET_ARR_2D_DATA(matrix, floyd_data.node_index(2), floyd_data.node_index(3), NODE_NUM, NODE_NUM).consume = 9;
GET_ARR_2D_DATA(matrix, floyd_data.node_index(2), floyd_data.node_index(4), NODE_NUM, NODE_NUM).consume = 3;
GET_ARR_2D_DATA(matrix, floyd_data.node_index(3), floyd_data.node_index(5), NODE_NUM, NODE_NUM).consume = 5;
GET_ARR_2D_DATA(matrix, floyd_data.node_index(4), floyd_data.node_index(3), NODE_NUM, NODE_NUM).consume = 4;
GET_ARR_2D_DATA(matrix, floyd_data.node_index(4), floyd_data.node_index(5), NODE_NUM, NODE_NUM).consume = 13;
GET_ARR_2D_DATA(matrix, floyd_data.node_index(4), floyd_data.node_index(6), NODE_NUM, NODE_NUM).consume = 15;
GET_ARR_2D_DATA(matrix, floyd_data.node_index(5), floyd_data.node_index(6), NODE_NUM, NODE_NUM).consume = 4;

调用floyd

floyd_data.callback_path(&floyd_data);

输出

for (uint64_t i = 1; i <= NODE_NUM; ++i)
{
	path_node_num = 0;
	floyd_path_output(&floyd_data, 1, i, path_node, &path_node_num);
	printf("%lld -> %lld consume:%lld  path:",(uint64_t)1, i, floyd_data.get_consume(&floyd_data, 1, i));
	for (uint64_t j = path_node_num; j > 0; j--)
	{
		printf("[%d]", path_node[j - 1]);
	}
	printf("\r\n");
}

在这里插入图片描述

参考

参考

夜雪-初霁
关注
专栏目录
(建议收藏)一文多图，彻底搞懂Floyd算法(多源最短路径)
bigsai
08-27 3万+
前言 在图论中，在寻路最短路径中除了Dijkstra算法以外，还有Floyd算法也是非常经典，然而两种算法还是有区别的，Floyd主要计算多源最短路径。 在单源正权值最短路径，我们会用Dijkstra算法来求最短路径，并且算法的思想很简单—贪心算法:每次确定最短路径的一个点然后维护(更新)这个点周围点的距离加入预选队列，等待下一次的抛出确定。虽然思想很简单，实现起来是非常复杂的，我们需要邻接矩阵(表)储存长度，需要优先队列(或者每次都比较)维护一个预选点的集合。还要用一个boolean数组标记是否已经确定、
Floyd算法
weixin_45837693的博客
11-15 931
1、算法介绍 1，从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。 2，对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。 把图用邻接矩阵G表示出来，如果从Vi到Vj有路可达，则G[i][j]=d，d表示该路的长度；否则G[i][j]=无穷大。定义一个矩阵D用来记录所插入点的信息，D[i][j]表示从Vi到Vj需要经过的点，初始化D[i][j]=j。把各个顶点插入图中，比较插点后的距离与原来的距离，G
Floyd算法分析
weixin_48916083的博客
11-06 1407
Floyd最短路径算法python实现
Floyd 算法介绍
实践求真知
07-08 1395
如果求解任意两个节点之间的最短路径，则需要以每个节点为源点，重复调用 n 次 DijKstra 算法。其实是完全没有必要这么麻烦，Floyd 算法可用于求解任意两个节点之间的最短距离。Floyd 算法又被称为插点法，其核心思想是在节点 i 与 j 之间插入节点 k，看看是否可以缩短节点 i 和 j 之间的距离。设置地图带权邻接矩阵为 G.Ege[][],即如果从节点 i 到节点 j 有边，则 G.Ege[i][j]=的权值，否则 G.Ege[i][j]=无穷大；采用两个辅助数组：最短距离数组dis...
Floyd算法求解最短路径
最新发布
冲出仁川，走出马德里，故事还会再继续
03-13 9308
Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德。核心思路：通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。算法过程：从任意一条单边路径开始。左右两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。对于每一对顶点u和v，看是否存在一个顶点w使得从u到w再到v比已知的路径更短，如果更短，则更新它。上述概念来源于百度百科。
Floyd算法解析
weixin_46890451的博客
06-04 4043
1、基本介绍 在带权有向图中，经常需要求解最短路径问题，Floyd算法即是用于求解图中任意两顶点间的最短路径。 2、算法思想 在谈算法过程前，我们需要先大概理解它的思路：图中一个顶点到另一个顶点的路径认为有两种，第一种是直接连接，即从起始点连接到终点；第二种是间接连接，即通过中间点将两者连接起来。而Floyd算法的任务即是比较这两种路径，选择出长度较短的路径。 3、具体实现 为了比较比较两种 4、物理结构 根据思路，我们需要频繁比较两顶点间的权值，故采用邻接矩阵。同时，该算法需要建立两个二维数组，A数组记录
FLOYD算法介绍
weixin_41568030的博客
09-05 220
刚刚（就在十秒钟前），我把floyd算法CSP-J的专题模拟测试题解写好了 那么对于FLOYD算法，你真的了解吗（呵呵，标题党） emmm我我的意思是你真的悟到了FLOYD算法的本质然后去做题吗？ 而不是单单把三重循环的顺序和模板背下来就把题目AC了？ 很多时候，我们无法（也不可能，不需要）带着所有算法的精神做题目，就需要把模板封装起来记住这个板子有什么用然后随手念来 这个FLOYD算法就是这样，你这次弄懂了下次就只需要背下来就行了 这样，你既容易记住模板，有方便你进行变通（也就是使用FLOYD
Floyd算法与Dijkstra算法的区别
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
12-14 3313
根据D，假如D(5,1)=3则说明从V5到V1经过V3，路径为{V5,V3,V1}，如果D(5,3)=3，说明V5与V3直接相连，如果D(3,1)=1，说明V3与V1直接相连。同时，买卖股票的数量也有一定的规定：即委托买人股票的数量必须是100的整倍数，但委托卖出股票的数量则可以不是100的整倍。除了柜台递单委托方式是由柜台的工作人员确认你的身份外，其余3种委托方式则是通过你的交易密码来确认你的身份，所以一定要好好保管你的交易密码，以免泄露，给你带来不必要的损失。4.回报分析：公司给股东的回报高吗？
python实现Floyd算法
09-20
Floyd算法，又称Floyd-Warshall算法，是一种解决图中所有顶点对之间最短路径问题的动态规划算法。它通过逐步考虑所有可能的中间节点来更新最短路径信息。Python实现Floyd算法的核心在于通过三重循环来迭代所有顶点，...
java实现Floyd算法
08-28
"java实现Floyd算法" Floyd算法是一种用于解决多源最短路径问题的算法，它可以计算出所有节点之间的最短距离。该算法的思路是首先初始化距离矩阵，然后从第一个点开始逐渐更新矩阵点值。d[i][j]表示从i点到j点的...
C语言实现Floyd算法
08-28
C语言实现Floyd算法 本文主要介绍了使用C语言实现Floyd算法，详细讲解了该算法的实现步骤和代码实现。Floyd算法是一种常用的图算法，用于解决最短路径问题。该算法的核心思想是通过对图中的所有顶点进行遍历，计算...
floyd算法实现思路及实例代码
09-04
Floyd算法，也被称为Floyd-Warshall算法，是一种经典的图论算法，主要用于解决图中所有顶点对之间的最短路径问题。该算法基于动态规划的思想，通过逐步考虑中间节点来更新最短路径信息。其核心在于三重循环，依次...
C语言从放弃到入门
雪夜的博客
09-09 4973
目录重新了解C语言数据类型大小编译器与语言标准 重新了解C语言 数据类型大小 编译器在给每个不同数据类型分配内存空间大小时与电脑所装操作系统位数(32位/64位)无关,与所用的编译器有关. 内存的分配由编译器决定的而与运行的环境无关. 编译器与语言标准 各个编译器对C语言的标准不一样,不同的编译器对C语言标准的支持不一样,有的编译器仅支持C89标准,而有的编译器能支持C99标准. gcc编译器对C...
内核打印调试printk学习笔记
雪夜的博客
10-26 2480
内核打印调试printk学习笔记Printk打印格式与打印等级打印数据打印等级日志级别(loglevel)修改控制台打印等级控制台、终端和串口之间的关系终端(terminal)与控制台(console)控制台与串口嵌入式平台下的console查看和重映射伪终端 Printk打印格式与打印等级 打印数据 打印数据格式(跟printf类似、不支持浮点型) 打印指针 %p:打印指针地址 %pF:打印函数指针的函数名和偏移地址 %pf:只打印函数指针的函数名，不打印偏移地址 …
GNU编码风格学习
雪夜的博客
03-27 540
GNU编码风格学习函数顶头写空格对齐命名 函数顶头写 函数返回类型单独占一行 空格 左括号之前 逗号之后 运算符两边 对齐 函数参数换行并对齐 命名 函数名、变量名小写,下划线分割 宏定义、枚举常量大写 ...
快速排序算法
雪夜的博客
08-28 459
快速排序
KMP算法
雪夜的博客
09-16 400
KMP算法

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值