算法基础篇 — 图的最短路

整体框架

---

朴素Dijkstra

时间复杂度O(n² + m)，n 表示点数，m 表示边数

适用场景

单源最短路 + 只有正权边 + 稠密图

模拟思路

1. 创建一个布尔类型数组st，用于记录每个顶点的访问状态。初始化数组中所有元素为未访问状态false。

2. 创建一个整型数组dist，用于记录从起始顶点到每个顶点的最短路径长度。初始化数组中所有元素为无穷大。

3. 将起始顶点的最短路径长度设置为0。

4. 对于图中的每个顶点，执行n次以下循环（其中n为顶点数量）：

   a. 在未访问的顶点中，选择距离起始顶点最近的顶点，将其标记为已访问。

   b.如果通过当前顶点可以获得更短的路径长度，则更新dist数组中对应顶点的值。

5. 最终，dist数组中存储了从起始顶点到每个顶点的最短距离。

算法模板

int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < n - 1; i ++ )
    {
        int t = -1;     // 在还未确定最短路的点中，寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);

        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

---

堆优化Dijkstra

时间复杂度O(mlogn)，n 表示点数，m 表示边数

适用场景

单源最短路 + 只有正权边 + 稀疏图

模拟思路

1. 创建一个整型数组dist，用于记录从起始顶点到每个顶点的最短路径长度。初始化数组中所有元素为无穷大。

2. 将起始顶点的最短路径长度设置为0。

3. 创建一个最小堆heap，用于选择当前最短距离的顶点。并将起始顶点及其距离0加入堆中。

4. 当最小堆不为空时，执行以下循环：

   a. 弹出堆顶元素，即距离最短的顶点。

   b. 如果顶点已经确认了最短距离，忽略该顶点进行下一次循环。

   c. 遍历其邻接顶点，如果邻接顶点未访问过且通过当前顶点可以获得更短的距离，则更新dist数组中邻接顶点的距离，并将邻接顶点及其距离加入最小堆。

5. 最终，dist数组中存储了从起始顶点到每个顶点的最短距离。

算法模板

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];
}

---

Bellman-Ford

时间复杂度O(nm)，n 表示点数，m 表示边数

适用场景

单源最短路 + 负权边 + 有边数限制

算法模板

int n, m;       // n表示点数，m表示边数
int dist[N];        // dist[x]存储1到x的最短路距离
int backup[N];  // 备份数组

struct Edge   // 边，a表示出点，b表示入点，w表示边的权重
{
    int a, b, w;
}edges[M];

// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
    for (int i = 0; i < n; i ++ )
    {
    	memcpy(backup, dist, sizeof dist);
        for (int j = 0; j < m; j ++ )
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            dist[b] = min(dist[b], backup[a] + w);
        }
    }

    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
}

---

SPFA

时间复杂度 平均情况下O(m)，最坏情况下 O(nm)，n 表示点数，m 表示边数

适用场景

单源最短路 + 负权边

模拟思路

1. 创建一个整型数组dist，用于记录从起始顶点到每个顶点的最短路径长度。初始化数组中所有元素为无穷大。

2. 创建一个布尔类型的st数组，用于记录每个顶点是否在队列中。初始化数组中所有元素为未访问状态false。

3. 创建一个队列来存储待访问的顶点。

4. 将起始顶点的最短路径长度设置为0，并将其标记为已经入队。

5. 在队列不为空的情况下，执行以下循环：

   a.出队队首元素，将其状态修改为不在队列中。

   b.遍历其邻接顶点，如果邻接顶点未访问过且通过当前顶点可以获得更短的距离，则更新distance数组中邻接顶点的距离，并且如果该邻接顶点不在队列中，则将其加入队列，并将其标记为已经入队。

6. 最终，distance数组中存储了从起始顶点到每个顶点的最短距离。

算法模板

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

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

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

    while (q.size())
    {
        auto 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])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

---

floyd

时间复杂度O(n³)，n 表示点数

适用场景

多源汇最短路

模拟思路

1. 创建一个二维数组 dist，用于存储任意两个顶点之间的最短路径长度。初始化数组中对角线元素为0，非对角线元素为无穷大。

2. 对于图中的每个顶点 k，执行 n 次以下循环（其中 n 为顶点数量）：

   a.对于每对顶点 i 和 j，进行以下循环：

   如果从顶点 i 到顶点 k 经过顶点 j 的路径长度比当前的最短距离小，则更新dist数组中对应顶点的值。

3. 最终，dist数组中存储了从起始顶点到每个顶点的最短距离。

算法模板

初始化：
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

// 算法结束后，d[a][b]表示a到b的最短距离
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]);
}