C# Есть код алгоритма Дейкстры на C++, как его можно преобразовать на язык C#?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            const int N = 1000; // количество вершин
 
             // матрица смежности: adj_matrix[i][j] == true,
             // если между вершинами i и j существует ребро
             bool adj_matrix = [N][N];
 
             int  cost = new int [N][N]; // веса рёбер
 
              /*********************************************/
 
               /*********Результаты работы алгоритма*********/
 
               int dist = new int [N]; // расстояния от заданной вершины
 
               int  parent = new int [N]; // из какой вершины пришли;
                // служит для восстановления маршрута
            void dijkstra(int start);
        }
 
        /*********************************************/
 
        // start -- вершина, от которой считаем расстояния
        public static void dijkstra(int start)
                 {
                  // in_tree[i] == true, если для вершины i
                   // уже посчитано минимальное расстояние
                    bool in_tree[N] = {false};
 
                    for(int i = 0; i < N; i++)
                    dist[i] = INT_MAX; // машинная бесконечность,
                    // т. е. любое расстояние будет меньше данного
 
                  dist[start] = 0; // понятно почему, не так ли? ;)
 
                  int cur = start; // вершина, с которой работаем
 
                  // пока есть необработанная вершина
                 while(!in_tree[cur])
                  {
                    in_tree[cur] = true;
 
                     for(int i = 0; i < N; i++)
                   {
                      // если между cur и i есть ребро
                   if(adj_matrix[cur][i])
                     {
            // считаем расстояние до вершины i:
            // расстояние до cur + вес ребра
            int d = dist[cur] + cost[cur][i];
            // если оно меньше, чем уже записанное
            if(d < dist[i])
            {
               dist[i]   = d;   // обновляем его
               parent[i] = cur; // и "родителя"
            }
         }
      }
 
      // ищем нерассмотренную вершину
      // с минимальным расстоянием
      int min_dist = INT_MAX;
      for(int i = 0; i < N; i++)
      {
         if(!in_tree[i] && dist[i] < min_dist)
         {
            cur      = i;
            min_dist = dist[i];
         }
      }
   }
 
   // Теперь:
   // в dist[i] минимальное расстояние от start до i
   // в parent[i] вершина, из которой лежит оптимальный путь в i
}
    }
}