代码随想录算法训练营Day67|Floyd算法、A*算法

Noir间

于 2024-07-13 17:56:13 发布

阅读量383

点赞数 15

文章标签：算法

本文链接：https://blog.csdn.net/github_35852648/article/details/140398241

版权

Floyd算法

代码随想录 (programmercarl.com)

97. 小明逛公园 (kamacoder.com)

本题要针对小明的计划，求计划中不同起点、不同终点的多条最短路径，与之前的dijkstra、bellman_ford等求单源最短路径不同，属于求多源最短。（多次调用单源最短路算法？）

这里引入Floyd算法，这里简单介绍下Floyd算法。

Floyd算法，全称为Floyd-Warshall算法，是一种用于计算图中所有顶点对之间最短路径的算法。该算法由罗伯特·弗洛伊德（Robert Floyd）于1962年提出，并以弗洛伊德和斯蒂芬·沃舍尔（Stephen Warshall）的名字命名。

Floyd算法对边的权值正负没有要求，都可以处理。

Floyd算法的基本思想是动态规划，其核心步骤如下：

初始化：建立一个二维数组D，其中D[i][j]表示顶点i到顶点j的最短路径长度。（若节点1到9的最短路径为10，则D[1][9] = 10）初始化时，若i和j直接相邻，则D[i][j]为它们之间的边权；若i和j不直接相邻，则D[i][j]为无穷大；对角线元素D[i][i]为0。
计算最短路径：对于图中的每个顶点k，依次考虑经过顶点k的所有可能路径，并更新D数组。更新规则为：若D[i][k] + D[k][j] < D[i][j]，则将D[i][j]更新为D[i][k] + D[k][j]。(考虑节点1到节点5的最短路径可以由节点1到节点3的最短距离和节点3到节点5的最短距离组合而成，只需判断D[1][3] + D[3][5]与D[1][5]的情况来更新D[i][j]数组，这就是子问题推导出整体最优方案的递归方式)
得到最短路径：经过所有顶点的迭代后，D数组中的元素即为图中所有顶点对之间的最短路径长度。

动态规划五部曲

针对Floyd算法的动态规划，用五部曲来详解。

确定dp数组（dp table）以及下标的含义
确定递推公式
dp数组如何初始化
确定遍历顺序
举例推导dp数组

具体参考代码随想录

dp数组 D[i][j][k] = m，其中D[i][j][k]表示节点i和j之间以中间集合k（[1....k-1]记录路径）为中间节点的最短路径，m表示最短路径。

递推公式，递推公式分为两种情况

节点i和j的最短路径经过节点k D[i][j][k] = D[i][k][k-1]+D[k][j][k-1]
节点i和j的最短路径不经过节点k D[i][j][k] = D[i][j][k-1]

节点i和节点k的最短路径不经过节点k，中间结点集合为[1...k-1]，选取两种情况的较小值。

D[i][j][k] = min(D[i][k][k-1] + D[k][j][k-1]，D[i][j][k-1])

数组的初始化

当i和j连通时，D[i][j] =val,D[j][i] = val，若需要考虑路径，则D[i][j][0] =val，D[j][i][0] =val。此外，D[i][i][0]和D[i][i]都为0，而其余位置赋值最大值。

遍历顺序

若是二维数组，直接i和j嵌套遍历即可，若为三维数组，考虑k由k-1得到，需将k=0的i和j遍历完后，再依次将k++，再遍历i和j。

