LeetCode - 850 矩形面积 II

news2024/12/23 14:42:41

题目来源

850. 矩形面积 II - 力扣（LeetCode）

 

题目描述

给你一个轴对齐的二维数组 rectangles 。

对于 rectangle[i] = [x1, y1, x2, y2]，其中（x1，y1）是矩形 i 左下角的坐标， (xi1, yi1) 是该矩形 左下角 的坐标， (xi2, yi2) 是该矩形 右上角 的坐标。

计算平面中所有 rectangles 所覆盖的 总面积 。任何被两个或多个矩形覆盖的区域应只计算 一次 。

返回 总面积 。因为答案可能太大，返回 10^9 + 7 的 模 。

示例

示例 1：

输入：rectangles = [[0,0,2,2],[1,0,2,3],[1,0,3,1]]
输出：6
解释：如图所示，三个矩形覆盖了总面积为 6 的区域。
从(1,1)到(2,2)，绿色矩形和红色矩形重叠。
从(1,0)到(2,3)，三个矩形都重叠。

示例 2：

输入：rectangles = [[0,0,1000000000,1000000000]]
输出：49
解释：答案是 1018 对 (109 + 7) 取模的结果， 即 49 。

提示

  • 1 <= rectangles.length <= 200
  • rectanges[i].length = 4
  • 0 <= xi1, yi1, xi2, yi2 <= 10^9

题目解析

本题如果从 ”面“ 的角度去思考，比如：所有矩形的面积 - 矩形交集部分的面积 = 最终面积。

两个矩形的交集很容易求解，比如下面图示

虽然矩形交集很容易求解，但是想要求出所有交集，则需要让每个矩形和剩余其他矩形尝试比较，得出交集。同时求出交集矩形后，这些交集矩形也是可能互相重叠的 。。。交集的交集矩形也是可能互相重叠的。。。这样是无穷无尽的求解。因此这个思路不可取。

本题如果从 ”线“ 的角度去思考，如下图所示，从假设有一条扫描线 x = c（x1 ≤ c ≤ x4），从左向右扫描，每扫描到一个位置，则判断该位置是否有矩形覆盖，如果有矩形覆盖，比如：

  • 图1 ~ 图3 中扫描线只覆盖到了矩形[左下角(x1,y1),右上角(x2,y2)]，因此矩形覆盖的高度为 ( y2 - y1)，对应扫描线扫描出的矩形面积 = (x3 - x1) * ( y2 - y1)
  • 图4 ~ 图5 中扫描线覆盖了两个矩形，分别是 [左下角(x1,y1),右上角(x2,y2)] 和  [左下角(x3,y3),右上角(x4,y4)]，因此矩形覆盖的高度区间也有两个： [y1, y2] 和 [y3, y4]，而这两个区间又是具有重叠部分的，因此我们可以转化为区间问题，利用区间问题解法，求解出所有区间的不重叠长度之和 height 。具体求解过程在下面。那么扫描线扫描出来的面积为 (x2 - x3) * h。
  1. 首先，排序区间，按照起始位置升序，如果起始位置相同，则按照结束位置降序
  2. 然后，遍历区间，假设当前区间是 [start, end]，上一个区间是 [last_start, last_end]，

    若 last_end >= end，那么说明当前区间被上一个区间完全覆盖，可以继续忽略当前区间（因为当前区间的长度已经在上一个区间被统计过了）
    若 last_end < end，那么当前区间的非重叠部分为 [max(start, last_end), end]，统计该部分长度：height += end - max(start, last_end)，并更新last_end = end
  3. 最后，我们就求出了区间组所有区间覆盖的不重叠长度了。

上面这种思路就是 ”扫描线算法“，扫描线法可以将 "面" 的问题，分解为 "线" 的问题，将 "矩形（面）交集问题" 降解为 "区间（线）交集问题"。

C源码实现

#define MAX_N 200
#define MOD (1e9 + 7)

int cmp(const void* a, const void* b) { return *(int*)a - *(int*)b; }

