Datasets:

hackercupai
/

hackercup

#include <algorithm>
#include <cstring>
#include <iostream>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;

const int LIM = 300003;
using pii = pair<int, int>;
#define x first
#define y second

struct Compressor {
  int N;
  vector<pii> V;

  Compressor() {}
  Compressor(vector<pii> _V) {
    V = _V;
    comp();
  }

  void insert(pii v) {
    V.push_back(v);
  }

  void comp() {
    sort(V.begin(), V.end());
    N = unique(V.begin(), V.end()) - V.begin();
    V.resize(N);
  }

  int get(pii v) {
    return lower_bound(V.begin(), V.end(), v) - V.begin();
  }
};

const int TLIM = 2100000;
const int ZERO_VAL = 0;
const int ZERO_LAZY = 0;

struct MaxRangeSegTree {
  static void update_value(int &a, int v, int r1, int r2) { a += v; }
  static void update_lazy(int &a, int v, int r1, int r2) { a += v; }
  static int join_values(int v1, int v2) { return max(v1, v2); }

  int N, sz;
  int tree[TLIM];
  int lazy[TLIM];

  MaxRangeSegTree() {}
  MaxRangeSegTree(int _N) { init(_N); }

  void init(int _N) {
    N = _N;
    for (sz = 1; sz < N; sz <<= 1)
      ;
    clear();
  }

  void clear() {
    for (int i = 0; i < (sz << 1); i++) {
      tree[i] = ZERO_VAL;
      lazy[i] = ZERO_LAZY;
    }
  }

  void propagate(int i, int r1, int r2) {
    int v = lazy[i];
    lazy[i] = ZERO_LAZY;
    update_value(tree[i], v, r1, r2);
    if (i < sz) {
      int m = (r1 + r2) >> 1, c1 = i << 1, c2 = c1 + 1;
      update_lazy(lazy[c1], v, r1, m);
      update_lazy(lazy[c2], v, m + 1, r2);
    }
  }

  void comp(int i) {
    int c1 = i << 1, c2 = c1 + 1;
    tree[i] = join_values(tree[c1], tree[c2]);
  }

  int query(int a, int b, int i = 1, int r1 = 0, int r2 = -1) {
    if (r2 < 0) {
      a = max(a, 0);
      b = min(b, sz - 1);
      if (a > b) {
        return ZERO_VAL;
      }
      r2 = sz - 1;
    }
    propagate(i, r1, r2);
    if (a <= r1 && r2 <= b) {
      return tree[i];
    }
    int m = (r1 + r2) >> 1, c = i << 1;
    int res = ZERO_VAL;
    if (a <= m) {
      res = join_values(res, query(a, b, c, r1, m));
    }
    if (b > m) {
      res = join_values(res, query(a, b, c + 1, m + 1, r2));
    }
    return res;
  }

  void update(int a, int b, int v, int i = 1, int r1 = 0, int r2 = -1) {
    if (r2 < 0) {
      a = max(a, 0);
      b = min(b, sz - 1);
      if (a > b) {
        return;
      }
      r2 = sz - 1;
    }
    if (r2 < 0) {
      r2 = sz - 1;
    }
    propagate(i, r1, r2);
    if (a <= r1 && r2 <= b) {
      update_lazy(lazy[i], v, r1, r2);
      propagate(i, r1, r2);
      return;
    }
    int m = (r1 + r2) >> 1, c = i << 1;
    if (a <= m) {
      update(a, b, v, c, r1, m);
    }
    if (b > m) {
      update(a, b, v, c + 1, m + 1, r2);
    }
    propagate(c, r1, m);
    propagate(c + 1, m + 1, r2);
    comp(i);
  }
};

const pii NONE{-1, -1};

struct MaxElemSegTree {
  pii join_values(pii v1, pii v2) { return max(v1, v2); }

  int N, sz;
  vector<pii> tree;

