как у вани

#include <iostream>
#include <vector>
#include <stdexcept>
#include <cstring>
#include <random>
#include <utility>
#include <ctime>

std::random_device rand_dev;
std::mt19937 generator(rand_dev());

struct vertex
{
    bool visited = false;
    std::vector<struct adj_vertex> adj_list;
    int list_size = 0;
    long long int label = 0;
};

struct adj_vertex
{
    int idx;
    int edge_value;
};


class FixedSet
{
    int count_numbers;
    int size;
    long long int alpha_a, alpha_b, beta_a, beta_b;
    int const shift = 1000000000;
    int const p = 2000000033;
    std::vector<int> table;
    std::vector<int> A;

public:
    FixedSet();
    void Initialize(const std::vector<int>& numbers);
    bool Contains(int number) const;

    long long int rand_int(int min, int max)
    {
        std::uniform_int_distribution<int> distr(min, max);
        return distr(generator);
    }

    long long int uni_hash(long long int a, long long int b, int m, int key) const
    {
        return ((a * key + b) % p) % size;
    }

    class Graph
    {
        struct vertex* G;

    public:
        explicit Graph(int n);
        int get_size();
        void addEdge(int i, int j, int key_idx);
        void DFS(int v_idx, int value, bool& flag, int n);
        bool is_correct(int n, int m);
        long long int get_label(int number_vertex);
        void clear(int m);
    };
};

FixedSet::Graph::Graph(int n)
{
    G = new vertex[n];
    for (int i = 0; i < n; ++i)
    {
        G[i].list_size = 0;
        G[i].label = 0;
        G[i].visited = false;
    }
}

long long int FixedSet::Graph::get_label(int number_vertex)
{
    return G[number_vertex].label;
}


void FixedSet::Graph::clear(int m)
{
    for (int i = 0; i < m; ++i)
    {
        G[i].adj_list.clear();
        G[i].list_size = 0;
        G[i].label = 0;
        G[i].visited = false;
    }
}

void FixedSet::Graph::addEdge(int i, int j, int key_idx)
{
    adj_vertex buff;
    buff.idx = j;
    buff.edge_value = key_idx;

    G[i].adj_list.push_back(buff);

    buff.idx = i;
    G[j].adj_list.push_back(buff);

    G[i].list_size++;
    G[j].list_size++;
}

void FixedSet::Graph::DFS(int v_idx, int value, bool& flag, int n)
{

    if (flag)
    {
        G[v_idx].visited = true;
        G[v_idx].label = value;

        vertex u;
        std::vector<struct adj_vertex> curr_list = G[v_idx].adj_list;
        int u_idx, val, edge_value;

        for (int i = 0; i < G[v_idx].list_size; ++i)
        {

            u_idx = curr_list[i].idx;
            u = G[u_idx];
            edge_value = curr_list[i].edge_value;

            if (!(u.visited))
            {
                val = edge_value - value;
                DFS(u_idx, val, flag, n);
            }

            if (((G[u_idx].label + G[v_idx].label) % n) != edge_value)
            {
                flag = false;
                break;
            }
        }
    }
}


bool FixedSet::Graph::is_correct(int n, int m)
{

    bool flag = true;
    for (int i = 0; i < m; ++i)
    {
        if (!G[i].visited)
            DFS(i, 0, flag, n);
        if (!flag)
            return false;
    }
    return true;
}


FixedSet::FixedSet()
{
    this->count_numbers = 0;
    this->size = 0;
}

void FixedSet::Initialize(const std::vector<int>& numbers)
{
    table.clear();
    A.clear();
    this->count_numbers = 0;
    this->size = 0;

    if (!numbers.empty())
    {

        int n = numbers.size();
        int m = 3 * n;

        this->count_numbers = n;
        this->size = m;

        Graph g(m);

        for (int i = 0; i < n; ++i)
            table.push_back(numbers[i] + shift);

        long long int alpha_k, beta_k;
        bool flag = false;

        while (!flag)
        {
            g.clear(m);

            this->alpha_a = rand_int(1, p - 1);
            this->alpha_b = rand_int(0, p - 1);
            this->beta_a = rand_int(1, p - 1);
            this->beta_b = rand_int(0, p - 1);

            for (int i = 0; i < n; ++i)
            {
                alpha_k = uni_hash(alpha_a, alpha_b, m, numbers[i] + shift);
                beta_k = uni_hash(beta_a, beta_b, m, numbers[i] + shift);
                g.addEdge(alpha_k, beta_k, i);
            }

            if (g.is_correct(n, m))
            {
                flag = true;
            }
        }

        for (int i = 0; i < m; ++i)
            A.push_back(g.get_label(i));
    }
}

bool FixedSet::Contains(int number) const
{
    if (this->size == 0)
        return false;

    int m = this->size;
    int n = this->count_numbers;
    int hash_alpha = uni_hash(this->alpha_a, this->alpha_b, m, number + shift);
    int hash_beta = uni_hash(this->beta_a, this->beta_b, m, number + shift);

    int idx = (A[hash_alpha] + A[hash_beta]) % n;

    if (0 <= idx)
        return (this->table[idx] == (number + shift));

    return false;
}

std::vector<int> ReadSequence()
{
    size_t size;
    std::cin >> size;
    std::vector<int> sequence(size);
    for (auto& current : sequence)
    {
        std::cin >> current;
    }
    return sequence;
}

std::vector<bool> PerformRequests(const std::vector<int>& requests, const FixedSet& set)
{
    std::vector<bool> request_answers;
    request_answers.reserve(requests.size());
    for (int request : requests)
    {
        request_answers.push_back(set.Contains(request));
    }
    return request_answers;
}

void PrintRequestsResponse(const std::vector<bool>& request_answers)
{
    for (bool answer : request_answers)
    {
        std::cout << (answer ? "Yes" : "No") << "\n";
    }
}

int main(int argc, char** argv)
{

    std::ios::sync_with_stdio(false);
    auto numbers = ReadSequence();
    auto requests = ReadSequence();
    FixedSet set;
    set.Initialize(numbers);
    PrintRequestsResponse(PerformRequests(requests, set));

    return 0;
}