How to fix DFS/BFS in a grid setting?
<p>Ok so I started working on this question <a href="http://dwite.ca/questions/shortest_path_around_v2.html" rel="nofollow">http://dwite.ca/questions/shortest_path_around_v2.html</a> , and I looked at it from two perspectives, DFS/BFS, now I want to ask why both my DFS/BFS do not work
here is my code for both a BFS and a DFS, also BFS gives output but not the shortest path, it only gives A path </p>

<pre><code>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 &lt; 5; q++) {
        char[][] maze = new char[8][8];
        for (int y = 0; y &lt; 8; y++) {
            String text = s.nextLine();
            for (int x = 0; x &lt; 8; x++) {
                maze[x][y] = text.charAt(x);
                numSteps[x][y] = 9999;
            }
        }
        for (int z = 0; z &lt; 8; z++) {
            for (int a = 0; a &lt; 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 &lt; 8; i++) {
            for (int a = 0; a &lt; 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 &gt; numSteps[x][y]) {
        return;
    }
    try {
        if (x &gt; 0) {
            dfs(x - 1, y, maze, steps + 1, target);
        }
        if (x &lt; 8) {
            dfs(x + 1, y, maze, steps + 1, target);
        }
        if (y &gt; 0) {
            dfs(x, y - 1, maze, steps + 1, target);
        }
        if (y &lt; 8) {
            dfs(x, y + 1, maze, steps + 1, target);
        }
        if (x &gt; 0 &amp;&amp; y &gt; 0) {
            dfs(x - 1, y - 1, maze, steps + 1, target);
        }
        if (x &gt; 0 &amp;&amp; y &lt; 8) {
            dfs(x - 1, y + 1, maze, steps + 1, target);
        }
        if (x &lt; 8 &amp;&amp; y &lt; 8) {
            dfs(x + 1, y + 1, maze, steps + 1, target);
        }
        if (x &lt; 8 &amp;&amp; y &gt; 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&lt;int[]&gt; queue = new LinkedList&lt;int[]&gt;();
    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 &lt; 0 || x &gt;= 8 || y &lt; 0 || y &gt;= 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 &lt; 8; i++) {
            int[] temp = {x + newPoints[i][0], y + newPoints[i][1], array[2] + 1};
            queue.add(temp);
        }
        maze[x][y] = wall;
    }

    return 0;

}
}
</code></pre>
