Floyd算法
本题要针对小明的计划，求计划中不同起点、不同终点的多条最短路径，与之前的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*算法
具体内容看 代码随想录 (programmercarl.com)
先简单介绍一下A*算法。
A*（A-star）算法是一种广泛应用于路径规划和图遍历的启发式搜索算法。它旨在找到从起始点到目标点的最短路径。A*算法结合了最佳优先搜索的高性能和Dijkstra算法的有点，通过使用启发式函数来评估到达目标点的代价，从而更高效地搜索路径。
A*算法的核心思想如下：
- 开放列表（Open List）：用于存储待检查的节点。
- 关闭列表（Closed List）：用于存储已经检查过的节点。
- 节点的评价函数（f(n)）：用于评估节点n的质量，以确定搜索的优先级。评价函数由两部分组成：
- g(n)：从起始点到节点n的实际距离。
- h(n)：从节点n到目标点的启发式估计距离。这个估计距离是基于某些启发式信息，例如曼哈顿距离、欧几里得距离等。
- 评价函数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)）
389
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
