代码随想录打卡|Day45 图论（孤岛的总面积 、沉没孤岛、水流问题、建造最大岛屿）

news2025/5/26 4:39:41

图论part03

孤岛的总面积

代码随想录链接
题目链接
视频讲解链接

在这里插入图片描述
在这里插入图片描述

思路：既然某个网格在边界上的岛屿不是孤岛，那么就把非 孤岛的所有岛屿变成海洋，最后再次统计还剩余的岛屿占据的网格总数即可。

dfs：

import java.util.Scanner;

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



    // TODO 4.dfs遍历逻辑
    private static void dfs(int[][] graph , int x , int y){
        graph[x][y] = 0;

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


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

            if(graph[nextX][nextY] == 1){
                graph[nextX][nextY] = 0;
                dfs(graph,nextX,nextY);
            }
        }

        
    }
    
    public static void main(String[] args){
        // TODO 1.生成graph
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        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();
            }
        }
        // sc.colse();

        // TODO 2.仅对四个边进行遍历，遇到陆地的时候将该陆地和与之相邻的陆地全部变为海洋
        for(int i = 0; i < n ; i++){
            if(graph[i][0] == 1){
                dfs(graph,i,0);
            }
        }

        for(int i = 0; i < n ; i++){
            if(graph[i][m - 1] == 1){
                dfs(graph,i,m-1);
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(graph[0][j] == 1){
                dfs(graph,0,j);
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(graph[n - 1][j] == 1){
                dfs(graph,n-1,j);
            }
        }

        // TODO 3.遍历图，获取所有岛屿土地数量
        int sum = 0 ;
        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < m ; j++){
                if(graph[i][j] == 1 ){
                    sum++;                
                }
            }
        }
        System.out.println(sum);
    }
}

bfs：

import java.util.*;

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


    // TODO 4.bfs遍历逻辑
    private static void bfs(int[][] graph , int x , int y){
        class Node{
            int x;
            int y;
            public Node(int x , int y){
                this.x = x;
                this.y = y;
            }
        }
        
        Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(x,y));
        graph[x][y] = 0;

        while(!queue.isEmpty()){
            Node node = queue.remove();
            for(int i = 0 ; i < 4 ; i++){
                int nextX = node.x + dir[i][0];
                int nextY = node.y + dir[i][1];
                if(nextX < 0 || nextY < 0 || nextX >= graph.length || nextY >= graph[0].length)
                    continue;

                if(graph[nextX][nextY] == 1){
                    graph[nextX][nextY] = 0;
                    queue.add(new Node(nextX,nextY));
                }
            }
        }
        
    }
    
    public static void main(String[] args){
        // TODO 1.生成graph
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        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();
            }
        }
        // sc.colse();

        // TODO 2.仅对四个边进行遍历，遇到陆地的时候将该陆地和与之相邻的陆地全部变为海洋
        for(int i = 0; i < n ; i++){
            if(graph[i][0] == 1){
                bfs(graph,i,0);
            }
        }

        for(int i = 0; i < n ; i++){
            if(graph[i][m - 1] == 1){
                bfs(graph,i,m-1);
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(graph[0][j] == 1){
                bfs(graph,0,j);
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(graph[n - 1][j] == 1){
                bfs(graph,n-1,j);
            }
        }

        // TODO 3.遍历图，获取所有岛屿土地数量
        int sum = 0 ;
        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < m ; j++){
                if(graph[i][j] == 1 ){
                    sum++;                
                }
            }
        }
        System.out.println(sum);
    }
}

沉没孤岛

代码随想录链接
题目链接
视频讲解链接

在这里插入图片描述
在这里插入图片描述

思路：在这道题之中，我们只需要将图保留两份，一份计算孤岛，计算完之后对第二份图的孤岛进行去除即可。

DFS:

import java.util.Scanner;

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



    // TODO 4.dfs遍历逻辑
    private static void dfs(int[][] graph , int x , int y){
        graph[x][y] = 0;

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


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

            if(graph[nextX][nextY] == 1){
                graph[nextX][nextY] = 0;
                dfs(graph,nextX,nextY);
            }
        }

        
    }
    
    public static void main(String[] args){
        // TODO 1.生成graph
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] graph = new int[n][m];
        int[][] graph2 = new int[n][m];

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



        // sc.colse();

        // TODO 2.仅对四个边进行遍历，遇到陆地的时候将该陆地和与之相邻的陆地全部变为海洋
        for(int i = 0; i < n ; i++){
            if(graph[i][0] == 1){
                dfs(graph,i,0);
            }
        }

        for(int i = 0; i < n ; i++){
            if(graph[i][m - 1] == 1){
                dfs(graph,i,m-1);
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(graph[0][j] == 1){
                dfs(graph,0,j);
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(graph[n - 1][j] == 1){
                dfs(graph,n-1,j);
            }
        }

        // TODO 3.遍历图，获取所有岛屿土地数量
        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < m ; j++){
                if(graph[i][j] == 1 && graph2[i][j] == 1){
                    graph2[i][j] = 0;                
                }
                System.out.print(graph2[i][j] + " ");
            }
            System.out.println();
        }

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

BFS：

import java.util.*;

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


    // TODO 4.bfs遍历逻辑
    private static void bfs(int[][] graph , int x , int y){
        class Node{
            int x;
            int y;
            public Node(int x , int y){
                this.x = x;
                this.y = y;
            }
        }
        
        Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(x,y));
        graph[x][y] = 0;

        while(!queue.isEmpty()){
            Node node = queue.remove();
            for(int i = 0 ; i < 4 ; i++){
                int nextX = node.x + dir[i][0];
                int nextY = node.y + dir[i][1];
                if(nextX < 0 || nextY < 0 || nextX >= graph.length || nextY >= graph[0].length)
                    continue;

                if(graph[nextX][nextY] == 1){
                    graph[nextX][nextY] = 0;
                    queue.add(new Node(nextX,nextY));
                }
            }
        }
        
    }
    
    public static void main(String[] args){
        // TODO 1.生成graph
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] graph = new int[n][m];
        int[][] graph2 = new int[n][m];
        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < m ; j++){
                int num = sc.nextInt();
                graph[i][j] = num;
                graph2[i][j] = num;
            }
        }
        // sc.colse();

        // TODO 2.仅对四个边进行遍历，遇到陆地的时候将该陆地和与之相邻的陆地全部变为海洋
        for(int i = 0; i < n ; i++){
            if(graph[i][0] == 1){
                bfs(graph,i,0);
            }
        }

        for(int i = 0; i < n ; i++){
            if(graph[i][m - 1] == 1){
                bfs(graph,i,m-1);
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(graph[0][j] == 1){
                bfs(graph,0,j);
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(graph[n - 1][j] == 1){
                bfs(graph,n-1,j);
            }
        }

        // TODO 3.遍历图，获取所有岛屿土地数量
        
        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < m ; j++){
                if(graph[i][j] == 1  && graph2[i][j] == 1){
                    graph2[i][j] = 0;                
                }
                System.out.print(graph2[i][j] + " ");
            }
            System.out.println();
        }
        
    }
}

水流问题

代码随想录链接
题目链接
视频讲解链接
在这里插入图片描述
在这里插入图片描述

暴力DFS：

import java.util.*;

public class Main{
    static int m,n;
    // static int[][] dir = {{0,1},{1,0},{0,-1},{1-,0}};
    static int[][] dir = {{0,1},{1,0},{0,-1},{-1,0}};
    private static void dfs(int[][] graph , boolean[][] visted , int x , int y ){
        if(visted[x][y]) return ;

        visted[x][y] = true;


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

            if(nextX < 0 || nextY < 0 || nextX >= n || nextY >= m) continue;

            if(graph[x][y] < graph[nextX][nextY]) continue;

            dfs(graph,visted,nextX,nextY);
        }
    }

    private static boolean isResult(int[][] graph , int x , int y){
        boolean[][] visted = new boolean[n][m];
        dfs(graph,visted,x,y);
        boolean isFirst = false;
        boolean isSecond = false;

        // 判断当前的（x,y）节点是否从第一组边界出去
        for(int i = 0 ; i < n ; i++){
            if(visted[i][0]){
                isFirst = true;
                break;
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(visted[0][j]){
                isFirst = true;
                break;
            }
        }

        // 判断当前的（x,y）节点是否从第二组边界出去
        for(int i = 0 ; i < n ; i++){
            if(visted[i][m-1]){
                isSecond = true;
                break;
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(visted[n - 1][j]){
                isSecond = true;
                break;
            }
        }

        return isFirst&&isSecond;
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);

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

        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();
            }
        } 

        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < m ; j++){
                if(isResult(graph,i,j))
                    System.out.println(i + " " + j);
            }
        }

    }
}

