华为OD机试真题——告警抑制（2025A卷：100分）Java/python/JavaScript/C/C++/GO最佳实现

在这里插入图片描述

2025 A卷 100分 题型

本专栏内全部题目均提供Java、python、JavaScript、C、C++、GO六种语言的最佳实现方式；
并且每种语言均涵盖详细的问题分析、解题思路、代码实现、代码详解、3个测试用例以及综合分析；
本文收录于专栏：《2025华为OD真题目录+全流程解析+备考攻略+经验分享》

华为OD机试真题《告警抑制》：

文章快捷目录

题目描述及说明

Java

python

JavaScript

C

GO

更多内容

题目名称：告警抑制

  1. 知识点：字符串处理、哈希映射（逻辑处理）
  2. 时间限制：1秒
  3. 空间限制：256MB
  4. 限定语言：不限

题目描述

告警抑制是指高优先级告警抑制低优先级告警的规则。高优先级告警产生后，低优先级告警不再产生。请根据原始告警列表和告警抑制关系，给出实际产生的告警列表。

输入描述：

  1. 第一行为数字 N，表示告警抑制关系个数（0 ≤ N ≤ 120）。
  2. 接下来 N 行，每行由空格分隔的两个告警ID（格式：大写字母+0或1个数字），例如 A B，表示 A 抑制 B。
  3. 最后一行为告警产生列表，列表长度范围为 [1,100]，告警ID间以空格分隔。

输出描述：
真实产生的告警列表（未被抑制的告警），按输入顺序输出，ID间以空格分隔。

示例：
输入：

2  
A B  
B C  
A B C D E

输出：

A D E

解释：

  • A 抑制 B，B 抑制 C，因此 B 和 C 被抑制，最终输出 A D E。
补充规则：
  1. 无循环抑制：不会出现 A→B→A 的循环关系。
  2. 无传递抑制：例如 A→B→C 时，A 不直接抑制 C，但被抑制的 B 仍可抑制 C。
  3. 位置无关：被抑制的告警无论在高优先级告警的前后，均被屏蔽。

Java

问题分析

我们需要根据给定的告警抑制关系和原始告警列表，输出实际产生的未被抑制的告警列表。高优先级告警会抑制低优先级告警，无论它们在输入列表中的顺序如何。

解题思路

  1. 建立抑制关系映射：记录每个告警被哪些高优先级告警抑制。
  2. 快速判断抑制存在性：通过集合快速检查某个告警是否存在于输入列表中。
  3. 遍历原始告警列表：对于每个告警，检查是否存在抑制它的告警存在于输入列表中，若存在则过滤，否则保留。

代码实现

import java.util.*;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int N = Integer.parseInt(scanner.nextLine()); // 读取抑制关系个数// 建立抑制关系映射表：key是被抑制的告警，value是抑制它的告警集合Map<String, Set<String>> suppressionMap = new HashMap<>();for (int i = 0; i < N; i++) {String[] parts = scanner.nextLine().split(" ");String suppressor = parts[0]; // 抑制者，例如AString suppressed = parts[1]; // 被抑制者，例如Bif (!suppressionMap.containsKey(suppressed)) {suppressionMap.put(suppressed, new HashSet<>());}suppressionMap.get(suppressed).add(suppressor);}// 读取原始告警列表，并转换为集合用于快速查询String[] alerts = scanner.nextLine().split(" ");Set<String> inputSet = new HashSet<>(Arrays.asList(alerts));List<String> result = new ArrayList<>(); // 保存未被抑制的告警for (String alert : alerts) {boolean isSuppressed = false;// 检查当前告警是否有抑制者存在于输入列表中if (suppressionMap.containsKey(alert)) {for (String suppressor : suppressionMap.get(alert)) {if (inputSet.contains(suppressor)) {isSuppressed = true;break;}}}if (!isSuppressed) {result.add(alert); // 未被抑制，加入结果}}// 按输入顺序输出结果System.out.println(String.join(" ", result));}
}

代码详细解析

  1. 读取抑制关系个数：使用 scanner.nextLine() 读取第一行并转换为整数 N。
  2. 建立抑制关系映射：
    • 使用 HashMap 存储，键为被抑制的告警，值为抑制它的告警集合。
    • 遍历 N 行，每行拆分为抑制者和被抑制者，将被抑制者作为键，抑制者添加到对应的集合。
  3. 读取原始告警列表：拆分为数组并转换为集合 inputSet 用于快速查询。
  4. 过滤被抑制的告警：
    • 遍历每个告警，检查是否存在抑制它的告警在 inputSet 中。
    • 若存在，则跳过；否则加入结果列表。
  5. 输出结果：按输入顺序拼接未被抑制的告警。

