Day51--图论--99. 岛屿数量（卡码网），100. 岛屿的最大面积（卡码网）

最新推荐文章于 2025-08-13 20:17:14 发布
原创 最新推荐文章于 2025-08-13 20:17:14 发布 · 207 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#图论 #深度优先搜索 #广度优先搜索 #深搜 #广搜 #岛屿数量 #岛屿的最大面积

Day51–图论–99. 岛屿数量（卡码网），100. 岛屿的最大面积（卡码网）

本篇重点，在于理解深搜和广搜遍历顺序的不同，以及深搜广搜对应的坑点。

给出了打印遍历顺序的代码，可以打印出来遍历点直观感受一下。

可以看到，DFS就是不撞南墙不回头；BFS就是像水波纹一样一层一层荡漾开来。

99. 岛屿数量（卡码网）

方法：深搜

思路：

本题思路，是遇到一个没有遍历过的陆地，计数器就加一，然后把该节点所能遍历到的陆地都标记上。

在遇到标记过的陆地节点或海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。

import java.util.*;

public class Main {

    // 四个方向：右、下、左，上
    private static final int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    private static void dfs(int[][] grid, boolean[][] visited, int x, int y) {

        // 四个方向都遍历一遍
        for (int i = 0; i < 4; i++) {
            int nextX = x + dir[i][0];
            int nextY = y + dir[i][1];

            // 检查是否越界
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }

            // 如果未访问且是陆地(1)，则继续DFS
            if (!visited[nextX][nextY] && grid[nextX][nextY] == 1) {
                visited[nextX][nextY] = true;
                dfs(grid, visited, nextX, nextY);
            }
        }
    }

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

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

        // 访问标记数组
        boolean[][] visited = new boolean[n][m];
        // 计数器
        int count = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 发现未访问的陆地，岛屿数量加1，并开始DFS标记所有相连的陆地
                if (!visited[i][j] && grid[i][j] == 1) {
                    visited[i][j] = true;
                    count++;
                    dfs(grid, visited, i, j);
                }
            }
        }

        System.out.println(count);
        in.close();
    }
}

遍历顺序：

DFS访问顺序:
 1  2  0  0  0 
 4  3  0  0  0 
 0  0  5  0  0 
 0  0  0  6  7

方法：广搜

思路：

只要加入队列就代表走过，就需要标记，而不是从队列拿出来的时候再去标记走过。

import java.util.*;

public class Main {

    // 四个方向：右、下、左，上
    private static final int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    // 广搜
    private static void bfs(int[][] grid, boolean[][] visited, int x, int y) {

        Deque<int[]> que = new ArrayDeque<>();

        // 存储节点坐标
        que.offer(new int[] {x, y});
        // 加入队列后立即标记为已访问
        visited[x][y] = true;

        while (!que.isEmpty()) {
            int[] cur = que.poll();
            int curX = cur[0];
            int curY = cur[1];

            // 四个方向都遍历一遍
            for (int i = 0; i < 4; i++) {
                int nextX = curX + dir[i][0];
                int nextY = curY + dir[i][1];

                // 检查是否越界
                if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                    continue;
                }

                // // 如果是未访问的陆地，则加入队列并标记
                if (!visited[nextX][nextY] && grid[nextX][nextY] == 1) {
                    que.offer(new int[] {nextX, nextY});
                    visited[nextX][nextY] = true;
                }
            }
        }
    }

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

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

        // 访问标记数组
        boolean[][] visited = new boolean[n][m];
        // 计数器
        int count = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 发现未访问的陆地，岛屿数量加1，并开始BFS标记所有相连的陆地
                if (!visited[i][j] && grid[i][j] == 1) {
                    count++;
                    bfs(grid, visited, i, j);
                }
            }
        }

        System.out.println(count);
        in.close();
    }
}

遍历顺序：

DFS访问顺序:
 1  2  0  0  0 
 4  3  0  0  0 
 0  0  5  0  0 
 0  0  0  6  7 
