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

#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define FOR(i, k, n) for (int(i) = (k); (i) < (n); ++(i))
#define rep(i, n) FOR(i, 0, n)
#define all(v) begin(v), end(v)
#ifdef ONLINE_JUDGE
#define debug(x)
#define debug2(x, y)
#define debug3(x, y, z)
#define assert(e)                                                              \\
  if (!(e)) {                                                                  \\
    stod("");                                                                  \\
  }
#else
#define debug(x) std::cerr << #x << ": " << x << "\\n"
#define debug2(x, y)                                                           \\
  std::cerr << #x << ": " << x << ", " << #y << ": " << y << "\\n"
#define debug3(x, y, z)                                                        \\
  std::cerr << #x << ": " << x << ", " << #y << ": " << y << ", " << #z        \\
            << ": " << z << "\\n"
#endif

using ll = long long;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
template <typename T> using vvec = std::vector<std::vector<T>>;
template <typename T> auto make_v(size_t sz) { return std::vector<T>(sz); }
template <typename T, typename... Ts> auto make_v(size_t sz, Ts... ts) {
  return std::vector<decltype(make_v<T>(ts...))>(sz, make_v<T>(ts...));
}
template <typename T> void fill_v(T &var, const T &x) { var = x; }
template <typename V, typename T> void fill_v(V &v, const T &x) {
  for (auto &&w : v) {
    fill_v(w, x);
  }
}