示例测试

示例1：
输入：

2
A B
B C
A B C D E

输出：

A D E

解析：A 抑制 B，B 抑制 C，B 和 C 被过滤，D、E 无抑制。

示例2：
输入：

1
B A
B A

输出：

B

解析：B 抑制 A，A 被过滤，B 被保留。

示例3：
输入：

0
A B C

输出：

A B C

解析：无抑制关系，所有告警均保留。

综合分析

  1. 时间复杂度：O(N + M*K)，其中 N 为抑制关系数，M 为告警列表长度，K 为每个告警的抑制者数量。高效处理最大数据规模。
  2. 空间复杂度：O(N + M)，存储抑制关系和输入集合。
  3. 正确性：通过抑制关系映射和集合查询，确保所有抑制条件被正确判断。
  4. 适用性：处理所有合法输入，包括重复告警和不同顺序的抑制关系。

python

问题分析

我们需要根据给定的告警抑制关系和原始告警列表，输出实际产生的未被抑制的告警列表。高优先级告警会抑制低优先级告警，无论它们在输入列表中的顺序如何。

解题思路

  1. 建立抑制关系映射：记录每个告警被哪些高优先级告警抑制。
  2. 快速判断抑制存在性：通过集合快速检查某个告警是否存在于输入列表中。
  3. 遍历原始告警列表：对于每个告警，检查是否存在抑制它的告警存在于输入列表中，若存在则过滤，否则保留。

代码实现

from collections import defaultdictdef main():n = int(input())  # 读取抑制关系个数suppression = defaultdict(set)  # 抑制关系映射表：被抑制的告警 → 抑制它的告警集合# 读取所有抑制关系for _ in range(n):suppressor, suppressed = input().strip().split()suppression[suppressed].add(suppressor)# 读取原始告警列表，并保留原始顺序alerts = input().strip().split()existing_alerts = set(alerts)  # 用于快速判断告警是否存在result = []for alert in alerts:# 检查当前告警是否被抑制is_suppressed = False# 如果当前告警存在于抑制关系中if alert in suppression:# 遍历所有能抑制它的告警，判断是否存在于原始列表for suppressor in suppression[alert]:if suppressor in existing_alerts:is_suppressed = Truebreak  # 只要有一个抑制者存在即可跳过if not is_suppressed:result.append(alert)print(' '.join(result))if __name__ == "__main__":main()

代码详细解析

  1. 读取输入：

    • n：抑制关系数量。
    • suppression：使用 defaultdict(set) 存储抑制关系。例如 A B 表示 B 被 A 抑制，存入 suppression['B'].add('A')。

  2. 处理原始告警列表：

    • alerts：保留原始顺序的告警列表。
    • existing_alerts：转换为集合用于快速查询。

  3. 过滤逻辑：

    • 遍历每个告警 alert。
    • 如果该告警在抑制关系中（suppression 字典中存在），检查其所有抑制者是否存在于 existing_alerts。
    • 只要有一个抑制者存在，则当前告警被过滤。

  4. 输出结果：按原始顺序输出未被抑制的告警。

示例测试

示例1：
输入：

2
A B
B C
A B C D E

输出：

A D E

解析：A 抑制 B，B 抑制 C，B 和 C 被抑制。

示例2：
输入：

1
B A
B A

输出：

B

解析：B 抑制 A，A 被过滤。

示例3：
输入：

0
A B C

输出：

A B C

解析：无抑制关系，所有告警保留。

综合分析

  1. 时间复杂度：O(N + M*K)

    • N 是抑制关系数量，M 是告警列表长度，K 是每个告警的最大抑制者数量。
    • 集合查询和遍历抑制者的时间复杂度为 O(1) 和 O(K)，总体高效。

  2. 空间复杂度：O(N + M)

    • 存储抑制关系和原始告警列表。

  3. 正确性：

    • 通过集合快速判断抑制者是否存在，确保所有抑制条件被正确检查。

  4. 适用性：

    • 处理所有合法输入，包括重复告警和多级抑制关系。

JavaScript

问题分析

我们需要根据给定的告警抑制关系和原始告警列表，输出实际产生的未被抑制的告警列表。高优先级告警会抑制低优先级告警，无论它们在输入列表中的顺序如何。

解题思路

  1. 建立抑制关系映射：记录每个告警被哪些高优先级告警抑制。
  2. 快速判断抑制存在性：通过集合快速检查某个告警是否存在于输入列表中。
  3. 遍历原始告警列表：对于每个告警，检查是否存在抑制它的告警存在于输入列表中，若存在则过滤，否则保留。

代码实现

const readline = require('readline');const rl = readline.createInterface({input: process.stdin,output: process.stdout
});let n; // 抑制关系数量
let lineCount = 0;
const suppressionMap = {}; // 抑制关系表：{ 被抑制的告警: Set(抑制者) }
let originalAlerts; // 原始告警列表rl.on('line', (line) => {if (lineCount === 0) { // 第一行读取Nn = parseInt(line);lineCount++;} else if (lineCount <= n) { // 读取N行抑制关系const [suppressor, suppressed] = line.trim().split(' ');if (!suppressionMap[suppressed]) {suppressionMap[suppressed] = new Set();}suppressionMap[suppressed].add(suppressor);lineCount++;} else { // 最后一行读取原始告警列表originalAlerts = line.trim().split(' ');rl.close();}
});rl.on('close', () => {const existingAlerts = new Set(originalAlerts); // 原始告警集合（快速查询）const result = [];for (const alert of originalAlerts) {let isSuppressed = false;if (suppressionMap[alert]) { // 检查当前告警是否被抑制// 遍历所有抑制者，判断是否存在于原始列表for (const suppressor of suppressionMap[alert]) {if (existingAlerts.has(suppressor)) {isSuppressed = true;break;}}}if (!isSuppressed) {result.push(alert); // 未被抑制，加入结果}}console.log(result.join(' '));
});

代码详细解析

  1. 输入处理：

    • 使用 readline 逐行读取输入，第一行解析为抑制关系数量 n。
    • 后续 n 行解析为抑制关系，存入 suppressionMap 对象，键为被抑制的告警，值为抑制者的集合。
    • 最后一行读取原始告警列表，转换为数组 originalAlerts。

  2. 抑制关系映射：

    if (!suppressionMap[suppressed]) {suppressionMap[suppressed] = new Set();
}
suppressionMap[suppressed].add(suppressor);
    • 若被抑制的告警不存在于映射表，初始化其对应的集合。
    • 将抑制者添加到被抑制告警的集合中。

  3. 过滤逻辑：

    const existingAlerts = new Set(originalAlerts); // 快速查询集合
for (const alert of originalAlerts) {if (suppressionMap[alert]) { // 当前告警可能被抑制for (const suppressor of suppressionMap[alert]) {if (existingAlerts.has(suppressor)) { // 抑制者存在isSuppressed = true;break;}}}if (!isSuppressed) result.push(alert);
}
    • 遍历原始告警列表，检查每个告警是否被抑制。
    • 若存在抑制者存在于原始列表中，过滤该告警；否则保留。

示例测试

示例1：
输入：

2
A B
B C
A B C D E

输出：

A D E

解析：A 抑制 B，B 抑制 C，B 和 C 被过滤。

示例2：
输入：

1
B A
B A

输出：

B

解析：B 抑制 A，A 被过滤。

示例3：
输入：

0
A B C

输出：

A B C

解析：无抑制关系，所有告警保留。

综合分析

  1. 时间复杂度：O(N + M*K)

    • N 是抑制关系数量，M 是告警列表长度，K 是每个告警的抑制者数量。
    • 集合查询时间为 O(1)，遍历抑制关系的时间为 O(K)。

  2. 空间复杂度：O(N + M)

    • 存储抑制关系和原始告警列表。

  3. 正确性：

    • 通过集合快速判断抑制者是否存在，确保所有抑制条件被正确过滤。

  4. 适用性：

    • 处理所有合法输入，包括重复告警和多级抑制关系。

C++

问题分析

我们需要根据给定的告警抑制关系和原始告警列表，输出实际产生的未被抑制的告警列表。高优先级告警会抑制低优先级告警，无论它们在输入列表中的顺序如何。

解题思路

  1. 建立抑制关系映射：记录每个告警被哪些高优先级告警抑制。
  2. 快速判断抑制存在性：通过集合快速检查某个告警是否存在于输入列表中。
  3. 遍历原始告警列表：对于每个告警，检查是否存在抑制它的告警存在于输入列表中，若存在则过滤，否则保留。

代码实现

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <unordered_map>
#include <unordered_set>using namespace std;int main() {// 读取抑制关系数量string line;getline(cin, line);int N = stoi(line);// 建立抑制关系映射表：key是被抑制的告警，value是抑制它的告警集合unordered_map<string, unordered_set<string>> suppressionMap;for (int i = 0; i < N; ++i) {getline(cin, line);istringstream iss(line);string suppressor, suppressed;iss >> suppressor >> suppressed;suppressionMap[suppressed].insert(suppressor);}// 读取原始告警列表并存入集合和数组getline(cin, line);istringstream iss_alerts(line);vector<string> alerts;unordered_set<string> alertSet;string alert;while (iss_alerts >> alert) {alerts.push_back(alert);alertSet.insert(alert);}// 过滤被抑制的告警vector<string> result;for (const string& a : alerts) {bool isSuppressed = false;if (suppressionMap.find(a) != suppressionMap.end()) {for (const string& suppressor : suppressionMap[a]) {if (alertSet.count(suppressor)) {isSuppressed = true;break;}}}if (!isSuppressed) {result.push_back(a);}}// 输出结果for (size_t i = 0; i < result.size(); ++i) {if (i > 0) cout << " ";cout << result[i];}cout << endl;return 0;
}

