(10-4）优先级遍历（Priority-based Search）算法：Beam Search (束搜索)算法

10.4  Beam Search (束搜索)算法

束搜索（Beam Search）是一种启发式搜索算法，通常用于解决搜索空间较大的问题，例如图搜索、自然语言处理中的语言生成等。它在搜索过程中通过限制搜索空间的宽度来降低搜索的复杂度，从而提高搜索效率。

10.4.1  Beam Search算法的基本思想

Beam Search (束搜索)算法的基本思想是维护一个大小固定的束（beam），在每一步中，从当前节点扩展出若干个子节点，并根据一定的评价准则（例如启发函数）选择若干个最有希望的子节点加入束中。然后，再从这些加入束中的子节点中选出下一步要扩展的节点，重复这个过程直到找到目标节点或达到搜索的终止条件。

Beam Search (束搜索)算法与宽度优先搜索类似，但不同之处在于束搜索限制了每一步扩展出的节点数量，而宽度优先搜索则会扩展所有的节点。束搜索通过这种限制来减少搜索空间，提高搜索效率，但同时也可能会牺牲搜索的完备性，因为有些节点可能由于被限制而无法被扩展到。

Beam Search (束搜索)算法的主要优点是在保证一定搜索质量的前提下，降低了搜索的复杂度，适用于那些搜索空间较大但解空间又不太复杂的问题。然而，束搜索也有一些缺点，例如可能会导致搜索结果不够全面，因为束的大小限制了搜索空间的广度。因此，在使用束搜索时需要根据具体问题进行权衡和调整束的大小，以达到较好的搜索效果。

10.4.2  Beam Search算法的实现步骤

实现Beam Search 算法的基本步骤如下所示。

（1）初始化：将起始节点加入束（beam）中，并设置束的大小（即允许同时探索的节点数量）。

（2）实现循环搜索工作：

1. 从束中选取若干个节点作为当前要扩展的节点。
2. 对于每个当前节点，根据问题的特性生成其所有可能的后继节点。
3. 对于每个后继节点，根据一定的评价准则（如启发函数）评估其质量，并选择一定数量的最优节点加入下一轮的束中。
4. 重复上述步骤，直到达到终止条件（如找到目标节点、束为空、达到最大搜索深度等）。

（3）返回结果：如果找到目标节点，则返回相应的解；否则，返回搜索过程中得到的最优解。

需要注意的是，在实现束搜索时，需要选择合适的评价准则来评估节点的质量，并动态调整束的大小以平衡搜索的广度和深度，从而提高搜索效率。束搜索算法的具体实现可以根据问题的特性进行调整和优化。

请看下面的例子，演示了使用Beam Search算法为迷宫中的机器人寻找最佳路径的过程。

1. 问题描述

假设有一个迷宫，迷宫由一个二维网格表示，其中包含空地和障碍物。现在有一个机器人，初始时位于迷宫的起始点，目标是到达迷宫的终点。机器人只能沿着空地移动，且每次只能向上、向下、向左或向右移动一步。为了尽快到达目标点，我们使用束搜索算法来帮助机器人寻找路径。

迷宫地图如下所示：

vector<vector<int>> grid = {
    {0, 0, 0, 0, 0},
    {0, 1, 1, 1, 0},
    {0, 0, 0, 0, 0},
    {0, 1, 1, 1, 0},
    {0, 0, 0, 0, 0}
};

1. 起始点：(0, 0)
2. 目标点：(4, 4)
3. 束宽度（beamWidth）：2。

2. 问题要求

请编写程序，在所提供的迷宫地图中执行束搜索算法，找到从起始点到目标点的路径。在找到路径时，打印输出提示信息。如果机器人无法找到到达目标点的路径，则输出相应的提示信息。

实例10-3：使用Beam Search算法为机器人寻找最短路径（codes/10/Beam.cpp）

实例文件Beam.cpp的具体实现代码如下所示。

#include <iostream>
#include <vector>
#include <queue>
#include <cmath>

using namespace std;

// 定义节点结构体
struct Node {
    int x, y; // 节点坐标
    int distance; // 起点到当前节点的距离
    int heuristic; // 启发式值

    Node(int _x, int _y, int _distance, int _heuristic) : x(_x), y(_y), distance(_distance), heuristic(_heuristic) {}

    // 重载小于运算符，用于优先队列的排序
    bool operator<(const Node& other) const {
        return (distance + heuristic) > (other.distance + other.heuristic);
    }
};

// 定义机器人类
class Robot {
private:
    vector<vector<int>> grid; // 二维网格地图
    int start_x, start_y; // 起始点坐标
    int goal_x, goal_y; // 目标点坐标
    int beamWidth; // 搜索束宽度

public:
    Robot(const vector<vector<int>>& _grid, int _start_x, int _start_y, int _goal_x, int _goal_y, int _beamWidth) : grid(_grid), start_x(_start_x), start_y(_start_y), goal_x(_goal_x), goal_y(_goal_y), beamWidth(_beamWidth) {}

    // 计算启发式值（曼哈顿距离）
    int calculateHeuristic(int x, int y) {
        return abs(x - goal_x) + abs(y - goal_y);
    }

    // 执行束搜索算法
    bool beamSearch() {
        int rows = grid.size();
        int cols = grid[0].size();

        priority_queue<Node> beam; // 搜索束

        // 将起始点加入搜索束
        beam.push(Node(start_x, start_y, 0, calculateHeuristic(start_x, start_y)));

        while (!beam.empty()) {
            // 从搜索束中取出当前要扩展的节点
            vector<Node> currentBeam;
            for (int i = 0; i < beamWidth && !beam.empty(); ++i) {
                currentBeam.push_back(beam.top());
                beam.pop();
            }

            // 对当前节点扩展出所有可能的后继节点
            for (const Node& currentNode : currentBeam) {
                int x = currentNode.x;
                int y = currentNode.y;
                int distance = currentNode.distance;

                // 到达目标点，返回true表示找到路径
                if (x == goal_x && y == goal_y) {
                    cout << "Path found!" << endl;
                    return true;
                }

                // 向上、向下、向左、向右尝试扩展节点
                int dx[] = {-1, 1, 0, 0};
                int dy[] = {0, 0, -1, 1};

                for (int i = 0; i < 4; ++i) {
                    int nx = x + dx[i];
                    int ny = y + dy[i];

                    // 如果新节点在地图范围内且可通行，则加入搜索束
                    if (nx >= 0 && nx < rows && ny >= 0 && ny < cols && grid[nx][ny] == 0) {
                        beam.push(Node(nx, ny, distance + 1, calculateHeuristic(nx, ny)));
                    }
                }
            }
        }

        // 搜索束为空且未找到路径，返回false表示未找到路径
        cout << "No path found." << endl;
        return false;
    }
};

int main() {
    // 定义机器人的起始点、目标点和地图
    vector<vector<int>> grid = {
        {0, 0, 0, 0, 0},
        {0, 1, 1, 1, 0},
        {0, 0, 0, 0, 0},
        {0, 1, 1, 1, 0},
        {0, 0, 0, 0, 0}
    };
    int start_x = 0, start_y = 0;
    int goal_x = 4, goal_y = 4;
    int beamWidth = 2; // 设置束宽度

    // 创建机器人对象并执行束搜索算法
    Robot robot(grid, start_x, start_y, goal_x, goal_y, beamWidth);
    robot.beamSearch();

    return 0;
}

上述代码的实现流程如下所示：

1. 首先，定义了一个机器人类 Robot，其中包括迷宫地图、起始点、目标点以及搜索束宽度等信息。
2. 接着，实现了 beamSearch 方法，这是束搜索算法的核心。该算法首先将起始点加入搜索束中，然后不断地从搜索束中取出当前要扩展的节点，将其周围可行的相邻节点加入搜索束中。在这个过程中，搜索束会根据节点的启发式值来自动选择扩展的节点。具体来说，搜索束会维护一个优先队列，队列中的节点按照它们的代价（路径长度加上启发式值）从大到小排序，每次取出队列中代价最小的节点进行扩展。
3. 然后，通过 calculateHeuristic 方法计算节点的启发式值，这里使用的是曼哈顿距离作为启发式值，曼哈顿距离是从当前节点到目标节点的水平和垂直距离的和。
4. 最后，在主函数main中创建了一个迷宫地图，设置了起始点、目标点和束的宽度，并创建了一个机器人对象。然后调用机器人对象的 beamSearch 方法执行束搜索算法，寻找从起始点到目标点的路径。如果找到路径，则输出路径信息；否则，输出提示信息表示未找到路径。

未完待续