BFS访问顺序:
 1  2  0  0  0 
 3  4  0  0  0 
 0  0  5  0  0 
 0  0  0  6  7

遍历顺序打印

思路：

可以复制代码，修改代码中的矩阵，打印出来，直观看看每一步都是怎么走的。

import java.util.LinkedList;
import java.util.Queue;

public class TraversalOrder {
    // 四个方向：右、下、左，上
    private static final int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    private static int count;
    
    // DFS遍历并记录访问顺序
    private static void dfs(int[][] grid, int[][] order, int x, int y) {
        for (int i = 0; i < 4; i++) {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            
            if (nextx >= 0 && nextx < grid.length && nexty >= 0 && nexty < grid[0].length) {
                if (grid[nextx][nexty] == 1 && order[nextx][nexty] == 0) {
                    count++;
                    order[nextx][nexty] = count;
                    dfs(grid, order, nextx, nexty);
                }
            }
        }
    }
    
    // BFS遍历并记录访问顺序
    private static void bfs(int[][] grid, int[][] order, int x, int y) {
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{x, y});
        count++;
        order[x][y] = count;
        
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int curx = cur[0];
            int cury = cur[1];
            
            for (int i = 0; i < 4; i++) {
                int nextx = curx + dir[i][0];
                int nexty = cury + dir[i][1];
                
                if (nextx >= 0 && nextx < grid.length && nexty >= 0 && nexty < grid[0].length) {
                    if (grid[nextx][nexty] == 1 && order[nextx][nexty] == 0) {
                        count++;
                        order[nextx][nexty] = count;
                        queue.offer(new int[]{nextx, nexty});
                    }
                }
            }
        }
    }
    
    // 打印访问顺序矩阵
    private static void printOrder(int[][] order) {
        for (int i = 0; i < order.length; i++) {
            for (int j = 0; j < order[0].length; j++) {
                System.out.printf("%2d ", order[i][j]);
            }
            System.out.println();
        }
    }
    
    public static void main(String[] args) {
        // 初始化给定的矩阵
        int[][] grid = {
            {1, 1, 1, 1, 1},
            {1, 1, 1, 1, 1},
            {1, 1, 1, 1, 1},
            {1, 1, 1, 1, 1},
            {1, 1, 1, 1, 1}
        };
        int n = grid.length;
        int m = grid[0].length;
        
        // 演示DFS访问顺序
        System.out.println("DFS访问顺序:");
        int[][] dfsOrder = new int[n][m];
        count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && dfsOrder[i][j] == 0) {
                    count++;
                    dfsOrder[i][j] = count;
                    dfs(grid, dfsOrder, i, j);
                }
            }
        }
        printOrder(dfsOrder);
        
        // 演示BFS访问顺序
        System.out.println("\nBFS访问顺序:");
        int[][] bfsOrder = new int[n][m];
        count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && bfsOrder[i][j] == 0) {
                    bfs(grid, bfsOrder, i, j);
                }
            }
        }
        printOrder(bfsOrder);
    }
}

目前代码打印效果

DFS访问顺序:
1  2  3  4  5 
22 23 24 25  6 
21 20 19 18  7 
14 15 16 17  8 
13 12 11 10  9 
BFS访问顺序:
1  2  4  7 11 
3  5  8 12 16 
6  9 13 17 20 
10 14 18 21 23 
15 19 22 24 25

可以看到，DFS就是不撞南墙不回头；BFS就是像水波纹一样一层一层荡漾开来。

100. 岛屿的最大面积（卡码网）

方法：深搜

思路：

在dfs递归的时候统计，每一层递归向上返回本次遍历到的岛屿数。

主函数里的循环，每次都是遇到一个新的岛屿，所以在主函数里，dfs回来之后，刷新maxLand。

import java.util.*;

public class Main {

