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

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

#define NIL -1

struct Point {
  int location;
  int x;
  int y;
};

bool asc_x(const Point &l, const Point &r) { return l.x < r.x; }

bool asc_y(const Point &l, const Point &r) { return l.y < r.y; }

struct Node {
  Point p;
  int left_idx;
  int right_idx;
};

class Tree {
private:
  vector<Node> N;
  int t_idx;

  int AddNode(vector<Point> &P, int l, int r, int depth) {
    if (l > r)
      return NIL;
    int m = (l + r) / 2;
    if (depth % 2) {
      sort(P.begin() + l, P.begin() + r + 1, asc_y);
    } else {
      sort(P.begin() + l, P.begin() + r + 1, asc_x);
    }
    int idx = t_idx++;
    N[idx].p = P[m];
    N[idx].left_idx = AddNode(P, l, m - 1, depth + 1);
    N[idx].right_idx = AddNode(P, m + 1, r, depth + 1);
    return idx;
  }
  void findNode(int s_x, int t_x, int s_y, int t_y, int idx, int depth,
                vector<int> &ans) {
    if (idx == NIL)
      return;
    if (s_x <= N[idx].p.x && N[idx].p.x <= t_x && s_y <= N[idx].p.y &&
        N[idx].p.y <= t_y) {
      ans.push_back(N[idx].p.location);
    }
    if (depth % 2) {
      if (N[idx].p.y <= t_y) {
        findNode(s_x, t_x, s_y, t_y, N[idx].right_idx, depth + 1, ans);
      }
      if (N[idx].p.y >= s_y) {
        findNode(s_x, t_x, s_y, t_y, N[idx].left_idx, depth + 1, ans);
      }
    } else {
      if (N[idx].p.x <= t_x) {
        findNode(s_x, t_x, s_y, t_y, N[idx].right_idx, depth + 1, ans);
      }
      if (N[idx].p.x >= s_x) {
        findNode(s_x, t_x, s_y, t_y, N[idx].left_idx, depth + 1, ans);
      }
    }
  }

public:
  Tree(int n) {
    N.resize(n);
    t_idx = 0;
  }

  int MakeTree(vector<Point> &P) { AddNode(P, 0, P.size() - 1, 0); }

  void find(int s_x, int t_x, int s_y, int t_y, vector<int> &ans) {
    findNode(s_x, t_x, s_y, t_y, 0, 0, ans);
  }

  void display() {
    for (int i = 0; i < N.size(); i++) {
      cout << i << " ";
      cout << N[i].p.x << " ";
      cout << N[i].p.y << " ";
      cout << N[i].left_idx << " ";
      cout << N[i].right_idx << " ";
      cout << endl;
    }
    cout << endl;
  }
};

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

  int n;
  scanf("%d", &n);
  // cin >> n;
  vector<Point> P(n);

  for (int i = 0; i < n; i++) {
    // cin >> P[i].x >> P[i].y;
    scanf("%d %d", &P[i].x, &P[i].y);
    P[i].location = i;
  }
  Tree T(n);
  T.MakeTree(P);
  // T.display();
  int q;
  cin >> q;
  for (int i = 0; i < q; i++) {
    int s_x, t_x, s_y, t_y;
    // cin >> s_x >> t_x >> s_y >> t_y;
    scanf("%d %d %d %d", &s_x, &t_x, &s_y, &t_y);
    vector<int> ans;
    T.find(s_x, t_x, s_y, t_y, ans);
    sort(ans.begin(), ans.end());
    for (int j = 0; j < ans.size(); j++) {
      // cout << ans[j] << endl;
      printf("%d\\n", ans[j]);
    }
    // cout << endl;
    printf("\\n");
  }
  return 0;
}

Error: TLE

Fixed submission:

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

#define NIL -1

struct Point {
  int location;
  int x;
  int y;
};

bool asc_x(const Point &l, const Point &r) { return l.x < r.x; }

bool asc_y(const Point &l, const Point &r) { return l.y < r.y; }

struct Node {
  Point p;
  int left_idx;
  int right_idx;
};

class Tree {
private:
  vector<Node> N;
  int t_idx;

  int AddNode(vector<Point> &P, int l, int r, int depth) {
    if (l > r)
      return NIL;
    int m = (l + r) / 2;
    if (depth % 2) {
      sort(P.begin() + l, P.begin() + r + 1, asc_y);
    } else {
      sort(P.begin() + l, P.begin() + r + 1, asc_x);
    }
    int idx = t_idx++;
    N[idx].p = P[m];
    N[idx].left_idx = AddNode(P, l, m - 1, depth + 1);
    N[idx].right_idx = AddNode(P, m + 1, r, depth + 1);
    return idx;
  }
  void findNode(int s_x, int t_x, int s_y, int t_y, int idx, int depth,
                vector<int> &ans) {
    if (idx == NIL)
      return;
    if (s_x <= N[idx].p.x && N[idx].p.x <= t_x && s_y <= N[idx].p.y &&
        N[idx].p.y <= t_y) {
      ans.push_back(N[idx].p.location);
    }
    if (depth % 2) {
      if (N[idx].p.y <= t_y) {
        findNode(s_x, t_x, s_y, t_y, N[idx].right_idx, depth + 1, ans);
      }
      if (N[idx].p.y >= s_y) {
        findNode(s_x, t_x, s_y, t_y, N[idx].left_idx, depth + 1, ans);
      }
    } else {
      if (N[idx].p.x <= t_x) {
        findNode(s_x, t_x, s_y, t_y, N[idx].right_idx, depth + 1, ans);
      }
      if (N[idx].p.x >= s_x) {
        findNode(s_x, t_x, s_y, t_y, N[idx].left_idx, depth + 1, ans);
      }
    }
  }

public:
  Tree(int n) {
    N.resize(n);
    t_idx = 0;
  }

  int MakeTree(vector<Point> &P) { AddNode(P, 0, P.size() - 1, 0); }

  void find(int s_x, int t_x, int s_y, int t_y, vector<int> &ans) {
    findNode(s_x, t_x, s_y, t_y, 0, 0, ans);
  }

  void display() {
    for (int i = 0; i < N.size(); i++) {
      cout << i << " ";
      cout << N[i].p.x << " ";
      cout << N[i].p.y << " ";
      cout << N[i].left_idx << " ";
      cout << N[i].right_idx << " ";
      cout << endl;
    }
    cout << endl;
  }
};

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++) {
    cin >> P[i].x >> P[i].y;
    P[i].location = i;
  }
  Tree T(n);
  T.MakeTree(P);
  // T.display();
  int q;
  cin >> q;
  for (int i = 0; i < q; i++) {
    int s_x, t_x, s_y, t_y;
    cin >> s_x >> t_x >> s_y >> t_y;
    vector<int> ans;
    T.find(s_x, t_x, s_y, t_y, ans);
    sort(ans.begin(), ans.end());
    for (int j = 0; j < ans.size(); j++) {
      cout << ans[j] << endl;
    }
    cout << endl;
  }
  return 0;
}