Problem p03033 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <valarray>
#include <vector>

#define rep(i, m, n) for (int i = int(m); i < int(n); i++)
#define all(c) begin(c), end(c)
#define ALL(v) (v).begin(), (v).end()

template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
  if (a > b)
    a = b;
}

template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
  if (a < b)
    a = b;
}

// 改造
typedef long long int ll;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0 // デバッグする時1にしてね
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 1000000007

// ここから編集する
template <typename T> class segtree {
  int size;
  vector<T> valtree;
  vector<int> ismixedtree;

public:
  segtree(int n) {
    size = 8;
    while (size < n)
      size <<= 1;
    valtree.resize(size * 2);
    ismixedtree.resize(size * 2);
  }

  void fill(T val) {
    std::fill(ALL(valtree), val);
    std::fill(ALL(ismixedtree), 0);
  }

  void setvalrange(int begin, int end, T val, int ptr = 0, int rangebegin = 0,
                   int rangeend = 0) {
    if (rangeend <= rangebegin) {
      rangeend = size;
    }

    if (rangeend <= begin || end <= rangebegin)
      return;

    if (begin <= rangebegin && rangeend <= end) {
      ismixedtree[ptr] = false;
      valtree[ptr] = val;
      return;
    }

    int rangemid = (rangebegin + rangeend) / 2;
    if (ismixedtree[ptr] == false) {
      // lazy
      valtree[ptr * 2 + 1] = valtree[ptr];
      valtree[ptr * 2 + 2] = valtree[ptr];
      ismixedtree[ptr * 2 + 1] = false;
      ismixedtree[ptr * 2 + 2] = false;
    }
    ismixedtree[ptr] = true;

    setvalrange(begin, end, val, ptr * 2 + 1, rangebegin, rangemid);
    setvalrange(begin, end, val, ptr * 2 + 2, rangemid, rangeend);
  }

  T getval(int index, int ptr = 0, int rangebegin = 0, int rangeend = 0) {
    if (rangeend <= rangebegin) {
      rangeend = size;
    }

    if (ismixedtree[ptr] == false) {
      return valtree[ptr];
    }

    int rangemid = (rangebegin + rangeend) / 2;
    if (index < rangemid)
      return getval(index, ptr * 2 + 1, rangebegin, rangemid);
    else
      return getval(index, ptr * 2 + 2, rangemid, rangeend);
  }
};

int N, Q;
vector<ll> S, T, X;
vector<ll> D;

vector<ll> inv;
map<ll, int> zat;
// unordered_map<ll, int> zat;

void input() {
  cin >> N >> Q;
  S.resize(N);
  T.resize(N);
  X.resize(N);
  D.resize(Q);
  rep(i, 0, N) {
    cin >> S[i] >> T[i] >> X[i];
    inv.push_back(S[i] - X[i]);
    //            inv.push_back(T[i] - X[i] + 1);
    inv.push_back(T[i] - X[i]);
  }
  rep(i, 0, Q) {
    cin >> D[i];
    inv.push_back(D[i]);
    //            inv.push_back(D[i] + 1);
  }

  sort(all(inv));
  inv.erase(unique(all(inv)), inv.end());
  sort(all(inv));
  for (int i = 0; i < inv.size(); ++i) {
    zat[inv[i]] = i;
  }
}

auto maket() {
  //    int n = zat.size() + 1;
  //    using T = pair<ll, int>;//value,time
  //    using E = pair<ll, int>;//value,time
  //    int time = 0;
  //
  //    T ti(INFl, 0); //要素の単位元?
  //    E ei(INFl, 0); //作用素の単位元?
  //    auto f = [](T a, T b) { return min(a, b); }; // 要素と要素のマージ
  //    auto g = [](T a, E b) {
  ////        if(b == INT_MAX) return a;
  ////        return b;
  //        if (a.second < b.second) {
  //            return b;
  //        } else {
  //            return a;
  //        }
  //    }; // 要素に作用素を作用
  //    auto h = [](E a, E b) {
  //        if (a.second < b.second) {
  //            return b;
  //        } else {
  //            return a;
  //        }
  //    }; // 作用素と作用素をマージ
  //
  //    auto p = [](E a, int b) { return a; }; // 作用素を区間加算する場合
  //
  //    SegmentTree <T, E> treeone(n, f, g, h, ti, ei, p);
  //    return treeone;
}

void solve() {
  input();
  int time = 0;
  int n = zat.size() + 1;
  segtree<int> seg(n);
  seg.fill(0x7FFFFFFF);
  struct tapi {
    ll s, t, x;
  };
  vector<tapi> tapya;
  for (int i = 0; i < N; ++i) {
    tapya.push_back({S[i] - X[i], T[i] - X[i], X[i]});
  }
  sort(all(tapya), [](auto a, auto b) { return a.x > b.x; });

  for (auto ei : tapya) {
    using T = pair<ll, int>; // value,time
    //            cerr << zat[ei.s] << " " << zat[ei.t] << endl;
    //        tree1.update(zat[ei.s], zat[ei.t], T(ei.x, ++time));
    seg.setvalrange(zat[ei.s], zat[ei.t], ei.x);

    //            cerr << "---" << endl;
    //            for (auto e : inv) cerr << e << " ";
    //            cerr << endl;
    //            for (auto e : inv) cerr << tree1.query(zat[e], zat[e] +
    //            1).first << " "; cerr << endl;
  }

  for (auto d : D) {
    //        auto tmp = tree1.query(zat[d], zat[d] + 1);
    ll tmp = seg.getval(zat[d]);
    ll ans = tmp;
    if (ans == 2147483647) {
      cout << -1 << endl;
    } else {
      cout << ans << endl;
    }
  }
}

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);

  solve();

  return 0;
}


