Datasets:

hackercupai
/

hackercup

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

const int MOD = 1000000007;

int N;

struct Seg {  // Directions: U / R / D / L
  int i = -1, r, c, p, d, t = 0;

  long long get_time_val() {
    return N * ((long long)t - r - c) + i;
  }

  bool operator<(const Seg& b) const {
    return make_pair(r, c) < make_pair(b.r, b.c);
  }
};

struct BIT {
  int N;
  vector<int> V;

  BIT() {}

  BIT(int _N): N(_N) {
    init(_N);
  }

  void init(int _N) {
    N = _N;
    V.resize(N + 1);
  }

  void clear() {
    fill(V.begin(), V.end(), 0);
  }

  void update(int i, int v) {
    for (i++; i <= N; i += (i & -i)) {
      V[i] += v;
    }
  }

  int query(int i) {
    int v = 0;
    i = min(i, N - 1);
    for (i++; i > 0; i -= (i & -i)) {
      v += V[i];
    }
    return v;
  }
};

struct SegTree {
  int N, sz;
  vector<vector<long long>> keys;
  vector<BIT> B;

  SegTree() {}

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

  void init(int _N) {
    N = _N;
    for (sz = 1; sz < N; sz <<= 1)
      ;
    keys.resize(sz << 1);
    B.resize(sz << 1);
  }

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

  int query_larger(int a, int b, long long 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 0;
      }
      r2 = sz - 1;
    }
    if (a <= r1 && r2 <= b) {
      auto &K = keys[i];
      v = lower_bound(K.begin(), K.end(), v) - K.begin();
      return B[i].query(K.size() - 1) - B[i].query(v - 1);
    }
    int m = (r1 + r2) >> 1, c = i << 1;
    int res = 0;
    if (a <= m) {
      res += query_larger(a, b, v, c, r1, m);
    }
    if (b > m) {
      res += query_larger(a, b, v, c + 1, m + 1, r2);
    }
    return res;
  }

  void update_one(int i, long long v, int d) {
    i += sz;
    while (i >= 1) {
      auto &K = keys[i];
      B[i].update(lower_bound(K.begin(), K.end(), v) - K.begin(), d);
      i >>= 1;
    }
  }
};

vector<Seg> SS;

Seg trim_seg(Seg s, int a, int b, bool hor) {
  if (s.d == 1 || s.d == 2) {    // Forward segment.
    int& sv1 = hor ? s.c : s.r;  // First value.
    int sv2 = sv1 + s.p - 1;     // Last value.
    int t1 = max(0, a - sv1);    // Truncation at start.
    int t2 = max(0, sv2 - b);    // Truncation at end.
    sv1 += t1, s.t += t1;
    s.p -= t1 + t2;
  } else {                       // Backward segment.
    int& sv2 = hor ? s.c : s.r;  // Last value.
    int sv1 = sv2 - (s.p - 1);   // First value.
    int t1 = max(0, a - sv1);    // Truncation at start.
    int t2 = max(0, sv2 - b);    // Truncation at end.
    sv2 -= t2, s.t += t2;
    s.p -= t1 + t2;
  }
  return s;
}

vector<Seg> merge_opp_segs(Seg s1, Seg s2, bool hor) {
  int nc = (hor ? s2.c - s1.c : s2.r - s1.r) + 1;
  int t1 = s1.t;                                  // Time for s1 to reach start.
  int t2 = s2.t + nc - 1 - (s2.i < s1.i ? 1 : 0); // Time for s2 to reach start.
  int m = (hor ? s1.c : s1.r) + (t2 - t1 + 2) / 2 -
            1; // Last value painted over by s2.
  vector<Seg> S;
  S.push_back(trim_seg(s2, -1e9 - 1, m, hor));
  S.push_back(trim_seg(s1, m + 1, 2e9 + 1, hor));
  return S;
}

void process_linear_segs(vector<Seg> V, bool hor) {
  // Collect and sort forward / backward segments.
  int d1, d2;
  if (hor) {
    d1 = 1;
    d2 = 3;
  } else {
    d1 = 2;
    d2 = 0;
  }
  vector<tuple<int, int, Seg>> P1, P2;
  for (auto s : V) {
    if (s.d == d1) {
      P1.emplace_back(s.r + s.c, -s.i, s);
    } else {
      P2.emplace_back(-(s.r + s.c), -s.i, s);
    }
  }
  sort(P1.begin(), P1.end());
  sort(P2.begin(), P2.end());
  // Reduce forward / backward segments independently.
  vector<Seg> S1, S2;
  int last = -1e9 - 1;
  for (auto p : P1) {
    Seg s = trim_seg(get<2>(p), last + 1, 2e9 + 1, hor); // Trim to after last.
    if (s.p > 0) {                                   // Include if not obsolete.
      S1.push_back(s);
    }
    last = max(last, (hor ? s.c : s.r) + (s.p - 1));
  }
  last = 2e9 + 1;
  for (auto p : P2) {
    Seg s = trim_seg(get<2>(p), -1e9 - 1, last - 1, hor); // Trim to before last.
    if (s.p > 0) {                                    // Include if not obsolete.
      S2.push_back(s);
    }
    last = min(last, (hor ? s.c : s.r) - (s.p - 1));
  }
  // Merge forward / backward segments.
  vector<tuple<int, int, int>> E;
  for (int i = 0; i < S1.size(); i++) {
    Seg s = S1[i];
    int sv = hor ? s.c : s.r;
    E.emplace_back(sv, 1, i);
    E.emplace_back(sv + s.p, 0, i);
  }
  for (int i = 0; i < S2.size(); i++) {
    Seg s = S2[i];
    int sv = hor ? s.c : s.r;
    E.emplace_back(sv - (s.p - 1), 3, i);
    E.emplace_back(sv + 1, 2, i);
  }
  sort(E.begin(), E.end());
  vector<int> inds{-1, -1};
  for (int i = 0; i < E.size(); i++) {
    int v = get<0>(E[i]), e = get<1>(E[i]);
    // Update set of ongoing segments.
    int j = e / 2;
    if (e % 2) {
      inds[j] = get<2>(E[i]);
    } else {
      inds[j] = -1;
    }
    // Process ongoing segments?
    if (i + 1 < E.size() && v < get<0>(E[i + 1])) {
      vector<Seg> S;
      if (inds[0] >= 0 && inds[1] >= 0) {
        S = merge_opp_segs(S1[inds[0]], S2[inds[1]], hor);
      } else if (inds[0] >= 0) {
        S.push_back(S1[inds[0]]);
      } else if (inds[1] >= 0) {
        S.push_back(S2[inds[1]]);
      }
      for (auto s : S) {
        Seg s2 = trim_seg(s, v, get<0>(E[i + 1]) - 1, hor);
        if (s2.p > 0) {
          SS.push_back(s2);
        }
      }
    }
  }
}

int solve() {
  SS.clear();
  map<int, vector<Seg>> rowS, colS;
  // Input.
  cin >> N;
  for (int i = 0; i < N; i++) {
    Seg s;
    s.i = i + 1;
    char d;
    cin >> s.r >> s.c >> s.p >> d;
    s.d = d == 'N' ? 0 : d == 'E' ? 1 : d == 'S' ? 2 : 3;
    if (s.d % 2) {
      rowS[s.r].push_back(s);
    } else {
      colS[s.c].push_back(s);
    }
  }
  // Reduce each relevant row / column to disjoint segments
  for (auto p : rowS) {
    process_linear_segs(p.second, true);
  }
  for (auto p : colS) {
    process_linear_segs(p.second, false);
  }
  // Compute base answer.
  int ans = 0;
  for (auto s : SS) {
    ans = (ans + (long long)s.i * s.p) % MOD;
  }
  // Consider 4 different rotations of the grid.
  for (int r = 0; r < 4; r++) {
    // Rotate everything 90 degrees clockwise.
    for (int i = 0; i < SS.size(); i++) {
      Seg &s = SS[i];
      int r = s.r, c = s.c, d = s.d;
      s.r = c;
      s.c = -r;
      s.d = (d + 1) % 4;
    }
    // Consider 2 different vertical flips of the grid.
    for (int _ : {0, 1}) {
      // Flip everything vertically.
      for (int i = 0; i < SS.size(); i++) {
        Seg &s = SS[i];
        s.r = -s.r;
        if (s.d % 2 == 0) {
          s.d = 2 - s.d;
        }
      }
      // Assemble list of line sweep events and distinct D segment columns.
      vector<tuple<int, int, Seg>> E;
      vector<int> cc;
      for (auto s : SS) {
        if (s.d == 1) {  // R
          E.emplace_back(s.r, 1, s);
        } else if (s.d == 2) {  // D
          E.emplace_back(s.r, 0, s);
          E.emplace_back(s.r + s.p - 1, 2, s);
          cc.push_back(s.c);
        }
      }
      sort(E.begin(), E.end());
      sort(cc.begin(), cc.end());
      cc.resize(unique(cc.begin(), cc.end()) - cc.begin());
      // Initialize 2D segment tree.
      SegTree ST(cc.size());
      for (auto s : SS) {
        if (s.d == 2) { // D
          ST.keys[ST.sz + (lower_bound(cc.begin(), cc.end(), s.c) - cc.begin())]
              .push_back(s.get_time_val());
        }
      }
      ST.init_keys();
      // Line sweep to subtract R segments covered by D ones.
      for (auto p : E) {
        int e = get<1>(p);
        Seg s = get<2>(p);
        if (e == 1) {
          int a = lower_bound(cc.begin(), cc.end(), s.c) - cc.begin();
          int b = lower_bound(cc.begin(), cc.end(), s.c + s.p) - cc.begin() - 1;
          long long v = s.get_time_val();
          ans = (ans + MOD - (long long)s.i * ST.query_larger(a, b, v) % MOD) % MOD;
        } else {
          ST.update_one(
            lower_bound(cc.begin(), cc.end(), s.c) - cc.begin(),
            s.get_time_val(),
            e == 0 ? 1 : -1
          );
        }
      }
    }
  }
  return ans;
}

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

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

	const int MOD = 1000000007;

	int N;

	struct Seg { // Directions: U / R / D / L
	int i = -1, r, c, p, d, t = 0;

	long long get_time_val() {
	return N * ((long long)t - r - c) + i;
	}

	bool operator<(const Seg& b) const {
	return make_pair(r, c) < make_pair(b.r, b.c);
	}
	};

	struct BIT {
	int N;
	vector<int> V;

	BIT() {}

	BIT(int _N): N(_N) {
	init(_N);
	}

	void init(int _N) {
	N = _N;
	V.resize(N + 1);
	}

	void clear() {
	fill(V.begin(), V.end(), 0);
	}

	void update(int i, int v) {
	for (i++; i <= N; i += (i & -i)) {
	V[i] += v;
	}
	}

	int query(int i) {
	int v = 0;
	i = min(i, N - 1);
	for (i++; i > 0; i -= (i & -i)) {
	v += V[i];
	}
	return v;
	}
	};

	struct SegTree {
	int N, sz;
	vector<vector<long long>> keys;
	vector<BIT> B;

	SegTree() {}

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

	void init(int _N) {
	N = _N;
	for (sz = 1; sz < N; sz <<= 1)
	;
	keys.resize(sz << 1);
	B.resize(sz << 1);
	}

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

	int query_larger(int a, int b, long long 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 0;
	}
	r2 = sz - 1;
	}
	if (a <= r1 && r2 <= b) {
	auto &K = keys[i];
	v = lower_bound(K.begin(), K.end(), v) - K.begin();
	return B[i].query(K.size() - 1) - B[i].query(v - 1);
	}
	int m = (r1 + r2) >> 1, c = i << 1;
	int res = 0;
	if (a <= m) {
	res += query_larger(a, b, v, c, r1, m);
	}
	if (b > m) {
	res += query_larger(a, b, v, c + 1, m + 1, r2);
	}
	return res;
	}

	void update_one(int i, long long v, int d) {
	i += sz;
	while (i >= 1) {
	auto &K = keys[i];
	B[i].update(lower_bound(K.begin(), K.end(), v) - K.begin(), d);
	i >>= 1;
	}
	}
	};

	vector<Seg> SS;

	Seg trim_seg(Seg s, int a, int b, bool hor) {
	if (s.d == 1 \|\| s.d == 2) { // Forward segment.
	int& sv1 = hor ? s.c : s.r; // First value.
	int sv2 = sv1 + s.p - 1; // Last value.
	int t1 = max(0, a - sv1); // Truncation at start.
	int t2 = max(0, sv2 - b); // Truncation at end.
	sv1 += t1, s.t += t1;
	s.p -= t1 + t2;
	} else { // Backward segment.
	int& sv2 = hor ? s.c : s.r; // Last value.
	int sv1 = sv2 - (s.p - 1); // First value.
	int t1 = max(0, a - sv1); // Truncation at start.
	int t2 = max(0, sv2 - b); // Truncation at end.
	sv2 -= t2, s.t += t2;
	s.p -= t1 + t2;
	}
	return s;
	}

	vector<Seg> merge_opp_segs(Seg s1, Seg s2, bool hor) {
	int nc = (hor ? s2.c - s1.c : s2.r - s1.r) + 1;
	int t1 = s1.t; // Time for s1 to reach start.
	int t2 = s2.t + nc - 1 - (s2.i < s1.i ? 1 : 0); // Time for s2 to reach start.
	int m = (hor ? s1.c : s1.r) + (t2 - t1 + 2) / 2 -
	1; // Last value painted over by s2.
	vector<Seg> S;
	S.push_back(trim_seg(s2, -1e9 - 1, m, hor));
	S.push_back(trim_seg(s1, m + 1, 2e9 + 1, hor));
	return S;
	}

	void process_linear_segs(vector<Seg> V, bool hor) {
	// Collect and sort forward / backward segments.
	int d1, d2;
	if (hor) {
	d1 = 1;
	d2 = 3;
	} else {
	d1 = 2;
	d2 = 0;
	}
	vector<tuple<int, int, Seg>> P1, P2;
	for (auto s : V) {
	if (s.d == d1) {
	P1.emplace_back(s.r + s.c, -s.i, s);
	} else {
	P2.emplace_back(-(s.r + s.c), -s.i, s);
	}
	}
	sort(P1.begin(), P1.end());
	sort(P2.begin(), P2.end());
	// Reduce forward / backward segments independently.
	vector<Seg> S1, S2;
	int last = -1e9 - 1;
	for (auto p : P1) {
	Seg s = trim_seg(get<2>(p), last + 1, 2e9 + 1, hor); // Trim to after last.
	if (s.p > 0) { // Include if not obsolete.
	S1.push_back(s);
	}
	last = max(last, (hor ? s.c : s.r) + (s.p - 1));
	}
	last = 2e9 + 1;
	for (auto p : P2) {
	Seg s = trim_seg(get<2>(p), -1e9 - 1, last - 1, hor); // Trim to before last.
	if (s.p > 0) { // Include if not obsolete.
	S2.push_back(s);
	}
	last = min(last, (hor ? s.c : s.r) - (s.p - 1));
	}
	// Merge forward / backward segments.
	vector<tuple<int, int, int>> E;
	for (int i = 0; i < S1.size(); i++) {
	Seg s = S1[i];
	int sv = hor ? s.c : s.r;
	E.emplace_back(sv, 1, i);
	E.emplace_back(sv + s.p, 0, i);
	}
	for (int i = 0; i < S2.size(); i++) {
	Seg s = S2[i];
	int sv = hor ? s.c : s.r;
	E.emplace_back(sv - (s.p - 1), 3, i);
	E.emplace_back(sv + 1, 2, i);
	}
	sort(E.begin(), E.end());
	vector<int> inds{-1, -1};
	for (int i = 0; i < E.size(); i++) {
	int v = get<0>(E[i]), e = get<1>(E[i]);
	// Update set of ongoing segments.
	int j = e / 2;
	if (e % 2) {
	inds[j] = get<2>(E[i]);
	} else {
	inds[j] = -1;
	}
	// Process ongoing segments?
	if (i + 1 < E.size() && v < get<0>(E[i + 1])) {
	vector<Seg> S;
	if (inds[0] >= 0 && inds[1] >= 0) {
	S = merge_opp_segs(S1[inds[0]], S2[inds[1]], hor);
	} else if (inds[0] >= 0) {
	S.push_back(S1[inds[0]]);
	} else if (inds[1] >= 0) {
	S.push_back(S2[inds[1]]);
	}
	for (auto s : S) {
	Seg s2 = trim_seg(s, v, get<0>(E[i + 1]) - 1, hor);
	if (s2.p > 0) {
	SS.push_back(s2);
	}
	}
	}
	}
	}

	int solve() {
	SS.clear();
	map<int, vector<Seg>> rowS, colS;
	// Input.
	cin >> N;
	for (int i = 0; i < N; i++) {
	Seg s;
	s.i = i + 1;
	char d;
	cin >> s.r >> s.c >> s.p >> d;
	s.d = d == 'N' ? 0 : d == 'E' ? 1 : d == 'S' ? 2 : 3;
	if (s.d % 2) {
	rowS[s.r].push_back(s);
	} else {
	colS[s.c].push_back(s);
	}
	}
	// Reduce each relevant row / column to disjoint segments
	for (auto p : rowS) {
	process_linear_segs(p.second, true);
	}
	for (auto p : colS) {
	process_linear_segs(p.second, false);
	}
	// Compute base answer.
	int ans = 0;
	for (auto s : SS) {
	ans = (ans + (long long)s.i * s.p) % MOD;
	}
	// Consider 4 different rotations of the grid.
	for (int r = 0; r < 4; r++) {
	// Rotate everything 90 degrees clockwise.
	for (int i = 0; i < SS.size(); i++) {
	Seg &s = SS[i];
	int r = s.r, c = s.c, d = s.d;
	s.r = c;
	s.c = -r;
	s.d = (d + 1) % 4;
	}
	// Consider 2 different vertical flips of the grid.
	for (int _ : {0, 1}) {
	// Flip everything vertically.
	for (int i = 0; i < SS.size(); i++) {
	Seg &s = SS[i];
	s.r = -s.r;
	if (s.d % 2 == 0) {
	s.d = 2 - s.d;
	}
	}
	// Assemble list of line sweep events and distinct D segment columns.
	vector<tuple<int, int, Seg>> E;
	vector<int> cc;
	for (auto s : SS) {
	if (s.d == 1) { // R
	E.emplace_back(s.r, 1, s);
	} else if (s.d == 2) { // D
	E.emplace_back(s.r, 0, s);
	E.emplace_back(s.r + s.p - 1, 2, s);
	cc.push_back(s.c);
	}
	}
	sort(E.begin(), E.end());
	sort(cc.begin(), cc.end());
	cc.resize(unique(cc.begin(), cc.end()) - cc.begin());
	// Initialize 2D segment tree.
	SegTree ST(cc.size());
	for (auto s : SS) {
	if (s.d == 2) { // D
	ST.keys[ST.sz + (lower_bound(cc.begin(), cc.end(), s.c) - cc.begin())]
	.push_back(s.get_time_val());
	}
	}
	ST.init_keys();
	// Line sweep to subtract R segments covered by D ones.
	for (auto p : E) {
	int e = get<1>(p);
	Seg s = get<2>(p);
	if (e == 1) {
	int a = lower_bound(cc.begin(), cc.end(), s.c) - cc.begin();
	int b = lower_bound(cc.begin(), cc.end(), s.c + s.p) - cc.begin() - 1;
	long long v = s.get_time_val();
	ans = (ans + MOD - (long long)s.i * ST.query_larger(a, b, v) % MOD) % MOD;
	} else {
	ST.update_one(
	lower_bound(cc.begin(), cc.end(), s.c) - cc.begin(),
	s.get_time_val(),
	e == 0 ? 1 : -1
	);
	}
	}
	}
	}
	return ans;
	}

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