华为OD机试 - 分班问题（Python/JS/C/C++ 2024 E卷 200分）

news2024/10/3 14:23:49

在这里插入图片描述

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

幼儿园两个班的同小朋友在排队时混在了一起，每位小朋友都知道自己是否与前面一位小朋友同班，请你帮忙把同班的小朋友找出来。
小朋友的编号是整数，与前一位小朋友同班用Y表示，不同班用N表示。
学生序号范围[0,999]，如果输入不合法则打印ERROR。

二、输入描述

输入为空格分开的朋友编号和是否同班标志。

三、输出描述

输出为两行，每一行记录一个班小朋友的编号，编号用空格分开，且：

  1. 编号需要按升序排列。
  2. 若只有一个班的小朋友，第二行为空行。

四、测试用例

测试用例1：

1、输入

1/N 2/Y 3/N 4/Y

2、输出

1 2
3 4

3、说明

第一个小朋友编号1，标志为N，分配到班级A。
第二个小朋友编号2，标志为Y，与前一个同班，分配到班级A。
第三个小朋友编号3，标志为N，与前一个不同班，分配到班级B。
第四个小朋友编号4，标志为Y，与前一个同班，分配到班级B。

测试用例2：

1、输入

1/N 2/Y 3/N 4/Y 5/Y

2、输出

1 2
3 4 5

3、说明

第五个小朋友编号5，标志为Y，与前一个同班，分配到班级B。

五、解题思路

  1. 输入处理与验证：
    • 将输入字符串按空格分割成多个小朋友的记录。
    • 对每个记录进行验证，确保格式为编号/标志。
    • 检查编号是否为整数且在[0,999]范围内。
    • 检查标志是否为Y或N。
    • 若任何验证失败，输出ERROR并终止程序。
  2. 班级分配：
    • 初始化两个班级A和B。
    • 使用一个变量currentClass跟踪当前班级，0表示班级A，1表示班级B。
    • 对于第一个小朋友，标志必须为N，分配到班级A。
  3. 对于后续的小朋友：
    • 若标志为Y，分配到与前一个小朋友相同的班级。
    • 若标志为N，切换到另一个班级分配。
  4. 排序与输出：
    • 对班级A和班级B的编号分别进行升序排序。
    • 按要求格式输出两个班级的编号，若某一班级为空，输出空行。

六、Python算法源码

import sys

def find_classes(records):
    """
    根据小朋友的记录，分配到两个班级
    :param records: list of tuples (number, flag)
    :return: 两个班级的列表
    """
    classA = []
    classB = []
    current_class = -1  # 0表示班级A，1表示班级B
    
    for i, (number, flag) in enumerate(records):
        if i == 0:
            # 第一个小朋友，标志必须是'N'，分配到班级A
            if flag != 'N':
                return "ERROR", None
            current_class = 0  # 班级A
            classA.append(number)
        else:
            if flag == 'Y':
                # 与前一个小朋友同班
                if current_class == 0:
                    classA.append(number)
                else:
                    classB.append(number)
            elif flag == 'N':
                # 与前一个小朋友不同班
                current_class = 1 - current_class  # 切换班级
                if current_class == 0:
                    classA.append(number)
                else:
                    classB.append(number)
            else:
                # 非法标志
                return "ERROR", None
    return classA, classB

def main():
    input_line = sys.stdin.readline().strip()
    if not input_line:
        print("ERROR")
        return
    
    tokens = input_line.split()
    records = []
    
    for token in tokens:
        if '/' not in token:
            print("ERROR")
            return
        parts = token.split('/')
        if len(parts) != 2:
            print("ERROR")
            return
        number_str, flag = parts
        try:
            number = int(number_str)
        except ValueError:
            print("ERROR")
            return
        if not (0 <= number <= 999):
            print("ERROR")
            return
        if flag not in ('Y', 'N'):
            print("ERROR")
            return
        records.append((number, flag))
    
    classA, classB = find_classes(records)
    if classA == "ERROR":
        print("ERROR")
        return
    
    # 排序
    classA_sorted = sorted(classA)
    classB_sorted = sorted(classB)
    
    # 输出
    print(' '.join(map(str, classA_sorted)))
    print(' '.join(map(str, classB_sorted)))

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// 导入readline模块用于读取输入
const readline = require('readline');

// 创建接口以读取输入
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let input = []; // 用于存储输入的行

// 监听每一行输入
rl.on('line', (line) => {
    input.push(line.trim());
    // 假设输入只有一行，如果需要多行，可以调整条件
    // 根据题目描述，输入是一个行的记录
    if (input.length === 1) {
        processInput(input[0]);
        rl.close(); // 关闭输入流
    }
});

/**
 * 处理输入并分配班级
 * @param {string} inputLine 输入的字符串
 */
function processInput(inputLine) {
    if (!inputLine) {
        console.log("ERROR");
        console.log("");
        return;
    }
    
    // 分割输入为每个小朋友的记录
    const tokens = inputLine.split(' ');
    
    let classA = [];
    let classB = [];
    let currentClass = -1; // 0表示班级A，1表示班级B
    
    for (let i = 0; i < tokens.length; i++) {
        let token = tokens[i];
        
        // 检查是否包含'/'
        if (!token.includes('/')) {
            console.log("ERROR");
            return;
        }
        
        // 分割编号和标志
        let parts = token.split('/');
        if (parts.length !== 2) {
            console.log("ERROR");
            return;
        }
        
        let numberStr = parts[0].trim();
        let flag = parts[1].trim();
        
        // 检查编号是否为整数
        let number = parseInt(numberStr, 10);
        if (isNaN(number)) {
            console.log("ERROR");
            return;
        }
        
        // 检查编号是否在[0,999]范围内
        if (number < 0 || number > 999) {
            console.log("ERROR");
            return;
        }
        
        // 检查标志是否为'Y'或'N'
        if (flag !== 'Y' && flag !== 'N') {
            console.log("ERROR");
            return;
        }
        
        // 处理班级分配
        if (i === 0) {
            // 第一个小朋友，标志必须是'N'，分配到班级A
            if (flag !== 'N') {
                console.log("ERROR");
                return;
            }
            currentClass = 0; // 班级A
            classA.push(number);
        } else {
            if (flag === 'Y') {
                // 与前一个小朋友同班
                if (currentClass === 0) {
                    classA.push(number);
                } else {
                    classB.push(number);
                }
            } else if (flag === 'N') {
                // 与前一个小朋友不同班
                currentClass = 1 - currentClass; // 切换班级
                if (currentClass === 0) {
                    classA.push(number);
                } else {
                    classB.push(number);
                }
            }
        }
    }
    
    // 排序
    classA.sort((a, b) => a - b);
    classB.sort((a, b) => a - b);
    
    // 构建输出字符串
    let outputA = classA.join(' ');
    let outputB = classB.join(' ');
    
    // 输出两个班级的编号
    console.log(outputA);
    console.log(outputB);
}

八、C算法源码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// 定义最大商品数量和最大价格
#define MAX_ITEMS 1000

