Problem p03033 (C++)

Buggy submission (status: Time Limit Exceeded):
////////////////////////////////////////
///  tu3 pro-con template            ///
////////////////////////////////////////
#include "bits/stdc++.h"
using namespace std;

// -- typedefs -- //
#define EPS 1e-9
typedef long long llong;

// -- loop macros -- //
#define REP(i, n) for (auto i = decltype(n)(0); i < (n); i++)
#define RREP(i, n) for (auto i = (n)-1; i >= 0; i--)
#define FOR(i, s, n) for (auto i = (s); i < (n); i++)
#define FORR(i, s, n) for (auto i = (n)-1; i >= (s); i--)
#define FORE(exp) for (auto &&exp)
#define allof(c) c.begin(), c.end()
#define partof(c, s, e) c.begin() + (s), c.begin() + (e)

// -- functors -- //
#define PREDICATE(t, a, ...) [&](const t &a) -> bool { return __VA_ARGS__; }
#define PRED(a, ...) PREDICATE(auto, a, __VA_ARGS__)
#define COMPARISON(t, a, b, ...)                                               \
  [&](const t &a, const t &b) -> bool { return __VA_ARGS__; }
#define COMP(a, b, ...) COMPARISON(auto, a, b, __VA_ARGS__)
#define CONV1(a, ...)                                                          \
  [&](const auto &a) -> auto{ return __VA_ARGS__; }
#define CONV2(a, b, ...)                                                       \
  [&](const auto &a, const auto &b) -> auto{ return __VA_ARGS__; }
#define CONV3(a, b, c, ...)                                                    \
  [&](const auto &a, const auto &b, const auto &c) -> auto{                    \
    return __VA_ARGS__;                                                        \
  }

// -- I/O Helper -- //
struct _Reader {
  istream &cin;
  template <class T> _Reader operator,(T &rhs) {
    cin >> rhs;
    return *this;
  }
};
struct _Writer {
  ostream &cout;
  const char *delim{" "};
  bool f{false};
  template <class T> _Writer operator,(const T &rhs) {
    cout << (f ? delim : "") << rhs;
    f = true;
    return *this;
  }
};
#define READ(t, ...)                                                           \
  t __VA_ARGS__;                                                               \
  (_Reader{cin}), __VA_ARGS__
#define WRITE(...) (_Writer{cout}), __VA_ARGS__, "\n"
#define WRITELN(...) (_Writer{cout, "\n"}), __VA_ARGS__, "\n"
#ifdef _DEBUG
#define DEBUG(...) (_Writer{cerr}), "DEBUG -> ", __VA_ARGS__, "\n"
#else
#define DEBUG(...)
#endif

// -- vevector -- //
template <class T> struct vevector : vector<vector<T>> {
  vevector(size_t n = 0, size_t m = 0, const T &initial = T())
      : vector<vector<T>>(n, vector<T>(m, initial)) {}
};
template <class T> struct vevevector : vector<vevector<T>> {
  vevevector(size_t n = 0, size_t m = 0, size_t l = 0, const T &initial = T())
      : vector<vevector<T>>(n, vevector<T>(m, l, initial)) {}
};
template <class T> struct vevevevector : vector<vevevector<T>> {
  vevevevector(size_t n = 0, size_t m = 0, size_t l = 0, size_t k = 0,
               const T &initial = T())
      : vector<vevevector<T>>(n, vevevector<T>(m, l, k, initial)) {}
};

namespace std {
template <class T1, class T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
  in >> p.first >> p.second;
  return in;
}
template <class T1, class T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
  out << p.first << " " << p.second;
  return out;
}
} // namespace std

template <class T> T read() {
  T t;
  cin >> t;
  return t;
}
template <class T> vector<T> read(int n) {
  vector<T> v;
  REP(i, n) { v.push_back(read<T>()); }
  return v;
}
template <class T> vevector<T> read(int n, int m) {
  vevector<T> v;
  REP(i, n) v.push_back(read<T>(m));
  return v;
}
template <class T> vector<T> readjag() { return read<T>(read<int>()); }
template <class T> vevector<T> readjag(int n) {
  vevector<T> v;
  REP(i, n) v.push_back(readjag<T>());
  return v;
}

