2021 Problems

.gitattributes

@@ -83,3 +83,18 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 2020/quals/running_on_fumes_ch1.in filter=lfs diff=lfs merge=lfs -text
 2020/quals/running_on_fumes_ch2.in filter=lfs diff=lfs merge=lfs -text
 2020/quals/timber.in filter=lfs diff=lfs merge=lfs -text
+2021/finals/antisocial.in filter=lfs diff=lfs merge=lfs -text
+2021/finals/hire_flyers.in filter=lfs diff=lfs merge=lfs -text
+2021/finals/ssssss.in filter=lfs diff=lfs merge=lfs -text
+2021/finals/table_flipping.in filter=lfs diff=lfs merge=lfs -text
+2021/finals/vacation.in filter=lfs diff=lfs merge=lfs -text
+2021/round1/blockchain.in filter=lfs diff=lfs merge=lfs -text
+2021/round2/chainblock.in filter=lfs diff=lfs merge=lfs -text
+2021/round2/runway.in filter=lfs diff=lfs merge=lfs -text
+2021/round2/valet_parking_ch2.in filter=lfs diff=lfs merge=lfs -text
+2021/round3/auth-ore-ization.in filter=lfs diff=lfs merge=lfs -text
+2021/round3/expl-ore-ation_ch1.in filter=lfs diff=lfs merge=lfs -text
+2021/round3/expl-ore-ation_ch2.in filter=lfs diff=lfs merge=lfs -text
+2021/round3/expl-ore-ation_ch3.in filter=lfs diff=lfs merge=lfs -text
+2021/round3/perf-ore-mance.in filter=lfs diff=lfs merge=lfs -text
+2021/round3/rep-ore-ting.in filter=lfs diff=lfs merge=lfs -text

2021/finals/and.cpp

@@ -0,0 +1,147 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+using namespace std;
+
+const int LIM = 4000005;
+
+struct UnionFind {
+  int N;
+  vector<int> root, diff_to_root, rank, sz, diffsum;
+
+  UnionFind(int _N):
+   N(_N), root(_N), diff_to_root(_N), rank(_N), sz(_N, 1), diffsum(_N) {
+    for (int i = 0; i < N; i++) {
+      root[i] = i;
+    }
+  }
+
+  int find(int i) {
+    int r = root[i];
+    if (r != i) {
+      root[i] = find(r);
+      diff_to_root[i] ^= diff_to_root[r];
+    }
+    return root[i];
+  }
+
+  bool merge(int i, int j, int d) {
+    int ri = find(i), rj = find(j);
+    d ^= diff_to_root[i] ^ diff_to_root[j];
+    if (ri == rj) {
+      return !d;
+    }
+    if (rank[ri] > rank[rj]) {
+      swap(ri, rj);
+    }
+    root[ri] = rj;
+    diff_to_root[ri] = d;
+    sz[rj] += sz[ri];
+    diffsum[rj] += d ? sz[ri] - diffsum[ri] : diffsum[ri];
+    if (rank[ri] == rank[rj]) {
+      rank[rj]++;
+    }
+    return true;
+  }
+};
+
+int N, K;
+
+void solve() {
+  vector<int> both(LIM), ans(LIM);
+  vector<vector<vector<int>>> ind(LIM, vector<vector<int>>(2));
+  int maxL = 0;
+  // Input.
+  cin >> N >> K;
+  for (int i = 0; i < N; i++) {
+    string s[2];
+    cin >> s[0] >> s[1];
+    int len = max(s[0].size(), s[1].size());
+    maxL = max(maxL, len);
+    for (int b = 0; b < len; b++) {
+      int ch[2];
+      for (int j : {0, 1}) {
+        int slen = s[j].size();
+        ch[j] = b < slen ? s[j][slen - b - 1] - '0' : 0;
+      }
+      if (ch[0] && ch[1]) {
+        both[b]++;
+      } else {
+        for (int j : {0, 1}) {
+          if (ch[j]) {
+            ind[b][j].push_back(i);
+          }
+        }
+      }
+    }
+  }
+  // Consider each bit, starting from the most significant.
+  UnionFind U(N);
+  for (int b = maxL - 1; b >= 0; b--) {
+    ans[b] = 0;
+    // Bit included twice?
+    if (both[b] == N) {
+      ans[b] = 2;
+      continue;
+    }
+    // Bit not included at all?
+    if (both[b] + ind[b][0].size() + ind[b][1].size() < N) {
+      continue;
+    }
+    // Include bit once if possible.
+    int k = 0;
+    bool imp = false;
+    UnionFind U2 = U;
+    for (int i = 0; !imp && i < 2; i++) {
+      for (int j = 0; !imp && j < (int)ind[b][i].size() - 1; j++) {
+        if (!U2.merge(ind[b][i][j], ind[b][i][j + 1], 0)) {
+          imp = true;
+        }
+      }
+    }
+    if (imp) {
+      continue;
+    }
+    if (ind[b][0].size() > 0 && ind[b][1].size() > 0) {
+      if (!U2.merge(ind[b][0][0], ind[b][1][0], 1)) {
+        continue;
+      }
+    }
+    for (int i = 0; i < N; i++) {
+      if (U2.find(i) == i) {
+        k += min(U2.diffsum[i], U2.sz[i] - U2.diffsum[i]);
+      }
+    }
+    if (k > K) {
+      continue;
+    }
+    U = U2;
+    ans[b] = 1;
+  }
+  // Add up answer in binary.
+  for (int i = 0; i < maxL; i++) {
+    if (i == maxL - 1 && ans[i] >= 2) {
+      ans[maxL++] = 0;
+    }
+    ans[i + 1] += ans[i] / 2;
+    ans[i] %= 2;
+  }
+  // Output.
+  while (maxL > 1 && !ans[maxL - 1]) {
+    maxL--;
+  }
+  for (int i = maxL - 1; i >= 0; i--) {
+    cout << ans[i];
+  }
+  cout << endl;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": ";
+    solve();
+  }
+  return 0;
+}

2021/finals/and.md

@@ -0,0 +1,44 @@
+Andy has no time for ores, he's just here for the `AND`s.
+
+Andy has \(N\) pairs of integers, with each integer given in binary as a bitstring. The \(i\)th pair consists of bitstrings \(A_i\) and \(B_i\). No bitstring has leading zeros (except for the bitstring `"0"` itself).
+
+Andy may choose at most \(K\) of these pairs for swapping. For each chosen pair \(i\), he'll swap its bitstrings \(A_i\) and \(B_i\).
+
+After all of these swaps, he'll compute \(X\) as the bitwise `AND` of the \(N\) bitstrings \(A_{1..N}\), and \(Y\) as the bitwise `AND` of the \(N\) bitstrings \(B_{1..N}\), and finally add \(X\) and \(Y\) together. What's the maximum sum of \(X + Y\) that Andy can achieve?
+
+Note that:
+
+  - The integer value of a bitstring \(S\) is equal to \(S_1 * 2^{|S|-1} + S_2 * 2^{|S|-2} + ... + S_{|S|} * 2^0\).
+  - The bitwise `AND` of a set of bitstrings \(S\) is a bitstring \(V\) such that, if leading zeros were appended to bitstrings in \(S\) until they all had the same length, then \(V\) also has that same length, with \(V_i\) equal to `1` if and only if all bitstrings in \(S\) have a `1` at index \(i\).
+
+
+# Constraints
+
+\(1 \le T \le 90\) 
+\(1 \le N \le 2{,}000{,}000\)
+\(0 \le K \le N\)
+\(0 \le A_{i,j}, B_{i,j} \le 1\)
+
+The total length of all bitstrings \(A_{1..N}\) and \(B_{1..N}\) is at most \(4{,}000{,}000\).
+The total length of all bitstrings across all test cases is at most \(10{,}000{,}000\).
+
+
+# Input
+
+Input begins with an integer \(T\), the number of test cases. For each test case, there is first a line containing \(2\) space-separated integers, \(N\) and \(K\). Then, \(N\) lines follow, the \(i\)th of which contains \(2\) space-separated bitstrings, \(A_i\) and \(B_i\).
+
+
+# Output
+
+For the \(i\)th test case, print a line containing *"Case #i: "* followed by a single bitstring, the maximum achievable sum of bitstring `AND`s, with no leading zeros (unless the bitstring is ``"0"``).
+
+
+# Sample Explanation
+
+In the first case, \(X = 1011011_2 \,(91_{10})\), \(Y = 101101_2 \,(45_{10})\), and \(X + Y = 10001000_2 \,(136_{10})\).
+
+In the second case, no swaps are allowed, so we must have \(X = 1011011_2\) `AND` \(0_2 = 0_2\) and \(Y = 0_2 \) `AND` \(101101_2 = 0_2\).
+
+In the third case, one option is to swap \(A_1\) and \(B_1\). This yields \(X = 0_2\) `AND` \(0_2 = 0_2\) and \(Y = 1011011_2\) `AND` \(101101_2 = 1001_2\).
+
+In the fourth case, one option is to swap \(A_1\) and \(B_1\) as well as \(A_3\) and \(B_3\), resulting in \(X = 111_2 \,(7_{10})\), \(Y = 1_2 \,(1_{10})\), and \(X + Y = 1000_2 \,(8_{10})\).

2021/finals/and_sol.md

@@ -0,0 +1,19 @@
+Let \(L\) be the length of the longest bitstring. Each bit index \(i\) (counting from the right, starting at \(0\)) between \(0\) and \(L-1\) (inclusive) will contribute either \(0\), \(2^i\), or \(2*2^i\) to the answer, depending on whether it's set in all bitstrings \(A_{1..N}\) and/or in all bitstrings \(B_{1..N}\). Once we determine which of these each bit index will contribute in the optimal solution, we'll be able to compute the resulting summed bitstring in \(O(L)\) time.
+
+Considering bit indices \(i\) in order from most to least significant (from \(L-1\) down to \(0\)), each will fall into one of three categories:
+
+  1. If \(i\) is set in all \(2N\) bitstrings \(A_{1..N}\) and \(B_{1..N}\), then it must always contribute \(2*2^i\) to the answer.
+  
+  2. If, for at least one pair \(j\), \(i\) is set in neither \(A_j\) nor \(B_j\), then it must always contribute \(0\) to the answer.
+  
+  3. Otherwise, it may either contribute \(0\) or \(2^i\) to the answer. We should greedily cause it to contribute \(2^i\) if possible (without compromising previously-considered bit indices), as doing so would be strictly better than doing so for all later bit indices combined (as \(2^i \gt \sum_{j=0}^{i-1}{2^j}\)).
+
+  Let \(O_j\) be the "orientation" of pair \(j\) (whether or not it's being swapped), \(X\) be the set of pairs \(j\) for which \(i\) is set in \(A_j\) but not \(B_j\), and \(Y\) be the set of pairs \(j\) for which \(i\) set in \(B_j\) but not \(A_j\).
+  
+  Bit index \(i\) will then contribute to the answer if and only if all pairs in \(X\) have equal \(O\) values, all pairs in \(Y\) have equal \(O\) values, and the \(X\) pairs' \(O\) values are the opposite of the \(Y\) pairs' \(O\) values. This can be expressed as a set of at most \(|X|+|Y|+1\) pairwise relationships, each stating whether a certain pair of pairs must have equal or opposite \(O\) values.
+
+  We'll maintain information about these relationships using a [disjoint set union](https://en.wikipedia.org/wiki/Disjoint-set_data_structure) data structure (over the \(N\) pairs), augmented such that the root of each set stores its total number of pairs and the number of pairs which must have opposite \(O\) values to the root, and such that each pair stores whether or not it must have the opposite \(O\) value to the root of its set.
+  
+  So, when considering each bit index \(i\), we'll make a copy of the DSU and attempt to add all of the newly-required relationships to it in \(O(N*α(N))\) time. If that proves possible without introducing conflicts, we'll take another \(O(N)\) time to compute the minimum total number of swaps required (by greedily choosing between the two possible arrangements of orientations for each set). If that comes out to at most \(K\), then we'll add \(2^i\) to the answer and keep the new state of the DSU, while we'll otherwise roll back to the DSU's prior state.
+  
+Each time a bit index falls into the third category described above, there must have been at least \(N\) set bits in the input (at that index). Therefore, if \(S\) is the sum of all \(2N\) bitstring lengths, then only \(O(S/N)\) bit indices can fall into that category. This means that the time complexity of this algorithm is \(O(S/N * N * α(N)) = O(S α(N))\) (effectively \(O(S)\)).

2021/finals/antisocial.cpp

@@ -0,0 +1,456 @@
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <functional>
+#include <iostream>
+#include <queue>
+#include <utility>
+#include <vector>
+using namespace std;
+
+const int LIM = 6000006;
+const long double EPS = 1e-9;
+
+using LD = long double;
+using pii = pair<int, int>;
+
+// From https://github.com/zigui-ps/VoronoiDiagram
+struct point {
+  LD x, y;
+
+  point(): x(0), y(0) {}
+  point(LD _x, LD _y): x(_x), y(_y) {}
+
+  LD operator/(point p) const { return x * p.y - y * p.x; }
+  point operator+(point p) const { return point(x + p.x, y + p.y); }
+  point operator-(point p) const { return point(x - p.x, y - p.y); }
+  friend point operator*(LD b, point a) { return point(b * a.x, b * a.y); }
+
+  LD size() const { return hypot(x, y); }
+  LD sz2() const { return x * x + y * y; }
+  point r90() const { return point(-y, x); }
+  LD dot(point p) { return x * p.x + y * p.y; }
+};
+
+int dcmp(LD x) {
+  return x < -EPS ? -1 : x > EPS ? 1 : 0;
+}
+
+point line_intersect(point a, point b, point u, point v) {
+  return u + (((a - u) / b) / (v / b)) * v;
+}
+
+point get_circumcenter(point p0, point p1, point p2) {
+  return line_intersect(
+    0.5 * (p0 + p1), (p0 - p1).r90(), 0.5 * (p1 + p2), (p1 - p2).r90()
+  );
+}
+
+point project_point_segment(point a, point b, point c) {
+  LD r = (b - a).dot(b - a);
+  if (fabs(r) < EPS) {
+    return a;
+  }
+  r = (c - a).dot(b - a) / r;
+  if (r < 0) {
+    return a;
+  }
+  if (r > 1) {
+    return b;
+  }
+  return a + r * (b - a);
+}
+
+bool point_in_polygon_incl(const vector<point> &p, point q) {
+  bool c = 0;
+  for (int i = 0; i < p.size(); i++) {
+    int j = (i + 1) % p.size();
+    if ((project_point_segment(p[i], p[j], q) - q).sz2() < EPS) {
+      return true;
+    }
+    if (
+      (p[i].y <= q.y && q.y < p[j].y || p[j].y <= q.y && q.y < p[i].y) &&
+      q.x < p[i].x + (p[j].x - p[i].x) * (q.y - p[i].y) / (p[j].y - p[i].y)
+    )  {
+      c = !c;
+    }
+  }
+  return c;
+}
+
+// https://www.youtube.com/watch?v=h_vvP4ah6Ck
+LD parabola_intersect(point left, point right, LD sweepline) {
+  auto f2 = [](point left, point right, LD sweepline) {
+    int sign = left.x < right.x ? 1 : -1;
+    point m = 0.5 * (left + right);
+    point v = line_intersect(
+      m, (right - left).r90(), point(0, sweepline), point(1, 0)
+    );
+    point w = line_intersect(m, (left - v).r90(), v, left - v);
+    LD l1 = (v - w).size();
+    LD l2 = sqrt(pow(sweepline - m.y, 2) - (m - w).sz2());
+    LD l3 = (left - v).size();
+    return v.x + (m.x - v.x) * l3 / (l1 + sign * l2);
+  };
+  if (fabs(left.y - right.y) < fabs(left.x - right.x) * EPS) {
+    return f2(left, right, sweepline);
+  }
+  int sign = left.y < right.y ? -1 : 1;
+  point v = line_intersect(
+    left, right - left, point(0, sweepline), point(1, 0)
+  );
+  LD d1 = (0.5 * (left + right) - v).sz2(), d2 = (0.5 * (left - right)).sz2();
+  return v.x + sign * sqrt(max(0.0L, d1 - d2));
+}
+
+struct Beachline {
+  struct node {
+    point pt;
+    int idx;
+    int end;
+    node *link[2], *par, *prv, *nxt;
+
+    node() {}
+    node(point _pt, int idx):
+      pt(_pt), idx(idx), end(0), link{0, 0}, par(0), prv(0), nxt(0) {}
+  } *root;
+
+  LD sweepline;
+
+  Beachline() : sweepline(-1e20), root(NULL) { }
+
+  inline int dir(node* x) {
+    return x->par->link[0] != x;
+  }
+
+  //     p        n          p            n
+  //    / \      / \        / \          / \
+  //   n   d => a   p   or a   n   =>   p   d
+  //  / \          / \        / \      / \
+  // a   b        b   d      c   d    a   c
+  void rotate(node* n) {
+    node* p = n->par;
+    int d = dir(n);
+    p->link[d] = n->link[!d];
+    if (n->link[!d]) {
+      n->link[!d]->par = p;
+    }
+    n->par = p->par;
+    if (p->par) {
+      p->par->link[dir(p)] = n;
+    }
+    n->link[!d] = p;
+    p->par = n;
+  }
+
+  void splay(node* x, node* f = NULL) {
+    while (x->par != f) {
+      if (x->par->par == f) {
+        // no-op
+      } else if (dir(x) == dir(x->par)) {
+        rotate(x->par);
+      } else {
+        rotate(x);
+      }
+      rotate(x);
+    }
+    if (f == NULL) {
+      root = x;
+    }
+  }
+
+  void insert(node* n, node* p, int d) {
+    splay(p);
+    node *c = p->link[d];
+    n->link[d] = c;
+    if (c) {
+      c->par = n;
+    }
+    p->link[d] = n;
+    n->par = p;
+    node *prv = !d ? p->prv : p, *nxt = !d ? p : p->nxt;
+    n->prv = prv;
+    if (prv) {
+      prv->nxt = n;
+    }
+    n->nxt = nxt;
+    if (nxt) {
+      nxt->prv = n;
+    }
+  }
+
+  void erase(node* n) {
+    node *prv = n->prv, *nxt = n->nxt;
+    if (!prv && !nxt) {
+      if (n == root) {
+        root = NULL;
+      }
+      return;
+    }
+    n->prv = NULL;
+    if (prv) {
+      prv->nxt = nxt;
+    }
+    n->nxt = NULL;
+    if (nxt) {
+      nxt->prv = prv;
+    }
+    splay(n);
+    if (!nxt) {
+      root->par = NULL;
+      n->link[0] = NULL;
+      root = prv;
+    } else {
+      splay(nxt, n);
+      node* c = n->link[0];
+      nxt->link[0] = c;
+      c->par = nxt;
+      n->link[0] = NULL;
+      n->link[1] = NULL;
+      nxt->par = NULL;
+      root = nxt;
+    }
+  }
+
+  bool get_event(node *cur, LD &next_sweep) {
+    if (!cur->prv || !cur->nxt) {
+      return false;
+    }
+    point u = (cur->pt - cur->prv->pt).r90();
+    point v = (cur->nxt->pt - cur->pt).r90();
+    if (dcmp(u / v) != 1) {
+      return false;
+    }
+    point p = get_circumcenter(cur->pt, cur->prv->pt, cur->nxt->pt);
+    next_sweep = p.y + (p - cur->pt).size();
+    return true;
+  }
+
+  node* find_beachline(LD x) {
+    node* cur = root;
+    while (cur) {
+      LD left = cur->prv
+                  ? parabola_intersect(cur->prv->pt, cur->pt, sweepline)
+                  : -1e30;
+      LD right = cur->nxt
+                  ? parabola_intersect(cur->pt, cur->nxt->pt, sweepline)
+                  : 1e30;
+      if (left <= x && x <= right) {
+        splay(cur);
+        return cur;
+      }
+      cur = cur->link[x > right];
+    }
+    return NULL;
+  }
+};
+
+using BeachNode = Beachline::node;
+
+static BeachNode arr[LIM];
+static int sz;
+static BeachNode* new_node(point point, int idx) {
+  arr[sz] = BeachNode(point, idx);
+  return arr + (sz++);
+}
+
+struct event {
+  int type, idx, prv, nxt;
+  BeachNode *cur;
+  LD sweep;
+
+  event(LD sweep, int idx) : type(0), sweep(sweep), idx(idx) {}
+  event(LD sweep, BeachNode* cur) :
+    type(1), sweep(sweep), prv(cur->prv->idx), cur(cur), nxt(cur->nxt->idx) {}
+
+  bool operator>(const event& l) const { return sweep > l.sweep; }
+};
+
+void voronoi_diagram(
+  vector<point> &input,
+  vector<point> &vertex,
+  vector<pii> &edge,
+  vector<pii> &area
+) {
+  Beachline beachline = Beachline();
+  priority_queue<event, vector<event>, greater<event>> events;
+
+  auto add_edge = [&](int u, int v, int a, int b, BeachNode* c1, BeachNode* c2) {
+    if (c1) {
+      c1->end = edge.size() * 2;
+    }
+    if (c2) {
+      c2->end = edge.size() * 2 + 1;
+    }
+    edge.emplace_back(u, v);
+    area.emplace_back(a, b);
+  };
+  auto write_edge = [&](int idx, int v) {
+    if (idx % 2 == 0) {
+      edge[idx / 2].first = v;
+    } else {
+      edge[idx / 2].second = v;
+    }
+  };
+  auto add_event = [&](BeachNode* cur) {
+    LD nxt;
+    if (beachline.get_event(cur, nxt)) {
+      events.emplace(nxt, cur);
+    }
+  };
+
+  int n = input.size(), cnt = 0;
+  /*arr = new BeachNode[n * 4]; */sz = 0;
+  sort(input.begin(), input.end(), [](const point &l, const point &r) {
+    return l.y != r.y ? l.y < r.y : l.x < r.x;
+  });
+
+  BeachNode *tmp = beachline.root = new_node(input[0], 0), *t2;
+  for (int i = 1; i < n; i++) {
+    if (dcmp(input[i].y - input[0].y) == 0) {
+      add_edge(-1, -1, i - 1, i, 0, tmp);
+      beachline.insert(t2 = new_node(input[i], i), tmp, 1);
+      tmp = t2;
+    } else {
+      events.emplace(input[i].y, i);
+    }
+  }
+
+  while (events.size()) {
+    event q = events.top();
+    events.pop();
+    BeachNode *prv, *cur, *nxt, *site;
+    int v = vertex.size(), idx = q.idx;
+    beachline.sweepline = q.sweep;
+    if (q.type == 0) {
+      point pt = input[idx];
+      cur = beachline.find_beachline(pt.x);
+      beachline.insert(site = new_node(pt, idx), cur, 0);
+      beachline.insert(prv = new_node(cur->pt, cur->idx), site, 0);
+      add_edge(-1, -1, cur->idx, idx, site, prv);
+      add_event(prv);
+      add_event(cur);
+    } else {
+      cur = q.cur;
+      prv = cur->prv;
+      nxt = cur->nxt;
+      if (!prv || !nxt || prv->idx != q.prv || nxt->idx != q.nxt) {
+        continue;
+      }
+      vertex.push_back(get_circumcenter(prv->pt, nxt->pt, cur->pt));
+      write_edge(prv->end, v);
+      write_edge(cur->end, v);
+      add_edge(v, -1, prv->idx, nxt->idx, 0, prv);
+      beachline.erase(cur);
+      add_event(prv);
+      add_event(nxt);
+    }
+  }
+  // delete arr;
+}
+
+int XR, YR;
+int N, M;
+vector<pair<int, LD>> adj[LIM];
+point KP[2];
+int KN[2];
+LD ans;
+
+void process_voronoi_diagrams(vector<point> P) {
+  int i, j, k;
+  vector<point> vertex;
+  vector<pii> edge, area;
+  voronoi_diagram(P, vertex, edge, area);
+  M = vertex.size();
+  for (int i = 0; i < area.size(); i++) {
+    int e1 = edge[i].first, e2 = edge[i].second;
+    if (e1 < 0 || e2 < 0) {
+      continue; // Infinite edge.
+    }
+    point v1 = vertex[e1], v2 = vertex[e2];
+    if (
+      min(v1.x, v2.x) < -EPS || max(v1.x, v2.x) > XR + EPS ||
+      min(v1.y, v2.y) < -EPS || max(v1.y, v2.y) > YR + EPS
+    ) {
+      continue; // Edge outside rectangle.
+    }
+    // Add edge to graph with appropriate weight.
+    int pi1 = area[i].first, pi2 = area[i].second;
+    point p1 = P[pi1], p2 = P[pi2];
+    LD d = (p1 - project_point_segment(v1, v2, p1)).size();
+    adj[e1].emplace_back(e2, d);
+    adj[e2].emplace_back(e1, d);
+    // Consider any key points in triangles adjacent to this edge.
+    point mid = 0.5 * (p1 + p2);
+    for (int j : {0, 1}) {
+      for (int k : {0, 1}) {
+        point kp = KP[j], p = k ? p2 : p1;
+        ans = min(ans, (kp - p).size());  // Must be this close to a point.
+        if (point_in_polygon_incl({p, v1, mid}, kp)) {
+          KN[j] = e1;
+        }
+        if (point_in_polygon_incl({p, mid, v2}, kp)) {
+          KN[j] = e2;
+        }
+      }
+    }
+  }
+}
+
+LD solve() {
+  vector<point> P;
+  for (int i = 0; i < LIM; i++) {
+    adj[i].clear();
+  }
+  // Input.
+  cin >> XR >> YR;
+  cin >> KP[0].x >> KP[0].y >> KP[1].x >> KP[1].y;
+  cin >> N;
+  for (int i = 0; i < N; i++) {
+    int a, b;
+    cin >> a >> b;
+    P.emplace_back(a, b);
+    // Additionally mirror each point across each side of the rectangle.
+    P.emplace_back(-a, b);
+    P.emplace_back(a, -b);
+    P.emplace_back(2 * XR - a, b);
+    P.emplace_back(a, 2 * YR - b);
+  }
+  // Compute Voronoi diagram and corresponding graph.
+  ans = 1e18;
+  KN[0] = KN[1] = -1;
+  process_voronoi_diagrams(P);
+  assert(KN[0] >= 0 && KN[1] >= 0);
+  // MST.
+  vector<bool> visit(M);
+  priority_queue<pair<LD, int>> Q;
+  Q.emplace(ans, KN[0]);
+  while (!Q.empty()) {
+    ans = min(ans, Q.top().first);
+    int i = Q.top().second;
+    Q.pop();
+    if (i == KN[1]) {
+      break;
+    }
+    if (visit[i]) {
+      continue;
+    }
+    visit[i] = true;
+    for (auto c : adj[i]) {
+      if (!visit[c.first]) {
+        Q.emplace(c.second, c.first);
+      }
+    }
+  }
+  return ans;
+}
+
+int main() {
+  cout.precision(10);
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << fixed << solve() << endl;
+  }
+  return 0;
+}

2021/finals/antisocial.in

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3775e7403b65e0a26f30ac7a55f82b9ff51e744f4436e97ba01226840e6619f0
+size 29523370

2021/finals/antisocial.md

