LeetCode-200-岛屿数量

---

题意描述：

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

---

示例：

示例一：

输入:
11110
11010
11000
00000

输出: 1

示例二：

输入:
11000
11000
00100
00011

输出: 3

---

解题思路：

Alice: 怎么判断不同的“１”是不是同一个岛屿呢　？
Bob：看题目里面的定义，相邻而且必须是横向后者纵向上直接相邻，只要是相邻的一块“１”或者一个“１”就能构成一个岛屿？
Alice: 也就是说，如果是对角线相邻的话，是不能算成一个岛屿的？
Bob: 对，不过判断不同的“1”是不是同一个岛屿可能不是一个好的思路，我好像做过类似的题目，是用宽度优先搜索或者深度优先搜索的方法做的。
Alice: 搜索 ？就是遍历整个二维数组吗 ？
Bob: 也算是一种遍历，不过遍历的方法不一样。宽度优先搜索是优先搜索自己身边的元素，深度优先搜索是尽量先一条道走到黑。我还是画个图比较好理解一些。


Alice: 上面是宽度优先搜索，下面是深度优先搜索 ? 大概能理解了。那这道题应该就是二重循环遍历整个数组，如果找到一个“1”,就用DFS或者BFS找到这个小岛的其余部分，然后打上标记，就不会重复计算小岛的数目了。
Bob: 没错，我们只记录第一次找到的那个“1”，其余的用DFS或者BFS找到就可以了，打标记可以直接打在输入的二维数组里面，反正也是参数，用DFS或者BFS找到的直接修改成"0"就好了，这样还可以省内存。
Alice: 不错不错。😎😎

---

代码：
Python 方法一： BFS，队列 + 循环。

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:

        if len(grid) == 0:
            return 0

        self.matrix = []
        for x in range(len(grid)):
            tmp = []
            for z in range(len(grid[0])):
                tmp.append(int(grid[x][z]))
            self.matrix.append(tmp)
        self.rows   = len(self.matrix)
        self.clos   = len(self.matrix[0])
        # print(self.rows)
        # print(self.clos)
        # print(self.matrix)
                
        cnt     = 0
        for x in range(len(self.matrix)):
            for z in range(len(self.matrix[0])):
                if self.matrix[x][z] == 1:
                    cnt += 1
                    self.matrix[x][z] = 0
                    self.clear(x,z)
                    #print(self.matrix)

        return cnt

    def clear(self, x, z):

        directions = [[0,1],[0,-1],[-1,0],[1,0]]
        dots = [[x, z]]
        while len(dots) > 0:
            tmp = dots.pop(0)
            xx  = tmp[0]
            zz  = tmp[1]
            for direction in directions:
                tmpx = xx + direction[0]
                tmpz = zz + direction[1]
                if tmpx >= 0 and tmpx < self.rows and tmpz >= 0 and tmpz < self.clos:
                    if self.matrix[tmpx][tmpz] == 1:
                        #print("test")
                        dots.append([tmpx, tmpz])
                        self.matrix[tmpx][tmpz] = 0
        return

Java 方法一： BFS，ArrayList作为 队列 + 循环。

class Solution {
    public int numIslands(char[][] grid) {

        if(grid.length == 0){
            return 0;
        }

        int cnt  = 0;
        int rows = grid.length;
        int clos = grid[0].length; 
        int[][] directions = {{0,1},{0,-1},{1,0},{-1,0}};
        
        for(int i=0; i<grid.length; ++i){
            for(int j=0; j<grid[i].length; ++j){
                if(grid[i][j] == '1'){
                    cnt += 1;
                    grid[i][j] = 'x';
                    ArrayList<ArrayList<Integer>> dots = new ArrayList();
                    ArrayList<Integer> tmp = new ArrayList();
                    tmp.add(i);
                    tmp.add(j);
                    dots.add(tmp);
                    while(dots.isEmpty() == false){
                        int x = dots.get(0).get(0);
                        int y = dots.get(0).get(1);
                        dots.remove(0);
                        for(int[] direciton : directions){
                            int xx = x + direciton[0];
                            int yy = y + direciton[1];
                            if(xx >= 0 && xx < rows && yy >= 0 && yy < clos && grid[xx][yy] == '1'){
                                ArrayList<Integer> anotherTmp = new ArrayList();
                                anotherTmp.add(xx);
                                anotherTmp.add(yy);
                                dots.add(anotherTmp);
                                grid[xx][yy] = 'x';
                            }
                        }
                    }                 
                }
            }
        } 
        return cnt;  
    }
}

Python 方法二： DFS, 深度优先循环，递归。

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        cnt = 0
        for x in range(len(grid)):
            for y in range(len(grid[0])):
                if grid[x][y] == '1':
                    cnt += 1
                    self.dfs(grid, x, y)
                    # 清除与该点相邻的其他点
        return cnt

    def dfs(self, grid, x, y):
        if x >= 0 and x < len(grid) and y >=0 and y < len(grid[x]) and grid[x][y] == '1':
            grid[x][y] = '0'
            self.dfs(grid, x-1, y)
            self.dfs(grid, x+1, y)
            self.dfs(grid, x, y+1)
            self.dfs(grid, x, y-1)
        

Java 方法二： DFS, 递归实现深度优先搜索，反而快了不少。

class Solution {
    public int numIslands(char[][] grid) {

        int cnt = 0;
        for(int i=0; i<grid.length; ++i){
            for(int j=0; j<grid[i].length; ++j){
                if(grid[i][j] == '1'){
                    cnt ++;
                    dfs(grid, i, j);
                }
            }
        }
        return cnt;
    }
    public void dfs(char[][] grid, int x, int y){
        if(x >= 0 && x < grid.length && y >= 0 &&y < grid[x].length && grid[x][y] == '1'){
            grid[x][y] = '0';
            dfs(grid, x+1, y);
            dfs(grid, x-1, y);
            dfs(grid, x, y+1);
            dfs(grid, x, y-1);
        }
        return;
    }
}

---

易错点：

• 一些测试点：

[]
[[]]
[["1","1","1"]]
[["1","1","1"],["1","1","1"],["1","1","1"]]
[["1","1","1"],["1","0","1"],["1","1","1"]]
[["1","0","1"],["0","0","0"],["1","0","1"]]
[["1","0","1"],["0","1","0"],["1","0","1"]]
[["1","1","1","1","0"],["1","1","0","1","0"],["1","1","0","0","0"],["0","0","0","0","0"]]

• 答案：

0
0
1
1
1
4
5
1

---

总结：

• DFS要靠递归，BFS要靠队列。

---