Java 如何在网格设置中修复DFS/BFS？

好的，我开始研究这个问题，我从两个角度来看，DFS/BFS，现在我想问为什么我的DFS/BFS都不起作用 这是我的BFS和DFS代码，BFS也给出了输出，但不是最短路径，它只给出了一条路径

package bfsv3;

import java.util.*;
import java.io.*;

public class BFSV3 {

static int steps = 0;
static int numSteps[][] = new int[8][8];
static int finx, finy;

public static void main(String[] args) throws FileNotFoundException {
    //        here is my input 
    //........
    //........
    //...##...
    //A..##...
    //...##...
    //...##...
    //...##..B
    //........
    //and this is the output for the dfs, as you can see where B is it doesnt give 8 but 9
    //3 3 3 3 4 5 6 7 
    //2 2 2 3 4 5 6 7 
    //1 1 2 # # 5 6 7 
    //0 1 2 # # 6 6 7 
    //1 1 2 # # 7 7 7 
    //2 2 2 # # 8 8 8 
    //3 3 3 # # 7 8 9 
    //4 4 4 4 5 6 7 8 
    Scanner s = new Scanner(new File("C:\\Users\\DANIEL\\Desktop\\Java\\BFSV3\\src\\bfsv3\\DATA4.txt"));
    for (int q = 0; q < 5; q++) {
        char[][] maze = new char[8][8];
        for (int y = 0; y < 8; y++) {
            String text = s.nextLine();
            for (int x = 0; x < 8; x++) {
                maze[x][y] = text.charAt(x);
                numSteps[x][y] = 9999;
            }
        }
        for (int z = 0; z < 8; z++) {
            for (int a = 0; a < 8; a++) {
                if (maze[a][z] == 'B') {
                    finx = a;
                    finy = z;
                }
                if (maze[a][z] == 'A') {
                    //System.out.println(bfs(maze, z, a, '#', 'B') - 1);
                    dfs(a, z, maze, 0, 'B');
                }
            }
        }
        // System.out.println(finx + " " + finy);
        //System.out.println(numSteps[finx][finy]);
        for (int i = 0; i < 8; i++) {
            for (int a = 0; a < 8; a++) {
                if (numSteps[a][i] != 9999) {
                    System.out.print(numSteps[a][i] + " ");
                } else {
                    System.out.print("#" + " ");
                }
            }
            System.out.println();
        }
        System.out.println("\n\n");
    }
}

public static void dfs(int x, int y, char[][] maze, int steps, char target) {
    if (maze[x][y] == '#') {
        return;
    }
    //System.out.println(steps+" "+numSteps[x][y]);
    numSteps[x][y] = Math.min(steps, numSteps[x][y]);
    if (steps > numSteps[x][y]) {
        return;
    }
    try {
        if (x > 0) {
            dfs(x - 1, y, maze, steps + 1, target);
        }
        if (x < 8) {
            dfs(x + 1, y, maze, steps + 1, target);
        }
        if (y > 0) {
            dfs(x, y - 1, maze, steps + 1, target);
        }
        if (y < 8) {
            dfs(x, y + 1, maze, steps + 1, target);
        }
        if (x > 0 && y > 0) {
            dfs(x - 1, y - 1, maze, steps + 1, target);
        }
        if (x > 0 && y < 8) {
            dfs(x - 1, y + 1, maze, steps + 1, target);
        }
        if (x < 8 && y < 8) {
            dfs(x + 1, y + 1, maze, steps + 1, target);
        }
        if (x < 8 && y > 0) {
            dfs(x + 1, y - 1, maze, steps + 1, target);
        }
    } catch (Exception e) {
    };
}

public static int bfs(char[][] maze, int yStart, int xStart, char wall, char goal) {
    Queue<int[]> queue = new LinkedList<int[]>();
    int[] start = {yStart, xStart, 0};
    queue.add(start);
    while (queue.peek() != null) {
        int[] array = queue.remove();
        int x = array[0];
        int y = array[1];
        if (x < 0 || x >= 8 || y < 0 || y >= 8) {
            continue;
        }
        if (maze[x][y] == wall) {
            continue;
        }
        if (maze[x][y] == goal) {
            return array[2] + 1;
        }

        int[][] newPoints = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}, {-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
        //int[][] newPoints = {{-1,-1},{-1,1},{1,-1},{1,1}}; 
        for (int i = 0; i < 8; i++) {
            int[] temp = {x + newPoints[i][0], y + newPoints[i][1], array[2] + 1};
            queue.add(temp);
        }
        maze[x][y] = wall;
    }

    return 0;

}
}