    // 四个方向：右、下、左，上
    private static final int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    private static int dfs(int[][] grid, boolean[][] visited, int x, int y) {

        // 坐标为x,y的本节点
        int sum = 1;

        // 四个方向都遍历一遍
        for (int i = 0; i < 4; i++) {
            int nextX = x + dir[i][0];
            int nextY = y + dir[i][1];

            // 检查是否越界
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }

            // 如果未访问且是陆地(1)，则继续DFS
            if (!visited[nextX][nextY] && grid[nextX][nextY] == 1) {
                visited[nextX][nextY] = true;
                // 加上从这个节点出发，深搜到的所有节点
                sum += dfs(grid, visited, nextX, nextY);
            }
        }
        // 返回给上一层
        return sum;
    }

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

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

        // 访问标记数组
        boolean[][] visited = new boolean[n][m];
        int maxLand = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 发现未访问的陆地，岛屿数量加1，并开始DFS标记所有相连的陆地
                if (!visited[i][j] && grid[i][j] == 1) {
                    visited[i][j] = true;
                    // 每次从这里进去的，是一整个岛屿
                    int land = dfs(grid, visited, i, j);
                    // 刷新最大岛屿面积
                    maxLand = Math.max(maxLand, land);
                }
            }
        }

        System.out.println(maxLand);
        in.close();
    }
}

方法：深搜

思路：

全局变量maxLand和count。

主函数里的循环，每次都是遇到一个新的岛屿，所以在主函数里，dfs之前，重置count=0，dfs回来之后，刷新maxLand。

import java.util.*;

public class Main {

    // 四个方向：右、下、左，上
    private static final int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    private static int maxLand = 0;
    private static int count = 0;

    private static void dfs(int[][] grid, boolean[][] visited, int x, int y) {

        count++;

        // 四个方向都遍历一遍
        for (int i = 0; i < 4; i++) {
            int nextX = x + dir[i][0];
            int nextY = y + dir[i][1];

            // 检查是否越界
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }

            // 如果未访问且是陆地(1)，则继续DFS
            if (!visited[nextX][nextY] && grid[nextX][nextY] == 1) {
                visited[nextX][nextY] = true;
                dfs(grid, visited, nextX, nextY);
            }
        }
    }

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

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

        // 访问标记数组
        boolean[][] visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 发现未访问的陆地，岛屿数量加1，并开始DFS标记所有相连的陆地
                if (!visited[i][j] && grid[i][j] == 1) {
                    visited[i][j] = true;
                    count = 0;
                    dfs(grid, visited, i, j);
                    maxLand = Math.max(res, count);
                }
            }
        }

        System.out.println(maxLand);
        in.close();
    }
}

方法：广搜

思路：

同上，接着用全局变量的方法，使用maxLand和count计数。

当队列que出队的时候，count++；

当回到主函数的时候，刷新maxLand。

import java.util.*;

public class Main {

    // 四个方向：右、下、左，上
    private static final int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    private static int maxLand = 0;
    private static int count = 0;

