Найти минимальный маршрут перемещения от первой остановки до второй

Console.WriteLine("Печатаем матрицу смежности : ");
   for (i = 0; i < 9; i++)
    {
     for (j = 0; j < 9; j++)
      Console.Write("\t" + a[i, j]);
     Console.WriteLine();
    }
   Console.WriteLine();
   // печать номеров вершин графа
   for (i = 0; i < 9; i++) Console.Write("\t" + i);
   Console.WriteLine();
   // печать массива минимальных расстояний
   for (i = 0; i < 9; i++) Console.Write("\t" + d[i]);
   Console.WriteLine();
   // печать массива маршрутов
   for (i = 0; i < 9; i++) Console.Write("\t" + post[i]);
   Console.WriteLine();
   Console.WriteLine();
   int dlin;
   // печать маршрутов стягивоющего дерева
   for (i = 0; i < 9; i++)
    {
     dlin = d[i];
     Console.Write("Путь № {0}-{1} длина пути = {2}\t\t{3}", i, begver, dlin,i);
     p = i;
     if (i != begver)
      {
       do
        {
         p = post[p];
         if (p!=0) Console.Write("\t" + p);
        }
       while (p != 0);
       Console.WriteLine();
      }
     else Console.WriteLine();            
    }

public class Station
  {
    public string StationName;
    public double Distance;
 
    public Station(string stationName, double distance)
    {
      StationName = stationName;
      Distance = distance;
    }
  }
  
  class Program
  {
    static void Main(string[] args)
    {
      Station[][] graph = new Station[5][];
      string stationStart;
      string stationEnd;
      int numberOfStations;
 
      graph[0] = new Station[] 
      { 
        new Station("a", 10), 
        new Station("b", 20), 
        new Station("c", 15), 
        new Station("d", 8),
        new Station("e", 0)
      };
 
      graph[1] = new Station[] 
      { 
        new Station("a", 10), 
        new Station("f", 12), 
        new Station("c", 15), 
        new Station("g", 18),
        new Station("e", 0)
      };
 
      graph[2] = new Station[] 
      { 
        new Station("a", 10), 
        new Station("h", 25), 
        new Station("i", 75), 
        new Station("e", 0)
      };
 
      graph[3] = new Station[] 
      { 
        new Station("a", 10), 
        new Station("j", 88),
        new Station("e", 0)
      };
 
      for (int g = 0; g < 4; g++) // перебираем маршруты
      {
        Console.WriteLine("  Граф №{0}:", g + 1);
        for (int s = 0; s < graph[g].Length - 1; s++) // Перебираем станции
        {
          Console.WriteLine("От станции {0} до {1} станции {2} км", graph[g][s].StationName, graph[g][s + 1].StationName, graph[g][s].Distance);
        }
        Console.WriteLine();
      }
 
      Console.Write("Имя станции отправления: ");
      stationStart = Console.ReadLine();
 
      Console.Write("Имя станции назначения:  ");
      stationEnd = Console.ReadLine();
 
      //Находим список допустимых станций
      List<string> stations = new List<string>();
 
      for (int g = 0; g < 4; g++) // перебираем маршруты
      {
        for (int s = 0; s < graph[g].Length; s++) // Перебираем станции
        {
          if (!stations.Contains(graph[g][s].StationName))
          {
            stations.Add(graph[g][s].StationName);
          }
        }
      }
      numberOfStations = stations.Count();
      
      //Строим матрицу инцидентности и заполняем ее длинами участков
      double[,] matrix = new double[numberOfStations, numberOfStations];
      for (int row = 0; row < numberOfStations; row++ )
      {
        for (int column = 0; column < numberOfStations; column++ )
        {
          if (row == column)
          {
            matrix[row, column] = 0;
            continue;
          }
 
          for (int g = 0; g < 4; g++) // перебираем маршруты
          {
            for (int s = 0; s < graph[g].Length - 1; s++) // Перебираем станции
            {
              if (string.Compare(graph[g][s].StationName, stations[row]) == 0 &&
                  string.Compare(graph[g][s+1].StationName, stations[column]) == 0)
              {
                matrix[row, column] = graph[g][s].Distance;
              }
            }
          }
          
        }
      }
 
 
 
      Console.ReadLine();
    }
  }

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace Graphs
{
  class Program
  {
    /// <summary>
    /// Связь между вершинами графа
    /// </summary>
    public class Link
    {
      public double Distance { get; set; }
      public string Node { get; set; }
    }
    
    /// <summary>
    /// Вершина графа
    /// </summary>
    public class Node
    {
      public List<Link> Links { get; set; } // ребра к другим вершинам
 
      public Node()
      {
        Links = new List<Link>();
      }
    }
 
    /// <summary>
    /// Вспомогательный класс для алгоритма Дейкстры
    /// </summary>
    public class Description
    {
      public bool Visited { get; set; }
      public double Distance { get; set; }
 
      public Description()
      {
        Visited = false;
        Distance = double.PositiveInfinity;
      }
    }
 
    /// <summary>
    /// Граф
    /// </summary>
    public class Graph
    {
      private Dictionary<string, Node> nodes;
 
      public Graph()
      {
        nodes = new Dictionary<string, Node>();
      }
 
      /// <summary>
      /// Добавить вершину графа
      /// </summary>
      /// <param name="name">Имя вершины графа</param>
      public void AddNode(string name)
      {
        nodes.Add(name, new Node());
      }
      
      /// <summary>
      /// Добавить ребро графа
      /// </summary>
      /// <param name="start">Начальная вершина графа</param>
      /// <param name="end">Конечная вершина граф</param>
      /// <param name="distance">расстояние</param>
      /// <param name="isOriented">двунаправленная связь</param>
      public void AddLinkToNode(string start, string end, double distance, bool isOriented)
      {
        nodes[start].Links.Add(new Link { Node = end, Distance = distance });
        if (!isOriented)
          nodes[end].Links.Add(new Link { Node = start, Distance = distance });
      }
 
      /// <summary>
      /// Нахождение минимального расстояния
      /// </summary>
      /// <param name="start">Начальная вершина графа</param>
      /// <param name="end">Конечная вершина граф</param>
      /// <returns>расстояние</returns>
      public double FindShortestDistance(string start, string end)
      {
        // Алгоритм Дейкстры.
        Dictionary<string, Description> info = new Dictionary<string, Description>(this.nodes.Count);
        foreach (string current in this.nodes.Keys)
          info.Add(current, new Description());
        info[start].Distance = 0;
 
        // Пока все вершины непосещенные.
        while (!info.Select(x => x.Value.Visited).Aggregate((x, y) => x & y))
        {
          // Находим непосещенную вершину с минимальной меткой.
          string current = info.Where(x => !x.Value.Visited
                  && x.Value.Distance == info.Where(y => !y.Value.Visited).Min(y => y.Value.Distance))
                  .First().Key;
          // Находим все непосещенные соседние вершины для текущей вершины.
          List<Link> neighbors = nodes[current].Links.Where(x => !info[x.Node].Visited).ToList();
          // Рассматриваем новую длину пути для каждой соседней вершины.
          foreach (Link link in neighbors)
          {
            double distance = info[current].Distance + link.Distance;
            if (info[link.Node].Distance > distance)
              info[link.Node].Distance = distance;
          }
          // Отмечаем текущую вершину как посещенная.
          info[current].Visited = true;
        }
        return info[end].Distance;
      }
 
      // список всех вершин 
      public string ShowNodes()
      {
        string result = string.Empty;
        foreach (var node in nodes)
        {
          result += node.Key + " ";
        }
        return result;
      }
 
    }
 
    static void Main(string[] args)
    {
      // Вершины графа
      string[] nodeNames = { "A", "B", "C", "D", "E", "F" };
      
      // Заполнение графа вершинами.
      Graph graph = new Graph();
      for (int i = 0; i < nodeNames.Length; i++)
        graph.AddNode(nodeNames[i]);
 
      // Создание у вершин связей.
      // Последнее значение говорит о том, что эта связь двунаправленная.
      graph.AddLinkToNode("A", "B", 7, false);
      graph.AddLinkToNode("A", "C", 9, false);
      graph.AddLinkToNode("A", "F", 14, false);
      graph.AddLinkToNode("B", "C", 10, false);
      graph.AddLinkToNode("B", "D", 15, false);
      graph.AddLinkToNode("C", "D", 11, false);
      graph.AddLinkToNode("C", "F", 2, false);
      graph.AddLinkToNode("D", "E", 6, false);
      graph.AddLinkToNode("E", "F", 9, false);
 
      string stationStart; // станция отправления
      string stationEnd; // станция назначения
 
      Console.WriteLine("Имеются следующие станции: {0}", graph.ShowNodes());
 
      Console.Write("Введите имя станции отправления: ");
      stationStart = Console.ReadLine();
 
      Console.Write("Введите имя станции назначения:  ");
      stationEnd = Console.ReadLine();
 
      double distance = graph.FindShortestDistance(stationStart, stationEnd);
      
      Console.WriteLine("Кратчайший маршрут от станции {0} до станции {1} = {2}", stationStart, stationEnd, distance);
 
      Console.ReadLine();
    }
  }
}