int cmp2(const void* a, const void* b) {
    int* A = (int*)a;
    int* B = (int*)b;

    return A[0] != B[0] ? A[0] - B[0] : B[1] - A[1];
}

int rectangleArea(int** rectangles, int rectanglesSize, int* rectanglesColSize) {
    // 统计所有矩形的左边边、右边边所在位置的x坐标
    int listX[MAX_N];
    int listX_size = 0;

    for (int i = 0; i < rectanglesSize; i++) {
        listX[listX_size++] = rectangles[i][0]; // 矩形左边边x坐标位置
        listX[listX_size++] = rectangles[i][2]; // 矩形右边边x坐标位置
    }

    // 所有x坐标升序（每个x视为一条扫描线）
    qsort(listX, listX_size, sizeof(int), cmp);

    // 记录所有矩形并集面积
    long ans = 0;

    for (int i = 1; i < listX_size; i++) {
        // 前一个扫描线x坐标
        int preX = listX[i - 1];
        // 当前扫描线x坐标
        int curX = listX[i];

        // 相邻两个扫描线的距离
        long width = curX - preX;

        // 距离为0, 则跳过
        if (width == 0)
            continue;

        // 将在[x1,x2]区间上的矩形片段（垂直方向高度区间）收集起来
        int lines[MAX_N][2];
        int lines_size = 0;

        // 遍历每个矩形
        for (int j = 0; j < rectanglesSize; j++) {
            // 矩形左上角坐标(x1,y1), 矩形右下角坐标(x2,y2)
            int x1 = rectangles[j][0], y1 = rectangles[j][1],
                    x2 = rectangles[j][2], y2 = rectangles[j][3];

            // 如果矩形包含了 [x1, x2] 区间
            if (x1 <= preX && curX <= x2) {
                // 那么该矩形在 水平方向区间[x1, x2] 对应的 垂直方向区间为 [y2, y1]
                lines[lines_size][0] = y1;
                lines[lines_size][1] = y2;
                lines_size++;
            }
        }

        // 将处于水方向区间 [x1, x2] 的所有垂直方向区间排序：按照起始位置升序, 如果起始位置相同, 则按照结束位置降序，这样排序的目的是保证排序后，前面的区间尽可能可以覆盖后面的区间
        qsort(lines, lines_size, sizeof(lines[0]), cmp2);

        // 记录lines多个区间，求长度之和，（重叠部分只计算一次）
        long height = 0;

        int last_end = -1;
        for (int j = 0; j < lines_size; j++) {
            int start = lines[j][0];
            int end = lines[j][1];

            // 如果 last_end >= end, 则当前区间被上一个区间完全覆盖，因此可以跳过
            // 如果 last_end < end
            if (last_end < end) {
                // 则当前区间的不重叠部分是 [max(start, last_end), end]
                height += end - (int)fmax(start, last_end);
                // 更新last_end
                last_end = end;
            }
        }

        // 当前扫描线扫描到的面积为 width * height
        ans += width * height;
        ans %= (int)MOD;
    }

    return (int)ans;
}

C++源码实现

#define MOD (1E9 + 7)

