2020 Problems

.gitattributes

@@ -78,3 +78,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 2019/finals/little_boat_on_the_sea.in filter=lfs diff=lfs merge=lfs -text
 2019/finals/temporal_revision.in filter=lfs diff=lfs merge=lfs -text
 2019/round3/chain_of_command.in filter=lfs diff=lfs merge=lfs -text
+2020/finals/cryptoconference.in filter=lfs diff=lfs merge=lfs -text
+2020/finals/somebody_elses_problem.in filter=lfs diff=lfs merge=lfs -text
+2020/quals/running_on_fumes_ch1.in filter=lfs diff=lfs merge=lfs -text
+2020/quals/running_on_fumes_ch2.in filter=lfs diff=lfs merge=lfs -text
+2020/quals/timber.in filter=lfs diff=lfs merge=lfs -text

2020/finals/cake_cutting_committee.cpp

@@ -0,0 +1,353 @@
+// Cake-Cutting Committee
+// Solution by Jacob Plachta
+
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <complex>
+#include <cstdlib>
+#include <ctime>
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <bitset>
+#include <sstream>
+using namespace std;
+
+#define LL long long
+#define LD long double
+#define PR pair<int,int>
+
+#define Fox(i,n) for (i=0; i<n; i++)
+#define Fox1(i,n) for (i=1; i<=n; i++)
+#define FoxI(i,a,b) for (i=a; i<=b; i++)
+#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
+#define FoxR1(i,n) for (i=n; i>0; i--)
+#define FoxRI(i,a,b) for (i=b; i>=a; i--)
+#define Foxen(i,s) for (auto i:s)
+#define Min(a,b) a=min(a,b)
+#define Max(a,b) a=max(a,b)
+#define Sz(s) int((s).size())
+#define All(s) (s).begin(),(s).end()
+#define Fill(s,v) memset(s,v,sizeof(s))
+#define pb push_back
+#define mp make_pair
+#define x first
+#define y second
+
+template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
+template<typename T> T Sqr(T x) { return(x * x); }
+string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }
+
+const int INF = (int)1e9;
+const LD EPS = 1e-12;
+const LD PI = acos(-1.0);
+
+#define GETCHAR getchar_unlocked
+
+bool Read(int& x) {
+  char c, r = 0, n = 0;
+  x = 0;
+  for (;;) {
+    c = GETCHAR();
+    if ((c < 0) && (!r))
+      return(0);
+    if ((c == '-') && (!r))
+      n = 1;
+    else if ((c >= '0') && (c <= '9'))
+      x = x * 10 + c - '0', r = 1;
+    else if (r)
+      break;
+  }
+  if (n)
+    x = -x;
+  return(1);
+}
+
+#define LIM 800
+
+#define TVAL int
+#define TLAZY int
+#define TLIM 4100
+
+TVAL ZERO_VAL = 0;
+TLAZY ZERO_LAZY = 0;
+
+struct SegTree
+{
+  void UpdateValForUpdateOrLazy(TVAL& a, TLAZY v)
+  {
+    a += v;
+  }
+
+  void UpdateLazyForUpdateOrLazy(TLAZY& a, TLAZY v)
+  {
+    a += v;
+  }
+
+  TVAL CombVals(TVAL v1, TVAL v2)
+  {
+    return(max(v1, v2));
+  }
+
+  int N, sz;
+  TVAL tree[TLIM];
+  TLAZY lazy[TLIM];
+
+  SegTree() {}
+
+  SegTree(int _N)
+  {
+    Init(_N);
+  }
+
+  void Init(int _N)
+  {
+    N = _N;
+    for (sz = 1; sz < N; sz <<= 1);
+    Clear();
+  }
+
+  void Clear()
+  {
+    int i;
+    Fox(i, sz << 1)
+      tree[i] = ZERO_VAL;
+    Fox(i, sz << 1)
+      lazy[i] = ZERO_LAZY;
+  }
+
+  void Prop(int i)
+  {
+    TLAZY v = lazy[i];
+    lazy[i] = ZERO_LAZY;
+    UpdateValForUpdateOrLazy(tree[i], v);
+    if (i < sz)
+    {
+      int c1 = i << 1, c2 = c1 + 1;
+      UpdateLazyForUpdateOrLazy(lazy[c1], v);
+      UpdateLazyForUpdateOrLazy(lazy[c2], v);
+    }
+  }
+
+  void Comp(int i)
+  {
+    int c1 = i << 1, c2 = c1 + 1;
+    tree[i] = CombVals(tree[c1], tree[c2]);
+  }
+
+  TVAL Query(
+    int a, int b,
+    int i = 1, int r1 = 0, int r2 = -1
+  ) {
+    if (r2 < 0)
+    {
+      Max(a, 0);
+      Min(b, sz - 1);
+      if (a > b)
+        return ZERO_VAL;
+      r2 = sz - 1;
+    }
+    Prop(i);
+    if (a <= r1 && r2 <= b)
+      return(tree[i]);
+    int m = (r1 + r2) >> 1, c = i << 1;
+    TVAL ret = ZERO_VAL;
+    if (a <= m)
+      ret = CombVals(ret, Query(a, b, c, r1, m));
+    if (b > m)
+      ret = CombVals(ret, Query(a, b, c + 1, m + 1, r2));
+    return(ret);
+  }
+
+  void Update(
+    int a, int b,
+    TLAZY v,
+    int i = 1, int r1 = 0, int r2 = -1
+  ) {
+    if (r2 < 0)
+    {
+      Max(a, 0);
+      Min(b, sz - 1);
+      if (a > b)
+        return;
+      r2 = sz - 1;
+    }
+    Prop(i);
+    if (a <= r1 && r2 <= b)
+    {
+      UpdateLazyForUpdateOrLazy(lazy[i], v);
+      Prop(i);
+      return;
+    }
+    int m = (r1 + r2) >> 1, c = i << 1;
+    if (a <= m)
+      Update(a, b, v, c, r1, m);
+    if (b > m)
+      Update(a, b, v, c + 1, m + 1, r2);
+    Prop(c), Prop(c + 1), Comp(i);
+  }
+};
+
+struct Event
+{
+  int x, y1, y2, c;
+  bool s;
+};
+
+const bool operator<(const Event& a, const Event& b)
+{
+  return(mp(a.x, !a.s) < mp(b.x, !b.s));
+}
+
+int S, N;
+int C[LIM], P[LIM][4];
+
+bool IsBetween(int a, int b, int p, bool ex)
+{
+  if (b < a)
+    b += INF;
+  if (p < a)
+    p += INF;
+  return ex ? a < p && p < b : a <= p && p <= b;
+}
+
+int GetPosAfter(int a, int p)
+{
+  if (p < a)
+    p += INF;
+  return(p - a);
+}
+
+int SolveForLine(vector<int> h)
+{
+  int i, j, s;
+  // compare all pieces against dividing line, and assemble line sweep events
+  int base = 0;
+  vector<int> CY;
+  vector<Event> E;
+  Fox(i, N)
+  {
+    // full intersection?
+    if (
+      (IsBetween(P[i][0], P[i][2], h[0], 0) || IsBetween(P[i][3], P[i][1], h[0], 0)) &&
+      (IsBetween(P[i][0], P[i][2], h[1], 0) || IsBetween(P[i][3], P[i][1], h[1], 0))
+      )
+    {
+      base += C[i];
+      continue;
+    }
+    // look for orientation of line segments such that at least one spans crosses from the 1st to the 2nd half
+    Fox(s, 2)
+    {
+      int p[4];
+      memcpy(p, P[i], sizeof(p));
+      if (s)
+        reverse(p, p + 4);
+      // check which points are on their required halves
+      bool bx[2], by[2];
+      Fox(j, 2)
+      {
+        bx[j] = IsBetween(h[0], h[1], p[j * 2], 0);
+        by[j] = IsBetween(h[1], h[0], p[j * 2 + 1], 0);
+      }
+      // neither line segment is entirely valid?
+      if ((!bx[0] || !by[0]) && (!bx[1] || !by[1]))
+        continue;
+      assert(bx[0] + by[0] + bx[1] + by[1] >= 3); // other one must be at least half-valid
+      // map points to positions on their halves
+      int x[2], y[2];
+      Fox(j, 2)
+      {
+        x[j] = bx[j] ? GetPosAfter(h[0], p[j * 2]) : 2 * INF * (j ? 1 : -1);
+        y[j] = by[j] ? -GetPosAfter(h[1], p[j * 2 + 1]) : 2 * INF * (j ? 1 : -1);
+      }
+      assert(x[0] < x[1] && y[0] < y[1]);
+      E.pb({ x[0], y[0], y[1], C[i], 1 });
+      E.pb({ x[1], y[0], y[1], C[i], 0 });
+      CY.pb(y[0]), CY.pb(y[1]);
+      break;
+    }
+  }
+  // compress Y-coordinates
+  sort(All(CY));
+  int K = unique(All(CY)) - CY.begin();
+  CY.resize(K);
+  // line sweep
+  SegTree ST(K);
+  sort(All(E));
+  Foxen(e, E)
+  {
+    e.y1 = lower_bound(All(CY), e.y1) - CY.begin();
+    e.y2 = lower_bound(All(CY), e.y2) - CY.begin();
+    // left edge of a rectangle?
+    if (e.s)
+    {
+      ST.Update(e.y1, K - 1, e.c);
+      continue;
+    }
+    // right edge of a rectangle
+    ST.Update(e.y2, e.y2, ST.Query(e.y2, K - 1) - ST.Query(e.y2, e.y2));
+    ST.Update(e.y2 + 1, K - 1, -e.c);
+  }
+  return(base + ST.Query(0, K - 1));
+}
+
+int ProcessCase()
+{
+  int i, j;
+  // input
+  Read(S), Read(N);
+  Fox(i, N)
+  {
+    Read(C[i]);
+    Fox(j, 4)
+    {
+      int x, y;
+      Read(x), Read(y);
+      if (!x)
+        P[i][j] = y;
+      else if (y == S)
+        P[i][j] = S + x;
+      else if (x == S)
+        P[i][j] = 3 * S - y;
+      else
+        P[i][j] = 4 * S - x;
+    }
+    // normalize lines
+    if (IsBetween(P[i][1], P[i][0], P[i][2], 1))
+      swap(P[i][0], P[i][1]);
+    if (IsBetween(P[i][2], P[i][3], P[i][0], 1))
+      swap(P[i][2], P[i][3]);
+  }
+  // consider all possible dividing lines
+  int ans = 0;
+  Fox(i, N)
+  {
+    Fox(j, 2)
+      Max(ans, SolveForLine({ P[i][j * 2], P[i][j * 2 + 1] }));
+  }
+  return(ans);
+}
+
+int main()
+{
+  int T, t;
+  Read(T);
+  Fox1(t, T)
+    printf("Case #%d: %d\n", t, ProcessCase());
+  return(0);
+}

2020/finals/cake_cutting_committee.md

@@ -0,0 +1,67 @@
+Melody is preparing a cake for a very special occasion. She's starting off with a square cake, though she'd like it cut down into a more unique shape. When viewed from above, it can be represented as a square on a 2D plane, with opposite corners at coordinates \((0, 0)\) and \((S, S)\).
+
+Out of countless contenders, Melody has interviewed \(N\) certified cake-cutting consultants, asking how the cake should be cut down. The \(i\)th consultant, who has a competence value of \(C_i\), has proposed that two cuts should be performed: the first being a line segment between coordinates \((X_{i,1}, Y_{i,1})\) and \((X_{i,2}, Y_{i,2})\), and the second between \((X_{i,3}, Y_{i,3})\) and \((X_{i,4}, Y_{i,4})\). Each of these four points is exactly on a side of the cake (but not on a corner), the two points describing each line segment are not on the same side of the cake, and the two line segments do not share any points in common (in other words, they don't intersect nor have any equal endpoints). Therefore, the two cuts would split the cake into three non-empty polygonal sections. Of those, the middle section (the one between the two cuts) would become their **proposed cake shape**, with the other two sections discarded.
+
+For example, the following diagram illustrates a cake with \(S = 10\) and a consultant's pair of proposed cuts (from \((4, 10)\) to \((2, 0)\) and from \((0, 9)\) to \((2, 10)\)), with their resulting proposed cake shape highlighted in blue:
+
+{{PHOTO_ID:186542789854750}}
+
+Melody wants to hire one or more of the consultants to form a committee, whose members will then deliberate on the final shape of the cake. That is, she calls for a completely competent consulting committee capable of coming to a consensus on a commendable cake-cutting configuration. Clearly.
+
+She wants the sum of the hired consultants' competence values to be as large as possible, no matter how many of them she has to hire. However, she won't allow a pair of consultants to both be part of the committee if their cake-cutting proposals *fundamentally differ*, which is the case if their proposed cake shapes do not share any points in common (in other words, if those two polygons are entirely disjoint, including at their edges and vertices).
+
+For example, the following diagram additionally includes another consultant's pair of proposed cuts (from (7, 10) to (10, 7) and from (10, 5) to (5, 10)), with their proposed cake shape highlighted in red. Since these two proposed cake shapes do not overlap at all, the two proposals fundamentally differ, meaning that if one of these consultants is hired, the other cannot also be hired:
+
+{{PHOTO_ID:3047534892140325}}
+
+On the other hand, each of the following cakes features a pair of proposals which do not fundamentally differ, due to the proposed cake shapes sharing at least one point in common (meaning that, for each cake, the two consultants could be hired together):
+
+{{PHOTO_ID:139722534273576}}
+
+Help Melody determine the maximum combined competence of consultants who can form the committee, such that no two of them have fundamentally differing cake-cutting proposals.
+
+# Constraints
+
+\(1 \le T \le 80\)
+\(1 \le N \le 800\)
+\(2 \le S \le 100,000,000\)
+\(1 \le C_i \le 500,000\)
+\(0 \le X_{i,j}, Y_{i,j} \le S\)
+
+The sum of \(N\) across all special occasions is at most 20,000.
+
+# Input
+
+Input begins with an integer \(T\), the number of special occasions. For each occasion, there are \(N + 1\) lines. The first line contains 2 space-separated integers, \(S\) and \(N\). \(N\) lines follow, the \(i\)th of which contains the 9 space-separated integers \(C_i\), \(X_{i,1}\), \(Y_{i,1}\), \(X_{i,2}\), \(Y_{i,2}\), \(X_{i,3}\), \(Y_{i,3}\), and \(X_{i,4}\), \(Y_{i,4}\).
+
+
+# Output
+
+For the \(i\)th special occasion, print a line containing *"Case #i: "*, followed by a single integer, the maximum combined competence of cake-cutting consultants who can form the committee.
+
+
+# Explanation of Sample
+
+The first cake (along with the consultants' proposed cake shapes) looks as follows:
+
+{{PHOTO_ID:2722961511304050}}
+
+The 1st and 2nd consultants can't both be hired together, but either can be hired alongside the 3rd consultant. So, the best Melody can do is to hire the 2nd and 3rd consultants for a combined competence of \(30 + 40 = 70\).
+
+The second cake looks as follows:
+
+{{PHOTO_ID:408936830244710}}
+
+Melody can hire all three consultants.
+
+The third cake looks as follows:
+
+{{PHOTO_ID:386528679257402}}
+
+The fourth cake looks as follows:
+
+{{PHOTO_ID:863939674419710}}
+
+The fifth cake looks as follows:
+
+{{PHOTO_ID:424906348725741}}

2020/finals/cake_cutting_committee.out

@@ -0,0 +1,112 @@
+Case #1: 70
+Case #2: 60
+Case #3: 60
+Case #4: 14
+Case #5: 11
+Case #6: 15
+Case #7: 26
+Case #8: 62
+Case #9: 59
+Case #10: 33
+Case #11: 10
+Case #12: 4
+Case #13: 8160
+Case #14: 7207
+Case #15: 7
+Case #16: 59
+Case #17: 41008
+Case #18: 52938
+Case #19: 17272
+Case #20: 250000000
+Case #21: 81000
+Case #22: 81000
+Case #23: 195153474
+Case #24: 157757408
+Case #25: 148427301
+Case #26: 33268941
+Case #27: 31942779
+Case #28: 29651063
+Case #29: 31340125
+Case #30: 29857414
+Case #31: 29451361
+Case #32: 29524220
+Case #33: 27477273
+Case #34: 30685666
+Case #35: 30626812
+Case #36: 27372492
+Case #37: 29689094
+Case #38: 5215
+Case #39: 55269
+Case #40: 3394
+Case #41: 1870
+Case #42: 3902
+Case #43: 1656
+Case #44: 22432
+Case #45: 61590
+Case #46: 2693
+Case #47: 11236
+Case #48: 4765
+Case #49: 11836
+Case #50: 25810
+Case #51: 17702
+Case #52: 69830
+Case #53: 13183
+Case #54: 39633
+Case #55: 16641
+Case #56: 20295
+Case #57: 8134
+Case #58: 371
+Case #59: 4361
+Case #60: 15012
+Case #61: 667
+Case #62: 7749
+Case #63: 7587
+Case #64: 66822
+Case #65: 13309
+Case #66: 8544
+Case #67: 62661
+Case #68: 22366
+Case #69: 1235
+Case #70: 12477
+Case #71: 12164
+Case #72: 7031
+Case #73: 21198
+Case #74: 15176
+Case #75: 6046
+Case #76: 1149
+Case #77: 35941
+Case #78: 810
+Case #79: 23259
+Case #80: 1335
+Case #81: 2950
+Case #82: 7170
+Case #83: 41925
+Case #84: 8782
+Case #85: 1107
+Case #86: 15565
+Case #87: 17094
+Case #88: 1250
+Case #89: 27818
+Case #90: 10246
+Case #91: 5690
+Case #92: 17200
+Case #93: 6868
+Case #94: 7621
+Case #95: 24280
+Case #96: 15790
+Case #97: 806
+Case #98: 24283
+Case #99: 21818
+Case #100: 636
+Case #101: 39706
+Case #102: 9505
+Case #103: 16829
+Case #104: 59786
+Case #105: 5017
+Case #106: 23559
+Case #107: 48806
+Case #108: 7429
+Case #109: 35980
+Case #110: 62511
+Case #111: 2200
+Case #112: 45468

2020/finals/cake_cutting_committee_sol.md

@@ -0,0 +1,18 @@
+We can number the possible positions of line segment endpoints from \(1\) to \(4(N-1)\) in clockwise order around the edge of the square, and then simply map all of the given line segment endpoints to these indices, noting that only their relative order is relevant for determining which proposed cake shapes overlap with one another.
+
+It's possible to show that, for any valid set of proposed cake shapes, there must exist at least one *key line segment* amongst them such that every polygon in the set overlaps with that line segment. We'll therefore consider all \(2N\) possible key line segments.
+
+For a given key line segment, each polygon either doesn't overlap with it at all (and so should be ignored), overlaps with all of it (and so may always be used), or overlaps with only part of it. For polygons falling into this final category, we're interested in the maximum combined value of any set of them such that each pair of them overlaps.
+
+The key line segment splits the full set of possible endpoint indices into two sections, which we'll call the X and Y sections. We can map each polygon's endpoints to new indices along these two sections, both numbered starting from the same ("first") endpoint of the key line segment (meaning that one section's sequence of indices is equivalent to increasing original indices, while the other section's is equivalent to decreasing original indices). If a polygon has 3 endpoints in one section and 1 endpoint in the other (as opposed to 2 in each), then we'll shift one of them over to one of the key line segment's endpoints without changing which other polygons it overlaps with.
+
+The result is that, for each line segment of each polygon, one endpoint will have been mapped to a new index in the X section, with the other mapped to a new index in the Y section. This allows us to represent each polygon by a pair of intervals \([x_1, x_2]\) and \([y_1, y_2]\) (consisting of its two X section indices and its two Y section indices, respectively). With this representation, we can then observe that a pair of polygons don't overlap if and only one of the polygons' X and Y intervals are both strictly to the right (or strictly to the left) of the other polygon's respective X and Y intervals.
+
+If we now visualize each such polygon as a rectangle on a 2D plane, with coordinates based on its X and Y intervals (in particular, with lower-left corner \((x_1, y_1)\) and upper-right corner \((x_1, y_1)\)), we're interested in the maximum combined value of any set of them such that no rectangle is strictly both above and to the right of any other rectangle. This may be accomplished in \(O(N log(N))\) time with a line sweep over the x-coordinates. We'll let \(M_y\) be the maximum combined value of a valid set of rectangles encountered so far, such that the lowest of their top-right corners encountered so far has y-coordinate `y`, and maintain this with the help of a segment tree:
+
+- When we encounter the left edge of a rectangle with bottom edge `y_1`, we should increase each of \(M_{y_1..\infty}\) by that rectangle's value (as this rectangle may be added to any such set).
+- When we encounter the right edge of a rectangle with top edge `y_2`, we should first set \(M_{y_2}\) to \(\max(M_{(y_2+1)..\infty})\) (as including this rectangle in any such set would decrease its lowest top-right corner to \(y_2\)). We should then decrease each of \(M_{(y_2+1)..\infty}\) by that rectangle's value (as this rectangle may no longer be added to any such set).
+
+Repeating the above process for all \(2N\) possible key line segments yields a solution with a time complexity of \(O(N^2 log(N))\) (though a less efficient, \(O(N^3)\) implementation would also suffice).
+
+For further reading, if we consider mapping the line segment endpoint indices to positions around the circumference of a circle instead (essentially treating the original square as a circle), each proposed cake shape is known as a *circle trapezoid*. The intersection graph of these polygons (a graph in which there's an edge between two pieces if and only if they overlap) is then known as a [*circle trapezoid graph*](https://en.wikipedia.org/wiki/Trapezoid_graph#Circle_trapezoid_graphs). The problem of computing the maximum clique weight in such a graph (equivalent to what's asked for in Cake-Cutting Committee), and other related problems, are explored further in [this paper](https://www.sciencedirect.com/science/article/pii/S0166218X96000133?via%3Dihub).

2020/finals/cryptoconference.cpp

@@ -0,0 +1,158 @@
+// Cryptoconference
+// Solution by Jacob Plachta
+
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <complex>
+#include <cstdlib>
+#include <ctime>
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <bitset>
+#include <sstream>
+using namespace std;
+
+#define LL long long
+#define LD long double
+#define PR pair<int,int>
+
+#define Fox(i,n) for (i=0; i<n; i++)
+#define Fox1(i,n) for (i=1; i<=n; i++)
+#define FoxI(i,a,b) for (i=a; i<=b; i++)
+#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
+#define FoxR1(i,n) for (i=n; i>0; i--)
+#define FoxRI(i,a,b) for (i=b; i>=a; i--)
+#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
+#define Min(a,b) a=min(a,b)
+#define Max(a,b) a=max(a,b)
+#define Sz(s) int((s).size())
+#define All(s) (s).begin(),(s).end()
+#define Fill(s,v) memset(s,v,sizeof(s))
+#define pb push_back
+#define mp make_pair
+#define x first
+#define y second
+
+template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
+template<typename T> T Sqr(T x) { return(x * x); }
+string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }
+
+const int INF = (int)1e9;
+const LD EPS = 1e-12;
+const LD PI = acos(-1.0);
+
+#define GETCHAR getchar_unlocked
+
+bool Read(int& x) {
+  char c, r = 0, n = 0;
+  x = 0;
+  for (;;) {
+    c = GETCHAR();
+    if ((c < 0) && (!r))
+      return(0);
+    if ((c == '-') && (!r))
+      n = 1;
+    else if ((c >= '0') && (c <= '9'))
+      x = x * 10 + c - '0', r = 1;
+    else if (r)
+      break;
+  }
+  if (n)
+    x = -x;
+  return(1);
+}
+
+#define MOD 1000000007
+
+int N, K;
+LL cur, ans;
+set<PR> S;
+
+// returns the # of valid intervals with start positions in:
+// (this interval's start, next interval's start]
+LL Count(set<PR>::iterator I)
+{
+  // get key points from this interval and the next one
+  int a = I->x + 1;
+  I++;
+  int b = I->x;
+  int c = I->y - 1;
+  // count intervals which start in [a, b] and end no later than c
+  int v1 = c - b;
+  int v2 = c - a;
+  return (LL)(v1 + v2) * (v2 - v1 + 1) / 2;
+}
+
+// inserts interval [a, b] into the set, while updating the total # of valid intervals
+void Insert(int a, int b)
+{
+  set<PR>::iterator I, J;
+  I = S.lower_bound(mp(a, -1));
+  // is the new interval obsolete (covers existing interval)?
+  if (a <= I->x && I->y <= b)
+    return;
+  // erase any existing obsolete intervals (covering the new one)
+  if (I->x > a)
+    I--;
+  for (;;)
+  {
+    if (I->y < b)
+      break;
+    J = I, I--;
+    cur -= Count(J) + Count(I);
+    S.erase(J);
+    cur += Count(I);
+  }
+  // insert the new interval
+  cur -= Count(I);
+  S.insert(mp(a, b));
+  cur += Count(I);
+  I++;
+  cur += Count(I);
+}
+
+LL ProcessCase()
+{
+  int i;
+  // input
+  Read(N), Read(K);
+  // init
+  S.clear();
+  S.insert(mp(-1, -1));
+  S.insert(mp(K, K + 1));
+  ans = 1;
+  cur = Count(S.begin());
+  // process intervals
+  Fox(i, N)
+  {
+    int s, d;
+    Read(s), Read(d);
+    Insert(s, s + d);
+    ans = ans * (cur % MOD) % MOD;
+  }
+  return(ans);
+}
+
+int main()
+{
+  int T, t;
+  Read(T);
+  Fox1(t, T)
+    printf("Case #%d: %lld\n", t, ProcessCase());
+  return(0);
+}

2020/finals/cryptoconference.in

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

2020/finals/cryptoconference.md

@@ -0,0 +1,41 @@
+Crys just invented a new cryptocurrency and is planning to present it at \(T\) blockchain conferences around the world. The conference schedules are already on their way to being finalized, but Crys is considering how she might get her own talks in at the last minute.
+
+A certain conference is \(K\) hours long, with talks to start and end on the hour. Each talk will span a non-empty inclusive time interval of hours \([x, y]\), such that \(x\) and \(y\) are integers and \(0 \le x \lt y \le K\). \(N\) talks are gradually being added to the schedule, one after another, with the \(i\)th added talk scheduled to span the time interval \([S_i, S_i + D_i]\). The \(N\) talks are not necessarily added in order of starting or ending time. Their time intervals may arbitrarily overlap with one another, and are not necessarily distinct.
+
+Each time a talk is added to the schedule, Crys will then consider submitting a request for her own talk to also be included. This involves proposing a time interval for her talk, which must similarly be an integral interval \([x, y]\) such that \(0 \le x \lt y \le K\). Crys suspects that her request would be rejected if the inclusion of her talk might prevent an attendee from hearing another talk due to her proposed time interval entirely subsuming an already-scheduled one. As such, after the first \(i\) talks have been added to the schedule, she will *not* propose a time interval \([x, y]\) if there exists any existing talk \(j\) \((1 \le j \le i)\) such that \(x \le S_j\) and \(S_j + D_j \le y\).
+
+Letting \(C_i\) be the number of different time intervals which Crys could validly propose for her talk after the first \(i\) talks have been added to the schedule, please determine the value of \((C_1 * C_2 * ... * C_N)\) modulo 1,000,000,007.
+
+# Constraints
+
+\(1 \le T \le 95\)
+\(1 \le N \le 300,000\)
+\(1 \le K \le 1,000,000,000\)
+\(0 \le S_i < K\)
+\(1 \le D_i \le K\)
+\(1 \le S_i + D_i \le K\)
+
+The sum of \(N\) across all conferences is at most 1,500,000.
+
+# Input
+
+Input begins with an integer \(T\), the number of conferences. For each conference there are \(N + 1\) lines. The first line contains the space-separated integers \(N\) and \(K\). \(N\) lines follow, the \(i\)th of which contains the space-separated integers \(S_i\) and \(D_i\).
+
+
+# Output
+
+For the \(i\)th conference, print a line containing *"Case #i: "*, followed by a single integer, the product of \(C_{1..N}\) modulo 1,000,000,007.
+
+
+
+
+
+# Explanation of Sample
+
+In the first conference, once a talk spanning time interval \([1, 2]\) exists, Crys can only propose time intervals \([0, 1]\) and \([2, 3]\) for her talk without subsuming \([1, 2]\). Therefore, \(C = [2]\).
+
+In the second conference, after the first talk (spanning time interval \([1, 3]\)) has been added to the schedule, Crys can propose any of the time intervals \([0, 1]\), \([0, 2]\), \([1, 2]\), or \([2, 3]\). After the introduction of the second talk (spanning time interval \([0, 2]\)), she can only propose \([0, 1]\), \([1, 2]\), or \([2, 3]\). Therefore, \(C = [4, 3]\), and the final answer is (4 * 3) modulo 1,000,000,007 = 12.
+
+In the third conference, \(C = [8, 4]\).
+
+In the fourth conference, \(C = [4126, 3631, 3239, 2687, 2687]\).

2020/finals/cryptoconference.out

@@ -0,0 +1,110 @@
+Case #1: 2
+Case #2: 12
+Case #3: 32
+Case #4: 352996146
+Case #5: 751550872
+Case #6: 20
+Case #7: 83444858
+Case #8: 572887886
+Case #9: 598916604
+Case #10: 470820377
+Case #11: 174927279
+Case #12: 896919730
+Case #13: 541761571
+Case #14: 515822691
+Case #15: 228409848
+Case #16: 659858375
+Case #17: 190419874
+Case #18: 948002069
+Case #19: 495164089
+Case #20: 989289949
+Case #21: 313062055
+Case #22: 317384968
+Case #23: 381355941
+Case #24: 861250172
+Case #25: 21268787
+Case #26: 426473611
+Case #27: 174566443
+Case #28: 270050563
+Case #29: 247721801
+Case #30: 128678835
+Case #31: 141554145
+Case #32: 589771144
+Case #33: 703459805
+Case #34: 770102403
+Case #35: 32994412
+Case #36: 98689617
+Case #37: 146465775
+Case #38: 429027202
+Case #39: 249562463
+Case #40: 939240223
+Case #41: 366445856
+Case #42: 629076290
+Case #43: 856574351
+Case #44: 816923530
+Case #45: 988573584
+Case #46: 227744671
+Case #47: 136671501
+Case #48: 552031554
+Case #49: 637297699
+Case #50: 0
+Case #51: 407393317
+Case #52: 648160821
+Case #53: 453730949
+Case #54: 626850629
+Case #55: 77514078
+Case #56: 776033559
+Case #57: 981403229
+Case #58: 164846153
+Case #59: 486727330
+Case #60: 181718458
+Case #61: 794033109
+Case #62: 741574342
+Case #63: 145879918
+Case #64: 171838401
+Case #65: 417158876
+Case #66: 725642265
+Case #67: 472767853
+Case #68: 740493091
+Case #69: 89444180
+Case #70: 608421866
+Case #71: 393203295
+Case #72: 879337785
+Case #73: 915216546
+Case #74: 290037518
+Case #75: 248932214
+Case #76: 953715588
+Case #77: 167356836
+Case #78: 317540564
+Case #79: 991575711
+Case #80: 879687486
+Case #81: 322773218
+Case #82: 589228118
+Case #83: 466166842
+Case #84: 748094367
+Case #85: 248333831
+Case #86: 515789417
+Case #87: 951341566
+Case #88: 948722510
+Case #89: 517082433
+Case #90: 535310061
+Case #91: 102636817
+Case #92: 805901472
+Case #93: 546788335
+Case #94: 684359382
+Case #95: 454605467
+Case #96: 310565738
+Case #97: 700636353
+Case #98: 266780658
+Case #99: 383812708
+Case #100: 664630757
+Case #101: 289228410
+Case #102: 957511402
+Case #103: 584046200
+Case #104: 58349857
+Case #105: 730036244
+Case #106: 945387917
+Case #107: 744001995
+Case #108: 854694249
+Case #109: 644309315
+Case #110: 801361727

2020/finals/cryptoconference_sol.md

@@ -0,0 +1,9 @@
+We'll maintain a set \(R\) of all "relevant" talk time intervals. An interval \([x, y]\) is considered irrelevant if ignoring it does not change the set of time intervals which may be proposed, which is the case if and only if there exists another interval which is inclusively contained within it (an interval \([x', y']\) such that \(x \le x'\) and \(y' \le y\)).
+
+We'll maintain \(R\) ordered by intervals' start times, in strictly increasing order. Note that this also means that the intervals' end times must be strictly increasing (otherwise, they cannot all be relevant). For convenience, we'll also begin by including dummy intervals \([-1, -1]\) and \([K, K+1]\) in \(R\), whose significance is explained below. From there, updating the set for each new interval may be done relatively straightforwardly in amortized \(O(log(N))\) time, with the new interval either already being irrelevant, or being relevant and causing 0 or more existing intervals to become irrelevant.
+
+What remains is maintaining the corresponding answer for \(R\) — that is, the number of time intervals which may be proposed without subsuming any interval in \(R\). For this purpose, let \(F([x_1, y_1], [x_2, y_2])\) be the number of different intervals \([x_p, y_p]\) which may be proposed such that \(x_1 < x_p \le x_2\), given that \([x_1, y_1]\) and \([x_2, y_2]\) form a pair of consecutive relevant intervals in \(R\). Note that \(F([x_1, y_1], [x_2, y_2])\) does not depend on any intervals in \(R\) besides those two, and may be easily computed in \(O(1)\) time using the fact that the only constraints are \(x_1 < x_p \le x_2\) and \(x_p < y_p < y_2\).
+
+We can observe that the sum of \(F([x_1, y_1], [x_2, y_2])\) over all pairs of consecutive relevant intervals (of which there are \(|R| - 1\)) is equal to the total answer — for example, this is the case when \(R\) consists only of the initial pair of dummy intervals \([-1, -1]\) and \([K, K+1]\), with additional intervals simply partitioning the set of possible start times. We can then maintain this sum with no additional time complexity as we go. For example, when inserting an interval \(X\) between two existing intervals \(A\) and \(B\), we should increase the sum by \(F(A, X) + F(X, B) - F(A, B)\), with deletions handled similarly.
+
+This gives us an algorithm with a time complexity of \(O(N log(N))\).

2020/finals/pond_precipitation.cpp

@@ -0,0 +1,178 @@
+// Pond Precipitation
+// Solution by Jacob Plachta
+
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <complex>
+#include <cstdlib>
+#include <ctime>
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <unordered_map>
+#include <set>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <bitset>
+#include <sstream>
+using namespace std;
+
+#define LL long long
+#define LD long double
+#define PR pair<int,int>
+
+#define Fox(i,n) for (i=0; i<n; i++)
+#define Fox1(i,n) for (i=1; i<=n; i++)
+#define FoxI(i,a,b) for (i=a; i<=b; i++)
+#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
+#define FoxR1(i,n) for (i=n; i>0; i--)
+#define FoxRI(i,a,b) for (i=b; i>=a; i--)
+#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
+#define Min(a,b) a=min(a,b)
+#define Max(a,b) a=max(a,b)
+#define Sz(s) int((s).size())
+#define All(s) (s).begin(),(s).end()
+#define Fill(s,v) memset(s,v,sizeof(s))
+#define pb push_back
+#define mp make_pair
+#define x first
+#define y second
+
+template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
+template<typename T> T Sqr(T x) { return(x * x); }
+string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }
+
+const int INF = (int)1e9;
+const LD EPS = 1e-12;
+const LD PI = acos(-1.0);
+
+#define GETCHAR getchar_unlocked
+
+bool Read(int& x)
+{
+  char c, r = 0, n = 0;
+  x = 0;
+  for (;;)
+  {
+    c = GETCHAR();
+    if ((c < 0) && (!r))
+      return(0);
+    if ((c == '-') && (!r))
+      n = 1;
+    else
+      if ((c >= '0') && (c <= '9'))
+        x = x * 10 + c - '0', r = 1;
+      else
+        if (r)
+          break;
+  }
+  if (n)
+    x = -x;
+  return(1);
+}
+
+#define LIM 32
+#define LIM2 500
+#define MOD 1000000007
+
+int N;
+int D[LIM], C[LIM];
+int ch[LIM2][LIM2];
+int dyn[LIM][LIM2];
+
+int Exp(int a, int b)
+{
+  LL p = a, v = 1;
+  while (b)
+  {
+    if (b & 1)
+      v = v * p % MOD;
+    p = p * p % MOD;
+    b >>= 1;
+  }
+  return(v);
+}
+
+void Add(int& a, int b)
+{
+  a = (a + b) % MOD;
+}
+
+int Prod(int a, int b)
+{
+  return((LL)a * b % MOD);
+}
+
+int Div(int a, int b)
+{
+  return Prod(a, Exp(b, MOD - 2));
+}
+
+int ProcessCase()
+{
+  int i, j, k;
+  // input
+  Read(N);
+  Fox(i, N)
+    Read(D[i]);
+  // compute max prefix capacities
+  int p = 0, s = 0;
+  Fox(i, N + 1)
+  {
+    if (i == N || D[i] < D[p])
+    {
+      FoxI(j, p, i - 1)
+        s += D[j] - D[p];
+      FoxI(j, p + (p ? 1 : 0), i)
+        C[j] = s;
+      p = i;
+    }
+  }
+  // DP
+  Fill(dyn, 0);
+  dyn[0][0] = 1;
+  Fox(i, N)
+  {
+    Fox(j, (i ? C[i - 1] : 0) + 1)
+    {
+      Fox(k, C[i] - j + 1)
+        Add(dyn[i + 1][j + k], Prod(dyn[i][j], ch[j + k][k]));
+    }
+  }
+  // compute answer
+  int ans = 0;
+  Fox(i, s + 1)
+    Add(ans, Div(dyn[N][i], Exp(N, i)));
+  return(ans);
+}
+
+int main()
+{
+  int T, t;
+  int i, j;
+  // precompute choose table
+  ch[0][0] = 1;
+  Fox1(i, LIM2 - 1)
+  {
+    Fox(j, i + 1)
+    {
+      ch[i][j] = ch[i - 1][j];
+      if (j)
+        Add(ch[i][j], ch[i - 1][j - 1]);
+    }
+  }
+  // testcase loop
+  Read(T);
+  Fox1(t, T)
+    printf("Case #%d: %d\n", t, ProcessCase());
+  return(0);
+}

2020/finals/pond_precipitation.in

@@ -0,0 +1,129 @@
+64
+2
+2 1
+2
+1 2
+1
+30
+3
+3 1 2
+3
+1 3 2
+5
+3 5 4 1 2
+8
+3 7 5 8 2 6 1 4
+15
+11 29 12 10 13 28 15 6 5 25 17 8 9 3 24
+2
+30 1
+2
+1 30
+16
+10 28 18 17 20 19 21 29 5 14 11 8 7 25 3 27
+19
+22 27 26 14 24 17 10 9 30 12 19 28 1 13 25 23 8 20 18
+20
+30 15 29 14 28 13 27 12 26 11 25 10 24 9 23 8 22 7 21 6
+30
+1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
+30
+3 30 22 20 14 17 27 19 24 1 23 25 5 12 11 15 29 13 2 8 21 16 26 28 18 4 6 7 9 10
+30
+30 23 9 4 14 10 20 29 26 19 3 22 16 13 24 11 2 15 18 8 7 17 5 28 27 12 6 1 21 25
+29
+23 24 25 30 14 26 22 12 27 19 18 7 8 28 13 9 15 29 10 4 20 17 6 11 3 21 5 1 2
+29
+21 26 6 14 19 27 9 8 23 3 20 4 25 12 17 16 10 22 13 30 24 11 18 15 7 5 1 29 2
+28
+21 28 18 26 10 30 13 19 6 17 24 23 11 3 2 29 4 27 22 14 9 8 1 12 7 20 15 16
+28
+4 12 28 9 15 5 1 17 26 20 27 22 13 29 3 2 21 25 14 6 24 23 10 18 30 16 8 11
+27
+30 24 25 27 20 29 26 15 11 28 23 13 16 10 14 19 3 6 17 8 22 18 2 12 5 1 4
+27
+27 22 21 1 5 7 26 23 13 18 14 28 25 19 29 6 11 3 17 30 24 10 12 16 4 15 8
+26
+22 11 2 16 1 25 15 9 29 12 4 21 8 26 24 18 6 30 13 19 5 23 17 20 7 3
+26
+2 25 29 20 21 27 28 8 23 10 18 17 26 22 24 13 7 12 3 5 14 4 1 15 6 9
+6
+18 25 26 8 10 20
+13
+16 26 25 2 30 27 19 24 22 9 6 4 14
+14
+1 7 20 26 17 11 30 14 15 27 28 5 24 12
+4
+30 7 26 2
+11
+30 24 29 9 18 17 25 13 8 11 4
+16
+10 28 18 17 20 19 21 29 5 14 11 8 7 25 3 27
+5
+30 21 18 9 8
+13
+19 13 24 7 8 21 16 20 3 15 2 30 11
+2
+1 25
+8
+13 12 23 22 25 20 30 15
+13
+20 8 13 3 17 9 30 22 28 2 21 5 12
+19
+22 27 26 14 24 17 10 9 30 12 19 28 1 13 25 23 8 20 18
+9
+30 27 28 13 5 6 2 19 15
+4
+12 25 23 11
+11
+24 6 29 16 14 22 11 1 7 15 2
+20
+11 29 12 10 13 28 15 2 3 25 21 17 8 9 5 24 27 16 23 26
+17
+11 7 6 9 20 14 21 30 23 19 24 8 27 25 2 15 12
+3
+24 20 2
+18
+30 16 25 8 6 23 14 27 29 3 12 18 22 19 9 15 13 11
+6
+17 15 14 12 3 11
+12
+4 22 23 15 13 1 19 8 12 27 14 21
+7
+1 16 25 13 23 7 6
+1
+3
+19
+7 27 24 30 23 29 8 28 25 19 13 21 12 18 1 11 16 10 4
+7
+10 29 30 9 8 5 11
+6
+29 27 25 17 7 2
+6
+29 25 12 10 15 9
+7
+26 21 24 19 20 14 13
+17
+7 25 27 17 21 28 29 24 10 2 4 19 5 8 26 3 11
+16
+18 28 14 7 26 21 17 10 16 13 12 4 8 2 6 1
+16
+23 15 30 16 4 29 1 9 14 2 12 11 22 24 21 17
+6
+30 18 24 17 8 5
+5
+27 30 17 15 5
+15
+29 26 20 28 10 17 19 9 15 5 6 4 8 11 3
+7
+26 27 24 10 17 2 4
+13
+26 22 30 18 28 14 9 20 3 10 5 2 4
+8
+15 20 24 26 14 5 1 2
+1
+26
+4
+17 5 22 7
+6
+28 24 17 5 1 3

2020/finals/pond_precipitation.md

@@ -0,0 +1,76 @@
+Cherry the turtle lives in a long, narrow pond. When cross-sectionally viewed from the side, the floor of the pond can be divided into \(N\) columns, each flat and 1 metre wide. The \(i\)th column from the left is at a depth of \(D_i\) metres below ground level, and all \(N\) column depths are distinct. The pond is surrounded by dirt (at ground level), just to the left of column 1 and the right of column \(N\). Cherry loves to sit on the floor in the leftmost column and bask as much as possible — but only when it's dry. Fortunately for her, the pond is initially devoid of water.
+
+For example, if \(D = [3, 5, 4, 1, 2]\), the pond would look as follows (with Cherry's position indicated in green):
+
+{{PHOTO_ID:311416436611683}}
+
+Unusually enormous drops of rainwater are about to begin falling into the pond, one by one, each onto a random column (drawn uniformly at random from the set of \(N\) columns). Each drop contains 1 cross-sectional square metre of water, and obeys the following process:
+
+  1. It falls until it hits a flat *surface*. This surface consists of the highest (least deep) point in its column (which might be either the floor of the pond itself or an existing layer of water atop it), as well as all contiguous equally-deep points to the left and right of it.
+  2. If that surface is immediately surrounded by any deeper columns to its left and/or right, then the drop's water flows down onto one of them. If there's only one such adjacent deeper column, then the drop flows onto that one. If the columns to the left and right are both deeper than the surface (note that this can only occur if the surface consists of a single column), then the drop's water all flows to the *left* one. Either way, once the drop flows into a different column, the process repeats back from Step 1.
+  3. Otherwise, the drop's 1 cross-sectional square metre of water spreads itself out evenly across the entire surface it landed on (which will never cause that surface to "overflow" by becoming strictly higher than the columns to its left or right).
+
+Cherry will be forced to stop basking as soon as a non-zero amount of water comes to rest atop column 1. She doesn't mind if raindrops fall directly on column 1 but then immediately flow away from it.
+
+For example, if a raindrop were to fall in column 4 of the above pond, it would flow to the left (onto column 3), and then flow left again to settle in column 2:
+
+{{PHOTO_ID:3533638723394837}}
+
+If a raindrop then fell in column 1, it would flow to the right and spread itself out over the surface spanning columns 2 and 3:
+
+{{PHOTO_ID:299743861289784}}
+
+If a raindrop then fell in column 5, it would remain there:
+
+{{PHOTO_ID:1094784447639382}}
+
+Another raindrop falling in column 5 (or *any* column) would then yield the following state:
+
+{{PHOTO_ID:747829032476688}}
+
+And one more raindrop falling in any column would yield the following state (forcing Cherry to stop basking due to column 1 becoming submerged in water):
+
+{{PHOTO_ID:477696676534167}}
+
+Determine the expected number of drops which will fall before Cherry is forced to stop basking. This will always occur after a finite number of drops have fallen, and before any water overflows the pond.
+
+Let this expected number of drops be represented as a quotient of integers \(p/q\) in lowest terms. Output the value of this quotient modulo 1,000,000,007 — in other words, output the unique integer \(x\) such that \(0 \le x \lt 1,000,000,007\) and \(p \equiv x*q\text{ }(\text{modulo }1,000,000,007)\).
+
+
+# Constraints
+
+\(1 \le T \le 50\)
+\(1 \le N \le 30\)
+\(1 \le D_i \le 30\)
+\(D_{1..N}\) are distinct
+
+The sum of \(N\) across all ponds is at most 1000.
+
+
+# Input
+
+Input begins with an integer \(T\), the number of ponds. For each pond, there are 2 lines. The first line contains a single integer \(N\). The second line contains the \(N\) space-separated integers \(D_{1..N}\).
+
+
+# Output
+
+For the \(i\)th pond, print a line containing *"Case #i: "*, followed by a single integer, the expected number of drops which will fall before the leftmost column becomes covered in water, expressed as a quotient of integers modulo 1,000,000,007.
+
+
+# Explanation of Sample
+
+The first pond initially looks as follows:
+
+{{PHOTO_ID:1173260263089522}}
+
+If the first raindrop falls in column 1, it will settle there, and if it falls in column 2 instead, it will flow into column 1. Either way, Cherry's position will be submerged and she'll be forced to stop basking.
+
+The second pond initially looks as follows:
+
+{{PHOTO_ID:127321889008596}}
+
+The first raindrop will always settle in column 2, leaving Cherry uninterrupted. However, the second raindrop will then always land on the surface spanning both columns, filling both up to a depth of 0.5 metres below ground level and thus forcing Cherry to stop basking.
+
+The third pond only has a single column, and Cherry will need to stop basking as soon as the first raindrop falls in it.
+
+The fourth pond may end up in various states depending on which columns the raindrops fall in. If the first drop falls in either column 1 or 2, then it will immediately settle in column 1, while if it falls in column 3, it will remain there and it will take a second drop to force Cherry to stop basking. The answer is therefore \(\frac{2}{3} 1 + \frac{1}{3} 2 = \frac{4}{3}\). \(4 \equiv 333,333,337 * 3\text{ }(\text{modulo }1,000,000,007)\), meaning that \(333,333,337\) should be outputted.

2020/finals/pond_precipitation.out

@@ -0,0 +1,64 @@
+Case #1: 1
+Case #2: 2
+Case #3: 1
+Case #4: 333333337
+Case #5: 4
+Case #6: 772800010
+Case #7: 600238862
+Case #8: 777291572
+Case #9: 1
+Case #10: 30
+Case #11: 937030791
+Case #12: 413793850
+Case #13: 839435693
+Case #14: 436
+Case #15: 443547255
+Case #16: 396227790
+Case #17: 466103174
+Case #18: 817567450
+Case #19: 617077188
+Case #20: 328627652
+Case #21: 923842801
+Case #22: 461892853
+Case #23: 120289842
+Case #24: 898611294
+Case #25: 639276210
+Case #26: 153140977
+Case #27: 224
+Case #28: 64313891
+Case #29: 492753435
+Case #30: 937030791
+Case #31: 1
+Case #32: 147204623
+Case #33: 25
+Case #34: 748059186
+Case #35: 716331815
+Case #36: 413793850
+Case #37: 351458863
+Case #38: 25
+Case #39: 510316599
+Case #40: 840006893
+Case #41: 943180527
+Case #42: 1
+Case #43: 249621861
+Case #44: 746767720
+Case #45: 981645522
+Case #46: 85
+Case #47: 1
+Case #48: 509775157
+Case #49: 3252335
+Case #50: 1
+Case #51: 646090541
+Case #52: 822157443
+Case #53: 357912021
+Case #54: 532071843
+Case #55: 723030647
+Case #56: 799725660
+Case #57: 4
+Case #58: 124032548
+Case #59: 677744521
+Case #60: 752783508
+Case #61: 893366069
+Case #62: 1
+Case #63: 64313891
+Case #64: 194444447

2020/finals/pond_precipitation_sol.md

@@ -0,0 +1,5 @@
+Let \(C_i\) be the maximum number of raindrops which can fall in the first \(i\) columns without causing any water to settle atop column 1. We can compute \(C_{1..N}\) in \(O(N)\) time by iterating over the columns from left to right, looking for each new highest (least deep) column, and considering filling the columns before it (back to the previous highest column) with water up to the depth of that previous highest column.
+
+Then, let \(\textit{DP}_{i,d}\) be the number of different ways for \(d\) raindrops to fall in the first \(i\) columns without causing any water to settle atop column 1. \(\textit{DP}_{0,0}\) = 1, with the remaining values computable using dynamic programming as follows. We can consider all triples \((i, d, d')\) in increasing order of \(i\) such that \(d\) drops have fallen in the first \(i\) columns (such that \(d \le C_i\)) and \(d'\) drops will fall in column \(i + 1\) (such that \(d + d' \le C_{i+1}\)). This allows us to increase \(\textit{DP}_{i+1,d+d'}\) by \(\textit{DP}_{i,d} * {d+d' \choose d'}\), given that the new \(d'\) drops may be mixed in anywhere amongst the total \(d+d'\) drops. Overall, this process takes \(O(N * \sum(D_{1..N})^2)\) time.
+
+Finally, let \(S_d\) be the probability that, once \(d\) drops have fallen, no water has yet settled atop column 1. Note that \(S_d = \textit{DP}_{N,d} / N^i\). The answer may then be computed as \(\sum(S_{0..C_N})\).

2020/finals/somebody_elses_problem.cpp

@@ -0,0 +1,152 @@
+// Somebody Else's Problem
+// Solution by Jacob Plachta
+
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <complex>
+#include <cstdlib>
+#include <ctime>
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <bitset>
+#include <sstream>
+using namespace std;
+
+#define LL long long
+#define LD long double
+#define PR pair<int,int>
+
+#define Fox(i,n) for (i=0; i<n; i++)
+#define Fox1(i,n) for (i=1; i<=n; i++)
+#define FoxI(i,a,b) for (i=a; i<=b; i++)
+#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
+#define FoxR1(i,n) for (i=n; i>0; i--)
+#define FoxRI(i,a,b) for (i=b; i>=a; i--)
+#define Foxen(i,s) for (auto i:s)
+#define Min(a,b) a=min(a,b)
+#define Max(a,b) a=max(a,b)
+#define Sz(s) int((s).size())
+#define All(s) (s).begin(),(s).end()
+#define Fill(s,v) memset(s,v,sizeof(s))
+#define pb push_back
+#define mp make_pair
+#define x first
+#define y second
+
+template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
+template<typename T> T Sqr(T x) { return(x * x); }
+string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }
+
+const int INF = (int)1e9;
+const LD EPS = 1e-12;
+const LD PI = acos(-1.0);
+
+#define GETCHAR getchar_unlocked
+
+bool Read(int& x) {
+  char c, r = 0, n = 0;
+  x = 0;
+  for (;;) {
+    c = GETCHAR();
+    if ((c < 0) && (!r))
+      return(0);
+    if ((c == '-') && (!r))
+      n = 1;
+    else if ((c >= '0') && (c <= '9'))
+      x = x * 10 + c - '0', r = 1;
+    else if (r)
+      break;
+  }
+  if (n)
+    x = -x;
+  return(1);
+}
+
+#define MOD 1000000007
+#define LIM 1000001
+
+int N, ans;
+vector<int> ch[LIM];
+int dyn1[LIM]; // max. len. of downward i -> leaf
+int dyn2[LIM]; // max. len. of downward root -> leaf outside i's subtree
+int dyn3[LIM]; // max. disjoint len. of downward root -> leaf plus other path ongoing from i's parent
+
+void rec1(int i)
+{
+  // recurse, and compute dyn1[i]
+  dyn1[i] = 0;
+  Foxen(c, ch[i])
+  {
+    rec1(c);
+    Max(dyn1[i], dyn1[c] + 1);
+  }
+}
+
+void rec2(int i, int d)
+{
+  // compute answer for i
+  ans = ans * (LL)max(dyn1[i] + dyn2[i] + (!i ? 0 : 1), dyn3[i]) % MOD;
+  // compute max 2 (dyn1[c] + 1, c) pairs
+  PR m1, m2;
+  m1 = m2 = mp(0, -1);
+  Foxen(c, ch[i])
+  {
+    PR p = mp(dyn1[c] + 1, c);
+    if (p > m1)
+      m2 = m1, m1 = p;
+    else if (p > m2)
+      m2 = p;
+  }
+  // compute dyn2[c] and dyn3[c], and recurse
+  Foxen(c, ch[i])
+  {
+    int m = (m1.y == c ? m2 : m1).x;
+    dyn2[c] = max(d + m, dyn2[i]);
+    dyn3[c] = max(dyn3[i] + 1, dyn2[i] + m + 1 + (!i ? 0 : 1));
+    rec2(c, d + 1);
+  }
+}
+
+int ProcessCase()
+{
+  int i, j;
+  // input
+  Read(N);
+  Fox1(i, N - 1)
+  {
+    Read(j), j--;
+    ch[j].pb(i);
+  }
+  // DP
+  ans = 1;
+  rec1(0);
+  rec2(0, 0);
+  // reset
+  Fox(i, N)
+    ch[i].clear();
+  return(ans);
+}
+
+int main()
+{
+  int T, t;
+  Read(T);
+  Fox1(t, T)
+    printf("Case #%d: %d\n", t, ProcessCase());
+  return(0);
+}

2020/finals/somebody_elses_problem.in

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

2020/finals/somebody_elses_problem.md

@@ -0,0 +1,44 @@
+H Combinator (HC) is a business incubator that provides seed funding to startups. It operates on the core value that "nothing is somebody else's problem" (since businesses slow down when tasks get perpetually passed from person to person). HC currently supports \(T\) companies. As a managing director hoping to weed out some bad investments, you would like to assess how well the structure of each company holds up to this important principle.
+
+Suppose a company has \(N\) employees, numbered \(1\) to \(N\) in decreasing order of seniority. Employee \(1\) is the CEO, while each other employee \(i\) \((i \ge 2)\) has a manager, employee \(M_i\) \((M_i \lt i)\).
+
+When employee \(i\) is assigned a task to complete, they may instead reassign it to one of the following employees:
+
+  1. One of their direct reports (any employee \(j\) such that \(M_j = i\)), if any exist
+  2. Their manager (employee \(M_i\)), if \(i \ge 2\)
+  3. The CEO (employee \(1\)), if \(i \ge 2\)
+
+That employee may then reassign the task to yet another employee, and so on. However, an employee may never be reassigned a task that has ever been previously assigned to them, as the lack of responsibility would become too apparent. For example, an employee and manager cannot repeatedly pass a task back and forth.
+
+Let \(R_i\) be the maximum number of times that a task could be reassigned from one employee to another if it were initially assigned to employee \(i\). For each company, you would like to calculate the product \((R_1 * R_2 * ... * R_N)\), modulo 1,000,000,007.
+
+# Constraints
+
+\(1 \le T \le 100\)
+\(2 \le N \le 1,000,000\)
+\(1 \le M_i \lt i\)
+
+The sum of \(N\) across all companies is at most 6,000,000.
+
+
+# Input
+
+Input begins with an integer \(T\), the number of companies. For each company there are 2 lines. The first line contains the single integer \(N\). The second line contains \(N - 1\) space-separated integers, \(M_{2..N}\).
+
+
+# Output
+
+For the \(i\)th company, print a line containing *"Case #i: "*, followed by a single integer, the product of \(R_{1..N}\) modulo 1,000,000,007.
+
+
+# Explanation of Sample
+
+For the first company, if the CEO is initially assigned a task, all they can do is reassign it to one of their reports, who cannot then assign it back. On the other hand, if another employee is initially assigned a task, they can reassign it to the CEO, who can then assign it to the other remaining employee. Therefore, \(R = [1, 2, 2]\), and the final answer is (1 * 2 * 2) modulo 1,000,000,007 = 4.
+
+For the second company, no matter which employee is initially assigned a task, it can then be reassigned twice. For example, employee 2 can assign their task to their report (employee 3), who can then assign it to the CEO. Therefore, \(R = [2, 2, 2]\).
+
+For the third company, \(R = [2, 2, 3, 3]\).
+
+For the fourth company, \(R = [3, 6, 6, 6, 7, 7, 7, 7, 8, 8]\).
+
+For the fifth company, \(R = [4, 6, 6, 7, 8, 6, 7, 7, 8, 7, 7, 8, 8, 9, 9]\).

2020/finals/somebody_elses_problem.out

@@ -0,0 +1,109 @@
+Case #1: 4
+Case #2: 8
+Case #3: 36
+Case #4: 99574272
+Case #5: 801542729
+Case #6: 512
+Case #7: 110638080
+Case #8: 100755024
+Case #9: 609548256
+Case #10: 449377614
+Case #11: 697200545
+Case #12: 40681884
+Case #13: 801335875
+Case #14: 912420599
+Case #15: 828211555
+Case #16: 222945837
+Case #17: 794621467
+Case #18: 539189349
+Case #19: 153951545
+Case #20: 403356442
+Case #21: 158834216
+Case #22: 757493143
+Case #23: 124049818
+Case #24: 157599195
+Case #25: 210009530
+Case #26: 934651967
+Case #27: 846283835
+Case #28: 135977128
+Case #29: 96550718
+Case #30: 460241648
+Case #31: 168595112
+Case #32: 212089364
+Case #33: 533764564
+Case #34: 887365886
+Case #35: 959297767
+Case #36: 518707324
+Case #37: 926754190
+Case #38: 800571094
+Case #39: 352762395
+Case #40: 446732699
+Case #41: 137078595
+Case #42: 82460488
+Case #43: 63988313
+Case #44: 368079615
+Case #45: 874039636
+Case #46: 259792328
+Case #47: 680495316
+Case #48: 310927912
+Case #49: 159825100
+Case #50: 757078864
+Case #51: 11192700
+Case #52: 815983871
+Case #53: 221642594
+Case #54: 881701383
+Case #55: 233697937
+Case #56: 842482923
+Case #57: 765406592
+Case #58: 989866696
+Case #59: 898464379
+Case #60: 345934457
+Case #61: 451190753
+Case #62: 322496398
+Case #63: 475160557
+Case #64: 996799426
+Case #65: 211994997
+Case #66: 690657310
+Case #67: 971619993
+Case #68: 440397393
+Case #69: 481512798
+Case #70: 186452849
+Case #71: 708281413
+Case #72: 357202043
+Case #73: 777137428
+Case #74: 841177015
+Case #75: 825117615
+Case #76: 853698291
+Case #77: 594949860
+Case #78: 404255967
+Case #79: 458058760
+Case #80: 589833391
+Case #81: 311188915
+Case #82: 858709805
+Case #83: 457598660
+Case #84: 291250389
+Case #85: 89919554
+Case #86: 964724850
+Case #87: 87366696
+Case #88: 253283539
+Case #89: 417747428
+Case #90: 10644788
+Case #91: 95418217
+Case #92: 560671530
+Case #93: 326047040
+Case #94: 463949173
+Case #95: 905018983
+Case #96: 201781788
+Case #97: 955583192
+Case #98: 319780485
+Case #99: 514572911
+Case #100: 92757427
+Case #101: 829713327
+Case #102: 367443664
+Case #103: 932977208
+Case #104: 247500328
+Case #105: 387055634
+Case #106: 191909169
+Case #107: 421840147
+Case #108: 730451318
+Case #109: 493473473

2020/finals/somebody_elses_problem_sol.md

@@ -0,0 +1,18 @@
+The employees can be considered nodes of a tree rooted at node 1 (the CEO), with each node \(i\)'s set of children \(C_i\) consisting of all nodes \(j\) such that \(M_j = i\). We'll additionally let \(D_i\) be the depth of node \(i\), and \(S_i\) be its set of siblings.
+
+We can observe that \(R_i\) corresponds to either of the following:
+
+- The maximum length of any single simple path starting at node \(i\) (potentially going upwards to some ancestor and then back downwards)
+- 1 plus the maximum combined length of any node-disjoint pair of simple paths, the first one starting at node \(i\) (potentially going upwards to some ancestor and then back downwards) and the second starting at the root (and only going downwards)
+
+We'll approach computing these lengths and sums with dynamic programming.
+
+First, let \(\textit{DP1}_i\) be the maximum length of any path starting at node \(i\) and contained within \(i\)'s subtree. \(\textit{DP1}_{1..N}\) may be computed in standard fashion based on the recurrence \(\textit{DP1}_i = \max(c \in C_i | \textit{DP1}_c + 1)\).
+
+Next, let \(\textit{DP2}_i\) be the maximum length of any path starting at the root and never entering node \(i\)'s subtree. If \(i\) is the root, then \(\textit{DP2}_i = 0\). Otherwise, \(\textit{DP2}_i = \max(D_{M_i} + \max(s \in S_i | \textit{DP1}_s + 1), \textit{DP2}_{M_i})\).
+
+Now, let \(\textit{DP3}_i\) be 1 plus the maximum combined length of any node-disjoint pair of simple paths, the first one starting at node \(i\) but not including any of \(i\)'s children, and the second starting at the root. If \(i\) is the root, then \(\textit{DP3}_i = 0\). Otherwise, \(\textit{DP3}_i = \max(\textit{DP3}_{M_i} + 1, \textit{DP2}_{M_i} + \max(s \in S_i | \textit{DP1}_s + 1) + 2)\).
+
+Finally, if \(i\) is the root, then \(R_i = \textit{DP1}_i\). Otherwise, \(R_i = \max(\textit{DP1}_i + \textit{DP2}_i + 1, \textit{DP3}_i)\).
+
+We can compute all of the above values in \(O(N)\) time through two recursive (or iterative) passes over the tree.

2020/finals/spider_spring.cpp

@@ -0,0 +1,310 @@
+// Spider Spring
+// Solution by Jacob Plachta
+
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <complex>
+#include <cstdlib>
+#include <ctime>
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <bitset>
+#include <sstream>
+using namespace std;
+
+#define LL long long
+#define LD long double
+#define PR pair<int,int>
+
+#define Fox(i,n) for (i=0; i<n; i++)
+#define Fox1(i,n) for (i=1; i<=n; i++)
+#define FoxI(i,a,b) for (i=a; i<=b; i++)
+#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
+#define FoxR1(i,n) for (i=n; i>0; i--)
+#define FoxRI(i,a,b) for (i=b; i>=a; i--)
+#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
+#define Min(a,b) a=min(a,b)
+#define Max(a,b) a=max(a,b)
+#define Sz(s) int((s).size())
+#define All(s) (s).begin(),(s).end()
+#define Fill(s,v) memset(s,v,sizeof(s))
+#define pb push_back
+#define mp make_pair
+#define x first
+#define y second
+
+template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
+template<typename T> T Sqr(T x) { return(x * x); }
+string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }
+
+const int INF = (int)1e9;
+const LD EPS = 1e-12;
+const LD PI = acos(-1.0);
+
+#define GETCHAR getchar_unlocked
+
+bool Read(int& x) {
+  char c, r = 0, n = 0;
+  x = 0;
+  for (;;) {
+    c = GETCHAR();
+    if ((c < 0) && (!r))
+      return(0);
+    if ((c == '-') && (!r))
+      n = 1;
+    else if ((c >= '0') && (c <= '9'))
+      x = x * 10 + c - '0', r = 1;
+    else if (r)
+      break;
+  }
+  if (n)
+    x = -x;
+  return(1);
+}
+
+void ReadSeq(int* V, int N, int K)
+{
+  int i, A, B, C, D;
+  Fox(i, K)
+    Read(V[i]);
+  Read(A), Read(B), Read(C), Read(D);
+  FoxI(i, K, N - 1)
+    V[i] = ((LL)A * V[i - 2] + (LL)B * V[i - 1] + C) % D + 1;
+}
+
+#define MOD 1000000007
+#define LIM 1000001
+
+#define TVAL LL
+#define TLAZY pair<LL,LL> // (set, increase)
+#define TLIM 2100000
+
+TVAL ZERO_VAL = 0;
+TLAZY ZERO_LAZY = mp(0, 0);
+
+struct SegTree
+{
+  void UpdateValForUpdateOrLazy(TVAL& a, TLAZY v)
+  {
+    if (v.x)
+      a = v.x;
+    if (v.y)
+      a += v.y;
+  }
+
+  void UpdateLazyForUpdateOrLazy(TLAZY& a, TLAZY v)
+  {
+    if (v.x)
+      a.x = v.x;
+    if (v.y)
+      a.y += v.y;
+  }
+
+  TVAL CombVals(TVAL v1, TVAL v2)
+  {
+    return(v1 + v2);
+  }
+
+  int N, sz;
+  TVAL tree[TLIM];
+  TLAZY lazy[TLIM];
+
+  SegTree() {}
+
+  SegTree(int _N)
+  {
+    Init(_N);
+  }
+
+  void Init(int _N)
+  {
+    N = _N;
+    for (sz = 1; sz < N; sz <<= 1);
+    Clear();
+  }
+
+  void Clear()
+  {
+    int i;
+    Fox(i, sz << 1)
+      tree[i] = ZERO_VAL;
+    Fox(i, sz << 1)
+      lazy[i] = ZERO_LAZY;
+  }
+
+  void Prop(int i)
+  {
+    TLAZY v = lazy[i];
+    lazy[i] = ZERO_LAZY;
+    UpdateValForUpdateOrLazy(tree[i], v);
+    if (i < sz)
+    {
+      int c1 = i << 1, c2 = c1 + 1;
+      UpdateLazyForUpdateOrLazy(lazy[c1], v);
+      UpdateLazyForUpdateOrLazy(lazy[c2], v);
+    }
+  }
+
+  void Comp(int i)
+  {
+    int c1 = i << 1, c2 = c1 + 1;
+    tree[i] = CombVals(tree[c1], tree[c2]);
+  }
+
+  TVAL Query(
+    int a, int b,
+    int i = 1, int r1 = 0, int r2 = -1
+  ) {
+    if (r2 < 0)
+      r2 = sz - 1;
+    Prop(i);
+    if (a <= r1 && r2 <= b)
+      return(tree[i]);
+    int m = (r1 + r2) >> 1, c = i << 1;
+    TVAL ret = ZERO_VAL;
+    if (a <= m)
+      ret = CombVals(ret, Query(a, b, c, r1, m));
+    if (b > m)
+      ret = CombVals(ret, Query(a, b, c + 1, m + 1, r2));
+    return(ret);
+  }
+
+  void Update(
+    int a, int b,
+    TLAZY v,
+    int i = 1, int r1 = 0, int r2 = -1
+  ) {
+    if (r2 < 0)
+      r2 = sz - 1;
+    Prop(i);
+    if (a <= r1 && r2 <= b)
+    {
+      UpdateLazyForUpdateOrLazy(lazy[i], v);
+      Prop(i);
+      return;
+    }
+    int m = (r1 + r2) >> 1, c = i << 1;
+    if (a <= m)
+      Update(a, b, v, c, r1, m);
+    if (b > m)
+      Update(a, b, v, c + 1, m + 1, r2);
+    Prop(c), Prop(c + 1), Comp(i);
+  }
+
+  void UpdateOne(int i, TLAZY v) {
+    i += sz;
+    UpdateValForUpdateOrLazy(tree[i], v);
+    while (i > 1)
+    {
+      i >>= 1;
+      Comp(i);
+    }
+  }
+};
+
+int N, M, K;
+int H[LIM], X[LIM], Y[LIM], Z[LIM], W[LIM];
+set<int> LS;
+
+// 0: height of column i
+// 1: sum of A endpoint weights with endpoint value i
+// 2: sum of A endpoint weighted values with endpoint value i
+// 3: sum of B endpoint weights with endpoint value i
+// 4: sum of B endpoint weighted values with endpoint value i
+SegTree ST[5];
+
+void UpdateHeights(int a, int b, int h)
+{
+  ST[0].Update(a, b, mp(h, 0));
+}
+
+void UpdateLineSegment(int i, int d) // d = 1 (add) / -1 (remove)
+{
+  if (i < 0 || i + 1 >= N)
+    return;
+  int a = ST[0].Query(i, i), b = ST[0].Query(i + 1, i + 1);
+  if (a > b)
+    swap(a, b);
+  LL w = (LL)(i + 1) * (N - i - 1);
+  ST[1].UpdateOne(a, mp(0, w % MOD * d));
+  ST[2].UpdateOne(a, mp(0, a * w % MOD * d));
+  ST[3].UpdateOne(b, mp(0, w % MOD * d));
+  ST[4].UpdateOne(b, mp(0, b * w % MOD * d));
+  if (d > 0)
+    LS.insert(i);
+  else
+    LS.erase(i);
+}
+
+int ProcessCase()
+{
+  int i;
+  // input
+  Read(N), Read(M), Read(K);
+  ReadSeq(H, N, K);
+  ReadSeq(X, M, K);
+  ReadSeq(Y, M, K);
+  ReadSeq(Z, M, K);
+  ReadSeq(W, M, K);
+  // init segment trees, line segment set, and horizontal sum
+  Fox(i, 5)
+    ST[i].Init(!i ? N : LIM);
+  LS.clear();
+  LL horiz = 0;
+  Fox(i, N)
+  {
+    UpdateHeights(i, i, H[i]);
+    UpdateLineSegment(i - 1, 1);
+    horiz = (horiz + (LL)i * (N - i)) % MOD;
+  }
+  // process events
+  int ans = 1;
+  Fox(i, M)
+  {
+    // update
+    int x = X[i] - 1;
+    int y = min(x + Y[i], N) - 1;
+    int z = Z[i];
+    auto I = LS.lower_bound(x - 1);
+    while (I != LS.end() && *I <= y)
+    {
+      int k = *I;
+      I++;
+      UpdateLineSegment(k, -1);
+    }
+    UpdateHeights(x, y, z);
+    UpdateLineSegment(x - 1, 1);
+    UpdateLineSegment(y, 1);
+    // query
+    int w = W[i];
+    LL d1 = ST[4].Query(w + 1, LIM - 1) - ST[2].Query(w + 1, LIM - 1);
+    LL d2 = ST[3].Query(w + 1, LIM - 1) - ST[1].Query(w + 1, LIM - 1);
+    LL vert = ((d1 - d2 % MOD * w) % MOD + MOD) % MOD;
+    ans = (LL)ans * (horiz + vert) * 2 % MOD;
+  }
+  return(ans);
+}
+
+int main()
+{
+  int T, t;
+  Read(T);
+  Fox1(t, T)
+    printf("Case #%d: %d\n", t, ProcessCase());
+  return(0);
+}

2020/finals/spider_spring.in

@@ -0,0 +1,1189 @@
+108
+2 2 2
+2 3
+0 0 0 100
+2 1
+0 0 0 2
+1 1
+0 0 0 2
+4 1
+0 0 0 100
+1 3
+0 0 0 100
+3 3 3
+1 2 4
+0 0 0 100
+2 3 1
+0 0 0 3
+1 1 2
+0 0 0 3
+2 4 6
+0 0 0 100
+1 5 5
+0 0 0 100
+6 6 6
+13 4 7 11 2 5
+0 0 0 100
+1 3 6 1 1 4
+0 0 0 6
+1 2 1 1 3 2
+0 0 0 6
+13 9 5 4 10 12
+0 0 0 100
+8 2 9 3 6 11
+0 0 0 100
+10 12 2
+37 11
+1 2 3 45
+2 7
+2 3 4 9
+2 1
+3 4 5 4
+24 38
+4 5 6 78
+16 9
+5 6 7 87
+100 200 3
+470 104 185
+213 20 226 692
+76 35 8
+499 768 377 92
+23 9 12
+880 205 286 31
+165 249 43
+883 477 453 674
+385 68 409
+853 105 54 410
+903 930 2
+1633 1521
+701 815 358 1878
+753 662
+656 986 148 901
+1 1
+401 8 25 5
+165 131
+282 747 129 1191
+116 123
+618 891 846 1164
+1000000 1000000 2
+1000000 1000000
+0 0 999999 1000000
+1000000 1000000
+0 0 999999 1000000
+1000000 1000000
+0 0 999999 1000000
+1000000 1000000
+0 0 999999 1000000
+1000000 1000000
+0 0 999999 1000000
+1000000 1000000 2
+1000000 1
+1 0 999999 1000000
+1 1
+0 0 0 1
+1 1
+0 0 0 1
+1000000 1000000
+0 0 999999 1000000
+1 2
+0 1 0 1000000
+1000000 1000000 2
+178 556
+584 595 823 1000000
+1 4
+433 783 232 1000000
+2 2
+0 0 1 3
+177 100
+680 28 717 1000000
+528 410
+60 815 683 1000000
+1000000 1000000 2
+19 24
+350 303 365 1000000
+51 52
+216 967 821 1000000
+2 3
+106 327 154 20
+82 163
+744 449 414 1000000
+464 306
+362 471 820 1000000
+1000000 1000000 2
+324 111
+101 937 252 1000000
+33 171
+175 798 441 12345
+987654 987654
+0 0 987654 1000000
+44 811
+459 777 237 1000000
+257 35
+704 951 629 1000000
+1000000 1000000 2
+430 157
+514 758 528 1000000
+548 141
+945 926 558 1000000
+47 42
+268 531 962 1000000
+3 162
+86 400 6 1000000
+1 2
+154 756 683 1000000
+100000 100000 2
+125 149
+311 576 518 100000
+6 32
+563 173 458 100000
+4 4
+544 210 328 100000
+14 286
+340 267 60 100000
+369 57
+509 315 521 100000
+100000 100000 2
+44 88
+242 300 281 100000
+25 30
+634 853 304 100000
+2 1
+208 685 950 100000
+327 11
+289 357 883 100000
+135 93
+891 910 259 100000
+903 930 2
+633 521
+701 815 358 878
+753 662
+656 986 148 901
+1 1
+401 8 25 2
+65 31
+282 747 129 191
+16 23
+618 891 846 164
+560 696 2
+169 198
+198 539 496 255
+140 17
+282 82 691 446
+24 14
+831 13 414 42
+376 39
+882 608 720 885
+227 52
+261 461 789 381
+972 540 2
+331 334
+648 253 91 489
+530 322
+732 335 927 893
+6 7
+301 667 399 18
+48 178
+430 392 172 301
+284 653
+32 807 789 962
+855 600 2
+145 135
+920 730 668 224
+247 646
+898 870 550 833
+67 10
+744 620 881 82
+392 316
+553 191 883 424
+79 223
+71 463 361 248
+301 113 2
+52 155
+208 684 646 784
+33 215
+736 691 995 259
+9 23
+76 461 136 25
+293 85
+823 97 279 420
+695 133
+239 888 885 698
+530 859 2
+70 763
+70 537 870 950
+18 262
+866 322 130 508
+3 18
+93 713 359 21
+21 77
+85 331 644 197
+309 496
+866 213 902 580
+634 721 2
+60 231
+468 492 479 357
+178 412
+811 454 239 522
+21 45
+414 524 132 49
+325 45
+207 720 216 638
+570 43
+534 876 111 875
+561 329 2
+614 541
+832 480 598 697
+261 76
+873 340 462 436
+31 20
+243 979 906 32
+292 107
+447 597 189 468
+59 146
+582 280 677 290
+330 749 2
+142 499
+701 963 70 583
+186 108
+622 896 827 249
+13 11
+290 282 580 13
+371 522
+619 692 591 594
+144 302
+942 108 659 661
+251 322 2
+30 135
+399 56 251 226
+190 52
+456 382 867 239
+7 2
+149 100 640 13
+360 48
+959 859 940 492
+48 237
+282 686 565 240
+958 436 2
+533 818
+59 810 553 950
+540 762
+177 425 49 954
+27 4
+552 414 728 27
+209 180
+622 438 998 496
+32 16
+6 969 88 72
+513 902 2
+301 435
+779 823 750 519
+175 356
+750 231 89 418
+31 28
+265 947 489 32
+39 7
+316 983 505 48
+30 369
+103 713 87 480
+206 517 2
+151 118
+85 178 267 834
+22 69
+859 466 727 186
+7 7
+418 864 848 8
+328 411
+358 164 939 696
+287 427
+127 386 335 604
+594 981 2
+1 2
+163 999 302 18
+334 239
+508 223 271 581
+5 5
+327 457 791 5
+433 13
+471 904 69 461
+617 534
+756 256 43 737
+833 242 2
+209 103
+939 521 682 243
+97 67
+373 545 125 730
+78 43
+341 224 763 82
+661 289
+475 751 558 938
+540 43
+641 407 96 834
+479 552 2
+773 95
+561 14 84 873
+138 298
+434 550 678 363
+5 11
+96 820 744 15
+5 16
+479 790 808 20
+316 544
+890 507 177 827
+408 650 2
+7 797
+495 737 239 825
+90 89
+766 944 708 370
+16 16
+580 975 345 28
+445 239
+142 720 688 462
+140 210
+571 928 250 224
+791 957 2
+615 452
+42 934 832 710
+781 48
+319 308 733 782
+7 4
+364 533 596 34
+334 346
+261 705 922 421
+90 92
+529 138 584 158
+546 301 2
+393 679
+919 681 106 789
+425 523
+792 958 404 533
+1 1
+589 283 628 1
+59 239
+903 702 401 373
+123 247
+942 685 70 608
+76 542 2
+211 172
+144 246 457 352
+27 42
+500 977 733 75
+3 2
+523 893 924 8
+21 15
+329 889 114 57
+33 178
+960 453 552 778
+360 84 2
+2 29
+707 417 370 29
+40 196
+696 131 893 327
+1 12
+465 830 658 27
+539 401
+518 768 936 566
+357 18
+242 566 931 464
+820 98 2
+3 295
+587 398 408 407
+525 548
+225 646 190 797
+7 6
+340 738 936 18
+303 31
+314 951 152 343
+32 24
+592 101 794 55
+930 117 2
+143 444
+445 505 199 931
+34 859
+225 935 398 926
+62 13
+815 727 139 74
+382 610
+938 136 78 976
+91 162
+374 20 826 578
+263 745 2
+153 59
+315 654 700 172
+5 186
+581 314 479 218
+14 7
+816 774 927 26
+65 27
+817 265 822 70
+18 77
+368 696 166 85
+279 738 2
+159 142
+898 425 339 318
+43 150
+769 530 503 259
+8 3
+672 517 872 18
+83 551
+732 669 499 685
+257 456
+947 301 419 789
+598 555 2
+30 7
+575 679 622 37
+536 186
+41 588 65 537
+43 2
+966 616 818 59
+248 256
+926 345 362 320
+7 212
+450 360 668 365
+264 577 2
+15 2
+717 154 500 21
+102 111
+656 620 658 219
+8 2
+892 626 865 8
+743 525
+179 112 70 876
+429 679
+880 3 973 825
+897 144 2
+540 332
+840 455 830 627
+562 400
+212 814 564 861
+6 8
+967 216 433 48
+53 397
+720 766 244 636
+135 196
+803 924 987 262
+429 612 2
+17 55
+996 594 794 123
+226 321
+720 686 277 385
+1 1
+890 830 894 1
+899 590
+168 359 680 933
+331 402
+446 717 585 638
+839 233 2
+521 845
+61 640 876 975
+551 296
+911 703 495 798
+34 29
+763 214 43 49
+159 144
+728 711 733 707
+687 417
+766 235 436 919
+365 586 2
+84 74
+448 91 430 285
+4 97
+110 366 424 305
+2 9
+867 175 438 15
+415 156
+819 867 368 520
+517 426
+533 851 639 597
+465 60 2
+330 409
+767 64 479 424
+343 275
+386 527 467 353
+1 1
+921 595 49 1
+324 322
+605 22 541 475
+480 415
+753 135 614 850
+801 771 2
+63 291
+144 684 80 412
+555 472
+749 518 924 684
+55 38
+775 334 474 65
+5 233
+907 805 320 742
+8 10
+213 117 454 404
+783 771 2
+598 530
+846 857 583 798
+553 176
+508 278 568 603
+7 25
+290 565 235 33
+3 94
+656 619 860 237
+529 436
+236 48 762 662
+432 863 2
+704 427
+213 389 808 976
+275 77
+851 125 737 385
+4 9
+957 52 233 15
+595 365
+905 284 117 861
+647 91
+292 115 735 765
+992 300 2
+525 297
+649 530 454 720
+834 212
+934 685 909 883
+28 12
+805 982 864 51
+24 511
+505 668 249 578
+187 182
+153 428 304 235
+427 382 2
+190 227
+759 686 149 442
+159 204
+313 771 135 420
+7 29
+294 207 468 30
+323 129
+44 983 618 527
+385 130
+837 293 873 478
+509 937 2
+73 76
+121 923 553 257
+370 177
+415 250 899 453
+3 7
+435 812 337 11
+252 311
+623 186 732 401
+180 470
+238 772 839 514
+842 577 2
+273 625
+269 271 271 657
+748 140
+414 784 901 768
+29 5
+721 553 330 37
+583 440
+69 152 381 723
+368 364
+414 820 333 689
+477 441 2
+89 1
+78 356 819 110
+90 387
+433 743 609 408
+16 3
+516 625 885 28
+75 65
+939 438 215 281
+566 739
+555 353 992 913
+356 406 2
+531 300
+232 72 584 972
+288 202
+971 588 35 346
+9 25
+199 601 573 30
+26 46
+124 574 366 169
+387 451
+384 662 131 637
+913 20 2
+21 81
+695 806 658 88
+628 413
+737 3 576 755
+2 21
+351 988 165 61
+256 57
+837 302 864 324
+55 653
+881 641 578 882
+698 679 2
+47 673
+551 473 606 997
+184 28
+216 911 779 691
+2 4
+704 423 546 14
+347 196
+792 634 838 689
+74 59
+915 525 986 842
+393 922 2
+240 570
+965 583 455 776
+330 323
+698 365 640 364
+8 16
+245 373 833 20
+152 449
+532 500 183 745
+62 14
+832 222 151 243
+315 43 2
+86 16
+395 803 569 187
+92 258
+828 665 547 273
+6 8
+667 827 876 12
+429 194
+346 346 589 843
+170 319
+206 272 331 385
+669 404 2
+258 490
+527 689 745 524
+212 388
+130 943 920 546
+8 13
+574 788 848 29
+43 119
+64 487 333 496
+243 140
+183 95 468 526
+273 706 2
+414 353
+436 437 355 942
+244 23
+640 387 315 251
+15 13
+553 925 689 18
+4 11
+370 471 315 119
+166 161
+569 223 990 208
+531 32 2
+506 504
+486 554 489 654
+384 77
+170 520 889 507
+7 41
+825 153 339 49
+123 129
+683 207 26 378
+240 222
+879 356 276 426
+745 956 2
+141 202
+874 518 913 207
+385 554
+787 532 492 617
+31 24
+474 781 354 42
+269 339
+239 554 367 389
+44 73
+590 458 10 280
+958 776 2
+176 226
+362 980 71 565
+83 658
+113 657 2 790
+5 18
+15 701 673 49
+75 308
+715 108 614 541
+269 339
+416 733 949 423
+798 353 2
+296 63
+499 720 142 388
+261 325
+590 147 182 693
+9 7
+421 916 646 11
+628 103
+50 562 658 982
+605 446
+323 289 464 610
+796 595 2
+49 46
+842 758 506 57
+101 616
+224 112 764 703
+10 3
+847 990 147 12
+172 574
+537 366 920 667
+439 108
+729 34 95 661
+350 73 2
+466 42
+546 898 16 895
+214 24
+585 290 713 280
+1 1
+931 720 958 11
+344 379
+387 158 827 552
+335 182
+928 388 807 397
+382 1000 2
+68 52
+911 968 211 82
+266 319
+398 831 183 353
+4 6
+898 78 585 25
+539 288
+804 190 800 698
+18 30
+107 564 732 36
+73 276 2
+118 139
+573 84 696 174
+56 37
+228 872 892 58
+2 2
+83 435 585 7
+785 430
+481 464 27 981
+367 105
+399 788 560 464
+52 65 2
+765 384
+369 187 978 776
+22 24
+501 428 954 47
+5 2
+656 300 499 6
+494 546
+5 402 392 548
+75 278
+606 745 297 309
+241 627 2
+12 586
+549 559 189 779
+137 4
+46 958 7 194
+18 19
+526 740 817 21
+186 92
+340 447 970 236
+771 140
+717 71 787 885
+341 917 2
+562 425
+783 957 382 739
+218 190
+498 57 390 299
+1 1
+233 320 920 1
+49 233
+219 332 549 248
+480 359
+969 659 769 718
+500 77 2
+800 453
+506 665 520 821
+412 21
+871 378 204 478
+20 40
+172 963 747 44
+163 109
+846 564 775 277
+411 509
+709 367 247 699
+913 517 2
+438 495
+242 879 176 652
+374 102
+216 69 835 708
+30 58
+524 794 32 71
+397 26
+88 571 386 886
+232 481
+333 192 794 809
+434 729 2
+353 664
+739 708 624 916
+14 49
+520 853 9 376
+1 3
+340 496 434 3
+283 657
+349 85 955 800
+215 830
+21 251 109 899
+290 327 2
+221 488
+425 90 815 561
+97 159
+109 760 64 267
+4 2
+801 242 69 7
+209 220
+97 574 13 286
+131 302
+729 106 277 333
+628 337 2
+23 130
+161 406 455 224
+389 430
+793 896 886 605
+7 11
+871 715 940 13
+309 149
+833 43 29 317
+14 101
+206 619 221 323
+950 324 2
+382 386
+237 285 492 788
+539 532
+842 746 526 809
+62 60
+641 128 580 92
+5 7
+137 119 15 9
+402 563
+446 248 393 842
+642 580 2
+253 437
+451 745 475 753
+288 48
+34 290 884 620
+18 40
+148 37 74 65
+52 25
+564 791 334 77
+4 93
+823 63 646 284
+533 381 2
+93 295
+942 79 375 684
+83 23
+422 291 917 430
+10 15
+692 613 456 23
+155 464
+142 558 663 557
+126 444
+764 906 703 768
+956 610 2
+175 203
+642 420 108 632
+199 335
+658 874 715 779
+27 26
+37 956 739 53
+103 240
+251 232 222 614
+262 326
+697 623 521 527
+473 209 2
+38 26
+435 450 519 65
+167 341
+714 563 948 358
+20 7
+890 511 311 32
+241 98
+585 209 622 316
+415 83
+194 145 527 543
+769 340 2
+240 205
+149 511 59 939
+447 428
+834 906 987 702
+10 1
+783 226 664 20
+368 469
+177 445 637 850
+328 22
+492 283 357 619
+16 568 2
+380 542
+445 325 581 683
+13 10
+101 971 396 15
+1 2
+234 168 442 2
+9 152
+945 89 932 172
+348 248
+689 627 696 447
+769 864 2
+345 114
+182 290 472 452
+355 601
+481 609 643 710
+53 19
+133 829 577 76
+378 66
+348 336 433 519
+574 271
+847 252 667 608
+330 330 2
+245 597
+684 89 256 650
+30 46
+417 409 636 312
+5 2
+236 943 280 6
+117 146
+615 775 832 223
+7 12
+353 186 107 16
+462 280 2
+824 24
+243 589 242 946
+368 74
+480 415 75 375
+5 8
+589 223 293 8
+647 594
+981 952 541 983
+284 257
+427 632 555 365
+816 159 2
+519 623
+519 756 873 679
+435 609
+891 719 333 632
+6 6
+874 500 522 28
+49 210
+954 657 739 388
+20 36
+473 708 831 251
+998 170 2
+455 327
+12 321 890 469
+236 78
+255 637 797 818
+34 1
+167 191 237 39
+608 27
+187 494 159 649
+249 180
+935 825 164 533
+514 863 2
+212 139
+951 359 544 272
+393 233
+742 52 391 425
+1 3
+210 583 168 47
+59 33
+371 633 77 179
+707 806
+522 643 958 903
+497 712 2
+58 80
+786 316 104 173
+141 341
+397 937 967 468
+12 6
+485 909 296 36
+426 270
+687 160 576 493
+28 177
+932 726 631 685
+351 490 2
+588 656
+867 187 989 903
+149 14
+408 504 113 343
+11 2
+116 72 65 21
+91 36
+146 590 781 140
+80 42
+547 6 173 267
+296 633 2
+48 8
+421 784 83 58
+34 89
+315 421 241 278
+7 13
+573 626 111 26
+361 257
+265 39 8 364
+14 44
+674 303 876 46
+136 801 2
+99 483
+436 695 919 618
+22 41
+666 715 388 127
+1 2
+482 583 478 2
+458 234
+39 160 420 496
+438 484
+349 709 431 537
+387 85 2
+82 221
+596 268 556 924
+97 246
+608 39 236 344
+30 16
+607 604 162 36
+284 611
+656 372 886 676
+31 47
+160 324 970 297
+165 354 2
+597 760
+538 219 926 859
+110 91
+283 621 671 150
+5 11
+49 404 158 13
+42 17
+345 31 409 61
+41 16
+160 448 354 120
+249 540 2
+918 839
+400 927 410 996
+186 176
+669 393 88 213
+1 1
+788 628 528 1
+402 528
+181 22 523 543
+175 141
+799 997 402 644
+445 287 2
+361 156
+628 174 747 369
+237 314
+12 879 291 424
+22 20
+452 512 387 40
+57 384
+864 339 957 421
+501 8
+827 151 78 520
+763 374 2
+321 421
+601 323 70 456
+527 148
+642 74 93 748
+20 15
+244 11 914 23
+350 191
+807 860 574 939
+620 156
+279 634 675 809
+425 39 2
+752 385
+811 187 622 948
+292 222
+12 143 608 386
+9 5
+633 146 514 23
+211 215
+894 693 864 310
+709 396
+135 691 837 778
+865 348 2
+278 484
+166 576 304 730
+533 474
+903 642 498 670
+3 2
+495 32 416 4
+9 10
+607 416 472 10
+83 112
+647 116 990 327
+800 954 2
+144 117
+710 703 439 245
+389 75
+133 615 901 646
+3 10
+537 481 182 16
+544 483
+369 91 585 618
+489 423
+403 858 268 524
+930 12 2
+304 30
+304 916 887 305
+638 32
+26 625 967 930
+40 52
+68 475 73 54
+67 31
+645 729 529 171
+392 703
+120 969 483 710
+715 72 2
+441 540
+423 115 917 570
+467 94
+100 549 243 565
+1 1
+227 199 797 1
+33 123
+977 775 857 1000
+2 6
+280 958 590 8
+663 16 2
+169 477
+510 376 476 540
+339 503
+614 248 494 604
+39 15
+843 132 278 48
+520 459
+313 584 80 718
+285 173
+41 67 913 870
+338 665 2
+173 140
+267 792 521 276
+304 187
+868 923 970 337
+12 2
+992 923 463 16
+73 195
+775 24 288 296
+224 406
+686 197 913 564
+656 687 2
+18 20
+490 573 447 150
+420 57
+25 789 37 648
+14 21
+606 571 686 22
+72 180
+282 131 414 219
+158 618
+51 585 489 751
+589 797 2
+470 11
+213 20 226 692
+376 35
+499 768 377 478
+23 9
+880 205 286 41
+165 249
+883 477 453 674
+385 68
+853 105 54 410

2020/finals/spider_spring.md

@@ -0,0 +1,104 @@
+A family of water spiders lives at a spring located on an earthquake hotspot. The spring features \(N\) columns of rocks in a row, numbered \(1\) to \(N\) from left to right. Each rocky column \(i\) has a width of 1 cm and a height of \(H_i\) cm.
+
+The spring always has some global water level. The rocky columns can each be below the water, at water level, or protrude above its surface. A spider in a given column must float on the surface of the water (if the rock is below water level) or stand atop the rock (if it's at or above water level). This means that, when the water level is W cm, the **effective elevation** at column \(i\) is \(max(H_i, W)\) cm.
+
+For example, the following diagram illustrates a spring with \(H = [2, 1, 3, 1]\) and \(W = 2\), with the effective elevations outlined in black:
+
+{{PHOTO_ID:1583104035206937}}
+
+Water spiders sometimes want to travel from one column \(a\) to another column \(b\). This involves starting horizontally in the middle of column \(a\), at its effective elevation, and walking along the outline of the effective elevations until ending up horizontally in the middle of column \(b\). This may include walking left/right across the tops of rocks or the surface of the water, as well as up/down along the sides of the protruding rocks. Note that a spider's route will never take it left of column \(1\), right of column \(N\), below the surface of the water, nor into mid-air.
+
+For example, the path which a water spider would follow from column 1 to column 4 (having a length of 5 cm) is indicated in red below:
+
+{{PHOTO_ID:862340924576901}}
+
+Unfortunately for the spring's inhabitants, frequent earthquakes occur, altering the heights of the rocky columns and the water. The spiders would like to survey the accessibility of the spring after each earthquake.
+
+Specifically, \(M\) earthquakes are about to occur, one after another. As part of the \(i\)th earthquake, the height of each rocky column \(c\) such that \(X_i \le c \le min(X_i + Y_i - 1, N)\) will become equal to \(Z_i\) cm, and the global water level will become \(W_i\) cm. After each earthquake \(i\), the spiders are interested in the current sum of travel distances (in cm) over all \(N*(N - 1)\) ordered pairs of starting and ending columns — we'll call this quantity \(S_i\).
+
+Please determine the value of \((S_1 * S_2 * ... * S_M)\) modulo 1,000,000,007.
+
+In order to reduce the size of the input, the above values will not all be provided explicitly. Instead, you'll be given the first \(K\) values \(H_{1..K}\), \(X_{1..K}\), \(Y_{1..K}\), \(Z_{1..K}\), and \(W_{1..K}\), as well as the five quadruples of constants \((A_H, B_H, C_H, D_H)\), \((A_X, B_X, C_X, D_X)\), \((A_Y, B_Y, C_Y, D_Y)\), \((A_Z, B_Z, C_Z, D_Z)\), and \((A_W, B_W, C_W, D_W)\), and must then compute \(H_{(K+1)..N}\), \(X_{(K+1)..M}\), \(Y_{(K+1)..M}\), \(Z_{(K+1)..M}\), and \(W_{(K+1)..M}\) as follows:
+
+  \(H_i = ((A_H * H_{i-2} + B_H * H_{i-1} + C_H) \text{ modulo } D_H) + 1\)  for \(i > K\)
+  \(X_i = ((A_X * X_{i-2} + B_X * X_{i-1} + C_X) \text{ modulo } D_X) + 1\)  for \(i > K\)
+  \(Y_i = ((A_Y * Y_{i-2} + B_Y * Y_{i-1} + C_Y) \text{ modulo } D_Y) + 1\)  for \(i > K\)
+  \(Z_i = ((A_Z * Z_{i-2} + B_Z * Z_{i-1} + C_Z) \text{ modulo } D_Z) + 1\)  for \(i > K\)
+  \(W_i = ((A_W * W_{i-2} + B_W * W_{i-1} + C_W) \text{ modulo } D_W) + 1\)  for \(i > K\)
+
+
+# Constraints
+
+\(1 \le T \le 90\)
+\(2 \le N \le 1,000,000\)
+\(2 \le M \le 1,000,000\)
+\(2 \le K \le min(N, M)\)
+\(0 \le A_H, B_H, C_H, A_X, B_X, C_X, A_Y, B_Y, C_Y, A_Z, B_Z, C_Z, A_W, B_W, C_W \le 1,000,000\)
+\(1 \le D_H, D_Z, D_W \le 1,000,000\)
+\(1 \le D_X, D_Y \le N\)
+\(1 \le H_i \le D_H\)
+\(1 \le X_i \le D_X\)
+\(1 \le Y_i \le D_Y\)
+\(1 \le Z_i \le D_Z\)
+\(1 \le W_i \le D_W\)
+
+The sum of \(N + M\) across all springs is at most 15,000,000.
+
+
+# Input:
+
+Input begins with an integer \(T\), the number of springs. For each spring there are 11 lines:
+
+The first line contains the 3 space-separated integers \(N\), \(M\), and \(K\).
+
+The second line contains the \(K\) space-separated integers \(H_{1..K}\).
+
+The third line contains the 4 space-separated integers \(A_H\), \(B_H\), \(C_H\), and \(D_H\).
+
+The fourth line contains the \(K\) space-separated integers \(X_{1..K}\).
+
+The fifth line contains the 4 space-separated integers \(A_X\), \(B_X\), \(C_X\), and \(D_X\).
+
+The sixth line contains the \(K\) space-separated integers \(Y_{1..K}\).
+
+The seventh line contains the 4 space-separated integers \(A_Y\), \(B_Y\), \(C_Y\), and \(D_Y\).
+
+The eighth line contains the \(K\) space-separated integers \(Z_{1..K}\).
+
+The ninth line contains the 4 space-separated integers \(A_Z\), \(B_Z\), \(C_Z\), and \(D_Z\).
+
+The tenth line contains the \(K\) space-separated integers \(W_{1..K}\).
+
+The eleventh line contains the 4 space-separated integers \(A_W\), \(B_W\), \(C_W\), and \(D_W\).
+
+
+# Output
+
+For the \(i\)th spring, print a line containing *"Case #i: "*, followed by a single integer, the product of \(S_{1..M}\) modulo 1,000,000,007.
+
+
+# Explanation of Sample
+
+For the first spring, after the first earthquake, the spring looks as follows (with the 3 cm-long path which a water spider would follow from column 1 to column 2, or vice versa, indicated in red):
+
+{{PHOTO_ID:825086724953069}}
+
+After the second earthquake, the spring looks as follows (with the path now only being 2 cm long in either direction):
+
+{{PHOTO_ID:2854957798069201}}
+
+Therefore, \(S = [6, 4]\), and the final answer is (6 * 4) modulo 1,000,000,007 = 24.
+
+For the second spring, \(S = [20, 8, 12]\), with the spring left in the following state after the final earthquake:
+
+{{PHOTO_ID:2008456099296384}}
+
+For the third spring, \(S = [222, 382, 110, 266, 136, 98]\).
+
+For the fourth spring: 
+- \(H = [37, 11, 18, 6, 34, 33, 14, 20, 13, 5]\)
+- \(X = [2, 7, 3, 1, 5, 4, 9, 4, 8, 1, 6, 7]\) 
+- \(Y = [2, 1, 4, 1, 2, 1, 4, 1, 2, 1, 4, 1]\) 
+- \(Z = [24, 38, 59, 64, 17, 36, 21, 22, 45, 8, 71, 4]\) 
+- \(W = [16, 9, 55, 35, 58, 9, 4, 77, 55, 27, 10, 29]\)
+- \(S = [2926, 3736, 650, 2754, 518, 6108, 5844, 330, 788, 3844, 7096, 9186]\)

2020/finals/spider_spring.out

@@ -0,0 +1,108 @@
+Case #1: 24
+Case #2: 1920
+Case #3: 633021623
+Case #4: 26104609
+Case #5: 222201367
+Case #6: 294984794
+Case #7: 126230317
+Case #8: 701835095
+Case #9: 476355486
+Case #10: 569072565
+Case #11: 770890219
+Case #12: 331545300
+Case #13: 586465964
+Case #14: 527373588
+Case #15: 660459755
+Case #16: 300060524
+Case #17: 334130994
+Case #18: 388975932
+Case #19: 463042989
+Case #20: 304920201
+Case #21: 113772377
+Case #22: 930176068
+Case #23: 769102540
+Case #24: 408615819
+Case #25: 38456416
+Case #26: 151183167
+Case #27: 495825208
+Case #28: 379977285
+Case #29: 464573744
+Case #30: 54753620
+Case #31: 245195659
+Case #32: 641620440
+Case #33: 598545150
+Case #34: 537132549
+Case #35: 923113036
+Case #36: 526657807
+Case #37: 842401388
+Case #38: 419985955
+Case #39: 964642955
+Case #40: 740556252
+Case #41: 841709531
+Case #42: 878347921
+Case #43: 312086860
+Case #44: 955911834
+Case #45: 276614878
+Case #46: 487022859
+Case #47: 795786176
+Case #48: 343190954
+Case #49: 74385760
+Case #50: 321245598
+Case #51: 965080929
+Case #52: 823067303
+Case #53: 135908834
+Case #54: 585300036
+Case #55: 926495473
+Case #56: 931152045
+Case #57: 894178522
+Case #58: 787600444
+Case #59: 293173412
+Case #60: 68209924
+Case #61: 209830385
+Case #62: 912463885
+Case #63: 575215794
+Case #64: 685242113
+Case #65: 444403624
+Case #66: 962706125
+Case #67: 248763200
+Case #68: 792547224
+Case #69: 91173824
+Case #70: 826460523
+Case #71: 236496818
+Case #72: 562509057
+Case #73: 910930512
+Case #74: 534456170
+Case #75: 3476227
+Case #76: 336398749
+Case #77: 196148390
+Case #78: 715823122
+Case #79: 83714804
+Case #80: 641318271
+Case #81: 725243218
+Case #82: 573492387
+Case #83: 510219501
+Case #84: 199176480
+Case #85: 612804801
+Case #86: 425635646
+Case #87: 969437741
+Case #88: 378662112
+Case #89: 507530203
+Case #90: 513904049
+Case #91: 848838110
+Case #92: 322953305
+Case #93: 517889920
+Case #94: 334400162
+Case #95: 466456064
+Case #96: 798068428
+Case #97: 300601975
+Case #98: 64947010
+Case #99: 468758813
+Case #100: 34487030
+Case #101: 259390400
+Case #102: 457033816
+Case #103: 683157728
+Case #104: 793162616
+Case #105: 992419153
+Case #106: 429921572
+Case #107: 165351954
+Case #108: 782762430

2020/finals/spider_spring_sol.md

@@ -0,0 +1,11 @@
+Let a line segment \((a, b)\) refer to a consecutive pair of columns with distinct heights \(a\) and \(b\), such that \(a < b\). If the column indices are \(i\) and \(i+1\), then we'll refer to \(i\) as the line segment's *position*.
+
+We'll define the *weight* \(w\) of a line segment to be the number of spider paths which would cross it. If its index is \(i\), then \(w = i*(N-i)\). We'll say that each line segment has two separate *endpoints* with values \(a\) and \(b\), each with weight \(w\), and with weighted values \(w*a\) and \(w*b\).
+
+When evaluating an \(S\) value for a water level \(W\), we'll define a *relevant line segment endpoint* as one with a value greater than \(W\). We'll start by computing the sum of relevant \(b\) endpoints' weighted values, and subtract the sum of relevant \(a\) endpoints' weighted values. There may be line segments for which we only added the \(b\) endpoint but didn't subtract the \(a\) endpoint (due to it being having a value no greater than \(W\)). To account for this, we'll take the sum of relevant \(b\) endpoints' weights, subtract the sum of relevant \(a\) endpoints' weights, multiply that difference by \(W\), and finally subtract that product to arrive at our final answer.
+
+In order to compute the above values efficiently, we can maintain 4 Fenwick (binary indexed) trees, containing the \(a\) / \(b\) endpoints' weights / weighted values (in each case indexed by the endpoints' values). Assuming these have been maintained, we can compute each \(S\) value in \(O(log(N))\) time.
+
+At first glance, it appears we'll need to perform up to \(O(NM)\) updates to these trees, given that up to \(N\) line segments may be affected by each of the \(M\) earthquakes. However, we can observe that setting the heights of an interval of columns \([L, R]\) causes all line segments at positions in \([L, R-1]\) to disappear, causes at most 2 new line segments (at positions \(L-1\) and \(R\)) to appear, and doesn't update any other line segments. Therefore, across all of the earthquakes, only \(O(N + M)\) line segments need to be updated, and we just need to not waste time iterating over positions not featuring line segments.
+
+This can be done either by maintaining a set of intervals of equal-height columns (such that there's a line segment between each consecutive pair of intervals), or by maintaining a segment tree of column heights combined with a set of line segment positions. Either way, these data structures may be updated in amortized \(O(log(N))\) time per earthquake and allow us to only update the Fenwick trees described above for \(O(N + M)\) line segments overall. The total complexity is therefore \(O((N + M) log(N))\).

2020/finals/tree_training.cpp

@@ -0,0 +1,201 @@
+// Tree Training
+// Solution by Jacob Plachta
+
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <complex>
+#include <cstdlib>
+#include <ctime>
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <deque>
+#include <queue>
+#include <stack>
+#include <bitset>
+#include <sstream>
+using namespace std;
+
+#define LL long long
+#define LD long double
+#define PR pair<int,int>
+
+#define Fox(i,n) for (i=0; i<n; i++)
+#define Fox1(i,n) for (i=1; i<=n; i++)
+#define FoxI(i,a,b) for (i=a; i<=b; i++)
+#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
+#define FoxR1(i,n) for (i=n; i>0; i--)
+#define FoxRI(i,a,b) for (i=b; i>=a; i--)
+#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
+#define Min(a,b) a=min(a,b)
+#define Max(a,b) a=max(a,b)
+#define Sz(s) int((s).size())
+#define All(s) (s).begin(),(s).end()
+#define Fill(s,v) memset(s,v,sizeof(s))
+#define pb push_back
+#define mp make_pair
+#define x first
+#define y second
+
+template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
+template<typename T> T Sqr(T x) { return(x * x); }
+string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }
+
+const int INF = (int)1e9;
+const LD EPS = 1e-12;
+const LD PI = acos(-1.0);
+
+#define GETCHAR getchar_unlocked
+
+bool Read(int& x) {
+  char c, r = 0, n = 0;
+  x = 0;
+  for (;;) {
+    c = GETCHAR();
+    if ((c < 0) && (!r))
+      return(0);
+    if ((c == '-') && (!r))
+      n = 1;
+    else if ((c >= '0') && (c <= '9'))
+      x = x * 10 + c - '0', r = 1;
+    else if (r)
+      break;
+  }
+  if (n)
+    x = -x;
+  return(1);
+}
+
+#define MOD 1000000007
+#define LIM 1000005
+#define LOG 20
+
+int N, M;
+char S[LIM];
+int Z[LIM];
+int DS[LIM];
+
+int TreeCnt(int h) // # of nodes in binary tree with height h
+{
+  return((1 << (h + 1)) - 1);
+}
+
+// E(z, s, h) = max. *s which can fit alongside z 0s (with s *s before the 1st 0) in a tree of height at most h (only relevant for z > 0)
+int E(int z, int s, int h)
+{
+  if (h >= LOG)
+    return(N);
+  int left = min(s, h + 1 - z); // *s at root and along leftmost branch
+  int cnt = TreeCnt(h); // full tree
+  cnt -= TreeCnt(h - left); // subtract subtree of 1st 0
+  if (cnt >= s)
+    cnt += TreeCnt(h - left - 1); // add back right subtree of 1st 0
+  return(cnt);
+}
+
+// F(p, z, s) = min. tree height for p *s, z 0s, and s *s before 1st 0 (s ignored if z = 0)
+int F(int p, int z, int s)
+{
+  int r1 = z ? (s > 0 ? z : z - 1) : 0;
+  int r2 = max(r1, min(LOG, p + z - 1));
+  while (r1 < r2)
+  {
+    int m = (r1 + r2) >> 1;
+    if ((z ? E(z, s, m) : TreeCnt(m)) >= p)
+      r2 = m;
+    else
+      r1 = m + 1;
+  }
+  return(r1);
+}
+
+int ProcessCase()
+{
+  int i, j, z;
+  // input
+  scanf("%s", &S);
+  N = strlen(S);
+  // find 0s
+  M = 0;
+  Z[M++] = -1;
+  Fox(i, N)
+    if (S[i] == '0')
+      Z[M++] = i;
+  Z[M++] = N;
+  // A) z = 0
+  int ans = 0;
+  int v = 0, s = 0;
+  Fill(DS, 0);
+  Fox1(i, M - 1)
+  {
+    int x = Z[i] - Z[i - 1] - 1; // sequence of x *s before ith 0
+    v += x;
+    DS[2]--, DS[x + 2]++;
+  }
+  Fox1(i, N)
+  {
+    s += DS[i];
+    v += s;
+    ans = (ans + (LL)v * F(i, 0, 0)) % MOD;
+  }
+  // B) 1 <= z <= LOG
+  Fox1(z, LOG) // z 0s
+  {
+    Fox1(i, M - z - 1) // ith 0 as the leftmost 0
+    {
+      int j = i + z - 1;
+      int c1 = Z[i] - Z[i - 1] - 1; // c1 *s to the left
+      int c2 = Z[j + 1] - Z[j] - 1; // c2 *s to the right
+      int m = Z[j] - Z[i] + 1 - z; // m *s in between
+      Fox(s, c1 + 1) // use s *s to the left
+      {
+        int p = s + m, mp = s + m + c2;
+        int h = F(p, z, s);
+        while (p <= mp)
+        {
+          int p2 = min(mp, E(z, s, h));
+          ans = (ans + (LL)(p2 - p + 1) * h) % MOD;
+          p = p2 + 1, h++;
+        }
+      }
+    }
+  }
+  // C) z > LOG
+  Fox1(i, M - 2) // count contribution of the ith 0
+  {
+    // add # of intervals containing it
+    ans = (ans + (LL)(Z[i] + 1) * (N - Z[i])) % MOD;
+    // subtract # of intervals containing it, with <= LOG 0s
+    FoxI(j, max(1, i - LOG + 1), i) // jth 0 as the leftmost 0
+    {
+      int k = min(M - 1, j + LOG); // first disallowed 0
+      int c = (LL)(Z[j] - Z[j - 1]) * (Z[k] - Z[i]) % MOD;
+      ans = (ans + MOD - c) % MOD;
+    }
+    // subtract # of intervals starting with it, with > LOG 0s
+    int j = i + LOG;
+    if (j < M)
+      ans = (ans + MOD - (N - Z[j])) % MOD;
+  }
+  return(ans);
+}
+
+int main()
+{
+  int T, t;
+  Read(T);
+  Fox1(t, T)
+    printf("Case #%d: %d\n", t, ProcessCase());
+  return(0);
+}