Поиск в ширину на C#

using System;
using System.Collections.Generic;
using System.Collections;
 
namespace BreadthFirstSearch
{
    class BreadthFirstSearch
    {
        static void Main(string[] args)
        {
            Hashtable graph = new Hashtable();
 
            graph.Add("A", new string[] { "G", "H", "F" });
            graph.Add("M", new string[] { "S", "I", "D" });
            graph.Add("G", new string[] { "L", "D" });
            graph.Add("H", new string[] { "M" });
            graph.Add("I", new string[] { "K", "J" });
 
            Console.WriteLine("Введите начальный узел графа: ");
            string startNode = Console.ReadLine();
 
            Console.WriteLine("Введите конечный узел графа: ");
            string endNode = Console.ReadLine();
 
            int answer = BFS(graph, startNode, endNode);
 
            if (answer == -1)
                Console.WriteLine($"Узлы {startNode} и {endNode} не связанны");
 
            else if (answer == 0)
                Console.WriteLine("Введён один и тот же узёл");
 
            else
                Console.WriteLine($"Расстояние между узлами {startNode} и {endNode} = {answer}");
        }
 
        public static int BFS(Hashtable graph, string startNode, string endNode)
        {
            if (startNode == endNode)
                return 0;
 
            Queue<object> queue = new Queue<object>();
            queue.Enqueue(graph[startNode]);
 
            List<string> used = new List<string>();
            used.Add(startNode);
 
            while (queue.Count > 0)
            {
                string[] nodes;
 
                if ((nodes = queue.Dequeue() as string[]) != null)
                {
                    foreach (string node in nodes)
                    {
                        if (!used.Contains(node))
                        {
                            used.Add(node);
 
                            if (node == endNode)
                                return GetWayLength(CreateReverseGraph(graph, DeleteNoKeys(used, graph.Keys)), startNode, endNode);
 
                            queue.Enqueue(graph[node]);
                        }
                    }
                }
            }
 
            return -1;
        }
 
        public static Hashtable CreateReverseGraph(Hashtable graph, List<string> nodes)
        {
            Hashtable reverseGraph = new Hashtable();
            List<string> used = new List<string>();
 
            foreach (string key in nodes)
            {
                string[] values = graph[key] as string[];
 
                foreach (string value in values)
                {
                    if (!used.Contains(value))
                    {
                        reverseGraph.Add(value, key);
                        used.Add(value);
                    }
                    else
                    {
                        int currentWayLength = GetWayLength(reverseGraph, nodes[0], reverseGraph[value] as string);
                        int potentialWayLength = GetWayLength(reverseGraph, nodes[0], key);
 
                        if (potentialWayLength < currentWayLength)
                            reverseGraph[value] = key;
                    }
                }
            }
 
            return reverseGraph;
        }
 
        public static List<string> DeleteNoKeys(List<string> used, ICollection graphKeys)
        {
            List<string> keys = new List<string>();
 
            foreach (string key in graphKeys)
                keys.Add(key);
 
            List<string> noKeys = new List<string>();
 
            foreach (string node in used)
                if (!keys.Contains(node))
                    noKeys.Add(node);
 
            foreach (string node in noKeys)
                used.Remove(node);
 
            return used;
        }
 
        public static int GetWayLength(Hashtable reverseGraph, string startNode, string endNode)
        {
            int wayLength = 1;
            string node;
            string currentNode = endNode;
 
            while ((node = reverseGraph[currentNode] as string) != startNode)
            {
                currentNode = node;
                wayLength++;
            }
 
            return wayLength;
        }
    }
}