Fixed submission:
#include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <valarray>
#include <vector>

#define rep(i, m, n) for (int i = int(m); i < int(n); i++)
#define all(c) begin(c), end(c)
#define ALL(v) (v).begin(), (v).end()

template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
  if (a > b)
    a = b;
}

template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
  if (a < b)
    a = b;
}

// 改造
typedef long long int ll;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0 // デバッグする時1にしてね
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 1000000007

// ここから編集する
template <typename T> class segtree {
  int size;
  vector<T> valtree;
  vector<int> ismixedtree;

public:
  segtree(int n) {
    size = 8;
    while (size < n)
      size <<= 1;
    valtree.resize(size * 2);
    ismixedtree.resize(size * 2);
  }

  void fill(T val) {
    std::fill(ALL(valtree), val);
    std::fill(ALL(ismixedtree), 0);
  }

  void setvalrange(int begin, int end, T val, int ptr = 0, int rangebegin = 0,
                   int rangeend = 0) {
    if (rangeend <= rangebegin) {
      rangeend = size;
    }

    if (rangeend <= begin || end <= rangebegin)
      return;

    if (begin <= rangebegin && rangeend <= end) {
      ismixedtree[ptr] = false;
      valtree[ptr] = val;
      return;
    }

    int rangemid = (rangebegin + rangeend) / 2;
    if (ismixedtree[ptr] == false) {
      // lazy
      valtree[ptr * 2 + 1] = valtree[ptr];
      valtree[ptr * 2 + 2] = valtree[ptr];
      ismixedtree[ptr * 2 + 1] = false;
      ismixedtree[ptr * 2 + 2] = false;
    }
    ismixedtree[ptr] = true;

    setvalrange(begin, end, val, ptr * 2 + 1, rangebegin, rangemid);
    setvalrange(begin, end, val, ptr * 2 + 2, rangemid, rangeend);
  }

  T getval(int index, int ptr = 0, int rangebegin = 0, int rangeend = 0) {
    if (rangeend <= rangebegin) {
      rangeend = size;
    }

    if (ismixedtree[ptr] == false) {
      return valtree[ptr];
    }

    int rangemid = (rangebegin + rangeend) / 2;
    if (index < rangemid)
      return getval(index, ptr * 2 + 1, rangebegin, rangemid);
    else
      return getval(index, ptr * 2 + 2, rangemid, rangeend);
  }
};

int N, Q;
vector<ll> S, T, X;
vector<ll> D;

vector<ll> inv;
// map<ll, int> zat;
unordered_map<ll, int> zat;

void input() {
  cin >> N >> Q;
  S.resize(N);
  T.resize(N);
  X.resize(N);
  D.resize(Q);
  rep(i, 0, N) {
    cin >> S[i] >> T[i] >> X[i];
    inv.push_back(S[i] - X[i]);
    //            inv.push_back(T[i] - X[i] + 1);
    inv.push_back(T[i] - X[i]);
  }
  rep(i, 0, Q) {
    cin >> D[i];
    inv.push_back(D[i]);
    //            inv.push_back(D[i] + 1);
  }

  sort(all(inv));
  inv.erase(unique(all(inv)), inv.end());
  sort(all(inv));
  for (int i = 0; i < inv.size(); ++i) {
    zat[inv[i]] = i;
  }
}

auto maket() {
  //    int n = zat.size() + 1;
  //    using T = pair<ll, int>;//value,time
  //    using E = pair<ll, int>;//value,time
  //    int time = 0;
  //
  //    T ti(INFl, 0); //要素の単位元?
  //    E ei(INFl, 0); //作用素の単位元?
  //    auto f = [](T a, T b) { return min(a, b); }; // 要素と要素のマージ
  //    auto g = [](T a, E b) {
  ////        if(b == INT_MAX) return a;
  ////        return b;
  //        if (a.second < b.second) {
  //            return b;
  //        } else {
  //            return a;
  //        }
  //    }; // 要素に作用素を作用
  //    auto h = [](E a, E b) {
  //        if (a.second < b.second) {
  //            return b;
  //        } else {
  //            return a;
  //        }
  //    }; // 作用素と作用素をマージ
  //
  //    auto p = [](E a, int b) { return a; }; // 作用素を区間加算する場合
  //
  //    SegmentTree <T, E> treeone(n, f, g, h, ti, ei, p);
  //    return treeone;
}

void solve() {
  input();
  int time = 0;
  int n = zat.size() + 1;
  segtree<int> seg(n);
  seg.fill(0x7FFFFFFF);
  struct tapi {
    ll s, t, x;
  };
  vector<tapi> tapya;
  for (int i = 0; i < N; ++i) {
    tapya.push_back({S[i] - X[i], T[i] - X[i], X[i]});
  }
  sort(all(tapya), [](auto a, auto b) { return a.x > b.x; });

  for (auto ei : tapya) {
    using T = pair<ll, int>; // value,time
    //            cerr << zat[ei.s] << " " << zat[ei.t] << endl;
    //        tree1.update(zat[ei.s], zat[ei.t], T(ei.x, ++time));
    seg.setvalrange(zat[ei.s], zat[ei.t], ei.x);

    //            cerr << "---" << endl;
    //            for (auto e : inv) cerr << e << " ";
    //            cerr << endl;
    //            for (auto e : inv) cerr << tree1.query(zat[e], zat[e] +
    //            1).first << " "; cerr << endl;
  }

  for (auto d : D) {
    //        auto tmp = tree1.query(zat[d], zat[d] + 1);
    ll tmp = seg.getval(zat[d]);
    ll ans = tmp;
    if (ans == 2147483647) {
      cout << -1 << endl;
    } else {
      cout << ans << endl;
    }
  }
}

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);

  solve();

  return 0;
}