本文已参与「新人创作礼」活动，一起开启掘金创作之路。
1.题目描述
给你一个由 '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'
来源：力扣（LeetCode）
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
2.题解
2.1 深度优先搜索（DFS）
2.1.1 思路
DFS除了用递归就是用栈，这道题用递归会好写很多。
思路就是从第一个‘1’开始，深度遍历上下左右四个方向，从这四个方向再继续向四周遍历。
只要能遍历到的值为‘1’的位置，就将值改为‘0’，这样下次遍历就不会再遍历到了。
然后在原函数能遍历到的‘1’的值都是所谓的‘岛屿’，这个数目之和就是答案。
2.1.2 Java代码
class Solution {
public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) {
return 0;
}
int numr = grid.length,numc = grid[0].length;
int ans = 0 ;
for(int i=0;i<numr;i++){
for(int j =0;j<numc;j++){
if(grid[i][j]=='1'){
dfs(grid,i,j);
ans++;
}
}
}
return ans;
}
void dfs(char[][]grid, int row,int column){
int numr = grid.length,numc = grid[0].length;
if(grid[row][column]=='0'){
return;
}
grid[row][column] = '0';
if(row-1>=0){
dfs(grid,row-1,column);
}
if(row+1<numr){
dfs(grid,row+1,column);
}
if(column-1>=0){
dfs(grid,row,column-1);
}
if(column+1<numc){
dfs(grid,row,column+1);
}
}
}
2.2 广度优先搜索（BFS）
2.2.1 思路
BFS肯定需要用到队列。这道题看起来代码很多，但其实思路不是很复杂就是单纯代码多。
思路肯定也是遍历，但是DFS的遍历是用递归来直接遍历四周的点，BFS的遍历用队列先存储要遍历的四周的点，通过while来遍历。
第一个点先存进去，再将第一个点的四周为‘1’的点存进去，再通过while取出来存进去的第二个点，依次往下遍历。
一个while结束了就说明这一个“岛屿”全部遍历完了，然后通过外面的两个for循环，继续找下一个“岛屿”进行遍历。
2.2.2 Java代码
class Solution {
public int numIslands(char[][] grid) {
if(grid == null || grid.length == 0){
return 0;
}
int numr = grid.length,numc = grid[0].length;
int ans = 0;
for(int i =0;i<numr;i++){
for(int j=0;j<numc;j++){
if(grid[i][j] == '1'){
ans++;
grid[i][j] = '0';
List<Integer> queue = new ArrayList<Integer>();
queue.add(i*numc +j);
while(!queue.isEmpty()){
int position = queue.remove(0);
int row = position/numc;
int column = position%numc;
if(row-1>=0&&grid[row-1][column]=='1'){
grid[row-1][column]='0';
queue.add((row-1)*numc+column);
}
if(row+1<numr&&grid[row+1][column]=='1'){
grid[row+1][column] = '0';
queue.add((row+1)*numc+column);
}
if(column-1>=0&&grid[row][column-1]=='1'){
grid[row][column-1] ='0';
queue.add(position-1);
}
if(column+1<numc&&grid[row][column+1]=='1'){
grid[row][column+1] = '0';
queue.add(position+1);
}
}
}
}
}
return ans;
}
}
2.3 并查集
2.3.1 思路
并查集忘光了/(ㄒoㄒ)/~~，先复习了一下。 再贴油管上的讲解,这个博主讲的很清楚。
难点在于并查集的实现，如果会写并查集了，题目要求的函数其实和DFS差不多。
如果复习或者学会了并查集，就知道除了初始化，并查集还需要些查找（Find）和合并（Union）操作。
而本题的并查集是这样实现的：
-
初始化：首先对一整个grid遍历，将所有值为‘1’的点都作为一个单独的节点，存在parent[]里，而rank[]也就是秩数组也全都设为0。同时与其他的并查集相比还增加了一个count,用来记录‘岛屿’也就是集合的个数。现在的岛屿个数当然是所有为‘1’的节点的个数。
-
查找（Find）：查找是用来查找节点的parent，find只需要通过parent[]查找就行。
-
合并（Union）：合并操作是用来合并集合，在这里也可以看成合并节点的。并查集的合并首先要找到两个点的parent节点，对两个parent节点进行合并。代码里用到了秩，也就是把秩小的parent节点接到秩大的parent节点上（认贼作父）。两个集合就合并了。
并查集建立好了，就可以通过遍历grid，将上下左右的点通过union合并到一起了。最后拿一下count就行。 贴一下官方题解的。
2.3.2 Java代码
class Solution {
class UnionFind {
int count;
int[] parent;
int[] rank;
public UnionFind(char[][] grid) {
count = 0;
int m = grid.length;
int n = grid[0].length;
parent = new int[m * n];
rank = new int[m * n];
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (grid[i][j] == '1') {
parent[i * n + j] = i * n + j;
++count;
}
rank[i * n + j] = 0;
}
}
}
public int find(int i) {
if (parent[i] != i) parent[i] = find(parent[i]);
return parent[i];
}
public void union(int x, int y) {
int rootx = find(x);
int rooty = find(y);
if (rootx != rooty) {
if (rank[rootx] > rank[rooty]) {
parent[rooty] = rootx;
} else if (rank[rootx] < rank[rooty]) {
parent[rootx] = rooty;
} else {
parent[rooty] = rootx;
rank[rootx] += 1;
}
--count;
}
}
public int getCount() {
return count;
}
}
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;
UnionFind uf = new UnionFind(grid);
for (int r = 0; r < nr; ++r) {
for (int c = 0; c < nc; ++c) {
if (grid[r][c] == '1') {
grid[r][c] = '0';
if (r - 1 >= 0 && grid[r-1][c] == '1') {
uf.union(r * nc + c, (r-1) * nc + c);
}
if (r + 1 < nr && grid[r+1][c] == '1') {
uf.union(r * nc + c, (r+1) * nc + c);
}
if (c - 1 >= 0 && grid[r][c-1] == '1') {
uf.union(r * nc + c, r * nc + c - 1);
}
if (c + 1 < nc && grid[r][c+1] == '1') {
uf.union(r * nc + c, r * nc + c + 1);
}
}
}
}
return uf.getCount();
}
}