暴力BFS：(超时)

import java.util.*;

public class Main{
    static int m,n;
    // static int[][] dir = {{0,1},{1,0},{0,-1},{1-,0}};
    static int[][] dir = {{0,1},{1,0},{0,-1},{-1,0}};
    private static void bfs(int[][] graph , boolean[][] visted , int x , int y ){
        class Node{
            int x ;
            int y;
            public Node(int x , int y){
                this.x = x;
                this.y = y;
            }
        }
        Queue<Node> queue = new LinkedList<>();

        queue.add(new Node(x,y));
        visted[x][y] = true;

        while(!queue.isEmpty()){
            Node node = queue.remove();
            for(int i = 0 ; i < 4 ; i++){
                int nextX = node.x + dir[i][0];
                int nextY = node.y + dir[i][1];

                if(nextX < 0 || nextY < 0 || nextX >= n || nextY >= m ) continue;

                if(visted[nextX][nextY]) continue;

                if(graph[node.x][node.y] < graph[nextX][nextY] ) continue;

                queue.add(new Node(nextX,nextY));
                visted[nextX][nextY] = true;
            }
        }
    }

    private static boolean isResult(int[][] graph , int x , int y){
        boolean[][] visted = new boolean[n][m];
        bfs(graph,visted,x,y);
        boolean isFirst = false;
        boolean isSecond = false;

        // 判断当前的（x,y）节点是否从第一组边界出去
        for(int i = 0 ; i < n ; i++){
            if(visted[i][0]){
                isFirst = true;
                break;
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(visted[0][j]){
                isFirst = true;
                break;
            }
        }

        // 判断当前的（x,y）节点是否从第二组边界出去
        for(int i = 0 ; i < n ; i++){
            if(visted[i][m-1]){
                isSecond = true;
                break;
            }
        }

        for(int j = 0 ; j < m ; j++){
            if(visted[n - 1][j]){
                isSecond = true;
                break;
            }
        }

        return isFirst&&isSecond;
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);

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

        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();
            }
        } 

        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < m ; j++){
                if(isResult(graph,i,j))
                    System.out.println(i + " " + j);
            }
        }

    }
}

DFS优化：
采用逆向思维，考虑水流从低处往高处可以流通的情况，从而获得第一组边界的流通情况和第二组流水的情况，二者均为true的情况则表明该网格可以从第一组边界和第二组边界流出。

import java.util.*;

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


    private static void dfs(int[][] graph , boolean[][] visted , int x , int y , int preH){
        // 遇到边界或者访问过的点直接返回
        if(x < 0 || y < 0 || x >= graph.length ||y >= graph[0].length || visted[x][y]) return;
        if(graph[x][y] < preH) return ;

        visted[x][y] = true;

        dfs(graph,visted,x+1,y,graph[x][y]);
        dfs(graph,visted,x,y+1,graph[x][y]);
        dfs(graph,visted,x-1,y,graph[x][y]);
        dfs(graph,visted,x,y-1,graph[x][y]);
    }

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

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

        int[][] graph = new int[n][m];
        boolean[][] firstB = new boolean[n][m];
        boolean[][] secondB = new boolean[n][m];

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

        // 从上下边界进行DFS
        for(int j = 0 ; j < m ; j++){
            dfs(graph,firstB,0,j,Integer.MIN_VALUE);
            dfs(graph,secondB,n-1,j,Integer.MIN_VALUE);
        }

        // 从左右边界进行DFS

        for(int i = 0 ; i < n ; i++){
            dfs(graph,firstB,i,0,Integer.MIN_VALUE);
            dfs(graph,secondB,i,m-1,Integer.MIN_VALUE);
        }

        
        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < m ; j++){
                if(firstB[i][j] && secondB[i][j])
                    System.out.println(i + " " + j);
            }
        }

    }
}