代码详细解析

  1. 读取抑制关系数量：

    • 使用 getline 读取第一行并转换为整数 N。

  2. 建立抑制关系映射：

    • 使用 unordered_map 存储，键为被抑制的告警，值为抑制者的集合。
    • 逐行读取抑制关系，将被抑制的告警作为键，抑制者添加到对应的集合。

  3. 处理原始告警列表：

    • 读取原始告警列表，存入 alerts 数组（保留顺序）和 alertSet 集合（快速查询）。

  4. 过滤逻辑：

    • 遍历每个告警，检查是否存在抑制者存在于 alertSet 中。
    • 若存在，则跳过；否则保留该告警。

  5. 输出结果：

    • 按原始顺序输出未被抑制的告警，用空格分隔。

示例测试

示例1：
输入：

2
A B
B C
A B C D E

输出：

A D E

解析：A 抑制 B，B 抑制 C，B 和 C 被过滤。

示例2：
输入：

1
B A
B A

输出：

B

解析：B 抑制 A，A 被过滤。

示例3：
输入：

0
A B C

输出：

A B C

解析：无抑制关系，所有告警保留。

综合分析

  1. 时间复杂度：O(N + M*K)

    • N 是抑制关系数量，M 是告警列表长度，K 是每个告警的抑制者数量。
    • 集合查询时间为 O(1)，遍历抑制关系的时间为 O(K)。

  2. 空间复杂度：O(N + M)

    • 存储抑制关系和原始告警列表。

  3. 正确性：

    • 通过集合快速判断抑制者是否存在，确保所有抑制条件被正确检查。

  4. 适用性：

    • 处理所有合法输入，包括重复告警和多级抑制关系。

C

问题分析

我们需要根据给定的告警抑制关系和原始告警列表，输出实际产生的未被抑制的告警列表。高优先级告警会抑制低优先级告警，无论它们在输入列表中的顺序如何。关键在于高效存储抑制关系并快速判断告警是否被抑制。

解题思路

  1. 输入处理：读取抑制关系并构建数据结构，保存每个告警的抑制者列表。
  2. 原始告警存储：将原始告警保存到数组以便按顺序输出，同时支持快速存在性检查。
  3. 过滤逻辑：遍历每个告警，检查其是否被列表中的任一抑制者抑制。
  4. 输出结果：按顺序输出未被抑制的告警。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>// 抑制者链表节点
