问题
B B B B B
B B B O B
B B S O B
B O O B B
B B X B B
Here,
S = Start Point(2,2)
B = Block
O = Open
X = Exit
I want to make a maze that will check north, west, east and south. if X is around it will return the program. If not, then check for any 'O' around the start point and pass the new start point recursively. It there is no way to go and 'X' is not found it will go back to the original start point(2,2) and check west, east and south.
after the program, i got:
B B B B B
B B B + B
B B + + B
B O + B B
B B X B B
but, I expect the output after the recursion is:
B B B B B
B B B - B
B B + - B
B O + B B
B B X B B
This is my code right now:
public static void Find_Path(char[][] maze, int startX, int startY){
int x[] = { -1, 0, 0, 1};
int y[] = {0,-1,1,0};
boolean found = false;
maze[startX][startY] = '+';
for(int i = 0; i < 4 ; i++){// check if there are 'X' around the S.
int afterX = x[i] + startX;
int afterY = y[i] + startY;
if(maze[afterX][afterY] == 'X'){// if yesy, return.
found = true;
return;
}
}
for(int i = 0; i < 4 ; i++){// if no, check for 'O'
int afterX = x[i] + startX;
int afterY = y[i] + startY;
if(maze[afterX][afterY] == 'O'){
Find_Path(maze, afterX, afterY);
if(!found){
maze[afterX][afterY] = '-';
}
}
}
startX and startY is the index of the start point.
I don't know how to turn the wrong path '-'. The program will check north first If top is B then it will backtrack and go back to the start point. Then, it will go east, west and south.
Can anyone help me out?? thx! @Muntasir
BBBBB
BBOOB
XOBOB
BSOBB
BBBBB
BBBBB
BBOOB
X+BOB ( It should stop right here, because there is X around it.)
BSOBB
BBBBB
BBBBB
BBOOB
X+BOB (but, somehow it go to the right of the startpoint and mark the 'O' to '+'
BS+BB
BBBBB
回答1:
Use a global variable (a flag) to determine whether you found the correct path.
For example:
public class YourClass{
static boolean found = false; // the global flag
// your existing code
public static void Find_Path(char[][] maze, int startX, int startY){
// ....
for(int i = 0; i < 4 ; i++){
// ...
if(maze[afterX][afterY] == 'X'){
found = true; // path found
return;
}
}
for(int i = 0; i < 4 ; i++){
// ...
if(found) // path already found in earlier recursive call; no need to search anymore
return;
else{ // path not found yet, have to continue searching
if(maze[afterX][afterY] == 'O'){
Find_Path(maze, afterX, afterY);
if(!found){ // path not found
maze[afterX][afterY] = '-';
}
}
}
}
}
}
回答2:
The algorithms you are looking for are called Breadth-First Search and Depth-First Search. A problem that you will run into is if there exists a cycle in your maze. For example, what happens if you have this?
B B B B B
B O O O B
B O S O B
B O O O B
B B B B B
Then the algorithm may get stuck in a loop that you cannot escape.
The classical method for solving this problem is to "color" the vertices using another data structure representing whether vertices have been visited before or not.
This MIT OCW lecture may help point you in the right direction: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/lecture-videos/lecture-13-breadth-first-search-bfs/
To answer your question directly, though, think about base cases. What stops the loops from churning and turning when you find the X? In the present state, it looks like the only thing stopping the iteration/recursion is that you run out of places to look. You'll need some kind of variable to tell the second for loop to stop searching.
回答3:
As the question is asked this solution should work:
import java.util.Arrays;
public class TwoDSolver {
private char[][] maze;
private String currPath;
private int currX;
private int currY;
private boolean unsolvable;
public static void main(String[] args) {
char[][] customMaze = {
{'B', 'B', 'B', 'B', 'B'},
{'B', 'B', 'B', 'O', 'B'},
{'B', 'B', 'S', 'O', 'B'},
{'B', 'O', 'O', 'B', 'B'},
{'B', 'B', 'X', 'B', 'B'}
};
String startPath = "";
int startX = 2;
int startY = 2;
TwoDSolver solver = new TwoDSolver(customMaze, startX, startY, startPath, false);
// place a plus at the start point
solver.placePlus();
solver.solveMaze();
if (solver.unsolvable) {
System.out.println("The maze is unsolvable");
} else {
System.out.println("Solved, A correct path is: " + solver.currPath);
}
solver.printMaze();
}
// constructor
TwoDSolver(char[][]aMaze, int stX, int stY, String currentPath, boolean noSolution) {
maze = aMaze;
currX = stX;
currY = stY;
currPath = currentPath;
unsolvable = noSolution;
}
// indicate taken path
void placePlus() {
maze[currX][currY] = '+';
}
// for backtracking
void placeMinus() {
maze[currX][currY] = '-';
}
// solve
// priority in this order East, West, South, North
void solveMaze() {
// check for a win
if (checkForWin()) {
return;
}
// No win, so let's check for an opening
// check east
if (currY + 1 < maze[currX].length && checkForOpen(currX, currY + 1)) {
currY++;
placePlus();
currPath += "E"; // Append East to our current path
// recursive call continue searching
solveMaze();
// check west
} else if (currY - 1 >= 0 && checkForOpen(currX, currY - 1)) {
currY--;
placePlus();
currPath += "W";
solveMaze();
// check south
} else if (currX + 1 < maze.length && checkForOpen(currX + 1, currY)) {
currX++;
placePlus();
currPath += "S";
solveMaze();
// check north
} else if (currX - 1 >= 0 && checkForOpen(currX - 1, currY)) {
currX--;
placePlus();
currPath += "N";
solveMaze();
} else { // we've hit a dead end, we need to backtrack
if (currPath.length() == 0) {
// we're back at the starting point, the maze is unsolvable
unsolvable = true;
return;
} else {
// we've reached a dead end, lets backtrack
placeMinus();
backTrack();
}
}
}
// see if the spot at a give x, y is open
boolean checkForOpen(int x, int y) {
return maze[x][y] == 'O';
}
// see if any of the surrounding spots are the exit
boolean checkForWin() {
// make sure to protect against out of bounds as well
return ((currY + 1 < maze[currX].length && maze[currX][currY + 1] == 'X') ||
(currY - 1 >= 0 && maze[currX][currY - 1] == 'X') ||
(currX + 1 < maze[currX].length && maze[currX + 1][currY] == 'X') ||
(currX -1 >= 0 && maze[currX -1][currY] == 'X'));
}
void backTrack() {
// sanity chek currPath.length() should always be > 0 when we call backTrack
if (currPath.length() > 0) {
placeMinus();
switch (currPath.charAt(currPath.length() - 1)) {
case 'E':
currY--;
break;
case 'W':
currY++;
break;
case 'S':
currX--;
break;
case 'N':
currX++;
break;
}
currPath = currPath.substring(0, currPath.length()-1);
solveMaze();
}
}
void printMaze() {
for (int i = 0; i < maze.length; i++) {
System.out.println(Arrays.toString(maze[i]));
}
}
}
For your example maze the output is:
Solved, A correct path is: S
[B, B, B, B, B]
[B, B, B, -, B]
[B, B, +, -, B]
[B, O, +, B, B]
[B, B, X, B, B]
For the example maze purposed by @William John Howard that has no solution:
{'B', 'B', 'B', 'B', 'B'},
{'B', 'O', 'O', 'O', 'B'},
{'B', 'O', 'S', 'O', 'B'},
{'B', 'O', 'O', 'O', 'B'},
{'B', 'B', 'B', 'B', 'B'}
The output is:
The maze is unsolvable
[B, B, B, B, B]
[B, -, -, -, B]
[B, -, +, -, B]
[B, -, -, -, B]
[B, B, B, B, B]
One thing to note about this solution and this way of approaching the problem: This won't provide the shortest path to the exit
This solution gives priority in this order: East, West, South, North.
Here's an example of what I mean:
Starting maze:
{'B', 'B', 'B', 'X', 'B'},
{'B', 'O', 'O', 'O', 'B'},
{'B', 'O', 'S', 'O', 'B'},
{'B', 'O', 'O', 'O', 'B'},
{'B', 'B', 'B', 'B', 'B'}
Output:
Solved, A correct path is: ESWWNNEE
[B, B, B, X, B]
[B, +, +, +, B]
[B, +, +, +, B]
[B, +, +, +, B]
[B, B, B, B, B]
As you can see there are multiple correct paths to the exit, NE, EN, WNEE, SENN, SWNNEE, ESWWNNEE (the one this algo chose because of direction priority).
I think the main thing you were missing from the code you posted is a way of keeping track of your current path and backtracking when you hit a dead end.
来源：https://stackoverflow.com/questions/43421551/how-do-i-find-path-using-2d-array-maze-in-java