using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace BlackHoleDetection
{
    class Program
    {
        const int N = 13;

        // Стандартная матрица смежности
        // graphInitial[i, j] = 1 означает наличие ребра от i к j
        // graphInitial[i, j] = 0 означает отсутствие ребра от i к j
        static int[,] graphInitial = new int[N, N]
        {
            {0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
        };

        static void Main(string[] args)
        {
            // Шаг 1: Поиск слабосвязных компонент (WCC) с использованием BFS
            List<List<int>> weaklyConnectedComponents = FindWeaklyConnectedComponents(graphInitial, N);

            // Шаг 2: Вывод найденных WCC
            Console.WriteLine("Слабосвязные компоненты (WCC):");
            for (int i = 0; i < weaklyConnectedComponents.Count; i++)
            {
                Console.WriteLine($"WCC {i}: {string.Join(" ", weaklyConnectedComponents[i].OrderBy(v => v))}");
            }
            Console.WriteLine();

            // Шаг 3: Создание отображения вершина -> индекс WCC
            Dictionary<int, int> vertexToWCC = new Dictionary<int, int>();
            for (int i = 0; i < weaklyConnectedComponents.Count; i++)
            {
                foreach (var vertex in weaklyConnectedComponents[i])
                {
                    vertexToWCC[vertex] = i;
                }
            }

            // Шаг 4: Определение наличия исходящих рёбер для каждой WCC
            bool[] hasOutgoing = new bool[weaklyConnectedComponents.Count];
            for (int i = 0; i < weaklyConnectedComponents.Count; i++)
            {
                foreach (var v in weaklyConnectedComponents[i])
                {
                    for (int j = 0; j < N; j++)
                    {
                        if (graphInitial[v, j] == 1 && !weaklyConnectedComponents[i].Contains(j))
                        {
                            hasOutgoing[i] = true;
                            break;
                        }
                    }
                    if (hasOutgoing[i]) break;
                }
            }

            // Шаг 5: Вывод информации об исходящих рёбрах
            for (int i = 0; i < weaklyConnectedComponents.Count; i++)
            {
                var wcc = weaklyConnectedComponents[i];
                var outgoing = new List<int>();
                foreach (var v in wcc)
                {
                    for (int j = 0; j < N; j++)
                    {
                        if (graphInitial[v, j] == 1 && !wcc.Contains(j))
                        {
                            outgoing.Add(j);
                        }
                    }
                }
                Console.WriteLine($"WCC {i} (вершины: {string.Join(", ", wcc.OrderBy(x => x))}) имеет исходящие рёбра к вершинам: {string.Join(", ", outgoing.Distinct())}");
            }
            Console.WriteLine();

            // Шаг 6 и 7: Параллельная классификация черных дыр
            List<List<int>> firstOrderBlackHoles = new List<List<int>>();
            List<List<int>> secondOrderBlackHoles = new List<List<int>>();
            HashSet<int> firstOrderIndices = new HashSet<int>();

            // Определение черных дыр первого порядка
            for (int i = 0; i < weaklyConnectedComponents.Count; i++)
            {
                if (weaklyConnectedComponents[i].Count > 1 && !hasOutgoing[i])
                {
                    firstOrderBlackHoles.Add(weaklyConnectedComponents[i]);
                    firstOrderIndices.Add(i);
                }
            }

            // Параллельное определение черных дыр второго порядка
            Parallel.For(0, weaklyConnectedComponents.Count, (i) =>
            {
                if (weaklyConnectedComponents[i].Count <= 1 || !hasOutgoing[i])
                    return;

                bool isSecondOrder = true;
                foreach (var v in weaklyConnectedComponents[i])
                {
                    for (int j = 0; j < N; j++)
                    {
                        if (graphInitial[v, j] == 1 && !weaklyConnectedComponents[i].Contains(j))
                        {
                            if (vertexToWCC.ContainsKey(j))
                            {
                                int targetWCC = vertexToWCC[j];
                                // Синхронизация доступа к firstOrderIndices
                                if (!firstOrderIndices.Contains(targetWCC))
                                {
                                    isSecondOrder = false;
                                    break;
                                }
                            }
                            else
                            {
                                isSecondOrder = false;
                                break;
                            }
                        }
                    }
                    if (!isSecondOrder) break;
                }

                if (isSecondOrder)
                {
                    lock (secondOrderBlackHoles)
                    {
                        secondOrderBlackHoles.Add(weaklyConnectedComponents[i]);
                    }
                }
            });

            // Шаг 8: Вывод результатов
            Console.WriteLine("Черные дыры первого порядка:");
            foreach (var bh in firstOrderBlackHoles.OrderBy(bh => bh.First()))
            {
                Console.WriteLine(string.Join(" ", bh.OrderBy(v => v)));
            }

            Console.WriteLine("\nЧерные дыры второго порядка:");
            foreach (var bh in secondOrderBlackHoles.OrderBy(bh => bh.First()))
            {
                Console.WriteLine(string.Join(" ", bh.OrderBy(v => v)));
            }

            // Ожидание завершения программы (опционально)
            // Console.ReadLine();
        }

        // Метод для поиска слабосвязных компонент (WCC) с использованием BFS
        static List<List<int>> FindWeaklyConnectedComponents(int[,] graph, int size)
        {
            List<List<int>> WCCs = new List<List<int>>();
            bool[] visited = new bool[size];
            for (int v = 0; v < size; v++)
            {
                if (!visited[v])
                {
                    List<int> component = new List<int>();
                    Queue<int> queue = new Queue<int>();
                    queue.Enqueue(v);
                    visited[v] = true;
                    while (queue.Count > 0)
                    {
                        int current = queue.Dequeue();
                        component.Add(current);

                        // Проверка исходящих рёбер
                        for (int i = 0; i < size; i++)
                        {
                            if (graph[current, i] == 1 && !visited[i])
                            {
                                queue.Enqueue(i);
                                visited[i] = true;
                            }
                        }

                        // Проверка входящих рёбер
                        for (int i = 0; i < size; i++)
                        {
                            if (graph[i, current] == 1 && !visited[i])
                            {
                                queue.Enqueue(i);
                                visited[i] = true;
                            }
                        }
                    }
                    WCCs.Add(component);
                }
            }
            return WCCs;
        }
    }
}
Это мой код. Это результат который я получаю:
Слабосвязные компоненты (WCC):
WCC 0: 0 1 4 5
WCC 1: 2 3
WCC 2: 6 7 8 9 10 11
WCC 3: 12

WCC 0 (вершины: 0, 1, 4, 5) имеет исходящие рёбра к вершинам:
WCC 1 (вершины: 2, 3) имеет исходящие рёбра к вершинам:
WCC 2 (вершины: 6, 7, 8, 9, 10, 11) имеет исходящие рёбра к вершинам:
WCC 3 (вершины: 12) имеет исходящие рёбра к вершинам:

Черные дыры первого порядка:
0 1 4 5
2 3
6 7 8 9 10 11

Черные дыры второго порядка:

E:\maga\3 семестр\BD\laba1\laba1\bin\Debug\net8.0\laba1.exe (процесс 17948) завершил работу с кодом 0.
Чтобы автоматически закрывать консоль при остановке отладки, включите параметр "Сервис" ->"Параметры" ->"Отладка" -> "Автоматически закрыть консоль при остановке отладки".
Нажмите любую клавишу, чтобы закрыть это окно:
Верно ли это, если нет, исправь мой код так, чтобы результаты были верны