Question

我正在开发一个以网格作为底层结构的2D游戏。在这个网格中，我想找到在特定范围内可以从给定单元格到达的每个单元格。仅允许在垂直和水平方向上移动，但不允许对角移动。

以下图片对此进行了说明。绿色方块是搜索的原点，红色方块是不能交叉的“墙”，蓝色是绿色方块周围的所有单元格，最大值。距离10：

我已经有一个递归算法的工作实现，但它极其缓慢（范围10为140ms，范围15几乎为一分钟）所以我需要改进它或完全重写它。这是：

//accessible is a vector of points
//blocked is a 2D array of bools

void updateAccessible(Point currentPoint, int restRange) {
    bool existing = false;
    for (int i = 0; i < accessible.size(); i++) {
        Point p = accessible[i];
        if (p.x == currentPoint.x && p.y == currentPoint.y) {
            existing = true;
            break;
        }
    }
    if (!existing) {
        accessible.push_back(currentPoint);
    }

    if (restRange == 0) 
        return;

    int dx[] = { -1, 1, 0, 0 };
    int dy[] = { 0, 0, -1, 1 };

    for (int i = 0; i < 4; i++) {
        Point nextPoint{ currentPoint.x + dx[i], currentPoint.y + dy[i] };
        if (nextPoint.x > 0 && nextPoint.y < gridWidth && nextPoint.y > 0 && nextPoint.y < gridHeight) {
            if (!blocked[nextPoint.x][nextPoint.y]) {
                updateAccessible(nextPoint, restRange - 1);
            }
        }
    }
}

是否存在针对此问题的现有算法，例如A *用于寻路，或者您是否有任何想法如何改进我的？我愿意接受任何建议。

编辑：在MBo提到“广度优先搜索”之后，我知道我的第一次尝试出了什么问题，这种情况甚至不适合深度优先，并且多次访问每个单元格。这是我的第二个版本，它使用先呼吸并且是迭代的。速度要快得多（范围10为3ms，范围15为10ms，范围50为1ms）：

void updateAccessible(Point start, int range) {
    struct Node {
        int x, y, r;
    };
    std::vector<Node> nodes = std::vector<Node>();
    accessible = std::vector<Point>();
    nodes.push_back(Node{ start.x,start.y,range });
    while (nodes.size() > 0) {
        Node currentNode = nodes[0];
        accessible.push_back(Point{ currentNode.x, currentNode.y });
        nodes.erase(nodes.begin());

        if (currentNode.r > 0) {
            int dx[] = { -1, 1, 0, 0 };
            int dy[] = { 0, 0, -1, 1 };

            for (int i = 0; i < 4; i++) {
                Node nextNode{ currentNode.x + dx[i],currentNode.y + dy[i], currentNode.r - 1 };
                if (nextNode.x > 0 && nextNode.x < gridWidth && nextNode.y > 0 && nextNode.y < gridHeight) {
                    if (!blocked[nextNode.x][nextNode.y]) {
                        bool existing = false;
                        for (int ii = 0; ii < nodes.size(); ii++) {
                            Node n = nodes[ii];
                            if (n.x == nextNode.x && n.y == nextNode.y) {
                                existing = true;
                                break;
                            }
                        }
                        for (int ii = 0; ii < accessible.size(); ii++) {
                            Point p = accessible[ii];
                            if (p.x == nextNode.x && p.y == nextNode.y) {
                                existing = true;
                                break;
                            }
                        }
                        if (!existing) {
                            nodes.push_back(nextNode);
                        }
                    }
                }
            }
        }
    }
}

尽管如此，如果您对如何改进它有任何建议，我很高兴听到它们。

Answer 1

您的实现会一次又一次地遍历相同的单元格。

此网格需要深度（距离）限制BFS（breadth-first-search）。要实现它，只需为单元格标记添加数组。当您将单元格标记为已访问时，请不要继续使用它。

查找特定范围内的网格单元格

1 个答案: