Problem p00204 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define EPS (1e-8)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define MAX 110
using namespace std;

// template
class Point {
public:
  long double x, y;

  Point(long double x = -inf, long double y = -inf) : x(x), y(y) {}

  Point operator+(Point p) { return Point(x + p.x, y + p.y); }
  Point operator-(Point p) { return Point(x - p.x, y - p.y); }
  Point operator*(long double a) { return Point(a * x, a * y); }
  Point operator/(long double a) { return Point(x / a, y / a); }

  bool operator<(const Point &p) const {
    return !equals(x, p.x) ? x < p.x : y < p.y;
  }
};

struct Segment {
  Point p1, p2;
  Segment(Point p1 = Point(-1, -1), Point p2 = Point(-1, -1))
      : p1(p1), p2(p2) {}
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;

double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }

double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }

double norm(Point a) { return a.x * a.x + a.y * a.y; }

bool point_equals(Point a, Point b) {
  return equals(a.x, b.x) && equals(a.y, b.y);
}

Point rotate(Point a, double rad) {
  return Point(cos(rad) * a.x - sin(rad) * a.y,
               sin(rad) * a.x + cos(rad) * a.y);
}

double toRad(double agl) { return agl * M_PI / 180.0; }

int ccw(Point p0, Point p1, Point p2) {
  Point a = p1 - p0;
  Point b = p2 - p0;
  if (cross(a, b) > EPS)
    return COUNTER_CLOCKWISE;
  if (cross(a, b) < -EPS)
    return CLOCKWISE;
  if (dot(a, b) < -EPS)
    return ONLINE_BACK;
  if (norm(a) < norm(b))
    return ONLINE_FRONT;
  return ON_SEGMENT;
}

double abs(Point a) { return sqrt(norm(a)); }

double getDistanceLP(Line s, Point p) {
  return abs(cross(s.p2 - s.p1, p - s.p1)) / abs(s.p2 - s.p1);
}

double getDistanceSP(Segment s, Point p) {
  if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
    return abs(p - s.p1);
  if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
    return abs(p - s.p2);
  return getDistanceLP(s, p);
}

// cross product of pq and pr
double cross3p(Point p, Point q, Point r) {
  return (r.x - q.x) * (p.y - q.y) - (r.y - q.y) * (p.x - q.x);
}

// returns true if point r is on the same line as the line pq
bool collinear(Point p, Point q, Point r) {
  return fabs(cross3p(p, q, r)) < EPS;
}

// returns true if point t is on the left side of line pq
bool ccwtest(Point p, Point q, Point r) {
  return cross3p(p, q, r) > 0; // can be modified to accept collinear points
}

bool onSegment(Point p, Point q, Point r) {
  return collinear(p, q, r) &&
         equals(sqrt(pow(p.x - r.x, 2) + pow(p.y - r.y, 2)) +
                    sqrt(pow(r.x - q.x, 2) + pow(r.y - q.y, 2)),
                sqrt(pow(p.x - q.x, 2) + pow(p.y - q.y, 2)));
}

//--------------------------------------------------------------------------

struct UFO {
  Point p;
  long double r, v;
  UFO(Point p = Point(), long double r = -inf, long double v = -inf)
      : p(p), r(r), v(v) {}
};

long double R;
int N;
UFO ufo[MAX];
bool alive[MAX];

int main() {
  int rx;
  while (cin >> rx >> N, rx | N) {
    R = (long double)rx;
    rep(i, N) {
      cin >> ufo[i].p.x >> ufo[i].p.y >> ufo[i].r >> ufo[i].v;
      alive[i] = true;
    }

    int pass = 0;

    while (true) {
      int nearest = -inf;
      rep(i, N) {
        if (!alive[i])
          continue;
        Point e = ufo[i].p / abs(ufo[i].p);
        Point next = ufo[i].p - e * ufo[i].v;
        long double dist_next = abs(next);
        if (onSegment(ufo[i].p, next, Point(0, 0)) || equals(dist_next, R) ||
            dist_next < R || equals(abs(ufo[i].p), R) || abs(ufo[i].p) < R) {
          alive[i] = false;
          pass++;
          continue;
        }
        ufo[i].p = next;
        if (nearest == -inf)
          nearest = i;
        else {
          long double d1 = abs(ufo[nearest].p);
          long double d2 = abs(ufo[i].p);
          if (!equals(d1, d2) && d1 > d2)
            nearest = i;
        }
      }

      if (nearest == -inf)
        break;

      Vector e = ufo[nearest].p / abs(ufo[nearest].p);

      Segment seg = Segment(e * R, e * 1000000.0);
      rep(i, N) {
        if (!alive[i])
          continue;
        assert(abs(e) > abs(ufo[i].p));
        long double dist = getDistanceSP(seg, ufo[i].p);
        if (equals(dist, ufo[i].r) || dist < ufo[i].r) {
          alive[i] = false;
          continue;
        }
      }
    }
    cout << pass << endl;
  }
  return 0;
}

