关于DFS和BFS的思考

在二维数组中进行搜索，什么时候用BFS，什么时候用DFS？

1，如果只需要我们找的结果是可不可行，或者只要求返回一个结果，那么用深度优先遍历会更加高效，因为它是一直往下走，不能走后进行
回溯，只要有一种结果就返回的，所以自然就会更加高效一点点。而BFS必须对每一种可能行都要进行尝试，所以会浪费很多时间。
2，如果是要求找最值问题，一般就采用BFS算法，因为它是进行所有可能性进行同步前进的，这样子的好处是谁先到目标位置，那么谁就是最值
而DFS则需要将所有的结果进行跑一遍，代码不好写容易出错。

常见的搜索类题目的选择方案

1，感染类：BFS
2，最短路径类：BFS
3，岛屿个数类：BFS
4，可达类：DFS
当然这里只是将的是个大概方向，不一定必须按照这个去写，要具体问题具体分析。

BFS解法种visited为什么可以全局使用？

在刚开始写时，对于visited总感觉如果在最短路径先到这结果这个位置却被占用了，是不是就出错了呢，现在看来这个本身就是一个相互违背
的规定，对于BFS来说，他们的每个方向走的位置都是同步进行的，即每个方向走的格子数一定是一致的，那么先到有一个不是最短路径的路径
先到最短路径格子的位置了，那么就于之前的定义冲突，即这是一个伪命题。

DFS的书写套路：

1，确定走的访问，即模拟我们试探的路径，一般是通过一个二维数组，或者两个二维数组。（可省略，也可以不写，其实代码量差不多）
2，开始遍历二维数组，寻找我们符合开始条件的位置
3，开始进行遍历（dfs正式开始），先判断是否符合深度遍历的条件（一般为是否越界，是否是我们能前进的格子，这个格子是否被访问），
然后开始向各个方向走。（如果是求连续面积之类的题目，可以用一个值去接收后面的dfs返回的值，例如说：int count = 1; count += dfs()）
4，DFS的本质是递归。
例题

class Solution {
    static int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
    public int numIslands(char[][] grid) {
        //高度
        int nr = grid.length;
        //宽度
        int nc = grid[0].length;
        int res = 0;
        for (int i = 0; i < nr; i++) {
            for (int j = 0; j < nc; j++) {
                if (grid[i][j] == '1') {
                    ++res;
                    dfs(grid, i, j);
                }
            }
        }
        return res;
    }

    void dfs(char[][] grid, int x, int y){
        //高度
        int nr = grid.length;
        //宽度
        int nc = grid[0].length;

        if (x < 0 || x >=nr || y < 0 || y >= nc || grid[x][y] == '0') {
            return;
        }
        grid[x][y] = '0';

        for (int i = 0; i < 4; i++) {
            int ni = x + dirs[i][0];
            int nj = y + dirs[i][1];
            dfs(grid,ni, nj);
        }
    }
}

BFS的书写套路：

1，确定走的访问，即模拟我们试探的路径，一般是通过一个二维数组，或者两个二维数组。
2，创建一个队列，进行存放每一次遍历的节点，代表的是这个方向中我们走到的位置。（这个队列一般为存放一个数组，这样子就可以表示一个坐标）
3，之后通过while循环来进行后续的操作，每次从队列中取出一个值，然后把它所有的能走的方向放进去。当循环结束时，那么就结束了BFS。
例题

class Solution {
    static int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
    public int orangesRotting(int[][] grid) {
        int h = grid.length, l = grid[0].length;
        int times = 0;
        boolean is1 = false;
        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < l; j++) {
                if (grid[i][j] == 2) {
                    queue.offer(new int[]{i,j});
                }else if (grid[i][j] == 1) {
                    is1 = true;
                }
            }
        }
        if (queue.isEmpty()) {
            if (is1) {
                return -1;
            }else {
                return 0;
            }
        }
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int z = 0; z < size; z++) {
                int[] poll = queue.poll();
                int i = poll[0]; int j = poll[1];
                for (int k = 0; k < 4; k++) {
                    int ni = i + dirs[k][0];
                    int nj = j + dirs[k][1];
                    if (ni >= 0 && ni < h && nj >= 0 && nj < l && grid[ni][nj] == 1) {
                        grid[ni][nj] = 2;
                        queue.offer(new int[]{ni, nj});
                    }
                }
            }
            times++;
        }
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < l; j++) {
                if (grid[i][j] == 1) {
                    return -1;
                }
            }
        }
        return times - 1;
    }
}