Реализовать процесс исчезновения точек и найти последнюю точку в dev c++

#include <iostream>
#include <iterator>
#include "world.hpp"
 
World::Point task_algorithm(World::Area& area) {
    World::Point current = area.find_min(), next;
    while (area.quantity()) {
        next = area.find_near(current);
        next.weight += current.weight;
        current = next;
    }
    return current;
}
 
int main()
try {
    World::Area area(std::istream_iterator<World::Point>(std::cin),
            std::istream_iterator<World::Point>());
    std::cout << task_algorithm(area).name << std::endl;
} catch (World::InvalidUsing&) {
    std::cerr << "Invalid input" << std::endl;
}

#ifndef WORLD_H_
#define WORLD_H_
 
#include <stdexcept>
#include <string>
#include <vector>
 
namespace World {
 
struct Point {
    double x;
    double y;
    double weight;
    std::string name;
};
 
class Area {
    std::vector<Point> array;
    template <typename F>
    World::Point helper(F);
public:
    template <typename IterT>
    Area(IterT first, IterT last) :
        array(first, last) { }
    Point find_near(const Point&);
    Point find_min();
    std::vector<Point>::size_type quantity() noexcept {
        return array.size();
    }
};
 
struct InvalidUsing :
    std::logic_error {
    InvalidUsing(const std::string& s) :
        std::logic_error(s) { }
};
 
std::istream& operator>> (std::istream& in, Point& p);
 
}   // namespace World
 
#endif  // WORLD_H_

#include <algorithm>
#include <cmath>
#include <sstream>
#include <string>
 
#include "world.hpp"
 
template <typename F>
World::Point World::Area::helper(F comp) {
    if (!array.size()) {
        throw World::InvalidUsing("area_helper");
    }
    auto it = std::min_element(array.begin(), array.end(), comp);
    auto result = *it;
    array.erase(it);
    return result;
}
 
World::Point World::Area::find_near(const World::Point& p) {
    return helper([&p](const Point& a, const Point& b) {
                return std::hypot(a.x - p.x, a.y - p.y) < std::hypot(b.x - p.x, b.y - p.y);
            });
}
 
World::Point World::Area::find_min() {
    return helper([](const Point& a, const Point& b) { return a.weight < b.weight; });
}
 
std::istream& World::operator>> (std::istream& in, World::Point& p) {
    std::string str;
    std::getline(in, str);
    std::istringstream s(std::move(str));
    s.copyfmt(in);
    char ch;
    s >> p.x >> p.y >> p.weight >> ch;
    s.putback(ch);
    std::getline(s, p.name);
    in.copyfmt(s);
    return in;
}