最短路问题

---

一、单源最短路

边权都为正

1.朴素版dijkstra

思路：

存储：邻接矩阵；如有重边：取最短边。

1. 初始化距离数组：dist[1] = 0; dist[i] = 无穷
2. 循环迭代n次，找到 不在集合s中的 且距离源点最近的点t（跳板）
   • 拿到t<---j
   • 跳板t加入集合s
   • 用t去更新其它点到源点的距离
3. 返回结果

【核心代码】

时间复杂度：O(n * n)

int g[N][N];
int dist[N];//存储各个点到源点的最短距离
bool st[N];//集合s

int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    for(int i = 0; i < n; i ++)
    {
    	int t = -1;
    	for(int j = 1; j <= n; j ++)
    	{
    		if(!st[j] && (t == -1 || dist[t] > dist[j]))
    			t = j;
    	}
    	st[t] = true;
    	
    	for(int j = 1; j <= n; j ++) dist[j] = min(dist[j], dist[t] + g[t][j]);
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    else return dist[n];
}

2.堆优化版dijkstra

朴素版dijkstra算法在寻找不在集合s中的 且 距离源点最近的点t 的时间复杂度为(n * n)，既然寻找最小，我们可以使用一个小根堆来优化这一步，其它实现大致相同！

和BFS代码框架十分的相像！

【核心代码】

思路：

存储方式：邻接表

1. 一号点的距离初始化为零，其他点初始化成无穷大。
2. 将一号点放入堆中。
3. 不断循环，直到堆空。每一次循环中执行的操作为：
   弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同，并标记该点的最短路径已经确定（加入集合s））。
   用该点更新邻接节点的距离，若更新成功就加入到堆中（我们肯定要小的）。

【核心代码】

时间复杂度：O(mlongn)

typedef pair<int, int> PII;// first:距离 second:节点编号(内部按first排序)
priority_queue<PII, vector<PII>, greater<PII>> heap; //小根堆的定义方式
int h[N], e[N], w[N], ne[N], idx;
int dist[N];
int st[N];

int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	heap.push({dist[1], 1});
	
	while(heap.size())
	{
		auto t = heap.top();// 拿到跳板t
		heap.pop();
		
		int ver = t.second, distance = t.first;// ver节点编号
		if(st[ver]) continue;
		st[ver] = true;
		
		//用t去更新它的邻接节点
		for(int i = h[ver]; i != -1; i = ne[i])
		{
			int j = e[i];
			if(dist[j] > distance + w[i])
			{
				dist[j] = distance + w[i];
				heap.push({dist[j], j});
			}
		}
	}
	if(dist[n] == 0x3f3f3f3f) return -1;
	else return dist[n];
}

存在负权边

1.Bellman-Ford：有边数限制的最短路

限制k次

松弛操作：

思路：

int dist[N];// 表示节点i到节点1的距离
int back[N];//数据备份防止串联
//存储方式：结构体存边
struct Edge
{
	int a, b, w;
}edge[M];

//1. 初始化距离

//2. 
for k 次
{
	备份数据，防止串联
	//3.
    for 所有边 a ---> b (w)// 枚举遍历所有条边
    {
		//更新（松弛操作）
		dist[b] = min(dist[b], backup[a] + w);
    }	
}

【核心代码】

时间复杂度：O(n*m)

void bellman_ford()
{
	memset(dist, 0x3f, sizeof dist);//初始化
	dist[1] = 0;
	
	for(int i = 0; i < k; i ++)
	{
		memcpy(back, dist, sizeof dist);//数据备份
		for(int j = 0; j < m; j ++)//枚举所有边
		{
			int a = edge[j].a, b = edge[j].b, w = edge[j].w;
			dist[b] = min(dist[b], dist[a] + w);
		}
	}
}


主函数：if(dist[n] > 0x3f3f3f3f / 2) puts("No");
else cout << dist[n];

限定k条边的原因：可能出现负权环

为什么要用backip[N]备份数据？