包bfsv3；
导入java.util.*；
导入java.io.*；
公共类BFSV3{
静态整数步长=0；
静态int numSteps[][]=新int[8][8]；
静态int finx，finy；
公共静态void main（字符串[]args）引发FileNotFoundException{
//这是我的意见
//........
//........
//...##...
//A。。。
//...##...
//...##...
//…###…B
//........
//这是dfs的输出，你可以看到B在哪里，它不是8而是9
//3 3 3 3 4 5 6 7 
//2 2 2 3 4 5 6 7 
//1 1 2 # # 5 6 7 
//0 1 2 # # 6 6 7 
//1 1 2 # # 7 7 7 
//2 2 2 # # 8 8 8 
//3 3 3 # # 7 8 9 
//4 4 4 4 5 6 7 8 
Scanner s=new Scanner（新文件（“C:\\Users\\DANIEL\\Desktop\\Java\\BFSV3\\src\\BFSV3\\DATA4.txt”）；
对于（int q=0；q<5；q++）{
字符[][]迷宫=新字符[8][8]；
对于（int y=0；y<8；y++）{
字符串text=s.nextLine（）；
对于（int x=0；x<8；x++）{
迷宫[x][y]=text.charAt（x）；
numSteps[x][y]=9999；
}
}
对于（intz=0；z<8；z++）{
对于（int a=0；a<8；a++）{
if（迷宫[a][z]='B'）{
finx=a；
finy=z；
}
if（迷宫[a][z]='a'）{
//系统输出println（bfs（迷宫，z，a，，'B'）-1）；
dfs（a，z，maze，0，'B'）；
}
}
}
//System.out.println（finx+“”+finy）；
//System.out.println（numSteps[finx][finy]）；
对于（int i=0；i<8；i++）{
对于（int a=0；a<8；a++）{
if（numSteps[a][i]！=9999）{
系统输出打印（numSteps[a][i]+“”）；
}否则{
系统输出打印（“#”+”）；
}
}
System.out.println（）；
}
System.out.println（“\n\n”）；
}
}
公共静态void dfs（int x、int y、char[][]迷宫、int步骤、char目标）{
如果（迷宫[x][y]='#'）{
返回；
}
//System.out.println（步数+“”+numSteps[x][y]）；
numSteps[x][y]=Math.min（步骤，numSteps[x][y]）；
如果（步骤>numSteps[x][y]）{
返回；
}
试一试{
如果（x>0）{
dfs（x-1，y，迷宫，步骤+1，目标）；
}
if（x<8）{
dfs（x+1，y，迷宫，步骤+1，目标）；
}
如果（y>0）{
dfs（x，y-1，迷宫，步骤+1，目标）；
}
if（y<8）{
dfs（x，y+1，迷宫，步骤+1，目标）；
}
如果（x>0&&y>0）{
dfs（x-1，y-1，迷宫，步骤+1，目标）；
}
如果（x>0&&y<8）{
dfs（x-1，y+1，迷宫，步骤+1，目标）；
}
如果（x<8&&y<8）{
dfs（x+1，y+1，迷宫，步骤+1，目标）；
}
如果（x<8&&y>0）{
dfs（x+1，y-1，迷宫，步骤+1，目标）；
}
}捕获（例外e）{
};
}
公共静态int-bfs（char[][]迷宫、int-yStart、int-xStart、char-wall、char-goal）{
Queue Queue=new LinkedList（）；
int[]start={yStart，xStart，0}；
queue.add（开始）；
while（queue.peek（）！=null）{
int[]数组=queue.remove（）；
int x=数组[0]；
int y=数组[1]；
如果（x<0 | | x>=8 | | y<0 | | y>=8）{
继续；
}
if（迷宫[x][y]==墙）{
继续；
}
如果（迷宫[x][y]==目标）{
返回数组[2]+1；
}
int[]newPoints={{0，-1}，{0，1}，{1，0}，{-1，0}，{-1，-1}，{-1，1}，{1，-1}，{1，1}；
//int[]newPoints={{-1，-1}，{-1,1}，{1，-1}，{1,1}；
对于（int i=0；i<8；i++）{
int[]temp={x+newPoints[i][0]，y+newPoints[i][1]，数组[2]+1}；
添加（临时）；
}
迷宫[x][y]=墙壁；
}
返回0；
}
}

DFS：

您正在检查迷宫超出边界的限制。（如

if（x<8）

， 但是你的迷宫被声明为

char[]maze=newchar[8][8]；

这就产生了一个， 但由于catch块为空，因此不会在任何地方引发此异常：

} catch (Exception e)
{
};

