图的最短路径算法（Dijkstra,SPFA,Bellman_Ford,Floyd）(迪杰斯特拉算法,Spfa算法,贝尔曼-福特算法,弗洛伊德算法)(超详代码注释+例题)(使用C/C++)

置顶 已于 2024-07-25 20:55:11 修改
阅读量914 收藏 7
点赞数 28
分类专栏： c++算法 文章标签： 算法 c++ 笔记
于 2024-07-24 20:45:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he10101/article/details/140671247
版权

目录

Dijkstra迪杰斯特拉算法

可行性证明

写法

时间复杂度

例题

描述

输入描述

输出描述

样例

输入用例

输出用例

写法

Spfa算法

写法

例题

描述

输入描述

输出描述

样例

输入用例

输出用例

写法

Bellman_Ford算法(贝尔曼-福特算法)

写法

例题

描述

输入描述

输出描述

样例

输入样例

输出样例

写法

Floyd算法(弗洛伊德算法)

写法

例题

描述

输入描述

输出描述

样例

输入描写

输出描写

写法

谢谢大家

Dijkstra迪杰斯特拉算法

迪杰斯特拉算法(Dijkstra)是由迪杰斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。

缺点：在负权图中无法使用(SPFA,Bellman_Ford皆可)

可行性证明

dis[i]表示点i到起点的距离。
队列中存在若干点，其中dis[i]最小。
假设i出队后，并不是最短路。即存在一点j使得dis[i]变得更小，则有：dis[i]>dis[j]+w。
又因为dis[j]>=dis[i]，当w>0时，该不等式不成立。因此点i出队后，一定找到i到起点的最短路。

写法

核心：根据已知最短路径来更新未知点

在BFS中定义小根堆优先队列，并且利用pair建立两个变量(点n距离1的值,点n)

1. 初始化所有点到起点1的距离为正无穷，且dis[1]=0。
2. 将起点信息(0,1)入队进行bfs拓展，将起点相连点入队，即(3,2)，（5,3）入队。更新点2,3的距离信息。
3. 继续拓展节点2，3，将(6,4)，(9,4)以及(119,5)入队。此时队首为(5,4)，将该节点出队，得到dis[4]=5。
4. 继续拓展，直到终点出队，BFS循环结束

时间复杂度

朴素写法：O(n^2)

优化写法：O((n+m) logm)

例题

描述

给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值(边权小于10000)。
请你求出1号点到n号点的最短距离。如果无法从1号点走到n号点，则输出-1。

输入描述

第一行包含整数n和m(n<=1e5,m<=2e5)。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出描述

输出一个整数，表示1号点到n号点的最短距离
如果路径不存在，则输出-1。

样例

输入用例
3 3
1 2 2
2 3 1
1 3 4
输出用例
3

写法

本题如果用朴素的dijkstra算法，按O(n^2)算的话，1e5*1e5一定会超时，故用优化算法

上优化后算法

#include<bits/stdc++.h>
using namespace std;
#pragma GCC s
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC fast
//优化程序运行效率 
void read(int &x) {
	x=0;
	int flag=1;
	char ch=getchar();
	for(; ch<'0'||ch>'9';) {
		if(ch=='-') flag=-1;
		ch=getchar();
	}
	for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
	x=x*flag;
}//快读进行常数优化 
const int N=1e5+5;
int dis[N],n,m;
int h[N],nx[N*2],v[N*2],w[N*2],tot;
bool vis[N];
//n*2原型：n*(n-1)=m,n为节点数,m为一个图的最大边数
priority_queue <pair <int,int> ,vector<pair <int,int> >,greater<pair <int,int> > > q;
/*
	优先队列大根堆写法：priority_queue < pair<int,int> > q; 
	优先队列小根堆写法：priority_queue <pair <int,int> ,vector<pair <int,int> >,greater<pair <int,int> > > q;
*/
void add(int x,int y,int z) {
	tot++;
	v[tot]=y;
	w[tot]=z;
	nx[tot]=h[x];
	h[x]=tot;
}//邻接表记录图的关系
void dijkstra(int x) {
	memset(dis,0x3f,sizeof dis);
    /*
	    1. 首先,memset()是按内存地址命名的,故用0x3f;
	    2. memset()中的0x3f赋完值后,dis[]中的数字是为0x3f3f3f3f,而int的最大值为0x7f7f7f7f,
	    为了防止两个标记的数组值相加导致爆int,故对半开为0x3f3f3f3f 
	*/ 
	dis[x]=0;//出发点到出发点的距离是0 
	q.push({0,x});//放入队列
	while(!q.empty()) {//队列为空时代表遍利完成 
		pair <int,int> tmp;
		tmp=q.top();//取得队列的第一位 
		q.pop();//弹出队列的第一位 
		vis[tmp.second]=1;//vis标记,防止二次入队,降低时间复杂度 
		for(int i=h[tmp.second]; i; i=nx[i]) {
			if(vis[v[i]]==0/*vis标记检查(==0代表没入队),防止二次入队,降低时间复杂度 */&&dis[v[i]]>dis[tmp.second]+w[i]) {
				dis[v[i]]=dis[tmp.second]+w[i];
				q.push({dis[v[i]],v[i]});//入队 
			}
		}
	}
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
    //优化程序 
	read(n);
	read(m);
	for(int i=1; i<=m; i++) {
		int x;
		int y;
		int z;
		read(x);
		read(y);
		read(z);
		add(x,y,z);
	}
	dijkstra(1);//进行遍历
	if(dis[n]==0x3f3f3f3f) cout<<-1;//如果没有被访问证明不联通，故输出-1 
	else cout<<dis[n];
	return 0;
}