BFS（待补充）

建造最大岛屿(待完成)

代码随想录链接
题目链接
视频讲解链接

在这里插入图片描述

import java.util.*;
public class Main {
    // 该方法采用 DFS
    // 定义全局变量
    // 记录每次每个岛屿的面积
    static int count;
    // 对每个岛屿进行标记
    static int mark;
    // 定义二维数组表示四个方位
    static int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

    // DFS 进行搜索，将每个岛屿标记为不同的数字
    public static void dfs(int[][] grid, int x, int y, boolean[][] visited) {
        // 当遇到边界，直接return
        if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length) return;
        // 遇到已经访问过的或者遇到海水，直接返回
        if (visited[x][y] || grid[x][y] == 0) return;

        visited[x][y] = true;
        count++;
        grid[x][y] = mark;

        // 继续向下层搜索
        dfs(grid, x, y + 1, visited);
        dfs(grid, x, y - 1, visited);
        dfs(grid, x + 1, y, visited);
        dfs(grid, x - 1, y, visited);
    }

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

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

        // 初始化mark变量，从2开始（区别于0水，1岛屿）
        mark = 2;

        // 定义二位boolean数组记录该位置是否被访问
        boolean[][] visited = new boolean[m][n];

        // 定义一个HashMap，记录某片岛屿的标记号和面积
        HashMap<Integer, Integer> getSize = new HashMap<>();

        // 定义一个HashSet，用来判断某一位置水四周是否存在不同标记编号的岛屿
        HashSet<Integer> set = new HashSet<>();

        // 定义一个boolean变量，看看DFS之后，是否全是岛屿
        boolean isAllIsland = true;

        // 遍历二维数组进行DFS搜索，标记每片岛屿的编号，记录对应的面积
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) isAllIsland = false;
                if (grid[i][j] == 1) {
                    count = 0;
                    dfs(grid, i, j, visited);
                    getSize.put(mark, count);
                    mark++;
                }
            }
        }

        int result = 0;
        if (isAllIsland) result =  m * n;

        // 对标记完的grid继续遍历，判断每个水位置四周是否有岛屿，并记录下四周不同相邻岛屿面积之和
        // 每次计算完一个水位置周围可能存在的岛屿面积之和，更新下result变量
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) {
                    set.clear();
                    // 当前水位置变更为岛屿，所以初始化为1
                    int curSize = 1;

                    for (int[] dir : dirs) {
                        int curRow = i + dir[0];
                        int curCol = j + dir[1];

                        if (curRow < 0 || curRow >= m || curCol < 0 || curCol >= n) continue;
                        int curMark = grid[curRow][curCol];
                        // 如果当前相邻的岛屿已经遍历过或者HashMap中不存在这个编号，继续搜索
                        if (set.contains(curMark) || !getSize.containsKey(curMark)) continue;
                        set.add(curMark);
                        curSize += getSize.get(curMark);
                    }

                    result = Math.max(result, curSize);
                }
            }
        }

        // 打印结果
        System.out.println(result);
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2385835.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SpringCloud实战：使用Sentinel构建可靠的微服务熔断机制

SpringCloud实战：使用Sentinel构建可靠的微服务熔断机制

上篇文章简单介绍了SpringCloud系列Gateway的基本用法以及Demo搭建&#xff0c;今天继续讲解下SpringCloud Gateway实战指南&#xff01;在分享之前继续回顾下本次SpringCloud的专题要讲的内容&#xff1a; 本教程demo源码已放入附件内 技术准备 读者须知&#xff1a; 本教程…
阅读更多...
张 Prompt Tuning--中文数据准确率提升：理性与冲动识别新突破

张 Prompt Tuning--中文数据准确率提升：理性与冲动识别新突破

Prompt Tuning–中文数据准确率提升：理性与冲动识别新突破 中文数据，准确率 数据标签三类：冲动21，理性21，（中性设为理性40：说明prompt 修正的有效性） 测试数据：冲动4，理性4，中性设为理性10 为了可视化做了 词嵌入 空间的相似文本计算，但是实际当loss 比较小的时…
阅读更多...
深入解析 MySQL 中的 SHOW_ROUTINE 权限