最后返回dp[i][j][k]，k为最大值。

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, m; // 定义变量n和m，分别表示景点的数量和双向道路的数量
    cin >> n >> m; // 从标准输入读取景点数量和双向道路数量

    // 创建一个三维向量grid，用于存储任意两个景点之间的最短路径长度
    // grid[i][j][k]表示从景点i到景点j，经过编号不大于k的景点的最短路径长度
    // 初始化大小为n+1，因为景点编号从1开始，且为了简化边界处理，包括了编号0的“虚拟”景点
    vector<vector<vector<int>>> grid(n + 1, vector<vector<int>>(n + 1, vector<int>(n + 1, 10005)));
    // 初始化路径长度为10005，代表无穷大，即两个景点之间没有直接路径

    int p1, p2, val; // 定义变量p1, p2, val，分别表示一条道路的两个端点和该道路的权重
    for (int i = 0; i < m; i++) { // 循环读取每条道路的信息
        cin >> p1 >> p2 >> val; // 从标准输入读取道路的两个端点和权重
        // 初始化直接相连的景点之间的路径长度
        grid[p1][p2][0] = val;
        grid[p2][p1][0] = val; // 因为是双向道路，所以两个方向都要初始化
    }

    // Floyd-Warshall算法的核心三重循环，用于计算所有景点对之间的最短路径
    for (int k = 1; k <= n; k++) { // k表示当前考虑经过的中间景点
        for (int i = 1; i <= n; i++) { // i表示起点
            for (int j = 1; j <= n; j++) { // j表示终点
                // 更新从i到j，经过编号不大于k的景点的最短路径长度
                // 比较直接到达j的路径长度和经过k到达j的路径长度，取较小值
                grid[i][j][k] = min(grid[i][k][k - 1] + grid[k][j][k - 1], grid[i][j][k - 1]);
            }
        }
    }

    int z, start, end; // 定义变量z, start, end，分别表示查询次数和每次查询的起始景点和终止景点
    cin >> z; // 从标准输入读取查询次数
    while (z--) { // 循环处理每次查询
        cin >> start >> end; // 从标准输入读取查询的起始景点和终止景点
        // 输出从起始景点到终止景点的最短路径长度
        // 如果最短路径长度为初始化时的无穷大值，则输出-1，表示没有路径
        if (grid[start][end][n] == 10005) cout << -1 << endl;
        else cout << grid[start][end][n] << endl; // 否则输出最短路径长度
    }
}

时间复杂度为O(N^3)，空间复杂度为O(N^3)(三维数组)

空间优化

滚动数组

grid[i][j] = min(grid[i][j],grid[i][k]+grid[k][j]);

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, m, p1, p2, val;
    cin >> n >> m;

    vector<vector<int>> grid(n + 1, vector<int>(n + 1, 10005));  // 因为边的最大距离是10^4

    for(int i = 0; i < m; i++){
        cin >> p1 >> p2 >> val;
        grid[p1][p2] = val;
        grid[p2][p1] = val; // 注意这里是双向图

    }
    // 开始 floyd
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                grid[i][j] = min(grid[i][j], grid[i][k] + grid[k][j]);
            }
        }
    }
    // 输出结果
    int z, start, end;
    cin >> z;
    while (z--) {
        cin >> start >> end;
        if (grid[start][end] == 10005) cout << -1 << endl;
        else cout << grid[start][end] << endl;
    }
}

算法的空间复杂度为O(n^2),时间复杂度为O(n^3)。

**A*算法**

127. 骑士的攻击 (kamacoder.com)

具体内容看代码随想录 (programmercarl.com)

先简单介绍一下A*算法。

A*（A-star）算法是一种广泛应用于路径规划和图遍历的启发式搜索算法。它旨在找到从起始点到目标点的最短路径。A*算法结合了最佳优先搜索的高性能和Dijkstra算法的有点，通过使用启发式函数来评估到达目标点的代价，从而更高效地搜索路径。

A*算法的核心思想如下：

开放列表（Open List）：用于存储待检查的节点。
关闭列表（Closed List）：用于存储已经检查过的节点。
节点的评价函数（f(n)）：用于评估节点n的质量，以确定搜索的优先级。评价函数由两部分组成：
1. g(n)：从起始点到节点n的实际距离。
2. h(n)：从节点n到目标点的启发式估计距离。这个估计距离是基于某些启发式信息，例如曼哈顿距离、欧几里得距离等。
3. 评价函数f(n)的计算公式为：f(n) = g(n) + h(n)

A*算法的步骤如下：

将起始节点添加到开放列表中。
如果开放列表为空，表示没有找到路径，算法结束。
从开放列表选出f(n)最小的节点，记作当前节点，
将当前节点从开放列表移除，并添加到关闭列表中。
对当前节点的每一个邻居节点进行以下操作：
- 如果邻居节点不可通过或在关闭列表中，则忽略它。
- 如果邻居节点不在开放列表中，计算其f(n)，并将其父节点设置为当前节点，然后将其添加到开放列表中。
- 如果邻居节点已经在开放列表中，检查通过当前节点到达它的路径是否更好（即g(n)值更小）。如果是，更新其f(n)值和父节点。
如果目标节点被添加到开放列表中，表示找到了一条路径。此时可以从目标节点开始，通过父节点回溯到起始节点，形成完整的最短路径。
返回到步骤2。

A*算法的效率很大程度上取决于启发式函数h(n)的选择。一个好的启发式函数可以显著减少搜索空间，提高算法的效率。如果h(n)始终低估从节点n到目标节点的实际距离，A算法保证能够找到最短路径。如果h(n)高估了距离，A*算法仍然能够找到最短路径，但效率可能不如使用更准确的启发式函数。

#include <iostream>
#include <queue>
#include <string.h>
using namespace std;