Spfa算法

SPFA就是由无权图的BFS转化而来。在无权图中，BFS首先到达的顶点所经历的路径一定是最短路(也就是经过的最少顶点数)，所以此时利用数组记录节点访问可以使每个顶点只进队一次，但在带权图中，最先到达的顶点所计算出来的路径不一定是最短路。一个解决是放弃数组，此时所需时间自然就是指数的，所以我们不能放弃数组，而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时，直接更新最优解。

缺点：在菊花图(下图)中，时间复杂度飘升至O(mn)(m为边数，n为点数)与Bellman_Ford的时间复杂度相同，也不能无法解决限制变数的问题(Bellman_Ford 可以)

不过在正常情况下时间复杂度为O(km) (在稀疏图中一般小于等于2)

写法


在求解各点到起点的最小距离dis值时，若某点i产生一个更小的dis[i]，那么节点i后续指向的节点都会重新更新，因此我们可以将该点i再次入队，重新更新即可。

例题

描述

给定一个n个点m条边(n<=1e5,m<=2e5)的有向图，图中可能存在重边和自环，边权绝对值小于104。数据保证图中不存在负权回路。

请你求出1号点到n号点的最短距离。如果无法从1号点走到n号点，则输出-1。

输入描述

第一行包含整数n和m(n<=1e5,m<=2e5)。

接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出描述

输出一个整数，表示1号点到n号点的最短距离
如果路径不存在，则输出-1。

样例

输入用例
3 3
1 2 1
2 3 2
1 3 1
输出用例
1

写法

#include<bits/stdc++.h>
using namespace std;
#pragma GCC s
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC fast
//优化程序运行效率 
void read(int &x) {
	x=0;
	int flag=1;
	char ch=getchar();
	for(; ch<'0'||ch>'9';) {
		if(ch=='-') flag=-1;
		ch=getchar();
	}
	for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
	x=x*flag;
}//快读进行常数优化 
const int N=1e5+5;
int dis[N],n,m;
int h[N],nx[N*2],v[N*2],w[N*2],tot;
bool vis[N];
//n*2原型：n*(n-1)=m,n为节点数,m为一个图的最大边数
queue<int>q;
void add(int x,int y,int z) {
	tot++;
	v[tot]=y;
	w[tot]=z;
	nx[tot]=h[x];
	h[x]=tot;
}//邻接表记录图的关系 
void spfa(int x) {
	memset(dis,0x3f,sizeof dis);
	/*
	1. 首先,memset()是按内存地址命名的,故用0x3f;
	2. memset()中的0x3f赋完值后,dis[]中的数字是为0x3f3f3f3f,而int的最大值为0x7f7f7f7f,
	为了防止两个标记的数组值相加导致爆int,故对半开为0x3f3f3f3f 
	*/ 
	dis[x]=0;//出发点到出发点的距离是0 
	q.push(x);//放入队列 
	vis[x]=1;//vis标记,防止二次入队,降低时间复杂度
	while(!q.empty()) {
		int tmp=q.front();//取得队列的第一位 
		q.pop();//弹出队列的第一位 
		vis[tmp]=0;//vis出队标记
		for(int i=h[tmp];i; i=nx[i]) {
			if(dis[v[i]]>dis[tmp]+w[i]) {
				dis[v[i]]=dis[tmp]+w[i];
				if(vis[v[i]]==0) {//vis标记检查(==0代表没入队),防止二次入队,降低时间复杂度 
					vis[v[i]]=1;//vis入队标记
					q.push({v[i]});//入队 
				}
			}
		}
	}
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	//优化程序 
	read(n);
	read(m);
	for(int i=1; i<=m; i++) {
		int x;
		int y;
		int z;
		read(x);
		read(y);
		read(z);
		add(x,y,z);
	}
	spfa(1);
	if(dis[n]==0x3f3f3f3f) cout<<-1;//如果没有被访问证明不联通，故输出-1 
	else cout<<dis[n];
	return 0;
}

