Дан набор координат точек. Начиная с первой, проложить кратчайший маршрут....

/////////////////////////////////////////////////////////////////////////////
//Дан набор координат точек. Начиная с первой, проложить кратчайший маршрут, 
//который позволил бы посетить их все по одному разу.
/////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <complex>
#include <iostream>
#include <numeric>
#include <vector>
 
typedef double                 T_coord;
typedef std::complex<T_coord>  T_point;
typedef T_coord                T_dist;
typedef T_point                T_shift;
typedef std::vector<T_shift>   T_shifts;
/////////////////////////////////////////////////////////////////////////////
struct T_numbered_point : T_point
{
    //-----------------------------------------------------------------------
    int  num_;
    //-----------------------------------------------------------------------
    T_numbered_point
        (
            T_point  point,
            int      num           
        ) 
        : T_point(point), 
          num_   (num)
    {}
    //-----------------------------------------------------------------------
    T_shift operator- (const T_numbered_point&  np)//Для алгоритма std::adjacent_difference
    {        
        return T_point(*this) - np;                
    }
    //-----------------------------------------------------------------------        
    bool operator < (const T_numbered_point&  np)//Для алгоритма  std::next_permutation.
    {
        return num_ < np.num_;
    }
    //-----------------------------------------------------------------------    
};
/////////////////////////////////////////////////////////////////////////////
typedef std::vector<T_numbered_point>   T_numbered_points;
/////////////////////////////////////////////////////////////////////////////
T_numbered_points  input_numbered_points()
{
    const int  POINTS_TOTAL_MIN = 2;
    int        points_total;    
    do
    {
        std::cout << "Введите количество точек >= "
                  << POINTS_TOTAL_MIN   
                  << ": ";
        std::cin >> points_total;
    }while(points_total < POINTS_TOTAL_MIN);
    
    std::cout << "Введите координаты "
              << points_total
              << " различных точек:"
              << std::endl;
    
    T_numbered_points  numbered_points;
    
    while(   numbered_points.empty()
          || numbered_points.size() != points_total)
    {        
        int point_num = numbered_points.size() + 1;
        std::cout << "X" 
                  << point_num
                  << " = ";
        int x;
        std::cin >> x;
        std::cout << "Y" 
                  << point_num
                  << " = ";
        int y;
        std::cin >> y;                
        T_numbered_point  numbered_point(T_point(x, y), point_num);
        if( !numbered_points.empty()
            && std::find(numbered_points.begin(), 
                         numbered_points.end(), 
                         numbered_point) != numbered_points.end() )
        {
             std::cout << "Такая точка уже есть."
                       << std::endl;       
        }
        else
        {
            numbered_points.push_back(numbered_point);
        }
        std::cout << std::endl;
    }    
    return  numbered_points;
}
/////////////////////////////////////////////////////////////////////////////
void print_optim_posledov_obchoda(const T_numbered_points&  numbered_points)
{    
    T_numbered_points  temp_numbered_points(numbered_points);    
    T_shifts           shifts(numbered_points.size());
    T_numbered_points  numbered_points_v_optim_posledov;
    T_dist             dist_sum_min;
    bool               dist_sum_min_is_init = false;
    do
    {
        std::adjacent_difference(temp_numbered_points.begin(), 
                                 temp_numbered_points.end(), shifts.begin());
 
        struct T_dist_sum
        {
            T_dist operator() (const T_shift& p1, const T_shift& p2)
            {
                return abs(p1) + abs(p2);
            }
        };   
 
        T_dist  dist_sum = std::accumulate(shifts.begin() + 1, shifts.end(), 
                                           T_dist(), T_dist_sum());
        if(!dist_sum_min_is_init
           || dist_sum < dist_sum_min)
        {
            dist_sum_min                      = dist_sum;
            dist_sum_min_is_init              = true;
            numbered_points_v_optim_posledov  = temp_numbered_points;
        }
    }while
         ( 
             std::next_permutation
                 (
                     temp_numbered_points.begin() + 1, 
                     temp_numbered_points.end()                     
                 ) 
         );
 
    struct T_print_point_num
    {
        void operator() (T_numbered_points::value_type  numbered_point)
        {
            std::cout << numbered_point.num_
                      << ' ';
        }
    };
 
    std::cout << "Минимальный путь обхода "
              << numbered_points.size()
              << " заданных точек в последовательности "
              << std::endl;
    
    std::for_each(numbered_points_v_optim_posledov.begin(),
                  numbered_points_v_optim_posledov.end(), T_print_point_num());    
 
    std::cout << std::endl
              << "равен "
              << dist_sum_min
              << "."
              << std::endl;
}
/////////////////////////////////////////////////////////////////////////////
 
int main()
{    
    std::locale::global(std::locale(""));
    T_numbered_points  numbered_points = input_numbered_points();
    print_optim_posledov_obchoda(numbered_points);   
    return 0;
}

