目录
Floyd算法
最简单的最短路径算法，使用邻接矩阵存图，因为Floyd算法计算的结果是所有点对之间的最短路，本身就要
的空间，用矩阵存储最合适。效率不高，计算复杂度为
,只能用于n<300的小规模的图，不能用于大图，在某些场景下有自己的优势，难以替代，能做传递闭包问题。
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],d[i][k]+dp[k][j]);
}
}
}
Floyd算法是多源最短路算法 ，以此计算能得到图中每一对结点 之间（多对多）的最短路径。
Floyd算法能判断负圈 ，若图中有权值为负的边，某个经过这个负边的环路，所有边长相加的总长度也是负数，这就是负圈。在这个负圈上每绕一圈，总长度就更小，从而陷入在兜圈子的死循环。Floyd算法很容易判断负圈，只要在算法运行过程中出现任意一个dp[i][j]<0就说明有负圈，因为dp[i][j]是从i出发，经过其它中转点绕一圈回到自己的最短路径，如果等于0，就存在负圈。
例题：蓝桥公园
#include<bits/stdc++.h>
using namespace std;
const long long INF=0x3f3f3f3f3f3f3f3fLL;
const int N=405;
long long dp[N][N];
int n,m,q;
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(){
cin>>n>>m>>q;
memset(dp,0x3f,sizeof(dp));
for(int i=1;i<=m;i++){
int u,v;
long long w;
cin>>u>>v>>w;
dp[u][v]=dp[v][u]=min(dp[u][v],w);
}
floyd();
while(q--){
int s,t;
cin>>s>>t;
if(dp[s][t]==INF){
cout<<"-1"<<endl;
}
else if(s==t){
cout<<"0"<<endl;
}
else{
cout<<dp[s][t]<<endl;
}
}
return 0;
}
Dijkstra算法
Dijkstra算法 用于求解单源最短路径问题，非常高效而且稳定，但是只能处理不含负权边的图。
Dijkstra算法是贪心思想实现的，首先把起点到所有点的距离存下来找个最短的，然后松弛一次再找出最短的，所谓的松弛操作就是，遍历一遍看通过刚刚找到的距离最短的点作为中转站会不会更近，如果更近了就更新距离，这样把所有的点找遍之后就存下了起点到其它所有点的最短距离。
采用优先队列 实现，每次往队列中放数据时，按从小到大的顺序放，采用小顶堆的方式，复杂度是
，保证最小的数总在最前面。找最小值，直接取第一个数，复杂度是
。
例题：蓝桥王国
#include<bits/stdc++.h>
using namespace std;
const long long INF=0x3f3f3f3f3f3f3f3fLL;
const int N=3e5+2;
struct edge{
int from,to;
long long w;
edge(int a,int b,long long c){
from=a;
to=b;
w=c;
}
};
vector<edge>e[N];
struct s_node{
int id;
long long n_dis;
s_node(int b,long long c){
id=b;
n_dis=c;
}
bool operator < (const s_node &a) const{
return n_dis>a.n_dis;
}
};
int n,m;
int pre[N];
void print_path(int s,int t){
if(s==t){
printf("%d ",s);
return;
}
print_path(s,pre[t]);
printf("%d ",t);
}
long long dis[N];
void dijkstra(){
int s=1;
bool done[N];
for(int i=1;i<=n;i++){
dis[i]=INF;
done[i]=false;
}
dis[s]=0;
priority_queue<s_node>Q;
Q.push(s_node(s,dis[s]));
while(!Q.empty()){
s_node u=Q.top();
Q.pop();
if(done[u.id]){
continue;
}
done[u.id]=true;
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.n_dis){
dis[y.to]=y.w+u.n_dis;
Q.push(s_node(y.to,dis[y.to]));
pre[y.to]=u.id;
}
}
}
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
e[i].clear();
}
while(m--){
int u,v,w;
cin>>u>>v>>w;
e[u].push_back(edge(u,v,w));
}
dijkstra();
for(int i=1;i<=n;i++){
if(dis[i]>=INF){
cout<<"-1";
}
else{
cout<<dis[i];
}
}
return 0;
}
SPFA算法
SPFA算法=队列处理+Bellman-Ford
Bellman-Ford算法有很多低效或无效的操作，其核心内容，是在每一轮操作中，更新所有节点到起点s的最短距离。
计算和调整一个节点u到s的最短距离后，如果紧接着调整u的邻居节点，这些邻居肯定有新的计算结果，而如果漫无目的的计算不与u相邻的节点，这可能毫无变化，所以这些操作是低效的。
改进：计算结点u之后，下一步只计算和调整它的邻居，能加速收敛的过程。这些步骤用队列操作
例题：随机数据下的最短路问题
#include<bits/stdc++.h>
using namespace std;
const long long INF=0x3f3f3f3f3f3f3f3f;
const int N=5e3+10;
struct edge{
int to;
long long w;
edge(int tt,long long ww){
to=tt;
w=ww;
}
};
long long dist[N];
int inq[N];
vector<edge>e[N];
void spfa(int s){
memset(dist,0x3f,sizeof(dist));
dist[s]=0;
queue<int>q;
q.push(s);
inq[s]=1;
while(!q.empty()){
int u=q.front();
q.pop();
inq[u]=0;
if(dist[u]==INF){
continue;
}
for(int i=0;i<e[u].size();i++){
int v=e[u][i].to;
long long w=e[u][i].w;
if(dist[v]>dist[u]+w){
dist[v]=dist[u]+w;
if(!inq[v]){
q.push(v);
inq[v]=1;
}
}
}
}
}
int main(){
int n,m,s;
cin>>n>>m>>s;
for(int i=1;i<=m;i++){
int u,v;
long long w;
cin>>u>>v>>w;
e[u].push_back(edge(v,w));
}
spfa(s);
for(int i=1;i<=n;i++){
if(dist[i]==INF){
cout<<-1;
}
else{
cout<<dist[i];
}
if(i!=n){
cout<<" ";
}
else{
cout<<endl;
}
}
return 0;
}
总结
单源最短路
（1）当权值非负时，用Dijkstra算法。
（2）当权值有负值，且没有负圈，则用SPFA。SPFA能检测负圈，但是不能输出负圈。
（3）当权值有负值而且有负圈需要输出，则用Bellman-Ford，能够检测并输出负圈。
多源最短路
使用Floyd算法。
最小生成树MST
一个含有n个结点的连通图的生成树是原图的极小连通子图，包含原图中的所有n个结点，并且边的权值之和最小。
Prim算法
对点进行贪心操作，从任意一个点u开始，把距离它最近的点加入到MST中，下一步，把距离{u,v}最近的点w加入到MST中；继续这个过程，直到所有的点都在MST中。适用于稠密图。
#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f3f3f3f3f;
const int MAXN=1005;
vector<int>demo;
int closest[MAXN],lowcost[MAXN],n,m;//m为节点的个数，n为边的数量
int G[MAXN][MAXN];//邻接矩阵
int prim(){
for(int i=0;i<n;i++){
lowcost[i]=INF;
}
for(int i=0;i<m;i++){
closest[i]=0;
}
closest[0]=-1;//加入第一个点，-1表示该点在集合U中，否则在集合V中
int num=0,ans=0,e=0;
while(num<m-1){//当点还没有全部放进去
int micost=INF;
for(int i=0;i<m;i++){
if(closest[i]!=-1){
int temp=G[e][i];
if(temp<lowcost[i]){
lowcost[i]=temp;
closest[i]=e;
}
if(lowcost[i]<micost){
micost=lowcost[i];
}
}
ans+=micost;
demo.push_back(micost);
closest[e]=-1;
num++;
}
}
return ans;
}
int main(){
cin>>m>>n;
memset(G,INF,sizeof(G));
for(int i=0;i<n;i++){
int a,b,c;
cin>>a>>b>>c;
G[b][a]=G[a][b]=c;
}
cout<<prim()<<endl;
for(int i=0;i<m-1;i++){
cout<<demo[i]<<" ";
}
return 0;
}
Kruskal算法
对边进行贪心操作。从最短的边开始，把它加入到MST中，在剩下的边中找最短的边，加入到 MST中，继续这个过程，直到所有的点都在MST中。适用于稀疏图。
kruskal算法的两个关键技术：
（1）对边进行排序
（2）判断圈，即处理连通性问题。这个问题用并查集简单而高效，并查集是krustral算法的绝配。
例题：聪明的猴子
#include<bits/stdc++.h>
using namespace std;
int n,m,father[1100000];
struct node{
int x,y,k;
}Q[1100000];
int find(int x){
if(father[x]==x){
return x;
}
return father[x]=find(father[x]);
}
bool cmp(node a,node b){
return a.k<b.k;
}
int main(){
cin>>n>>m;
int sum=0,st=0;
for(int i=0;i<m;i++){//把m条边扫描进来
cin>>Q[i].x>>Q[i].y>>Q[i].k;
}
sort(Q,Q+m,cmp);
for(int i=1;i<=n;i++){
father[i]=i;
}
for(int i=0;i<m;i++){
int tx=find(Q[i].x);
int ty=find(Q[i].y);
if(tx!=ty){
sum+=Q[i].k;
st++;
father[tx]=ty;
if(st==n-1){
break;
}
}
}
cout<<sum<<endl;
return 0;
}