Bellman_Ford算法(贝尔曼-福特算法)

遇到有限制边数的题可采用bellman_ford，从起点开始，每一次循环只更新一次，更新出新的最小值。

时间复杂度为O(nm)。

写法

如果只使用一个dis数组进行存储的话 ，在面对下图的时候，会更新多个节点，这不满足我们的需要。

而为了解决此问题，我们建立了一个dis_old数组进行存储，将dis数组第i轮的操作后得到的值，完整复制到dis_old数组，用此数组和dis数组进行处理，就可以避免一次循环更新多个节点的问题了。

下图为dis数组和dis_old数组用上图样例进行更新时候的过程。

——12345
tmp∞∞∞∞∞
dis0∞∞∞∞
————————————
tmp0∞∞∞∞
dis01∞∞∞
————————————
tmp01∞∞∞
dis013∞∞
————————————
tmp013∞∞
dis0136∞
————————————
tmp0136∞
dis013610
————————————

例题

描述

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。

输入描述

第一行包含三个整数 n,m,k。

接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x
到点 y 的有向边，边长为 z。

点的编号为 1∼n。

输出描述

输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

样例

输入样例
3 3 1
1 2 1
2 3 1
1 3 3
输出样例
3

写法

#include<bits/stdc++.h>
using namespace std;
#pragma GCC s
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC fast
//优化程序
void read(int &x) {
	x=0;
	int flag=1;
	char ch=getchar();
	for(; ch<'0'||ch>'9';) {
		if(ch=='-') flag=-1;
		ch=getchar();
	}
	for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
	x=x*flag;
}//快读进行常数优化 
int n,m,k,dis[505],tmp[505];//俩数组,用来记录和复制 
struct node {
	int x;
	int y;
	int z;
} t[10005];//记录边的两顶点,边权 
void bellman_ford(int x) {
	memset(dis,0x3f,sizeof(dis));
	/*
		优先队列大根堆写法：priority_queue < pair<int,int> > q; 
		优先队列小根堆写法：priority_queue <pair <int,int> ,vector<pair <int,int> >,greater<pair <int,int> > > q;
	*/
	dis[x]=0;//出发点到出发点的距离是0
	for(int i=0; i<k; i++) {//模拟边数 
		memcpy(tmp,dis,sizeof(tmp));//复制数组 
		for(int j=1; j<=m; j++) {//枚举边 
			int x=t[j].x;
			int y=t[j].y;
			int w=t[j].z;
			dis[y]=min(dis[y],tmp[x]+w);//找最小值 
		}
	}
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	//优化程序 
	read(n);
	read(m);
	read(k);
	for(int i=1; i<=m; i++) {
		read(t[i].x);
		read(t[i].y);
		read(t[i].z);
	}
	bellman_ford(1);
	if(dis[n]>=0x3f3f3f3f/2) cout<<"impossible";
	/*
		由于负边权的存在初始化的值可能被减小
		但题目中负边权的值一般不会小于 -5e8,故用 dis[n]>=0x3f3f3f3f/2
	*/
	else cout<<dis[n];
	return 0;
}

Floyd算法(弗洛伊德算法)

写法

因为Floyd算法的时间复杂度为O(n^3),故用邻接矩阵即可(之前的三种算法都要邻接表)

floyd算法核心原理：我们可以用一个二维矩阵表示两点之间的最短路径，即我们只需要维护图中最小距离的邻接矩阵。

只有在两点路径间插入一个中间点，才可能使得两点距离减小。如：3->4，距离为11，插入中间节点1后3->1->4，变成10。
因此，每加入一个中间点k，矩阵中有些点对的距离就有可能减小。同时也说明两点的最短路径链上就可能会增加该中间点k。
当所有点都作为中间点加入且完成矩阵的更新后，最终矩阵一定存储任意两点之间的距离最小值。

模拟3->4的最短路径

初始矩阵