Fixed submission:
#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define EPS (1e-8)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define MAX 110
using namespace std;

// template
class Point {
public:
  long double x, y;

  Point(long double x = -inf, long double y = -inf) : x(x), y(y) {}

  Point operator+(Point p) { return Point(x + p.x, y + p.y); }
  Point operator-(Point p) { return Point(x - p.x, y - p.y); }
  Point operator*(long double a) { return Point(a * x, a * y); }
  Point operator/(long double a) { return Point(x / a, y / a); }

  bool operator<(const Point &p) const {
    return !equals(x, p.x) ? x < p.x : y < p.y;
  }
};

struct Segment {
  Point p1, p2;
  Segment(Point p1 = Point(-1, -1), Point p2 = Point(-1, -1))
      : p1(p1), p2(p2) {}
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;

double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }

double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }

double norm(Point a) { return a.x * a.x + a.y * a.y; }

bool point_equals(Point a, Point b) {
  return equals(a.x, b.x) && equals(a.y, b.y);
}

Point rotate(Point a, double rad) {
  return Point(cos(rad) * a.x - sin(rad) * a.y,
               sin(rad) * a.x + cos(rad) * a.y);
}

double toRad(double agl) { return agl * M_PI / 180.0; }

int ccw(Point p0, Point p1, Point p2) {
  Point a = p1 - p0;
  Point b = p2 - p0;
  if (cross(a, b) > EPS)
    return COUNTER_CLOCKWISE;
  if (cross(a, b) < -EPS)
    return CLOCKWISE;
  if (dot(a, b) < -EPS)
    return ONLINE_BACK;
  if (norm(a) < norm(b))
    return ONLINE_FRONT;
  return ON_SEGMENT;
}

double abs(Point a) { return sqrt(norm(a)); }

double getDistanceLP(Line s, Point p) {
  return abs(cross(s.p2 - s.p1, p - s.p1)) / abs(s.p2 - s.p1);
}

double getDistanceSP(Segment s, Point p) {
  if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
    return abs(p - s.p1);
  if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
    return abs(p - s.p2);
  return getDistanceLP(s, p);
}

// cross product of pq and pr
double cross3p(Point p, Point q, Point r) {
  return (r.x - q.x) * (p.y - q.y) - (r.y - q.y) * (p.x - q.x);
}

// returns true if point r is on the same line as the line pq
bool collinear(Point p, Point q, Point r) {
  return fabs(cross3p(p, q, r)) < EPS;
}

// returns true if point t is on the left side of line pq
bool ccwtest(Point p, Point q, Point r) {
  return cross3p(p, q, r) > 0; // can be modified to accept collinear points
}

bool onSegment(Point p, Point q, Point r) {
  return collinear(p, q, r) &&
         equals(sqrt(pow(p.x - r.x, 2) + pow(p.y - r.y, 2)) +
                    sqrt(pow(r.x - q.x, 2) + pow(r.y - q.y, 2)),
                sqrt(pow(p.x - q.x, 2) + pow(p.y - q.y, 2)));
}

//--------------------------------------------------------------------------

struct UFO {
  Point p;
  long double r, v;
  UFO(Point p = Point(), long double r = -inf, long double v = -inf)
      : p(p), r(r), v(v) {}
};

long double R;
int N;
UFO ufo[MAX];
bool alive[MAX];

int main() {
  int rx;
  while (cin >> rx >> N, rx | N) {
    R = (long double)rx;
    rep(i, N) {
      cin >> ufo[i].p.x >> ufo[i].p.y >> ufo[i].r >> ufo[i].v;
      alive[i] = true;
    }

    int pass = 0;

    while (true) {
      int nearest = -inf;
      rep(i, N) {
        if (!alive[i])
          continue;
        Point e = ufo[i].p / abs(ufo[i].p);
        Point next = ufo[i].p - e * ufo[i].v;
        long double dist_next = abs(next);
        if (onSegment(ufo[i].p, next, Point(0, 0)) || equals(dist_next, R) ||
            dist_next < R || equals(abs(ufo[i].p), R) || abs(ufo[i].p) < R) {
          alive[i] = false;
          pass++;
          continue;
        }
        ufo[i].p = next;
        if (nearest == -inf)
          nearest = i;
        else {
          long double d1 = abs(ufo[nearest].p);
          long double d2 = abs(ufo[i].p);
          if (!equals(d1, d2) && d1 > d2)
            nearest = i;
        }
      }

      if (nearest == -inf)
        break;

      Vector e = ufo[nearest].p / abs(ufo[nearest].p);

      Segment seg = Segment(e * R, e * 1000000.0);
      rep(i, N) {
        if (!alive[i])
          continue;
        // assert(abs(e) > abs(ufo[i].p));
        long double dist = getDistanceSP(seg, ufo[i].p);
        if (equals(dist, ufo[i].r) || dist < ufo[i].r) {
          alive[i] = false;
          continue;
        }
      }
    }
    cout << pass << endl;
  }
  return 0;
}