По множеству пар вершин построить матрицу инцидентности

cout<<"\nvvedite kilkist vershin: "; cin>>n; 
int kr; 
//введення 
cout<<"\n"<<"vvedite pochergovo rebra (po zavershenu vvedite '0'):"<<"\n"; 
for (i=0; i<100; i++) 
{ 
cout<<"\n";    
cin>>sk; 
if (sk==0) //вихід із циклу, якщо вводиться 0 
{ 
break; 
} 
cin>>sb; 
if (sk>n || sb>n) //при неправильному введені ребер 
cout<<"\npomulkovuy vvid, sprobuyte che raz"<<"\n"; 
else if (sk>0 && sb>0) //правильний ввід вершин 
{ 
sk--; sb--; 
if (sk != sb) 
a[sb][sk]++; 
a[sk][sb]++; 
grani++; 
} 
else //при любому неправильному введені вершин 
cout<<"\npomulkovuy vvid, sprobuyte che raz"<<"\n"; 
}

//////////////////////////////////////////////////////////////////////////////////////////
//  задано множество пар вершин, построить матрицу инцидентности
//////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <deque>
#include <iostream>
#include <set>
#include <string>
#include <vector>
//////////////////////////////////////////////////////////////////////////////////////////
typedef std::string             T_vert;
typedef std::set<T_vert>        T_vertices_set;
typedef std::multiset<T_vert>   T_edge;
typedef std::set<T_edge>        T_edges_set;
typedef std::deque<bool>        T_inc_row;
typedef std::vector<T_inc_row>  T_inc_matr;
typedef std::vector<T_vert>     T_vertices_vect;
typedef std::vector<T_edge>     T_edges_vect;
//////////////////////////////////////////////////////////////////////////////////////////
void  print_incidence_matrix
    (
        const T_vertices_set&  vertices_set,
        const T_edges_set&     edges_set
    )
{
    T_vertices_vect  vertices_vect  (vertices_set.  begin(),  vertices_set.  end());
    T_edges_vect     edges_vect     (edges_set.     begin(),  edges_set.     end());
 
    T_inc_matr  inc_matr(vertices_set.size(), T_inc_row(edges_set.size()));
 
    for(size_t  i = 0; i < vertices_vect.size(); ++i)
    {
        for(size_t  j = 0; j < edges_vect.size(); ++j)
        {
            inc_matr[i][j] = std::find
                                 (
                                     edges_vect[j].begin(), 
                                     edges_vect[j].end(), 
                                     vertices_vect[i]
                                 ) != edges_vect[j].end();
        }
    }
 
    std::cout << std::endl
              << "Матрица инцидентности графа:"
              << std::endl
              << "V\\E"
              << '\t';
    for(T_edges_set::const_iterator  edge_it = edges_set.begin(); 
        edge_it != edges_set.end(); 
        ++edge_it)
    {
        std::cout << *(edge_it->begin())
                  << "_"
                  << *(edge_it->rbegin());
        std::cout << '\t';
    }
    std::cout << std::endl
              << std::endl;
 
    for(size_t  i = 0; i < inc_matr.size(); ++i)
    {
        std::cout << vertices_vect[i]
        << '\t';
        for(size_t j = 0; j < edges_set.size(); ++j)
        {
            std::cout << (inc_matr[i][j] ? 1 : 0)
                      << '\t';
        }
        std::cout << std::endl;
    }
}
//////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    
    size_t  vertices_total;
    do
    {
        std::cout << "Введите количество вершин неориентированного графа >= 1: ";
        std::cin >> vertices_total;
    }while(vertices_total < 1);    
    
    std::cout << "Введите "
              << vertices_total
              << " вершин неориентированного графа: "
              << std::endl;
 
    T_vertices_set  vertices_set;
    T_vert  vert_cur;
 
    while(vertices_set.size() < vertices_total)
    {
        std::cout << "Вершина "  
                  << vertices_set.size() + 1
                  << ": ";
 
        std::cin >> vert_cur;
        vertices_set.insert(vert_cur);
    }
 
    size_t  edges_total;
    do
    {
        std::cout << "Введите количество ребер неориентированного графа >= 0: ";    
        std::cin >> edges_total;
    }while(edges_total < 0);    
    
    std::cout << "Введите "
              << edges_total 
              << " ребер графа: "
              << std::endl;
 
    T_edges_set  edges_set;
    
    while(edges_set.size() < edges_total)
    {
        T_edge  edge_cur;
        edge_cur.clear();
        std::cout << "Ребро "
                  << edges_set.size() + 1
                  << ": "
                  << std::endl;
 
        T_vert  A;
        do
        {
            std::cout << "\tвершина ->: ";
            std::cin >> A;
        }while(vertices_set.count(A) == 0);       
        edge_cur.insert(A);
 
        T_vert  B;
        do
        {
            std::cout << "\tвершина ->: ";
            std::cin >> B;
        }while(vertices_set.count(B) == 0);       
        edge_cur.insert(B);
 
        edges_set.insert(edge_cur);
    }
    print_incidence_matrix(vertices_set, edges_set);
}