template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  int sz = v.size();
  s << "\\n";
  rep(i, sz) {
    s << v[i];
    if (i < sz - 1) {
      s << "\\t";
    }
  }
  s << "\\n";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &v) {
  for (auto &&w : v) {
    s << w;
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  int sz = v.size();
  s << "\\n";
  rep(i, sz) {
    s << v[i];
    if (i < sz - 1) {
      s << "\\t";
    }
  }
  s << "\\n";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<std::deque<T>> &v) {
  for (auto &&w : v) {
    s << w;
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &v) {
  s << "\\n";
  for (auto &&elm : v) {
    s << elm << "\\t";
  }
  s << "\\n";
  return s;
}

inline void scan(int &a) { scanf("%d", &a); }
inline void scan(ll &a) { scanf("%lld", &a); }
inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
template <typename T> inline void scan(std::vector<T> &v) {
  for (auto &&sv : v) {
    scan(sv);
  }
}
template <typename First, typename... Args>
inline void scan(First &f, Args &...args) {
  scan(f);
  scan(args...);
}
inline void scan(std::string &s) {
  char BUF[3000000];
  scanf(" %s", BUF);
  s = std::string(BUF);
}
inline void print(int a) { printf("%d\\n", a); }
inline void print(ll a) { printf("%lld\\n", a); }
inline void print(double a) { printf("%.12f\\n", a); }
inline void print(std::string s) { std::cout << s << "\\n"; }

using namespace std;

void inf() {
  print("INF");
  exit(0);
}

struct Cell {
  int y, x;
};

void solve() {
  int n, m;
  scan(n, m);
  vll ally, allx;
  ally.reserve(4000);
  allx.reserve(4000);
  ally.push_back(0);
  allx.push_back(0);
  vll a(n), b(n), c(n);
  rep(i, n) {
    scan(a[i], b[i], c[i]);
    ally.push_back(a[i]);
    ally.push_back(b[i]);
    allx.push_back(c[i]);
  }
  vll d(m), e(m), f(m);
  rep(i, m) {
    scan(d[i], e[i], f[i]);
    ally.push_back(d[i]);
    allx.push_back(e[i]);
    allx.push_back(f[i]);
  }
  sort(all(ally));
  ally.erase(std::unique(ally.begin(), ally.end()), ally.end());
  sort(all(allx));
  allx.erase(std::unique(allx.begin(), allx.end()), allx.end());
  int ysz = ally.size();
  int xsz = allx.size();
  unordered_map<ll, ll> yidx, xidx;
  rep(i, ysz) { yidx[ally[i]] = i; }
  rep(i, xsz) { xidx[allx[i]] = i; }
  int ycell = ysz - 1;
  int xcell = xsz - 1;

  if (0 <= ally[0] || ally[ycell] <= 0 || 0 <= allx[0] || allx[xcell] <= 0) {
    inf();
  }
  vvi vborder(xsz, vi(ycell, 0));
  rep(i, n) {
    int x_index = xidx[c[i]];
    int y_min = yidx[a[i]];
    int y_max = yidx[b[i]];
    FOR(y, y_min, y_max) { vborder[x_index][y] = 1; }
  }
  vvi hborder(ysz, vi(xcell, 0));
  rep(i, m) {
    int y_index = yidx[d[i]];
    int x_min = xidx[e[i]];
    int x_max = xidx[f[i]];
    FOR(x, x_min, x_max) { hborder[y_index][x] = 1; }
  }

  debug("start bfs");
  vvi field(ycell, vi(xcell, 0));
  int y0 = upper_bound(all(ally), 0) - begin(ally) - 1;
  int x0 = upper_bound(all(allx), 0) - begin(allx) - 1;
  assert(0 <= y0 && y0 < ycell && 0 <= x0 && x0 < xcell);
  field[y0][x0] = 1;
  debug2(y0, x0);
  deque<Cell> q;
  q.push_back(Cell{y0, x0});
  vi dy = {0, 1, 0, -1};
  vi dx = {1, 0, -1, 0};
  while (!q.empty()) {
    Cell cell = q.front();
    q.pop_front();
    int y = cell.y;
    int x = cell.x;
    vi borders = {vborder[x + 1][y], hborder[y + 1][x], vborder[x][y],
                  hborder[y][x]};
    rep(k, 4) {
      if (borders[k] == 1) {
        continue;
      }
      int ny = y + dy[k];
      int nx = x + dx[k];
      if (ny < 0 || ycell <= ny || nx < 0 || xcell <= nx) {
        debug2(ny, nx);
        debug2(ally[ny], allx[nx]);
        return inf();
      }
      if (field[ny][nx] == 1) {
        continue;
      }
      field[ny][nx] = 1;
      q.push_back(Cell{ny, nx});
    }
  }
  // debug(field);
  ll ans = 0;
  rep(i, ycell) {
    ll ylen = ally[i + 1] - ally[i];
    rep(j, xcell) {
      if (field[i][j] == 0) {
        continue;
      }
      ll xlen = allx[j + 1] - allx[j];
      ans += ylen * xlen;
    }
  }
  print(ans);
}

int main() {
  solve();
  return 0;
}


Error: WA

Fixed submission:

#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define FOR(i, k, n) for (int(i) = (k); (i) < (n); ++(i))
#define rep(i, n) FOR(i, 0, n)
#define all(v) begin(v), end(v)
#ifdef ONLINE_JUDGE
#define debug(x)
#define debug2(x, y)
#define debug3(x, y, z)
#define assert(e)                                                              \\
  if (!(e)) {                                                                  \\
    stod("");                                                                  \\
  }
#else
#define debug(x) std::cerr << #x << ": " << x << "\\n"
#define debug2(x, y)                                                           \\
  std::cerr << #x << ": " << x << ", " << #y << ": " << y << "\\n"
#define debug3(x, y, z)                                                        \\
  std::cerr << #x << ": " << x << ", " << #y << ": " << y << ", " << #z        \\
            << ": " << z << "\\n"
#endif

using ll = long long;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
template <typename T> using vvec = std::vector<std::vector<T>>;
template <typename T> auto make_v(size_t sz) { return std::vector<T>(sz); }
template <typename T, typename... Ts> auto make_v(size_t sz, Ts... ts) {
  return std::vector<decltype(make_v<T>(ts...))>(sz, make_v<T>(ts...));
}
template <typename T> void fill_v(T &var, const T &x) { var = x; }
template <typename V, typename T> void fill_v(V &v, const T &x) {
  for (auto &&w : v) {
    fill_v(w, x);
  }
}

template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  int sz = v.size();
  s << "\\n";
  rep(i, sz) {
    s << v[i];
    if (i < sz - 1) {
      s << "\\t";
    }
  }
  s << "\\n";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &v) {
  for (auto &&w : v) {
    s << w;
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  int sz = v.size();
  s << "\\n";
  rep(i, sz) {
    s << v[i];
    if (i < sz - 1) {
      s << "\\t";
    }
  }
  s << "\\n";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<std::deque<T>> &v) {
  for (auto &&w : v) {
    s << w;
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &v) {
  s << "\\n";
  for (auto &&elm : v) {
    s << elm << "\\t";
  }
  s << "\\n";
  return s;
}

inline void scan(int &a) { scanf("%d", &a); }
inline void scan(ll &a) { scanf("%lld", &a); }
inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
template <typename T> inline void scan(std::vector<T> &v) {
  for (auto &&sv : v) {
    scan(sv);
  }
}
template <typename First, typename... Args>
inline void scan(First &f, Args &...args) {
  scan(f);
  scan(args...);
}
inline void scan(std::string &s) {
  char BUF[3000000];
  scanf(" %s", BUF);
  s = std::string(BUF);
}
inline void print(int a) { printf("%d\\n", a); }
inline void print(ll a) { printf("%lld\\n", a); }
inline void print(double a) { printf("%.12f\\n", a); }
inline void print(std::string s) { std::cout << s << "\\n"; }

using namespace std;

void inf() {
  print("INF");
  exit(0);
}

struct Cell {
  int y, x;
};

void solve() {
  int n, m;
  scan(n, m);
  vll ally, allx;
  ally.reserve(2 * n + m);
  allx.reserve(n + 2 * m);
  vll a(n), b(n), c(n);
  rep(i, n) {
    scan(a[i], b[i], c[i]);
    ally.push_back(a[i]);
    ally.push_back(b[i]);
    allx.push_back(c[i]);
  }
  vll d(m), e(m), f(m);
  rep(i, m) {
    scan(d[i], e[i], f[i]);
    ally.push_back(d[i]);
    allx.push_back(e[i]);
    allx.push_back(f[i]);
  }
  sort(all(ally));
  ally.erase(std::unique(ally.begin(), ally.end()), ally.end());
  sort(all(allx));
  allx.erase(std::unique(allx.begin(), allx.end()), allx.end());
  int ysz = ally.size();
  int xsz = allx.size();
  unordered_map<ll, ll> yidx, xidx;
  rep(i, ysz) { yidx[ally[i]] = i; }
  rep(i, xsz) { xidx[allx[i]] = i; }
  int ycell = ysz - 1;
  int xcell = xsz - 1;

  if (0 <= ally[0] || ally[ycell] <= 0 || 0 <= allx[0] || allx[xcell] <= 0) {
    inf();
  }
  vvi vborder(xsz, vi(ycell, 0));
  rep(i, n) {
    int x_index = lower_bound(all(allx), c[i]) - begin(allx);
    int y_min = lower_bound(all(ally), a[i]) - begin(ally);
    int y_max = lower_bound(all(ally), b[i]) - begin(ally);
    FOR(y, y_min, y_max) { vborder[x_index][y] = 1; }
  }
  vvi hborder(ysz, vi(xcell, 0));
  rep(i, n) {
    int y_index = lower_bound(all(ally), d[i]) - begin(ally);
    int x_min = lower_bound(all(allx), e[i]) - begin(allx);
    int x_max = lower_bound(all(allx), f[i]) - begin(allx);
    FOR(x, x_min, x_max) { hborder[y_index][x] = 1; }
  }
  print("INF");
  exit(0);

  vvi field(ycell, vi(xcell, 0));
  int y0 = upper_bound(all(ally), 0) - begin(ally) - 1;
  int x0 = upper_bound(all(allx), 0) - begin(allx) - 1;
  assert(0 <= y0 && y0 < ycell && 0 <= x0 && x0 < xcell);
  field[y0][x0] = 1;
  debug2(y0, x0);
  deque<Cell> q;
  q.push_back(Cell{y0, x0});
  vi dy = {0, 1, 0, -1};
  vi dx = {1, 0, -1, 0};
  while (!q.empty()) {
    Cell cell = q.front();
    q.pop_front();
    int y = cell.y;
    int x = cell.x;
    vi borders = {vborder[x + 1][y], hborder[y + 1][x], vborder[x][y],
                  hborder[y][x]};
    rep(k, 4) {
      if (borders[k] == 1) {
        continue;
      }
      int ny = y + dy[k];
      int nx = x + dx[k];
      if (ny < 0 || ycell <= ny || nx < 0 || xcell <= nx) {
        return inf();
      }
      if (field[ny][nx] == 1) {
        continue;
      }
      field[ny][nx] = 1;
      q.push_back(Cell{ny, nx});
    }
  }
  // debug(field);
  ll ans = 0;
  rep(i, ycell) {
    ll ylen = ally[i + 1] - ally[i];
    rep(j, xcell) {
      if (field[i][j] == 0) {
        continue;
      }
      ll xlen = allx[j + 1] - allx[j];
      ans += ylen * xlen;
    }
  }
  print(ans);
}

int main() {
  solve();
  return 0;
}