@@ -0,0 +1,41 @@
+Cole is a programmer in the coal division of Metal (previously Facebulk), working across \(T\) office buildings with very pleasant coworkers and unlimited free ice cream. However, as a self-proclaimed antisocial code monkey, he still prefers to "mine" his own business when possible.
+
+A given office building can be represented by an axis-aligned rectangle with opposite corners \((0, 0)\) and \((X_R, Y_R)\) on a 2D plane. Inside, there are \(N\) friendly coworkers, the \(i\)th of whom is permanently seated at position \((X_i, Y_i)\), distinct from all other coworkers.
+
+Cole is currently at position \((X_A, Y_A)\), and would like to reach the unlimited free ice cream at a different position \((X_B, Y_B)\). Neither position is located at a coworker's seat.
+
+Please help Cole determine the closest distance he'll need to get to another coworker in order to travel from \((X_A, Y_A)\) to \((X_B, Y_B)\) without leaving the building. Your answer will be accepted if it is within either \(10^{-6}\) or \(0.000001\%\) of the right answer.
+
+# Constraints
+
+\(1 \le T \le 800\)
+\(1 \le N \le 800{,}000\)
+\(2 \le X_R, Y_R \le 1{,}000{,}000{,}000\)
+\(0 < X_i, X_A, X_B < X_R\)
+\(0 < Y_i, Y_A, Y_B < Y_R\)
+
+The sum of \(N\) across all buildings is at most \(3{,}000{,}000\).
+
+# Input
+
+Input begins with a single integer \(T\), the number of office buildings. For each building, there is first a line containing \(2\) space-separated integers, \(X_R\) and \(Y_R\). Then, there is a line containing \(4\) space-separated integers, \(X_A\), \(Y_A\), \(X_B\), and \(Y_B\). Then, there a line containing a single integer \(N\). Then, \(N\) lines follow, the \(i\)th of which consists of \(2\) space-separated integers, \(X_i\) and \(Y_i\).
+
+# Output
+
+For the \(i\)th building, print a line containing *"Case #i: "* followed by a single real number, the closest that Cole will need to get to another coworker in order to reach the free ice cream.
+
+# Sample Explanation
+
+In the first building, walking directly from \((3, 1)\) to \((17, 1)\) would take Cole within just 2 units of the coworker at \((10, 3)\). Instead, one optimal route might involve walking upward first, then across, and then back down, as illustrated below:
+
+{{PHOTO_ID:441536274154579|WIDTH:450}}
+
+The closest such a route gets to the coworker is \(7\) units (for example at coordinates \((10, 10)\).
+
+In the second building, Cole's route must begin and end at a distance of \(\sqrt{4^2 + 2^2} \approx 4.47\) units from the coworker at \((10, 3)\). It's possible for Cole to get around them without getting any closer than that, for example with the following route:
+
+{{PHOTO_ID:4816243665107323|WIDTH:450}}
+  
+In the third building, one optimal route for Cole might look as follows:
+
+{{PHOTO_ID:440615224330860|WIDTH:280}}

2021/finals/antisocial.out

@@ -0,0 +1,1007 @@
+Case #1: 7.00000000
+Case #2: 4.47213595
+Case #3: 1.50000000
+Case #4: 1.00000000
+Case #5: 0.70710678
+Case #6: 20.67002661
+Case #7: 80.21533519
+Case #8: 1414210.02683937
+Case #9: 4.92442890
+Case #10: 4.00000000
+Case #11: 2.23606798
+Case #12: 2.23606798
+Case #13: 3.00000000
+Case #14: 3.00000000
+Case #15: 3.00000000
+Case #16: 1.00000000
+Case #17: 3.60555128
+Case #18: 3.00000000
+Case #19: 2.00000000
+Case #20: 2.23606798
+Case #21: 2.50000000
+Case #22: 4.12310563
+Case #23: 2.00000000
+Case #24: 1.00000000
+Case #25: 6.40312424
+Case #26: 1.41421356
+Case #27: 28.44292531
+Case #28: 156.78010078
+Case #29: 24.08318916
+Case #30: 64.12487817
+Case #31: 17.26267650
+Case #32: 72.71863585
+Case #33: 30.00000000
+Case #34: 5.83095189
+Case #35: 5.65685425
+Case #36: 33.01514804
+Case #37: 2.00000000
+Case #38: 1.00000000
+Case #39: 3.60555128
+Case #40: 1.41421356
+Case #41: 1.00000000
+Case #42: 3.16227766
+Case #43: 1.41421356
+Case #44: 2.23606798
+Case #45: 1.00000000
+Case #46: 1.00000000
+Case #47: 9543.00000000
+Case #48: 128840.13542371
+Case #49: 208298.03709589
+Case #50: 104872.11421536
+Case #51: 107938.38446540
+Case #52: 1.00000000
+Case #53: 1.00000000
+Case #54: 1.00000000
+Case #55: 1.00000000
+Case #56: 1.41421356
+Case #57: 1.00000000
+Case #58: 1.41421356
+Case #59: 1.00000000
+Case #60: 1.00000000
+Case #61: 1.00000000
+Case #62: 1.00000000
+Case #63: 1.00000000
+Case #64: 1.00000000
+Case #65: 1.00000000
+Case #66: 1.00000000
+Case #67: 1.00000000
+Case #68: 1.00000000
+Case #69: 1.00000000
+Case #70: 1.00000000
+Case #71: 1.00000000
+Case #72: 35976.61908796
+Case #73: 42938.23665744
+Case #74: 58489.66686518
+Case #75: 116585.96945173
+Case #76: 6369.86860147
+Case #77: 123579.24923708
+Case #78: 55709.89155437
+Case #79: 21791.00000000
+Case #80: 120268.51226319
+Case #81: 445241.52874255
+Case #82: 1.00000000
+Case #83: 1.00000000
+Case #84: 1.00000000
+Case #85: 1.00000000
+Case #86: 1.00000000
+Case #87: 3.00000000
+Case #88: 1.00000000
+Case #89: 1.00000000
+Case #90: 1.00000000
+Case #91: 1.00000000
+Case #92: 1.00000000
+Case #93: 2.23606798
+Case #94: 1.00000000
+Case #95: 1.00000000
+Case #96: 1.00000000
+Case #97: 1.00000000
+Case #98: 1.00000000
+Case #99: 1.00000000
+Case #100: 1.00000000
+Case #101: 1.00000000
+Case #102: 1.00000000
+Case #103: 0.70710678
+Case #104: 3.16227766
+Case #105: 1.00000000
+Case #106: 1.00000000
+Case #107: 1.00000000
+Case #108: 1.00000000
+Case #109: 1.00000000
+Case #110: 1.00000000
+Case #111: 1.41421356
+Case #112: 78704.90217420
+Case #113: 44624.42169933
+Case #114: 15757.11880389
+Case #115: 27250.00000000
+Case #116: 17927.39251118
+Case #117: 13889.43231381
+Case #118: 35204.23625077
+Case #119: 131886.18824578
+Case #120: 29047.53876407
+Case #121: 8179.31745319
+Case #122: 18736.13321900
+Case #123: 109403.20688627
+Case #124: 15882.17834555
+Case #125: 25585.01033809
+Case #126: 44822.85592195
+Case #127: 28679.92440715
+Case #128: 17528.28508440
+Case #129: 39216.44272496
+Case #130: 23306.10780461
+Case #131: 15247.12671293
+Case #132: 2.82842712
+Case #133: 1.00000000
+Case #134: 5.38516481
+Case #135: 4.00000000
+Case #136: 3.16227766
+Case #137: 1.00000000
+Case #138: 2.23606798
+Case #139: 1.00000000
+Case #140: 2.23606798
+Case #141: 1.00000000
+Case #142: 1.00000000
+Case #143: 2.82842712
+Case #144: 2.00000000
+Case #145: 4.92442890
+Case #146: 1.41421356
+Case #147: 3.16227766
+Case #148: 1.00000000
+Case #149: 2.23606798
+Case #150: 2.00000000
+Case #151: 2.91547595
+Case #152: 849.21257645
+Case #153: 612.24341564
+Case #154: 864.87976043
+Case #155: 363.88047488
+Case #156: 209.30360723
+Case #157: 434.00115207
+Case #158: 227.90568225
+Case #159: 303.64617567
+Case #160: 255.00000000
+Case #161: 564.00000000
+Case #162: 12.04159458
+Case #163: 5.00000000
+Case #164: 4.00000000
+Case #165: 10.04987562
+Case #166: 7.81024968
+Case #167: 3.16227766
+Case #168: 1.41421356
+Case #169: 22.20360331
+Case #170: 1.00000000
+Case #171: 4.24264069
+Case #172: 6.32455532
+Case #173: 1.41421356
+Case #174: 1.00000000
+Case #175: 1.00000000
+Case #176: 1.00000000
+Case #177: 1.00000000
+Case #178: 13.03840481
+Case #179: 10.00000000
+Case #180: 4.47213595
+Case #181: 2.00000000
+Case #182: 172138.00000290
+Case #183: 61871.00029093
+Case #184: 193561.86906000
+Case #185: 2603.00691509
+Case #186: 115472.29394534
+Case #187: 6695.00067214
+Case #188: 45248.57161281
+Case #189: 1538.00130039
+Case #190: 267166.22841220
+Case #191: 72714.38709086
+Case #192: 161.91355718
+Case #193: 139.03237033
+Case #194: 132.83448347
+Case #195: 182.00274723
+Case #196: 588.16409275
+Case #197: 61.13100686
+Case #198: 294.17001887
+Case #199: 386.42981251
+Case #200: 677.83257520
+Case #201: 143.31521203
+Case #202: 216.17816726
+Case #203: 137.38267722
+Case #204: 39.05124838
+Case #205: 158.34456101
+Case #206: 460.00978250
+Case #207: 452.63368191
+Case #208: 4.47213595
+Case #209: 2.23606798
+Case #210: 2.23606798
+Case #211: 5.09901951
+Case #212: 2.23606798
+Case #213: 2.00000000
+Case #214: 1.00000000
+Case #215: 5.09901951
+Case #216: 1.41421356
+Case #217: 1.41421356
+Case #218: 8.60232527
+Case #219: 2.82842712
+Case #220: 1.00000000
+Case #221: 10.00000000
+Case #222: 4.47213595
+Case #223: 1.00000000
+Case #224: 3.60555128
+Case #225: 1.41421356
+Case #226: 3.00000000
+Case #227: 4.00000000
+Case #228: 2.23606798
+Case #229: 2.00000000
+Case #230: 6.70820393
+Case #231: 2.00000000
+Case #232: 1.00000000
+Case #233: 1.00000000
+Case #234: 3.60555128
+Case #235: 6.70820393
+Case #236: 7.28010989
+Case #237: 1.41421356
+Case #238: 1.00000000
+Case #239: 5.00000000
+Case #240: 2.00000000
+Case #241: 1.41421356
+Case #242: 5.00000000
+Case #243: 2.00000000
+Case #244: 2.23606798
+Case #245: 2.23606798
+Case #246: 5.83095189
+Case #247: 1.41421356
+Case #248: 2.23606798
+Case #249: 2.82842712
+Case #250: 3.00000000
+Case #251: 1.00000000
+Case #252: 3.16227766
+Case #253: 1.00000000
+Case #254: 1.00000000
+Case #255: 3.16227766
+Case #256: 1.00000000
+Case #257: 1.41421356
+Case #258: 3.60555128
+Case #259: 2.82842712
+Case #260: 1.41421356
+Case #261: 2.23606798
+Case #262: 7.28010989
+Case #263: 3.00000000
+Case #264: 1.00000000
+Case #265: 2.23606798
+Case #266: 1.00000000
+Case #267: 3.16227766
+Case #268: 4.12310563
+Case #269: 2.00000000
+Case #270: 1.41421356
+Case #271: 2.00000000
+Case #272: 2.00000000
+Case #273: 6.40312424
+Case #274: 3.16227766
+Case #275: 8.06225775
+Case #276: 8.24621125
+Case #277: 2.23606798
+Case #278: 2.82842712
+Case #279: 3.80788655
+Case #280: 1.00000000
+Case #281: 9.21954446
+Case #282: 2.23606798
+Case #283: 3.16227766
+Case #284: 2.82842712
+Case #285: 3.60555128
+Case #286: 5.09901951
+Case #287: 3.60555128
+Case #288: 9.05538514
+Case #289: 2.23606798
+Case #290: 3.16227766
+Case #291: 5.83095189
+Case #292: 1.00000000
+Case #293: 8.00000000
+Case #294: 4.00000000
+Case #295: 2.00000000
+Case #296: 1.41421356
+Case #297: 2.00000000
+Case #298: 5.09901951
+Case #299: 1.00000000
+Case #300: 1.00000000
+Case #301: 7.00000000
+Case #302: 1.00000000
+Case #303: 2.23606798
+Case #304: 8.06225775
+Case #305: 2.00000000
+Case #306: 2.00000000
+Case #307: 4.12310563
+Case #308: 1.41421356
+Case #309: 1.41421356
+Case #310: 2.82842712
+Case #311: 1.41421356
+Case #312: 1.41421356
+Case #313: 2.23606798
+Case #314: 2.23606798
+Case #315: 2.23606798
+Case #316: 1.41421356
+Case #317: 5.40832691
+Case #318: 2.23606798
+Case #319: 6.08276253
+Case #320: 5.38516481
+Case #321: 1.00000000
+Case #322: 2.23606798
+Case #323: 1.00000000
+Case #324: 4.12310563
+Case #325: 3.60555128
+Case #326: 2.00000000
+Case #327: 5.00000000
+Case #328: 4.00000000
+Case #329: 6.00000000
+Case #330: 3.60555128
+Case #331: 4.47213595
+Case #332: 1.00000000
+Case #333: 1.00000000
+Case #334: 1.41421356
+Case #335: 3.16227766
+Case #336: 12.16552506
+Case #337: 4.00000000
+Case #338: 2.23606798
+Case #339: 2.23606798
+Case #340: 3.16227766
+Case #341: 9.43398113
+Case #342: 2.82842712
+Case #343: 1.41421356
+Case #344: 5.65685425
+Case #345: 4.12310563
+Case #346: 3.00000000
+Case #347: 6.08276253
+Case #348: 6.70820393
+Case #349: 3.00000000
+Case #350: 5.38516481
+Case #351: 4.12310563
+Case #352: 6.08276253
+Case #353: 6.70820393
+Case #354: 2.82842712
+Case #355: 1.00000000
+Case #356: 2.82842712
+Case #357: 2.82842712
+Case #358: 1.41421356
+Case #359: 2.82842712
+Case #360: 1.00000000
+Case #361: 3.16227766
+Case #362: 5.09901951
+Case #363: 1.41421356
+Case #364: 1.00000000
+Case #365: 4.00000000
+Case #366: 8.06225775
+Case #367: 1.41421356
+Case #368: 2.23606798
+Case #369: 2.00000000
+Case #370: 7.00000000
+Case #371: 2.23606798
+Case #372: 1.41421356
+Case #373: 2.00000000
+Case #374: 2.82842712
+Case #375: 2.82842712
+Case #376: 5.65685425
+Case #377: 3.16227766
+Case #378: 8.06225775
+Case #379: 4.24264069
+Case #380: 1.00000000
+Case #381: 3.60555128
+Case #382: 2.23606798
+Case #383: 1.41421356
+Case #384: 1.00000000
+Case #385: 4.12310563
+Case #386: 2.23606798
+Case #387: 3.60555128
+Case #388: 3.00000000
+Case #389: 2.23606798
+Case #390: 3.60555128
+Case #391: 3.16227766
+Case #392: 1.41421356
+Case #393: 4.12310563
+Case #394: 3.00000000
+Case #395: 3.00000000
+Case #396: 1.41421356
+Case #397: 5.00000000
+Case #398: 1.00000000
+Case #399: 1.41421356
+Case #400: 2.23606798
+Case #401: 4.47213595
+Case #402: 2.00000000
+Case #403: 3.16227766
+Case #404: 1.41421356
+Case #405: 3.60555128
+Case #406: 2.23606798
+Case #407: 2.23606798
+Case #408: 3.16227766
+Case #409: 3.60555128
+Case #410: 1.41421356
+Case #411: 2.82842712
+Case #412: 2.23606798
+Case #413: 5.00000000
+Case #414: 2.00000000
+Case #415: 2.00000000
+Case #416: 5.00000000
+Case #417: 3.60555128
+Case #418: 6.70820393
+Case #419: 2.82842712
+Case #420: 5.00000000
+Case #421: 5.38516481
+Case #422: 2.00000000
+Case #423: 5.83095189
+Case #424: 3.00000000
+Case #425: 4.00000000
+Case #426: 3.16227766
+Case #427: 3.16227766
+Case #428: 1.00000000
+Case #429: 7.21110255
+Case #430: 3.60555128
+Case #431: 1.00000000
+Case #432: 2.23606798
+Case #433: 1.41421356
+Case #434: 8.06225775
+Case #435: 6.32455532
+Case #436: 1.00000000
+Case #437: 4.12310563
+Case #438: 1.41421356
+Case #439: 6.40312424
+Case #440: 3.16227766
+Case #441: 3.60555128
+Case #442: 2.23606798
+Case #443: 3.16227766
+Case #444: 3.00000000
+Case #445: 3.60555128
+Case #446: 1.41421356
+Case #447: 13.41640786
+Case #448: 3.00000000
+Case #449: 3.16227766
+Case #450: 5.09901951
+Case #451: 2.23606798
+Case #452: 1.41421356
+Case #453: 2.23606798
+Case #454: 5.09901951
+Case #455: 4.00000000
+Case #456: 1.41421356
+Case #457: 2.00000000
+Case #458: 3.80788655
+Case #459: 1.00000000
+Case #460: 3.16227766
+Case #461: 6.40312424
+Case #462: 2.23606798
+Case #463: 2.00000000
+Case #464: 6.08276253
+Case #465: 1.00000000
+Case #466: 1.41421356
+Case #467: 2.23606798
+Case #468: 3.60555128
+Case #469: 2.00000000
+Case #470: 4.00000000
+Case #471: 3.00000000
+Case #472: 2.23606798
+Case #473: 2.23606798
+Case #474: 10.00000000
+Case #475: 3.16227766
+Case #476: 1.00000000
+Case #477: 1.00000000
+Case #478: 5.09901951
+Case #479: 3.16227766
+Case #480: 3.00000000
+Case #481: 3.16227766
+Case #482: 10.77032961
+Case #483: 2.00000000
+Case #484: 3.00000000
+Case #485: 7.28010989
+Case #486: 2.23606798
+Case #487: 5.00000000
+Case #488: 1.00000000
+Case #489: 1.41421356
+Case #490: 1.00000000
+Case #491: 1.00000000
+Case #492: 5.00000000
+Case #493: 1.41421356
+Case #494: 4.47213595
+Case #495: 2.23606798
+Case #496: 4.12310563
+Case #497: 1.41421356
+Case #498: 3.60555128
+Case #499: 1.41421356
+Case #500: 3.00000000
+Case #501: 3.60555128
+Case #502: 1.00000000
+Case #503: 5.00000000
+Case #504: 2.23606798
+Case #505: 1.41421356
+Case #506: 1.00000000
+Case #507: 2.00000000
+Case #508: 2.82842712
+Case #509: 4.47213595
+Case #510: 3.60555128
+Case #511: 4.12310563
+Case #512: 6.70820393
+Case #513: 1.41421356
+Case #514: 1.00000000
+Case #515: 5.09901951
+Case #516: 5.83095189
+Case #517: 3.00000000
+Case #518: 2.00000000
+Case #519: 1.41421356
+Case #520: 4.24264069
+Case #521: 1.00000000
+Case #522: 5.09901951
+Case #523: 1.00000000
+Case #524: 1.00000000
+Case #525: 5.83095189
+Case #526: 11.66190379
+Case #527: 1.00000000
+Case #528: 5.09901951
+Case #529: 1.00000000
+Case #530: 2.23606798
+Case #531: 5.83095189
+Case #532: 4.47213595
+Case #533: 2.82842712
+Case #534: 1.00000000
+Case #535: 8.06225775
+Case #536: 2.00000000
+Case #537: 2.23606798
+Case #538: 1.41421356
+Case #539: 6.32455532
+Case #540: 5.38516481
+Case #541: 6.32455532
+Case #542: 3.16227766
+Case #543: 8.06225775
+Case #544: 5.00000000
+Case #545: 2.23606798
+Case #546: 1.41421356
+Case #547: 3.60555128
+Case #548: 2.82842712
+Case #549: 1.00000000
+Case #550: 2.00000000
+Case #551: 6.00000000
+Case #552: 1.00000000
+Case #553: 2.00000000
+Case #554: 2.00000000
+Case #555: 2.23606798
+Case #556: 3.16227766
+Case #557: 1.41421356
+Case #558: 1.00000000
+Case #559: 1.00000000
+Case #560: 3.16227766
+Case #561: 1.00000000
+Case #562: 1.00000000
+Case #563: 2.23606798
+Case #564: 1.00000000
+Case #565: 13.03840481
+Case #566: 1.00000000
+Case #567: 7.28010989
+Case #568: 1.41421356
+Case #569: 12.04159458
+Case #570: 2.00000000
+Case #571: 2.00000000
+Case #572: 1.41421356
+Case #573: 3.16227766
+Case #574: 1.00000000
+Case #575: 3.16227766
+Case #576: 4.12310563
+Case #577: 1.00000000
+Case #578: 2.00000000
+Case #579: 10.44030651
+Case #580: 1.00000000
+Case #581: 2.00000000
+Case #582: 1.41421356
+Case #583: 4.00000000
+Case #584: 1.41421356
+Case #585: 2.23606798
+Case #586: 1.41421356
+Case #587: 5.00000000
+Case #588: 4.12310563
+Case #589: 2.00000000
+Case #590: 4.12310563
+Case #591: 2.00000000
+Case #592: 1.00000000
+Case #593: 7.28010989
+Case #594: 3.00000000
+Case #595: 2.23606798
+Case #596: 10.29563014
+Case #597: 7.21110255
+Case #598: 1.41421356
+Case #599: 1.00000000
+Case #600: 4.47213595
+Case #601: 5.00000000
+Case #602: 2.23606798
+Case #603: 2.00000000
+Case #604: 9.43398113
+Case #605: 5.83095189
+Case #606: 3.60555128
+Case #607: 2.23606798
+Case #608: 2.23606798
+Case #609: 1.00000000
+Case #610: 5.09901951
+Case #611: 1.00000000
+Case #612: 1.41421356
+Case #613: 1.00000000
+Case #614: 2.00000000
+Case #615: 1.00000000
+Case #616: 5.09901951
+Case #617: 2.82842712
+Case #618: 1.41421356
+Case #619: 9.21954446
+Case #620: 2.82842712
+Case #621: 2.00000000
+Case #622: 4.24264069
+Case #623: 2.00000000
+Case #624: 2.23606798
+Case #625: 1.00000000
+Case #626: 2.23606798
+Case #627: 1.41421356
+Case #628: 3.00000000
+Case #629: 4.12310563
+Case #630: 3.16227766
+Case #631: 4.24264069
+Case #632: 6.70820393
+Case #633: 2.00000000
+Case #634: 7.07106781
+Case #635: 1.00000000
+Case #636: 2.23606798
+Case #637: 2.00000000
+Case #638: 1.00000000
+Case #639: 5.09901951
+Case #640: 1.00000000
+Case #641: 1.00000000
+Case #642: 2.00000000
+Case #643: 3.16227766
+Case #644: 4.47213595
+Case #645: 6.08276253
+Case #646: 2.00000000
+Case #647: 10.44030651
+Case #648: 3.16227766
+Case #649: 2.23606798
+Case #650: 6.08276253
+Case #651: 2.00000000
+Case #652: 15.55634919
+Case #653: 3.60555128
+Case #654: 5.09901951
+Case #655: 3.16227766
+Case #656: 3.60555128
+Case #657: 1.41421356
+Case #658: 1.41421356
+Case #659: 2.00000000
+Case #660: 1.00000000
+Case #661: 4.24264069
+Case #662: 8.06225775
+Case #663: 2.23606798
+Case #664: 1.00000000
+Case #665: 5.00000000
+Case #666: 1.00000000
+Case #667: 4.47213595
+Case #668: 5.00000000
+Case #669: 4.12310563
+Case #670: 6.00000000
+Case #671: 3.00000000
+Case #672: 1.41421356
+Case #673: 3.00000000
+Case #674: 2.00000000
+Case #675: 1.00000000
+Case #676: 3.90512484
+Case #677: 5.09901951
+Case #678: 6.08276253
+Case #679: 5.00000000
+Case #680: 3.60555128
+Case #681: 1.00000000
+Case #682: 3.16227766
+Case #683: 3.00000000
+Case #684: 4.12310563
+Case #685: 2.23606798
+Case #686: 4.00000000
+Case #687: 2.00000000
+Case #688: 2.82842712
+Case #689: 2.23606798
+Case #690: 2.00000000
+Case #691: 1.00000000
+Case #692: 12.04159458
+Case #693: 1.41421356
+Case #694: 6.70820393
+Case #695: 2.23606798
+Case #696: 3.00000000
+Case #697: 3.60555128
+Case #698: 3.16227766
+Case #699: 2.00000000
+Case #700: 1.00000000
+Case #701: 2.82842712
+Case #702: 5.09901951
+Case #703: 8.06225775
+Case #704: 6.70820393
+Case #705: 1.00000000
+Case #706: 4.00000000
+Case #707: 4.00000000
+Case #708: 1.00000000
+Case #709: 6.08276253
+Case #710: 1.41421356
+Case #711: 4.00000000
+Case #712: 4.00000000
+Case #713: 5.00000000
+Case #714: 1.41421356
+Case #715: 2.23606798
+Case #716: 3.00000000
+Case #717: 2.82842712
+Case #718: 2.82842712
+Case #719: 1.00000000
+Case #720: 1.41421356
+Case #721: 5.09901951
+Case #722: 6.32455532
+Case #723: 1.41421356
+Case #724: 2.82842712
+Case #725: 1.00000000
+Case #726: 2.23606798
+Case #727: 4.00000000
+Case #728: 1.00000000
+Case #729: 11.00000000
+Case #730: 2.00000000
+Case #731: 3.60555128
+Case #732: 6.32455532
+Case #733: 5.00000000
+Case #734: 1.41421356
+Case #735: 4.12310563
+Case #736: 1.00000000
+Case #737: 6.08276253
+Case #738: 2.82842712
+Case #739: 1.00000000
+Case #740: 3.00000000
+Case #741: 3.16227766
+Case #742: 1.00000000
+Case #743: 2.82842712
+Case #744: 2.23606798
+Case #745: 3.00000000
+Case #746: 4.12310563
+Case #747: 1.00000000
+Case #748: 1.00000000
+Case #749: 3.16227766
+Case #750: 5.65685425
+Case #751: 5.65685425
+Case #752: 1.41421356
+Case #753: 3.60555128
+Case #754: 2.00000000
+Case #755: 3.16227766
+Case #756: 1.00000000
+Case #757: 2.00000000
+Case #758: 4.00000000
+Case #759: 5.65685425
+Case #760: 1.41421356
+Case #761: 5.00000000
+Case #762: 1.41421356
+Case #763: 4.47213595
+Case #764: 4.47213595
+Case #765: 7.81024968
+Case #766: 2.00000000
+Case #767: 2.23606798
+Case #768: 1.00000000
+Case #769: 1.00000000
+Case #770: 4.47213595
+Case #771: 1.00000000
+Case #772: 7.28010989
+Case #773: 2.23606798
+Case #774: 2.23606798
+Case #775: 4.47213595
+Case #776: 1.41421356
+Case #777: 2.23606798
+Case #778: 1.00000000
+Case #779: 1.00000000
+Case #780: 3.16227766
+Case #781: 1.41421356
+Case #782: 1.41421356
+Case #783: 1.00000000
+Case #784: 3.60555128
+Case #785: 1.00000000
+Case #786: 10.29563014
+Case #787: 2.23606798
+Case #788: 2.23606798
+Case #789: 4.12310563
+Case #790: 5.65685425
+Case #791: 2.00000000
+Case #792: 3.60555128
+Case #793: 8.06225775
+Case #794: 1.41421356
+Case #795: 2.82842712
+Case #796: 1.00000000
+Case #797: 2.00000000
+Case #798: 4.47213595
+Case #799: 7.21110255
+Case #800: 12.36931688
+Case #801: 2.00000000
+Case #802: 1.41421356
+Case #803: 2.23606798
+Case #804: 3.16227766
+Case #805: 5.00000000
+Case #806: 2.23606798
+Case #807: 3.60555128
+Case #808: 4.00000000
+Case #809: 3.16227766
+Case #810: 5.09901951
+Case #811: 6.70820393
+Case #812: 4.47213595
+Case #813: 3.16227766
+Case #814: 4.12310563
+Case #815: 1.00000000
+Case #816: 3.00000000
+Case #817: 3.16227766
+Case #818: 2.00000000
+Case #819: 4.12310563
+Case #820: 1.00000000
+Case #821: 4.47213595
+Case #822: 1.41421356
+Case #823: 3.00000000
+Case #824: 1.00000000
+Case #825: 2.23606798
+Case #826: 3.00000000
+Case #827: 1.41421356
+Case #828: 7.28010989
+Case #829: 1.41421356
+Case #830: 8.60232527
+Case #831: 2.82842712
+Case #832: 4.24264069
+Case #833: 4.12310563
+Case #834: 1.41421356
+Case #835: 1.00000000
+Case #836: 4.12310563
+Case #837: 1.41421356
+Case #838: 2.00000000
+Case #839: 3.16227766
+Case #840: 1.41421356
+Case #841: 1.00000000
+Case #842: 6.08276253
+Case #843: 1.00000000
+Case #844: 3.60555128
+Case #845: 6.32455532
+Case #846: 3.16227766
+Case #847: 2.23606798
+Case #848: 9.43398113
+Case #849: 3.16227766
+Case #850: 1.00000000
+Case #851: 5.38516481
+Case #852: 7.61577311
+Case #853: 4.47213595
+Case #854: 3.60555128
+Case #855: 1.00000000
+Case #856: 2.82842712
+Case #857: 6.08276253
+Case #858: 4.00000000
+Case #859: 3.60555128
+Case #860: 9.84885780
+Case #861: 1.00000000
+Case #862: 2.23606798
+Case #863: 1.00000000
+Case #864: 2.23606798
+Case #865: 4.12310563
+Case #866: 5.00000000
+Case #867: 1.41421356
+Case #868: 1.00000000
+Case #869: 5.00000000
+Case #870: 5.38516481
+Case #871: 4.00000000
+Case #872: 4.47213595
+Case #873: 5.38516481
+Case #874: 1.00000000
+Case #875: 6.00000000
+Case #876: 2.00000000
+Case #877: 2.23606798
+Case #878: 2.82842712
+Case #879: 5.38516481
+Case #880: 4.12310563
+Case #881: 4.00000000
+Case #882: 2.82842712
+Case #883: 3.00000000
+Case #884: 1.41421356
+Case #885: 7.07106781
+Case #886: 5.38516481
+Case #887: 3.00000000
+Case #888: 3.00000000
+Case #889: 1.41421356
+Case #890: 1.00000000
+Case #891: 2.82842712
+Case #892: 3.53553391
+Case #893: 1.41421356
+Case #894: 1.00000000
+Case #895: 3.00000000
+Case #896: 3.60555128
+Case #897: 4.47213595
+Case #898: 1.00000000
+Case #899: 2.23606798
+Case #900: 1.00000000
+Case #901: 3.60555128
+Case #902: 1.41421356
+Case #903: 1.41421356
+Case #904: 6.08276253
+Case #905: 5.83095189
+Case #906: 2.23606798
+Case #907: 1.00000000
+Case #908: 2.00000000
+Case #909: 1.00000000
+Case #910: 8.24621125
+Case #911: 5.00000000
+Case #912: 3.16227766
+Case #913: 2.00000000
+Case #914: 2.23606798
+Case #915: 4.12310563
+Case #916: 2.00000000
+Case #917: 2.23606798
+Case #918: 1.00000000
+Case #919: 2.23606798
+Case #920: 4.12310563
+Case #921: 1.41421356
+Case #922: 1.41421356
+Case #923: 2.23606798
+Case #924: 2.23606798
+Case #925: 1.41421356
+Case #926: 8.54400375
+Case #927: 2.23606798
+Case #928: 3.60555128
+Case #929: 1.41421356
+Case #930: 4.24264069
+Case #931: 3.00000000
+Case #932: 2.82842712
+Case #933: 5.38516481
+Case #934: 2.23606798
+Case #935: 2.23606798
+Case #936: 3.00000000
+Case #937: 1.41421356
+Case #938: 2.00000000
+Case #939: 2.23606798
+Case #940: 2.00000000
+Case #941: 6.00000000
+Case #942: 2.23606798
+Case #943: 1.00000000
+Case #944: 1.00000000
+Case #945: 2.00000000
+Case #946: 3.60555128
+Case #947: 1.00000000
+Case #948: 3.60555128
+Case #949: 4.24264069
+Case #950: 3.60555128
+Case #951: 1.00000000
+Case #952: 5.00000000
+Case #953: 1.00000000
+Case #954: 3.60555128
+Case #955: 2.00000000
+Case #956: 3.16227766
+Case #957: 1.00000000
+Case #958: 1.00000000
+Case #959: 2.00000000
+Case #960: 1.00000000
+Case #961: 1.00000000
+Case #962: 2.23606798
+Case #963: 5.09901951
+Case #964: 1.00000000
+Case #965: 7.28010989
+Case #966: 1.00000000
+Case #967: 2.23606798
+Case #968: 1.00000000
+Case #969: 1.00000000
+Case #970: 3.16227766
+Case #971: 2.00000000
+Case #972: 4.24264069
+Case #973: 2.82842712
+Case #974: 2.23606798
+Case #975: 12.64911064
+Case #976: 1.00000000
+Case #977: 1.00000000
+Case #978: 5.65685425
+Case #979: 1.00000000
+Case #980: 10.44030651
+Case #981: 1.41421356
+Case #982: 6.08276253
+Case #983: 2.23606798
+Case #984: 3.04138127
+Case #985: 1.00000000
+Case #986: 3.60555128
+Case #987: 1.41421356
+Case #988: 2.00000000
+Case #989: 4.24264069
+Case #990: 2.00000000
+Case #991: 3.60555128
+Case #992: 2.23606798
+Case #993: 3.00000000
+Case #994: 3.00000000
+Case #995: 3.16227766
+Case #996: 1.00000000
+Case #997: 4.47213595
+Case #998: 3.00000000
+Case #999: 2.82842712
+Case #1000: 9.84885780
+Case #1001: 5.38516481
+Case #1002: 1.00000000
+Case #1003: 3.16227766
+Case #1004: 1.00000000
+Case #1005: 1.00000000
+Case #1006: 3.60555128
+Case #1007: 3.16227766

2021/finals/antisocial_sol.md

@@ -0,0 +1,20 @@
+We can imagine "danger circles" around all coworkers increase at a constant size until there is no path to the finish. This idea is very similar to the construction of a Voronoi diagram, which can be done in \(O(N \log(N))\) time using Fortune's algorithm. If we remove the restriction that you are not allowed to leave the building's borders, the optimal path maximizing the distance to the nearest person will be a sequence of edges on the Voronoi diagram, as well as a segment from the start position to a Voronoi node and a segment from the end position to a Voronoi node. For the first and last segment, we simply want to walk to a Voronoi node that isn't *closer* to our nearest neighbor than we are, of the Voronoi nodes tangential to this neighbor's corresponding node in the Delaunay triangulation. Valid start and end Voronoi nodes can be found by iterating through all neighboring Voronoi nodes to the nearest person, and simply taking the one which is most in the direction away from the nearest coworker. Then, we can handle the path of Voronoi edges by sorting the edges and using a disjoint set (similarly to Kruskal's minimum spanning tree algorithm, though in this case as a maximum spanning tree), stopping once the start and end Voronoi nodes are unioned.
+
+Note that there are also 2 cases in which the path might not remain on the Voronoi diagram's edges:
+
+  1. At the start (and similarly at the end), the path must move from the the starting point \(a = (X_A, Y_A)\) to some graph node. If it's in the Voronoi cell of some closest point \(x\), then it should move to some node on the boundary of that cell without getting closer to \(x\) (any such node will do). A valid choice of node is the one which is closest angle-wise (relative to \(x\)) to \(a\).
+  
+  2. The path can also travel along the borders of the building's rectangle — there should effectively be a graph node at each rectangle corner and at each intersection of an (infinite) Voronoi edge with the rectangle's border, with these nodes connected around the border by edges (weighted like the other edges). A good way of constructing this situation is to begin by mirroring all \(N\) points across the rectangle's \(4\) sides, and then computing the Voronoi diagram for all \(5N\) resulting points. Provided that we then include Voronoi edges lying inside or on the border of the rectangle (excluding ones lying outside it), the set of edges will then be exactly what we need. 
+  This is because the introduction of the mirrored points doesn't affect the portion of the Voronoi diagram strictly inside the rectangle (as no mirrored point can be the closest point to a point inside the rectangle; the corresponding original point must be closer), while at each point along the rectangle's boundary, whatever original point was closest to it, the corresponding mirrored point must now be equidistant (resulting in a Voronoi node/edge at the border). 
+  For a visualization of this concept with a 3-point example, check out [this tool](http://alexbeutel.com/webgl/voronoi.html) with the following input data: `{"sites":[220,240,270,250,290,220,180,240,220,160,380,240,220,360,270,150,270,350,130,250,330,250,290,180,290,380,110,220,310,220],"queries":[]}`.
+  
+The time complexity of the above algorithm is \(O(N \log(N))\).
+
+It's worth noting that it's also possible to solve this problem for many (e.g. \(10^5\)) queries of start/end points, though that extension was not included in the contest as its implementation would be rather long.
+
+Computation of which Voronoi cell and graph node each starting/ending point corresponds to must now be done more efficiently, in less than \(O(N)\) time per such point. It's possible to augment Fortune's algorithm to determine which Voronoi cell each such point lies within. Alternatively, you can do a line sweep from left to right, finding for each query point which Voronoi edge is above it (form which you can determine which Voronoi cell it is in). For each cell, if the angles of its surrounding Voronoi vertices (relative to the cell's central point) are precomputed and sorted, it's possible to binary search over them for each starting/ending point to find its enclosing triangle. These changes take a total of \(O((N+K) \log(N))\) time.
+
+To solve the second part of the problem, one approach involves still generating a maximum spanning tree using Kruskal's algorithm. The answer for a query is then based on the minimum edge weight on the path connecting its starting/ending points' corresponding nodes in this tree. This can be computed for each query using binary lifting (or other methods). Thus, the time complexity of this portion also comes out to \(O((N+K) \log(N))\) time.
+
+Another approach for the second part of the problem is to use a parallel binary search. For each query, we can store its minimum and maximum possible answer, and iterate through all edges until these ranges are sufficiently small. At each iteration, the range for each query's possible answer will be halved. An iteration consists of maintaining a disjoint set of all components, processing queries and edges in decreasing order of weight. When we get to a query, we simply check if its two nodes are in the same component, and adjust either the high or low value of that queries binary search accordingly (this will change its mid for where it is sorted in the next iteration). At a Voronoi edge, we simply union the two components.
+

2021/finals/hire_flyers.cpp

@@ -0,0 +1,354 @@
+#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;
+}

2021/finals/hire_flyers.in

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec067e73d4e7660125c8b0e7f05c676243bd6de76bb7fe2d619a564f925d1b41
+size 35952813

2021/finals/hire_flyers.md

@@ -0,0 +1,50 @@
+The market is hot for geological talent! Hiring agents are competing to display their job flyers on street intersections across \(T\) towns.
+
+A town's streets can be represented as an infinite 2D grid with rows numbered by increasing integers from North to South and columns numbered by increasing integers from West to East.
+
+There are \(N\) hiring agents, numbered from \(1\) to \(N\). Agent \(i\) starts at the intersection of row \(R_i\) and column \(C_i\), holding \(P_i\) flyers, and facing the cardinal direction \(D_i\) (`"N"` for North, `"S"` for South, `"E"` for East, or `"W"` for West). Each *turn* taken by an agent consists of the following:
+
+  1. Post one of their own flyers at their current intersection, shredding any competing flyer that may have previously been there.
+  2. If the agent has more flyers, move to the adjacent intersection in direction \(D_i\).
+  
+The agents will take turns posting one flyer at a time. Agent \(1\) will take a turn, followed by agent \(2\), and so on until agent \(N\) takes a turn, at which point agent \(1\) will go again (if necessary). Note that there may be multiple agents occupying the same intersection at any point in time.
+
+Let \(F_i\) be the number of flyers placed by agent \(i\) which remain will unshredded at the end. Your job is to compute the sum of \(i * F_i\) over all agents \(i\). As this sum may be very large, you should only compute it modulo \(1{,}000{,}000{,}007\).
+
+
+# Constraints
+
+\(1 \le T \le 75\)
+\(1 \le N \le 800{,}000\)
+\(0 \le R_i, C_i \le 1{,}000{,}000{,}000\)
+\(1 \le P_i \le 1{,}000{,}000{,}000\)
+\(D_i \in \{\)`"N"`, `"S"`, `"E"`, `"W"`\(\}\)
+
+The sum of \(N\) across all towns is at most \(2{,}000{,}000\).
+
+
+# Input
+
+Input begins with an integer \(T\), the number of towns. For each town, there is first a line containing a single integer \(N\). Then, \(N\) lines follow, the \(i\)th of which consists of \(3\) space-separated integers \(R_i\), \(C_i\), and \(P_i\), followed by a space-separated character, \(D_i\).
+
+
+# Output
+
+For the \(i\)th town, print a line containing *"Case #i: "* followed by a single integer, the sum of \(i * F_i\) over all agents \(i\), modulo \(1{,}000{,}000{,}007\).
+
+
+# Sample Explanation
+
+In the first town, the relevant portion of the grid will end up with the following flyers (with `"."` representing an intersection with no flyer), yielding an answer of \((1 * 3 + 2 * 2 + 3 * 1 + 4 * 1) \;\mathrm{mod}\; 1{,}000{,}000{,}007 = 14\):
+
+{{PHOTO_ID:1597395337265553|WIDTH:180}}
+
+In the second town, the relevant portion of the grid will end up with the following flyers, yielding an answer of \((1 * 2 + 2 * 2 + 3 * 2 + 4 * 2) \;\mathrm{mod}\; 1{,}000{,}000{,}007 = 20\):
+
+{{PHOTO_ID:4543454065770744|WIDTH:234}}
+
+In the third town, each of agent \(2\)'s turns will involve shredding the last flyer placed by agent \(1\) and replacing it with her own. This will result in \(1{,}000{,}000{,}000\) intersections containing agent \(2\)'s flyers, for an answer of \((2 * 1{,}000{,}000{,}000) \;\mathrm{mod}\; 1{,}000{,}000{,}007 = 999999993\).
+
+In the fourth town, the relevant portion of the grid will end up with the following flyers:
+
+{{PHOTO_ID:451563133198975|WIDTH:360}}

2021/finals/hire_flyers.out

@@ -0,0 +1,118 @@
+Case #1: 14
+Case #2: 20
+Case #3: 999999993
+Case #4: 40
+Case #5: 431
+Case #6: 99999993
+Case #7: 999999994
+Case #8: 99999994
+Case #9: 1000000002
+Case #10: 1000000000
+Case #11: 999999993
+Case #12: 999999993
+Case #13: 999999993
+Case #14: 999999897
+Case #15: 999999871
+Case #16: 423
+Case #17: 199999229
+Case #18: 217073425
+Case #19: 33397706
+Case #20: 485540721
+Case #21: 357736831
+Case #22: 9508
+Case #23: 23
+Case #24: 18
+Case #25: 6628
+Case #26: 17604
+Case #27: 616191825
+Case #28: 856214908
+Case #29: 616087243
+Case #30: 471216968
+Case #31: 38733402
+Case #32: 936491239
+Case #33: 730649978
+Case #34: 306373993
+Case #35: 65225585
+Case #36: 285757320
+Case #37: 930974524
+Case #38: 372468607
+Case #39: 928733717
+Case #40: 275995039
+Case #41: 836627363
+Case #42: 65664903
+Case #43: 983496873
+Case #44: 519454660
+Case #45: 90348890
+Case #46: 684422234
+Case #47: 513902139
+Case #48: 669592753
+Case #49: 357034246
+Case #50: 43918841
+Case #51: 521394249
+Case #52: 564353372
+Case #53: 855226307
+Case #54: 239432065
+Case #55: 625583995
+Case #56: 513611137
+Case #57: 275942363
+Case #58: 587689801
+Case #59: 731508246
+Case #60: 231112528
+Case #61: 854323953
+Case #62: 174113343
+Case #63: 183976986
+Case #64: 521066588
+Case #65: 22830859
+Case #66: 326336345
+Case #67: 272982133
+Case #68: 598100830
+Case #69: 150190138
+Case #70: 391017847
+Case #71: 486836356
+Case #72: 820516557
+Case #73: 908604859
+Case #74: 640323950
+Case #75: 616284508
+Case #76: 31141531
+Case #77: 226022048
+Case #78: 320220618
+Case #79: 599198956
+Case #80: 306153532
+Case #81: 725058056
+Case #82: 569982633
+Case #83: 199539090
+Case #84: 908976066
+Case #85: 306805906
+Case #86: 190096232
+Case #87: 350305906
+Case #88: 692998074
+Case #89: 675835976
+Case #90: 342816784
+Case #91: 816435451
+Case #92: 685089027
+Case #93: 74992281
+Case #94: 935277973
+Case #95: 512924016
+Case #96: 231908365
+Case #97: 42789399
+Case #98: 329880680
+Case #99: 645685346
+Case #100: 937296473
+Case #101: 342175151
+Case #102: 606419669
+Case #103: 725071734
+Case #104: 267317223
+Case #105: 679712553
+Case #106: 198107887
+Case #107: 703671316
+Case #108: 365207939
+Case #109: 635956066
+Case #110: 917227680
+Case #111: 77831067
+Case #112: 934581893
+Case #113: 820657774
+Case #114: 59748552
+Case #115: 494746701
+Case #116: 962057137
+Case #117: 687849975
+Case #118: 199374792

2021/finals/hire_flyers_sol.md

@@ -0,0 +1,15 @@
+Each contiguous portion of a hiring agent's path can be represented as a 2D segment with \(6\) properties (agent's index, segment's initial row, segment's initial column, turns taken by the agent before reaching the segment's initial row/column, direction, and segment length). Each agent's full path corresponds to one such segment (with \(0\) turns taken before reaching it), but we may want to split/trim/remove some of these segments, based on which portions of them "cover" portions of others (visit cells later, thus replacing their flyers).
+
+For each relevant row containing \(a_1\) `'E'` agents and \(a_2\) `'W'` agents (with \(a_1 + a_2 \gt 0\)), our first goal will be to transform all of its `'E'` agents' segments into a disjoint set of segments. For these, if segment \(s_1\) begins in an earlier column than segment \(s_2\) (or also in the same column if \(s_1\)'s agent index is greater than \(s_2\)'s), then \(s_1\) will cover \(s_2\) up to the end of \(s_1\), meaning that \(s_2\) should be trimmed to begin past that column (or removed entirely if it would become empty). Based on this idea, the `'E'` agents can be handled in \(O(a_1 \log(a_1))\) time, involving sorting them by their initial columns. We can repeat much the same process to transform all of the `'W'` agents' segments into a disjoint set of segments.
+
+Our next step will be to combine the `'E'` and `'W'` segments together into a single disjoint set of segments. This can be done in \(O((a_1 + a_2)\log(a_1 + a_2))\) time using a line sweep across the segments' endpoints. For each interval between such endpoints, if it has at most ongoing segment (either `'E'` or a `'W'`), we'll simply keep that segment (trimmed down to that interval). On the other hand, if the interval has both a `'E'` and a `'W'` segment ongoing, we can compute how they interact within that interval, with the `'E'` segment potentially covering some right portion of the `'W'` segment and vice versa (resulting in at most disjoint \(2\) segments for the interval). Note that we'll end up with \(O(a_1 + a_2)\) segments overall.
+
+Finally, all of the above should be repeated for each relevant column, transforming all of the `'S'` and `'N'` agents' segments into a disjoint set of segments. Based on the \(O(N)\) transformed segments, we can then trivially compute a base answer, ignoring interactions of horizontal segments with vertical ones.
+
+What remains is subtracting from the answer based on each cell at which a horizontal segment intersects with a vertical one, with one segment covering the other there. We'll consider each possible pair of directions (`'E'` covered by `'S'`, `'N'` covered by `'W'`, etc.) independently. Through a combination of \(90 \degree\) rotations and axis-aligned flips of the entire grid and its segments, all \(8\) direction pairs can be transformed into just considering `'E'` covered by `'S'`.
+
+We'll perform a line sweep downward through the `'E'` segments' rows and the `'S'` segments top/bottom rows, while maintaining some info about the ongoing `'S'` segments. It's possible to compute a constant "time value" for each `'E'`/`'S'` segment such that, whenever \(2\) segments intersect, the one with the larger time value will cover the other. In particular, a way to compute this time value (properly accounting for row/column offsets and breaking ties based on agent indices) is \(N*(\)(turns previously taken by agent) \(-\) (initial row) \(-\) (initial column)\() + \) (agent index).
+
+We can therefore maintain a 2D segment tree (over the \(O(N)\) coordinate-compressed relevant columns), with each node of the tree storing the set of time values of ongoing `'S'` segments in its interval of columns (most conveniently in an order statistics tree, though a coordinate-compressed Fenwick tree can also work). Whenever a `'S'` segment starts or ends, we'll update the segment tree accordingly, and whenever an `'E'` segment is encountered, we can compute the number of its cells which are covered by querying for the number of time values greater than its own time value present in its interval of columns.
+
+The total time complexity of this solution is \(O(N \log^2(N))\), due to updating and querying the 2D segment tree \(O(N)\) times.

2021/finals/ssssss.cpp

@@ -0,0 +1,113 @@
+#include <algorithm>
+#include <iostream>
+#include <set>
+#include <tuple>
+#include <utility>
+#include <vector>
+using namespace std;
+
+const int LIM = 800008;
+
+int N;
+int A[LIM], B[LIM];
+
+void solve() {
+  vector<tuple<int, bool, int>> E;
+  set<pair<int, int>> S;
+  // Input, while finding tallest grounded ladder.
+  int ng = 0, mg = -1;
+  cin >> N;
+  for (int i = 0; i < N; i++) {
+    cin >> A[i] >> B[i];
+    if (!A[i]) {
+      ng++;
+      if (mg < 0 || B[i] > B[mg]) {
+        mg = i;
+      }
+    } else {
+      E.emplace_back(A[i], 0, i);
+      E.emplace_back(B[i], 1, i);
+    }
+  }
+  // None grounded?
+  if (ng == 0) {
+    cout << "0 0" << endl;
+    return;
+  }
+  // Sort endpoints (including tallest grounded ladder).
+  E.emplace_back(B[mg], 1, mg);
+  sort(E.begin(), E.end());
+
+  // Line sweep.
+  int ans1 = ng, ans2 = 0;
+  int a = mg, b = mg;
+  S.clear();
+  for (auto e : E) {
+    int i = get<2>(e);
+    if (!get<1>(e)) {
+      // Bottom of ladder i.
+      S.emplace(B[i], i);
+      continue;
+    }
+    // Top of ladder i.
+    if (B[a] > B[b]) {
+      swap(a, b);
+    }
+    auto it = S.find(make_pair(B[i], i));
+    if (it != S.end()) {
+      // Ladder i not used yet, so jump from ladder a to it.
+      S.erase(it);
+      ans1++;
+      ans2++;
+      a = i;
+    } else if (i == b) {
+      // Consider ladder i to be ladder a rather than b.
+      swap(a, b);
+    } else if (i != a) {
+      // Ladder i is irrelevant.
+      continue;
+    }
+    // Top of ladder a, so need to jump off of it.
+    if (!S.empty()) {
+      // There are other unused ladders, so jump from ladder a to the one with
+      // lowest top.
+      bool isB = a == b;
+      a = S.begin()->second;
+      S.erase(make_pair(B[a], a));
+      ans1++;
+      ans2++;
+      if (isB) {
+        // This is also ladder b, so repeat for it.
+        if (!S.empty()) {
+          // Jump from ladder b to another unused ladder.
+          b = S.begin()->second;
+          S.erase(make_pair(B[b], b));
+          ans1++;
+          ans2++;
+        } else {
+          // Jump from ladder b to the new ladder a.
+          ans2++;
+          b = a;
+        }
+      }
+    } else if (a != b) {
+      // Jump from ladder a to ladder b.
+      ans2++;
+      a = b;
+    } else {
+      // Nowhere else to go, so stop.
+      break;
+    }
+  }
+  cout << ans1 << " " << ans2 << endl;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": ";
+    solve();
+  }
+  return 0;
+}

2021/finals/ssssss.in

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe48271e0b6976f5bd39e98bcd684756097fcab280e70694910643f0411d0e9b
+size 72370704

2021/finals/ssssss.md

@@ -0,0 +1,62 @@
+The mining company Facebulk Inc. has just rebranded to Metal Platforms Inc. In order to move fast with stable infrastructure, Metal has contracted the serpentine safety inspector, Solid Snake, to inspect \(T\) walls across its mine shafts.
+
+A given wall has \(N\) vertical ladders (numbered from \(1\) to \(N\)) for Solid Snake to inspect. The wall can be represented as a 2D plane, with \(y=0\) being the lowest part of the wall, where it touches the ground. The \(i\)th ladder is positioned at x-coordinate \(i\), with its bottom at y-coordinate \(A_i\) and its top at y-coordinate \(B_i\).
+
+Solid Snake is initially on the ground at coordinates \((0, 0)\) and hopes to inspect as many ladders as possible, ensuring they meet Solid Snake's Strict Serpentine Safety Specifications (SSSSSS), before finally returning to any position on the ground.
+
+For example, the fourth sample case is depicted below:
+
+{{PHOTO_ID:426120359137830|WIDTH:300}}
+
+Solid Snake can perform the following actions:
+
+1. If he's on the ground, he can freely move left and right, and can climb onto any ladder \(i\) which touches the ground at his current x-coordinate (i.e. \(A_i = 0\))
+2. If he's on a ladder \(i\), he can:
+    1. **Inspect** it (if he hasn't already inspected that ladder)
+    2. Freely move up and down on that ladder — in other words, decrease his y-coordinate as low as \(A_i\) or increase it as high as \(B_i\) (while keeping his x-coordinate equal to \(i\))
+    3. Freely move onto the ground if the ladder touches the ground (i.e. \(A_i = 0\))
+    4. **Jump** horizontally to any other ladder \(j\) such that \(A_j \le y \le B_j\), where \(y\) is his current y-coordinate (note that he can jump directly to *any* such ladder, potentially passing by and ignoring other ladders along the way)
+
+Please help Solid Snake determine the maximum number of ladders that he can inspect. Furthermore, determine the minimum number of jumps required for him to inspect that many ladders and then end up back on the ground at the end. Note that Solid Snake is allowed to intermediately return to the ground before he's done with all of his ladder inspections.
+
+
+# Constraints
+
+\(1 \le T \le 80\)
+\(1 \le N \le 800{,}000\)
+\(0 \le A_i < B_i \le 1{,}000{,}000{,}000\)
+
+The sum of \(N\) across all walls is at most \(4{,}000{,}000\).
+
+
+# Input
+
+Input begins with an integer \(T\), the number of mine shaft walls to be inspected. For each wall, there is first a line containing a single integer \(N\). Then, \(N\) lines follow, the \(i\)th of which consists of \(2\) space-separated integers, \(A_i\) and \(B_i\).
+
+
+# Output
+
+For the \(i\)th wall, print a line containing *"Case #i: "* followed by \(2\) space-separated integers, the maximum number of ladders which Solid Snake can inspect and the minimum number of jumps required for him to do so.
+
+
+# Sample Explanation
+
+On the first wall, Solid Snake can move along the ground to each ladder, climb onto it, inspect it, and return to the ground, all without performing any jumps.
+
+{{PHOTO_ID:525571725505702|WIDTH:240}}
+
+On the second wall, Solid Snake cannot climb onto or inspect any ladders.
+
+{{PHOTO_ID:247278897354943|WIDTH:240}}
+
+On the third wall, one possible solution is for Solid Snake to:
+- climb onto (and inspect) the third ladder at coordinates \((3, 0)\),
+- move up to \((3, 10)\),
+- jump to (and inspect) the second ladder at \((2, 10)\),
+- move up to \((2, 15)\),
+- jump to (and inspect) the first ladder at \((1, 15)\), and
+- retrace his path by jumping to the second ladder, jumping to the third ladder, and finally returning to the ground.
+
+Along the way, he will have inspected all \(3\) ladders while performing \(4\) jumps.
+
+{{PHOTO_ID:436214534714219|WIDTH:240}}

2021/finals/ssssss.out

@@ -0,0 +1,105 @@
+Case #1: 3 0
+Case #2: 0 0
+Case #3: 3 4
+Case #4: 3 3
+Case #5: 10 12
+Case #6: 1 0
+Case #7: 5 8
+Case #8: 5 5
+Case #9: 6 8
+Case #10: 6 5
+Case #11: 6 7
+Case #12: 7 8
+Case #13: 11 12
+Case #14: 72 74
+Case #15: 197 196
+Case #16: 500 740
+Case #17: 501 501
+Case #18: 800000 970282
+Case #19: 84752 84831
+Case #20: 800000 1599998
+Case #21: 800000 800001
+Case #22: 0 0
+Case #23: 1 0
+Case #24: 0 0
+Case #25: 1 0
+Case #26: 10 0
+Case #27: 10 0
+Case #28: 1 0
+Case #29: 10 14
+Case #30: 1 0
+Case #31: 10000 14601
+Case #32: 200000 293133
+Case #33: 1 0
+Case #34: 0 0
+Case #35: 0 0
+Case #36: 0 0
+Case #37: 0 0
+Case #38: 10 0
+Case #39: 10 9
+Case #40: 0 0
+Case #41: 0 0
+Case #42: 0 0
+Case #43: 100 0
+Case #44: 100 86
+Case #45: 100 99
+Case #46: 100 100
+Case #47: 0 0
+Case #48: 1000 0
+Case #49: 1000 822
+Case #50: 1000 976
+Case #51: 0 0
+Case #52: 0 0
+Case #53: 10000 0
+Case #54: 10000 8232
+Case #55: 10000 9789
+Case #56: 10000 9978
+Case #57: 0 0
+Case #58: 10 0
+Case #59: 10 0
+Case #60: 10 0
+Case #61: 15 8
+Case #62: 10 0
+Case #63: 1000 1045
+Case #64: 10 0
+Case #65: 1000 1790
+Case #66: 675 666
+Case #67: 10 0
+Case #68: 1000 991
+Case #69: 10 0
+Case #70: 31 0
+Case #71: 31 0
+Case #72: 31 0
+Case #73: 36 8
+Case #74: 31 0
+Case #75: 1000 988
+Case #76: 31 0
+Case #77: 1000 1778
+Case #78: 999 973
+Case #79: 31 0
+Case #80: 1000 970
+Case #81: 31 0
+Case #82: 10 0
+Case #83: 11 2
+Case #84: 10 0
+Case #85: 18710 20988
+Case #86: 10 0
+Case #87: 19999 20033
+Case #88: 28 21
+Case #89: 20000 36516
+Case #90: 20000 19991
+Case #91: 10 0
+Case #92: 20000 19991
+Case #93: 10 0
+Case #94: 141 0
+Case #95: 142 2
+Case #96: 141 0
+Case #97: 15972 17798
+Case #98: 142 2
+Case #99: 20000 19940
+Case #100: 163 26
+Case #101: 20000 36504
+Case #102: 20000 19860
+Case #103: 141 0
+Case #104: 20000 19860
+Case #105: 141 0

2021/finals/ssssss_sol.md

@@ -0,0 +1,19 @@
+If there are no ladders touching the ground, the answer is \(0\). Otherwise, those can all be inspected for free, and only the one with the largest \(B\) value is relevant.
+
+We can perform a line sweep upwards over the ladders' endpoints (including the top of the tallest grounded ladder) while greedily constructing \(2\) "paths" of ladders simultaneously (one for the way up from the ground, and another for the way back down).
+
+We'll maintain the ongoing ladders \(a\) and \(b\) for the \(2\) paths (not necessarily distinct, and both initially equal to the grounded ladder), the set \(U\) of ongoing ladders not yet used in either path (ordered by their \(B\) values, and initially empty), and the number of ladders inspected \(I\) and number of jumps used \(J\). We'll maintain an invariant that \(B_b\) is always greater than or equal to the \(B\) values of all other ongoing ladders not in \(U\) (including \(a\)). For convenience, we'll also assume that \(b\)'s top comes after \(a\)'s top in the line sweep (in case \(a \ne b\) and \(B_a = B_b\)).
+
+When we encounter the bottom of a ladder, we'll simply add it to \(U\).
+
+When we encounter the top of ladder \(i\), if \(i\) is in \(U\), then this is our last chance to visit it. So, we'll jump from ladder a to ladder \(i\) (leaving ladder \(b\) alone), removing \(i\) from \(U\), setting a to equal \(i\), and incrementing \(I\) and \(J\).
+
+Either way, ladder \(i\)'s top being reached is then only relevant if \(i = a\) (and potentially also \(i = b\)), as we must jump to different ladder(s) to continue the path(s). One of the following situations will apply:
+
+  1. If \(U\) is empty and \(i = a = b\), we should terminate the line sweep, as both paths have converged and there are no higher ladders to jump to.
+  
+  2. If \(U\) is empty but \(a \ne b\) (with \(i = a\)), we'll jump from ladder \(a\) to ladder \(b\) (necessary to attempt to continue \(a\)'s path or at least converge with \(b\)'s path), setting \(a\) to equal \(b\) and incrementing \(J\).
+
+  3. Otherwise, if \(U\) is non-empty, we'll jump from ladder \(a\) to the ladder \(j\) in \(U\) with the smallest \(B\) value, removing \(j\) from \(U\), setting \(a\) to equal \(j\), and incrementing \(I\) and \(J\). If \(i = b\), then we'll repeat this process to similarly jump from ladder \(b\) to the ladder in \(U\) with the next-smallest \(B\) value (though if \(U\) has become empty, then we'll instead need to jump from ladder \(b\) to the new ladder \(a\)). We may need to then swap \(a\) and \(b\) to maintain the aforementioned invariant regarding ladder \(b\).
+  
+The time complexity of this algorithm is \(O(N \log(N))\).

2021/finals/table_flipping.cpp

@@ -0,0 +1,430 @@
+#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;
+}

2021/finals/table_flipping.in

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6165ba7ac7b576b2c2eeef3bc6342a5d831a6282bfe0c64934a2f20cfd83bba4
+size 47880833

2021/finals/table_flipping.md

@@ -0,0 +1,48 @@
+Tabitha is tired of tricky Hacker Cup problems, and is hosting a table flipping after-party for the finalists to let out some steam. Her party will be held with finalists distributed across \(T\) rooms.
+
+A given room has \(N\) tables (numbered from \(1\) to \(N\)), with one finalist at each table. Each table \(i\) is represented as an axis-aligned rectangle of positive area on a 2D plane, with bottom-left vertex at \((X_i, Y_i)\), a width of \(W_i\), and a height of \(H_i\). No two tables overlap (intersect with positive area).
+
+Finalists will take turns flipping their tables in one of the \(4\) cardinal directions by reflecting the rectangle across an edge. Table \(i\) must be flipped in direction \(D_i\) (`"U"` if the table is to be flipped over its upper edge, `"D"` for its lower edge, `"L"` for its left edge, or `"R"` for its right edge). Finalists must flip their tables one-by-one, i.e., no two tables may be flipped at the exact same time.
+
+Every finalist knows which direction each table must be flipped, and do not wish to interfere with each other. Tabitha would like to know if there exists some permutation in which the tables can be flipped, such that at no time do any two tables overlap (intersect with positive area).
+
+# Constraints
+
+\(1 \le T \le 70\)
+\(1 \le N \le 300{,}000\)
+\(0 \le X_i, Y_i \le 500{,}000{,}000\)
+\(1 \le W_i, H_i \le 500{,}000{,}000\)
+\(D_i \in \{\)`"U"`, `"D"`, `"L"`, `"R"`\(\}\)
+
+The sum of \(N\) across all test cases is at most \(3{,}000{,}000\).
+
+# Input
+
+Input begins with a single integer \(T\), the number of rooms. For each room, there is first a line containing a single integer \(N\). Then, \(N\) lines follow, the \(i\)th of which contains \(4\) space-separated integers, \(X_i\), \(Y_i\), \(W_i\), and \(H_i\), followed by a space-separated character \(D_i\).
+
+# Output
+
+For the \(i\)th room, print a line containing *"Case #i: "* followed by `"YES"` if there exists a permutation of tables as described above, or `"NO"` otherwise.
+
+# Sample Explanation
+
+In the first room, the two tables (along with their flipping directions) are arranged as follows:
+
+{{PHOTO_ID:616805819746914|WIDTH:420}}
+
+Flipping the left table first would result in it overlapping with the right table. On the other hand, if the right table is flipped first, then the left table can be validly flipped as well, leaving the tables looking as follows:
+
+{{PHOTO_ID:382533823663612|WIDTH:420}}
+
+In the second room, the left table is to be flipped to the right instead. No matter which order the tables are flipped in, they will overlap with one another at some point.
+
+The third room is arranged as follows:
+
+{{PHOTO_ID:462323098803710|WIDTH:420}}
+  
+No matter which order the tables are flipped in, they will touch but not overlap with one another.
+  
+The fourth room is arranged as follows, and has no valid table-flipping order:
+
+{{PHOTO_ID:1268827100291056|WIDTH:320}}
+

2021/finals/table_flipping.out

@@ -0,0 +1,100 @@
+Case #1: YES
+Case #2: NO
+Case #3: YES
+Case #4: NO
+Case #5: YES
+Case #6: NO
+Case #7: YES
+Case #8: NO
+Case #9: NO
+Case #10: NO
+Case #11: YES
+Case #12: NO
+Case #13: NO
+Case #14: NO
+Case #15: NO
+Case #16: YES
+Case #17: NO
+Case #18: NO
+Case #19: YES
+Case #20: NO
+Case #21: NO
+Case #22: NO
+Case #23: NO
+Case #24: NO
+Case #25: NO
+Case #26: NO
+Case #27: NO
+Case #28: YES
+Case #29: YES
+Case #30: YES
+Case #31: YES
+Case #32: NO
+Case #33: NO
+Case #34: NO
+Case #35: NO
+Case #36: NO
+Case #37: YES
+Case #38: NO
+Case #39: NO
+Case #40: YES
+Case #41: YES
+Case #42: YES
+Case #43: YES
+Case #44: YES
+Case #45: YES
+Case #46: YES
+Case #47: YES
+Case #48: YES
+Case #49: YES
+Case #50: YES
+Case #51: YES
+Case #52: YES
+Case #53: YES
+Case #54: YES
+Case #55: YES
+Case #56: YES
+Case #57: YES
+Case #58: YES
+Case #59: NO
+Case #60: NO
+Case #61: NO
+Case #62: NO
+Case #63: NO
+Case #64: NO
+Case #65: YES
+Case #66: YES
+Case #67: YES
+Case #68: NO
+Case #69: NO
+Case #70: NO
+Case #71: NO
+Case #72: NO
+Case #73: NO
+Case #74: NO
+Case #75: NO
+Case #76: NO
+Case #77: NO
+Case #78: YES
+Case #79: YES
+Case #80: NO
+Case #81: NO
+Case #82: NO
+Case #83: NO
+Case #84: NO
+Case #85: NO
+Case #86: NO
+Case #87: NO
+Case #88: NO
+Case #89: NO
+Case #90: NO
+Case #91: NO
+Case #92: NO
+Case #93: NO
+Case #94: NO
+Case #95: NO
+Case #96: NO
+Case #97: NO
+Case #98: NO
+Case #99: NO
+Case #100: NO

2021/finals/table_flipping_sol.md

@@ -0,0 +1,67 @@
+For each table, we know which direction it is going to be flipped over, so we can create two rectangle objects for each table. The rectangle of the starting position will be denoted as \(S\), and the rectangle for the ending position will be denoted as \(E\). We can coordinate compress all the values across these rectangles to make the problem slightly easier.
+
+First, we can check if any of the tables overlap in their ending states. A standard line sweep can be done over all of the \(E\) rectangles in one dimension, with a segment tree of ongoing rectangles maintained over the other dimension. If any overlap is found, the answer for the test case is `"NO"`.
+
+The tables must start in a valid position, and now we know that they also end in a valid position. We must now check if there is an ordering where they stay valid at each step. Let’s create a graph \(G\) with \(N\) nodes, one for each table. Let there be a directed edge from table \(A\) to table \(B\) if flipping over table \(A\) would cause it to intersect with a non-flipped over table \(B\) (\(E\) rectangle from \(A\) intersects with \(S\) rectangle from \(B\)). This means that rectangle \(B\) must be flipped over before rectangle \(A\). If this graph is acyclic then an ordering exists such that the tables never overlap at any step. The ordering would be the reverse of the topological sort based on how edges are defined above. This leads to a simple \(O(N^2)\) solution. Construct the graph above naively by checking every pair of rectangles and adding the edge if it exists, then run a cycle check or topological sorting on the graph. There are \(N\) vertices and \(N^2\) edges so any cycle check or topo sort algorithm will take \(O(V+E) = O(N^2)\).
+
+Due to the properties of the graph, it is actually possible to perform a cycle check on this graph on the order of number of vertices, and not edges. Consider the following interactive problem:
+
+There is a graph \(G\) with \(V\) vertices and \(E\) edges. There are no self-loops or multi-edges. You are not given the graph, only the number of vertices \(V\) (labeled \(1\) to \(V\)). You may perform \(2\) queries on this graph:
+
+Query 1) Remove vertex with label \(X\) from the graph. This will remove all incoming and outgoing edges from this node.
+
+Query 2) Ask for any outgoing edge from vertex \(X\). If vertex \(X\) contains any outgoing edges, this will return the vertex of any of them at random. If vertex \(X\) is already removed or contains no outgoing edges, this will return \(-1\).
+
+Your task is to determine whether the original graph (before removing any vertices) contains a cycle in no more than \(4*V\) queries. 
+
+This can be solved via the following algorithm:
+```
+  void dfs(int n) {
+    seen[n] = true;
+    while (!hasCycle) {
+      int to = query2(n);
+      if (to == -1) break;
+      else if (seen[to]) hasCycle = true;
+      else dfs(to);
+    }
+    query1(n);
+  }
+
+  boolean hasCycle = false;
+  boolean[] seen = new boolean[N];
+  for (int i = 0; i < N; i++) if (!seen[i]) dfs(i);
+```
+
+Query 1 is performed on each node at most once amounting to \(N\) queries. For query 2, if a returned node has previously been visited then a cycle is found and the process ends. Otherwise we visit that node, so query 2 is performed at most once for each time a node is entered, and then potentially once more on each node when no more edges are found. The total amount of queries is at most \(N + N + N + 1\). 
+
+Since this DFS only follows edges of the original graph, it is easy to see that if no cycle exists in the original graph, no false positive will be found. If a cycle exists, this solution will find it. Consider the initial path of nodes the DFS visits right before calling query 1 on any node:
+
+\(A \to B \to C \to D \to E\)
+
+We know each of these nodes are distinct because if there were any duplicates, a cycle would be found. We also know that node \(E\) has no outgoing edges in the original graph since no node has been destroyed yet and query 1 is about to be called (if \(E\) had an outgoing edge to \(A-D\), then this cycle would get found and the process would end). Since node \(E\) has no outgoing edges, we can guarantee that it is not part of any cycle in the graph. Node \(E\) then gets safely removed and now the stack looks like
+
+\(A \to B \to C \to D\)
+
+Now we will take any outgoing edge from \(D\) (if any exist) until we reach another point where a node has no more outgoing edges:
+
+\(A \to B \to C \to D \to F \to G\)
+
+If we do not reach a point where a node has no more outgoing edges, that means a cycle will get reached and be found.
+
+If none of the nodes reachable from \(A\) (including \(A\) itself) are part of a cycle, then this function will eventually remove all of these nodes from the graph and finish without finding a cycle. Then search then starts from another node (if available).
+
+Let’s consider the case where one of the reachable nodes is part of a cycle. Let’s consider the stack right after the first node that is part of a cycle is reached:
+
+\(A \to B \to C \to D\)
+
+Here \(D\) is the first node on the stack that is part of a cycle. It has been shown that nodes are only removed when they are not part of any cycle, and if we call DFS on node \(X\) then eventually all nodes reachable from \(X\) including \(X\) itself will be removed if they are not part of a cycle. This means that we will certainly find and reach any outgoing edges from \(D\) to nodes that also belong to a cycle containing \(D\). This logic continues until we eventually reach a node with an outgoing edge to \(D\) itself. Once we process this edge, we find the cycle and the process ends. 
+
+Now that we’ve shown we can do cycle section on a graph with these two queries, the original problem needs to be translated to this new problem. We can create a data structure to store/remove rectangles and query for some rectangle if there is another rectangle that intersects with it, and return one of them. 
+
+Create a segment tree across the \(X\) values of the rectangles. Each node stores an implicit segment tree across \(Y\) values. When adding a rectangle, for its left \(X\) and right \(X\) boundaries, for all \(\log(N)\) nodes including that \(X\), set the index of the lower \(Y\) to be the value of the upper \(Y\). To support insertion and deletion of multiple rectangles with the same lower \(Y\) without disrupting each other, one approach is to give each rectangle a unique lower \(Y\) "key" rather than compressing them all to exactly the same one.
+
+Add all the \(S\) rectangles to this data structure. Now to check if a node has any outgoing edges, query from left X to right X for the corresponding \(E\) rectangle of that node. For each \(\log(N)\) nodes in this range, query the max from \([0, \) upper \(Y]\) and check if that value is \(\ge\) lower \(Y\). If this is true, then there is some intersecting rectangle and we can return the index of it by storing extra data.
+
+There is one case this will not find: If the intersecting \(S\) rectangle starts at a smaller \(X\) and ends at a larger \(X\) than the \(E\) rectangle we are checking, the \(\log(N)\) nodes in the segment tree will not find this rectangle. If we rotate the problem and also check by having a segment tree across \(Y\) values and implicit segment tree across \(X\), then it will be instead found in the other structure. Since \(E\) rectangles are formed by reflecting across its corresponding \(S\) rectangle, then if there were any case such that an \(E\) rectangle is completely contained inside an \(S\) rectangle (without touching its borders) then there would be an intersection between the two \(S\) rectangles and this would be found during the sweep line.
+
+Each insertion into and deletion from this data structure takes \(O(\log^2(N))\) time, and querying for an intersecting rectangle also takes \(O(\log^2(N))\) time. Since these queries are called \(O(N)\) times in the algorithm described above, the overall runtime of this solution is \(O(N \log^2(N))\).

2021/finals/vacation.cpp

@@ -0,0 +1,115 @@
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <vector>
+#include <utility>
+using namespace std;
+
+const int LIM = 1000001;
+
+int N;
+long long K;
+int C[LIM];
+vector<int> ch[LIM];
+
+// <sum, negative # of paths>
+pair<long long, int> DP[LIM][3];            // [node][# of incoming paths]
+pair<long long, int> DP2[3][2], nxt[3][2];  // [# of ongoing paths][counted node?]
+
+void rec(int i, int p, long long P) {
+  for (auto c : ch[i]) {
+    rec(c, i, P);
+  }
+  memset(DP2, 0, sizeof DP2);
+  DP2[1][1] = make_pair(C[i], 0);
+  memcpy(nxt, DP2, sizeof nxt);
+  for (auto c : ch[i]) {
+    for (int j = 2; j >= 0; j--) {
+      for (int b = 1; b >= 0; b--) {
+        auto d = DP2[j][b];
+        for (int j2 = 0; j2 <= 2; j2++) {
+          auto d2 = DP[c][j2];
+          for (int u = 0; u <= j2; u++) {
+            int r = j2 - u;
+            if (r > j) {
+              continue;
+            }
+            int j3 = j + u - r;
+            if (j3 < 0 || j3 > 2) {
+              continue;
+            }
+            int b2 = b | (j2 ? 1 : 0);
+            long long dv = d.first + d2.first + (!b && b2 ? C[i] : 0) - r * P;
+            int dk = d.second + d2.second - r;
+            nxt[j3][b2] = max(nxt[j3][b2], make_pair(dv, dk));
+          }
+        }
+      }
+    }
+    memcpy(DP2, nxt, sizeof nxt);
+  }
+  for (int j = 0; j <= 2; j++) {
+    for (int j2 = 0; j2 <= j; j2++) {
+      int e = j - j2;
+      for (int b : {0, 1}) {
+        auto d = DP2[j][b];
+        DP[i][j2] = max(DP[i][j2], make_pair(d.first - e * P, d.second - e));
+      }
+    }
+  }
+}
+
+pair<long long, int> solve(long long P) {
+  memset(DP, 0, sizeof DP);
+  rec(0, -1, P);
+  auto d = DP[0][0];
+  return make_pair(d.first + -d.second * P, -d.second - 1);
+}
+
+int solve() {
+  for (int i = 0; i < LIM; i++) {
+    ch[i].clear();
+  }
+  // Input.
+  cin >> N >> K;
+  for (int i = 0; i < N; i++) {
+    cin >> C[i];
+  }
+  for (int i = 1, j; i <= N - 1; i++) {
+    cin >> j;
+    ch[j - 1].push_back(i);
+  }
+  // Binary search for appropriate path penalty.
+  long long r1 = -1, r2 = (long long)N * 1e9 + 1;
+  while (r2 > r1) {
+    long long m = (r1 + r2 + 1) >> 1;
+    auto ans = solve(m);
+    if (ans.first < K) {
+      r2 = m - 1;
+    } else {
+      r1 = m;
+    }
+  }
+  // Compute final answer.
+  int ans = -1;
+  if (r1 >= 0) {
+    pair<long long, int> ans1 = solve(r1), ans2 = solve(r1 + 1);
+    assert(ans2.first < K && K <= ans1.first && ans2.second < ans1.second);
+    long long diffV = ans1.first - ans2.first;
+    int diffK = ans1.second - ans2.second;
+    long long need = K - ans2.first;
+    ans = ans2.second + (need * diffK + diffV - 1) / diffV;
+    assert(ans2.second < ans && ans <= ans1.second);
+  }
+  return ans;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2021/finals/vacation.in

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81ebf295afac73c8c95cf13046266c11072057ac4d463f6af778aa03f9d4bd2c
+size 61315378

2021/finals/vacation.md

@@ -0,0 +1,40 @@
+Melody is planning her Christmas vacation in the Metalverse, an ore-rich VR experience consisting of \(T\) virtual worlds.
+
+A given world has \(N\) cities (numbered from \(1\) to \(N\)) with \(N - 1\) roads running between them. The \(i\)th road allows Melody to drive between cities \(P_i\) and \(i+1\) in either direction (with \(1 \le P_i \le i\)). City \(i\) also contains \(C_i\) ore-naments which Melody can collect as souvenirs while she's there.
+
+Melody's vacation consists of starting in any city of her choice, and then repeatedly performing either of the following actions:
+
+  1. Drive along a road to another city, unless her previous action was to drive *from* that city
+  2. Teleport to any other city
+
+Melody may visit a city multiple times, but may only collect its ore-naments once. She may stop her vacation at any point.
+
+Please help Melody evaluate, for each world, the minimum number of times she must teleport to collect at least K ore-naments, if it's possible at all.
+
+# Constraints
+
+\(1 \le T \le 95\)
+\(2 \le N \le 10^6\)
+\(1 \le K \le 10^{12}\)
+\(0 \le C_i \le 10^9\)
+\(1 \le P_i \le i\)
+
+The sum of \(N\) across all worlds is at most \(5{,}000{,}000\).
+
+# Input
+
+Input begins with an integer \(T\), the number of virtual worlds to be evaluated. For each world, there is first a line containing \(2\) space-separated integers, \(N\) and \(K\). Then, there is a line containing \(N\) space-separated integers, \(C_{1..N}\). Then, there is a line containing \(N-1\) space-separated integers, \(P_{1..(N-1)}\).
+
+# Output
+
+For the \(i\)th world, print a line containing *"Case #i: "* followed a single integer, the minimum number of times Melody must teleport to collect at least \(K\) ore-naments, or \(-1\) if it's impossible to do so.
+
+# Sample Explanation
+
+In the first three worlds, the cities are arranged as follows:
+
+{{PHOTO_ID:2893643357566792|WIDTH:300}}
+
+In the first world, one option is to start in city \(4\), drive to city \(2\), and finally drive to city \(3\). This will yield \(40 + 20 + 30 = 90\) ore-naments.
+
+In the second world, one option is to start in city \(2\), drive to city \(1\), teleport to city \(3\), drive to city \(2\), and finally drive to city \(4\). This will yield \(20 + 10 + 30 + 0 + 40 = 100\) ore-naments.

2021/finals/vacation.out

@@ -0,0 +1,101 @@
+Case #1: 0
+Case #2: 1
+Case #3: -1
+Case #4: 1
+Case #5: 1
+Case #6: 2
+Case #7: 0
+Case #8: 0
+Case #9: 1
+Case #10: 2
+Case #11: 2
+Case #12: 2
+Case #13: 3
+Case #14: 4
+Case #15: -1
+Case #16: 15
+Case #17: 75
+Case #18: 73180
+Case #19: 0
+Case #20: 499
+Case #21: 499999
+Case #22: -1
+Case #23: -1
+Case #24: -1
+Case #25: 0
+Case #26: 0
+Case #27: 0
+Case #28: 0
+Case #29: 0
+Case #30: 0
+Case #31: 0
+Case #32: 0
+Case #33: 0
+Case #34: 0
+Case #35: 0
+Case #36: 0
+Case #37: -1
+Case #38: -1
+Case #39: -1
+Case #40: 51
+Case #41: 12
+Case #42: 0
+Case #43: 0
+Case #44: 0
+Case #45: 0
+Case #46: 0
+Case #47: 0
+Case #48: 0
+Case #49: 0
+Case #50: -1
+Case #51: -1
+Case #52: -1
+Case #53: -1
+Case #54: 51
+Case #55: 12
+Case #56: 0
+Case #57: 0
+Case #58: 0
+Case #59: 0
+Case #60: 0
+Case #61: 0
+Case #62: 0
+Case #63: 51
+Case #64: 11
+Case #65: 0
+Case #66: 0
+Case #67: 0
+Case #68: 0
+Case #69: 439
+Case #70: 60
+Case #71: 0
+Case #72: 27
+Case #73: 4
+Case #74: 0
+Case #75: 0
+Case #76: 0
+Case #77: 0
+Case #78: 5541
+Case #79: 1661
+Case #80: 510
+Case #81: 26
+Case #82: 4
+Case #83: 0
+Case #84: 0
+Case #85: 0
+Case #86: 0
+Case #87: 0
+Case #88: 0
+Case #89: 0
+Case #90: 5571
+Case #91: 1627
+Case #92: 518
+Case #93: 26
+Case #94: 4
+Case #95: 0
+Case #96: 0
+Case #97: 0
+Case #98: 0
+Case #99: 448
+Case #100: 70
+Case #101: 0

2021/finals/vacation_sol.md

@@ -0,0 +1,16 @@
+Note that the network of cities and roads form a tree (which we consider to be rooted at node \(1\)), and that a vacation using \(t\) teleports is equivalent to a set of \(t+1\) simple paths on the tree, with ore-naments collected from all nodes present in at least one path.
+
+We'll begin by considering a different variation of this problem, in which each path used incurs some constant penalty of \(P\) ore-naments (such that, if \(o\) ore-naments are collected using \(p\) paths, the final ore-nament count \(x\) will be \(o - p * P\)). In this variation, let's maximize \(x\), breaking ties by minimizing \(p\).
+
+This variation is solvable using DP, letting \(DP_{i,j}\) be the optimal pair of \((x, p)\) for node \(i\)'s subtree, such that \(j\) paths are ongoing between node \(i\) and its parent (with those \(j\) paths not included in \(x\) and \(p\)). The overall answer will then be \(DP_{1,0}\). We can observe that values of \(j\) up to \(2\) are relevant (as there must be an optimal set of paths such that no tree edge is part of \(3\) or more paths). This means there are only \(O(N)\) states, which are all possible to evaluate in linear time. A key aspect of the implementation is only counting each path and its penalty once, for example only at its topmost node (when it doesn't continue from node \(i\) up to its parent, due to either ending there or feeding into two of \(i\)'s children).
+
+To now solve the original problem, we can employ a technique which goes by various names, including "parameter search" or the "Aliens optimization" — its workings and requirements are described in greater detail [here](http://www.serbanology.com/article/The%20Trick%20From%20Aliens).
+
+In short, we'll binary search for the largest per-path penalty \(P\) (between \(0\) and \(\sum_{i=1}^N C_i)\)) which results in an ore-nament count of \(o\) (excluding subtraction from path penalties) of at least \(K\). Note that \(o = x + p * P\). We can do so because:
+
+  - As \(P\) increases, the path count \(p\) and corresponding ore-nament count \(o\) decrease or stays equal
+  - If we define a function \(F(p)\) as the maximum ore-nament count \(o\) for a given path count \(p\), \(F(p)\) is concave (the more paths are used, the more diminished are their returns)
+
+Let \(o_1\) and \(p_1\) be the optimal ore-nament and path counts for the penalty \(P\) produced by the binary search, and \(o_2\) and \(p_2\) be the corresponding counts for penalty \(P+1\). Note that \(o_2 \lt K \le o_1\) and \(p_2 \lt p_1\). The minimum number of paths required to collect \(K\) ore-naments is then somewhere in the interval \((p_2, p_1]\). In particular, we can linearly interpolate between \((o_1, p_1)\) and \((o_2, p_2)\) to compute our final answer as \(p_2 + \lceil(K - o_2)(p_1 - p_2) / (o_1 - o_2)\rceil + 1\).
+
+The time complexity of this solution is \(O(N * \log(\sum_{i=1}^N C_i))\).

2021/quals/consistency_ch1.cpp

@@ -0,0 +1,35 @@
+#include <algorithm>
+#include <iostream>
+using namespace std;
+
+const int INF = 1e6;
+
+bool is_vowel(char c) {
+  return c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U';
+}
+
+string S;
+
+int solve() {
+  cin >> S;
+  int ans = INF;
+  for (char c1 = 'A'; c1 <= 'Z'; c1++) {
+    int curr = 0;
+    for (char c2 : S) {
+      if (c1 != c2) {
+        curr += is_vowel(c1) == is_vowel(c2) ? 2 : 1;
+      }
+    }
+    ans = min(ans, curr);
+  }
+  return ans;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2021/quals/consistency_ch1.in

@@ -0,0 +1,54 @@
+53
+ABC
+F
+BANANA
+FBHC
+FOXEN
+CONSISTENCY
+HAAACKEEERCUUUP
+OOEUEUIUUOOAUEIOIEEUIAIUAUOOAUUIIEUUOAAIOAEAUEIAOAOOAOOAAIEOAEOEIOIAAEAAIOEEOIIIEEIOIUEIEEEAAEEEEOAA
+QPQWJXRJJXBTKKGBKVXNSCQBHZTSFZRYCDZFYQJQWHWHYJVDRXSGWRLJNTHBXYBRBTVXBBPPCXRBFVXVNDQQTHHBKXZDPQZGSHWF
+EDHHDGFGCFHBHCAFGHHCBDHHECAEGGAGAGDGEGGFDGBCDFDCBHFGBDBCGHEACCGFAGEFBFGECFGFCGGBEDGDBFCEHEDHEHHFGCEB
+AAAAAAAAAAEEEEEEEEEEIIIIIIIIIIOOOOOOOOOOUUUUUUUUUUBBBBBBBBBBBCCCCDDDDFFFFGGGGHHHHJJJJKKKKLLLLMMMMNNN
+AAAAAEEEEEIIIIIOOOOOOUUUUUXYZ
+IOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOIWOWIOI
+OEOUAEOUAUAEIEIIIAIOOUAUIAEEUUIAIAIOUIIAUUIIUAUUEAOAOAEEUEUOUAOAIOUUEEIEAUOAIOEEOUIOAUOEOIAEO
+EJZITADGAAAKTEIQVEWLLIIZXWLKSEAIUUUIERFKEUOXONORJRXGKGLIUIUBNXINNJHHAEAACBEQWXZ
+OIOUAUOAIEUOEUIUIIUAAAAUOEIEUAIEEOIAOEUEAOOEAIIEEAEIUIOAUIIOEEUEAOEOOAAIAUAO
+OWAMBXIRMUNOIXEUJILQLAPGLHQSFXUNAJLIERKUQEGCIYNHHEEYFHOFIAMH
+ZVOIAGIMOLAHOAIAJEIUBHLNDDFIHGZHCIUWRMGIHIUOPICDOURTUVAOO
+IOAOIAAOAEOIEIEAIIEAOUEIEIOOIEIEOIEIOEOUUOEUEOAOEIOOUUUIIOAEIAIEIOIEUOIUUEIEAEIAAIEOE
+HLVTMEAUMYEDMFIMUMEEBEUKEAITNWOIIOSGTIAUPBUINUQGYOAAAETCJGOEMWQEAOPUTTDAAQEESKISO
+AIIOEAAAUEUUOEOOUAIIIIOEEIEAAAAUAIAEUUOUEUOAUAOIUAOUAAIUIIIE
+EMLEKLIXUPNUEAUEAXUCKHPUEJBUIAKJTKCYIGITCIAUPIQAZUO
+RGQQRTUSHOIUEJBEYZSHIIRDASATUUPUBKTHHUZNTPNLOILOOQYU
+SYMPHXFDDRQRPMZTJBVFYWMPLGBRBPRYMTTBDBNTMTJFYJ
+AOEEUOAOOUEUUUUEEOAOIOOAAEIEAIEUOIAOOAIOUAAUIUEUIOIUUEEOOAEOIEUIUOOOIEIUEIAEEIIEIEEEEAUIOEIIUE
+UVZVEOMIJOOAWGLCIEIAUBSQPRM
+UUKWEQAESOAANZPGYMYEDHQEQZWUPZRZIHIIYEUEICKALGANOHKMIEXMXCUAXXYLODOZKEOUGDFKCNI
+OOKMHREFNKYAYIIGKZTIQBUUAEOIOUAKXFIYTGLBZAEEGIEBZEUVUW
+OAAOOEUIEOIEAOIOEOAOEIUAEOAAAEAUEOUIAEEOAUOEIEOAOOAAUAUAOAIUAIIAOAAOAOUOEAEAIUUUUIOAOO
+AYOOZMUIADIDNXXHTMDEFFDDJIMPJANSTOAUHSAIGAFXJHTAABWUZBURBOVJEDZICDOBEAXIJADNLMSKHAOAFEJPHWIAHC
+KDIYULAIEGHARWVOIKBAUTEINPMEBAPRETFOUL
+OBHMEAIJAJEROOFEHOHEYEVGHHOOUTIPAETOEAQOJVICAUNLWNUL
+GLZIAUAIULAYREOPAALTETAGFHAAURKILIEAAZAOOLJNBZKKICUIZOQUOEUKKIDUBUTQOUVRAUWNYIQAPASQA
+PTCJRYMLRWZVMZZPBKPNSDMFTCFKLCZXLPQLNQCLDXQVQZMYHBXPLQMXMHJQFKLHNXTKCRZMRKBWDTBBPYFTMLBQZMVVRBTXBCM
+OKMEOEQIUSFATUOTONBRYEEUUUDGEITUGRARKUIUGOJIAOEGUKJOPIAYZBGKOEFOFHOXIJTCEOOEMSSOFCEXIUYOF
+ALECOEAGWFOIEERMFTABOYKUCIXJRZMV
+OEOQUIAFDWEXDKOSAFVUMBBYVEUUWDETZUGNHWJEIWAIHITNAMFLYPIGJOLAOCPFOTOEHVEARVPXCSTITMHA
+OXEOURJOEUEJUUTUEIEQORXSBGLUIIARAVUBPUICEIJAIILEQDBIIQONE
+UFOVKZEOUTPUJSWEITEUAIYDRIBGUIUIOEII
+XHWYBOALEKWBXNTCUJUZUMPMXULCJQUELATALEPLSAGAWOVOULNCOFYIUZGORZGAHIVAQTFJLUEHAREICHTTJCBNIEEXXPIIA
+IPQALOOEQAWOTODUOFNIAZGQPUTHFFSAEZWOOGYEVQSHRIKCALEUSDAVBUFKIACUSIAKSBLU
+LNJYCVQZUUIKAFAIJSVMZPT
+IEOFAAANDPZTKXEOBULZIEL
+GJNZWNDWKKNPLRRBSSDNHXFZ
+KTNIUDNSSOOFAMLGAXJGKXOEBHGEOGQQELSAAEZAGKEFEYYRLETFAEBOAHASLIZUUEAGCP
+GMJAIDRIBTPAOJATREMCOOVXODUIHEUBSAGF
+MYNTULUYAUBJWTUHTUUOWEOUUIQPGPKFPEAUUAOOARIVSDIQEIMCUIQUQDAUAIIENPILCBGIOCVNUR
+OOOYSRHWNQELBPPMEPOMAZUEZWZAUBAOHNEEYXACMAKUUHUEAULHHBILUHWIONXKNFEAIAZOEUXIZOKJBUONPQAXPEOIRCX
+LEAEJOUUJOHCANBFJVIEEAZAEBUEWFXDECKUN
+AOWESABWHAIARBELWCPEMRJSIE
+AHKELEGPWUNIMUEIUAFOEMAJVFNAEGDOIPASOCLZGPBEAZECGJUUOKHFZSIICWUGRGEAAIZANQIEFVNANAITXIOVDVAEOE
+EASAYUEOXQXEAKAFIUOEAALAUIIUUGPA
+FBBNOBTGQYATFOVKWIHAHOXQRNOAAIEUUUIKGFQMGEWYYINOIIEQNQHOQKOOLIXIAKOFEURNOZUKAGAVQAYNQ

2021/quals/consistency_ch1.md

@@ -0,0 +1,33 @@
+**Note: This problem shares similarities with [Chapter 2](https://www.facebook.com/codingcompetitions/hacker-cup/2021/qualification-round/problems/A2). The solution to either chapter may help with solving the other, so please consider reading both first.**
+
+Connie received a string \(S\) for her birthday, consisting entirely of uppercase letters (each between `"A"` and `"Z"`, inclusive).
+
+However, Connie really only likes nice, *consistent* strings. She considers a string to be consistent if and only if all of its letters are the same.
+
+Each second, Connie may choose one letter in \(S\) and replace it with a different letter. **If her chosen letter is a vowel, then she may replace it with any consonant of her choice. On the other hand, if her chosen letter is a consonant, then she may replace it with any vowel of her choice.** The \(5\) letters `"A"`, `"E"`, `"I"`, `"O"`, and `"U"` are considered vowels, while the remaining \(21\) letters of the alphabet are considered consonants. If a letter appears multiple times in \(S\), she may only replace a single occurrence per second.
+
+Help her determine the minimum number of seconds required to change \(S\) into any consistent string. Note that \(S\) might already be consistent, in which case \(0\) seconds would be required.
+
+# Constraints
+
+\(1 \le T \le 45\)
+\(1 \le |S| \le 100\)
+`"A"` \(\le S_i \le\) `"Z"`
+
+The sum of \(|S|\) across all test cases is at most \(4{,}500\).
+
+# Input
+
+Input begins with an integer \(T\), the number of birthdays Connie has had. For each birthday, there is a single line containing the string \(S\).
+
+# Output
+
+For the \(i\)th string, print a line containing *"Case #i: "* followed by the minimum number of seconds required to change \(S\) into any consistent string.
+
+# Sample Explanation
+
+In the first case, Connie could replace the second and third letters (`"B"` and `"C"`) each with `"A"`, yielding the string `"AAA"` in \(2\) seconds.
+
+In the second case, `"F"` is already consistent.
+
+In the third case, Connie could replace the first, third, and fifth letters (`"B"`, `"N"`, and `"N"`) each with `"A"`, yielding the string `"AAAAAA"` in \(3\) seconds.

2021/quals/consistency_ch1.out

@@ -0,0 +1,53 @@
+Case #1: 2
+Case #2: 0
+Case #3: 3
+Case #4: 4
+Case #5: 5
+Case #6: 12
+Case #7: 17
+Case #8: 100
+Case #9: 100
+Case #10: 94
+Case #11: 128
+Case #12: 30
+Case #13: 67
+Case #14: 93
+Case #15: 95
+Case #16: 76
+Case #17: 70
+Case #18: 66
+Case #19: 85
+Case #20: 99
+Case #21: 60
+Case #22: 60
+Case #23: 57
+Case #24: 46
+Case #25: 94
+Case #26: 33
+Case #27: 94
+Case #28: 67
+Case #29: 86
+Case #30: 102
+Case #31: 47
+Case #32: 62
+Case #33: 98
+Case #34: 99
+Case #35: 106
+Case #36: 37
+Case #37: 102
+Case #38: 72
+Case #39: 43
+Case #40: 114
+Case #41: 86
+Case #42: 25
+Case #43: 28
+Case #44: 24
+Case #45: 80
+Case #46: 43
+Case #47: 88
+Case #48: 117
+Case #49: 41
+Case #50: 29
+Case #51: 114
+Case #52: 38
+Case #53: 100

2021/quals/consistency_ch1_sol.md

@@ -0,0 +1,5 @@
+There are only \(26\) possible consistent strings which \(S\) might be changed into, with all characters in \(S\) ending up equal to some character \(x\) (`"A"` \(\le x \le\) `"Z"`). We'll consider each possible value of \(x\) and compute the total number of seconds required to change all characters in \(S\) into \(x\), with the minimum of those \(26\) possible totals being our final answer.
+
+For each character \(x\), we'll need to consider each character \(c\) in \(S\) and compute the number of seconds required to change \(c\) into \(x\). If \(c = x\), then \(0\) seconds are required. If \(c\) is a vowel while \(x\) is a consonant (or vice versa), then \(1\) second is required. Otherwise (that is, \(c\) and \(x\) differ but are either both vowels or both consonants), \(2\) seconds are required.
+
+[See David Harmeyer's solution video here](https://youtu.be/p5yPTHNUTlc).

2021/quals/consistency_ch2.cpp

@@ -0,0 +1,48 @@
+#include <algorithm>
+#include <iostream>
+using namespace std;
+
+const int INF = 1e6;
+
+string S;
+int K;
+int dist[26][26];
+
+int solve() {
+  for (int i = 0; i < 26; i++) {
+    for (int j = 0; j < 26; j++) {
+      dist[i][j] = (i == j) ? 0 : INF;
+    }
+  }
+  cin >> S >> K;
+  for (int i = 0; i < K; i++) {
+    char a, b;
+    cin >> a >> b;
+    dist[a - 'A'][b - 'A'] = 1;
+  }
+  for (int k = 0; k < 26; k++) {
+    for (int i = 0; i < 26; i++) {
+      for (int j = 0; j < 26; j++) {
+        dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
+      }
+    }
+  }
+  int ans = INF;
+  for (int i = 0; i < 26; i++) {
+    int curr = 0;
+    for (char c : S) {
+      curr += dist[c - 'A'][i];
+    }
+    ans = min(ans, curr);
+  }
+  return ans == INF ? -1 : ans;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2021/quals/consistency_ch2.in

@@ -0,0 +1,7292 @@
+51
+ABC
+2
+BA
+CA
+ABC
+2
+AB
+AC
+F
+0
+BANANA
+4
+AB
+AN
+BA
+NA
+FBHC
+4
+FB
+BF
+HC
+CH
+FOXEN
+8
+NI
+OE
+NX
+EW
+OI
+FE
+FN
+XW
+CONSISTENCY
+26
+AB
+BC
+CD
+DE
+EF
+FG
+GH
+HI
+IJ
+JK
+KL
+LM
+MN
+NO
+OP
+PQ
+QR
+RS
+ST
+TU
+UV
+VW
+WX
+XY
+YZ
+ZA
+ABC
+9
+AB
+BX
+BZ
+CY
+IJ
+JK
+KC
+XI
+YZ
+KJJQTQEURABTEDFLTDPQTQLULKXAVSMDHZBQWUNNRUSZQLXNXT
+50
+PF
+VM
+MW
+FG
+QP
+WD
+XV
+QF
+YG
+MG
+DJ
+VB
+ZY
+VN
+UK
+SL
+NI
+LG
+GQ
+PU
+KX
+XD
+UR
+NY
+JL
+XK
+XF
+OV
+DV
+KJ
+HF
+AM
+CG
+GF
+XM
+RY
+DY
+MR
+FR
+MS
+RN
+UD
+JT
+XP
+YF
+BP
+RQ
+TV
+EA
+BM
+CTIRHZXUMSTXXFUGBFFCKODOCDVJXDNJPWSILUQPKLWOEXLKRSDUYLTENZIZXMAVSHVTJXTRIHZOFKDBPWTZLEIOXKCIQCIDHEKL
+300
+HJ
+YF
+WS
+KQ
+SV
+EV
+YV
+MC
+CF
+IV
+YS
+LK
+LF
+RC
+SC
+WY
+JO
+SM
+US
+CE
+QY
+SE
+UY
+GQ
+RQ
+SF
+RH
+LP
+QH
+CU
+TR
+CH
+DV
+OS
+TV
+BI
+WB
+DM
+RB
+MO
+DE
+OT
+UT
+DY
+VC
+MN
+WF
+WV
+XR
+HI
+NE
+VB
+GV
+PW
+FG
+NY
+KR
+UH
+KJ
+FR
+MG
+ME
+VL
+IO
+EJ
+BK
+NI
+WR
+GP
+WM
+MS
+NP
+BE
+BT
+CP
+HF
+XQ
+EI
+NR
+FY
+WD
+YD
+KB
+KN
+XJ
+FJ
+QS
+LJ
+JV
+OW
+TY
+UE
+MJ
+GL
+NB
+WL
+HK
+OG
+CJ
+KL
+AB
+KT
+XH
+EX
+DH
+HE
+KO
+KU
+EU
+PB
+MA
+PD
+XU
+AT
+XK
+FH
+ST
+TG
+XA
+YR
+WC
+CO
+OQ
+QC
+JU
+AE
+HR
+VS
+BX
+EK
+OU
+VW
+SD
+DR
+UG
+MB
+LE
+TK
+KE
+PY
+LU
+YK
+HP
+XG
+LX
+AR
+CV
+GI
+OI
+PK
+GN
+EO
+BS
+FU
+XO
+OL
+AW
+OH
+RO
+QB
+GO
+YQ
+VJ
+WE
+IX
+TS
+DI
+FQ
+UA
+RT
+IF
+QE
+OE
+JM
+SW
+CS
+XM
+BU
+AU
+SB
+MR
+FC
+TO
+SP
+YJ
+QM
+MK
+CI
+HT
+IJ
+RY
+XP
+HM
+BC
+RP
+DA
+BA
+YE
+WN
+GD
+SO
+PM
+NL
+HS
+PE
+LD
+XE
+QN
+MT
+BL
+PV
+KX
+CK
+JS
+QR
+CM
+PH
+FE
+HU
+UP
+SN
+QI
+RF
+ED
+TP
+AO
+UW
+XL
+DS
+BV
+MX
+JH
+DG
+EY
+FL
+HL
+EF
+WQ
+XI
+UB
+EP
+CY
+SX
+BP
+WX
+QD
+FO
+LR
+HY
+LA
+VR
+FX
+AQ
+BY
+LM
+TE
+FW
+OD
+SY
+CA
+RE
+KF
+VX
+OP
+NV
+WU
+EQ
+HC
+WG
+KC
+KG
+WH
+SQ
+GK
+VQ
+FV
+BJ
+JN
+EN
+KA
+VD
+TA
+EL
+LN
+PG
+OV
+UO
+XV
+OJ
+WA
+KP
+DN
+QP
+QK
+YT
+GE
+DT
+YN
+KW
+JE
+UETNRSJASUXUTTLLGAJVQXKWSJBLTPCFMFIIPTUEYYNUVUETUKKIQMWCHJADPRAUPKWNSUCJHVBSBXMHUGNUHYNVHAIMAOIGZCUO
+300
+GM
+LX
+CE
+FN
+CM
+EQ
+HU
+XZ
+KS
+RV
+CX
+CJ
+CZ
+CL
+CG
+BE
+OS
+FI
+FS
+IT
+FU
+LQ
+GV
+AV
+MP
+CD
+KV
+HS
+BM
+IY
+AB
+NV
+AD
+KY
+VX
+AR
+GQ
+HI
+LS
+GJ
+FY
+OQ
+DO
+JS
+MX
+MV
+JU
+AZ
+AS
+PR
+DT
+JM
+EI
+CH
+IM
+QU
+GZ
+RZ
+GR
+SY
+LZ
+JN
+DU
+UX
+AU
+DN
+EH
+BC
+RU
+CT
+FJ
+QY
+IK
+DJ
+QS
+KW
+NW
+RW
+KT
+JT
+GS
+GO
+AO
+NT
+WX
+HX
+QR
+SU
+HY
+MU
+KX
+NP
+JZ
+DZ
+LP
+NY
+VY
+ER
+PQ
+PS
+TW
+EX
+NS
+FO
+JK
+KQ
+FH
+DW
+HK
+HJ
+MS
+XY
+GI
+TZ
+TX
+BV
+LW
+IW
+JO
+ST
+IS
+GU
+GH
+EP
+AJ
+MN
+EV
+BL
+TY
+CP
+UY
+OZ
+EM
+JR
+BO
+ET
+EG
+MY
+AM
+DQ
+BF
+FG
+LY
+AQ
+FX
+CY
+OP
+GW
+JQ
+CI
+CF
+QT
+AG
+KN
+GP
+IV
+SZ
+HM
+AX
+FR
+FM
+HL
+DH
+CN
+HN
+RY
+WY
+OY
+OX
+IN
+EU
+RX
+BW
+NQ
+CQ
+DX
+MW
+UV
+PU
+QV
+AC
+AF
+IU
+EO
+HW
+DY
+MO
+WZ
+CK
+HR
+EK
+IX
+KU
+LR
+DI
+BY
+CR
+KR
+BZ
+BK
+YZ
+BR
+EY
+DF
+EN
+AW
+SV
+EF
+FT
+HZ
+DK
+CU
+PZ
+HO
+IP
+BS
+AN
+ES
+EZ
+HP
+CS
+IR
+VZ
+VW
+AH
+GY
+LN
+FW
+AI
+RT
+FK
+HV
+CO
+MQ
+LM
+NX
+UZ
+JV
+EL
+MZ
+FP
+EW
+KZ
+HQ
+DR
+NU
+BN
+BD
+JY
+IZ
+JX
+SW
+KL
+PT
+BP
+GN
+GL
+TV
+PW
+GX
+BX
+AE
+QX
+IQ
+KO
+IJ
+NZ
+NO
+OT
+DG
+LT
+LU
+OW
+CW
+FQ
+JW
+GK
+DL
+JP
+AP
+NR
+MT
+DE
+OR
+SX
+MR
+RS
+DS
+OU
+EJ
+PX
+UW
+BT
+IO
+FV
+TU
+PY
+BG
+CV
+LO
+UXATTHDNUSYAKHRQFPXSYGLNNHSBIELBBTRLWYLMQGFTOOBSQPQOGQGMNZVHDUEEAJNBFXWHJVOZEBEJTZADPGCDINUJTVUISZJQ
+300
+DL
+DY
+AK
+GI
+CU
+NR
+BZ
+IO
+BL
+DJ
+GU
+PS
+LZ
+OP
+MX
+JN
+EV
+DS
+FM
+FT
+DP
+IQ
+PY
+JL
+CK
+DN
+BY
+KO
+EO
+QZ
+KT
+MR
+KS
+TW
+ET
+JS
+BM
+AY
+JP
+LO
+CZ
+KL
+AU
+DU
+NU
+DW
+BF
+OV
+KP
+CI
+AJ
+JQ
+SX
+DK
+UW
+LM
+IK
+IZ
+GJ
+YZ
+EQ
+HK
+KR
+QR
+EN
+TZ
+PQ
+MV
+HZ
+RS
+NT
+FQ
+FJ
+DM
+CQ
+PT
+BC
+DT
+HP
+VZ
+FL
+AG
+AR
+CP
+TV
+NX
+LR
+FK
+JU
+AH
+EI
+GN
+AS
+GK
+VY
+FP
+GP
+MQ
+SY
+QX
+KX
+EZ
+DZ
+OR
+AT
+FH
+AD
+GR
+JY
+HQ
+BE
+FO
+HW
+EW
+OY
+LY
+SW
+EY
+HS
+MY
+GS
+IN
+FS
+CY
+RY
+OU
+GW
+TU
+AQ
+BO
+ST
+BR
+CL
+CT
+IR
+EH
+HL
+SV
+AI
+SZ
+ES
+HU
+MW
+EJ
+AX
+GQ
+RW
+PW
+WZ
+VX
+DQ
+FX
+NY
+AW
+KM
+OT
+FY
+GO
+SU
+CG
+JT
+IW
+AE
+RZ
+HN
+NV
+FU
+DI
+BW
+MP
+HJ
+BK
+RX
+WX
+OS
+PX
+LS
+BG
+LT
+RV
+EK
+CW
+TX
+JR
+GX
+GY
+KU
+GL
+CX
+CM
+LN
+MT
+CR
+HM
+CH
+UV
+MS
+BH
+HO
+RT
+DE
+DV
+AB
+WY
+NP
+KY
+HT
+BU
+RU
+QS
+GT
+LP
+BI
+JV
+AO
+XZ
+AP
+IJ
+AZ
+IM
+IT
+BT
+JW
+EF
+MZ
+BQ
+DR
+LX
+CS
+NQ
+HX
+PV
+HV
+GZ
+BN
+EM
+PU
+DG
+HR
+CV
+NO
+IV
+JO
+MO
+MU
+CO
+MN
+DO
+FZ
+PZ
+JX
+FN
+GH
+EL
+KN
+JZ
+JM
+EP
+AN
+CE
+OX
+QT
+EU
+LQ
+CF
+IU
+CD
+LV
+NS
+NW
+XY
+KZ
+PR
+IY
+IS
+LU
+BP
+HY
+KQ
+IL
+FW
+AL
+UX
+DH
+QW
+BV
+LW
+BX
+IX
+CN
+EG
+DX
+GV
+VW
+AM
+FI
+FV
+IP
+OQ
+GM
+KWHOFYWRATTBFMFQKHRAYNZTSQYFEXNYZCSMCBOMALUVXAIBAXFFWSRPTBGIXJIEXKBFKLSAGHZJVFIHGETPUSVLIBXXDOYWRWPG
+300
+WQ
+MK
+QD
+HR
+OK
+XI
+GC
+BC
+XT
+YN
+IB
+TW
+FQ
+HD
+MY
+XM
+EG
+QM
+US
+HJ
+PK
+FD
+MU
+YC
+WH
+LO
+TG
+TC
+AO
+AR
+WU
+CE
+AH
+CB
+AC
+XG
+NT
+AB
+GM
+NF
+SY
+BH
+XD
+XH
+FU
+VT
+VW
+WB
+AI
+GT
+ER
+EC
+GQ
+MJ
+HC
+KM
+QU
+HN
+QS
+WS
+QP
+YH
+TH
+NU
+UQ
+WL
+CP
+WG
+RB
+BF
+CX
+JG
+IY
+SH
+DX
+NI
+CR
+DY
+EO
+NB
+QE
+CI
+JR
+MP
+GL
+BW
+JT
+GP
+SK
+GK
+EN
+JY
+FI
+IJ
+OT
+HM
+FP
+FE
+FW
+NQ
+CQ
+QL
+AW
+VC
+UR
+KW
+IC
+GS
+TN
+PV
+LE
+PJ
+TK
+UV
+OS
+IH
+EY
+AP
+QV
+OL
+SQ
+QC
+QW
+OB
+OX
+DG
+LM
+WI
+VD
+JQ
+YX
+SA
+OH
+IM
+TD
+XF
+NJ
+JP
+QJ
+AY
+XQ
+RP
+MA
+WV
+PM
+JN
+DV
+LX
+LR
+KV
+UH
+XN
+YP
+WC
+YG
+SG
+BD
+VM
+VY
+EQ
+KE
+WY
+BU
+VI
+YO
+RO
+HO
+MV
+SL
+UW
+OM
+YM
+OR
+YQ
+DJ
+VF
+JU
+VU
+RC
+KH
+DH
+KS
+YF
+RQ
+OC
+NY
+JL
+YB
+KU
+RK
+TM
+PD
+VH
+GF
+PU
+HP
+MD
+LD
+JC
+JX
+DA
+JK
+BK
+GV
+CO
+XO
+TU
+WA
+EJ
+VN
+SB
+NC
+FL
+DP
+GE
+ED
+HQ
+XW
+PN
+TX
+CD
+BL
+VK
+MQ
+CU
+EA
+NL
+BY
+PE
+TL
+UO
+NX
+NM
+VX
+YU
+MC
+LW
+FM
+OU
+HB
+YT
+QB
+NE
+JO
+CM
+AE
+SC
+UK
+TP
+CJ
+DI
+MG
+HL
+KP
+GH
+QA
+CG
+XR
+GD
+JB
+CW
+TO
+YA
+KJ
+WJ
+PS
+ET
+KR
+OV
+JS
+RE
+BQ
+KY
+FA
+GW
+UT
+IA
+DU
+AF
+QN
+IT
+ON
+FG
+AL
+PW
+SE
+EX
+JI
+MX
+SF
+VA
+PQ
+NG
+KX
+XL
+LJ
+UM
+FX
+YV
+VE
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ
+25
+AB
+BC
+CD
+DE
+EF
+FG
+GH
+HI
+IJ
+JK
+KL
+LM
+MN
+NO
+OP
+PQ
+QR
+RS
+ST
+TU
+UV
+VW
+WX
+XY
+YZ
+QRDFWDOMXARXHNHTCYAEDCQKSPKJIKVADIATJRYFQFMAXOVO
+230
+KZ
+LQ
+JQ
+HT
+RS
+IV
+LT
+GH
+CK
+PT
+IP
+CO
+BO
+GZ
+JV
+SW
+LS
+GQ
+EH
+QY
+FS
+NQ
+FP
+CR
+HO
+DR
+AN
+IQ
+FU
+GL
+DN
+RZ
+KT
+EO
+NO
+AE
+RT
+CM
+CU
+FK
+KV
+JN
+OR
+CG
+DL
+ES
+GU
+CH
+PS
+KU
+DU
+IW
+NZ
+SU
+KW
+BF
+DS
+IX
+EJ
+XZ
+CQ
+CS
+SY
+TW
+JL
+BK
+BL
+IM
+HL
+JT
+EG
+MU
+AF
+MZ
+CP
+NX
+JK
+TV
+RY
+JS
+ER
+GO
+LW
+KL
+HX
+BC
+FV
+KN
+VW
+AG
+CI
+KS
+CL
+FR
+DI
+PQ
+DG
+LO
+QR
+AB
+BJ
+FT
+NS
+DY
+DH
+UX
+KR
+AS
+HM
+DE
+IO
+RW
+FM
+GS
+AZ
+PY
+DZ
+UY
+OV
+IR
+YZ
+OY
+MN
+EF
+MQ
+HV
+CJ
+NV
+HZ
+GT
+LZ
+GW
+IT
+BV
+LY
+OW
+GP
+BR
+AT
+FW
+HN
+AH
+BT
+KQ
+BY
+FI
+QX
+IZ
+FJ
+IN
+AI
+UZ
+HS
+CZ
+MW
+ST
+EN
+LP
+LU
+OU
+TZ
+GK
+RX
+BP
+HK
+DX
+OX
+EY
+GR
+CX
+EK
+IY
+DQ
+FG
+QV
+AD
+MR
+QZ
+NR
+GI
+TX
+GV
+AQ
+RV
+AW
+BX
+AJ
+SV
+CD
+AK
+GJ
+NW
+JZ
+QU
+VX
+BU
+BM
+GX
+HP
+MP
+LV
+EL
+FO
+DV
+HJ
+BG
+KX
+EZ
+AY
+BW
+AR
+AC
+JU
+OP
+FH
+EM
+ET
+XY
+UW
+HY
+DF
+JO
+OQ
+AU
+JY
+MO
+SX
+HQ
+AM
+BZ
+BDKCZAWSSOBNYFYKMILGTPZFTGVUQXDSMZRTJIRLKTQRTBR
+244
+DP
+KS
+SW
+IW
+EU
+OW
+DN
+IJ
+CF
+FY
+IM
+BK
+IX
+EP
+WY
+RV
+VX
+CO
+AM
+CN
+CM
+FV
+LM
+XY
+QR
+DE
+UY
+OP
+EQ
+AV
+CX
+FZ
+AD
+GQ
+EO
+MW
+BN
+EZ
+GX
+AS
+BW
+AK
+RT
+GY
+IN
+FQ
+EI
+BG
+GO
+PR
+UX
+HU
+NU
+BF
+CZ
+CJ
+LZ
+EV
+KX
+VZ
+OQ
+HZ
+DM
+PZ
+TZ
+HM
+OV
+NR
+QX
+KO
+CW
+AW
+NV
+HO
+VY
+IO
+GP
+CL
+RX
+AZ
+PX
+LP
+DK
+LO
+BM
+MU
+BC
+JU
+IQ
+BO
+NY
+EM
+HJ
+CS
+AU
+PS
+DG
+AY
+KU
+DI
+OY
+HP
+JM
+JK
+GW
+FN
+RU
+IU
+RZ
+JS
+ER
+CK
+MQ
+LX
+QZ
+EX
+DY
+UZ
+GT
+QY
+AE
+AX
+FJ
+AP
+SY
+MR
+MY
+BX
+TU
+KT
+CY
+AI
+CP
+KN
+HI
+AJ
+KY
+BD
+PU
+KV
+JR
+GU
+PQ
+DS
+NW
+AC
+IV
+WZ
+NZ
+QV
+EF
+NX
+DQ
+HK
+FT
+FG
+DX
+AQ
+FW
+AF
+SV
+GI
+CG
+EJ
+DU
+JW
+WX
+EL
+IP
+DV
+LN
+FL
+BP
+BV
+CV
+MX
+FU
+BI
+GJ
+FK
+FI
+QW
+PT
+CH
+BU
+YZ
+FO
+EN
+BE
+SX
+TV
+AB
+DJ
+IY
+KR
+CU
+HQ
+SU
+LV
+DL
+JL
+HX
+JO
+EG
+IR
+MN
+IK
+AN
+LY
+OU
+HN
+AH
+MV
+LR
+BL
+TX
+EW
+CI
+MP
+CD
+EH
+LQ
+GN
+NS
+AG
+HS
+KZ
+PV
+IZ
+JY
+DH
+BH
+GH
+KP
+JN
+AO
+KQ
+KL
+MT
+UV
+DF
+HV
+BR
+CT
+ECYHYKWGQTYLYBDXPMGFOLLYJFQUURMRUHWKEPSQ
+124
+RV
+ZH
+HW
+GS
+BQ
+HS
+ZW
+CJ
+BA
+AG
+VH
+DI
+MH
+UR
+KD
+OH
+JI
+VR
+MX
+UE
+HG
+QC
+DX
+SK
+WD
+KT
+VO
+LV
+BM
+XF
+DE
+AD
+CP
+OB
+DC
+GB
+IV
+EC
+KX
+AZ
+UX
+PC
+DP
+PE
+GR
+YC
+RS
+AW
+IF
+SV
+BK
+DW
+JG
+ZN
+LK
+OX
+SZ
+WH
+ND
+UB
+OR
+SQ
+TH
+UK
+DH
+NT
+UA
+BY
+ED
+OS
+NY
+LO
+JD
+CS
+JF
+GW
+LY
+NL
+RE
+WM
+RM
+PT
+LG
+DF
+CV
+QL
+OP
+GC
+QH
+HE
+US
+VU
+JH
+EQ
+JQ
+VN
+JS
+JT
+RP
+XY
+RW
+NH
+QE
+KJ
+ES
+HK
+RI
+UY
+CW
+FR
+XR
+FK
+WX
+HY
+RH
+IU
+EH
+HO
+QW
+AC
+QZ
+NM
+MF
+YK
+ZGYDGANSWZKXKIUEQXKKFLWUBAJUYHDMEETESIPGEGCEKIUSFEXKHSZVNMTBWGJOPMHIRB
+198
+DJ
+ET
+IQ
+AO
+OQ
+FR
+MV
+NX
+KR
+QS
+JL
+IN
+BJ
+IZ
+JQ
+CI
+MN
+DY
+KZ
+BN
+ES
+DK
+EQ
+DH
+ST
+MP
+OT
+YZ
+LT
+MZ
+BI
+HQ
+HS
+SZ
+EI
+RY
+JR
+RV
+IX
+HJ
+HR
+IJ
+TW
+JP
+AX
+IT
+AD
+DU
+QX
+FO
+QV
+CW
+EK
+DT
+BH
+EW
+EN
+KU
+BK
+DL
+AH
+KM
+WZ
+AV
+FN
+IL
+TV
+HZ
+JW
+NR
+DG
+JN
+PR
+LO
+GW
+LP
+CL
+TZ
+DE
+LN
+SX
+FS
+CF
+DI
+BP
+DP
+UZ
+IM
+KV
+GR
+GT
+QT
+HP
+FV
+FM
+CN
+KO
+VZ
+GH
+DR
+GX
+MY
+EH
+DW
+HN
+TY
+GV
+EF
+BE
+MU
+OY
+GO
+HW
+KX
+DZ
+HU
+AW
+EU
+KY
+VW
+CQ
+HI
+AE
+DO
+JU
+FU
+PU
+HK
+FY
+KN
+AN
+JV
+GP
+AT
+DV
+BU
+AF
+OV
+CY
+TU
+FG
+HO
+DS
+CV
+EV
+JZ
+IK
+VX
+RT
+CE
+HM
+EX
+OR
+UW
+QZ
+AR
+BL
+LZ
+AG
+LS
+BT
+HL
+CR
+CD
+DQ
+BM
+GN
+PQ
+KW
+MO
+IO
+FL
+UY
+QW
+PX
+TX
+IS
+JT
+GS
+FI
+ER
+NZ
+GU
+GI
+QR
+BY
+BX
+RZ
+DN
+IU
+MR
+LV
+AZ
+AJ
+UV
+GZ
+PY
+CH
+OIHWQMOCQNHZRROYFBACXTJBTVRGECUKVMDWAQGOIYRBJBYVAIQLHFVDLQCOAOOBAACSMIHQTH
+95
+YZ
+QI
+MT
+MD
+BR
+HG
+KR
+KW
+QC
+KP
+DP
+CY
+RA
+LQ
+EG
+AM
+NE
+XR
+QM
+FB
+BZ
+PA
+GD
+CF
+MC
+JO
+BC
+AW
+ER
+FA
+PE
+UV
+CD
+MK
+GA
+AK
+ZL
+HR
+UA
+BN
+LO
+PR
+VM
+WX
+UP
+CO
+KX
+RN
+MU
+IE
+KH
+RX
+WH
+PX
+ZD
+MB
+XI
+BE
+IL
+TI
+SP
+KV
+DU
+EL
+ES
+NV
+BA
+JQ
+AL
+RH
+PY
+XK
+KJ
+ZJ
+XG
+BH
+OU
+YP
+WE
+XH
+VY
+JM
+WR
+ON
+KN
+LD
+IX
+RT
+WC
+RF
+CE
+ZW
+OY
+OD
+SF
+RJAKSGJOHUOGVHBVCRBJTUVBDZGEIFSUEWQHJWKLBJJW
+107
+FN
+CO
+BJ
+FQ
+DG
+QX
+OS
+DE
+BU
+SZ
+JP
+PZ
+LS
+DU
+FP
+DK
+VW
+JT
+FW
+BL
+AM
+BQ
+AU
+EX
+PQ
+IJ
+FY
+AN
+MS
+NT
+OY
+GY
+IT
+AE
+CM
+DW
+JR
+MO
+BG
+KU
+KY
+OQ
+DP
+RX
+QU
+RT
+HX
+HY
+BD
+FL
+MP
+IX
+BW
+GP
+FZ
+CJ
+CZ
+VX
+EG
+MX
+ST
+GS
+AW
+OV
+CF
+UY
+MU
+TX
+OU
+LM
+LZ
+BE
+PU
+FO
+HV
+EV
+MR
+CD
+DY
+AV
+KS
+KV
+RZ
+GZ
+AG
+JO
+AF
+CN
+GR
+DJ
+JM
+JL
+QW
+CY
+VZ
+RS
+OT
+AJ
+RY
+AT
+JS
+BP
+TZ
+FJ
+KP
+UX
+GL
+OUAUVIGHMLNYZDPWXUNBRKHFUEORZOGLGTVHBXILSSIEXQCGDEXYUTRZUOQIMYYIQFGS
+270
+AK
+HO
+BJ
+UD
+MI
+MQ
+AT
+NL
+UE
+OP
+TM
+VB
+XY
+NJ
+BQ
+GO
+PH
+AB
+ML
+SE
+GF
+TG
+HF
+SX
+QJ
+NU
+KD
+WU
+YO
+QI
+NE
+KU
+FN
+SW
+XS
+BE
+CH
+JM
+VN
+KP
+DF
+LC
+UP
+YP
+PN
+SD
+LU
+UO
+WG
+AQ
+SO
+PW
+XR
+HV
+MK
+VI
+DM
+TK
+CG
+RX
+CO
+BA
+YD
+VP
+RS
+DN
+LY
+UX
+AY
+JF
+FK
+QD
+FC
+WT
+KT
+NG
+AF
+DK
+CF
+EM
+MR
+KE
+XE
+WM
+FQ
+VK
+EW
+WS
+YK
+YG
+DY
+NR
+YN
+MD
+PU
+TH
+UH
+EI
+YV
+HI
+SF
+JU
+JI
+FW
+DU
+IB
+QY
+AO
+GR
+OU
+YU
+PG
+GT
+KL
+ME
+XH
+BV
+AX
+UM
+IE
+UL
+BM
+SZ
+JE
+IV
+TI
+YQ
+VZ
+HS
+QP
+EC
+DB
+FA
+HL
+KR
+LX
+PI
+MN
+UK
+CM
+LP
+IC
+FO
+AM
+BC
+UZ
+ES
+OS
+WO
+SK
+EG
+QF
+JG
+CR
+IX
+KX
+RL
+ZK
+CY
+VY
+AG
+HC
+GK
+YT
+PR
+XT
+RV
+NK
+HZ
+BW
+GU
+LN
+DR
+BK
+KH
+BS
+CK
+ST
+ID
+RJ
+EQ
+MB
+MV
+XD
+HR
+BG
+ND
+PQ
+LG
+BD
+IY
+XA
+UG
+RH
+RC
+YI
+UB
+RT
+UJ
+ZO
+UI
+QH
+GZ
+NB
+JS
+DS
+QX
+SP
+OG
+HB
+ZJ
+WP
+WA
+LI
+EO
+NX
+SI
+WD
+SM
+DH
+SJ
+HM
+PY
+PF
+KM
+IM
+TW
+DT
+YF
+SN
+KC
+ED
+HX
+OL
+DI
+ZX
+ZV
+GP
+ZT
+JK
+VQ
+CX
+AP
+AD
+EP
+GS
+LW
+MY
+EU
+IK
+MC
+QE
+PM
+IO
+BX
+NS
+VS
+AC
+GJ
+XQ
+LZ
+PA
+PK
+AL
+OF
+SH
+GY
+RF
+GE
+TP
+GHZPCGJFWNVJEYFSUGKJFQLTFWDQSJQHDETBALMGABUFRNIPMHQAEADZNYAGTZLBP
+35
+OS
+GS
+IV
+JN
+BZ
+FM
+JV
+PX
+LT
+NQ
+DV
+AS
+IT
+JM
+QW
+AL
+JR
+HO
+MZ
+RX
+DT
+OU
+EX
+BT
+TV
+HZ
+UV
+EQ
+MY
+QV
+KW
+GM
+IJ
+HT
+BG
+EDHTCBCSRZOMGPQERBHHAW
+180
+WU
+BG
+IQ
+AU
+GD
+TM
+VS
+CR
+IE
+VL
+NU
+UA
+IW
+DQ
+CT
+WD
+HJ
+KP
+QZ
+TC
+FN
+XE
+XB
+RT
+ZI
+GW
+QB
+DT
+AZ
+QN
+IJ
+DG
+PR
+EY
+NM
+UV
+MH
+AX
+GS
+QP
+FU
+AD
+JC
+GQ
+HD
+OJ
+KE
+BY
+TV
+KF
+RV
+MR
+JV
+GK
+RN
+GH
+PQ
+SL
+CN
+BI
+PS
+UH
+UJ
+GM
+VK
+AM
+OH
+LG
+HG
+YE
+QY
+MG
+MT
+ZM
+IB
+CL
+RE
+NW
+NR
+KA
+OD
+QA
+DY
+SQ
+SY
+CW
+SB
+KZ
+VW
+QW
+VX
+AH
+SI
+ZX
+IU
+CS
+WI
+BJ
+OL
+XT
+VO
+QF
+CX
+AE
+GT
+GZ
+NE
+YS
+UR
+XP
+SV
+RH
+WR
+HC
+MB
+BQ
+UK
+SZ
+MU
+NZ
+ZQ
+KS
+JO
+JR
+AT
+NV
+IF
+FO
+EX
+FD
+WS
+ND
+AV
+IR
+UI
+IO
+EF
+OR
+MF
+EJ
+DA
+KC
+VH
+UO
+MC
+TQ
+BM
+VC
+DS
+UL
+TG
+KL
+XG
+HB
+IG
+BH
+EG
+SR
+DM
+IA
+WY
+LP
+EO
+BD
+MN
+JZ
+CK
+JE
+WN
+DW
+YX
+CJ
+ZP
+JF
+SK
+OY
+QH
+PV
+CV
+TS
+FOQSTAHIPOJEBFJMSXHEPZOJOYFOKBYVCWSBMWQQCBNCISQ
+70
+KN
+MN
+NU
+GN
+BU
+AW
+CK
+RU
+XY
+MS
+NP
+ER
+KQ
+MX
+AB
+GL
+LM
+IJ
+CY
+PY
+WZ
+OT
+DU
+NT
+TW
+NQ
+DK
+BR
+CT
+KM
+DI
+FQ
+CW
+SW
+EM
+JY
+OY
+FH
+AP
+JR
+GO
+LU
+GP
+UV
+OR
+BG
+FR
+GI
+MW
+CS
+LY
+FT
+CM
+DE
+UZ
+CN
+BV
+JK
+EF
+AV
+RZ
+LV
+RY
+KY
+BP
+CF
+OQ
+KT
+OU
+AG
+ONOQLUUAMOSDUYAGNDFKDJEMSKLMMBFSFRHGSRHUPJWHTNAZPSKMXZTLNZZEYRYPIEHYUTSESWTDJXCXFLSHTGOW
+184
+LB
+TE
+WQ
+KM
+QP
+GX
+VN
+JF
+BA
+KD
+IZ
+JZ
+YH
+DN
+EF
+TZ
+ZW
+OC
+AM
+ON
+GK
+XP
+OD
+FS
+HJ
+NW
+WP
+SF
+IJ
+UE
+YK
+NR
+DA
+DP
+JO
+UK
+MX
+ET
+AI
+NQ
+NO
+EP
+KS
+XE
+PK
+BK
+QV
+BQ
+NB
+AQ
+DS
+IK
+RH
+RT
+SR
+GJ
+BC
+KY
+AN
+VB
+YT
+HT
+KR
+WS
+YP
+QH
+TW
+FY
+ZD
+OK
+WY
+IA
+JV
+VM
+MD
+YR
+UQ
+AS
+YI
+HA
+FK
+VR
+AU
+GF
+XT
+EO
+ZO
+NS
+AZ
+SM
+LN
+OF
+FR
+PL
+SZ
+SG
+DM
+DO
+JB
+JT
+QY
+TL
+SQ
+RE
+DK
+EH
+LE
+OT
+UP
+LH
+BX
+AV
+EN
+CQ
+FP
+HQ
+CA
+ZJ
+KP
+HO
+SO
+CY
+KU
+PW
+SU
+MY
+QN
+RN
+NC
+RW
+DY
+XJ
+LU
+KB
+AF
+TO
+UT
+HB
+WL
+ID
+DI
+TS
+KO
+DE
+DU
+QS
+QW
+CZ
+TN
+MJ
+FE
+SN
+RU
+BH
+BM
+MR
+MO
+TC
+FX
+UB
+VF
+CI
+DV
+BO
+AJ
+OR
+SP
+JG
+WC
+NX
+EB
+HF
+WU
+BD
+TA
+OM
+HD
+JC
+MH
+ND
+VQ
+JN
+HS
+UF
+KXAVSMDHZBQWUNNRUSZQLXNXTKJJQTQEURABTEDFLTDPQTQLULVLQBQZMMQNSCQG
+69
+TU
+WD
+XV
+QF
+PN
+YG
+MG
+DJ
+VB
+ZY
+VN
+UX
+OP
+UK
+SL
+VF
+BY
+JU
+BD
+NI
+LG
+QH
+DA
+GQ
+PU
+KX
+XD
+UR
+NY
+JL
+DR
+UZ
+XK
+IE
+IF
+XF
+OV
+DV
+KJ
+HF
+AM
+CG
+GF
+XM
+RY
+DY
+MR
+FR
+MS
+RN
+UD
+JT
+XP
+YF
+BP
+RQ
+VD
+TV
+EA
+BM
+YV
+VP
+PF
+VM
+YC
+TN
+MW
+FG
+QP
+IVYPGYOYQEZVMNVZTBJOJSAWJHQBMOFLQVWUTKBWUIERBXZVVDOTQSVRQLXULSYJPRJQ
+111
+RH
+KC
+PS
+QF
+SF
+JR
+LK
+IR
+TL
+HZ
+PR
+PO
+ZY
+IT
+WH
+BN
+MG
+DM
+RN
+EM
+RI
+DV
+FO
+OD
+FZ
+AP
+UQ
+JZ
+QC
+WA
+YT
+FC
+GD
+UA
+ZR
+ZC
+AF
+OK
+NA
+UH
+HP
+EL
+HL
+GX
+ZI
+LO
+AU
+UE
+RG
+DP
+XT
+MB
+ZP
+IJ
+FV
+FT
+FA
+BS
+ML
+ZW
+OB
+DQ
+FK
+GJ
+ZA
+BL
+LW
+BF
+US
+TI
+YP
+TA
+GP
+BP
+EC
+LH
+YL
+LG
+HX
+UJ
+KM
+IG
+SM
+CU
+AK
+LM
+VM
+QD
+HR
+UY
+OI
+KX
+GB
+VH
+FN
+KI
+CQ
+KE
+UD
+UT
+VR
+KF
+XJ
+YU
+GY
+ZH
+RZ
+EZ
+TJ
+HM
+FR
+MNTQELQJFKDLDKNZTCINIPWRESPQZNWUNESWGJZ
+207
+FL
+UW
+BJ
+EX
+AH
+PQ
+EV
+VZ
+FG
+IT
+RS
+GQ
+GW
+ER
+NZ
+BK
+IR
+HP
+OQ
+MO
+NX
+AK
+AX
+AV
+DS
+FS
+JV
+GV
+HT
+QR
+GP
+KZ
+AD
+IJ
+KY
+QT
+XY
+EN
+FN
+DY
+JQ
+LZ
+RX
+CP
+CK
+DN
+OZ
+MR
+HV
+BD
+CZ
+OV
+CO
+GX
+JW
+EP
+RT
+OT
+IV
+KM
+DI
+FW
+SV
+TX
+WZ
+TZ
+PV
+DO
+DG
+HY
+UZ
+EQ
+EH
+BP
+HI
+GS
+GM
+DZ
+KN
+LU
+TV
+CW
+RW
+AJ
+FM
+KS
+CT
+SX
+SZ
+BI
+CR
+DK
+PX
+JK
+AF
+GT
+SU
+JO
+CQ
+KR
+QZ
+DH
+BT
+WX
+EW
+LS
+AT
+HQ
+NS
+NU
+JM
+AR
+GH
+QV
+CJ
+HK
+DV
+BL
+IO
+OY
+MQ
+LX
+PT
+BG
+AW
+EI
+LN
+EG
+IP
+MU
+KT
+JY
+QY
+RY
+MN
+AI
+EM
+EO
+LM
+UV
+DQ
+EY
+BU
+JZ
+CX
+JR
+FH
+HN
+HL
+CY
+DU
+CD
+MP
+AC
+RV
+BH
+EZ
+DT
+NV
+AN
+QW
+HR
+NO
+YZ
+OU
+CU
+JX
+BF
+FT
+IY
+AM
+BM
+LT
+HM
+FP
+AQ
+DP
+WY
+AL
+BN
+SY
+OR
+CI
+BV
+GN
+OW
+UY
+GI
+LP
+JP
+LW
+LR
+MX
+AG
+HU
+JS
+PZ
+PR
+DL
+CH
+ST
+LQ
+CS
+HX
+LO
+QX
+FZ
+WARHBSPIFYYINCLNJIFUHKDCYYZCWYUZYNCJ
+162
+KR
+VL
+AF
+XW
+TW
+US
+OX
+SY
+WE
+KC
+TI
+ES
+FS
+ME
+NG
+RK
+ZW
+JM
+LX
+PT
+VF
+NA
+UM
+GN
+WA
+DP
+HJ
+HG
+XC
+GV
+RD
+BI
+PS
+HX
+XZ
+HK
+DQ
+MI
+AT
+QB
+HW
+SG
+SO
+NV
+AY
+PM
+LO
+JC
+HZ
+TC
+SL
+PB
+BH
+ID
+OI
+HE
+JO
+UW
+YJ
+DZ
+JF
+HT
+MJ
+XI
+ZU
+XA
+YX
+OD
+RL
+EQ
+MU
+PF
+IY
+VI
+QD
+EL
+XJ
+QM
+CD
+NP
+QR
+YE
+KU
+ON
+AJ
+WO
+UR
+ZX
+PK
+QO
+UN
+SA
+ZS
+VE
+QS
+CW
+WH
+KB
+IG
+LY
+KL
+PY
+RG
+GR
+XF
+QY
+MK
+TF
+DR
+OA
+JW
+DU
+IW
+MD
+NX
+BJ
+RW
+XH
+IQ
+JU
+WU
+WZ
+XK
+UP
+PH
+ZC
+DH
+YZ
+LC
+UV
+WM
+FJ
+UE
+XN
+KG
+XV
+YO
+ND
+OG
+XO
+DO
+YP
+FE
+BX
+WS
+CJ
+DC
+FO
+LG
+KI
+BO
+CV
+EF
+MG
+OC
+BN
+PI
+XP
+WT
+UX
+KM
+RO
+MITBPNHKDFBKQBJDWSMEWJGCPZXVYTEUBPEROWBBOCBJKXWGLEPDNLZJZPKKZUIVAHGLAZZRTYJPFJSNFGRKP
+211
+QX
+KR
+HP
+ZQ
+AJ
+AB
+GA
+TU
+RD
+HZ
+WR
+IR
+UY
+WP
+PH
+YW
+ML
+OQ
+TR
+AL
+TA
+DT
+QT
+WS
+WC
+VO
+YH
+UV
+DL
+SF
+XU
+TD
+TE
+LY
+EF
+LO
+WG
+IJ
+OL
+LM
+YZ
+JX
+VI
+GJ
+WM
+YD
+LR
+MV
+IT
+SP
+NQ
+HR
+RA
+YE
+PE
+RY
+SZ
+JD
+YQ
+BD
+UT
+NU
+CP
+FU
+WA
+RE
+UB
+IZ
+SL
+YJ
+LF
+EC
+DK
+JB
+LG
+NI
+DU
+MI
+UX
+LA
+AC
+YC
+ZH
+CG
+BY
+ZC
+KL
+YF
+ND
+NV
+ED
+MG
+PZ
+KS
+CH
+ZA
+TN
+EW
+SN
+BA
+UJ
+VA
+UI
+EA
+BN
+PL
+UA
+KT
+FC
+IA
+DI
+BS
+UZ
+RI
+GY
+QU
+RZ
+QC
+HA
+NY
+BM
+MP
+NB
+SE
+HM
+JM
+VU
+XE
+GF
+ER
+PJ
+RB
+MW
+YG
+EO
+OJ
+HN
+IV
+JZ
+IX
+LK
+VQ
+QR
+DG
+EX
+UW
+JE
+QJ
+SU
+BK
+WD
+LD
+GW
+ZX
+XZ
+KU
+LS
+HD
+XD
+KA
+EK
+FT
+TS
+QA
+YO
+QW
+KF
+OW
+GZ
+RN
+IC
+GN
+OV
+ZV
+XL
+YI
+TC
+TF
+VY
+VJ
+YX
+JI
+AF
+EQ
+HK
+DX
+BQ
+GC
+PV
+AK
+WY
+ZB
+LP
+FK
+UL
+MX
+BZ
+QP
+PA
+JA
+AY
+AP
+KZ
+RG
+FQ
+RJ
+YR
+UO
+LU
+ZI
+XQ
+YJQESDHZLXMOTUEPTUORYIIYQFJMAJTFPNQYSLBFKCBQTEFXLAMSWUZYBUUGXNPYSDBZLOJUUKSQHTSUESHFJFKVGPWVSIYJBN
+135
+HI
+HX
+AW
+XZ
+GM
+BU
+JR
+KR
+FZ
+SY
+RY
+ER
+KW
+EQ
+GV
+SZ
+AG
+CX
+OX
+LQ
+MV
+GX
+LZ
+CK
+BW
+BC
+AX
+NP
+FV
+OW
+IS
+OV
+GN
+DR
+FY
+IO
+LY
+IT
+HN
+KO
+AV
+LW
+MX
+EI
+ST
+BJ
+AL
+LT
+QX
+HP
+FX
+TZ
+AB
+JK
+EL
+KQ
+QS
+GY
+FI
+SW
+DX
+CF
+RW
+OY
+QY
+GU
+DN
+IV
+DI
+KZ
+CS
+HL
+FR
+IZ
+PX
+GR
+OZ
+LS
+DL
+RT
+KP
+QZ
+GO
+DP
+LO
+MT
+BO
+SV
+FH
+IN
+IU
+HQ
+DF
+FS
+FU
+BQ
+PY
+BI
+OT
+PS
+GL
+HV
+MW
+DQ
+UW
+ET
+HT
+BZ
+OR
+NY
+MQ
+EH
+EY
+IR
+HY
+PV
+OU
+CW
+JP
+JW
+BX
+FM
+JL
+CD
+EF
+LU
+CR
+GZ
+KY
+NO
+AH
+PQ
+AC
+BT
+KM
+LSKUGECWHUTLKILFVIWFFQLUSMJMYHTQFOWEOTRMTRCCLZLTRKUCEBERD
+168
+OD
+MV
+ZF
+JP
+HX
+VW
+VK
+SC
+CF
+SV
+OR
+BV
+MX
+AI
+DC
+FU
+YV
+HZ
+MT
+AB
+RH
+PN
+SJ
+NP
+QN
+XA
+PM
+NR
+IF
+OG
+EO
+MB
+DV
+WC
+TE
+OT
+FR
+AS
+VS
+DF
+PJ
+GM
+ZO
+WF
+RY
+HO
+MK
+BE
+GY
+EW
+MD
+QH
+ND
+HS
+RF
+KX
+GE
+IZ
+ZL
+DR
+ZV
+PZ
+UD
+JK
+GU
+JS
+RO
+KE
+BR
+WR
+OM
+TD
+TR
+OU
+LF
+IL
+TU
+LD
+KU
+JI
+WK
+YF
+TA
+BM
+DK
+DW
+GN
+WD
+IQ
+CH
+WO
+ZK
+VP
+GR
+NO
+FI
+YU
+BQ
+ET
+JW
+CQ
+PW
+SO
+VO
+JD
+JB
+MU
+AC
+FH
+HU
+QZ
+XZ
+PB
+OX
+UQ
+FC
+WZ
+XG
+RE
+UA
+OP
+MQ
+CU
+VD
+PO
+YD
+BF
+MZ
+MJ
+XQ
+DA
+IO
+RD
+XK
+DJ
+UW
+ZA
+QF
+LJ
+GV
+CL
+DU
+PR
+GT
+TV
+LZ
+ID
+ER
+FE
+TM
+DG
+XB
+HI
+OL
+ZI
+WS
+GK
+IG
+PL
+GP
+JE
+AW
+XY
+JL
+UN
+OI
+HD
+QR
+WVBZCPYIQMATGVVRPFVJQQXRYPJIIATPRKIICLWKHZEJMHEYRWUPAXP
+163
+XQ
+KR
+IW
+JI
+FE
+AP
+GF
+VK
+LN
+WB
+FJ
+TC
+MQ
+OJ
+OU
+XC
+EL
+WM
+HZ
+HQ
+SI
+BC
+DP
+CL
+ID
+BJ
+OV
+DL
+PQ
+GM
+GY
+AG
+BA
+ML
+NP
+LM
+TF
+MK
+WF
+UF
+QW
+QG
+CT
+AH
+IA
+XP
+OK
+PI
+RS
+LA
+DB
+JA
+TB
+CV
+DU
+TU
+BE
+FX
+BK
+SW
+ZI
+BI
+EX
+SD
+ED
+ZT
+SF
+NB
+EW
+WO
+QP
+RM
+GU
+RB
+AZ
+SC
+TE
+BF
+HR
+UR
+HL
+PR
+QZ
+CH
+ZQ
+GK
+LH
+VU
+JV
+CU
+TV
+HS
+RY
+FU
+AK
+XH
+NJ
+US
+TD
+WA
+IF
+LC
+RP
+VO
+OQ
+PD
+CS
+HD
+LJ
+QJ
+HE
+IM
+XY
+LR
+DG
+AM
+SB
+DX
+AQ
+PK
+UE
+OD
+KB
+ZD
+YA
+HM
+AT
+SQ
+YD
+KE
+SH
+QA
+ZS
+NC
+JG
+ME
+IU
+TN
+RG
+HY
+PV
+PF
+HC
+FC
+ZX
+DO
+SZ
+HU
+NM
+YX
+WZ
+WK
+XI
+NR
+JH
+UH
+UX
+GR
+XM
+QY
+EY
+CF
+JP
+CDHHMSCCCAUQDSUCBDLVVURXLBUNOWNOQIBUIURZRTBSPWMPXYYVTNOVWDQUXAIQTVOMZSIESNQHWMGALDQXKRBPZCCPUGU
+267
+KX
+OP
+GU
+DO
+EU
+VZ
+HK
+GM
+NO
+DX
+DI
+TY
+CQ
+BW
+MT
+SV
+DG
+NS
+BU
+EW
+DJ
+NY
+DW
+CK
+LM
+KT
+BD
+CO
+HZ
+LV
+GV
+PY
+DS
+LP
+AX
+QY
+FJ
+XZ
+KY
+XY
+KL
+AU
+WZ
+FP
+BF
+FO
+WX
+MS
+BG
+HJ
+RW
+AK
+SX
+BY
+AS
+FQ
+LQ
+IW
+YZ
+DR
+QT
+OZ
+QS
+FW
+HT
+CX
+CH
+DE
+DQ
+CW
+MW
+SU
+BV
+EQ
+FG
+IJ
+JQ
+LS
+BO
+AG
+BJ
+AY
+OS
+JP
+CE
+AP
+NQ
+NU
+AW
+PV
+DK
+IU
+EF
+OQ
+HP
+FI
+OW
+NV
+IX
+KV
+EO
+PX
+RT
+UZ
+CV
+GS
+UX
+FR
+IL
+JN
+EX
+RX
+MN
+AL
+VW
+HW
+DV
+CG
+FV
+LR
+TX
+FM
+DZ
+NZ
+LZ
+ST
+CI
+BS
+ES
+JX
+AV
+AE
+KZ
+CN
+HX
+KN
+OR
+IS
+DY
+AR
+MY
+NX
+BQ
+HL
+JL
+AT
+QW
+OT
+BL
+BN
+EP
+TW
+FY
+FT
+DT
+AO
+FZ
+RV
+HR
+BC
+CJ
+AI
+LX
+GP
+QX
+CF
+QR
+AQ
+VY
+CZ
+GN
+MR
+LW
+DF
+DL
+GO
+EJ
+IN
+GQ
+PW
+OX
+AZ
+OY
+JY
+DM
+AD
+FH
+WY
+CP
+AJ
+PT
+MQ
+JS
+IM
+IV
+JK
+MX
+FN
+KQ
+SW
+KO
+NT
+TU
+IO
+RU
+JR
+SZ
+CM
+EV
+BX
+AB
+JO
+EG
+GL
+NW
+BM
+EY
+LU
+AF
+RZ
+BI
+HI
+PU
+MZ
+JZ
+MP
+GK
+FS
+AN
+MV
+CY
+CT
+CL
+FX
+EM
+HV
+JM
+JW
+CU
+OV
+DN
+KR
+BT
+PS
+HQ
+JV
+BH
+QZ
+UV
+KU
+CR
+PR
+LT
+EH
+LO
+HU
+DU
+AC
+IZ
+BZ
+RS
+RY
+HN
+TZ
+MU
+ER
+IY
+HLIIMZYUODTKROGRZGIBECKBWVEZ
+51
+US
+OP
+KW
+UC
+QP
+PR
+DW
+IY
+BV
+QK
+BZ
+MH
+KA
+JE
+TJ
+ZL
+PN
+DK
+EF
+DE
+IH
+HV
+BL
+ZX
+TX
+UX
+GW
+JB
+OQ
+RX
+TY
+IX
+XY
+BU
+KB
+LG
+EV
+MB
+YC
+BD
+AO
+XI
+DB
+GX
+EJ
+SK
+FR
+MF
+OV
+NL
+QA
+GXIENJCPYBWMGJJPTUZZDWIOAMHHWWNSYRCPJNYBVXBBARCILOFNPHH
+94
+ZS
+NZ
+OZ
+MW
+SJ
+CY
+OX
+KB
+YQ
+DY
+EN
+CU
+FO
+KO
+OI
+LP
+NP
+VO
+MN
+GW
+PZ
+IV
+LD
+UF
+AO
+WV
+JT
+FZ
+VA
+YW
+WS
+IA
+JR
+OC
+NK
+QE
+XH
+CF
+PD
+PE
+UK
+TY
+AK
+PF
+VD
+DH
+FV
+KY
+JW
+RC
+QF
+AI
+IN
+KA
+CP
+LA
+QV
+UE
+FD
+PN
+LO
+XI
+JH
+XL
+CL
+QT
+AZ
+SI
+DA
+PH
+SL
+SF
+IJ
+NY
+IT
+QW
+ZN
+NO
+DM
+DF
+ID
+NU
+XB
+GL
+OJ
+SK
+IP
+RS
+RQ
+CE
+SB
+QK
+XW
+XM
+GHHSMPAYWLAHVTCTOMTDXIPXIVTPBOQKDLLCBMPONYELWQRQAVBANRPJSKBAFRGYQOJIAL
+229
+TX
+DW
+EG
+CT
+VW
+EW
+CY
+NO
+FV
+OV
+BS
+HU
+CZ
+JW
+LQ
+OY
+CN
+BD
+AU
+GI
+LO
+MU
+TY
+HO
+HV
+HR
+PV
+JT
+BQ
+DR
+AV
+EO
+LV
+RT
+MO
+QW
+DV
+GM
+KW
+LT
+NW
+FJ
+IZ
+KV
+HQ
+UV
+RX
+AG
+JO
+AW
+TZ
+AF
+EL
+CK
+CO
+RS
+IV
+IN
+JN
+FG
+IL
+DS
+GU
+QS
+OS
+KO
+DF
+HS
+GS
+UZ
+DL
+GO
+RW
+MY
+IP
+CL
+CP
+CV
+LY
+AR
+FH
+GH
+IK
+HJ
+EZ
+PZ
+DO
+HI
+BE
+JL
+AJ
+AX
+AM
+UX
+MR
+BW
+QY
+OP
+CX
+ER
+CG
+BR
+BU
+CR
+KP
+GK
+IU
+KL
+MX
+CQ
+XZ
+EY
+CI
+HX
+AK
+UY
+LZ
+AH
+NZ
+DU
+EK
+BM
+XY
+TV
+GP
+NU
+GL
+BJ
+SV
+HY
+IJ
+BN
+OT
+KR
+FR
+BG
+GT
+AS
+HM
+ST
+EJ
+PU
+RV
+MV
+EU
+TW
+AB
+LX
+JZ
+SX
+MT
+GQ
+AN
+DG
+EV
+IW
+AT
+JR
+GY
+LW
+LS
+IX
+OW
+SZ
+HT
+DY
+FX
+EM
+PW
+DI
+BP
+KQ
+QZ
+RY
+WZ
+QT
+NT
+OQ
+DM
+YZ
+EF
+IR
+BI
+DH
+IT
+LN
+KZ
+BY
+CM
+FT
+IQ
+UW
+EN
+BF
+SU
+CH
+PS
+GJ
+BC
+BO
+AE
+RZ
+PX
+DJ
+DX
+CD
+CW
+LP
+LU
+CJ
+FM
+JY
+FI
+FL
+AP
+NR
+FN
+EQ
+SY
+LR
+GN
+JX
+HP
+AO
+BK
+QV
+PQ
+FP
+DP
+AWWFIZHMUNEZAJRAGNKLWKSOCTMATGFHYDEACOHKYRQTEEIHLEBH
+222
+GQ
+HL
+ZU
+IX
+DK
+UK
+JY
+WV
+CB
+PJ
+UM
+XE
+SW
+TN
+LW
+JP
+SD
+MU
+ZF
+UJ
+KG
+HO
+ZP
+NZ
+KS
+OX
+XT
+ZD
+PC
+JI
+EQ
+AO
+XR
+WE
+WP
+MT
+IN
+QK
+FA
+HI
+IU
+KY
+KI
+TS
+MO
+ZH
+AY
+DZ
+BI
+FN
+BF
+PM
+JZ
+AR
+UI
+UQ
+OS
+XP
+RV
+CS
+MV
+PX
+VC
+JC
+FY
+KO
+SF
+GL
+BE
+CZ
+QZ
+QV
+CV
+YN
+XH
+EY
+UN
+TC
+GC
+SX
+RJ
+IR
+PH
+NC
+MA
+PE
+NF
+IV
+US
+SH
+VS
+KE
+YF
+EI
+QM
+UZ
+HK
+NL
+GA
+FD
+HY
+RU
+EK
+OF
+ZO
+IO
+EP
+BQ
+SY
+XW
+FI
+GZ
+KJ
+OI
+UD
+DU
+MH
+IY
+GE
+WO
+VH
+JR
+DG
+GD
+KC
+TK
+ZW
+RE
+WY
+XJ
+GF
+IP
+LA
+NY
+BX
+ZJ
+ZA
+NG
+OC
+VR
+OL
+XL
+ET
+AQ
+GS
+XS
+WA
+OY
+FB
+FZ
+CL
+SB
+VA
+IW
+HM
+PO
+QO
+ZB
+FV
+LN
+VP
+ID
+VU
+IE
+ZR
+LP
+KW
+TY
+TD
+NR
+XC
+KZ
+TV
+BM
+QE
+MX
+MC
+TH
+EB
+CF
+YZ
+BY
+SV
+SE
+NT
+OP
+OD
+VG
+YU
+VT
+MB
+JD
+JG
+BT
+YS
+GO
+DC
+XV
+RH
+OJ
+EF
+DI
+QA
+DE
+JX
+JE
+QS
+AF
+FK
+PY
+RW
+NQ
+XI
+DA
+AL
+OZ
+JU
+DS
+HR
+QG
+BL
+DY
+RCVJXGWPXOOCEFZLVNSHQ
+276
+VL
+YJ
+HI
+GJ
+IA
+XI
+WT
+CJ
+CR
+GX
+MI
+YM
+OX
+YZ
+XP
+YV
+EC
+ZY
+HD
+XB
+UD
+KQ
+UM
+CW
+FX
+FV
+RK
+QT
+PM
+QO
+MD
+VT
+JN
+GP
+QW
+FC
+DQ
+VM
+CM
+GT
+PY
+PC
+VX
+FZ
+EU
+AH
+WM
+UT
+KJ
+AD
+TR
+RC
+LS
+CV
+OD
+VB
+LA
+ZH
+ZE
+YA
+IX
+TS
+AS
+FS
+ZV
+QS
+NK
+AG
+VU
+JF
+OF
+HB
+SO
+EN
+UQ
+RY
+QX
+OV
+XK
+TM
+ZA
+NH
+FM
+ZQ
+ZO
+KZ
+UA
+DH
+VN
+XQ
+BH
+RS
+YQ
+GQ
+MO
+OA
+HU
+EV
+ZI
+JQ
+PX
+JE
+SA
+IT
+DS
+FK
+LT
+JX
+YI
+OU
+IN
+FU
+DM
+FH
+HC
+CF
+TD
+CB
+MF
+TW
+TK
+AJ
+VQ
+WL
+AQ
+YE
+JO
+YK
+ZT
+NL
+YG
+WQ
+XR
+OK
+ZX
+YX
+KW
+KE
+SE
+CI
+UC
+FO
+CT
+IY
+HZ
+FB
+UZ
+DB
+WZ
+AY
+PD
+MX
+QV
+JZ
+FR
+NI
+XV
+NB
+SN
+VA
+GU
+QH
+UG
+JA
+GI
+HR
+PS
+DG
+YL
+SF
+TA
+DF
+FN
+PJ
+YO
+KB
+UJ
+WH
+BC
+FY
+FP
+CQ
+YC
+KN
+RJ
+PN
+KC
+LE
+PO
+BQ
+AK
+SL
+BI
+XM
+QP
+UV
+NY
+OE
+ML
+MQ
+ZP
+TF
+FL
+CY
+XJ
+FI
+XO
+TH
+ND
+PL
+CN
+JC
+GW
+OM
+RO
+XF
+DN
+ON
+FG
+BV
+UP
+DK
+PQ
+WA
+AP
+FQ
+JG
+ZM
+ZK
+HX
+TL
+DE
+EF
+LO
+RD
+DV
+KA
+EQ
+HG
+LJ
+IJ
+SG
+FE
+ZL
+AZ
+PT
+BW
+VW
+KM
+LH
+SX
+OR
+EK
+SZ
+BS
+XT
+HM
+BJ
+BN
+CS
+PK
+QN
+XN
+RH
+IQ
+IB
+WO
+JT
+OW
+BF
+WB
+NE
+WG
+EP
+WF
+BG
+NKIBMKPUTAZPXRGNNKOAOQUVFLDFZISACTXIGBLAOMHRNEKGHOUCOD
+39
+OH
+KD
+FX
+AL
+ND
+NP
+QV
+VS
+BU
+PM
+BQ
+PR
+FL
+LE
+KU
+KM
+WJ
+ER
+JQ
+YX
+OT
+IF
+YW
+VY
+BO
+HW
+WQ
+YM
+DB
+LU
+AT
+RM
+IR
+GJ
+TD
+HQ
+QR
+DC
+UN
+MOKWSMAHEGIXZJIEWICZAFMORDIKHTKNIOFRGAA
+50
+SZ
+TV
+HL
+EO
+WJ
+AF
+VL
+VQ
+HE
+JV
+ME
+XL
+CV
+JG
+FC
+CM
+KC
+EL
+EK
+SG
+LG
+EU
+NT
+KD
+ON
+EQ
+OD
+ZQ
+PD
+WT
+SL
+WH
+NW
+FN
+VZ
+DQ
+UL
+UK
+IV
+VT
+UP
+LY
+KP
+MR
+FY
+NP
+DC
+JX
+KB
+GW
+BACEVZIGKSKCUZCUSFMWDWMVIVQHGOMTMF
+114
+GO
+AC
+NS
+QW
+DK
+DE
+HN
+LQ
+OU
+IV
+CU
+XZ
+GI
+OQ
+CZ
+AQ
+MO
+BJ
+IY
+IT
+KQ
+EZ
+AE
+OR
+IL
+TV
+LS
+ER
+EK
+DV
+FR
+DM
+IW
+RV
+LY
+GQ
+JQ
+UW
+CG
+ES
+PV
+JZ
+JK
+AI
+JU
+BF
+AX
+HO
+RX
+GU
+CL
+LV
+MP
+KX
+BN
+MX
+KU
+FL
+TX
+IR
+LW
+AG
+RT
+HZ
+EV
+GW
+CK
+EL
+NV
+VY
+DR
+CP
+MN
+FO
+BX
+TZ
+DW
+TU
+KY
+FM
+WX
+KO
+EI
+GR
+FT
+QV
+BL
+GN
+CQ
+AD
+EP
+EG
+HX
+DS
+DN
+KR
+HV
+MY
+JL
+JY
+TW
+MS
+ET
+LO
+FW
+WZ
+CO
+PZ
+HT
+UV
+XY
+MZ
+NU
+RU
+BVSTPGPUDKCKTIYHTXJKI
+71
+IP
+EF
+XZ
+HL
+JT
+PX
+UX
+LU
+QZ
+KR
+EO
+QS
+SU
+QW
+ES
+JO
+NV
+BS
+HP
+UV
+GX
+HY
+BT
+UW
+GQ
+KT
+MX
+GI
+TY
+AT
+BG
+GP
+GN
+FL
+SX
+FU
+DI
+AS
+CV
+CM
+ST
+PR
+GJ
+LW
+BI
+BX
+DE
+HU
+TZ
+DP
+CO
+OX
+CQ
+CL
+RX
+JW
+AV
+RY
+IO
+EJ
+GR
+EU
+YZ
+DK
+MU
+RW
+EV
+MO
+AH
+MQ
+JZ
+LHAGGCKQQIXKCRFYUWTCQUEKCVUHS
+192
+DT
+HX
+TY
+AZ
+DO
+PY
+JS
+HV
+FK
+HJ
+OU
+HO
+GW
+EJ
+FT
+CG
+JY
+MU
+DR
+KS
+GR
+HU
+BN
+FU
+CL
+LS
+BU
+HM
+NR
+LW
+EX
+AN
+LY
+LP
+SV
+CF
+AR
+PS
+RV
+QV
+DG
+GS
+JU
+TZ
+JO
+DK
+DF
+FR
+CR
+LZ
+EP
+PR
+IR
+MO
+KW
+SX
+NU
+IM
+AP
+AG
+IX
+LV
+RT
+HS
+JN
+IT
+ET
+AC
+AX
+SW
+OP
+GX
+FL
+TU
+QU
+PQ
+CI
+GO
+FZ
+QT
+QX
+JW
+EM
+MN
+WZ
+QZ
+DJ
+BS
+ST
+CD
+RU
+JL
+BI
+DS
+GH
+VY
+BR
+RS
+HZ
+KP
+KZ
+KQ
+MV
+KR
+GP
+AQ
+GT
+HW
+GZ
+UZ
+IS
+OV
+BT
+MZ
+DM
+VZ
+JZ
+CP
+FY
+IP
+QW
+BD
+FW
+LR
+OY
+LO
+CW
+BM
+NY
+WY
+NQ
+DQ
+OW
+MQ
+GN
+RY
+FJ
+PV
+HI
+FH
+AM
+FG
+NP
+KU
+JP
+JT
+LM
+HP
+LN
+DY
+MX
+AS
+FM
+HR
+FQ
+PT
+UW
+AJ
+IU
+OT
+FN
+AD
+DZ
+IL
+XZ
+FO
+EY
+GU
+GY
+MW
+MT
+CY
+CK
+VW
+LU
+EI
+CH
+NO
+LQ
+GL
+AY
+DH
+EZ
+LX
+CX
+TX
+AL
+SY
+IW
+CE
+PU
+HL
+GGAIHCJQVGNWNYVTKUANBYKVVWKHPHRUPYORRPUFXNPNFJITASYISXCTBXBHLHHPCPEWLMLUDEUAUIF
+234
+LI
+XO
+PI
+AX
+EU
+SP
+BI
+WV
+PV
+WS
+AH
+KU
+NK
+JM
+UV
+YQ
+LT
+WD
+NV
+BD
+MZ
+OR
+MJ
+XE
+ZV
+PM
+PD
+IE
+XI
+UE
+GE
+BJ
+UG
+ST
+BS
+VL
+PF
+CG
+BQ
+GV
+EI
+WK
+SQ
+LH
+KH
+TO
+JE
+TN
+YA
+UN
+VK
+UK
+VP
+TQ
+GO
+HL
+SE
+VI
+BG
+LB
+KA
+YK
+UR
+JW
+DQ
+FU
+PU
+GQ
+SH
+NS
+RP
+LY
+VX
+OC
+UI
+UH
+RI
+NB
+UL
+DI
+VT
+TK
+IK
+TS
+XW
+IN
+WF
+QL
+PR
+MI
+RW
+LG
+HE
+TD
+UX
+RC
+WU
+BT
+YL
+AY
+MU
+XR
+MH
+PG
+CD
+XL
+SA
+RU
+BL
+PX
+OS
+MA
+XB
+XH
+AN
+KB
+AO
+JF
+OL
+HJ
+NA
+KN
+ZO
+VB
+KZ
+OT
+GL
+AS
+YR
+QP
+MO
+NE
+IP
+FI
+RO
+HB
+XC
+YT
+GS
+PL
+WC
+ZD
+EN
+DV
+FK
+FE
+BN
+IJ
+IY
+FO
+EA
+ZN
+WZ
+KQ
+AD
+ZM
+ZI
+FS
+YI
+DY
+AC
+YH
+HT
+YM
+HI
+OB
+SX
+XF
+RF
+HO
+LM
+XG
+TC
+ON
+PO
+CX
+IT
+PJ
+AU
+RG
+HD
+QS
+MK
+FJ
+MD
+WH
+RT
+GK
+BM
+KW
+ER
+FN
+QU
+MY
+JK
+AQ
+DJ
+CU
+KT
+NC
+SD
+RN
+YD
+OZ
+QE
+DZ
+QT
+RQ
+ZX
+QV
+LP
+BV
+CY
+SK
+YX
+SR
+GM
+WR
+WO
+HW
+QO
+NW
+JP
+JB
+FL
+PC
+IW
+EG
+UO
+LS
+IS
+PY
+EF
+MN
+FMYLOQNETTJSVVJBCSHYKTPWRZYQBTIPPZMLYSCVTTAHIKEHVXPWDOM
+128
+IR
+WK
+AW
+CL
+GH
+FJ
+UN
+WQ
+BD
+RW
+TP
+WN
+ZK
+AX
+CJ
+XL
+VM
+CS
+PR
+UR
+JF
+TF
+KC
+RH
+ZD
+ZO
+YS
+JD
+PW
+PK
+OR
+JN
+ER
+OB
+NR
+BX
+SZ
+TV
+MK
+RG
+LE
+JL
+VQ
+ME
+KB
+ZS
+KJ
+HJ
+NQ
+YF
+WJ
+VZ
+EN
+RP
+VF
+NE
+SP
+NX
+KH
+LJ
+HL
+XS
+UI
+EP
+ZR
+AS
+OP
+IC
+AF
+LN
+TE
+NU
+KX
+PD
+IO
+FY
+MN
+RJ
+PH
+YX
+KR
+ED
+QM
+DI
+QL
+QG
+VW
+BH
+VL
+AQ
+CB
+FG
+RD
+GV
+OS
+GB
+PU
+ZV
+EF
+MW
+YL
+TM
+PJ
+RZ
+CR
+XK
+IV
+YJ
+ES
+XV
+DS
+HF
+DN
+LI
+IU
+UY
+XH
+YU
+EL
+KM
+FZ
+XP
+OV
+FK
+FT
+UZ
+AT
+ZH
+IAZDJPGDBWOWNPTMFMSOOFWYHBAWQ
+182
+OM
+NK
+PD
+MR
+WI
+YM
+YH
+GQ
+JB
+PS
+ED
+AW
+YD
+DN
+WJ
+HR
+NF
+LC
+MZ
+WG
+XL
+LJ
+YS
+YZ
+IW
+ZM
+QB
+JH
+NR
+WY
+UO
+NA
+PW
+TK
+XK
+FW
+AP
+PU
+VS
+MS
+TF
+QZ
+JC
+BE
+FK
+EG
+LX
+RM
+RB
+JT
+PO
+OW
+EO
+OE
+XC
+NB
+LO
+KB
+NO
+CO
+UT
+MA
+BA
+KH
+PZ
+BW
+PN
+SP
+QL
+OY
+LM
+BJ
+VE
+QO
+FS
+FL
+OU
+YX
+DG
+OT
+VU
+UB
+DB
+RV
+PV
+EQ
+ZF
+JI
+DM
+XD
+HA
+AR
+BT
+MD
+EI
+AE
+SZ
+DU
+KL
+KR
+YQ
+LT
+HF
+EF
+XR
+TZ
+JG
+GI
+UL
+XI
+VM
+XZ
+TR
+WU
+MU
+KD
+XU
+IQ
+VP
+UN
+HL
+XG
+CQ
+HN
+CZ
+IX
+KE
+MP
+RA
+QF
+NT
+AV
+GR
+GM
+QW
+TY
+TE
+OQ
+QJ
+WC
+IS
+FO
+YB
+DA
+BI
+SM
+EA
+BG
+IN
+NQ
+PE
+JN
+HC
+ZS
+VI
+IH
+GO
+AN
+AX
+HP
+IA
+LG
+GK
+GZ
+IL
+ZR
+CJ
+HT
+LV
+VF
+KX
+RS
+NY
+QA
+ZH
+KN
+WV
+XW
+SI
+DE
+PB
+YA
+LPEHATOJCOZCHJWENYRQXBQLWLMCDAWLEAXKKYRYRUQQVUJKCMVFFOX
+280
+KW
+JR
+GX
+WZ
+CS
+IW
+QX
+TU
+GH
+JL
+AL
+FQ
+SY
+GQ
+FW
+IM
+FX
+EK
+HY
+PZ
+AE
+UY
+GN
+SZ
+KM
+BR
+HJ
+LQ
+XZ
+ER
+AC
+ST
+ES
+HO
+NU
+EU
+FP
+XY
+KS
+CP
+TZ
+RW
+HU
+BN
+AN
+PQ
+KT
+EN
+OU
+LM
+IN
+AT
+EH
+IU
+FV
+ET
+MO
+BP
+EX
+KP
+BL
+DP
+DT
+GO
+RZ
+BE
+CT
+BV
+JQ
+UW
+IL
+LZ
+HT
+JZ
+NP
+HN
+JX
+BM
+JM
+BU
+KV
+SX
+RS
+CH
+MQ
+CI
+MX
+DV
+QR
+AV
+DK
+MS
+KR
+HR
+FL
+AB
+IO
+OX
+EO
+PT
+CN
+NT
+DE
+OV
+TX
+CJ
+AW
+BY
+DW
+QU
+HX
+AQ
+YZ
+AD
+IK
+AG
+IJ
+SU
+BW
+CV
+CY
+IV
+CE
+DH
+HV
+NS
+RU
+LS
+HS
+MP
+AS
+KZ
+DO
+LY
+EL
+KN
+KU
+NW
+HK
+DF
+CO
+CU
+GS
+OQ
+GJ
+GW
+LV
+TY
+VY
+FI
+GT
+GR
+JV
+MU
+AY
+AF
+CL
+CZ
+DM
+PW
+RX
+EQ
+AP
+SW
+NX
+EM
+PX
+BQ
+BC
+AM
+LN
+VZ
+JT
+AK
+IT
+AI
+LX
+JO
+BO
+FY
+DI
+OW
+DX
+TV
+VX
+FU
+BX
+NR
+HW
+VW
+LO
+PR
+CF
+DJ
+BF
+RV
+FO
+OP
+HQ
+LT
+KO
+FG
+MW
+JN
+IY
+CQ
+PY
+EF
+QT
+PV
+FR
+IP
+BZ
+RT
+IX
+MV
+DR
+JK
+JY
+EP
+EV
+UX
+UV
+DU
+BJ
+GM
+KQ
+FH
+WY
+MT
+JW
+IQ
+QZ
+BI
+AU
+GL
+CG
+FM
+BD
+LU
+DN
+DY
+EI
+LR
+OS
+AX
+DQ
+GZ
+QV
+NO
+MN
+EY
+HI
+BH
+AH
+FT
+MY
+NY
+JU
+FZ
+GK
+IR
+HZ
+AR
+DS
+CX
+UZ
+GP
+WX
+KY
+BG
+GI
+TW
+KL
+AZ
+FK
+BS
+OZ
+GY
+CK
+SZSASTHPDPSNSAMCCKXHMKF
+231
+SX
+GJ
+DL
+YG
+WO
+GZ
+UQ
+MF
+MQ
+SO
+DV
+YX
+WI
+HI
+JZ
+ZJ
+XD
+GK
+TR
+LC
+HX
+ER
+LK
+SR
+DQ
+ZM
+BV
+VZ
+US
+QV
+KB
+LD
+FI
+TS
+JR
+UX
+WN
+EF
+OD
+RH
+LB
+KR
+BA
+SB
+UT
+QZ
+XG
+HK
+AF
+GE
+UL
+VY
+IO
+UG
+GL
+JU
+NM
+OI
+LG
+QP
+CD
+IB
+FQ
+NH
+BG
+OK
+NV
+YV
+BM
+HO
+WK
+PC
+ST
+BR
+BI
+VR
+KG
+NO
+NX
+ES
+MY
+ZH
+HS
+EW
+YR
+IL
+CB
+WJ
+FL
+NF
+EP
+PA
+ZL
+HP
+PH
+TD
+VS
+VB
+CX
+RP
+BF
+PF
+ZS
+XB
+FC
+YI
+GC
+FT
+RZ
+GT
+KN
+VQ
+XO
+GH
+NA
+WH
+MO
+HG
+QH
+QW
+XU
+BH
+XR
+PZ
+WL
+LN
+VC
+RX
+OR
+EB
+KU
+ET
+UD
+TL
+JK
+TO
+CR
+DT
+JC
+OP
+CQ
+OS
+WM
+ZX
+PE
+DY
+VE
+LQ
+OX
+JX
+TX
+HJ
+JT
+GA
+KT
+NI
+MD
+FA
+WG
+VO
+QC
+FS
+YZ
+PM
+VP
+RT
+LZ
+OW
+QS
+EJ
+BN
+SU
+NP
+MT
+WZ
+FE
+QY
+ZW
+MZ
+AU
+OY
+SQ
+CA
+IJ
+MP
+AK
+JO
+QM
+JF
+LE
+CF
+IF
+OF
+AL
+VT
+GS
+BY
+YO
+TK
+QG
+KA
+EQ
+RJ
+EM
+AN
+UP
+RO
+ZQ
+VD
+PO
+DH
+DR
+XC
+PR
+XQ
+CW
+PV
+HW
+NU
+ZO
+YT
+NZ
+HL
+JN
+MR
+RG
+ED
+YP
+RU
+XM
+VH
+PDJNSTZVPMSVOILLVNFYHBKOQDBTFZQMERMBGZOZIJBCI
+177
+NT
+YC
+XO
+UT
+YH
+OT
+ON
+RE
+WF
+JT
+OF
+VS
+QM
+RA
+EI
+EH
+AD
+NX
+LZ
+GX
+QY
+IW
+OX
+JR
+JL
+RQ
+BK
+SG
+DQ
+HC
+AO
+QS
+QA
+HO
+MW
+VK
+JN
+HL
+JD
+HA
+JE
+AE
+AH
+FR
+VJ
+CA
+AN
+IQ
+ZE
+GP
+MO
+PM
+OP
+IF
+GO
+GI
+OE
+FM
+YW
+DV
+UJ
+PW
+RU
+JC
+KI
+SH
+DY
+OZ
+SK
+VB
+WN
+KD
+UE
+XN
+EW
+BN
+LK
+WU
+VL
+PU
+KN
+FL
+XH
+XG
+ZS
+MY
+CG
+GK
+IS
+FD
+WM
+SP
+VX
+HS
+US
+TL
+GA
+JX
+EL
+MZ
+PV
+ZR
+KX
+XK
+XT
+HI
+DT
+IO
+PG
+HV
+NY
+UP
+DL
+RS
+EU
+YX
+MB
+VM
+ZT
+HM
+LQ
+BJ
+TJ
+FA
+RK
+ZY
+KM
+EG
+SV
+XF
+VR
+GW
+ZA
+RY
+KH
+DF
+UF
+UW
+PF
+KW
+BZ
+OB
+FS
+DK
+ZB
+NO
+FH
+YM
+SO
+TK
+DS
+MC
+FO
+PL
+YL
+WI
+FE
+PO
+YS
+FX
+DR
+RT
+QE
+WH
+WT
+RW
+JS
+MA
+AR
+IZ
+DZ
+VT
+YQ
+UH
+PI
+IP
+DM
+JYGPXSWTIJHUAKYHSUMBECDZWJOPOVNKHF
+59
+UR
+OE
+LC
+UY
+UD
+UO
+KU
+YO
+LJ
+KX
+OK
+FW
+YV
+LV
+WV
+UA
+XA
+CX
+BL
+SN
+FT
+TG
+GA
+VE
+ZN
+AT
+PI
+GE
+ND
+BV
+HC
+AP
+RS
+XT
+PH
+AE
+WD
+PZ
+VM
+HL
+CH
+SW
+FA
+WZ
+PN
+QD
+FR
+LT
+ZQ
+EJ
+BF
+CN
+JB
+WA
+UC
+GC
+ET
+AJ
+HM

2021/quals/consistency_ch2.md

@@ -0,0 +1,44 @@
+**Note: This problem shares similarities with [Chapter 1](https://www.facebook.com/codingcompetitions/hacker-cup/2021/qualification-round/problems/A1). The solution to either chapter may help with solving the other, so please consider reading both first.**
+
+Connie received a string \(S\) for her birthday, consisting entirely of uppercase letters (each between `"A"` and `"Z"`, inclusive).
+
+However, Connie really only likes nice, *consistent* strings. She considers a string to be consistent if and only if all of its letters are the same.
+
+Each second, Connie may choose one letter in \(S\) and replace it with a different letter. **There are \(K\) different types of replacements she may make, with the \(i\)th one involving choosing letter \(A_i\) anywhere in \(S\) and replacing it with letter \(B_i\).** No type of replacement (ordered pair of \(A_i\) and \(B_i\)) is given twice. There is no limit on how many times she may end up using each type of replacement. If a letter appears multiple times in \(S\), she may only replace a single occurrence per second.
+
+Help her determine the minimum number of seconds required to change \(S\) into any consistent string, if possible. If it's impossible to ever do so, output \(-1\) instead. Note that \(S\) might already be consistent, in which case \(0\) seconds would be required.
+
+# Constraints
+
+\(1 \le T \le 40\)
+\(1 \le |S| \le 100\)
+\(0 \le K \le 300 \)
+`"A"` \(\le S_i, A_i, B_i \le\) `"Z"`
+\(A_i \ne B_i\)
+
+The sum of \(|S|\) across all test cases is at most \(4{,}000\).
+
+
+
+
+# Input
+
+Input begins with an integer \(T\), the number of birthdays Connie has had. For each birthday, there is one line containing the string \(S\), then another line containing the integer \(K\), then \(K\) more lines, the \(i\)th of which contains the two characters \(A_i\) and \(B_i\).
+
+
+# Output
+
+For the \(i\)th string, print a line containing *"Case #i: "* followed by the minimum number of seconds required to change \(S\) into any consistent string, or \(-1\) if it's impossible to do so.
+
+
+# Sample Explanation
+
+In the first case, Connie could replace the second and third letters (`"B"` and `"C"`) each with `"A"`, yielding the string `"AAA"` in \(2\) seconds.
+
+In the second case, Connie cannot apply either available type of replacement to `"ABC"`, meaning that she cannot change it into a consistent string.
+
+In the third case, `"F"` is already consistent.
+
+In the fourth case, Connie could replace the first, third, and fifth letters (`"B"`, `"N"`, and `"N"`) each with `"A"`, yielding the string `"AAAAAA"` in \(3\) seconds.
+
+In the sixth case, Connie could change "`FOXEN"` into the string `"WWWWW"` in \(8\) seconds. Note that she may apply a sequence of multiple replacements to any of the letters in \(S\).

2021/quals/consistency_ch2.out

@@ -0,0 +1,51 @@
+Case #1: 2
+Case #2: -1
+Case #3: 0
+Case #4: 3
+Case #5: -1
+Case #6: 8
+Case #7: 100
+Case #8: 5
+Case #9: 108
+Case #10: -1
+Case #11: 103
+Case #12: 111
+Case #13: -1
+Case #14: 2475
+Case #15: -1
+Case #16: 59
+Case #17: 61
+Case #18: -1
+Case #19: 138
+Case #20: -1
+Case #21: 91
+Case #22: -1
+Case #23: 29
+Case #24: -1
+Case #25: 122
+Case #26: 120
+Case #27: 112
+Case #28: 41
+Case #29: 53
+Case #30: 104
+Case #31: -1
+Case #32: 78
+Case #33: 88
+Case #34: 99
+Case #35: -1
+Case #36: -1
+Case #37: 98
+Case #38: 64
+Case #39: 26
+Case #40: -1
+Case #41: -1
+Case #42: -1
+Case #43: -1
+Case #44: -1
+Case #45: 105
+Case #46: 86
+Case #47: 37
+Case #48: 61
+Case #49: 30
+Case #50: 66
+Case #51: -1

2021/quals/consistency_ch2_sol.md

@@ -0,0 +1,7 @@
+As in Chapter 1, we'll consider each possible character \(x\) (`"A"` \(\le x \le\) `"Z"`) such that all characters in \(S\) are to be changed into \(x\). The only difference is in computing the minimum number of seconds it takes to change some character \(c\) into another character \(x\) (if it's possible at all).
+
+If we imagine an unweighted graph with \(26\) nodes (one for each letter from `"A"` to `"Z"`), such that there's a directed edge from node \(A_i\) to node \(B_i\) for each type of replacement \(i\), then the minimum number of seconds required to change \(c\) into \(x\) is equal to the shortest length of any path from node \(c\) to node \(x\) (if any such path exists). 
+
+We can precompute a \(26*26\) table of these shortest distances between all pairs of nodes by using the [Floyd–Warshall algorithm](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm) or by performing a [BFS (breadth-first search)](https://en.wikipedia.org/wiki/Breadth-first_search) from each possible starting node, taking care to mark unreachable pairs of nodes as effectively having an infinite distance and being unusable in the final answer. For each character \(x\) and for each character \(c\) in \(S\), we can then look up the shortest distance from node \(c\) to node \(x\) in the table.
+
+[See David Harmeyer's solution video here](https://youtu.be/p5yPTHNUTlc).

2021/quals/gold_mine_ch1.cpp

@@ -0,0 +1,56 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+using namespace std;
+
+const int LIM = 52;
+
+int N, C[LIM];
+vector<int> adj[LIM];
+
+// Maximum path sum from i down to any leaf.
+int rec(int i, int parent) {
+  int m = 0;
+  for (int j : adj[i]) {
+    if (j != parent) {
+      m = max(m, rec(j, i));
+    }
+  }
+  return C[i] + m;
+}
+
+int solve() {
+  cin >> N;
+  for (int i = 0; i < N; i++) {
+    cin >> C[i];
+    adj[i].clear();
+  }
+  for (int i = 0; i < N - 1; i++) {
+    int a, b;
+    cin >> a >> b;
+    a--, b--;
+    adj[a].push_back(b);
+    adj[b].push_back(a);
+  }
+  // Find up to 2 best children of root.
+  int m1 = 0, m2 = 0;
+  for (auto c : adj[0]) {
+    int v = rec(c, 0);
+    if (v > m1) {
+      m2 = m1;
+      m1 = v;
+    } else {
+      m2 = max(m2, v);
+    }
+  }
+  return C[0] + m1 + m2;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2021/quals/gold_mine_ch1.in

@@ -0,0 +1,956 @@
+56
+2
+10 20
+1 2
+4
+1 1 1 1
+2 1
+4 2
+1 3
+4
+1 1 1 1
+2 1
+4 1
+1 3
+6
+5 4 1 3 2 4
+5 1
+5 4
+5 3
+5 2
+6 3
+9
+2 14 7 6 11 3 6 1 8
+4 5
+6 7
+8 9
+1 3
+6 8
+2 4
+4 1
+1 8
+1
+0
+1
+20000000
+50
+10781795 9557808 1853831 8423199 13742134 9391909 16578911 1493660 4495014 12643630 8281227 14100842 1245098 18524652 2988334 14561137 16666695 9299012 15862790 17721246 9922966 1225383 17847177 6262771 19901037 14907244 6631578 6927800 19177901 7008600 13196264 2973903 11068968 12618816 15130596 6490405 2343468 14699973 6213468 13011780 16035761 18356031 18155449 12593158 1363995 12257973 1752529 16612197 17458347 15297287
+1 33
+7 33
+29 7
+15 29
+44 15
+44 12
+45 12
+45 42
+42 37
+37 20
+20 40
+26 40
+26 19
+19 24
+24 13
+13 6
+38 6
+38 49
+18 49
+18 36
+36 50
+27 50
+8 27
+3 8
+3 5
+16 5
+31 16
+2 31
+48 2
+48 25
+25 22
+22 43
+4 43
+3 14
+14 10
+10 23
+23 47
+47 21
+21 34
+30 34
+32 30
+46 32
+41 46
+41 39
+39 17
+35 17
+11 35
+9 11
+28 9
+49
+17302004 10273548 5740500 17973923 13685251 15645774 622007 1492681 4327318 3323822 14848368 13996716 15111113 7731583 5968618 4352086 11385157 4010472 15722800 13378328 14902259 15121331 2892404 8049510 13094347 14804404 4593452 2330703 19144650 14047444 4521047 7793047 15549186 16288441 2108382 2618482 396235 15495700 10244373 11687135 4683031 15349894 17699168 10705055 8220388 12126767 17928434 11570898 3110858
+40 1
+22 40
+22 5
+18 5
+18 21
+21 12
+12 14
+14 32
+34 32
+20 1
+15 20
+15 31
+13 31
+13 24
+30 24
+45 30
+45 3
+7 3
+41 7
+9 1
+4 9
+4 23
+23 49
+19 49
+19 44
+16 44
+27 16
+28 27
+28 37
+1 17
+17 2
+6 2
+6 38
+47 38
+25 47
+11 25
+11 46
+46 48
+42 48
+1 39
+39 35
+43 35
+29 43
+29 8
+8 36
+10 36
+10 33
+33 26
+48
+19468394 11245085 96422 2258067 19303323 8694050 17794081 8162102 18142289 5914229 15522922 10467206 1482294 14252202 5651542 1702350 11149417 15283645 11245775 14478157 9029416 15182710 7217297 4789867 15226391 19566312 8644990 17618951 8105007 16907283 17782431 3762411 10795846 18161833 4452792 3566945 18590774 12366830 17579655 7050719 9915565 13715896 10665880 2962653 5977489 9893270 5673672 5937608
+40 1
+1 43
+13 40
+40 31
+43 2
+43 5
+35 13
+15 13
+31 26
+20 31
+2 7
+2 29
+5 33
+17 5
+9 35
+35 4
+15 22
+16 15
+26 37
+38 26
+19 20
+23 20
+3 7
+18 7
+29 47
+29 24
+33 12
+39 33
+17 6
+17 27
+10 9
+9 48
+25 4
+4 11
+42 22
+28 22
+16 32
+30 16
+37 44
+14 37
+21 38
+46 38
+34 19
+19 8
+23 45
+23 36
+41 3
+19
+53 908 148 709 390 629 17 695 434 219 503 759 839 251 436 723 566 625 584
+6 1
+1 3
+3 4
+6 15
+4 18
+4 5
+5 14
+14 8
+2 8
+10 2
+8 9
+16 2
+13 16
+16 7
+9 17
+11 7
+12 13
+19 12
+50
+18912310 18898464 9703986 18912689 2009993 4434239 9954547 19121924 2609372 18973224 14435844 13483385 3626463 2358310 660000 5989543 4964520 11365947 11345297 17094483 7809461 10905240 5814466 9676595 3331964 2183977 10303843 4902860 3732401 4909127 16038707 15024764 16354836 11631505 11285869 7612564 6859251 9943765 18178513 6007965 19332675 5418023 11461709 11572412 14616407 8894484 4313416 8458288 7368507 10417137
+1 8
+23 8
+35 23
+35 16
+34 16
+29 34
+29 48
+48 15
+15 4
+4 43
+43 11
+11 39
+39 32
+50 32
+50 26
+26 17
+17 25
+25 38
+33 38
+33 20
+20 44
+5 44
+12 5
+12 46
+46 18
+18 37
+40 37
+14 40
+14 45
+45 47
+47 27
+10 27
+30 10
+30 9
+31 9
+31 19
+42 19
+7 42
+49 7
+49 36
+36 22
+3 22
+41 3
+6 41
+2 6
+2 24
+21 24
+13 21
+13 28
+50
+18722046 12710434 16020009 4888908 14836429 6218620 11504022 6626860 9294133 8048471 3189363 4648600 4622144 2470903 1984131 8809675 7697925 18471764 11138701 11257526 14865598 19460650 7447560 5368676 2059911 19869997 8209250 13119358 10952374 1918042 12594669 8057835 9985489 6766697 6026342 13136271 4568624 12938079 1685284 12127285 18825520 14743872 19963610 9009543 4560145 12243425 14921993 3056186 18857581 11345370
+46 1
+46 38
+45 38
+27 45
+47 27
+47 40
+40 23
+50 23
+50 26
+3 26
+3 10
+49 10
+13 49
+13 33
+33 8
+41 8
+41 25
+17 25
+17 24
+28 24
+36 28
+36 14
+20 14
+20 43
+21 43
+6 1
+35 6
+35 42
+42 11
+11 18
+2 18
+19 2
+19 9
+32 9
+30 32
+30 44
+44 4
+4 5
+5 31
+22 31
+22 15
+15 34
+48 34
+48 12
+39 12
+16 39
+37 16
+37 7
+29 7
+50
+13859433 18628942 7347267 4813943 16978714 15303963 6580609 7087898 1282597 17231025 12811294 9673049 3538611 18865997 15180831 13520772 8715179 14281497 2489079 16929588 10106875 6867369 2611428 11334811 9897608 11174561 5757160 7529719 11068080 4630901 10974819 17483809 14382456 7754057 8912970 4341058 1061719 7392247 13464838 14706852 539294 1847086 15492075 19938470 8518530 10316215 12941651 13247946 6510792 19914451
+1 37
+18 37
+14 18
+14 23
+34 23
+34 35
+48 35
+43 48
+43 7
+39 7
+12 39
+49 12
+49 13
+11 13
+11 16
+16 27
+22 27
+17 22
+25 17
+40 25
+50 40
+50 24
+24 3
+3 4
+8 4
+8 41
+33 41
+33 6
+6 31
+10 31
+15 10
+2 15
+5 2
+30 4
+30 29
+29 28
+38 28
+38 19
+45 19
+44 45
+26 44
+20 26
+20 42
+47 42
+46 47
+21 46
+36 21
+36 32
+9 32
+50
+1059625 7399861 4160424 8188362 17502519 13530183 3225904 2167562 7695292 6667986 1369655 272121 18991240 4580900 6451404 17036126 9630706 1191067 14628869 18615863 11287266 4569815 3646051 617070 10649864 5791744 2384211 2057530 4568367 3469488 6736337 2670613 13142188 15840383 16961319 11253589 5117424 6674474 348116 1690218 13320765 11690591 254343 17334707 9879670 18598952 15285578 12291069 9084174 12436465
+1 47
+47 24
+15 24
+48 15
+27 48
+27 16
+16 22
+22 4
+4 43
+43 45
+45 44
+20 44
+20 21
+21 10
+10 19
+19 8
+1 11
+33 11
+33 36
+5 36
+5 23
+23 40
+18 40
+29 18
+38 29
+12 38
+12 17
+2 17
+37 2
+37 13
+13 46
+31 46
+31 9
+50 1
+7 50
+7 35
+32 35
+32 41
+39 41
+6 39
+6 28
+14 28
+14 30
+26 30
+26 34
+42 34
+3 42
+25 3
+25 49
+50
+15348007 15930520 7862316 8776851 7767735 2058353 13822633 8327546 15305367 1051015 13144842 11788841 1356503 16948905 7467273 14305319 14345609 18738710 5040710 10238368 18185530 18735728 11323225 17420201 9164812 6084560 3900278 1684386 15231345 8205555 19500476 14225333 10566022 10026385 19187482 2185594 10017545 2812622 1856478 19705789 8295929 4546762 9436380 258647 11279049 8832083 18064695 14269496 15520576 6156730
+6 1
+25 6
+43 25
+19 43
+19 5
+5 49
+12 49
+15 12
+26 15
+47 1
+8 47
+14 8
+14 41
+40 41
+7 40
+7 23
+23 37
+37 17
+17 27
+45 1
+45 30
+28 30
+28 50
+50 42
+39 42
+33 39
+18 33
+4 18
+4 46
+1 36
+36 29
+29 34
+34 22
+21 22
+20 21
+20 2
+35 2
+35 3
+48 3
+1 10
+10 11
+31 11
+31 13
+13 9
+24 9
+44 24
+44 16
+16 32
+32 38
+50
+11886753 14396775 13790329 16324347 18497188 11945684 7004094 13185557 11553720 8824602 5705261 4810797 16291852 11701920 17863995 12390470 14961622 16542723 16380400 5753246 15447735 19992783 2236447 18811132 14750269 18578906 12849328 19840925 725634 15855933 11960601 2553781 3274993 15990512 11631083 5908132 10679849 2074625 11425928 14075574 5485305 475761 14396659 10192279 18475915 2545579 15898304 4097874 2395806 14762401
+1 6
+1 46
+6 2
+29 6
+46 47
+23 46
+2 3
+27 2
+10 29
+29 30
+47 32
+47 18
+39 23
+23 37
+3 17
+3 11
+27 26
+4 27
+33 10
+28 10
+30 36
+30 7
+32 16
+34 32
+18 50
+18 44
+5 39
+39 41
+37 35
+24 37
+17 9
+48 17
+11 40
+11 25
+26 8
+26 12
+4 13
+4 43
+14 33
+33 49
+28 15
+19 28
+36 21
+36 38
+7 42
+31 7
+20 16
+22 16
+45 34
+50
+8080772 15272279 16956387 9264291 13249675 16538490 747726 5595331 15422402 9728532 4109565 2617489 1581766 10252507 8366478 19972632 8915273 3209563 153782 6596774 14507637 16038678 13127217 10536120 4122362 11944133 5982819 18209556 4304310 16038589 2615568 3414774 10539776 9153389 17082805 13191010 8510609 5599236 18926721 1607576 12365328 20271 19898611 17742502 15914297 16537088 1432337 12400663 8207273 12180714
+1 47
+43 1
+3 1
+1 17
+1 26
+5 1
+1 36
+37 1
+21 1
+1 33
+1 16
+35 1
+29 1
+1 30
+1 39
+1 28
+46 1
+27 1
+18 1
+7 1
+50 1
+1 2
+20 1
+49 1
+1 11
+1 22
+4 1
+1 8
+1 14
+1 41
+1 40
+1 44
+1 19
+32 1
+1 15
+45 1
+31 1
+1 38
+1 23
+25 1
+1 12
+42 1
+13 1
+48 1
+1 24
+1 34
+9 1
+10 1
+6 1
+50
+3207047 8503498 17230684 400553 10550055 4615982 3755920 10392641 5838806 702516 12415512 16704449 16696162 900946 3850500 18625414 641526 8254892 16079374 14993250 13703938 15492942 7302736 16172137 9770551 13933574 1461014 13568857 13554094 3541980 4689102 1642403 4852264 19211312 5094684 19954714 8374384 8326254 13540362 379959 1728989 8379247 10896477 8095751 6752500 16562287 16880642 2105777 12860970 10614439
+35 1
+1 16
+18 16
+7 18
+25 18
+25 3
+3 26
+26 30
+6 30
+42 6
+44 42
+13 42
+17 44
+13 36
+12 36
+22 12
+20 12
+4 22
+4 34
+34 10
+29 34
+21 10
+15 21
+15 8
+46 8
+8 19
+40 46
+5 19
+40 31
+23 31
+14 23
+33 23
+24 33
+43 24
+48 24
+45 48
+45 49
+49 39
+49 50
+27 39
+2 27
+2 38
+2 32
+38 28
+28 47
+47 9
+41 9
+9 11
+37 41
+11
+506 696 439 932 126 77 596 953 635 750 476
+6 1
+3 1
+6 8
+11 6
+2 8
+8 5
+11 4
+9 2
+7 9
+10 9
+14
+529 916 700 489 652 598 253 40 981 950 658 271 372 25
+1 13
+13 12
+1 5
+12 11
+13 3
+4 13
+3 8
+9 12
+11 7
+14 3
+11 10
+6 8
+2 11
+9
+640 190 883 390 249 293 50 28 181
+2 1
+5 2
+3 5
+4 3
+8 4
+7 8
+7 6
+9 6
+10
+972 146 694 61 605 692 109 104 374 199
+1 5
+10 5
+10 2
+2 3
+3 7
+7 9
+8 9
+8 6
+4 6
+10
+780 301 621 12 911 224 109 144 232 811
+2 1
+1 10
+10 8
+9 10
+9 4
+4 6
+5 8
+4 3
+7 6
+11
+362 497 398 159 99 522 67 94 112 176 166
+2 1
+1 3
+3 10
+3 6
+9 1
+2 5
+5 8
+7 8
+11 2
+2 4
+12
+71 393 381 505 160 957 793 905 720 443 912 55
+8 1
+1 6
+4 8
+10 6
+7 6
+7 5
+10 11
+5 3
+3 12
+3 2
+2 9
+7
+271 700 622 314 774 954 374
+5 1
+7 1
+7 4
+1 2
+6 5
+2 3
+8
+635 846 256 438 511 374 480 182
+1 8
+4 1
+8 5
+5 7
+2 5
+7 3
+6 7
+4
+717 848 767 290
+3 1
+2 1
+1 4
+14
+717 926 430 917 235 131 547 205 69 433 526 629 2 411
+1 4
+1 9
+9 6
+6 14
+9 8
+11 14
+8 5
+5 2
+4 13
+10 5
+14 7
+12 14
+10 3
+7
+240 680 69 238 365 424 727
+4 1
+7 1
+3 4
+1 2
+3 5
+6 7
+4
+724 352 867 399
+1 2
+4 1
+3 2
+15
+920 874 869 256 565 750 247 622 2 852 151 208 67 662 65
+1 8
+1 4
+7 1
+12 8
+11 12
+15 12
+14 4
+2 14
+5 7
+6 8
+13 14
+14 9
+10 12
+3 7
+5
+732 218 246 356 475
+4 1
+4 2
+2 5
+5 3
+10
+518 303 729 430 405 209 136 632 882 161
+1 2
+3 1
+9 2
+6 2
+5 9
+9 7
+10 7
+4 5
+8 10
+6
+6 130 306 143 365 524
+1 2
+3 1
+2 5
+2 4
+6 4
+10
+957 679 994 834 959 868 379 444 709 451
+5 1
+6 1
+9 5
+9 2
+5 3
+1 7
+10 1
+4 2
+6 8
+9
+873 911 850 505 731 92 0 917 185
+7 1
+5 1
+7 3
+3 4
+5 2
+8 4
+2 9
+9 6
+11
+836 849 330 879 721 15 953 26 168 552 209
+6 1
+1 5
+8 5
+2 5
+7 2
+2 9
+8 10
+11 8
+3 1
+10 4
+7
+798 64 888 566 249 246 94
+1 7
+1 6
+6 3
+3 2
+6 5
+5 4
+8
+25 673 12 948 616 712 691 775
+1 6
+1 3
+7 3
+6 2
+5 2
+8 2
+4 2
+9
+396 829 598 685 793 397 944 25 190
+1 8
+4 1
+5 8
+6 4
+7 8
+2 1
+7 9
+6 3
+7
+444 584 100 717 804 491 731
+1 7
+1 6
+6 3
+5 6
+3 2
+3 4
+10
+28 560 811 351 755 636 869 300 186 642
+5 1
+1 9
+10 9
+5 7
+3 10
+2 7
+4 7
+8 2
+6 7
+14
+100 595 973 106 110 265 834 208 840 54 817 305 832 522
+6 1
+13 1
+8 13
+5 1
+14 5
+4 13
+7 8
+12 6
+11 13
+10 7
+9 5
+7 3
+2 10
+3
+761 421 546
+2 1
+3 2
+3
+847 236 563
+1 2
+3 1
+7
+535 70 182 504 689 485 731
+1 7
+1 5
+7 2
+6 5
+5 4
+7 3
+5
+593 392 426 79 532
+3 1
+4 3
+5 4
+5 2
+6
+120 272 703 997 592 407
+4 1
+1 5
+6 5
+6 2
+3 2
+4
+729 897 271 687
+1 4
+1 2
+3 1
+3
+742 235 854
+1 2
+3 1
+9
+576 860 132 449 971 236 91 763 481
+7 1
+4 1
+8 4
+1 9
+5 9
+3 9
+7 2
+2 6
+12
+500 151 201 711 664 719 708 380 597 329 668 789
+1 11
+4 11
+3 4
+2 3
+2 5
+12 5
+12 6
+8 6
+9 8
+10 9
+7 10
+5
+148 720 790 669 396
+3 1
+4 1
+4 5
+3 2
+7
+394 979 854 329 446 51 349
+7 1
+4 1
+7 2
+4 5
+6 7
+5 3

2021/quals/gold_mine_ch1.md

@@ -0,0 +1,57 @@
+**Note: This problem shares similarities with [Chapter 2](https://www.facebook.com/codingcompetitions/hacker-cup/2021/qualification-round/problems/C2). The solution to either chapter may help with solving the other, so please consider reading both first.**
+
+Just like [logging](https://www.youtube.com/watch?v=7AheBqBk0iQ), mining is a key industry in Canada's primary sector. Prospectors use geological tools to find ore deposits, then [drill, and blast](https://www.youtube.com/watch?v=zPbY--IXGg8&t=463s) to excavate a system of underground tunnels for access to the ores.
+
+Minerva is a contract miner who spends her days extracting gold ore from underground mines across Ontario. One particular gold mine she's contracting for consists of \(N\) underground caves, numbered from \(1\) to \(N\), with cave \(1\) having an exit to the surface. There are also \(N - 1\) tunnels running among the caves, the \(i\)th of which allows one to travel in either direction between caves \(A_i\) and \(B_i\). Each cave is reachable from cave \(1\) by a sequence of these tunnels.
+
+Cave \(i\) is known to contain \(C_i\) ounces of gold ore. With her trusty dump truck, Minerva plans to drive underground starting in cave \(1\), collect as much gold ore as possible, and exit back to the surface through cave \(1\).
+
+There's just one issue: the tunnels are highly unstable, and will cave in after Minerva drives through them. Therefore, she is only able to traverse each tunnel at most once. Fortunately, the caves themselves are reinforced with pillars and will never collapse — she may visit each cave any number of times (though she can only collect its gold ore at most once).
+
+This safety measure may limit mobility. Thankfully, Minerva's truck is also equipped to be a drill rig. As she travels through the system of caves, she may at any point use it to travel from her current cave to *any* other cave by drilling a new tunnel. **In this chapter, the rig only has the energy to drill at most one such tunnel.** Unfortunately, this new tunnel will be just as unstable as the existing ones — Minerva will only dare travel through it once.
+
+Please help Minerva determine the maximum weight of gold ore that can be collected if she begins in cave \(1\), spends any amount of time exploring the mine (traveling through tunnels, drilling at most one new tunnel, and collecting ore from any visited caves), and end up once again in cave \(1\).
+
+
+# Constraints
+
+\(1 \le T \le 35\)
+\(1 \le N \le 50\)
+\(0 \le C_i \le 20{,}000{,}000\)
+\(1 \le A_i, B_i \le N\)
+
+The sum of \(N\) across all mines is at most \(1{,}000\).
+
+
+# Input
+
+Input begins with an integer \(T\), the number of mines that Minerva is contracted to work. For each mine, there is first a line containing the single integer \(N\). Then, there is a second line containing \(N\) space-separated integers, \(C_{1..N}\). Then, \(N - 1\) lines follow, the \(i\)th of which contains the space-separated integers \(A_i\) and \(B_i\).
+
+
+# Output
+
+For the \(i\)th mine, output a line containing *"Case #i: "* followed by a single integer, the maximum weight of gold ore (in ounces) that Minerva can collect before leaving the mine.
+
+
+
+# Sample Explanation
+
+The first mine looks as follows:
+
+{{PHOTO_ID:328916612261658}}
+
+It's possible to visit both caves (collecting \(30\) ounces of ore) and then return to cave \(1\), for example by taking the tunnel from cave \(1\) to cave \(2\) and then drilling a tunnel back to cave \(1\).
+
+
+The second mine looks as follows:
+
+{{PHOTO_ID:271244381102893}}
+
+It's possible to end up with the ore from all \(4\) caves, for example by taking the tunnel to cave \(3\), drilling to cave \(4\), and then taking tunnels to cave \(2\) followed by cave \(1\).
+
+
+The third mine looks as follows:
+
+{{PHOTO_ID:160428912890161}}
+
+It's possible to end up with \(3\) ounces of ore, but Minerva cannot collect all \(4\) ounces while still returning to cave \(1\) and only drilling one tunnel.

2021/quals/gold_mine_ch1.out

@@ -0,0 +1,56 @@
+Case #1: 30
+Case #2: 4
+Case #3: 3
+Case #4: 12
+Case #5: 32
+Case #6: 0
+Case #7: 20000000
+Case #8: 430281141
+Case #9: 260237126
+Case #10: 155055536
+Case #11: 7124
+Case #12: 493215271
+Case #13: 501845900
+Case #14: 399532193
+Case #15: 284199587
+Case #16: 271952925
+Case #17: 139158830
+Case #18: 47952015
+Case #19: 361976459
+Case #20: 4056
+Case #21: 3432
+Case #22: 2904
+Case #23: 3956
+Case #24: 2947
+Case #25: 2039
+Case #26: 4885
+Case #27: 3321
+Case #28: 2620
+Case #29: 2332
+Case #30: 3071
+Case #31: 2071
+Case #32: 2342
+Case #33: 4394
+Case #34: 2027
+Case #35: 3361
+Case #36: 1109
+Case #37: 5450
+Case #38: 5064
+Case #39: 3689
+Case #40: 2090
+Case #41: 3061
+Case #42: 3235
+Case #43: 2483
+Case #44: 4151
+Case #45: 3897
+Case #46: 1728
+Case #47: 1646
+Case #48: 2641
+Case #49: 2022
+Case #50: 3091
+Case #51: 2313
+Case #52: 1831
+Case #53: 3240
+Case #54: 6417
+Case #55: 2723
+Case #56: 3351