华为OD机试 - 计算观看演唱会场次 - 逻辑分析（Python/JS/C/C++ 2025 A卷 200分）-CSDN博客

在这里插入图片描述

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

专栏导读

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

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

一、题目描述

为了庆祝中国共产党成立100周年，某公园将举行多场文艺表演，很多演出都是同时进行，一个人只能同时观看一场演出，且不能迟到早退，由于演出分布在不同的演出场地，所以连续观看的演出最少有15分钟的时间间隔。

小明是一个狂热的文艺迷，想观看尽可能多的演出，现给出演出时间表，请帮小明计算他最多能观看几场演出。

二、输入描述

第一行为一个数N,表示演出场数，1 <= N<=1000,接下来N行，每行有被空格分割的两个整数；
第一个整数T表示演出的开始时间，第二个整数L表示演出的持续时间；

T和L的单位为分钟，0 <=T <=1440, 0 <= L <= 100

三、输出描述

输出最多能观看的演出场数。

四、测试用例

1、输入

3
100 120
240 150
400 100

2、输出

3、说明

第一场100开始，持续120分钟，结束时220；
第一场220结束，距离第二场开始时间240，大于15分钟，时间来得及，观看场次+1；
第二场390结束，距离第三场开始时间400，小于15分钟，来不及了。

在这里插入图片描述

五、解题思路

输入演出场数N；
定义演出开始时间+演出结束时间list集合timeList；
输入演出的开始时间T；
输入演出的持续时间L；
初始化timeList集合，并排序；
定义最多能观看的演出场数max；
遍历时间集合timeList；
连续观看的演出最少有15分钟的时间间隔，观看场次+1；
输出最多能观看的演出场数

六、Python算法源码

def max_performances(N, performances):
    # 按照演出结束时间排序，结束时间相同的情况下按开始时间升序
    performances.sort(key=lambda x: (x[1], x[0]))
    
    start_time = -1
    max_performances = 0
    
    for performance in performances:
        cur_start_time = performance[0]
        cur_end_time = performance[1]
        
        # 连续观看的演出最少有15分钟的时间间隔
        if cur_start_time >= start_time + 15:
            max_performances += 1
            start_time = cur_end_time
    
    return max_performances

七、JavaScript算法源码

function maxPerformances(N, performances) {
    // 按照演出结束时间排序，结束时间相同的情况下按开始时间升序
    performances.sort((a, b) => a[1] - b[1] || a[0] - b[0]);

    let startTime = -1;
    let maxPerformances = 0;

    for (let performance of performances) {
        let curStartTime = performance[0];
        let curEndTime = performance[1];

        // 连续观看的演出最少有15分钟的时间间隔
        if (curStartTime >= startTime + 15) {
            maxPerformances++;
            startTime = curEndTime;
        }
    }

    return maxPerformances;
}

八、C算法源码

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

typedef struct {
    int start;
    int end;
} Performance;

int compare(const void* a, const void* b) {
    Performance* perfA = (Performance*)a;
    Performance* perfB = (Performance*)b;
    if (perfA->end == perfB->end) {
        return perfA->start - perfB->start;
    }
    return perfA->end - perfB->end;
}

int maxPerformances(int N, Performance performances[]) {
    qsort(performances, N, sizeof(Performance), compare);
    
    int startTime = -1;
    int maxPerformances = 0;

    for (int i = 0; i < N; i++) {
        int curStartTime = performances[i].start;
        int curEndTime = performances[i].end;

        if (curStartTime >= startTime + 15) {
            maxPerformances++;
            startTime = curEndTime;
        }
    }

    return maxPerformances;
}

九、C++算法源码

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

struct Performance {
    int start;
    int end;
};

bool compare(Performance a, Performance b) {
    if (a.end == b.end) {
        return a.start < b.start;
    }
    return a.end < b.end;
}

int maxPerformances(int N, vector<Performance>& performances) {
    sort(performances.begin(), performances.end(), compare);

    int startTime = -1;
    int maxPerformances = 0;

    for (int i = 0; i < N; i++) {
        int curStartTime = performances[i].start;
        int curEndTime = performances[i].end;

        if (curStartTime >= startTime + 15) {
            maxPerformances++;
            startTime = curEndTime;
        }
    }

    return maxPerformances;
}