【无标题】

产品经理(PM)有很多好的idea，而这些idea需要程序员实现。现在有N个PM，在某个时间会想出一个 idea，每个 idea 有提出时间、所需时间和优先等级。对于一个PM来说，最想实现的idea首先考虑优先等级高的，相同的情况下优先所需时间最小的，还相同的情况下选择最早想出的，没有 PM 会在同一时刻提出两个 idea。

同时有M个程序员，每个程序员空闲的时候就会查看每个PM尚未执行并且最想完成的一个idea,然后从中挑选出所需时间最小的一个idea独立实现，如果所需时间相同则选择PM序号最小的。直到完成了idea才会重复上述操作。如果有多个同时处于空闲状态的程序员，那么他们会依次进行查看idea的操作。

求每个idea实现的时间。

输入第一行三个数N、M、P，分别表示有N个PM，M个程序员，P个idea。随后有P行，每行有4个数字，分别是PM序号、提出时间、优先等级和所需时间。输出P行，分别表示每个idea实现的时间点。

输入描述:
输入第一行三个数N、M、P，分别表示有N个PM，M个程序员，P个idea。随后有P行，每行有4个数字，分别是PM序号、提出时间、优先等级和所需时间。全部数据范围 [1, 3000]。

输出描述:
输出P行，分别表示每个idea实现的时间点。

输入例子1:
2 2 5
1 1 1 2
1 2 1 1
1 3 2 2
2 1 1 2
2 3 5 5

输出例子1:
3
4
5
3
9

#include<bits/stdc++.h>
using namespace std;
struct idea{
    // idea的标号, 想出idea的pm, 想出idea的时间, idea的优先级, idea所需时间
    int id, pm, time, priority, cost;
    idea(int id_, int pm_, int time_, int priority_, int cost_):
        id(id_),pm(pm_),time(time_),priority(priority_),cost(cost_){
    }
};
// pm对idea的优先级比较
struct cmp_by_pm{
    bool operator()(const idea& a, const idea& b) {
        if (a.priority != b.priority) {
            return a.priority < b.priority;
        }
        if (a.cost != b.cost) {
            return a.cost > b.cost;
        }
        if (a.time != b.time) {
            return a.time > b.time;
        }
        return a.pm < b.pm;
    }
};
// 想出idea的时间比较
bool cmp_time(const idea& a, const idea& b){
    return a.time < b.time;
}
// 程序员对idea的优先级比较
struct cmp_by_worker{
    bool operator()(const idea& a, const idea& b) {
        if (a.cost != b.cost) {
            return a.cost > b.cost;
        }
        return a.pm > b.pm;
    }
};
int main(){
    int i;
    int N, M, P;
    cin >> N >> M >> P;
    vector<idea> ideas;  // 记录ideas
    int pm, time, priority, cost;
    for (int i = 0; i < P; i++) {
        cin >> pm >> time >> priority >> cost;
        ideas.emplace_back(idea(i, pm - 1, time, priority, cost));
    }
    vector<int> workers(M, 0);  // 程序员剩余的工作时间
    vector<int> finished(P);  // 记录ideas的完成时间
    // 优先队列, 分别记录每个PM当前尚未执行的idea, 可获得其最想执行的idea
    priority_queue<idea, vector<idea>, cmp_by_pm> cur_ideas[N];
    // 对ideas排序, 按时间逐个加入每个PM的优先队列中
    sort(ideas.begin(), ideas.end(), cmp_time);
    int count = 0, p = 0;
    time = 1;
    while (count < P) {
        while (p < P && ideas[p].time <= time) {
            int pm_ = ideas[p].pm;
            cur_ideas[pm_].push(ideas[p]);
            p++;
        }
        // 优先队列, 记录每个PM最想执行的idea, 可获得程序员将要做的idea
        priority_queue<idea, vector<idea>, cmp_by_worker> q;
        for (i = 0; i < N; i++) {
            if (!cur_ideas[i].empty()) {
                q.push(cur_ideas[i].top());
            }
        }
        // 更新程序员的剩余工作时间, 为空闲程序员分配工作
        for (i = 0; i < M; i++) {
            if (workers[i] > 0) {
                workers[i]--;
            }
            if (workers[i] == 0 && !q.empty()) {
                idea t = q.top();
                q.pop();
                cur_ideas[t.pm].pop();
                // 一个PM的idea被执行后, 他的次优先idea需要加入队列中
                if (!cur_ideas[t.pm].empty()) {
                    q.push(cur_ideas[t.pm].top());
                }
                // 分配工作后更新剩余工作时间, 同时可确定完成时间
                workers[i] = t.cost;
                finished[t.id] = time + t.cost;
                count++;
            }
        }
        time++;
    }
    for (i = 0; i < P; i++) {
        cout << finished[i] << endl;
    }
}