задание повышенной сложности

#include <cassert>
#include <vector>
#include <algorithm>
#include <iostream>
 
/****************************************************************************************/
 
struct E
{
  const wchar_t *what;
  E(const wchar_t *what) : what(what) {}
};
 
struct EIo : E
{
  EIo(const wchar_t *what) : E(what) {}
};
 
struct EBadData : E
{
  EBadData(const wchar_t *what) : E(what) {}
};
 
/****************************************************************************************/
 
struct Point
{
  int x, y;
};
 
typedef std::vector<Point> Points;
 
Points read_chain(unsigned n)
{
  Points chain(n);
 
  for (auto &p : chain)
    if (!(std::cin >> p.x >> p.y))
      throw EIo(L"Не могу прочитать координаты");
 
  if (!std::is_sorted(chain.begin(), chain.end(), 
         [](const Point &p1, const Point &p2) { return p1.x < p2.x; }))
    throw EBadData(L"Координаты не упорядочены по X");
 
  return chain;
}
 
void read_chains(Points &lo, Points &hi)
{
  int n = 0, m = 0;
  if (!(std::cin >> n >> m))
      throw EIo(L"Не могу прочитать количества вершин в ломаных");
 
  if (n < 2 || m < 2)
    throw EBadData(L"Недопустимые количества вершин в ломаных");
 
  hi = read_chain(n);
  lo = read_chain(m);
 
  assert(!lo.empty() && !hi.empty());
 
  if (lo.front().x != hi.front().x || lo.back().x != hi.back().x)
    throw EBadData(L"Не совпадают концевые X координаты ломаных");
}
 
/****************************************************************************************/
 
const double EPSILON = 0.001;
typedef std::vector<double> Distances; 
 
double vertical_distance(const Point &p, const Point &a, const Point &b)
{ // Знаковое вертикальное расстояние от точки 'p' до отрезка 'ab'. Положительно, если 
  // точка лежит над отрезком, отрицательно - если точка лежит под отрезком
  assert(a.x < b.x);
  assert(p.x >= a.x && p.x <= b.x);
  double y = a.y + (double) (p.x - a.x) * (b.y - a.y) / (b.x - a.x);
  return p.y - y;
}
 
Distances calculate_distances(const Points &lo, const Points &hi)
{ // Вычисляем вертикальное расстояние между ломаными для каждой уникальной X координаты 
  // вершин
  Distances distances;
 
  auto it_lo = lo.begin(), it_hi = hi.begin();
 
  while (it_lo != lo.end())
  {
    assert(it_hi != hi.end());
 
    double distance = 0;
 
    if (it_lo->x < it_hi->x)
    {
      assert(it_hi > hi.begin());
      distance = -vertical_distance(*it_lo, *std::prev(it_hi), *it_hi);
      ++it_lo;
    }
    else if (it_lo->x > it_hi->x)
    {
      assert(it_lo > lo.begin());
      distance = vertical_distance(*it_hi, *std::prev(it_lo), *it_lo);
      ++it_hi;
    }
    else
    {
      assert(it_lo->x == it_hi->x);
      distance = it_hi->y - it_lo->y;
      ++it_lo, ++it_hi;
    }
 
    if (distance < -EPSILON)
      throw EBadData(L"Ломаные изначально пересекаются");
 
    distances.push_back(std::max(distance, 0.));
  }
 
  assert(it_hi == hi.end());
 
  return distances;
}
 
unsigned count_lakes(const Distances &distances, double shift)
{ // Подсчитываем количество озер, которые получатся, если одну из ломаных пододвинуть к 
  // другой на растояние 'shift'
  assert(shift >= 0);
 
  unsigned n_lakes = 0;
  double prev_distance = 0;
 
  for (auto original_distance : distances)
  {
    double distance = original_distance - shift;
    assert(distance >= -EPSILON);
    distance = distance > EPSILON ? distance : 0;
 
    if (prev_distance == 0 && distance > 0)
      ++n_lakes;
 
    prev_distance = distance;
  }
 
  return n_lakes;
}
 
/****************************************************************************************/
 
int main()
{
   try
   {
     Points lo, hi;
     read_chains(lo, hi);
 
     Distances distances = calculate_distances(lo, hi);
 
     auto it_min = std::min_element(distances.begin(), distances.end());
     assert(it_min != distances.end());
     double min_distance = *it_min;
 
     unsigned n_lakes = count_lakes(distances, min_distance);
 
     std::wcout << n_lakes << std::endl;
   }
   catch (const EIo &e)
   {
     std::wcerr << L"Ошибка ввода-вывода: " << e.what << std::endl;
   }
   catch (const EBadData &e)
   {
     std::wcerr << L"Ошибка во входных данных: " << e.what << std::endl;
   }
}