typedef struct SuppressorNode {char suppressor[32];struct SuppressorNode *next;
} SuppressorNode;// 抑制关系条目：被抑制的告警及其抑制者链表
typedef struct {char suppressed[32];SuppressorNode *sup_list;
} SuppressionEntry;SuppressionEntry suppression_entries[120]; // 最大抑制关系数
int num_suppression_entries = 0;// 判断字符串是否存在于原始告警列表中
bool is_exist(char *str, char **alerts, int alert_count) {for (int i = 0; i < alert_count; i++) {if (strcmp(str, alerts[i]) == 0) {return true;}}return false;
}int main() {int N;char line[1024];// 读取抑制关系数量fgets(line, sizeof(line), stdin);sscanf(line, "%d", &N);// 读取抑制关系并构建数据结构for (int i = 0; i < N; i++) {fgets(line, sizeof(line), stdin);char suppressor[32], suppressed[32];sscanf(line, "%s %s", suppressor, suppressed);// 查找是否已有对应的被抑制条目bool found = false;for (int j = 0; j < num_suppression_entries; j++) {if (strcmp(suppression_entries[j].suppressed, suppressed) == 0) {// 添加抑制者到链表头部SuppressorNode *node = (SuppressorNode *)malloc(sizeof(SuppressorNode));strcpy(node->suppressor, suppressor);node->next = suppression_entries[j].sup_list;suppression_entries[j].sup_list = node;found = true;break;}}if (!found) {// 新增条目strcpy(suppression_entries[num_suppression_entries].suppressed, suppressed);SuppressorNode *node = (SuppressorNode *)malloc(sizeof(SuppressorNode));strcpy(node->suppressor, suppressor);node->next = NULL;suppression_entries[num_suppression_entries].sup_list = node;num_suppression_entries++;}}// 读取原始告警列表fgets(line, sizeof(line), stdin);char *alerts[100];int alert_count = 0;char *token = strtok(line, " \n");while (token != NULL && alert_count < 100) {alerts[alert_count] = strdup(token); // 复制字符串alert_count++;token = strtok(NULL, " \n");}// 过滤被抑制的告警char *result[100];int result_count = 0;for (int i = 0; i < alert_count; i++) {char *current = alerts[i];bool is_suppressed = false;// 检查当前告警是否被抑制for (int j = 0; j < num_suppression_entries; j++) {if (strcmp(suppression_entries[j].suppressed, current) == 0) {// 遍历抑制者链表，判断是否存在SuppressorNode *node = suppression_entries[j].sup_list;while (node != NULL) {if (is_exist(node->suppressor, alerts, alert_count)) {is_suppressed = true;break;}node = node->next;}if (is_suppressed) break;}}if (!is_suppressed) {result[result_count++] = current;}}// 输出结果for (int i = 0; i < result_count; i++) {if (i > 0) printf(" ");printf("%s", result[i]);}printf("\n");// 释放内存for (int i = 0; i < alert_count; i++) {free(alerts[i]);}for (int i = 0; i < num_suppression_entries; i++) {SuppressorNode *node = suppression_entries[i].sup_list;while (node != NULL) {SuppressorNode *temp = node;node = node->next;free(temp);}}return 0;
}

代码详细解析

  1. 数据结构定义：

    • SuppressorNode：链表节点，存储抑制者ID。
    • SuppressionEntry：被抑制的告警及其抑制者链表。

  2. 读取抑制关系：

    • 每行拆分为抑制者和被抑制者。
    • 若被抑制的告警已存在，将抑制者添加到链表头部；否则创建新条目。

  3. 原始告警处理：

    • 使用strtok分割输入行，保存到alerts数组，并复制字符串（strdup）。

  4. 过滤被抑制告警：

    • 遍历每个告警，检查其是否在抑制关系中。
    • 若存在抑制关系，遍历抑制者链表，判断是否存在原始列表中。

  5. 输出结果：

    • 按顺序输出未被抑制的告警。

  6. 内存释放：

    • 释放动态分配的告警字符串和抑制者链表节点。

示例测试

示例1：
输入：

2
A B
B C
A B C D E

输出：

A D E

解析：A抑制B，B抑制C，B和C被过滤。

示例2：
输入：

1
B A
B A

输出：

B

解析：B抑制A，A被过滤。

示例3：
输入：

0
A B C

输出：

A B C

解析：无抑制关系，所有告警保留。

综合分析

  1. 时间复杂度：

    • 读取抑制关系：O(N)，N为抑制关系数。
    • 过滤告警：O(M*K)，M为告警列表长度，K为抑制者数量。
    • 总体时间复杂度为O(N + M*K)，适用于题目限制。

  2. 空间复杂度：

    • 存储抑制关系和原始告警列表，空间复杂度为O(N + M)。

  3. 正确性：

    • 通过链表和线性查找确保所有抑制关系被正确处理。

  4. 适用性：

    • 处理所有合法输入，包括循环抑制和传递抑制（但题目规定不存在）。

GO

问题分析

