DFS和BFS

深度搜索算法

广度搜索算法

其实两算法的思路很简单，主要就是代码编写上的细节问题

797. 所有可能的路径 - 力扣（LeetCode）

200. 岛屿数量 - 力扣（LeetCode）

上面这两道题都是很经典的dfs和bfs问题

dfs

1. 确认递归函数，参数
2. 确认终止条件
3. 处理当前节点出发的路径

class Solution {
    List<List<Integer>> ans=new ArrayList();
    List<Integer> path=new ArrayList();

    void dfs(int[][] graph,int node){
        if(node==graph.length-1){
            
            ans.add(new ArrayList(path));
            return;
        }
        for(int i=0;i<graph[node].length;i++){
            int t=graph[node][i];
            System.out.println(t);
            path.add(t);
            dfs(graph,t);
            path.remove(path.size()-1);
        }
    }

    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        path.add(0);
        dfs(graph,0);
        return ans;
    }
}

bfs

利用一个队列和boolean数组实现

class Solution {
    boolean[][] visited;
    int[] dx=new int[]{0,1,0,-1};
    int[] dy=new int[]{1,0,-1,0};

    public int numIslands(char[][] grid) {
        int ans=0;
        visited=new boolean[grid.length][grid[0].length];
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(!visited[i][j]&&grid[i][j]=='1'){

                    bfs(grid,i,j);
                    ans++;
                }
            }
        }
        return ans;
    }

    void bfs(char[][] grid,int x,int y){
        Queue<Integer> q=new LinkedList();
        q.offer(x);
        q.offer(y);
        visited[x][y]=true;
        while(!q.isEmpty()){
            int n=q.poll();
            int m=q.poll();
            for(int i=0;i<4;i++){
                for(int j=0;j<4;j++){
                    int a=n+dx[i];
                    int b=m+dy[i];
                    if(a<0||a>=grid.length||b<0||b>=grid[0].length) continue;
                    if(!visited[a][b]&&grid[a][b]=='1'){
                        q.offer(a);
                        q.offer(b);
                        visited[a][b]=true;
                    }
                }
            }
        }
    }
}