HA15

#include <iostream>

// Деструктор и улучшение списка с нодами

class List {
public:
    // Конструктор
    List() : start(nullptr), finish(nullptr), size(0) {}

    // Этот простой деструктор удаляет все ноды
    ~List() {
        // Пока список не пуст, удаляем элементы с начала
        while (size > 0) {
            pop_front();
        }
    }

    void push_back(int new_value) {
        Node* new_node = new Node(new_value);
        if (size > 0) {
            finish->next = new_node;
            new_node->prev = finish;
        } else {
            start = new_node;
        }
        finish = new_node;
        ++size;
    }

    void push_front(int new_value) {
        Node* new_node = new Node(new_value);
        new_node->next = start;
        if (start != nullptr) {
            start->prev = new_node;
        }
        start = new_node;
        if (size == 0) {
            finish = new_node;
        }
        ++size;
    }

    void pop_front() {
        if (size == 0) {
            return;
        }
        Node* old_start = start;
        start = start->next;
        if (start != nullptr) {
            start->prev = nullptr;
        } else {
            finish = nullptr;
        }
        delete old_start;
        --size;
    }

    void pop_back() {
        if (size == 0) {
            return;
        }
        Node* old_finish = finish;
        finish = finish->prev;
        if (finish != nullptr) {
            finish->next = nullptr;
        } else {
            start = nullptr;
        }
        delete old_finish;
        --size;
    }

    Node* getStart() const { return start; }
    int getSize() const { return size; }

private:
    // Вложенный класс, перенес ноды в прайват
    class Node {
    public:
        Node(int val) : value(val), next(nullptr), prev(nullptr) {}

        int value;
        Node* next;
        Node* prev;
    };

    Node* start;  // указатель на первый
    Node* finish; // указатель на последний
    int size;     // размер
};

void process_operation(List* compartments, char op, int index, int value, int& current_total, int& max_total) {
    if (op == '+') {
        compartments[index - 1].push_back(value);
        current_total++;
    } else if (op == '-') {
        if (compartments[index - 1].getStart() != nullptr && compartments[index - 1].getStart()->value == value) {
            compartments[index - 1].pop_front();
            current_total--;
        }
    }

    if (current_total > max_total) {
        max_total = current_total;
    }
}

int main() {
    int N, K, P;
    std::cin >> N >> K >> P;
    std::cin.ignore();

    List* compartments = new List[N];

    char op;
    int index, value;
    int current_total = 0;
    int max_total = 0;

    for (int i = 0; i < P; ++i) {
        std::cin >> op >> index >> value;
        process_operation(compartments, op, index, value, current_total, max_total);
    }

    std::cout << max_total << std::endl;

    // Тут нам помогает деструктор - раньше была очистка циклом!
    delete[] compartments;
    return 0;
}