在

dfs

方法的末尾

请不要做这种事

而且，这会破坏你的递归

BFS：我认为使用

int的辅助数组更容易理解，至少对于测试来说是这样

无论如何，这里有您发布的代码的修改工作版本：

---

---

bfs不应该返回实际路径而不仅仅是长度吗？我只是读了你的bfs 10遍，除了只返回一个长度外，我看不出有任何问题。我需要最短路径，所以从a到B的长度，它没有给出最短路径，因为一些奇怪的原因：(

package rpax.stackoverflow.maze13549150;

import java.io.File;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main13549150 {

    static int steps = 0;
    static int numSteps[][] = new int[8][8];
    static int finx, finy;

    public static void main(String[] args) {
        try
        {

            Scanner s = new Scanner(new File("files/files13549150/DATA4.txt"));
            // for (int q = 0; q < 5; q++)
            // { // I dont know the reason of this loop - Maybe more files?
            char[][] maze = new char[8][8];
            System.out.println("MAZE: ");
            for (int y = 0; y < 8; y++)
            {
                String text = s.nextLine();
                for (int x = 0; x < 8; x++)
                {
                    maze[x][y] = text.charAt(x);
                    System.out.print(maze[x][y] + " ");
                    numSteps[x][y] = Integer.MAX_VALUE;
                }
                System.out.println();
            }
            System.out.println();
            outer:
            for (int z = 0; z < 8; z++)
            {
                for (int a = 0; a < 8; a++)
                {
                    if (maze[a][z] == 'B')
                    {
                        finx = a;
                        finy = z;
                    }
                    if (maze[a][z] == 'A')
                    {
                        System.out.println("BFS: ");
                        System.out.println(bfs2(maze, a, z, '#', 'B'));
                        dfs(a, z, maze, 0, 'B');
                        break outer;
                    }
                }
            }
            System.out.println("DFS: ");
            for (int y = 0; y < 8; y++)
            {

                for (int x = 0; x < 8; x++)
                {
                    if (maze[x][y] == '#')
                    {

                        System.out.print('#' + " ");
                    }

                    else
                        System.out.print(numSteps[x][y] + " ");
                }
                System.out.println();
            }

        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public static void dfs(int x, int y, char[][] maze, int steps, char target) {
        if (maze[x][y] == '#')
        {
            return;
        }
        // System.out.println(steps+" "+numSteps[x][y]);
        numSteps[x][y] = Math.min(steps, numSteps[x][y]);
        if (steps > numSteps[x][y])
        {
            return;
        }
        // try {
        if (x > 0)
        {
            dfs(x - 1, y, maze, steps + 1, target);
        }
        if (x < 7)
        {
            dfs(x + 1, y, maze, steps + 1, target);
        }
        if (y > 0)
        {
            dfs(x, y - 1, maze, steps + 1, target);
        }
        if (y < 7)
        {
            dfs(x, y + 1, maze, steps + 1, target);
        }
        if (x > 0 && y > 0)
        {
            dfs(x - 1, y - 1, maze, steps + 1, target);
        }
        if (x > 0 && y < 7)
        {
            dfs(x - 1, y + 1, maze, steps + 1, target);
        }
        if (x < 7 && y < 7)
        {
            dfs(x + 1, y + 1, maze, steps + 1, target);
        }
        if (x < 7 && y > 0)
        {
            dfs(x + 1, y - 1, maze, steps + 1, target);
        }
        // try to avoid this kind of things -> bad practice + breaks recursion
        // } catch (Exception e) {
        // };
    }

    public static int bfs2(char[][] maze, int yStart, int xStart, char wall,
            char goal) {
        Queue<int[]> queue = new LinkedList<int[]>();
        int[] start = { yStart, xStart, 0 };
        int[][] res = new int[8][8];
        int distanceToGoal = Integer.MAX_VALUE;
        for (int i = 0; i < res.length; i++)
        {
            for (int j = 0; j < res.length; j++)
            {
                res[i][j] = Integer.MAX_VALUE;
            }
        }

        queue.add(start);
        while (queue.peek() != null)
        {

            int[] array = queue.remove();
            int x = array[0];
            int y = array[1];
            if (x < 0 || x >= 8 || y < 0 || y >= 8)
            {
                continue;
            }

            if (maze[x][y] == wall)
            {
                continue;
            }

            // already explored
            if (array[2] >= res[x][y])
            {
                continue;
            }
            res[x][y] = array[2];

            if (maze[x][y] == goal)
            {
                distanceToGoal = array[2] + 1;
                break;
            }

            int[][] newPoints = { { 0, -1 }, { 0, 1 }, { 1, 0 }, { -1, 0 },
                    { -1, -1 }, { -1, 1 }, { 1, -1 }, { 1, 1 } };
            for (int i = 0; i < 8; i++)
            {
                int[] temp = { x + newPoints[i][0], y + newPoints[i][1],
                        array[2] + 1 };
                queue.add(temp);
            }

        }
        // testing
        for (int i = 0; i < 8; i++)
        {
            for (int j = 0; j < 8; j++)
            {

                if (maze[j][i] == wall)
                {
                    System.out.print("#" + " ");
                }
                else if (res[j][i] != Integer.MAX_VALUE)
                    System.out.print(res[j][i] + " ");
                else // if not explored
                    System.out.print("." + " ");
            }
            System.out.println();
        }
        return distanceToGoal;

    }
}

MAZE: 
. . . . . . . . 
. . . . . . . . 
. . . # # . . . 
A . . # # . . . 
. . . # # . . . 
. . . # # . . . 
. . . # # . . B 
. . . . . . . . 

BFS: 
3 3 3 3 4 5 6 7 
2 2 2 3 4 5 6 7 
1 1 2 # # 5 6 7 
0 1 2 # # 6 6 7 
1 1 2 # # 7 7 7 
2 2 2 # # 7 7 . 
3 3 3 # # 6 7 8 
4 4 4 4 5 6 7 8 
9
DFS: 
3 3 3 3 4 5 6 7 
2 2 2 3 4 5 6 7 
1 1 2 # # 5 6 7 
0 1 2 # # 6 6 7 
1 1 2 # # 7 7 7 
2 2 2 # # 7 7 8 
3 3 3 # # 6 7 8 
4 4 4 4 5 6 7 8