Question

为了增强我的java脚本技能，我正在尝试用js开发一个pacman游戏。网格为20乘20。此网格具有0和1，表示是否有墙或路径。现在我想为恶魔开发一个跟随pacman的算法。我不确定应该选择哪种算法。

所以我对函数的输入将是foo（当前位置，pacman位置，网格，路径）

var maze = [            [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],
                        [0,1,1,1,1,1,1,0,1,1,1,1,0,1,1,1,1,1,1,0],
                        [0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0],
                        [0,1,0,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,0],
                        [0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0],
                        [0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0],
                        [0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0],
                        [0,1,1,1,1,1,0,0,0,1,1,0,0,0,1,1,1,1,1,0],
                        [0,1,0,0,0,1,1,0,0,1,1,0,0,1,1,0,0,0,1,0],
                        [0,1,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,1,0],
                        [1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,1],
                        [0,1,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,1,0],
                        [0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0],
                        [0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0],
                        [0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0],
                        [0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0],
                        [0,1,0,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,0],
                        [0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0],
                        [0,1,1,1,1,1,1,0,1,1,1,1,0,1,1,1,1,1,1,0],
                        [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0]];

Answer 1

对于未加权的图表，您有几个选项可以找到最短路径：

BFS - 最简单的解决方案 - BFS是完整且最优的 - 如果存在，它将找到最短的路径。
Bi-Directional BFS - 基本相同，但从双方做BFS，并在两个BFS见面时结束。它显着减少了发现的顶点数量。我在this thread中解释了更多关于如何做以及为什么这样做的原因。
Heuristical A* Algorithm - 它是一个明智的算法，因此通常比其他算法更快，但更难编程。使用admissible heuristic function，例如manhattan distances。

个人 - 我想我会在这种情况下使用BFS - 但是从pacman开始，直到你发现所有“目标”（恶魔位置） - 它将为你提供从每个恶魔到pacman的最短路径。
请注意，如果你只有几个恶魔和一块大板，多次做A *（每个恶魔一次）可能是一个更好的解决方案。

人们应该对它进行基准测试，看看哪个更好。

Answer 2

如果您需要找到从源到所有顶点的最短路径，请从源执行宽度优先搜索并继续将每个顶点的父节点存储在单独的数组中。以下父节点将为您提供每个顶点的路径顶点到它的父节点。

Answer 3

我认为Depth-first search也适用于此。与广度优先搜索相比，使用DFS时无需存储所有叶节点。但它有时无法找到解决方案。这里的输入并不复杂，所以我认为DFS足够好。

此外，A *搜索算法是最佳选择，因为它比不知情的搜索更快，并且总是完整和最优。它保证了解决方案的最佳性。对于复杂的情况，创建一个有效的启发式功能确实是成本。在这里，您可以使用曼哈顿距离或欧几里德距离。

最短路径算法未加权图

3 个答案: