代码随想录Day66（图论Part03）

已于 2024-06-29 20:18:54 修改
阅读量293 收藏 2
点赞数 8
分类专栏： 代码随想录 文章标签： 图论 算法 深度优先
于 2024-06-28 14:48:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Allen_7_kklt/article/details/140036078
版权

101.孤岛的总面积

题目：101. 孤岛的总面积 (kamacoder.com)

思路：无

答案
import java.util.Scanner;

class Main {
    private static int N, M;
    private static int[][] grid;
    private static boolean[][] visited;
    private static boolean touchesEdge;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        N = scanner.nextInt();
        M = scanner.nextInt();
        grid = new int[N][M];
        visited = new boolean[N][M];

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }

        int totalIslandArea = 0;

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    touchesEdge = false;
                    int islandArea = dfs(i, j);
                    if (!touchesEdge) {
                        totalIslandArea += islandArea;
                    }
                }
            }
        }

        System.out.println(totalIslandArea);
    }

    private static int dfs(int x, int y) {
        if (x < 0 || x >= N || y < 0 || y >= M) {
            return 0;
        }
        if (grid[x][y] == 0 || visited[x][y]) {
            return 0;
        }

        if (x == 0 || x == N - 1 || y == 0 || y == M - 1) {
            touchesEdge = true;
        }

        visited[x][y] = true;
        int area = 1;

        area += dfs(x + 1, y);
        area += dfs(x - 1, y);
        area += dfs(x, y + 1);
        area += dfs(x, y - 1);

        return area;
    }
}
小结

在dfs里面需要判断岛屿时候接触边缘

102.沉没孤岛

题目：102. 沉没孤岛 (kamacoder.com)

思路：判断周围也没有岛屿，上下左右都没有，那就将当前位置变为0

尝试（标题4）
import java.util.Scanner;

class Main{
    public static int m;
    public static int n;
    public static int[][] grid;
    public static boolean[][] visited;
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        grid = new int[n][m];
        visited = new boolean[n][m];
        
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                grid[i][j] = scanner.nextInt();
            }
        }
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    int area = dfs(i, j);
                    if(area == 1) grid[i][j] = 0;
                }
            }
        }
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(grid[i][j]+" ");
            }
            System.out.println();
        }
        
    }
    private static int dfs(int i, int j) {
        if (i < 0 || i >= n || j < 0 || j >= m || grid[i][j] == 0 || visited[i][j]) {
            return 0;
        }
        
        visited[i][j] = true;
        int area = 1;  // 当前格子的面积为1
        
        // 上
        area += dfs(i - 1, j);
        // 下
        area += dfs(i + 1, j);
        // 左
        area += dfs(i, j - 1);
        // 右
        area += dfs(i, j + 1);
        
        return area;
    }
}
答案
import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 读取矩阵的行数和列数
        int N = scanner.nextInt();
        int M = scanner.nextInt();
        
        int[][] grid = new int[N][M];
        
        // 读取矩阵
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }
        
        // 从边缘开始标记所有与边缘相连的陆地
        for (int i = 0; i < N; i++) {
            if (grid[i][0] == 1) {
                dfs(grid, i, 0, N, M);
            }
            if (grid[i][M - 1] == 1) {
                dfs(grid, i, M - 1, N, M);
            }
        }
        for (int j = 0; j < M; j++) {
            if (grid[0][j] == 1) {
                dfs(grid, 0, j, N, M);
            }
            if (grid[N - 1][j] == 1) {
                dfs(grid, N - 1, j, N, M);
            }
        }
        
        // 将所有未标记的陆地（孤岛）沉没
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (grid[i][j] == 1) {
                    grid[i][j] = 0;
                } else if (grid[i][j] == 2) {
                    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();
        }
        
        scanner.close();
    }
    
    // 深度优先搜索（DFS）函数
    private static void dfs(int[][] grid, int x, int y, int N, int M) {
        if (x < 0 || x >= N || y < 0 || y >= M || grid[x][y] != 1) {
            return;
        }
        grid[x][y] = 2; // 标记为非孤岛
        dfs(grid, x + 1, y, N, M);
        dfs(grid, x - 1, y, N, M);
        dfs(grid, x, y + 1, N, M);
        dfs(grid, x, y - 1, N, M);
    }
}
小结

先标记所有非孤岛，再沉没所有孤岛，再撤销所有非孤岛标记

103.水流问题

题目：103. 水流问题 (kamacoder.com)

思路：我需要找到最大的数字，然后再用dfs搜索？以每一个格子为中心，画一个十字，只要有朝向第一组边界和朝向第二组边界的递减数组即可，写一个函数，计算水流能否到达第一组边界，另一个函数计算水流能否到达第二组边界，两个函数返回均为true时，记录该坐标

尝试（超时）
import java.util.Scanner;
import java.util.ArrayList;
class Main{
    public static int N;
    public static int M;
    public static int[][] grid;
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        N = scanner.nextInt();
        M = scanner.nextInt();
        grid = new int[N][M];
        ArrayList<int[]> dynamicArray = new ArrayList<>();
        for(int i=0; i<N; i++){
            for(int j=0; j<M; j++){
                grid[i][j] = scanner.nextInt();
            }
        }
        
        for(int i=0; i<N; i++){
            for(int j=0; j<M; j++){
                if(firstBoundary(i,j) && secondBoundary(i,j)){
                    dynamicArray.add(new int[]{i,j});
                }
            }
        }
         // 输出动态数组中的内容
        for (int[] array : dynamicArray) {
            System.out.println(array[0] + " " + array[1]);
        }
        
    }
    public static boolean firstBoundary(int i,int j){
        boolean up = true;
        boolean left = true;
        for(int k=i; k>0; k--){
            if(grid[k][j]>grid[i][j]) up = false;
        }
        for(int k=j; k>0; k--){
            if(grid[i][k]>grid[i][j]) left = false;
        }
        return up|| left;
    }
    public static boolean secondBoundary(int i,int j){
        boolean down = true;
        boolean right = true;
        for(int k=i; k<N; k++){
            if(grid[k][j]>grid[i][j]) down = false;
        }
        for(int k=j; k<M; k++){
            if(grid[i][k]>grid[i][j]) right = false;
        }
        return down||right;
    }
}
答案
import java.util.ArrayList;
import java.util.Scanner;

class Main {
    public static int N;
    public static int M;
    public static int[][] grid;
    public static boolean[][] canReachFirstBoundary;
    public static boolean[][] canReachSecondBoundary;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        N = scanner.nextInt();
        M = scanner.nextInt();
        grid = new int[N][M];
        canReachFirstBoundary = new boolean[N][M];
        canReachSecondBoundary = new boolean[N][M];

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }

        // 从第一组边界开始反向DFS
        for (int i = 0; i < N; i++) {
            dfs(i, 0, canReachFirstBoundary);
            dfs(i, M - 1, canReachSecondBoundary);
        }
        for (int j = 0; j < M; j++) {
            dfs(0, j, canReachFirstBoundary);
            dfs(N - 1, j, canReachSecondBoundary);
        }

        // 找出既能到达第一组边界又能到达第二组边界的单元格
        ArrayList<int[]> result = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (canReachFirstBoundary[i][j] && canReachSecondBoundary[i][j]) {
                    result.add(new int[]{i, j});
                }
            }
        }

        // 输出结果
        for (int[] cell : result) {
            System.out.println(cell[0] + " " + cell[1]);
        }
    }

    // 深度优先搜索（DFS）函数
    private static void dfs(int x, int y, boolean[][] canReach) {
        if (canReach[x][y]) {
            return;
        }
        canReach[x][y] = true;

        int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
        for (int[] direction : directions) {
            int newX = x + direction[0];
            int newY = y + direction[1];
            if (newX >= 0 && newX < N && newY >= 0 && newY < M && grid[newX][newY] >= grid[x][y]) {
                dfs(newX, newY, canReach);
            }
        }
    }
}
小结

反向dfs效率更高

104.建造最大岛屿

题目：104. 建造最大岛屿 (kamacoder.com)

思路：感觉肯定是要找到最大的岛屿，再去连接，或者是第二大的，又或者是岛屿从大到小，都试一遍，逐个将岛屿的某个边缘变为陆地

这个1 肯定是出现在岛屿的边缘，或许我可以先遍历一遍，找到所有的边缘，

尝试（写不出来）
import java.util.Scanner;

class Main{
    public static int N;
    public static int M;
    public static int[][] grid;
    public static boolean[][] visited;
    public static boolean flag;
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        N = scan.nextInt();
        M = scan.nextInt();
        grid = new int[N][M];
        for(int i=0; i<N; i++){
            for(int j=0; j<M; j++){
                grid[i][j] = scan.nextInt();
            }
        }
        
        // 遍历grid，找到所有的边缘，单元格每与一个陆地接触，就加1
        // 初始值为2，为了区分岛屿的1
        for(int i=0; i<N; i++){
            for(int j=0; j<M; j++){
                grid[i][j] = scan.nextInt();
            }
        }
    }
    public static void dfs(int i, int j){
        if(i<0 || i>=N || j<0 ||  j>=M){
            return;
        }
        visited[i][j] = true;
        if(grid[i][j]==1) flag = true;
        if(flag){
            if(grid[i][j]==0){
                grid[i][j] =2;
            }else{
                grid[i][j]+=1;
            }
        } 
        dfs(i-1,j);
        dfs(i+1,j);
        dfs(i,j-1);
        dfs(i,j+1);
    }
    
}
答案(卡码网上别人的，看不懂)
import java.util.Arrays;
import java.util.Map;
import java.util.Scanner;

// 逆向思维
public class Main {
    static int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
    static int ans = 0, area = 1;
    static boolean[][] visited;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // row
        int m = sc.nextInt(); // col
        int[][] graph = new int[n][m];

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


        boolean flag  = false;

        // 遍历
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                area = 1;
                visited = new boolean[n][m];
                if (graph[i][j] == 0){
                    dfs(i, j, graph, n, m);
                    flag = true;

                }
            }
        }

        System.out.println(flag ? ans : n * m);
    }

    private static void dfs(int row, int col, int[][] graph, int n, int m) {
        ans = Math.max(ans, area);
        visited[row][col] = true;
        for (int[] dir : dirs) {
            int newX = dir[0] + row;
            int newY = dir[1] + col;
            if(newX >= 0 && newX < n && newY >= 0 && newY < m && graph[newX][newY] == 1 && !visited[newX][newY]){
                area++;
                dfs(newX,newY,graph,n,m);
            }
        }
    }

}
答案（仿照代码随想录中C++的逻辑，运行错误）
import java.util.*;

public class Main {

    static int n, m;
    static int count;
    static int[][] dir = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}}; // 四个方向

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

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

        boolean[][] visited = new boolean[n][m]; // 标记访问过的点，初始化为false
        Map<Integer, Integer> gridNum = new HashMap<>();
        int mark = 2; // 记录每个岛屿的编号
        boolean isAllGrid = true; // 标记是否整个地图都是陆地

        // 计算每个岛屿的面积并标记
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 0) isAllGrid = false;
                if (!visited[i][j] && grid[i][j] == 1) {
                    count = 0;
                    dfs(grid, visited, i, j, mark); // 将与其链接的陆地都标记上 true
                    gridNum.put(mark, count); // 记录每一个岛屿的面积
                    mark++; // 记录下一个岛屿编号
                }
            }
        }

        if (isAllGrid) {
            System.out.println(n * m); // 如果都是陆地，返回全面积
            return; // 结束程序
        }

        // 以下逻辑是根据添加陆地的位置，计算周边岛屿面积之和
        int result = 0; // 记录最后结果
        Set<Integer> visitedGrid = new HashSet<>(); // 标记访问过的岛屿

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                count = 1; // 记录连接之后的岛屿数量
                visitedGrid.clear(); // 每次使用时，清空
                if (grid[i][j] == 0) {
                    for (int k = 0; k < 4; k++) {
                        int neari = i + dir[k][0]; // 计算相邻坐标
                        int nearj = j + dir[k][1];
                        if (neari < 0 || nearj < 0 || neari >= n || nearj >= m) continue;
                        if (visitedGrid.contains(grid[neari][nearj])) continue; // 添加过的岛屿不要重复添加
                        // 把相邻四面的岛屿数量加起来
                        count += gridNum.get(grid[neari][nearj]);
                        visitedGrid.add(grid[neari][nearj]); // 标记该岛屿已经添加过
                    }
                }
                result = Math.max(result, count);
            }
        }

        System.out.println(result);
    }

    // 深度优先搜索函数
    private static void dfs(int[][] grid, boolean[][] visited, int x, int y, int mark) {
        if (visited[x][y] || grid[x][y] == 0) return; 
        visited[x][y] = true; // 标记访问过
        grid[x][y] = mark; // 给陆地标记新标签
        count++;
        for (int i = 0; i < 4; i++) {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if(nextx <0 || nextx >=n || nexty<0 || nexty >=m) continue;
            dfs(grid, visited, nextx, nexty, mark);
            
        }
    }
}

