Problem p01292 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <valarray>
#include <vector>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define FOR(i, c)                                                              \
  for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RFOR(i, c)                                                             \
  for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a, b) make_pair(a, b)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());

template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
  os << "[";
  FOR(it, t) {
    if (it != t.begin())
      os << ",";
    os << *it;
  }
  os << "]";
  return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &t) {
  os << "{";
  FOR(it, t) {
    if (it != t.begin())
      os << ",";
    os << *it;
  }
  os << "}";
  return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
  return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
  return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
  return pair<S, T>(s.first - t.first, s.second - t.second);
}

namespace geom {
#define X real()
#define Y imag()
#define at(i) ((*this)[i])
#define SELF (*this)
enum { TRUE = 1, FALSE = 0, BORDER = -1 };
typedef int BOOL;
typedef double R;
const R INF = 1e8;
R EPS = 1e-6;
const R PI = 3.1415926535897932384626;
inline int sig(const R &x) { return (abs(x) < EPS ? 0 : x > 0 ? 1 : -1); }
inline BOOL less(const R &x, const R &y) { return sig(x - y) ? x < y : BORDER; }
typedef complex<R> P;
inline R norm(const P &p) { return p.X * p.X + p.Y * p.Y; }
inline R inp(const P &a, const P &b) { return (conj(a) * b).X; }
inline R outp(const P &a, const P &b) { return (conj(a) * b).Y; }
inline P unit(const P &p) { return p / abs(p); }
inline P proj(const P &s, const P &t) { return t * inp(s, t) / norm(t); }
inline int ccw(const P &s, const P &t, const P &p, int adv = 0) {
  int res = sig(outp(t - s, p - s));
  if (res || !adv)
    return res;
  if (sig(inp(t - s, p - s)) < 0)
    return -2; // p-s-t
  if (sig(inp(s - t, p - t)) < 0)
    return 2; // s-t-p
  return 0;   // s-p-t
}

struct L : public vector<P> { // line
  L(const P &p1, const P &p2) {
    this->push_back(p1);
    this->push_back(p2);
  }
  L() {}
  P dir() const { return at(1) - at(0); }
  BOOL online(const P &p) const { return !sig(outp(p - at(0), dir())); }
};
struct S : public L { // segment
  S(const P &p1, const P &p2) : L(p1, p2) {}
  S() {}
  BOOL online(const P &p) const {
    if (!sig(norm(p - at(0))) || !sig(norm(p - at(1))))
      return BORDER;
    // 座標の二乗とEPSの差が大きすぎないように注意
    return !sig(outp(p - at(0), dir())) && inp(p - at(0), dir()) > EPS &&
           inp(p - at(1), -dir()) > -EPS;
    // return !sig(abs(at(0)-p) + abs(at(1) - p) - abs(at(0) - at(1)));
  }
};
BOOL intersect(const S &s, const S &t) {
  const int p = ccw(t[0], t[1], s[0], 1) * ccw(t[0], t[1], s[1], 1);
  const int q = ccw(s[0], s[1], t[0], 1) * ccw(s[0], s[1], t[1], 1);
  return (p > 0 || q > 0) ? FALSE : (!p || !q) ? BORDER : TRUE;
}

#undef SELF
#undef at
} // namespace geom

using namespace geom;

namespace std {
bool operator<(const P &a, const P &b) {
  return sig(a.X - b.X) ? a.X < b.X : a.Y + EPS < b.Y;
}
bool operator==(const P &a, const P &b) { return abs(a - b) < EPS; }
istream &operator>>(istream &is, P &p) {
  R x, y;
  is >> x >> y;
  p = P(x, y);
  return is;
}
const R B = 500;
const R Z = .05;
ostream &operator<<(ostream &os, const P &c) {
  return os << "circle(" << B + Z * (c.X) << ", " << 1000 - B - Z * (c.Y)
            << ", 2)";
}
ostream &operator<<(ostream &os, const S &s) {
  return os << "line(" << B + Z * (s[0].X) << ", " << 1000 - B - Z * (s[0].Y)
            << ", " << B + Z * (s[1].X) << ", " << 1000 - B - Z * (s[1].Y)
            << ")";
}

} // namespace std

