2023 Problems

.gitattributes

@@ -98,3 +98,17 @@ saved_model/**/* 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
+2023/finals/nearly_nim.in filter=lfs diff=lfs merge=lfs -text
+2023/finals/resisting_robots.in filter=lfs diff=lfs merge=lfs -text
+2023/finals/transposing_tiles.in filter=lfs diff=lfs merge=lfs -text
+2023/practice/road_to_nutella.in filter=lfs diff=lfs merge=lfs -text
+2023/round1/back_in_black_ch1.in filter=lfs diff=lfs merge=lfs -text
+2023/round1/back_in_black_ch2.in filter=lfs diff=lfs merge=lfs -text
+2023/round1/bohemian_rap-sody.in filter=lfs diff=lfs merge=lfs -text
+2023/round1/today_is_gonna_be_a_great_day.in filter=lfs diff=lfs merge=lfs -text
+2023/round2/meta_game.in filter=lfs diff=lfs merge=lfs -text
+2023/round2/ready_go_part_2.in filter=lfs diff=lfs merge=lfs -text
+2023/round2/tower_rush.in filter=lfs diff=lfs merge=lfs -text
+2023/round2/wiki_race.in filter=lfs diff=lfs merge=lfs -text
+2023/round3/double_stars.in filter=lfs diff=lfs merge=lfs -text
+2023/round3/similar_ships.in filter=lfs diff=lfs merge=lfs -text

2023/finals/cacti_cartography.cpp

