Сравнить два графа по компоненте связности

using System;
 
using Microsoft.Msagl.Drawing; //Граф
 
namespace WindowsFormsApplication1
{
    public partial class btn_open2 : Form
    {
        public btn_open2()
        {
            InitializeComponent();
            gViewer1.Visible = false;
            gViewer2.Visible = false;
            radioButton2.Checked = true;
            radioButton3.Checked = true;
        }
 
 
   
 
 
        //Формирование матрицы смежности
        private int[,] AdjacencyMatrix(int size, int[] g, int[] p)
        {
            int[,] arr = new int[size, size];
            int last = 0;
            for (int i = 0; i < size; i++)
            {
                while (p[i] != last)
                {
                    arr[i, g[last] - 1] = 1;
                    last++;
                }
                last = p[i];
            }
            return arr;
        }
 
        //Проверка матрицы смежности на симметричность
        private bool CheckSimetric(int[,] matrix)
        {
            int size = (int)matrix.GetLength(0);
            for (int i = 0; i < size; i++)
                for (int j = 0; j < size; j++)
                    if (matrix[i, j] != matrix[j, i]) return false;
            return true;
        }
 
 
      
 
        //Удаление висячих вершин
        void deleteTops(ref int[,] matrix)
        {
            int count;
            int n = matrix.GetLength(0);
            for (int i = 0; i < n; i++)
            {
                count = 0;
                for (int j = 0; j < n; j++)
                {
                    if (matrix[i, j] == 1) count++;
                }
 
                if (count == 1)
                {
                    for (int j = 0; j < n; j++)
                    {
                        if (matrix[i, j] == 1)
                        {
                            matrix[i, j] = 0;
                            matrix[j, i] = 0;
                        }
                    }
                }
            }
        }
 
        //Нахождение матрицы кратчайших путей с помощью алгоритма Дейкстры
        int[,] SearchMinWay(int[,] matrix)
        {
            int n = matrix.GetLength(0);
            int v;
            int infinity = 1000;
            int[] x = new int[n]; //Массив, содержащий единицы и нули для каждой вершины,
            // x[i]=0 - еще не найден кратчайший путь в i-ю вершину,
            // x[i]=1 - кратчайший путь в i-ю вершину уже найден
            int[] Length = new int[n]; //t[i] - длина кратчайшего пути от вершины s в i
            int[,] D = new int[n, n];
            int comp = 0;
            int start = 0;                       // Номер исходной вершины
            int end;                             // Номер конечной вершины
            for (start = 0; start < n; start++) //Нахождение путей для всех вершин
                for (int prosto = 0; prosto < n; prosto++)
                {
                    end = prosto;                    //цикл прогоняет алгоритм Дейкстры p-ое количество раз
                    if (end == start) continue;      //исключаем просчет растояния между одной и той же точкой
                    else
                    {                                         // Инициализируем начальные значения массивов
                        int u;                                // Счетчик вершин
                        for (u = 0; u < n; u++)
                        {
                            Length[u] = infinity;                    //Сначала все кратчайшие пути из s в i 
                            //равны бесконечности
                            x[u] = 0;                                    // и нет кратчайшего пути ни для одной вершины
                        }
                        Length[start] = 0;                      // Кратчайший путь из s в s равен 0
                        x[start] = 1;                              // Для вершины s найден кратчайший путь
                        v = start;                                 // Делаем s текущей вершиной
 
                        while (true)
                        {
                            // Перебираем все вершины, смежные v, и ищем для них кратчайший путь
                            for (u = 0; u < n; u++)
                            {
                                if (matrix[v, u] == 0) continue;      // Вершины u и v несмежные
                                if (x[u] == 0 && Length[u] > Length[v] + matrix[v, u]) //Если для вершины 'u' еще не 
                                //найден кратчайший путь
                                // и новый путь в 'u' короче чем 
                                //старый, то
                                {
                                    Length[u] = Length[v] + matrix[v, u];
                                    comp++;//запоминаем более короткую длину пути в
                                    //массив t[и]                                                 
                                }
                            }
 
                            // Ищем из всех длин некратчайших путей самый короткий
                            int w = infinity;                   // Для поиска самого короткого пути
                            v = -1;                             // В конце поиска v - вершина, в которую будет 
                            // найден новый кратчайший путь. Она станет 
                            // текущей вершиной
                            for (u = 0; u < n; u++)                  // Перебираем все вершины.
                            {
                                if (x[u] == 0 && Length[u] < w)  // Если для вершины не найден кратчайший 
                                // путь и если длина пути в вершину 'u' меньше
                                // уже найденной, то
                                {
                                    v = u;                         // текущей вершиной становится 'u'-я вершина
                                    w = Length[u];
                                }
                            }
 
                            if (v == -1)
                            {
                                Console.WriteLine("Нет пути из вершины X" + (start + 1) + " в вершину X" + (end + 1) + ".");
                                //rBox_MinWay.Text += "Нет пути из вершины X" + (start + 1) + " в вершину X" + (end + 1) + ".";
                                break;
                            }
 
                            if (v == end)                     // Найден кратчайший путь,
                            {
                                //rBox_MinWay.Text += "\nКратчайший путь из вершины X" + (start + 1) + " в вершину X" + (end + 1) + ":\n";
                                //u = end;
                                D[start, end] = Length[end];
                                //rBox_MinWay.Text += "\nДлина пути - " + Length[end] + "\n";
                                break;
                            }
                            x[v] = 1;
                        }
                    }
                }
            return D;
        }
 
