Question

我们得到一个nxn方阵，0和1。 0表示阻塞的单元格，1表示机器人可以行走的开放单元格。如果您的机器人最初处于（0,0），那么到达的方式的数量是多少（n-1，n-1）。
您的机器人可以向左，向右，向上和向下移动。路径需要是不同的。如果你有一个循环，那么你可以将路径计算为1而不是无限。比如答案 7x7矩阵。

1 1 0 1 1 0 1
0 1 0 0 1 1 1
1 1 1 1 0 1 0
0 1 0 1 1 1 1
0 1 0 0 1 0 1
0 1 1 1 1 0 1
0 0 0 0 1 1 1

是4

4条路径是：
_ _ 0 1 1 0 1
0 _ 0 0 1 1 1
1 _ 1 1 0 1 0
0 _ 0 1 1 1 1
0 _ 0 0 1 0 1
0 _ _ _ _ 0 1
0 0 0 0 _ _ _

_ _ 0 1 1 0 1
0 _ 0 0 1 1 1
1 _ 1 1 0 1 0
0 _ 0 1 _ _ _
0 _ 0 0 _ 0 _
0 _ _ _ _ 0 _
0 0 0 0 1 1 _

_ _ 0 1 1 0 1
0 _ 0 0 1 1 1
1 _ _ _ 0 1 0
0 1 0 _ _ 1 1
0 1 0 0 _ 0 1
0 1 1 1 _ 0 1
0 0 0 0 _ _ _

_ _ 0 1 1 0 1
0 _ 0 0 1 1 1
1 _ _ _ 0 1 0
0 1 0 _ _ _ _
0 1 0 0 1 0 _
0 1 1 1 1 0 _
0 0 0 0 1 1 _

当机器人只允许向下和向下移动时，我已经解决了使用dp的问题。请帮我解决相同的算法。我是否必须将其转换为图表并应用一些算法。

Answer 1

我认为你应该对跟随路径的记忆做DFS。在伪代码中，它看起来像这样：

DFS(matrix, path):
   /* End conditions */
   If path.last is [n-1, n-1]
      print path /* Hooray! Found a path! */
   If path.last has already been visited in path
      Discard solution
   If path.last is out of bounds (coordinates < 0 or > n-1)
      Discard solution
   If matrix[path.last] value is 0
      Discard solution

   /* We're in the middle of a path: continue exploring */
   For direction in [1, 0], [0, 1], [-1, 0], [0, -1]
      Add [path.last + direction] to path // Move north, south, east, west
      DFS(matrix, path)
      Remove last element from path

/* Call the algorithm */
DFS(matrix, [1, 1])

在此算法中，您可以传递对矩阵和路径的引用，这为您提供了一个常量内存算法（您只有一个path实例）。至于时间复杂度，这对于可能的路径数是线性的（因为你探索每个可能的路径，甚至被解散的路径），并且在长度上是二次的（因为你测试每个点，它是否已经存在于线性搜索的路径中）。请注意，路径数量可以指数 n，路径长度最差情况为n^2。非常慢的强力算法。

此算法的最差情况将是一个仅填充指数复杂度的矩阵。

最佳情况将是一个矩阵，[1, 1]和[n-1, n-1]之间只有一条可能的路径。在这种情况下，路径长度的复杂程度可能介于O(n)和O(n^2)之间。

Matrix中的方式数量

1 个答案: