华为OD机试-会议室占用时间段（Java 2024 C卷 100分）

题目描述

现有若干个会议，所有会议共享一个会议室，用数组表示各个会议的开始时间和结束时间，格式为：[[会议1开始时间, 会议1结束时间], [会议2开始时间, 会议2结束时间], ...]。请计算会议室占用时间段。

输入描述

输入为一个二维数组，表示各个会议的开始时间和结束时间。会议个数范围为 [1,100]，会议室时间段为 [1,24]。

输出描述

输出格式与输入一致，输出合并后的会议室占用时间段。

示例

输入:

[[1,4],[4,5]]

输出:

[[1,5]]

解题思路

1. 排序: 首先按照会议的开始时间进行排序。
2. 合并: 遍历排序后的会议列表，如果当前会议的开始时间小于或等于前一个会议的结束时间，则合并这两个会议。
3. 输出: 输出合并后的会议室占用时间段。

代码实现

Java

import java.util.*;

public class Solution {
    public int[][] merge(int[][] intervals) {
        if (intervals.length <= 1) {
            return intervals;
        }

        // Sort by start time
        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));

        List<int[]> merged = new ArrayList<>();
        int[] currentInterval = intervals[0];
        merged.add(currentInterval);

        for (int[] interval : intervals) {
            int currentEnd = currentInterval[1];
            int nextStart = interval[0];
            int nextEnd = interval[1];

            if (currentEnd >= nextStart) {
                currentInterval[1] = Math.max(currentEnd, nextEnd);
            } else {
                currentInterval = interval;
                merged.add(currentInterval);
            }
        }

        return merged.toArray(new int[merged.size()][]);
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[][] intervals = {{1, 4}, {4, 5}};
        int[][] result = solution.merge(intervals);
        for (int[] interval : result) {
            System.out.print(Arrays.toString(interval) + " ");
        }
    }
}

Python

def merge(intervals):
    if not intervals:
        return []

    # Sort by start time
    intervals.sort(key=lambda x: x[0])

    merged = []
    current_interval = intervals[0]
    merged.append(current_interval)

    for interval in intervals:
        current_end = current_interval[1]
        next_start = interval[0]
        next_end = interval[1]

        if current_end >= next_start:
            current_interval[1] = max(current_end, next_end)
        else:
            current_interval = interval
            merged.append(current_interval)

    return merged

intervals = [[1, 4], [4, 5]]
result = merge(intervals)
print(result)

C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<vector<int>> merge(vector<vector<int>>& intervals) {
    if (intervals.size() <= 1) {
        return intervals;
    }

    // Sort by start time
    sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0];
    });

    vector<vector<int>> merged;
    vector<int> currentInterval = intervals[0];
    merged.push_back(currentInterval);

    for (const auto& interval : intervals) {
        int currentEnd = currentInterval[1];
        int nextStart = interval[0];
        int nextEnd = interval[1];

        if (currentEnd >= nextStart) {
            currentInterval[1] = max(currentEnd, nextEnd);
        } else {
            currentInterval = interval;
            merged.push_back(currentInterval);
        }
    }

    return merged;
}

int main() {
    vector<vector<int>> intervals = {{1, 4}, {4, 5}};
    vector<vector<int>> result = merge(intervals);
    for (const auto& interval : result) {
        cout << "[" << interval[0] << ", " << interval[1] << "] ";
    }
    return 0;
}

JavaScript

function merge(intervals) {
    if (intervals.length <= 1) {
        return intervals;
    }

    // Sort by start time
    intervals.sort((a, b) => a[0] - b[0]);

    const merged = [];
    let currentInterval = intervals[0];
    merged.push(currentInterval);

    for (const interval of intervals) {
        const currentEnd = currentInterval[1];
        const nextStart = interval[0];
        const nextEnd = interval[1];

        if (currentEnd >= nextStart) {
            currentInterval[1] = Math.max(currentEnd, nextEnd);
        } else {
            currentInterval = interval;
            merged.push(currentInterval);
        }
    }

    return merged;
}

const intervals = [[1, 4], [4, 5]];
const result = merge(intervals);
console.log(result);

复杂度分析

• 时间复杂度: O(n log n)，其中 n 是会议的数量。排序的时间复杂度为 O(n log n)，合并的时间复杂度为 O(n)。
• 空间复杂度: O(n)，用于存储合并后的会议时间段。

总结

通过排序和合并重叠的会议时间段，我们可以有效地计算会议室的占用时间段。不同语言的实现方式略有不同，但核心思路一致。