2.6
1.蓝桥公园
2.路径
3.打印路径
4.【模板】Floyd

Floyd算法：

是一种多源的最短路径算法，经过一次计算可以得到任意两个点之间的最短路径。

这种算法是基于动态规划的思想：

m[i][j]表示从i到j这条边的距离，dp[k][i][j]表示从i到j且经过{0,1,...,k-1}中若干点的最短路径。

那么转移方程就就是dp[k][i][j]=min(dp[k−1][i][j],dp[k−1][i][k]+dp[k−1][k][j])这表示了比较经过k和不经过k两种的情况的路径，找到较小值

例如，在k=1的时候，
d p [ 1 ] [ i ] [ j ] = m i n ( d p [ 0 ] [ i ] [ j ] , d p [ 0 ] [ i ] [ 1 ] + d p [ 0 ] [ 1 ] [ j ] ) = m i n ( m [ i ] [ j ] , m [ i ] [ 1 ] + m [ 1 ] [ j ] )         

通过滚动数组，我们可以优化dp数组的空间，将他从三维的数组变成二维的

dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j])

与其他最短路径相比Floyd算法有以下几点特点：

1.可以找到所有节点之间的最短距离

2.代码简单，就三重循环

3.效率比较低，是O（n^3）的时间复杂度

这是算法的模版：

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)dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
				else dp[i][j]=dp[j][i]=0;
			}
		}
	}
}

蓝桥公园：https://www.lanqiao.cn/problems/1121/learning/?page=1&first_category_id=1&status=2

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long
const int INF=0x3f3f3f3f3f3f3f3fll; 
const int N=405;
int dp[N][N];
int n,m,q;
void input(){
	memset(dp,0x3f,sizeof(dp));
	for (int i=1;i<=m;++i){
		int u,v,w;
		cin>>u>>v>>w;
		dp[u][v]=dp[v][u]=min(dp[u][v],w);
	}
}
void fioyd(){
	for (int k=1;k<=n;++k){
		for (int i=1;i<=n;++i){
			for (int j=1;j<=n;++j){
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
			}
		}
	}
}
void output(){
	while (q--){
		 int s,t; cin>>s>>t;
		if (s==t) cout<<0<<endl;
		else if (dp[s][t]==INF) cout<<-1<<endl;
		else cout<<dp[s][t]<<endl;
	}
}
signed main(){
	cin>>n>>m>>q;
	input(); fioyd();  output();
	return 0;
}

路径：https://www.lanqiao.cn/problems/1460/learning/?page=1&first_category_id=1&problem_id=1460

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long
const int INF=0x3f3f3f3f;
const int N=2050;
int dp[N][N];
int gcd(int a,int b){
	if (b==0) return a;
	return gcd(b,a%b);
}
void floyd(){
	for (int k=1;k<=2021;++k){
		for (int i=1;i<=2021;++i){
			for (int j=1;j<=2021;++j){
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
			}
		}
	}
}
signed main(){
	for (int i=1;i<2021;++i){
		for (int j=i+1;j<=2021;++j){
			if (abs(i-j)>21){
				dp[i][j]=dp[j][i]=INF;
			}else if (abs(i-j)<=21){
				dp[i][j]=dp[j][i]=(i*j)/gcd(i,j);
			}
		}
	}
	floyd();
	cout<<dp[1][2021];
}

打印路径：https://www.lanqiao.cn/problems/1656/learning/?page=1&first_category_id=1&problem_id=1656

这道题需要的点比较多，需要记录最短路径，还有每个 城市都会收税，记录最短路径的话，就再建一个二维数组，记录每个点之间的关系

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long
const int INF=0x3f3f3f3f;
const int N=505;
int n;
int dp[N][N],shui[N],path[N][N];
void input(){
	cin>>n;
	for (int i=1;i<=n;++i){
		for (int j=1;j<=n;++j){
			int x;	cin>>x;
			if (x==-1) dp[i][j]=dp[j][i]=INF;
			else{
				dp[i][j]=dp[j][i]=x;
			}
			path[i][j]=j;
		}
	}
	for (int i=1;i<=n;++i) cin>>shui[i];
}
void floyd(){
	for (int k=1;k<=n;++k){
		for (int i=1;i<=n;++i){
			for (int j=1;j<=n;++j){
				if (dp[i][j]>dp[i][k]+dp[k][j]+shui[k]){
					dp[i][j]=dp[i][k]+dp[k][j]+shui[k];
					path[i][j]=path[i][k];
				}else if (dp[i][k]+dp[k][j]+shui[k]==dp[i][j] && path[i][k]<path[i][j]){
					dp[i][j]=dp[i][k]+dp[k][j]+shui[k];
					path[i][j]=path[i][k];
				}
			}
		}
	}
}
void output(){
	int s,t;
	while (cin>>s>>t){
		if (s==-1 && t==-1)break;
		cout<<"From "<<s<<" to "<<t<<" :"<<endl;
		cout<<"Path: "<<s;
		int idx=s;
		while (idx!=t){
			idx=path[idx][t];
			cout<<"-->"<<idx;
		}
		cout<<endl;
		cout<<"Total cost : "<<dp[s][t]<<endl<<endl;
	}
}
signed main(){
	input(); floyd(); output();
	return 0;
}

【模板】Floydhttps://www.luogu.com.cn/problem/B3647

题目描述

给出一张由 �n 个点 �m 条边组成的无向图。

求出所有点对 (�,�)(i,j) 之间的最短路径。

输入格式

第一行为两个整数 �,�n,m，分别代表点的个数和边的条数。

接下来 �m 行，每行三个整数 �,�,�u,v,w，代表 �,�u,v 之间存在一条边权为 �w 的边。

输出格式

输出 �n 行每行 �n 个整数。

第 �i 行的第 �j 个整数代表从 �i 到 �j 的最短路径。

输入输出样例

输入 #1复制

4 4
1 2 1
2 3 1
3 4 1
4 1 1

输出 #1复制

0 1 2 1
1 0 1 2
2 1 0 1
1 2 1 0

说明/提示

对于 100%100% 的数据，�≤100n≤100，�≤4500m≤4500，任意一条边的权值 �w 是正整数且 1⩽�⩽10001⩽w⩽1000。

数据中可能存在重边。

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long
const int INF=0x3f3f3f3f;
const int N=505;
int n,m;
int dp[N][N];
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)dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
				else dp[i][j]=dp[j][i]=0;
			}
		}
	}
}
signed main(){
	cin>>n>>m;
	memset(dp,INF,sizeof(dp));
	for (int i=1;i<=m;++i){
		int a,b,c;
		cin>>a>>b>>c;
		dp[a][b]=dp[b][a]=min(dp[a][b],c);	//防止重边 
	}
	floyd();
	for (int i=1;i<=n;++i){
		for (int j=1;j<=n;++j){
			cout<<dp[i][j]<<" ";
		}
		cout<<endl;
	}
	
	return 0;
}