【2024年华为OD机试】 (A卷,100分)- 二元组个数（Java JS PythonC/C++）

在这里插入图片描述

一、问题描述

以下是题目描述的 Markdown 格式：

题目描述

给定两个数组 a 和 b，若 a[i] == b[j]，则称 [i, j] 为一个二元组。求在给定的两个数组中，二元组的个数。

输入描述

  • 第一行输入 m，表示第一个数组的长度。
  • 第二行输入 m 个数，表示第一个数组 a。
  • 第三行输入 n，表示第二个数组的长度。
  • 第四行输入 n 个数，表示第二个数组 b。

输出描述

输出二元组的个数。

用例

用例 1

输入

4
1 2 3 4
1
1

输出

1

说明
二元组个数为 1 个。

用例 2

输入

6
1 1 2 2 4 5
3
2 2 4

输出

5

说明
二元组个数为 5 个。

代码实现思路

  1. 输入处理：

    • 读取两个数组的长度 m 和 n。
    • 读取两个数组 a 和 b。

  2. 统计二元组：

    • 遍历数组 a 和 b，统计满足 a[i] == b[j] 的二元组个数。

  3. 输出结果：

    • 输出统计结果。

题目解析

题目要求计算两个数组 arrM 和 arrN 中相同元素的出现次数的乘积之和。具体来说，对于每个在 arrM 中出现的元素，如果它也在 arrN 中出现，则计算它在两个数组中出现次数的乘积，并将这些乘积相加。

问题分析

  1. 暴力解法：

    • 使用双重 for 循环遍历 arrM 和 arrN，统计相同元素的出现次数。
    • 时间复杂度为 O(m * n)，其中 m 和 n 分别是 arrM 和 arrN 的长度。
    • 这种方法在 m 和 n 较大时效率较低。

  2. 优化解法：

    • 使用哈希表（字典）分别统计 arrM 和 arrN 中每个元素的出现次数。
    • 然后遍历其中一个哈希表，计算相同元素的出现次数的乘积，并将这些乘积相加。
    • 时间复杂度为 O(m + n)，空间复杂度为 O(m + n)。

优化解法详细步骤

  1. 统计 arrM 中每个元素的出现次数：

    • 使用一个哈希表 countM，键为元素，值为该元素在 arrM 中出现的次数。

  2. 统计 arrN 中每个元素的出现次数：

    • 使用一个哈希表 countN，键为元素，值为该元素在 arrN 中出现的次数。

  3. 计算相同元素的出现次数的乘积：

    • 遍历 countM，对于每个键 key，如果 key 也在 countN 中出现，则计算 countM[key] * countN[key]，并将结果累加到 count 中。

二、JavaScript算法源码

以下是带有详细中文注释和逻辑讲解的 JavaScript 代码：

代码实现

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");// 创建 readline 接口，用于从控制台读取输入
const rl = readline.createInterface({input: process.stdin,  // 输入流为标准输入output: process.stdout, // 输出流为标准输出
});// 存储输入的行数据
const lines = [];// 监听 'line' 事件，每次读取一行输入
rl.on("line", (line) => {lines.push(line); // 将输入的行数据存入 lines 数组// 当 lines 数组中有 4 行数据时，表示输入完成if (lines.length === 4) {// 解析输入数据const m = lines[0] - 0; // 第一个数组的长度，转换为数字const arrM = lines[1].split(" ").map(Number); // 第一个数组，转换为数字数组const n = lines[2] - 0; // 第二个数组的长度，转换为数字const arrN = lines[3].split(" ").map(Number); // 第二个数组，转换为数字数组// 调用算法函数，计算二元组个数并输出结果console.log(getResult(arrM, m, arrN, n));// 清空 lines 数组，以便处理下一组输入lines.length = 0;}
});/*** 计算二元组个数的函数* @param {number[]} arrM 第一个数组* @param {number} m 第一个数组的长度* @param {number[]} arrN 第二个数组* @param {number} n 第二个数组的长度* @returns {number} 二元组的个数*/
function getResult(arrM, m, arrN, n) {// 使用 Set 数据结构存储两个数组的元素，方便快速查找const setM = new Set(arrM); // 第一个数组的元素集合const setN = new Set(arrN); // 第二个数组的元素集合// 统计第一个数组中每个元素在第二个数组中出现的次数const countM = {};for (let m of arrM) {if (setN.has(m)) { // 如果第二个数组中包含当前元素countM[m] ? countM[m]++ : (countM[m] = 1); // 统计该元素的出现次数}}// 统计第二个数组中每个元素在第一个数组中出现的次数const countN = {};for (let n of arrN) {if (setM.has(n)) { // 如果第一个数组中包含当前元素countN[n] ? countN[n]++ : (countN[n] = 1); // 统计该元素的出现次数}}// 计算二元组的总数let count = 0;for (let k in countM) {// 对于每个共同元素，其二元组个数为 countM[k] * countN[k]count += countM[k] * countN[k];}// 返回二元组的总数return count;
}

