算法学习笔记：最短路（朴素dijkstra + 堆优化dijkstra + Bellman-Ford + spfa + floyd）

基本思想

朴素Dijkstra代码模板

int g[N][N]; //用邻接矩阵存储稠密图
int dist[N]; //存储所有节点到起点的最短距离
bool st[N]; //判断该点是否已经确定到起点的最短距离
int n, m; //点和边

void dijkstra()
{
    memset(dist, 0x3f, sizeof(dist)); 初始化所有点到起点的距离为最大值
    dist[1] = 0; //起点到起点的距离初始化为0
    
    for (int i = 0; i < n; i ++) //进行n轮迭代，每一轮迭代确定一个点到起点的最短距离
    {
    	//寻找不在集合中的距离起点最近的点
        int t = -1;
        for (int j = 1; j <= n; j ++)
        {
            if (!st[j] && (t == -1 || dist[j] < dist[t]))
            {
                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) cout << -1; //起点无法到达点n
    else cout << dist[n];
}

堆优化版Dijkstra代码模板

int h[N], e[N], ne[N], w[N], idx; //稀疏图使用邻接表存储
int dist[N]; //存储1号节点到所有节点的距离
bool st[N]; //判断该点是否已经确定到起点的最短距离
int n, m; //点和边

typedef pair <int, int> PII; //队列中需要存储点的编号以及该点到起点的距离

//邻接表的初始化
memset(h, -1, sizeof(h));

//邻接表的创建
void add(int x, int y, int z)
{
    e[idx] = y;
    w[idx] = z; //记录该节点的权重
    ne[idx] = h[x];
    h[x] = idx ++;
}

void dijkstra()
{
    //初始化点到起点的距离
    memset(dist, 0x3f, sizeof(dist));
    dist[1] = 0;
    
    //创建小根堆
    priority_queue <PII, vector <PII>, greater<PII>> heap;
    //将起点放入队列
    heap.push({0, 1});
    
    while (!heap.empty())
    {
        auto t = heap.top(); //取出距离起点最近的那个点
        heap.pop();
        
        int d = t.first, id = t.second;
        if (st[id]) continue; //会有很多点重复的在堆里，已经确定了这个点到起点的最小距离了
        
        st[id] = true; //将这个点纳入集合
        
        //更新与这个点相邻的点与起点的距离
        for (int i = h[id]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (!st[j])
            {
                if (dist[j] > d + w[i])
                {
                    dist[j] = d + w[i];
                    heap.push({dist[j], j});
                }
            }
        }
    }
    
    if (dist[n] == 0x3f3f3f3f) cout << -1;
    else cout << dist[n];
}

Bellman-ford代码模板

struct //使用结构体存储每条边，方便遍历
{
    int a, b, c;
}Edges[M];

int n, m, k; //点，边，最短路径所含边数小于等于k
int dist[N], backup[N]; //备份dist数组，防止边的串联改变

int Bellman_ford()
{
    //初始化
    memset(dist, 0x3f, sizeof(dist));
    dist[1] = 0;
    
    for (int i = 0; i < k; i ++)
    {
        memcpy(backup, dist, sizeof(dist)); //备份dist数组
        
        //遍历每一条边，更新
        for (int j = 0; j < m; j ++)
        {
            int a = Edges[j].a, b = Edges[j].b, c = Edges[j].c;
            dist[b] = min(dist[b], backup[a] + c); //要使用备份数组进行判断是否更新
        }
    }
    
    //可能存在负权边使得dist[n] < 0x3f3f3f3f,但是不会小太多，最多少n * m, 大于0x3f3f3f3f / 2表示仍然无法到达
    if (dist[n] > 0x3f3f3f3f / 2) return 0x3f3f3f3f; 
    else return dist[n];
}

SPFA代码模板

int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N];
//int cnt[N]用于判断图中是否存在负权回路

void add(int x, int y, int c)
{
    e[idx] = y;
    ne[idx] = h[x];
    w[idx] = c;
    h[x] = idx ++;
}

int spfa()
{
    memset(dist, 0x3f, sizeof(dist));
    dist[1] = 0;
    
    queue<int> q;
    q.push(1);
    st[1] = true;
    
    while (!q.empty()) //每次队列中加入与起点距离变小了的点
    {
        int t = q.front();
        q.pop();
        st[t] = false;
        
        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];
}

Floyd代码模板

int d[N][N] //初始化，当i == j ,d[i][j] = 0,else d[i][j] = 0x3f3f3f3f
//存储边时，取min，解决重边问题
//也有可能存在无法到达，但是该段距离有被减小，使用大于0x3f3f3f3f / 2判断是否可达
void floyd()
{
    for (int k = 1; k <= n; k ++)
    {
        for (int i = 1; i <= n; i ++)
        {
            for (int j = 1; j <= n; j ++)
            {
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]); //三重循环更新最短距离
            }
        }
    }
}