#include <iostream.h>
#include <math.h>
 
 
const int KolT=5;//количество точек
///////////////////////////////////
void main()
{
    double X[]={1,2,3,4,5}, Y[]={1,1,1,1,1},//координаты точек
           MasDl[KolT][KolT],//массив для хранения матрицы длин
           DlToch[KolT],//массив куда копируются длины от текущей точки до всех остальных
           Dlin, Dt, 
           NToch[KolT];//массив хранящий последовательность номеров точек
    int j=0,i=0,k=0;
    unsigned long int Max;// бесконечно большое число
    bool IndT[KolT];// массив индикатор прошли точку 1 или нет 0
//////////////////показываем какие у нас координаты/////////////////
    cout << "Vvedennie coord:\n";
        for(i=0; i<KolT; i++)
        {
            cout <<"Tochka "<<i+1<<": X="<<X[i]<<"Y="<<Y[i]<<"\n";
            for (j=0;j<KolT;j++)
            {
            Dlin=sqrt(((X[i]-X[j])*(X[i]-X[j]))+((Y[i]-Y[j])*(Y[i]-Y[j])));//находим расстояния между точками
 
                if(Dlin!=0)// если не 0 записываем в массив матрицы длин
                {
                MasDl[i][j]=Dlin;
                }
                else // иначе приравниваем длинну к бесконечно большой
                {
                MasDl[i][j]=Max;
                }
 
            }
        }
        cout<<"\n";
/////////////////проверка матрицы длин///////////////
cout<<"Matrica Dlin megdu tochkami\n";
 
    for (i=0;i<KolT;i++)
    {
        for (j=0;j<KolT;j++)
        {
        
        cout << MasDl[i][j]<<"   ";
        }
    cout<<"\n";
    }
    cout<<"\n";
/////////////////проверка массива индикатора и обнуление его///////////////
    cout<<"Massiv Indikator"<<"\n";
    for (i=0;i<KolT;i++)
    {   
        IndT[i]=0;
        cout << IndT[i]<<" ";
    }
    cout<<"\n";
////////////////////////////////
////////////////подготовка данных////////////////
    for (i=0;i<KolT;i++)
    {
        NToch[i]=i;cout<<"Tochka:"<<NToch[i]<<" ";// номер  точки
        IndT[i]=0;cout<<"Ee indikator:"<<IndT[i]<<" ";//обнуление (еще раз ну это можно удалить)
        DlToch[i]=MasDl[i][0];cout<<"Perv znac:"<<DlToch[i]<<" \n";//первая длинна текущей точки
    }
////////////////Поиск кратчайшего пути////////////////
    NToch[0]=0;//задаем начало
    IndT[0]=1;
    Dt=Max;// минимальная длина делаем ее большой
    cout<< "Posled tochek:";
    for(i=0;i<(KolT-1);i++)
    {
        Dt=Max;
        for (j=0;j<KolT;j++)
        {
        if((IndT[j]==0)&&(Dt>DlToch[j]))// сравниваем и ищем минимальную длинну для точки
        {
            Dt=DlToch[j];
            k=j;//запоминаем близ лежащую точку
        }
 
        IndT[k]=1;// меняем индикатор длижней точки на пройденную
        if((IndT[j]==0)&&(DlToch[j]>(DlToch[k]+MasDl[k][j]))) //еще раз смотрим массив на наличие блжайшей точки и сравниваем расстояние уже с найденной
        {
            DlToch[j]=DlToch[k]+MasDl[k][j];
            NToch[j]=k;//запоминаем номер
        }
        }
        cout<<NToch[k]<<" "; //вывод точек как они связываются
    }
 
    
    cout<<"\nMinimalnoe rasstoyanie: "<<Dt<<"\n";// вывод мин.расстояния
////////////////////////////////
    cout<<"Massiv Indikator"<<"\n";
    for (i=0;i<KolT;i++)
    {   
        cout << IndT[i]<<" ";//проверим индикатор все ли точки прошли
    }
    cout<<"\n";
////////////////////////////////
}

#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
 
using namespace std;
 
ifstream fin("input.txt");
ofstream fout("output.txt");
 
struct point
{
    int x, y;
    bool operator < (const point &p)
    {
        return x < p.x || x == p.x && y < p.y;
    }
};
 
#define sqr(x) ((x)*(x))
 
double dist(const point &a, const point &b)
{
    return sqrt(double(sqr(a.x-b.x) + sqr(a.y-b.y)));
}
 
int main()
{
    int n;
    fin >> n;
    vector<point> v(n);
    for(int i = 0; i < n; i++)
        fin >> v[i].x >> v[i].y;
    sort(v.begin(),v.end());
    vector<point> ans(n);
    double mi = 987654321;
    do {
        double len = 0;
        for(int i = 0; i < n-1; i++)
            len += dist(v[i],v[i+1]);
        if(len < mi)
        {
            mi = len;
            ans = v;
        }
    }while(next_permutation(v.begin(),v.end()));
    for(int i = 0; i < n; i++)
        fout << ans[i].x << ' ' << ans[i].y << endl;
}

int n, i;

for(i = 0; i < n; i++)

return 0;