今日头条校招2017.7.21编程3，PM、idea、程序员

PM有很多idea，由程序员实现。

有N个PM，某时间会想出一个idea，每个idea有提出时间、所需时间和优先等级，对于PM来说，最想实现的idea首先考虑优先等级高的，相同下优先所需时间小的，还相同下选择最早想出的，没有PM会在同一时刻提出2个idea。

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

求每个idea实现时间

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

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

样例

输入
2 2 5
1 1 1 2
1 2 1 1
1 3 2 2
2 1 1 2
2 3 5 5

输出
3
4
5
3
9

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

using namespace std;

class Idea{
public:
    Idea(int PM, int start, int pri, int cost) 
    : mPm(PM-1), mStart(start), mPriority(pri), mCost(cost), mAchieve(0){};

    //true 优先级高
    bool operator< (const Idea &idea)
    {
        // 比较优先级
        if (mPriority > idea.mPriority)
            return true;
        else if (mPriority < idea.mPriority)
            return false;


        if (mCost < idea.mCost)
            return true;
        else if (mCost > idea.mCost)
            return false;

        if (mStart < idea.mStart)
            return true;
        else if (mStart > idea.mStart)
            return false;

        if (mPm < idea.mPm)
            return true;
        else
            return false; 
    };    

public:
    int mPm;
    int mStart;
    int mPriority;
    int mCost;
    int mAchieve;
};

bool sortPIdea(Idea* a, Idea* b){
    if (*a < *b)
        return true;
    else
        return false;
}

void printTime(vector<Idea> &vec){
    for (int i = 0; i < vec.size(); i++){
        cout << vec[i].mAchieve << endl;
    }
}

int main()
{
    int nums_PM, nums_programmer, nums_idea;
    cin >> nums_PM >> nums_programmer >> nums_idea;

    vector<Idea> vec_idea;
    vector<vector<Idea*> > pm_idea;
    vector<int> pro_state;

    pm_idea.resize(nums_PM);
    pro_state.assign(nums_programmer, 0);

    for (int i = 0; i < nums_idea; i++){
        int pm, start, pri, cost;
        cin >> pm >> start >> pri >> cost;

        vec_idea.push_back(Idea(pm, start, pri, cost));
    }

    for (int i = 0; i < nums_idea; i++){
        pm_idea[vec_idea[i].mPm].push_back(&vec_idea[i]);
    }

    int time = 0;
    int sum_idea = nums_idea;
    while (1){
        time++;

        //更新程序员状态
        for (int i = 0; i < pro_state.size(); i++){
            if (pro_state[i] != 0)
                pro_state[i]--;
        }

        //PM任务排序，[0]是PM最想实现的
        for (int i = 0; i < pm_idea.size(); i++){
            int j = 0;
            for (j = 0; j < pm_idea[i].size(); j++){
                if (pm_idea[i][j]->mStart > time){
                    break;
                }
            }
            std::sort(pm_idea[i].begin(), pm_idea[i].begin() + j, sortPIdea);
        }

        //程序源接idea
        for (int i = 0; i < pro_state.size(); i++){
            if (sum_idea == 0)
            {
                printTime(vec_idea);
                return 0 ;
            }

            if (pro_state[i] == 0){
                Idea* p = NULL;
                int index = 0;
                for (int j = 0; j < pm_idea.size(); j++){
                    if (pm_idea[j].size() > 0 && pm_idea[j][0]->mStart <= time){
                        if (p == NULL){
                            p = pm_idea[j][0];
                            index = j;
                        }
                        else{
                            if (pm_idea[j][0]->mCost < p->mCost){
                                p = pm_idea[j][0];
                                index = j;
                            }
                        }
                    }
                }

                //暂时没有idea
                if (p == NULL){
                    continue;
                }

                //接idea
                sum_idea--;
                pro_state[i] = p->mCost;
                p->mAchieve = time + p->mCost;
                pm_idea[index].erase(pm_idea[index].begin());
            }
        }
    }

    return 0;
}