Выкладываю реализацию алгоритма Дейкстры на С++

#include <iostream.h>
#include <conio.h>
#include <windows.h>
#include<iomanip.h>
    
char NEWT[256];
char*RUS(char*TEXT) {
CharToOem(TEXT,NEWT);
return NEWT;}
 
int v;
int main()
{   int i,j;
   int infinity=1000;                     // Бесконечность
                                          // Количество вершин в графе
   int VES[100][100];                         // Матрица весов графа
 
   int x[100];                            //Массив, содержащий единицы и нули для каждой вершины,
                                          // x[i]=0 - еще не найден кратчайший путь в i-ю вершину,
                                          // x[i]=1 - кратчайший путь в i-ю вершину уже найден
   
   int DlinaPuti[100];                    //t[i] - длина кратчайшего пути от вершины s в i
 
   int PredVertex[100];                   //h[i] - вершина, предшествующая i-й вершине
                                          //на кратчайшем пути
   int VERTEX;
   int p;                         
cout<<RUS("Ввести количество вершин в графе ")<<endl;
cin>>VERTEX;p= VERTEX;                    //Число вершин в графе
cout<<RUS("Заполните матрицу весов графа ")<<endl;      // Матрица весов графа
cout<<setw(4);
for (i=0;i<VERTEX;i++)
cout<<RUS("|x")<<i+1;
cout<<endl;
 
for(i=0;i<VERTEX;i++)
{cout<<RUS("X")<<i+1<<'|';
for(j=0;j<VERTEX;j++)
cin>>VES[i][j];}
 
                                        // Будем искать путь из вершины s в вершину g по циклу
   int start;                           // Номер исходной вершины
   int end;                             // Номер конечной вершины
N: cout<<RUS("Введите стартовую вершину: "); // Номер может изменяться от 0 до p-1
   cin>>start;
   if (start>(p-1) && start<0) {cout<<RUS("Нет такой вершины повторите ввод...")<<endl; goto N; } // на случай неверных данных
   start=start-1;                       //так как массив начинается с 0 отнимаем от вводимой цифры 1
   for (int prosto=0;prosto<VERTEX;prosto++)
   {end=prosto;                         //цикл прогоняет алгоритм Флойда p-ое количество раз преврашая его в алгоритм Дейкстры  
   if (end==start) continue;            //исключаем просчет растояния между одной и той же точкой
   else
   {
 
                                         // Инициализируем начальные значения массивов
   int u;                                // Счетчик вершин
   for (u=0;u<p;u++)
   {
       DlinaPuti[u]=infinity;                    //Сначала все кратчайшие пути из s в i 
                                         //равны бесконечности
      x[u]=0;                            // и нет кратчайшего пути ни для одной вершины
   }
   PredVertex[start]=0;                     // s - начало пути, поэтому этой вершине ничего не предшествует
   DlinaPuti[start]=0;                      // Кратчайший путь из s в s равен 0
   x[start]=1;                              // Для вершины s найден кратчайший путь
   v=start;                                 // Делаем s текущей вершиной
   
   while(1)
   {
                                        // Перебираем все вершины, смежные v, и ищем для них кратчайший путь
      for(u=0;u<p;u++)
      {
         if(VES[v][u]==0)continue;      // Вершины u и v несмежные
         if(x[u]==0 && DlinaPuti[u]>DlinaPuti[v]+VES[v][u]) //Если для вершины 'u' еще не 
                                        //найден кратчайший путь
                                        // и новый путь в 'u' короче чем 
                                        //старый, то
         {
            DlinaPuti[u]=DlinaPuti[v]+VES[v][u];            //запоминаем более короткую длину пути в
                                        //массив t[и]
           PredVertex[u]=v;                     //запоминаем, что v->u часть кратчайшего 
                                        //пути из s->u
         }
      }
 
                                         // Ищем из всех длин некратчайших путей самый короткий
      int w=infinity;                   // Для поиска самого короткого пути
      v=-1;                             // В конце поиска v - вершина, в которую будет 
                                        // найден новый кратчайший путь. Она станет 
                                        // текущей вершиной
      for(u=0;u<p;u++)                  // Перебираем все вершины.
      {
         if(x[u]==0 && DlinaPuti[u]<w)           // Если для вершины не найден кратчайший 
                                         // путь и если длина пути в вершину 'u' меньше
                                         // уже найденной, то
         {
            v=u;                         // текущей вершиной становится 'u'-я вершина
            w= DlinaPuti[u];
         }
      }
      if(v==-1)
      {
         cout<<RUS("Нет пути из вершины ")<<start+1;cout<<RUS(" в вершину ")<<end+1<<"."<<endl;
         break;
      }
      if(v==end)                            // Найден кратчайший путь,
      {                                 // выводим его
         cout<<RUS("Кратчайший путь из вершины ")<<start+1;cout<<RUS(" в вершину ")<<end+1<<":";
       u=end;
       while(u!=start)
         {
            cout<<" "<<u+1;
            u=PredVertex[u];
         }
         cout<<" "<<start+1<<RUS(". Длина пути - ")<< DlinaPuti[end];cout<<endl;
       break;
      }
      x[v]=1;
   }}}
   
return 0;}