深入解析 MySQL 中的 SHOW_ROUTINE 权限

目录 前言 权限作用 授权方法 MySQL8.0.20以上 MySQL8.0.20以下 总结 前言 SHOW_ROUTINE 是 MySQL 中用于控制用户查看存储过程和函数定义的权限。拥有该权限的用户可以通过 SHOW CREATE PROCEDURE 和 SHOW CREATE FUNCTION 等语句查看存储过程和函数的详细定义&#xff…
阅读更多...
电脑网络如何改ip地址？ip地址改不了怎么回事

电脑网络如何改ip地址？ip地址改不了怎么回事

在日常使用电脑上网时&#xff0c;我们有时会遇到需要更改IP地址的情况&#xff0c;比如访问某些受限制的网站、解决网络冲突问题&#xff0c;或者出于隐私保护的需求。然而&#xff0c;许多用户在尝试修改IP地址时可能会遇到各种问题&#xff0c;例如IP地址无法更改、修改后无…
阅读更多...
打开小程序提示请求失败(小程序页面空白)

打开小程序提示请求失败(小程序页面空白)

1、小程序代码是商城后台下载的还是自己编译的 &#xff08;1&#xff09;要是商城后台下载的&#xff0c;检查设置里面的域名是不是https的 &#xff08;2&#xff09;要是自己编译的&#xff0c;检查app.js里面的接口域名是不是https的&#xff0c;填了以后有没有保存 注&a…
阅读更多...
一张纸决定的高度

一张纸决定的高度

从我捧起《格局》这个本书开始&#xff0c;转眼间两个月过去了。 回头望一望&#xff0c;好似还在昨天。 这两个月&#xff0c;心态在变&#xff0c;前进的方向在变&#xff0c;但唯一不变的就是每天晚上睡前&#xff0c;留给自己十分钟的读书时光。 我也从来没想过&#xf…
阅读更多...
IP查询基础介绍

IP查询基础介绍

IP 查询原理 IP 地址是网络设备唯一标识&#xff0c;IP 查询通过解析 IP 地址获取地理位置、运营商等信息。目前主流的 IPv4&#xff08;32 位&#xff09;与 IPv6&#xff08;128 位&#xff09;协议&#xff0c;前者理论提供约 43 亿地址&#xff0c;后者地址空间近乎无限。…
阅读更多...
常见的gittee开源项目推荐

常见的gittee开源项目推荐

https://gitee.com/macrozheng/mall https://doc.ruoyi.vip/ https://eladmin.vip/ https://gitee.com/dromara/RuoYi-Cloud-Plus https://gitee.com/dromara/RuoYi-Vue-Plus https://gitee.com/ZhongBangKeJi/crmeb_java
阅读更多...
日常效率工具【Tools】【持续更新】

日常效率工具【Tools】【持续更新】

日常效率工具【Tools】 VScodevscode原理&#xff08;居然和Chrome同源&#xff09;Chromium(Chrome开源版)node.js:让JavaScript可以运行在wab之外的环境 配置文件setting.jesn vscode快捷键万事不求人&#xff08;Ctrl K,Ctrl S&#xff09;vscode修改光标所在行的背景色Gene…
阅读更多...
数据结构与算法——链式二叉树

数据结构与算法——链式二叉树

链式二叉树 遍历方式与其规则代码的实现递归的复习前&#xff0c;中&#xff0c;后序遍历的实现二叉树结点个数二叉树叶子结点个数二叉树第k层结点个数二叉树的深度/高度二叉树查找值为x的结点二叉树销毁层序遍历 遍历方式与其规则 前序遍历&#xff1a;访问根结点的操作发⽣在…
阅读更多...
Android12 launcher3修改App图标白边问题

Android12 launcher3修改App图标白边问题

Android12 launcher3修改App图标白边问题 1.前言&#xff1a; 今天在Android12 Rom定制客制化系统应用时发现改变系统App图标的形状会出现一个问题&#xff0c;那就是图标被缩小了&#xff0c;没有显示完整&#xff0c;有一个白边&#xff0c;这在普通的App开发很少遇到&…
阅读更多...
【iOS】分类、扩展、关联对象