// 定义一个全局数组，用于记录每个位置到起点的移动次数
int moves[1001][1001];
// 定义一个全局数组，用于表示马在棋盘上的八个可能移动方向
int dir[8][2] = {
    -2, -1, -2,  1, -1,  2,  1,  2, // 表示马走“日”字形的四个方向
     2,  1,  2, -1,  1, -2, -1, -2  // 再加上对称的四个方向
};

// 定义全局变量，表示目标位置
int b1, b2;

// 定义Knight结构体，表示马的当前位置、G值、H值和F值
struct Knight {
    int x, y;  // 当前位置坐标
    int g, h, f;  // G值、H值和F值
    // 重载小于运算符，用于优先队列排序，F值小的优先
    bool operator<(const Knight & k) const {
        return k.f < f;
    }
};

// 定义一个优先队列，用于存储待处理的Knight节点
priority_queue<Knight> que;

// 启发式函数，计算从当前位置到目标位置的预估消耗H值
int Heuristic(const Knight& k) {
    // 使用欧几里得距离的平方作为启发式函数
    return (k.x - b1) * (k.x - b1) + (k.y - b2) * (k.y - b2);
}

// A*算法实现
void astar(const Knight& k) {
    Knight cur, next;
    que.push(k);  // 将起始位置加入优先队列
    while (!que.empty()) {
        cur = que.top();  // 取出F值最小的节点
        que.pop();
        // 如果当前节点是目标节点，则结束搜索
        if (cur.x == b1 && cur.y == b2)
            break;
        // 遍历所有可能的移动方向
        for (int i = 0; i < 8; i++) {
            next.x = cur.x + dir[i][0];  // 计算下一个可能的节点位置
            next.y = cur.y + dir[i][1];
            // 检查新位置是否在棋盘范围内
            if (next.x < 1 || next.x > 1000 || next.y < 1 || next.y > 1000)
                continue;
            // 如果新位置还没有被访问过
            if (!moves[next.x][next.y]) {
                moves[next.x][next.y] = moves[cur.x][cur.y] + 1;  // 更新移动次数
                // 计算新位置的G、H和F值
                next.g = cur.g + 5;  // 马走一步的消耗，这里简化为5
                next.h = Heuristic(next);
                next.f = next.g + next.h;
                que.push(next);  // 将新位置加入优先队列
            }
        }
    }
}

int main() {
    int n;  // 查询次数
    cin >> n;
    int a1, a2;  // 起始位置
    while (n--) {
        cin >> a1 >> a2 >> b1 >> b2;  // 读取起始位置和目标位置
        memset(moves, 0, sizeof(moves));  // 初始化移动次数数组
        Knight start;  // 创建起始位置的Knight节点
        start.x = a1;
        start.y = a2;
        start.g = 0;  // 起始位置的G值为0
        start.h = Heuristic(start);  // 计算起始位置的H值
        start.f = start.g + start.h;  // 计算起始位置的F值
        astar(start);  // 调用A*算法
        while (!que.empty()) que.pop();  // 清空优先队列
        cout << moves[b1][b2] << endl;  // 输出从起始位置到目标位置的移动次数
    }
    return 0;
}

A * 算法的时间复杂度其实是不好去量化的，因为他取决于启发式函数怎么写。

最坏情况下，A * 退化成广搜，算法的时间复杂度是 O(n * 2)，n 为节点数量。

最佳情况，是从起点直接到终点，时间复杂度为 O(dlogd)，d 为起点到终点的深度。

因为在搜索的过程中也需要堆排序，所以是 O(dlogd)。

实际上 A * 的时间复杂度是介于最优和最坏情况之间，可以非常粗略的认为 A * 算法的时间复杂度是 O(nlogn) ，n 为节点数量。

A * 算法的空间复杂度 O(b ^ d) ,d 为起点到终点的深度，b 是图中节点间的连接数量，本题因为是无权网格图，所以节点间连接数量为 4。（代码随想录 (programmercarl.com)）

Noir间

关注

15
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营Day67|Floyd算法、A*算法

本题要针对小明的计划，求计划中不同起点、不同终点的多条最短路径，与之前的dijkstra、bellman_ford等求单源最短路径不同，属于求多源最短。（多次调用单源最短路算法？这里引入Floyd算法，这里简单介绍下Floyd算法。Floyd算法，全称为Floyd-Warshall算法，是一种用于计算图中所有顶点对之间最短路径的算法。该算法由罗伯特·弗洛伊德（Robert Floyd）于1962年提出，并以弗洛伊德和斯蒂芬·沃舍尔（Stephen Warshall）的名字命名。，都可以处理。
复制链接

扫一扫