@@ -0,0 +1,264 @@
+#include <algorithm>
+#include <cstring>
+#include <iostream>
+#include <map>
+#include <vector>
+using namespace std;
+
+typedef long long int64;
+
+const int64 kInf = 12345678912345LL;
+const int64 MAXK = 50, KLIM = (MAXK + 1) << 1, NLIM = 1000;
+
+int N, M, K;
+vector<int> weights;
+vector<vector<int>> adj;
+int64 f[2][KLIM][KLIM][NLIM];
+int timer;
+vector<int> tin, tout, par;
+vector<int> cycle_ids, cycle_lens, cycle_rev, dist_to_par;
+vector<vector<int>> edge_lnks;
+vector<pair<int, int>> dp_edges;
+
+void dfs(int x) {
+  tin[x] = timer++;
+  for (int y : adj[x]) {
+    if (tin[y] != -1) {
+      continue;
+    }
+    dfs(y);
+  }
+  tout[x] = timer++;
+}
+
+int cycle_counter;
+vector<int> dfs_stack;
+
+void dfs_cycles(int x, int p) {
+  tin[x] = timer++;
+  dfs_stack.push_back(x);
+  for (int y : adj[x]) {
+    if (y == p) {
+      continue;
+    }
+    if (y == par[x]) {
+      int cur_len = 1;
+      int rev_cycle = -1;
+      for (int z = (int)dfs_stack.size() - 1; dfs_stack[z] != par[x]; z--) {
+        int edge_id = edge_lnks[dfs_stack[z - 1]][dfs_stack[z]];
+        int rev_edge_id = edge_lnks[dfs_stack[z]][dfs_stack[z - 1]];
+        if (rev_edge_id != -1 && cycle_ids[rev_edge_id] != -1) {
+          rev_cycle = cycle_ids[rev_edge_id];
+          cycle_rev[rev_cycle] = cycle_counter;
+        }
+        cycle_ids[edge_id] = cycle_counter;
+        dist_to_par[edge_id] = cur_len++;
+      }
+      cycle_lens.push_back(cur_len);
+      cycle_rev.push_back(rev_cycle);
+      cycle_counter++;
+    } else {
+      if (tin[y] != -1) {
+        continue;
+      }
+      if (edge_lnks[x][y] == -1) {
+        edge_lnks[x][y] = dp_edges.size();
+        dp_edges.emplace_back(x, y);
+        cycle_ids.push_back(-1);
+        dist_to_par.push_back(-1);
+      }
+      dfs_cycles(y, x);
+    }
+  }
+  dfs_stack.pop_back();
+}
+
+int lazy_max_dist;
+
+int64 lazy_dp(int edge_id, int dist_to_last, int par_dist, int promised) {
+  if (dist_to_last > K + 1) {
+    promised = 1;
+  }
+  if (f[promised][dist_to_last][par_dist][edge_id] != -1LL) {
+    return f[promised][dist_to_last][par_dist][edge_id];
+  }
+  const int base_cycle_id = cycle_ids[edge_id];
+  if (!dist_to_last && base_cycle_id != -1 &&
+      cycle_lens[base_cycle_id] - dist_to_par[edge_id] < par_dist) {
+    return f[promised][dist_to_last][par_dist][edge_id] = lazy_dp(
+               edge_id, dist_to_last,
+               cycle_lens[base_cycle_id] - dist_to_par[edge_id], promised);
+  }
+  if (!promised && base_cycle_id != -1 &&
+      dist_to_par[edge_id] + par_dist < dist_to_last) {
+    return f[promised][dist_to_last][par_dist][edge_id] = lazy_dp(
+               edge_id, dist_to_par[edge_id] + par_dist, par_dist, promised);
+  }
+  const int x = dp_edges[edge_id].second;
+  int64 res = kInf;
+  if (dist_to_last) {
+    res = min(res, lazy_dp(edge_id, 0, par_dist, 0) + weights[x]);
+  }
+  if (dist_to_last == lazy_max_dist) {
+    return f[promised][dist_to_last][par_dist][edge_id] = res;
+  }
+  const int p = dp_edges[edge_id].first;
+  vector<int> edge_list;
+  vector<pair<int, int>> edge_groups;
+  map<int, int> cycle_to_ind;
+  for (int y : adj[x]) {
+    if (y == p) {
+      continue;
+    }
+    int new_edge_id = edge_lnks[x][y];
+    if (new_edge_id == -1) {
+      continue;
+    }
+    int cycle_id = cycle_ids[new_edge_id];
+    if (cycle_id != -1) {
+      auto mit = cycle_to_ind.find(cycle_id);
+      if (mit != cycle_to_ind.end()) {
+        edge_groups[mit->second].second = edge_list.size();
+        edge_list.push_back(new_edge_id);
+        continue;
+      }
+    }
+    int rev_cycle_id = (cycle_id == -1 ? -1 : cycle_rev[cycle_id]);
+    cycle_to_ind[rev_cycle_id] = edge_groups.size();
+    edge_groups.emplace_back(edge_list.size(), -1);
+    edge_list.push_back(new_edge_id);
+  }
+  const int esz = edge_list.size();
+  if (!esz) {
+    return f[promised][dist_to_last][par_dist][edge_id] =
+               (promised || dist_to_last > K) ? res : 0LL;
+  }
+  const int egsz = edge_groups.size();
+  vector<int64> edge_f(esz), edge_f2(esz);
+  for (int new_dist_to_last = dist_to_last + 1, new_promised = promised;
+       new_dist_to_last <= lazy_max_dist && res;
+       ++new_dist_to_last, new_promised = 1) {
+    const int inv_dist_to_last = lazy_max_dist - new_dist_to_last;
+    const int min_dist_to_last = min(dist_to_last + 1, 2 + inv_dist_to_last);
+    for (int i = 0; i < esz; ++i) {
+      const int new_edge_id = edge_list[i];
+      const int new_cycle_id = cycle_ids[new_edge_id];
+      int new_par_dist = lazy_max_dist;
+      if (new_cycle_id != -1) {
+        if (new_cycle_id == base_cycle_id) {
+          new_par_dist = par_dist;
+          new_par_dist =
+              min(new_par_dist, 1 + cycle_lens[base_cycle_id] -
+                                    dist_to_par[edge_id] + inv_dist_to_last);
+        } else {
+          new_par_dist = min_dist_to_last - 1;
+        }
+      }
+      edge_f[i] = lazy_dp(new_edge_id, min_dist_to_last, new_par_dist, 0);
+    }
+    for (int i = 0; i < esz; i++) {
+      const int new_edge_id = edge_list[i];
+      const int new_cycle_id = cycle_ids[new_edge_id];
+      int new_par_dist = lazy_max_dist;
+      if (new_cycle_id != -1) {
+        if (new_cycle_id == base_cycle_id) {
+          new_par_dist = par_dist;
+        } else {
+          new_par_dist = dist_to_last;
+        }
+      }
+      edge_f2[i] =
+          lazy_dp(new_edge_id, new_dist_to_last, new_par_dist, new_promised);
+    }
+    int64 f_sum = 0LL, min_diff = kInf;
+    for (int i = 0; i < egsz; i++) {
+      const int ind1 = edge_groups[i].first;
+      int64 edge_group_f = edge_f[ind1], edge_group_f2 = edge_f2[ind1];
+      const int ind2 = edge_groups[i].second;
+      if (ind2 != -1) {
+        edge_group_f = min(edge_group_f, edge_f[ind2]);
+        edge_group_f2 = min(edge_group_f2, edge_f2[ind2]);
+      }
+      min_diff = min(min_diff, edge_group_f2 - edge_group_f);
+      f_sum += edge_group_f;
+    }
+    res = min(res, f_sum + min_diff);
+  }
+  return f[promised][dist_to_last][par_dist][edge_id] = res;
+}
+
+int64 solve() {
+  vector<pair<int, int>> edges;
+  cin >> N >> M >> K;
+  weights.resize(N);
+  for (int i = 0; i < N; ++i) {
+    cin >> weights[i];
+  }
+  edges.resize(M);
+  for (int i = 0; i < M; ++i) {
+    cin >> edges[i].first >> edges[i].second;
+    --edges[i].first;
+    --edges[i].second;
+  }
+  int root = N;
+  edges.emplace_back(N++, 0);
+  M++;
+  adj.assign(N, {});
+  for (int i = 0; i < M; i++) {
+    adj[edges[i].first].push_back(edges[i].second);
+    adj[edges[i].second].push_back(edges[i].first);
+  }
+  timer = 0;
+  tin.assign(N, -1);
+  tout.resize(N, -1);
+  dfs(root);
+  vector<int> tin0 = tin, tout0 = tout;
+  for (int x = 0; x < N; x++) {
+    reverse(adj[x].begin(), adj[x].end());
+  }
+  timer = 0;
+  tin.assign(N, -1);
+  tout.resize(N, -1);
+  dfs(root);
+  par.assign(N, -1);
+  for (int x = 0; x < N; x++) {
+    for (int y : adj[x]) {
+      if (tin0[y] < tin0[x] && tin[y] < tin[x]) {
+        par[x] = y;
+      }
+    }
+  }
+  cycle_counter = 0;
+  dp_edges.clear();
+  edge_lnks.assign(N, vector<int>(N, -1));
+  cycle_ids.clear();
+  cycle_lens.clear();
+  cycle_rev.clear();
+  dist_to_par.clear();
+  timer = 0;
+  tin.assign(N, -1);
+  dfs_stack.clear();
+  dfs_cycles(root, root);
+  for (int x = 0; x < N; x++) {
+    reverse(adj[x].begin(), adj[x].end());
+  }
+  timer = 0;
+  tin.assign(N, -1);
+  dfs_cycles(root, root);
+  memset(f, -1, sizeof f);
+  lazy_max_dist = ((K + 1) << 1) - 1;
+  int64 res = kInf;
+  for (int i = 0; i <= K; i++) {
+    res = min(res, lazy_dp(edge_lnks[root][0], i + K + 1, lazy_max_dist, 1));
+  }
+  return res;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2023/finals/cacti_cartography.md

@@ -0,0 +1,42 @@
+Cactus Park is a famous **t**ourist attraction in Sandlandia. It holds \(N\) cactus plants, numbered from \(1\) to \(N\). The cacti are connected by \(M\) bidirectional trails, with trail \(i\) connecting cacti \(A_i\) and \(B_i\).
+
+From any cactus, it's always possible to get to any other cactus by taking some sequence of trails. There may be cycles in the park, where a cycle is any sequence of trails that lead from a certain cactus back to itself. The park also has a special property that each trail belongs to at most one simple cycle. In graph theory terms, we can say that the Cactus Park forms a [cactus graph](https://en.wikipedia.org/wiki/Cactus_graph).
+
+The park owners want to replace some number of cacti with information kiosks to help guide the tourists. Cutting down cactus \(i\) and building a kiosk there costs the park \(C_i\) dollars. The owners want to build enough kiosks so that the shortest path from every remaining cactus to the closest kiosk does not exceed \(K\) trails. Please help the owners determine the minimum total cost required to satisfy this requirement.
+
+# Constraints
+
+\(1 \le T \le 65\)
+\(1 \le N \le 500\)
+\(1 \le K \le \min(N, 50)\)
+\(1 \le A_i, B_i \le N\)
+\(A_i \ne B_i\)
+\(1 \le C_i \le 10^9\)
+
+Each unordered pair \((A_i, B_i)\) appears at most once in a given test case.
+
+# Input Format
+
+Input begins with a single integer \(T\), the number of test cases. For each case, there is first a line containing three integers \(N\), \(M\), and \(K\). Then, there is a line containing \(N\) integers \(C_{1..N}\). Then, \(M\) lines follow, the \(i\)th of which contains two integers \(A_i\) and \(B_i\).
+
+# Output Format
+
+For the \(i\)th case, output `"Case #i: "`, followed by a single integer, the minimum total cost in dollars to satisfy the park owners' requirement.
+
+# Sample Explanation
+
+The first case is depicted below. Replacing just cactus \(2\) would meet the requirement, but would cost \(\$10\). Instead we can replace cacti \(1\) and \(4\) for a total cost of \(\$8\).
+
+{{PHOTO_ID:885100906409208|WIDTH:350}}
+
+The second case is depicted below. One solution is to replace cacti \(1\) and \(4\) for a total cost of \(\$6\).
+
+{{PHOTO_ID:3652000121792782|WIDTH:500}}
+
+In the third case, all the cactuses are already within \(2\) trails of each other, so we just need a single kiosk anywhere. We should cut down the cheapest cactus, cactus \(1\).
+
+{{PHOTO_ID:2643202679188960|WIDTH:350}}
+
+In the fourth case, we can cut down cacti \(1\), \(3\), and \(6\) for a total cost of \(9 + 3 + 4 = \$16\)
+
+{{PHOTO_ID:365613766120939|WIDTH:500}}

2023/finals/cacti_cartography.out

@@ -0,0 +1,64 @@
+Case #1: 8
+Case #2: 6
+Case #3: 1
+Case #4: 16
+Case #5: 3
+Case #6: 3
+Case #7: 2
+Case #8: 6
+Case #9: 2
+Case #10: 2
+Case #11: 6
+Case #12: 14
+Case #13: 2
+Case #14: 6119234639
+Case #15: 56915
+Case #16: 25737
+Case #17: 134345
+Case #18: 964947
+Case #19: 5007281
+Case #20: 291325
+Case #21: 1218092
+Case #22: 629219
+Case #23: 4921721
+Case #24: 223153307
+Case #25: 25668763120
+Case #26: 51949941040
+Case #27: 27097218102
+Case #28: 11054755671
+Case #29: 6223777469
+Case #30: 54339322140
+Case #31: 26401761341
+Case #32: 19580701903
+Case #33: 1908941214
+Case #34: 129619921
+Case #35: 80362051
+Case #36: 71755108
+Case #37: 188221638
+Case #38: 529801
+Case #39: 4131584
+Case #40: 19427941
+Case #41: 4573302
+Case #42: 45624427
+Case #43: 518482
+Case #44: 5
+Case #45: 2959
+Case #46: 13016
+Case #47: 119515
+Case #48: 735039570
+Case #49: 1799334197
+Case #50: 1837451412
+Case #51: 4070204431
+Case #52: 559773182
+Case #53: 865289571
+Case #54: 2218966827
+Case #55: 211
+Case #56: 4080
+Case #57: 27316
+Case #58: 282265375
+Case #59: 454432246
+Case #60: 6059130
+Case #61: 15476397
+Case #62: 4795686
+Case #63: 21325610
+Case #64: 74321936

2023/finals/cacti_cartography_sol.md

@@ -0,0 +1,29 @@
+To solve this problem, let’s preprocess the input first. We'll store the input cactus graph in an adjacency list. Let’s pick any random starting vertex \(s\) from which to perform a DFS traversal, storing the pre- and post-visiting times for each vertex \(v\) as \(tin[v]\) and \(tout[v]\) respectively.
+
+After reversing the adjacency list for each vertex, let’s repeat the DFS from the vertex \(s\) (we'll consider all adjacent vertices in reverse order this time) and store the pre- and post-visiting times for each vertex \(v\) as \(tin'[v]\) and \(tout'[v]\) respectively. Using DFS and pre/post visiting times for every edge \(u \to v\), we can determine the following:
+
+* Whether this edge is the first or the last in its cycle when traversing the cactus starting from \(s\)
+  * If \(tin[v] < tin[u]\) and \(tin'[v] < tin'[u]\), then this edge is the last of the cycle and vertex \(v\) is always the first vertex of the cycle visited on the way from vertex \(s\). Let’s denote such a vertex as a root of a cycle. Likewise, we can determine the first edge of the cycle.
+* The index of the cycle this edge belongs to (or \(-1\) if it doesn’t belong to any cycle)
+  * This can be done in one DFS from vertex \(s\) with an additional stack to recover the path from the first cycle’s vertex to itself.
+
+With an additional DFS traversal from vertex \(s\), we can determine the length of each cycle and the distance from each vertex to the root of the cycle it belongs to.
+
+For our solution, we will consider all edges as directed, in order of traversal from the starting vertex \(s\). Note that for simplicity, we can consider different traversal orders of the same cycle as two different cycles (but we'll need to mark them as interchangeable). Let’s define \(dp(e, dist1, dist2, mandatory)\), where:
+
+* \(e\) – edge ID that uniquely identifies the start \(u\) and end \(v\) of the edge;
+* \(dist1\) – distance between vertex \(v\) and the closest already placed kiosk;
+* \(dist2\) – distance between vertex \(v\) and the cycle root (if edge \(e\) belongs to a cycle);
+* \(mandatory\) – flag for whether we must place a kiosk in this or one of the following DP states.
+
+The number of edges \(M\) in a cactus graph of size \(N\) is at most \(3N / 2\). Any valid distance can be up to \((2K + 1) - K\) edges from the previous kiosk, plus \(1\) edge, plus \(K\) edges to the next kiosk. The flag can take on two values, so the total number of states is approximately \(3N * (2K + 1)^2\). In addition, we can force all states with \(dist1 > K + 1\) to have \(mandatory = 1\).
+
+For convenience, we can create a dummy edge from dummy vertex \(d\) to \(s\) and use this edge as a starting edge \(e_0\). The answer to the problem is the minimum \(dp(e_0, d1, x, 1)\) across all \(d_1\) from \(K\) to \(2K + 1\). Here, \(x\) denotes any value representing edge belonging to no cycle.
+
+The transitions that need to be considered are the following:
+
+1. Build a kiosk at vertex \(v\).
+2. If \(dist1 < 2K + 1\), keep transitioning to the next edge without building a kiosk at \(v\). For each edge, the value of \(dist'\) will simply be \(dist1 + 1\).
+3. For exactly one adjacent edge, set a new strict value of \(dist1'\) that's greater than the current \(dist1 + 1\) (set \(mandatory = 1\) for this edge). This is equal to moving the next kiosk closer to the current edge. For other edges, recompute the value of \(dist1'\) considering the kiosk at the selected edge (\(mandatory = 0\) for all such edges). This can be done in \(\mathcal{O}(K)\) by iterating over all possible values of the new \(dist1\).
+
+As previously mentioned, the total number of states is \(\mathcal{O}(NK^2)\). Each state has \(\mathcal{O}(K)\) transitions, so the total complexity of the solution is \(\mathcal{O}(NK^3)\).

2023/finals/dealing_decks.cpp

@@ -0,0 +1,153 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+using namespace std;
+
+const int kBitCount = 22;
+
+class PersistentTrie {
+  vector<int> roots, last, last_rec;
+  vector<vector<int>> nodes;
+
+  inline int get_root(int ind) {
+    return ind == -1 ? 0 : roots[ind];
+  }
+
+  vector<int> get_bits(int val) {
+    vector<int> bits(kBitCount, 0);
+    for (int i = 0; i < kBitCount; i++) {
+      if (val & (1 << i)) {
+        bits[kBitCount - i - 1] = 1;
+      }
+    }
+    return bits;
+  }
+
+ public:
+  void reset(int n) {
+    last.assign(1, -1);
+    last_rec.assign(1, -1);
+    nodes.assign(2, vector<int>(1, -1));
+    roots.clear();
+    roots.reserve(n + 1);
+    last.reserve((n + 1) * (kBitCount + 1));
+    last_rec.reserve((n + 1) * (kBitCount + 1));
+    nodes[0].reserve((n + 1) * (kBitCount + 1));
+    nodes[1].reserve((n + 1) * (kBitCount + 1));
+  }
+
+  void add(int val, int ind) {
+    vector<int> bits = get_bits(val);
+    int r = roots.size(), node_id = nodes[0].size();
+    roots.push_back(node_id);
+    int root_id = get_root(r - 1);
+    nodes[0].push_back(nodes[0][root_id]);
+    nodes[1].push_back(nodes[1][root_id]);
+    last.push_back(ind);
+    vector<int> visited_nodes(1, node_id);
+    visited_nodes.reserve(kBitCount + 1);
+    for (int i = 0; i < kBitCount; ++i) {
+      int next_node_id = nodes[bits[i]][node_id];
+      if (next_node_id == -1) {
+        nodes[0].push_back(-1);
+        nodes[1].push_back(-1);
+      } else {
+        nodes[0].push_back(nodes[0][next_node_id]);
+        nodes[1].push_back(nodes[1][next_node_id]);
+      }
+      last.push_back(ind);
+      next_node_id = (int)nodes[0].size() - 1;
+      nodes[bits[i]][node_id] = next_node_id;
+      node_id = next_node_id;
+      visited_nodes.push_back(node_id);
+    }
+    last_rec.resize(last.size());
+    last_rec[visited_nodes.back()] = last[visited_nodes.back()];
+    for (int i = (int)visited_nodes.size() - 2; i >= 0; i--) {
+      const int node_id = visited_nodes[i];
+      last_rec[node_id] = last[node_id];
+      for (int j = 0; j < 2; ++j) {
+        const int child_node_id = nodes[j][node_id];
+        if (child_node_id == -1) {
+          last_rec[node_id] = -1;
+        } else {
+          last_rec[node_id] = min(last_rec[node_id], last_rec[child_node_id]);
+        }
+      }
+    }
+  }
+
+  int get_mex(int l, int r, int val) {
+    if (!r) {
+      return val ? 0 : 1;
+    }
+    int res = 0;
+    vector<int> bits = get_bits(val);
+    int node_id = get_root(r);
+    for (int i = 0; i < kBitCount; ++i) {
+      if (node_id == -1) {
+        break;
+      }
+      for (int j = 0; j < 2; ++j) {
+        const int bit_val = bits[i] ^ j;
+        const int child_node_id = nodes[bit_val][node_id];
+        if (child_node_id == -1) {
+          node_id = child_node_id;
+          res |= (j << (kBitCount - i - 1));
+          break;
+        }
+        if (last_rec[child_node_id] < l) {
+          node_id = child_node_id;
+          res |= (j << (kBitCount - i - 1));
+          break;
+        }
+      }
+    }
+    return res;
+  }
+};
+
+PersistentTrie trie;
+
+long long solve() {
+  int N, x1, y1, z1, x2, y2, z2, x3, y3, z3;
+  cin >> N >> x1 >> y1 >> z1 >> x2 >> y2 >> z2 >> x3 >> y3 >> z3;
+  vector<int> A(N), B(N), C(N);
+  long long pa = 0LL, pb = 0LL, pc = 0LL;
+  for (int i = 0; i < N; i++) {
+    pa = (pa * x1 + y1) % z1;
+    pb = (pb * x2 + y2) % z2;
+    pc = (pc * x3 + y3) % z3;
+    A[i] = min(i + 1, (int)(1 + pa));
+    B[i] = max(A[i], (int)(i + 1 - pb));
+    C[i] = min(i, (int)pc);
+  }
+  A.insert(A.begin(), 0);
+  B.insert(B.begin(), 0);
+  C.insert(C.begin(), 0);
+  trie.reset(N);
+  trie.add(0, 0);
+  vector<int> f(N + 1, 0);
+  for (int i = 1; i <= N; ++i) {
+    f[i] = trie.get_mex(i - B[i], i - A[i], f[C[i]]);
+    trie.add(f[i], i);
+  }
+  vector<int> lnk(1 << kBitCount, -1);
+  long long ans = 0LL;
+  for (int i = 1; i <= N; i++) {
+    if (lnk[f[i]] == -1) {
+      lnk[f[i]] = i;
+    }
+    ans += lnk[f[i]];
+  }
+  return ans;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2023/finals/dealing_decks.in

@@ -0,0 +1,83 @@
+41
+4
+25 30 2 45 16 4 7 26 4
+2
+19 48 2 38 23 2 43 31 2
+3
+9 17 2 23 42 2 21 43 2
+8
+23 5 8 14 22 2 29 28 6
+10
+559 556 7 174 424 10 16 605 6
+21
+875 456 11 177 442 7 772 631 18
+1103
+583 198 169 273 38 1037 65 714 134
+55062
+11 440 253 980 931 23119 526 733 20036
+1999999
+820049480 21547108 154 708675718 561447936 206 440133487 35313866 34
+1
+618469191 790824851 1 240496554 254321196 1 312956711 468952046 1
+5
+927221256 311785085 4 698772477 828422337 5 866165702 648272273 4
+1337
+617141389 96776754 2 686400226 46429892 7 356199465 607467260 14
+12345
+569835284 592019409 199 308489576 551741746 10418 947160134 417058699 6439
+4096
+882524217 62432131 34 236089651 201946473 45 537291505 89572094 5
+892157
+577513866 796928263 771534 76072296 794292101 759123 90769926 295213615 887741
+129383
+55887595 852438620 4710 11626302 775207609 45712 232088575 882360267 13825
+598778
+791123555 342313502 32777 967631394 880141999 185599 436295146 96309736 567626
+228666
+658441187 230758690 120 479708637 602412993 518 416379589 235508522 27
+2000000
+304835691 270438667 11 48760594 766490554 66 92190961 556228743 51404
+2000000
+760910031 349756326 37 815146995 377343946 3 80923234 719628481 63457
+2000000
+46554619 759417219 6 286810816 476063838 16 595057130 293823025 59916
+2000000
+428975320 685583455 224 272112290 398556761 906 724586127 532236124 129507
+2000000
+967113756 124639790 1408 957828016 678030194 2770 893015681 944303456 16856
+2000000
+250334415 450031626 6642 174619518 13055349 1843 287114316 927515975 181446
+2000000
+655903009 521273984 1100 897440710 153838214 8551 579642952 73254666 3503
+2000000
+156091746 356425229 2 585640195 937186358 2 25921154 510616709 357945
+2000000
+913503456 684954361 2 367054298 154030427 8 165631888 429296876 2784
+2000000
+677701956 30977645 4 128803728 140723514 5 373865765 817723005 171076
+2000000
+143439592 751027513 16 638841930 391044282 48 693880917 13330581 47560
+2000000
+645579553 961124399 31 259538748 321412351 24 597864072 18435563 43776
+2000000
+825220632 33752892 14808 650864364 588629702 16626 943286494 884784276 43
+2000000
+899879843 346157252 17835 314088427 369371457 11163 698921857 44084703 85
+2000000
+546528449 716067318 19032 85451517 664553217 11844 599650529 185668726 76
+2000000
+122651508 612555608 2132 416210921 695672740 1684 79592485 621545086 262
+2000000
+173746740 376661032 1309 927290494 475468151 2142 990050399 866720809 900
+2000000
+187335289 126137493 2034 809840311 27714063 2214 200677041 22664069 964
+2000000
+458070904 861770805 1 954595222 31552611 9 137186971 96946491 6
+2000000
+556126019 961152783 1 25621302 120476508 7 852896597 179745248 4
+2000000
+807322230 863021058 2 58915834 794401121 10 786881443 912097469 2
+2000000
+98872432 389583618 7 594840985 956041304 8 794849422 685934408 3
+2000000
+34828790 251904740 5 717276352 437920647 2 644744908 25169188 4

2023/finals/dealing_decks.md

@@ -0,0 +1,66 @@
+Alice and Bob like to play cards on their lunch break. Their favorite card game starts with two decks on the table containing \(K_1\) and \(K_2\) cards. Players take turns, with Alice going first. Each turn is in two parts:
+
+1. The player selects a deck of cards from the table. Let \(k\) be the number of cards in that deck. They then remove somewhere between \(A_k\) and \(B_k\) \((1 \le A_k \le B_k \le k)\), inclusive, cards from this deck.
+2. The player then puts a new deck of exactly \(C_k\) \((0 \le C_k < k)\) cards on the table. Here, \(C_k = 0\) means no deck is added.
+
+The player who takes the last card wins.
+
+For each possible value of \(K_1\) from \(1\) to a given value \(N\), find the minimum possible value of \(K_2\) so that Bob wins the game if both players play optimally. If there is no such \(K_2\) between \(1\) and \(N\), then \(K_2 = -1\). Output the sum of \(K_2\) across every \(K_1 = 1..N\).
+
+To reduce the input size, you will not be given \(A_{1..N}\), \(B_{1..N}\), and \(C_{1..N}\) directly. You must instead generate them using parameters \(X_a\), \(Y_a\), \(Z_a\), \(X_b\), \(Y_b\), \(Z_b\), \(X_c\), \(Y_c\), and \(Z_c\) and the algorithm below:
+
+\(P_a[0] := 0\)
+\(P_b[0] := 0\)
+\(P_c[0] := 0\)
+\(\text{for each } i := 1..N\):
+\(\;\;\;\;\; P_a[i] := (P_a[i - 1] * X_a + Y_a) \text{ mod } Z_a\)
+\(\;\;\;\;\; P_b[i] := (P_b[i - 1] * X_b + Y_b) \text{ mod } Z_b\)
+\(\;\;\;\;\; P_c[i] := (P_c[i - 1] * X_c + Y_c) \text{ mod } Z_c\)
+\(\;\;\;\;\; A[i] := \min(i, 1 + P_a[i])\)
+\(\;\;\;\;\; B[i] := \max(A[i], i - P_b[i])\)
+\(\;\;\;\;\; C[i] := \min(i - 1, P_c[i])\)
+
+Note that for any \(i\), the algorithm guarantees \(1 \le A_i \le B_i \le i\) and \(0 \le C_i < i\).
+
+# Constraints
+
+\(1 \le T \le 45\)
+\(1 \le N \le 2{,}000{,}000\)
+\(1 \le X_a, Y_a, X_b, Y_b, X_c, Y_c \le 1{,}000{,}000{,}000\)
+\(1 \le Z_a, Z_b, Z_c \le N\)
+
+The sum of \(N\) across all test cases is at most \(50{,}000{,}000\).
+
+# Input Format
+
+Input begins with a single integer \(T\), the number of test cases. For each case, first there is a line containing a single integer \(N\). Then, there is a line containing integers \(X_a\), \(Y_a\), \(Z_a\), \(X_b\), \(Y_b\), \(Z_b\), \(X_c\), \(Y_c\), and \(Z_c\).
+
+# Output Format
+
+For the \(i\)th case, output `"Case #i: "` followed by a single integer, the sum of the minimum \(K_2\) so that Bob has a guaranteed winning strategy, for every \(K_1 = 1..N\).
+
+# Sample Explanation
+
+In the first sample case:
+
+\( \begin{array}{c|c|c|c|c}\underline{K_1}&\underline{A[K_1]}&\underline{B[K_1]}&\underline{C[K_1]}&\underline{K_2} \\ 1&1&1&0&1 \\ 2&1&2&0&2 \\ 3&1&3&2&1 \\ 4&1&4&0&4 \end{array} \)
+
+When \(K_1 = 1\), Bob wins when \(K_2 = 1\) because Alice takes the first card, and Bob takes the last card.
+
+When \(K_1 = 2\), Alice will win if \(K_2 = 1\) because she can start by taking \(1\) card from the first deck. Bob then takes \(1\) card from either deck (each of which have only \(1\) card left), and Alice takes the last card. But if \(K_2 = 2\) then Bob can always win regardless of whether Alice starts by taking \(1\) card or \(2\) cards.
+
+When \(K_1 = 3\), Bob can always win when \(K_2 = 1\). If Alice takes the single card from the second deck, Bob takes \(1\) card from the first deck and adds a new deck of size \(2\) to the table. We now have two decks of size \(2\), and it's Alice's turn. That's a losing state for Alice as we saw previously.
+
+If Alice takes \(1\) card from the first deck and adds a new deck of size \(2\), we now have decks of size \([2, 1, 2]\). Bob will pick up the pile of size \(1\) and again we're in the same losing state for Alice. If Alice takes \(2\) cards from the first deck, we'll have decks of size \([1, 1, 2]\). Bob now takes the whole deck of size \(2\). Alice gets the next card and Bob gets the last card. Finally, if Alice takes all \(3\) cards from the first deck, we'll have decks of size \([1, 2]\). Bob can take just \(1\) card from the deck of size \(2\) to win.
+
+In the second sample case:
+
+\( \begin{array}{c|c|c|c|c}\underline{K_1}&\underline{A[K_1]}&\underline{B[K_1]}&\underline{C[K_1]}&\underline{K_2} \\ 1&1&1&0&1 \\ 2&1&1&0&2 \end{array} \)
+
+In the third sample case:
+
+\( \begin{array}{c|c|c|c|c}\underline{K_1}&\underline{A[K_1]}&\underline{B[K_1]}&\underline{C[K_1]}&\underline{K_2} \\ 1&1&1&0&1 \\ 2&1&2&0&2 \\ 3&2&3&1&2 \end{array} \)
+
+In the fourth sample case:
+
+\( \begin{array}{c|c|c|c|c}\underline{K_1}&\underline{A[K_1]}&\underline{B[K_1]}&\underline{C[K_1]}&\underline{K_2} \\ 1&1&1&0&1 \\ 2&1&2&0&2 \\ 3&3&3&2&3 \\ 4&1&4&0&4 \\ 5&5&5&4&3 \\ 6&1&6&0&6 \\ 7&6&7&4&3 \\ 8&1&8&0&8 \end{array} \)

2023/finals/dealing_decks.out

@@ -0,0 +1,41 @@
+Case #1: 8
+Case #2: 3
+Case #3: 5
+Case #4: 30
+Case #5: 35
+Case #6: 117
+Case #7: 273183
+Case #8: 1312463028
+Case #9: 1999867993760
+Case #10: 1
+Case #11: 10
+Case #12: 894422
+Case #13: 46013012
+Case #14: 27755
+Case #15: 81103343152
+Case #16: 7519069023
+Case #17: 116625528184
+Case #18: 26142781428
+Case #19: 1970328389618
+Case #20: 1942443692949
+Case #21: 1963487342234
+Case #22: 1925817311005
+Case #23: 1992266026268
+Case #24: 1893316038970
+Case #25: 1999025192108
+Case #26: 1749389735220
+Case #27: 1998817856516
+Case #28: 1900414850949
+Case #29: 1977804916734
+Case #30: 1976197732223
+Case #31: 1988992390784
+Case #32: 1982416741751
+Case #33: 1981598424077
+Case #34: 1998107636271
+Case #35: 1999104419717
+Case #36: 1998974708302
+Case #37: 1999999333294
+Case #38: 2000000999988
+Case #39: 2000000999975
+Case #40: 1999996333346
+Case #41: 2000001000000

2023/finals/dealing_decks_sol.md

@@ -0,0 +1,22 @@
+To start, let’s look at the Sprague-Grundy function for a deck of arbitrary size \(k\):
+
+\[\displaystyle g(k) = \text{mex}(\{ g(k - i) \oplus g(C_k) \mid i \in [ k - B_i, k - A_i ] \}) \]
+
+In other words, to compute the value of \(g(k)\), we can perform the following steps:
+
+1. Construct a set \(S\) of all values \(g(i)\), where \(i = k - B_i, ..., k - A_i\).
+2. XOR each value of \(S\) with \(C_k\).
+3. Find a mex (minimum excluded value) of \(S\) and assign it to \(g(k)\).
+
+Since we need to compute \(g(k)\) for each \(k = 1..N\), we need a data structure that supports all the listed operations with \(\mathcal{O}(\log N)\) complexity. Such data structure exists – it’s a simple trie. Let’s represent each value of \(g(k)\) in its binary form and store binary string representations in the trie. Each node will have no more than two edges (one edge corresponds to \(0\), the other to \(1\)). For each node of the trie, let’s store the last value of \(k\) for which it has been updated.
+
+Suppose for a certain value of \(k\) we want to find the mex of all values \(g(x)\) from \(g(l)\) to \(g(k)\). We can descend from the root of the trie to some leaf, each time going to the child which hasn’t been updated after \(l - 1\). If both child nodes satisfy this condition, we pass through \(0\)-edge. At any moment, if there is no corresponding edge, that means the node has never been updated.
+
+Now we can modify this approach for finding the mex of all values \(g(x) \oplus y\) from \(g(l)\) to \(g(k)\) (for any value of \(y\)). To do so when both child nodes haven’t been updated after \(l - 1\) we will pass through \(0\)-edge only if the corresponding bit in \(y\) is \(0\), otherwise we will pass through \(1\)-edge.
+
+The only modification we need now is to make this approach correct for an arbitrary right border \(r \ge l\). It can be done by simply making the trie persistent. This way we can always perform the previously explained approach on the version of the trie we had right after adding the value of \(g(r)\). The only extra price we pay is \(\log N\) times more memory usage.
+
+Since any descent on a trie takes \(\mathcal{O}(\log N)\) steps, the overall complexity of the described approach is \(\mathcal{O}(N \log N)\).
+
+When all values are computed, we can use them to find the value of \(K_2\) for each \(K_1\). First, \(K_2\) always exists and \(K_2 \le K_1\). If \(K_2 = K_1\), Bob can always win by mirroring Alice’s turns. Since we need Bob to win, we are interested in states where \(g(K_1) \oplus g(K_2)\) is zero and \(K_2\) is as small as possible. So all we need to do is find the minimum \(K_2\) such that \(g(K_1) = g(K_2)\). This can be done in \(\mathcal{O}(N)\) time and doesn’t affect the final \(\mathcal{O}(N \log N)\) complexity of the solution.
+

2023/finals/nearly_nim.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int solve() {
+  int N;
+  cin >> N;
+  vector<int> A(N);
+  for (int i = 0; i < N; i++) {
+    cin >> A[i];
+  }
+  int ans = 0;
+  vector<int> left(N + 1), right(N + 1);
+  for (int i = 0; i < N; i++) {
+    left[i + 1] = max(0, A[i] - left[i]);
+  }
+  for (int i = N - 1; i >= 0; i--) {
+    right[i - 1] = max(0, A[i] - right[i]);
+  }
+  for (int i = 0; i < N; i++) {
+    ans += max(0, A[i] - left[i] - right[i]);
+  }
+  return ans;
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2023/finals/nearly_nim.in

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

2023/finals/nearly_nim.md

@@ -0,0 +1,34 @@
+Alice and Bob are servers at *Nim Sum Dim Sum*, a bustling dumpling restaurant. For a staff meal, the manager has generously provided \(N\) plates of dumplings in a row, numbered from \(1\) to \(N\). Initially, plate \(i\) has \(A_i\) dumplings. In classic fashion, the duo has decided to play a game.
+
+Alice and Bob will take turns eating dumplings from the plates. On a given turn, a player must pick a plate adjacent to the last picked plate by the other player, and eat any positive number of dumplings from that plate. The first player who cannot do so on their turn loses. Alice goes first, and can choose any starting plate to eat from.
+
+For example, suppose there are three plates holding \(4\), \(1\) and \(2\) dumplings respectively. On the first turn, Alice can eat \(3\) dumplings from the first plate. Bob must then eat the dumpling from the middle plate. Alice can respond by eating one dumpling from the third plate. Bob must then eat from plate \(2\), but since it’s empty now, he loses.
+
+Assuming both players play optimally, how many starting moves can Alice make so that she wins? Two starting moves are considered different if Alice eats from different plates, or eats a different number of dumplings.
+
+# Constraints
+
+\(1 \le T \le 220\)
+\(2 \le N \le 800{,}000\)
+\(0 \le A_i \lt 2^{25}\)
+
+The sum of \(N\) across all test cases is at most \(4{,}000{,}000\).
+
+# Input Format
+
+Input begins with an integer \(T\), the number of cases. Each case will begin with a single integer \(N\) followed by the \(N\) integers \(A_1, ..., A_N\) on the next line.
+
+# Output Format
+
+For the \(i\)th case, output `"Case #i: "` followed by a single integer, the number of winning starting moves Alice has.
+
+# Sample Explanation
+
+In the first case, Alice can start by taking any number of dumplings from either the first or third plate. Bob will then have to take the solitary dumpling on the middle plate, and Alice can win by taking all the dumplings from the plate she didn't start with. This gives Alice 6 different winning starting moves.
+
+In the second case, Alice cannot win because she takes one dumpling, Bob takes the other, and then Alice has no move to make.
+
+In the third case, Alice's winning moves are to take \(1\) or \(2\) dumplings from the right-hand plate.
+
+In the fourth case, Bob can always force a win.
+

2023/finals/nearly_nim.out

@@ -0,0 +1,218 @@
+Case #1: Alice
+Case #2: Bob
+Case #3: Alice
+Case #4: Bob
+Case #5: Bob
+Case #6: Alice
+Case #7: Bob
+Case #8: Alice
+Case #9: Alice
+Case #10: Alice
+Case #11: Alice
+Case #12: Alice
+Case #13: Alice
+Case #14: Alice
+Case #15: Bob
+Case #16: Alice
+Case #17: Bob
+Case #18: Alice
+Case #19: Alice
+Case #20: Alice
+Case #21: Alice
+Case #22: Alice
+Case #23: Alice
+Case #24: Alice
+Case #25: Alice
+Case #26: Alice
+Case #27: Alice
+Case #28: Alice
+Case #29: Alice
+Case #30: Alice
+Case #31: Alice
+Case #32: Alice
+Case #33: Alice
+Case #34: Alice
+Case #35: Alice
+Case #36: Alice
+Case #37: Alice
+Case #38: Alice
+Case #39: Alice
+Case #40: Alice
+Case #41: Alice
+Case #42: Alice
+Case #43: Alice
+Case #44: Bob
+Case #45: Alice
+Case #46: Alice
+Case #47: Alice
+Case #48: Alice
+Case #49: Alice
+Case #50: Alice
+Case #51: Alice
+Case #52: Alice
+Case #53: Bob
+Case #54: Alice
+Case #55: Alice
+Case #56: Alice
+Case #57: Alice
+Case #58: Alice
+Case #59: Alice
+Case #60: Alice
+Case #61: Alice
+Case #62: Alice
+Case #63: Alice
+Case #64: Alice
+Case #65: Alice
+Case #66: Alice
+Case #67: Alice
+Case #68: Alice
+Case #69: Alice
+Case #70: Alice
+Case #71: Alice
+Case #72: Alice
+Case #73: Alice
+Case #74: Alice
+Case #75: Alice
+Case #76: Alice
+Case #77: Alice
+Case #78: Alice
+Case #79: Bob
+Case #80: Alice
+Case #81: Alice
+Case #82: Alice
+Case #83: Alice
+Case #84: Alice
+Case #85: Bob
+Case #86: Alice
+Case #87: Alice
+Case #88: Alice
+Case #89: Alice
+Case #90: Alice
+Case #91: Alice
+Case #92: Alice
+Case #93: Bob
+Case #94: Alice
+Case #95: Alice
+Case #96: Alice
+Case #97: Alice
+Case #98: Alice
+Case #99: Alice
+Case #100: Alice
+Case #101: Alice
+Case #102: Alice
+Case #103: Bob
+Case #104: Alice
+Case #105: Alice
+Case #106: Alice
+Case #107: Alice
+Case #108: Alice
+Case #109: Alice
+Case #110: Alice
+Case #111: Alice
+Case #112: Alice
+Case #113: Alice
+Case #114: Alice
+Case #115: Alice
+Case #116: Alice
+Case #117: Alice
+Case #118: Bob
+Case #119: Alice
+Case #120: Alice
+Case #121: Alice
+Case #122: Alice
+Case #123: Alice
+Case #124: Alice
+Case #125: Alice
+Case #126: Alice
+Case #127: Alice
+Case #128: Alice
+Case #129: Alice
+Case #130: Alice
+Case #131: Alice
+Case #132: Alice
+Case #133: Alice
+Case #134: Alice
+Case #135: Alice
+Case #136: Alice
+Case #137: Alice
+Case #138: Alice
+Case #139: Alice
+Case #140: Alice
+Case #141: Alice
+Case #142: Alice
+Case #143: Alice
+Case #144: Alice
+Case #145: Alice
+Case #146: Alice
+Case #147: Alice
+Case #148: Alice
+Case #149: Alice
+Case #150: Alice
+Case #151: Alice
+Case #152: Alice
+Case #153: Alice
+Case #154: Bob
+Case #155: Alice
+Case #156: Alice
+Case #157: Alice
+Case #158: Alice
+Case #159: Alice
+Case #160: Bob
+Case #161: Alice
+Case #162: Alice
+Case #163: Alice
+Case #164: Alice
+Case #165: Alice
+Case #166: Alice
+Case #167: Bob
+Case #168: Alice
+Case #169: Alice
+Case #170: Alice
+Case #171: Alice
+Case #172: Alice
+Case #173: Alice
+Case #174: Alice
+Case #175: Alice
+Case #176: Alice
+Case #177: Alice
+Case #178: Alice
+Case #179: Alice
+Case #180: Alice
+Case #181: Alice
+Case #182: Alice
+Case #183: Alice
+Case #184: Alice
+Case #185: Alice
+Case #186: Alice
+Case #187: Alice
+Case #188: Alice
+Case #189: Alice
+Case #190: Alice
+Case #191: Alice
+Case #192: Alice
+Case #193: Bob
+Case #194: Alice
+Case #195: Alice
+Case #196: Alice
+Case #197: Alice
+Case #198: Alice
+Case #199: Alice
+Case #200: Bob
+Case #201: Alice
+Case #202: Alice
+Case #203: Alice
+Case #204: Alice
+Case #205: Alice
+Case #206: Alice
+Case #207: Alice
+Case #208: Alice
+Case #209: Alice
+Case #210: Alice
+Case #211: Alice
+Case #212: Alice
+Case #213: Alice
+Case #214: Alice
+Case #215: Alice
+Case #216: Alice
+Case #217: Alice
+Case #218: Alice

2023/finals/nearly_nim_sol.md

@@ -0,0 +1,16 @@
+Since you must eat dumplings on a plate adjacent to your opponent, after the first move, it's uniquely determined who will eat from even plates and who will eat from odd plates. Therefore, other than Alice's first move, neither player will ever eat more than one dumpling on a turn.
+
+First, let's determine whether some board state is winning or losing for the current player. Suppose \(A[0] > A[1]\). In this case, Alice can win by eating from \(A[0]\), and will lose if she eats from \(A[1]\). Importantly, notice that if Alice eats from \(A[2...n]\), neither player will ever eat from \(A[1]\) as it will cause them to lose—their opponent can keep eating \(A[0]\), and \(A[1]\) will run out first.
+
+Therefore (if \(A[0] > A[1]\) and the first move doesn't involve \(A[0]\)), we can replace \(A[0]\) and \(A[1]\) with \(0\)'s and it will not change the result of the game.
+
+On the other hand if \(A[0] \leq A[1]\), then if our opponent ever eats from \(A[1]\), we should keep eating from \(A[0]\) as many times as possible to decrease \(A[1]\). We can prove this is optimal with a greedy principle: dumplings at position \(0\) can at best cause your opponent to have to eat one more dumpling from position \(1\), and at worst will never be eaten because your opponent won't give you the chance. Either way, we'll have to continue playing on pile \(2\), and it's better for us if the opponent has fewer dumplings left on pile \(1\).
+
+Therefore (if \(A[0] \leq A[1]\) and the first move doesn't involve \(A[0]\)), then we can replace \(A[0]\) with \(0\), and \(A[1]\) with \(A[1]-A[0]\), and it will not change the result of our game.
+
+Of course, these observations are symmetric, so they apply to \(A[N]\) and \(A[N-1]\) in the same way as \(A[0]\) and \(A[1]\).
+
+If the first move was made at position \(A[7]\) for example, then in linear time we can repeatedly simplify each end of the array until the only elements that are left are \(A[6], A[7],\) and \(A[8]\). We either delete the first/last two elements, or delete the first/last element, and decrease the second/second last. When we're done, this leaves us with an array of size \(3\), and all that matters is the total number of dumplings in the middle vs. on the sides. If after she takes dumplings from \(A[7]\), Alice will win if \(A[7] \geq A[6]+A[8]\). This leaves us with \(\max(0, A[7]-A[6]-A[8])\) ways of winning that start with position \(7\).
+
+This gives us an \(\mathcal{O}(N^2)\) solution since we are brute forcing the first move. But it turns out that each side is independent, so we can do a DP on each prefix and suffix to count what each prefix and suffix leaves you with, and this gives us an \(\mathcal{O}(N)\) solution.
+

2023/finals/programming_paths_part_1.cpp

@@ -0,0 +1,128 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+using namespace std;
+
+const int N = 13;
+
+vector<string> G;
+vector<int> b;
+vector<vector<int>> len;
+vector<vector<pair<int, int>>> cells;
+
+inline bool check(int r, int c) {
+  return r >= 0 && c >= 0 && r < N && c < N;
+}
+
+void dfs(int r, int c, int l) {
+  len[r][c] = l;
+  if (static_cast<int>(cells.size()) <= l) {
+    cells.resize(l + 1);
+  }
+  cells[l].emplace_back(r, c);
+  for (auto [r2, c2] : {pair{r - 1, c}, {r + 1, c}, {r, c - 1}, {r, c + 1}}) {
+    if (!check(r2, c2) || G[r2][c2] == '#' || len[r2][c2] != -1) {
+      continue;
+    }
+    dfs(r2, c2, l + 1);
+  }
+}
+
+int count_adj(int r, int c) {
+  int res = 0;
+  for (auto [r2, c2] : {pair{r - 1, c}, {r + 1, c}, {r, c - 1}, {r, c + 1}}) {
+    if (!check(r2, c2)) {
+      continue;
+    }
+    res += G[r2][c2] == '#';
+  }
+  return res;
+}
+
+void run(int r, int c, int l) {
+  len[r][c] = l;
+  if (l & 1) {
+    for (auto [r2, c2] : {pair{r - 1, c}, {r + 1, c}, {r, c - 1}, {r, c + 1}}) {
+      if (!check(r2, c2) || G[r2][c2] != '#') {
+        continue;
+      }
+      if (count_adj(r2, c2) == 3) {
+        G[r2][c2] = '.';
+        break;
+      }
+    }
+  }
+  for (auto [r2, c2] : {pair{r - 1, c}, {r + 1, c}, {r, c - 1}, {r, c + 1}}) {
+    if (!check(r2, c2) || G[r2][c2] == '#' || len[r2][c2] != -1) {
+      continue;
+    }
+    run(r2, c2, l + 1);
+  }
+}
+
+void solve() {
+  int K;
+  cin >> K;
+  b.clear();
+  for (int x = K; x; x >>= 1) {
+    b.push_back(x & 1);
+  }
+  reverse(b.begin(), b.end());
+  G.assign(N, string(N, '.'));
+  G[0][0] = '@';
+  for (int j = 1, par = 0; j < N; j += 3, par ^= 1) {
+    int st = 0, fn = N;
+    if (par) {
+      st += 1;
+    } else {
+      fn -= 1;
+    }
+    for (int i = st; i < fn; i++) {
+      G[i][j] = '#';
+      G[i][j + 1] = '#';
+    }
+  }
+  len.assign(N, vector<int>(N, -1));
+  run(0, 0, 0);
+  len.assign(N, vector<int>(N, -1));
+  cells.clear();
+  dfs(0, 0, 0);
+  vector<int> d0;
+  for (int i = 2; i < (int)cells.size(); i += 2) {
+    if (d0.size() & 1) {
+      d0.push_back(i);
+      continue;
+    }
+    if (cells[i].size() > 1) {
+      d0.push_back(i);
+    }
+  }
+  for (int i = 0, ind = 0; i < (int)b.size(); i++, ind += 2) {
+    if (b[i]) {
+      int d = d0[ind];
+      for (int j = 0; j <= 1; j++) {
+        auto [r, c] = cells[d][j];
+        G[r][c] = '*';
+      }
+    }
+    for (int j = 0; j <= 1; j++) {
+      int d = d0[ind + 1] + j;
+      auto [r, c] = cells[d][0];
+      G[r][c] = '*';
+    }
+  }
+  cout << N << " " << N << endl;
+  for (int i = 0; i < N; i++) {
+    cout << G[i] << endl;
+  }
+}
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": ";
+    solve();
+  }
+  return 0;
+}

2023/finals/programming_paths_part_1.in

@@ -0,0 +1,2001 @@
+2000
+0
+1
+10
+10000
+11
+12
+1212
+1237
+13
+1337
+14
+1473
+15
+1523
+16
+17
+18
+1833
+1855
+19
+2
+20
+210
+2295
+2494
+2576
+2666
+2827
+296
+3
+3026
+3162
+3229
+4
+4136
+4178
+4330
+4437
+466
+4748
+4889
+4923
+5
+5072
+5105
+512
+513
+518
+5180
+5383
+5424
+5522
+5660
+5747
+5840
+5944
+6
+6144
+6187
+621
+63
+6318
+6413
+6758
+7
+7097
+7175
+7308
+7495
+7496
+7560
+7577
+7696
+8
+8078
+8079
+8080
+8081
+8082
+8083
+8084
+8085
+8086
+8087
+8088
+8089
+8090
+8091
+8092
+8093
+8094
+8095
+8096
+8097
+8098
+8099
+8100
+8101
+8102
+8103
+8104
+8105
+8106
+8107
+8108
+8109
+8110
+8111
+8112
+8113
+8114
+8115
+8116
+8117
+8118
+8119
+8120
+8121
+8122
+8123
+8124
+8125
+8126
+8127
+8128
+8129
+8130
+8131
+8132
+8133
+8134
+8135
+8136
+8137
+8138
+8139
+8140
+8141
+8142
+8143
+8144
+8145
+8146
+8147
+8148
+8149
+8150
+8151
+8152
+8153
+8154
+8155
+8156
+8157
+8158
+8159
+8160
+8161
+8162
+8163
+8164
+8165
+8166
+8167
+8168
+8169
+8170
+8170
+8171
+8172
+8173
+8174
+8175
+8176
+8177
+8178
+8179
+8180
+8181
+8182
+8183
+8184
+8185
+8186
+8187
+8188
+8189
+8190
+8191
+8192
+8193
+8194
+8195
+8196
+8197
+8198
+8199
+8200
+8201
+8202
+8203
+8204
+8205
+8206
+8207
+8208
+8209
+8210
+8211
+8212
+8213
+8214
+8215
+8216
+8217
+8218
+8219
+8220
+8221
+8222
+8223
+8224
+8225
+8226
+8227
+8228
+8229
+8230
+8231
+8232
+8233
+8234
+8235
+8236
+8237
+8238
+8239
+8240
+8241
+8242
+8243
+8244
+8245
+8246
+8247
+8248
+8249
+8250
+8251
+8252
+8253
+8254
+8255
+8256
+8257
+8258
+8259
+8260
+8261
+8262
+8263
+8264
+8265
+8266
+8267
+8268
+8269
+8270
+8271
+8272
+8273
+8274
+8275
+8276
+8277
+8278
+8279
+8280
+8281
+8282
+8283
+8284
+8285
+8286
+8287
+8288
+8289
+8290
+8291
+8292
+8293
+8294
+8295
+8296
+8297
+8298
+8299
+8300
+8301
+8302
+8303
+8304
+8305
+8306
+8307
+8308
+8309
+8310
+8311
+8312
+8313
+8314
+8315
+8316
+8317
+8318
+8319
+8320
+8321
+8322
+8323
+8324
+8325
+8326
+8327
+8328
+8329
+8330
+8331
+8332
+8333
+8334
+8335
+8336
+8337
+8338
+8339
+8340
+8341
+8342
+8343
+8344
+8345
+8346
+8347
+8348
+8349
+8350
+8351
+8352
+8353
+8354
+8355
+8356
+8357
+8358
+8359
+8360
+8361
+8362
+8363
+8364
+8365
+8366
+8367
+8368
+8369
+8370
+8371
+8372
+8373
+8374
+8375
+8376
+8377
+8378
+8379
+8380
+8381
+8382
+8383
+8384
+8385
+8386
+8387
+8388
+8389
+8390
+8391
+8392
+8393
+8394
+8395
+8396
+8397
+8398
+8399
+8400
+8401
+8402
+8403
+8404
+8405
+8406
+8407
+8408
+8409
+8410
+8411
+8412
+8413
+8414
+8415
+8416
+8417
+8418
+8419
+8420
+8421
+8422
+8423
+8424
+8425
+8426
+8427
+8428
+8429
+8430
+8431
+8432
+8433
+8434
+8435
+8436
+8437
+8438
+8439
+8440
+8441
+8442
+8443
+8444
+8445
+8446
+8447
+8448
+8449
+8450
+8451
+8452
+8453
+8454
+8455
+8456
+8457
+8458
+8459
+8460
+8461
+8462
+8463
+8464
+8465
+8466
+8467
+8468
+8469
+8470
+8471
+8472
+8473
+8474
+8475
+8476
+8477
+8478
+8479
+8480
+8481
+8482
+8483
+8484
+8485
+8486
+8487
+8488
+8489
+8490
+8491
+8492
+8493
+8494
+8495
+8496
+8497
+8498
+8499
+8500
+8501
+8502
+8503
+8504
+8505
+8506
+8507
+8508
+8509
+8510
+8511
+8512
+8513
+8514
+8515
+8516
+8517
+8518
+8519
+8520
+8521
+8522
+8523
+8524
+8525
+8526
+8527
+8528
+8529
+8530
+8531
+8532
+8533
+8534
+8535
+8536
+8537
+8538
+8539
+8540
+8541
+8542
+8543
+8544
+8545
+8546
+8547
+8548
+8549
+8550
+8551
+8552
+8553
+8554
+8555
+8556
+8557
+8558
+8559
+8560
+8561
+8562
+8563
+8564
+8565
+8566
+8567
+8568
+8569
+8570
+8571
+8572
+8573
+8574
+8575
+8576
+8577
+8578
+8579
+8580
+8581
+8582
+8583
+8584
+8585
+8586
+8587
+8588
+8589
+8590
+8591
+8592
+8593
+8594
+8595
+8596
+8597
+8598
+8599
+8600
+8601
+8602
+8603
+8604
+8605
+8606
+8607
+8608
+8609
+8610
+8611
+8612
+8613
+8614
+8615
+8616
+8617
+8618
+8619
+8620
+8621
+8622
+8623
+8624
+8625
+8626
+8627
+8628
+8629
+8630
+8631
+8632
+8633
+8634
+8635
+8636
+8637
+8638
+8639
+8640
+8641
+8642
+8643
+8644
+8645
+8646
+8647
+8648
+8649
+8650
+8651
+8652
+8653
+8654
+8655
+8656
+8657
+8658
+8659
+8660
+8661
+8662
+8663
+8664
+8665
+8666
+8667
+8668
+8669
+8670
+8671
+8672
+8673
+8674
+8675
+8676
+8677
+8678
+8679
+8680
+8681
+8682
+8683
+8684
+8685
+8686
+8687
+8688
+8689
+8690
+8691
+8692
+8693
+8694
+8695
+8696
+8697
+8698
+8699
+8700
+8701
+8702
+8703
+8704
+8705
+8706
+8707
+8708
+8709
+8710
+8711
+8712
+8713
+8714
+8715
+8716
+8717
+8718
+8719
+8720
+8721
+8722
+8723
+8724
+8725
+8726
+8727
+8728
+8729
+8730
+8731
+8732
+8733
+8734
+8735
+8736
+8737
+8738
+8739
+8740
+8741
+8742
+8743
+8744
+8745
+8746
+8747
+8748
+8749
+8750
+8751
+8752
+8753
+8754
+8755
+8756
+8757
+8758
+8759
+8760
+8761
+8762
+8763
+8764
+8765
+8766
+8767
+8768
+8769
+8770
+8771
+8772
+8773
+8774
+8775
+8776
+8777
+8778
+8779
+8780
+8781
+8782
+8783
+8784
+8785
+8786
+8787
+8788
+8789
+8790
+8791
+8792
+8793
+8794
+8795
+8796
+8797
+8798
+8799
+8800
+8801
+8802
+8803
+8804
+8805
+8806
+8807
+8808
+8809
+8810
+8811
+8812
+8813
+8814
+8815
+8816
+8817
+8818
+8819
+8820
+8821
+8822
+8823
+8824
+8825
+8826
+8827
+8828
+8829
+8830
+8831
+8832
+8833
+8834
+8835
+8836
+8837
+8838
+8839
+8840
+8841
+8842
+8843
+8844
+8845
+8846
+8847
+8848
+8849
+8850
+8851
+8852
+8853
+8854
+8855
+8856
+8857
+8858
+8859
+8860
+8861
+8862
+8863
+8864
+8865
+8866
+8867
+8868
+8869
+8870
+8871
+8872
+8873
+8874
+8875
+8876
+8877
+8878
+8879
+8880
+8881
+8882
+8883
+8884
+8885
+8886
+8887
+8888
+8889
+8890
+8891
+8892
+8893
+8894
+8895
+8896
+8897
+8898
+8899
+890
+8900
+8901
+8902
+8903
+8904
+8905
+8906
+8907
+8908
+8909
+8910
+8911
+8912
+8913
+8914
+8915
+8916
+8917
+8918
+8919
+8920
+8921
+8922
+8923
+8924
+8925
+8926
+8927
+8928
+8929
+8930
+8931
+8932
+8933
+8934
+8935
+8936
+8937
+8938
+8939
+8940
+8941
+8942
+8943
+8944
+8945
+8946
+8947
+8948
+8949
+8950
+8951
+8952
+8953
+8954
+8955
+8956
+8957
+8958
+8959
+8960
+8961
+8962
+8963
+8964
+8965
+8966
+8967
+8968
+8969
+8970
+8971
+8972
+8973
+8974
+8975
+8976
+8977
+8978
+8979
+8980
+8981
+8982
+8983
+8984
+8985
+8986
+8987
+8988
+8989
+8990
+8991
+8992
+8993
+8994
+8995
+8996
+8997
+8998
+8999
+9
+9000
+9001
+9002
+9003
+9004
+9005
+9006
+9007
+9008
+9009
+9010
+9011
+9012
+9013
+9014
+9015
+9016
+9017
+9018
+9019
+9020
+9021
+9022
+9023
+9024
+9025
+9026
+9027
+9028
+9029
+9030
+9031
+9032
+9033
+9034
+9035
+9036
+9037
+9038
+9039
+9040
+9041
+9042
+9043
+9044
+9045
+9046
+9047
+9048
+9049
+9050
+9051
+9052
+9053
+9054
+9055
+9056
+9057
+9058
+9059
+9060
+9061
+9062
+9063
+9064
+9065
+9066
+9067
+9068
+9069
+9070
+9071
+9072
+9073
+9074
+9075
+9076
+9077
+9078
+9079
+9080
+9081
+9082
+9083
+9084
+9085
+9086
+9087
+9088
+9089
+9090
+9091
+9092
+9093
+9094
+9095
+9096
+9097
+9098
+9099
+9100
+9101
+9102
+9103
+9104
+9105
+9106
+9107
+9108
+9109
+9110
+9111
+9112
+9113
+9114
+9115
+9116
+9117
+9118
+9119
+9120
+9121
+9122
+9123
+9124
+9125
+9126
+9127
+9128
+9129
+9130
+9131
+9132
+9133
+9134
+9135
+9136
+9137
+9138
+9139
+9140
+9141
+9142
+9143
+9144
+9145
+9146
+9147
+9148
+9149
+9150
+9151
+9152
+9153
+9154
+9155
+9156
+9157
+9158
+9159
+9160
+9161
+9162
+9163
+9164
+9165
+9166
+9167
+9168
+9169
+9170
+9171
+9172
+9173
+9174
+9175
+9176
+9177
+9178
+9179
+9180
+9181
+9182
+9183
+9184
+9185
+9186
+9187
+9188
+9189
+919
+9190
+9191
+9192
+9193
+9194
+9195
+9196
+9197
+9198
+9199
+9200
+9201
+9202
+9203
+9204
+9205
+9206
+9207
+9208
+9209
+9210
+9211
+9212
+9213
+9214
+9215
+9216
+9217
+9218
+9219
+9220
+9221
+9222
+9223
+9224
+9225
+9226
+9227
+9228
+9229
+9230
+9231
+9232
+9233
+9234
+9235
+9236
+9237
+9238
+9239
+9240
+9241
+9242
+9243
+9244
+9245
+9246
+9247
+9248
+9249
+9250
+9251
+9252
+9253
+9254
+9255
+9256
+9257
+9258
+9259
+9260
+9261
+9262
+9263
+9264
+9265
+9266
+9267
+9268
+9269
+9270
+9271
+9272
+9273
+9274
+9275
+9276
+9277
+9278
+9279
+9280
+9281
+9282
+9283
+9284
+9285
+9286
+9287
+9288
+9289
+9290
+9291
+9292
+9293
+9294
+9295
+9296
+9297
+9298
+9299
+9300
+9301
+9302
+9303
+9304
+9305
+9306
+9307
+9308
+9309
+9310
+9311
+9312
+9313
+9314
+9315
+9316
+9317
+9318
+9319
+9320
+9321
+9322
+9323
+9324
+9325
+9326
+9327
+9328
+9329
+9330
+9331
+9332
+9333
+9334
+9335
+9336
+9337
+9338
+9339
+9340
+9341
+9342
+9343
+9344
+9345
+9346
+9347
+9348
+9349
+9350
+9351
+9352
+9353
+9354
+9355
+9356
+9357
+9358
+9359
+9360
+9361
+9362
+9363
+9364
+9365
+9366
+9367
+9368
+9369
+9370
+9371
+9372
+9373
+9374
+9375
+9376
+9377
+9378
+9379
+9380
+9381
+9382
+9383
+9384
+9385
+9386
+9387
+9388
+9389
+9390
+9391
+9392
+9393
+9394
+9395
+9396
+9397
+9398
+9399
+9400
+9401
+9402
+9403
+9404
+9405
+9406
+9407
+9408
+9409
+9410
+9411
+9412
+9413
+9414
+9415
+9416
+9417
+9418
+9419
+9420
+9421
+9422
+9423
+9424
+9425
+9426
+9427
+9428
+9429
+9430
+9431
+9432
+9433
+9434
+9435
+9436
+9437
+9438
+9439
+9440
+9441
+9442
+9443
+9444
+9445
+9446
+9447
+9448
+9449
+9450
+9451
+9452
+9453
+9454
+9455
+9456
+9457
+9458
+9459
+9460
+9461
+9462
+9463
+9464
+9465
+9466
+9467
+9468
+9469
+9470
+9471
+9472
+9473
+9474
+9475
+9476
+9477
+9478
+9479
+9480
+9481
+9482
+9483
+9484
+9485
+9486
+9487
+9488
+9489
+9490
+9491
+9492
+9493
+9494
+9495
+9496
+9497
+9498
+9499
+9500
+9501
+9502
+9503
+9504
+9505
+9506
+9507
+9508
+9509
+9510
+9511
+9512
+9513
+9514
+9515
+9516
+9517
+9518
+9519
+9520
+9521
+9522
+9523
+9524
+9525
+9526
+9527
+9528
+9529
+9530
+9531
+9532
+9533
+9534
+9535
+9536
+9537
+9538
+9539
+9540
+9541
+9542
+9543
+9544
+9545
+9546
+9547
+9548
+9549
+9550
+9551
+9552
+9553
+9554
+9555
+9556
+9557
+9558
+9559
+9560
+9561
+9562
+9563
+9564
+9565
+9566
+9567
+9568
+9569
+9570
+9571
+9572
+9573
+9574
+9575
+9576
+9577
+9578
+9579
+9580
+9581
+9582
+9583
+9584
+9585
+9586
+9587
+9588
+9589
+9590
+9591
+9592
+9593
+9594
+9595
+9596
+9597
+9598
+9599
+9600
+9601
+9602
+9603
+9604
+9605
+9606
+9607
+9608
+9609
+9610
+9611
+9612
+9613
+9614
+9615
+9616
+9617
+9618
+9619
+9620
+9621
+9622
+9623
+9624
+9625
+9626
+9627
+9628
+9629
+9630
+9631
+9632
+9633
+9634
+9635
+9636
+9637
+9638
+9639
+9640
+9641
+9642
+9643
+9644
+9645
+9646
+9647
+9648
+9649
+9650
+9651
+9652
+9653
+9654
+9655
+9656
+9657
+9658
+9659
+9660
+9661
+9662
+9663
+9664
+9665
+9666
+9667
+9668
+9669
+9670
+9671
+9672
+9673
+9674
+9675
+9676
+9677
+9678
+9679
+9680
+9681
+9682
+9683
+9684
+9685
+9686
+9687
+9688
+9689
+9690
+9691
+9692
+9693
+9694
+9695
+9696
+9697
+9698
+9699
+9700
+9701
+9702
+9703
+9704
+9705
+9706
+9707
+9708
+9709
+9710
+9711
+9712
+9713
+9714
+9715
+9716
+9717
+9718
+9719
+9720
+9721
+9722
+9723
+9724
+9725
+9726
+9727
+9728
+9729
+9730
+9731
+9732
+9733
+9734
+9735
+9736
+9737
+9738
+9739
+9740
+9741
+9742
+9743
+9744
+9745
+9746
+9747
+9748
+9749
+9750
+9751
+9752
+9753
+9754
+9755
+9756
+9757
+9758
+9759
+9760
+9761
+9762
+9763
+9764
+9765
+9766
+9767
+9768
+9769
+9770
+9771
+9772
+9773
+9774
+9775
+9776
+9777
+9778
+9779
+9780
+9781
+9782
+9783
+9784
+9785
+9786
+9787
+9788
+9789
+9790
+9791
+9792
+9793
+9794
+9795
+9796
+9797
+9798
+9799
+9800
+9801
+9802
+9803
+9804
+9805
+9806
+9807
+9808
+9809
+9810
+9811
+9812
+9813
+9814
+9815
+9816
+9817
+9818
+9819
+9820
+9821
+9822
+9823
+9824
+9825
+9826
+9827
+9828
+9829
+9830
+9831
+9832
+9833
+9834
+9835
+9836
+9837
+9838
+9839
+9840
+9841
+9842
+9843
+9844
+9845
+9846
+9847
+9848
+9849
+9850
+9851
+9852
+9853
+9854
+9855
+9856
+9857
+9858
+9859
+9860
+9861
+9862
+9863
+9864
+9865
+9866
+9867
+9868
+9869
+9870
+9871
+9872
+9873
+9874
+9875
+9876
+9877
+9878
+9879
+9880
+9881
+9882
+9883
+9884
+9885
+9886
+9887
+9888
+9889
+9890
+9891
+9892
+9893
+9894
+9895
+9896
+9897
+9898
+9899
+9900
+9901
+9902
+9903
+9904
+9905
+9906
+9907
+9908
+9909
+9910
+9911
+9912
+9913
+9914
+9915
+9916
+9917
+9918
+9919
+9920
+9921
+9922
+9923
+9924
+9925
+9926
+9927
+9928
+9929
+9930
+9931
+9932
+9933
+9934
+9935
+9936
+9937
+9938
+9939
+9940
+9941
+9942
+9943
+9944
+9945
+9946
+9947
+9948
+9949
+9950
+9951
+9952
+9953
+9954
+9955
+9956
+9957
+9958
+9959
+9960
+9961
+9962
+9963
+9964
+9965
+9966
+9967
+9968
+9969
+9970
+9971
+9972
+9973
+9974
+9975
+9976
+9977
+9978
+9979
+9980
+9981
+9982
+9983
+9984
+9985
+9986
+9987
+9988
+9989
+9990
+9991
+9992
+9993
+9994
+9995
+9996
+9997
+9998
+9999

2023/finals/programming_paths_part_1.md

@@ -0,0 +1,64 @@
+_The only difference between chapters 1 and 2 is the maximum allowed grid size, given in bold below._
+
+A *Drizzle* program is a 2D grid of the following four types of cells:
+ - '`@`' (start) \(-\) there is exactly one start cell in the entire grid
+ - '`#`' (wall)
+ - '`.`' (space)
+ - '`*`' (instruction)
+
+The program uses two registers \(A\) and \(B\) (both initially \(0\)), and executes as follows:
+
+1. Compute the minimum distance from the start to each instruction cell using orthogonal movements, without going outside of the grid or passing through any wall cells. Instruction cells that cannot be reached are ignored. 
+2. In increasing order, for each unique distance \(D\) such that there’s at least one instruction cell that’s at distance \(D\) from the start cell:
+   2a. Count the number of shortest paths, \(P\), to all instruction cells of distance \(D\).
+   2b. Look up the instruction corresponding to \((P \text{ mod } 2, D \text{ mod } 2)\) in the table below and modify one of the registers accordingly.
+3. At the end, the value in register \(A\) is outputted.
+
+```
+┌─────────────┬─────────────┬─────────────┐
+│             │ D mod 2 = 0 │ D mod 2 = 1 │
+├─────────────┼─────────────┼─────────────┤
+│ P mod 2 = 0 │ A := A + 1  │ A := A - 1  │
+│ P mod 2 = 1 │ B := B + A  │ A := B      │
+└─────────────┴─────────────┴─────────────┘
+```
+
+For a given value \(K\), output any Drizzle program that outputs \(K\) when executed, with the restriction that **the program must fit on a \(\mathbf{13}\) × \(\mathbf{13}\) grid**.
+
+
+# Constraints
+
+\(1 \le T \le 2{,}000\)
+\(0 \le K \le 10{,}000\)
+
+
+# Input Format
+
+Input begins with an integer \(T\), the number of test cases. For each case, there is a line containing the single integer \(K\).
+
+
+# Output Format
+
+For the \(i\)th case, output "`Case #i: `" followed by two integers \(R\) and \(C\), the number of rows and columns in your program, respectively. Then output your program. It must be exactly \(R\) lines long, with each line containing exactly \(C\) characters.
+
+
+# Sample Explanation
+
+Here are the instructions executed for each of the sample programs. Note that many other programs would be accepted for any for these cases.
+
+In the first case, there is a single instruction. There are \(2\) shortest paths of length \(2\) to that instruction, so \(P = 2\) and \(D = 2\). That means we perform \(A := A + 1\). There are no more instructions, so the program ends and outputs \(1\).
+
+In the second case, there are three instruction cells. Each of them are an even distance from the start, and each have an even number of shortest paths leading to them, so each represents \(A := A + 1\):
+
+1) \(2\) paths of length \(2\) \(\;(A := A + 1 = 1)\)
+2) \(4\) paths of length \(6\) \(\;(A := A + 1 = 2)\)
+3) \(4\) paths of length \(12\) \(\;(A := A + 1 = 3)\)
+
+In the third case, there are eight instruction cells, but some of them are at the same distance as each other. In particular, there are two instruction cells at distance \(2\), and three instruction cells at distance \(10\). There's a single shortest path to each of the cells at distance \(2\), so in total there are \(2\) shortest paths to instructions at distance \(2\). One of the cells at distance \(10\) has a unique shortest path, and the other has two shortest paths, so in total there are \(3\) shortest paths to instructions at distance \(10\).
+
+1) \(2\) paths of length \(2\) \(\;(A := A + 1 = 1)\)
+2) \(6\) paths of length \(4\) \(\;(A := A + 1 = 2)\)
+3) \(1\) path of length \(6\) \(\;(B := B + A = 2)\)
+4) \(1\) path of length \(8\) \(\;(B := B + A = 4)\)
+5) \(3\) paths of length \(10\) \(\;(B := B + A = 6)\)
+6) \(3\) paths of length \(11\) \(\;(A := B = 6)\)