R T, range;
int n;

const R inc = 7e-5;

int main(int argc, char *argv[]) {
  ios::sync_with_stdio(false);
  while (cin >> T >> range, range > EPS) {
    vector<pair<P, R>> M, G;
    int L;
    cin >> L;
    REP(i, L) {
      P p;
      R t;
      cin >> p >> t;
      M.emplace_back(p, t);
    }
    cin >> L;
    REP(i, L) {
      P p;
      R t;
      cin >> p >> t;
      G.emplace_back(p, t);
    }
    vector<S> obs;
    cin >> L;
    REP(i, L) {
      R sx, sy, tx, ty;
      cin >> sx >> sy >> tx >> ty;
      obs.emplace_back(P(sx, sy), P(sx, ty));
      obs.emplace_back(P(sx, sy), P(tx, sy));
      obs.emplace_back(P(tx, sy), P(tx, ty));
      obs.emplace_back(P(sx, ty), P(tx, ty));
    }
    int i = -1, j = -1;
    R ans = 0;
    P m = M[0].first;
    P g = G[0].first;
    P md;
    P gd;
    for (R t = 0; t < T; t += inc) {
      if (M[i + 1].second <= t) {
        i++;
        m = M[i].first;
        md = (M[i + 1].first - M[i].first);
      }
      if (G[j + 1].second <= t) {
        j++;
        g = G[j].first;
        gd = (G[j + 1].first - G[j].first);
      }
      const P mm =
          m + md * ((t - M[i].second) / (M[i + 1].second - M[i].second));
      const P gg =
          g + gd * ((t - G[j].second) / (G[j + 1].second - G[j].second));
      const S s(gg, mm);
      if (abs(arg((G[j + 1].first - G[j].first) / s.dir())) > PI * (R).25 ||
          norm(s.dir()) > range * range || [&]() {
            FOR(o, obs) if (intersect(s, *o)) return 1;
            return 0;
          }())
        continue;
      ans += inc;
    }
    printf("%.5f\n", ans);
  }
  return 0;
}

Fixed submission:
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <valarray>
#include <vector>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define FOR(i, c)                                                              \
  for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RFOR(i, c)                                                             \
  for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a, b) make_pair(a, b)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());

template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
  os << "[";
  FOR(it, t) {
    if (it != t.begin())
      os << ",";
    os << *it;
  }
  os << "]";
  return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &t) {
  os << "{";
  FOR(it, t) {
    if (it != t.begin())
      os << ",";
    os << *it;
  }
  os << "}";
  return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
  return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
  return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
  return pair<S, T>(s.first - t.first, s.second - t.second);
}

namespace geom {
#define X real()
#define Y imag()
#define at(i) ((*this)[i])
#define SELF (*this)
enum { TRUE = 1, FALSE = 0, BORDER = -1 };
typedef int BOOL;
typedef double R;
const R INF = 1e8;
R EPS = 1e-6;
const R PI = 3.1415926535897932384626;
inline int sig(const R &x) { return (abs(x) < EPS ? 0 : x > 0 ? 1 : -1); }
inline BOOL less(const R &x, const R &y) { return sig(x - y) ? x < y : BORDER; }
typedef complex<R> P;
inline R norm(const P &p) { return p.X * p.X + p.Y * p.Y; }
inline R inp(const P &a, const P &b) { return (conj(a) * b).X; }
inline R outp(const P &a, const P &b) { return (conj(a) * b).Y; }
inline P unit(const P &p) { return p / abs(p); }
inline P proj(const P &s, const P &t) { return t * inp(s, t) / norm(t); }
inline int ccw(const P &s, const P &t, const P &p, int adv = 0) {
  int res = sig(outp(t - s, p - s));
  if (res || !adv)
    return res;
  if (sig(inp(t - s, p - s)) < 0)
    return -2; // p-s-t
  if (sig(inp(s - t, p - t)) < 0)
    return 2; // s-t-p
  return 0;   // s-p-t
}

struct L : public vector<P> { // line
  L(const P &p1, const P &p2) {
    this->push_back(p1);
    this->push_back(p2);
  }
  L() {}
  P dir() const { return at(1) - at(0); }
  BOOL online(const P &p) const { return !sig(outp(p - at(0), dir())); }
};
struct S : public L { // segment
  S(const P &p1, const P &p2) : L(p1, p2) {}
  S() {}
  BOOL online(const P &p) const {
    if (!sig(norm(p - at(0))) || !sig(norm(p - at(1))))
      return BORDER;
    // 座標の二乗とEPSの差が大きすぎないように注意
    return !sig(outp(p - at(0), dir())) && inp(p - at(0), dir()) > EPS &&
           inp(p - at(1), -dir()) > -EPS;
    // return !sig(abs(at(0)-p) + abs(at(1) - p) - abs(at(0) - at(1)));
  }
};
BOOL intersect(const S &s, const S &t) {
  const int p = ccw(t[0], t[1], s[0], 1) * ccw(t[0], t[1], s[1], 1);
  const int q = ccw(s[0], s[1], t[0], 1) * ccw(s[0], s[1], t[1], 1);
  return (p > 0 || q > 0) ? FALSE : (!p || !q) ? BORDER : TRUE;
}

#undef SELF
#undef at
} // namespace geom

using namespace geom;

namespace std {
bool operator<(const P &a, const P &b) {
  return sig(a.X - b.X) ? a.X < b.X : a.Y + EPS < b.Y;
}
bool operator==(const P &a, const P &b) { return abs(a - b) < EPS; }
istream &operator>>(istream &is, P &p) {
  R x, y;
  is >> x >> y;
  p = P(x, y);
  return is;
}
const R B = 500;
const R Z = .05;
ostream &operator<<(ostream &os, const P &c) {
  return os << "circle(" << B + Z * (c.X) << ", " << 1000 - B - Z * (c.Y)
            << ", 2)";
}
ostream &operator<<(ostream &os, const S &s) {
  return os << "line(" << B + Z * (s[0].X) << ", " << 1000 - B - Z * (s[0].Y)
            << ", " << B + Z * (s[1].X) << ", " << 1000 - B - Z * (s[1].Y)
            << ")";
}

} // namespace std

R T, range;
int n;

const R inc = 7e-5;

int main(int argc, char *argv[]) {
  ios::sync_with_stdio(false);
  while (cin >> T >> range, range > EPS) {
    vector<pair<P, R>> M, G;
    int L;
    cin >> L;
    REP(i, L) {
      P p;
      R t;
      cin >> p >> t;
      M.emplace_back(p, t);
    }
    cin >> L;
    REP(i, L) {
      P p;
      R t;
      cin >> p >> t;
      G.emplace_back(p, t);
    }
    vector<S> obs;
    cin >> L;
    REP(i, L) {
      R sx, sy, tx, ty;
      cin >> sx >> sy >> tx >> ty;
      obs.emplace_back(P(sx, sy), P(sx, ty));
      obs.emplace_back(P(sx, sy), P(tx, sy));
      obs.emplace_back(P(tx, sy), P(tx, ty));
      obs.emplace_back(P(sx, ty), P(tx, ty));
    }
    int i = -1, j = -1;
    R ans = 0;
    P m = M[0].first;
    P g = G[0].first;
    P md;
    P gd;
    for (R t = 0; t < T; t += inc) {
      if (M[i + 1].second <= t) {
        i++;
        m = M[i].first;
        md = (M[i + 1].first - M[i].first);
      }
      if (G[j + 1].second <= t) {
        j++;
        g = G[j].first;
        gd = (G[j + 1].first - G[j].first);
      }
      const P mm =
          m + md * ((t - M[i].second) / (M[i + 1].second - M[i].second));
      const P gg =
          g + gd * ((t - G[j].second) / (G[j + 1].second - G[j].second));
      const S s(gg, mm);
      if (norm(s.dir()) > range * range ||
          abs(arg(gd / s.dir())) > PI * (R).25 || [&]() {
            FOR(o, obs) if (intersect(s, *o)) return 1;
            return 0;
          }())
        continue;
      ans += inc;
    }
    printf("%.5f\n", ans);
  }
  return 0;
}