принята (дерево отрезков)

#include <iostream>
#include <string>
#include <vector>

const int MAX = 2e5;

struct vertex
{
    int res;
    int left;
    int right;
};

class Segment_Tree
{
    struct vertex* tree;
    int tree_size;
    int count_numbers;
    std::vector<int> numbers;

public:
    void build_tree(int v, int tl, int tr);
    int to_deg_of_two(std::vector<int>& numbers, int count_numbers);
    void Initialize(int count_numbers);
    void set_number(int k, int x);
    int get_min(int node, int a, int b);
    int find_spot(int start_number);
    int free_up(int number);
    void print_tree();
    void permute_request(char s, std::string number);
};

void Segment_Tree::build_tree(int v, int tl, int tr)
{


    if (tr - tl == 1)
    {
        this->tree[v].res = this->numbers[tl];
        this->tree[v].left = tl;
        this->tree[v].right = tr;
    }
    else
    {
        int tm = (tl + tr) / 2;
        build_tree(v * 2 + 1, tl, tm);
        build_tree(v * 2 + 2, tm, tr);
        this->tree[v].left = tl;
        this->tree[v].right = tr;

        if (tree[v * 2 + 1].res < tree[v * 2 + 2].res)
            this->tree[v].res = tree[v * 2 + 1].res;
        else
            this->tree[v].res = tree[v * 2 + 2].res;
    }
}

int Segment_Tree::to_deg_of_two(std::vector<int>& numbers, int count_numbers)
{

    int p = 1;
    while (count_numbers > p)
        p *= 2;

    for (int i = 0; i < p - count_numbers; ++i)
        this->numbers.push_back(MAX);

    return p;
}

void Segment_Tree::Initialize(int count_numbers)
{


    this->count_numbers = count_numbers;
    this->numbers.clear();
    this->numbers.resize(count_numbers);

    for (int i = 1; i <= count_numbers; ++i)
        this->numbers[i - 1] = i;

    this->count_numbers = to_deg_of_two(numbers, count_numbers);
    this->tree_size = 2 * this->count_numbers - 1;
    this->tree = new vertex[tree_size];

    build_tree(0, 0, this->count_numbers);
}


void Segment_Tree::set_number(int k, int x)
{
    int v = this->count_numbers - 1 + k;
    this->tree[v].res = x;
    while (v > 0)
    {
        v = (v - 1) / 2;

        int l_min = tree[2 * v + 1].res;
        int r_min = tree[2 * v + 2].res;
        (l_min < r_min) ? this->tree[v].res = l_min : this->tree[v].res = r_min;
    }
}

int Segment_Tree::get_min(int node, int a, int b)
{
    int l = tree[node].left;
    int r = tree[node].right;
    if (r <= a || l >= b)
        return MAX;

    if (r <= b & l >= a)
        return tree[node].res;

    int m_one = get_min(node * 2 + 1, a, b);
    int m_two = get_min(node * 2 + 2, a, b);
    return (m_one < m_two) ? m_one : m_two;
}

int Segment_Tree::find_spot(int start_number)
{

    int pos = (start_number - 1) + (this->tree_size - this->count_numbers);

    if (tree[pos].res != MAX)
    {

        set_number(start_number - 1, MAX);
        return start_number;
    }

    else
    {
        int min_num = get_min(0, start_number - 1, this->count_numbers);

        if (min_num == MAX)
        {
            min_num = get_min(0, 0, start_number);

            if (min_num == MAX)
                return -1;
            else
            {
                set_number(min_num - 1, MAX);
                return min_num;
            }
        }

        else
        {
            set_number(min_num - 1, MAX);
            return min_num;
        }
    }
}

int Segment_Tree::free_up(int number)
{
    int pos = (number - 1) + (this->tree_size - this->count_numbers);

    if (tree[pos].res == MAX)
    {
        set_number(number - 1, number);
        return 0;
    }
    else
        return -2;
}

void Segment_Tree::permute_request(char s, std::string number)
{
    int num = std::stoi(number);
    if (s == '+')
        std::cout << find_spot(num) << std::endl;
    else
        std::cout << free_up(num) << std::endl;
}

int main()
{

    int n, m;
    char s;
    std::string number;
    std::cin >> n >> m;

    Segment_Tree tree;
    tree.Initialize(n);

    for (int i = 0; i < m; ++i)
    {
        std::cin >> s >> number;
        tree.permute_request(s, number);
    }

    return 0;
}