template <class T> struct iter_range_t {
  T beg, end;
};
template <class T> iter_range_t<T> iter_range(T beg, T end) {
  return iter_range_t<T>{beg, end};
}
template <class T> ostream &operator<<(ostream &out, iter_range_t<T> v) {
  if (v.beg != v.end) {
    out << *v.beg++;
    while (v.beg != v.end) {
      out << " " << *v.beg++;
    }
  }
  return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
  return out << iter_range(allof(v));
}

// -- etc -- //
template <class T> T infinity_value();
template <> int infinity_value<int>() { return int(1) << 28; }
template <> llong infinity_value<llong>() { return llong(1) << 60; }
template <> double infinity_value<double>() { return 1e+300 * 1e+300; }
#define INF(T) infinity_value<T>()

inline int sign_of(double x) { return (abs(x) < EPS ? 0 : x > 0 ? 1 : -1); }
template <class TInt> bool in_range(TInt val, TInt min, TInt max) {
  return val >= min && val < max;
}
template <> bool in_range<double>(double val, double min, double max) {
  return val - min > -EPS && val - max < EPS;
}
template <class TInt> bool in_range2d(TInt x, TInt y, TInt w, TInt h) {
  return x >= 0 && x < w && y >= 0 && y < h;
}
vector<int> iotavn(int start, int count) {
  vector<int> r(count);
  iota(allof(r), start);
  return r;
}

//// start up ////
void solve();
int32_t main() {
  //// for local debugging
  // freopen("input.txt", "right_", stdin);
  // freopen("output.txt", "w", stdout);

  // auto classic_table = ctype<char>::classic_table();
  // vector<ctype<char>::mask> ctable(classic_table, classic_table +
  // ctype<char>::table_size); ctable[':'] |= ctype_base::space; // as delimitor
  // ctable[','] |= ctype_base::space; // as delimitor
  // cin.imbue(locale(cin.getloc(), new ctype<char>(ctable.data())));

  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  cout << fixed;
  cout << setprecision(std::numeric_limits<double>::max_digits10);

  solve();

  return 0;
}

/// 座圧 座標圧縮
template <class T> struct CoordinateCompression {
  map<T, int> comp{};
  vector<T> decomp{};
  vector<T> init(const vector<T> &orig) {
    decomp = orig;
    decomp.push_back(numeric_limits<T>::min());
    decomp.push_back(numeric_limits<T>::max());
    sort(allof(decomp));
    decomp.erase(unique(allof(decomp)), decomp.end());
    REP(i, decomp.size()) { comp[decomp[i]] = i; }
    vector<T> ret(orig.size());
    REP(i, orig.size()) { ret[i] = comp[orig[i]]; }
    return ret;
  }
  size_t size() { return decomp.size(); }
  T operator[](int x) {
    return decomp[x];
  } ///< 圧縮後の値xはもともと何の値だったのか？
};

////////////////////
/// template end ///
////////////////////

void solve() {
  READ(llong, N, Q);

  vector<llong> koji;
  vector<llong> zahyo;
  REP(i, N) {
    READ(int, S, T, X);
    koji.push_back(X);
    zahyo.push_back(X - T + 1);
    zahyo.push_back(X - S + 1);

    DEBUG(X - T + 1, X - S + 1, X);
  }
  auto D = read<int>(Q);
  FORE(d : D) { zahyo.push_back(-d); }

  CoordinateCompression<int> comp;
  vector<int> zahyo2 = comp.init(std::vector<int>(allof(zahyo)));

  vector<llong> mp(comp.size(), INF(llong));
  REP(i, N) {
    FOR(j, zahyo2[i * 2], zahyo2[i * 2 + 1]) {
      mp[j] = min<llong>(mp[j], koji[i]);
    }
  }

  REP(i, Q) {
    auto a = mp[zahyo2[N * 2 + i]];
    WRITE(a == INF(llong) ? -1 : a);
  }
}


Fixed submission:
////////////////////////////////////////
///  tu3 pro-con template            ///
////////////////////////////////////////
#include "bits/stdc++.h"
using namespace std;

// -- typedefs -- //
#define EPS 1e-9
typedef long long llong;

// -- loop macros -- //
#define REP(i, n) for (auto i = decltype(n)(0); i < (n); i++)
#define RREP(i, n) for (auto i = (n)-1; i >= 0; i--)
#define FOR(i, s, n) for (auto i = (s); i < (n); i++)
#define FORR(i, s, n) for (auto i = (n)-1; i >= (s); i--)
#define FORE(exp) for (auto &&exp)
#define allof(c) c.begin(), c.end()
#define partof(c, s, e) c.begin() + (s), c.begin() + (e)

// -- functors -- //
#define PREDICATE(t, a, ...) [&](const t &a) -> bool { return __VA_ARGS__; }
#define PRED(a, ...) PREDICATE(auto, a, __VA_ARGS__)
#define COMPARISON(t, a, b, ...)                                               \
  [&](const t &a, const t &b) -> bool { return __VA_ARGS__; }
#define COMP(a, b, ...) COMPARISON(auto, a, b, __VA_ARGS__)
#define CONV1(a, ...)                                                          \
  [&](const auto &a) -> auto{ return __VA_ARGS__; }
#define CONV2(a, b, ...)                                                       \
  [&](const auto &a, const auto &b) -> auto{ return __VA_ARGS__; }
#define CONV3(a, b, c, ...)                                                    \
  [&](const auto &a, const auto &b, const auto &c) -> auto{                    \
    return __VA_ARGS__;                                                        \
  }

// -- I/O Helper -- //
struct _Reader {
  istream &cin;
  template <class T> _Reader operator,(T &rhs) {
    cin >> rhs;
    return *this;
  }
};
struct _Writer {
  ostream &cout;
  const char *delim{" "};
  bool f{false};
  template <class T> _Writer operator,(const T &rhs) {
    cout << (f ? delim : "") << rhs;
    f = true;
    return *this;
  }
};
#define READ(t, ...)                                                           \
  t __VA_ARGS__;                                                               \
  (_Reader{cin}), __VA_ARGS__
#define WRITE(...) (_Writer{cout}), __VA_ARGS__, "\n"
#define WRITELN(...) (_Writer{cout, "\n"}), __VA_ARGS__, "\n"
#ifdef _DEBUG
#define DEBUG(...) (_Writer{cerr}), "DEBUG -> ", __VA_ARGS__, "\n"
#else
#define DEBUG(...)
#endif

// -- vevector -- //
template <class T> struct vevector : vector<vector<T>> {
  vevector(size_t n = 0, size_t m = 0, const T &initial = T())
      : vector<vector<T>>(n, vector<T>(m, initial)) {}
};
template <class T> struct vevevector : vector<vevector<T>> {
  vevevector(size_t n = 0, size_t m = 0, size_t l = 0, const T &initial = T())
      : vector<vevector<T>>(n, vevector<T>(m, l, initial)) {}
};
template <class T> struct vevevevector : vector<vevevector<T>> {
  vevevevector(size_t n = 0, size_t m = 0, size_t l = 0, size_t k = 0,
               const T &initial = T())
      : vector<vevevector<T>>(n, vevevector<T>(m, l, k, initial)) {}
};

namespace std {
template <class T1, class T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
  in >> p.first >> p.second;
  return in;
}
template <class T1, class T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
  out << p.first << " " << p.second;
  return out;
}
} // namespace std

template <class T> T read() {
  T t;
  cin >> t;
  return t;
}
template <class T> vector<T> read(int n) {
  vector<T> v;
  REP(i, n) { v.push_back(read<T>()); }
  return v;
}
template <class T> vevector<T> read(int n, int m) {
  vevector<T> v;
  REP(i, n) v.push_back(read<T>(m));
  return v;
}
template <class T> vector<T> readjag() { return read<T>(read<int>()); }
template <class T> vevector<T> readjag(int n) {
  vevector<T> v;
  REP(i, n) v.push_back(readjag<T>());
  return v;
}

