算法基础课—搜索与图论（三）最短路问题——Dijkstra、bellman-ford、spfa、Floyd

最短路算法

问题类型

源点——起点，汇点——终点
单源最短路，即起点是固定的，求其到任意点的最短路
多源汇的最短路，给定任意两个点
n点数、m边数
稠密图——用朴素的dj。。
稀疏图——堆优化的。。。
存在负权边——如果求第k条边的，对边数有限制的，只能用Bellman算法
其他情况存在负权边的，用SPFA比较好

最短路问题难点——构建图

如何根据题目的背景，构建图，构建节点，构建边

Djikstra 算法

朴素版的Dijkstra算法

所需数据结构

1、dist[] 数组（int）——用于记录从起到到各个点的最短路径
一开始时dist[start] = 0,其他为无穷大
2、st[] 数组（bool）——用于记录是否在已经确定最短路径的集合中
3、g[][] 邻接矩阵，也可以用邻接表

算法流程

1、初始化dist数组，起点距离为0，其他为正无穷，将st[start] 置为true
2、for（i = 0； i < n; i ++）循环n次
3、在2循环内嵌套循环遍历n个节点，找出当前dist最小的节点，加入st集合，表示已经确定了最短路径
4、对当前dist最小的节点的边进行遍历，先判断是否存在集合st中，如果不存在，即还未确定最短路径，则判断其最短路径dist[j] 是否 > dist[i] + w,如果大于则更新。

核心

算法思想本质上是利用，不断利用已经确定最短路径的点，然后利用其确定了最短路径去更新其他点，然后再继续找出下一个确定最短路径的点，再去更新。

如何找出已经确定最短路径的点？用dist数组判断，当前dist最小，且不存在负边，那么其他的加起来都不会小于它，于是可以如此确定，但是如果存在负边，则不能这样确定,有可能某个点加上负边比当前小。

和Floyd比较类似，区别在，Floyd是利用从1-n的点，遍历他们的边，依次更新他们的距离，而Dijkstra则是每次先确定已经确定最短路径的点，再去更新，这样子是很有可能会小于其原本dist的，减少了更新比较的次数。

缺点

缺点：无法处理负权边

重边和自环的处理

对于重边和自环的处理
在算法中，如果有两条边的起点终点都相同，只取最短的那条边

例子

堆优化的Djikstra 算法

问题的提出

可以发现在朴素版的Djikstra中，需要每次查找当前dist最小值的问题，这一步时间复杂度为O（n2）为了进一步优化，可以采用堆排序的算法，找出最小值为O（1），更新堆为O（logn），这样子总的复杂度是O（logn）。

堆可以采用优先队列进行存储，由于优先队列无法更改其中的值，于是采用直接添加的方式，为了区分是哪个节点设计pair类型的优先队列{a，b} a为dist【】的值，b为下标，pair类型的优先队列总是先比较第一个再比较第二个，这样，就可以比较好的进行最小值的输出。

需要的数据结构

1、堆 优先队列
2、dist数组，记录当前最小情况
3、邻接表（h[],e[],ne[],w[],idx）or 邻接矩阵(g[][])
4、st数组，判断其是否已经确定最短路径

对于重边和自环的问题

视频里说由于是邻接表可以不用考虑？？？一定是最小的？？？
但是感觉还是得考虑!

算法流程

1、初始化dist数组，将dist[start]置为0，其余置为0x3f；将第一个信息{0，start}压入堆中
2、设置循环 while (heap.size()) 其实我感觉设置0-n也可以，但是设置0-n如果碰到st[]=true的情况的时候其实是不能叠加迭代次数的，应该还是n，这样不太好设置，不如设置成heap.size()。
3、每次取出堆顶元素即最小值，先判断其是否已经确定最短路径，即st【】。如果已经确定最短路径，则continue，否则，遍历其边，更新dist数组，并将更新的dist信息压入堆中。
4、结果输出，如果dist还是==0x3f3f3f3f,即没有边到达，则输出-1，有则输出对应最短路径。

模板

typedef pair<int, int> PII;

int n;      // 点的数量
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
   
   
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({
   
   0, 1});      // first存储距离，second存储节点编号

    while (heap.size())
    {
   
   
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        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;
    return dist[n];
}

自己的代码

#include<iostream>
#include<cstring>
#include<queue>//优先队列也是导入的这个头文件
using namespace std;
const int N = 2e5;
int  d[N];
bool st[N];
int n, m;
int start = 1;//起始点
int h[N], e[N], ne[N], w[N], idx;
typedef pair<int, int> PII;
priority_queue<PII, vector<PII>, greater<PII>> heap;
void add(int a, int b, int we){
   
   
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx;
    w[idx] = we;
    idx ++;
}
int djikstra(){
   
   
    int i, j;
    d[start] = 0;
    heap.push({
   
   0,1});//pair类型的优先队列总是先比较first的大小，再比较second大小，所以first为dist的值，second为下标
    for(i = 1; i <= n; i ++){
   
   
        auto min_t = heap.top(