终点1终点2终点3终点4
出发点1003f3f3f3f03f3f3f3f2        
出发点21003f3f3f3f6
出发点383011
出发点403f3f3f3f03f3f3f3f03f3f3f3f0

加入1当中点

终点1终点2终点3终点4
出发点1003f3f3f3f03f3f3f3f2        
出发点21003f3f3f3f3
出发点383010
出发点403f3f3f3f03f3f3f3f03f3f3f3f0

加入2当中间点

终点1终点2终点3终点4
出发点1003f3f3f3f03f3f3f3f2        
出发点21003f3f3f3f3
出发点34306
出发点403f3f3f3f03f3f3f3f03f3f3f3f0

最开始dis[3][4]=11。
当节点1作为中间点进行更新得到：
2->4 变为 2->1->4(dis[2][4]=3)，而3->4 变为3->1->4(dis[3][4]=10)。

当节点2作为中间点更新得到：
3->1 变为 3->2->1(dis[3][1]=4)。而3->4变为3->2->4(dis[3][4]=6)，而2->4的路径已经变成为2->1->4，故3->4的最短路径为3->2->1->4。

例题

描述

给定由n个点m条边的构成无向图，边权可能为负，图中可能存在重边，不存自环以及负权环。现在给定q组询问，请输出每组询问中节点i到j的最短距离及其路径。

输入描述

第一行 n,m,q，其中n≤500,m≤106,q≤104。接下来m行表示这两个点之间有边相连，边权绝对值小于10000。随后q行，代表接下来有q个询问，每个询问由ai​,bi​构成。

输出描述

一共输出q行，如果两点不存在路径则输出-1，否则每行第一个数字表示两点之间的最短距离，随后输出其路径(如果存在多条最短路径，则输出字典序最小的一个)

样例

输入描写
3 3 2
1 2 1
2 3 1
1 3 3
1 3
2 3
输出描写
2 1 2 3
1 2 3

写法

#include<bits/stdc++.h>
#pragma GCC s
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC fast
//优化程序运行效率
using namespace std;
long long read() {
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9') {
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9') {
		x=x*10+c-'0';
		c=getchar();
	}
	return x*f;
}//快读进行常数优化
const int N=505;
int n,m,q,tot,g[N][N],fa[N][N];//g[N][N]记录边的两顶点，fa[N][N]记录父亲节点 
void prt(int x,int y) {
	if(fa[x][y]==0)	printf(" %d",y);
	else prt(x,fa[x][y]),prt(fa[x][y],y);
}//输出部分
void floyd() {
	for(int k=1; k<=n; k++) {//枚举加入的点
		for(int i=1; i<=n; i++) {//枚举起点 
			for(int j=1; j<=n; j++) {//枚举终点 
				if(i==j||i==k||j==k)	continue;
				//加入的点和起点或终点相同则无需更新，起点和终点相同也无需更新 
				if(g[i][j]>g[i][k]+g[k][j]) {//如果加入的新点可以减少路径长度，那么就更新 
					g[i][j]=g[i][k]+g[k][j];//更新路径 
					fa[i][j]=k;//记录父亲节点 
				}
			}
		}
	}
}
int main() {
	n=read();
	m=read();
	q=read();
	memset(g,0x3f,sizeof(g));
	/*
	    1. 首先,memset()是按内存地址命名的,故用0x3f;
	    2. memset()中的0x3f赋完值后,dis[]中的数字是为0x3f3f3f3f,而int的最大值为0x7f7f7f7f,
	    为了防止两个标记的数组值相加导致爆int,故对半开为0x3f3f3f3f
	*/
	for(int i=1; i<=m; i++) {
		int a,b,c;
		a=read();
		b=read();
		c=read();
		g[a][b]=g[b][a]=min(g[a][b],c);
		//min(g[a][b],c)是因为有可能重边，又因为本题求最小值，故用min求最小值
	}
	floyd();//进行遍历
	while(q--) {
		int a;
		int b;
		a=read();
		b=read();
		if(g[a][b]>=0x3f3f3f3f) {
			cout<<-1;
			continue;
		}//如果没有被访问证明不联通，故输出-1
		printf("%d %d",g[a][b],a);
		prt(a,b);
		cout<<endl;
	}
	return 0;
}

谢谢大家

(写了正文8380+标题94+文章摘要94(合计8572)个字，点个赞再走吧，谢谢了)

(累死个人啦)

