#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <numeric>
#include <set>
#include <iomanip>
#include <queue>
#include <map>


using namespace std;

struct Process {
	int arrivalTime;
	int serviceTime;
	int index;
	int priority = 5;
	map<int, int> PriorityToUnit = { { 5,1 },{ 4,2 },{ 3,4 },{ 2, 8 },{ 1, numeric_limits<int>::max() } };
	Process(int arrival, int service, int indx) : arrivalTime(arrival), serviceTime(service), index(indx) {}
};

namespace {
	struct ArrivalTimeSort {
		bool operator() (const Process &a, const Process &b) {
			return a.arrivalTime < b.arrivalTime;
		}
	};

	struct SJF_Sort {
		bool operator() (const Process &a, const Process &b) {
			if (a.arrivalTime == b.arrivalTime)
				return a.serviceTime < b.serviceTime;
			else
				return a.arrivalTime < b.arrivalTime;
		}
	};

	struct ServiceTimeSort {
		bool operator() (const Process *a, const Process *b) {
			if (a->serviceTime == b->serviceTime)
				return a->arrivalTime < b->arrivalTime;
			return a->serviceTime < b->serviceTime;
		}
	};

	struct PrioritySort {
		bool operator() (const Process *a, const Process *b) {
			return a->priority > b->priority;
		}
	};
}

vector<int> MLF(vector<Process> processes) {
	vector<int> toReturn(processes.size());
	stable_sort(processes.begin(), processes.end(), ArrivalTimeSort());

	int currentTime = 0;
	//priority_queue<Process*, vector<Process*>, PrioritySort> q;
	multiset<Process*, PrioritySort> q;
	int currentRunningProcessTimeFrame = 0;
	bool returnToQueue = false;
	int i = 0;
	while (i < processes.size() || !q.empty()) {
		if (q.empty()) {
			q.insert(&processes[i]);
			currentTime = (*q.begin())->arrivalTime;
			i++;
		}

		Process *currentRunningProcess = *q.begin();

		if (currentRunningProcess->serviceTime <= currentRunningProcess->PriorityToUnit[currentRunningProcess->priority]) {
			currentTime += (currentRunningProcessTimeFrame = currentRunningProcess->serviceTime);
			currentRunningProcess->PriorityToUnit[currentRunningProcess->priority] = currentRunningProcess->serviceTime;
			returnToQueue = false;
		}
		else {
			currentTime += (currentRunningProcessTimeFrame = currentRunningProcess->PriorityToUnit[currentRunningProcess->priority]);
			returnToQueue = true;
		}

		while (i < processes.size() && processes[i].arrivalTime < currentTime) {
			q.insert(&(processes[i]));
			if (processes[i].priority > currentRunningProcess->priority) {
				currentRunningProcess->serviceTime -= processes[i].arrivalTime - (currentTime - currentRunningProcessTimeFrame);
				currentRunningProcess->PriorityToUnit[currentRunningProcess->priority] = currentTime - processes[i].arrivalTime;

				currentRunningProcess = *q.begin();
				currentTime = currentRunningProcess->arrivalTime;
				if (currentRunningProcess->serviceTime <= currentRunningProcess->PriorityToUnit[currentRunningProcess->priority]) {
					currentTime += (currentRunningProcessTimeFrame = currentRunningProcess->serviceTime);
					returnToQueue = false;
				}
				else {
					currentTime += (currentRunningProcessTimeFrame = currentRunningProcess->PriorityToUnit[currentRunningProcess->priority]);
					returnToQueue = true;
				}
			}
			i++;
		}

		if (!returnToQueue) {
			toReturn[currentRunningProcess->index] = currentTime - currentRunningProcess->arrivalTime;
			q.erase(q.begin());
		}
		else {
			q.erase(q.begin());
			currentRunningProcess->serviceTime -= currentRunningProcess->PriorityToUnit[currentRunningProcess->priority];
			currentRunningProcess->priority--;
			q.insert(currentRunningProcess);
		}
	}

	return toReturn;
}