@@ -183,7 +183,18 @@ Now we need to decide on how to set $d$ so that it minimizes $\Theta(\sum_{i=1}^ We need $d$ to be an approximation of the minimum distance $d$, and the trick is to just sample $n$ distances randomly and choose $d$ to be the smallest of these distances. We now prove that with high probability this has linear cost. -**Proof.** Assume with a particular choice of $d$, the resulting squares have $C \coloneqq \sum_{i=1}^{k} n_i^2 = \lambda n$. What is the probability that such $d$ survives the sampling of $n$ independent distances? If a single pair among the sampled ones has distance smaller than $d$, this arrangement is not possible. Inside a square, at least half of the pairs would raise a smaller distance, so we have $\sum_{i=1}^{k} \frac{1}{2} {n_i \choose 2}$ pairs which yield a smaller final $d$. This is, approximately, $\frac{1}{4} \sum_{i=1}^{k} n_i^2 = \frac{\lambda}{4} n$. On the other hand, there are about $\frac{1}{2} n^2$ pairs that can be sampled. We have that the probability of sampling a pair with distance smaller than $d$ is at least (approximately) $\frac{\lambda n / 4}{n^2 / 2} = \frac{\lambda/2}{n}$, so the probability of at least one such pair being chosen during the $n$ rounds (and therefore avoiding this situation) is $1 - (1 - \frac{\lambda/2}{n})^n \approx 1 - e^{-\lambda/2}$. This goes to $1$ as $\lambda$ increases. $\quad \blacksquare$ +**Proof.** Imagine the disposition of points in squares with a particular choice of $d$, say $x$. Consider $d$ a random variable, resulting from our sampling of distances. Let's define $C(x) = \sum_{i=1}^{k(x)} n_i(x)^2$ as the cost estimation for a particular disposition when we choose $d=x$. Now, let's define $\lambda(x)$ such that $C(x) = \lambda(x) \, n$. What is the probability that such choice $x$ survives the sampling of $n$ independent distances? If a single pair among the sampled ones has distance smaller than $x$, this arrangement will be replaced by the smaller $d$. Inside a square, at least a quarter of the pairs would raise a smaller distance (imagine four subsquares in every square, and use the pigeonhole principle), so we have $\sum_{i=1}^{k} \frac{1}{4} {n_i \choose 2}$ pairs which yield a smaller final $d$. This is, approximately, $\frac{1}{8} \sum_{i=1}^{k} n_i^2 = \frac{1}{8} \lambda(x) n$. On the other hand, there are about $\frac{1}{2} n^2$ pairs that can be sampled. We have that the probability of sampling a pair with distance smaller than $x$ is at least (approximately) +$$\frac{\lambda(x) n / 8}{n^2 / 2} = \frac{\lambda(x)/4}{n}$$ +so the probability of at least one such pair being chosen during the $n$ rounds (and therefore finding a smaller $d$) is +$$1 - \left(1 - \frac{\lambda(x)/4}{n}\right)^n \ge 1 - e^{-\lambda(x)/4}$$ +(we have used that $(1 + x)^n \le e^{xn}$ for any real number $x$, check https://en.wikipedia.org/wiki/Bernoulli%27s_inequality#Related_inequalities).
Notice this goes to $1$ exponentially as $\lambda(x)$ increases. This hints that $\lambda$ will be small usually. + + +We have shown that $\Pr(d \le x) \ge 1 - e^{-\lambda(x)/4}$, or equivalently, $\Pr(d \ge x) \le e^{-\lambda(x)/4}$. We need to know $\Pr(\lambda(d) \ge \text{something})$ to be able to estimate its expected value. We notice that $\lambda(d) \ge \lambda(x) \iff d \ge x$. This is because making the squares smaller only reduces the number of points in each square (splits the points into other squares), and this keeps reducing the sum of squares. Therefore, +$$\Pr(\lambda(d) \ge \lambda(x)) = \Pr(d \ge x) \le e^{-\lambda(x)/4} \implies \Pr(\lambda(d) \ge t) \le e^{-t/4} \implies \mathbb{E}[\lambda(d)] \le \int_{0}^{+\infty} e^{-t/4} \, \mathrm{d}t = 4$$ +(we have used that $E[X] = \int_0^{+\infty} \Pr(X \ge x) \, \mathrm{d}x$, check https://math.stackexchange.com/a/1690829). + +Finally, $\mathbb{E}[C(d)] = \mathbb{E}[\lambda(d) \, n] \le 4n$, and the expected running time is $O(n)$, with a reasonable constant factor. $\quad \blacksquare$ #### Implementation of the algorithm @@ -277,7 +288,7 @@ pair closest_pair_of_points_rand_reals(vector P) { ``` -### A randomized algorithm with expected linear time +### An alternative randomized linear expected time algorithm Now we introduce a different randomized algorithm which is less practical but very easy to show that it runs in expected linear time. From f79a21148de2bf1037ee38bef290718495591e75 Mon Sep 17 00:00:00 2001 From: Izan Beltran Date: Thu, 26 Jun 2025 21:31:23 +0200 Subject: [PATCH 04/12] Update nearest_points.md - small mistakes in writing --- src/geometry/nearest_points.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index d2bf8f740..067eee4ef 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -181,7 +181,7 @@ Now we need to decide on how to set $d$ so that it minimizes $\Theta(\sum_{i=1}^ #### Choosing d -We need $d$ to be an approximation of the minimum distance $d$, and the trick is to just sample $n$ distances randomly and choose $d$ to be the smallest of these distances. We now prove that with high probability this has linear cost. +We need $d$ to be an approximation of the minimum distance $d$, and the trick is to just sample $n$ distances randomly and choose $d$ to be the smallest of these distances. We now prove that the expected running time is linear. **Proof.** Imagine the disposition of points in squares with a particular choice of $d$, say $x$. Consider $d$ a random variable, resulting from our sampling of distances. Let's define $C(x) = \sum_{i=1}^{k(x)} n_i(x)^2$ as the cost estimation for a particular disposition when we choose $d=x$. Now, let's define $\lambda(x)$ such that $C(x) = \lambda(x) \, n$. What is the probability that such choice $x$ survives the sampling of $n$ independent distances? If a single pair among the sampled ones has distance smaller than $x$, this arrangement will be replaced by the smaller $d$. Inside a square, at least a quarter of the pairs would raise a smaller distance (imagine four subsquares in every square, and use the pigeonhole principle), so we have $\sum_{i=1}^{k} \frac{1}{4} {n_i \choose 2}$ pairs which yield a smaller final $d$. This is, approximately, $\frac{1}{8} \sum_{i=1}^{k} n_i^2 = \frac{1}{8} \lambda(x) n$. On the other hand, there are about $\frac{1}{2} n^2$ pairs that can be sampled. We have that the probability of sampling a pair with distance smaller than $x$ is at least (approximately) $$\frac{\lambda(x) n / 8}{n^2 / 2} = \frac{\lambda(x)/4}{n}$$ From c2eba24a1b074a2561f0ad718d944c9f8f4fe311 Mon Sep 17 00:00:00 2001 From: Izan Beltran Date: Thu, 26 Jun 2025 21:37:58 +0200 Subject: [PATCH 05/12] Update nearest_points.md - improve image size and latex spacing for correct visualization --- src/geometry/nearest_points.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index 067eee4ef..454b62595 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -169,7 +169,7 @@ rec(0, n); An alternative method arises from a very simple idea to heuristically improve the runtime: We can divide the plane into a grid of $d \times d$ squares, then it is only required to test distances between same-block or adjacent-block points (unless all squares are disconnected from each other, but we will avoid this by design), since any other pair has larger distance that the two points in the same square.

@@ -184,14 +184,20 @@ Now we need to decide on how to set $d$ so that it minimizes $\Theta(\sum_{i=1}^ We need $d$ to be an approximation of the minimum distance $d$, and the trick is to just sample $n$ distances randomly and choose $d$ to be the smallest of these distances. We now prove that the expected running time is linear. **Proof.** Imagine the disposition of points in squares with a particular choice of $d$, say $x$. Consider $d$ a random variable, resulting from our sampling of distances. Let's define $C(x) = \sum_{i=1}^{k(x)} n_i(x)^2$ as the cost estimation for a particular disposition when we choose $d=x$. Now, let's define $\lambda(x)$ such that $C(x) = \lambda(x) \, n$. What is the probability that such choice $x$ survives the sampling of $n$ independent distances? If a single pair among the sampled ones has distance smaller than $x$, this arrangement will be replaced by the smaller $d$. Inside a square, at least a quarter of the pairs would raise a smaller distance (imagine four subsquares in every square, and use the pigeonhole principle), so we have $\sum_{i=1}^{k} \frac{1}{4} {n_i \choose 2}$ pairs which yield a smaller final $d$. This is, approximately, $\frac{1}{8} \sum_{i=1}^{k} n_i^2 = \frac{1}{8} \lambda(x) n$. On the other hand, there are about $\frac{1}{2} n^2$ pairs that can be sampled. We have that the probability of sampling a pair with distance smaller than $x$ is at least (approximately) + $$\frac{\lambda(x) n / 8}{n^2 / 2} = \frac{\lambda(x)/4}{n}$$ + so the probability of at least one such pair being chosen during the $n$ rounds (and therefore finding a smaller $d$) is + $$1 - \left(1 - \frac{\lambda(x)/4}{n}\right)^n \ge 1 - e^{-\lambda(x)/4}$$ + (we have used that $(1 + x)^n \le e^{xn}$ for any real number $x$, check https://en.wikipedia.org/wiki/Bernoulli%27s_inequality#Related_inequalities).
Notice this goes to $1$ exponentially as $\lambda(x)$ increases. This hints that $\lambda$ will be small usually. We have shown that $\Pr(d \le x) \ge 1 - e^{-\lambda(x)/4}$, or equivalently, $\Pr(d \ge x) \le e^{-\lambda(x)/4}$. We need to know $\Pr(\lambda(d) \ge \text{something})$ to be able to estimate its expected value. We notice that $\lambda(d) \ge \lambda(x) \iff d \ge x$. This is because making the squares smaller only reduces the number of points in each square (splits the points into other squares), and this keeps reducing the sum of squares. Therefore, + $$\Pr(\lambda(d) \ge \lambda(x)) = \Pr(d \ge x) \le e^{-\lambda(x)/4} \implies \Pr(\lambda(d) \ge t) \le e^{-t/4} \implies \mathbb{E}[\lambda(d)] \le \int_{0}^{+\infty} e^{-t/4} \, \mathrm{d}t = 4$$ + (we have used that $E[X] = \int_0^{+\infty} \Pr(X \ge x) \, \mathrm{d}x$, check https://math.stackexchange.com/a/1690829). Finally, $\mathbb{E}[C(d)] = \mathbb{E}[\lambda(d) \, n] \le 4n$, and the expected running time is $O(n)$, with a reasonable constant factor. $\quad \blacksquare$ From 5a2e3493130642d71f013b710d3d5f6ee1dffb74 Mon Sep 17 00:00:00 2001 From: Izan Beltran Date: Thu, 26 Jun 2025 21:43:19 +0200 Subject: [PATCH 06/12] Update nearest_points.md - avoid \coloneqq and add links --- src/geometry/nearest_points.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index 454b62595..794256466 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -183,7 +183,7 @@ Now we need to decide on how to set $d$ so that it minimizes $\Theta(\sum_{i=1}^ We need $d$ to be an approximation of the minimum distance $d$, and the trick is to just sample $n$ distances randomly and choose $d$ to be the smallest of these distances. We now prove that the expected running time is linear. -**Proof.** Imagine the disposition of points in squares with a particular choice of $d$, say $x$. Consider $d$ a random variable, resulting from our sampling of distances. Let's define $C(x) = \sum_{i=1}^{k(x)} n_i(x)^2$ as the cost estimation for a particular disposition when we choose $d=x$. Now, let's define $\lambda(x)$ such that $C(x) = \lambda(x) \, n$. What is the probability that such choice $x$ survives the sampling of $n$ independent distances? If a single pair among the sampled ones has distance smaller than $x$, this arrangement will be replaced by the smaller $d$. Inside a square, at least a quarter of the pairs would raise a smaller distance (imagine four subsquares in every square, and use the pigeonhole principle), so we have $\sum_{i=1}^{k} \frac{1}{4} {n_i \choose 2}$ pairs which yield a smaller final $d$. This is, approximately, $\frac{1}{8} \sum_{i=1}^{k} n_i^2 = \frac{1}{8} \lambda(x) n$. On the other hand, there are about $\frac{1}{2} n^2$ pairs that can be sampled. We have that the probability of sampling a pair with distance smaller than $x$ is at least (approximately) +**Proof.** Imagine the disposition of points in squares with a particular choice of $d$, say $x$. Consider $d$ a random variable, resulting from our sampling of distances. Let's define $C(x) := \sum_{i=1}^{k(x)} n_i(x)^2$ as the cost estimation for a particular disposition when we choose $d=x$. Now, let's define $\lambda(x)$ such that $C(x) = \lambda(x) \, n$. What is the probability that such choice $x$ survives the sampling of $n$ independent distances? If a single pair among the sampled ones has distance smaller than $x$, this arrangement will be replaced by the smaller $d$. Inside a square, at least a quarter of the pairs would raise a smaller distance (imagine four subsquares in every square, and use the pigeonhole principle), so we have $\sum_{i=1}^{k} \frac{1}{4} {n_i \choose 2}$ pairs which yield a smaller final $d$. This is, approximately, $\frac{1}{8} \sum_{i=1}^{k} n_i^2 = \frac{1}{8} \lambda(x) n$. On the other hand, there are about $\frac{1}{2} n^2$ pairs that can be sampled. We have that the probability of sampling a pair with distance smaller than $x$ is at least (approximately) $$\frac{\lambda(x) n / 8}{n^2 / 2} = \frac{\lambda(x)/4}{n}$$ @@ -191,14 +191,14 @@ so the probability of at least one such pair being chosen during the $n$ rounds $$1 - \left(1 - \frac{\lambda(x)/4}{n}\right)^n \ge 1 - e^{-\lambda(x)/4}$$ -(we have used that $(1 + x)^n \le e^{xn}$ for any real number $x$, check https://en.wikipedia.org/wiki/Bernoulli%27s_inequality#Related_inequalities).
Notice this goes to $1$ exponentially as $\lambda(x)$ increases. This hints that $\lambda$ will be small usually. +(we have used that $(1 + x)^n \le e^{xn}$ for any real number $x$, check [this Wikipedia page](https://en.wikipedia.org/wiki/Bernoulli%27s_inequality#Related_inequalities)).
Notice this goes to $1$ exponentially as $\lambda(x)$ increases. This hints that $\lambda$ will be small usually. We have shown that $\Pr(d \le x) \ge 1 - e^{-\lambda(x)/4}$, or equivalently, $\Pr(d \ge x) \le e^{-\lambda(x)/4}$. We need to know $\Pr(\lambda(d) \ge \text{something})$ to be able to estimate its expected value. We notice that $\lambda(d) \ge \lambda(x) \iff d \ge x$. This is because making the squares smaller only reduces the number of points in each square (splits the points into other squares), and this keeps reducing the sum of squares. Therefore, $$\Pr(\lambda(d) \ge \lambda(x)) = \Pr(d \ge x) \le e^{-\lambda(x)/4} \implies \Pr(\lambda(d) \ge t) \le e^{-t/4} \implies \mathbb{E}[\lambda(d)] \le \int_{0}^{+\infty} e^{-t/4} \, \mathrm{d}t = 4$$ -(we have used that $E[X] = \int_0^{+\infty} \Pr(X \ge x) \, \mathrm{d}x$, check https://math.stackexchange.com/a/1690829). +(we have used that $E[X] = \int_0^{+\infty} \Pr(X \ge x) \, \mathrm{d}x$, check [the proof](https://math.stackexchange.com/a/1690829)). Finally, $\mathbb{E}[C(d)] = \mathbb{E}[\lambda(d) \, n] \le 4n$, and the expected running time is $O(n)$, with a reasonable constant factor. $\quad \blacksquare$ @@ -299,13 +299,13 @@ pair closest_pair_of_points_rand_reals(vector P) { Now we introduce a different randomized algorithm which is less practical but very easy to show that it runs in expected linear time. - Permute the $n$ points randomly -- Take $\delta \coloneqq \operatorname{dist}(p_1, p_2)$ +- Take $\delta := \operatorname{dist}(p_1, p_2)$ - Partition the plane in squares of side $\delta/2$ - For $i = 1,2,\dots,n$: - Take the square corresponding to $p_i$ - Interate over the $25$ squares within two steps to our square in the grid of squares partitioning the plane - If some $p_j$ in those squares has $\operatorname{dist}(p_j, p_i) < \delta$, then - - Recompute the partition and squares with $\delta \coloneqq \operatorname{dist}(p_j, p_i)$ + - Recompute the partition and squares with $\delta := \operatorname{dist}(p_j, p_i)$ - Store points $p_1, \dots, p_i$ in the corresponding squares - else, store $p_i$ in the corresponding square - output $\delta$ From e09c0424b8ce340a5aff0118076c8f87016273fb Mon Sep 17 00:00:00 2001 From: Michael Hayter Date: Sat, 28 Jun 2025 14:31:49 -0400 Subject: [PATCH 07/12] Update nearest_points.md Quick edits. Rendering --- src/geometry/nearest_points.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index 794256466..f39de98ed 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -166,7 +166,7 @@ rec(0, n); ### A randomized algorithm with linear expected time -An alternative method arises from a very simple idea to heuristically improve the runtime: We can divide the plane into a grid of $d \times d$ squares, then it is only required to test distances between same-block or adjacent-block points (unless all squares are disconnected from each other, but we will avoid this by design), since any other pair has larger distance that the two points in the same square. +An alternative method arises from a very simple idea to heuristically improve the runtime: We can divide the plane into a grid of $d \times d$ squares, then it is only required to test distances between same-block or adjacent-block points (unless all squares are disconnected from each other, but we will avoid this by design), since any other pair has a larger distance than the two points in the same square.

@@ -191,14 +191,14 @@ so the probability of at least one such pair being chosen during the $n$ rounds $$1 - \left(1 - \frac{\lambda(x)/4}{n}\right)^n \ge 1 - e^{-\lambda(x)/4}$$ -(we have used that $(1 + x)^n \le e^{xn}$ for any real number $x$, check [this Wikipedia page](https://en.wikipedia.org/wiki/Bernoulli%27s_inequality#Related_inequalities)).
Notice this goes to $1$ exponentially as $\lambda(x)$ increases. This hints that $\lambda$ will be small usually. +(we have used that $(1 + x)^n \le e^{xn}$ for any real number $x$, check [Bernoulli inequalities](https://en.wikipedia.org/wiki/Bernoulli%27s_inequality#Related_inequalities)).
Notice this goes to $1$ exponentially as $\lambda(x)$ increases. This hints that $\lambda$ will be small usually. We have shown that $\Pr(d \le x) \ge 1 - e^{-\lambda(x)/4}$, or equivalently, $\Pr(d \ge x) \le e^{-\lambda(x)/4}$. We need to know $\Pr(\lambda(d) \ge \text{something})$ to be able to estimate its expected value. We notice that $\lambda(d) \ge \lambda(x) \iff d \ge x$. This is because making the squares smaller only reduces the number of points in each square (splits the points into other squares), and this keeps reducing the sum of squares. Therefore, $$\Pr(\lambda(d) \ge \lambda(x)) = \Pr(d \ge x) \le e^{-\lambda(x)/4} \implies \Pr(\lambda(d) \ge t) \le e^{-t/4} \implies \mathbb{E}[\lambda(d)] \le \int_{0}^{+\infty} e^{-t/4} \, \mathrm{d}t = 4$$ -(we have used that $E[X] = \int_0^{+\infty} \Pr(X \ge x) \, \mathrm{d}x$, check [the proof](https://math.stackexchange.com/a/1690829)). +(we have used that $E[X] = \int_0^{+\infty} \Pr(X \ge x) \, \mathrm{d}x$, check [Stackexchange proof](https://math.stackexchange.com/a/1690829)). Finally, $\mathbb{E}[C(d)] = \mathbb{E}[\lambda(d) \, n] \le 4n$, and the expected running time is $O(n)$, with a reasonable constant factor. $\quad \blacksquare$ @@ -315,7 +315,7 @@ While this algorithm may look slow, because of recomputing everything multiple t **Proof.** Let $X_i$ the random variable that is $1$ when point $p_i$ causes a change of $\delta$ and a recomputation of the data structures, and $0$ if not. It is easy to show that the cost is $O(n + \sum_{i=1}^{n} i X_i)$, since on the $i$-th step we are considering only the first $i$ points. However, turns out that $\Pr(X_i = 1) \le \frac{2}{i}$. This is because on the $i$-th step, $\delta$ is the distance of the closest pair in $\{p_1,\dots,p_i\}$, and $\Pr(X_i = 1)$ is the probability of $p_i$ belonging to the closest pair, which only happens in $2(i-1)$ pairs out of the $i(i-1)$ possible pairs (assuming all distances are different), so the probability is at most $\frac{2(i-1)}{i(i-1)} = \frac{2}{i}$, since we previously shuffled the points uniformly. We can therefore see that the expected cost is -$$O(n + \sum_{i=1}^{n} i \Pr(X_i = 1)) \le O(n + \sum_{i=1}^{n} i \frac{2}{i}) = O(3n) = O(n) \quad \quad \blacksquare $$ +$$O(n + \sum_{i=1}^{n} i \Pr(X_i = 1)) \le O(n + \sum_{i=1}^{n} i \frac{2}{i}) = O(3n) = O(n) \quad \quad \blacksquare$$ ## Generalization: finding a triangle with minimal perimeter From 9b2611cdd4c16dd1b2d28c7bb8be38fb94a5abcd Mon Sep 17 00:00:00 2001 From: Izan Beltran Date: Sat, 28 Jun 2025 22:13:26 +0200 Subject: [PATCH 08/12] Update nearest_points.md - block equation spacing for correct rendering --- src/geometry/nearest_points.md | 1 + 1 file changed, 1 insertion(+) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index f39de98ed..2db764a3d 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -315,6 +315,7 @@ While this algorithm may look slow, because of recomputing everything multiple t **Proof.** Let $X_i$ the random variable that is $1$ when point $p_i$ causes a change of $\delta$ and a recomputation of the data structures, and $0$ if not. It is easy to show that the cost is $O(n + \sum_{i=1}^{n} i X_i)$, since on the $i$-th step we are considering only the first $i$ points. However, turns out that $\Pr(X_i = 1) \le \frac{2}{i}$. This is because on the $i$-th step, $\delta$ is the distance of the closest pair in $\{p_1,\dots,p_i\}$, and $\Pr(X_i = 1)$ is the probability of $p_i$ belonging to the closest pair, which only happens in $2(i-1)$ pairs out of the $i(i-1)$ possible pairs (assuming all distances are different), so the probability is at most $\frac{2(i-1)}{i(i-1)} = \frac{2}{i}$, since we previously shuffled the points uniformly. We can therefore see that the expected cost is + $$O(n + \sum_{i=1}^{n} i \Pr(X_i = 1)) \le O(n + \sum_{i=1}^{n} i \frac{2}{i}) = O(3n) = O(n) \quad \quad \blacksquare$$ From fc76d12f824b8230a49da2015467d8095a77a68c Mon Sep 17 00:00:00 2001 From: Izan Beltran Date: Sat, 28 Jun 2025 22:20:28 +0200 Subject: [PATCH 09/12] Update nearest_points.md - try improve format --- src/geometry/nearest_points.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index 2db764a3d..02ac5672a 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -302,12 +302,12 @@ Now we introduce a different randomized algorithm which is less practical but ve - Take $\delta := \operatorname{dist}(p_1, p_2)$ - Partition the plane in squares of side $\delta/2$ - For $i = 1,2,\dots,n$: - - Take the square corresponding to $p_i$ - - Interate over the $25$ squares within two steps to our square in the grid of squares partitioning the plane - - If some $p_j$ in those squares has $\operatorname{dist}(p_j, p_i) < \delta$, then - - Recompute the partition and squares with $\delta := \operatorname{dist}(p_j, p_i)$ - - Store points $p_1, \dots, p_i$ in the corresponding squares - - else, store $p_i$ in the corresponding square + - Take the square corresponding to $p_i$ + - Interate over the $25$ squares within two steps to our square in the grid of squares partitioning the plane + - If some $p_j$ in those squares has $\operatorname{dist}(p_j, p_i) < \delta$, then + - Recompute the partition and squares with $\delta := \operatorname{dist}(p_j, p_i)$ + - Store points $p_1, \dots, p_i$ in the corresponding squares + - else, store $p_i$ in the corresponding square - output $\delta$ While this algorithm may look slow, because of recomputing everything multiple times, we can show the total expected cost is linear. @@ -316,7 +316,7 @@ While this algorithm may look slow, because of recomputing everything multiple t We can therefore see that the expected cost is -$$O(n + \sum_{i=1}^{n} i \Pr(X_i = 1)) \le O(n + \sum_{i=1}^{n} i \frac{2}{i}) = O(3n) = O(n) \quad \quad \blacksquare$$ +$$O\left(n + \sum_{i=1}^{n} i \Pr(X_i = 1)\right) \le O\left(n + \sum_{i=1}^{n} i \frac{2}{i}\right) = O(3n) = O(n) \quad \quad \blacksquare$$ ## Generalization: finding a triangle with minimal perimeter From 937d47bd2e8529c47ec3be04799b4f1b1fd858db Mon Sep 17 00:00:00 2001 From: Izan Beltran Date: Sat, 28 Jun 2025 22:42:29 +0200 Subject: [PATCH 10/12] Update nearest_points.md - explanation of the implementation --- src/geometry/nearest_points.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index 02ac5672a..e3e738b70 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -204,7 +204,7 @@ Finally, $\mathbb{E}[C(d)] = \mathbb{E}[\lambda(d) \, n] \le 4n$, and the expect #### Implementation of the algorithm -The advantage of this algorithm is that it is straightforward to implement, but still has good performance in practise. +The advantage of this algorithm is that it is straightforward to implement, but still has good performance in practise. We first sample $n$ distances and set $d$ as the minimum of the distances. Then we insert points into the "blocks" by using a hash table from 2D coordinates to a vector of points. Finally, just compute distances between same-block pairs and adjacent-block pairs. Hash table operations have $O(1)$ expected time cost, and therefore our algorithm retains the $O(n)$ expected time cost with an increased constant. ```{.cpp file=nearest_pair_randomized} using ll = long long; From 4d47823ffc221c6f07fc64562c397ae359727dfa Mon Sep 17 00:00:00 2001 From: Izan Beltran Date: Sat, 28 Jun 2025 22:57:36 +0200 Subject: [PATCH 11/12] Update nearest_points.md - put proofs in dropdowns --- src/geometry/nearest_points.md | 51 ++++++++++++++++++---------------- 1 file changed, 27 insertions(+), 24 deletions(-) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index e3e738b70..01d744fb4 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -175,7 +175,8 @@ An alternative method arises from a very simple idea to heuristically improve th We will consider only the squares containing at least one point. Denote by $n_1, n_2, \dots, n_k$ the number of points in each of the $k$ remaining squares. Assuming at least two points are in the same or in adjacent squares, the time complexity is $\Theta(\sum_{i=1}^{k} n_i^2)$. -**Proof.** For the $i$-th square containing $n_i$ points, the number of pairs inside is $\Theta(n_i^2)$. If the $i$-th square is adjacent to the $j$-th square, then we also perform $n_i n_j \le \max(n_i, n_j)^2 \le n_i^2 + n_j^2$ distance comparisons. Notice that each cube has at most $8$ adjacent cubes, so we can bound the sum of all comparisons by $\Theta(\sum_{i=1}^{k} n_i^2)$. $\quad \blacksquare$ +??? info "Proof" + For the $i$-th square containing $n_i$ points, the number of pairs inside is $\Theta(n_i^2)$. If the $i$-th square is adjacent to the $j$-th square, then we also perform $n_i n_j \le \max(n_i, n_j)^2 \le n_i^2 + n_j^2$ distance comparisons. Notice that each cube has at most $8$ adjacent cubes, so we can bound the sum of all comparisons by $\Theta(\sum_{i=1}^{k} n_i^2)$. $\quad \blacksquare$ Now we need to decide on how to set $d$ so that it minimizes $\Theta(\sum_{i=1}^{k} n_i^2)$. @@ -183,24 +184,25 @@ Now we need to decide on how to set $d$ so that it minimizes $\Theta(\sum_{i=1}^ We need $d$ to be an approximation of the minimum distance $d$, and the trick is to just sample $n$ distances randomly and choose $d$ to be the smallest of these distances. We now prove that the expected running time is linear. -**Proof.** Imagine the disposition of points in squares with a particular choice of $d$, say $x$. Consider $d$ a random variable, resulting from our sampling of distances. Let's define $C(x) := \sum_{i=1}^{k(x)} n_i(x)^2$ as the cost estimation for a particular disposition when we choose $d=x$. Now, let's define $\lambda(x)$ such that $C(x) = \lambda(x) \, n$. What is the probability that such choice $x$ survives the sampling of $n$ independent distances? If a single pair among the sampled ones has distance smaller than $x$, this arrangement will be replaced by the smaller $d$. Inside a square, at least a quarter of the pairs would raise a smaller distance (imagine four subsquares in every square, and use the pigeonhole principle), so we have $\sum_{i=1}^{k} \frac{1}{4} {n_i \choose 2}$ pairs which yield a smaller final $d$. This is, approximately, $\frac{1}{8} \sum_{i=1}^{k} n_i^2 = \frac{1}{8} \lambda(x) n$. On the other hand, there are about $\frac{1}{2} n^2$ pairs that can be sampled. We have that the probability of sampling a pair with distance smaller than $x$ is at least (approximately) - -$$\frac{\lambda(x) n / 8}{n^2 / 2} = \frac{\lambda(x)/4}{n}$$ - -so the probability of at least one such pair being chosen during the $n$ rounds (and therefore finding a smaller $d$) is - -$$1 - \left(1 - \frac{\lambda(x)/4}{n}\right)^n \ge 1 - e^{-\lambda(x)/4}$$ - -(we have used that $(1 + x)^n \le e^{xn}$ for any real number $x$, check [Bernoulli inequalities](https://en.wikipedia.org/wiki/Bernoulli%27s_inequality#Related_inequalities)).
Notice this goes to $1$ exponentially as $\lambda(x)$ increases. This hints that $\lambda$ will be small usually. - - -We have shown that $\Pr(d \le x) \ge 1 - e^{-\lambda(x)/4}$, or equivalently, $\Pr(d \ge x) \le e^{-\lambda(x)/4}$. We need to know $\Pr(\lambda(d) \ge \text{something})$ to be able to estimate its expected value. We notice that $\lambda(d) \ge \lambda(x) \iff d \ge x$. This is because making the squares smaller only reduces the number of points in each square (splits the points into other squares), and this keeps reducing the sum of squares. Therefore, - -$$\Pr(\lambda(d) \ge \lambda(x)) = \Pr(d \ge x) \le e^{-\lambda(x)/4} \implies \Pr(\lambda(d) \ge t) \le e^{-t/4} \implies \mathbb{E}[\lambda(d)] \le \int_{0}^{+\infty} e^{-t/4} \, \mathrm{d}t = 4$$ - -(we have used that $E[X] = \int_0^{+\infty} \Pr(X \ge x) \, \mathrm{d}x$, check [Stackexchange proof](https://math.stackexchange.com/a/1690829)). - -Finally, $\mathbb{E}[C(d)] = \mathbb{E}[\lambda(d) \, n] \le 4n$, and the expected running time is $O(n)$, with a reasonable constant factor. $\quad \blacksquare$ +??? info "Proof" + Imagine the disposition of points in squares with a particular choice of $d$, say $x$. Consider $d$ a random variable, resulting from our sampling of distances. Let's define $C(x) := \sum_{i=1}^{k(x)} n_i(x)^2$ as the cost estimation for a particular disposition when we choose $d=x$. Now, let's define $\lambda(x)$ such that $C(x) = \lambda(x) \, n$. What is the probability that such choice $x$ survives the sampling of $n$ independent distances? If a single pair among the sampled ones has distance smaller than $x$, this arrangement will be replaced by the smaller $d$. Inside a square, at least a quarter of the pairs would raise a smaller distance (imagine four subsquares in every square, and use the pigeonhole principle), so we have $\sum_{i=1}^{k} \frac{1}{4} {n_i \choose 2}$ pairs which yield a smaller final $d$. This is, approximately, $\frac{1}{8} \sum_{i=1}^{k} n_i^2 = \frac{1}{8} \lambda(x) n$. On the other hand, there are about $\frac{1}{2} n^2$ pairs that can be sampled. We have that the probability of sampling a pair with distance smaller than $x$ is at least (approximately) + + $$\frac{\lambda(x) n / 8}{n^2 / 2} = \frac{\lambda(x)/4}{n}$$ + + so the probability of at least one such pair being chosen during the $n$ rounds (and therefore finding a smaller $d$) is + + $$1 - \left(1 - \frac{\lambda(x)/4}{n}\right)^n \ge 1 - e^{-\lambda(x)/4}$$ + + (we have used that $(1 + x)^n \le e^{xn}$ for any real number $x$, check [Bernoulli inequalities](https://en.wikipedia.org/wiki/Bernoulli%27s_inequality#Related_inequalities)).
Notice this goes to $1$ exponentially as $\lambda(x)$ increases. This hints that $\lambda$ will be small usually. + + + We have shown that $\Pr(d \le x) \ge 1 - e^{-\lambda(x)/4}$, or equivalently, $\Pr(d \ge x) \le e^{-\lambda(x)/4}$. We need to know $\Pr(\lambda(d) \ge \text{something})$ to be able to estimate its expected value. We notice that $\lambda(d) \ge \lambda(x) \iff d \ge x$. This is because making the squares smaller only reduces the number of points in each square (splits the points into other squares), and this keeps reducing the sum of squares. Therefore, + + $$\Pr(\lambda(d) \ge \lambda(x)) = \Pr(d \ge x) \le e^{-\lambda(x)/4} \implies \Pr(\lambda(d) \ge t) \le e^{-t/4} \implies \mathbb{E}[\lambda(d)] \le \int_{0}^{+\infty} e^{-t/4} \, \mathrm{d}t = 4$$ + + (we have used that $E[X] = \int_0^{+\infty} \Pr(X \ge x) \, \mathrm{d}x$, check [Stackexchange proof](https://math.stackexchange.com/a/1690829)). + + Finally, $\mathbb{E}[C(d)] = \mathbb{E}[\lambda(d) \, n] \le 4n$, and the expected running time is $O(n)$, with a reasonable constant factor. $\quad \blacksquare$ #### Implementation of the algorithm @@ -312,11 +314,12 @@ Now we introduce a different randomized algorithm which is less practical but ve While this algorithm may look slow, because of recomputing everything multiple times, we can show the total expected cost is linear. -**Proof.** Let $X_i$ the random variable that is $1$ when point $p_i$ causes a change of $\delta$ and a recomputation of the data structures, and $0$ if not. It is easy to show that the cost is $O(n + \sum_{i=1}^{n} i X_i)$, since on the $i$-th step we are considering only the first $i$ points. However, turns out that $\Pr(X_i = 1) \le \frac{2}{i}$. This is because on the $i$-th step, $\delta$ is the distance of the closest pair in $\{p_1,\dots,p_i\}$, and $\Pr(X_i = 1)$ is the probability of $p_i$ belonging to the closest pair, which only happens in $2(i-1)$ pairs out of the $i(i-1)$ possible pairs (assuming all distances are different), so the probability is at most $\frac{2(i-1)}{i(i-1)} = \frac{2}{i}$, since we previously shuffled the points uniformly. - -We can therefore see that the expected cost is - -$$O\left(n + \sum_{i=1}^{n} i \Pr(X_i = 1)\right) \le O\left(n + \sum_{i=1}^{n} i \frac{2}{i}\right) = O(3n) = O(n) \quad \quad \blacksquare$$ +??? info "Proof" + Let $X_i$ the random variable that is $1$ when point $p_i$ causes a change of $\delta$ and a recomputation of the data structures, and $0$ if not. It is easy to show that the cost is $O(n + \sum_{i=1}^{n} i X_i)$, since on the $i$-th step we are considering only the first $i$ points. However, turns out that $\Pr(X_i = 1) \le \frac{2}{i}$. This is because on the $i$-th step, $\delta$ is the distance of the closest pair in $\{p_1,\dots,p_i\}$, and $\Pr(X_i = 1)$ is the probability of $p_i$ belonging to the closest pair, which only happens in $2(i-1)$ pairs out of the $i(i-1)$ possible pairs (assuming all distances are different), so the probability is at most $\frac{2(i-1)}{i(i-1)} = \frac{2}{i}$, since we previously shuffled the points uniformly. + + We can therefore see that the expected cost is + + $$O\left(n + \sum_{i=1}^{n} i \Pr(X_i = 1)\right) \le O\left(n + \sum_{i=1}^{n} i \frac{2}{i}\right) = O(3n) = O(n) \quad \quad \blacksquare$$ ## Generalization: finding a triangle with minimal perimeter From 50bb91b96f6ca449fd28c83beef4baf6ef57f7a4 Mon Sep 17 00:00:00 2001 From: Izan Beltran Date: Sun, 29 Jun 2025 21:28:11 +0200 Subject: [PATCH 12/12] Update nearest_points.md - patch code error --- src/geometry/nearest_points.md | 134 ++++++++++++++++----------------- 1 file changed, 67 insertions(+), 67 deletions(-) diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md index 01d744fb4..395eda726 100644 --- a/src/geometry/nearest_points.md +++ b/src/geometry/nearest_points.md @@ -213,85 +213,85 @@ using ll = long long; using ld = long double; struct RealPoint { - ld x, y; - RealPoint() {} - RealPoint(T x_, T y_) : x(x_), y(y_) {} + ld x, y; + RealPoint() {} + RealPoint(ld x_, ld y_) : x(x_), y(y_) {} }; using pt = RealPoint; struct CustomHash { - size_t operator()(const pair& p) const { - static const uint64_t C = chrono::steady_clock::now().time_since_epoch().count(); - return C ^ ((p.first << 32) ^ p.second); - } + size_t operator()(const pair& p) const { + static const uint64_t C = chrono::steady_clock::now().time_since_epoch().count(); + return C ^ ((p.first << 32) ^ p.second); + } }; -ld dist(pt a, pt b) { - ld dx = a.x - b.x; - ld dy = a.y - b.y; - return sqrt(dx*dx + dy*dy); +ld dist(const pt& a, const pt& b) { + ld dx = a.x - b.x; + ld dy = a.y - b.y; + return sqrt(dx*dx + dy*dy); } pair closest_pair_of_points_rand_reals(vector P) { const ld eps = 1e-9; - int n = int(P.size()); - assert(n >= 2); - unordered_map,vector,CustomHash> grid; - grid.reserve(n); - - mt19937 rd(chrono::system_clock::now().time_since_epoch().count()); - uniform_int_distribution dis(0, n-1); - - ld d = dist(P[0], P[1]); - pair closest = {P[0], P[1]}; - - auto consider_pair = [&](const pt& a, const pt& b) -> void { - ld ab = dist(a, b); - if (ab + eps < d) { - d = ab; - closest = {a, b}; - } - }; - - for (int i = 0; i < n; ++i) { - int j = dis(rd); - int k = dis(rd); - while (j == k) - k = dis(rd); - consider_pair(P[j], P[k]); - } - - for (const pt& p : P) - grid[{ll(p.x/d), ll(p.y/d)}].push_back(p); - - for (const auto& it : grid) { // same block - int k = int(it.second.size()); - for (int i = 0; i < k; ++i) { - for (int j = i+1; j < k; ++j) - consider_pair(it.second[i], it.second[j]); - } - } + int n = int(P.size()); + assert(n >= 2); + unordered_map,vector,CustomHash> grid; + grid.reserve(n); + + mt19937 prng(chrono::system_clock::now().time_since_epoch().count()); + uniform_int_distribution uniform(0, n-1); + + ld d = dist(P[0], P[1]); + pair closest = {P[0], P[1]}; + + auto consider_pair = [&](const pt& a, const pt& b) -> void { + ld ab = dist(a, b); + if (ab + eps < d) { + d = ab; + closest = {a, b}; + } + }; + + for (int i = 0; i < n; ++i) { + int j = uniform(prng); + int k = uniform(prng); + while (j == k) + k = uniform(prng); + consider_pair(P[j], P[k]); + } + + for (const pt& p : P) + grid[{ll(p.x/d), ll(p.y/d)}].push_back(p); + + for (const auto& it : grid) { // same block + int k = int(it.second.size()); + for (int i = 0; i < k; ++i) { + for (int j = i+1; j < k; ++j) + consider_pair(it.second[i], it.second[j]); + } + } - for (const auto& it : grid) { // adjacent blocks - auto coord = it.first; - for (int dx = 0; dx <= 1; ++dx) { - for (int dy = -1; dy <= 1; ++dy) { - if (dx == 0 and dy == 0) continue; - pair neighbour = { - coord.first + dx, - coord.second + dy - }; - for (const pt& p : it.second) { - if (not grid.count(neighbour)) continue; - for (const pt& q : grid.at(neighbour)) - candidate_closest(p, q); - } - } - } - } - - return closest; + for (const auto& it : grid) { // adjacent blocks + auto coord = it.first; + for (int dx = 0; dx <= 1; ++dx) { + for (int dy = -1; dy <= 1; ++dy) { + if (dx == 0 and dy == 0) continue; + pair neighbour = { + coord.first + dx, + coord.second + dy + }; + for (const pt& p : it.second) { + if (not grid.count(neighbour)) continue; + for (const pt& q : grid.at(neighbour)) + consider_pair(p, q); + } + } + } + } + + return closest; } ``` pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.

Alternative Proxies: