СиАКОД Графы 1 и 2

using System;
using System.IO;
using System.Collections.Generic;

namespace Example
{
    class Program
    {
        static void Main()
        {
            Graph g = new Graph("C:/Users/contest.W12-418-05/Desktop/input.txt");
            g.Show();

            // ЗАДАНИЕ 1

            Console.Write("v1 = ");
            int v1 = int.Parse(Console.ReadLine());

            Console.WriteLine("Число вершин, смежных с вершиной v1 = {0}", g.AdjacentVertices(v1));

            // ЗАДАНИЕ 2

            Console.Write("v2 = ");
            int v2 = int.Parse(Console.ReadLine());
            if (v2 < 1 || v2 > g.Size) throw new Exception("Вершины v2 в графе нет"); --v2;

            Console.Write("Достижимые вершины (1-ая вершина = v2, на нее можно не смотреть): ");
            g.DFS(v2);
        }
    };

    public class Graph
    {
        private class Node //вложенный класс для скрытия данных и алгоритмов
        {
            private int[,] array; //матрица смежности
            public int this[int i, int j] //индексатор для обращения к матрице смежности
            {
                get
                {
                    return array[i, j];
                }
                set
                {
                    array[i, j] = value;
                }
            }

            public int Size //свойство для получения размерности матрицы смежности
            {
                get
                {
                    return array.GetLength(0);
                }
            }

            private bool[] nov; // вспомогательный массив:
                                // nov[v] = true <=> вершина НЕ просмотрена
                                // nov[v] = false <=> вершина просмотрена

            public void NovSet() //метод помечает все вершины графа как непросмотреные
            {
                for (int i = 0; i < Size; i++)
                {
                    nov[i] = true;
                }
            }

            // конструктор вложенного класса, инициализирует матрицу смежности и
            // вспомогательный массив
            public Node(int[,] a)
            {
                array = a;
                nov = new bool[a.GetLength(0)];
            }

            // подсчет кол-ва смежных вершин
            public int AdjacentVertices (int v)
            {
                if (v < 1 || v > Size)
                    throw new Exception("Вершины v в графе нет");
                else
                {
                    int res = 0;
                    --v;

                    for (int to = 0; to < Size; ++to)
                        if (array[v, to] == 1) ++res;

                    return res;
                }
            }

            //реализация алгоритма обхода графа в глубину
            public void DFS(int v)
            {
                Console.Write("{0} ", v + 1);      // просматриваем текущую вершину
                nov[v] = false;                    // помечаем ее как просмотренную

                for (int u = 0; u < Size; u++)     // в матрице смежности просматриваем строку с номером v
                {
                    //если вершины v и u смежные, к тому же вершина u не просмотрена,
                    if (array[v, u] != 0 && nov[u])
                        DFS(u);  // то рекурсивно просматриваем вершину
                }
            }

            //реализация алгоритма обхода графа в ширину
            public void BFS(int v)
            {
                Queue <int> q = new Queue <int>(); // инициализируем очередь
                q.Enqueue(v);                      // помещаем вершину v в очередь
                nov[v] = false;                    // помечаем вершину v как просмотренную

                while (q.Count != 0)               // пока очередь не пуста
                {
                    v = q.Dequeue();               // извлекаем вершину из очереди
                    Console.Write("{0} ", v);      // просматриваем ее

                    for (int u = 0; u < Size; u++) // находим все вершины
                    {
                        if (array[v, u] != 0 && nov[u]) // смежные с данной и еще не просмотренные
                        {
                            q.Enqueue(u);               // помещаем их в очередь
                            nov[u] = false;             // и помечаем как просмотренные
                        }
                    }
                }
            }
        } //конец вложенного клаcса

        private Node graph; // закрытое поле, реализующее АТД «граф»

        public int Size    // свойство для получения размерности матрицы смежности
        {
            get
            {
                return graph.Size;
            }
        }

        public Graph(string name) //конструктор внешнего класса
        {
            using (StreamReader file = new StreamReader(name))
            {
                int n = int.Parse(file.ReadLine());
                int[,] a = new int[n, n];

                for (int i = 0; i < n; i++)
                {
                    string line = file.ReadLine();
                    string[] mas = line.Split(", ");

                    for (int j = 0; j < n; j++)
                    {
                        a[i, j] = int.Parse(mas[j]);
                    }
                }

                graph = new Node(a);
            }
        }

        //метод выводит матрицу смежности на консольное окно
        public void Show()
        {
            Console.WriteLine("n = {0}", graph.Size);

            for (int i = 0; i < graph.Size; i++)
            {
                for (int j = 0; j < graph.Size; j++)
                {
                    Console.Write("{0, -4}", graph[i, j]);
                }

                Console.WriteLine();
            }
        }

        public int AdjacentVertices(int v)
        {
            return graph.AdjacentVertices(v);
        }

        public void DFS(int v)
        {
            graph.NovSet();        // помечаем все вершины графа как непросмотренные
            graph.DFS(v);          // запускаем алгоритм обхода графа в глубину
            Console.WriteLine();
        }

        public void BFS(int v)
        {
            graph.NovSet();        // помечаем все вершины графа как непросмотренные
            graph.BFS(v);          // запускаем алгоритм обхода графа в ширину
            Console.WriteLine();
        }
    }
}