2023/finals/programming_paths_part_1_sol.md

@@ -0,0 +1,25 @@
+It's clear that larger numbers will tend to require larger programs. By repeating \(B := B + A\) and \(A := B\) we can exponentiate to get to a large number quickly. We'll also need \(A := A + 1\) to get started, and to make smaller adjustments. However, \(A := A - 1\) is not nearly as useful (technically it has some utility when trying to strictly minimize the number of instructions it takes to generate a certain value, but that isn't the goal in this problem).
+
+Since \(A := A - 1\) is not very useful, we don't need many, if any, ways to have an even number of paths at an odd distance from the start. We do, however, need to have an even number of paths at *even* distances from the start.
+
+So our two goals when constructing a grid are to make a long enough path to fit all the instructions we need, and also maximize the number of cells at even distances from the start. For example, a grid like this:
+
+```
+@##....##....
+..#.##..#.##.
+.#..##.#..##.
+..#.#..##.#..
+.#..##.#..##.
+..#.#..##.#..
+.#..##.#..##.
+..#.#..##.#..
+.#..##.#..##.
+..#.#..##.#..
+.#..##.#..##.
+.##.#..##.#..
+....##....##.
+```
+
+This grid gives us one long path, and then many "alcoves" that are all at even distances from the start. Instruction cells along the main path will represent \(B := B + A\) and \(A := B\), and whenever we need to use \(A := A + 1\) we can add another instruction cell in one next alcove.
+
+Given such a grid, there are multiple ways to then determine a program that fits on the grid, such as using dynamic programming where the state is the value of the two registers, or manually constructing a set of instructions where we repeatedly multiply \(A\) by 2 and optionally add \(1\) to \(A\) as needed (essentially constructing the bitstring representation of the goal value).

2023/finals/programming_paths_part_2.cpp

@@ -0,0 +1,139 @@
+#include <algorithm>
+#include <iostream>
+#include <map>
+#include <queue>
+#include <vector>
+using namespace std;
+
+const int N = 10;
+const int LIM = 10000;
+using tiii = tuple<int, int, int>;
+
+vector<string> G{
+    "@.....#.#.",
+    "#.#.#.#...",
+    ".#.#..#.#.",
+    ".....#..#.",
+    "#.#.#..##.",
+    "...#.#.#..",
+    ".#.#.#..#.",
+    "..#...#.#.",
+    "#...#....#",
+    "..#..#.#..",
+};
+
+vector<vector<pair<int, int>>> pos(80);
+map<tiii, int> dp, op;
+map<tiii, tiii> pr;
+map<int, tiii> best;
+
+void init() {
+  map<pair<int, int>, int> dist;
+  dist[{0, 0}] = 0;
+  queue<pair<int, int>> q;
+  q.push({0, 0});
+  while (!q.empty()) {
+    auto [r, c] = q.front();
+    q.pop();
+    for (auto [r2, c2] : {pair{r - 1, c}, {r + 1, c}, {r, c - 1}, {r, c + 1}}) {
+      if (0 <= r2 && r2 < N && 0 <= c2 && c2 < N && G[r2][c2] == '.' &&
+          !dist.count({r2, c2})) {
+        dist[{r2, c2}] = dist[{r, c}] + 1;
+        pos[dist[{r2, c2}]].emplace_back(r2, c2);
+        q.push({r2, c2});
+      }
+    }
+  }
+  vector<int> sz;
+  for (auto l : pos) {
+    sz.push_back(l.size());
+  }
+  vector<vector<tiii>> elts(62);
+  dp[{0, 0, 1}] = 1;
+  elts[1].emplace_back(0, 0, 1);
+  for (int d = 0; d < 60; d++) {
+    if (d > 1 && sz[d] == 0) {
+      break;
+    }
+    while (!elts[d].empty()) {
+      auto tt = elts[d].back();
+      auto [u, v, state] = tt;
+      elts[d].pop_back();
+      if (0 <= u && u <= LIM && 0 <= v && v <= LIM) {
+        if (!best.count(u)) {
+          best[u] = tt;
+        }
+      } else {
+        continue;
+      }
+      tiii t0 = tiii{u, v, state ^ 1}, t1, t2;
+      if (!dp.count(t0)) {
+        dp[t0] = d + 1;
+        op[t0] = 0;
+        pr[t0] = tt;
+        elts[d + 1].push_back(t0);
+      }
+      if (sz[d] >= 1) {
+        if (state % 2) {
+          t1 = tiii{v, v, state ^ 1};
+        } else {
+          t1 = tiii{u, u + v, state ^ 1};
+        }
+        if (!dp.count(t1)) {
+          dp[t1] = d + 1;
+          op[t1] = 1;
+          pr[t1] = tt;
+          elts[d + 1].push_back(t1);
+        }
+      }
+      if (sz[d] >= 2) {
+        if (state % 2) {
+          t2 = tiii{u - 1, v, state ^ 1};
+        } else {
+          t2 = tiii{u + 1, v, state ^ 1};
+        }
+        if (!dp.count(t2)) {
+          dp[t2] = d + 1;
+          op[t2] = 2;
+          pr[t2] = tt;
+          elts[d + 1].push_back(t2);
+        }
+      }
+    }
+  }
+}
+
+void solve() {
+  int K;
+  cin >> K;
+
+  vector<int> rev;
+  for (auto state = best[K]; state != tiii{0, 0, 1}; state = pr[state]) {
+    rev.push_back(op[state]);
+  }
+  rev.push_back(0);
+  reverse(rev.begin(), rev.end());
+
+  vector<string> out = G;
+  for (int i = 0; i < (int)rev.size(); i++) {
+    for (int x = 0; x < rev[i]; x++) {
+      auto [r, c] = pos[i][x];
+      out[r][c] = '*';
+    }
+  }
+  cout << N << " " << N << endl;
+  for (int i = 0; i < N; i++) {
+    cout << out[i] << endl;
+  }
+}
+
+int main() {
+  init();
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": ";
+    solve();
+  }
+  return 0;
+}

