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

#include <cstdio>
// #include<iostream>
#include <algorithm>
#include <utility>
#include <vector>
using namespace std;

struct Pos {
  int x;
  int y;
  int order;
};
bool asc_x(const Pos &l, const Pos &r) { return l.x < r.x; }
bool asc_y(const Pos &l, const Pos &r) { return l.y < r.y; }

struct Node {
  int x;
  int y;
  int order;
  Node *left;
  Node *right;
};

class Tree {
  Node *root;
  Node *makeTree(vector<Pos> &A, int l, int r, int depth) {
    if (l > r)
      return nullptr;
    if (depth % 2) {
      sort(A.begin() + l, A.begin() + r + 1, asc_y);
    } else {
      sort(A.begin() + l, A.begin() + r + 1, asc_x);
    }
    int mid = (l + r) / 2;
    Node *p = new Node;
    p->x = A[mid].x;
    p->y = A[mid].y;
    p->order = A[mid].order;
    p->left = makeTree(A, l, mid - 1, depth + 1);
    p->right = makeTree(A, mid + 1, r, depth + 1);
    return p;
  }
  void find_(Node *n, int sx, int tx, int sy, int ty, int depth,
             vector<int> &ans) {
    if (n == nullptr)
      return;
    int n_, s, t;
    if (depth % 2) {
      n_ = n->y;
      s = sy;
      t = ty;
    } else {
      n_ = n->x;
      s = sx;
      t = tx;
    }
    if (n_ >= s)
      find_(n->left, sx, tx, sy, ty, depth + 1, ans);
    if (n->x >= sx && n->x <= tx && n->y >= sy && n->y <= ty) {
      ans.push_back(n->order);
    }
    if (n_ <= t)
      find_(n->right, sx, tx, sy, ty, depth + 1, ans);
  }

public:
  Tree(vector<Pos> &A) { root = makeTree(A, 0, A.size() - 1, 0); }
  void find(int sx, int tx, int sy, int ty) {
    vector<int> ans;
    find_(root, sx, tx, sy, ty, 0, ans);
    sort(ans.begin(), ans.end());
    for (int i = 0; i < ans.size(); i++) {
      // cout << ans[i] << endl;
      printf("%d\\n", ans[i]);
    }
    // cout << endl;
    printf("\\n");
  }
};

int main() {
  int n;
  // cin >> n;
  scanf("%d", &n);
  vector<Pos> A(n);
  for (int i = 0; i < n; i++) {
    // cin >> A[i].x >> A[i].y;
    scanf("%d %d", &(A[i].x), &(A[i].y));
    A[i].order = i;
  }
  Tree T(A);
  int q;
  // cin >> q;
  scanf("%d", &q);
  for (int i = 0; i < q; i++) {
    int sx, tx, sy, ty;
    // cin >> sx >> tx >> sy >> ty;
    scanf("%d %d %d %d", &sx, &tx, &sy, &ty);
    T.find(sx, tx, sy, ty);
  }
  return 0;
}


Error: TLE

Fixed submission:

// #include<cstdio>
#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;

struct Pos {
  int x;
  int y;
  int order;
};
bool asc_x(const Pos &l, const Pos &r) { return l.x < r.x; }
bool asc_y(const Pos &l, const Pos &r) { return l.y < r.y; }

struct Node {
  int x;
  int y;
  int order;
  Node *left;
  Node *right;
};

class Tree {
  Node *root;
  Node *makeTree(vector<Pos> &A, int l, int r, int depth) {
    if (l > r)
      return nullptr;
    if (depth % 2) {
      sort(A.begin() + l, A.begin() + r + 1, asc_y);
    } else {
      sort(A.begin() + l, A.begin() + r + 1, asc_x);
    }
    int mid = (l + r) / 2;
    Node *p = new Node;
    p->x = A[mid].x;
    p->y = A[mid].y;
    p->order = A[mid].order;
    p->left = makeTree(A, l, mid - 1, depth + 1);
    p->right = makeTree(A, mid + 1, r, depth + 1);
    return p;
  }
  void find_(Node *n, int sx, int tx, int sy, int ty, int depth,
             vector<int> &ans) {
    if (n == nullptr)
      return;
    int n_, s, t;
    if (depth % 2) {
      n_ = n->y;
      s = sy;
      t = ty;
    } else {
      n_ = n->x;
      s = sx;
      t = tx;
    }
    if (n_ >= s)
      find_(n->left, sx, tx, sy, ty, depth + 1, ans);
    if (n->x >= sx && n->x <= tx && n->y >= sy && n->y <= ty) {
      ans.push_back(n->order);
    }
    if (n_ <= t)
      find_(n->right, sx, tx, sy, ty, depth + 1, ans);
  }

public:
  Tree(vector<Pos> &A) { root = makeTree(A, 0, A.size() - 1, 0); }
  void find(int sx, int tx, int sy, int ty) {
    vector<int> ans;
    find_(root, sx, tx, sy, ty, 0, ans);
    sort(ans.begin(), ans.end());
    for (int i = 0; i < ans.size(); i++) {
      cout << ans[i] << endl;
    }
    cout << endl;
  }
};

int main() {
  int n;
  cin >> n;
  vector<Pos> A(n);
  for (int i = 0; i < n; i++) {
    cin >> A[i].x >> A[i].y;
    A[i].order = i;
  }
  Tree T(A);
  int q;
  cin >> q;
  for (int i = 0; i < q; i++) {
    int sx, tx, sy, ty;
    cin >> sx >> tx >> sy >> ty;
    T.find(sx, tx, sy, ty);
  }
  return 0;
}