LeetCode刷题笔记（11）-DFS深度优先搜索算法Ⅰ

LeetCode刷题笔记（11）-DFS深度优先搜索算法Ⅰ

BFS深度优先搜索定义

广度优先搜索一层一层遍历，每一层得到的所有新节点，要用队列存储起来以备下一层遍历的时候再遍历。

而深度优先搜索在得到一个新节点时立即对新节点进行遍历：从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。

从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 可达性 问题。

在程序实现 DFS 时需要考虑以下问题：

栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。
标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。

547、寻找朋友圈

班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。
*

• 给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。
• 示例 1:
• 输入:
• [[1,1,0],
• [1,1,0],
• [0,0,1]]
• 输出: 2
• 说明：已知学生0和学生1互为朋友，他们在一个朋友圈。
• 第2个学生自己在一个朋友圈。所以返回2。

好友关系可以看成是一个无向图，
例如第 0 个人与第 1 个人是好友，那么 M[0][1] 和 M[1][0] 的值都为 1。

public class findCircleNum547 {
    private int n;
    public int findCircleNum(int[][] M){
        n = M.length;
        int circleNum = 0;
        boolean[] hasVisted = new boolean[n];
        for(int i = 0; i < n; i++){
            if(!hasVisted[i]){
                dfs(M,i,hasVisted);
                circleNum++;
            }
        }
        return circleNum;
    }

    private void dfs(int[][] M, int i, boolean[] hasVisted) {
        hasVisted[i] = true;
        for(int k = 0; k < n; k++){
            if(M[i][k] == 1 && !hasVisted[k]){
                dfs(M,k,hasVisted);
            }
        }
    }
}
 */

总结：这道题目也是比较典型的BFS，可以发现很多题目可以利用BFS也可以用DFS。

200、岛屿个数

• 给定一个包含了一些 0 和 1 的非空二维数组 grid 。
• 一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，
• 这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。
• 你可以假设 grid 的四个边缘都被 0（代表水）包围着。
• 找到给定的二维数组中最大的岛屿面积。
• (如果没有岛屿，则返回面积为 0 。)
• [[0,0,1,0,0,0,0,1,0,0,0,0,0],
• [0,0,0,0,0,0,0,1,1,1,0,0,0],
• [0,1,1,0,1,0,0,0,0,0,0,0,0],
• [0,1,0,0,1,1,0,0,1,0,1,0,0],
• [0,1,0,0,1,1,0,0,1,1,1,0,0],
• [0,0,0,0,0,0,0,0,0,0,1,0,0],
• [0,0,0,0,0,0,0,1,1,1,0,0,0],
• [0,0,0,0,0,0,0,1,1,0,0,0,0]]
  *对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，
• 因为岛屿只能包含水平或垂直的四个方向的 1 。

好友关系可以看成是一个无向图，
例如第 0 个人与第 1 个人是好友，那么 M[0][1] 和 M[1][0] 的值都为 1。

算法:
我们想知道网格中每个连通形状的面积，然后取最大值。
如果我们在一个土地上，
以 4 个方向探索与之相连的每一个土地（以及与这些土地相连的土地），
那么探索过的土地总数将是该连通形状的面积。
为了确保每个土地访问不超过一次，
我们每次经过一块土地时，将这块土地的值置为 0。
这样我们就不会多次访问同一土地。

 public int maxAreaOfIsland(int[][] grid){
        int res = 0;
        for(int i = 0; i < grid.length; i++){
                for(int j = 0; j <grid[i].length; j++){
                    if (grid[i][j]==1){
                        res = Math.max(res,dfs(i,j,grid));
                    }
                }
        }
        return res;
    }

    private int dfs(int i, int j, int[][] grid) {
        if(i < 0 || j < 0 || i >= grid.length || j >= grid[i].length) return 0;
        grid[i][j]=0;
        int num = 1;
        num += dfs(i-1,j,grid);
        num += dfs(i-1,j,grid);
        num += dfs(i,j+1,grid);
        num += dfs(i,j-1,grid);
        return num;
    }
}

200、岛屿数量

• 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
• 岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。
• 此外，你可以假设该网格的四条边均被水包围。
• 示例 1:
• 输入:
• [
• [‘1’,‘1’,‘1’,‘1’,‘0’],
• [‘1’,‘1’,‘0’,‘1’,‘0’],
• [‘1’,‘1’,‘0’,‘0’,‘0’],
• [‘0’,‘0’,‘0’,‘0’,‘0’]
• ]
• 输出: 1

public class numIslands200 {
    public int numIslands(char[][] grid){
        if(grid == null || grid.length ==0) return 0;
        int nr = grid.length;
        int nc = grid[0].length;
        int num_islands = 0;
        for(int r = 0; r < nr; ++r){
            for(int c = 0; c < nc; ++c){
                if (grid[r][c] == '1'){
                    ++num_islands;
                    dfs(grid,r,c);
                }
            }
        }
        return  num_islands;
    }

    private void dfs(char[][] grid, int r, int c) {
        int nr = grid.length;
        int nc = grid[0].length;
        if(r < 0 || c <0 || r >= nr || c >= nc || grid[r][c]==0) return;

        grid[r][c] = '0';
        dfs(grid, r-1, c);
        dfs(grid, r+1, c);
        dfs(grid,r,c+1);
        dfs(grid,r,c-1);
    }

}