int main() {
    char inputLine[5000];
    
    // 读取整行输入
    if (fgets(inputLine, sizeof(inputLine), stdin) == NULL) {
        printf("ERROR\n");
        return 0;
    }
    
    // 去除换行符
    size_t len = strlen(inputLine);
    if (len > 0 && inputLine[len - 1] == '\n') {
        inputLine[len - 1] = '\0';
    }
    
    // 分割输入为每个小朋友的记录
    char *token = strtok(inputLine, " ");
    if (token == NULL) {
        printf("ERROR\n");
        return 0;
    }
    
    int classA[MAX_ITEMS];
    int classB[MAX_ITEMS];
    int countA = 0, countB = 0;
    int currentClass = -1; // 0表示班级A，1表示班级B
    int index = 0;
    
    while (token != NULL) {
        // 检查是否包含'/'
        char *slash = strchr(token, '/');
        if (slash == NULL) {
            printf("ERROR\n");
            return 0;
        }
        
        // 分割编号和标志
        *slash = '\0';
        char *numberStr = token;
        char *flag = slash + 1;
        
        // 检查标志是否为'Y'或'N'
        if (strcmp(flag, "Y") != 0 && strcmp(flag, "N") != 0) {
            printf("ERROR\n");
            return 0;
        }
        
        // 检查编号是否为整数
        char *endptr;
        long numberLong = strtol(numberStr, &endptr, 10);
        if (*endptr != '\0') {
            printf("ERROR\n");
            return 0;
        }
        int number = (int)numberLong;
        
        // 检查编号是否在[0,999]范围内
        if (number < 0 || number > 999) {
            printf("ERROR\n");
            return 0;
        }
        
        // 处理班级分配
        if (index == 0) {
            // 第一个小朋友，标志必须是'N'，分配到班级A
            if (strcmp(flag, "N") != 0) {
                printf("ERROR\n");
                return 0;
            }
            currentClass = 0; // 班级A
            classA[countA++] = number;
        } else {
            if (strcmp(flag, "Y") == 0) {
                // 与前一个小朋友同班
                if (currentClass == 0) {
                    classA[countA++] = number;
                } else {
                    classB[countB++] = number;
                }
            } else if (strcmp(flag, "N") == 0) {
                // 与前一个小朋友不同班
                currentClass = 1 - currentClass; // 切换班级
                if (currentClass == 0) {
                    classA[countA++] = number;
                } else {
                    classB[countB++] = number;
                }
            }
        }
        
        index++;
        token = strtok(NULL, " ");
    }
    
    // 排序班级A
    for (int i = 0; i < countA - 1; i++) {
        for (int j = i + 1; j < countA; j++) {
            if (classA[i] > classA[j]) {
                int temp = classA[i];
                classA[i] = classA[j];
                classA[j] = temp;
            }
        }
    }
    
    // 排序班级B
    for (int i = 0; i < countB - 1; i++) {
        for (int j = i + 1; j < countB; j++) {
            if (classB[i] > classB[j]) {
                int temp = classB[i];
                classB[i] = classB[j];
                classB[j] = temp;
            }
        }
    }
    
    // 输出班级A
    for (int i = 0; i < countA; i++) {
        printf("%d", classA[i]);
        if (i != countA - 1) {
            printf(" ");
        }
    }
    printf("\n");
    
    // 输出班级B
    for (int i = 0; i < countB; i++) {
        printf("%d", classB[i]);
        if (i != countB - 1) {
            printf(" ");
        }
    }
    printf("\n");
    
    return 0;
}

九、C++算法源码

#include <iostream>
#include <vector>
#include <sstream>
#include <algorithm>
#include <string>
using namespace std;

