Merge pull request #4360 from cpinitiative/mobile-o(n)

add o(N) solution to mobile

Author: SansPapyrus683

content/3_Silver/Binary_Search.problems.json

@@ -334,7 +334,7 @@
       "source": "Baltic OI",
       "difficulty": "Very Hard",
       "isStarred": false,
-      "tags": ["Binary Search"],
+      "tags": ["Binary Search", "Stack"],
       "solutionMetadata": {
         "kind": "internal"
       }

content/4_Gold/Stacks.problems.json

@@ -52,6 +52,18 @@
         "kind": "internal"
       }
     },
+    {
+      "uniqueId": "baltic-12-mobile",
+      "name": "2012 - Mobile",
+      "url": "https://oj.uz/problem/view/BOI12_mobile",
+      "source": "Baltic OI",
+      "difficulty": "Normal",
+      "isStarred": false,
+      "tags": ["Binary Search", "Stack"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
     {
       "uniqueId": "usaco-743",
       "name": "Modern Art 2",

solutions/silver/baltic-12-mobile.mdx

@@ -2,7 +2,7 @@
 id: baltic-12-mobile
 source: Baltic OI 2012
 title: Mobile
-author: Andi Qu
+author: Andi Qu, Ryan Chou
 ---
 
 [Official Analysis](https://boi.cses.fi/files/boi2012_solutions.zip)
@@ -64,8 +64,6 @@ a sorted list and still get the correct answer!
 This gets rid of the $\log N$ factor in our original complexity and so the final
 complexity is $\mathcal{O}(N \log L)$, which is good enough for 100 points.
 
-(There is also an $\mathcal{O}(N)$ solution - try to come up with it yourself!)
-
 ## Implementation
 
 ```cpp
@@ -100,3 +98,147 @@ int main() {
 	return 0;
 }
 ```
+
+---
+
+<Info title="Faster Solution">
+
+Although not necessary for full credit, there also exists an $\mathcal{O}(N)$ solution.
+
+Try to come up with it yourself before moving on!
+
+</Info>
+
+<Spoiler title="Faster Solution">
+
+The key observation is that not all stations contribute to the answer. If we ever have a station that isn't the closest to any point on the highway, we can simply ignore it.
+
+In fact, we can also ignore some points on the highway! Once we have this list of key stations, the number of points can be bounded by the number of key stations.
+
+<Spoiler title="How?">
+
+Let's say that we're looking for the point on the highway (excluding the endpoints) with the maximum distance to the nearest station, where there are only two stations, $a$ and $b$.
+
+Then, we can imagine a line perpendicular to the line segment formed by these two stations that passes through the midpoint. Everything on the left side is closer to $a$, and everything on the right side is closer to $b$.
+
+Thus, the maximum point is at the point where the perpendicular line intersects the highway! We only have to get the answer from these critical points, and since there are only two stations that could be closest to it, we can compute them in $\mathcal{O}(1)$.
+
+![Maximum Point](<baltic-12-mobile/perpendicular.png>)
+
+This intersection can be represented by $\frac{b_x^2 + b_y^2 - a_x^2 - a_y^2}{2(b_x - a_x)}$.
+
+From here on, we'll refer to this point as $p(a, b)$, where $a$ and $b$ are stations.
+
+</Spoiler>
+
+Now, let's consider cases where there exist unnecessary stations.
+
+Without loss of generality, let's assume all points are above the y-axis, and $a_x < b_x < c_x$. If not all the points are above the y-axis, we can just flip their sign because the distance to the x-axis remains the same.
+
+### Case 1: $p(a, b) < p(b, c)$
+
+In this arrangement, all stations are the closest to some points on the highway, so we should keep them.
+
+![Case 1](<baltic-12-mobile/case1.png>)
+
+### Case 2: $p(a, b) > p(b, c)$
+
+Note how this creates a cross, which makes $b$ useless. All points on the highway are now closer to $a$ or $c$. To find the maximum point here, we can just remove $b$, and recalculate for $p(a, c)$.
+
+![Case 2](<baltic-12-mobile/case2.png>)
+
+Since we only remove the most recent stations, this motivates the use of a [stack](/gold/stacks) to perform these removals/additions in $\mathcal{O}(1)$.
+
+## Implementation
+
+**Time Complexity**: $\mathcal{O}(N)$
+
+<LanguageSection>
+<CPPSection>
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Point {
+	double x, y;
+};
+
+/**
+ * @return the intersection of the perpendicular line that
+ * crosses the midpoint of Points a & b with the highway
+ */
+double max_point(const Point &a, const Point &b) {
+	return (b.x * b.x + b.y * b.y - a.x * a.x - a.y * a.y) /
+	       (2 * b.x - 2 * a.x);
+}
+/** @return the euclidean distance between points a & b */
+double dist(const Point &a, const Point &b) {
+	return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
+}
+
+int main() {
+	int n, l;
+	cin >> n >> l;
+
+	deque<Point> needed;
+	for (int i = 0; i < n; i++) {
+		Point cur;
+		cin >> cur.x >> cur.y;
+		cur.y = abs(cur.y);
+
+		// always take the one with the lowest y coord
+		if ((int)needed.size() && needed.back().x == cur.x) {
+			if (cur.y >= needed.back().y) {
+				continue;
+			} else if (cur.y < needed.back().y) {
+				needed.pop_back();
+			}
+		}
+
+		// find "crosses"
+		while ((int)needed.size() > 1 &&
+		       max_point(needed[(int)needed.size() - 2], needed.back()) >
+		           max_point(needed.back(), cur)) {
+			needed.pop_back();
+		}
+
+		needed.push_back(cur);
+	}
+
+	// out of bounds
+	while ((int)needed.size() > 1 && max_point(needed[0], needed[1]) < 0) {
+		needed.pop_front();
+	}
+
+	while ((int)needed.size() > 1 &&
+	       max_point(needed[(int)needed.size() - 2], needed.back()) > l) {
+		needed.pop_back();
+	}
+
+	double ans = 0;
+	for (int x = 0; x < (int)needed.size(); x++) {
+		// get critical points needed[x] is in charge of
+		Point left = {0, 0};
+		Point right{l, 0};
+
+		if (x) { left.x = max_point(needed[x], needed[x - 1]); }
+		if (x < (int)needed.size() - 1) {
+			right.x = max_point(needed[x], needed[x + 1]);
+		}
+
+		if (left.x < 0 || right.x > l || right.x < 0 || left.x > l) {
+			continue;
+		}
+
+		ans = max({ans, dist(needed[x], left), dist(needed[x], right)});
+	}
+
+	cout << fixed << setprecision(6) << ans << endl;
+}
+```
+
+</CPPSection>
+</LanguageSection>
+
+</Spoiler>