Problem Komiwojażera

public class Miasto
{
    public string Nazwa { get; set; }
    public Dictionary<Miasto, int> Sąsiedzi { get; set; }

    public Miasto(string nazwa)
    {
        Nazwa = nazwa;
        Sąsiedzi = new Dictionary<Miasto, int>();
    }
}

public class Graf
{
    public List<Miasto> Miasta { get; set; }

    public Graf()
    {
        Miasta = new List<Miasto>();
    }

    public void DodajMiasto(Miasto miasto)
    {
        Miasta.Add(miasto);
    }
}

public void DodajPołączenie(string nazwaMiasta1, string nazwaMiasta2, int odległość)
{
    var miasto1 = Miasta.Find(m => m.Nazwa == nazwaMiasta1);
    var miasto2 = Miasta.Find(m => m.Nazwa == nazwaMiasta2);

    miasto1.Sąsiedzi.Add(miasto2, odległość);
    miasto2.Sąsiedzi.Add(miasto1, odległość);
}

public (List<Miasto> Ścieżka, int Długość) NajkrótszaŚcieżka(string nazwaMiasta1, string nazwaMiasta2)
{
    var start = Miasta.Find(m => m.Nazwa == nazwaMiasta1);
    var meta = Miasta.Find(m => m.Nazwa ==

using Komiwojażer;
using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    static void Main(string[] args)
    {
        Graf graf = new Graf();
        odleglosci trasy = new odleglosci();

        // utwórz obiekt Miasto i dodaj go do klasy Graf wszystkie połączenia(sąsiadów). 
        foreach (var trasa in trasy.GetTrasy())
        {
            Miasto miasto1 = new Miasto(trasa.miejscowosc1);
            Miasto miasto2 = new Miasto(trasa.miejscowosc2);

            if (!graf.Miasta.Contains(miasto1))
                graf.DodajMiasto(miasto1);
            else
                miasto1 = graf.Miasta.Find(m => m.Nazwa == trasa.miejscowosc1);

            if (!graf.Miasta.Contains(miasto2))
                graf.DodajMiasto(miasto2);
            else
                miasto2 = graf.Miasta.Find(m => m.Nazwa == trasa.miejscowosc2);

            graf.DodajPołączenie(trasa.miejscowosc1, trasa.miejscowosc2, (double)trasa.odleglosc);
        }

        // znajdź najkrótszą trasę pomiędzy dwoma miastami. 

        //toDo
        //dla użytkownika należy wyświetlić wszystkie miasta i ma mieć możliwość wybrania najkrótszej
        var (ścieżka, długość) = graf.NajkrótszaŚcieżka("Miasto1", "Miasto2");

        // podaj resultat
        Console.WriteLine("Najkrótsza ścieżka:");
        int i = 1;
        foreach (var miasto in ścieżka)
        {
            if (i != ścieżka.Count())
            {
                i++;
                miasto.Nazwa += " -> ";
            }
            Console.Write(miasto.Nazwa);
        }
        Console.WriteLine($"\nRAZEM: {długość}");
    }

}
public class Miasto : IComparable<Miasto>
{
    public string Nazwa { get; set; }
    public Dictionary<Miasto, double> Sąsiedzi { get; set; }

    public Miasto(string nazwa)
    {
        Nazwa = nazwa;
        Sąsiedzi = new Dictionary<Miasto, double>();
    }

    //nieuzywany fragment ale wymaga tego zaimplementowany interfejs
    public int CompareTo(Miasto other)
    {
        return Nazwa.CompareTo(other.Nazwa);
    }
}

public class Graf
{
    public List<Miasto> Miasta { get; set; }

    public Graf()
    {
        Miasta = new List<Miasto>();
    }

    public void DodajMiasto(Miasto miasto)
    {
        Miasta.Add(miasto);
    }

    public void DodajPołączenie(string nazwaMiasta1, string nazwaMiasta2, double odległość)
    {
        var miasto1 = Miasta.Find(m => m.Nazwa == nazwaMiasta1);
        var miasto2 = Miasta.Find(m => m.Nazwa == nazwaMiasta2);

        miasto1.Sąsiedzi.Add(miasto2, odległość);
        miasto2.Sąsiedzi.Add(miasto1, odległość);
    }

    public (List<Miasto> Ścieżka, double Długość) NajkrótszaŚcieżka(string nazwaMiasta1, string nazwaMiasta2)
    {
        //określenie miejsca startu i końca trasy
        var start = Miasta.Find(m => m.Nazwa == nazwaMiasta1);
        var meta = Miasta.Find(m => m.Nazwa == nazwaMiasta2);

        var odległości = new SortedDictionary<Miasto, double>(Comparer<Miasto>.Create((x, y) => x.Nazwa.CompareTo(y.Nazwa)));
        var poprzednicy = new Dictionary<Miasto, Miasto>();
        var kolejka = new SortedSet<(double, Miasto)>();

        foreach (var _miasto in Miasta)
        {
            odległości[_miasto] = double.PositiveInfinity;
        }

        odległości[start] = 0;
        kolejka.Add((0, start));

        while (kolejka.Count > 0)
        {
            var (obecnaOdległość, obecneMiasto) = kolejka.Min;
            kolejka.Remove((obecnaOdległość, obecneMiasto));

            if (obecneMiasto == meta)
            {
                break;
            }

            foreach (var (sąsiad, odległość) in obecneMiasto.Sąsiedzi)
            {
                var alternatywnaOdległość = odległości[obecneMiasto] + odległość;
                if (alternatywnaOdległość < odległości[sąsiad])
                {
                    odległości[sąsiad] = alternatywnaOdległość;
                    poprzednicy[sąsiad] = obecneMiasto;
                    kolejka.Add((alternatywnaOdległość, sąsiad));
                }
            }
        }

        var ścieżka = new List<Miasto>();
        var miasto = meta;
        while (miasto != start)
        {
            ścieżka.Add(miasto);
            miasto = poprzednicy[miasto];
        }
        ścieżka.Add(start);
        ścieżka.Reverse();

        return (ścieżka, odległości[meta]);
    }

}