最短路径算法

1.最短路径算法分为单源最短路径算法和多源最短路径算法

（a）单源最短路径算法，可以计算出从起点到任意一个起点的最短路径。

例如：Dijkstra算法 ，SPFA算法

（b）多源最短路径算法，可以计算出任意两点之间的最短路径。

例如：Floyd算法。

（c）负权边，就是指图中有边的权值为负数，此时Dijkstra算法失效（无法计算出最短路径），SPFA算法和Floyd算法仍然有效。

（d）负权回路，也叫负权环。所有最短路径算法全部失效，但是用SPFA算法可以检测出负权环，Dijkstra算法，Floyd算法无法检测出负权环。

2.Dijkstra算法和SPFA算法

（1）Dijkstra算法分三步：第一步选最小，第二步标记，第三步更新。

（2）SPFA算法，本质上是BFS算法，主要采用队列，其关键操作是出队和入队。

（a）出队：每次队首的父结点出队

（b）入队：初始时起点入队，之后孩子入队必须要满足两个条件：条件1--经过父结点能使该孩子到起点的距离更短，条件2--孩子未在队中

3. 代码

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2500+10,maxm=6200+10;
const int INF = 1<<30;
struct Edge
{
	int v,w,next;
}e[maxm*2];
int en,front[maxn];
int n,m,s,t;

void AddEdge(int u,int v,int w)
{
	en++;
	e[en].v=v;
	e[en].w=w;
	e[en].next=front[u];
	front[u]=en;
}
//SPFA 最坏O(nm)随机图实践性很好
void SPFA()
{
	int inq[maxn],d[maxn];
	queue<int> q;
	memset(inq,0,sizeof(inq)) ;
	for(int i=1;i<=n;i++) d[i]=INF;
	
	d[s]=0; inq[s]=1; q.push(s);
	while(!q.empty())
	{
		int u=q.front (); q.pop () ; inq[u]=0;
		for(int i=front[u];i>=0;i=e[i].next)
		{
			int v=e[i].v,w=e[i].w;
			if(d[v]>d[u]+w)
			{
				d[v]=d[u]+w;
				if(!inq[v])
				{
				 inq[v]=1;q.push(v);		
				} 	
			}	
		}
	} 
	printf("%d\n",d[t]);
}
//Dijkstra 0(mlogn)
struct HeapNode//小想堆，储存最小的
{
	int u,d;
	bool operator<(const HeapNode& rhs)const
	{
		return d>rhs.d;	
	}
		//注意这边要取反，因为pg是小根堆，我们要取最大的
};
void Dijkstra()
{
	int d[maxn];
	priority_queue<HeapNode> q;
	for(int i=1;i<=n;i++) d[i]=INF;
	d[s]=0;
	q. push((HeapNode){s,d[s]});//找到dist最小的
	while(!q.empty())
	{
		HeapNode x=q.top();
		q.pop(); //队首出队 
		int u=x.u;
		if(x.d != d[u]) //表明队首的x点已经失去时效性，直接跳过不处理 
		{
			continue; //x是队首出来的，考虑其时效性 
		}
		for(int i=front[u];i>=0;i=e[i].next)
		{
			int v=e[i].v,w=e[i].w;
			if(d[u]+w<d[v])
			{
				d[v]=d[u]+w;
				q.push((HeapNode){v,d[v]}); //点可以重复入队 
			}
		}
	}

} 
int main()
{
	memset(front,-1,sizeof(front));
	scanf("%d%d%d%d",&n,&m,&s,&t);
	int u,v,w;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d%d",&u,&v,&w);
		AddEdge(u,v,w);
		AddEdge(v,u,w);
	} 
	Dijkstra();//这里可以换成SPFA（），进行对比。 
	return 0;
}

3.Floyd算法

1. 这个算法是最简单、功能最强大的最短路径算法，但缺点是时间复杂度高

2. 相比其他算法，此算法必须背过
3 此算法是插点法，即如果经过k点能使i点和j点的最短路径变短，那就经过k点。
此算法使用枚举方法，依次插入一个点，更新任意两点之间的最短路径。
即在任意两点之间插入1号点，看是否能够跟新其最短路径;
在任意两点之问插入2号点，看是否能够跟新其最短路径;
...
在任意两点之间插入n号点，看是否能够跟新其最短路径

4. 关键算法

 5. 注意事项

中间点k必须为外层循环（不可以交换），起点i和终点j可以交换

6. 示例代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=100;
const int INF=10000;
int n;//点的数量
int m;//边的数量
int g[maxn][maxn];//二维数组存图,邻接矩阵存图,数组的初始值全部为0
int d[maxn][maxn];//存储任意两点的最短路径长度
void insertEdge(int from,int to,int w)//边的起点终点和权值
{
    g[from][to]=w;
}
void Floyd()
{
    for(int k=1;k<=n;k++) //k是中间点 
    {
        for(int i=1;i<=n;i++) //i是起点 
        {
            for(int j=1;j<=n;j++) //j是终点 
            {
                if(d[i][j]>d[i][k]+d[k][j])
                {
                    d[i][j]=d[i][k]+d[k][j]; //更新 
                }
            }
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++) //建图 
    {
      int from,to,w;
      cin>>from>>to>>w;
      insertEdge(from,to,w);
      insertEdge(to,from,w);
    }
    //初始化d数组，若两点之间存有边初始化成权值大小，没有边则初始为无穷大
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(g[i][j]>0)//i到j之间有边
            {
                d[i][j]=g[i][j];
            }
            else
            {
                d[i][j]=INF;
            }
            if(i==j)
            {
                d[i][j]=0;
            }
        }
    }
 
    Floyd();
 
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cout<<i<<"->"<<j<<":"<<d[i][j]<<endl;
        }
    }
    return 0;
}
/*
6
9
1 2 1
1 6 2
2 3 4
2 6 4
3 4 2
3 6 1
4 5 3
4 6 3
5 6 5
*/