Программа нахождении минимально удалённой точки от других точек

#include<math.h>
#include<stdio.h>
#include<conio.h>
struct tchk
{
    int x, y;
};
float rast(tchk a, tchk b)
{
    float x, y, d;
    x = b.x - a.x;
    y = b.y - a.y;
    d = sqrt(x*x + y*y);
    return d;
}
int main()
{

#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
 
template <class T> T sqr(T a) { return a * a; }
 
class Point 
{
    float x;
    float y;
    
public:
    Point(): x(0), y(0)
    {
        
    }
    
    friend std::istream& operator >> (std::istream& stream, Point& p)
    {
        stream >> p.x;
        stream >> p.y;
        return stream;
    }
    
    friend std::ostream& operator << (std::ostream& stream, const Point& p)
    {
        stream << '(' << p.x << "; " << p.y << ')';
        return stream;
    }
    
    friend float distanceTo(Point p1, Point p2)
    {
        return sqrt(sqr(p1.x - p2.x) + sqr(p1.y - p2.y));
    }
};
 
int main()
{
    typedef std::vector<Point> VecPoint;
    typedef VecPoint::iterator VecPointItr;
    typedef std::vector<float> VecFloat;
    const int size = 10;
    std::vector<Point> points(size);
    for(VecPointItr it = points.begin(); it != points.end(); ++it)
        std::cin >> *it;
    VecFloat d;
    for(int i = 0; i < size; ++i)
    {
        float sum = 0;
        for(int j = 0; j < i; ++j)
            sum += distanceTo(points.at(i), points.at(j));
        for(int j = i + 1; j < size; ++j)
            sum += distanceTo(points.at(i), points.at(j));
        d.push_back(sum);
    }
    int pos = std::min_element(d.begin(), d.end()) - d.begin();
    std::cout << "min #" << pos << ", = " << points.at(pos) << std::endl;
    return 0;
}

#include <cmath>
#include <ctime>
#include <cstdlib>
#include <iostream>
 
class Point {
 public:
  Point() : x_(0.), y_(0.) {}
  Point(float x, float y) : x_(x), y_(y) {}
  float getX() const { return x_; }
  float getY() const { return y_; }
  float getDistanceTo(const Point &point) const {
    return sqrt(pow(point.getX() - getX(), 2.) +
      pow(point.getY() - getY(), 2.));
  }
  static Point randomPoint() {
    return Point((rand() % 1000) / 100., (rand() % 1000) / 100.);
  }
 private:
  float x_, y_;
};
 
std::ostream &operator<<(std::ostream &stream, const Point &point) {
  return stream << "[" << point.getX() << ":" << point.getY() << "]";
}
 
float sumOfDistances(size_t id, const Point *points, size_t size) {
  float sum = 0.;
  for (size_t i = 0; i < size; ++i)
    if (i != id)
      sum += points[id].getDistanceTo(points[i]);
  return sum;
}
 
int main(int argc, char *argv[]) {
  srand(time(0));
  size_t numberOfPoints = 10;
  Point *points = new Point[numberOfPoints]();
 
  std::cout << "Points: ";
  for (size_t i = 1; i < numberOfPoints; ++i)
    std::cout << (points[i] = Point::randomPoint()) << " ";
  std::cout << std::endl;
 
  size_t minPointId = 0;
  float minPointDistanceSum = sumOfDistances(minPointId, points, numberOfPoints);
  for (size_t i = 1; i < numberOfPoints; ++i) {
    float currentPointDistanceSum = sumOfDistances(i, points, numberOfPoints);
    if (currentPointDistanceSum < minPointDistanceSum) {
      minPointDistanceSum = currentPointDistanceSum;
      minPointId = i;
    }
  }
 
  std::cout << "Closest point: " << points[minPointId] << std::endl <<
    "Sum of distances: " << minPointDistanceSum << std::endl;
  
  delete [] points;
  return 0;
}