最短路各方法总结&&变体思考（未完成）

最新推荐文章于 2021-05-26 11:04:47 发布
最新推荐文章于 2021-05-26 11:04:47 发布
阅读量243 收藏
点赞数
分类专栏： 知识点 2021湖南多校对抗赛系列题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51945248/article/details/116245550
版权

部分目录

Floyd算法多源最短路

参考博客

Dk-1[i][j]表示从i到j的中间点不大于k-1的最短路径p：i…j，

哦，也就是我们把图给分裂开来，有多少对i,j就是分成多少图。

在一个分图中，
i到j开始没有中间节点。
最外层for循环一次加一个中间节点k。
第一次加k1，如果经过k1能使i到j变短，就变短了
不管有没有短，都是在中间节点有k1,的情况下i到j最短
由于每一个节点都是让所有的i,j组合有了这个在中间节点有k1时的结果
那k2节点加进来时

任何两点间，已经是在中间节点有k1所能达到的最短距离
——这个让我理解了一下午

再看经过k2是否让i到j更短
也就是有i,j,k1,k2时i到j的最短
直到所有的k都在其中了，就变成一个完整的图
i到j在中间节点有k1,k2,…,kn图里的最短路就出来了
注意到在i,j里恰好加入i点时，是不会更新的，相当于pass，还不用多判断一次k是不是i或j里

