с ручкой более менее работает

#include <iostream>
#include <vector>
#include <fstream>
using namespace std;

struct heap_elements;

struct list_segments
{
    int l;
    int r;
    int status;
    struct list_segments* next;
    struct list_segments* prev;
    int to_heap;
    int heapID;
};

struct heap_elements
{
    int l;
    int r;
    int pos;
    list_segments* to_list;
};

bool operator<(const heap_elements& a, const heap_elements& b)
{

    if ((a.r - a.l < b.r - b.l))
        return true;
    if ((a.r - a.l == b.r - b.l) & (a.l > b.l))
        return true;

    return false;
}

class Heap
{
    std::vector<struct heap_elements> h;
    std::vector<int> ID_to_HeapIdx;
    int heap_size;

public:
    Heap();
    void siftup(int ID, std::vector<int>& HeapIdx_to_ID);
    void siftdown(int ID, std::vector<int>& HeapIdx_to_ID);
    void add(int ID, std::vector<int>& HeapIdx_to_ID, int l, int r, list_segments* to_list);
    void delete_vertex(int ID, std::vector<int>& HeapIdx_to_ID);
    void out();
    bool isempty();
    heap_elements* get_head();
};

Heap::Heap()
{
    std::vector<struct heap_elements> h;
    heap_size = 0;
    std::vector<int> ID_to_HeapIdx;
}

heap_elements* Heap::get_head()
{
    return &h[0];
}

bool Heap::isempty()
{
    if (heap_size == 0)
        return true;
    return false;
}

void Heap::siftup(int ID, std::vector<int>& HeapIdx_to_ID)
{
    int curr, parent;
    int tmp;
    curr = heap_size - 1;
    parent = (curr - 1) / 2;
    while (parent >= 0 && curr > 0)
    {
        if (h[parent] < h[curr])
        {
            heap_elements buff = h[curr];
            h[curr] = h[parent];
            h[parent] = buff;


            tmp = HeapIdx_to_ID[parent];
            HeapIdx_to_ID[parent] = HeapIdx_to_ID[curr];
            HeapIdx_to_ID[curr] = tmp;


            tmp = ID_to_HeapIdx[HeapIdx_to_ID[parent]];
            ID_to_HeapIdx[HeapIdx_to_ID[parent]] = ID_to_HeapIdx[HeapIdx_to_ID[curr]];
            ID_to_HeapIdx[HeapIdx_to_ID[curr]] = tmp;

            h[curr].pos = curr;
            h[parent].pos = parent;

            h[curr].to_list->to_heap = curr;
            h[parent].to_list->to_heap = parent;
        }
        curr = parent;
        parent = (curr - 1) / 2;
    }
}

void Heap::siftdown(int ID, std::vector<int>& HeapIdx_to_ID)
{

    cout << "IN" << endl;
    int parent, max_child;
    int tmp;
    int curr = ID_to_HeapIdx[ID];
    //ID_to_HeapIdx[ID] = -100;

    cout << "curr = " << curr << endl;

    cout << "HeapIdx_to_ID = ";
    for (int j=0;j<HeapIdx_to_ID.size(); j++)
        cout << HeapIdx_to_ID[j] << " " ;
    cout << endl;

    //int curr = pos;
    int child_l = 2 * curr + 1;
    int child_r = 2 * curr + 2;

    if (h[child_r] < h[child_l])
        max_child = child_l;
    else
        max_child = child_r;

    while (child_l < heap_size)
    {
        if (child_l == heap_size - 1)
            max_child = child_l;
        else if (h[child_r] < h[child_l])
            max_child = child_l;
        else
            max_child = child_r;

        if (h[curr] < h[max_child])
        {
            heap_elements buff = h[curr];
            h[curr] = h[max_child];
            h[max_child] = buff;


            tmp = HeapIdx_to_ID[max_child];
            HeapIdx_to_ID[max_child] = HeapIdx_to_ID[curr];
            HeapIdx_to_ID[curr] = tmp;

            tmp = ID_to_HeapIdx[HeapIdx_to_ID[max_child]];
            ID_to_HeapIdx[HeapIdx_to_ID[max_child]] = ID_to_HeapIdx[HeapIdx_to_ID[curr]];
            ID_to_HeapIdx[HeapIdx_to_ID[curr]] = tmp;

            h[curr].pos = curr;
            h[max_child].pos = max_child;

            h[curr].to_list->to_heap = curr;
            h[max_child].to_list->to_heap = max_child;
        }

        curr = max_child;
        child_l = 2 * curr + 1;
        child_r = 2 * curr + 2;
    }
}

void Heap::add(int ID, std::vector<int>& HeapIdx_to_ID, int l, int r, list_segments* to_list)
{

    heap_elements vertex;
    vertex.l = l;
    vertex.r = r;
    vertex.to_list = to_list;
    h.push_back(vertex);
    h[heap_size].pos = heap_size;
    if (h[heap_size].to_list != NULL)
        h[heap_size].to_list->to_heap = heap_size;

    ID_to_HeapIdx.push_back(heap_size);
    HeapIdx_to_ID.push_back(ID);

    heap_size++;
    siftup(ID, HeapIdx_to_ID);
}

void Heap::delete_vertex(int ID, std::vector<int>& HeapIdx_to_ID)
{

    int pos = ID_to_HeapIdx[ID];
    h[pos] = h[heap_size - 1];
    h.pop_back();
    heap_size--;

    int id_last_el = HeapIdx_to_ID[heap_size];
    HeapIdx_to_ID[pos] = id_last_el;
    //HeapIdx_to_ID[heap_size] = -100;
    ID_to_HeapIdx[id_last_el] = pos;

    siftdown(ID, HeapIdx_to_ID);
}

void Heap::out(void)
{

    for (int i = 0; i < heap_size; i++)
    {
        cout << "(" << h[i].l << "," << h[i].r << ") ";
    }
    cout << endl;
}

class LIST_SEGMENTS
{
    struct list_segments* Head;
    int count;

public:
    LIST_SEGMENTS();
    list_segments* get_head();
    void add(int, int, int, int, list_segments*, int heapID);
    void delete_segment(list_segments* segment);
    void add_head(int, int, int, int, int heapID);
    void Print();
};

LIST_SEGMENTS::LIST_SEGMENTS()
{
    Head = NULL;
    count = 0;
}

void LIST_SEGMENTS::add_head(int l, int r, int status, int to_heap, int heapID)
{
    list_segments* buff = new list_segments;
    buff->prev = 0;
    buff->l = l;
    buff->r = r;
    buff->status = status;
    buff->next = Head;
    buff->heapID = heapID;

    if (Head != NULL)
        Head->prev = buff;

    Head = buff;
    count++;
}

void LIST_SEGMENTS::add(int l, int r, int status, int to_heap, list_segments* segment, int heapID)
{
    list_segments* after_segment = new list_segments;
    after_segment->l = l;
    after_segment->r = r;
    after_segment->status = status;
    after_segment->next = segment->next;
    after_segment->prev = segment;
    after_segment->to_heap = to_heap;
    after_segment->heapID = heapID;

    if (segment->next != NULL)
        segment->next->prev = after_segment;

    segment->next = after_segment;
    count++;
}

void LIST_SEGMENTS::delete_segment(list_segments* segment)
{
    if (segment->next != NULL)
        segment->next->prev = segment->prev;
    if (segment->prev != NULL)
        segment->prev->next = segment->next;
    else
        Head = segment->next;
    delete segment;
}

list_segments* LIST_SEGMENTS::get_head()
{
    return Head;
}

void LIST_SEGMENTS::Print()
{


    list_segments* buff = Head;
    while (buff->next != NULL)
    {
        cout << "(" << buff->l << ";" << buff->status << ";"  << buff->r << ")"<< ";";
        buff = buff->next;
    }

    cout << "(" << buff->l << ";" << buff->status << ";"  << buff->r << ")"<< ";\n";
}


void find_memory(Heap* heap, LIST_SEGMENTS* List, int K, int query_number,
    std::vector<int>& answers, list_segments** requests, std::vector<int>& HeapIdx_to_ID, int &ID)
{
    int old_l;
    heap_elements* heap_head;

    cout << "1" << endl;
    heap_head = heap->get_head();
    if (!heap->isempty() & (heap_head->r - heap_head->l + 1) >= K)
    {
        cout << "2" << endl;
        int top_heap_id = HeapIdx_to_ID[0];
        if ((heap_head->r - heap_head->l + 1) == K)
        {
            heap_head->to_list->status = 0;
            requests[query_number] = heap_head->to_list;
            answers.push_back(heap_head->l);

            heap->delete_vertex(top_heap_id, HeapIdx_to_ID);
        }
        else
        {
            cout << "3" << endl;
            old_l = heap_head->l;
            heap_head->l = old_l + K;
            heap_head->to_list->l = old_l + K;
            int none_id = -5;
            if (heap_head->to_list->prev != NULL)
            {
                cout << "4" << endl;
                List->add(old_l, old_l + K - 1, 0, -1, heap_head->to_list->prev, none_id);
                requests[query_number] = heap_head->to_list->prev;
                cout << "4.1" << endl;
            }
            else
            {
                cout << "5" << endl;
                List->add_head(old_l, old_l + K - 1, 0, -1,none_id);
                requests[query_number] = List->get_head();
            }
            cout << "6.1" << endl;
            cout << "top_heap_id, HeapIdx_to_ID" << endl;
            cout << top_heap_id << endl;
            for (int j=0;j<HeapIdx_to_ID.size(); j++)
                cout << HeapIdx_to_ID[j] << " " ;
            cout << endl;
            heap->siftdown(top_heap_id, HeapIdx_to_ID);
            cout << "6.2" << endl;
            answers.push_back(old_l);
            cout << "6" << endl;
        }
    }
    else
    {
        cout << "7" << endl;
        requests[query_number] = NULL;
        answers.push_back(-1);
    }
}

