LeetCode刷题（ACM模式）-01数组

news2024/11/17 8:54:43

参考引用：代码随想录

  • 注：每道 LeetCode 题目都使用 ACM 代码模式，可直接在本地运行，蓝色字体为题目超链接

0. 数组理论基础

  • 数组（array）是存放在连续内存空间上的相同类型数据的集合，是一种复合数据类型，它是有序数据的集合，在存储空间中也是按顺序存储。数组中的每个元素具有相同的数据类型，可以方便的通过下标索引的方式访问到对应的数据。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。举一个字符数组的例子，如图所示
    • 数组下标都是从 0 开始的
    • 数组内存空间的地址是连续的
    • 数值数组元素的默认值为 0，而引用元素的默认值为 null
    • 数组元素可以是任何类型，包括数组类型

在这里插入图片描述

  • 正是因为数组的在内存空间的地址是连续的，所以在删除或者增添元素的时候，就难免要移动其他元素的地址。例如删除下标为 3 的元素，需要对下标为 3 的元素后面的所有元素都要做移动操作，如图所示

在这里插入图片描述

  • 要注意 vector 和 array 的区别，vector 的底层实现是 array，严格来讲 vector 是容器，不是数组。数组的元素是不能删的，只能覆盖，平时删除操作也是依次用后一位覆盖，因为存储空间申请且初始化后就固定了，如下图二维数组所示。此外，在 C++ 中二维数组也是连续分布的

在这里插入图片描述

1. 二分查找

704. 二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1

  • 示例 1
    输入: nums = [-1,0,3,5,9,12]，target = 9
    输出: 4
    解释: 9 出现在 nums 中并且下标为 4
  • 示例 2
    输入: nums = [-1,0,3,5,9,12]，target = 2
    输出: -1
    解释: 2 不存在 nums 中因此返回 -1
  • 提示
    你可以假设 nums 中的所有元素是不重复的
    n 将在 [1, 10000] 之间
    nums 的每个元素都将在 [-9999, 9999] 之间

1.1 解题思路

  • 使用二分法的前提条件

    • 数组为有序数组
    • 数组中无重复元素

  • 二分法核心思想

    • 在二分查找的过程中，保持不变量，即：在 while 寻找每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则
    • 区间的定义一般为两种，左闭右闭即 [left, right]，或者左闭右开即 [left, right)

1.2 二分法之左闭右闭

  • 例如在数组：1,2,3,4,7,9,10 中查找元素 2，如图所示

在这里插入图片描述

// 时间复杂度：O(log n)
// 空间复杂度：O(1)
#include <iostream>
#include <vector>

class Solution {
public:
    int search(std::vector<int> &nums, int target) {
        int left = 0;
        int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
        while (left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=
            int middle = left + ((right - left) / 2); // 防止溢出 等同于(left + right)/2
            if (nums[middle] > target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 1, 2, 3, 4, 7, 9, 10 };
    int target = 2;

    Solution solution;
    int result = solution.search(nums, target);

    std::cout << result << std::endl;
    return 0;
}

1.3 二分法之左闭右开

// 时间复杂度：O(log n)
// 空间复杂度：O(1)
#include <iostream>
#include <vector>

class Solution {
public:
    int search(std::vector<int> &nums, int target) {
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int middle = left + (right - left) / 2;
            if (nums[middle] > target) {
                right = middle;
            } else if (nums[middle] < target) {
                left = middle + 1;
            } else {
                return middle;
            }
        }
        return -1;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 1, 2, 3, 4, 7, 9, 10 };
    int target = 2;

    Solution solution;
    int result = solution.search(nums, target);

    std::cout << result << std::endl;
    return 0;
}

2. 移除元素

27. 移除元素
给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O ( 1 ) O(1) O(1) 额外空间并原地修改输入数组

  • 示例 1
    给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2
  • 示例 2
    给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4
  • 提示
    元素的顺序可以改变
    你不需要考虑数组中超出新长度后面的元素
    数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖
    数组在内存中是连续的地址空间，不能释放单一元素，如果要释放，就是全释放（程序运行结束，回收内存栈空间）

2.1 暴力解法

  • 两层 for 循环，第一个 for 循环遍历数组元素 ，第二个 for 循环更新数组
    在这里插入图片描述
// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
#include <iostream>
#include <vector>

class Solution {
public:
    int removeElement(std::vector<int> &nums, int val) {
        int size = nums.size();
        for (int i = 0; i < size; ++i) {
            if (nums[i] == val) {
                // 发现需要移除的元素，就将数组集体向前移动一位
                for (int j = i + 1; j < size; ++j) {
                    nums[j - 1] = nums[j];
                }
                // 因为下标 i 以后的数值都向前移动了一位，所以如果不对 i 进行自减操作
                // 那么下次循环时会漏掉移动后的当前位置（即原来的下标 i+1）
                // 从而导致这个位置上的元素没有被处理到
                --i;
                --size; // 此时数组的大小 -1
            }
        }
        return size;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 0, 1, 2, 2, 3, 0, 4, 2 };

    Solution solution;
    int result = solution.removeElement(nums, 2);

    std::cout << result << std::endl;
    return 0;
}

2.2 双指针法

  • 双指针法（快慢指针法）：通过一个快指针和慢指针在一个 for 循环下完成两个 for 循环的工作
  • 定义快慢指针
    • 快指针：寻找新数组的元素，新数组就是不含有目标元素的数组
    • 慢指针：指向更新的新数组下标的位置
      在这里插入图片描述
// 时间复杂度：O(n)
// 空间复杂度：O(1)
#include <iostream>
#include <vector>

class Solution {
public:
    int removeElement(std::vector<int> &nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); ++fastIndex) {
            if (val != nums[fastIndex]) {
                nums[slowIndex] = nums[fastIndex];
                ++slowIndex;
            }
        }
        return slowIndex;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 0, 1, 2, 2, 3, 0, 4, 2 };

    Solution solution;
    int result = solution.removeElement(nums, 2);

    std::cout << result << std::endl;
    return 0;
}

3. 有序数组的平方

977. 有序数组的平方
给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序

  • 示例 1
    输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]
  • 示例 2
    输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

3.1 暴力解法

  • 每个数平方之后，排个序
// 时间复杂度：O(n + nlogn)
#include <iostream>
#include <vector>
#include <algorithm>

class Solution {
public:
    std::vector<int> sortedSquares(std::vector<int> &A) {
        for (int i = 0; i < A.size(); ++i) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序
        return A;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> A{ -7, -3, 2, 3, 11 };

    Solution solution;
    std::vector<int> result = solution.sortedSquares(A); // 调用快速排序算法

    // 打印排序后的数组
    for (auto i = result.begin(); i < result.end(); ++i) {
        std::cout << *i << ' ';
    }
    
    return 0;
}

3.2 双指针法

  • 数组其实是有序的，只不过负数平方之后可能成为最大数了。那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。此时可以考虑双指针法了，i 指向起始位置，j 指向终止位置。定义一个新数组 result，和 A 数组一样的大小
    如果 A[i] * A[i] < A[j] * A[j] 那么 result[k--] = A[j] * A[j]; 
如果 A[i] * A[i] >= A[j] * A[j] 那么 result[k--] = A[i] * A[i];

在这里插入图片描述

// 时间复杂度：O(n)
#include <iostream>
#include <vector>

class Solution {
public:
    std::vector<int> sortedSquares(std::vector<int> &A) {
        std::vector<int> result(A.size());
        // 定义左右指针，初始时分别指向数组的第一个和最后一个元素
        int left = 0;
        int right = A.size() - 1;
        // 从右向左遍历数组
        for (int i = A.size() - 1; i >= 0; --i) {
            // 取左右指针指向的数的平方的较大值添加到结果中，并将左右指针向中间移动
            if (A[left] * A[left] >= A[right] * A[right]) {
                result[i] =  A[left] * A[left];
                ++left;
            } else {
                result[i] = A[right] * A[right];
                --right;
            }
        }
        return result;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> A{ -7, -3, 2, 3, 11 };
    Solution solution;
    std::vector<int> result = solution.sortedSquares(A); // 调用快速排序算法

    // 打印排序后的数组
    for (auto i = result.begin(); i < result.end(); ++i) {
        std::cout << *i << ' ';
    }
    
    return 0;
}

4. 长度最小的子数组

209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0

  • 示例 1
    输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组
  • 提示
    1 <= target <= 10^9
    1 <= nums.length <= 10^5
    1 <= nums[i] <= 10^5

滑动窗口法

  • 所谓滑动窗口（也可以理解为双指针法的一种），就是不断的调节子序列的起始位置和终止位置，从而得出要想的结果。在暴力解法中，是一个 for 循环为滑动窗口的起始位置，另一个 for 循环为滑动窗口的终止位置，用两个 for 循环 完成了一个不断搜索区间的过程。那么滑动窗口如何用一个 for 循环来完成这个操作呢？

    • 首先要思考：如果用一个 for 循环，那么应该表示滑动窗口的起始位置，还是终止位置。只用一个 for 循环，那么这个循环的索引，一定是表示滑动窗口的终止位置。那么问题来了，滑动窗口的起始位置如何移动呢？这里还是以题目中的示例来举例，s=7，数组是 2，3，1，2，4，3，来看一下查找的过程

  • 在本题中实现滑动窗口，主要确定如下三点

    • 窗口内是什么？
      • 窗口就是满足其和 ≥ s 的长度最小的连续子数组
    • 如何移动窗口的起始位置？
      • 如果当前窗口的值大于 s 了，窗口就要向前移动了（也就是该缩小了）
    • 如何移动窗口的结束位置？
      • 窗口的结束位置就是遍历数组的指针，也就是 for 循环里的索引

  • 解题的关键在于窗口的起始位置如何移动，滑动窗口的精妙之处在于，根据当前子序列和大小的情况，不断调节子序列的起始位置，从而将 O ( n 2 ) O(n^2) O(n2) 暴力解法降为 O ( n ) O(n) O(n)：每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2n 也就是 O ( n ) O(n) O(n)
    在这里插入图片描述

// 时间复杂度：O(n)
// 空间复杂度：O(1)
#include <iostream>
#include <vector>

class Solution {
public:
    int minSubArrayLen(int target, std::vector<int> &nums) {
        int result = INT32_MAX; // 子数组初始值
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度

        for (int j = 0; j < nums.size(); ++j) { // j 滑动窗口终止位置
            sum += nums[j];
            // 使用 while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= target) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i]; // 不断变更 i（子序列的起始位置）
                ++i;
            }
        }
        // 如果 result 没有被赋值的话，就返回 0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 2, 3, 1, 2, 4, 3 };
    int target = 7;

    Solution solution;
    std::cout << solution.minSubArrayLen(target, nums) << std::endl;
    
    return 0;
}

5. 螺旋矩阵II

59. 螺旋矩阵 II
给定一个正整数 n，生成一个包含 1 到 n 2 n^2 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵

  • 示例
    输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

5.1 思路

