2021/finals/hire_flyers.cpp

#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;
}