v2

#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;

struct vertex
{
    bool isterminal = false;
    // mapchar,int adj_list; // Заменить на массив длины 26
    int adj_list[26];
    bool is_exist[26];
    // vector<int> adj_list(26,-1);
    int list_size = 0;
    int number_vertex;
};

struct my_pair
{
    int a;
    int b;
};

struct vertex_2
{
    int u;
    int v;
    bool isterminal = false;
    bool isvisited = false;
    struct my_pair adj_list[26];
    bool is_exist[26] = { false };
    int number_in_array;
};




struct adj_vertex
{
    int number_vertex;
    char symbol;
};

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;
    DFA[i].list_size++;
}

void Fill_DFA(int n, int k, int l, vector<char>& alphabet, struct vertex* DFA)
{
    int u, v, c_idx;
    char c;
    int terminals[k];

    int indicators[26] = { 0 };

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

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


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

        //Запоминаю алфавит автоматов
        c_idx = int(c) - 97;
        if (indicators[c_idx] == 0)
        {
            alphabet.push_back(c);
            indicators[c_idx] = 1;
        }
        else
            indicators[c_idx] = 1;
    }

    return;
}


void display(struct vertex* DFA, int n)
{
    cout << "\n print:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << "vertex: " << i << " ";
        if (DFA[i].isterminal)
            cout << "isterminal"
                 << " ";

        cout << "adj_vertexes: ";
        for (int j = 0; j < 26; ++j)
        {
            if (DFA[i].is_exist[j] == true)
                std::cout << "(" << char(j + 97) << "," << DFA[i].adj_list[j] << "); ";
        }
        cout << endl;
    }
}

void clean_DFA(struct vertex* DFA, int n)
{
    for (int i = 0; i < n; i++)
    {
        DFA[i].isterminal = false;
        DFA[i].list_size = 0;

        for (int j = 0; j < 26; ++j)
        {
            DFA[i].adj_list[j] = -1;   //Эта строчка ломает код
            DFA[i].is_exist[j] = false;
        }
    }
}

void clean_DFA2(struct vertex_2* DFA, int n)
{
    for (int i = 0; i < n; i++)
    {
        DFA[i].isterminal = false;
        //DFA[i].list_size = 0;

        for (int j = 0; j < 26; ++j)
        {
            DFA[i].is_exist[j] = false;
        }
    }
}

void display2(struct vertex_2* DFA, int n)
{
    cout << "\n print:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << "vertex: (" << DFA[i].u << "," << DFA[i].v << ") ";
        if (DFA[i].isterminal)
            cout << "(isterminal)" << " ";

        cout << "adj_vertexes: ";
        for (int j = 0; j < 26; ++j)
        {
            if (DFA[i].is_exist[j] == true)
                std::cout << char(j + 97) << "->(" << DFA[i].adj_list[j].a << "," << DFA[i].adj_list[j].b <<  "); ";
        }
        cout << endl;
    }
}

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

    int v1,v2;
    int number_in_array;
    int N = n1*n2;
    vertex_2 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);
            buff.number_in_array = i*n2+j;

            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]; //Куда переходит авт1 по символу c
                    dec_ver.b = DFA2[j].adj_list[k]; //Куда переходит авт2 по символу c
                    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;
        }
    }
}

int main()
{
    // n — колво состояний.  k — колво терминальных состояний.  l — колво букв в алфавите.
    int n1, k1, l1;
    vector<char> alphabet1;
    int n2, k2, l2;
    vector<char> alphabet2;
    cin >> n1 >> k1 >> l1;
    vertex DFA1[n1];
    clean_DFA(DFA1, n1);
    Fill_DFA(n1, k1, l1, alphabet1, DFA1);


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



    //int v1,v2;
    //int number_in_array;

    int N = n1*n2;
    struct vertex_2 dec_graph[N];
    cartesian_product(dec_graph, DFA1, DFA2, n1, n2);
    /*
    vertex_2 buff;
    struct my_pair dec_ver;
    cout << " start2" << endl;
    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);
            buff.number_in_array = i*n2+j;

            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]; //Куда переходит авт1 по символу c
                    dec_ver.b = DFA2[j].adj_list[k]; //Куда переходит авт2 по символу c
                    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;
        }
    }
    */
    display(DFA1, n1);
    display(DFA2, n2);

    display2(dec_graph, N);

    return 0;
}