代码讲解

1. 输入处理
  • 使用 readline 模块从控制台读取输入。
  • 将输入的行数据存储在 lines 数组中。
  • 当 lines 数组中有 4 行数据时，表示输入完成，开始解析数据：
    • 第一行：第一个数组的长度 m。
    • 第二行：第一个数组 arrM。
    • 第三行：第二个数组的长度 n。
    • 第四行：第二个数组 arrN。
2. 算法逻辑：getResult 函数
  • 步骤 1：使用 Set 存储数组元素
    • 将两个数组 arrM 和 arrN 转换为 Set 集合 setM 和 setN，方便快速查找。
  • 步骤 2：统计共同元素的出现次数
    • 遍历 arrM，统计每个元素在 arrN 中出现的次数，结果存储在 countM 对象中。
    • 遍历 arrN，统计每个元素在 arrM 中出现的次数，结果存储在 countN 对象中。
  • 步骤 3：计算二元组总数
    • 对于每个共同元素 k，其二元组个数为 countM[k] * countN[k]。
    • 将所有共同元素的二元组个数累加，得到总数 count。
  • 步骤 4：返回结果
    • 返回二元组的总数 count。

示例解析

输入
6
1 1 2 2 4 5
3
2 2 4
运行结果
5
  • 解析：
    • 共同元素为 2 和 4。
    • 在 arrM 中：
      • 2 出现 2 次。
      • 4 出现 1 次。
    • 在 arrN 中：
      • 2 出现 2 次。
      • 4 出现 1 次。
    • 二元组总数：
      • 2 的二元组个数：2 * 2 = 4。
      • 4 的二元组个数：1 * 1 = 1。
      • 总数为 4 + 1 = 5。

总结

  • 该代码通过 Set 和哈希表（对象）高效地统计了共同元素的出现次数。
  • 时间复杂度为 O(m + n)，空间复杂度为 O(m + n)，适用于处理大规模数据。
  • 代码逻辑清晰，注释详细，易于理解和扩展。

如果有其他问题，欢迎随时提问！

三、Java算法源码

以下是带有详细中文注释和逻辑讲解的 Java 代码：

代码实现