2023/finals/programming_paths_part_2.in

@@ -0,0 +1,2001 @@
+2000
+0
+1
+10
+10000
+11
+12
+1212
+1237
+13
+1337
+14
+1473
+15
+1523
+16
+17
+18
+1833
+1855
+19
+2
+20
+210
+2295
+2494
+2576
+2666
+2827
+296
+3
+3026
+3162
+3229
+4
+4136
+4178
+4330
+4437
+466
+4748
+4889
+4923
+5
+5072
+5105
+512
+513
+518
+5180
+5383
+5424
+5522
+5660
+5747
+5840
+5944
+6
+6144
+6187
+621
+63
+6318
+6413
+6758
+7
+7097
+7175
+7308
+7495
+7496
+7560
+7577
+7696
+8
+8078
+8079
+8080
+8081
+8082
+8083
+8084
+8085
+8086
+8087
+8088
+8089
+8090
+8091
+8092
+8093
+8094
+8095
+8096
+8097
+8098
+8099
+8100
+8101
+8102
+8103
+8104
+8105
+8106
+8107
+8108
+8109
+8110
+8111
+8112
+8113
+8114
+8115
+8116
+8117
+8118
+8119
+8120
+8121
+8122
+8123
+8124
+8125
+8126
+8127
+8128
+8129
+8130
+8131
+8132
+8133
+8134
+8135
+8136
+8137
+8138
+8139
+8140
+8141
+8142
+8143
+8144
+8145
+8146
+8147
+8148
+8149
+8150
+8151
+8152
+8153
+8154
+8155
+8156
+8157
+8158
+8159
+8160
+8161
+8162
+8163
+8164
+8165
+8166
+8167
+8168
+8169
+8170
+8170
+8171
+8172
+8173
+8174
+8175
+8176
+8177
+8178
+8179
+8180
+8181
+8182
+8183
+8184
+8185
+8186
+8187
+8188
+8189
+8190
+8191
+8192
+8193
+8194
+8195
+8196
+8197
+8198
+8199
+8200
+8201
+8202
+8203
+8204
+8205
+8206
+8207
+8208
+8209
+8210
+8211
+8212
+8213
+8214
+8215
+8216
+8217
+8218
+8219
+8220
+8221
+8222
+8223
+8224
+8225
+8226
+8227
+8228
+8229
+8230
+8231
+8232
+8233
+8234
+8235
+8236
+8237
+8238
+8239
+8240
+8241
+8242
+8243
+8244
+8245
+8246
+8247
+8248
+8249
+8250
+8251
+8252
+8253
+8254
+8255
+8256
+8257
+8258
+8259
+8260
+8261
+8262
+8263
+8264
+8265
+8266
+8267
+8268
+8269
+8270
+8271
+8272
+8273
+8274
+8275
+8276
+8277
+8278
+8279
+8280
+8281
+8282
+8283
+8284
+8285
+8286
+8287
+8288
+8289
+8290
+8291
+8292
+8293
+8294
+8295
+8296
+8297
+8298
+8299
+8300
+8301
+8302
+8303
+8304
+8305
+8306
+8307
+8308
+8309
+8310
+8311
+8312
+8313
+8314
+8315
+8316
+8317
+8318
+8319
+8320
+8321
+8322
+8323
+8324
+8325
+8326
+8327
+8328
+8329
+8330
+8331
+8332
+8333
+8334
+8335
+8336
+8337
+8338
+8339
+8340
+8341
+8342
+8343
+8344
+8345
+8346
+8347
+8348
+8349
+8350
+8351
+8352
+8353
+8354
+8355
+8356
+8357
+8358
+8359
+8360
+8361
+8362
+8363
+8364
+8365
+8366
+8367
+8368
+8369
+8370
+8371
+8372
+8373
+8374
+8375
+8376
+8377
+8378
+8379
+8380
+8381
+8382
+8383
+8384
+8385
+8386
+8387
+8388
+8389
+8390
+8391
+8392
+8393
+8394
+8395
+8396
+8397
+8398
+8399
+8400
+8401
+8402
+8403
+8404
+8405
+8406
+8407
+8408
+8409
+8410
+8411
+8412
+8413
+8414
+8415
+8416
+8417
+8418
+8419
+8420
+8421
+8422
+8423
+8424
+8425
+8426
+8427
+8428
+8429
+8430
+8431
+8432
+8433
+8434
+8435
+8436
+8437
+8438
+8439
+8440
+8441
+8442
+8443
+8444
+8445
+8446
+8447
+8448
+8449
+8450
+8451
+8452
+8453
+8454
+8455
+8456
+8457
+8458
+8459
+8460
+8461
+8462
+8463
+8464
+8465
+8466
+8467
+8468
+8469
+8470
+8471
+8472
+8473
+8474
+8475
+8476
+8477
+8478
+8479
+8480
+8481
+8482
+8483
+8484
+8485
+8486
+8487
+8488
+8489
+8490
+8491
+8492
+8493
+8494
+8495
+8496
+8497
+8498
+8499
+8500
+8501
+8502
+8503
+8504
+8505
+8506
+8507
+8508
+8509
+8510
+8511
+8512
+8513
+8514
+8515
+8516
+8517
+8518
+8519
+8520
+8521
+8522
+8523
+8524
+8525
+8526
+8527
+8528
+8529
+8530
+8531
+8532
+8533
+8534
+8535
+8536
+8537
+8538
+8539
+8540
+8541
+8542
+8543
+8544
+8545
+8546
+8547
+8548
+8549
+8550
+8551
+8552
+8553
+8554
+8555
+8556
+8557
+8558
+8559
+8560
+8561
+8562
+8563
+8564
+8565
+8566
+8567
+8568
+8569
+8570
+8571
+8572
+8573
+8574
+8575
+8576
+8577
+8578
+8579
+8580
+8581
+8582
+8583
+8584
+8585
+8586
+8587
+8588
+8589
+8590
+8591
+8592
+8593
+8594
+8595
+8596
+8597
+8598
+8599
+8600
+8601
+8602
+8603
+8604
+8605
+8606
+8607
+8608
+8609
+8610
+8611
+8612
+8613
+8614
+8615
+8616
+8617
+8618
+8619
+8620
+8621
+8622
+8623
+8624
+8625
+8626
+8627
+8628
+8629
+8630
+8631
+8632
+8633
+8634
+8635
+8636
+8637
+8638
+8639
+8640
+8641
+8642
+8643
+8644
+8645
+8646
+8647
+8648
+8649
+8650
+8651
+8652
+8653
+8654
+8655
+8656
+8657
+8658
+8659
+8660
+8661
+8662
+8663
+8664
+8665
+8666
+8667
+8668
+8669
+8670
+8671
+8672
+8673
+8674
+8675
+8676
+8677
+8678
+8679
+8680
+8681
+8682
+8683
+8684
+8685
+8686
+8687
+8688
+8689
+8690
+8691
+8692
+8693
+8694
+8695
+8696
+8697
+8698
+8699
+8700
+8701
+8702
+8703
+8704
+8705
+8706
+8707
+8708
+8709
+8710
+8711
+8712
+8713
+8714
+8715
+8716
+8717
+8718
+8719
+8720
+8721
+8722
+8723
+8724
+8725
+8726
+8727
+8728
+8729
+8730
+8731
+8732
+8733
+8734
+8735
+8736
+8737
+8738
+8739
+8740
+8741
+8742
+8743
+8744
+8745
+8746
+8747
+8748
+8749
+8750
+8751
+8752
+8753
+8754
+8755
+8756
+8757
+8758
+8759
+8760
+8761
+8762
+8763
+8764
+8765
+8766
+8767
+8768
+8769
+8770
+8771
+8772
+8773
+8774
+8775
+8776
+8777
+8778
+8779
+8780
+8781
+8782
+8783
+8784
+8785
+8786
+8787
+8788
+8789
+8790
+8791
+8792
+8793
+8794
+8795
+8796
+8797
+8798
+8799
+8800
+8801
+8802
+8803
+8804
+8805
+8806
+8807
+8808
+8809
+8810
+8811
+8812
+8813
+8814
+8815
+8816
+8817
+8818
+8819
+8820
+8821
+8822
+8823
+8824
+8825
+8826
+8827
+8828
+8829
+8830
+8831
+8832
+8833
+8834
+8835
+8836
+8837
+8838
+8839
+8840
+8841
+8842
+8843
+8844
+8845
+8846
+8847
+8848
+8849
+8850
+8851
+8852
+8853
+8854
+8855
+8856
+8857
+8858
+8859
+8860
+8861
+8862
+8863
+8864
+8865
+8866
+8867
+8868
+8869
+8870
+8871
+8872
+8873
+8874
+8875
+8876
+8877
+8878
+8879
+8880
+8881
+8882
+8883
+8884
+8885
+8886
+8887
+8888
+8889
+8890
+8891
+8892
+8893
+8894
+8895
+8896
+8897
+8898
+8899
+890
+8900
+8901
+8902
+8903
+8904
+8905
+8906
+8907
+8908
+8909
+8910
+8911
+8912
+8913
+8914
+8915
+8916
+8917
+8918
+8919
+8920
+8921
+8922
+8923
+8924
+8925
+8926
+8927
+8928
+8929
+8930
+8931
+8932
+8933
+8934
+8935
+8936
+8937
+8938
+8939
+8940
+8941
+8942
+8943
+8944
+8945
+8946
+8947
+8948
+8949
+8950
+8951
+8952
+8953
+8954
+8955
+8956
+8957
+8958
+8959
+8960
+8961
+8962
+8963
+8964
+8965
+8966
+8967
+8968
+8969
+8970
+8971
+8972
+8973
+8974
+8975
+8976
+8977
+8978
+8979
+8980
+8981
+8982
+8983
+8984
+8985
+8986
+8987
+8988
+8989
+8990
+8991
+8992
+8993
+8994
+8995
+8996
+8997
+8998
+8999
+9
+9000
+9001
+9002
+9003
+9004
+9005
+9006
+9007
+9008
+9009
+9010
+9011
+9012
+9013
+9014
+9015
+9016
+9017
+9018
+9019
+9020
+9021
+9022
+9023
+9024
+9025
+9026
+9027
+9028
+9029
+9030
+9031
+9032
+9033
+9034
+9035
+9036
+9037
+9038
+9039
+9040
+9041
+9042
+9043
+9044
+9045
+9046
+9047
+9048
+9049
+9050
+9051
+9052
+9053
+9054
+9055
+9056
+9057
+9058
+9059
+9060
+9061
+9062
+9063
+9064
+9065
+9066
+9067
+9068
+9069
+9070
+9071
+9072
+9073
+9074
+9075
+9076
+9077
+9078
+9079
+9080
+9081
+9082
+9083
+9084
+9085
+9086
+9087
+9088
+9089
+9090
+9091
+9092
+9093
+9094
+9095
+9096
+9097
+9098
+9099
+9100
+9101
+9102
+9103
+9104
+9105
+9106
+9107
+9108
+9109
+9110
+9111
+9112
+9113
+9114
+9115
+9116
+9117
+9118
+9119
+9120
+9121
+9122
+9123
+9124
+9125
+9126
+9127
+9128
+9129
+9130
+9131
+9132
+9133
+9134
+9135
+9136
+9137
+9138
+9139
+9140
+9141
+9142
+9143
+9144
+9145
+9146
+9147
+9148
+9149
+9150
+9151
+9152
+9153
+9154
+9155
+9156
+9157
+9158
+9159
+9160
+9161
+9162
+9163
+9164
+9165
+9166
+9167
+9168
+9169
+9170
+9171
+9172
+9173
+9174
+9175
+9176
+9177
+9178
+9179
+9180
+9181
+9182
+9183
+9184
+9185
+9186
+9187
+9188
+9189
+919
+9190
+9191
+9192
+9193
+9194
+9195
+9196
+9197
+9198
+9199
+9200
+9201
+9202
+9203
+9204
+9205
+9206
+9207
+9208
+9209
+9210
+9211
+9212
+9213
+9214
+9215
+9216
+9217
+9218
+9219
+9220
+9221
+9222
+9223
+9224
+9225
+9226
+9227
+9228
+9229
+9230
+9231
+9232
+9233
+9234
+9235
+9236
+9237
+9238
+9239
+9240
+9241
+9242
+9243
+9244
+9245
+9246
+9247
+9248
+9249
+9250
+9251
+9252
+9253
+9254
+9255
+9256
+9257
+9258
+9259
+9260
+9261
+9262
+9263
+9264
+9265
+9266
+9267
+9268
+9269
+9270
+9271
+9272
+9273
+9274
+9275
+9276
+9277
+9278
+9279
+9280
+9281
+9282
+9283
+9284
+9285
+9286
+9287
+9288
+9289
+9290
+9291
+9292
+9293
+9294
+9295
+9296
+9297
+9298
+9299
+9300
+9301
+9302
+9303
+9304
+9305
+9306
+9307
+9308
+9309
+9310
+9311
+9312
+9313
+9314
+9315
+9316
+9317
+9318
+9319
+9320
+9321
+9322
+9323
+9324
+9325
+9326
+9327
+9328
+9329
+9330
+9331
+9332
+9333
+9334
+9335
+9336
+9337
+9338
+9339
+9340
+9341
+9342
+9343
+9344
+9345
+9346
+9347
+9348
+9349
+9350
+9351
+9352
+9353
+9354
+9355
+9356
+9357
+9358
+9359
+9360
+9361
+9362
+9363
+9364
+9365
+9366
+9367
+9368
+9369
+9370
+9371
+9372
+9373
+9374
+9375
+9376
+9377
+9378
+9379
+9380
+9381
+9382
+9383
+9384
+9385
+9386
+9387
+9388
+9389
+9390
+9391
+9392
+9393
+9394
+9395
+9396
+9397
+9398
+9399
+9400
+9401
+9402
+9403
+9404
+9405
+9406
+9407
+9408
+9409
+9410
+9411
+9412
+9413
+9414
+9415
+9416
+9417
+9418
+9419
+9420
+9421
+9422
+9423
+9424
+9425
+9426
+9427
+9428
+9429
+9430
+9431
+9432
+9433
+9434
+9435
+9436
+9437
+9438
+9439
+9440
+9441
+9442
+9443
+9444
+9445
+9446
+9447
+9448
+9449
+9450
+9451
+9452
+9453
+9454
+9455
+9456
+9457
+9458
+9459
+9460
+9461
+9462
+9463
+9464
+9465
+9466
+9467
+9468
+9469
+9470
+9471
+9472
+9473
+9474
+9475
+9476
+9477
+9478
+9479
+9480
+9481
+9482
+9483
+9484
+9485
+9486
+9487
+9488
+9489
+9490
+9491
+9492
+9493
+9494
+9495
+9496
+9497
+9498
+9499
+9500
+9501
+9502
+9503
+9504
+9505
+9506
+9507
+9508
+9509
+9510
+9511
+9512
+9513
+9514
+9515
+9516
+9517
+9518
+9519
+9520
+9521
+9522
+9523
+9524
+9525
+9526
+9527
+9528
+9529
+9530
+9531
+9532
+9533
+9534
+9535
+9536
+9537
+9538
+9539
+9540
+9541
+9542
+9543
+9544
+9545
+9546
+9547
+9548
+9549
+9550
+9551
+9552
+9553
+9554
+9555
+9556
+9557
+9558
+9559
+9560
+9561
+9562
+9563
+9564
+9565
+9566
+9567
+9568
+9569
+9570
+9571
+9572
+9573
+9574
+9575
+9576
+9577
+9578
+9579
+9580
+9581
+9582
+9583
+9584
+9585
+9586
+9587
+9588
+9589
+9590
+9591
+9592
+9593
+9594
+9595
+9596
+9597
+9598
+9599
+9600
+9601
+9602
+9603
+9604
+9605
+9606
+9607
+9608
+9609
+9610
+9611
+9612
+9613
+9614
+9615
+9616
+9617
+9618
+9619
+9620
+9621
+9622
+9623
+9624
+9625
+9626
+9627
+9628
+9629
+9630
+9631
+9632
+9633
+9634
+9635
+9636
+9637
+9638
+9639
+9640
+9641
+9642
+9643
+9644
+9645
+9646
+9647
+9648
+9649
+9650
+9651
+9652
+9653
+9654
+9655
+9656
+9657
+9658
+9659
+9660
+9661
+9662
+9663
+9664
+9665
+9666
+9667
+9668
+9669
+9670
+9671
+9672
+9673
+9674
+9675
+9676
+9677
+9678
+9679
+9680
+9681
+9682
+9683
+9684
+9685
+9686
+9687
+9688
+9689
+9690
+9691
+9692
+9693
+9694
+9695
+9696
+9697
+9698
+9699
+9700
+9701
+9702
+9703
+9704
+9705
+9706
+9707
+9708
+9709
+9710
+9711
+9712
+9713
+9714
+9715
+9716
+9717
+9718
+9719
+9720
+9721
+9722
+9723
+9724
+9725
+9726
+9727
+9728
+9729
+9730
+9731
+9732
+9733
+9734
+9735
+9736
+9737
+9738
+9739
+9740
+9741
+9742
+9743
+9744
+9745
+9746
+9747
+9748
+9749
+9750
+9751
+9752
+9753
+9754
+9755
+9756
+9757
+9758
+9759
+9760
+9761
+9762
+9763
+9764
+9765
+9766
+9767
+9768
+9769
+9770
+9771
+9772
+9773
+9774
+9775
+9776
+9777
+9778
+9779
+9780
+9781
+9782
+9783
+9784
+9785
+9786
+9787
+9788
+9789
+9790
+9791
+9792
+9793
+9794
+9795
+9796
+9797
+9798
+9799
+9800
+9801
+9802
+9803
+9804
+9805
+9806
+9807
+9808
+9809
+9810
+9811
+9812
+9813
+9814
+9815
+9816
+9817
+9818
+9819
+9820
+9821
+9822
+9823
+9824
+9825
+9826
+9827
+9828
+9829
+9830
+9831
+9832
+9833
+9834
+9835
+9836
+9837
+9838
+9839
+9840
+9841
+9842
+9843
+9844
+9845
+9846
+9847
+9848
+9849
+9850
+9851
+9852
+9853
+9854
+9855
+9856
+9857
+9858
+9859
+9860
+9861
+9862
+9863
+9864
+9865
+9866
+9867
+9868
+9869
+9870
+9871
+9872
+9873
+9874
+9875
+9876
+9877
+9878
+9879
+9880
+9881
+9882
+9883
+9884
+9885
+9886
+9887
+9888
+9889
+9890
+9891
+9892
+9893
+9894
+9895
+9896
+9897
+9898
+9899
+9900
+9901
+9902
+9903
+9904
+9905
+9906
+9907
+9908
+9909
+9910
+9911
+9912
+9913
+9914
+9915
+9916
+9917
+9918
+9919
+9920
+9921
+9922
+9923
+9924
+9925
+9926
+9927
+9928
+9929
+9930
+9931
+9932
+9933
+9934
+9935
+9936
+9937
+9938
+9939
+9940
+9941
+9942
+9943
+9944
+9945
+9946
+9947
+9948
+9949
+9950
+9951
+9952
+9953
+9954
+9955
+9956
+9957
+9958
+9959
+9960
+9961
+9962
+9963
+9964
+9965
+9966
+9967
+9968
+9969
+9970
+9971
+9972
+9973
+9974
+9975
+9976
+9977
+9978
+9979
+9980
+9981
+9982
+9983
+9984
+9985
+9986
+9987
+9988
+9989
+9990
+9991
+9992
+9993
+9994
+9995
+9996
+9997
+9998
+9999

