一、广度优先搜索
1、思路：距离开始点最近的点首先被赋值，最远的点最后被赋值。
2、适用范围：对于非负数权的无圈图来说（单源最短路径）。
3、算法实现：
（1）一个队列记录每个每个节点的编号。
（2）将起始节点入队，将所有节点到起始节点的距离设置为无穷大，起始节点到起始节点的距离为0；
（3）取队列的第一个节点，这个节点出队，遍历这个节点相邻的节点，如果这个节点的距离是INF就变为它前一个节点的距离+1，并且入队。
（4）重复（3）操作，直到所有所有队列为空为止，此时dis数组记录了每一个节点到起始节点的最小距离。
4、代码：
#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
const int maxn = 1200;
const int INF = 0x3fff;
vector <int> vc[maxn];
int dis[maxn];
void bfs(int n)
{
int i,j,tmp;
for(i=1;i<=n;i++) dis[i]=INF;
dis[1]=0;
queue <int> q;
q.push(1);
while(!q.empty())
{
tmp=q.front();
q.pop();
for(i=0;i<vc[tmp].size();i++)
{
if(dis[vc[tmp][i]]>dis[tmp])
{
dis[vc[tmp][i]]=dis[tmp]+1;
q.push(vc[tmp][i]);
}
}
}
}
int main(void)
{
int n,m,i,x,y;
cin>>n>>m;
for(i=1;i<=m;i++)
{
cin>>x>>y;
vc[x].push_back(y);
}
bfs(n);
cout<<dis[n]<<endl;
return 0;
}
5、复杂度：O(|V|^2)，复杂度较高。
二、Dijkstra算法
1、思路：贪心
2、适用范围：有权图的非负值的无圈图，解决单源最短路径的问题（即从st到ed的最短路径，st确定）。
3、算法实现：
（1）edge二维数组表示存储图的边的信息，（即邻接数组存储图结构），vis数组存储每个节点的状态
dis存储每个节点到起始节点的距离，pre存储每个节点的前一个节点，用来记录最短路径。
（2）开始先初始化，pre数组初始化为-1，设置dis[st]=1（这一步也可以放到dij（）函数里面）。
（3）找到dis中最小值的未被标记过的值，然后标记这个值，找到这个值的邻接点中可以更新的距离。
（4）重复（3）直到pos为-1。
4、代码：
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 1200;
const int INF = 0x3fff;
//建立图结构
int edge[maxn][maxn],dis[maxn],pre[maxn];
int vis[maxn],m,n;
void Init()
{
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
edge[i][j]=(i==j?0:INF);
for(int i=1;i<=n;i++) dis[i]=INF,pre[i]=-1,vis[i]=0;
}
void dij(int st)
{
int i,j;
dis[st]=0;
for(j=1;j<=n;j++)
{
int pos=-1,mi=INF;
for(i=1;i<=n;i++)
if(vis[i]==0&&dis[i]<mi)
{
mi=dis[i];
pos=i;
}
if(pos==-1) break;
vis[pos]=1;
for(i=1;i<=n;i++)
if(vis[i]==0&&dis[pos]+edge[pos][i]<dis[i])
{
dis[i]=dis[pos]+edge[pos][i];
pre[pos]=i;
}
}
}
void Print(int st,int ed)
{
int x=dis[st];
printf("路径是：");
while(st!=-1)
{
printf(" %d",st);
st=pre[st];
}
printf("\t最短路径距离是：%d\n",dis[ed]);
}
int main(void)
{
int x,y,i,z;
cin>>n>>m;
Init();
for(i=1;i<=m;i++)
{
cin>>x>>y>>z;
edge[x][y]=edge[y][x]=z;
}
dij(1);
Print(1,n);
return 0;
}
/*
5 5
1 2 3
1 4 5
2 3 4
3 4 1
3 5 7
*/
5、时间复杂度：O(|V|^3)。
补充：具有负值边的图
1、可以加上一个值变为正数然后再进行dij。
2、直接用广搜，队列可以保证不会重复计算。
过程：
（1）将开始的节点放进队列
（2）每一次取出队列的头结点，并查找它的邻接节点，寻找比它小的边的权值。
（3）重复操作直到队列为空。
#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int maxn = 1200;
const int INF = 0x3fff;
int edge[maxn][maxn],vis[maxn],pre[maxn],dis[maxn],n,m;
void Init()
{
int i,j;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
edge[i][j]=(i==j?0:INF);
for(i=1;i<=n;i++) pre[i]=-1,dis[i]=INF,vis[i]=0;
dis[1]=0;
}
void bfs()
{
queue <int> q;
q.push(1);
while(!q.empty())
{
int top=q.front();
q.pop();
for(int i=1;i<=n;i++)
{
if(edge[top][i]!=INF&&top!=i&&dis[top]+edge[top][i]<dis[i])
{
dis[i]=dis[top]+edge[top][i];
pre[i]=top;
if(vis[i]==0) q.push(i),vis[i]=1;
}
}
vis[top]=0;
}
}
void Print(int st,int ed)
{
while(st!=-1)
{
printf("%d ",st);
st=pre[st];
}
printf("\t%d\n",dis[ed]);
}
int main(void)
{
int i,j,x,y,z;
cin>>n>>m;
Init();
for(i=1;i<=m;i++)
{
cin>>x>>y>>z;
edge[x][y]=z;
}
bfs();
Print(n,n);
return 0;
}
/*
5 5
1 2 3
2 3 -4
3 5 7
1 4 5
4 3 -1
*/
三、Floyd算法
1、思路：动态规划，状态转移方程dw=min(dw,Cv,w);
2、适用范围：边权值可以为负数，可以求从任意节点s到其他节点的最短路径。
3、算法实现：
（1）设置二维数组dis（存储每个节点到其他节点的距离），path（记录i，j节点之间的中转节点）。
（2）先初始化，dis数组赋值为INF，path赋值为j（为中转做准备）。
（3）三层循环，k表示中转接点，i，j循环用来遍历图的每一个节点。
（4）可以求出任意两点之间的最短距离。
4、代码：
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 1200;
const int INF = 0x3fff;
int dis[maxn][maxn],path[maxn][maxn],m,n;
void Init()
{
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++) dis[i][j]=INF,path[i][j]=j;
}
void Floyd()
{
int i,j,k;
for(k=1;k<=n;k++)
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
if(dis[i][j]>dis[i][k]+dis[k][j])
dis[i][j]=dis[i][k]+dis[k][j],path[i][j]=path[i][k];
}
int main(void)
{
int x,y,z;
cin>>n>>m;
Init();
for(int i=1;i<=m;i++)
{
cin>>x>>y>>z;dis[x][y]=z;
}
Floyd();
printf("%d\n",dis[1][n]);
int st=1,ed=n;
while(st!=ed) //记录路径
{
cout<<st<<" ";
st=path[st][ed];
}
printf("%d\n",ed);
return 0;
}
/*
5 4
1 2 3
2 3 4
3 4 2
2 5 -1
*/
5、复杂度：O(|V|^3)。
四、Bellmen-Ford 算法
1、思路：判断图中是否含有负环，如果松弛n-1次还可以松弛，说明有负环，无法得出结果，否则就完成。
2、适用范围：含有或不含有负数边的图，求单源最短路径的算法。
3、实现过程：
（1）建立一个边的结构体数组edge（存储边的两个节点和权值，如果有向图，输入时就是一条边，无向图每次输入就是两条边）；
建立一个数组dis记录每个节点的距离到起始节点的距离；
建立一个pre数组，存储每一个节点的前一个节点。
（2）初始化：dis初始化为INF，起始节点初始化为0；pre数组初始化为0；
（3）进行n-1次松弛操作，每次判断dis[v]<dis[u]+C(u,v)是否成立，成立的话，更新dis[v]和pre[v]（类似于dijkstra算法里对每个节点的距离的更新）。
（4）判断是否有负负数环。
4、代码：（以有向图为例）
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 1200;
const int INF = 0x3fff;
struct Node{
int u,v,cost;
}edge[maxn];
int dis[maxn],pre[maxn],m,n,st,ed;
void Init() //初始化
{
for(int i=1;i<=n;i++) dis[i]=(i==st?0:INF),pre[i]=0;
}
bool Bellman_Ford()
{
int i,j;
for(i=1;i<=n-1;i++) //n-1次松弛
for(j=1;j<=m;j++)
if(dis[edge[j].u]+edge[j].cost<dis[edge[j].v])
dis[edge[j].v]=dis[edge[j].u]+edge[j].cost,pre[edge[j].v]=edge[j].u;
for(i=1;i<=n;i++) //判断是否存在负数环
if(dis[edge[i].v]>dis[edge[i].u]+edge[i].cost) return false;
return true;
}
int main(void)
{
int x,y,z,i;
cin>>n>>m;
st=1;ed=n;
Init();
for(i=1;i<=m;i++)
{
cin>>x>>y>>z;
edge[i].u=x;edge[i].v=y;edge[i].cost=z;
}
pre[st]=st;
if(Bellman_Ford())
{
printf("%d\n",dis[ed]);
while(ed!=pre[ed])
{
printf("%d ",ed);
ed=pre[ed];
}
printf("%d\n",ed);
}
return 0;
}
/*
5 4
1 2 3
2 3 4
3 4 2
2 5 -1
*/
5、复杂度：O(|E|*|V|)。
五、Bellman-Ford算法的队列优化（spfa算法）
1、思路：一次松弛结束后会有一些节点的值已经达到最小，以后也不用去改变，如果再次判断就浪费了时间。可以考虑每次对最短路径发生变化的点进行松弛，这里就是对Bellman算法的优化（与上面具有负数边的广搜处理类似）。
2、适用范围：含有或不含有负数边的图，求单源最短路径的算法。
3、实现过程：
（1）建立一个Node表示边的信息，建立一个数组dis表示距离的大小，vis数组标记每个节点是否出现过，pre存储路径，cnt存储每一个节点出现的次数。
（2）初始化，清空edge，dis赋值为INF；cnt，pre，vis数组初始化为0.
（3）用广搜的思想进行，将起始节点入队。
（4）取出第一个节点，标记它出队，找到与它相邻的节点，更新相邻节点的距离的值，如果这个邻接点未在队列中，就可以入队。
判断一下这个点的操作数是否超过n-1，如果超过n-1就返回false。
（5）重复（4）直到队列为空或者直接返回false。
4、代码：（以有向图为例）
#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
using namespace std;
//以有向图为例。
const int maxn = 1200;
const int INF = 0x3ffff;
int vis[maxn],dis[maxn],pre[maxn],cnt[maxn],n,m,st,ed;
struct Node{
int v,cost;
Node(int a,int b):v(a),cost(b){}
};
vector <Node> edge[maxn];
void Init()
{
for(int i=1;i<=n;i++) dis[i]=INF,edge[i].clear(),vis[i]=0,pre[i]=0,cnt[i]=0;
st=1;ed=n;
}
bool Bellman()
{
dis[st]=0;
queue <int> q;
q.push(st);vis[st]=1;
while(!q.empty())
{
int top=q.front();q.pop();
vis[top]=0;
for(int i=0;i<edge[top].size();i++)
{
Node tp=edge[top][i];
if(dis[top]<INF&&dis[top]+tp.cost<dis[tp.v])
{
dis[tp.v]=dis[top]+tp.cost;
pre[tp.v]=top;
if(vis[tp.v]==0)
{
q.push(tp.v);vis[tp.v]=1;
if(++cnt[tp.v]>n) return false;
}
}
}
}
return true;
}
int main(void)
{
int x,y,z;
cin>>n>>m;
Init();
for(int i=1;i<=m;i++)
{
cin>>x>>y>>z;
edge[x].push_back(Node(y,z));
}
if(Bellman())
{
printf("%d\n",dis[ed]);
while(ed!=st)
{
cout<<" "<<ed;
ed=pre[ed];
}
printf(" %d\n",st);
}
return 0;
}
/*
5 4
1 2 3
2 3 4
3 4 2
2 5 -1
*/
5、复杂度：O(|V|*|E|)。
来源：https://www.cnblogs.com/2018zxy/p/10120549.html