算法题目 搜索

---

BFS

---

DFS

---

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

而深度优先搜索在得到一个新节点时立即对新节点进行遍历，直到没有新节点了，此时返回，然后继续以上步骤。

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

DFS 与回溯法会省去一个回退的过程

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

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

---

连通块的最大面积

leetcode 695 岛屿的最大面积（中等）
给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)

示例 1:

[
 [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’。

示例 2:

[[0,0,0,0,0,0,0,0]]

对于上面这个给定的矩阵, 返回 0。

注意: 给定的矩阵grid 的长度和宽度都不超过 50。

题解：

class Solution {
    private int res;
    private int m, n;
    private boolean[][] used;
    private int[][] nextStep = {
  {1,0}, {-1,0}, {0,1}, {0,-1}};
    
    public int maxAreaOfIsland(int[][] grid) {
        if(grid.length==0 || grid[0].length==0){
            return 0;
        }
        
        m = grid.length;
        n = grid[0].length;
        used = new boolean[m][n];
               
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j] == 1 && !used[i][j]){
                    int cnt = dfs(grid, i, j);
                    res = Math.max(res, cnt);                
                }
            }
        }
        
        return res;
    }
    
    private boolean inArea(int i, int j){
        return i>=0 && i<m && j>=0 && j<n;
    }
    
    private int dfs(int[][] grid, int i, int j){
        int cnt = 1;
        used[i][j] = true;
        for(int k=0; k<4; k++){
            int nextI = i + nextStep[k][0];
            int nextJ = j + nextStep[k][1];
            
            if(inArea(nextI, nextJ) && grid[nextI][nextJ] == 1 && !used[nextI][nextJ]){
                cnt += dfs(grid, nextI, nextJ);
            }
        }
        
        return cnt;
    }
}

连通块的数目

leetcode 200 岛屿数量（中等）
给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

示例 1:

输入:
 11110
 11010
 11000
 00000
输出: 1

示例 2:

输入:
 11000
 11000
 00100
 00011
输出: 3

题解：

class Solution {
    private int res;
    private int m, n;
    private boolean[][] used;
    private int[][] dist = {
  {1,0}, {-1,0}, {0,1}, {0,-1}};
    
    public int numIslands(char[][] grid) {
        if(grid.length == 0 || grid[0].length==0){
            return 0;
        }
        m = grid.length;
        n = grid[0].length;
        used = new boolean[m][n];
        
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j] == '1' && !used[i][j]){
                    dfs(grid, i, j);
                    res++;
                }
            }
        }
        
        return res;
    }
    
    private boolean inArea(int i, int j){
        return i>=0 && i<m && j>=0 && j<n;
    }
    
    private void dfs(char[][] grid, int i, int j){
        used[i][j] = true;
        for(int k=0; k<4; k++){
            int nextI = i+dist[k][0];
            int nextJ = j+dist[k][1];
            
            if(inArea(nextI, nextJ) && grid[nextI][nextJ] == '1' && !used[nextI][nextJ]){
                dfs(grid, nextI, nextJ);
            }
        }
    }
}

好友关系连通分量数目

leetcode 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。

示例 2:

输入:
[[1,1,0],
[1,1,1],
[0,1,1]]
输出: 1
说明：已知学生0和学生1互为朋友，学生1和学生2互为朋友，所以学生0和学生2也是朋友，所以他们三个在一个朋友圈，返回1。

注意：

• N 在[1,200]的范围内。
• 对于所有学生，有M[i][i] = 1。
• 如果有M[i][j] = 1，则有M[j][i] = 1。

题解：

class Solution {
    private int res;
    private int n;
    private boolean[] used;
    
    public int findCircleNum(int[][] M) {
        if(M.length == 0){
            return 0;
        }    
        
        n = M.length;
        used = new boolean[n];
        
        // 寻找没有建立盆友圈的人
        for(int i=0; i<n; i++){
            if(!used[i]){
                // 以第i个人出发建立盆友圈
                dfs(M, i);
                res++;
            }
        }
        
        return res;
    }
    
    private void dfs(int[][] M, int i){
        used[i] = true;
        for(int k=0; k<n; k++){
            // 若i与k是朋友，且k还未建立朋友圈， 则将k归到i的盆友圈
            if(M[i][k] == 1 && !used[k]){
                dfs(M, k);
            }
        }
    }
}

---

能到达的太平洋和大西洋的区域

leetcode 417 太平洋大西洋水流问题（中等）

给定一个 m x n 的非负整数矩阵来表示一片大陆上各个单元格的高度。“太平洋”处于大陆的左边界和上边界，而“大西洋”处于大陆的右边界和下边界。

规定水流只能按照上、下、左、右四个方向流动，且只能从高到低或者在同等高度上流动。

请找出那些水流既可以流动到“太平洋”，又能流动到“大西洋”的陆地单元的坐标。

提示：

• 输出坐标的顺序不重要
• m 和 n 都小于150

示例：

给定下面的 5x5 矩阵:
 太平洋 ~ ~ ~ ~ ~
   ~ 1 2 2 3 5 *
   ~ 3 2 3 4 4 *
   ~ 2 4 5 3 1 *
   ~ 6 7 1 4 5 *
   ~ 5 1 1 2 4 *
    * * * * * 大西洋
返回:
[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (上图中加粗的单元).

题解：

class Solution {
    private ArrayList<List<Integer>> res = new ArrayList<List<Integer>>();
    private int m, n;
    private int[][] dist = {
  {0,1}, {0,-1}, {1,0}, {-1,0}};
    
    public List<List<Integer>> pacificAtlantic(int[][] matrix) {
        if(matrix.length==0 || matrix[0].length==0){
            return res;