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

专栏导读

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

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

一、题目描述

新来的老师给班里的同学排一个队。

每个学生有一个影响值。

一些学生是刺头，不会听老师的话，自己选位置，剩余从听老师话的同学在剩下的位置按能力值从小到大排。

对于非刺头同学，如果发现他们前面有能力值比自己高的同学，他不满程度就增加，增加的数量等于前面能力值比他大的同学的个数。

刺头不会产生不满。

如果某个班级的总体不满程度超过k，那么老师就无法继续教这个班级了。

二、输入描述

输入有三行：

第一行为n,m,k，空格隔开，分别表示班级总人数n，刺头人数m，最大不满程度k。

第二行为刺头所在位置的下标，即排队数组的下标，比如1代表队伍中第2个同学是刺头，位置的数组也是排好序的。

第三行为n个数，空格隔开，表示老师排好的队列中每个人的能力值，其中刺头同学一定按照能力值从小到大排序的。

三、输出描述

0 表示老师可以继续教这个班级。

1 表示老师无法继续教这个班级。

备注

n 范围是 [1,100000]
m 范围是 [1,n]
k 范围是 [1,1000000000]
每位同学的能力值范围是 [1000,100000]

四、测试用例

测试用例1：

1、输入

4 2 3
0 1
1810 1809 1801 1802

2、输出

1

3、说明

刺头在0,1位置，2号同学不满程度2（前面两个刺头能力值都比他大），3号同学不满程度2，总不满程度4，大于3。输出不能教这班(1)。

测试用例2：

1、输入

4 2 4
0 1
1810 1809 1801 1802

2、输出

0

3、说明

同前，4不大于4，输出能教这个班(0)。

五、解题思路

1、数据结构和算法

（1）Fenwick 树（Binary Indexed Tree）：

用途：高效地进行前缀和查询和更新操作。

原因：需要在 O(n log n) 时间内处理大量数据（n ≤ 100,000），Fenwick 树能在对数时间内完成插入和查询。

（2）坐标压缩：

用途：将能力值范围从 [1000, 100,000] 压缩到 [1, uniqueCount]，以适应 Fenwick 树的索引。

原因：能力值可能很大且不连续，直接使用能力值作为索引会浪费空间。通过排序和去重，能够有效地映射能力值到连续的排名。

（3）遍历学生队列：

用途：按队列顺序处理每个学生，计算不满程度。

原因：需要根据学生在队列中的位置和能力值，动态地计算不满程度。

这种组合使得算法能够在保证效率的同时，准确地计算出总不满程度，满足题目的要求。

六、Python算法源码

# 导入必要的库
import sys
import bisect

# 定义 Fenwick 树（又称二叉索引树）类
class FenwickTree:
    def __init__(self, size):
        self.size = size
        self.tree = [0] * (size + 1)  # 初始化树，索引从1开始

    # 在索引位置添加值
    def update(self, index, value):
        while index <= self.size:
            self.tree[index] += value
            index += index & -index  # 移动到下一个需要更新的位置

    # 查询前缀和，包含当前索引
    def query(self, index):
        result = 0
        while index > 0:
            result += self.tree[index]
            index -= index & -index  # 移动到父节点
        return result

def main():
    # 读取所有输入并分割成列表
    input = sys.stdin.read().split()
    ptr = 0  # 指针初始化

    # 读取 n（总人数），m（刺头人数），k（最大不满程度）
    n = int(input[ptr])
    m = int(input[ptr + 1])
    k = int(input[ptr + 2])
    ptr += 3

    # 初始化一个布尔列表标记刺头
    rebellious = [False] * n
    for _ in range(m):
        idx = int(input[ptr])
        rebellious[idx] = True
        ptr += 1

    # 读取所有学生的能力值
    abilities = []
    for _ in range(n):
        abilities.append(int(input[ptr]))
        ptr += 1

    # 坐标压缩：将能力值排序并去重
    sorted_abilities = sorted(list(set(abilities)))
    # 为每个能力值分配一个唯一的排名
    ability_to_rank = {ability: idx + 1 for idx, ability in enumerate(sorted_abilities)}

    # 初始化 Fenwick 树，大小为唯一能力值的数量
    fenwick = FenwickTree(len(sorted_abilities))

    total_dissatisfaction = 0  # 总不满程度初始化
    inserted_count = 0  # 已插入的学生数量初始化

    for i in range(n):
        ability = abilities[i]
        rank = ability_to_rank[ability]
        if not rebellious[i]:
            # 计算已插入的学生中能力值大于当前学生的数量
            higher_count = inserted_count - fenwick.query(rank)
            total_dissatisfaction += higher_count
            # 如果总不满程度超过k，提前终止
            if total_dissatisfaction > k:
                break
        # 将当前学生的能力值插入 Fenwick 树
        fenwick.update(rank, 1)
        inserted_count += 1

    # 根据总不满程度输出结果
    if total_dissatisfaction > k:
        print(1)
    else:
        print(0)

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// 定义 Fenwick 树（又称二叉索引树）类
class FenwickTree {
    constructor(size) {
        this.size = size;
        this.tree = new Array(size + 1).fill(0); // 初始化树，索引从1开始
    }