class Solution {
public:
    int rectangleArea(vector<vector<int>>& rectangles) {
        // 统计所有矩形的左边边、右边边所在位置的x坐标
        vector<int> listX;
        for (vector<int>& rect : rectangles) {
            listX.emplace_back(rect[0]); // 矩形左边边x坐标位置
            listX.emplace_back(rect[2]); // 矩形右边边x坐标位置
        }

        // 所有x坐标升序（每个x视为一条扫描线）
        sort(listX.begin(), listX.end());

        // 记录所有矩形并集面积
        long ans = 0;

        for (int i = 1; i < listX.size(); i++) {
            // 前一个扫描线x坐标
            int preX = listX[i - 1];
            // 当前扫描线x坐标
            int curX = listX[i];

            // 相邻两个扫描线的距离
            long width = curX - preX;

            // 距离为0, 则跳过
            if (width == 0)
                continue;

            // 将在[x1,x2]区间上的矩形片段（垂直方向高度区间）收集起来
            vector<vector<int>> lines;

            // 遍历每个矩形
            for (vector<int>& rect : rectangles) {
                // 矩形左下角坐标(x1,y1), 矩形右上角坐标(x2,y2)
                int x1 = rect[0], y1 = rect[1], x2 = rect[2], y2 = rect[3];

                // 如果矩形包含了 [x1, x2] 区间
                if (x1 <= preX && curX <= x2) {
                    // 那么该矩形在 水平方向区间[x1, x2] 对应的 垂直方向区间为 [y1, y2]
                    lines.emplace_back(vector<int>{y1, y2});
                }
            }

            // 将处于水方向区间 [x1, x2]
            // 的所有垂直方向区间排序：按照起始位置升序, 如果起始位置相同,
            // 则按照结束位置降序，这样排序的目的是保证排序后，前面的区间尽可能可以覆盖后面的区间
            sort(lines.begin(), lines.end(),
                 [](vector<int>& lineA, vector<int>& lineB) {
                     if (lineA[0] != lineB[0]) {
                         return lineA[0] < lineB[0];
                     } else {
                         return lineA[1] > lineB[1];
                     }
                 });

            // 记录lines多个区间，求长度之和，（重叠部分只计算一次）
            long height = 0;

            int last_end = INT_MIN;
            for (vector<int>& line : lines) {
                int start = line[0];
                int end = line[1];

                // 如果 last_end >= end,
                // 则当前区间被上一个区间完全覆盖，因此可以跳过 如果 last_end <
                // end
                if (last_end < end) {
                    // 则当前区间的不重叠部分是 [max(start, last_end), end]
                    height += end - max(start, last_end);
                    // 更新last_end
                    last_end = end;
                }
            }

            // 当前扫描线扫描到的面积为 width * height
            ans += width * height;
            ans %= (int) MOD;
        }

        return (int) ans;
    }
};

Java源码实现

class Solution {
    public int rectangleArea(int[][] rectangles) {
        // 统计所有矩形的左边边、右边边所在位置的x坐标
        ArrayList<Integer> listX = new ArrayList<>();
        for (int[] rect : rectangles) {
            listX.add(rect[0]);
            listX.add(rect[2]);
        }

        // 所有x坐标升序（每个x视为一条扫描线）
        listX.sort((a, b) -> a - b);

        // 记录所有矩形并集面积
        long ans = 0;

        for (int i = 1; i < listX.size(); i++) {
            // 前一个扫描线x坐标
            int preX = listX.get(i - 1);
            // 当前扫描线x坐标
            int curX = listX.get(i);

            // 相邻两个扫描线的距离
            int width = curX - preX;

            // 距离为0, 则跳过
            if (width == 0)
                continue;

            // 将在[x1,x2]区间上的矩形片段（垂直方向高度区间）收集起来
            ArrayList<int[]> lines = new ArrayList<>();

            // 遍历每个矩形
            for (int[] rect : rectangles) {
                // 矩形左下角坐标(x1,y1), 矩形右上角坐标(x2,y2)
                int x1 = rect[0], y1 = rect[1], x2 = rect[2], y2 = rect[3];

                // 如果矩形包含了 [x1, x2] 区间
                if (x1 <= preX && curX <= x2) {
                    // 那么该矩形在 水平方向区间[x1, x2] 对应的 垂直方向区间为 [y1, y2]
                    lines.add(new int[] { y1, y2 });
                }
            }

            // 将处于水方向区间 [x1, x2] 的所有垂直方向区间排序：按照起始位置升序, 如果起始位置相同,则按照结束位置降序，
            // 这样排序的目的是保证排序后，前面的区间尽可能可以覆盖后面的区间
            lines.sort((lineA, lineB) -> lineA[0] != lineB[0] ? lineA[0] - lineB[0] : lineB[1] - lineA[1]);

            // 记录lines多个区间，求长度之和，（重叠部分只计算一次）
            int height = 0;

            int last_end = -1;
            for (int[] line : lines) {
                int start = line[0];
                int end = line[1];

                // 如果 last_end >= end, 则当前区间被上一个区间完全覆盖，因此可以跳过
                // 如果 last_end < end
                if (last_end < end) {
                    // 则当前区间的不重叠部分是 [max(start, last_end), end]
                    height += end - Math.max(start, last_end);
                    // 更新last_end
                    last_end = end;
                }
            }

            // 当前扫描线扫描到的面积为 width * height
            ans += (long) width * height;
            ans %= (int) (1e9 + 7);
        }

        return (int) ans;
    }
}