        //Нахождение максимального кратчайшего пути для каждой из вершин
        int[] SearchMax(int[,] matrix)
        {
            int n = matrix.GetLength(0);
            int max = matrix[0, 0]; //делаем первый элемент максимальный
            int[] maxVec = new int[n]; //вектор максимальных путей
 
            for (int i = 0; i < n; i++) //нахождение максимального пути для каждой из вершин
            {
                max = matrix[i, 0];
                for (int j = 0; j < n; j++)
                {
                    if (matrix[i, j] > max) max = matrix[i, j];
                }
                maxVec[i] = max;
            }
            return maxVec;
        }
 
        //Нахождение центральных вершин
        int[] SearchMiddleTop(int[] maxVec)
        {
            int min = maxVec[0]; //делаем первый элемент минимальным
            int[] result = { }; //вектор центральных вершин
            for (int i = 0; i < maxVec.Length; i++) //Находим минимальные пути в векторе максимальных
            {
                if (maxVec[i] < min) min = maxVec[i];
            }
            int n = 0;
            for (int i = 0; i < maxVec.Length; i++) //Формируем массив центральных вершин
            {
                if (maxVec[i] == min) { Array.Resize(ref result, result.Length + 1); result[n] = i; n++; }
            }
            return result;
        }
 
        //Считывание с файла
        private void InputFile(NumericUpDown cn, NumericUpDown cm, TextBox cg, TextBox cp)
        {
            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                try
                {
                    StreamReader sr = new StreamReader(openFileDialog1.FileName);
                    string s = sr.ReadToEnd();
                    sr.Close();
                    var l = from w in s.Split('\n') select w;
                    int nn = 0;
                    foreach (var el in l)
                    {
                        nn++;
                        if (nn == 1)
                        {
                            string[] n = el.Split(' ');
                            if (int.Parse(n[0]) > 20 || int.Parse(n[0]) < 1) { MessageBox.Show("Ошибка ввода количества вершин", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); break; }
                            cn.Value = Convert.ToDecimal(n[0]);
                            if (int.Parse(n[1]) > 50 || int.Parse(n[1]) < 0) { MessageBox.Show("Ошибка ввода количества ребер", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); break; }
                            cm.Value = Convert.ToDecimal(n[1]);
                        }
                        if (nn == 2)
                            cg.Text = el.Trim(' ');
                        if (nn == 3)
                            cp.Text = el.Trim(' ');
                    }
                }
                catch
                {
                    MessageBox.Show("Ошибка считывания!", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
        }
 
        //Кнопка "Вычислить"
        private void btn_calc_Click_1(object sender, EventArgs e)
        {
            try
            {
                //Первый граф
                int n1 = (int)nmr_n1.Value; //количество вершин          
                int m1 = (int)nmr_m1.Value; //количество ребер 
 
                int[] g1 = new int[m1]; //MFО представление
                int[] p1 = new int[n1];     //
 
                ConversionFrom(ref g1, tb_g1); //считывание с формы
                ConversionFrom(ref p1, tb_p1); //
 
                CheckG(n1, m1, g1, 1); //проверка матрицы G
                CheckP(n1, m1, p1, 1); //проверка матрицы P
 
                int[,] matrix1 = AdjacencyMatrix(n1, g1, p1); //Создание матрицы смежности
 
                if (!CheckSimetric(matrix1)) throw new Exception("Матрица смежности 1-ого графа не симметрична!");
 
 
 
                deleteTops(ref matrix1); //удаление висячих вершин
 
                int[,] D1 = SearchMinWay(matrix1); //создание матрицы кратчайших путей
 
                int[] max1 = SearchMax(D1); //вектор максимальных путей для каждой вершины
                 
                int[] MiddleTop1 = SearchMiddleTop(max1); //поиск центральных вершин
 
                //Второй граф
                int n2 = (int)nmr_n2.Value; //количество вершин
                int m2 = (int)nmr_m2.Value; //количество ребер
 
                int[] p2 = new int[n2];     //MFO представление
                int[] g2 = new int[m2]; //
 
                ConversionFrom(ref g2, tb_g2); //считывание с формы
                ConversionFrom(ref p2, tb_p2); //
 
                CheckG(n2, m2, g2, 2); //проверка элементов массива G
                CheckP(n2, m2, p2, 2); //проверка элементов массива P
 
                int[,] matrix2 = AdjacencyMatrix(n2, g2, p2); //создание матрицы смежности
 
                if (!CheckSimetric(matrix2)) throw new Exception("Матрица смежности 2-ого графа не симметрична!");
 
                deleteTops(ref matrix2); //удаление висячих вершин
 
 
                int[,] D2 = SearchMinWay(matrix2); //создание матрицы кратчайших путей
 
                int[] max2 = SearchMax(D2); //вектор максимальных путей для каждой вершины
 
                int[] MiddleTop2 = SearchMiddleTop(max2); //поиск центральных вершин
 
                //Сравнивание графов по
                string s;
                if (MiddleTop1.Length == MiddleTop2.Length)
                    s = "Графы эквивалентны";
                else s = "Графы не эквивалентны";
                MessageBox.Show(s, "Результат", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
 
        }
   
    }
}