  MaxElemSegTree() {}
  MaxElemSegTree(int _N) { init(_N); }

  void init(int _N) {
    N = _N;
    for (sz = 1; sz < N; sz <<= 1)
      ;
    clear();
  }

  void clear() {
    tree.clear();
    tree.resize(sz << 1, NONE);
  }

  void comp(int i) {
    int c1 = i << 1, c2 = c1 + 1;
    tree[i] = join_values(tree[c1], tree[c2]);
  }

  pii query(int a, int b, int i = 1, int r1 = 0, int r2 = -1) {
    if (r2 < 0) {
      a = max(a, 0);
      b = min(b, sz - 1);
      if (a > b) {
        return NONE;
      }
      r2 = sz - 1;
    }
    if (a <= r1 && r2 <= b) {
      return tree[i];
    }
    int m = (r1 + r2) >> 1, c = i << 1;
    pii res = NONE;
    if (a <= m) {
      res = join_values(res, query(a, b, c, r1, m));
    }
    if (b > m) {
      res = join_values(res, query(a, b, c + 1, m + 1, r2));
    }
    return res;
  }

  void update_one(int i, pii p) {
    i += sz;
    tree[i] = p;
    while (i > 1) {
      i >>= 1;
      comp(i);
    }
  }
};

struct NestedSegTree {
  int N, sz;
  bool has_init_keys;
  vector<int> keys[TLIM];
  MaxElemSegTree T[TLIM];

  NestedSegTree() {}
  NestedSegTree(int _N) { init(_N); }

  void init(int _N) {
    N = _N;
    for (sz = 1; sz < N; sz <<= 1)
      ;
    has_init_keys = false;
  }

  void init_keys() {
    for (int i = sz; i < sz + N; i++) {
      auto &k = keys[i];
      sort(k.begin(), k.end());
      k.resize(unique(k.begin(), k.end()) - k.begin());
      T[i].init(k.size());
    }
    for (int i = sz - 1; i >= 1; i--) {
      auto &k = keys[i], &c1 = keys[i << 1], &c2 = keys[(i << 1) + 1];
      int a = 0, b = 0;
      while (a < c1.size() || b < c2.size()) {
        if (a < c1.size() && b < c2.size() && c1[a] == c2[b]) {
          k.push_back(c1[a++]);
          b++;
        } else if (b == c2.size() || (a < c1.size() && c1[a] < c2[b])) {
          k.push_back(c1[a++]);
        } else {
          k.push_back(c2[b++]);
        }
      }
      T[i].init(k.size());
    }
    has_init_keys = true;
  }

  pii query_max_up_to_k(int a, int b, int k, int i = 1, int r1 = 0, int r2 = -1) {
    if (r2 < 0) {
      a = max(a, 0);
      b = min(b, sz - 1);
      if (a > b) {
        return NONE;
      }
      r2 = sz - 1;
    }
    if (a <= r1 && r2 <= b) {
      k = lower_bound(keys[i].begin(), keys[i].end(), k + 1) - keys[i].begin() - 1;
      return T[i].query(0, k);
    }
    int m = (r1 + r2) >> 1, c = i << 1;
    pii res = NONE;
    if (a <= m) {
      res = max(res, query_max_up_to_k(a, b, k, c, r1, m));
    }
    if (b > m) {
      res = max(res, query_max_up_to_k(a, b, k, c + 1, m + 1, r2));
    }
    return res;
  }

  void update_one(int i, int k, pii p) {
    i += sz;
    if (!has_init_keys) {
      keys[i].push_back(k);
      return;
    }
    while (i >= 1) {
      T[i].update_one(
        lower_bound(keys[i].begin(), keys[i].end(), k) - keys[i].begin(), p
      );
      i >>= 1;
    }
  }
};

int N;
pair<pii, pii> A[LIM], B[LIM];
int Axx[LIM], Axy[LIM];
int lowerX[3 * LIM], lowerY[3 * LIM];
bool visit[LIM];
NestedSegTree STX, STY;

void update_A_rect(int i, bool ins) {
  STX.update_one(A[i].x.x, Axy[i], ins ? make_pair(A[i].y.y, i) : NONE);
  STX.update_one(A[i].y.x, Axy[i], ins ? make_pair(A[i].y.y, i) : NONE);
  STY.update_one(A[i].x.y, Axx[i], ins ? make_pair(A[i].y.x, i) : NONE);
  STY.update_one(A[i].y.y, Axx[i], ins ? make_pair(A[i].y.x, i) : NONE);
}

int get_A_rect_for_B_rect(int i) {
  pii p = STX.query_max_up_to_k(B[i].x.x, B[i].y.x, B[i].y.y);
  if (p.x >= B[i].x.y) {
    return p.y;
  }
  p = STY.query_max_up_to_k(B[i].x.y, B[i].y.y, B[i].y.x);
  if (p.x >= B[i].x.x) {
    return p.y;
  }
  return -1;
}

bool rec(int i) {
  visit[i] = true;
  for (;;) {
    int j = get_A_rect_for_B_rect(i);
    if (j < 0) {
      break;
    }
    if (visit[j]) {
      return true;
    }
    if (rec(j)) {
      return true;
    }
  }
  update_A_rect(i, 0);
  return false;
}

bool solve() {
  Compressor cx, cy;
  // Input, and compute flipped rectangles.
  cin >> N;
  for (int i = 0; i < N; i++) {
    char c;
    cin >> A[i].x.x >> A[i].x.y >> A[i].y.x >> A[i].y.y >> c;
    B[i] = A[i];
    switch (c) {
      case 'U': B[i].x.y += A[i].y.y; break;
      case 'D': B[i].x.y -= A[i].y.y; break;
      case 'L': B[i].x.x -= A[i].y.x; break;
      case 'R': B[i].x.x += A[i].y.x; break;
    }
    A[i].y.x += A[i].x.x;
    A[i].y.y += A[i].x.y;
    B[i].y.x += B[i].x.x;
    B[i].y.y += B[i].x.y;
    cx.insert({A[i].x.x, i});
    cx.insert({A[i].y.x, i}),
    cx.insert({B[i].x.x, i});
    cx.insert({B[i].y.x, i});
    cy.insert({A[i].x.y, i});
    cy.insert({A[i].y.y, i});
    cy.insert({B[i].x.y, i});
    cy.insert({B[i].y.y, i});
  }
  // Compress coordinates.
  cx.comp(), cy.comp();
  auto V = cx.V;
  for (int i = 0; i < V.size(); i++) {
    lowerX[i] = (i == 0 || V[i - 1].x != V[i].x) ? i : lowerX[i - 1];
  }
  V = cy.V;
  for (int i = 0; i < V.size(); i++) {
    lowerY[i] = (i == 0 || V[i - 1].x != V[i].x) ? i : lowerY[i - 1];
  }
  for (int i = 0; i < N; i++) {
    A[i].x.x = cx.get({A[i].x.x, i});
    A[i].x.y = cy.get({A[i].x.y, i}),
    A[i].y.x = cx.get({A[i].y.x, i});
    A[i].y.y = cy.get({A[i].y.y, i});
    B[i].x.x = cx.get({B[i].x.x, i});
    B[i].x.y = cy.get({B[i].x.y, i}),
    B[i].y.x = cx.get({B[i].y.x, i});
    B[i].y.y = cy.get({B[i].y.y, i});
    // Remember exact (unique) lower coordinates.
    Axx[i] = A[i].x.x, Axy[i] = A[i].x.y;
    // Round coordinates up to value boundaries (with exclusive upper
    // coordinates).
    A[i].x.x = lowerX[A[i].x.x];
    B[i].x.x = lowerX[B[i].x.x];
    A[i].x.y = lowerY[A[i].x.y];
    B[i].x.y = lowerY[B[i].x.y];
    A[i].y.x = lowerX[A[i].y.x] - 1;
    B[i].y.x = lowerX[B[i].y.x] - 1;
    A[i].y.y = lowerY[A[i].y.y] - 1;
    B[i].y.y = lowerY[B[i].y.y] - 1;
  }
  // Check for any overlap between final tables via line sweep.
  vector<tuple<int, int, int, int>> E;
  for (int i = 0; i < N; i++) {
    E.emplace_back(B[i].x.y, 1, B[i].x.x, B[i].y.x);
    E.emplace_back(B[i].y.y + 1, -1, B[i].x.x, B[i].y.x);
  }
  sort(E.begin(), E.end());
  MaxRangeSegTree ST(cx.V.size());
  for (auto e : E) {
    ST.update(get<2>(e), get<3>(e), get<1>(e));
    if (ST.query(0, cx.V.size() - 1) > 1) {
      return false;
    }
  }
  // Initialize segment trees of initial tables, over x and y coordinates.
  STX = NestedSegTree(cx.V.size());
  STY = NestedSegTree(cy.V.size());
  for (int j : {0, 1}) {
    if (j) {  // Initialize keys second time around.
      STX.init_keys();
      STY.init_keys();
    }
    for (int i = 0; i < N; i++) {
      // Set up keys first time around, then perform actual updates.
      update_A_rect(i, 1);
    }
  }
  // Search for cycles via DFS.
  memset(visit, 0, sizeof visit);
  for (int i = 0; i < N; i++) {
    if (!visit[i]) {
      if (rec(i)) {
        return false;  // Cycle found.
      }
    }
  }
  return true;
}

int main() {
  int T;
  cin >> T;
  for (int t = 1; t <= T; t++) {
    cout << "Case #" << t << ": " << (solve() ? "YES" : "NO") << endl;
  }
  return 0;
}

	#include <algorithm>
	#include <cstring>
	#include <iostream>
	#include <tuple>
	#include <utility>
	#include <vector>
	using namespace std;

	const int LIM = 300003;
	using pii = pair<int, int>;
	#define x first
	#define y second

	struct Compressor {
	int N;
	vector<pii> V;

	Compressor() {}
	Compressor(vector<pii> _V) {
	V = _V;
	comp();
	}

	void insert(pii v) {
	V.push_back(v);
	}

	void comp() {
	sort(V.begin(), V.end());
	N = unique(V.begin(), V.end()) - V.begin();
	V.resize(N);
	}

	int get(pii v) {
	return lower_bound(V.begin(), V.end(), v) - V.begin();
	}
	};

	const int TLIM = 2100000;
	const int ZERO_VAL = 0;
	const int ZERO_LAZY = 0;

	struct MaxRangeSegTree {
	static void update_value(int &a, int v, int r1, int r2) { a += v; }
	static void update_lazy(int &a, int v, int r1, int r2) { a += v; }
	static int join_values(int v1, int v2) { return max(v1, v2); }

	int N, sz;
	int tree[TLIM];
	int lazy[TLIM];

	MaxRangeSegTree() {}
	MaxRangeSegTree(int _N) { init(_N); }

	void init(int _N) {
	N = _N;
	for (sz = 1; sz < N; sz <<= 1)
	;
	clear();
	}

	void clear() {
	for (int i = 0; i < (sz << 1); i++) {
	tree[i] = ZERO_VAL;
	lazy[i] = ZERO_LAZY;
	}
	}

	void propagate(int i, int r1, int r2) {
	int v = lazy[i];
	lazy[i] = ZERO_LAZY;
	update_value(tree[i], v, r1, r2);
	if (i < sz) {
	int m = (r1 + r2) >> 1, c1 = i << 1, c2 = c1 + 1;
	update_lazy(lazy[c1], v, r1, m);
	update_lazy(lazy[c2], v, m + 1, r2);
	}
	}

	void comp(int i) {
	int c1 = i << 1, c2 = c1 + 1;
	tree[i] = join_values(tree[c1], tree[c2]);
	}

	int query(int a, int b, int i = 1, int r1 = 0, int r2 = -1) {
	if (r2 < 0) {
	a = max(a, 0);
	b = min(b, sz - 1);
	if (a > b) {
	return ZERO_VAL;
	}
	r2 = sz - 1;
	}
	propagate(i, r1, r2);
	if (a <= r1 && r2 <= b) {
	return tree[i];
	}
	int m = (r1 + r2) >> 1, c = i << 1;
	int res = ZERO_VAL;
	if (a <= m) {
	res = join_values(res, query(a, b, c, r1, m));
	}
	if (b > m) {
	res = join_values(res, query(a, b, c + 1, m + 1, r2));
	}
	return res;
	}

	void update(int a, int b, int v, int i = 1, int r1 = 0, int r2 = -1) {
	if (r2 < 0) {
	a = max(a, 0);
	b = min(b, sz - 1);
	if (a > b) {
	return;
	}
	r2 = sz - 1;
	}
	if (r2 < 0) {
	r2 = sz - 1;
	}
	propagate(i, r1, r2);
	if (a <= r1 && r2 <= b) {
	update_lazy(lazy[i], v, r1, r2);
	propagate(i, r1, r2);
	return;
	}
	int m = (r1 + r2) >> 1, c = i << 1;
	if (a <= m) {
	update(a, b, v, c, r1, m);
	}
	if (b > m) {
	update(a, b, v, c + 1, m + 1, r2);
	}
	propagate(c, r1, m);
	propagate(c + 1, m + 1, r2);
	comp(i);
	}
	};

	const pii NONE{-1, -1};

	struct MaxElemSegTree {
	pii join_values(pii v1, pii v2) { return max(v1, v2); }

	int N, sz;
	vector<pii> tree;

	MaxElemSegTree() {}
	MaxElemSegTree(int _N) { init(_N); }

	void init(int _N) {
	N = _N;
	for (sz = 1; sz < N; sz <<= 1)
	;
	clear();
	}

	void clear() {
	tree.clear();
	tree.resize(sz << 1, NONE);
	}

	void comp(int i) {
	int c1 = i << 1, c2 = c1 + 1;
	tree[i] = join_values(tree[c1], tree[c2]);
	}

	pii query(int a, int b, int i = 1, int r1 = 0, int r2 = -1) {
	if (r2 < 0) {
	a = max(a, 0);
	b = min(b, sz - 1);
	if (a > b) {
	return NONE;
	}
	r2 = sz - 1;
	}
	if (a <= r1 && r2 <= b) {
	return tree[i];
	}
	int m = (r1 + r2) >> 1, c = i << 1;
	pii res = NONE;
	if (a <= m) {
	res = join_values(res, query(a, b, c, r1, m));
	}
	if (b > m) {
	res = join_values(res, query(a, b, c + 1, m + 1, r2));
	}
	return res;
	}

	void update_one(int i, pii p) {
	i += sz;
	tree[i] = p;
	while (i > 1) {
	i >>= 1;
	comp(i);
	}
	}
	};

	struct NestedSegTree {
	int N, sz;
	bool has_init_keys;
	vector<int> keys[TLIM];
	MaxElemSegTree T[TLIM];

	NestedSegTree() {}
	NestedSegTree(int _N) { init(_N); }

	void init(int _N) {
	N = _N;
	for (sz = 1; sz < N; sz <<= 1)
	;
	has_init_keys = false;
	}

	void init_keys() {
	for (int i = sz; i < sz + N; i++) {
	auto &k = keys[i];
	sort(k.begin(), k.end());
	k.resize(unique(k.begin(), k.end()) - k.begin());
	T[i].init(k.size());
	}
	for (int i = sz - 1; i >= 1; i--) {
	auto &k = keys[i], &c1 = keys[i << 1], &c2 = keys[(i << 1) + 1];
	int a = 0, b = 0;
	while (a < c1.size() \|\| b < c2.size()) {
	if (a < c1.size() && b < c2.size() && c1[a] == c2[b]) {
	k.push_back(c1[a++]);
	b++;
	} else if (b == c2.size() \|\| (a < c1.size() && c1[a] < c2[b])) {
	k.push_back(c1[a++]);
	} else {
	k.push_back(c2[b++]);
	}
	}
	T[i].init(k.size());
	}
	has_init_keys = true;
	}

	pii query_max_up_to_k(int a, int b, int k, int i = 1, int r1 = 0, int r2 = -1) {
	if (r2 < 0) {
	a = max(a, 0);
	b = min(b, sz - 1);
	if (a > b) {
	return NONE;
	}
	r2 = sz - 1;
	}
	if (a <= r1 && r2 <= b) {
	k = lower_bound(keys[i].begin(), keys[i].end(), k + 1) - keys[i].begin() - 1;
	return T[i].query(0, k);
	}
	int m = (r1 + r2) >> 1, c = i << 1;
	pii res = NONE;
	if (a <= m) {
	res = max(res, query_max_up_to_k(a, b, k, c, r1, m));
	}
	if (b > m) {
	res = max(res, query_max_up_to_k(a, b, k, c + 1, m + 1, r2));
	}
	return res;
	}

	void update_one(int i, int k, pii p) {
	i += sz;
	if (!has_init_keys) {
	keys[i].push_back(k);
	return;
	}
	while (i >= 1) {
	T[i].update_one(
	lower_bound(keys[i].begin(), keys[i].end(), k) - keys[i].begin(), p
	);
	i >>= 1;
	}
	}
	};

	int N;
	pair<pii, pii> A[LIM], B[LIM];
	int Axx[LIM], Axy[LIM];
	int lowerX[3 * LIM], lowerY[3 * LIM];
	bool visit[LIM];
	NestedSegTree STX, STY;

	void update_A_rect(int i, bool ins) {
	STX.update_one(A[i].x.x, Axy[i], ins ? make_pair(A[i].y.y, i) : NONE);
	STX.update_one(A[i].y.x, Axy[i], ins ? make_pair(A[i].y.y, i) : NONE);
	STY.update_one(A[i].x.y, Axx[i], ins ? make_pair(A[i].y.x, i) : NONE);
	STY.update_one(A[i].y.y, Axx[i], ins ? make_pair(A[i].y.x, i) : NONE);
	}

	int get_A_rect_for_B_rect(int i) {
	pii p = STX.query_max_up_to_k(B[i].x.x, B[i].y.x, B[i].y.y);
	if (p.x >= B[i].x.y) {
	return p.y;
	}
	p = STY.query_max_up_to_k(B[i].x.y, B[i].y.y, B[i].y.x);
	if (p.x >= B[i].x.x) {
	return p.y;
	}
	return -1;
	}

	bool rec(int i) {
	visit[i] = true;
	for (;;) {
	int j = get_A_rect_for_B_rect(i);
	if (j < 0) {
	break;
	}
	if (visit[j]) {
	return true;
	}
	if (rec(j)) {
	return true;
	}
	}
	update_A_rect(i, 0);
	return false;
	}

	bool solve() {
	Compressor cx, cy;
	// Input, and compute flipped rectangles.
	cin >> N;
	for (int i = 0; i < N; i++) {
	char c;
	cin >> A[i].x.x >> A[i].x.y >> A[i].y.x >> A[i].y.y >> c;
	B[i] = A[i];
	switch (c) {
	case 'U': B[i].x.y += A[i].y.y; break;
	case 'D': B[i].x.y -= A[i].y.y; break;
	case 'L': B[i].x.x -= A[i].y.x; break;
	case 'R': B[i].x.x += A[i].y.x; break;
	}
	A[i].y.x += A[i].x.x;
	A[i].y.y += A[i].x.y;
	B[i].y.x += B[i].x.x;
	B[i].y.y += B[i].x.y;
	cx.insert({A[i].x.x, i});
	cx.insert({A[i].y.x, i}),
	cx.insert({B[i].x.x, i});
	cx.insert({B[i].y.x, i});
	cy.insert({A[i].x.y, i});
	cy.insert({A[i].y.y, i});
	cy.insert({B[i].x.y, i});
	cy.insert({B[i].y.y, i});
	}
	// Compress coordinates.
	cx.comp(), cy.comp();
	auto V = cx.V;
	for (int i = 0; i < V.size(); i++) {
	lowerX[i] = (i == 0 \|\| V[i - 1].x != V[i].x) ? i : lowerX[i - 1];
	}
	V = cy.V;
	for (int i = 0; i < V.size(); i++) {
	lowerY[i] = (i == 0 \|\| V[i - 1].x != V[i].x) ? i : lowerY[i - 1];
	}
	for (int i = 0; i < N; i++) {
	A[i].x.x = cx.get({A[i].x.x, i});
	A[i].x.y = cy.get({A[i].x.y, i}),
	A[i].y.x = cx.get({A[i].y.x, i});
	A[i].y.y = cy.get({A[i].y.y, i});
	B[i].x.x = cx.get({B[i].x.x, i});
	B[i].x.y = cy.get({B[i].x.y, i}),
	B[i].y.x = cx.get({B[i].y.x, i});
	B[i].y.y = cy.get({B[i].y.y, i});
	// Remember exact (unique) lower coordinates.
	Axx[i] = A[i].x.x, Axy[i] = A[i].x.y;
	// Round coordinates up to value boundaries (with exclusive upper
	// coordinates).
	A[i].x.x = lowerX[A[i].x.x];
	B[i].x.x = lowerX[B[i].x.x];
	A[i].x.y = lowerY[A[i].x.y];
	B[i].x.y = lowerY[B[i].x.y];
	A[i].y.x = lowerX[A[i].y.x] - 1;
	B[i].y.x = lowerX[B[i].y.x] - 1;
	A[i].y.y = lowerY[A[i].y.y] - 1;
	B[i].y.y = lowerY[B[i].y.y] - 1;
	}
	// Check for any overlap between final tables via line sweep.
	vector<tuple<int, int, int, int>> E;
	for (int i = 0; i < N; i++) {
	E.emplace_back(B[i].x.y, 1, B[i].x.x, B[i].y.x);
	E.emplace_back(B[i].y.y + 1, -1, B[i].x.x, B[i].y.x);
	}
	sort(E.begin(), E.end());
	MaxRangeSegTree ST(cx.V.size());
	for (auto e : E) {
	ST.update(get<2>(e), get<3>(e), get<1>(e));
	if (ST.query(0, cx.V.size() - 1) > 1) {
	return false;
	}
	}
	// Initialize segment trees of initial tables, over x and y coordinates.
	STX = NestedSegTree(cx.V.size());
	STY = NestedSegTree(cy.V.size());
	for (int j : {0, 1}) {
	if (j) { // Initialize keys second time around.
	STX.init_keys();
	STY.init_keys();
	}
	for (int i = 0; i < N; i++) {
	// Set up keys first time around, then perform actual updates.
	update_A_rect(i, 1);
	}
	}
	// Search for cycles via DFS.
	memset(visit, 0, sizeof visit);
	for (int i = 0; i < N; i++) {
	if (!visit[i]) {
	if (rec(i)) {
	return false; // Cycle found.
	}
	}
	}
	return true;
	}

	int main() {
	int T;
	cin >> T;
	for (int t = 1; t <= T; t++) {
	cout << "Case #" << t << ": " << (solve() ? "YES" : "NO") << endl;
	}
	return 0;
	}