Матрица смежности, ввод через рёбра

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
int n,m;
int s[10][10];
bool mf[10];
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button3Click(TObject *Sender)
{
int i;
n=StrToInt(Edit1->Text);
StringGrid1->RowCount=n;
StringGrid1->ColCount=n;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{ int i,j;
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
     s[i][j]=StrToInt(StringGrid1->Cells[j-1][i-1]);
}
//---------------------------------------------------------------------------
void poisk(int n,int m)
{int i_st, i_end, i;
 int Q[10];
for (int i=1;i<=n;i++)
mf[i]=false;
mf[m]=true;
Q[1]=m;
 i_st=1;
 i_end=2;
while (i_st<i_end)
  {
  for (int i=1;i<=n;i++)
  if ((s[Q[i_st]][i]==1) && (mf[i]==false))
  {
    Q[i_end]=i;
    mf[i]=true;
    i_end+=1;
  }
  i_st+=1;
  }
}
//---------------------------------------------------------------------------
void vivod(int n,TStringGrid *p)
{int i;
 bool fl;
 fl=false;
for (int i=1;i<=n;i++)
 if (mf[i]==true)
 {
 p->Cells[i-1][0]=IntToStr(i);
 fl=true;}
 
 if (!fl)
 ShowMessage("Íåò äîñòåæèìûõ âåðøèí");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
m=StrToInt(Edit2->Text);
poisk(n,m);
vivod(n,StringGrid2);
}
//---------------------------------------------------------------------------

#include <iostream>
#include <clocale>
#include <vector>
using namespace std; // используем пространство имен std по-умолчанию
 
int main()
{
    setlocale(LC_ALL, "Russian");
    // здесь задаете размерность матрицы
    const int N = 10;
    // --------------------------объявление переменных--------------------------
    bool FIKS[N]; //false - вершина не рассмотрена, true - рассмотрена
    int MIN_WEG[N]; // текущие кратчайшие расстояния до соответствующей вершины
    int VON_PUNKT[N]; // номера вершин
    int DUG[N][N]; // матрица расстояний (смежности)
    int start, end; // номер стартовой  и конечной вершин
 
    // ------------------------------инициализация------------------------------
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            // расстояние между вершинами это очень большое число, т.о. мы
            // показываем, что они не связанны
            DUG[i][j] = 999;
    int n; // количество ребер (связей)
    cout << "Введите количество ребер графа: ";
    cin >> n;
    int from, to, length; // переменные для задания матрицы расстояний
    for (int i=0; i < n; i++)
    {
        cout << "Введите вершину (откуда): ";
        cin >> from;
        cout << "Введите вершину (куда): ";
        cin >> to;
        cout << "Введите расстояние: ";
        cin >> length;
        if (from < 0 || from >= N || to < 0 || to >= N || to == from ||
            length < 0)
        {
            cout << "Ошибка ввода\n";
            i--;
        }
        else // заносим расстояние в матрицу
            DUG[from][to] = DUG[to][from] = length;
    }
 
    cout << "Введите начальную вершину: ";
    do cin >> start; while (start < 0 || start >= N); // проверка введ. значений
    cout << "Введите конечную вершину: ";
    do cin >> end; while (end < 0 || end >= N || end == start); // проверка
    for (int i = 0; i < N; i++)
    {
        FIKS[i] = false; // все вершины непосещенные
        VON_PUNKT[i] = start;
    }
 
    // перенести i-ую строчку матрицы DUG в массив MIN_WEG
    for (int i = 0; i < N; i++)
        // мин. расстояния равны текущим до начальной вершины
        MIN_WEG[i] = DUG[i][start];
    FIKS[start] = true; // начальная вершина посещена
    VON_PUNKT[start] = 0; // находимся в текущей вершине
 
    // --------------------------------общий шаг--------------------------------
    bool yes = false; // флаг, установлен ли минимум
    int min = 0, min_index = 0;
    for (int k = 0; k < N; k++)
    {
        // находим минимум
        yes = false;
        for (int i = 0; i < N; i++)
            if (FIKS[i] == false) // если вершина не посещена
            {
                if (yes == false) // если минимум не установлен
                {
                    // устанавливаем его (равен тек. минимальному расстоянию)
                    min = MIN_WEG[i];
                    min_index = i;
                    yes = true;
                }
                else
                if (MIN_WEG[i] < min) // если кратчайшее расстояние меньше мин.
                {
                    // минимум равен текущему кратчайшему расстоянию
                    min = MIN_WEG[i];
                    min_index = i; // индекс минимума равен i
                }
            }
        FIKS[min_index] = true; // вершина с мин. расстоянием посещена
        for (int j = 0; j < N ; j++)
        // если есть более короткий путь, то изменяем след. вершину на ту,
        // которую следовало бы посетить, чтобы срезать
            if (MIN_WEG[j] > MIN_WEG[min_index] + DUG[min_index][j])
            {
                MIN_WEG[j] = MIN_WEG[min_index] + DUG[min_index][j];
                VON_PUNKT[j] = min_index;
            }
    }
 
    // ------------------------------выдача ответа------------------------------
    vector<int> v; // вспомагательный вектор для выдачи ответа
    // новая вершина равна переходу из текущей пока не пришли в начальную
    for(int z = end; z != start; z = VON_PUNKT[z])
        // заносим в вектор вершины, пройденные от конечной до начальной
        v.push_back(z);
    v.push_back(start); // записываем начальную вершину
    // двигаемся с конца вектора до начала, выводя содержимое на экран
    for (vector<int>::reverse_iterator cur = v.rbegin(); cur != v.rend(); cur++)
        cout << *cur << " ";
    return 0;
}