算法--岛屿数量

)

题目

描述
给一个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]]
复制
返回值：
3
复制
示例2
输入：
[[0]]
复制
返回值：
0
复制
示例3
输入：
[[1,1],[1,1]]
复制
返回值：
1
复制
备注：
01矩阵范围<=200*200

解题答案

java

package net.test.app.liko;

import static org.apache.hadoop.yarn.webapp.hamlet.HamletSpec.Media.print;
import static sun.misc.Version.print;

/**
 * @author dpx
 * @date 2023/8/21 9:57
 * @Version 1.0
 */
public class SolutionDaoYu {
    public static void main(String[] args) {
        char[][] arr1 = {{'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'}};

        char[][] arr = new char[5][5];

        arr[0] = new char[]{'1', '1', '0', '0', '0'};
        arr[1] = new char[]{'0', '1', '0', '1', '1'};
        arr[2] = new char[]{'0', '0', '0', '1', '1'};
        arr[3] = new char[]{'0', '0', '0', '0', '0'};
        arr[4] = new char[]{'0', '0', '1', '1', '1'};

        System.out.println(SolutionDaoYu.solve(arr));
    }

    public static int solve(char[][] grid) {
        // 边界条件判断
        if (grid == null || grid.length == 0) return 0;
        // 统计孤岛的个数
        int count = 0;
        // 两个for循环遍历每一个格子
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                //只有当前格子是1才开始计算
                if (grid[i][j] == '1') {
                    // 如果当前格子是1, 岛屿的数量加1
                    count++;
                    // 然后通过dfs把当前格子的上下左右4个位置都置为0, 连着的算一个岛屿
                    dfs(grid, i, j);
                }
            }
        }
        // 返回岛屿的数量
        return count;
    }

    // 将矩阵中当前格子以及其它临近的为1的格子都会置为1
    public static void dfs(char[][] grid, int i, int j) {
        // 边界条件判断, 不能越界
        if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') return;
        // 把当前格子置为0, 然后从他的上下左右四个方向继续遍历
        grid[i][j] = '0';
        dfs(grid, i - 1, j); // 上
        dfs(grid, i + 1, j); // 下
        dfs(grid, i, j - 1); // 左
        dfs(grid, i, j + 1); // 右
    }


}

scala

package net.clickwifi.app.test.liKo

/**
 * @author dpx
 * @date 2023/8/16 11:11
 * @Version 1.0
 *
 */
object SolutionDaoYu {
  /**
   * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
   *
   * 判断岛屿数量
   *
   * @param grid char字符型二维数组
   * @return int整型
   */
  def main(args: Array[String]): Unit = {

    val grid: Array[Array[Char]] = Array(
      Array('1', '1', '0', '0', '0'),
      Array('0', '1', '0', '1', '1'),
      Array('0', '0', '0', '1', '1'),
      Array('0', '0', '0', '0', '0'),
      Array('0', '0', '1', '1', '1')
    )

    println(solve(grid))
  }

  def solve(grid: Array[Array[Char]]): Int = {
    val n = grid.length
    //空矩阵的情况
    if (n == 0) return 0
    val m = grid(0).length
    //记录岛屿数
    var count = 0
    //遍历矩阵
    for (i <- 0 until n) {
      for (j <- 0 until m) {
        //遍历到1的情况
        if (grid(i)(j) == '1') {
          //计数
          count += 1
          //将与这个1相邻的所有1置为0
          dfs(grid, i, j)
        }
      }
    }
    return count
  }

  //深度 优先遍历与i,j相邻的所有1
  def dfs(grid: Array[Array[Char]], i: Int, j: Int): Unit = {
    val n = grid.length
    val m = grid(0).length
    // 置为0
    grid(i)(j) = '0'
    //后续四个方向遍历
    if (i - 1 >= 0 && grid(i - 1)(j) == '1') dfs(grid, i - 1, j)
    if (i + 1 < n && grid(i + 1)(j) == '1') dfs(grid, i + 1, j)
    if (j - 1 >= 0 && grid(i)(j - 1) == '1') dfs(grid, i, j - 1)
    if (j + 1 < m && grid(i)(j + 1) == '1') dfs(grid, i, j + 1)
  }
}