template <class T> struct iter_range_t {
  T beg, end;
};
template <class T> iter_range_t<T> iter_range(T beg, T end) {
  return iter_range_t<T>{beg, end};
}
template <class T> ostream &operator<<(ostream &out, iter_range_t<T> v) {
  if (v.beg != v.end) {
    out << *v.beg++;
    while (v.beg != v.end) {
      out << " " << *v.beg++;
    }
  }
  return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
  return out << iter_range(allof(v));
}

// -- etc -- //
template <class T> T infinity_value();
template <> int infinity_value<int>() { return int(1) << 28; }
template <> llong infinity_value<llong>() { return llong(1) << 60; }
template <> double infinity_value<double>() { return 1e+300 * 1e+300; }
#define INF(T) infinity_value<T>()

inline int sign_of(double x) { return (abs(x) < EPS ? 0 : x > 0 ? 1 : -1); }
template <class TInt> bool in_range(TInt val, TInt min, TInt max) {
  return val >= min && val < max;
}
template <> bool in_range<double>(double val, double min, double max) {
  return val - min > -EPS && val - max < EPS;
}
template <class TInt> bool in_range2d(TInt x, TInt y, TInt w, TInt h) {
  return x >= 0 && x < w && y >= 0 && y < h;
}
vector<int> iotavn(int start, int count) {
  vector<int> r(count);
  iota(allof(r), start);
  return r;
}

//// start up ////
void solve();
int32_t main() {
  //// for local debugging
  // freopen("input.txt", "right_", stdin);
  // freopen("output.txt", "w", stdout);

  // auto classic_table = ctype<char>::classic_table();
  // vector<ctype<char>::mask> ctable(classic_table, classic_table +
  // ctype<char>::table_size); ctable[':'] |= ctype_base::space; // as delimitor
  // ctable[','] |= ctype_base::space; // as delimitor
  // cin.imbue(locale(cin.getloc(), new ctype<char>(ctable.data())));

  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  cout << fixed;
  cout << setprecision(std::numeric_limits<double>::max_digits10);

  solve();

  return 0;
}

/// 座圧 座標圧縮
template <class T> struct CoordinateCompression {
  map<T, int> comp{};
  vector<T> decomp{};
  vector<T> init(const vector<T> &orig) {
    decomp = orig;
    decomp.push_back(numeric_limits<T>::min());
    decomp.push_back(numeric_limits<T>::max());
    sort(allof(decomp));
    decomp.erase(unique(allof(decomp)), decomp.end());
    REP(i, decomp.size()) { comp[decomp[i]] = i; }
    vector<T> ret(orig.size());
    REP(i, orig.size()) { ret[i] = comp[orig[i]]; }
    return ret;
  }
  size_t size() { return decomp.size(); }
  T operator[](int x) {
    return decomp[x];
  } ///< 圧縮後の値xはもともと何の値だったのか？
};

////////////////////
/// template end ///
////////////////////

void solve() {
  READ(llong, N, Q);

  vector<llong> koji;
  vector<llong> zahyo;
  REP(i, N) {
    READ(int, S, T, X);
    koji.push_back(X);
    zahyo.push_back(X - T + 1);
    zahyo.push_back(X - S + 1);

    DEBUG(X - T + 1, X - S + 1, X);
  }
  auto D = read<int>(Q);
  FORE(d : D) { zahyo.push_back(-d); }

  CoordinateCompression<int> comp;
  vector<int> zahyo2 = comp.init(std::vector<int>(allof(zahyo)));

  vector<llong> mp(comp.size());

  {
    vevector<pair<int, llong>> w(mp.size());
    REP(i, N) {
      w[zahyo2[i * 2]].push_back({1, koji[i]});
      w[zahyo2[i * 2 + 1]].push_back({0, koji[i]});
    }

    set<llong> w2 = {INF(llong)};
    REP(i, mp.size()) {
      sort(allof(w[i]));
      FORE(c : w[i]) {
        if (c.first == 0) {
          w2.erase(c.second);
        } else {
          w2.insert(c.second);
        }
      }
      mp[i] = *w2.begin();
    }
  }

  REP(i, Q) {
    auto a = mp[zahyo2[N * 2 + i]];
    WRITE(a == INF(llong) ? -1 : a);
  }
}