Очередь — поведение баннера сервера

Этот вопрос от Edx-UCSanDiegoX: Структура данных ALGS201x
Основы программирования Задача 1-3: обработка сетевых пакетов
моделирование

Привет всем, у меня очень длинный вопрос, я искренне ценю всех, кто тратит свое драгоценное время. Только Процесс ответа (постоянный запрос &запрос) реализация задается в вопросе, остальное предоставляется.
У меня возникли трудности, почему в случае неудачного теста я нашел тот же ответ, попробовав бумагу и ручку :), возможно, я сделал глупую ошибку. Благодарю вас.

Описание проблемы Задача:

Вам предоставляется серия входящих сетевых пакетов, и ваша задача — смоделировать их обработку. Пакеты прибывают в некотором порядке. Для каждого пакета i вы знаете, когда прибыл Ai и сколько времени процессору требуется для его обработки Pi (обе в миллисекундах). Есть только один процессор, и он обрабатывает входящие пакеты в порядке их поступления. Когда процессор начал обрабатывать какой-либо пакет, он не прерывает и не останавливает, пока не завершит обработку этого пакета, а обработка пакета I занимает ровно Pi миллисекунд.

Компьютер, обрабатывающий пакеты, имеет сетевой буфер фиксированного размера S. Когда пакеты поступают, они сохраняются в буфере до обработки. Однако, если буфер заполнен, когда приходит пакет (есть S пакетов, которые были доставлены до этого пакета, и компьютер не завершил обработку любого из них), он удаляется и вообще не будет обрабатываться. Если несколько пакетов поступают одновременно, все они сохраняются в буфере (некоторые из них могут быть отброшены из-за их прибытия, и он начинает обрабатывать следующий доступный пакет из буфера, как только заканчивает обработку предыдущего. В какой-то момент компьютер не занят, и в буфере нет пакетов, компьютер просто ожидает поступления следующего пакета.Обратите внимание, что пакет покидает буфер и освобождает место в буфере, как только компьютер заканчивает его обработку.

Формат ввода:

Первая строка ввода содержит размер S буфера и количество n входящих сетевых пакетов. Каждая из следующих n строк содержит два числа, I-я строка содержит время прибытия Ai и время обработки Pi (оба в мс) I-го пакета. Гарантируется, что последовательность времени прибытия не уменьшается. (Тем не менее, он может содержать те же самые времена прибытия в миллисекундах в этом случае пакет, который находится на входе раньше, считается поступившим раньше.

Выходной формат: Для каждого пакета выведите либо момент времени, когда процессор начал его обрабатывать, либо -1, если пакет был отброшен. (вывод в том же порядке, что и входные пакеты)

Пробные прогоны

Образец 1
Входные данные:

1 0

Выход:

Если нет пакетов, вы не должны ничего выводить

---

Образец 2

Входные данные:

1 1
0 0

Выход:

0

Единственный пакет прибыл в момент 0. И компьютер начал обрабатывать его.

---

Образец 3

Входные данные:

1 2
0 1
0 1

Выход:

0
1

Первый пакет прибыл в момент 0. Второй пакет также прибыл в момент 0, но был отброшен. Поскольку сетевой буфер имеет размер 1 и уже заполнен первым пакетом. Первый пакет начал обрабатываться в момент времени 0, второй не был обработан вообще.

---

Образец 4

Вход:

1 2
0 1
1 1

Выход:

0
1

Первый пакет прибыл в момент времени 0, компьютер начал обрабатывать его немедленно и завершил в момент времени 1. Второй пакет прибыл в момент времени 1, и компьютер начал обрабатывать его немедленно.

---

Сбой теста

Входы:

3 6
0 2
1 2
2 2
3 2
4 2
5 2

Мой вывод:

0
2
4
-1
6
-1

Правильный вывод:

0
2
4
6
8
-1

---

Код

#include <iostream>
#include <queue>
#include <vector>

struct Request {
Request(int arrival_time, int process_time) :
arrival_time(arrival_time),
process_time(process_time)
{}

int arrival_time;
int process_time;
};

struct Response {
Response(bool dropped, int start_time) :
dropped(dropped),
start_time(start_time)
{}

bool dropped;
int start_time;
};

class Buffer {
public:
Buffer(int size) :
size_(size),
finish_time_()
{}

Response Process(const Request &request)
{
while (!finish_time_.empty() && finish_time_.front() <= request.arrival_time)
finish_time_.pop();

if (finish_time_.empty())
{
finish_time_.push(request.arrival_time + request.process_time);
return Response(false, request.arrival_time);
}
else
{
if (size_> (finish_time_.back() - request.arrival_time))
{
int before = finish_time_.back();
finish_time_.push(before + request.process_time);
return Response(false, before);
}
else
{
return Response(true, 5);
}
}}
private:
int size_;
std::queue <int> finish_time_;
};

std::vector <Request> ReadRequests()
{
std::vector <Request> requests;
int count;
std::cin >> count;
for (int i = 0; i < count; ++i) {
int arrival_time, process_time;
std::cin >> arrival_time >> process_time;
requests.push_back(Request(arrival_time, process_time));
}
return requests;
}

std::vector <Response> ProcessRequests(const std::vector <Request> &requests, Buffer *buffer)
{
std::vector <Response> responses;
for (int i = 0; i < requests.size(); ++i)
responses.push_back(buffer->Process(requests[i]));
return responses;
}

void PrintResponses(const std::vector <Response> &responses)
{
for (int i = 0; i < responses.size(); ++i)
std::cout << (responses[i].dropped ? -1 : responses[i].start_time) << std::endl;
}

int main() {
int size;
std::cin >> size;
std::vector <Request> requests = ReadRequests();

Buffer buffer(size);
std::vector <Response> responses = ProcessRequests(requests, &buffer);

PrintResponses(responses);
return 0;
}