Update content/5_Plat/Range_Sweep.mdx

Author: HaccerKat

content/5_Plat/Range_Sweep.mdx

@@ -1,7 +1,7 @@
 ---
 id: range-sweep
 title: 'Range Queries with Sweep Line'
-author: Benjamin Qi, Andi Qu, Dong Liu
+author: Benjamin Qi, Andi Qu, Dong Liu, Peng Bai
 prerequisites:
   - PURS
   - lis
@@ -13,9 +13,6 @@ frequency: 2
 
 <FocusProblem problem="sample2" />
 
-## Tutorial
-
-<IncompleteSection />
 
 ## Solution - Intersection Points
 
@@ -46,10 +43,12 @@ Our answer would be the sum of all the queries.
 #include <bits/stdc++.h>
 using namespace std;
 
-int bit[2000005];
+// max coordinate
+const int X = 1e6;
+int bit[2 * X + 1];
 
 void update(int i, int x) {
-	for (; i < 2000005; i += i & (-i)) bit[i] += x;
+	for (; i <= 2 * X; i += i & (-i)) bit[i] += x;
 }
 int query(int i) {
 	int sum = 0;
@@ -62,8 +61,11 @@ vector<array<int, 4>> v;
 
 int main() {
 	cin.tie(0)->sync_with_stdio(0);
-
 	cin >> n;
+	// types of events (order for if some y values are equal):
+	// 1 -> start of vertical segment
+	// 2 -> horizontal segment
+	// 3 -> end of vertical segment
 	for (int i = 0, x1, y1, x2, y2; i < n; ++i) {
 		cin >> x1 >> y1 >> x2 >> y2;
 		if (y1 == y2) v.push_back({y1, 2, x1, x2});
@@ -75,11 +77,11 @@ int main() {
 	sort(begin(v), end(v));
 
 	long long ans = 0;
-	for (auto x : v) {
-		x[2] += 1000001, x[3] += 1000001;
-		if (x[1] == 1) update(x[2], 1);
-		else if (x[1] == 2) ans += query(x[3]) - query(x[2] - 1);
-		else update(x[2], -1);
+	for (auto [y, type, x1, x2] : v) {
+		x1 += X, x2 += X;
+		if (type == 1) update(x1, 1);
+		else if (type == 2) ans += query(x2) - query(x1 - 1);
+		else update(x1, -1);
 	}
 	cout << ans << '\n';
 }
@@ -91,20 +93,50 @@ int main() {
 
 ## Solution - Springboards
 
-<IncompleteSection />
+**Naive DP:** $\mathcal{O}(P^2)$
 
-The problem boils down to having a data structure that supports the following
-operations:
+The first step is to create a DP to solve the first subtask. The states are the springboards and the transitions are between springboards. First, sort the springboards by the pair $(x_1, y_1)$ in increasing order. It is possible to show that for all $i$, $j$, where $i < j$, Bessie cannot use springboard $j$ then $i$ later.
 
-1. Add a pair $(a,b)$.
-2. For any $x$, query the minimum value of $b$ over all pairs satisfying
-   $a\le x$.
+For each springboard $A_i$, let $ans[i]$ denote the minimum distance needed to walk to the start point of springboard $i$.
+
+Let $dist(a, b)$ be the walking distance from the end of springboard $a$ and the start of springboard $b$.
+
+$dist(a, b) = x_1[b] + y_1[b] - x_2[a] - y_2[a]$
+
+Then, the transitions are:
+
+$ans[i] = \min\limits_{j < i, x_2[j] \le x_1[i], y_2[j] \le y_1[i]}(ans[j] + dist(j, i))$ 
+
+**Full Solution:** $\mathcal{O}(P \log P)$
+
+Optimizing the DP involves the use of a min point update range query segment tree. Let's first expand $dist(i, j)$ in the transition formula.
+
+$ans[i] = \min\limits_{j < i, x_2[j] \le x_1[i], y_2[j] \le y_1[i]}(ans[j] + x_1[i] + y_1[i] - x_2[j] - y_2[j])$ 
+
+$ans[i] = x_1[i] + y_1[i] + \min\limits_{j < i, x_2[j] \le x_1[i], y_2[j] \le y_1[i]}(ans[j] - x_2[j] - y_2[j])$ 
 
-The [other module](/adv/springboards) describes a simpler way of doing this,
-though it's probably more straightforward to do coordinate compression and use a
-min segtree. The latter approach is shown below.
+We notice that everything inside the $\min$ statement only depends on $j$. The segment tree stores $ans[j] - x_2[j] - y_2[j]$ at index $y_2[j]$. We can seperate the start and end of springboards to create two seperate events from them, still sorting by $(x, y)$. When the event is the start of a springboard, update $ans[i]$ through a segment tree query. When the event is the end of a springboard, update the segment tree.
+
+By processing in order, the first two conditions in the $\min$ statement are always satisfied. The third is where the segment tree comes into play, where querying the range $[0, y_1[i]]$ is sufficent to satisfy all constraints.
+
+Due to the large $N$, coordinate compression is required in the code.
 
 ```cpp
+#include <bits/stdc++.h>
+using namespace std;
+#define f first
+#define s second
+#define pb push_back
+#define rep(i, a, b) for(int i = a; i < (b); ++i)
+#define all(x) begin(x), end(x)
+#define sz(x) (int)(x).size()
+typedef long long ll;
+typedef pair<int, int> pii;
+typedef vector<int> vi;
+
+template<class T> bool ckmin(T& a, const T& b) {
+	return b < a ? a = b, 1 : 0; } // set a = min(a,b)
+
 /**
  * Description: 1D point update, range query where \texttt{comb} is
  * any associative operation. If $N=2^p$ then \texttt{seg[1]==query(0,N-1)}.
@@ -139,27 +171,31 @@ template <class T> struct Seg {  // comb(ID,b) = b
 	}
 };
 
+const int MX = 1e5 + 5;
 Seg<int> S;
 int N, P;
 int ans[MX];
 vi distinct_y;
 
 int query_min(int ind) { return S.query(0, ind); }
 void ins(int ind, int val) { S.upd(ind, val); }
-int y_index(int y) { return lb(all(distinct_y), y) - begin(distinct_y); }
+int y_index(int y) { return lower_bound(all(distinct_y), y) - begin(distinct_y); }
 
 int main() {
-	setIO("boards");
+	ios_base::sync_with_stdio(0); cin.tie(0);
+	freopen("boards.in", "r", stdin);
+	freopen("boards.out", "w", stdout);
 	cin >> N >> P;
 	vector<pair<pair<int, int>, pair<int, int>>> ev;
 	for (int i = 0; i < P; ++i) {
 		pair<int, int> a, b;
 		cin >> a.f >> a.s >> b.f >> b.s;
-		ev.push_back({a, {i, -1}});  // start point
-		ev.push_back({b, {i, 1}});   // end point
+		ev.pb({a, {i, -1}});  // start point
+		ev.pb({b, {i, 1}});   // end point
 		distinct_y.pb(a.s);
 		distinct_y.pb(b.s);
 	}
+
 	sort(all(distinct_y));
 	sort(begin(ev), end(ev));
 	S.init(2 * P);
@@ -175,6 +211,19 @@ int main() {
 }
 ```
 
+Bonus: Think of this problem as maximizing the distance covered by springboards to simplify the solution.
+
+## Different Approach - Springboards
+It turns out there is also a simpler though less straightforward method to solve this problem.
+
+The problem boils down to having a data structure that supports the following
+operations:
+
+1. Add a pair $(a,b)$.
+2. For any $x$, query the minimum value of $b$ over all pairs satisfying
+   $a\le x$.
+
+This solution is described in the [official editorial](https://usaco.org/current/data/sol_boards_gold_jan20.html) and the [other module](/adv/springboards).
 ## Problems
 
 <Problems problems="sweep" />