Python源码实现

class Solution(object):
    def rectangleArea(self, rectangles):
        """
        :type rectangles: List[List[int]]
        :rtype: int
        """
        # 统计所有矩形的左边边、右边边所在位置的x坐标
        listX = []

        for rect in rectangles:
            listX.append(rect[0])  # 矩形左边边x坐标位置
            listX.append(rect[2])  # 矩形右边边x坐标位置

        # 所有x坐标升序（每个x视为一条扫描线）
        listX.sort()

        # 记录所有矩形并集面积
        ans = 0

        for i in range(1, len(listX)):
            # 前一个扫描线x坐标
            preX = listX[i - 1]
            # 当前扫描线x坐标
            curX = listX[i]

            # 相邻两个扫描线的距离
            width = curX - preX

            # 距离为0, 则跳过
            if width == 0:
                continue

            # 将在[x1,x2]区间上的矩形片段（垂直方向高度区间）收集起来
            lines = []

            # 遍历每个矩形
            # 矩形左下角坐标(x1,y1)，矩形右上角坐标(x2,y2)
            for x1, y1, x2, y2 in rectangles:
                # 如果矩形包含了 [x1, x2] 区间
                if x1 <= preX and curX <= x2:
                    # 那么该矩形在 水平方向区间[x1, x2] 对应的 垂直方向区间为 [y1, y2]
                    lines.append((y1, y2))

            # 将处于水方向区间 [x1, x2] 的所有垂直方向区间排序：按照起始位置升序, 如果起始位置相同, 则按照结束位置降序，这样排序的目的是保证排序后，前面的区间尽可能可以覆盖后面的区间
            lines.sort(key=lambda line: (line[0], -line[1]))

            # 记录lines多个区间，求长度之和，（重叠部分只计算一次）
            height = 0

            # 题目说坐标范围 [-100, 100], 因此对应 [?, -101] 的区间必然不会和任何区间相交
            last_end = -1

            # 如果 last_end >= end, 则当前区间被上一个区间完全覆盖，因此可以跳过
            # 如果 last_end < end
            for start, end in lines:
                if last_end < end:
                    # 则当前区间的不重叠部分是 [max(start, last_end), end]
                    height += end - max(start, last_end)
                    # 更新last_end
                    last_end = end

            # 当前扫描线扫描到的面积为 width * height
            ans += width * height

        return ans % 1000000007

JavaScript源码实现

/**
 * @param {number[][]} rectangles
 * @return {number}
 */