for(int k=0; k<n; k++)
for(int i=0; i<n; i++)
//一点点的优化：
//if(dist[i][k]==INF)continue;
for(int j=0; j<n; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

实现：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text.out","w",stdout);
#endif
using namespace std;
#define ll long long
#define ld long double
#define pii pair<int,int>
#define piii pair<int,pii>
#define pll pair<ll,ll>
#define plll pair<ll,pll> 
#define pdd pair<double,double>
#define pdi pair<double,int>
#define pid pair<int,double>
#define vi vector <int> 
#define vii vector <vi> 
#define st first
#define nd second
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define _forplus(i,a,b) for( register int i=(a); i<=(b); i++)
#define forplus(i,a,b) for( register int i=(a); i<(b); i++)
#define _forsub(i,a,b) for( register int i=(a); i>=(b); i--)
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3f
#define pi (acos(-1))
#define EPS 0.00000001
#define MOD 1000000007
#define fastio 	std::ios::sync_with_stdio(false);std::cin.tie(0);
#define N 205
int  n,m,d[N][N],l,r;
int p[N][N];
//求多源最短Foryd ,要在m基础上直接上 
void foryd(){
	_forplus(i,1,n){
		_forplus(j,1,n){
			_forplus(k,1,n){
				if(d[j][k]>d[j][i]+d[i][k]){
					d[j][k]=d[j][i]+d[i][k];
					p[j][k]=i;
				}
			}
		}
	}
}
int path[N]; 
int k;
void retrieve_path(int i,int j){
	if(i==j)return;
	if(p[i][j] == -1)
        path[k++] = j;
    else
    {
        retrieve_path(i, p[i][j]);
        retrieve_path(p[i][j], j);
    }//二分 
}
//n为节点数，m是边数，d是邻接矩阵 
int main(){
	fastio
	mem(d,0x3f);
	mem(p,-1);
	cin>>n>>m;
	_forplus(i,1,m){
		cin>>l>>r;
		cin>>d[l][r];
	}
	_forplus(i,1,n){
		d[i][i]=0;	
	}
	//_forplus(i,1,n){
		//_forplus(j,1,n){
		//	cin>>m[i][j];
		//}
	//}
	foryd();
	_forplus(i,1,n){
		_forplus(j,1,n){
			cout<<"从"<<i<<"到"<<j<<endl; 
			cout<<"距离："<<d[i][j]<<endl; 
			path[0]=i;
			k=1;
			retrieve_path(i,j);
			forplus(i,0,k){
				cout<<path[i]<<"->";
			}cout<<"end"<<endl;
		}
	}
	return 0;
}

由下面bellman-fords算法想到的判断是否有负环的方法：
再来一次，碰到有更新就是有

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text.out","w",stdout);
#endif
using namespace std;
#define ll long long
#define ld long double
#define pii pair<int,int>
#define piii pair<int,pii>
#define pll pair<ll,ll>
#define plll pair<ll,pll> 
#define pdd pair<double,double>
#define pdi pair<double,int>
#define pid pair<int,double>
#define vi vector <int> 
#define vii vector <vi> 
#define st first
#define nd second
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define _forplus(i,a,b) for( register int i=(a); i<=(b); i++)
#define forplus(i,a,b) for( register int i=(a); i<(b); i++)
#define _forsub(i,a,b) for( register int i=(a); i>=(b); i--)
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3f
#define pi (acos(-1))
#define EPS 0.00000001
#define MOD 1000000007
#define fastio 	std::ios::sync_with_stdio(false);std::cin.tie(0);
#define N 205
int  n,m,d[N][N],l,r,t;
int p[N][N];
int flag=0;//是否是负权环，默认不是 
//求多源最短Foryd ,要在m基础上直接上 
void floyd(int tag){//tag 0是最短路，1是负权环 
	_forplus(i,1,n){
		_forplus(j,1,n){
			_forplus(k,1,n){
				if(d[j][k]>d[j][i]+d[i][k]){
					if(tag){
						flag=1;return;
					}
					d[j][k]=d[j][i]+d[i][k];
					p[j][k]=i;
				}
			}
		}
	}
	
}
int path[N]; 
int k;
void retrieve_path(int i,int j){
	if(i==j)return;
	if(p[i][j] == -1)
        path[k++] = j;
    else
    {
        retrieve_path(i, p[i][j]);
        retrieve_path(p[i][j], j);
    }//二分 
}
//n为节点数，m是边数，d是邻接矩阵 
int main(){
	fastio
	mem(d,0x3f);
	mem(p,-1);
	cin>>n>>m;
	_forplus(i,1,m){
		cin>>l>>r;
		cin>>t;
		t<d[l][r]?d[l][r]=t:t=t;
	}
	_forplus(i,1,n){
		d[i][i]=0;	
	}
	//_forplus(i,1,n){
		//_forplus(j,1,n){
		//	cin>>m[i][j];
		//}
	//}
	floyd(0);
	floyd(1);//如果要判断是否负权环就用 
	if(flag){
		cout<<"注意，有负权环，最短路为负无穷。"<<endl;
	}else{
		_forplus(i,1,n){
			_forplus(j,1,n){
				cout<<"从"<<i<<"到"<<j<<endl; 
				cout<<"距离："<<d[i][j]<<endl;
				path[0]=i;
				k=1;
				retrieve_path(i,j);
				forplus(i,0,k){
					cout<<path[i]<<"->";
				}cout<<"end"<<endl;
			}
		}
	}
	return 0;
}
Floyd算法的抽象基础：Warshall算法

如果i能到k，k能到j，
则i能经过k到j。
这样子可以给一个图，得到任意两点是否联通的结果
可以用1表示联通，0表示不联通
还是先i,j,再一个一个加k

for(int k=0; k<n; k++)
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
if(to[i][k]&&to[k][j])to[i][j]=1;

学术上把一个一个加k的过程好像称为Rk 的k从0到n的过程，矩阵阶数增加

这个算法可能算k次重复的1，其实有第一次就可以了
怎么办，判断的话其实也是要做一次的
那就算了吧，节省vis数组节省空间

最短路变体：走k步能到达的最短

——不做优化，可以直接BFS

单源之Bellman-Ford算法

Pecco的
更容易懂

因为起点被固定了，我们现在只需要一个一维数组dist[]来存储每个点到起点的距离。
1为起点，我们初始化时把dist[1]初始化为0，其他初始化为INF。

松弛操作：
dist[y] = min(dist[y], dist[x] + e[x][y]);
//这里的e[x][y]表示x、y之间的距离，具体形式可能根据存图方法不同而改变

松弛操作就相当于考察能否经由x点使起点到y点的距离变短
设起点为S，终点为D，那这条最短路一定是S->P1->P2->…->D的形式，假设没有负权环，那这条路径上的点的总个数一定不大于n。
先松弛S, P1，此时dist[P1]必然等于e[S][P1]。
再松弛P1,P2，因为S->P1->P2是最短路的一部分，最短路的子路也是最短路（这是显然的），所以dist[P2]不可能小于dist[P1]+e[P1][P2]，因此它会被更新为dist[P1]+e[P1][P2]，即e[S][P1]+e[P1][P2]。
再松弛P2, P3，……以此类推，最终dist[D]必然等于e[S][P1]+e[P1][P2]+…，这恰好就是最短路径。
说得好像很有道理，但是问题来了，我怎么知道这些P1、P2是什么呢？我们不就是要找它们吗？关键的来了，Bellman-Ford算法告诉我们：

把所有边松弛一遍！

因为我们要求的是最小值，而多余的松弛操作不会使某个dist比最小值还小。所以多余的松弛操作不会影响结果。把所有边的端点松弛完一遍后，我们可以保证S,
P1已经被松弛过了，现在我们要松弛P1, P2，怎么做呢？

再把所有边松弛一遍！

好了，现在我们松弛了P1,
P2，继续这么松弛下去，什么时候是尽头呢？还记得我们说过吗？最短路上的点的总个数一定不大于n，尽管一般而言最短路上的顶点数比n少得多，但反正多余的松弛操作不会影响结果，我们索性：

把所有边松弛n-1遍！

其实由Bellman-Ford算法是可以在n-1次有结果的，那么我们在第n次还能通过有的边更新，就有负权环了。
但是由于岔路，不能数组回溯找到该环，只能试图用最短路的树看是否成环。
先来一个只能判断是否有环的

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text.out","w",stdout);
#endif
using namespace std;
#define ll long long
#define ld long double
#define pii pair<int,int>
#define piii pair<int,pii>
#define pll pair<ll,ll>
#define plll pair<ll,pll> 
#define pdd pair<double,double>
#define pdi pair<double,int>
#define pid pair<int,double>
#define vi vector <int> 
#define vii vector <vi> 
#define st first
#define nd second
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define _forplus(i,a,b) for( register int i=(a); i<=(b); i++)
#define forplus(i,a,b) for( register int i=(a); i<(b); i++)
#define _forsub(i,a,b) for( register int i=(a); i>=(b); i--)
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3f
#define pi (acos(-1))
#define EPS 0.00000001
#define MOD 1000000007
#define fastio 	std::ios::sync_with_stdio(false);std::cin.tie(0);
#define N 205
#define M 40005
int d[N],p[N];//点距离,来路 
int f[M],t[M],e[M];//存边,距离，来，去 
int n,m=0;//点数，边数(也可计，这里输入) 
int flag=0,sub[N];//判断有无负权环，默认0无，1有 ,sub记录有负权环的点 
void loop(int tag){//节省代码，0是最短路1是看负环——后来证明，暂时不能看负环 
	_forplus(i,1,n){
		_forplus(j,1,m){
			if(d[t[j]]>d[f[j]]+e[j]){
				d[t[j]]=d[f[j]]+e[j];
				if(!tag){
					if(i==n){//处理负权环 
						flag=1;
						//错误思想：找负权环 
						//如果我们要找出负权环，要多两个n的复杂度，因为有的枢纽有多方向，难以单个存 
						//loop(1);
						//——如果有负权环，那么任意两点都可以通过负权环转无数次而距离无穷小
						//所以判断会是，要么没有负权环，要么都被负权环影响，不要想找环了 
						break;
					}
					p[t[j]]=f[j];
				}else{
					sub[t[j]]=1;
				}
			}
		}
	}	
}
void bford(int now){
	mem(d,0x3f);
	mem(p,-1);
	mem(sub,0);
	d[now]=0;
	loop(0); 
}
bool jd(int now){
	int t=p[now];
	while(t!=now&&~t){
		if(sub[t])return true;
		t=p[t];
	}
	return false;
}
void print(int now){
	if(flag){
		cout<<"注意，有负权环，最短路为负无穷。";
		//_forplus(i,1,n){
		//	if(sub[i])cout<<" "<<i;
		//}
		cout<<endl;
		return; 
	}
	cout<<"这不是个有负权环的图"<<endl;
	_forplus(i,1,n){
		if(sub[i]){
			cout<<i<<"点是负权环上的点"<<endl; continue;
		}else if(jd(i)){
			cout<<"此点是连在负权环上的点"<<endl;continue;
		}
		cout<<"从"<<now<<"到"<<i<<"的最短距离是："<<d[i]<<endl; 
		cout<<"路径是：";
		int t=i;
		while(~t){
			cout<<t<<"<-";
			t=p[t];
		} 
		cout<<"begin"<<endl;
	}
}
int main(){
	fastio
	cin>>n>>m;//从1到n个节点 
	_forplus(i,1,m){
		cin>>f[i]>>t[i]>>e[i];
	}
	int from=1;//起点 
	bford(from);
	print(from);
	return 0;
}
关于找负权环

由于枢纽的原因而不能通过数组找路的，请用一棵树做，是常见的
这次是在网上知乎看到的，下次要自己有这个意识
里面说用到LCT(Link Cut Tree)，又和树链剖分有密切的联系，是一个大块头
找的时候，有个文章里提到用Tarjan 算法，这是一篇比较好的资料
接下来先学SPFA，再一起讨论怎么找负权环
将在这里可以找到

单源最短路之SPFA
出尘呢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Yocto 之四 详解移植及构建过程、镜像文件介绍及使用验证
技术干货
03-11 249
我们从 Yocto 官网下载 Poky 仅仅是一个用于构建 Linux 的 DEMO，我们可以选择将这个 Poky（本身定义了可以在 QEMU 中运行的发行版） 进行大改造，也可以根据这个 Poky 从零搭建出一套自己的 Poky。我这里就以 YP CORE - KIRKSTONE 4.0.13 - 2023.10.05 这个版本为参考，从零开始搭建。
K最短路问题MATLAB实现
05-26
对于K最短路问题，首先找出两点之间的所有路径，然后利用K最短路算法，将最短路、次短路、第三最短路等计算出来，存入数组中。该matlab程序具有很好的通用性，希望对大家有用。 说明：findpath.m文件可计算出任意两点的所有路径，dijstra.m可算出两点间的最短路，main.m为K最短路算法，文件夹中附有一张计算结果图！
K最短路算法实现(KSP)
07-29
实现K最短路算法，包括双向图算法（删除法）、单向无环图算法（附加节点法）。VC7、VC6都可通过编译。算法原理可在CSDN上找到一堆论文。
K最短路问题(单源点最短路径+A*算法)
热门推荐
始往流离，终彼成章。
05-01 1万+
/* *算法引入： *在单源点最短路径问题中,实际运用时还需知道最短路径外,次短路或者第三短路; *即要知道多条最短路,并排出其长度增加的顺序,即为K最短路问题; * *算法思想： *单源点最短路径+高级搜索A*; *A*算法结合了启发式方法和形式化方法; *启发式方法通过充分利用图给出的信息来动态地做出决定而使搜索次数大大降低; *形式化方法不利用图给出的信息,而仅通过数学的形
最短路径算法-Dijkstra算法的实质与变体
学无止境
04-17 1760
DJ算法：求有向网G的v0顶点到其余顶点v最短路径P[v]及带权长度D[v] DJ算法思想： 1 用于存储最短路径下标的数组 2 用于存储到各点最短路径的权值和。 3 用于标记是否已经获得v0至v的最短路径。 首先说明两种情况： 1 路径上有权值，这种是普遍情况，直接用节点v与节点0之间的路径值作为最短路径一维数组的初始值。 2 路
第 K 最短路 问题
weixin_30682415的博客
07-31 91
在这求第 k 短路用的是，A*+dij 所谓的A* 是一种启发式搜索，他给搜索选定一定的方向，避免了，无谓的搜索，如何来确定搜索的顺序？..也就是用一个值来表示这个值为f[x]..每次搜索取f[x]最小的拓展...那么这个f[x]=h[x]+g[x]其中这个h[x]就是当前搜索时的代价..如求K段路这个就是前一个点的h[x']+边的长度...而g[x]是一个估价函数..估价函数要小于是对当前点到...
前k条最短路径算法
Ghost
05-08 2170
一、算法说明 Deletion Algorithm删除算法的核心是通过在有向图中已有的最短路径上删除某条弧，并寻找替换的弧来寻找下一条可选的最短路径。删除算法实际上是通过在有向图中增加附加节点和相应的弧来实现的。算法描述如下： 1．利用Dijkstra算法求得有向图(N,A)中以开始节点s为根的最短路径树（注意，这里的最短路径树并不是最小生成树，因为Dijkstra算法并不保证能生成最
改进的几乎无圈图的最短路算法及其时间复杂度分析
232理论计算机科学电子笔记42（2001）网址：http://www.elsevier.nl/locate/entcs/volume42.html17页改进的几乎无圈图Shane Saunders1高冈忠雄2新西兰基督城坎特伯雷大学计算机科学系摘要Dijkstra这里n是顶点数，m是...
时间依赖方法在时间表信息系统中的应用
理论计算机科学电子札记92（2004）85-103www.elsevier.com/locate/entcs通过时间依赖方法实现时间表信息的真实建模*Evangelia Pyrgaa，1，Frank Schulzb，2，DorotheaWagnerb，3，Christiane Zaroliagisa，4a计算机...
大数据高频面试题总结
qq_43530218的博客
10-15 922
大数据面试总结 1.==和equale的区别 答：（1）.可以比较基本类型也可比较引用类型，基本类型比较值，而引用类型比较内存地址。（2）equals的话，它属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是（源码149行）；String类的equals方法被重写过的，而且String类在日常中用的比较多，形成了equals是比较值的错误观点。（3）具体的比较还是要看...
Eppstein K最短路 程序代码 C#
09-12
Eppstein K最短路 程序代码 C#
算法导论-上课笔记11:单源最短路径
我是一只小嵩鼠
05-26 2696
找到从源结点s到图G中每个结点v的最短路径
K - 最短路
x311609001028的博客
08-09 1282
点击打开链接 在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？  Input输入包括多组数据。每组数据第一行是两个整数N、M（N 输入保证至少存在1条商店到赛场的路线。  Output对于每组输入，输出一行，
K最短路问题(A*算法)
平凡的脚步也可以走完伟大的行程。
05-20 3045
问题在有向带权图G，求从s到t的第k短路（不严格递增）的长度。A*算法通过一个估价函数f(x)来估计图中的当前点p到终点的距离,并由此决定它的搜索方向; 设g(x)表示走当前路径到x的长度，dis(x,y)表示x到y的最短距离，由于y只有等于t时才有用，所以我们可以连反向边，然后从t出发跑一遍最短路得到。 令f(x)=g(x)+dis(x,t) 建一个优先队列,初始将源点s加入到队列中; 每
[矩乘]K步最短路
Vector
09-21 952
把矩乘换成floyd .. #include #include using namespace std; const int INF=9999999; int n,k,S,T; string m; struct mat { int m[101][101]; }unit,a; mat mul(mat a,mat b) { mat t; for(int i=0;i<n;++i)
图论 —— k 短路
Alex_McAvoy的博客
10-11 4734
【概述】 所谓 k 短路问题，是指给定一个具有 n 个点 m 条边的带正权有向图，再给定起点 S 与终点 T，询问从 S 到 T 的所有权和中，第 k 短的路径的长度。 k 短路问题的解决方法有两种，一种是利用A*算法求解，另一种是利用最短路算法与可持久化堆结合求解。 【A*算法】 对于 Dijkstra 算法，有一个结论是：当一个点第 k 次出队的时候，此时路径长度就是 s 到它的第 k...
pku2449第K短路 最短路+A*
qjklw
08-03 2845
题意：求一点至另一点的第K短路。注意如果起点和终点一样的话，那么刚开始起点不算到达终点。         分析：寻找最短路，直接SPFA就可以了。。。这里是第K短路，把每一条路径都找出来。开始想用DP，dp[i][j]表示到i结点第j大的路径权值是多少，但这样还是搜，而且会超时
K短路算法
runninghui的专栏
10-08 3315
1 A*算法     A*算法在人工智能中是一种典型的启发式搜索算法，启发中的估价是用估价函数表示的： 其中f(n)是节点n的估价函数，g(n)表示实际状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。另外定义h'(n)为n到目标节点最佳路径的实际值。如果h'(n)≥h(n)则如果存在从初始状态走到目标状态的最小代价的解，那么用该估价函数搜索的
ACM竞赛必备：最短路算法（Dijkstra & Floyd-Warshall）详解
最短路问题是算法与数据结构领域中的经典问题，在ACM/ICPC等计算机竞赛中频繁出现。这些问题涉及寻找网络中两点之间的最短路径，通常分为单源最短路径问题和多源最短路径问题。 1. **单源最短路径问题** (Single-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值