题目概述:
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1：
输入：grid = [
["1","1","1","1","0"],
["1","1","0","1","0"],
["1","1","0","0","0"],
["0","0","0","0","0"]
]
输出：1
示例 2：
输入：grid = [
["1","1","0","0","0"],
["1","1","0","0","0"],
["0","0","1","0","0"],
["0","0","0","1","1"]
]
输出：3
提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 '0' 或 '1'
算法思路:
1. 深度优先搜索
- 求岛屿数量，与搜索相关。由题中所给条件：岛屿总是被水包围，可以得出DFS的结束条件：grid[row][column]=‘0’
- 依次遍历grid中的所有元素，并且进行DFS，遇到陆地时，计数器自增
- DFS中，遇到陆地(‘1’)就将陆地覆盖为水(‘0’)，出边界以及遇到水时跳出搜索
代码实现:
public void dfs(char[][] grid,int row,int column){
int rowLength = grid.length;
int columnLength = grid[0].length;
if(row >= rowLength || column >= columnLength || row < 0 || column < 0 || grid[row][column] == '0'){
return;
}
grid[row][column] = '0';
dfs(grid,row - 1,column);
dfs(grid,row + 1,column);
dfs(grid,row,column + 1);
dfs(grid,row,column - 1);
}
public int numIslands(char[][] grid) {
if(grid == null || grid.length == 0){
return -1;
}
int rowLength = grid.length;
int columnLength = grid[0].length;
int count = 0;
for(int row = 0; row < rowLength; row++){
for(int column = 0; column < columnLength; column++){
if(grid[row][column] == '1'){
count++;
}
dfs(grid,row,column);
}
}
return count;
}
复杂度分析:
- 时间复杂度：O(M*N)，其中M和N分别为行数与列数
- 空间复杂度：O(M*N)，在最坏情况下，整个网格都为陆地，深度优先搜索的深度达到M*N
2. 广度优先搜索
- 逻辑与深度优先搜索相似，当找到一个陆地时，计数器自增
- 然后进行广度优先搜索，将附近的陆地全部更新为水
- 当所有陆地都为水的时候，循环结束
分离行与列的方法:
a b c 三个数，需要将ab组合后再分离
组合:a*c + b
分离:(a*c + b)/c = a + 0
(a*c + b)%c = 0 + b
代码实现:
public int numIslands(char[][] grid) {
if(grid == null || grid.length == 0){
return 0;
}
int rowLength = grid.length;
int columnLength = grid[0].length;
int count = 0;
for(int row = 0; row < rowLength; row++){
for(int column = 0; column < columnLength; column++) {
if (grid[row][column] == '1') {
count++;
grid[row][column] = '0';
Queue<Integer> roundLand = new LinkedList<>();
roundLand.add(row * columnLength + column);
while (!roundLand.isEmpty()) {
int location = roundLand.remove();
int curRow = location / columnLength;
int curCol = location % columnLength;
if (curRow - 1 >= 0 && grid[curRow - 1][curCol] == '1') {
roundLand.add((curRow - 1) * columnLength + curCol);
grid[curRow - 1][curCol] = '0';
}
if (curRow + 1 < rowLength && grid[curRow + 1][curCol] == '1') {
roundLand.add((curRow + 1) * columnLength + curCol);
grid[curRow + 1][curCol] = '0';
}
if (curCol - 1 >= 0 && grid[curRow][curCol - 1] == '1') {
roundLand.add(curRow * columnLength + curCol - 1);
grid[curRow][curCol - 1] = '0';
}
if (curCol + 1 < columnLength && grid[curRow][curCol + 1] == '1') {
roundLand.add(curRow * columnLength + curCol + 1);
grid[curRow][curCol + 1] = '0';
}
}
}
}
}
return count;
}
复杂度分析:
-
时间复杂度：O(MN)，其中 MM 和 NN 分别为行数和列数。
-
空间复杂度：O(min(M,N))，在最坏情况下，整个网格均为陆地，队列的大小可以达到 min(M,N)
