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

#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;

// ------ Classes ------ //
class Point {
public:
  long double px, py;
  Point() : px(0), py(0){};
  Point(long double px_, long double py_) : px(px_), py(py_){};
  bool operator==(const Point &p) const { return px == p.px && py == p.py; }
  bool operator!=(const Point &p) const { return px != p.px || py != p.py; }
  bool operator<(const Point &p) const {
    return px < p.px ? true : (px == p.px && py < p.py);
  }
  bool operator>(const Point &p) const {
    return px > p.px ? true : (px == p.px && py > p.py);
  }
  bool operator<=(const Point &p) const { return !(Point(px, py) > p); }
  bool operator>=(const Point &p) const { return !(Point(px, py) < p); }
  Point operator+(const Point &p) const { return Point(px + p.px, py + p.py); }
  Point operator-(const Point &p) const { return Point(px - p.px, py - p.py); }
  Point operator/(long double d) const { return Point(px / d, py / d); }
  friend Point operator*(const Point p, long double d) {
    return Point(p.px * d, p.py * d);
  }
  friend Point operator*(long double d, const Point &p) { return p * d; }
  Point &operator+=(const Point &p1) {
    px += p1.px, py += p1.py;
    return *this;
  }
  Point &operator-=(const Point &p1) {
    px -= p1.px, py -= p1.py;
    return *this;
  }
  Point &operator*=(long double d) {
    px *= d, py *= d;
    return *this;
  }
  Point &operator/=(long double d) {
    px /= d, py /= d;
    return *this;
  }
};
class Circle {
public:
  Point p;
  long double r;
  Circle() : p(Point()), r(0.0L){};
  Circle(Point p_) : p(p_), r(0.0L){};
  Circle(Point p_, long double r_) : p(p_), r(r_){};
  Circle(long double x_, long double y_) : p(Point(x_, y_)), r(0.0L){};
  Circle(long double x_, long double y_, long double r_)
      : p(Point(x_, y_)), r(r_){};
  bool operator==(const Circle &c) const { return p == c.p && r == c.r; }
  bool operator!=(const Circle &c) const { return !(Circle(p, r) == c); }
};

// ------ Functions ------ //
long double norm(const Point &a) { return a.px * a.px + a.py * a.py; }
long double abs(const Point &a) { return sqrtl(norm(a)); }
long double arg(const Point &a) { return atan2l(a.py, a.px); }
long double dot(const Point &a, const Point &b) {
  return a.px * b.px + a.py * b.py;
}
long double crs(const Point &a, const Point &b) {
  return a.px * b.py - a.py * b.px;
}
Point pol(long double r, long double d) {
  return Point(cosl(d) * r, sinl(d) * r);
}
int ccw(const Point &p0, const Point &p1, const Point &p2) {
  Point a = p1 - p0, b = p2 - p0;
  if (crs(a, b) > 1e-10)
    return 1;
  if (crs(a, b) < -1e-10)
    return -1;
  if (dot(a, b) < -1e-10)
    return 2;
  if (norm(a) < norm(b))
    return -2;
  return 0;
}
bool its(const Point &p1, const Point &p2, const Point &p3, const Point &p4) {
  return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
          ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}
long double dst(const Point &a, const Point &b) { return abs(b - a); }
vector<Point> crp(Circle c1, Circle c2) {
  double d = abs(c1.p - c2.p);
  double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
  double t = arg(c2.p - c1.p);
  return {c1.p + pol(c1.r, t + a), c1.p + pol(c1.r, t - a)};
}

// ------ Main ------ //
int n;
char c;
vector<Circle> v;
int main() {
  while (cin >> n, n) {
    v.resize(n);
    for (int i = 0; i < n; i++)
      cin >> v[i].p.px >> c >> v[i].p.py, v[i].r = 1;
    int ret = 1;
    for (int i = 0; i < n; i++) {
      for (int j = i + 1; j < n; j++) {
        if (dst(v[i].p, v[j].p) > 2.0L + 1e-10)
          continue;
        vector<Point> w = crp(v[i], v[j]);
        for (int k = 0; k < 2; k++) {
          int s = 0;
          for (int l = 0; l < n; l++) {
            if (dst(w[k], v[l].p) <= 1.0L + 1e-10)
              s++;
          }
          ret = max(ret, s);
        }
      }
    }
    cout << ret << endl;
  }
}

Error: TLE

Fixed submission:

#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
struct Point {
  long double px, py;
};
struct Circle {
  Point p;
  long double r;
};
Point pol(long double r, long double d) {
  return Point{cosl(d) * r, sinl(d) * r};
}
long double arg(const Point &a) { return atan2l(a.py, a.px); }
long double norm(const Point &a) { return a.px * a.px + a.py * a.py; }
long double abs(const Point &a) { return sqrtl(norm(a)); }
Point Minus(Point a, Point b) { return Point{a.px - b.px, a.py - b.py}; }
Point Plus(Point a, Point b) { return Point{a.px + b.px, a.py + b.py}; }
long double dst(const Point &a, const Point &b) { return abs(Minus(b, a)); }
pair<Point, Point> crp(Circle c1, Circle c2) {
  double d = abs(Minus(c1.p, c2.p));
  double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
  double t = arg(Minus(c2.p, c1.p));
  return make_pair(Plus(c1.p, pol(c1.r, t + a)), Plus(c1.p, pol(c1.r, t - a)));
}
int main() {
  Circle x[100];
  int n;
  vector<Point> y;
  while (true) {
    cin >> n;
    char ch;
    if (n == 0)
      break;
    for (int i = 0; i < n; i++) {
      cin >> x[i].p.px >> ch >> x[i].p.py;
      x[i].r = 1.0l;
    }
    for (int i = 0; i < n; i++) {
      for (int j = i + 1; j < n; j++) {
        y.push_back(crp(x[i], x[j]).first);
        y.push_back(crp(x[i], x[j]).second);
      }
    }
    int maxn = 0;
    for (int i = 0; i < y.size(); i++) {
      int cnt = 0;
      for (int j = 0; j < n; j++) {
        if (dst(y[i], x[j].p) <= 1.0l) {
          cnt++;
        }
      }
      maxn = max(maxn, cnt);
    }
    cout << maxn << endl;
  }
  return 0;
}