// прототипы
void infile (int **VES,int num); //вводим из файла
int size();                            //вводим размер матрицы
 
//в main
 
n=size();
VES=new int *[n];
for (i=0;i<n;i++)                                    
VES[i]=new int[n];
infile(VES,n);
 
// main кончается
int size()
{   int n;
    ifstream in;//открываем поток in для ввода данных из файла
    in.open("n.txt",ios::nocreate);//связываем поток ввода in с файлом input.txt, если этот файл существует
    if(in.fail()) {
        cout<<RUS("Файла не существует...\n");
        exit(1);}//если файл не существует, на экран выводится сообщение об ошибке и программа закрываетс
    in>>n;  //вводим из файла n.txt данные в переменную 
    in.close();//закрываем поток ввода из файла in
    return n;//возвращаем полученное значение n в главную функцию
}
 
//////////////////////////////////////////////////////////////////////////////////
 
void infile (int **VES, int n){
    ifstream in;                        //открываем поток in для ввода данных из файла}
    in.open("input.txt",ios::nocreate);//связываем поток ввода in с файлом input.txt, если этот файл существует
    
    if(in.fail()) {
        cout<<RUS("Файла не существует...\n");     
        exit(1);}//если файл не существует, на экран выводится сообщение об ошибке и программа закрывается
    for (int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        in>>VES[i][j];//вводим из файла "input.txt" массив VES
    in.close();//закрываем поток ввода из файла in
}

#include <vector>
#include <iostream>
using namespace std;
 
#define im 2000000000
 
int main()
{
    int f, n, s;
    cin >> n;
    cin >> s;
    cin >> f;
    vector <bool> used;
    vector <int> distance;
    vector <int> parents(n);
    vector <vector <int>> g(n);
    
    used.assign(n, 0);
    distance.assign(n, im);
    distance[s-1] = 0;
    for(int i=0; i < n; i++)
        g[i].assign(n, 0);
    
    for(int i=0; i < n; i++)
        for(int j=0; j < n; j++)
            cin >> g[i][j];
    
    for(int i=0; i < n; i++)
    {
        int v = -1;
        for(int j=0; j < n; j++)
            if(used[j] == false && (v == -1 || distance[j] < distance[v]))
                v = j;
        used[v] = true;
        for(int j=0; j < n; j++)
            if(g[v][j] != -1 && distance[v]+g[v][j] < distance[j])
            {
                parents[j] = v;
                distance[j] = distance[v]+g[v][j];
            }
    }
    if(distance[f-1] != im)
        cout << distance[f-1] << endl;
    else
        cout << -1 << endl;
    //system("pause");
    return 0;
}

void Dijkstra(int GR[V][V], int st)
{
int distance[V], count, index, i, u, m=st+1;
bool visited[V];
for (i=0; i<V; i++)
{
distance[i]=INT_MAX; visited[i]=false;
}
distance[st]=0;
for (count=0; count<V-1; count++)
{
int min=INT_MAX;
for (i=0; i<V; i++)
if (!visited[i] && distance[i]<=min)
{
min=distance[i]; index=i;
}
u=index;
visited[u]=true;
for (i=0; i<V; i++)
if (!visited[i] && GR[u][i] && distance[u]!=INT_MAX &&
distance[u]+GR[u][i]<distance[i])
distance[i]=distance[u]+GR[u][i];
}
cout<<"Стоимость пути из начальной вершины до остальных:\t\n";
for (i=0; i<V; i++) if (distance[i]!=INT_MAX)
cout<<m<<" > "<<i+1<<" = "<<distance[i]<<endl;
else cout<<m<<" > "<<i+1<<" = "<<"маршрут недоступен"<<endl;
}

#include <iostream>
#include <string.h>
#define MAX 400
#define INF 1061109568
using namespace std;
int mass[MAX][MAX], used[MAX], d[MAX], v, n;
void relax(int v, int to){
    if (d[to] > d[v]+mass[v][to]){
        d[to] = d[v]+mass[v][to];
    }
}
int findmin(){  
    int v, min = INF;
    for (int i=1; i<=n; i++){
        if (!used[i] && d[i]<min){
            min = d[i];
            v = i;
        }
    }
    return v;
}
int main(){
    int id;
    cin>>n>>id;
    int a, b, c;
    memset(mass, 63, sizeof(mass));
    memset(d, 63, sizeof(d));
    memset(used, 0, sizeof(used));
    d[id] = 0;
    while (scanf("%d %d %d", &a, &b, &c) == 3){
        mass[a][b] = c;
    }
    for (int i=1; i<n; i++){
        v = findmin();
        for (int to=1; to<=n; to++){
            if (!used[to]){
                relax(v, to);
            }
        }
        used[v] = 1;
    }
    if (mass[n][id] != 1061109568){
        cout<<mass[n][id];
    }
    else{
        cout<<-1;
    }
}