代码随想录算法训练营第 51 天 | 101. 孤岛的总面积、102. 沉没孤岛、103. 高山流水、104. 建造最大岛屿

原创已于 2025-11-30 23:52:37 修改 · 1k 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #java #图 #dfs #数据结构

于 2025-11-30 23:40:14 首次发布

算法训练营专栏收录该内容

53 篇文章

订阅专栏

101. 孤岛的总面积

题目链接

注意：题目要求的是孤岛总面积而不是孤岛个数。

思路：
遍历第一行、最后一行、第一列、最后一列。遇到陆地就将它相邻的所有陆地都标记为 0（省去 visited 数组）。最后统计 grid 有多少个 1。

方法一：
dfs

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        for (int i = 0; i < n; i++) { // 第一列和最后一列
            if (grid[i][0] == 1) {
                dfs(grid, i, 0);
            }
            if (grid[i][m - 1] == 1) {
                dfs(grid, i, m - 1);
            }
        }

        for (int i = 0; i < m; i++) { // 第一行和最后一行
            if (grid[0][i] == 1) {
                dfs(grid, 0, i);
            }
            if (grid[n - 1][i] == 1) {
                dfs(grid, n - 1, i);
            }
        }

        int result = 0;
        for (int i = 0; i < n; i++) { // 统计剩余孤岛陆地面积
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) {
                    result++;
                }
            }
        }
        System.out.println(result);
    }

    public static void dfs(int[][] grid, int x, int y) {
        grid[x][y] = 0; // 进入 dfs 后，把陆地赋值为 0 变为海洋

        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
            if (grid[nextX][nextY] == 1) { // 必须是陆地才 dfs
                dfs(grid, nextX, nextY);
            }
        }
    }
}

方法二：
bfs

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        for (int i = 0; i < n; i++) { // 第一列和最后一列
            if (grid[i][0] == 1) {
                bfs(grid, i, 0);
            }
            if (grid[i][m - 1] == 1) {
                bfs(grid, i, m - 1);
            }
        }

        for (int i = 0; i < m; i++) { // 第一行和最后一行
            if (grid[0][i] == 1) {
                bfs(grid, 0, i);
            }
            if (grid[n - 1][i] == 1) {
                bfs(grid, n - 1, i);
            }
        }

        int result = 0;
        for (int i = 0; i < n; i++) { // 统计剩余孤岛陆地面积
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) {
                    result++;
                }
            }
        }
        System.out.println(result);
    }

    public static void bfs(int[][] grid, int x, int y) {
        Queue<int[]> queue = new ArrayDeque<>();
        queue.offer(new int[] {x, y});
        grid[x][y] = 0; // 加入队列后，把陆地变海洋

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            for (int i = 0; i < 4; i++) {
                int nextX = dir[i][0] + cur[0];
                int nextY = dir[i][1] + cur[1];
                
                if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                    continue;
                }
                
                if (grid[nextX][nextY] == 1) {
                    queue.offer(new int[] {nextX, nextY});
                    grid[nextX][nextY] = 0; // 加入队列后，把陆地变海洋
                }
            }
        }
    }
}

102. 沉没孤岛

题目链接

思路：
同上题。只不过把“陆地 1 变为海洋 0”改为“陆地 1 变成中间状态 2”。最后再把 1 变为 0，把 2 变为 1。

易错点：
必须先把 1 变为 0，再把 2 变为 1，否则会覆盖导致数组全为 0

方法一：
dfs

import java.util.*;

public class Main2 {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        for (int i = 0; i < n; i++) { // 第一列和最后一列
            if (grid[i][0] == 1) {
                dfs(grid, i, 0);
            }
            if (grid[i][m - 1] == 1) {
                dfs(grid, i, m - 1);
            }
        }

        for (int i = 0; i < m; i++) { // 第一行和最后一行
            if (grid[0][i] == 1) {
                dfs(grid, 0, i);
            }
            if (grid[n - 1][i] == 1) {
                dfs(grid, n - 1, i);
            }
        }

        // 更改网格内容
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) { // 将 1 变为 0（必须先把 1 变为 0，再把 2 变为 1，否则会覆盖导致数组全为 0）
                    grid[i][j] = 0;
                }
                if (grid[i][j] == 2) { // 将 2 变为 1
                    grid[i][j] = 1;
                }
            }
        }

        // 输出网格
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(grid[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void dfs(int[][] grid, int x, int y) {
        grid[x][y] = 2; // 进入 dfs 后，把陆地赋值为 2

        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
            if (grid[nextX][nextY] == 1) { // 必须是陆地才 dfs
                dfs(grid, nextX, nextY);
            }
        }
    }
}

方法二：
bfs

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        for (int i = 0; i < n; i++) { // 第一列和最后一列
            if (grid[i][0] == 1) {
                bfs(grid, i, 0);
            }
            if (grid[i][m - 1] == 1) {
                bfs(grid, i, m - 1);
            }
        }

        for (int i = 0; i < m; i++) { // 第一行和最后一行
            if (grid[0][i] == 1) {
                bfs(grid, 0, i);
            }
            if (grid[n - 1][i] == 1) {
                bfs(grid, n - 1, i);
            }
        }

        // 更改网格内容
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) { // 将 1 变为 0（必须先把 1 变为 0，再把 2 变为 1，否则会覆盖导致数组全为 0）
                    grid[i][j] = 0;
                }
                if (grid[i][j] == 2) { // 将 2 变为 1
                    grid[i][j] = 1;
                }
            }
        }

        // 输出网格
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(grid[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void bfs(int[][] grid, int x, int y) {
        Queue<int[]> queue = new ArrayDeque<>();
        queue.offer(new int[] {x, y});
        grid[x][y] = 2; // 把陆地变为状态 2

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            for (int i = 0; i < 4; i++) {
                int nextX = dir[i][0] + cur[0];
                int nextY = dir[i][1] + cur[1];

                if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                    continue;
                }

                if (grid[nextX][nextY] == 1) {
                    queue.offer(new int[] {nextX, nextY});
                    grid[nextX][nextY] = 2; // 把陆地变为状态 2
                }
            }
        }
    }
}

