Algorithm 在8个方向上遍历矩阵迷宫

给您一个1和0的矩阵，其中0表示自由路径，1表示阻塞区域。您可以在8个方向中的任意一个方向移动。找到从源到目标的最短路径

我能想到的解决方案是，其中

dp[i，j]

存储到起始顶点的最小距离：

recursion(int i, int j , int sum)
{

  if(!issafe(i,j) || isvisited[i,j]) // within bounds
  return ;

  if(matrix(i,j)==0)//blocked
  return ;

  isvisited[i,j]=true;

  dp[i,j] = min(dp[i,j] , sum);
  // directions have usual meaning

  recursion(east ,sum+1);  // i , j+1
  recursion(north , sum+1);  //i-1 , j
  recursion(west , sum+1);
  recursion(south , sum+1);
  recursion(north-east , sum+1);
  recursion(north-west , sum+1);
  recursion(south-east , sum+1);
  recursion(south-west , sum+1);

  isvisited[i,j]=false;

return;
}  

现在我怀疑的是，假设我们可以从8个位置到达[i，j]。一旦我从位置1到达它，比如说最小路径是x个单位，我就会立即递归地检查它的邻居。现在，我来自路径2，发现min.path（以前的x）现在是y而不是x，现在再次递归检查。因此，我在第1步做了额外的计算，这是不需要的。有没有什么方法，只有在我找到当前单元格的最小路径（从所有8个位置都可以到达）后，我才能递归地检查邻居

这是非加权图中的a，可由a求解

这里的图形是

G=（V，E）

where

• V={矩阵中的所有单元格}

• E={（v1，v2）|可以从单元格v1移动到单元格v2}

请注意，您的方法是的变体，使用附加数据[the

dp

array]

---

更高级的方法是搜索或（作为启发式函数）

---

bfs伪代码：

BFS(source,destination):
  visited <- {} //empty dictionary
  queue <- new queue
  queue.add (source)
  visited.add(source,null)
  while (! queue.isEmpty()):
      v <- queue.pop()
      if v == destination:
         return getPath(visited, v)
      for each edge (v,u):
         if u is not a key in visited:
             visited.add(u,v)
             queue.add(u)

getPath(visited,v):
   list <- new linked list
   while (v != null):
      list.addFirst(v)
      v <- visited.get(v)
   return list

BFS（源、目标）：
拜访