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

#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
  int v;
  istringstream sin(s);
  sin >> v;
  return v;
}
template <class T> inline string toString(T x) {
  ostringstream sout;
  sout << x;
  return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
const double EPS = 1e-7;
const double PI = acos(-1.0);

#define EQ(a, b) (abs((a) - (b)) < EPS)
#define LT(a, b) ((a) + EPS < (b))

void mergeF(vi &b, vector<double> &f, vi &a) {
  REP(i, b.size() - 1) {
    REP(j, f.size() - 1) {
      if (b[i] < f[j] && f[j] < b[i + 1] && b[i] < f[j + 1] &&
          f[j + 1] < b[i + 1]) {
        a[j + 1] += a[j];
        f.erase(f.begin() + j);
        a.erase(a.begin() + j);
        j--;
      }
    }
  }
}

int main() {
  cout.precision(16);
  int numdata;
  cin >> numdata;
  REP(data, numdata) {
    int n;
    cin >> n;
    vi b(n + 2), h(n + 2);
    b[0] = 0;
    h[0] = 50;
    b[n + 1] = 100;
    h[n + 1] = 50;
    REP(i, n) { cin >> b[i + 1] >> h[i + 1]; }
    int m;
    cin >> m;
    vector<double> f(m);
    vi a(m);
    REP(i, m) { cin >> f[i] >> a[i]; }
    int l;
    cin >> l;
    vi p(l), t(l);
    vector<pair<int, pii>> pt(l);
    REP(i, l) {
      cin >> pt[i].second.first >> pt[i].first;
      pt[i].second.second = i;
    }
    sort(ALL(pt));
    vi ansindex(l);
    REP(i, l) {
      p[i] = pt[i].second.first;
      t[i] = pt[i].first;
      ansindex[i] = pt[i].second.second;
    }

    mergeF(b, f, a);

    vector<double> tank(n + 1);
    double cur_time = 0;
    int next_obs = 0;
    vector<double> ans(l);
    while (next_obs < t.size()) {
      double next_time = INT_MAX;
      REP(i, b.size() - 1) {
        REP(j, f.size()) {
          if (b[i] < f[j] && f[j] < b[i + 1]) {
            int height = min(h[i], h[i + 1]);
            double t = (b[i + 1] - b[i]) * (height - tank[i]) * 30 / a[j];
            next_time = min(next_time, cur_time + t);
          }
        }
      }
      if (LT(t[next_obs], next_time)) {
        next_time = t[next_obs];
      }
      double diff_time = next_time - cur_time;
      REP(i, b.size() - 1) {
        REP(j, f.size()) {
          if (b[i] < f[j] && f[j] < b[i + 1]) {
            tank[i] += a[j] * diff_time / ((b[i + 1] - b[i]) * 30);
          }
        }
      }
      REP(i, b.size() - 1) {
        REP(j, f.size()) {
          if (b[i] < f[j] && f[j] < b[i + 1]) {
            if (EQ(tank[i], h[i])) {
              f[j] = b[i] - 0.5;
              mergeF(b, f, a);
            }
            if (EQ(tank[i], h[i + 1])) {
              f[j] = b[i + 1] + 0.5;
              mergeF(b, f, a);
            }
            if (i < tank.size() - 1 && EQ(tank[i], tank[i + 1]) &&
                EQ(tank[i], h[i + 1]) && EQ(tank[i + 1], h[i + 1])) {
              b.erase(b.begin() + i + 1);
              h.erase(h.begin() + i + 1);
              tank.erase(tank.begin() + i + 1);
            }
          }
        }
      }
      if (EQ(next_time, t[next_obs])) {
        REP(k, b.size() - 1) {
          if (b[k] < p[next_obs] && p[next_obs] < b[k + 1]) {
            ans[ansindex[next_obs]] = (tank[k]);
            next_obs++;
            break;
          }
        }
      }
      cur_time = next_time;
    }
    REP(i, ans.size()) { cout << ans[i] << endl; }
  }
}

Error: WA

Fixed submission:

#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
  int v;
  istringstream sin(s);
  sin >> v;
  return v;
}
template <class T> inline string toString(T x) {
  ostringstream sout;
  sout << x;
  return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
const double EPS = 1e-10;
const double PI = acos(-1.0);

void mergeF(vi &b, vi &f, vi &a, vi &done) {
  REP(i, b.size() - 1) {
    REP(j, f.size() - 1) {
      if (b[i] < f[j] && f[j] < b[i + 1] && b[i] < f[j + 1] &&
          f[j + 1] < b[i + 1]) {
        a[j + 1] += a[j];
        done[j + 1] |= done[j];
        f.erase(f.begin() + j);
        a.erase(a.begin() + j);
        done.erase(done.begin() + j);
        j--;
      }
    }
  }
}

int main() {
  cout.precision(16);
  int numdata;
  cin >> numdata;
  REP(data, numdata) {
    int n;
    cin >> n;
    vi b(n + 2), h(n + 2);
    b[0] = 0;
    h[0] = 50;
    b[n + 1] = 100;
    h[n + 1] = 50;
    REP(i, n) { cin >> b[i + 1] >> h[i + 1]; }
    int m;
    cin >> m;
    vi f(m), a(m);
    REP(i, m) { cin >> f[i] >> a[i]; }
    int l;
    cin >> l;
    vi p(l), t(l);
    vector<pair<int, pii>> pt(l);
    REP(i, l) {
      cin >> pt[i].second.first >> pt[i].first;
      pt[i].second.second = i;
    }
    sort(ALL(pt));
    vi ansindex(l);
    REP(i, l) {
      p[i] = pt[i].second.first;
      t[i] = pt[i].first;
      ansindex[i] = pt[i].second.second;
    }

    vi dd(m);
    mergeF(b, f, a, dd);

    vector<double> tank(n + 1);
    double cur_time = 0;
    int next_obs = 0;
    vector<double> ans(l);
    while (next_obs < t.size()) {
      double next_time = INT_MAX;
      REP(i, b.size() - 1) {
        REP(j, f.size()) {
          if (b[i] < f[j] && f[j] < b[i + 1]) {
            int height = min(h[i], h[i + 1]);
            assert(height - tank[i] >= 0);
            double t = (b[i + 1] - b[i]) * (height - tank[i]) * 30 / a[j];
            next_time = min(next_time, cur_time + t);
          }
        }
      }
      if (t[next_obs] < next_time + EPS) {
        next_time = t[next_obs];
      }
      double diff_time = next_time - cur_time;
      vi done(f.size());
      REP(i, b.size() - 1) {
        REP(j, f.size()) {
          if (done[j]) {
            continue;
          }
          if (b[i] < f[j] && f[j] < b[i + 1]) {
            done[j] = 1;
            tank[i] += a[j] * diff_time / ((b[i + 1] - b[i]) * 30);
            if (tank[i] + EPS > h[i]) {
              f[j] = b[i] - 1;
              done[j] = 1;
              mergeF(b, f, a, done);
            }
            if (tank[i] + EPS > h[i + 1]) {
              f[j] = b[i + 1] + 1;
              done[j] = 1;
              mergeF(b, f, a, done);
            }
            if (i > 0 && i < tank.size() - 1 &&
                abs(tank[i] - tank[i + 1]) < EPS && tank[i] + EPS > h[i + 1] &&
                tank[i + 1] + EPS > h[i + 1]) {
              b.erase(b.begin() + i);
              h.erase(h.begin() + i);
              tank.erase(tank.begin() + i);
            }
            if (i > 0 && abs(tank[i] - tank[i - 1]) < EPS &&
                tank[i] + EPS > h[i] && tank[i - 1] + EPS > h[i]) {
              b.erase(b.begin() + i);
              h.erase(h.begin() + i);
              tank.erase(tank.begin() + i);
              i--;
            }
          }
        }
      }
      if (abs(next_time - t[next_obs]) < EPS) {
        REP(k, b.size() - 1) {
          if (b[k] < p[next_obs] && p[next_obs] < b[k + 1]) {
            ans[ansindex[next_obs]] = (tank[k]);
            next_obs++;
            break;
          }
        }
      }
      cur_time = next_time;
    }
    REP(i, ans.size()) { cout << ans[i] << endl; }
  }
}