一、题目描述：
leetcode第200题：岛屿数量
给你一个由 '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
二、思路分析：
解法1：深度优先搜索
由题可知，我们可以将二维网格看成一个无向图，竖直或水平相邻的 1 之间有边相连。 为了求出岛屿的数量，我们可以扫描整个二维网格。
- 如果一个结点包含1，则以其为起始点进行深度优先搜索。
- 在搜索过程中，每搜索到1都会被重新标记为0。 最终岛屿的数量就是我们进行深度优先搜索的次数。
复杂度分析
- 时间复杂度：O(MN)，其中M和N分别为二维网格的行数和列数。
- 空间复杂度：O(MN)，在最坏情况下，整个网格均为陆地，深度优先搜索的深度达到 MN。
解法2：广度优先搜索
我们可以使用广度优先搜索代替深度优先搜索，来优化空间复杂度。 为了求出岛屿的数量，我们可以扫描整个二维网格。
- 如果一个位置为 1，则将其加入队列，开始进行广度优先搜索。
- 在广度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。直到队列为空，搜索结束。 最终岛屿的数量就是我们进行广度优先搜索的次数。
复杂度分析
- 时间复杂度：O(MN)，其中M和N分别为二维网格的行数和列数。
- 空间复杂度：O(min(M,N))，在最坏情况下，整个网格均为陆地，队列的大小可以达到 min(M,N)。
解法3：并查集
我们也可以使用并查集代替搜索。
为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则将其与相邻四个方向上的 1 在并查集中进行合并。
最终岛屿的数量就是并查集中连通分量的数目。
复杂度分析
- 时间复杂度：O(MN×α(MN))，其中 M 和 N 分别为行数和列数。注意当使用路径压缩和按秩合并实现并查集时，单次操作的时间复杂度为 α(MN)，其中 α(x) 为反阿克曼函数，当自变量 x 的值在人类可观测的范围内（宇宙中粒子的数量）时，函数 α(x) 的值不会超过 5，因此也可以看成是常数时间复杂度。
- 空间复杂度：O(MN)，这是并查集需要使用的空间。
三、AC 代码：
深度优先搜索的代码
var numIslands = function(grid) {
let count = 0
for (let i = 0; i < grid.length; i++) {
for (let j = 0; j < grid[0].length; j++) {
if (grid[i][j] === '1') {
count++
turnZero(i, j, grid)
}
}
}
return count
};
function turnZero(i, j, grid) {
if (i < 0 || i >= grid.length || j < 0
|| j >= grid[0].length || grid[i][j] === '0') return
grid[i][j] = '0'
turnZero(i, j + 1, grid)
turnZero(i, j - 1, grid)
turnZero(i + 1, j, grid)
turnZero(i - 1, j, grid)
}
广度优先搜索的代码
var numIslands = function(grid) {
if(grid.length < 1) return 0
let m = grid.length
let n = grid[0].length
let islands = 0
for(let i = 0; i < m; i++){
for(let j = 0; j < n; j++){
if(grid[i][j] == 1){
islands++
grid[i][j] = 0 // 把查找过的项变成0 防止重新查找
let queue = []
queue.push([i, j]) // 把当前点加入队列
while(queue.length > 0){ // 当队列不为空时, 继续循环
let cur = queue.shift() // 拿出队列第一项
let x = cur[0], y = cur[1]
// 上下左右检查
if(x - 1 >= 0 && grid[x-1][y] == 1){ // 上
queue.push([x - 1, y])
grid[x - 1][y] = 0
}
if(x + 1 < m && grid[x + 1][y] == 1){ // 下
queue.push([x + 1, y])
grid[x + 1][y] = 0
}
if(y - 1 >= 0 && grid[x][y - 1] == 1){ // 左
queue.push([x, y - 1])
grid[x][y - 1] = 0
}
if(y + 1 < n && grid[x][y + 1] == 1){ // 右
queue.push([x, y + 1])
grid[x][y + 1] = 0
}
}
}
}
}
return islands;
};
并查集的代码
class UnionFind{
constructor(n){ //构造一个节点数为n的集合
this.count = n
this.parent = new Array(n)
this.size = new Array(n) // size数组记录着每棵树的重量
for (let i = 0; i < n; i++) {
this.parent[i] = i; // 自己是自己的parent
this.size[i] = 1;
}
}
union(p,q){ //连通结点p和结点q, p和q都是索引
let rootP = this.find(p);
let rootQ = this.find(q);
if(rootP === rootQ) return
// 小树接到大树下面，这样比较平衡
if (this.size[rootP] > this.size[rootQ]) {
this.parent[rootQ] = rootP;
this.size[rootP] += this.size[rootQ];
} else {
this.parent[rootP] = rootQ;
this.size[rootQ] += this.size[rootP];
}
this.count--;
}
isConnected(p, q) { //判断p,q是否连通
return this.find(p)=== this.find(q)
}
find(x) { //找到x结点的root
while (this.parent[x] != x) {
// 进行路径压缩
this.parent[x] = this.parent[this.parent[x]];
x = this.parent[x];
}
return x;
}
getCount() { //返回节点数
return this.count;
}
}
var numIslands = function(grid) {
let m = grid.length
if(m === 0) return 0
let n = grid[0].length
const dummy = m*n + 1
const dirs = [[1,0],[0,1]]
const uf = new UnionFind(m*n + 1)
for(let x=0;x<m;x++){
for(let y=0;y<n;y++)
if(grid[x][y] === '0'){
uf.union(n*x+y,dummy)
}
else if(grid[x][y] === '1'){
for(let d of dirs){
let r = x + d[0]
let c = y + d[1]
if(r>=m || c>=n) continue
if(grid[r][c] === '1'){
uf.union(n*x+y, n*r+c)
}
}
}
}
return uf.getCount() - 1 //返回并查集的个数减一就行
};
四、总结：
本题解法3并查集更符合人的逻辑思维，先将1的陆地合并成整体，最后统计岛屿的个数。
本文正在参与「掘金 3 月闯关活动」，点击查看活动详情