    // 在索引位置添加值
    update(index, value) {
        while (index <= this.size) {
            this.tree[index] += value;
            index += index & -index; // 移动到下一个需要更新的位置
        }
    }

    // 查询前缀和，包含当前索引
    query(index) {
        let result = 0;
        while (index > 0) {
            result += this.tree[index];
            index -= index & -index; // 移动到父节点
        }
        return result;
    }
}

// 主函数
function main() {
    const fs = require('fs');
    const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split(/\s+/);
    let ptr = 0; // 指针初始化

    // 读取 n（总人数），m（刺头人数），k（最大不满程度）
    const n = parseInt(input[ptr++]);
    const m = parseInt(input[ptr++]);
    const k = parseInt(input[ptr++]);

    // 初始化一个布尔数组标记刺头
    const rebellious = Array(n).fill(false);
    for (let i = 0; i < m; i++) {
        const idx = parseInt(input[ptr++]);
        rebellious[idx] = true;
    }

    // 读取所有学生的能力值
    const abilities = [];
    for (let i = 0; i < n; i++) {
        abilities.push(parseInt(input[ptr++]));
    }

    // 坐标压缩：将能力值排序并去重
    const sortedAbilities = Array.from(new Set(abilities)).sort((a, b) => a - b);
    // 为每个能力值分配一个唯一的排名
    const abilityToRank = new Map();
    sortedAbilities.forEach((ability, index) => {
        abilityToRank.set(ability, index + 1); // 排名从1开始
    });

    // 初始化 Fenwick 树，大小为唯一能力值的数量
    const fenwick = new FenwickTree(sortedAbilities.length);

    let totalDissatisfaction = 0; // 总不满程度初始化
    let insertedCount = 0; // 已插入的学生数量初始化

    for (let i = 0; i < n; i++) {
        const ability = abilities[i];
        const rank = abilityToRank.get(ability);
        if (!rebellious[i]) {
            // 计算已插入的学生中能力值大于当前学生的数量
            const higherCount = insertedCount - fenwick.query(rank);
            totalDissatisfaction += higherCount;
            // 如果总不满程度超过k，提前终止
            if (totalDissatisfaction > k) {
                break;
            }
        }
        // 将当前学生的能力值插入 Fenwick 树
        fenwick.update(rank, 1);
        insertedCount += 1;
    }

    // 根据总不满程度输出结果
    if (totalDissatisfaction > k) {
        console.log(1);
    } else {
        console.log(0);
    }
}

// 调用主函数
main();

八、C算法源码

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

// 定义 Fenwick 树（又称二叉索引树）结构体
typedef struct {
    int size;
    long long* tree;
} FenwickTree;

// 初始化 Fenwick 树
FenwickTree* createFenwickTree(int size) {
    FenwickTree* ft = (FenwickTree*)malloc(sizeof(FenwickTree));
    ft->size = size;
    ft->tree = (long long*)calloc(size + 1, sizeof(long long)); // 初始化树，索引从1开始
    return ft;
}

// 在索引位置添加值
void updateFenwickTree(FenwickTree* ft, int index, long long value) {
    while (index <= ft->size) {
        ft->tree[index] += value;
        index += index & (-index); // 移动到下一个需要更新的位置
    }
}

// 查询前缀和，包含当前索引
long long queryFenwickTree(FenwickTree* ft, int index) {
    long long result = 0;
    while (index > 0) {
        result += ft->tree[index];
        index -= index & (-index); // 移动到父节点
    }
    return result;
}

