解决迷宫的可能方法有哪些？
我有两个主意，但我认为它们不是很优雅。
基本情况：我们有一个矩阵，该矩阵中的元素以代表迷宫的方式排序，一种进出一种迷宫。
我的第一个想法是让机器人从迷宫中穿过，直到一侧离开迷宫。我认为这是一个非常缓慢的解决方案。
第二个遍历每个标记为1的连续项，检查它可以去向何处（上，右，下，左），选择一种方法，并在该处继续其路径。这甚至比第一个慢。
当然，如果我在两个交叉点使两个机器人成为多线程，速度会更快一些，但这也不是最好的方法。
需要有更好的解决方案来使机器人通过迷宫。
编辑
第一：谢谢你的美好的答案！
我的问题的第二部分是：如果我们有多维图，该怎么办？是否有特殊的做法，或者贾斯汀·L。的答案是否也可以用于此？
我认为这不是解决此问题的最佳方法。
第三个问题：
哪种迷宫求解器算法最快？（完全假设）
Answers:
您可以将迷宫想象成一棵树。
一种
/ \
/ \
公元前
///
DEFG
/ \ \
HIJ
/ \
LM
/ \
** O
（可能代表）
开始
+ + --- + --- +
| ACG |
+ --- + + + +
| DB | F | J |
+ --- + --- + + --- + --- +
| LHEI |
+ --- + + --- + --- +
| MO |
+ + --- +
完
（忽略树上的左右顺序）
每个节点都是路径的交汇点。D，I，J，L和O是死胡同，**是目标。当然，在您的实际树中，每个节点都有可能拥有多达三个子节点。
现在，您的目标只是找到要遍历的节点以找到终点。任何其他的树搜索算法都可以。
查看树，只需从树的最深处的**中“追溯”即可很容易地找到正确的解决方案：
A B E H M **
请注意，当您的迷宫中有“圈”时，这种方法只会变得稍微复杂一点（即，如果可能的话，没有回溯，您可以重新输入已经遍历的段落）。检查评论，找到一个不错的解决方案。
现在，让我们看看您提到的应用于该树的第一个解决方案。
您的第一个解决方案基本上是“深度优先”搜索，这的确不错。实际上，这是一个很好的递归搜索。基本上，它说：“始终首先使用最右边的方法。如果没有任何东西，请回溯到可以直行或左行的位置，然后重复。
深度优先搜索将按以下顺序搜索上述树：
A B D (backtrack) E H L (backtrack) M ** (backtrack) O (backtrack thrice) I
(backtrack thrice) C F (backtrack) G J
请注意，一旦找到**，您就可以停止。
但是，当您实际编写深度优先搜索的代码时，使用递归编程可以使一切变得容易得多。即使是迭代方法也可以使用，并且您不必显式编程如何回溯。查看链接的文章以获取实现。
搜索树的另一种方法是“广度优先”解决方案，该解决方案按深度搜索树。它将按上述顺序搜索上面的树：
A (next level) B C (next level) D E F G (next level)
H I J (next level) L M (next level) ** O
请注意，由于迷宫的性质，广度优先的平均节点数量要多得多。广度优先是很容易实现的，它具有要搜索的路径队列，并且每次迭代都将路径从队列中弹出，通过在一步之后获取所有可以变为的路径，然后放置这些新路径来“爆炸”它。在队列末尾。没有明确的“下一级”命令可以编码，而这些命令只是为了帮助理解。
实际上，有很多搜索树的方法。我刚刚提到了两种最简单，最直接的方法。
如果您的迷宫非常非常长且很深，并且有环回和疯狂的声音并且很复杂，我建议您使用A *算法，这是行业标准的寻路算法，将广度优先搜索与启发式技术相结合...类似“智能广度优先搜索”。
它基本上是这样的：
这就是A *，我特别介绍了它，因为它或多或少是针对寻路的所有应用程序的行业标准寻路算法，包括从地图的一个边缘移至另一边缘，同时避开越野道路或山脉等。很好，因为它使用了最短的距离启发式算法，这使其具有“智能”。A *用途广泛，因为如果有任何问题，如果您有尽可能短的距离启发式可用方法（我们很容易-直线），则可以应用它。
但是请注意，A *不是您唯一的选择，这非常有价值。
实际上，树遍历算法的维基百科类别仅列出了97个！（最好的仍然会在此页面的前面链接）
抱歉，长度= P（我倾向于漫步）
存在许多迷宫求解算法：
http://en.wikipedia.org/wiki/Maze_solving_algorithm
http://www.astrolog.org/labyrnth/algrithm.htm#solve
对于机器人而言，Tremaux的算法看起来很有希望。
至少我发现很有趣的一种有趣的方法是使用细胞自动机。简而言之，被3个“墙”单元包围的“空间”单元变为“墙”单元。最后，仅剩下的空间单元是到达出口的通道。
如果您看一下贾斯汀在他的回答中插入的树，那么您会看到叶节点具有3面墙。修剪树直到有路径。
这是我最喜欢的算法之一。
1) Move forward
2) Are you at a wall?
2a) If yes, turn left
3) Are you at the finish?
3a) If no, go to 1
3b) If yes, solved
这是在C ++中模拟迷宫的非常简单的表示形式：)
#ifndef vAlgorithms_Interview_graph_maze_better_h
#define vAlgorithms_Interview_graph_maze_better_h
static const int kMaxRows = 100;
static const int kMaxColumns = 100;
class MazeSolver
{
private:
char m_matrix[kMaxRows][kMaxColumns]; //matrix representation of graph
int rows, cols; //actual rows and columns
bool m_exit_found;
int m_exit_row, m_exit_col;
int m_entrance_row, m_entrance_col;
struct square //abstraction for data stored in every verex
{
pair<int, int> m_coord; //x and y co-ordinates of the matrix
square* m_parent; //to trace the path backwards
square() : m_parent(0) {}
};
queue<square*> Q;
public:
MazeSolver(const char* filename)
: m_exit_found(false)
, m_exit_row(0)
, m_exit_col(0)
, m_entrance_row(0)
, m_entrance_col(0)
{
ifstream file;
file.open(filename);
if(!file)
{
cout << "could not open the file" << endl << flush;
// in real world, put this in second phase constructor
}
init_matrix(file);
}
~MazeSolver()
{
}
void solve_maze()
{
//we will basically use BFS: keep pushing squares on q, visit all 4 neighbors and see
//which way can we proceed depending on obstacle(wall)
square* s = new square();
s->m_coord = make_pair(m_entrance_row, m_entrance_col);
Q.push(s);
while(!m_exit_found && !Q.empty())
{
s = Q.front();
Q.pop();
int x = s->m_coord.first;
int y = s->m_coord.second;
//check if this square is an exit cell
if(x == m_exit_row && y == m_exit_col)
{
m_matrix[x][y] = '>'; // end of the path
m_exit_found = true;
//todo: try breaking? no= queue wont empty
}
else
{
//try walking all 4 neighbors and select best path
//NOTE: Since we check all 4 neighbors simultaneously,
// the path will be the shortest path
walk_path(x-1, y, s);
walk_path(x+1, y, s);
walk_path(x, y-1, s);
walk_path(x, y+1, s);
}
} /* end while */
clear_maze(); //unset all previously marked visited shit
//put the traversed path in maze for printing
while(s->m_parent)
{
m_matrix[s->m_coord.first][s->m_coord.second] = '-';
s = s->m_parent;
} /* end while */
}
void print()
{
for(int i=0; i<rows; i++)
{
for(int j=0; j<cols; j++)
cout << m_matrix[i][j];
cout << endl << flush;
}
}
private:
void init_matrix(ifstream& file)
{
//read the contents line-wise
string line;
int row=0;
while(!file.eof())
{
std::getline(file, line);
for(int i=0; i<line.size(); i++)
{
m_matrix[row][i] = line[i];
}
row++;
if(line.size() > 0)
{
cols = line.size();
}
} /* end while */
rows = row - 1;
find_exit_and_entry();
m_exit_found = false;
}
//find and mark ramp and exit points
void find_exit_and_entry()
{
for(int i=0; i<rows; i++)
{
if(m_matrix[i][cols-1] == ' ')
{
m_exit_row = i;
m_exit_col = cols - 1;
}
if(m_matrix[i][0] == ' ')
{
m_entrance_row = i;
m_entrance_col = 0;
}
} /* end for */
//mark entry and exit for testing
m_matrix[m_entrance_row][m_entrance_col] = 's';
m_matrix[m_exit_row][m_exit_col] = 'e';
}
void clear_maze()
{
for(int x=0; x<rows; x++)
for(int y=0; y<cols; y++)
if(m_matrix[x][y] == '-')
m_matrix[x][y] = ' ';
}
// Take a square, see if it's the exit. If not,
// push it onto the queue so its (possible) pathways
// are checked.
void walk_path(int x, int y, square* parent)
{
if(m_exit_found) return;
if(x==m_exit_row && y==m_exit_col)
{
m_matrix[x][y] = '>';
m_exit_found = true;
}
else
{
if(can_walk_at(x, y))
{
//tag this cell as visited
m_matrix[x][y] = '-';
cout << "can walk = " << x << ", " << y << endl << flush;
//add to queue
square* s = new square();
s->m_parent = parent;
s->m_coord = make_pair(x, y);
Q.push(s);
}
}
}
bool can_walk_at(int x, int y)
{
bool oob = is_out_of_bounds(x, y);
bool visited = m_matrix[x][y] == '-';
bool walled = m_matrix[x][y] == '#';
return ( !oob && !visited && !walled);
}
bool is_out_of_bounds(int x, int y)
{
if(x<0 || x > rows || y<0 || y>cols)
return true;
return false;
}
};
void run_test_graph_maze_better()
{
MazeSolver m("/Users/vshakya/Dropbox/private/graph/maze.txt");
m.print();
m.solve_maze();
m.print();
}
#endif
只是一个主意。为什么不以蒙特卡洛的方式在其中扔一些机器人呢？让我们称第一代机器人gen0。我们只让gen0的机器人以这种方式保持连续行驶：
-从起点到某个点，
或者-从某个点到终点
我们在新的随机点中运行新的bot机器人gen1，然后尝试将gen1机器人与gen0机器人的道路连接起来，看看从头到尾是否有连续的道路。
因此，对于genn，我们尝试以gen0，gen1，...，genn-1形式连接机器人。
当然，一代只会持续一段有限的时间。
我不知道该算法的复杂性是否会证明对小数据集可行。
该算法还假设我们知道起点和终点。
一些好的想法网站：
http
:
//citeseerx.ist.psu.edu/
http://arxiv.org/
我的大学计算机之一也遇到了类似的问题。科学 培训班。我们想出的解决方案是沿左手墙移动（右手墙也将正常工作）。这是一些伪代码
While Not At End
If Square To Left is open,
Rotate Left
Go Forward
Else
Rotate Right
End If
Wend
基本上就是这样。复杂的部分是跟踪您面对的方向，并根据该方向找出您左侧的网格位置。它适用于我反对的任何测试用例。有趣的是，教授的解决方案大致如下：
While Not At End
If Can Go North
Go North
ElseIf Can Go East
Go East
ElseIf Can Go South
Go South
ElseIf Can Go West
Go West
EndIf
Wend
这对于大多数简单的迷宫效果很好，但在如下所示的迷宫中却无法使用：
SXXXXXXXXXXXXX
X X
X X
X X
XXX X
X X X
X XXXXXXXXXXX XXXE
X X
XXXXXXXXXXXXXXXXXXX
以S和E为起点和终点。
遇到任何不符合要求的事情，您最终都必须保存自己去过的地方的清单，以便在陷入困境时可以在必要时回溯，以免被抓住在一个循环中。如果您沿着墙走，则无需跟踪您去过的地方。尽管您找不到通过迷宫的最佳路径，但是您将始终通过它。
如果机器人可以跟踪其位置，那么它就知道它是否曾经去过某个位置，那么深度优先搜索是显而易见的算法。您可以通过对抗性论证表明，最坏情况下的性能不可能比深度优先搜索更好。
如果您拥有机器人无法实现的技术，那么广度优先搜索可能会更好地解决许多迷宫问题，就像Dijkstra用于在图形中找到最短路径的算法一样。
与所有关于堆栈溢出的问题的答案相同；）
使用vi！
http://www.texteditors.org/cgi-bin/wiki.pl?Vi-Maze
看到文本编辑器解决ascii迷宫确实令人着迷，我敢肯定emacs家伙也有同等的知识。
有很多算法，并且有许多不同的设置指定哪种算法最好。这只是一个有趣的设置的想法：
假设您具有以下属性...
然后您可以设计一个AI ...
解决迷宫的最佳方法是使用连接算法，例如Union-find，它是假设完成路径压缩的准线性时间算法。
Union-Find是一种数据结构，它告诉您集合中的两个元素是否可传递地连接。
为了使用联合查找数据结构来解决迷宫，首先使用邻居连接数据来构建联合查找数据结构。然后，联合查找被压缩。为了确定迷宫是否可解决，将入口和出口值进行比较。如果它们具有相同的值，则说明它们已连接且迷宫可解。最后，要找到解决方案，请从入口开始，然后检查与每个邻居相关联的根。一旦找到与当前单元格具有相同根的先前未曾访问过的邻居，便可以访问该单元格并重复该过程。
这种方法的主要缺点是，如果有多个路径，它不会告诉您通过迷宫的最短路径。