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

#include <bits/stdc++.h>
using namespace std;

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 {
private:
  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;
  vector<node> T;
  vector<point> &P;

  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:
  kdtree(vector<point> &p) : P(p) {
    np = 0;
    N = p.size();
    T.resize(N);
    root = make_kd_tree(0, N, 0);
  }
  void query(int sx, int sy, int tx, int ty, vector<point> &p) {
    find(root, sx, sy, tx, ty, 0, p);
  }
};

int main() {
  int n;
  cin >> n;
  vector<point> p(n);
  for (int i = 0; i < n; i++) {
    p[i].id = i;
    scanf("%d %d", &p[i].x, &p[i].y);
  }
  kdtree tree(p);
  int q;
  cin >> q;
  while (q--) {
    int sx, tx, sy, ty;
    scanf("%d %d %d %d", &sx, &tx, &sy, &ty);

    vector<point> ans;
    tree.query(sx, sy, tx, ty, ans);

    sort(begin(ans), end(ans));
    for (int i = 0; i < (int)ans.size(); i++) {
      printf("%d\\n", ans[i].id);
    }
    printf("\\n");
  }
  return 0;
}

Error: TLE

Fixed submission:

#include <bits/stdc++.h>
using namespace std;

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 {
private:
  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;
  vector<node> T;
  vector<point> &P;

  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:
  kdtree(vector<point> &p) : P(p) {
    np = 0;
    N = p.size();
    T.resize(N);
    root = make_kd_tree(0, N, 0);
  }
  void query(int sx, int sy, int tx, int ty, vector<point> &p) {
    find(root, sx, sy, tx, ty, 0, p);
  }
};

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  int n;
  cin >> n;
  vector<point> p(n);
  for (int i = 0; i < n; i++) {
    p[i].id = i;
    cin >> p[i].x >> p[i].y;
  }
  kdtree tree(p);
  int q;
  cin >> q;
  while (q--) {
    int sx, tx, sy, ty;
    cin >> sx >> tx >> sy >> ty;

    vector<point> ans;
    tree.query(sx, sy, tx, ty, ans);

    sort(begin(ans), end(ans));
    for (int i = 0; i < (int)ans.size(); i++) {
      cout << ans[i].id << endl;
    }
    cout << endl;
  }
  return 0;
}