Question

我需要找到有障碍的网格中两点之间的最短路径。

给出一个二维矩阵，其中一些元素被填充用1和其余元素填充。 X表示您无法遍历该特定点。您可以从一个单元格向左，向右，向上或向下移动。给定矩阵中的两个点找到这些点之间的最短路径。这里S是开始点，E是终点。

我想出了下面的代码，但我想从访谈的角度理解解决这个问题的最有效算法是什么？有更好的方法吗？

  public static void main(String[] args) {
    char[][] matrix =  {{'1','1','1', '1'},
                        {'1','S','1', '1'},
                        {'1','1','X', '1'},
                        {'1','1','1', 'E'}};

    System.out.println(shortestPath(matrix));
  }

  public static int shortestPath(char[][] matrix) {
    int s_row = 0, s_col = 0;
    boolean flag = false;
    for (s_row = 0; s_row < matrix.length; s_row++) {
      for (s_col = 0; s_col < matrix[0].length; s_col++) {
        if (matrix[s_row][s_col] == 'S')
          flag = true;
        if (flag)
          break;
      }
      if (flag)
        break;
    }
    return shortestPath(matrix, s_row, s_col);
  }

  public static int shortestPath(char[][] matrix, int s_row, int s_col) {
    int count = 0;
    Queue<int[]> nextToVisit = new LinkedList<>();
    nextToVisit.offer(new int[] {s_row, s_col});
    Set<int[]> visited = new HashSet<>();
    Queue<int[]> temp = new LinkedList<>();

    while (!nextToVisit.isEmpty()) {
      int[] position = nextToVisit.poll();
      int row = position[0];
      int col = position[1];

      if (matrix[row][col] == 'E')
        return count;
      if (row > 0 && !visited.contains(new int[] {row - 1, col}) && matrix[row - 1][col] != 'X')
        temp.offer(new int[] {row - 1, col});
      if (row < matrix.length - 1 && !visited.contains(new int[] {row + 1, col})
          && matrix[row + 1][col] != 'X')
        temp.offer(new int[] {row + 1, col});
      if (col > 0 && !visited.contains(new int[] {row, col - 1}) && matrix[row][col - 1] != 'X')
        temp.offer(new int[] {row, col - 1});
      if (col < matrix[0].length - 1 && !visited.contains(new int[] {row, col + 1})
          && matrix[row][col + 1] != 'X')
        temp.offer(new int[] {row, col + 1});

      if (nextToVisit.isEmpty() && !temp.isEmpty()) {
        nextToVisit = temp;
        temp = new LinkedList<>();
        count++;
      }

    }
    return count;
  }

Answer 1

如果固定从一个点到另一个点的成本，则解决此类问题的最有效算法是BFS (Breadth-first search)。如果成本是可变的但为正，那么您需要使用Dijkstra Algorithm，并且如果存在负成本的可能性，则Bellman-Ford algorithm是正确的选择。

还有一件事情，要使自己适应此类问题，一种方法是更多地解决此类问题。您会在this网站上找到这种类型的问题。

找到有障碍的两点之间的最短路径

1 个答案: