View difference between Paste ID: NKDAbiED and gfR6HN51

 ///////////////////////////////////
 //            Graph.h            //
 ///////////////////////////////////
 
 #pragma once
 #include <iostream>
 #include <iomanip>
 #include <fstream>
 #include <vector>
 #include <map>
 using namespace std;
 
 /// <summary>
 /// Граф
 /// </summary>
 /// <typeparam name="Vertice"> тип вершин графа </typeparam>
 /// <typeparam name="Edge"> тип ребер графа (int по умолчанию) </typeparam>
 template <class Vertice, class Edge = int>
-	/// <summary>
+
-	/// Количество вершин и ребер в графе
+
-	/// </summary>
+    /// <summary>
-	int _N = 0, _M = 0;
+    /// Количество вершин и ребер в графе
     /// </summary>
-	/// <summary>
+    int _N = 0, _M = 0;
-	/// Критерий ориентированности и взвешенности графа
+
-	/// </summary>
+    /// <summary>
-	bool IsDirected = false, IsWeighted = false;
+    /// Критерий ориентированности и взвешенности графа
     /// </summary>
-	/// <summary>
+    bool IsDirected = false, IsWeighted = false;
-	/// Список смежности графа
+
-	/// </summary>
+    /// <summary>
-	map <Vertice, map<Vertice, Edge>> graph;
+    /// Список смежности графа
     /// </summary>
     map <Vertice, map<Vertice, Edge>> graph;
 
-	/// <summary>
+
-	/// Конструктор по умолчанию
+
-	/// </summary>
+    /// <summary>
-	Graph() {};
+    /// Конструктор по умолчанию
     /// </summary>
-	/// <summary>
+    Graph() {};
-	/// Конструктор, создающий пустой граф, определяющий
+
-	/// ориентированность и взвешенность графа
+    /// <summary>
-	/// </summary>
+    /// Конструктор, создающий пустой граф, определяющий
-	/// <param name="direction"> критерий ориентированности </param>
+    /// ориентированность и взвешенность графа
-	/// <param name="weighting"> критерий взвешенности </param>
+    /// </summary>
-	Graph(string direction, string weighting)
+    /// <param name="direction"> критерий ориентированности </param>
-	{
+    /// <param name="weighting"> критерий взвешенности </param>
-		if (direction == "directed") IsDirected = true;
+    Graph(string direction, string weighting)
-		if (weighting == "weighted") IsWeighted = true;
+    {
-	}
+        if (direction == "directed") IsDirected = true;
         if (weighting == "weighted") IsWeighted = true;
-	/// <summary>
+    }
-	/// Конструктор, считывающий информацию из файла
+
-	/// или из консоли (stdin)
+    /// <summary>
-	/// </summary>
+    /// Конструктор, считывающий информацию из файла
-	/// <param name="filePath"> путь к файлу или ключевое слово stdin </param>
+    /// или из консоли (stdin)
-	Graph(string filePath)
+    /// </summary>
-	{
+    /// <param name="filePath"> путь к файлу или ключевое слово stdin </param>
-		ifstream fin;
+    Graph(string filePath)
     {
-		if (filePath == "stdin") fin = ifstream(stdin);
+        ifstream fin;
-		else fin = ifstream(filePath);
+
         if (filePath == "stdin") fin = ifstream(stdin);
-		string cmd, direction, weighting;
+        else fin = ifstream(filePath);
-		fin >> cmd >> direction >> weighting;
+
         string cmd, direction, weighting;
-		*this = Graph(direction, weighting);
+        fin >> cmd >> direction >> weighting;
 
-		fin >> cmd >> _N;
+        *this = Graph(direction, weighting);
 
-		for (int i = 0; i < _N; ++i)
+        fin >> cmd >> _N;
-		{
+
-			Vertice v; fin >> v;
+        for (int i = 0; i < _N; ++i)
-			graph.insert(pair<Vertice, map<Vertice, Edge>>(v, map<Vertice, Edge>()));
+        {
-		}
+            Vertice v; fin >> v;
             graph.insert(pair<Vertice, map<Vertice, Edge>>(v, map<Vertice, Edge>()));
-		fin >> cmd >> _M;
+        }
 
-		for (int i = 0; i < _M; ++i)
+        fin >> cmd >> _M;
-		{
+
-			Vertice u, v; Edge w; fin >> u >> v;
+        for (int i = 0; i < _M; ++i)
         {
-			if (!IsWeighted) w = 1;
+            Vertice u, v; Edge w; fin >> u >> v;
-			else fin >> w;
+
             if (!IsWeighted) w = 1;
-			graph[u].insert(pair<Vertice, Edge>(v, w));
+            else fin >> w;
-			if (!IsDirected) graph[v].insert(pair<Vertice, Edge>(u, w));
+
-		}
+            graph[u].insert(pair<Vertice, Edge>(v, w));
             if (!IsDirected) graph[v].insert(pair<Vertice, Edge>(u, w));
-		if (filePath != "stdin") fin.close();
+        }
-	}
+
         if (filePath != "stdin") fin.close();
-	/// <summary>
+    }
-	/// Количество вершин графа
+
-	/// </summary>
+    /// <summary>
-	/// <returns> количество вершин графа </returns>
+    /// Количество вершин графа
-	int n() { return _N; }
+    /// </summary>
     /// <returns> количество вершин графа </returns>
