очищен v2 (без принтов)

#include <iostream>

struct my_pair
{
    int a;
    int b;
};

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

struct cartesian_vertex
{
    int u;
    int v;
    bool isterminal;
    bool isvisited;
    struct my_pair adj_list[26];
    bool is_exist[26] = { false }; //Если убрать = не будет работать
};

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

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

    for (int i = 0; i < k; ++i)
        std::cin >> terminals[i];

    for (int i = 0; i < k; ++i)
        DFA[terminals[i]].isterminal = true;

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

    return;
}

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;
            DFA[i].is_exist[j] = false;
        }
    }
}

void clean_DFA2(struct cartesian_vertex* DFA, int n)
{
    for (int i = 0; i < n; i++)
    {
        DFA[i].isterminal = false;
        DFA[i].isvisited = false;
        for (int j = 0; j < 26; ++j)
            DFA[i].is_exist[j] = false;
    }
}

void cartesian_product(
    struct cartesian_vertex* dec_graph, struct vertex* DFA1, struct vertex* DFA2, int n1, int n2)
{

    int N = n1 * n2;
    cartesian_vertex buff;
    struct my_pair dec_ver;

    clean_DFA2(dec_graph, N);

    for (int i = 0; i < n1; ++i)
    {
        for (int j = 0; j < n2; ++j)
        {
            buff.u = i;
            buff.v = j;
            buff.isterminal = (DFA1[i].isterminal != DFA2[j].isterminal);

            for (int k = 0; k < 26; ++k)
            {
                if (DFA1[i].is_exist[k] && DFA2[j].is_exist[k])
                {
                    dec_ver.a = DFA1[i].adj_list[k];
                    dec_ver.b = DFA2[j].adj_list[k];
                    buff.adj_list[k] = dec_ver;
                    buff.is_exist[k] = true;
                }
                else
                    dec_graph[i * n2 + j].is_exist[k] = false;
            }

            dec_graph[i * n2 + j] = buff;
        }
    }
}

void DFS(int v_idx, struct cartesian_vertex* graph, bool& flag, int n2)
{

    int a, b;
    if (flag)
    {
        if (graph[v_idx].isterminal)
        {
            flag = false;
            a = graph[v_idx].u;
            b = graph[v_idx].v;
            return;
        }

        graph[v_idx].isvisited = true;

        for (int i = 0; i < 26; ++i)
        {
            if (graph[v_idx].is_exist[i])
            {
                int a = graph[v_idx].adj_list[i].a;
                int b = graph[v_idx].adj_list[i].b;
                int idx = a * n2 + b;
                if (not graph[idx].isvisited)
                    DFS(idx, graph, flag, n2);
            }
        }
    }
    return;
}

int main()
{

    int n1, k1, l1;
    int n2, k2, l2;

    std::cin >> n1 >> k1 >> l1;
    vertex DFA1[n1];
    clean_DFA(DFA1, n1);
    Fill_DFA(n1, k1, l1, DFA1);

    std::cin >> n2 >> k2 >> l2;
    vertex DFA2[n2];
    clean_DFA(DFA2, n2);
    Fill_DFA(n2, k2, l2, DFA2);

    int N = n1 * n2;
    struct cartesian_vertex dec_graph[N];
    cartesian_product(dec_graph, DFA1, DFA2, n1, n2);

    bool flag = true;
    DFS(0, dec_graph, flag, n2);

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

    return 0;
}