Problem p01134 (C++) — buggy submission, verdict: Runtime Error

#include <bits/stdc++.h>
using namespace std;

#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif

typedef long long int ll;
typedef pair<int, int> pii;
// template<typename T> using vec=std::vector<T>;

const int inf = 1 << 30;
const long long int infll = 1LL << 58;
const long double eps = 1e-10;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};

template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (const auto &v : vec) {
    os << v << ",";
  }
  os << "]";
  return os;
}

typedef complex<long double> point;
typedef pair<point, point> line;
bool equal(const long double x1, const long double x2) {
  return abs(x1 - x2) < eps;
}
bool equal(const point &a, const point &b) {
  return equal(a.real(), b.real()) and equal(a.imag(), b.imag());
}
long double length(const point &a) { return abs(a); }
long double distance(const point &a, const point &b) { return abs(a - b); }
long double dot(const point &a, const point &b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
long double cross(const point &a, const point &b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
bool is_orthogonal(const point &a1, const point &a2, const point &b1,
                   const point &b2) {
  return equal(dot(a1 - a2, b1 - b2), 0.0);
}
bool is_orthogonal(const line &l, const line &m) {
  return is_orthogonal(l.first, l.second, m.first, m.second);
}
bool is_parallel(const point &a1, const point &a2, const point &b1,
                 const point &b2) {
  return equal(cross(a1 - a2, b1 - b2), 0.0);
}
bool is_parallel(const line &l, const line &m) {
  return is_parallel(l.first, l.second, m.first, m.second);
}
int ccw(point a, point b, point c) {
  b -= a;
  c -= a;
  if (cross(b, c) > 0)
    return +1; // counter clockwise
  if (cross(b, c) < 0)
    return -1; // clockwise
  if (dot(b, c) < 0)
    return +2; // c--a--b on line
  if (norm(b) < norm(c))
    return -2; // a--b--c on line
  return 0;
}
bool intersectLL(const line &l, const line &m) {
  return abs(cross(l.second - l.first, m.second - m.first)) >
             eps || // non-parallel
         abs(cross(l.second - l.first, m.first - l.first)) < eps; // same line
}
bool intersectLS(const line &l, const line &s) {
  return cross(l.second - l.first, s.first - l.first) * // s.first is left of l
             cross(l.second - l.first, s.second - l.first) <
         eps; // s.second is right of l
}
bool intersectLP(const line &l, const point &p) {
  return abs(cross(l.second - p, l.first - p)) < eps;
}
bool intersectSS(const line &s, const line &t) {
  return ccw(s.first, s.second, t.first) * ccw(s.first, s.second, t.second) <=
             0 &&
         ccw(t.first, t.second, s.first) * ccw(t.first, t.second, s.second) <=
             0;
}
bool intersectSP(const line &s, const point &p) {
  return abs(s.first - p) + abs(s.second - p) - abs(s.second - s.first) <
         eps; // triangle inequality
}
point projection(const line &l, const point &p) {
  long double t =
      dot(p - l.first, l.first - l.second) / norm(l.first - l.second);
  return l.first + t * (l.first - l.second);
}
point reflection(const line &l, const point &p) {
  return p + point((projection(l, p) - p).real() * 2,
                   (projection(l, p) - p).imag() * 2);
}
long double distanceLP(const line &l, const point &p) {
  return abs(p - projection(l, p));
}
long double distanceLL(const line &l, const line &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m.first);
}
long double distanceLS(const line &l, const line &s) {
  if (intersectLS(l, s))
    return 0;
  return min(distanceLP(l, s.first), distanceLP(l, s.second));
}
long double distanceSP(const line &s, const point &p) {
  const point r = projection(s, p);
  if (intersectSP(s, r))
    return abs(r - p);
  return min(abs(s.first - p), abs(s.second - p));
}
long double distanceSS(const line &s, const line &t) {
  if (intersectSS(s, t))
    return 0;
  return min(min(distanceSP(s, t.first), distanceSP(s, t.second)),
             min(distanceSP(t, s.first), distanceSP(t, s.second)));
}
// a1,a2???????????´?????¨b1,b2???????????´?????????????¨????
point intersection_l(const point &a1, const point &a2, const point &b1,
                     const point &b2) {
  const point &a = a2 - a1, b = b2 - b1;
  return a1 + a * cross(b, b1 - a1) / cross(b, a);
}
point intersection_l(const line &l, const line &m) {
  return intersection_l(l.first, l.second, m.first, m.second);
}

void solve() {
  while (true) {
    int n;
    cin >> n;
    if (!n)
      break;

    vector<line> ls1;
    rep(i, 0, n) {
      long double x1, y1, x2, y2;
      cin >> x1 >> y1 >> x2 >> y2;
      ls1.emplace_back(make_pair(point(x1, y1), point(x2, y2)));
    }

    const int offset = 128;
    int ans = 2;
    vector<vector<point>> ps(256);
    vector<line> ls2 = {ls1[0]};
    vector<point> done;
    rep(i, 1, n) {
      const auto l1 = ls1[i];
      int cnt = i + 1;
      vector<vector<point>> tmp(256);
      vector<point> done;
      for (const auto &l2 : ls2) {
        if (is_parallel(l1, l2)) {
          --cnt;
          continue;
        }
        auto p1 = intersection_l(l1, l2);
        if (int(p1.real()) + 1 - p1.real() < eps)
          p1 = point(int(p1.real()) + 1, p1.imag());
        if (abs(p1.real()) + eps >= 100 or abs(p1.imag()) + eps >= 100) {
          --cnt;
          continue;
        }

        bool is_new = true;
        for (const auto &p2 : ps[int(p1.real()) + offset])
          if (distance(p1, p2) < eps) {
            is_new = false;
            break;
          }
        if (!is_new) {
          --cnt;
          bool ok = true;
          for (const auto &p2 : done)
            if (distance(p1, p2) < eps) {
              ok = false;
              break;
            }
          if (ok)
            done.emplace_back(p1);
        } else
          tmp[int(p1.real()) + offset].emplace_back(p1);
      }
      rep(j, 0, 256) ps[j].insert(ps[j].end(), tmp[j].begin(), tmp[j].end());
      ls2.emplace_back(l1);
      cnt += done.size();
      ans += cnt;
    }
    cout << ans << endl;
  }
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  cout << fixed << setprecision(8);
  solve();
  return 0;
}

Error: 0

Fixed submission:

#include <bits/stdc++.h>
using namespace std;

#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif

typedef long long int ll;
typedef pair<int, int> pii;
// template<typename T> using vec=std::vector<T>;

const int inf = 1 << 30;
const long long int infll = 1LL << 58;
const long double eps = 1e-10;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};