he10101
关注
  • 28
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最短路径算法总结（Dijkstra、Bellman-ford、SPFA和Floyd）
Thewei666的博客
02-25 1758
在最短路径算法中，常用的有Dijkstra、Bellman-ford、spfa、Floyd这四大算法 Dijkstra：迪克斯特拉算法 Bellman-ford：贝尔曼-福特算法 SPFA：Shortest Path Faster Algorithm算法 Floyd：弗洛伊德算法 四大算法介绍 简介 Dijkstra：是一种用于求解单源最短路径的贪心算法。它从起始节点开始，逐步扩展到其他节点，每次选择当前距离起始节点最近的节点进行扩展。通过不断更新节点的最短距离，最终得到起始节点到其他所有节点的最短路
图解 Dijkstra、Floyd、BellMan-Ford 最短路径算法
weixin_54383080的博客
02-21 3500
图解 Dijkstra Floyd BellMan-Ford 最短路径算法
(最短路径算法整理)dijkstra、floyd、bellman-ford、spfa算法
李响
09-26 578
一、floyd 1.介绍 　　floyd算法只有五行代码，代码简单，三个for循环就可以解决问题，所以它的时间复杂度为O(n^3)，可以求多源最短路问题。 　　2.思想： 　　　Floyd算法的基本思想如下：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点X到B。所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们检查D...
C++图论之常规最短路径算法的花式玩法（Floyd、Bellman、SPFA、Dijkstra算法合集）
y6123236的专栏
12-01 894
权重图中的最短路径有两种，多源最短路径和单源最短路径。多源指任意点之间的最短路径。单源最短路径为求解从某一点出到到任意点之间的最短路径。算法。也称为插点法，是一种利用动态规划思想寻找权重图中多源点之间[最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授[罗伯特·弗洛伊德命名。算法。贝尔曼-福特算法取自于创始人理查德.贝尔曼和莱斯特.福特，暴力穷举法，算法效率较低。但是，能解决的问题范围较大，如负权问题。SPFA算法。
matlab.rar_最短路径_最短路径 matlab_最短路径算法_迪杰斯特拉
09-23
迪杰斯特拉（Dijkstra）算法是解决此类问题的一种高效方法，尤其适用于寻找单源最短路径，即从一个特定起点到图中所有其他顶点的最短路径。本篇文章将深入探讨迪杰斯特拉算法及其在MATLAB环境中的实现。 迪杰斯特拉...
Dijkstra_1_迪杰特斯拉_最短路径_dijkstra算法_
09-30
迪杰斯特拉（Dijkstra）算法是图论中一个经典的单源最短路径算法，由荷兰计算机科学家艾兹格·迪杰斯特拉在1956年提出。这个算法主要用于解决带权重的有向图中从某一点到其余所有点的最短路径问题。在本案例中，我们...
最短路径算法dijkstra的matlab实现_dijkstra_最短路径算法_
10-04
最短路径算法是图论中的一个经典问题，用于寻找图中两点之间最短的路径。Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出的一种解决这一问题的有效方法。本篇文章将深入探讨Dijkstra算法的基本原理、...
zuiduanlujing.rar_最短路径_迪杰斯特拉_迪杰斯特拉算法
09-24
迪杰斯特拉（Dijkstra）算法是图论中一个经典的单源最短路径算法，由荷兰计算机科学家艾兹格·迪杰斯特拉在1956年提出。这个算法主要用于解决在加权图中找到从指定起始节点到其他所有节点的最短路径问题。加权图指的...
matlab-最短路径算法Dijkstra.zip_dijkstra
09-22
为了解决这个问题，可以使用其他算法，如Bellman-Ford或Floyd-Warshall算法。 在实际应用中，当图的规模较大时，Dijkstra算法的时间复杂度可能会成为问题。尽管优先队列能有效减少搜索时间，但在最坏情况下，时间...
算法-KMP字符串匹配
xx_xb的博客
07-23 163
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 384
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 640
AtCoder Beginner Contest 363 ABCDE
2024.7.19 刷题总结
TheJustice_的博客
07-19 302
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 523
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 731
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 737
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【常微分方程】
qq_74285286的博客
07-24 240
常微分方程笔记
python实现图像缩放算法
qq_42568323的博客
07-20 396
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
最短路径算法解析：Bellman-Ford与SPFA
"该资源是关于蓝桥杯竞赛中图论最短路径问题的解决方案，主要涉及两种算法：Bellman-Ford算法和SPFA算法。文档可能包含了对这两种算法的详细解释以及01背包问题的输出方案。" 图论中的最短路径问题是一个经典的问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值