Java question Consider a maze made up of a rectangular array

Java question:

Consider a maze made up of a rectangular array of squares. The maze will contain a character (either +, -, or |) to represent a blocked square, and to form the walls of the maze. Mazes will have only one entrance at the Coordinate (0, 1), with only one exit in the lower right hand corner of the maze.

Beginning at the entrance to the maze, find a path to the exit at the bottom right of the maze. You may only move up, down, left, and right. Each square in the maze can be in one of four states: clear (space), blocked (X), path (.), or visited (*). Initially, after the maze has been read in from the file, each square will be either clear or blocked. If a square lies on a successful path, mark it with a period. If you visit a square but it does not lead to a successful path, mark it as visited with an asterisk.

Appendix B: Sample Output D java p2.MazeSolver Before solving 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 67 8 9 0 0 x X X X X X X XXx xXX X X X X X X x X 5 X 9 X 10 X X X X X 11 X X X X X X X XX XXX 13 X 14 X X X X X X X X X XXX X XX 15 X 16 X X X X X X X XX X X X X X X X X 17 X 18 X XX X X XXX X X X X XX X X 19 X 20 X X x X X X X X X X X X X X X X x x x Start is (0,1) End is (20,19) After solving shows solution, o shows visited) 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 89 5 X 7 X 9 X 10 X X X XXX X X XX X X X XX X X 11 x 12 x XX X XX x xXX X X xX X X 13 X X*X 15 X 16 X X X XX XXX*X X X XX XX X X 17 X 18 x XXXX X*XXX X*X XX X X.x 19 X 20 X X X X XX X XX X XX X XX X XX X X X

Answer:

import java.io.*;

public class DetectedShortestPathInMaze
{

   static int number_of_rows=10;       static    int number_of_columns=10;
   static int begin_of_row=5;       static int begin_of_coloumn=3;
static int end_of_row=1;       static int end_of_coloumn=6;

   static    int taken_maze[][]={{1,1,1,1,1,1,1,1,1,1},
                           {1,0,0,1,0,0,0,1,0,1},
                           {1,0,1,1,1,0,1,1,0,1},
                           {1,0,0,0,0,0,0,0,0,1},
                           {1,0,1,0,1,1,0,1,1,1},
                           {1,0,0,0,0,1,0,0,0,1},
                           {1,0,1,1,1,0,0,1,1,1},
                           {1,0,1,1,1,1,0,1,0,1},
                           {1,0,0,0,0,0,0,0,0,1},
                           {1,1,1,1,1,1,1,1,1,1}};

   static    int shortestpath[]=new int[number_of_rows*number_of_columns];
   static    int length_short;

boolean visitedalready(int row, int col, int detectedpathsofar[], int detectedlengthsofar){


       int x;
       int goal = row*number_of_columns+col;

for (x=0;x<detectedlengthsofar;x++)
if (detectedpathsofar[x]==goal) return true;

return false;
}

   public void displayupdatedpath(int takenpath[], int takenlength){

int r,c;

       for (r=0;r<number_of_rows;r++){
           for(c=0;c<number_of_columns;c++){
               if (taken_maze[r][c]==1)
                   System.out.print(\"|\");
               else if (r==begin_of_row && c==begin_of_coloumn)
                   System.out.print(\"S\");
               else if (r==end_of_row && c==end_of_coloumn)
                   System.out.print(\"X\");
               else if (visitedalready(r,c,takenpath,takenlength))
                   System.out.print(\"o\");
               else
                   System.out.print(\" \");
           }
           System.out.println(\"\");
       }
   }

   public void searchnewpath(int row, int col, int detectedpathsofar[], int detectedlengthsofar){

       if (row<0 || col<0 || row>=number_of_rows || col>=number_of_columns)
           return;
       if (taken_maze[row][col]==1) return ;
       if (visitedalready(row, col, detectedpathsofar, detectedlengthsofar)) return;

int takenpath[]=new int[detectedlengthsofar+1];

       System.arraycopy(detectedpathsofar, 0, takenpath, 0, detectedlengthsofar);



       takenpath[detectedlengthsofar++]=row*number_of_columns+col;

if (row==end_of_row && col==end_of_coloumn){

System.out.println(\"Detected path of length \"+detectedlengthsofar+\":\");
displayupdatedpath(takenpath, detectedlengthsofar);

           if (detectedlengthsofar<=length_short){
               length_short=detectedlengthsofar;
               System.arraycopy(takenpath, 0, shortestpath, 0, detectedlengthsofar);
               System.out.println(\" The new shortest path is of length \" + detectedlengthsofar);
           }
           System.out.println(\"\");
           return;
       }

       searchnewpath(row-1, col, takenpath, detectedlengthsofar);
       searchnewpath(row, col-1, takenpath, detectedlengthsofar);
       searchnewpath(row, col+1, takenpath, detectedlengthsofar);
       searchnewpath(row+1, col, takenpath, detectedlengthsofar);
   }


   public static void main(String[] args)
   {

       int r,c,x;
       int detectedpathsofar[];
       int detectedlengthsofar;

DetectedShortestPathInMaze obj=new DetectedShortestPathInMaze();

       detectedpathsofar=new int[obj.number_of_rows*obj.number_of_columns];

       for (x=0;x<obj.number_of_rows*obj.number_of_columns;x++){
           obj.shortestpath[x]=-1;
           detectedpathsofar[x]=-1;
       }

       obj.length_short=obj.number_of_rows*obj.number_of_columns+1;
       detectedlengthsofar=0;

       System.out.println(\"The Maze Is Shown As Below:\");
       for (r=0;r<obj.number_of_rows;r++){
           for (c=0;c<obj.number_of_columns;c++){
               if (r==begin_of_row && c==begin_of_coloumn)
                   System.out.print(\"S\");
               else if (r==end_of_row && c==end_of_coloumn)
                   System.out.print(\"x\");
               else if (obj.taken_maze[r][c]==0)
                   System.out.print(\" \");
               else System.out.print(\"|\");
           }
           System.out.println(\"\");
       }

System.out.println(\"\");
System.out.println(\"Searching For Paths!!!!!\");

obj.searchnewpath(begin_of_row, begin_of_coloumn, detectedpathsofar, detectedlengthsofar);

       System.out.println(\"\");
       System.out.println(\"The shortest path was found with the following of length \"+ obj.length_short);
       obj.displayupdatedpath(obj.shortestpath, obj.length_short);

}
}

Java question: Consider a maze made up of a rectangular array of squares. The maze will contain a character (either +, -, or |) to represent a blocked square, a

Java question Consider a maze made up of a rectangular array

Solution

Get Help Now

Submit a Take Down Notice