int main(){
    // 读取整行输入
    string inputLine;
    if(!getline(cin, inputLine)){
        // 如果读取失败，输出ERROR并结束程序
        cout << "ERROR" << endl;
        return 0;
    }

    // 去除前后空格
    size_t start = inputLine.find_first_not_of(" ");
    size_t end = inputLine.find_last_not_of(" ");
    if(start == string::npos){
        // 输入全为空，输出ERROR并结束程序
        cout << "ERROR" << endl;
        return 0;
    }
    inputLine = inputLine.substr(start, end - start +1);

    // 分割输入为每个小朋友的记录
    vector<string> tokens;
    stringstream ss(inputLine);
    string token;
    while(ss >> token){
        tokens.push_back(token);
    }

    // 初始化两个班级的列表
    vector<int> classA;
    vector<int> classB();

    // 当前班级标志，0表示班级A，1表示班级B
    int currentClass = -1;

    // 遍历每个小朋友的记录
    for(int i=0; i<tokens.size(); i++){
        string t = tokens[i];

        // 检查是否包含'/'
        size_t slashPos = t.find('/');
        if(slashPos == string::npos){
            // 如果不包含'/'，输入不合法，输出ERROR并结束程序
            cout << "ERROR" << endl;
            return 0;
        }

        // 分割编号和标志
        string numberStr = t.substr(0, slashPos);
        string flag = t.substr(slashPos+1);

        // 去除可能的空格
        size_t numStart = numberStr.find_first_not_of(" ");
        size_t numEnd = numberStr.find_last_not_of(" ");
        if(numStart == string::npos){
            // 编号为空，输入不合法，输出ERROR并结束程序
            cout << "ERROR" << endl;
            return 0;
        }
        numberStr = numberStr.substr(numStart, numEnd - numStart +1);

        size_t flagStart = flag.find_first_not_of(" ");
        size_t flagEnd = flag.find_last_not_of(" ");
        if(flagStart == string::npos){
            // 标志为空，输入不合法，输出ERROR并结束程序
            cout << "ERROR" << endl;
            return 0;
        }
        flag = flag.substr(flagStart, flagEnd - flagStart +1);

        // 检查编号是否为整数
        int number;
        try{
            number = stoi(numberStr);
        }
        catch(...){
            // 编号不是有效整数，输入不合法，输出ERROR并结束程序
            cout << "ERROR" << endl;
            return 0;
        }

        // 检查编号是否在[0,999]范围内
        if(number <0 || number >999){
            // 编号超出范围，输入不合法，输出ERROR并结束程序
            cout << "ERROR" << endl;
            return 0;
        }

        // 检查标志是否为'Y'或'N'
        if(flag != "Y" && flag != "N"){
            // 标志不是'Y'或'N'，输入不合法，输出ERROR并结束程序
            cout << "ERROR" << endl;
            return 0;
        }

        // 处理班级分配
        if(i ==0){
            // 第一个小朋友，标志必须为'N'
            if(flag != "N"){
                // 第一个小朋友标志不是'N'，输入不合法，输出ERROR并结束程序
                cout << "ERROR" << endl;
                return 0;
            }
            currentClass =0; // 班级A
            classA.push_back(number);
        }
        else{
            if(flag == "Y"){
                // 与前一个小朋友同班
                if(currentClass ==0){
                    classA.push_back(number);
                }
                else{
                    classB.push_back(number);
                }
            }
            else{
                // 与前一个小朋友不同班，切换班级
                currentClass =1 - currentClass;
                if(currentClass ==0){
                    classA.push_back(number);
                }
                else{
                    classB.push_back(number);
                }
            }
        }
    }

    // 对两个班级的编号进行升序排序
    sort(classA.begin(), classA.end());
    sort(classB.begin(), classB.end());

    // 构建输出字符串
    string outputA = "";
    for(auto num : classA){
        outputA += to_string(num) + " ";
    }
    if(outputA.length()>0){
        outputA.pop_back(); // 移除最后一个空格
    }

    string outputB = "";
    for(auto num : classB){
        outputB += to_string(num) + " ";
    }
    if(outputB.length()>0){
        outputB.pop_back(); // 移除最后一个空格
    }

    // 输出两个班级的编号
    cout << outputA << endl;
    cout << outputB << endl;

    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

在这里插入图片描述

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

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

相关文章

无人机电力巡检:点亮电力巡检新视野!

无人机电力巡检:点亮电力巡检新视野!

一、无人机电力巡查的优势 提高巡检效率&#xff1a;无人机可以搭载高清摄像头、红外热像仪等先进设备&#xff0c;实时拍摄和传输图像&#xff0c;帮助巡检人员快速发现潜在问题&#xff0c;如电线破损、绝缘子污损、设备过热等&#xff0c;从而大大缩短了巡检周期。 降低人…
阅读更多...
Tiny Transformer：从零开始构建简化版Transformer模型

Tiny Transformer：从零开始构建简化版Transformer模型

引言 自然语言处理&#xff08;NLP&#xff09;与计算机视觉&#xff08;CV&#xff09;有显著差异&#xff0c;各自任务的独特性决定了它们适用的模型架构。在CV中&#xff0c;卷积神经网络&#xff08;CNN&#xff09;长期占据主导地位&#xff0c;而在NLP领域&#xff0c;循…
阅读更多...
基于微信小程序的四六级词汇+ssm(lw+演示+源码+运行）

基于微信小程序的四六级词汇+ssm(lw+演示+源码+运行）

摘 要 随着我国经济迅速发展&#xff0c;人们对手机的需求越来越大&#xff0c;各种手机软件也都在被广泛应用&#xff0c;但是对于手机进行数据信息管理&#xff0c;对于手机的各种软件也是备受用户的喜爱&#xff0c;四六级词汇小程序被用户普遍使用&#xff0c;为方便用户能…
阅读更多...
Python入门--判断语句

Python入门--判断语句

目录 1. 布尔类型和比较运算符 2. if语句的基本格式 3. if-else语句 4. if-elif-else语句 5. 判断语句的嵌套 6. 应用--猜数字游戏 进行逻辑判断&#xff0c;是生活中常见的行为。同样&#xff0c;在程序中&#xff0c;进行逻辑判断也是最为基础的功能。 1. 布尔类型和比…
阅读更多...
OceanBase—02（入门篇——对于单副本单节点，由1个observer扩容为3个observer集群）——之前的记录，当初有的问题未解决，目前新版未尝试

OceanBase—02（入门篇——对于单副本单节点，由1个observer扩容为3个observer集群）——之前的记录，当初有的问题未解决，目前新版未尝试

OceanBase—02&#xff08;入门篇——对于单副本单节点&#xff0c;由1个observer扩容为3个observer集群&#xff09;——之前的记录&#xff0c;有的问题未解决&#xff0c;新版未尝试 1、前言—安装单副本单节点集群1.1 docker安装OB 2、查看现有集群情况2.1 进入容器&#x…
阅读更多...
设置服务器走本地代理

设置服务器走本地代理

勾选&#xff1a; 然后&#xff1a; git clone https://github.com/rofl0r/proxychains-ng.git./configure --prefix/home/wangguisen/usr --sysconfdir/home/wangguisen/etcmakemake install# 在最后配置成本地代理地址 vim /home/wangguisen/etc/proxychains.confsocks4 17…
阅读更多...
Python编写的贪吃蛇小游戏

Python编写的贪吃蛇小游戏

安装包 pip install pygame完整代码 import pygame import randompygame.init()# 定义颜色 white (255, 255, 255) black (0, 0, 0) red (213, 50, 80) green (0, 255, 0) blue (50, 153, 213)# 定义屏幕大小 dis_width 800 dis_height 600dis pygame.display.set_mo…
阅读更多...
【数据结构】什么是平衡二叉搜索树(AVL Tree)?

【数据结构】什么是平衡二叉搜索树(AVL Tree)?

&#x1f984;个人主页:修修修也 &#x1f38f;所属专栏:数据结构 ⚙️操作环境:Visual Studio 2022 目录 &#x1f4cc;AVL树的概念 &#x1f4cc;AVL树的操作 &#x1f38f;AVL树的插入操作 ↩️右单旋 ↩️↪️右左双旋 ↪️↩️左右双旋 ↪️左单旋 &#x1f38f;AVL树的删…
阅读更多...
CTF刷题buuctf

CTF刷题buuctf

[WUSTCTF2020]颜值成绩查询 拿到相关题目&#xff0c;其实根据功能和参数分析。需要传入一个学号然后进行针对于对应的学号进行一个查询&#xff0c;很可能就会存在sql注入。 其实这道题最难的点&#xff0c;在于过滤了空格&#xff0c;因此我们使用 /**/来过滤空格的限制。…
阅读更多...
智能化焊接数据管理系统：系统功能设计与应用场景，OEM定制

智能化焊接数据管理系统：系统功能设计与应用场景，OEM定制

在快速发展的工业4.0时代&#xff0c;智能化技术正以前所未有的速度改变着各行各业&#xff0c;其中焊接行业也不例外。随着物联网、大数据、人工智能等技术的不断融合&#xff0c;智能化焊接数据管理系统应运而生&#xff0c;成为提高焊接效率、保障焊接质量、优化生产流程的重…
阅读更多...
半监督学习与数据增强（论文复现）

半监督学习与数据增强（论文复现）

半监督学习与数据增强&#xff08;论文复现&#xff09; 本文所涉及所有资源均在传知代码平台可获取 文章目录 半监督学习与数据增强&#xff08;论文复现&#xff09;概述算法原理核心逻辑效果演示使用方式 概述 本文复现论文提出的半监督学习方法&#xff0c;半监督学习&…
阅读更多...
C题（二）字符串转数字 --- atoi

C题（二）字符串转数字 --- atoi

———————————————————**目录**—————————————————— 一、 atoi函数介绍 功能函数原型使用示例 二、题解之一 三、留言 问题引入&#x1f449; 输入样例&#x1f449; 5 01234 00123 00012 00001 00000 输出样例&#x1f449; 1234 123 …
阅读更多...
‌文件名称与扩展名：批量重命名的技巧与指南

‌文件名称与扩展名：批量重命名的技巧与指南

在日常的文件管理中&#xff0c;我们经常需要处理大量的文件&#xff0c;这些文件可能有着各种各样的名称和扩展名。为了更好地管理和识别这些文件&#xff0c;批量重命名成为了一项非常实用的技能。能够帮助我们快速整理文件&#xff0c;提高工作效率。本文将深入探讨文件名称…
阅读更多...
vue2圆形标记（Marker）添加点击事件不弹出信息窗体（InfoWindow）的BUG解决

vue2圆形标记（Marker）添加点击事件不弹出信息窗体（InfoWindow）的BUG解决

目录 一、问题详情 二、问题排查 三、解决方案 一、问题详情 地图上面的轨迹点希望能通过点击看到详细的经纬度信息&#xff0c;但是点击的时候就是显示不出来。 二、问题排查 代码都是参考高德的官方文档&#xff0c;初步看没有问题啊&#xff0c;但是点击事件就感觉失效…
阅读更多...
10.3今日错题解析（软考）

10.3今日错题解析（软考）

目录 前言计算机网络——路由配置数据库系统——封锁协议 前言 这是用来记录我备考软考设计师的错题的&#xff0c;今天知识点为路由配置、封锁协议&#xff0c;大部分错题摘自希赛中的题目&#xff0c;但相关解析是原创&#xff0c;有自己的思考&#xff0c;为了复习&#xf…
阅读更多...
Pix2Pix实现图像转换

Pix2Pix实现图像转换

tutorials/application/source_zh_cn/generative/pix2pix.ipynb MindSpore/docs - Gitee.com Pix2Pix概述 Pix2Pix是基于条件生成对抗网络&#xff08;cGAN, Condition Generative Adversarial Networks &#xff09;实现的一种深度学习图像转换模型&#xff0c;该模型是由Ph…
阅读更多...
Comparable接口和Comparator接口

Comparable接口和Comparator接口

前言 Java中基本数据类型可以直接比较大小&#xff0c;但引用类型呢&#xff1f;同时引用对象中可能存在多个可比较的字段&#xff0c;那么我们该怎么比较呢&#xff1f; Java中引用类型不能直接进行大小的比较&#xff0c;这种行为在编译器看来是危险的&#xff0c;所以会编译…
阅读更多...
程序员在AI时代的生存指南：打造不可替代的核心竞争力

程序员在AI时代的生存指南：打造不可替代的核心竞争力

在这个AI大行其道的时代&#xff0c;似乎每天都有新的语言模型像变魔术一样涌现出来&#xff0c;比如ChatGPT、midjourney、claude等等。这些家伙不仅会聊天&#xff0c;还能帮忙写代码&#xff0c;让程序员们感受到了前所未有的“压力”。我身边的一些程序员朋友开始焦虑&…
阅读更多...
SpringCloud入门（十）统一网关Gateway

SpringCloud入门（十）统一网关Gateway

一、网关的作用 Spring Cloud Gateway 是 Spring Cloud 的一个全新项目&#xff0c;该项目是基于 Spring 5.0&#xff0c;Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关&#xff0c;它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。 …
阅读更多...
E. Tree Pruning Codeforces Round 975 (Div. 2)

E. Tree Pruning Codeforces Round 975 (Div. 2)

原题 E. Tree Pruning 解析 本题题意很简单, 思路也很好想到, 假设我们保留第 x 层的树叶, 那么对于深度大于 x 的所有节点都要被剪掉, 而深度小于 x 的节点, 如果没有子节点深度大于等于 x, 那么也要被删掉 在做这道题的时候, 有关于如何找到一个节点它的子节点能通到哪里,…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023