HA14_classes

#include <iostream>

// Struct -> classes

class Node {
public:
    Node(int val) : value(val), next(nullptr), prev(nullptr) {}
    int getValue() const { return value; }
    Node* getNext() const { return next; }
    void setNext(Node* nextNode) { next = nextNode; }
    Node* getPrev() const { return prev; }
    void setPrev(Node* prevNode) { prev = prevNode; }

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

class List {
public:
    List() : start(nullptr), finish(nullptr), size(0) {}

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

    void push_front(int new_value) {
        Node* new_node = new Node(new_value);
        new_node->setNext(start);
        if (start != nullptr) {
            start->setPrev(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->getNext();
        if (start != nullptr) {
            start->setPrev(nullptr);
        } else {
            finish = nullptr;
        }
        delete old_start;
        --size;
    }

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

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

private:
    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()->getValue() == 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;

    for (int i = 0; i < N; ++i) {
        while (compartments[i].getSize() > 0) {
            compartments[i].pop_front();
        }
    }

    delete[] compartments;
    return 0;
}