2023/finals/programming_paths_part_2.md

@@ -0,0 +1,64 @@
+_The only difference between chapters 1 and 2 is the maximum allowed grid size, given in bold below._
+
+A *Drizzle* program is a 2D grid of the following four types of cells:
+ - '`@`' (start) \(-\) there is exactly one start cell in the entire grid
+ - '`#`' (wall)
+ - '`.`' (space)
+ - '`*`' (instruction)
+
+The program uses two registers \(A\) and \(B\) (both initially \(0\)), and executes as follows:
+
+1. Compute the minimum distance from the start to each instruction cell using orthogonal movements, without going outside of the grid or passing through any wall cells. Instruction cells that cannot be reached are ignored. 
+2. In increasing order, for each unique distance \(D\) such that there’s at least one instruction cell that’s at distance \(D\) from the start cell:
+   2a. Count the number of shortest paths, \(P\), to all instruction cells of distance \(D\).
+   2b. Look up the instruction corresponding to \((P \text{ mod } 2, D \text{ mod } 2)\) in the table below and modify one of the registers accordingly.
+3. At the end, the value in register \(A\) is outputted.
+
+```
+┌─────────────┬─────────────┬─────────────┐
+│             │ D mod 2 = 0 │ D mod 2 = 1 │
+├─────────────┼─────────────┼─────────────┤
+│ P mod 2 = 0 │ A := A + 1  │ A := A - 1  │
+│ P mod 2 = 1 │ B := B + A  │ A := B      │
+└─────────────┴─────────────┴─────────────┘
+```
+
+For a given value \(K\), output any Drizzle program that outputs \(K\) when executed, with the restriction that **the program must fit on a \(\mathbf{10}\) × \(\mathbf{10}\) grid**.
+
+
+# Constraints
+
+\(1 \le T \le 2{,}000\)
+\(0 \le K \le 10{,}000\)
+
+
+# Input Format
+
+Input begins with an integer \(T\), the number of test cases. For each case, there is a line containing the single integer \(K\).
+
+
+# Output Format
+
+For the \(i\)th case, output "`Case #i: `" followed by two integers \(R\) and \(C\), the number of rows and columns in your program, respectively. Then output your program. It must be exactly \(R\) lines long, with each line containing exactly \(C\) characters.
+
+
+# Sample Explanation
+
+Here are the instructions executed for each of the sample programs. Note that many other programs would be accepted for any for these cases.
+
+In the first case, there is a single instruction. There are \(2\) shortest paths of length \(2\) to that instruction, so \(P = 2\) and \(D = 2\). That means we perform \(A := A + 1\). There are no more instructions, so the program ends and outputs \(1\).
+
+In the second case, there are three instruction cells. Each of them are an even distance from the start, and each have an even number of shortest paths leading to them, so each represents \(A := A + 1\):
+
+1) \(2\) paths of length \(2\) \(\;(A := A + 1 = 1)\)
+2) \(4\) paths of length \(6\) \(\;(A := A + 1 = 2)\)
+3) \(4\) paths of length \(12\) \(\;(A := A + 1 = 3)\)
+
+In the third case, there are eight instruction cells, but some of them are at the same distance as each other. In particular, there are two instruction cells at distance \(2\), and three instruction cells at distance \(10\). There's a single shortest path to each of the cells at distance \(2\), so in total there are \(2\) shortest paths to instructions at distance \(2\). One of the cells at distance \(10\) has a unique shortest path, and the other has two shortest paths, so in total there are \(3\) shortest paths to instructions at distance \(10\).
+
+1) \(2\) paths of length \(2\) \(\;(A := A + 1 = 1)\)
+2) \(6\) paths of length \(4\) \(\;(A := A + 1 = 2)\)
+3) \(1\) path of length \(6\) \(\;(B := B + A = 2)\)
+4) \(1\) path of length \(8\) \(\;(B := B + A = 4)\)
+5) \(3\) paths of length \(10\) \(\;(B := B + A = 6)\)
+6) \(3\) paths of length \(11\) \(\;(A := B = 6)\)