void free_up_memory(Heap* heap, LIST_SEGMENTS* List, int q, int query_number,  //Сделать обновление кар АЙДИ при добавлении
    std::vector<int>& answers, list_segments** requests, std::vector<int>& HeapIdx_to_ID, int &ID)
{

    if (requests[q] != NULL)
    {

        requests[q]->status = 1;

        if (requests[q]->prev != NULL)
        {
            if (requests[q]->prev->status == 1 & requests[q]->prev->r == requests[q]->l - 1)
            {

                requests[q]->l = requests[q]->prev->l;
                heap->delete_vertex(requests[q]->prev->heapID, HeapIdx_to_ID);
                List->delete_segment(requests[q]->prev);

            }
        }
        if (requests[q]->next != NULL)
        {

            if (requests[q]->next->status == 1 & requests[q]->next->l - 1 == requests[q]->r)
            {
                requests[q]->r = requests[q]->next->r;
                heap->delete_vertex(requests[q]->next->heapID, HeapIdx_to_ID);
                List->delete_segment(requests[q]->next);

            }
        }

        ID++;
        requests[q]->heapID = ID;
        heap->add(ID, HeapIdx_to_ID, requests[q]->l, requests[q]->r, requests[q]);
        requests[query_number] = requests[q];
        requests[q] = NULL;

    }
    else
    {
        requests[query_number] = NULL;
    }
}




int main()
{

    /*
    -9
    6 8 2 3 -1 3 3 -5 2 2 //1 3 -1 -1 1 -1
    1 7 2 2 1 1 -4 -1 -3 //-1 -1 1 -1               yes
    6 9 2 2 2 -1 -3 -2  2 2 2 // 1 3 5 1 3 5
    6 2 3 -1 //1
    6 7 6 6-2-1 2 4 -5
    10 14 8 2 -2 5 -4 -4 -1 4 4 2 -8 -10 -9 10 //1 9 -1 1 5 9 1
    1 1 1  // 1
    1 2 1 2   //1 -1
    1 9 2 -1 1 1 -1 2 1 -3 1 //-1 1 -1 -1 -1 1  yes
    8 10 2 2 -1 1 3 -2 3 -4 3 -9

    */
    int N, M, K, q, old_l;

    int count_tests;
    ifstream ifs("tests.txt");
    ifs >> count_tests;
    ofstream out("results.txt");


    for (int i = 0; i < count_tests; ++i)
    {
        ifs >> N;
        ifs >> M;
        Heap heap;
        LIST_SEGMENTS List;
        heap_elements* heap_head;
        std::vector<int> answers;
        int ID = -1;
        std::vector<int> HeapIdx_to_ID;

        ID++;
        List.add_head(1, N, 1, 0, ID);
        heap.add(ID, HeapIdx_to_ID, 1, N, List.get_head());
        //HeapIdx_to_ID.push_back(ID);

        list_segments* requests[M];
        for (int query_number = 0; query_number < M; ++query_number)
        {
            ifs >> K;
            cout << "\n ЗАПРОС НОМЕР " << query_number+1 <<  " Enter K: " << K << endl;
            if (K > 0)
            {
                find_memory(&heap, &List, K, query_number, answers, requests, HeapIdx_to_ID, ID);
            }
            else
            {
                q = -K - 1;
                free_up_memory(&heap, &List, q, query_number, answers, requests, HeapIdx_to_ID, ID);
            }


                cout << "Куча после запроса: ";
                heap.out();
                cout << "List после запроса: ";
                List.Print();
                cout << "requests после запроса " << query_number << ": ";


                cout << "\n---------------\n";



        }

    for (int i = 0; i < answers.size(); ++i)
    {
        out << answers[i] << ' ';
        cout << answers[i] << " ";
    }

    cout << endl;
    out << '\n';

    }
    return 0;
}