  • 核心思想：循环不变量原则
    • 模拟顺时针画矩阵的过程，一圈下来要画每四条边，每画一条边都坚持一致的左闭右开（或左开右闭）原则
    • 下图每一种颜色代表一条边及遍历的长度，可以看出每一个拐角处的处理规则，拐角处让给新的一条边来继续画，即左闭右开的原则
      • 填充上行从左到右
      • 填充右列从上到下
      • 填充下行从右到左
      • 填充左列从下到上

在这里插入图片描述

5.2 代码实现

// 时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
// 空间复杂度 O(1)
#include <iostream>
#include <vector>

class Solution {
public:
    std::vector<std::vector<int>> generateMatrix(int n) {
        std::vector<std::vector<int>> res(n, std::vector<int>(n, 0)); // 使用vector定义一个二维数组，每个位置初始化为0
        int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
        int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2; // 矩阵中间的位置，例如：n为3，中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int count = 1; // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int i,j;
        while (loop--) {
            i = startx;
            j = starty;

            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (j = starty; j < n - offset; j++) {
                res[i][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (i = startx; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {
                res[i][j] = count++;
            }

            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startx++;
            starty++;

            // offset 控制每一圈里每一条边遍历的长度
            offset += 1;
        }

        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};

int main(int argc, char *argv[]) {
    Solution solution;
    int n = 3;

    std::vector<std::vector<int>> res = solution.generateMatrix(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cout << res[i][j] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

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

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

相关文章

【哪些人不适合学习云计算？看看有没有你！】

【哪些人不适合学习云计算？看看有没有你！】

云计算作为是互联网技术革命的重要一员&#xff0c;也是区别于一般IT职业的。作为高级技工&#xff0c;不是谁都能学会&#xff0c;也不是谁都适合这个技术。优秀的云计算工程师能让技术成为炫耀的资本&#xff0c;玩得神乎其技&#xff0c;引得众人追捧。我想这也是大部分热爱…
阅读更多...
Cam APP-HAL流程追踪之demo梳理

Cam APP-HAL流程追踪之demo梳理

一、基础知识 1、Google官网的Cam流程如下图1 2、Cam的预览、拍照、录像是分开的 Cam的预览、拍照、录像是各自独立的-换句话说可以不开启预览拍照或者录像–后面代码会详细介绍&#xff1b;市场上的成品Cam应用&#xff0c;打开Cam后直接打开了预览&#xff0c;然后可以拍照…
阅读更多...
【数据结构】线性表之栈、队列

【数据结构】线性表之栈、队列

前言 前面两篇文章讲述了关于线性表中的顺序表与链表&#xff0c;这篇文章继续讲述线性表中的栈和队列。 这里讲述的两种线性表与前面的线性表不同&#xff0c;只允许在一端入数据&#xff0c;一段出数据&#xff0c;详细内容请看下面的文章。 顺序表与链表两篇文章的链接&…
阅读更多...
最新社区论坛小程序源码 含流量主功能+前后端+部署搭建教程

最新社区论坛小程序源码 含流量主功能+前后端+部署搭建教程

分享一个社区论坛小程序源码&#xff0c;含完整前后端代码包和详细的部署搭建教程&#xff0c;做地方运营很适合&#xff0c;集成了流量主功能&#xff0c;一键轻松开启。 系统功能一览&#xff1a; 广场管理&#xff1a;广场列表&#xff0c;圈子列表&#xff0c;圈子审核 帖…
阅读更多...
CE作业(4)

CE作业(4)

一、准备前提 服务端 客户端 ; 关闭防火墙systemctl stop firewalld 关闭selinux setenforce 0 提供DNS服务的软件叫bind&#xff0c;服务名是named 一、正向解析&#xff1a; 1.装包 yum install bind -y 2.配置服务 vim /etc/named.conf #监听53号端口 #访问的是本…
阅读更多...
​数据库原理及应用上机（实验三 SQL数据查询）

​数据库原理及应用上机（实验三 SQL数据查询）

✨作者&#xff1a;命运之光 ✨专栏&#xff1a;数据库原理及应用上机实验 ​ 目录 ✨一、实验目的和要求 ✨二、实验内容及步骤 ✨三、实验结果 ✨四、附加练习 ✨五、实验总结 &#x1f353;&#x1f353;前言&#xff1a; 数据库原理及应用上机实验报告的一个简单整理…
阅读更多...
用别人的钱创咖啡的业，戴威与陆正耀殊途同归？

用别人的钱创咖啡的业，戴威与陆正耀殊途同归？

文 | 新熔财经 作者 | 和花 近四年来&#xff0c;ofo退押一事没有出现任何明显的转机&#xff0c;但ofo创始人戴威却已经在海外大张旗鼓地开启了名为About Time Coffee的新创业项目。 当“ofo创始人戴威再次创业”的消息登上微博热搜&#xff0c;收获的几乎都是“还钱”的征…
阅读更多...
字符串按规则生成字典

字符串按规则生成字典

带数字的字符串以数字为key倒序生成字典&#xff0c;字符串列表按其元素索引为key倒序生成字典。 【学习的细节是欢悦的历程】 Python 官网&#xff1a;https://www.python.org/ Free&#xff1a;大咖免费“圣经”教程《 python 完全自学教程》&#xff0c;不仅仅是基础那么简…
阅读更多...
实验室云检验信息系统(云LIS源码)

实验室云检验信息系统(云LIS源码)

一、区域云LIS系统概述&#xff1a; 区域云LIS平台源码&#xff0c;系统完全采用B/S架构模式&#xff0c;扩展性强。整个系统的运行基于WEB层面&#xff0c;只需要在对应的工作台安装一个浏览器软件有外网即可访问。 云LIS系统为实验室服务对象提供检验申请、采集标本、结果查…
阅读更多...
【IDEA使用码云教程】

【IDEA使用码云教程】

IDEA使用码云教程 一、下载、安装git二、配置Gitee插件三、克隆项目四、上传项目五、推送项目六、更新项目 一、下载、安装git 1.打开git官网&#xff0c;选择你的操作系统 官网下载地址&#xff1a;https://git-scm.com/downloads 2.根据你的系统位数选择相应的版本下载 系统…
阅读更多...
frp+nginx+xposed搭建xp模块集群

frp+nginx+xposed搭建xp模块集群

frpcnginxxposed搭建xp模块集群 前言实现逻辑配置内网穿透实现负载均衡 前言 为了能够稳定的采集一些app的详情页数据&#xff0c;就得借助xposed&#xff0c;xposed跟NanoHTTPD配合使用就可以在手机端开启接口服务&#xff0c;直接调用手机端的接口就能获取我们想要的数据&am…
阅读更多...
【机器学习】线性模型

【机器学习】线性模型

文章目录 第三章&#xff1a;线性模型一、线性回归模型1.1、线性回归模型1.2、求解线性回归模型&#xff08;时刻要分清维度&#xff09;1.3、多输出线性回归模型 二、线性分类模型2.1、判别函数2.2、概率判别模型2.3、概率生成模型 第三章&#xff1a;线性模型 一、线性回归模…
阅读更多...
怎么把视频压缩到500m以下？

怎么把视频压缩到500m以下？

如何把视频压缩到500m以下&#xff1f;视频文件通常是非常大的&#xff0c;特别是高清视频或超高清视频&#xff0c;因此压缩可以帮助将视频文件大小减小&#xff0c;在有限的存储空间中存储更多的视频文件。较大的视频文件在上传和下载时需要较长时间&#xff0c;而压缩视频文…
阅读更多...
Flink学习——Flink中的时间语义和窗口

Flink学习——Flink中的时间语义和窗口

一、时间语义 1.1 为什么会出现时间语义&#xff1f; flink是一个大数据处理引擎&#xff0c;它的最大特点就是分布式。每一个机器都有自己的时间&#xff0c;那么集群当中的时间应该以什么为准呢&#xff1f; 比如&#xff1a;我们希望统计8-9点的数据时&#xff0c;对并行任…
阅读更多...
使用RSD从DEM数据创建用户高程数据层

使用RSD从DEM数据创建用户高程数据层

李国春 SRTM90和Aster DEM的V2/V3是比较常用的免费共享高程数据。用户下载好以后应用到自己的项目时&#xff0c;经常会需要进行拼接合成和投影重采样等。RSD提供了一种创建自己项目的高程数据的方法。 一. 高程图像生成方法 在自己的项目中&#xff0c;选择图1的菜单。 图1…
阅读更多...
使用LabVIEW AI视觉工具包快速实现SIFT特征检测（含源码）

使用LabVIEW AI视觉工具包快速实现SIFT特征检测（含源码）

‍‍&#x1f3e1;博客主页&#xff1a; virobotics的CSDN博客&#xff1a;LabVIEW深度学习、人工智能博主 &#x1f384;所属专栏&#xff1a;『LabVIEW深度学习实战』 &#x1f37b;上期文章&#xff1a; 使用LabVIEW AI视觉工具包快速实现霍夫圆和霍夫直线检测&#xff08;含…
阅读更多...
Jmeter事务控制器聚合报告

Jmeter事务控制器聚合报告

Jmeter 事务控制器。 在Jmeter中&#xff0c;默认一个取样器就是一个事务事务控制器控制其子集取样器&#xff0c;合并为一个事务 添加&#xff1a;逻辑控制器/Logic Controller -> 事务控制器/Transaction Controller TPS: 服务器每秒处理的事务数在事务控制器下添加多个…
阅读更多...
海康威视iVMS综合安防系统任意文件上传漏洞复现（0day）

海康威视iVMS综合安防系统任意文件上传漏洞复现（0day）

0x01 产品简介 海康威视iVMS集中监控应用管理平台&#xff0c;是以安全防范业务应用为导向&#xff0c;以视频图像应用为基础手段&#xff0c;综合视频监控、联网报警、智能分析、运维管理等多种安全防范应用系统&#xff0c;构建的多业务应用综合管理平台。 0x02 漏洞概述 海…
阅读更多...
利用CX-ONE搭建omron PLC仿真环境

利用CX-ONE搭建omron PLC仿真环境

目录 1 安装参考 2 CX-Simulator 2.1 打开软件 2.2 选择PLC配置文件存放位置 2.3 选择PLC类型 2.4 PLC Unit全部选择 2.5 设置FINS通讯 2.6 设置串口通讯 2.7 建立连接 3 CX-Programmer 3.1 新建工程 3.2 设置PLC型号 3.3 设置网络类型 3.4 设置串口通讯 3.5 设…
阅读更多...
chatgpt在哪用？详谈一下gpt的各方面

chatgpt在哪用？详谈一下gpt的各方面

ChatGPT是一种人工智能技术&#xff0c;它可以通过自然语言交互回答各种问题。这种技术已经被广泛应用于各个领域和场景中&#xff0c;帮助人们更好地获取知识和信息。那么&#xff0c;ChatGPT在哪里使用呢&#xff1f;下面我们来探讨一下。 一.chatgpt在哪用 打开任意的浏览器…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023