var rectangleArea = function (rectangles) {
    // 统计所有矩形的左边边、右边边所在位置的x坐标
    const listX = [];

    for (let rect of rectangles) {
        listX.push(rect[0]); // 矩形左边边x坐标位置
        listX.push(rect[2]); // 矩形右边边x坐标位置
    }

    // 所有x坐标升序（每个x视为一条扫描线）
    listX.sort((a, b) => a - b);

    // 记录所有矩形并集面积
    let ans = 0n;

    for (let i = 1; i < listX.length; i++) {
        // 前一个扫描线x坐标
        const preX = listX[i - 1];
        // 当前扫描线x坐标
        const curX = listX[i];

        // 相邻两个扫描线的距离
        const width = curX - preX;

        // 距离为0, 则跳过
        if (width == 0) continue;

        // 将处于[x1,x2]区间上的矩形片段（垂直方向高度区间）收集起来
        const lines = [];

        // 遍历每个矩形
        // 矩形左下角坐标(x1,y1)，矩形右上角坐标(x2,y2)
        for (let [x1, y1, x2, y2] of rectangles) {
            // 如果矩形有片段处于 [x1, x2] 区间
            if (x1 <= preX && curX <= x2) {
                // 那么该矩形在 水平方向区间[x1, x2] 对应的 垂直方向区间为 [y1, y2]
                lines.push([y1, y2]);
            }
        }

        // 将处于水方向区间 [x1, x2] 的所有垂直方向区间排序：按照起始位置升序, 如果起始位置相同, 则按照结束位置降序，这样排序的目的是保证排序后，前面的区间尽可能可以覆盖后面的区间
        lines.sort((lineA, lineB) =>
            lineA[0] != lineB[0] ? lineA[0] - lineB[0] : lineB[1] - lineA[1]
        );

        // 记录lines多个区间，求长度之和，（重叠部分只计算一次）
        let height = 0;

        let last_end = -1;
        for (let [start, end] of lines) {
            // 如果 last_end >= end, 则当前区间被上一个区间完全覆盖，因此可以跳过
            // 如果 last_end < end
            if (last_end < end) {
                // 则当前区间的不重叠部分是 [max(start, last_end), end]
                height += end - Math.max(start, last_end);
                // 更新last_end
                last_end = end;
            }
        }

        // 当前扫描线扫描到的面积为 width * height
        ans += BigInt(width) * BigInt(height);
    }

    return Number(ans % 1000000007n);
};

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

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

相关文章

灵当CRM index.php接口SQL注入漏洞复现 [附POC]

灵当CRM index.php接口SQL注入漏洞复现 [附POC]

文章目录 灵当CRM index.php接口SQL注入漏洞复现 [附POC]0x01 前言0x02 漏洞描述0x03 影响版本0x04 漏洞环境0x05 漏洞复现1.访问漏洞环境2.构造POC3.复现 0x06 修复建议 灵当CRM index.php接口SQL注入漏洞复现 [附POC] 0x01 前言 免责声明&#xff1a;请勿利用文章内的相关技…
阅读更多...
数据治理003-数据域

数据治理003-数据域

数据仓库是面向主题&#xff08;数据综合、归类并进行分析利用的抽象&#xff09;的应用。 数据仓库模型设计除横向的分层外&#xff0c;通常也需要根据业务情况进行纵向划分数据域。数据域是联系较为紧密的数据主题的集合&#xff0c;通常是根据业务类别、数据来源、数据用途…
阅读更多...
001、视频添加字幕

001、视频添加字幕

1. 腾讯智影 (可用) https://zenvideo.qq.com/ 1.1 操作步骤 https://zenvideo.qq.com/ https://zenvideo.qq.com/my/material?typeexport 上传资源 自动字幕识别 修改字幕 下载字幕 上传字幕 https://zenvideo.qq.com/my/material?typeexport 2. 秒剪–手机版app &a…
阅读更多...
【Python-GUI图形化界面-PyQt5模块（3）】——Qwidget核心模块

【Python-GUI图形化界面-PyQt5模块（3）】——Qwidget核心模块

本文旨在带大家学习Python中的一种GUI图形化界面模块——PyQt5模块&#xff0c;将为大家详细了解PyQt5模块中函数的参数和使用&#xff1a; 一、PyQt5简介 PyQt是Qt框架的Python语言实现&#xff0c;由Riverbank Computing开发&#xff0c;是最强大的GUI库之一。 官方网站&a…
阅读更多...
Win32打开UWP应用

Win32打开UWP应用

最近无意间发现Windows里一个神奇的文件夹。 shell:appsfolder 运行打开 这个文件夹后&#xff0c;你可以看到本机安装的所有应用程序。 我觉得这个挺方便的&#xff0c;所以做了一个简单的appFolderDialog包给C#用 项目地址&#xff1a;https://github.com/TianXiaTech/App…
阅读更多...
大数据毕业设计选题推荐-内蒙古旅游景点数据分析系统-Hive-Hadoop-Spark