-	/// <summary>
+    int n() { return _N; }
-	/// Количество ребер графа
+
-	/// </summary>
+    /// <summary>
-	/// <returns> количество ребер графа </returns>
+    /// Количество ребер графа
-	int m() { return _M; }
+    /// </summary>
     /// <returns> количество ребер графа </returns>
-	/// <summary>
+    int m() { return _M; }
-	/// Метод, выдающий информацию об
+
-	/// ориентированности графа
+    /// <summary>
-	/// </summary>
+    /// Метод, выдающий информацию об
-	/// <returns> true, если граф ориентированный, иначе - false </returns>
+    /// ориентированности графа
-	bool isDirected() { return IsDirected; }
+    /// </summary>
     /// <returns> true, если граф ориентированный, иначе - false </returns>
-	/// <summary>
+    bool isDirected() { return IsDirected; }
-	/// Метод, выдающий информацию о
+
-	/// взвешенности графа
+    /// <summary>
-	/// </summary>
+    /// Метод, выдающий информацию о
-	/// <returns> true, если граф взвешенный, иначе - false </returns>
+    /// взвешенности графа
-	bool isWeighted() { return IsWeighted; }
+    /// </summary>
     /// <returns> true, если граф взвешенный, иначе - false </returns>
-	/// <summary>
+    bool isWeighted() { return IsWeighted; }
-	/// Добавление вершины в граф
+
-	/// </summary>
+    /// <summary>
-	/// <param name="v"> добавляемая в граф вершина </param>
+    /// Метод, возращающий список смежности графа
-	void addVertice(Vertice v)
+    /// </summary>
-	{
+    /// <returns> список смежности графа </returns>
-		try
+    map<Vertice, map<Vertice, Edge>> edges() { return graph; }
-		{
+
-			if (graph.find(v) != graph.end()) throw "Добавление вершины: заданная вершина уже есть в графе";
+    /// <summary>
-			else
+    /// Добавление вершины в граф
-			{
+    /// </summary>
-				++_N;
+    /// <param name="v"> добавляемая в граф вершина </param>
-				graph.insert(pair<Vertice, map<Vertice, Edge>>(v, map<Vertice, Edge>()));
+    void addVertice(Vertice v)
-			}
+    {
-		}
+        try
-		catch (const char* msg)
+        {
-		{
+            if (graph.find(v) != graph.end()) throw "Добавление вершины: заданная вершина уже есть в графе";
-			cout << msg << "\n";
+            else
-		}
+            {
-	}
+                ++_N;
                 graph.insert(pair<Vertice, map<Vertice, Edge>>(v, map<Vertice, Edge>()));
-	/// <summary>
+            }
-	/// Удаление вершины из графа
+        }
-	/// </summary>
+        catch (const char* msg)
-	/// <param name="v"> удаляемая из графа вершина </param>
+        {
-	void removeVertice(Vertice v)
+            cout << msg << "\n";
-	{
+        }
-		try
+    }
-		{
+
-			if (graph.find(v) == graph.end()) throw "Удаление вершины: в графе отсутствует заданная вершина";
+    /// <summary>
-			else
+    /// Удаление вершины из графа
-			{
+    /// </summary>
-				--_N; _M -= graph[v].size();
+    /// <param name="v"> удаляемая из графа вершина </param>
     void removeVertice(Vertice v)
-				graph.erase(v);
+    {
         try
-				for (auto p : graph)
+        {
-					if (graph[p.first].find(v) != graph[p.first].end())
+            if (graph.find(v) == graph.end()) throw "Удаление вершины: в графе отсутствует заданная вершина";
-					{
+            else
-						if (IsDirected) --_M;
+            {
-						graph[p.first].erase(v);
+                --_N; _M -= graph[v].size();
-					}
+
-			}
+                graph.erase(v);
-		}
+
-		catch (const char* msg)
+                for (auto p : graph)
-		{
+                    if (graph[p.first].find(v) != graph[p.first].end())
-			cout << msg << "\n";
+                    {
-		}
+                        if (IsDirected) --_M;
-	}
+                        graph[p.first].erase(v);
                     }
-	/// <summary>
+            }
-	/// Добавление ребра в граф
+        }
-	/// </summary>
+        catch (const char* msg)
-	/// <param name="u"> первая вершина ребра </param>
+        {
-	/// <param name="v"> вторая вершина ребра </param>
+            cout << msg << "\n";
-	/// <param name="w"> вес ребра (для невзвешенных графов w = 1) </param>
+        }
-	void addEdge(Vertice u, Vertice v, Edge w)
+    }
-	{
+
-		try
+    /// <summary>
-		{
+    /// Добавление ребра в граф
-			if (graph.find(u) == graph.end() || graph.find(v) == graph.end()) throw "Добавление ребра: в графе отсутствует(ют) заданная(ые) вершина(ы)";
+    /// </summary>
-			else if (!IsDirected && u == v) throw "Добавление ребра: невозможно добавить петлю в неориентированный граф";
+    /// <param name="u"> первая вершина ребра </param>
-			else if (graph[u].find(v) != graph[u].end()) throw "Добавление ребра: заданное ребро уже есть в графе";
+    /// <param name="v"> вторая вершина ребра </param>
-			else
+    /// <param name="w"> вес ребра (для невзвешенных графов w = 1) </param>
-			{
+    void addEdge(Vertice u, Vertice v, Edge w)
-				++_M;
+    {
-				graph[u][v] = w;
+        try
-				if (!IsDirected) graph[v][u] = w;
+        {
-			}
+            if (graph.find(u) == graph.end() || graph.find(v) == graph.end()) throw "Добавление ребра: в графе отсутствует(ют) заданная(ые) вершина(ы)";
-		}
+            else if (!IsDirected && u == v) throw "Добавление ребра: невозможно добавить петлю в неориентированный граф";
-		catch (const char* msg)
+            else if (graph[u].find(v) != graph[u].end()) throw "Добавление ребра: заданное ребро уже есть в графе";
-		{
+            else
-			cout << msg << "\n";
+            {
-		}
+                ++_M;
-	}
+                graph[u][v] = w;
                 if (!IsDirected) graph[v][u] = w;
-	/// <summary>
+            }
-	/// Удаление ребра из графа
+        }
-	/// </summary>
+        catch (const char* msg)
-	/// <param name="u"> первая вершина ребра </param>
+        {
-	/// <param name="v"> вторая вершина ребра </param>
+            cout << msg << "\n";
-	void removeEdge(Vertice u, Vertice v)
+        }
-	{
+    }
-		try
+
-		{
+    /// <summary>
-			if (graph.find(u) == graph.end() || graph.find(v) == graph.end()) throw "Удаление ребра: в графе отсутствует(ют) заданная(ые) вершина(ы)";
+    /// Удаление ребра из графа
-			else
+    /// </summary>
-			{
+    /// <param name="u"> первая вершина ребра </param>
-				if (graph[u].find(v) == graph[u].end()) throw "Удаление ребра: в графе отсутствует заданное ребро";
+    /// <param name="v"> вторая вершина ребра </param>
-				else
+    void removeEdge(Vertice u, Vertice v)
-				{
+    {
-					--_M;
+        try
-					graph[u].erase(v);
+        {
-					if (!IsDirected) graph[v].erase(u);
+            if (graph.find(u) == graph.end() || graph.find(v) == graph.end()) throw "Удаление ребра: в графе отсутствует(ют) заданная(ые) вершина(ы)";
-				}
+            else
-			}
+            {
-		}
+                if (graph[u].find(v) == graph[u].end()) throw "Удаление ребра: в графе отсутствует заданное ребро";
-		catch (const char* msg)
+                else
-		{
+                {
-			cout << msg << "\n";
+                    --_M;
-		}
+                    graph[u].erase(v);
-	}
+                    if (!IsDirected) graph[v].erase(u);
                 }
-	/// <summary>
+            }
-	/// Очищение графа (ориентированность
+        }
-	/// и взвешенность остаются прежними)
+        catch (const char* msg)
-	/// </summary>
+        {
-	void clear()
+            cout << msg << "\n";
-	{
+        }
-		_N = 0; _M = 0;
+    }
-		graph.clear();
+
-	}
+    /// <summary>
     /// Очищение графа (ориентированность
-	/// <summary>
+    /// и взвешенность остаются прежними)
-	/// Вывод информации о графе в файл или
+    /// </summary>
-	/// на консоль (stdout)
+    void clear()
-	/// </summary>
+    {
-	/// <param name="filePath"> путь к файлу или ключевое слово stdout </param>
+        _N = 0; _M = 0;
-	void print(string filePath)
+        graph.clear();
-	{
+    }
-		ofstream fout;
+
     /// <summary>
-		if (filePath == "stdout") fout = ofstream(stdout);
+    /// Вывод информации о графе в файл или
-		else fout = ofstream(filePath);
+    /// на консоль (stdout)
     /// </summary>
-		if (filePath != "stdout")
+    /// <param name="filePath"> путь к файлу или ключевое слово stdout </param>
-		{
+    void print(string filePath)
-			fout << "GRAPH ";
+    {
         ofstream fout;
-			if (IsDirected) fout << "directed ";
+
-			else fout << "undirected ";
+        if (filePath == "stdout") fout = ofstream(stdout);
         else fout = ofstream(filePath);
-			if (IsWeighted) fout << "weighted\n";
+
-			else fout << "unweighted\n";
+        if (filePath != "stdout")
         {
-			fout << "VERTICES: " << _N << "\n";
+            fout << "GRAPH ";
 
-			for (auto p : graph)
+            if (IsDirected) fout << "directed ";
-				fout << p.first << "\n";
+            else fout << "undirected ";
 
-			fout << "EDGES: " << _M << "\n";
+            if (IsWeighted) fout << "weighted\n";
             else fout << "unweighted\n";
-			for (auto p1 : graph)
+
-			{
+            fout << "VERTICES: " << _N << "\n";
-				Vertice u = p1.first;
+
             for (auto p : graph)
-				for (auto p2 : p1.second)
+                fout << p.first << "\n";
-				{
+
-					Vertice v = p2.first; Edge w = p2.second;
+            fout << "EDGES: " << _M << "\n";
 
-					if (IsDirected || u < v)
+            for (auto p1 : graph)
-					{
+            {
-						fout << u << " " << v << " ";
+                Vertice u = p1.first;
-						if (IsWeighted) fout << w;
+
-						fout << "\n";
+                for (auto p2 : p1.second)
-					}
+                {
-				}
+                    Vertice v = p2.first; Edge w = p2.second;
-			}
+
                     if (IsDirected || u < v)
-			fout.close();
+                    {
-		}
+                        fout << u << " " << v << " ";
-		else
+                        if (IsWeighted) fout << w;
-		{
+                        fout << "\n";
-			fout << "GRAPH ";
+                    }
                 }
-			if (IsDirected) fout << "directed ";
+            }
-			else fout << "undirected ";
+
             fout.close();
-			if (IsWeighted) fout << "weighted\n";
+        }
-			else fout << "unweighted\n";
+        else
         {
-			fout << "VERTICES: " << _N << "\n";
+            fout << "GRAPH ";
 
-			for (auto p : graph)
+            if (IsDirected) fout << "directed ";
-				fout << p.first << "\n";
+            else fout << "undirected ";
 
-			fout << "EDGES: " << _M << "\n";
+            if (IsWeighted) fout << "weighted\n";
             else fout << "unweighted\n";
-			for (auto p1 : graph)
+
-			{
+            fout << "VERTICES: " << _N << "\n";
-				Vertice u = p1.first;
+
             for (auto p : graph)
-				fout << u << ": ";
+                fout << p.first << "\n";
 
-				for (auto p2 : p1.second)
+            fout << "EDGES: " << _M << "\n";
-				{
+
-					Vertice v = p2.first; Edge w = p2.second;
+            for (auto p1 : graph)
             {
-					if (!IsWeighted) fout << v << " ";
+                Vertice u = p1.first;
-					else fout << "(" << v << ", " << w << ") ";
+
-				}
+                fout << u << ": ";
 
-				fout << "\n";
+                for (auto p2 : p1.second)
-			}
+                {
-		}
+                    Vertice v = p2.first; Edge w = p2.second;
-	}
+
                     if (!IsWeighted) fout << v << " ";
                     else fout << "(" << v << ", " << w << ") ";
                 }
 
                 fout << "\n";
             }
         }
     }
 };
 
 /// <summary>
 /// Задание 1a: степени вершин в орграфе
 /// </summary>
 /// <typeparam name="Vertice"> тип вершин орграфа </typeparam>
 /// <typeparam name="Edge"> тип дуг орграфа </typeparam>
 /// <param name="g"> граф </param>
 template <class Vertice, class Edge>
 void VerticesDegrees(Graph<Vertice, Edge> g)
 {
-	/// <summary>
+    try
-	/// Граф
+    {
-	/// </summary>
+        if (!g.isDirected()) throw "Задание 1a: работаем с орграфом";
-	Graph<Vertice, Edge> g;
+        else
         {
-	/// <summary>
+            map <Vertice, int> in_degree, out_degree;
-	/// Вывод на консоль списка доступных команд
+            map <Vertice, map<Vertice, Edge>> edges = g.edges();
-	/// </summary>
+
-	void Hint()
+            for (auto p1 : edges)
-	{
+            {
-		cout << "+---------------------------------------+\n";
+                Vertice u = p1.first;
-		cout << "|             СПИСОК КОМАНД             |\n";
+
-		cout << "+---------------------------------------+\n";
+                for (auto p2 : p1.second)
-		cout << "|  1. CREATE GRAPH direction weighting  |\n";
+                {
-		cout << "|  2. CREATE GRAPH filePath             |\n";
+                    Vertice v = p2.first;
-		cout << "|  3. ADD VERTICE v                     |\n";
+
-		cout << "|  4. REMOVE VERTICE v                  |\n";
+                    in_degree[u]++;
-		cout << "|  5. ADD EDGE u v [w]                  |\n";
+                    out_degree[v]++;
-		cout << "|  6. REMOVE EDGE u w                   |\n";
+                }
-		cout << "|  7. CLEAR GRAPH                       |\n";
+            }
-		cout << "|  8. PRINT GRAPH filePath              |\n";
+
-		cout << "|  9. GET HINT                          |\n";
+            cout << "+---------------+-----------+------------+--------+\n";
-		cout << "|  10. EXIT                             |\n";
+            cout << "| Вершина       | in_degree | out_degree | degree |\n";
-		cout << "+---------------------------------------+\n";
+            cout << "+---------------+-----------+------------+--------+\n";
-	}
+
             for (auto p : edges)
             {
                 Vertice u = p.first;
-	/// <summary>
+
-	/// Конструктор по умолчанию
+                int u_in = in_degree[u];
-	/// </summary>
+                int u_out = out_degree[u];
-	ConsoleInterface() {};
+
                 cout << left << "| " << setw(14) << u << "| " << setw(10) << u_in << "| " << setw(11) << u_out << "| " << setw(7) << u_in + u_out << "|\n";
-	/// <summary>
+            }
-	/// Запуск интерфейса
+
-	/// </summary>
+            cout << "+---------------+-----------+------------+--------+\n";
-	void Start()
+        }
-	{
+    }
-		Hint();
+    catch (const char* msg)
     {
-		while (true)
+        cout << msg << "\n";
-		{
+    }
-			cout << ">> ";
+}
 
-			string w1; cin >> w1;
+
 /// Задание 1а: поиск вершины, соединенной с u и v
-			if (w1 == "CREATE")
+
-			{
+/// <typeparam name="Vertice"> тип вершин орграфа </typeparam>
-				string w2, w3; cin >> w2 >> w3;
+/// <typeparam name="Edge"> тип дуг орграфа </typeparam>
 /// <param name="g"> граф </param>
-				if (w3 == "directed" || w3 == "undirected")
+/// <param name="u"> первая вершина </param>
-				{
+/// <param name="v"> вторая вершина </param>
-					string w4; cin >> w4;
+template <class Vertice, class Edge>
-					g = Graph<Vertice, Edge>(w3, w4);
+void FindVertice(Graph<Vertice, Edge> g, Vertice u, Vertice v, bool allow_loop)
-				}
+
-				else g = Graph<Vertice, Edge>(w3);
+    map<Vertice, map<Vertice, Edge>> edges = g.edges();
-			}
+
-			else if (w1 == "ADD")
+    try
-			{
+    {
-				string w2; cin >> w2;
+        if (!g.isDirected()) throw "Задание 1a: работаем с орграфом";
         else if (u == v) throw "Задание 1а: вершины u и v должны быть различны";
-				if (w2 == "VERTICE")
+        else if (edges.find(u) == edges.end() || edges.find(v) == edges.end()) throw "Задание 1а: в графе отсутствует(ют) заданная(ые) вершина(ы)";
-				{
+        else
-					Vertice w3; cin >> w3;
+        {
-					g.addVertice(w3);
+            bool allow_loops = allow_loop;
-				}
+            vector <Vertice> ans;
-				else
+
-				{
+            for (auto p : edges[u])
-					Vertice w3, w4; Edge w5; cin >> w3 >> w4;
+            {
                 Vertice x = p.first;
-					if (!g.isWeighted()) w5 = 1;
+                if ((allow_loops || (x != u && x != v)) && edges[v].find(x) != edges[v].end()) ans.push_back(x);
-					else cin >> w5;
+            }
 
-					g.addEdge(w3, w4, w5);
+            if (ans.size())
-				}
+            {
-			}
+                cout << "Существуют: ";
-			else if (w1 == "REMOVE")
+
-			{
+                for (int i = 0; i < ans.size(); ++i)
-				string w2; cin >> w2;
+                    cout << ans[i] << " ";
             }
-				if (w2 == "VERTICE")
+            else cout << "НЕ существуют";
-				{
+
-					Vertice w3; cin >> w3;
+            cout << "\n";
-					g.removeVertice(w3);
+        }
-				}
+    }
-				else
+    catch (const char* msg)
-				{
+    {
-					Vertice w3, w4; cin >> w3 >> w4;
+        cout << msg << "\n";
-					g.removeEdge(w3, w4);
+    }
-				}
+}
-			}
+
-			else if (w1 == "CLEAR")
+
-			{
+/// Задание 1b: удаление ребер в графе с одинаковыми степенями
-				string w2; cin >> w2;
+
-				g.clear();
+
-			}
+/// <typeparam name="Edge"> тип вершин орграфа </typeparam>
-			else if (w1 == "PRINT")
+/// <param name="g"> граф </param>
-			{
+template <class Vertice, class Edge>
-				string w2, w3; cin >> w2 >> w3;
+void RemoveEdges(Graph<Vertice, Edge> g, string filePath)
-				g.print(w3);
+
-			}
+    try
-			else if (w1 == "GET")
+    {
-			{
+        if (g.isDirected()) throw "Задание 1b: работаем с графом";
-				string w2; cin >> w2;
+        else
-				Hint();
+        {
-			}
+            map<Vertice, int> degree;
-			else if (w1 == "EXIT")
+            map <Vertice, map<Vertice, Edge>> edges = g.edges();
-			{
+
-				break;
+            for (auto p1 : edges)
-			}
+                degree[p1.first] = p1.second.size();
-		}
+
-	}
+            for (auto p1 : edges)
             {
                 Vertice u = p1.first;
 
                 for (auto p2 : p1.second)
                 {
                     Vertice v = p2.first;
                     if (degree[u] == degree[v] && u < v)
                         g.removeEdge(u, v);
                 }
             }
 
             g.print(filePath);
         }
     }
     catch (const char* msg)
     {
         cout << msg << "\n";
     }
 }
 
 //////////////////////////////////////////////
 //            ConsoleInterface.h            //
 //////////////////////////////////////////////
 
 #pragma once
 #include "Graph.h"
 #include <vector>
 #include <string>
 
 /// <summary>
 /// Консольный интерфейс, работающий с одним графом
 /// </summary>
 /// <typeparam name="Vertice"> тип вершин графа </typeparam>
 /// <typeparam name="Edge"> тип ребер графа </typeparam>
 template <class Vertice, class Edge = int>
 class ConsoleInterface
 {
     /// <summary>
     /// Граф
     /// </summary>
     Graph<Vertice, Edge> g;
 
     /// <summary>
     /// Вывод на консоль списка доступных команд
     /// </summary>
     void Hint()
     {
         cout << "+---------------------------------------+\n";
         cout << "|             СПИСОК КОМАНД             |\n";
         cout << "+---------------------------------------+\n";
         cout << "|  1. CREATE GRAPH direction weighting  |\n";
         cout << "|  2. CREATE GRAPH filePath             |\n";
         cout << "|  3. ADD VERTICE v                     |\n";
         cout << "|  4. REMOVE VERTICE v                  |\n";
         cout << "|  5. ADD EDGE u v [w]                  |\n";
         cout << "|  6. REMOVE EDGE u w                   |\n";
         cout << "|  7. CLEAR GRAPH                       |\n";
         cout << "|  8. PRINT GRAPH filePath              |\n";
         cout << "|  9. TASK 1                            |\n";
         cout << "|  10. TASK 2 u v allow_loop            |\n";
         cout << "|  11. TASK 3 filePath                  |\n";
         cout << "|  12. GET HINT                         |\n";
         cout << "|  13. EXIT                             |\n";
         cout << "+---------------------------------------+\n";
     }
 
 public:
 
     /// <summary>
     /// Конструктор по умолчанию
     /// </summary>
     ConsoleInterface() {};
 
     /// <summary>
     /// Запуск интерфейса
     /// </summary>
     void Start()
     {
         Hint();
 
         while (true)
         {
             cout << ">> ";
 
             string w1; cin >> w1;
 
             if (w1 == "CREATE")
             {
                 string w2, w3; cin >> w2 >> w3;
 
                 if (w3 == "directed" || w3 == "undirected")
                 {
                     string w4; cin >> w4;
                     g = Graph<Vertice, Edge>(w3, w4);
                 }
                 else g = Graph<Vertice, Edge>(w3);
             }
             else if (w1 == "ADD")
             {
                 string w2; cin >> w2;
 
                 if (w2 == "VERTICE")
                 {
                     Vertice w3; cin >> w3;
                     g.addVertice(w3);
                 }
                 else
                 {
                     Vertice w3, w4; Edge w5; cin >> w3 >> w4;
 
                     if (!g.isWeighted()) w5 = 1;
                     else cin >> w5;
 
                     g.addEdge(w3, w4, w5);
                 }
             }
             else if (w1 == "REMOVE")
             {
                 string w2; cin >> w2;
 
                 if (w2 == "VERTICE")
                 {
                     Vertice w3; cin >> w3;
                     g.removeVertice(w3);
                 }
                 else
                 {
                     Vertice w3, w4; cin >> w3 >> w4;
                     g.removeEdge(w3, w4);
                 }
             }
             else if (w1 == "CLEAR")
             {
                 string w2; cin >> w2;
                 g.clear();
             }
             else if (w1 == "PRINT")
             {
                 string w2, w3; cin >> w2 >> w3;
                 g.print(w3);
             }
             else if (w1 == "TASK")
             {
                 int w2; cin >> w2;
 
                 if (w2 == 1) VerticesDegrees(g);
                 else if (w2 == 2)
                 {
                     Vertice u, v; bool b; cin >> u >> v >> b;
                     FindVertice(g, u, v, b);
                 }
                 else if (w2 == 3)
                 {
                     string w3; cin >> w3; RemoveEdges(g, w3);
                 }
             }
             else if (w1 == "GET")
             {
                 string w2; cin >> w2;
                 Hint();
             }
             else if (w1 == "EXIT")
             {
                 break;
             }
         }
     }
 };
 
 /////////////////////////////////////
 //            Graph.cpp            //
 /////////////////////////////////////
 
 #include "ConsoleInterface.h"
 #include <Windows.h>
 
 int main()
 {
 	SetConsoleCP(1251);
 	SetConsoleOutputCP(1251);
 
 	ConsoleInterface<string, string> consoleInterface;
 	consoleInterface.Start();
 
 	return 0;
 }