Problem p00738 (C++) — buggy submission, verdict: Time Limit Exceeded

#ifndef ___Geometry_Library
#define ___Geometry_Library

// ------ Includes ------ //
#include <algorithm>
#include <cmath>
#include <complex>
#include <utility>
#include <vector>

// ------ Defines ------ //
typedef long double GType;
typedef std::complex<GType> Point;
typedef std::pair<Point, Point> Segment;

// ------ Constants ------ //
const GType EPS = 1.0e-10L;

// ------ Functions Level 1 ------ //
GType dot(const Point &p1, const Point &p2) {
  return (std::conj(p1) * p2).real();
}
GType cross(const Point &p1, const Point &p2) {
  return (std::conj(p1) * p2).imag();
}
int ccw(const Point &p1, const Point &p2, const Point &p3) {
  Point v1 = p2 - p1, v2 = p3 - p1;
  if (cross(v1, v2) > EPS)
    return +1;
  if (cross(v1, v2) < -EPS)
    return -1;
  if (dot(v1, v2) < -EPS)
    return +2;
  if (std::norm(v1) < std::norm(v2))
    return -2;
  return 0;
}

// ------ Functions Level 2 ------ //
bool intersect(const Segment &s1, const Point &p1, bool segflag) {
  if (!segflag)
    return std::abs(cross(s1.second - p1, s1.first - p1)) < EPS;
  return (std::abs(s1.first - p1) + std::abs(s1.second - p1) -
          std::abs(s1.second - s1.first)) < EPS;
}
bool intersect(const Segment &s1, const Segment &s2, bool segflag) {
  if (!segflag)
    return cross(s1.second - s1.first, s2.first - s1.first) *
               cross(s1.second - s1.first, s2.second - s1.first) <
           EPS;
  return (ccw(s1.first, s1.second, s2.first) *
                  ccw(s1.first, s1.second, s2.second) <=
              0 &&
          ccw(s2.first, s2.second, s1.first) *
                  ccw(s2.first, s2.second, s1.second) <=
              0);
}
Point projection(const Segment &s1, const Point &p1) {
  GType mul =
      dot(p1 - s1.first, s1.first - s1.second) / norm(s1.first - s1.second);
  return s1.first + (s1.first - s1.second) * mul;
}
Point reflection(const Segment &s1, const Point &p1) {
  return p1 + (projection(s1, p1) - p1) * (GType)(2);
}
GType distance(const Point &p1, const Point &p2) { return std::abs(p2 - p1); }
GType distance(const Segment &s1, const Point &p1, bool segflag) {
  if (!segflag)
    return std::abs(p1 - projection(s1, p1));
  const Point p2 = projection(s1, p1);
  if (intersect(s1, p2, true))
    return std::abs(p2 - p1);
  return std::min(std::abs(s1.first - p1), std::abs(s1.second - p1));
}
GType distance(const Segment &s1, const Segment &s2, bool segflag) {
  if (intersect(s1, s2, segflag))
    return 0;
  if (!segflag)
    return std::min(distance(s1, s2.first, false),
                    distance(s1, s2.second, false));
  return std::min({distance(s1, s2.first, true), distance(s1, s2.second, true),
                   distance(s2, s1.first, true),
                   distance(s2, s1.second, true)});
}

#endif

#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int n, sx, sy, ex, ey, xa[55], ya[55], xb[55], yb[55], h[55];
int main() {
  while (cin >> n, n) {
    cin >> sx >> sy >> ex >> ey;
    for (int i = 0; i < n; i++)
      cin >> xa[i] >> ya[i] >> xb[i] >> yb[i] >> h[i];
    vector<vector<Point>> v(n);
    for (int i = 0; i < n; i++) {
      v[i] = {Point(xa[i], ya[i]), Point(xa[i], yb[i]), Point(xb[i], yb[i]),
              Point(xb[i], ya[i])};
    }
    bool flag = true;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < 4; j++) {
        if (intersect(Segment(Point(sx, sy), Point(ex, ey)),
                      Segment(v[i][j], v[i][(j + 1) & 3]), true))
          flag = false;
      }
      if (xa[i] <= sx && sx <= xb[i] && ya[i] <= sy && sy <= yb[i])
        flag = false;
      if (xa[i] <= ex && ex <= xb[i] && ya[i] <= sy && sy <= yb[i])
        flag = false;
    }
    if (!flag)
      cout << 0 << endl;
    else {
      double ret = 1.0e+9;
      for (int i = 0; i < n; i++) {
        for (int j = 0; j < 4; j++) {
          double dist = distance(Segment(Point(sx, sy), Point(ex, ey)),
                                 Segment(v[i][j], v[i][(j + 1) & 3]), true);
          double r = 0.5 * (h[i] + dist * dist / h[i]);
          if (h[i] >= dist)
            r = dist;
          ret = min(ret, r);
        }
      }
      cout << fixed << setprecision(15) << ret << endl;
    }
  }
  return 0;
}

Error: TLE

Fixed submission:

#ifndef ___Geometry_Library
#define ___Geometry_Library