103. 高山流水

题目链接

暴力时间复杂度：O(n * m * n * m)

优化方法
思路：

不要从高往低流，而是从边界出发从低往高流。
设置两个 visited[][] 数组，一个 firstBorder[][] 表示从左边和上边边界能流到的格子，一个 secondBorder[][] 表示从右边和下边边界能流到的格子。
最后统计 firstBorder[][] 和 secondBorder[][] 都为 true 的格子。

时间复杂度：
看似是 $O (2 * (n + m) * n * m) = O ((n + m) * n * m)$
实际为 $O (2 * n * m) = O (n * m)$
因为每个格子只会被 firstBorder 和 secondBorder 各访问一次。被标记为 true 的节点不会再次访问。

代码以 dfs 为例：

import java.util.Scanner;

public class Main {
    static int[][] dir = new int[][] {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};


    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        boolean[][] firstBoarder = new boolean[n][m]; // 左边和上边的边界
        boolean[][] secondBoarder = new boolean[n][m]; // 右边和下边的边界

        for (int i = 0; i < n; i++) { // 第一列和最后一列
            dfs(grid, firstBoarder, i, 0); // 左边
            dfs(grid, secondBoarder, i, m - 1); // 右边
        }

        for (int j = 0; j < m; j++) { // 第一行和最后一行
            dfs(grid, firstBoarder, 0, j); // 上边
            dfs(grid, secondBoarder,n - 1, j); // 下边
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (firstBoarder[i][j] && secondBoarder[i][j]) { // 两个边界都能逆序流的格子就是题目要求值
                    System.out.println(i + " " + j);
                }
            }
        }
    }

    public static void dfs (int[][] grid, boolean[][] visited, int x, int y) {
        if (visited[x][y]) {
            return;
        }
        visited[x][y] = true; // 标记为 true

        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;

            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }

            if (grid[nextX][nextY] >= grid[x][y]) {
                dfs(grid, visited, nextX, nextY);
            }
        }
    }
}

104. 建造最大岛屿

题目链接

暴力方法：每个海洋都尝试变成陆地，然后统计最大岛屿面积。
时间复杂度：O(n * m * n * m)

优化方法
思路：

先统计出每块岛屿面积，用 Map 保存。
（需要给岛屿编号并染色。编号从 2 开始，因为 1 表示陆地。染色在 dfs 中进行。）
对每块海洋，尝试与它上下左右的格子相连成为更大陆地，计算变大后的陆地面积。
（需要设置一个 Set，避免重复加了某块大陆的面积，如下图所示。）
（此时 grid 中已经没有 1，都被染色。）

在这里插入图片描述

在上面这个过程中求出最大的陆地面积。

易错点：

需要判断上下左右格子是否越界、为海洋、已经在 Set 里重复添加。
要考虑到没有海洋的情况，解决办法：result 设置为岛屿面积最大值。

时间复杂度：
$O (n * m)$

代码以 dfs 为例：dfs 很简单，主函数有点复杂。

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
    public static int count; // 统计单块区域面积

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        boolean[][] visited = new boolean[n][m];
        int maxCount = 0; // 最大岛屿面积
        HashMap<Integer, Integer> map = new HashMap<>();
        int mark = 2; // 大陆编号从 2 开始

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    count = 0;
                    dfs(grid, visited, i, j, mark);
                    maxCount = Math.max(maxCount, count); // 求最大岛屿面积
                    map.put(mark, count); // 把每块大陆面积保存到 map
                    mark++; // mark 要 ++
                }
            }
        }

        int result = maxCount; // 把 result 设置为已有岛屿的最大面积，防止出现没有海洋的情况

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 0) {
                    HashSet<Integer> number = new HashSet<>(); // 用于判断大陆面积有没有重复加。4 个方向判断完，刚好在这里初始化
                    int square = 1; // 初始面积包括它自身，所以设为 1
                    for (int k = 0; k < 4; k++) {
                        int nearX = dir[k][0] + i;
                        int nearY = dir[k][1] + j;

                        // 越界
                        if (nearX < 0 || nearX >= n || nearY < 0 || nearY >= m) {
                            continue;
                        }

                        mark = grid[nearX][nearY]; // 大陆的编号

                        // 相邻格子不是大陆
                        if (mark == 0) {
                            continue;
                        }

                        // 已经添加过该大陆
                        if (number.contains(mark)) {
                            continue;
                        }

                        square += map.get(mark);
                        number.add(mark); // 别忘添加到 set
                    }
                    result = Math.max(result, square); // 求最值
                }
            }
        }

        System.out.println(result);
    }

    public static void dfs(int[][] grid, boolean[][] visited, int x, int y, int mark) {
        if (grid[x][y] == 0 || visited[x][y]) {
            return;
        }
        count++;
        visited[x][y] = true;
        grid[x][y] = mark; // 染色

        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
            dfs(grid, visited, nextX, nextY, mark);
        }
    }
}