Тестирование (файл)

#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;
};

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;
    int heap_size;

public:
    Heap();
    void siftup();
    void siftdown(int pos);
    void add(int, int, list_segments*);
    void delete_vertex(int pos);
    bool isempty();
    heap_elements* get_head();
};

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

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

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

void Heap::siftup()
{
    int curr, parent;
    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;

            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 pos)
{
    int parent, max_child;

    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;

            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 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;

    heap_size++;
    siftup();
}

void Heap::delete_vertex(int pos)
{
    h[pos] = h[heap_size - 1];
    h.pop_back();
    heap_size--;
    siftdown(pos);
}

class LIST_SEGMENTS
{
    struct list_segments* Head;
    int count;

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

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

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

    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)
{
    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;

    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 find_memory(Heap* heap, LIST_SEGMENTS* List, int K, int query_number,
    std::vector<int>& answers, list_segments** requests)
{
    int old_l;
    heap_elements* heap_head;

    heap_head = heap->get_head();
    if (!heap->isempty() & (heap_head->r - heap_head->l + 1) >= K)
    {
        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(0);
        }
        else
        {
            old_l = heap_head->l;
            heap_head->l = old_l + K;
            heap_head->to_list->l = old_l + K;

            if (heap_head->to_list->prev != NULL)
            {
                List->add(old_l, old_l + K - 1, 0, -1, heap_head->to_list->prev);
                requests[query_number] = heap_head->to_list->prev;
            }
            else
            {
                List->add_head(old_l, old_l + K - 1, 0, -1);
                requests[query_number] = List->get_head();
            }

            heap->siftdown(0);
            answers.push_back(old_l);
        }
    }
    else
    {
        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)
{

    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->to_heap);
                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->to_heap);
                List->delete_segment(requests[q]->next);
            }
        }

        heap->add(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
    6 9 2 2 2 -1 -3 -2  2 2 2 // 1 3 5 1 3 5
    6 2 3 -1 //1,-1,1,3
    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

    */
    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;

        List.add_head(1, N, 1, 0);
        heap.add(1, N, List.get_head());
        list_segments* requests[M];
        for (int query_number = 0; query_number < M; ++query_number)
        {
            ifs >> K;
            if (K > 0)
                find_memory(&heap, &List, K, query_number, answers, requests);
            else
            {
                q = -K - 1;
                free_up_memory(&heap, &List, q, query_number, answers, requests);
            }
        }

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

    return 0;
}