使用递归查找数组中的最短路径

Question

我正在开发这个程序。它在数组中找到到目的地的短路径。例如，如果输入是这样的：

###########
#         #
#### ######
#    #    X
#    #    #
# ###### ##
#         #
###########

输出看起来像这样

###########
#>>>V     #
####V######
#   V#  >>X
#V<<<#  ^ #
#V######^##
#>>>>>>>^ #
###########

用户还可以选择从哪个位置开始。这里用户从矩阵的 (1,1) 开始。 这是我的代码：

public class Test3 {

    static char a[][] = 
    {
        {'#','#','#','#','#','#','#','#','#','#','#'},
        {'#',' ',' ',' ',' ',' ',' ',' ',' ',' ','#'},
        {'#','#','#','#',' ','#','#','#','#','#','#'},
        {'#',' ',' ',' ',' ','#',' ',' ',' ',' ','X'},
        {'#',' ',' ',' ',' ','#',' ',' ',' ',' ','#'},
        {'#',' ','#','#','#','#','#','#',' ','#','#'},
        {'#',' ',' ',' ',' ',' ',' ',' ',' ',' ','#'},
        {'#','#','#','#','#','#','#','#','#','#','#'},

    };

    static boolean[][] visited = new boolean[a.length][a[0].length];



    public static void main(String[] args) {


                // fill visited array
        visited = new boolean[a.length][a[0].length];
        for (int i = 0; i < visited.length; i++) {
            for (int j = 0; j < visited[0].length; j++) {
                visited[i][j] = false;
            }
        }

        recursion(1,1);
        /** This code block prints the array **/    

        for(int i=0; i< a.length;i++){
            for(int j=0;j<a[i].length;j++){
                System.out.print(a[i][j]);
            }
        System.out.println();

        }
            /**    End of Print  **/

    }



    private static void recursion(int row, int col) {
        if (!isInBound(row, col) || visited[row][col])
            return;
        visited[row][col] = true;

        if (a[row][col] == 'X') {
            return;
        }else if (a[row][col]==' ') { // check blank before entering 

            if(a[row][col+1]=='X'){
                a[row][col]='>';
            }

            else if (((a[row][col-1]=='>')|| (a[row][col+1]=='<'))&&(a[row+1][col]==' ')){      // move down
                a[row][col]='V';
                recursion(row+1,col);
            } 
            else if((a[row+1][col]==' ')&&((a[row-1][col]=='V')||(a[row][col-1]==' '))){    // keep going down
                a[row][col]='V';
                recursion(row+1,col);                       
            }

            else if((a[row][col-1]==' ')&& (a[row+1][col]!=' ')&& (a[row][col+1]!=' ')){ // move left
                a[row][col]='<';
                recursion(row,col-1);
            }
            else if((a[row-1][col]==' ')&&(a[row][col-1]=='>')){                        //move up
                a[row][col]='^';
                recursion(row-1,col);
            }else if((a[row+1][col]=='^')&&(a[row-1][col]==' ')){
                a[row][col]='^';
                recursion(row-1,col);
            }else if ((a[row][col+1]=='#')){
                a[row][col]='.';
                recursion(row,col-1);
            }
            else {  
                                                                                        // Keep going forward //
                a[row][col]='>';
                recursion(row, col + 1);
            }

        }
        }





    private static boolean isInBound(int row, int col) {
          boolean bol = false;
            if (row < a.length && col < a[0].length && col >= 0 && row >= 0) {
                bol = true;
            }

            return bol;
    }
}

到目前为止，它适用于简单的输入，如 (1,1) 或 (1,2) 等，当输入复杂时，如 (3,1) 发生这种情况：

###########
#         #
#### ######
#>V>V#    X
# >^.#    #
# ###### ##
#         #
###########

它绕着同一个地方。除了通过很多 else if 语句之外，还有其他方法吗？我想将它用于更大的矩阵，如 100x100。有没有其他方法可以递归地找到最短路径。

Answer 1

这个伪代码告诉如何遍历，而不是找到最小距离。您首先需要正确遍历。
现在修改它以找到最小距离。

 solve ( i , j , ch)
    {
      if(! safe(i,j)) return false

      mark visited[i][j] = ch
      if(matrix[i][j] == 'X') return true
      return ( solve(i-1 , j ,T) | solve(i , j-1 , L) |solve(i , j+1 , R) |solve(i+1 , j , B))
    }

    main()
    {
    // x,y is starting point
      if(!solve(x,y))  print no path
      else found a path
    }

您需要探索所有 4 个方向，但您只探索第一个可能的方向，这就是您使用这么多 if-else 的原因，这仍然会导致循环在您在测试用例中看到的相同路径上。