岛屿 - 码农教程

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

示例 1:

输入:
11110
11010
11000
00000

输出: 1
示例 2:

输入:
11000
11000
00100
00011

输出: 3

var numIslands = function(grid) {
    if(grid===null || grid.length===0) return 0;
   let c = grid.length;
   let k = grid[0].length;
    let step = 0;
    for(let i=0; i<c; i++){
        for(let j=0; j<k; j++){
            if(grid[i][j]==1){
                step++
                dfs(grid, i, j)
            }
        }
    }
    function dfs(grid, i, j){
        if(i<0 || i>=c || j<0 || j>=k || grid[i][j]==0){
            return;
        }
        // 最关键
        if(grid[i][j]==1) grid[i][j] = 0;
        dfs(grid, i+1, j)
        dfs(grid, i-1, j)
        dfs(grid, i, j+1)
        dfs(grid, i, j-1)
    }
    return step
};

/**
 * @param {character[][]} grid
 * @return {number}
 */
var numIslands = function(grid) {
    if(grid===null || grid.length===0) return 0;
    let c = grid.length;
    let k = grid[0].length;
    let res = 0;
    let list = [];
    for(let i=0; i<c; i++){
        for(let j=0; j<k; j++){
            if(grid[i][j] == 1){
                res ++;
                grid[i][j] = 0;
                list.push([i, j])
               while(list.length){
                   let [i, j] = list.shift();
                    if(i-1>=0 && grid[i-1][j]==1) {
                        list.push([i-1, j]);
                        grid[i-1][j] = 0;                   
                    }
                   if(i+1<c && grid[i+1][j]==1) {
                        list.push([i+1, j]);
                        grid[i+1][j] = 0;                   
                    }
                   if(j-1>=0 && grid[i][j-1]==1) {
                        list.push([i, j-1]);
                        grid[i][j-1] = 0;                   
                    }
                   if(j+1<k && grid[i][j+1]==1) {
                        list.push([i, j+1]);
                        grid[i][j+1] = 0;                   
                    }
                }   
            }
        }
    }
    return res
};

有一个二维矩阵 grid ，每个位置要么是陆地（记号为 0 ）要么是水域（记号为 1 ）。

我们从一块陆地出发，每次可以往上下左右 4 个方向相邻区域走，能走到的所有陆地区域，我们将其称为一座「岛屿」。

如果一座岛屿完全由水域包围，即陆地边缘上下左右所有相邻区域都是水域，那么我们将其称为「封闭岛屿」。

请返回封闭岛屿的数目。

示例 1：

输入：grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
输出：2
解释：
灰色区域的岛屿是封闭岛屿，因为这座岛屿完全被水域包围（即被 1 区域包围）。

示例 2：

输入：grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
输出：1

示例 3：

输入：grid = [[1,1,1,1,1,1,1],
             [1,0,0,0,0,0,1],
             [1,0,1,1,1,0,1],
             [1,0,1,0,1,0,1],
             [1,0,1,1,1,0,1],
             [1,0,0,0,0,0,1],
             [1,1,1,1,1,1,1]]
输出：2

提示：

1 <= grid.length, grid[0].length <= 100
0 <= grid[i][j] <=1

// 这是我写的，死循环

const goto=(i, j, grid, flag)=>{
if(i<0 || j<0 || i>grid.length-1 || j>grid[0].length-1){
return;
}
if(grid[i][j]===1){
flag++;
return;
}

// 会在下面2个地方死循环
goto(i+1, j, grid, flag);
goto(i-1, j, grid, flag)
goto(i, j+1, grid, flag)
goto(i, j-1, grid, flag)
if(flag===4){
return true
}else{
return false
}
}
var closedIsland = function(grid) {
let count = 0, flag = 0;
for(let i=0; i<grid.length; i++){
let grid1 = grid[i];
for(let j=0; j<grid1.length; j++){
let item = grid1[j];
if(item === 0){
let res = goto(i, j, grid, flag);
if(res) count++
}
}
}
return count;
};

/**
 * @param {number[][]} grid
 * @return {number}
 */
const dx = [0, 1, 0, -1]
const dy = [1, 0, -1, 0]
var closedIsland = function(grid) {
    function bfs(x, y) {
        let flag = true
        const que = [[x, y]]
        while(que.length !== 0) {
            const [x, y] = que.shift()
            if (x === 0 || x === grid.length - 1 || y === 0 || y === grid[0].length - 1) flag = false
            for(let i = 0; i < 4; i++) {
                const xx = dx[i] + x
                const yy = dy[i] + y
                if (xx < 0 || xx >= grid.length) continue
                if (yy < 0 || yy >= grid[0].length) continue
                if (grid[xx][yy] === 0) {
                    que.push([xx, yy])
                    grid[xx][yy] = 1
                    if (xx === 0 || xx === grid.length - 1 || yy === 0 || yy === grid[0].length - 1) flag = false
                }
            }
        }
        // console.log(flag)
        if (flag) return 1
        return 0
    }
    let ans = 0
    for(let i = 0; i < grid.length; i++) {
        for(let j = 0; j < grid[i].length; j++) {
            if (grid[i][j] === 0) {
                ans += bfs(i, j)
                // console.log(i, j)
            }
        }
    }
    return ans
};

/**
 * @param {number[][]} grid
 * @return {number}
 */
var closedIsland = function(grid) {
    let result = 0;
    var dfs = function(x, y) {
        grid[x][y] = 1;
        let r = 1;
        if (x === 0) {
            r = 0;
        } else if (grid[x - 1][y] === 0 && dfs(x - 1, y) === 0) {
            r = 0;
        }
        if (y === 0) {
            r = 0;
        } else if (grid[x][y - 1] === 0 && dfs(x, y - 1) === 0) {
            r = 0;
        }
        if (x === grid.length - 1) {
            r = 0;
        } else if (grid[x + 1][y] === 0 && dfs(x + 1, y) === 0) {
            r = 0;
        }
        if (y === grid[0].length - 1) {
            r = 0;
        } else if (grid[x][y + 1] === 0 && dfs(x, y + 1) === 0) {
            r = 0;
        }
        return r;
    }
    for (let i = 0; i < grid.length; i++) {
        for (let j = 0; j < grid[i].length; j++) {
            if (grid[i][j] === 0) {
                result += dfs(i, j);
            }
        }
    }
    return result;
};

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-islands
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

原文地址：https://www.cnblogs.com/zhangzs000/p/11830885.html