Untitled

#include<iostream>
#include <unordered_map>
#include <string>
#include <set>
using namespace std;
#define MAX 30001
struct Task
{
    int finishtime;
    int currtime;
    int maxprocessoressor;
    int currproc;
    int ops;
};
Task tasks[MAX];
 
struct comparator {
    bool operator()(const int p1, const int p2)const
    {
        if (tasks[p1].finishtime == tasks[p2].finishtime)
        {
            return p1 < p2;
        }
        else if (tasks[p1].finishtime != tasks[p2].finishtime)
        {
            return tasks[p1].finishtime < tasks[p2].finishtime;
        }
    }
};
unordered_map<string, int> MP;
set<int, struct comparator> myset;
int c;
int TotalProc, Idx;
void init(int n)
{
    MP.clear();
    myset.clear();
    TotalProc = n;
    Idx = 1;
    c = 1;
}
void addProcessors(int timestamp, int mProcessors);
 
void UpdatetoCurrtime(int ctime)
{
    while (myset.size() > 0 && tasks[*myset.begin()].finishtime <= ctime)
    {
        int tmp = *myset.begin();
        myset.erase(myset.begin());
        addProcessors(tasks[tmp].finishtime, tasks[tmp].currproc);
    }
}
 
void processorToCurrTime(int timestamp)
{
    while (TotalProc && Idx < c)
    {
        while (tasks[Idx].currproc >= tasks[Idx].maxprocessoressor)
        {
            Idx++;
            if (Idx >= c)
                return;
        }
        int val = TotalProc;
        if (val > (tasks[Idx].maxprocessoressor - tasks[Idx].currproc))
            val = tasks[Idx].maxprocessoressor - tasks[Idx].currproc;
        tasks[Idx].ops -= (tasks[Idx].currproc * (timestamp - tasks[Idx].currtime));
        if (tasks[Idx].ops <= 0)
        {
            tasks[Idx].ops = 0;
            Idx++;
            continue;
        }
        tasks[Idx].currproc += val;
        TotalProc -= val;
        tasks[Idx].currtime = timestamp;
        myset.erase(Idx);
        tasks[Idx].finishtime = timestamp + tasks[Idx].ops / tasks[Idx].currproc;
        if (tasks[Idx].ops %tasks[Idx].currproc)
            tasks[Idx].finishtime++;
        myset.insert(Idx);
    }
}
 
void newTask(int timestamp, char mTask[], int mOperations, int mMaxProes)
{
    UpdatetoCurrtime(timestamp);
    MP[mTask] = c;
    tasks[c].ops = mOperations;
    tasks[c].currproc = 0;
    tasks[c].finishtime = 99999999;
    tasks[c].currtime = timestamp;
    tasks[c].maxprocessoressor = mMaxProes;
    c++;
    processorToCurrTime(timestamp);
}
void addProcessors(int timestamp, int mProcessors)
{
    UpdatetoCurrtime(timestamp);
    TotalProc += mProcessors;
    processorToCurrTime(timestamp);
}
int getTaskOperations(int timestamp, char mTask[])
{
    int tid = MP[mTask];
    UpdatetoCurrtime(timestamp);
    int ret = tasks[tid].ops - tasks[tid].currproc * (timestamp - tasks[tid].currtime);
    if (ret > 0)
        return ret;
    return 0;
}