我们需要根据告警抑制关系和原始告警列表，过滤掉所有被抑制的告警，输出未被抑制的告警。高优先级告警会抑制所有直接关联的低优先级告警，无论其顺序如何。关键在于快速判断某个告警是否被其他告警抑制。

解题思路

  1. 存储抑制关系：使用嵌套字典记录每个告警的抑制者集合。
  2. 快速存在性检查：将原始告警存入集合，以便快速判断抑制者是否存在。
  3. 遍历过滤：对于每个告警，检查其是否有抑制者存在于原始列表中，若存在则过滤。

代码实现

package mainimport ("bufio""fmt""os""strings"
)func main() {scanner := bufio.NewScanner(os.Stdin)// 读取抑制关系数量scanner.Scan()var n intfmt.Sscanf(scanner.Text(), "%d", &n)// 初始化抑制关系映射：被抑制告警 → 抑制者集合suppression := make(map[string]map[string]struct{})// 读取并存储抑制关系for i := 0; i < n; i++ {scanner.Scan()parts := strings.Split(scanner.Text(), " ")if len(parts) != 2 {continue // 跳过格式错误行}suppressor, suppressed := parts[0], parts[1]if _, ok := suppression[suppressed]; !ok {suppression[suppressed] = make(map[string]struct{})}suppression[suppressed][suppressor] = struct{}{}}// 读取原始告警列表并构建存在集合scanner.Scan()alerts := strings.Fields(scanner.Text())existing := make(map[string]struct{})for _, a := range alerts {existing[a] = struct{}{}}// 过滤被抑制的告警var result []stringfor _, a := range alerts {suppressed := false// 检查当前告警是否有抑制者在原始列表中if suppressors, ok := suppression[a]; ok {for s := range suppressors {if _, exists := existing[s]; exists {suppressed = truebreak}}}if !suppressed {result = append(result, a)}}// 输出结果fmt.Println(strings.Join(result, " "))
}

代码详细解析

  1. 读取抑制关系数量：

    • 使用 bufio.Scanner 读取输入的第一行，解析为整数 n。

  2. 存储抑制关系：

    • 使用嵌套字典 suppression，外层键为被抑制告警，内层键为抑制者集合。
    • 每行抑制关系拆分为抑制者（suppressor）和被抑制者（suppressed），存入字典。

  3. 处理原始告警列表：

    • 将原始告警存入切片 alerts 以保留顺序。
    • 使用字典 existing 存储所有原始告警，以便 O(1) 时间存在性检查。

  4. 过滤逻辑：

    • 遍历每个原始告警 a。
    • 若 a 存在于 suppression 中，遍历其所有抑制者，检查是否存在于 existing。
    • 若存在任一抑制者，则 a 被抑制，否则保留。

  5. 输出结果：

    • 使用 strings.Join 按原始顺序拼接未被抑制的告警。

示例测试

示例1：
输入：

2
A B
B C
A B C D E

输出：

A D E

解析：A 抑制 B，B 抑制 C。B 和 C 被过滤。

示例2：
输入：

1
B A
B A

输出：

B

解析：B 抑制 A，A 被过滤。

示例3：
输入：

0
A B C

输出：

A B C

解析：无抑制关系，全部保留。

综合分析

  1. 时间复杂度：

    • 读取输入：O(N + M)，N 为抑制关系数，M 为原始告警数。
    • 过滤过程：O(M*K)，K 为每个告警的抑制者数量。每个告警的抑制者检查为 O(1)。

  2. 空间复杂度：

    • 抑制关系存储：O(N)，每个抑制关系存储一次。
    • 原始告警存储：O(M)，存储列表和集合。

  3. 正确性：

    • 通过直接检查抑制者是否存在于原始列表，确保所有抑制关系被正确处理。

  4. 适用性：

    • 处理大规模数据高效，适用于题目给出的最大输入限制。

更多内容：

https://www.kdocs.cn/l/cvk0eoGYucWA

本文发表于【纪元A梦】，关注我，获取更多实用教程/资源！

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

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

相关文章

ASP.NET MVC​ 入门指南四

ASP.NET MVC​ 入门指南四

21. 高级路由配置 21.1 自定义路由约束 除了使用默认的路由约束&#xff0c;你还可以创建自定义路由约束。自定义路由约束允许你根据特定的业务逻辑来决定一个路由是否匹配。例如&#xff0c;创建一个只允许特定年份的路由约束&#xff1a; csharp public class YearRouteCo…
阅读更多...
测试基础笔记第十八天

