查找图中两个顶点之间的边数

Question

我正在尝试执行一项练习任务，该任务需要查找图中两个顶点之间的边数。我正在练习平台上针对一些测试测试我的代码（我不知道测试）。其中一项测试失败了。你能帮我找出我的代码有什么问题吗，可能是我看不到某些极端情况或其他东西。

任务：
查找两个顶点之间的边数。
给定：
我们有 N 个坐标对的输入。每个坐标对都连接到所有其他坐标对。 我们有可到达顶点的 MaxWeight。 以及一个基于 1 的开始和结束索引。

所以我用顶点和边创建了图形，计算了距离（权重），并做了 bfs 但它仍然说对于某些测试有一个错误的答案。

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

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            using (StreamReader reader = File.OpenText("input.txt"))
            {
                int verteciesAmount = int.Parse(reader.ReadLine());
                Graph graph = new Graph();
                for (int i = 0; i < verteciesAmount; i++)
                {
                    string coordinates = reader.ReadLine();
                    string[] coordinateValues = coordinates.Split(' ');
                    graph.AddVertex(new Vertex(int.Parse(coordinateValues[0]), int.Parse(coordinateValues[1]), i));
                }

                int maxDistance = int.Parse(reader.ReadLine());
                graph.InitEdges(maxDistance);
                string[] tripRoute = reader.ReadLine().Split(' ');
                int startVertexIndex = int.Parse(tripRoute[0]) - 1;
                int destinationVertexIndex = int.Parse(tripRoute[1]) - 1;
                int result = graph.FindRoute(startVertexIndex, destinationVertexIndex);
                Console.WriteLine(result);
                Console.ReadLine();
            }
        }
    }

    class Vertex
    {
        protected bool Equals(Vertex other)
        {
            return X == other.X && Y == other.Y;
        }

        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj)) return false;
            if (ReferenceEquals(this, obj)) return true;
            if (obj.GetType() != this.GetType()) return false;
            return Equals((Vertex)obj);
        }

        public override int GetHashCode()
        {
            unchecked
            {
                return (X * 397) ^ Y;
            }
        }

        public Vertex(int x, int y, int index)
        {
            X = x;
            Y = y;
            Index = index;
        }

        public int X { get; set; }
        public int Y { get; set; }
        public int Index { get; set; }

        public int GetDistanceTo(Vertex vertex)
        {
            return Math.Abs(X - vertex.X) + Math.Abs(Y - vertex.Y);
        }

        public override string ToString()
        {
            return Index.ToString();
        }
    }

    class Edge
    {
        public Edge(Vertex from, Vertex to, int weight)
        {
            From = from;
            To = to;
            Weight = weight;
        }

        public Vertex From { get; set; }
        public Vertex To { get; set; }
        public int Weight { get; set; }

        public override string ToString()
        {
            return $"{From.Index}, {To.Index}";
        }
    }

    class Graph
    {
        private List<Vertex> Vertices { get; }
        private List<Edge> Edges { get; }

        public Graph()
        {
            Vertices = new List<Vertex>();
            Edges = new List<Edge>();
        }

        private List<Vertex> GetAvailableVertices(Vertex vertex)
        {
            List<Vertex> result = new List<Vertex>();
            foreach (Edge edge in Edges)
            {
                if (edge.From == vertex)
                {
                    result.Add(edge.To);
                }
            }

            return result;
        }

        public void AddVertex(Vertex vertex)
        {
            Vertices.Add(vertex);
        }

        private void AddEdge(Edge edge)
        {
            Edges.Add(edge);
        }
        
        public void InitEdges(int maxWeight)
        {
            foreach (Vertex vertexFrom in Vertices)
            {
                foreach (Vertex vertexTo in Vertices.Where(vertex => vertex != vertexFrom))
                {
                    var distance = vertexFrom.GetDistanceTo(vertexTo);
                    if (distance <= maxWeight)
                    {
                        AddEdge(new Edge(vertexFrom, vertexTo, distance));
                    }
                }
            }
        }

        public int FindRoute(int startCityIndex, int destinationCityIndex)
        {
            Vertex from = Vertices[startCityIndex];
            Vertex to = Vertices[destinationCityIndex];

            var result = new Dictionary<Vertex, int>();
            Queue<Vertex> visited = new Queue<Vertex>();
            visited.Enqueue(from);
            result[from] = 0;
            while (visited.Count > 0)
            {
                Vertex vertex = visited.Dequeue();
                var vertexLevel = result[vertex];
                foreach (Vertex availableVertex in GetAvailableVertices(vertex))
                {
                    if (result.ContainsKey(availableVertex))
                    {
                        continue;
                    }
                    else
                    {
                        visited.Enqueue(availableVertex);
                        result[availableVertex] = vertexLevel + 1;
                    }
                }
            }

            int resultLevel;
            if (result.TryGetValue(to, out resultLevel))
            {
                return resultLevel;
            }
            else
            {
                return -1;
            }
        }
    }
}