为什么是dist[n]>0x3f3f3f3f/2， 而不是dist[n]==0x3f3f3f3f
5号节点距离起点的距离是无穷大，利用5号节点更新n号节点距离起点的距离，将得到10^9−2，109−2, 虽然小于10^9, 但并不存在最短路，(在边数限制在k条的条件下)。

2.spaf

SPFA 算法是 Bellman-Ford算法 的**队列优化**算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。

Bellman_ford算法会遍历所有的边，但是有很多的边遍历了其实没有什么意义，我们只用遍历那些到源点距离变小的点所连接的边即可，只有当一个点的前驱结点更新了，该节点才会得到更新；因此考虑到这一点，我们将创建一个队列每一次加入距离被更新的结点。（队列里边存的是所有变小的节点，只有前面的点变小了，那么当更新时它的后继节点才有可能变小！）

时间复杂度：通常O(m)，最坏O(n*m)

基于宽搜思想：

1. queue <– 1
2. while queue 不为空
   (1) t <– 队头
   queue.pop()
   (2)用 t 更新所有出边 t –> b，权值为w
   queue <– b (若该点被更新过，则拿该点更新其他点)

（特像dijkstra算法，hhhhh）

(1)spfa求最短路

【核心代码】

//存储方式：邻接表

int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];//st存的是这个点是否在队列当中，防止队列存储重复的点（存重复没有意义）

int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        int t = q.front();
        q.pop();

        st[t] = false;// 拿出后，不在队列中了
		
		//用t更新所有出边
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])
                {
                    q.push(j);// 待更新其它点的点入队（表小的点）
                    st[j] = true;
                }
            }
        }
    }

    return dist[n];
}

(2)spfa判断负环

思路：

维护一个计数cnt[]数组，当cnt[x]>=n时，则表明出现负环！

1、dist[x]记录虚拟源点到x的最短距离

2、cnt[x]记录当前x点到虚拟源点最短路的边数，初始每个点到虚拟源点的距离为0，只要他能再走n步，即cnt[x] >= n，则表示该图中一定存在负环，由于从虚拟源点到x至少经过n条边时，则说明图中至少有n + 1个点，表示一定有点是重复使用

3、若dist[j] > dist[t] + w[i],则表示从t点走到j点能够让权值变少，因此进行对该点j进行更新，并且对应cnt[j] = cnt[t] + 1,往前走一步

【注意】：

• 判断是否存在负环，并非判断是否存在从1开始的负环，因此需要将所有的点都加入队列中，更新周围的点。
• 不需要初始化dist数组，如果存在负环，不管初值为多少，都会被更新！

【核心代码】

//存储方式：邻接表
int h[N], w[N], e[N], ne[N], idx;
int dist[N];//存放点到源点的最短距离
int cnt[N];//cnt[x] 表示 当前从1~x的最短路的边数
bool st[N];
bool spfa()
{

    // 这里不需要初始化dist数组为 正无穷/初始化的原因是， 如果存在负环， 那么dist不管初始化为多少， 都会被更新
    queue<int> q;
    
    //不仅仅是1了， 因为点1可能到不了有负环的点， 因此把所有点都加入队列
    for(int i = 1; i <= n; i ++)
    {
        q.push(i);
        st[i] = true;
    }
    
    while(q.size())
    {
        int t = q.front();
        q.pop();
        st[t] = false;//取出队列后 标记为已用过
        
        //用t去去更新所有出边（后继）
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;//维护cnt数组
                if(cnt[j] >= n) return true;
                
                if(!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
            
        }
    }
    return false;
}

二、多源最短路

Floyd

思想：动态规划

时间复杂度：O（n ^ 3）

【核心代码】

void floyd()
{
    for(int k = 1; k <= n; k ++)
        for(int i = 1; i <= n; i ++)
            for(int j = 1; j <= n; j ++)
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}

三、总结

本文是对acwing基础课搜索与图论章节最短路问题的复盘，旨在进一步加深对算法的理解，并能快速码出代码，希望对你也有些许帮助呀！

---

注：如果文章有任何错误或不足，请各位大佬尽情指出，评论留言留下您宝贵的建议！如果这篇文章对你有些许帮助，希望可爱亲切的您点个赞推荐一手，非常感谢啦

欢迎访问：本人博客园地址