template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (const auto &v : vec) {
    os << v << ",";
  }
  os << "]";
  return os;
}

typedef complex<long double> point;
typedef pair<point, point> line;
bool equal(const long double x1, const long double x2) {
  return abs(x1 - x2) < eps;
}
bool equal(const point &a, const point &b) {
  return equal(a.real(), b.real()) and equal(a.imag(), b.imag());
}
long double length(const point &a) { return abs(a); }
long double distance(const point &a, const point &b) { return abs(a - b); }
long double dot(const point &a, const point &b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
long double cross(const point &a, const point &b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
bool is_orthogonal(const point &a1, const point &a2, const point &b1,
                   const point &b2) {
  return equal(dot(a1 - a2, b1 - b2), 0.0);
}
bool is_orthogonal(const line &l, const line &m) {
  return is_orthogonal(l.first, l.second, m.first, m.second);
}
bool is_parallel(const point &a1, const point &a2, const point &b1,
                 const point &b2) {
  return equal(cross(a1 - a2, b1 - b2), 0.0);
}
bool is_parallel(const line &l, const line &m) {
  return is_parallel(l.first, l.second, m.first, m.second);
}
int ccw(point a, point b, point c) {
  b -= a;
  c -= a;
  if (cross(b, c) > 0)
    return +1; // counter clockwise
  if (cross(b, c) < 0)
    return -1; // clockwise
  if (dot(b, c) < 0)
    return +2; // c--a--b on line
  if (norm(b) < norm(c))
    return -2; // a--b--c on line
  return 0;
}
bool intersectLL(const line &l, const line &m) {
  return abs(cross(l.second - l.first, m.second - m.first)) >
             eps || // non-parallel
         abs(cross(l.second - l.first, m.first - l.first)) < eps; // same line
}
bool intersectLS(const line &l, const line &s) {
  return cross(l.second - l.first, s.first - l.first) * // s.first is left of l
             cross(l.second - l.first, s.second - l.first) <
         eps; // s.second is right of l
}
bool intersectLP(const line &l, const point &p) {
  return abs(cross(l.second - p, l.first - p)) < eps;
}
bool intersectSS(const line &s, const line &t) {
  return ccw(s.first, s.second, t.first) * ccw(s.first, s.second, t.second) <=
             0 &&
         ccw(t.first, t.second, s.first) * ccw(t.first, t.second, s.second) <=
             0;
}
bool intersectSP(const line &s, const point &p) {
  return abs(s.first - p) + abs(s.second - p) - abs(s.second - s.first) <
         eps; // triangle inequality
}
point projection(const line &l, const point &p) {
  long double t =
      dot(p - l.first, l.first - l.second) / norm(l.first - l.second);
  return l.first + t * (l.first - l.second);
}
point reflection(const line &l, const point &p) {
  return p + point((projection(l, p) - p).real() * 2,
                   (projection(l, p) - p).imag() * 2);
}
long double distanceLP(const line &l, const point &p) {
  return abs(p - projection(l, p));
}
long double distanceLL(const line &l, const line &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m.first);
}
long double distanceLS(const line &l, const line &s) {
  if (intersectLS(l, s))
    return 0;
  return min(distanceLP(l, s.first), distanceLP(l, s.second));
}
long double distanceSP(const line &s, const point &p) {
  const point r = projection(s, p);
  if (intersectSP(s, r))
    return abs(r - p);
  return min(abs(s.first - p), abs(s.second - p));
}
long double distanceSS(const line &s, const line &t) {
  if (intersectSS(s, t))
    return 0;
  return min(min(distanceSP(s, t.first), distanceSP(s, t.second)),
             min(distanceSP(t, s.first), distanceSP(t, s.second)));
}
// a1,a2???????????´?????¨b1,b2???????????´?????????????¨????
point intersection_l(const point &a1, const point &a2, const point &b1,
                     const point &b2) {
  const point &a = a2 - a1, b = b2 - b1;
  return a1 + a * cross(b, b1 - a1) / cross(b, a);
}
point intersection_l(const line &l, const line &m) {
  return intersection_l(l.first, l.second, m.first, m.second);
}

void solve() {
  while (true) {
    int n;
    cin >> n;
    if (!n)
      break;

    vector<line> ls1;
    rep(i, 0, n) {
      long double x1, y1, x2, y2;
      cin >> x1 >> y1 >> x2 >> y2;
      ls1.emplace_back(make_pair(point(x1, y1), point(x2, y2)));
    }

    const int offset = 128;
    int ans = 2;
    vector<vector<point>> ps(200);
    vector<line> ls2 = {ls1[0]};
    rep(i, 1, n) {
      const auto l1 = ls1[i];
      int cnt = i + 1;
      vector<vector<point>> tmp(256);
      for (const auto &l2 : ls2) {
        if (is_parallel(l1, l2)) {
          --cnt;
          continue;
        }
        bool is_new = true;
        auto p1 = intersection_l(l1, l2);
        if (p1.real() - int(p1.real()) < eps)
          p1 = point(int(p1.real()), p1.imag());
        if (abs(p1.real()) > 100 or abs(p1.imag()) > 100)
          is_new = false;
        else {
          for (const auto &p2 : ps[int(p1.real()) + offset])
            if (distance(p1, p2) <= eps) {
              is_new = false;
              break;
            }
        }
        if (!is_new)
          --cnt;
        else
          tmp[int(p1.real()) + offset].emplace_back(p1);
      }
      rep(j, 0, 256) ps[j].insert(ps[j].end(), tmp[j].begin(), tmp[j].end());
      ls2.emplace_back(l1);
      ans += cnt;
    }
    cout << ans << endl;
  }
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  cout << fixed << setprecision(8);
  solve();
  return 0;
}