最短路模板

BellmanFord：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAXN = 1e5 + 5;
int n, m, s, t, d[MAXN], pre[MAXN];
struct node{
	int u, v, d;
}a[MAXN];
void print(int x) {
	if(pre[x] == 0) {
		printf("%d ", x);
		return;
	}
	print(pre[x]);
	printf("%d ", x);
}
int B(int s, int t) {
	memset(d, 0x3f, sizeof(d));
	d[s] = 0;
	for(int i = 1; i <= n; i++) {
		for(int j = 1;j <= m; j++) {
			if(d[a[j].u] + a[j].d <= d[a[j].v]) {
				if(d[a[j].u] + a[j].d == d[a[j].v] && pre[a[j].v] != 0) {
					pre[a[j].v] = min(a[j].u, pre[a[j].v]);
				}
				else{
					pre[a[j].v] = a[j].u;
				}
				d[a[j].v] = d[a[j].u] + a[j].d;
			}
		}
	}
	for(int i = 1; i <= n; i++) {
		for(int j = 1;j <= m; j++) {
			if(d[a[j].u] + a[j].d < d[a[j].v]) {
				return 0;
			}
		}
	}
	return 1;
}
int main() {
	scanf("%d %d", &n, &m);
	for(int i = 1;i <=m; i++) {
		scanf("%d %d %d", &a[i].u, &a[i].v, &a[i].d);
		pre[a[i].v] = a[i].v;
	}
	scanf("%d %d", &s, &t);
	if(B(s, t)) {
		printf("%d\n", d[t]);
		print(pre[t]);
		printf("%d", t);
	}
	else{
		printf("No Solution");
	}
	return 0;
} 

Spfa：

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
bool vis[1000005];
int dis[1000005], x, y, n, m, d, s, t;
struct edge {
    int u, v;
    edge() {}
    edge(int U, int V) { u = U, v = V; }
};
vector<edge> ve[100005];
queue<int> q;
int spfa(int s, int t) {
    q.push(s);
    dis[s] = 0;
    vis[s] = 1;
    while (!q.empty()) {
        int t = q.front();
        vis[t] = 0;
        q.pop();
        int siz = ve[t].size();
        for (int i = 0; i < siz; i++) {
            int V = ve[t][i].u, w = ve[t][i].v;
            if (dis[V] > dis[t] + w) {
                dis[V] = dis[t] + w;
                if (!vis[V]) {
                    vis[V] = 1;
                    q.push(V);
                }
            }
        }
    }
    return dis[t];
}
int main() {
    memset(dis, 0x3f, sizeof(dis));
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= m; i++) {
        scanf("%d %d %d", &x, &y, &d);
        ve[x].push_back(edge(y, d));
        ve[y].push_back(edge(x, d));
    }
    printf("%d", spfa(1, n));
    return 0;
}

Floyd:

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN = 1e3 + 5;
long long d[MAXN][MAXN], vis[MAXN][MAXN], n, u, v, s;
int main() {
	memset(d, 0x3f, sizeof(d));
	scanf("%lld", &n);
	for(int i = 1; i <= n; i++) {
		for(int j = 1;j <= n; j++) {
			scanf("%lld", &s);
			d[i][j] = s;
		}	
	}
	for(int k = 1;k <= n; k++) {
		for(int i = 1;i <= n; i++) {
			for(int j = 1;j <= n; j++) {
				if(d[i][k] + d[k][j] < d[i][j]) d[i][j] = d[i][k] + d[k][j];
			}
		}
	}
	for(int i = 1; i <= n; i++) {
		for(int j = 1;j <= n; j++) {
			printf("%lld ", d[i][j]);
		}	
		printf("\n");
	}
	return 0;
}
/*4
0 487 569 408
705 0 306 357
95 222 0 618
961 401 688 0*/

Dijkstra:

#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
const int MAXN = 2505;
int n, m, s, t, dj[MAXN], vis[MAXN], x, y, d;
struct node{
	int u, v;
	node(){};
	node(int U, int V) {
		u = U, v = V; 
	}
};
struct edge{
	int qi, d;
	edge(){};
	edge(int Qi, int D) {
		qi = Qi, d = D; 
	}
	bool operator < (const edge x) const {return d > x.d;};
};
priority_queue<edge>qu;
vector<node>ve[2505];
int Dijkstra(int s, int t) {
	qu.push(edge(s, 0));
	dj[s] = 0;
	while(!qu.empty()) {
		edge r = qu.top();
		qu.pop();
		if(vis[r.qi]) {
			continue;
		}
		vis[r.qi] = 1;
		for(int i = 0;i < ve[r.qi].size(); i++) {
			node p = ve[r.qi][i];
			if(dj[r.qi] + p.v < dj[p.u]) {
				dj[p.u] = dj[r.qi] + p.v;
				qu.push(edge(p.u, dj[p.u]));
			}
		}
	}
	return dj[t];
}
int main() {
	memset(dj, 0x3f, sizeof(dj));
	scanf("%d %d %d %d", &n, &m, &s, &t);
	for(int i = 1;i <= m; i++) {
		scanf("%d %d %d", &x, &y, &d);
		ve[y].push_back(node(x, d));
		ve[x].push_back(node(y, d));
	}
	printf("%d", Dijkstra(s, t));
	return 0;
}