Problem p02347 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <bits/stdc++.h>
using namespace std;
// #define int long long
using ll = long long;
using vi = vector<int>;
using vl = vector<long long>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ITR(v, c) for (auto v = begin(c); v != end(c); ++v)
#define FORE(x, c) for (auto &x : c)
#define FOR(v, a, n) for (int v = a; v < (int)(n); ++v)
#define REP(v, n) FOR(v, 0, n)
#define RREP(v, n) for (int v = ((int)(n)-1); v >= 0; --v)
#define ALL(c) begin(c), end(c)
#define RALL(c) rbegin(c), rend(c)
#define SZ(c) ((int)c.size())
const int DX[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
          DY[9] = {-1, 0, 1, 0, -1, 1, 1, -1, 0};
const int INF = 1e9;
const long long INFLL = 1e18;
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
  ITR(i, v) os << *i << (i == end(v) - 1 ? "" : " ");
  return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
  ITR(i, v) is >> *i;
  return is;
}
//------------------------------------------------------------------------------

struct point {
  int id, x, y;
  point() : id(-1), x(0), y(0) {}
  point(int id, int x, int y) : id(id), x(x), y(y) {}
  point(int id, pair<int, int> xy) : id(id), x(xy.first), y(xy.second) {}
  bool operator<(const point &p) const { return id < p.id; }
};
class kdtree {
  struct node {
    int p;
    int location;
    int l, r;
    node() : l(NIL), r(NIL) {}
  };

  static bool lessX(const point &a, const point &b) { return a.x < b.x; }
  static bool lessY(const point &a, const point &b) { return a.y < b.y; }

  static const int NIL = -1;
  int root;
  int np;
  int N;

  int make_kd_tree(int l, int r, int depth) {
    if (!(l < r))
      return -1;
    int mid = (l + r) / 2;
    int t = np++;
    if (depth)
      sort(begin(P) + l, begin(P) + r, lessY);
    else
      sort(begin(P) + l, begin(P) + r, lessX);

    T[t].location = mid;
    T[t].l = make_kd_tree(l, mid, !depth);
    T[t].r = make_kd_tree(mid + 1, r, !depth);

    return t;
  }
  void find(int v, int sx, int sy, int tx, int ty, int depth,
            vector<point> &ans) {
    int x = P[T[v].location].x;
    int y = P[T[v].location].y;

    if (sx <= x && x <= tx && sy <= y && y <= ty) {
      ans.push_back(P[T[v].location]);
    }

    if (depth) {
      if (T[v].l != NIL && sy <= y)
        find(T[v].l, sx, sy, tx, ty, !depth, ans);
      if (T[v].r != NIL && y <= ty)
        find(T[v].r, sx, sy, tx, ty, !depth, ans);
    } else {
      if (T[v].l != NIL && sx <= x)
        find(T[v].l, sx, sy, tx, ty, !depth, ans);
      if (T[v].r != NIL && x <= tx)
        find(T[v].r, sx, sy, tx, ty, !depth, ans);
    }
  }

public:
  vector<node> T;
  vector<point> &P;
  kdtree(vector<point> &p) : P(p) {
    np = 0;
    N = p.size();
    T.resize(N);
    root = make_kd_tree(0, N, 0);
  }

  // ????¬?????????¢???????????????????????????????????????
  vector<point> query(int sx, int sy, int tx, int ty) {
    vector<point> p;
    find(root, sx, sy, tx, ty, 0, p);
    return p;
  }

  int getsize() { return N; }
};
signed main() {
  int n;
  scanf("%d", &n);
  vector<point> p(n);
  REP(i, n) {
    p[i].id = i;
    scanf("%d %d", &p[i].x, &p[i].y);
  }
  kdtree kdt(p);

  int q;
  cin >> q;
  REP(i, q) {
    int sx, tx, sy, ty;
    scanf("%d %d %d %d", &sx, &tx, &sy, &ty);
    vector<point> ans = kdt.query(sx, sy, tx, ty);
    sort(ALL(ans));
    REP(i, SZ(ans)) { printf("%d\\n", ans[i].id); }
    printf("\\n");
  }
  return 0;
}

Error: TLE

Fixed submission:

#include <bits/stdc++.h>
using namespace std;
// #define int long long
using ll = long long;
using vi = vector<int>;
using vl = vector<long long>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ITR(v, c) for (auto v = begin(c); v != end(c); ++v)
#define FORE(x, c) for (auto &x : c)
#define FOR(v, a, n) for (int v = a; v < (int)(n); ++v)
#define REP(v, n) FOR(v, 0, n)
#define RREP(v, n) for (int v = ((int)(n)-1); v >= 0; --v)
#define ALL(c) begin(c), end(c)
#define RALL(c) rbegin(c), rend(c)
#define SZ(c) ((int)c.size())
const int DX[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
          DY[9] = {-1, 0, 1, 0, -1, 1, 1, -1, 0};
const int INF = 1e9;
const long long INFLL = 1e18;
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
  ITR(i, v) os << *i << (i == end(v) - 1 ? "" : " ");
  return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
  ITR(i, v) is >> *i;
  return is;
}
//------------------------------------------------------------------------------

struct point {
  int id, x, y;
  point() : id(-1), x(0), y(0) {}
  point(int id, int x, int y) : id(id), x(x), y(y) {}
  point(int id, pair<int, int> xy) : id(id), x(xy.first), y(xy.second) {}
  bool operator<(const point &p) const { return id < p.id; }
};
class kdtree {
  struct node {
    int p;
    int location;
    int l, r;
    node() : l(NIL), r(NIL) {}
  };

  static bool lessX(const point &a, const point &b) { return a.x < b.x; }
  static bool lessY(const point &a, const point &b) { return a.y < b.y; }

  static const int NIL = -1;
  int root;
  int np;
  int N;

  int make_kd_tree(int l, int r, int depth) {
    if (!(l < r))
      return -1;
    int mid = (l + r) / 2;
    int t = np++;
    if (depth)
      sort(begin(P) + l, begin(P) + r, lessY);
    else
      sort(begin(P) + l, begin(P) + r, lessX);

    T[t].location = mid;
    T[t].l = make_kd_tree(l, mid, !depth);
    T[t].r = make_kd_tree(mid + 1, r, !depth);

    return t;
  }
  void find(int v, int sx, int sy, int tx, int ty, int depth,
            vector<point> &ans) {
    int x = P[T[v].location].x;
    int y = P[T[v].location].y;

    if (sx <= x && x <= tx && sy <= y && y <= ty) {
      ans.push_back(P[T[v].location]);
    }

    if (depth) {
      if (T[v].l != NIL && sy <= y)
        find(T[v].l, sx, sy, tx, ty, !depth, ans);
      if (T[v].r != NIL && y <= ty)
        find(T[v].r, sx, sy, tx, ty, !depth, ans);
    } else {
      if (T[v].l != NIL && sx <= x)
        find(T[v].l, sx, sy, tx, ty, !depth, ans);
      if (T[v].r != NIL && x <= tx)
        find(T[v].r, sx, sy, tx, ty, !depth, ans);
    }
  }

public:
  vector<node> T;
  vector<point> &P;
  kdtree(vector<point> &p) : P(p) {
    np = 0;
    N = p.size();
    T.resize(N);
    root = make_kd_tree(0, N, 0);
  }

  // ????¬?????????¢???????????????????????????????????????
  vector<point> query(int sx, int sy, int tx, int ty) {
    vector<point> p;
    find(root, sx, sy, tx, ty, 0, p);
    return p;
  }

  int getsize() { return N; }
};
signed main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  int n;
  cin >> n;
  vector<point> p(n);
  REP(i, n) {
    p[i].id = i;
    cin >> p[i].x >> p[i].y;
  }
  kdtree kdt(p);

  int q;
  cin >> q;
  REP(i, q) {
    int sx, tx, sy, ty;
    cin >> sx >> tx >> sy >> ty;
    vector<point> ans = kdt.query(sx, sy, tx, ty);
    sort(ALL(ans));
    REP(i, SZ(ans)) { cout << ans[i].id << endl; }
    cout << endl;
  }
  return 0;
}