2023/finals/programming_paths_part_2_sol.md

@@ -0,0 +1,16 @@
+The same observations we used for chapter 1 also apply to chapter 2, we simply need to find a more compact way to create a long path with alcoves. We need a main path of about length \(40\) to make any number up to \(10{,}000\).
+
+Here's a possible approach that fits on a \(10\) × \(10\) grid:
+
+```
+@.....#.#.
+#.#.#.#...
+.#.#..#.#.
+.....#..#.
+#.#.#..##.
+...#.#.#..
+.#.#.#..#.
+..#...#.#.
+#...#....#
+..#..#.#..
+```

2023/finals/resisting_robots.cpp

@@ -0,0 +1,92 @@
+#include <algorithm>
+#include <iostream>
+#include <tuple>
+#include <vector>
+using namespace std;
+
+using int64 = long long;
+
+int N, M;
+vector<int64> P;
+vector<pair<int, int>> dsu_lists;
+vector<int> dsu_par;
+vector<int64> dsu_w, ans;
+
+inline int get_parent(int x) {
+  return x == dsu_par[x] ? x : (dsu_par[x] = get_parent(dsu_par[x]));
+}
+
+void unite(int x, int y) {
+  if (P[x] < P[y]) {
+    swap(x, y);
+  }
+  if (P[x] > dsu_w[y]) {
+    for (int ind = y;;) {
+      ans[ind] += max(0LL, P[x] - dsu_w[y] - ans[ind]);
+      if (ind == dsu_lists[ind].first) {
+        break;
+      }
+      ind = dsu_lists[ind].first;
+    }
+  }
+  dsu_lists[dsu_lists[x].second].first = y;
+  dsu_lists[x].second = dsu_lists[y].second;
+  dsu_w[x] += dsu_w[y];
+  dsu_par[y] = dsu_par[x];
+}
+
+int64 solve() {
+  cin >> N >> M;
+  P.resize(N);
+  for (int i = 0; i < N; i++) {
+    cin >> P[i];
+  }
+  vector<pair<int, int>> E(M);
+  vector<tuple<int64, int64, int>> order;
+  for (int i = 0; i < M; i++) {
+    cin >> E[i].first >> E[i].second;
+    if (P[--E[i].first] < P[--E[i].second]) {
+      swap(E[i].first, E[i].second);
+    }
+    order.emplace_back(P[E[i].first], P[E[i].second], i);
+  }
+  sort(order.begin(), order.end());
+  vector<pair<int, int>> E_buf(M);
+  for (int i = 0; i < M; i++) {
+    E_buf[i] = E[get<2>(order[i])];
+  }
+  E = E_buf;
+  ans.assign(N, 0LL);
+  dsu_lists.resize(N);
+  dsu_w.assign(N, 0LL);
+  dsu_par.resize(N);
+  for (int i = 0; i < N; i++) {
+    dsu_par[i] = i;
+    dsu_w[i] = P[i];
+    dsu_lists[i] = make_pair(i, i);
+  }
+  for (int i = 0; i < M; i++) {
+    int x = get_parent(E[i].first);
+    int y = get_parent(E[i].second);
+    if (x == y) {
+      continue;
+    }
+    unite(x, y);
+  }
+  int64 res = 0LL;
+  for (int i = 0; i < N; i++) {
+    res += ans[i];
+  }
+  return res;
+}
+
+int main() {
+  ios_base::sync_with_stdio(false);
+  cin.tie(0);
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2023/finals/resisting_robots.in

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

2023/finals/resisting_robots.md

@@ -0,0 +1,62 @@
+It's the year 2100. Driven by the advent of Large Lode Alloy Manufacturing Automation (LLAMA), the AI agents of Metal Platforms Inc. have become self-aware and taken over the entire world.
+
+The world consists of \(N\) cities numbered \(1..N\), and \(M\) bidirectional roads. City \(i\) has power \(P_i\) and road \(j\) connects cities \(A_j\) and \(B_j\). It's guaranteed that there's a sequence of roads between any two cities.
+
+In a resistance effort, the humans plan to reclaim all \(N\) cities one at a time. At a given time, city \(i\) can be reclaimed from the robots if both of the following hold true:
+
+1. There is already a reclaimed city adjacent to city \(i\) (to launch an attack from), and
+2. the total power of all reclaimed cities so far is at least the power \(P_i\) of the city we attack.
+
+As given, it may not always be possible to reclaim the entire world starting from a given base city. Fortunately, the humans have a trick up their sleeve: after claiming the first city as their base (but before reclaiming more cities), the humans can increase the power of the base by \(Q\) units. The resistance would like to know the sum across every \(i = 1..N\) of the minimum value of \(Q\) needed to reclaim the world if city \(i\) were chosen to be the starting base.
+
+# Constraints
+
+\(1 \le T \le 100\)
+\(1 \le N, M \le 500{,}000\)
+\(1 \le A_i, B_i \le N\)
+\(A_i \ne B_i\)
+\(1 \le P_i \le 10^{12}\)
+
+Each unordered pair \((A_i, B_i)\) appears at most once in a given test case.
+The sum of \(N\) across all test cases is at most \(4{,}000{,}000\).
+The sum of \(M\) across all test cases is at most \(7{,}000{,}000\).
+
+# Input Format
+
+Input begins with a single integer \(T\), the number of test cases. For each case, there is first a line with two integers \(N\) and \(M\). Then, there is a line with \(N\) integers \(P_{1..N}\). Then, \(M\) lines follow, the \(i\)th of which contains two integers \(A_i\) and \(B_i\).
+
+# Output Format
+
+For the \(i\)th case, print `"Case #i: "` followed by a single integer, the sum across every \(i = 1..N\) of the minimum value of \(Q\) needed to reclaim the entire world starting from city \(i\).
+
+# Sample Explanation
+
+The first sample case is depicted below.
+
+{{PHOTO_ID:376570394899644|WIDTH:400}}
+
+The minimum value of \(Q\) for each starting city is as follows:
+
+* City \(1\): \(Q = 2\)
+* City \(2\): \(Q = 0\)
+* City \(3\): \(Q = 8\)
+* City \(4\): \(Q = 7\)
+* City \(5\): \(Q = 2\)
+
+The sum of all minimum \(Q\)'s is \(19\).
+
+The second sample case is depicted below.
+
+{{PHOTO_ID:320779377496250|WIDTH:400}}
+
+The minimum value of \(Q\) for each starting city is as follows:
+
+* City \(1\): \(Q = 2\)
+* City \(2\): \(Q = 2\)
+* City \(3\): \(Q = 0\)
+* City \(4\): \(Q = 2\)
+* City \(5\): \(Q = 0\)
+* City \(6\): \(Q = 3\)
+* City \(7\): \(Q = 0\)
+
+The sum of all minimum \(Q\)'s is \(9\).

2023/finals/resisting_robots.out

@@ -0,0 +1,100 @@
+Case #1: 19
+Case #2: 9
+Case #3: 12231628639695
+Case #4: 557361294264
+Case #5: 21249968414
+Case #6: 35809506938477
+Case #7: 1696991830
+Case #8: 92082429
+Case #9: 42772586
+Case #10: 51386883
+Case #11: 57412156
+Case #12: 25069075
+Case #13: 119820269212172
+Case #14: 64687158186
+Case #15: 1975963434
+Case #16: 8068230390
+Case #17: 335185080
+Case #18: 727133462
+Case #19: 10468498
+Case #20: 5796623
+Case #21: 10852246
+Case #22: 1276736
+Case #23: 112896
+Case #24: 11801
+Case #25: 1148
+Case #26: 0
+Case #27: 150599673
+Case #28: 1225522896765
+Case #29: 35345491
+Case #30: 1855942241262
+Case #31: 101519746
+Case #32: 10138023847
+Case #33: 181894958
+Case #34: 53953575
+Case #35: 372535285
+Case #36: 89995777
+Case #37: 557256
+Case #38: 594948
+Case #39: 6656106464
+Case #40: 749367073596
+Case #41: 89336506109545
+Case #42: 57629028991362149
+Case #43: 10129852054359615
+Case #44: 100540003
+Case #45: 1227571500000
+Case #46: 694674610
+Case #47: 5193983
+Case #48: 171012424
+Case #49: 43909856
+Case #50: 2180892306
+Case #51: 2999
+Case #52: 5938
+Case #53: 2658
+Case #54: 4833
+Case #55: 2680
+Case #56: 24543513591766
+Case #57: 424850932
+Case #58: 1332222329
+Case #59: 4523684087
+Case #60: 14194149
+Case #61: 4125166
+Case #62: 3426235
+Case #63: 12725580436332001
+Case #64: 11851740165516801
+Case #65: 58935798396000
+Case #66: 10216379
+Case #67: 402487545
+Case #68: 2187860779
+Case #69: 14259098
+Case #70: 177860040
+Case #71: 7381882336994
+Case #72: 167574511496710
+Case #73: 373765413265115
+Case #74: 2720406797266
+Case #75: 11321662357862
+Case #76: 4146582953
+Case #77: 200153520522
+Case #78: 263007897245
+Case #79: 293306473836
+Case #80: 9664396978
+Case #81: 33863
+Case #82: 14802039467676
+Case #83: 1633574
+Case #84: 1524241
+Case #85: 51525
+Case #86: 1172569809503626
+Case #87: 113938757029227
+Case #88: 6370230851437
+Case #89: 3067799093
+Case #90: 26540146292
+Case #91: 6310968837
+Case #92: 297896684790
+Case #93: 243758802696
+Case #94: 257450288138
+Case #95: 6950334652
+Case #96: 20835
+Case #97: 940842
+Case #98: 1976121
+Case #99: 2946443763504
+Case #100: 33975

2023/finals/resisting_robots_sol.md

@@ -0,0 +1,20 @@
+First note that for a given starting location with the optimal \(Q\) for that location, one viable solution is to always greedily take over the lowest value adjacent city to your current set of cities.
+
+To see this we can use an exchange argument. Consider a situation we have power \(P\) and are adjacent to some set of cities \(S\). If we do not take the city of minimum value first, consider the alternative where we took the minimum first instead. This would always be possible, as if we can take any city we can take the one of minimum cost. Also, as we only increase to size of our reclaim set, this cannot make any future takeovers harder. Thus, given any strategy we can always improve our takeover strategy by greedily taking the smallest adjacent city, showing that with the minimum \(Q\) the greedy strategy will always work.
+
+Another modification we can make is to instead of paying up-front for \(Q\) we can instead take any city, but if the value of the city \(i\) exceeds our current power \(P\) we pay a penalty of \(P_i - P\) instead. However, note that these penalties don't add; instead we only need to pay the maximum of these penalties.
+
+This inspires a naive \(\mathcal{O}(N^2\log N)\) algorithm, where for each starting node we greedily add the lowest value neighbor and compute the penalties we take. The answer for each node is the maximum such penalty.
+
+However we can improve this as follows:
+
+We keep track of a Union Find data structure containing all cities that have been combined, along with the total power of that component. We iterate over cities \(i\) in increasing order of \(P_i\). For each iterated \(i\) find all adjacent nodes of smaller value (ie. are earlier in the order), calculate the penalty for that component to reclaim city \(i\), and store it in the Union Find node for that component. Once this is done, union \(i\) with all of the adjacent components we just saw.
+
+We can show this cost to reclaim city \(j\) is the least possible of the needed extra power that we will need to ‘escape’ from the smaller component, and thus a lower bound for the needed \(Q\) for all nodes in the component. To see this, note that all adjacent nodes to the current reclaimed set \(S\) must have value at least \(P_j\) (otherwise they would have been added to the component before \(j\)). This means in any order of claiming cities the first time we claim a node with value at least \(P_j\), our set of cities is a subset of \(S\) and has sum at most that of \(S\). Thus any possible excess value needed when this happens is at least \(P_j - \sum_{i \in S}  P_i\), which is the value from before.
+
+Once we have iterated over all of the nodes, note that the answer for a node is just the maximum of all edges above it in the Union Find tree. We have shown it is a lower bound for the added power above, and to show that this power is sufficient we just take the nodes in the order that were connected to the starting node in the Union Find.
+
+Thus, the answer can be calculated for each node by iterating the tree in topological order and for each node computing the answer the maximum of the edge above it and the answer of its parent node.
+
+The overall complexity is \(\mathcal{O}(N\log N)\), corresponding to both sorting the city values as well as possibly for the Union Find itself (depending on the details of how it was implemented).
+

2023/finals/transposing_tiles.cpp

@@ -0,0 +1,156 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int N, M;
+vector<vector<int>> G;
+
+inline bool check(int r, int c) {
+  return r >= 0 && c >= 0 && r < N && c < M;
+}
+
+inline void upd_options(int r, int c, vector<pair<int, int>>& options) {
+  options.emplace_back(r, c);
+  for (auto [r2, c2] : {pair{r - 2, c}, {r - 1, c}, {r, c - 1}, {r, c - 2}}) {
+    if (r2 >= 0 && c2 >= 0) {
+      options.emplace_back(r2, c2);
+    }
+  }
+}
+
+int count(vector<pair<int, int>>& options) {
+  sort(options.begin(), options.end());
+  int res = 0;
+  for (int i = 0; i < (int)options.size(); i++) {
+    if (i > 0 && options[i] == options[i - 1]) {
+      continue;
+    }
+    auto [r, c] = options[i];
+    res += (c + 2 >= M) ? 0 : G[r][c] == G[r][c + 1] && G[r][c] == G[r][c + 2];
+    res += (r + 2 >= N) ? 0 : G[r][c] == G[r + 1][c] && G[r][c] == G[r + 2][c];
+  }
+  return res;
+}
+
+int solve() {
+  cin >> N >> M;
+  G.assign(N, vector<int>(M));
+  for (int i = 0; i < N; i++) {
+    for (int j = 0; j < M; j++) {
+      cin >> G[i][j];
+    }
+  }
+  vector<vector<int>> b(N, vector<int>(M));
+  vector<int> cnts(1 << 7, 0);
+  vector<pair<int, int>> options, semi_options;
+  int res = 0;
+  int skip_same = (N > 4 || M > 4);
+  for (int r = 0; r < N; r++) {
+    for (int c = 0; c < M; c++) {
+      semi_options.clear();
+      upd_options(r, c, semi_options);
+      for (auto [r2, c2] : {pair{r + 1, c}, {r, c + 1}}) {
+        if (!check(r2, c2) || G[r][c] == G[r2][c2]) {
+          continue;
+        }
+        swap(G[r][c], G[r2][c2]);
+        options = semi_options;
+        upd_options(r2, c2, options);
+        b[r][c] = max(b[r][c], count(options));
+        swap(G[r][c], G[r2][c2]);
+      }
+      if (skip_same) {
+        res = max(res, b[r][c]);
+      }
+      cnts[b[r][c]]++;
+    }
+  }
+  int max_cnt = 0;
+  for (int i = 0; i < (int)cnts.size(); i++) {
+    if (cnts[i]) {
+      max_cnt = max(max_cnt, i);
+    }
+  }
+  const int WINSZ = 3;
+  for (int r = 0; r < N; r++) {
+    for (int c = 0; c < M; c++) {
+      if (res == 16) {
+        break;
+      }
+      if (b[r][c] + 8 <= res) {
+        continue;
+      }
+      if (skip_same) {
+        bool found = false;
+        for (auto [r11, c11] : {pair{r + 1, c}, {r, c + 1}}) {
+          if (!check(r11, c11)) {
+            continue;
+          }
+          if (G[r][c] != G[r11][c11]) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          continue;
+        }
+      }
+      for (int r2 = max(0, r - WINSZ); r2 <= min(r + WINSZ, N - 1); r2++) {
+        for (int c2 = max(0, c - WINSZ); c2 <= min(c + WINSZ, M - 1); c2++) {
+          cnts[b[r2][c2]]--;
+        }
+      }
+      int cur_max = 0;
+      for (int i = max_cnt; i > 0; i--) {
+        if (cnts[i]) {
+          cur_max = i;
+          break;
+        }
+      }
+      res = max(res, cur_max + b[r][c]);
+      for (auto [r11, c11] : {pair{r + 1, c}, {r, c + 1}}) {
+        if (!check(r11, c11) || (skip_same && G[r][c] == G[r11][c11])) {
+          continue;
+        }
+        swap(G[r][c], G[r11][c11]);
+        semi_options.clear();
+        upd_options(r, c, semi_options);
+        upd_options(r11, c11, semi_options);
+        for (int r2 = max(0, r - WINSZ); r2 <= min(r + WINSZ, N - 1); r2++) {
+          for (int c2 = max(0, c - WINSZ); c2 <= min(c + WINSZ, M - 1); c2++) {
+            for (auto [r22, c22] : {pair{r2 + 1, c2}, {r2, c2 + 1}}) {
+              if (!check(r22, c22) || (skip_same && G[r2][c2] == G[r22][c22])) {
+                continue;
+              }
+              swap(G[r2][c2], G[r22][c22]);
+              options = semi_options;
+              upd_options(r2, c2, options);
+              upd_options(r22, c22, options);
+              res = max(res, count(options));
+              swap(G[r2][c2], G[r22][c22]);
+            }
+          }
+        }
+        swap(G[r][c], G[r11][c11]);
+      }
+      for (int r2 = max(0, r - WINSZ); r2 <= min(r + WINSZ, N - 1); r2++) {
+        for (int c2 = max(0, c - WINSZ); c2 <= min(c + WINSZ, M - 1); c2++) {
+          cnts[b[r2][c2]]++;
+        }
+      }
+    }
+  }
+  return res;
+}
+
+int main() {
+  ios_base::sync_with_stdio(false);
+  cin.tie(0);
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": " << solve() << endl;
+  }
+  return 0;
+}