import java.util.*;
import java.util.stream.Collectors;public class Main {public static void main(String[] args) {// 创建 Scanner 对象，用于从控制台读取输入Scanner sc = new Scanner(System.in);// 读取第一个数组的长度 mint m = Integer.parseInt(sc.nextLine());// 读取第一个数组，并将其转换为 List<Integer>List<Integer> listM =Arrays.stream(sc.nextLine().split(" ")) // 按空格分割字符串.map(Integer::parseInt)          // 将字符串转换为整数.collect(Collectors.toList());   // 收集为 List// 读取第二个数组的长度 nint n = Integer.parseInt(sc.nextLine());// 读取第二个数组，并将其转换为 List<Integer>List<Integer> listN =Arrays.stream(sc.nextLine().split(" ")) // 按空格分割字符串.map(Integer::parseInt)          // 将字符串转换为整数.collect(Collectors.toList());   // 收集为 List// 调用算法函数，计算二元组个数并输出结果System.out.println(getResult(listM, listN));}/*** 计算二元组个数的函数* @param listM 第一个数组* @param listN 第二个数组* @return 二元组的个数*/public static int getResult(List<Integer> listM, List<Integer> listN) {// 使用 HashSet 存储两个数组的元素，方便快速查找HashSet<Integer> setM = new HashSet<Integer>(listM); // 第一个数组的元素集合HashSet<Integer> setN = new HashSet<Integer>(listN); // 第二个数组的元素集合// 统计第一个数组中每个元素在第二个数组中出现的次数HashMap<Integer, Integer> countM = new HashMap<>();for (Integer m : listM) {if (setN.contains(m)) { // 如果第二个数组中包含当前元素// 使用 getOrDefault 方法统计该元素的出现次数countM.put(m, countM.getOrDefault(m, 0) + 1);}}// 统计第二个数组中每个元素在第一个数组中出现的次数HashMap<Integer, Integer> countN = new HashMap<>();for (Integer n : listN) {if (setM.contains(n)) { // 如果第一个数组中包含当前元素// 使用 getOrDefault 方法统计该元素的出现次数countN.put(n, countN.getOrDefault(n, 0) + 1);}}// 计算二元组的总数int count = 0;for (Integer k : countM.keySet()) {// 对于每个共同元素，其二元组个数为 countM.get(k) * countN.get(k)count += countM.get(k) * countN.get(k);}// 返回二元组的总数return count;}
}

代码讲解

1. 输入处理
  • 使用 Scanner 从控制台读取输入。
  • 读取第一个数组的长度 m 和数组内容，并将其转换为 List<Integer>。
  • 读取第二个数组的长度 n 和数组内容，并将其转换为 List<Integer>。
2. 算法逻辑：getResult 函数
  • 步骤 1：使用 HashSet 存储数组元素
    • 将两个数组 listM 和 listN 转换为 HashSet 集合 setM 和 setN，方便快速查找。
  • 步骤 2：统计共同元素的出现次数
    • 遍历 listM，统计每个元素在 listN 中出现的次数，结果存储在 countM 哈希表中。
    • 遍历 listN，统计每个元素在 listM 中出现的次数，结果存储在 countN 哈希表中。
  • 步骤 3：计算二元组总数
    • 对于每个共同元素 k，其二元组个数为 countM.get(k) * countN.get(k)。
    • 将所有共同元素的二元组个数累加，得到总数 count。
  • 步骤 4：返回结果
    • 返回二元组的总数 count。

示例解析

输入
6
1 1 2 2 4 5
3
2 2 4
运行结果
5
  • 解析：
    • 共同元素为 2 和 4。
    • 在 listM 中：
      • 2 出现 2 次。
      • 4 出现 1 次。
    • 在 listN 中：
      • 2 出现 2 次。
      • 4 出现 1 次。
    • 二元组总数：
      • 2 的二元组个数：2 * 2 = 4。
      • 4 的二元组个数：1 * 1 = 1。
      • 总数为 4 + 1 = 5。

总结

  • 该代码通过 HashSet 和 HashMap 高效地统计了共同元素的出现次数。
  • 时间复杂度为 O(m + n)，空间复杂度为 O(m + n)，适用于处理大规模数据。
  • 代码逻辑清晰，注释详细，易于理解和扩展。

如果有其他问题，欢迎随时提问！

四、Python算法源码

以下是带有详细中文注释和逻辑讲解的 Python 代码：

代码实现

# 输入获取
# 读取第一个数组的长度 m
m = int(input())
# 读取第一个数组，并将其转换为整数列表
arrM = list(map(int, input().split()))# 读取第二个数组的长度 n
n = int(input())
# 读取第二个数组，并将其转换为整数列表
arrN = list(map(int, input().split()))# 算法入口
def getResult(arrM, arrN):# 使用集合存储两个数组的元素，方便快速查找setM = set(arrM)  # 第一个数组的元素集合setN = set(arrN)  # 第二个数组的元素集合# 统计第一个数组中每个元素在第二个数组中出现的次数countM = {}for m in arrM:if m in setN:  # 如果第二个数组中包含当前元素if countM.get(m) is None:  # 如果该元素还未被统计过countM[m] = 1  # 初始化计数为 1else:countM[m] += 1  # 否则计数加 1# 统计第二个数组中每个元素在第一个数组中出现的次数countN = {}for n in arrN:if n in setM:  # 如果第一个数组中包含当前元素if countN.get(n) is None:  # 如果该元素还未被统计过countN[n] = 1  # 初始化计数为 1else:countN[n] += 1  # 否则计数加 1# 计算二元组的总数count = 0for k in countM.keys():  # 遍历所有共同元素# 对于每个共同元素，其二元组个数为 countM[k] * countN[k]count += countM[k] * countN[k]# 返回二元组的总数return count# 算法调用
print(getResult(arrM, arrN))

代码讲解

1. 输入处理
  • 使用 input() 函数从控制台读取输入。
  • 读取第一个数组的长度 m 和数组内容，并将其转换为整数列表 arrM。
  • 读取第二个数组的长度 n 和数组内容，并将其转换为整数列表 arrN。
2. 算法逻辑：getResult 函数
  • 步骤 1：使用集合存储数组元素
    • 将两个数组 arrM 和 arrN 转换为集合 setM 和 setN，方便快速查找。
  • 步骤 2：统计共同元素的出现次数
    • 遍历 arrM，统计每个元素在 arrN 中出现的次数，结果存储在字典 countM 中。
    • 遍历 arrN，统计每个元素在 arrM 中出现的次数，结果存储在字典 countN 中。
  • 步骤 3：计算二元组总数
    • 对于每个共同元素 k，其二元组个数为 countM[k] * countN[k]。
    • 将所有共同元素的二元组个数累加，得到总数 count。
  • 步骤 4：返回结果
    • 返回二元组的总数 count。

示例解析

输入
6
1 1 2 2 4 5
3
2 2 4
运行结果
5
  • 解析：
    • 共同元素为 2 和 4。
    • 在 arrM 中：
      • 2 出现 2 次。
      • 4 出现 1 次。
    • 在 arrN 中：
      • 2 出现 2 次。
      • 4 出现 1 次。
    • 二元组总数：
      • 2 的二元组个数：2 * 2 = 4。
      • 4 的二元组个数：1 * 1 = 1。
      • 总数为 4 + 1 = 5。

总结

  • 该代码通过集合和字典高效地统计了共同元素的出现次数。
  • 时间复杂度为 O(m + n)，空间复杂度为 O(m + n)，适用于处理大规模数据。
  • 代码逻辑清晰，注释详细，易于理解和扩展。

如果有其他问题，欢迎随时提问！

五、C/C++算法源码：

以下是C++ 实现，并附有详细的中文注释和逻辑讲解：

C++ 代码实现

#include <iostream>
#include <vector>
#include <unordered_set>
#include <unordered_map>using namespace std;/*** 计算二元组个数的函数* @param arrM 第一个数组* @param arrN 第二个数组* @return 二元组的个数*/
int getResult(const vector<int>& arrM, const vector<int>& arrN) {// 使用 unordered_set 存储两个数组的元素，方便快速查找unordered_set<int> setM(arrM.begin(), arrM.end()); // 第一个数组的元素集合unordered_set<int> setN(arrN.begin(), arrN.end()); // 第二个数组的元素集合// 统计第一个数组中每个元素在第二个数组中出现的次数unordered_map<int, int> countM;for (int m : arrM) {if (setN.count(m)) { // 如果第二个数组中包含当前元素countM[m]++; // 统计该元素的出现次数}}// 统计第二个数组中每个元素在第一个数组中出现的次数unordered_map<int, int> countN;for (int n : arrN) {if (setM.count(n)) { // 如果第一个数组中包含当前元素countN[n]++; // 统计该元素的出现次数}}// 计算二元组的总数int count = 0;for (const auto& pair : countM) {int k = pair.first; // 共同元素// 对于每个共同元素，其二元组个数为 countM[k] * countN[k]count += pair.second * countN[k];}// 返回二元组的总数return count;
}int main() {// 读取第一个数组的长度 mint m;cin >> m;// 读取第一个数组vector<int> arrM(m);for (int i = 0; i < m; i++) {cin >> arrM[i];}// 读取第二个数组的长度 nint n;cin >> n;// 读取第二个数组vector<int> arrN(n);for (int i = 0; i < n; i++) {cin >> arrN[i];}// 调用算法函数，计算二元组个数并输出结果cout << getResult(arrM, arrN) << endl;return 0;
}

代码讲解

1. 输入处理
  • 使用 cin 从标准输入读取数据。
  • 读取第一个数组的长度 m 和数组内容，并将其存储在 vector<int> arrM 中。
  • 读取第二个数组的长度 n 和数组内容，并将其存储在 vector<int> arrN 中。
2. 算法逻辑：getResult 函数
  • 步骤 1：使用 unordered_set 存储数组元素
    • 将两个数组 arrM 和 arrN 转换为 unordered_set 集合 setM 和 setN，方便快速查找。
  • 步骤 2：统计共同元素的出现次数
    • 遍历 arrM，统计每个元素在 arrN 中出现的次数，结果存储在 unordered_map<int, int> countM 中。
    • 遍历 arrN，统计每个元素在 arrM 中出现的次数，结果存储在 unordered_map<int, int> countN 中。
  • 步骤 3：计算二元组总数
    • 对于每个共同元素 k，其二元组个数为 countM[k] * countN[k]。
    • 将所有共同元素的二元组个数累加，得到总数 count。
  • 步骤 4：返回结果
    • 返回二元组的总数 count。

示例解析

输入
6
1 1 2 2 4 5
3
2 2 4
运行结果
5
  • 解析：
    • 共同元素为 2 和 4。
    • 在 arrM 中：
      • 2 出现 2 次。
      • 4 出现 1 次。
    • 在 arrN 中：
      • 2 出现 2 次。
      • 4 出现 1 次。
    • 二元组总数：
      • 2 的二元组个数：2 * 2 = 4。
      • 4 的二元组个数：1 * 1 = 1。
      • 总数为 4 + 1 = 5。

总结

  • 该代码通过 unordered_set 和 unordered_map 高效地统计了共同元素的出现次数。
  • 时间复杂度为 O(m + n)，空间复杂度为 O(m + n)，适用于处理大规模数据。
  • 代码逻辑清晰，注释详细，易于理解和扩展。

如果有其他问题，欢迎随时提问！

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

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

相关文章

Homebrew 【MAC安装软件利器】

Homebrew 【MAC安装软件利器】

1、brew介绍 Homebrew游来: Homebrew 的诞生源于一个年轻程序员的不满和创新。2009 年&#xff0c;Max Howell 当时是一名在苹果公司工作的程序员。他觉得在 Mac 上安装和管理开源软件特别麻烦&#xff0c;常常需要手动下载源代码、解决依赖关系、编译安装&#xff0c;过程繁琐…
阅读更多...
AOP实现操作日志记录

AOP实现操作日志记录

文章目录 1.common-log4j2-starter1.目录2.pom.xml 引入依赖3.LogAspect.java4.Log4j2AutoConfiguration.java Log4j2自动配置类条件注入切面类 2.common-log4j2-starter-demo 测试1.目录2.application.yml 启用日志切面3.TraceController.java4.结果 1.common-log4j2-starter …
阅读更多...
JavaEE之线程池

JavaEE之线程池

前面我们了解了多个任务可以通过创建多个线程去处理&#xff0c;达到节约时间的效果&#xff0c;但是每一次的线程创建和销毁也是会消耗计算机资源的&#xff0c;那么我们是否可以将线程进阶一下&#xff0c;让消耗计算机的资源尽可能缩小呢&#xff1f;线程池可以达到此效果&a…
阅读更多...
YOLOv11改进，YOLOv11添加HAttention注意机制用于图像修复的混合注意力转换器，CVPR2023，超分辨率重建

YOLOv11改进，YOLOv11添加HAttention注意机制用于图像修复的混合注意力转换器，CVPR2023，超分辨率重建

摘要 基于Transformer的方法在低层视觉任务中表现出色，例如图像超分辨率。然而，作者通过归因分析发现，这些网络只能利用有限的空间范围的输入信息。这意味着现有网络尚未充分发挥Transformer的潜力。为了激活更多的输入像素以获得更好的重建效果，作者提出了一种新型的混合…
阅读更多...
Shader -＞ SweepGradient扫描渐变着色器详解

Shader -＞ SweepGradient扫描渐变着色器详解

XML文件 <com.example.myapplication.MyViewxmlns:android"http://schemas.android.com/apk/res/android"android:layout_width"match_parent"android:layout_gravity"center"android:layout_height"400dp"/>自定义View代码 c…
阅读更多...
LabVIEW调用不定长数组 DLL数组

LabVIEW调用不定长数组 DLL数组

在使用 LabVIEW 调用 DLL 库函数时&#xff0c;如果函数中的结构体包含不定长数组&#xff0c;直接通过 调用库函数节点&#xff08;Call Library Function Node&#xff09; 调用通常会遇到问题。这是因为 LabVIEW 需要与 DLL 中的数据结构完全匹配&#xff0c;而包含不定长数…
阅读更多...
IOS开发如何从入门进阶到高级

IOS开发如何从入门进阶到高级

针对iOS开发的学习&#xff0c;不同阶段应采取不同的学习方式&#xff0c;以实现高效提升.本文将iOS开发的学习分为入门、实战、进阶三个阶段&#xff0c;下面分别详细介绍. 一、学习社区 iOS开源中国社区 这个社区专注于iOS开发的开源项目分享与协作&#xff0c;汇集了大量开…
阅读更多...
Next.js 实战 (七)：浅谈 Layout 布局的嵌套设计模式

Next.js 实战 (七)：浅谈 Layout 布局的嵌套设计模式

业务场景 在目前常见的中后台管理系统中&#xff0c;比较常见的是固定的布局方式包裹页面&#xff0c;但一些特殊页面&#xff0c;比如&#xff1a;登录页面、注册页面、忘记密码页面这些页面是不需要布局包裹的。 但在 Next.js AppRouter 中&#xff0c;必须包含一个根布局文…
阅读更多...
基于 Python 和 OpenCV 的人脸识别上课考勤管理系统

基于 Python 和 OpenCV 的人脸识别上课考勤管理系统

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝12w、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;…
阅读更多...
人工智能与物联网：智慧城市的未来

人工智能与物联网：智慧城市的未来

引言 清晨6点&#xff0c;智能闹钟根据你的睡眠状态和天气情况&#xff0c;自动调整叫醒时间&#xff1b;窗帘缓缓打开&#xff0c;阳光洒满房间&#xff1b;厨房里的咖啡机已经为你准备好热饮&#xff0c;而无人驾驶公交车正按时抵达楼下站点。这不是科幻电影的场景&#xff…
阅读更多...
python-leetcode-无重复字符的最长子串

python-leetcode-无重复字符的最长子串

3. 无重复字符的最长子串 - 力扣&#xff08;LeetCode&#xff09; class Solution:def lengthOfLongestSubstring(self, s: str) -> int:char_set set()left 0max_length 0for right in range(len(s)):while s[right] in char_set:char_set.remove(s[left])left 1char_…
阅读更多...
新版本的IDEA如何解决Git分支显示为警告⚠＜unknown＞的问题

新版本的IDEA如何解决Git分支显示为警告⚠＜unknown＞的问题

目录 问题再现 解决思路 首先我们要想到 这个分支有没有从远程代码仓库拉去下来 复习一下 git 命令 其次思考 最后思考 问题再现 这边我使用的是 IDEA 2024.3.3.1 Jetbrains 官网的最新版 同时也是官方账号登录 的 今天上 github 去拉项目到 本地 出现了分支不显示的问…
阅读更多...
libusb学习——简单介绍

libusb学习——简单介绍

文章目录 libusb 简介libusb 编译libusb 源码目录介绍核心代码文件平台支持例子 API使用libusb初始化和去初始化libusb设备处理和枚举libusb 杂项libusb USB描述符libusb 设备热插拔事件通知libusb 异步设备I/Olibusb 同步设备I/Olibusb 轮询与定时 libusb 涉及技术参考 libusb…
阅读更多...
案例解读 | 香港某多元化综合金融企业基础监控+网管平台建设实践

案例解读 | 香港某多元化综合金融企业基础监控+网管平台建设实践

PART01 项目背景 01客户简介案例客户是一家创立20多年的香港某多元化综合金融企业&#xff0c;其业务范围涵盖证券、期货、资产管理、财富管理等&#xff0c;凭借广泛的业务网络和多元化的金融服务产品&#xff0c;在市场中拥有显著的影响力。02痛点分析随着业务版图的持续拓展…
阅读更多...
551 灌溉

551 灌溉

常规解法&#xff1a; #include<bits/stdc.h> using namespace std; int n,m,k,t; const int N105; bool a[N][N],b[N][N]; int cnt; //设置滚动数组来存贮当前和下一状态的条件 //处理传播扩散问题非常有效int main() {cin>>n>>m>>t;for(int i1;i&l…
阅读更多...
【简博士统计学习方法】第1章：4. 模型的评估与选择

【简博士统计学习方法】第1章：4. 模型的评估与选择

4. 模型的评估与选择 4.1 训练误差与测试误差 假如存在样本容量为 N N N的训练集&#xff0c;将训练集送入学习系统可以训练学习得到一个模型&#xff0c;我们将这么模型用决策函数的形式表达&#xff0c;也就是 y f ^ ( x ) y\hat{f}(x) yf^​(x)&#xff0c;关于模型的拟合…
阅读更多...
【css】浏览器强制设置元素状态（hover|focus……）

【css】浏览器强制设置元素状态（hover|focus……）

直接上步骤&#xff1a; 打开浏览器控制台 → 找到样式选项 → 找到:hov选项 → 点击:hov选项&#xff0c;会展开【设置元素状态】。 只要选中就会展示出自己写在css里面的该种状态下的样式了。
阅读更多...
LabVIEW水轮发电机组振动摆度故障诊断

LabVIEW水轮发电机组振动摆度故障诊断

本文介绍了基于LabVIEW的水轮发电机组振动摆度故障诊断系统的设计与实施过程。系统在通过高效的故障诊断功能&#xff0c;实现水轮发电机组的振动、温度等关键指标的实时监控与智能分析&#xff0c;从而提高电力设备的可靠性和安全性。 ​ 项目背景 随着电力行业对设备稳定性…
阅读更多...
pytorch模型的保存失敗しましたが、

pytorch模型的保存失敗しましたが、

目录 简洁&#xff1a; 评估模式 后缀 区别 保存模型&#xff08;整个模型&#xff09; 加载过程: 保存状态字典 加载过程: 总结 把模型训练到一半保存&#xff0c;想下次接着训练&#xff0c;用那种保存方式 保存模型和优化器状态字典 加载模型和优化器状态字典 如…
阅读更多...
风水算命系统架构与功能分析

风水算命系统架构与功能分析

系统架构 服务端&#xff1a;Java&#xff08;最低JDK1.8&#xff0c;支持JDK11以及JDK17&#xff09;数据库&#xff1a;MySQL数据库&#xff08;标配5.7版本&#xff0c;支持MySQL8&#xff09;ORM框架&#xff1a;Mybatis&#xff08;集成通用tk-mapper&#xff0c;支持myb…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023