大数据毕业设计选题推荐-内蒙古旅游景点数据分析系统-Hive-Hadoop-Spark

✨作者主页&#xff1a;IT研究室✨ 个人简介&#xff1a;曾从事计算机专业培训教学&#xff0c;擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Python…
阅读更多...
【有啥问啥】深度理解主动学习：机器学习的高效策略

【有啥问啥】深度理解主动学习：机器学习的高效策略

深度理解主动学习&#xff1a;机器学习的高效策略 在大数据时代&#xff0c;数据量的爆炸性增长与有限的标注资源之间的矛盾日益凸显。如何高效地利用标注资源来训练高质量的模型&#xff0c;成为了机器学习领域亟待解决的问题。主动学习&#xff08;Active Learning, AL&…
阅读更多...
Oracle RMAN 无敌备份脚本

Oracle RMAN 无敌备份脚本

1 说明 上一篇文章&#xff1a;Oracle逻辑备份脚本&#xff0c;介绍了如何部署Oracle数据库的逻辑备份脚本&#xff0c;在数据迁移场景下十分好用&#xff0c;但是作为备份来说有点牵强。仅仅有逻辑备份时&#xff0c;当故障发生后&#xff0c;逻辑备份恢复只能恢复到某一时刻…
阅读更多...
网络资源模板--Android Studio 飞机大战游戏

网络资源模板--Android Studio 飞机大战游戏

目录 一、项目演示 二、项目测试环境 三、项目详情 四、完整的项目源码 一、项目演示 网络资源模板--飞机大战 二、项目测试环境 三、项目详情 首页 1. **继承 Activity**: - SecondActivity 类继承自 Activity&#xff0c;表示一个新的屏幕或界面。 2. **重写 onCrea…
阅读更多...
FLUX.1图像生成模型：AI工程师的实践与探索

FLUX.1图像生成模型：AI工程师的实践与探索

文章目录 1 FLUX.1系列模型2 AI工程师的视角3 ComfyUI部署4 FLUX.1部署5 工作流6 面向未来 黑森林实验室&#xff08;Black Forest Labs&#xff09;研发的FLUX.1图像生成模型&#xff0c;以其120亿参数的庞大规模&#xff0c;正在重新定义图像生成技术的新标准。FLUX.1系列模型…
阅读更多...
服务器数据恢复—SAN环境下LUN映射出错导致文件系统一致性出错的数据恢复案例

服务器数据恢复—SAN环境下LUN映射出错导致文件系统一致性出错的数据恢复案例

服务器数据恢复环境&#xff1a; SAN环境下一台存储设备中有一组由6块硬盘组建的RAID6磁盘阵列&#xff0c;划分若干LUN&#xff0c;MAP到不同业务的SOLARIS操作系统服务器上。 服务器故障&#xff1a; 用户新增了一台服务器&#xff0c;将存储中的某个LUN映射到新增加的这台服…
阅读更多...
yolo自动化项目实例解析（六）自建UI（主窗口、预览窗口）

yolo自动化项目实例解析（六）自建UI（主窗口、预览窗口）

前面我们大致把各个代码块梳理出来了&#xff0c;但是还是不知道从那块开始&#xff0c;我们这里主要先通过ui页面的元素去推理整个执行过程&#xff0c;我们首先需要知道ui功能里面有那些组件 qt设计师基础控件 Qt Designer 是一个图形界面设计工具&#xff0c;用于创建 Qt 应…
阅读更多...
遇到慢SQL、SQL报错，应如何快速定位问题 | OceanBase优化实践

遇到慢SQL、SQL报错，应如何快速定位问题 | OceanBase优化实践