测试基础笔记第十八天

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 一、web自动化1.xpath定位1.属性定位2.属性与逻辑结合3.属性和层级结合 2.常见元素定位方法&#xff08;面试题&#xff09;3.常见元素定位失败原因4.cookie1.验证码…
阅读更多...
（笔记）List

（笔记）List

一、List的介绍和使用 1.List的介绍 1.1 list是可以在任意常数范围内插入和删除的序列式容器&#xff0c;并且该容器可以前后双向迭代。 1.2 list底层是双向链表结构&#xff0c;双向链表中每个元素都储存在互不相关的独立节点中&#xff0c;在节点中通过指针指向前其前一个…
阅读更多...
重载和覆写有什么区别？

重载和覆写有什么区别？

重载&#xff08;Overload&#xff09;和覆写&#xff08;Override&#xff0c;也叫重写 &#xff09;是面向对象编程中的重要概念&#xff0c;它们有以下区别&#xff1a; 定义 - 重载&#xff1a;在同一类中&#xff0c;允许存在多个方法名相同&#xff0c;但参数列表&#x…
阅读更多...
flask 获取各种请求数据：GET form-data x-www-form-urlencoded JSON headers 上传文件

flask 获取各种请求数据：GET form-data x-www-form-urlencoded JSON headers 上传文件

在 Flask 里&#xff0c;能使用多种方法获取不同类型的请求数据&#xff0c;下面详细介绍常见请求数据的获取方式。 获取查询字符串参数&#xff08;GET 请求&#xff09; 查询字符串参数一般在 URL 里&#xff0c;以 ?key1value1&key2value2 这种形式存在。可通过 requ…
阅读更多...
人工智能助力工业制造：迈向智能制造的未来

人工智能助力工业制造：迈向智能制造的未来

在当今数字化转型的浪潮中&#xff0c;人工智能&#xff08;AI&#xff09;技术正逐渐成为推动工业制造领域变革的核心力量。智能制造作为工业 4.0 的重要组成部分&#xff0c;通过将 AI 技术与传统制造工艺深度融合&#xff0c;正在重塑整个生产流程&#xff0c;提高生产效率、…
阅读更多...
【java八股文】深入浅出synchronized优化原理

【java八股文】深入浅出synchronized优化原理

&#x1f50d; 开发者资源导航 &#x1f50d;&#x1f3f7;️ 博客主页&#xff1a; 个人主页&#x1f4da; 专栏订阅&#xff1a; JavaEE全栈专栏 synchronized优化原理 synchronized即使悲观锁也是乐观锁&#xff0c;拥有自适应性。 jvm内部会统计每个锁的竞争激烈程度&…
阅读更多...
生成式 AI 的重要性

生成式 AI 的重要性

在科技飞速发展的今天，我们正站在一个前所未有的变革节点上。生成式 AI，宛如一颗突然划破夜空的耀眼流星，以其强大的创造力和无限的可能性，迅速成为全球瞩目的焦点。它究竟有何等魔力，能在如此短的时间内引发如此巨大的轰动？这背后又隐藏着怎样的时代密码，等待着我们去解…
阅读更多...
生成式 AI 的阐释

生成式 AI 的阐释

在科技浪潮的汹涌推动下，一个全新的时代正以前所未有的速度向我们奔来，生成式 AI 无疑是这股浪潮中最耀眼的浪尖。它究竟是什么？又将如何重塑我们的世界？这不仅是科技爱好者们热衷探讨的话题，更是关乎每一个人未来发展的重要命题。 生成式 AI，从本质上来说，是一种能够自…
阅读更多...
C++ 中 virtual 的作用

C++ 中 virtual 的作用

文章目录 1. 用于虚继承2. 用于抽象基类3. 用于多态 C 的 virtual 关键字&#xff0c;常见有 3 种用途&#xff1a;虚继承、抽象基类和多态。 1. 用于虚继承 virtual 用于虚继承时&#xff0c;主要是为了解决菱形继承中的重复继承同名成员问题。使用形式如下 class Derived:…
阅读更多...
软件测试52讲学习分享：深入理解单元测试

软件测试52讲学习分享：深入理解单元测试