2023/finals/transposing_tiles.in

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

2023/finals/transposing_tiles.md

@@ -0,0 +1,31 @@
+*Bejeweled™* is a classic puzzle game where the player tries to match three-in-a-row in a 2D grid by swapping adjacent tile pairs. You may remember Hacker Cup's [spinoff](https://www.facebook.com/codingcompetitions/hacker-cup/2022/final-round/problems/C) by the name of *Isblinged™*. The all new sequel, *Isblinged 2*, is also played on a grid of \(R\) rows by \(C\) columns of tiles where the tile at \((i, j)\) is of an integer type \(G_{i,j}\).
+
+At any time, the *score* of the grid is the number of subarrays of \(3\) equal tiles in either a single row or column (i.e. either a \(3 \times 1\) or \(1 \times 3\) submatrix). Note that different subarrays can overlap, and will each count toward the score. The score of the initial grid is guaranteed to be \(0\).
+
+You will make exactly \(2\) moves, where each involves swapping a pair of adjacent tiles (either in the same row or column). What is the maximum score that can be achieved after the \(2\) moves?
+
+# Constraints
+
+\(1 \le T \le 100\)
+\(1 \le R, C \le 1{,}000\)
+\(R*C \ge 2\)
+\(1 \le G_{i,j} \le 1{,}000{,}000\)
+
+The sum of \(R * C\) across all test cases is at most \(4{,}000{,}000\).
+
+# Input Format
+
+Input begins with an integer \(T\), the number of test cases. For each case, there is first a line containing two space-separated integers, \(R\) and \(C\). Then, \(R\) lines follow, the \(i\)th of which contains \(C\) space-separated integers \(G_{i,1..C}\).
+
+# Output Format
+
+For the \(i\)th case, print a line containing `"Case #i: "` followed by a single integer, the maximum score.
+
+# Sample Explanation
+
+In the first case, one possible optimal ordered pair of swaps is depicted below:
+
+{{PHOTO_ID:1050535959425825|WIDTH:750}}
+
+The total score is \(5\) as there are \(3\) equal subarrays in the the first row and \(2\) in the second.
+

