принята

#include <iostream>

struct vertex
{
    bool isterminal;
    int adj_list[26];
};

struct cart_vertex
{
    int u;
    int v;
    bool isvisited;
};

void addEdge(int i, int j, char symbol, struct vertex* DFA)
{
    int symbol_idx = static_cast<int>(symbol) - 97;
    DFA[i].adj_list[symbol_idx] = j;
}

void clean_DFA(struct vertex* DFA, int n)
{
    for (int i = 0; i < n; ++i)
    {
        DFA[i].isterminal = false;
        for (int j = 0; j < 26; ++j)
            DFA[i].adj_list[j] = -1;
    }
}


void Fill_DFA(int n, int k, int l, struct vertex* DFA)
{
    int u, v;
    int number_terminal;
    char c;

    clean_DFA(DFA, n);

    for (int i = 0; i < k; ++i)
    {
        std::cin >> number_terminal;
        DFA[number_terminal].isterminal = true;
    }

    for (int i = 0; i < n * l; ++i)
    {
        std::cin >> u >> c >> v;
        addEdge(u, v, c, DFA);
    }

    return;
}

void cartesian_product(struct cart_vertex* cart_graph, int n_one, int n_two)
{

    int N = n_one * n_two;

    for (int i = 0; i < N; ++i)
        cart_graph[i].isvisited = false;

    for (int i = 0; i < n_one; ++i)
    {
        for (int j = 0; j < n_two; ++j)
        {
            int idx = i * n_two + j;
            cart_graph[idx].u = i;
            cart_graph[idx].v = j;
        }
    }
}


void DFS(int v_idx, struct cart_vertex* graph, bool& is_equiv, int n_two, struct vertex* DFA_one,
    struct vertex* DFA_two)
{

    int a, b;
    if (is_equiv)
    {
        int i = graph[v_idx].u;
        int j = graph[v_idx].v;
        if (DFA_one[i].isterminal != DFA_two[j].isterminal)
        {
            is_equiv = false;
            return;
        }

        graph[v_idx].isvisited = true;
        for (int k = 0; k < 26; ++k)
        {
            a = DFA_one[i].adj_list[k];
            b = DFA_two[j].adj_list[k];
            if (a >= 0 && b >= 0)
            {
                int idx = a * n_two + b;
                if (not graph[idx].isvisited)
                    DFS(idx, graph, is_equiv, n_two, DFA_one, DFA_two);
            }
        }
    }
    return;
}

void check_equiv(
    struct cart_vertex* cart_graph, int n_two, struct vertex* DFA_one, struct vertex* DFA_two)
{
    bool is_equiv = true;
    DFS(0, cart_graph, is_equiv, n_two, DFA_one, DFA_two);

    if (is_equiv)
        std::cout << "EQUIVALENT";
    else
        std::cout << "NOT EQUIVALENT";
}

int main()
{

    int n_one, k_one, l_one;
    int n_two, k_two, l_two;

    std::cin >> n_one >> k_one >> l_one;
    vertex DFA_one[n_one];
    Fill_DFA(n_one, k_one, l_one, DFA_one);

    std::cin >> n_two >> k_two >> l_two;
    vertex DFA_two[n_two];
    Fill_DFA(n_two, k_two, l_two, DFA_two);

    int N = n_one * n_two;
    struct cart_vertex cart_graph[N];
    cartesian_product(cart_graph, n_one, n_two);

    check_equiv(cart_graph, n_two, DFA_one, DFA_two);

    return 0;
}