BM57 岛屿数量

描述

给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。

岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。

例如：

输入

[

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

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

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

[0,0,0,0,0],

[0,0,1,1,1]

]

对应的输出为3

(注：存储的01数据其实是字符'0','1')

示例1

输入：

[[1,1,0,0,0],[0,1,0,1,1],[0,0,0,1,1],[0,0,0,0,0],[0,0,1,1,1]]
  • 1.

返回值：

3
  • 1.

示例2

输入：

[[0]]
  • 1.

返回值：

0
  • 1.


Java代码：

import java.util.*;
public class Solution {
    public int solve (char[][] grid) {
        int count = 0;
        for (int i = 0; i < grid.length; i ++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == '1') {
                    fun(grid, i, j);
                    count ++;
                }
            }
        }
        return count;
    }

    void fun(char[][] grid, int h, int w) {
        if (grid[h][w] == '0') return;
        grid[h][w] = '0';
        if (h < grid.length - 1) fun(grid, h + 1, w);
        if (h > 0) fun(grid, h - 1, w);
        if (w < grid[0].length - 1) fun(grid, h, w + 1);
        if (w > 0) fun(grid, h, w - 1);
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
import java.util.*;

public class Solution {
    // 不想多传值，所以增加的全局变量
    int lengthX;
    int lengthY;
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 判断岛屿数量
     * @param grid char字符型二维数组
     * @return int整型
     */
    public int solve (char[][] grid) {
        // write code here
        int count = 0;
        lengthX = grid.length;
        lengthY = grid[0].length;
        for (int j = 0; j < lengthY; j++) {
            for (int i = 0; i < lengthX; i++) {
                if (grid[i][j] ==  '1') {
                    // 改变为0，表示已经算过了，下次不要再进入
                    grid[i][j] = '0';
                    // 向四周递归遍历，只有四周都为0才会返回true，以为之前将自身已经改为0了，所以没有影响
                    if (findNext(i + 1, j, grid)
                            && findNext(i - 1, j, grid)
                            && findNext(i, j + 1, grid)
                            && findNext(i, j - 1, grid)) {
                        count++;
                    }
                }
            }
        }
        return count;
    }

    private boolean findNext(int x, int y, char[][] grid) {
        if (x == lengthX || y == lengthY || x < 0 || y < 0) {
            return true;
        }
        if (grid[x][y] == '0') {
            return true;
        } else {
            // 改变为0，表示已经算过了，下次不要再进入
            grid[x][y] = '0';
            // 向四周递归遍历，只有四周都为0才会返回true，以为之前将自身已经改为0了，所以没有影响
            return (findNext(x + 1, y, grid)
                    && findNext(x - 1, y, grid)
                    && findNext(x, y + 1, grid)
                    && findNext(x, y - 1, grid));
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.