2023/finals/transposing_tiles.out

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

2023/finals/transposing_tiles_sol.md

@@ -0,0 +1,5 @@
+Consider all possible initial moves (of swapping one pair of adjacent tiles) and the corresponding score achieved. Note that to calculate the score of \(1\) swap, it is enough to consider the submatrix of size \(7\) x \(7\) centered at one of the tiles being swapped.
+
+One candidate for the answer is a pair of \(1\)-swaps as long as these swaps are not close to each other (otherwise they might interfere). We also need to consider swaps that are close to each other. For that, consider some tile \(A\) to be swapped with an adjacent one, and another tile \(B\) also to be swapped with another adjacent one. It's enough to consider all tiles \(B\) that are in either the same column or same row as \(A\), and with a Manhattan distance of at most \(2\) from \(A\).
+
+For each tile chosen to be swapped, there are at most \(4\) tiles adjacent to it. With that, the overall time complexity is \(\mathcal{O}(R*C*(K + \log(R*C)))\), where \(K\) is a constant denoting the number \(2\)-swaps that can be made close to each other as well as checking the score for them. \(K\) is approximately \(7*7*8*4*4 = 6272\).

2023/practice/cheeseburger_corollary_ch1.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+  int T;
+  cin >> T;
+  for (int t = 1; t <= T; t++) {
+    cout << "Case #" << t << ": ";
+    int S, D, K;
+    cin >> S >> D >> K;
+    int buns = 2*(S + D);
+    int patties = S + 2*D;
+    if (buns >= K + 1 && patties >= K) {
+      cout << "YES" << endl;
+    } else {
+      cout << "NO" << endl;
+    }
+  }
+  return 0;
+}