图论最短路算法是一种家喻户晓的算法，并且一直受到各种出题人的青睐，在此简单介绍下几种常见算法
先看看个奇怪的概念(十分钟重要)：
松弛
以上图为例，黑点到红点有条路，你可以把它看成黑点和红点的连线，也可以看成黑红间一些点的连线，总之，已知求出的最短路长度即为7
这时候，我们引入一点(绿点)，发现比起原来求出的，通过从黑点用绿点中转到达红点，结果更优，这个操作，就叫做松弛

多源最短路：Floyd

多源最短路，即需要求图中任意两个点的最短路径，这种最短路目前貌似只有Floyd比较好用
这个算法的实现和思想都比较简单，是一种基于动规的思想
首先令点 i 到点 j 的最短路径为dis[ i ][ j ]，若 i 和 j 不连通，可以先设
dis[ i ][ j ]=INF(一个很大的值即可)
初始化后进入主题部分，我们每次枚举三个数:k,i,j，看看是原来求出的
dis[ i ][ j ]更优，还是通过k点中转，即dis[ i ][ k ]+dis[ k ][ j ]更优，这样就可以得出我们的转移方程，即dis[ i ][ j ]=min{ dis[ i ][ j ],dis[ i ][ k ]+dis[ k ][ j ] }
于是乎，核心代码也是相当的简单

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int n,m;
struct node{
	int x,y;
}a[N];
int dis[N][N];//邻接矩阵存图
void Floyed()//核心代码
{
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				if(i!=j && j!=k)
					if(dis[i][k]+dis[k][j]<dis[i][j])
						dis[i][j]=dis[i][k]+dis[k][j];
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		a[i].x=x;
		a[i].y=y;
	}
	memset(dis,1<<30,sizeof(dis));//初始化，赋一个极大值
	cin>>m;
	for(int i=1;i<=m;i++)
	{
		int x,y,u;
		cin>>x>>y>>u;
		dis[x][y]=dis[y][x]=u;
	}
	int s,t;
	cin>>s>>t;//求点s到点t的最短路
	Floyed();
	cout<<dis[s][t]<<endl;
	return 0;	
} 

时间复杂度显而易见为O(n^3)
Floyd虽然粗暴了点，但是用起来很方便，预处理后直接O(1)拿出来用，十分方便

单源最短路

单源最短路，即求指定的一点到其它点的最短路

法一：Bellman-Ford算法

由于本人对这个算法运用不是很熟练，所以就暂时跳过了，有兴趣的话可以去看看别的大佬的讲解

法二：Dijkstra

迪杰在OIer是最受欢迎的最短路算法，理解起来可能有点难，但是它的速度很快(优化后)，且较之SPFA，它很难被卡掉
初始化：起点s，dis[ s ]=0，其它赋一个很大的值
算法流程：
①在没被访问的节点中，找一个u，使得dis[ u ]最小
②将它标记为已知的最短路
③对所有和u相连的点做松弛操作
上面的文字略显枯燥，我们可以动手做一做

比如我们有这么一个图，要求单源最短路，起点为1
初始化：dis={0,∞,∞,∞,∞}

我们首先找到dis最小的，即起点，将它标记
然后发现，它可以对2，3，4进行松弛
修改：dis[2]=2,dis[3]=4,dis[4]=7
dis={0,2,4,7,∞}

接着，在未标记的点，找到dis最小的点2并标记，发现它可以对3，5进行松弛
修改：dis[3]=3,dis[5]=4
dis={0,2,3,7,4}

然后找到3并标记，发现它可以对4，5进行松弛，但由于数值比原来大，所以对5的松弛失败
改变：dis[4]=4
dis={0,2,3,4,4}
简单来说，就是每一次找到距离最小的点，然后对它相连的点进行松弛

#include<bits/stdc++.h>
using namespace std;
const int N=1e4+10;
int n,m,s,dis[N],vis[N];
struct node{
    int to,u;
};
vector<node> v[N];//邻接表存图
void Dijkstra()//算法主体
{
    for(int i=1;i<=n;i++)
    {
        int k=0;
        for(int j=1;j<=n;j++)//寻找距离最小点
            if(vis[j]==0 && dis[j]<dis[k])
                k=j;
	    vis[k]=1;//标记
        for(int j=0;j<v[k].size();j++)//寻找相连的点
        {
            int to=v[k][j].to,u=v[k][j].u;
            if(dis[k]+u<dis[to])//松弛
                dis[to]=dis[k]+u;
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    v[s].push_back((node){s,0});
    for(int i=0;i<=n;i++)
    	dis[i]=INT_MAX;
    dis[s]=0;
    for(int i=1;i<=m;i++)
    {
        int x,y,u;
        scanf("%d%d%d",&x,&y,&u);
        v[x].push_back((node){y,u});
        v[y].push_back((node){x,u});
    }
    Dijkstra();
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<' ';
}

算法复杂度为O(n^2),不能解决有边权为负数的图

Dijkstra的优化

其实，每次都循环找最小值十分浪费，c++提供给我们一种数据结构，堆，当我们用这个数据结构在线查询时，复杂度会小很多
改完后变成这样的了

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int n,m,s,dis[N],vis[N];
struct node{
    int to,u;
};
vector<node> v[N];
priority_queue<pair<int,int> > q;//优先队列(堆)，pair的第一关键字存dis的值的相反数(以此保证小的在堆顶，实现小根堆，第二关键字是节点的编号
void Dijkstra()
{
    q.push(make_pair(0,s));//压入初始节点
    while(q.size())
    {
        int x=q.top().second;//查询最小的，并存下它的节点编号
        q.pop();
        if(vis[x]==1) continue;
        vis[x]=1;
        for(int i=0;i<v[x].size();i++)
        {
            int to=v[x][i].to,u=v[x][i].u;
            if(dis[to]>dis[x]+u)//松弛
            {
                dis[to]=dis[x]+u;
                q.push(make_pair(-dis[to],to));//将松弛后的信息压入堆
            }
        }
    }
    
}
int main()
{
    cin>>n>>m>>s;
    v[s].push_back((node){s,0});
    for(int i=0;i<=n;i++)
    	dis[i]=INT_MAX;
    dis[s]=0;
    for(int i=1;i<=m;i++)
    {
        int x,y,u;
        scanf("%d%d%d",&x,&y,&u);
        v[x].push_back((node){y,u});
        v[y].push_back((node){x,u});
    }
    Dijkstra();
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<' ';
}

创作不易，求赞