【iOS】分类、扩展、关联对象

分类、扩展、关联对象 前言分类扩展扩展和分类的区别关联对象key的几种用法流程 总结 前言 最近的学习中笔者发现自己对于分类、扩展相关知识并不是很熟悉&#xff0c;刚好看源码类的加载过程中发现有类扩展与关联对象详解。本篇我们来探索一下这部分相关知识&#xff0c;首先…
阅读更多...
内蒙古工程系列建设工程技术人才评审条件

内蒙古工程系列建设工程技术人才评审条件

关于印发《内蒙古自治区工程系列建设工程专业技术人才职称评审条件》的通知 内蒙古工程系列建设工程技术人才评审条件适用范围 内蒙古工程系列建设工程技术人才评审条件之技术员评审要求 内蒙古工程系列建设工程技术人才评审条件之助理工程师评审要求 内蒙古工程系列建设工程技…
阅读更多...
目标检测DINO-DETR（2023）详细解读

目标检测DINO-DETR（2023）详细解读

文章目录 对比去噪训练混合查询选择look forward twice 论文全称为&#xff1a;DETR with Improved DeNoising Anchor Boxes for End-to-End Object Detection 提出了三个新的方法&#xff1a; 首先&#xff0c;为了改进一对一的匹配效果&#xff0c;提出了一种对比去噪训练方法…
阅读更多...
SGlang 推理模型优化(PD架构分离)

SGlang 推理模型优化(PD架构分离)

一、技术背景 随着大型语言模型&#xff08;LLM&#xff09;广泛应用于搜索、内容生成、AI助手等领域&#xff0c;对模型推理服务的并发能力、响应延迟和资源利用效率提出了前所未有的高要求。与模型训练相比&#xff0c;推理是一个持续进行、资源消耗巨大的任务&#xff0c;尤…
阅读更多...
Vue语法【2】

Vue语法【2】

1.插值表达式&#xff1a; 语法规则&#xff1a; {{Vue实例中data的变量名}}使用场景&#xff1a; 插值表达式一般使用在文本内容中&#xff0c;如果是元素的属性内容中则无法使用&#xff1b; 案例&#xff1a; <!DOCTYPE html> <html lang"en"> &l…
阅读更多...
2.2.1 05年T2

2.2.1 05年T2

引言 本文将从一预习、二自习、三学习、四复习等四个阶段来分析2005年考研英语阅读第二篇文章。为了便于后续阅读&#xff0c;我将第四部分复习放在了首位。 四、复习 方法&#xff1a;错误思路分析总结考点文章梳理 4.1 错题分析 题目&#xff1a;26&#xff08;细节题&…
阅读更多...
Linux虚拟文件系统(2)

Linux虚拟文件系统(2)

2.3 目录项-dentry 目录项&#xff0c;即 dentry&#xff0c;用来记录文件的名字、索引节点指针以及与其他目录项的关联关系。多个关联的目录项&#xff0c;就构成了文件系统的目录结构。和上一章中超级块和索引节点不同&#xff0c;目录项并不是实际存在于磁盘上的&#xff0c…
阅读更多...
【数据结构】栈和队列(上)

【数据结构】栈和队列(上)

目录 一、栈&#xff08;先进后出、后进先出的线性表&#xff09; 1、栈的概念及结构 2、栈的底层结构分析 二、代码实现 1、定义一个栈 2、栈的初始化 3、入栈 3、增容 4、出栈 5、取栈顶 6、销毁栈 一、栈&#xff08;先进后出、后进先出的线性表&#xff09; 1、…
阅读更多...
科技赋能·长效治理｜无忧树建筑修缮渗漏水长效治理交流会圆满举行！

科技赋能·长效治理｜无忧树建筑修缮渗漏水长效治理交流会圆满举行！

聚焦行业痛点&#xff0c;共话长效未来&#xff01;5月16日&#xff0c;由无忧树主办的主题为“科技赋能长效治理”的建筑修缮渗漏水长效治理技术交流会在上海圆满举行。来自全国的建筑企业代表、专家学者、技术精英齐聚一堂&#xff0c;共探渗漏治理前沿技术&#xff0c;见证科…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023