Python 在给定一些移动规则的情况下，如何枚举从棋盘的左下（a1）方开始到达右上（h8）方的唯一路径？

几周前，我被要求找到所有不同且独特的方法来到达棋盘的右上角，x，y>3，从（0，0）开始，知道你只能将x和y增加+1

我仍然无法找到解释如何在棋盘上导航的算法，所以我想知道你们有什么可以推荐的吗

换言之：

如何列出从左下角（0，0）开始，用大头针到达棋盘右上角（x，y）的所有独特方法。您只能向上或向右移动pin

# 2010年10月16日更新：

好的，我对DFS做了一些研究，不确定从哪里开始，然后查找树的前序遍历，我得出了这个结论，因为基本上棋盘是一棵树：

#!/usr/bin/python

class Node(object):

  value = None
  left = None
  right = None

  def SetValue(self, value):
    self.value = value

  def SetLeftNode(self, node):
    self.left = node

  def SetRightNode(self, node):
    self.right = node

def main():
  a = Node()
  a.SetValue((0,0))

  b = Node()
  b.SetValue((1,0))

  c = Node()
  c.SetValue((2,0))

  d = Node()
  d.SetValue((0,1))

  e = Node()
  e.SetValue((1,1))

  f = Node()
  f.SetValue((2,1))

  g = Node()
  g.SetValue((0,2))

  h = Node()
  h.SetValue((1,2))

  i = Node()
  i.SetValue((2,2))

  a.SetLeftNode(b)
  a.SetRightNode(d)

  b.SetLeftNode(g)
  b.SetRightNode(e)

  c.SetLeftNode(f)
  c.SetRightNode(None)

  d.SetLeftNode(e)
  d.SetRightNode(c)

  e.SetLeftNode(h)
  e.SetRightNode(f)

  f.SetLeftNode(i)
  f.SetRightNode(None)

  g.SetLeftNode(None)
  g.SetRightNode(h)

  h.SetLeftNode(None)
  h.SetRightNode(i)

  i.SetLeftNode(None)
  i.SetRightNode(None)

  PreOrderTraversal(a)

def PreOrderTraversal(node):
  if not node:
    return None
  print node.value
  if node.value == (2,2):
    print 'Reached i' 
  PreOrderTraversal(node.left)
  PreOrderTraversal(node.right)

main() 

其输出如下所示：

(0, 0)
(1, 0)
(0, 2)
(1, 2)
(2, 2)
Reached i
(1, 1)
(1, 2)
(2, 2)
Reached i
(2, 1)
(2, 2)
Reached i
(0, 1)
(1, 1)
(1, 2)
(2, 2)
Reached i
(2, 1)
(2, 2)
Reached i
(2, 0)
(2, 1)
(2, 2)
Reached i

---

它肯定会通过所有独特的路径，但我相信有一种方法可以改进它，实际打印出完整的路径。由于某种原因，我找不到一种使用递归的方法。有什么想法吗？

我建议您研究一下，当x&y都大于3时，您的搜索是成功的，并且树下的每个成功搜索路径都是有效路径。

是的，正如Bryan提到的，使用DFS。 在这种情况下，您不需要保存一个堆栈来记录您所走的路，只需要一个计数器、一个位置和一个好的算法。 例如：

int count = 0;
int x = 0;
int y = 0;
int to_x[3] = {0, 0, 0};
for(; to_x[2] < 8; counter++)
{
    for(int arridx = 0; arridx < 2; arridx++)
    {
        if(to_x[arridx] == 8)
        {
            to_x[arridx] = 0;
            to_x[arridx+1] += 1;
        }
    }
/*
    for(int arridx2 = 0; arridx2 < 3; arridx2++)
    {
        //for(; x < to_x[arridx2]; x++);
        x = to_x[arridx2];

        y++;
    }
*/
}

int count=0；
int x=0；
int y=0；
int到_x[3]={0,0,0}；
对于（；to_x[2]<8；计数器++）
{
对于（int-arridx=0；arridx<2；arridx++）
{
if（to_x[arridx]==8）
{
to_x[arridx]=0；
to_x[arridx+1]+=1；
}
}
/*
for（int-arridx2=0；arridx2<3；arridx2++）
{
//for（；x

---

这真的只是一道数学题，但如果你不想让你的头太痛，就这么做。

有（x+y）/x/Y（x+yCx）到达那里的方法。到达每一点的方法的数量只是到达点旁边/下面的方法的数量之和。

好的，经过一点研究，我得出了以下结论：

#!/usr/bin/python

chess_board = {'A': ['B', 'C'],
               'B': ['D', 'E'],
               'C': ['E', 'F'],
               'D': ['G'],
               'E': ['G', 'H'],
               'F': ['H'],
               'G': ['I'],
               'H': ['I'],
               'I': []} 


def find_all_paths(graph, start, end, path=[]):
  path = path + [start]
  if start == end:
    return [path]
  paths = []
  for node in graph[start]:
    if node not in path:
      new_paths = find_all_paths(graph, node, end, path)
      for new_path in new_paths:
        paths.append(new_path)
  return paths

all_path =  find_all_paths(chess_board, 'A', 'I')
for path in all_path:
  print path

这就是输出：

>> python chess_bfs.py 
['A', 'B', 'D', 'G', 'I']
['A', 'B', 'E', 'G', 'I']
['A', 'B', 'E', 'H', 'I']
['A', 'C', 'E', 'G', 'I']
['A', 'C', 'E', 'H', 'I']
['A', 'C', 'F', 'H', 'I']

---

要使接缝工作正常，我唯一的问题是，如果我需要在棋盘上添加更多节点，那么我必须手动操作。

@Jason:不，只是好奇而已。我离开大学很久了：）@muntoo:我更新了描述，希望这有帮助。我想你是指（x+y）/（x！y！）问题是列表，而不仅仅是计数。谢谢布莱恩。我提出了一种解决方案，我在页面底部添加了一种解决方案。我用的是BFS。你知道如何改进代码吗？你正在使用DFS？无论如何，现在就开始考虑修剪：为当前距离目标的最大距离设置一个全局状态（变量）。如果任何节点离它更远，只需将其从搜索树中删除即可。这基本上是alpha-beta修剪。