у меня есть такой код:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace BlackHoleDetection
{
    class Program
    {
        static void Main(string[] args)
        {
            // Определение размера графа (N = 10)
            const int N = 10;

            // Матрица смежности графа (10x10)
            // В каждой строке указаны исходящие рёбра для соответствующей вершины
            // Например, graphInitial[0,1] = 1 означает наличие рёбра из вершины 0 в вершину 1
            int[,] graphInitial = new int[N, N]
            {
                {0, 1, 1, 0, 0, 0, 0, 0, 1, 0}, // Вершина 0
                {0, 0, 0, 0, 0, 1, 1, 0, 1, 0}, // Вершина 1
                {0, 0, 0, 0, 0, 0, 0, 0, 1, 0}, // Вершина 2
                {0, 0, 1, 0, 0, 0, 0, 0, 1, 0}, // Вершина 3
                {0, 0, 0, 1, 0, 1, 0, 0, 1, 0}, // Вершина 4
                {0, 0, 0, 0, 0, 0, 1, 0, 0, 1}, // Вершина 5
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Вершина 6
                {0, 0, 1, 1, 0, 0, 0, 0, 0, 0}, // Вершина 7
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Вершина 8
                {0, 0, 0, 0, 0, 0, 0, 0, 1, 0}  // Вершина 9
            };

            // Шаг 1: Построение неориентированного списка смежности
            List<List<int>> undirectedAdjacencyList = BuildUndirectedAdjacencyList(graphInitial, N);

            // Шаг 2: Поиск слабосвязных компонент (WCC) с использованием BFS
            List<List<int>> weaklyConnectedComponents = FindWeaklyConnectedComponents(undirectedAdjacencyList, N);

            // Шаг 3: Вывод найденных 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();

            // Шаг 4: Создание отображения вершина -> индекс 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;
                }
            }

            // Шаг 5: Определение наличия исходящих рёбер для каждой 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;
                }
            }

            // Шаг 6: Вывод информации об исходящих рёбрах
            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($"hasOutgoing[{i}] = {hasOutgoing[i]}");
            }
            Console.WriteLine();

            // Шаг 7: Классификация черных дыр первого порядка
            List<List<int>> firstOrderBlackHoles = 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);
                }
            }

            // Шаг 8: Параллельная классификация черных дыр второго порядка
            List<List<int>> secondOrderBlackHoles = new List<List<int>>();
            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];
                                // Проверка, что целевая WCC является черной дырой первого порядка
                                if (!firstOrderIndices.Contains(targetWCC))
                                {
                                    isSecondOrder = false;
                                    break;
                                }
                            }
                            else
                            {
                                isSecondOrder = false;
                                break;
                            }
                        }
                    }
                    if (!isSecondOrder) break;
                }

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

            // Шаг 9: Вывод результатов
            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.WriteLine("\nНажмите любую клавишу для выхода...");
            Console.ReadKey();
        }

        /// <summary>
        /// Построение неориентированного списка смежности из ориентированного графа.
        /// </summary>
        /// <param name="graph">Матрица смежности ориентированного графа.</param>
        /// <param name="size">Количество вершин в графе.</param>
        /// <returns>Неориентированный список смежности.</returns>
        static List<List<int>> BuildUndirectedAdjacencyList(int[,] graph, int size)
        {
            List<List<int>> adjacencyList = new List<List<int>>(size);
            for (int i = 0; i < size; i++)
            {
                adjacencyList.Add(new List<int>());
            }

            for (int i = 0; i < size; i++)
            {
                for (int j = 0; j < size; j++)
                {
                    if (graph[i, j] == 1)
                    {
                        if (!adjacencyList[i].Contains(j))
                            adjacencyList[i].Add(j);
                        if (!adjacencyList[j].Contains(i))
                            adjacencyList[j].Add(i);
                    }
                }
            }

            return adjacencyList;
        }

        /// <summary>
        /// Поиск слабосвязных компонент с использованием BFS.
        /// </summary>
        /// <param name="adjacencyList">Неориентированный список смежности.</param>
        /// <param name="size">Количество вершин в графе.</param>
        /// <returns>Список слабосвязных компонент.</returns>
        static List<List<int>> FindWeaklyConnectedComponents(List<List<int>> adjacencyList, 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);

                        foreach (var neighbor in adjacencyList[current])
                        {
                            if (!visited[neighbor])
                            {
                                queue.Enqueue(neighbor);
                                visited[neighbor] = true;
                            }
                        }
                    }

                    WCCs.Add(component);
                }
            }

            return WCCs;
        }
    }
}
Такое задание:
Задание №1.
	Написать последовательную и параллельную программу, реализующие поиск черных дыр в графе.

Постановка задачи.
Предлагается задача поиска чёрных дыр в ориентированном графе без весов.
Дан граф G=(V,E)  G=(V,E), где V  – множество вершин, E  – множество ребер.
Чёрная дыра в графе G  – слабо связный подграф (т.е. просто связный подграф, если не учитывать направление рёбер) B, состоящий из более чем одной вершины, такой что ∀v∈B∀e(v,u)∈E: u∈B .  Иными словами, чёрная дыра – это слабо связный подграф, состоящий хотя бы из двух вершин, в вершины которого могут идти ребра из остальных вершин графа, но не наоборот. 

На мой взгляд программа работает неправильно, она направильно определяет черные дыры, мне кажется ошибка уже на поиске слабо связного подграфа, это не просто слабосвязный подграф, главная особенность, что в черных дырах фершины гафа связаны искличительно с вершинами этой дыры, например ждя графа в этой прогрмме насколько я понимаю черная дыра в вершинах 8 и 9, поскольку из вершины 8 вообще нет ориентированных путей, а вершина 9 связана только с ней, из нее ребра никуда больше не идут