floyd && dijkstra

floyd
问题
用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩
阵（顶点之间的最短距离矩阵）
用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩
阵（顶点之间的最短距离矩阵）
原理
floyd运用到了动态规划的思想，求两点之间最短的距离，分为经过k和不经过k的路径，取两者最短
伪代码：

   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]);
            }
        }
    }

矩阵：

0 2 5 4
2 0 3 4
5 3 0 1
4 4 1 0

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=105;
const int INF=0x3f3f3f3f;
int dp[N][N];
int n,m;
void init(){
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(j==i)dp[i][j]=0;
            else dp[i][j]=INF;
        }
    }
}
void floyd(){
    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]);
            }
        }
    }
}
int main(){
    while(cin>>n>>m&&n+m){
        int u,v,w;
        init();
        for(int i=1;i<=m;i++){
        scanf("%d%d%d",&u,&v,&w);
        dp[u][v]=min(dp[u][v],w);
        }
        floyd();
        for(int i=1;i<=n;i++){
        	for(int j=1;j<=n;j++){
        		printf("%d%c",dp[i][j],j==n?'\n':' ');
			}
		}
        printf("%d\n",dp[1][n]);
    }    
}

分析
floyd因为有很多计算是无效的所以算法效率不高，复杂度为（$n^3$）;
dijkstra
问题
对于下图使用Dijkstra算法求由顶点a到顶点h的最短路径。

原理
选择一个起始点，选择与它相连的最小路径。然后如果原点到i点的权值和加i点到j点的权值小于已知原点到j点的权值和，则将其更新，按照这个步骤往下去，直到所有点都被访问过

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<stack>
#include<algorithm>
#include<vector>
#include<cmath>
#include<map>
#include<string>
#include<set>
#define Case int t;scanf("%d",&t);while(t--)
#define pi acos(-1)
#define eps 1e-8
using namespace std;
typedef long long ll;
const int N = 1e6 + 10;
const int M = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const ll mod = 1e9+7;
struct edge{
	int from,to,w;
	edge(int a,int b,int c){from=a;to=b;w=c;}
};
vector<edge>e[M];
struct node{
	int id,dist;
	node(int u,int v){id=u,dist=v;}
	bool operator<(const node &a)const{
		return dist>a.dist;
	}
};
int n,m;
int dis[M];
bool done[M];
void dijkstra(){
	int s=1;
	for(int i=1;i<=n;i++){
		dis[i]=inf;
		done[i]=0;
	}
	dis[s]=0;
	priority_queue<node>q;
	q.push(node(s,dis[s]));
	while(!q.empty()){
		node u=q.top();
		q.pop();
		if(done[u.id])continue;
		done[u.id]=1;
		for(int i=0;i<e[u.id].size();i++){
			edge y=e[u.id][i];
			if(done[y.to])continue;
			if(dis[y.to]>y.w+u.dist){
				dis[y.to]=y.w+u.dist;
				q.push(node(y.to,dis[y.to]));
			}
		}
	}
	printf("%d\n",dis[n]);
}
void run() {
	while(~scanf("%d%d",&n,&m)&&n&&m){
		for(int i=1;i<=n;i++)e[i].clear();
		for(int i=1;i<=m;i++){
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			e[u].push_back(edge(u,v,w));
		}
		dijkstra();
	}
}
int main() {
//	Case
		run();
	return 0;
}

分析
Dijkstra算法适用于计算正权图（边权为正）上的单源最短路，即从单个源点出发，到所有节点的最短路。该算法同时适用于有向图和无向图。不适于环，复杂度为o($n^2$).
代码维护
https://github.com/kitalekita/kitalekita/blob/main/dijkstra.cpp
https://github.com/kitalekita/kitalekita/blob/main/floyd.cpp