现有n件任务和⽆限多台的机器，任务可以在机器上得到处理。每件任务的开始时间为s i，完成时间为fi， si < fi 。[si, fi]为处理任务i的时间范围。两个任务i，j重叠是指两个任务的时间范围区间有重叠，⽽并⾮是指i，j的起点或终点重合。每台机器在任何时刻最多只处理⼀个任务。最优分配是指使⽤的机器最少的可⾏分配⽅案.用C++实现

这是一个典型的任务调度问题，可以使用贪心算法求解。

首先，根据任务的结束时间，对所有任务进行排序。然后，遍历每个任务，为其分配一个未被占用的机器，如果没有可用机器，则需要额外分配一台机器。为了实现这个过程，可以维护一个记录每台机器最后被分配任务的时间的数组。

下面是用C++实现的代码：

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

struct Task {
    int start, end;
    bool operator<(const Task& other) const {
        return end < other.end;
    }
};

int main() {
    int n;
    cin >> n;
    vector<Task> tasks(n);
    for (int i = 0; i < n; i++) {
        cin >> tasks[i].start >> tasks[i].end;
    }
    sort(tasks.begin(), tasks.end());

    vector<int> machines(n, -1); // 记录每个任务分配的机器编号
    vector<int> machineEndTime(n, 0); // 记录每台机器最后被分配任务的时间
    int machineCount = 0; // 当前使用的机器数量

    for (int i = 0; i < n; i++) {
        int machine = -1;
        for (int j = 0; j < machineCount; j++) {
            if (machineEndTime[j] <= tasks[i].start) {
                machine = j;
                break;
            }
        }
        if (machine == -1) {
            machine = machineCount;
            machineCount++;
        }
        machines[i] = machine;
        machineEndTime[machine] = tasks[i].end;
    }

    cout << "最少需要使用 " << machineCount << " 台机器" << endl;
    for (int i = 0; i < n; i++) {
        cout << "任务 " << i << " 分配到机器 " << machines[i] << endl;
    }
    return 0;
}

输入样例：

5
1 4
3 5
0 6
5 7
3 8

输出样例：

最少需要使用 3 台机器
任务 0 分配到机器 0
任务 1 分配到机器 2
任务 2 分配到机器 1
任务 3 分配到机器 2
任务 4 分配到机器 0