找到所有路径（和最短路径）的迷宫算法

Question

Hi everyone in the this code i want to find all path to exit the maze in some case for one exit home you have more than one path i want to select shortest path how should i add this future to below code, the below code is my algorithm to find path,but it is not find all path

public void searchPath(char[][] BW, int i , int j ){   // megdar avalie i = SX-1 ,megdar avalie j= SY-1

        if(i<0 || i>(N-1)) return;     // check out of bound
        if(j<0 || j>(N-1)) return;
        if(BW[i][j] == 'b') return;     // if cell is black return
        if(visit[i][j]== true) return;

        visit[i][j] = true;

        path.add(i+","+j);

        if( !(i==SX-1 && j==SY-1 )){
            if(i==0 || i==N-1 || j==0 || j==N-1) {

                    if(first){
                        //first = false;
                        drawWay(path);
                    }                       
            }
        } 
        searchPath(BW , i , j+1);          // right

        searchPath(BW , i-1 , j);          // search the up side of cell    

        searchPath(BW , i , j-1);          // left
        searchPath(BW , i+1 , j);           // search the down          

        path.remove(path.size()-1);        // remove the not necceccery path


    }

Answer 1

I am not sure if I got this right - first you said that you want to find all possible paths to exit the maze, but then you mentioned finding the shortest one.

Actually, both of your problems can be solved with the same approach. Your are currently using depth first search in your algorithm ( http://en.wikipedia.org/wiki/Depth-first_search ). It goes as deep as possible and when there's no other way to go, it returns back - hence the name.

What you should use instead is breadth first search ( http://en.wikipedia.org/wiki/Breadth-first_search ). This way, you'll traverse the maze in layers - in ith "round", you'll visit all positions that are i squares away from home square. So when you now get to the border square, it has to be the shortest possible path. BFS can be implemented using queue.

To find all possible solutions, you'll have to use extra space in order to remember from which position did you get to the current one. Then, when you'll want to find the way back home from position i, j, you'll write current position to output, then look into the array of previous positions for i, j. Now you have predecessors of i, j - k, l and do the same with them - output k, l and look into the array for predecessors of k, l. Repeat this until you "get back home".

I would post you a bit of a code, but I don't know Java so I don't want to confuse you. ;)