    // 广搜
    private static void bfs(int[][] grid, boolean[][] visited, int x, int y) {

        Deque<int[]> que = new ArrayDeque<>();

        // 存储节点坐标
        que.offer(new int[] {x, y});
        // 加入队列后立即标记为已访问
        visited[x][y] = true;

        while (!que.isEmpty()) {
            // 每次弹出队列的时候，节点+1，岛屿面积++
            count++;
            int[] cur = que.poll();
            int curX = cur[0];
            int curY = cur[1];

            // 四个方向都遍历一遍
            for (int i = 0; i < 4; i++) {
                int nextX = curX + dir[i][0];
                int nextY = curY + dir[i][1];

                // 检查是否越界
                if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                    continue;
                }

                // // 如果是未访问的陆地，则加入队列并标记
                if (!visited[nextX][nextY] && grid[nextX][nextY] == 1) {
                    que.offer(new int[] {nextX, nextY});
                    visited[nextX][nextY] = true;
                }
            }
        }
    }

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

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

        // 访问标记数组
        boolean[][] visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 发现未访问的陆地，岛屿数量加1，并开始BFS标记所有相连的陆地
                if (!visited[i][j] && grid[i][j] == 1) {
                    count = 0;
                    bfs(grid, visited, i, j);
                    maxLand = Math.max(maxLand, count);
                }
            }
        }

        System.out.println(maxLand);
        in.close();
    }
}
2025最新华为OD机试真题目录A+B+C+D+E卷(持续收录中)-Java版
**My Coding Family**
02-12 2885
🔔本文收录于「最新最全华为OD机试真题(Java版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！专栏所写题库均搜集于互联网，经过精心筛选和整理，结合数位十多年大厂实战经验资深大佬经验所撰，欢迎订阅。    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可
day52 第十一章：图论part03
mvufi的博客
02-16 319
dfs：两种写法：一种是进来之前就判断了，判断条件在dfs的for内部；另一种是进来没有判断，那么终止条件在dfs开头。bfs: 加进来的时候就变，不要等pop的时候再变。即两处append的地方，开头和for内部，都要同时加变化。dfs, bfs流程都差不多，主要看在图的处理上，怎么需要dfs，bfs。空间复杂度高了，可以不用新建一个list，而是把陆地改成2，dfs: 进入条件即退出条件，二者选一即可。，然后遍历，再把孤岛改成0，陆地改成1。101. 孤岛的总面积。104.建造最大岛屿。
代码随想录训练营 Day51打卡 图论part02 99. 岛屿数量 100. 岛屿的最大面积
qq_42952637的博客
09-05 1261
代码随想录训练营 Day51打卡 图论part02 99. 岛屿数量 100. 岛屿的最大面积
图论day56|广度优先搜索理论基础 、bfs与dfs的对比（思维导图）、 99.岛屿数量（卡码网）、100.岛屿的最大面积（卡码网）
2402_84438596的博客
10-09 1417
图论day56|广度优先搜索理论基础 、bfs与dfs的对比（思维导图）、 99.岛屿数量（卡码网）、100.岛屿的最大面积（卡码网）
【c++刷题笔记-图论】day51：99.岛屿数量、100.岛屿的最大面积
qq_48662659的博客
07-26 237
dfs和bfs都是做图的方法，理解题意看看使用什么方法。bfs写法是有模板的，可以背下来。
day 51 第十一章：图论part02 99.岛屿数量 深搜 99.岛屿数量 广搜 100.岛屿的最大面积
2302_78039690的博客
08-02 340
思路：遇到一个没有遍历过的节点陆地，计数器就加一，然后标记该节点陆地所能遍历到的所有陆地。dfs函数：此题就一个递归终止条件所以不用写确定递归终止的条件，然后确定单层递归逻辑，分别向上右下左四个方向进行递归，符合条件的继续下一层递归。2.一般dfs里面有两个终止递归的地方，一个在确定递归终止条件里，一个在确定单层递归逻辑里，如果当前限制条件较少，这两个终止条件只能写一个，否则答案会错误。一圈一圈地遍历），然后将符合条件的节点压入队列中并标记，然后在弹出队列中的元素一圈一圈的遍历循环往复一直到队列为空。
day 65 图论part02 99.岛屿数量 深搜 99.岛屿数量 广搜 100.岛屿的最大面积
m0_68259754的博客
06-23 869
每座岛屿只能由相邻的陆地连接形成。本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。在遇到标记过的陆地节点和海洋节点的时候直接跳过。这样计数器就是最终岛屿的数量。那么如何把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。
Day52--图论--101. 孤岛的总面积（卡码网），102. 沉没孤岛（卡码网），103. 水流问题（卡码网），104. 建造最大岛屿（卡码网）
最新发布
m0_60740070的博客
08-13 490
Day52--图论--101. 孤岛的总面积（卡码网），102. 沉没孤岛（卡码网），103. 水流问题（卡码网），104. 建造最大岛屿（卡码网）
代码随想录Day51 99. 岛屿数量，99. 岛屿数量，100. 岛屿的最大面积。
get_money_的博客
12-27 989
代码随想录Day51 99. 岛屿数量，99. 岛屿数量，100. 岛屿的最大面积。
【代码随想录算法训练Day57】卡码网99.岛屿数量、卡码网100.岛屿的最大面积
qq_46121420的博客
07-03 179
图论第二天
day51|99.岛屿数量, 100.岛屿的最大面积
bindloy的博客
07-29 228
99.岛屿数量 99. 岛屿数量 (kamacoder.com) DFS 思路没问题，内存超限了。 #include<iostream> #include<vector> using namespace std; int times = 0; inline bool valid(int i, int j, const int &m, const int &n){ return i >= 0 && i < n &amp
day51 图论章节刷题Part03（101.孤岛的总面积、102.沉没孤岛、103.水流问题、104.建造最大岛屿）
m0_51007517的博客
11-05 532
思路：要找不靠边缘的陆地面积，可以将靠边缘的陆地且相邻的陆地都变成海洋，然后再去重新遍历地图 统计此时还剩下的陆地。
【代码随想录day51】【C++复健】 101. 孤岛的总面积；102. 沉没孤岛； 103. 水流问题； 104. 建造最大岛屿
yumenohimiko的博客
12-07 821
此外，我还思考了下遍历边界的dfs和遍历中心的dfs是不是也需要不一样，但事实上用同一个就行了，不光消灭陆地，还要消灭孤岛，反正能统计出来数就完事了，我统计弹匣里发射出去的子弹数也不是相当于统计人数了。然后就去偷看了一下解析，发现卡哥做法就很单纯直接，虽然我找不到浮岛，但我可以把其他地方都换一个值，换完之后我再回来搞，你是2就换回1，你是1就置0，很简单直接的想法。当然我写的代码还是很麻烦的，不过毕竟图论是完全的一周目，能写出来就算万事大吉了，也不奢求什么代码行数上的提升了。
Day51 图论part02
2401_83448199的博客
12-24 440
另一种是for循环里面调用递归函数的时候，加上判断条件，这样递归函数里面传入的都是合法的节点，这样也就不用在写上终止条件了。3.整体思路就是如果是未被标记的陆地，result加1，然后把该节点加入到队列里面，然后做个标记，然后把该节点弹出，在以弹出的节点为中心，上下左右搜索合法的节点加入到队列里面。1.广搜的写法有一种会超时，如果从队列拿出节点，再去标记这个节点走过，会导致很多节点重复加入队列，相当于如果该节点符合要求，会被重复加入到队列里面，因为如果该节点不被弹出的话，是不会被标记的，这样就会导致超时。
代码随想录算法训练营第五十九天|图论part9
xindafu的博客
08-10 234
（Function Call Operator Overload），它让一个对象可以像函数一样被调用。dijkstra（堆优化版）精讲。1.选取距离源节点并且未访过的节点。Container：底层容器类型。对所有边进行n-1次松弛操作。现在改为用邻接链表去存储图。2.标记选取节点为已访问。带有负权值的单源最短路径。Compare：比较器。
代码随想录day60图论10
皮蛋瘦肉粥的博客
08-09 297
【代码】代码随想录day60图论10。
leetcode-hot-100 (图论）
weixin_73557167的博客
08-11 806
图论
【CF】Day125——图论三题
qq_61422664的博客
08-11 764
客串一下牛客本题让我们求权值之和，那么首先能想到的就是如果 x 有奉献，那么 1 ~ x-1 的数就必须都也出现什么意思呢？比如下图如果 1 造成了奉献，那么显然其奉献大小就是所有其子树中包含 1节点 的根的数量，那么都有谁呢？显然就是 1 的所有父节点及其自身，或者说其大小就是 1 的深度，这是显然的那么对于 2 呢？首先既然 2 要有奉献，那么显然 2 和 1 就要同时出现，那么什么时候会同时出现呢？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值