三个最简单的最短路模板（待补充~

Floyd

由动态规划思想推导出转移公式
再经滚动优化可得

void Floyd(){
	for(int k = 1;k <= n;k ++)
		for(int i = 1;i <= n;i ++)
			for(int j = 1;j <= n;j ++)
				d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
}

Dijsktra

直接扔代码吧也没啥好说的
我习惯用堆优化写

struct node{
	int d,s;
	bool operator < (const node& b)const {
		return d > b.d;
	}
};
int g[N][N];//邻接矩阵
int d[N];//最短路
bool vis[N];
void Dijsktra(int s){
	for(int i = 1;i <= n;i ++) d[i] = INF;
	priority_queue<node> q;
	d[s] = 0;
	q.push((node){0,s});
	while(!q.empty()){
		int u = q.top().s;q.pop();
		if(vis[u]) continue;
		vis[u] = 1;
		for(int i = 1;i <= n;i ++){
			if(!vis[i] && g[u][i] && d[i] > g[u][i] + d[u]){
				d[i] = d[u] + g[u][i];
				q.push((node){d[i],i});
			}
		}
	}
}

SPFA

栈优化版本

int g[N][N];//邻接矩阵
int d[N];//最短路
int inf[N];//进栈次数
bool vis[N];

bool spfa(int s){
    stack<int> stk;
    stk.push(s);
    while(!stk.empty()){
        int u = stk.top();stk.pop();
        vis[u] = 0;
        for(int i = 1;i <= n;i ++){
            if(d[i] > d[u] + g[u][i] && g[u][i]){
                d[i] = d[u] + g[u][i];
                if(!vis[i]){
                    stk.push(i);
                    vis[i] = 1;
                    inf[i] ++;
                    if(inf[i] > n) return false;
                }
            }
        }
    }
    return true;
}                                              

队列优化版本

int g[N][N];//邻接矩阵
int d[N];//最短路
int inf[N];//进队次数
bool vis[N];

bool spfa(int s){
    for(int i = 1;i <= n;i ++) d[i] = INF;
    queue<int> q;
    d[s] = 0;
    q.push(s);vis[s] = 1;
    while(!q.empty()){
        int u = q.front();q.pop();
        vis[u] = 0;
        for(int i = 1;i <= n;i ++){
            if(g[u][i] && d[i] > d[u] + g[u][i]){
                d[i] = d[u] + g[u][i];
                if(!vis[i]){
                    q.push(i);
                    vis[i] = 1;
                    inf[i] ++;
                    if(inf[i] > n) return false;//出现负环
                }
            }
        }
    }
    return true;
}

若有错漏，还望各位大佬指正！