// 比较函数，用于qsort
int cmp(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int main() {
    int n, m;
    long long k;
    
    // 读取 n（总人数），m（刺头人数），k（最大不满程度）
    scanf("%d %d %lld", &n, &m, &k);
    
    // 初始化一个布尔数组标记刺头
    int* rebellious = (int*)calloc(n, sizeof(int));
    for(int i = 0; i < m; i++) {
        int idx;
        scanf("%d", &idx);
        rebellious[idx] = 1;
    }
    
    // 读取所有学生的能力值
    int* abilities = (int*)malloc(n * sizeof(int));
    for(int i = 0; i < n; i++) {
        scanf("%d", &abilities[i]);
    }
    
    // 坐标压缩：将能力值排序并去重
    int* sorted = (int*)malloc(n * sizeof(int));
    memcpy(sorted, abilities, n * sizeof(int));
    qsort(sorted, n, sizeof(int), cmp);
    
    // 去重并记录唯一能力值的数量
    int uniqueCount = 1;
    for(int i = 1; i < n; i++) {
        if(sorted[i] != sorted[i - 1]) {
            sorted[uniqueCount++] = sorted[i];
        }
    }
    
    // 为每个能力值分配一个唯一的排名
    // 使用二分查找进行映射
    // 因为sorted数组已经排序且去重
    // 所以可以使用二分查找来找到每个能力值的排名
    // 初始化 Fenwick 树
    FenwickTree* fenwick = createFenwickTree(uniqueCount);
    
    long long totalDissatisfaction = 0; // 总不满程度初始化
    long long insertedCount = 0; // 已插入的学生数量初始化
    
    for(int i = 0; i < n; i++) {
        // 使用二分查找找到当前能力值的排名
        int ability = abilities[i];
        int left = 0, right = uniqueCount - 1, mid, rank = 1;
        while(left <= right) {
            mid = left + (right - left) / 2;
            if(sorted[mid] == ability) {
                rank = mid + 1; // 排名从1开始
                break;
            }
            else if(sorted[mid] < ability) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        
        if(!rebellious[i]) {
            // 计算已插入的学生中能力值大于当前学生的数量
            long long higherCount = insertedCount - queryFenwickTree(fenwick, rank);
            totalDissatisfaction += higherCount;
            // 如果总不满程度超过k，提前终止
            if(totalDissatisfaction > k) {
                break;
            }
        }
        // 将当前学生的能力值插入 Fenwick 树
        updateFenwickTree(fenwick, rank, 1);
        insertedCount += 1;
    }
    
    // 根据总不满程度输出结果
    if(totalDissatisfaction > k) {
        printf("1\n");
    }
    else {
        printf("0\n");
    }
    
    // 释放内存
    free(rebellious);
    free(abilities);
    free(sorted);
    free(fenwick->tree);
    free(fenwick);
    
    return 0;
}

九、C++算法源码

#include <bits/stdc++.h>
using namespace std;

// 定义 Fenwick 树（又称二叉索引树）类
class FenwickTree {
public:
    int size;
    vector<long long> tree;

    // 构造函数，初始化树，索引从1开始
    FenwickTree(int sz) {
        size = sz;
        tree.assign(size + 1, 0);
    }

    // 在索引位置添加值
    void update(int index, long long value) {
        while(index <= size){
            tree[index] += value;
            index += index & (-index); // 移动到下一个需要更新的位置
        }
    }

    // 查询前缀和，包含当前索引
    long long query(int index){
        long long result = 0;
        while(index > 0){
            result += tree[index];
            index -= index & (-index); // 移动到父节点
        }
        return result;
    }
};

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n, m;
    long long k;
    cin >> n >> m >> k;

    // 初始化一个布尔数组标记刺头
    vector<bool> rebellious(n, false);
    for(int i = 0; i < m; i++){
        int idx;
        cin >> idx;
        rebellious[idx] = true;
    }

    // 读取所有学生的能力值
    vector<int> abilities(n);
    for(int i = 0; i < n; i++) cin >> abilities[i];

    // 坐标压缩：将能力值排序并去重
    vector<int> sorted = abilities;
    sort(sorted.begin(), sorted.end());
    sorted.erase(unique(sorted.begin(), sorted.end()), sorted.end());

    // 为每个能力值分配一个唯一的排名
    // 使用 lower_bound 进行映射
    // 初始化 Fenwick 树
    FenwickTree fenwick(sorted.size());

    long long totalDissatisfaction = 0; // 总不满程度初始化
    long long insertedCount = 0; // 已插入的学生数量初始化

    for(int i = 0; i < n; i++){
        int ability = abilities[i];
        // 使用 lower_bound 找到能力值的排名
        int rank = lower_bound(sorted.begin(), sorted.end(), ability) - sorted.begin() + 1; // 排名从1开始

        if(!rebellious[i]){
            // 计算已插入的学生中能力值大于当前学生的数量
            long long higherCount = insertedCount - fenwick.query(rank);
            totalDissatisfaction += higherCount;
            // 如果总不满程度超过k，提前终止
            if(totalDissatisfaction > k){
                break;
            }
        }
        // 将当前学生的能力值插入 Fenwick 树
        fenwick.update(rank, 1);
        insertedCount += 1;
    }

    // 根据总不满程度输出结果
    if(totalDissatisfaction > k){
        cout << "1\n";
    }
    else{
        cout << "0\n";
    }

    return 0;
}

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

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

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