课程背景 最近我在学习极客时间的《软件测试52讲》课程&#xff0c;这是由腾讯TEG基础架构部T4级专家茹炳晟老师主讲的认证课程。作为数字化转型与人工智能(DTAI)产业人才基地建设中心的认证课程&#xff0c;内容非常专业实用。今天想和大家分享第3讲"什么是单元测试&…
阅读更多...
Java SE(7)——类和对象（二）

Java SE(7)——类和对象（二）

1.包(package) 1.1 包的定义 在Java中&#xff0c;包是一种用于组织和管理类&#xff0c;接口和其他包的机制。主要作用是防止命名冲突&#xff0c;并提供一种访问控制机制 1.2 package关键字 package关键字的主要作用是声明当前类在哪个包里面。 当然&#xff0c;用户也可以…
阅读更多...
Manus联合创始人：公司产品基于Claude和阿里千问大模型开发

Manus联合创始人：公司产品基于Claude和阿里千问大模型开发

3月11日消息&#xff0c;日前&#xff0c;Manus官方在社交平台转发了公司联合创始人、首席科学家季逸超对Manus的技术解读&#xff0c;季逸超在评论区回复网友关于“Manus使用了哪一个基础大模型”这一问题时回复称&#xff0c;“我们用过Claude&#xff0c;也用过不同版本的Qw…
阅读更多...
欺骗单页应用（SPA）渲染隐藏路由 -- trouble at the spa b01lersCTF

欺骗单页应用（SPA）渲染隐藏路由 -- trouble at the spa b01lersCTF

题目信息&#xff1a;I had this million-dollar app idea the other day, but I can’t get my routing to work! I’m only using state-of-the-art tools and frameworks, so that can’t be the problem… right? Can you navigate me to the endpoint of my dreams? 题目…
阅读更多...
大数据引领行业革命：深度解析与未来趋势

大数据引领行业革命：深度解析与未来趋势

📝个人主页🌹：慌ZHANG-CSDN博客 🌹🌹期待您的关注 🌹🌹 在信息化、数字化、智能化日益发展的今天，大数据技术已经成为推动产业变革的重要引擎。它不仅仅是一个技术工具，更是各行各业创新和优化的核心动力。无论是大企业还是初创公司，大数据的应用已经成为提升效…
阅读更多...
[machine learning] Transformer - Attention (二)

[machine learning] Transformer - Attention (二)

本文介绍带训练参数的self-attention&#xff0c;即在transformer中使用的self-attention。 首先引入三个可训练的参数矩阵Wq, Wk, Wv&#xff0c;这三个矩阵用来将词向量投射(project)到query, key, value三个向量上。下面我们再定义几个变量&#xff1a; import torch inpu…
阅读更多...
施磊老师rpc(三)

施磊老师rpc(三)

文章目录 mprpc框架项目动态库编译框架生成动态库框架初始化函数-文件读取1. 为什么要传入 argc, argv2. 读取参数逻辑3. 配置文件设计 init部分实现 mprpc配置文件加载(一)配置文件加载类成员变量主要方法**src/include/mprpcconfig.h** 配置文件**bin/test.conf** 实现配置文…
阅读更多...
文献分享：通过简单的生物偶联策略将肽双特异性抗体（pBsAbs）应用于免疫治疗

文献分享：通过简单的生物偶联策略将肽双特异性抗体（pBsAbs）应用于免疫治疗

背景 双特异性抗体是将单克隆抗体的两个不同抗原结合位点融合成一个单一实体的人工分子。它们已经成为一种很有前景的下一代抗癌治疗方法。尽管双特异性抗体的应用令人着迷&#xff0c;但双特异性抗体的设计和生产仍然繁琐而富有挑战性&#xff0c;导致研发过程漫长&#xff0…
阅读更多...
二、shell脚本--变量与数据类型

二、shell脚本--变量与数据类型

1. 变量的定义与使用 定义变量&#xff1a;简单直接 在 Shell 里定义变量相当容易&#xff1a; 基本格式: variable_namevalue关键点 ❗&#xff1a;赋值号 的两边绝对不能有空格&#xff01;这绝对是初学者最容易踩的坑之一 &#x1f628;&#xff0c;务必留意&#xff01…
阅读更多...
java_Lambda表达式

java_Lambda表达式

1、背景 lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。lambda表达式就和方法一样样&#xff0c;它提供了一个正常的参数列表和一个使用这些参数的主体&#xff08;body&#xff0c;可以是一个表达式和一个代码块&#xff09;。La…
阅读更多...
最新文章

Copyright @ 2022~2023