阿拉-M83
关注
  • 8
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
代码随想录 day52图论 part1
qq_40445763的博客
07-13 184
本题是一道简单的深搜题目，也可以说是模板题，和 力扣 797. 所有可能的路径(opens new window) 思路是一样一样的。很多录友做力扣的时候，轻松就把代码写出来了， 但做面试笔试的时候，遇到这样的题就写不出来了。在力扣上刷题不用考虑图的存储方式，也不用考虑输出的格式。而这些都是 ACM 模式题目的知识点（图的存储方式）和细节（输出的格式）所以我才会特别制作ACM题目，同样也重点去讲解图的存储和遍历方式，来帮大家去练习。
代码随想录Day72（图论Part08）
Allen_7_kklt的博客
07-04 476
存储节点和节点依赖关系。思路：看了一下蓝不过海呀的视频，要找到入度为0的点，删掉该点和该点的出度，要用一个数据结构存起来边，而且要方便删除。思路：直接看的蓝不过海呀的视频，懒得自己写了，抄一遍。
代码随想录Day70（图论Part06）
Allen_7_kklt的博客
07-03 392
思路：每次更新输出的边，来保证删除的是输入中最后出现的那条边。关键是，我要知道哪条边可以删除，而且是在join的时候就判断。基于【寻找存在的路径】代码改造，如果发现输入的（s，t）指向同一个根，说明是冗余连接，通过s1，t1每次join的时候更新。思路：按照题目的意思，至少有一条边是可以删除的，我想通过fa数组，找到fa中最少被指向的元素，删掉该边，或者是说，输出该边。在遍历father数组时，还需要记录是哪条边，或许可以用set来存储。
代码随想录Day71(图论Part07)
Allen_7_kklt的博客
07-03 315
思路：首先，我不知道怎么存这样的东西，用三维数组吗，没搞懂，果断放弃。prim算法的关键是加点。
代码随想录Day76（图论Part11）
Allen_7_kklt的博客
07-04 314
思路：毫无疑问是最难的一题。
代码随想录Day69(图论Part05)
Allen_7_kklt的博客
07-02 349
思路：难道说，使用并查集的find函数，遍历所有的边，将节点的父亲信息存起来，如果source和destination没有指向同一个根节点，那么就说明不存在路径。路径压缩，也就是在某一次find函数执行过程中，更新子节点的指向，直接指向顶级节点。
代码随想录Day67(图论 part04)
Allen_7_kklt的博客
07-02 343
通过递归, 把所有路径跑一遍, 之后再检查是否所有的节点都有被访问到, 此处不需要回溯。思路：逐个遍历1，计算每个1跟临近的0所形成的边界，加起来，就是周长。思路：从1出发,进行深搜,走完所有路径,看是否能够到达所有节点。注意每次只统计上边和左边的相邻陆地。
随想录Day 64| 图论part01
weixin_44645059的博客
06-20 206
深度搜索广度搜索。
代码随想录Day74（图论Part10）
Allen_7_kklt的博客
07-04 705
思路：出现负权回路，按照之前的思路，会一直循环回路，使得成本不断减小，因此核心思路是，在。Bellman_ford 算法 每次都是对所有边进行松弛，其实是多做了一些无用功。更新用的是minDist，判断用的是minDistCopy。使用LinkedList实现Queue，不断从中。思路：关键是在于，每次松弛要基于上一次松弛的结果。因此，关键在于记录上次松弛更新过的节点，用。出节点node，操作。邻接表存储，方便找到。
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
代码随想录-大厂八股文-面试
04-25
"代码随想录-大厂八股文-面试" 从标题和描述中，我们可以看出这篇文章主要讲述的是代码随想录的大厂八股文面试相关知识点。下面将对这些知识点进行详细的解释和总结。 首先，代码随想录是一种常用的编程技巧，旨在...
代码随想录算法训练营Day 62| 图论 part02 | 695. 岛屿的最大面积、1020.飞地的数量、130.被围绕的区域
m0_51759998的博客
07-12 431
其实就是从边缘遍历，不是整幅图遍历，最后边缘能遍历到的就都visited=True了，剩下的False且为陆地的就是飞地。
图论连通性
Xing_ke的博客
07-13 938
无向图Tarjan求割点if(x!=a&&x!求点双求割边 求边双点双缩点连图边双缩点连图缩点连图有向图Tarjan 强连通缩点i<=cc;++i){if(!in[i])a++;if(!out[i])b++;代码。
hot100 | 九、图论
LMEdward的博客
07-11 345
注意：×1res+1dfs。
Day53:图论 岛屿数量 岛屿的最大面积
最新发布
2301_76352996的博客
07-15 473
99. 岛屿数量时间限制：1.000S 空间限制：256MB。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值