在数据库的使用中&#xff0c;大家时常会遇到慢SQL&#xff0c;或执行出错的SQL。对于某些SQL问题&#xff0c;其错误原因显而易见&#xff0c;但也有不少情况难以直观判断。面对这类问题&#xff0c;我们应当如何应对&#xff1f;如何准确识别SQL错误的根源&#xff1f;是否需…
阅读更多...
电脑usb接口封禁如何实现？5种禁用USB接口的方法分享！(第一种你GET了吗？）

电脑usb接口封禁如何实现？5种禁用USB接口的方法分享！(第一种你GET了吗？）

“防患于未然&#xff0c;安全始于细节。”在信息技术飞速发展的今天&#xff0c;企业的信息安全问题日益凸显。 USB接口作为数据传输的重要通道&#xff0c;在带来便利的同时&#xff0c;也成为了数据泄露和安全风险的高发地。 因此&#xff0c;对电脑USB接口进行封闭管理&a…
阅读更多...
WPF项目中使用Caliburn.Micro框架实现日志和主题切换

WPF项目中使用Caliburn.Micro框架实现日志和主题切换

目录 一、添加Caliburn.Micro框架 二、配置Serilog日志 三、实现主题切换 Caliburn.Micro是MVVM模式的轻量级WPF框架&#xff0c;简化了WPF中的不少用法。这个框架中所有的页面控制都是通过ViewModel去实现的。 以下内容是自己在进行项目实战的同时进行记录的&#xff0c;对于…
阅读更多...
【08】纯血鸿蒙HarmonyOS NEXT星河版开发0基础学习笔记-Scroll容器与Tabs组件

【08】纯血鸿蒙HarmonyOS NEXT星河版开发0基础学习笔记-Scroll容器与Tabs组件

序言&#xff1a; 本文详细讲解了关于我们在页面上经常看到的可滚动页面和导航栏在鸿蒙开发中如何用Scroll和Tabs组件实现&#xff0c;介绍了Scroll和Tabs的基本用法与属性。 笔者也是跟着B站黑马的课程一步步学习&#xff0c;学习的过程中添加部分自己的想法整理为笔记分享出…
阅读更多...
晶圆厂如何突破多网隔离实现安全稳定又快速的跨网域文件传输？

晶圆厂如何突破多网隔离实现安全稳定又快速的跨网域文件传输？

在当今数字化时代&#xff0c;晶圆厂作为高科技产业的核心&#xff0c;其生产效率和数据安全性直接影响到整个半导体行业的竞争力。晶圆厂内部网络通常被划分为多个安全域&#xff0c;如生产网络、研发网络、办公网络等&#xff0c;以确保数据安全和防止敏感信息泄露。然而&…
阅读更多...
【RabbitMQ 项目】服务端：服务器模块

【RabbitMQ 项目】服务端：服务器模块

文章目录 一.编写思路二.代码实践三.服务端模块关系总结 一.编写思路 成员变量&#xff1a; muduo 库中的 TCP 服务器EventLoop 对象&#xff1a;用于主线程循环监控连接事件协议处理句柄分发器&#xff1a;用于初始化协议处理器&#xff0c;便于把不同请求派发给不同的业务处理…
阅读更多...
大语言模型在构建UNSPSC 分类数据中的应用

大语言模型在构建UNSPSC 分类数据中的应用

UNSPSC 是联合国标准产品和服务代码。UNSPSC由联合国开发计划署&#xff08;UNDP&#xff09;和Dun & Bradstreet公司&#xff08;D & B&#xff09;于1998年联合制定&#xff0c;自2003年以来一直由GS1 US管理。GS1 US 将在 2024 年底前将 UNSPSC 的管理权移交给 UNDP…
阅读更多...
【HarmonyOS】TaskPool非阻塞UI

【HarmonyOS】TaskPool非阻塞UI

TaskPool方法不会阻塞UI&#xff0c;如果做上传图片的功能加载Loading记得使用TaskPool&#xff0c;Promise、Async/Await都会阻塞UI 【引言】 发现Promise可能会阻塞UI&#xff0c;尝试使用async或await&#xff0c;但发现它们仍然会导致阻塞。后来看到chaoxiaoshu回复的Tas…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023