// ------ Includes ------ //
#include <algorithm>
#include <cmath>
#include <complex>
#include <utility>
#include <vector>

// ------ Defines ------ //
typedef long double GType;
typedef std::complex<GType> Point;
typedef std::pair<Point, Point> Segment;

// ------ Constants ------ //
const GType EPS = 1.0e-10L;

// ------ Functions Level 1 ------ //
GType dot(const Point &p1, const Point &p2) {
  return (std::conj(p1) * p2).real();
}
GType cross(const Point &p1, const Point &p2) {
  return (std::conj(p1) * p2).imag();
}
int ccw(const Point &p1, const Point &p2, const Point &p3) {
  Point v1 = p2 - p1, v2 = p3 - p1;
  if (cross(v1, v2) > EPS)
    return +1;
  if (cross(v1, v2) < -EPS)
    return -1;
  if (dot(v1, v2) < -EPS)
    return +2;
  if (std::norm(v1) < std::norm(v2))
    return -2;
  return 0;
}

// ------ Functions Level 2 ------ //
bool intersect(const Segment &s1, const Point &p1, bool segflag) {
  if (!segflag)
    return std::abs(cross(s1.second - p1, s1.first - p1)) < EPS;
  return (std::abs(s1.first - p1) + std::abs(s1.second - p1) -
          std::abs(s1.second - s1.first)) < EPS;
}
bool intersect(const Segment &s1, const Segment &s2, bool segflag) {
  if (!segflag)
    return cross(s1.second - s1.first, s2.first - s1.first) *
               cross(s1.second - s1.first, s2.second - s1.first) <
           EPS;
  return (ccw(s1.first, s1.second, s2.first) *
                  ccw(s1.first, s1.second, s2.second) <=
              0 &&
          ccw(s2.first, s2.second, s1.first) *
                  ccw(s2.first, s2.second, s1.second) <=
              0);
}
Point projection(const Segment &s1, const Point &p1) {
  GType mul =
      dot(p1 - s1.first, s1.first - s1.second) / norm(s1.first - s1.second);
  return s1.first + (s1.first - s1.second) * mul;
}
Point reflection(const Segment &s1, const Point &p1) {
  return p1 + (projection(s1, p1) - p1) * (GType)(2);
}
GType distance(const Point &p1, const Point &p2) { return std::abs(p2 - p1); }
GType distance(const Segment &s1, const Point &p1, bool segflag) {
  if (!segflag)
    return std::abs(p1 - projection(s1, p1));
  const Point p2 = projection(s1, p1);
  if (intersect(s1, p2, true))
    return std::abs(p2 - p1);
  return std::min(std::abs(s1.first - p1), std::abs(s1.second - p1));
}
GType distance(const Segment &s1, const Segment &s2, bool segflag) {
  if (intersect(s1, s2, segflag))
    return 0;
  if (!segflag)
    return std::min(distance(s1, s2.first, false),
                    distance(s1, s2.second, false));
  return std::min({distance(s1, s2.first, true), distance(s1, s2.second, true),
                   distance(s2, s1.first, true),
                   distance(s2, s1.second, true)});
}

// ------ Functions Level 3 ------ //
int contain(std::vector<Point> v, Point p) {
  bool in = false;
  for (int i = 0; i < v.size(); i++) {
    Point a = v[i] - p, b = v[(i + 1 != v.size() ? i + 1 : 0)] - p;
    if (a.imag() > b.imag())
      swap(a, b);
    if (a.imag() <= EPS && EPS < b.imag() && cross(a, b) < -EPS)
      in = !in;
    if (cross(a, b) == 0 && dot(a, b) <= 0)
      return 1;
  }
  return in ? 2 : 0;
}

#endif

#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int n, sx, sy, ex, ey, xa[55], ya[55], xb[55], yb[55], h[55];
int main() {
  while (cin >> n, n) {
    cin >> sx >> sy >> ex >> ey;
    for (int i = 0; i < n; i++)
      cin >> xa[i] >> ya[i] >> xb[i] >> yb[i] >> h[i];
    vector<vector<Point>> v(n);
    for (int i = 0; i < n; i++) {
      v[i] = {Point(xa[i], ya[i]), Point(xa[i], yb[i]), Point(xb[i], yb[i]),
              Point(xb[i], ya[i])};
    }
    bool flag = true;
    for (int i = 1; i < 20000; i++) {
      Point pt(sx + (ex - sx) * i / 20000.0, sy + (ey - sy) * i / 20000.0);
      for (int j = 0; j < n; j++) {
        if (contain(v[j], pt))
          flag = false;
      }
    }
    if (!flag)
      cout << 0 << endl;
    else {
      double ret = 1.0e+9;
      for (int i = 0; i < n; i++) {
        for (int j = 0; j < 4; j++) {
          double dist = distance(Segment(Point(sx, sy), Point(ex, ey)),
                                 Segment(v[i][j], v[i][(j + 1) & 3]), true);
          double r = 0.5 * (h[i] + dist * dist / h[i]);
          ret = min(ret, r);
        }
      }
      cout << fixed << setprecision(15) << ret << endl;
    }
  }
  return 0;
}