Copyright © 2014 - 2024 by cp-algorithms contributors +edit_uri: edit/main/src/ +copyright: Text is available under the Creative Commons Attribution Share Alike 4.0 International License
Copyright © 2014 - 2025 by cp-algorithms contributors extra_javascript: - javascript/config.js - https://cdnjs.cloudflare.com/polyfill/v3/polyfill.min.js?features=es6 @@ -57,12 +56,13 @@ markdown_extensions: permalink: true plugins: + - toggle-sidebar: + toggle_button: all - mkdocs-simple-hooks: hooks: on_env: "hooks:on_env" - search - - tags: - tags_file: tags.md + - tags - literate-nav: nav_file: navigation.md - git-revision-date-localized: @@ -74,6 +74,7 @@ plugins: docs_path: src/ token: !ENV MKDOCS_GIT_COMMITTERS_APIKEY enabled: !ENV [MKDOCS_ENABLE_GIT_COMMITTERS, False] + branch: !ENV [MKDOCS_GIT_COMMITERS_BRANCH, main] - macros - rss diff --git a/scripts/install-mkdocs.sh b/scripts/install-mkdocs.sh index 4202c9a97..9c4e73c3f 100755 --- a/scripts/install-mkdocs.sh +++ b/scripts/install-mkdocs.sh @@ -2,6 +2,7 @@ pip install \ "mkdocs-material>=9.0.2" \ + mkdocs-toggle-sidebar-plugin \ mkdocs-macros-plugin \ mkdocs-literate-nav \ mkdocs-git-authors-plugin \ diff --git a/src/algebra/big-integer.md b/src/algebra/big-integer.md index 7f8dd1816..72d137983 100644 --- a/src/algebra/big-integer.md +++ b/src/algebra/big-integer.md @@ -30,7 +30,7 @@ To improve performance we'll use $10^9$ as the base, so that each "digit" of the const int base = 1000*1000*1000; ``` -Digits will be stored in order from least to most significant. All operations will be implemented so that after each of them the result doesn't have any leading zeros, as long as operands didn't have any leading zeros either. All operations which might result in a number with leading zeros should be followed by code which removes them. Note that in this representation there are two valid notations for number zero: and empty vector, and a vector with a single zero digit. +Digits will be stored in order from least to most significant. All operations will be implemented so that after each of them the result doesn't have any leading zeros, as long as operands didn't have any leading zeros either. All operations which might result in a number with leading zeros should be followed by code which removes them. Note that in this representation there are two valid notations for number zero: an empty vector, and a vector with a single zero digit. ### Output diff --git a/src/algebra/bit-manipulation.md b/src/algebra/bit-manipulation.md index 39eda1b46..f29810323 100644 --- a/src/algebra/bit-manipulation.md +++ b/src/algebra/bit-manipulation.md @@ -207,7 +207,7 @@ We can see that the all the columns except the leftmost have $4$ (i.e. $2^2$) se With the new knowledge in hand we can come up with the following algorithm: - Find the highest power of $2$ that is lesser than or equal to the given number. Let this number be $x$. -- Calculate the number of set bits from $1$ to $2^x - 1$ by using the formua $x \cdot 2^{x-1}$. +- Calculate the number of set bits from $1$ to $2^x - 1$ by using the formula $x \cdot 2^{x-1}$. - Count the no. of set bits in the most significant bit from $2^x$ to $n$ and add it. - Subtract $2^x$ from $n$ and repeat the above steps using the new $n$. diff --git a/src/algebra/euclid-algorithm.md b/src/algebra/euclid-algorithm.md index 665ca2b07..2de931871 100644 --- a/src/algebra/euclid-algorithm.md +++ b/src/algebra/euclid-algorithm.md @@ -15,7 +15,7 @@ $$\gcd(a, b) = \max \{k > 0 : (k \mid a) \text{ and } (k \mid b) \}$$ When one of the numbers is zero, while the other is non-zero, their greatest common divisor, by definition, is the second number. When both numbers are zero, their greatest common divisor is undefined (it can be any arbitrarily large number), but it is convenient to define it as zero as well to preserve the associativity of $\gcd$. Which gives us a simple rule: if one of the numbers is zero, the greatest common divisor is the other number. -The Euclidean algorithm, discussed below, allows to find the greatest common divisor of two numbers $a$ and $b$ in $O(\log \min(a, b))$. +The Euclidean algorithm, discussed below, allows to find the greatest common divisor of two numbers $a$ and $b$ in $O(\log \min(a, b))$. Since the function is **associative**, to find the GCD of **more than two numbers**, we can do $\gcd(a, b, c) = \gcd(a, \gcd(b, c))$ and so forth. The algorithm was first described in Euclid's "Elements" (circa 300 BC), but it is possible that the algorithm has even earlier origins. @@ -70,7 +70,7 @@ Moreover, it is possible to show that the upper bound of this theorem is optimal Given that Fibonacci numbers grow exponentially, we get that the Euclidean algorithm works in $O(\log \min(a, b))$. -Another way to estimate the complexity is to notice that $a \bmod b$ for the case $a \geq b$ is at least $2$ times smaller than $a$, so the larger number is reduced at least in half on each iteration of the algorithm. +Another way to estimate the complexity is to notice that $a \bmod b$ for the case $a \geq b$ is at least $2$ times smaller than $a$, so the larger number is reduced at least in half on each iteration of the algorithm. Applying this reasoning to the case when we compute the GCD of the set of numbers $a_1,\dots,a_n \leq C$, this also allows us to estimate the total runtime as $O(n + \log C)$, rather than $O(n \log C)$, since every non-trivial iteration of the algorithm reduces the current GCD candidate by at least a factor of $2$. ## Least common multiple diff --git a/src/algebra/extended-euclid-algorithm.md b/src/algebra/extended-euclid-algorithm.md index 4e96f3729..3e845e728 100644 --- a/src/algebra/extended-euclid-algorithm.md +++ b/src/algebra/extended-euclid-algorithm.md @@ -95,9 +95,32 @@ int gcd(int a, int b, int& x, int& y) { If you look closely at the variables `a1` and `b1`, you can notice that they take exactly the same values as in the iterative version of the normal [Euclidean algorithm](euclid-algorithm.md). So the algorithm will at least compute the correct GCD. -To see why the algorithm also computes the correct coefficients, you can check that the following invariants will hold at any time (before the while loop, and at the end of each iteration): $x \cdot a + y \cdot b = a_1$ and $x_1 \cdot a + y_1 \cdot b = b_1$. -It's trivial to see, that these two equations are satisfied at the beginning. -And you can check that the update in the loop iteration will still keep those equalities valid. +To see why the algorithm computes the correct coefficients, consider that the following invariants hold at any given time (before the while loop begins and at the end of each iteration): + +$$x \cdot a + y \cdot b = a_1$$ + +$$x_1 \cdot a + y_1 \cdot b = b_1$$ + +Let the values at the end of an iteration be denoted by a prime ($'$), and assume $q = \frac{a_1}{b_1}$. From the [Euclidean algorithm](euclid-algorithm.md), we have: + +$$a_1' = b_1$$ + +$$b_1' = a_1 - q \cdot b_1$$ + +For the first invariant to hold, the following should be true: + +$$x' \cdot a + y' \cdot b = a_1' = b_1$$ + +$$x' \cdot a + y' \cdot b = x_1 \cdot a + y_1 \cdot b$$ + +Similarly for the second invariant, the following should hold: + +$$x_1' \cdot a + y_1' \cdot b = a_1 - q \cdot b_1$$ + +$$x_1' \cdot a + y_1' \cdot b = (x - q \cdot x_1) \cdot a + (y - q \cdot y_1) \cdot b$$ + +By comparing the coefficients of $a$ and $b$, the update equations for each variable can be derived, ensuring that the invariants are maintained throughout the algorithm. + At the end we know that $a_1$ contains the GCD, so $x \cdot a + y \cdot b = g$. Which means that we have found the required coefficients. diff --git a/src/algebra/factorial-modulo.md b/src/algebra/factorial-modulo.md index 73ff0145b..86961ba33 100644 --- a/src/algebra/factorial-modulo.md +++ b/src/algebra/factorial-modulo.md @@ -14,7 +14,7 @@ Otherwise $p!$ and subsequent terms will reduce to zero. But in fractions the factors of $p$ can cancel, and the resulting expression will be non-zero modulo $p$. Thus, formally the task is: You want to calculate $n! \bmod p$, without taking all the multiple factors of $p$ into account that appear in the factorial. -Imaging you write down the prime factorization of $n!$, remove all factors $p$, and compute the product modulo $p$. +Imagine you write down the prime factorization of $n!$, remove all factors $p$, and compute the product modulo $p$. We will denote this *modified* factorial with $n!_{\%p}$. For instance $7!_{\%p} \equiv 1 \cdot 2 \cdot \underbrace{1}_{3} \cdot 4 \cdot 5 \underbrace{2}_{6} \cdot 7 \equiv 2 \bmod 3$. diff --git a/src/algebra/factorization.md b/src/algebra/factorization.md index 58a43b961..14715605f 100644 --- a/src/algebra/factorization.md +++ b/src/algebra/factorization.md @@ -159,11 +159,10 @@ By looking at the squares $a^2$ modulo a fixed small number, it can be observed ## Pollard's $p - 1$ method { data-toc-label="Pollard's method" } -It is very likely that at least one factor of a number is $B$**-powersmooth** for small $B$. -$B$-powersmooth means that every prime power $d^k$ that divides $p-1$ is at most $B$. +It is very likely that a number $n$ has at least one prime factor $p$ such that $p - 1$ is $\mathrm{B}$**-powersmooth** for small $\mathrm{B}$. An integer $m$ is said to be $\mathrm{B}$-powersmooth if every prime power dividing $m$ is at most $\mathrm{B}$. Formally, let $\mathrm{B} \geqslant 1$ and let $m$ be any positive integer. Suppose the prime factorization of $m$ is $m = \prod {q_i}^{e_i}$, where each $q_i$ is a prime and $e_i \geqslant 1$. Then $m$ is $\mathrm{B}$-powersmooth if, for all $i$, ${q_i}^{e_i} \leqslant \mathrm{B}$. E.g. the prime factorization of $4817191$ is $1303 \cdot 3697$. -And the factors are $31$-powersmooth and $16$-powersmooth respectably, because $1303 - 1 = 2 \cdot 3 \cdot 7 \cdot 31$ and $3697 - 1 = 2^4 \cdot 3 \cdot 7 \cdot 11$. -In 1974 John Pollard invented a method to extracts $B$-powersmooth factors from a composite number. +And the values, $1303 - 1$ and $3697 - 1$, are $31$-powersmooth and $16$-powersmooth respectively, because $1303 - 1 = 2 \cdot 3 \cdot 7 \cdot 31$ and $3697 - 1 = 2^4 \cdot 3 \cdot 7 \cdot 11$. +In 1974 John Pollard invented a method to extract factors $p$, s.t. $p-1$ is $\mathrm{B}$-powersmooth, from a composite number. The idea comes from [Fermat's little theorem](phi-function.md#application). Let a factorization of $n$ be $n = p \cdot q$. @@ -180,7 +179,7 @@ This means that $a^M - 1 = p \cdot r$, and because of that also $p ~|~ \gcd(a^M Therefore, if $p - 1$ for a factor $p$ of $n$ divides $M$, we can extract a factor using [Euclid's algorithm](euclid-algorithm.md). -It is clear, that the smallest $M$ that is a multiple of every $B$-powersmooth number is $\text{lcm}(1,~2~,3~,4~,~\dots,~B)$. +It is clear, that the smallest $M$ that is a multiple of every $\mathrm{B}$-powersmooth number is $\text{lcm}(1,~2~,3~,4~,~\dots,~B)$. Or alternatively: $$M = \prod_{\text{prime } q \le B} q^{\lfloor \log_q B \rfloor}$$ @@ -189,11 +188,11 @@ Notice, if $p-1$ divides $M$ for all prime factors $p$ of $n$, then $\gcd(a^M - In this case we don't receive a factor. Therefore, we will try to perform the $\gcd$ multiple times, while we compute $M$. -Some composite numbers don't have $B$-powersmooth factors for small $B$. -For example, the factors of the composite number $100~000~000~000~000~493 = 763~013 \cdot 131~059~365~961$ are $190~753$-powersmooth and $1~092~161~383$-powersmooth. -We will have to choose $B >= 190~753$ to factorize the number. +Some composite numbers don't have factors $p$ s.t. $p-1$ is $\mathrm{B}$-powersmooth for small $\mathrm{B}$. +For example, for the composite number $100~000~000~000~000~493 = 763~013 \cdot 131~059~365~961$, values $p-1$ are $190~753$-powersmooth and $1~092~161~383$-powersmooth correspondingly. +We will have to choose $B \geq 190~753$ to factorize the number. -In the following implementation we start with $B = 10$ and increase $B$ after each each iteration. +In the following implementation we start with $\mathrm{B} = 10$ and increase $\mathrm{B}$ after each each iteration. ```{.cpp file=factorization_p_minus_1} long long pollards_p_minus_1(long long n) { @@ -246,7 +245,9 @@ If $p$ is smaller than $\sqrt{n}$, the repetition will likely start in $O(\sqrt[ Here is a visualization of such a sequence $\{x_i \bmod p\}$ with $n = 2206637$, $p = 317$, $x_0 = 2$ and $f(x) = x^2 + 1$. From the form of the sequence you can see very clearly why the algorithm is called Pollard's $\rho$ algorithm. -
+ 
+
Yet, there is still an open question.
How can we exploit the properties of the sequence $\{x_i \bmod p\}$ to our advantage without even knowing the number $p$ itself?
diff --git a/src/algebra/fft.md b/src/algebra/fft.md
index 2e6532558..38ed620a5 100644
--- a/src/algebra/fft.md
+++ b/src/algebra/fft.md
@@ -97,7 +97,7 @@ It is easy to see that
$$A(x) = A_0(x^2) + x A_1(x^2).$$
-The polynomials $A_0$ and $A_1$ are only half as much coefficients as the polynomial $A$.
+The polynomials $A_0$ and $A_1$ have only half as many coefficients as the polynomial $A$.
If we can compute the $\text{DFT}(A)$ in linear time using $\text{DFT}(A_0)$ and $\text{DFT}(A_1)$, then we get the recurrence $T_{\text{DFT}}(n) = 2 T_{\text{DFT}}\left(\frac{n}{2}\right) + O(n)$ for the time complexity, which results in $T_{\text{DFT}}(n) = O(n \log n)$ by the **master theorem**.
Let's learn how we can accomplish that.
diff --git a/src/algebra/fibonacci-numbers.md b/src/algebra/fibonacci-numbers.md
index 22403419a..6d18015f0 100644
--- a/src/algebra/fibonacci-numbers.md
+++ b/src/algebra/fibonacci-numbers.md
@@ -22,6 +22,8 @@ Fibonacci numbers possess a lot of interesting properties. Here are a few of the
$$F_{n-1} F_{n+1} - F_n^2 = (-1)^n$$
+>This can be proved by induction. A one-line proof by Knuth comes from taking the determinant of the 2x2 matrix form below.
+
* The "addition" rule:
$$F_{n+k} = F_k F_{n+1} + F_{k-1} F_n$$
@@ -116,11 +118,63 @@ In this way, we obtain a linear solution, $O(n)$ time, saving all the values pri
### Matrix form
-It is easy to prove the following relation:
+To go from $(F_n, F_{n-1})$ to $(F_{n+1}, F_n)$, we can express the linear recurrence as a 2x2 matrix multiplication:
-$$\begin{pmatrix} 1 & 1 \cr 1 & 0 \cr\end{pmatrix} ^ n = \begin{pmatrix} F_{n+1} & F_{n} \cr F_{n} & F_{n-1} \cr\end{pmatrix}$$
+$$
+\begin{pmatrix}
+1 & 1 \\
+1 & 0
+\end{pmatrix}
+\begin{pmatrix}
+F_n \\
+F_{n-1}
+\end{pmatrix}
+=
+\begin{pmatrix}
+F_n + F_{n-1} \\
+F_{n}
+\end{pmatrix}
+=
+\begin{pmatrix}
+F_{n+1} \\
+F_{n}
+\end{pmatrix}
+$$
+
+This lets us treat iterating the recurrence as repeated matrix multiplication, which has nice properties. In particular,
+
+$$
+\begin{pmatrix}
+1 & 1 \\
+1 & 0
+\end{pmatrix}^n
+\begin{pmatrix}
+F_1 \\
+F_0
+\end{pmatrix}
+=
+\begin{pmatrix}
+F_{n+1} \\
+F_{n}
+\end{pmatrix}
+$$
+
+where $F_1 = 1, F_0 = 0$.
+In fact, since
+
+$$
+\begin{pmatrix} 1 & 1 \\ 1 & 0 \end{pmatrix}
+= \begin{pmatrix} F_2 & F_1 \\ F_1 & F_0 \end{pmatrix}
+$$
+
+we can use the matrix directly:
+
+$$
+\begin{pmatrix} 1 & 1 \\ 1 & 0 \end{pmatrix}^n
+= \begin{pmatrix} F_{n+1} & F_n \\ F_n & F_{n-1} \end{pmatrix}
+$$
-Thus, in order to find $F_n$ in $O(log n)$ time, we must raise the matrix to n. (See [Binary exponentiation](binary-exp.md))
+Thus, in order to find $F_n$ in $O(\log n)$ time, we must raise the matrix to n. (See [Binary exponentiation](binary-exp.md))
```{.cpp file=fibonacci_matrix}
struct matrix {
diff --git a/src/algebra/linear-diophantine-equation.md b/src/algebra/linear-diophantine-equation.md
index 047067c59..3f4ede86c 100644
--- a/src/algebra/linear-diophantine-equation.md
+++ b/src/algebra/linear-diophantine-equation.md
@@ -27,10 +27,10 @@ A degenerate case that need to be taken care of is when $a = b = 0$. It is easy
When $a \neq 0$ and $b \neq 0$, the equation $ax+by=c$ can be equivalently treated as either of the following:
-\begin{gather}
-ax \equiv c \pmod b,\newline
-by \equiv c \pmod a.
-\end{gather}
+\begin{align}
+ax &\equiv c \pmod b \\
+by &\equiv c \pmod a
+\end{align}
Without loss of generality, assume that $b \neq 0$ and consider the first equation. When $a$ and $b$ are co-prime, the solution to it is given as
@@ -51,6 +51,12 @@ y = \frac{c-ax}{b}.
## Algorithmic solution
+**Bézout's lemma** (also called Bézout's identity) is a useful result that can be used to understand the following solution.
+
+> Let $g = \gcd(a,b)$. Then there exist integers $x,y$ such that $ax + by = g$.
+>
+> Moreover, $g$ is the least such positive integer that can be written as $ax + by$; all integers of the form $ax + by$ are multiples of $g$.
+
To find one solution of the Diophantine equation with 2 unknowns, you can use the [Extended Euclidean algorithm](extended-euclid-algorithm.md). First, assume that $a$ and $b$ are non-negative. When we apply Extended Euclidean algorithm for $a$ and $b$, we can find their greatest common divisor $g$ and 2 numbers $x_g$ and $y_g$ such that:
$$a x_g + b y_g = g$$
@@ -119,7 +125,7 @@ $$y = y_0 - k \cdot \frac{a}{g}$$
are solutions of the given Diophantine equation.
-Moreover, this is the set of all possible solutions of the given Diophantine equation.
+Since the equation is linear, all solutions lie on the same line, and by the definition of $g$ this is the set of all possible solutions of the given Diophantine equation.
## Finding the number of solutions and the solutions in a given interval
diff --git a/src/algebra/phi-function.md b/src/algebra/phi-function.md
index 8129542f3..c69ee2841 100644
--- a/src/algebra/phi-function.md
+++ b/src/algebra/phi-function.md
@@ -73,7 +73,7 @@ int phi(int n) {
## Euler totient function from $1$ to $n$ in $O(n \log\log{n})$ { #etf_1_to_n data-toc-label="Euler totient function from 1 to n in " }
-If we need all all the totient of all numbers between $1$ and $n$, then factorizing all $n$ numbers is not efficient.
+If we need the totient of all numbers between $1$ and $n$, then factorizing all $n$ numbers is not efficient.
We can use the same idea as the [Sieve of Eratosthenes](sieve-of-eratosthenes.md).
It is still based on the property shown above, but instead of updating the temporary result for each prime factor for each number, we find all prime numbers and for each one update the temporary results of all numbers that are divisible by that prime number.
diff --git a/src/algebra/sieve-of-eratosthenes.md b/src/algebra/sieve-of-eratosthenes.md
index d537bd6c2..560d176e7 100644
--- a/src/algebra/sieve-of-eratosthenes.md
+++ b/src/algebra/sieve-of-eratosthenes.md
@@ -19,7 +19,9 @@ And we continue this procedure until we have processed all numbers in the row.
In the following image you can see a visualization of the algorithm for computing all prime numbers in the range $[1; 16]$. It can be seen, that quite often we mark numbers as composite multiple times.
-
+
+ 
+
The idea behind is this:
A number is prime, if none of the smaller prime numbers divides it.
@@ -61,7 +63,7 @@ $$\sum_{\substack{p \le n, \\\ p \text{ prime}}} \frac n p = n \cdot \sum_{\subs
Let's recall two known facts.
- The number of prime numbers less than or equal to $n$ is approximately $\frac n {\ln n}$.
- - The $k$-th prime number approximately equals $k \ln k$ (this follows immediately from the previous fact).
+ - The $k$-th prime number approximately equals $k \ln k$ (this follows from the previous fact).
Thus we can write down the sum in the following way:
diff --git a/src/combinatorics/binomial-coefficients.md b/src/combinatorics/binomial-coefficients.md
index a81c8bd0d..9f065c1a7 100644
--- a/src/combinatorics/binomial-coefficients.md
+++ b/src/combinatorics/binomial-coefficients.md
@@ -220,7 +220,6 @@ When $m$ is not square-free, a [generalization of Lucas's theorem for prime powe
* [LightOj - Necklaces](http://www.lightoj.com/volume_showproblem.php?problem=1419)
* [HACKEREARTH: Binomial Coefficient](https://www.hackerearth.com/problem/algorithm/binomial-coefficient-1/description/)
* [SPOJ - Ada and Teams](http://www.spoj.com/problems/ADATEAMS/)
-* [DevSkill - Drive In Grid](https://devskill.com/CodingProblems/ViewProblem/61)
* [SPOJ - Greedy Walking](http://www.spoj.com/problems/UCV2013E/)
* [UVa 13214 - The Robot's Grid](https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=5137)
* [SPOJ - Good Predictions](http://www.spoj.com/problems/GOODB/)
@@ -228,7 +227,6 @@ When $m$ is not square-free, a [generalization of Lucas's theorem for prime powe
* [SPOJ - Topper Rama Rao](http://www.spoj.com/problems/HLP_RAMS/)
* [UVa 13184 - Counting Edges and Graphs](https://uva.onlinejudge.org/index.php?option=onlinejudge&page=show_problem&problem=5095)
* [Codeforces - Anton and School 2](http://codeforces.com/contest/785/problem/D)
-* [DevSkill - Parandthesis](https://devskill.com/CodingProblems/ViewProblem/255)
* [Codeforces - Bacterial Melee](http://codeforces.com/contest/760/problem/F)
* [Codeforces - Points, Lines and Ready-made Titles](http://codeforces.com/contest/872/problem/E)
* [SPOJ - The Ultimate Riddle](https://www.spoj.com/problems/DCEPC13D/)
diff --git a/src/combinatorics/burnside.md b/src/combinatorics/burnside.md
index fa799399c..894b1e87d 100644
--- a/src/combinatorics/burnside.md
+++ b/src/combinatorics/burnside.md
@@ -266,3 +266,8 @@ int solve(int n, int m) {
return sum / s.size();
}
```
+## Practice Problems
+* [CSES - Counting Necklaces](https://cses.fi/problemset/task/2209)
+* [CSES - Counting Grids](https://cses.fi/problemset/task/2210)
+* [Codeforces - Buildings](https://codeforces.com/gym/101873/problem/B)
+* [CS Academy - Cube Coloring](https://csacademy.com/contest/beta-round-8/task/cube-coloring/)
diff --git a/src/combinatorics/inclusion-exclusion.md b/src/combinatorics/inclusion-exclusion.md
index b89b22c4f..ed6767216 100644
--- a/src/combinatorics/inclusion-exclusion.md
+++ b/src/combinatorics/inclusion-exclusion.md
@@ -449,7 +449,6 @@ A list of tasks that can be solved using the principle of inclusions-exclusions:
* [TopCoder SRM 390 "SetOfPatterns" [difficulty: medium]](http://www.topcoder.com/stat?c=problem_statement&pm=8307)
* [TopCoder SRM 176 "Deranged" [difficulty: medium]](http://community.topcoder.com/stat?c=problem_statement&pm=2013)
* [TopCoder SRM 457 "TheHexagonsDivOne" [difficulty: medium]](http://community.topcoder.com/stat?c=problem_statement&pm=10702&rd=14144&rm=303184&cr=22697599)
-* [Test>>>thebest "HarmonicTriples" (in Russian) [difficulty: medium]](http://esci.ru/ttb/statement-62.htm)
* [SPOJ #4191 MSKYCODE "Sky Code" [difficulty: medium]](http://www.spoj.com/problems/MSKYCODE/)
* [SPOJ #4168 SQFREE "Square-free integers" [difficulty: medium]](http://www.spoj.com/problems/SQFREE/)
* [CodeChef "Count Relations" [difficulty: medium]](http://www.codechef.com/JAN11/problems/COUNTREL/)
diff --git a/src/data_structures/disjoint_set_union.md b/src/data_structures/disjoint_set_union.md
index 8218d72a3..2964a87cf 100644
--- a/src/data_structures/disjoint_set_union.md
+++ b/src/data_structures/disjoint_set_union.md
@@ -98,7 +98,7 @@ The trick is to make the paths for all those nodes shorter, by setting the paren
You can see the operation in the following image.
On the left there is a tree, and on the right side there is the compressed tree after calling `find_set(7)`, which shortens the paths for the visited nodes 7, 5, 3 and 2.
-
+
The new implementation of `find_set` is as follows:
diff --git a/src/data_structures/fenwick.md b/src/data_structures/fenwick.md
index 152138060..439885b83 100644
--- a/src/data_structures/fenwick.md
+++ b/src/data_structures/fenwick.md
@@ -121,14 +121,16 @@ h(31) = 63 &= 0111111_2 \\\\
Unsurprisingly, there also exists a simple way to perform $h$ using bitwise operations:
-$$h(j) = j ~\|~ (j+1),$$
+$$h(j) = j ~|~ (j+1),$$
-where $\|$ is the bitwise OR operator.
+where $|$ is the bitwise OR operator.
The following image shows a possible interpretation of the Fenwick tree as tree.
The nodes of the tree show the ranges they cover.
-
+
+ 
+
## Implementation
diff --git a/src/data_structures/sqrt_decomposition.md b/src/data_structures/sqrt_decomposition.md
index ff9c3e351..9de18621f 100644
--- a/src/data_structures/sqrt_decomposition.md
+++ b/src/data_structures/sqrt_decomposition.md
@@ -120,7 +120,7 @@ But in a lot of situations this method has advantages.
During a normal sqrt decomposition, we have to precompute the answers for each block, and merge them during answering queries.
In some problems this merging step can be quite problematic.
E.g. when each queries asks to find the **mode** of its range (the number that appears the most often).
-For this each block would have to store the count of each number in it in some sort of data structure, and we cannot longer perform the merge step fast enough any more.
+For this each block would have to store the count of each number in it in some sort of data structure, and we can no longer perform the merge step fast enough any more.
**Mo's algorithm** uses a completely different approach, that can answer these kind of queries fast, because it only keeps track of one data structure, and the only operations with it are easy and fast.
The idea is to answer the queries in a special order based on the indices.
@@ -246,3 +246,4 @@ You can read about even faster sorting approach [here](https://codeforces.com/bl
* [Codeforces - XOR and Favorite Number](https://codeforces.com/problemset/problem/617/E)
* [Codeforces - Powerful array](http://codeforces.com/problemset/problem/86/D)
* [SPOJ - DQUERY](https://www.spoj.com/problems/DQUERY)
+* [Codeforces - Robin Hood Archery](https://codeforces.com/contest/2014/problem/H)
diff --git a/src/data_structures/stack_queue_modification.md b/src/data_structures/stack_queue_modification.md
index c8bee7927..fbce47929 100644
--- a/src/data_structures/stack_queue_modification.md
+++ b/src/data_structures/stack_queue_modification.md
@@ -187,5 +187,6 @@ Since all operations with the queue are performed in constant time on average, t
## Practice Problems
* [Queries with Fixed Length](https://www.hackerrank.com/challenges/queries-with-fixed-length/problem)
+* [Sliding Window Minimum](https://cses.fi/problemset/task/3221)
* [Binary Land](https://www.codechef.com/MAY20A/problems/BINLAND)
diff --git a/src/data_structures/treap.md b/src/data_structures/treap.md
index 05eeb4bca..11ff00482 100644
--- a/src/data_structures/treap.md
+++ b/src/data_structures/treap.md
@@ -92,7 +92,7 @@ Alternatively, insert can be done by splitting the initial treap on $X$ and doin
+
-Implementation of **Erase ($X$)** is also clear. First we descend in the tree (as in a regular binary search tree by $X$), looking for the element we want to delete. Once the node is found, we call **Merge** on it children and put the return value of the operation in the place of the element we're deleting.
+Implementation of **Erase ($X$)** is also clear. First we descend in the tree (as in a regular binary search tree by $X$), looking for the element we want to delete. Once the node is found, we call **Merge** on its children and put the return value of the operation in the place of the element we're deleting.
Alternatively, we can factor out the subtree holding $X$ with $2$ split operations and merge the remaining treaps (see the picture).
diff --git a/src/dynamic_programming/divide-and-conquer-dp.md b/src/dynamic_programming/divide-and-conquer-dp.md
index 457e17c24..a33cc7b45 100644
--- a/src/dynamic_programming/divide-and-conquer-dp.md
+++ b/src/dynamic_programming/divide-and-conquer-dp.md
@@ -113,7 +113,7 @@ both!
- [SPOJ - LARMY](https://www.spoj.com/problems/LARMY/)
- [SPOJ - NKLEAVES](https://www.spoj.com/problems/NKLEAVES/)
- [Timus - Bicolored Horses](https://acm.timus.ru/problem.aspx?space=1&num=1167)
-- [USACO - Circular Barn](http://www.usaco.org/index.php?page=viewproblem2&cpid=616)
+- [USACO - Circular Barn](https://usaco.org/index.php?page=viewproblem2&cpid=626)
- [UVA - Arranging Heaps](https://onlinejudge.org/external/125/12524.pdf)
- [UVA - Naming Babies](https://onlinejudge.org/external/125/12594.pdf)
diff --git a/src/dynamic_programming/intro-to-dp.md b/src/dynamic_programming/intro-to-dp.md
index 9d227796e..8bc33fd82 100644
--- a/src/dynamic_programming/intro-to-dp.md
+++ b/src/dynamic_programming/intro-to-dp.md
@@ -7,7 +7,7 @@ tags:
The essence of dynamic programming is to avoid repeated calculation. Often, dynamic programming problems are naturally solvable by recursion. In such cases, it's easiest to write the recursive solution, then save repeated states in a lookup table. This process is known as top-down dynamic programming with memoization. That's read "memoization" (like we are writing in a memo pad) not memorization.
-One of the most basic, classic examples of this process is the fibonacci sequence. It's recursive formulation is $f(n) = f(n-1) + f(n-2)$ where $n \ge 2$ and $f(0)=0$ and $f(1)=1$. In C++, this would be expressed as:
+One of the most basic, classic examples of this process is the fibonacci sequence. Its recursive formulation is $f(n) = f(n-1) + f(n-2)$ where $n \ge 2$ and $f(0)=0$ and $f(1)=1$. In C++, this would be expressed as:
```cpp
int f(int n) {
@@ -25,7 +25,7 @@ Our recursive function currently solves fibonacci in exponential time. This mean
To increase the speed, we recognize that the number of subproblems is only $O(n)$. That is, in order to calculate $f(n)$ we only need to know $f(n-1),f(n-2), \dots ,f(0)$. Therefore, instead of recalculating these subproblems, we solve them once and then save the result in a lookup table. Subsequent calls will use this lookup table and immediately return a result, thus eliminating exponential work!
-Each recursive call will check against a lookup table to see if the value has been calculated. This is done is $O(1)$ time. If we have previously calcuated it, return the result, otherwise, we calculate the function normally. The overall runtime is $O(n)$! This is an enormous improvement over our previous exponential time algorithm!
+Each recursive call will check against a lookup table to see if the value has been calculated. This is done in $O(1)$ time. If we have previously calculated it, return the result, otherwise, we calculate the function normally. The overall runtime is $O(n)$. This is an enormous improvement over our previous exponential time algorithm!
```cpp
const int MAXN = 100;
@@ -44,7 +44,7 @@ int f(int n) {
With our new memoized recursive function, $f(29)$, which used to result in *over 1 million calls*, now results in *only 57* calls, nearly *20,000 times* fewer function calls! Ironically, we are now limited by our data type. $f(46)$ is the last fibonacci number that can fit into a signed 32-bit integer.
-Typically, we try to save states in arrays,if possible, since the lookup time is $O(1)$ with minimal overhead. However, more generically, we can save states anyway we like. Other examples include maps (binary search trees) or unordered_maps (hash tables).
+Typically, we try to save states in arrays, if possible, since the lookup time is $O(1)$ with minimal overhead. However, more generically, we can save states any way we like. Other examples include binary search trees (`map` in C++) or hash tables (`unordered_map` in C++).
An example of this might be:
@@ -86,9 +86,9 @@ This approach is called top-down, as we can call the function with a query value
## Bottom-up Dynamic Programming
Until now you've only seen top-down dynamic programming with memoization. However, we can also solve problems with bottom-up dynamic programming.
-Bottom up is exactly the opposite of top-down, you start at the bottom (base cases of the recursion), and extend it to more and more values.
+Bottom-up is exactly the opposite of top-down, you start at the bottom (base cases of the recursion), and extend it to more and more values.
-To create a bottom-up approach for fibonacci numbers, we initilize the base cases in an array. Then, we simply use the recursive definition on array:
+To create a bottom-up approach for fibonacci numbers, we initialize the base cases in an array. Then, we simply use the recursive definition on array:
```cpp
const int MAXN = 100;
@@ -107,7 +107,7 @@ Of course, as written, this is a bit silly for two reasons:
Firstly, we do repeated work if we call the function more than once.
Secondly, we only need to use the two previous values to calculate the current element. Therefore, we can reduce our memory from $O(n)$ to $O(1)$.
-An example of a bottom up dynamic programming solution for fibonacci which uses $O(1)$ might be:
+An example of a bottom-up dynamic programming solution for fibonacci which uses $O(1)$ memory might be:
```cpp
const int MAX_SAVE = 3;
@@ -123,19 +123,19 @@ int f(int n) {
}
```
-Note that we've changed the constant from `MAXN` TO `MAX_SAVE`. This is because the total number of elements we need to have access to is only 3. It no longer scales with the size of input and is, by definition, $O(1)$ memory. Additionally, we use a common trick (using the modulo operator) only maintaining the values we need.
+Note that we've changed the constant from `MAXN` TO `MAX_SAVE`. This is because the total number of elements we need to access is only 3. It no longer scales with the size of input and is, by definition, $O(1)$ memory. Additionally, we use a common trick (using the modulo operator) only maintaining the values we need.
-That's it. That's the basics of dynamic programming: Don't repeat work you've done before.
+That's it. That's the basics of dynamic programming: Don't repeat the work you've done before.
One of the tricks to getting better at dynamic programming is to study some of the classic examples.
## Classic Dynamic Programming Problems
| Name | Description/Example |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| 0-1 knapsack | Given $W$, $N$, and $N$ items with weights $w_i$ and values $v_i$, what is the maximum $\sum_{i=1}^{k} v_i$ for each subset of items of size $k$ ($1 \le k \le N$) while ensuring $\sum_{i=1}^{k} w_i \le W$? |
+| 0-1 Knapsack | Given $W$, $N$, and $N$ items with weights $w_i$ and values $v_i$, what is the maximum $\sum_{i=1}^{k} v_i$ for each subset of items of size $k$ ($1 \le k \le N$) while ensuring $\sum_{i=1}^{k} w_i \le W$? |
| Subset Sum | Given $N$ integers and $T$, determine whether there exists a subset of the given set whose elements sum up to the $T$. |
-| Longest Increasing Subsequence | You are given an array containing $N$ integers. Your task is to determine the LCS in the array, i.e., LCS where every element is larger than the previous one. |
-| Counting all possible paths in a matrix. | Given $N$ and $M$, count all possible distinct paths from $(1,1)$ to $(N, M)$, where each step is either from $(i,j)$ to $(i+1,j)$ or $(i,j+1)$. |
+| Longest Increasing Subsequence (LIS) | You are given an array containing $N$ integers. Your task is to determine the LIS in the array, i.e., a subsequence where every element is larger than the previous one. |
+| Counting Paths in a 2D Array | Given $N$ and $M$, count all possible distinct paths from $(1,1)$ to $(N, M)$, where each step is either from $(i,j)$ to $(i+1,j)$ or $(i,j+1)$. |
| Longest Common Subsequence | You are given strings $s$ and $t$. Find the length of the longest string that is a subsequence of both $s$ and $t$. |
| Longest Path in a Directed Acyclic Graph (DAG) | Finding the longest path in Directed Acyclic Graph (DAG). |
| Longest Palindromic Subsequence | Finding the Longest Palindromic Subsequence (LPS) of a given string. |
@@ -153,11 +153,13 @@ Of course, the most important trick is to practice.
* [LeetCode - 1137. N-th Tribonacci Number](https://leetcode.com/problems/n-th-tribonacci-number/description/)
* [LeetCode - 118. Pascal's Triangle](https://leetcode.com/problems/pascals-triangle/description/)
* [LeetCode - 1025. Divisor Game](https://leetcode.com/problems/divisor-game/description/)
+* [Codeforces - Vacations](https://codeforces.com/problemset/problem/699/C)
+* [Codeforces - Hard problem](https://codeforces.com/problemset/problem/706/C)
* [Codeforces - Zuma](https://codeforces.com/problemset/problem/607/b)
* [LeetCode - 221. Maximal Square](https://leetcode.com/problems/maximal-square/description/)
* [LeetCode - 1039. Minimum Score Triangulation of Polygon](https://leetcode.com/problems/minimum-score-triangulation-of-polygon/description/)
-## Dp Contests
+## DP Contests
* [Atcoder - Educational DP Contest](https://atcoder.jp/contests/dp/tasks)
* [CSES - Dynamic Programming](https://cses.fi/problemset/list/)
diff --git a/src/dynamic_programming/knapsack.md b/src/dynamic_programming/knapsack.md
index 6675933dd..9f73d173c 100644
--- a/src/dynamic_programming/knapsack.md
+++ b/src/dynamic_programming/knapsack.md
@@ -116,7 +116,7 @@ Let $A_{i, j}$ denote the $j^{th}$ item split from the $i^{th}$ item. In the tri
The grouping is made more efficient by using binary grouping.
-Specifically, $A_{i, j}$ holds $2^j$ individual items ($j\in[0,\lfloor \log_2(k_i+1)\rfloor-1]$).If $k_i + 1$ is not an integer power of $2$, another bundle of size $k_i-2^{\lfloor \log_2(k_i+1)\rfloor-1}$ is used to make up for it.
+Specifically, $A_{i, j}$ holds $2^j$ individual items ($j\in[0,\lfloor \log_2(k_i+1)\rfloor-1]$).If $k_i + 1$ is not an integer power of $2$, another bundle of size $k_i-(2^{\lfloor \log_2(k_i+1)\rfloor}-1)$ is used to make up for it.
Through the above splitting method, it is possible to obtain any sum of $\leq k_i$ items by selecting a few $A_{i, j}$'s. After splitting each item in the described way, it is sufficient to use 0-1 knapsack method to solve the new formulation of the problem.
@@ -177,6 +177,8 @@ for (each item) {
- [Atcoder: Knapsack-1](https://atcoder.jp/contests/dp/tasks/dp_d)
- [Atcoder: Knapsack-2](https://atcoder.jp/contests/dp/tasks/dp_e)
+- [LeetCode - 494. Target Sum](https://leetcode.com/problems/target-sum)
+- [LeetCode - 416. Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum)
- [CSES: Book Shop II](https://cses.fi/problemset/task/1159)
- [DMOJ: Knapsack-3](https://dmoj.ca/problem/knapsack)
- [DMOJ: Knapsack-4](https://dmoj.ca/problem/knapsack4)
diff --git a/src/dynamic_programming/knuth-optimization.md b/src/dynamic_programming/knuth-optimization.md
index 535c7caf2..35978b839 100644
--- a/src/dynamic_programming/knuth-optimization.md
+++ b/src/dynamic_programming/knuth-optimization.md
@@ -77,7 +77,7 @@ $$
\sum\limits_{i=1}^N \sum\limits_{j=i}^{N-1} [opt(i+1,j+1)-opt(i,j)].
$$
-As you see, most of the terms in this expression cancel each other out, except for positive terms with $j=N$ and negative terms with $i=1$. Thus, the whole sum can be estimated as
+As you see, most of the terms in this expression cancel each other out, except for positive terms with $j=N-1$ and negative terms with $i=1$. Thus, the whole sum can be estimated as
$$
\sum\limits_{k=1}^N[opt(k,N)-opt(1,k)] = O(n^2),
diff --git a/src/game_theory/sprague-grundy-nim.md b/src/game_theory/sprague-grundy-nim.md
index 0d03983f9..a6a172d87 100644
--- a/src/game_theory/sprague-grundy-nim.md
+++ b/src/game_theory/sprague-grundy-nim.md
@@ -100,6 +100,17 @@ If $s \neq 0$, we have to prove that there is a move leading to a state with $t
Any state of Nim can be replaced by an equivalent state as long as the xor-sum doesn't change.
Moreover, when analyzing a Nim with several piles, we can replace it with a single pile of size $s$.
+### Misère Game
+
+In a **misère game**, the goal of the game is opposite, so the player who removes the last stick loses the game.
+It turns out that the misère nim game can be optimally played almost like a standard nim game.
+ The idea is to first play the misère game like the standard game, but change the strategy at the end of the game.
+ The new strategy will be introduced in a situation where each heap would contain at most one stick after the next move.
+In the standard game, we should choose a move after which there is an even number of heaps with one stick. However, in
+the misère game,we choose a move so that there is an odd number of heaps with one stick.
+ This strategy works because a state where the strategy changes always appears in the game, and this state is a
+ winning state, because it contains exactly one heap that has more than one stick so the nim sum is not 0.
+
## The equivalence of impartial games and Nim (Sprague-Grundy theorem)
Now we will learn how to find, for any game state of any impartial game, a corresponding state of Nim.
@@ -209,3 +220,4 @@ In fact, $g(n)$ has a period of length 34 starting with $n=52$.
- [HackerRank - Tower Breakers, Revisited!](https://www.hackerrank.com/contests/5-days-of-game-theory/challenges/tower-breakers-2)
- [HackerRank - Tower Breakers, Again!](https://www.hackerrank.com/contests/5-days-of-game-theory/challenges/tower-breakers-3/problem)
- [HackerRank - Chessboard Game, Again!](https://www.hackerrank.com/contests/5-days-of-game-theory/challenges/a-chessboard-game)
+- [Atcoder - ABC368F - Dividing Game](https://atcoder.jp/contests/abc368/tasks/abc368_f)
\ No newline at end of file
diff --git a/src/geometry/basic-geometry.md b/src/geometry/basic-geometry.md
index 4c052a784..89acb1642 100644
--- a/src/geometry/basic-geometry.md
+++ b/src/geometry/basic-geometry.md
@@ -112,7 +112,9 @@ The dot (or scalar) product $\mathbf a \cdot \mathbf b$ for vectors $\mathbf a$
Geometrically it is product of the length of the first vector by the length of the projection of the second vector onto the first one.
As you may see from the image below this projection is nothing but $|\mathbf a| \cos \theta$ where $\theta$ is the angle between $\mathbf a$ and $\mathbf b$. Thus $\mathbf a\cdot \mathbf b = |\mathbf a| \cos \theta \cdot |\mathbf b|$.
-
+ 
+
The dot product holds some notable properties:
@@ -181,7 +183,9 @@ To see the next important property we should take a look at the set of points $\
You can see that this set of points is exactly the set of points for which the projection onto $\mathbf a$ is the point $C \cdot \dfrac{\mathbf a}{|\mathbf a|}$ and they form a hyperplane orthogonal to $\mathbf a$.
You can see the vector $\mathbf a$ alongside with several such vectors having same dot product with it in 2D on the picture below:
-
+
+ 
+
In 2D these vectors will form a line, in 3D they will form a plane.
Note that this result allows us to define a line in 2D as $\mathbf r\cdot \mathbf n=C$ or $(\mathbf r - \mathbf r_0)\cdot \mathbf n=0$ where $\mathbf n$ is vector orthogonal to the line and $\mathbf r_0$ is any vector already present on the line and $C = \mathbf r_0\cdot \mathbf n$.
@@ -192,14 +196,18 @@ In the same manner a plane can be defined in 3D.
### Definition
Assume you have three vectors $\mathbf a$, $\mathbf b$ and $\mathbf c$ in 3D space joined in a parallelepiped as in the picture below:
-
+
+ 
+
How would you calculate its volume?
From school we know that we should multiply the area of the base with the height, which is projection of $\mathbf a$ onto direction orthogonal to base.
That means that if we define $\mathbf b \times \mathbf c$ as the vector which is orthogonal to both $\mathbf b$ and $\mathbf c$ and which length is equal to the area of the parallelogram formed by $\mathbf b$ and $\mathbf c$ then $|\mathbf a\cdot (\mathbf b\times\mathbf c)|$ will be equal to the volume of the parallelepiped.
For integrity we will say that $\mathbf b\times \mathbf c$ will be always directed in such way that the rotation from the vector $\mathbf b$ to the vector $\mathbf c$ from the point of $\mathbf b\times \mathbf c$ is always counter-clockwise (see the picture below).
-
+
+ 
+
This defines the cross (or vector) product $\mathbf b\times \mathbf c$ of the vectors $\mathbf b$ and $\mathbf c$ and the triple product $\mathbf a\cdot(\mathbf b\times \mathbf c)$ of the vectors $\mathbf a$, $\mathbf b$ and $\mathbf c$.
diff --git a/src/geometry/chebyshev-transformation.png b/src/geometry/chebyshev-transformation.png
new file mode 100644
index 000000000..bcad9616f
Binary files /dev/null and b/src/geometry/chebyshev-transformation.png differ
diff --git a/src/geometry/convex-hull.md b/src/geometry/convex-hull.md
index 1a096d334..f74061d37 100644
--- a/src/geometry/convex-hull.md
+++ b/src/geometry/convex-hull.md
@@ -194,6 +194,6 @@ void convex_hull(vector
+
+ 
+
One has to keep points on the convex hull and normal vectors of the hull's edges.
When you have a $(x;1)$ query you'll have to find the normal vector closest to it in terms of angles between them, then the optimum linear function will correspond to one of its endpoints.
@@ -90,7 +92,9 @@ Assume we're in some vertex corresponding to half-segment $[l,r)$ and the functi
Here is the illustration of what is going on in the vertex when we add new function:
-
+
+ 
+
Let's go to implementation now. Once again we will use complex numbers to keep linear functions.
diff --git a/src/geometry/delaunay.md b/src/geometry/delaunay.md
index c5f5c22d1..68d67ce8f 100644
--- a/src/geometry/delaunay.md
+++ b/src/geometry/delaunay.md
@@ -30,7 +30,9 @@ Because of the duality, we only need a fast algorithm to compute only one of $V$
## Quad-edge data structure
During the algorithm $D$ will be stored inside the quad-edge data structure. This structure is described in the picture:
-
+
+ 
+
In the algorithm we will use the following functions on edges:
diff --git a/src/geometry/intersecting_segments.md b/src/geometry/intersecting_segments.md
index a5eba5f6b..ac26c8fd5 100644
--- a/src/geometry/intersecting_segments.md
+++ b/src/geometry/intersecting_segments.md
@@ -16,18 +16,24 @@ The naive solution algorithm is to iterate over all pairs of segments in $O(n^2)
Let's draw a vertical line $x = -\infty$ mentally and start moving this line to the right.
In the course of its movement, this line will meet with segments, and at each time a segment intersect with our line it intersects in exactly one point (we will assume that there are no vertical segments).
-
+
+ 
+
Thus, for each segment, at some point in time, its point will appear on the sweep line, then with the movement of the line, this point will move, and finally, at some point, the segment will disappear from the line.
We are interested in the **relative order of the segments** along the vertical.
Namely, we will store a list of segments crossing the sweep line at a given time, where the segments will be sorted by their $y$-coordinate on the sweep line.
-
+
+ 
+
This order is interesting because intersecting segments will have the same $y$-coordinate at least at one time:
-
+
+ 
+
We formulate key statements:
diff --git a/src/geometry/lattice-points.md b/src/geometry/lattice-points.md
index 8bd9db346..e3d6faf7e 100644
--- a/src/geometry/lattice-points.md
+++ b/src/geometry/lattice-points.md
@@ -38,7 +38,9 @@ We have two cases:
This amount is the same as the number of points such that $0 < y \leq (k - \lfloor k \rfloor) \cdot x + (b - \lfloor b \rfloor)$.
So we reduced our problem to $k'= k - \lfloor k \rfloor$, $b' = b - \lfloor b \rfloor$ and both $k'$ and $b'$ less than $1$ now.
Here is a picture, we just summed up blue points and subtracted the blue linear function from the black one to reduce problem to smaller values for $k$ and $b$:
-
+
+ 
+
- $k < 1$ and $b < 1$.
@@ -51,7 +53,9 @@ We have two cases:
which returns us back to the case $k>1$.
You can see new reference point $O'$ and axes $X'$ and $Y'$ in the picture below:
-
+
+ 
+
As you see, in new reference system linear function will have coefficient $\tfrac 1 k$ and its zero will be in the point $\lfloor k\cdot n + b \rfloor-(k\cdot n+b)$ which makes formula above correct.
## Complexity analysis
diff --git a/src/geometry/manhattan-distance.md b/src/geometry/manhattan-distance.md
new file mode 100644
index 000000000..87514868a
--- /dev/null
+++ b/src/geometry/manhattan-distance.md
@@ -0,0 +1,189 @@
+---
+tags:
+ - Original
+---
+
+# Manhattan Distance
+
+## Definition
+For points $p$ and $q$ on a plane, we can define the distance between them as the sum of the differences between their $x$ and $y$ coordinates:
+
+$$d(p,q) = |x_p - x_q| + |y_p - y_q|$$
+
+Defined this way, the distance corresponds to the so-called [Manhattan (taxicab) geometry](https://en.wikipedia.org/wiki/Taxicab_geometry), in which the points are considered intersections in a well designed city, like Manhattan, where you can only move on the streets horizontally or vertically, as shown in the image below:
+
+
+
+ 
+
+
+This images show some of the smallest paths from one black point to the other, all of them with length $12$.
+
+There are some interesting tricks and algorithms that can be done with this distance, and we will show some of them here.
+
+## Farthest pair of points in Manhattan distance
+
+Given $n$ points $P$, we want to find the pair of points $p,q$ that are farther apart, that is, maximize $|x_p - x_q| + |y_p - y_q|$.
+
+Let's think first in one dimension, so $y=0$. The main observation is that we can bruteforce if $|x_p - x_q|$ is equal to $x_p - x_q$ or $-x_p + x_q$, because if we "miss the sign" of the absolute value, we will get only a smaller value, so it can't affect the answer. More formally, it holds that:
+
+$$|x_p - x_q| = \max(x_p - x_q, -x_p + x_q)$$
+
+So, for example, we can try to have $p$ such that $x_p$ has the plus sign, and then $q$ must have the negative sign. This way we want to find:
+
+$$\max\limits_{p, q \in P}(x_p + (-x_q)) = \max\limits_{p \in P}(x_p) + \max\limits_{q \in P}( - x_q ).$$
+
+Notice that we can extend this idea further for 2 (or more!) dimensions. For $d$ dimensions, we must bruteforce $2^d$ possible values of the signs. For example, if we are in $2$ dimensions and bruteforce that $p$ has both the plus signs we want to find:
+
+$$\max\limits_{p, q \in P} [(x_p + (-x_q)) + (y_p + (-y_q))] = \max\limits_{p \in P}(x_p + y_p) + \max\limits_{q \in P}(-x_q - y_q).$$
+
+As we made $p$ and $q$ independent, it is now easy to find the $p$ and $q$ that maximize the expression.
+
+The code below generalizes this to $d$ dimensions and runs in $O(n \cdot 2^d \cdot d)$.
+
+```cpp
+long long ans = 0;
+for (int msk = 0; msk < (1 << d); msk++) {
+ long long mx = LLONG_MIN, mn = LLONG_MAX;
+ for (int i = 0; i < n; i++) {
+ long long cur = 0;
+ for (int j = 0; j < d; j++) {
+ if (msk & (1 << j)) cur += p[i][j];
+ else cur -= p[i][j];
+ }
+ mx = max(mx, cur);
+ mn = min(mn, cur);
+ }
+ ans = max(ans, mx - mn);
+}
+```
+
+## Rotating the points and Chebyshev distance
+
+It's well known that, for all $m, n \in \mathbb{R}$,
+
+$$|m| + |n| = \text{max}(|m + n|, |m - n|).$$
+
+To prove this, we just need to analyze the signs of $m$ and $n$. And it's left as an exercise.
+
+We may apply this equation to the Manhattan distance formula to find out that
+
+$$d((x_1, y_1), (x_2, y_2)) = |x_1 - x_2| + |y_1 - y_2| = \text{max}(|(x_1 + y_1) - (x_2 + y_2)|, |(x_1 - y_1) - (x_2 - y_2)|).$$
+
+The last expression in the previous equation is the [Chebyshev distance](https://en.wikipedia.org/wiki/Chebyshev_distance) of the points $(x_1 + y_1, x_1 - y_1)$ and $(x_2 + y_2, x_2 - y_2)$. This means that, after applying the transformation
+
+$$\alpha : (x, y) \to (x + y, x - y),$$
+
+the Manhattan distance between the points $p$ and $q$ turns into the Chebyshev distance between $\alpha(p)$ and $\alpha(q)$.
+
+Also, we may realize that $\alpha$ is a [spiral similarity](https://en.wikipedia.org/wiki/Spiral_similarity) (rotation of the plane followed by a dilation about a center $O$) with center $(0, 0)$, rotation angle of $45^{\circ}$ in clockwise direction and dilation by $\sqrt{2}$.
+
+Here's an image to help visualizing the transformation:
+
+
+
+ 
+
+
+## Manhattan Minimum Spanning Tree
+
+The Manhattan MST problem consists of, given some points in the plane, find the edges that connect all the points and have a minimum total sum of weights. The weight of an edge that connects two points is their Manhattan distance. For simplicity, we assume that all points have different locations.
+Here we show a way of finding the MST in $O(n \log{n})$ by finding for each point its nearest neighbor in each octant, as represented by the image below. This will give us $O(n)$ candidate edges, which, as we show below, will guarantee that they contain the MST. The final step is then using some standard MST, for example, [Kruskal algorithm using disjoint set union](https://cp-algorithms.com/graph/mst_kruskal_with_dsu.html).
+
+
+
+ 
+ *The 8 octants relative to a point S*
+
+
+The algorithm shown here was first presented in a paper from [H. Zhou, N. Shenoy, and W. Nichollos (2002)](https://ieeexplore.ieee.org/document/913303). There is also another know algorithm that uses a Divide and conquer approach by [J. Stolfi](https://www.academia.edu/15667173/On_computing_all_north_east_nearest_neighbors_in_the_L1_metric), which is also very interesting and only differ in the way they find the nearest neighbor in each octant. They both have the same complexity, but the one presented here is easier to implement and has a lower constant factor.
+
+First, let's understand why it is enough to consider only the nearest neighbor in each octant. The idea is to show that for a point $s$ and any two other points $p$ and $q$ in the same octant, $d(p, q) < \max(d(s, p), d(s, q))$. This is important, because it shows that if there was a MST where $s$ is connected to both $p$ and $q$, we could erase one of these edges and add the edge $(p,q)$, which would decrease the total cost. To prove this, we assume without loss of generality that $p$ and $q$ are in the octanct $R_1$, which is defined by: $x_s \leq x$ and $x_s - y_s > x - y$, and then do some casework. The image below give some intuition on why this is true.
+
+
+ *The 8 octants relative to a point S*
+
+ 
+ *Intuitively, the limitation of the octant makes it impossible that $p$ and $q$ are both closer to $s$ than to each other*
+
+
+
+Therefore, the main question is how to find the nearest neighbor in each octant for every single of the $n$ points.
+
+## Nearest Neighbor in each Octant in O(n log n)
+
+For simplicity we focus on the NNE octant ($R_1$ in the image above). All other directions can be found with the same algorithm by rotating the input.
+
+We will use a sweep-line approach. We process the points from south-west to north-east, that is, by non-decreasing $x + y$. We also keep a set of points which don't have their nearest neighbor yet, which we call "active set". We add the images below to help visualize the algorithm.
+
+
+ *Intuitively, the limitation of the octant makes it impossible that $p$ and $q$ are both closer to $s$ than to each other*
+
+ 
+ *In black with an arrow you can see the direction of the line-sweep. All the points below this lines are in the active set, and the points above are still not processed. In green we see the points which are in the octant of the processed point. In red the points that are not in the searched octant.*
+
+
+
+ *In black with an arrow you can see the direction of the line-sweep. All the points below this lines are in the active set, and the points above are still not processed. In green we see the points which are in the octant of the processed point. In red the points that are not in the searched octant.*
+
+ 
+ *In this image we see the active set after processing the point $p$. Note that the $2$ green points of the previous image had $p$ in its north-north-east octant and are not in the active set anymore, because they already found their nearest neighbor.*
+
+
+When we add a new point point $p$, for every point $s$ that has it in its octant we can safely assign $p$ as the nearest neighbor. This is true because their distance is $d(p,s) = |x_p - x_s| + |y_p - y_s| = (x_p + y_p) - (x_s + y_s)$, because $p$ is in the north-north-east octant. As all the next points will not have a smaller value of $x + y$ because of the sorting step, $p$ is guaranteed to have the smaller distance. We can then remove all such points from the active set, and finally add $p$ to the active set.
+
+The next question is how to efficiently find which points $s$ have $p$ in the north-north-east octant. That is, which points $s$ satisfy:
+
+- $x_s \leq x_p$
+- $x_p - y_p < x_s - y_s$
+
+Because no points in the active set are in the $R_1$ region of another, we also have that for two points $q_1$ and $q_2$ in the active set, $x_{q_1} \neq x_{q_2}$ and their ordering implies $x_{q_1} < x_{q_2} \implies x_{q_1} - y_{q_1} \leq x_{q_2} - y_{q_2}$.
+
+You can try to visualize this on the images above by thinking of the ordering of $x - y$ as a "sweep-line" that goes from the north-west to the south-east, so perpendicular to the one that is drawn.
+
+This means that if we keep the active set ordered by $x$ the candidates $s$ are consecutively placed. We can then find the largest $x_s \leq x_p$ and process the points in decreasing order of $x$ until the second condition $x_p - y_p < x_s - y_s$ breaks (we can actually allow that $x_p - y_p = x_s - y_s$ and that deals with the case of points with equal coordinates). Notice that because we remove from the set right after processing, this will have an amortized complexity of $O(n \log(n))$.
+ Now that we have the nearest point in the north-east direction, we rotate the points and repeat. It is possible to show that actually we also find this way the nearest point in the south-west direction, so we can repeat only 4 times, instead of 8.
+
+In summary we:
+
+- Sort the points by $x + y$ in non-decreasing order;
+- For every point, we iterate over the active set starting with the point with the largest $x$ such that $x \leq x_p$, and we break the loop if $x_p - y_p \geq x_s - y_s$. For every valid point $s$ we add the edge $(s,p, d(s,p))$ in our list;
+- We add the point $p$ to the active set;
+- Rotate the points and repeat until we iterate over all the octants.
+- Apply Kruskal algorithm in the list of edges to get the MST.
+
+Below you can find a implementation, based on the one from [KACTL](https://github.com/kth-competitive-programming/kactl/blob/main/content/geometry/ManhattanMST.h).
+
+```{.cpp file=manhattan_mst}
+struct point {
+ long long x, y;
+};
+
+// Returns a list of edges in the format (weight, u, v).
+// Passing this list to Kruskal algorithm will give the Manhattan MST.
+vector
+ *In this image we see the active set after processing the point $p$. Note that the $2$ green points of the previous image had $p$ in its north-north-east octant and are not in the active set anymore, because they already found their nearest neighbor.*
+
+ 
+
## Distance between two polygons
One of the most common applications of Minkowski sum is computing the distance between two convex polygons (or simply checking whether they intersect).
diff --git a/src/geometry/nearest_points.md b/src/geometry/nearest_points.md
index 4aab174d5..0c8abc259 100644
--- a/src/geometry/nearest_points.md
+++ b/src/geometry/nearest_points.md
@@ -173,6 +173,6 @@ In fact, to solve this problem, the algorithm remains the same: we divide the fi
* [UVA 10245 "The Closest Pair Problem" [difficulty: low]](https://uva.onlinejudge.org/index.php?option=onlinejudge&page=show_problem&problem=1186)
* [SPOJ #8725 CLOPPAIR "Closest Point Pair" [difficulty: low]](https://www.spoj.com/problems/CLOPPAIR/)
* [CODEFORCES Team Olympiad Saratov - 2011 "Minimum amount" [difficulty: medium]](http://codeforces.com/contest/120/problem/J)
-* [Google CodeJam 2009 Final " Min Perimeter "[difficulty: medium]](https://code.google.com/codejam/contest/311101/dashboard#s=a&a=1)
+* [Google CodeJam 2009 Final "Min Perimeter" [difficulty: medium]](https://github.com/google/coding-competitions-archive/blob/main/codejam/2009/world_finals/min_perimeter/statement.pdf)
* [SPOJ #7029 CLOSEST "Closest Triple" [difficulty: medium]](https://www.spoj.com/problems/CLOSEST/)
* [TIMUS 1514 National Park [difficulty: medium]](https://acm.timus.ru/problem.aspx?space=1&num=1514)
diff --git a/src/geometry/planar.md b/src/geometry/planar.md
index 1c613f585..2cfc81282 100644
--- a/src/geometry/planar.md
+++ b/src/geometry/planar.md
@@ -13,7 +13,7 @@ In this article we will deal with finding both inner and outer faces of a planar
## Some facts about planar graphs
-In this section we present several facts about planar graphs without proof. Readers who are interested in proofs should refer to [Graph Theory by R. Diestel](https://sites.math.washington.edu/~billey/classes/562.winter.2018/articles/GraphTheory.pdf) or some other book.
+In this section we present several facts about planar graphs without proof. Readers who are interested in proofs should refer to [Graph Theory by R. Diestel](https://www.math.uni-hamburg.de/home/diestel/books/graph.theory/preview/Ch4.pdf) (see also [video lectures on planarity](https://www.youtube.com/@DiestelGraphTheory) based on this book) or some other book.
### Euler's theorem
Euler's theorem states that any correct embedding of a connected planar graph with $n$ vertices, $m$ edges and $f$ faces satisfies:
@@ -53,7 +53,9 @@ It's quite clear that the complexity of the algorithm is $O(m \log m)$ because o
At the first glance it may seem that finding faces of a disconnected graph is not much harder because we can run the same algorithm for each connected component. However, the components may be drawn in a nested way, forming **holes** (see the image below). In this case the inner face of some component becomes the outer face of some other components and has a complex disconnected border. Dealing with such cases is quite hard, one possible approach is to identify nested components with [point location](point-location.md) algorithms.
-
+
+ 
+
## Implementation
The following implementation returns a vector of vertices for each face, outer face goes first.
@@ -125,20 +127,14 @@ std::vector
+
+ 
+
## Implementation
```{.cpp file=planar_implicit}
diff --git a/src/geometry/point-location.md b/src/geometry/point-location.md
index 10c0d3f51..c6d21b7f8 100644
--- a/src/geometry/point-location.md
+++ b/src/geometry/point-location.md
@@ -15,7 +15,9 @@ This problem may arise when you need to locate some points in a Voronoi diagram
Firstly, for each query point $p\ (x_0, y_0)$ we want to find such an edge that if the point belongs to any edge, the point lies on the edge we found, otherwise this edge must intersect the line $x = x_0$ at some unique point $(x_0, y)$ where $y < y_0$ and this $y$ is maximum among all such edges.
The following image shows both cases.
-
+
+ 
+
We will solve this problem offline using the sweep line algorithm. Let's iterate over x-coordinates of query points and edges' endpoints in increasing order and keep a set of edges $s$. For each x-coordinate we will add some events beforehand.
@@ -27,7 +29,9 @@ Finally, for each query point we will add one _get_ event for its x-coordinate.
For each x-coordinate we will sort the events by their types in order (_vertical_, _get_, _remove_, _add_).
The following image shows all events in sorted order for each x-coordinate.
-
+
+ 
+
We will keep two sets during the sweep-line process.
A set $t$ for all non-vertical edges, and one set $vert$ especially for the vertical ones.
diff --git a/src/geometry/tangents-to-two-circles.md b/src/geometry/tangents-to-two-circles.md
index 4f4dfa4e9..546150a62 100644
--- a/src/geometry/tangents-to-two-circles.md
+++ b/src/geometry/tangents-to-two-circles.md
@@ -14,7 +14,9 @@ The described algorithm will also work in the case when one (or both) circles de
## The number of common tangents
The number of common tangents to two circles can be **0,1,2,3,4** and **infinite**.
Look at the images for different cases.
-
+
+ 
+
Here, we won't be considering **degenerate** cases, i.e *when the circles coincide (in this case they have infinitely many common tangents), or one circle lies inside the other (in this case they have no common tangents, or if the circles are tangent, there is one common tangent).*
diff --git a/src/geometry/vertical_decomposition.md b/src/geometry/vertical_decomposition.md
index 934db8044..96853994f 100644
--- a/src/geometry/vertical_decomposition.md
+++ b/src/geometry/vertical_decomposition.md
@@ -39,7 +39,9 @@ For simplicity we will show how to do this for an upper segment, the algorithm f
Here is a graphic representation of the three cases.
-
+
+ 
+
Finally we should remark on processing all the additions of $1$ or $-1$ on all stripes in $[x_1, x_2]$. For each addition of $w$ on $[x_1, x_2]$ we can create events $(x_1, w),\ (x_2, -w)$
and process all these events with a sweep line.
diff --git a/src/graph/01_bfs.md b/src/graph/01_bfs.md
index 15022c141..5d7aee6f4 100644
--- a/src/graph/01_bfs.md
+++ b/src/graph/01_bfs.md
@@ -7,7 +7,7 @@ tags:
It is well-known, that you can find the shortest paths between a single source and all other vertices in $O(|E|)$ using [Breadth First Search](breadth-first-search.md) in an **unweighted graph**, i.e. the distance is the minimal number of edges that you need to traverse from the source to another vertex.
We can interpret such a graph also as a weighted graph, where every edge has the weight $1$.
-If not all edges in graph have the same weight, that we need a more general algorithm, like [Dijkstra](dijkstra.md) which runs in $O(|V|^2 + |E|)$ or $O(|E| \log |V|)$ time.
+If not all edges in graph have the same weight, then we need a more general algorithm, like [Dijkstra](dijkstra.md) which runs in $O(|V|^2 + |E|)$ or $O(|E| \log |V|)$ time.
However if the weights are more constrained, we can often do better.
In this article we demonstrate how we can use BFS to solve the SSSP (single-source shortest path) problem in $O(|E|)$, if the weight of each edge is either $0$ or $1$.
diff --git a/src/graph/2SAT.md b/src/graph/2SAT.md
index b66316bbe..fbd1a6a35 100644
--- a/src/graph/2SAT.md
+++ b/src/graph/2SAT.md
@@ -39,7 +39,9 @@ b \Rightarrow a & \lnot b \Rightarrow \lnot a & b \Rightarrow \lnot a & c \Right
You can see the implication graph in the following image:
-
+
+ 
+
It is worth paying attention to the property of the implication graph:
if there is an edge $a \Rightarrow b$, then there also is an edge $\lnot b \Rightarrow \lnot a$.
@@ -59,7 +61,9 @@ The following image shows all strongly connected components for the example.
As we can check easily, neither of the four components contain a vertex $x$ and its negation $\lnot x$, therefore the example has a solution.
We will learn in the next paragraphs how to compute a valid assignment, but just for demonstration purposes the solution $a = \text{false}$, $b = \text{false}$, $c = \text{false}$ is given.
-
+
+ 
+
Now we construct the algorithm for finding the solution of the 2-SAT problem on the assumption that the solution exists.
diff --git a/src/graph/bellman_ford.md b/src/graph/bellman_ford.md
index a17b7cbed..d4ffdf655 100644
--- a/src/graph/bellman_ford.md
+++ b/src/graph/bellman_ford.md
@@ -151,7 +151,7 @@ It is easy to see that the Bellman-Ford algorithm can endlessly do the relaxatio
Hence we obtain the **criterion for presence of a cycle of negative weights reachable for source vertex $v$**: after $(n-1)_{th}$ phase, if we run algorithm for one more phase, and it performs at least one more relaxation, then the graph contains a negative weight cycle that is reachable from $v$; otherwise, such a cycle does not exist.
-Moreover, if such a cycle is found, the Bellman-Ford algorithm can be modified so that it retrieves this cycle as a sequence of vertices contained in it. For this, it is sufficient to remember the last vertex $x$ for which there was a relaxation in $n_{th}$ phase. This vertex will either lie in a negative weight cycle, or is reachable from it. To get the vertices that are guaranteed to lie in a negative cycle, starting from the vertex $x$, pass through to the predecessors $n$ times. Hence we will get the vertex $y$, namely the vertex in the cycle earliest reachable from source. We have to go from this vertex, through the predecessors, until we get back to the same vertex $y$ (and it will happen, because relaxation in a negative weight cycle occur in a circular manner).
+Moreover, if such a cycle is found, the Bellman-Ford algorithm can be modified so that it retrieves this cycle as a sequence of vertices contained in it. For this, it is sufficient to remember the last vertex $x$ for which there was a relaxation in $n_{th}$ phase. This vertex will either lie on a negative weight cycle, or is reachable from it. To get the vertices that are guaranteed to lie on a negative cycle, starting from the vertex $x$, pass through to the predecessors $n$ times. In this way, we will get to the vertex $y$, which is guaranteed to lie on a negative cycle. We have to go from this vertex, through the predecessors, until we get back to the same vertex $y$ (and it will happen, because relaxation in a negative weight cycle occur in a circular manner).
### Implementation:
diff --git a/src/graph/breadth-first-search.md b/src/graph/breadth-first-search.md
index 458f417bd..fec09142c 100644
--- a/src/graph/breadth-first-search.md
+++ b/src/graph/breadth-first-search.md
@@ -152,10 +152,10 @@ Let $d_a []$ be the array containing shortest distances obtained from the first
Now for each vertex it is easy to check whether it lies on any shortest path between $a$ and $b$:
the criterion is the condition $d_a [v] + d_b [v] = d_a [b]$.
-* Find the shortest path of even length from a source vertex $s$ to a target vertex $t$ in an unweighted graph:
+* Find the shortest walk of even length from a source vertex $s$ to a target vertex $t$ in an unweighted graph:
For this, we must construct an auxiliary graph, whose vertices are the state $(v, c)$, where $v$ - the current node, $c = 0$ or $c = 1$ - the current parity.
Any edge $(u, v)$ of the original graph in this new column will turn into two edges $((u, 0), (v, 1))$ and $((u, 1), (v, 0))$.
-After that we run a BFS to find the shortest path from the starting vertex $(s, 0)$ to the end vertex $(t, 0)$.
+After that we run a BFS to find the shortest walk from the starting vertex $(s, 0)$ to the end vertex $(t, 0)$.
+**Note**: This item uses the term "_walk_" rather than a "_path_" for a reason, as the vertices may potentially repeat in the found walk in order to make its length even. The problem of finding the shortest _path_ of even length is NP-Complete in directed graphs, and [solvable in linear time](https://onlinelibrary.wiley.com/doi/abs/10.1002/net.3230140403) in undirected graphs, but with a much more involved approach. ## Practice Problems diff --git a/src/graph/dinic.md b/src/graph/dinic.md index d1945d893..2947e05b2 100644 --- a/src/graph/dinic.md +++ b/src/graph/dinic.md @@ -106,7 +106,7 @@ struct Dinic { int v = q.front(); q.pop(); for (int id : adj[v]) { - if (edges[id].cap - edges[id].flow < 1) + if (edges[id].cap == edges[id].flow) continue; if (level[edges[id].u] != -1) continue; @@ -125,7 +125,7 @@ struct Dinic { for (int& cid = ptr[v]; cid < (int)adj[v].size(); cid++) { int id = adj[v][cid]; int u = edges[id].u; - if (level[v] + 1 != level[u] || edges[id].cap - edges[id].flow < 1) + if (level[v] + 1 != level[u]) continue; long long tr = dfs(u, min(pushed, edges[id].cap - edges[id].flow)); if (tr == 0) @@ -154,3 +154,7 @@ struct Dinic { } }; ``` + +## Practice Problems + +* [SPOJ: FASTFLOW](https://www.spoj.com/problems/FASTFLOW/) \ No newline at end of file diff --git a/src/graph/edge_vertex_connectivity.md b/src/graph/edge_vertex_connectivity.md index 085e50470..2a875cb02 100644 --- a/src/graph/edge_vertex_connectivity.md +++ b/src/graph/edge_vertex_connectivity.md @@ -39,7 +39,7 @@ It is clear, that the vertex connectivity of a graph is equal to the minimal siz ### The Whitney inequalities -The **Whitney inequalities** (1932) gives a relation between the edge connectivity $\lambda$, the vertex connectivity $\kappa$ and the smallest degree of the vertices $\delta$: +The **Whitney inequalities** (1932) gives a relation between the edge connectivity $\lambda$, the vertex connectivity $\kappa$, and the minimum degree of any vertex in the graph $\delta$: $$\kappa \le \lambda \le \delta$$ @@ -77,7 +77,7 @@ Especially the algorithm will run pretty fast for random graphs. ### Special algorithm for edge connectivity -The task of finding the edge connectivity if equal to the task of finding the **global minimum cut**. +The task of finding the edge connectivity is equal to the task of finding the **global minimum cut**. Special algorithms have been developed for this task. One of them is the Stoer-Wagner algorithm, which works in $O(V^3)$ or $O(V E)$ time. diff --git a/src/graph/edmonds_karp.md b/src/graph/edmonds_karp.md index fa4ec25bf..bab54772f 100644 --- a/src/graph/edmonds_karp.md +++ b/src/graph/edmonds_karp.md @@ -43,7 +43,9 @@ The source $s$ is origin of all the water, and the water can only drain in the s The following image shows a flow network. The first value of each edge represents the flow, which is initially 0, and the second value represents the capacity. -
+ 
+
The value of the flow of a network is the sum of all the flows that get produced in the source $s$, or equivalently to the sum of all the flows that are consumed by the sink $t$.
A **maximal flow** is a flow with the maximal possible value.
@@ -53,7 +55,9 @@ In the visualization with water pipes, the problem can be formulated in the foll
how much water can we push through the pipes from the source to the sink?
The following image shows the maximal flow in the flow network.
-
+
+ 
+
## Ford-Fulkerson method
@@ -79,19 +83,30 @@ we update $f((u, v)) ~\text{+=}~ C$ and $f((v, u)) ~\text{-=}~ C$ for every edge
Here is an example to demonstrate the method.
We use the same flow network as above.
Initially we start with a flow of 0.
-
+
+
+
We can find the path $s - A - B - t$ with the residual capacities 7, 5, and 8.
Their minimum is 5, therefore we can increase the flow along this path by 5.
This gives a flow of 5 for the network.
-
+
+ 
+ 
+
Again we look for an augmenting path, this time we find $s - D - A - C - t$ with the residual capacities 4, 3, 3, and 5.
Therefore we can increase the flow by 3 and we get a flow of 8 for the network.
-
+
+
+ 
+ 
+
This time we find the path $s - D - C - B - t$ with the residual capacities 1, 2, 3, and 3, and hence, we increase the flow by 1.
-
+
+
+ 
+ 
+
This time we find the augmenting path $s - A - D - C - t$ with the residual capacities 2, 3, 1, and 2.
We can increase the flow by 1.
@@ -101,7 +116,10 @@ In the original flow network, we are not allowed to send any flow from $A$ to $D
But because we already have a flow of 3 from $D$ to $A$, this is possible.
The intuition of it is the following:
Instead of sending a flow of 3 from $D$ to $A$, we only send 2 and compensate this by sending an additional flow of 1 from $s$ to $A$, which allows us to send an additional flow of 1 along the path $D - C - t$.
-
+
+
+ 
+
+
Now, it is impossible to find an augmenting path between $s$ and $t$, therefore this flow of $10$ is the maximal possible.
We have found the maximal flow.
@@ -184,7 +202,7 @@ int maxflow(int s, int t) {
## Integral flow theorem ## { #integral-theorem}
-The theorem simply says, that if every capacity in the network is an integer, then the flow in each edge will be an integer in the maximal flow.
+The theorem says, that if every capacity in the network is an integer, then the size of the maximum flow is an integer, and there is a maximum flow such that the flow in each edge is an integer as well. In particular, Ford-Fulkerson method finds such a flow.
## Max-flow min-cut theorem
@@ -200,7 +218,9 @@ It says that the capacity of the maximum flow has to be equal to the capacity of
In the following image, you can see the minimum cut of the flow network we used earlier.
It shows that the capacity of the cut $\{s, A, D\}$ and $\{B, C, t\}$ is $5 + 3 + 2 = 10$, which is equal to the maximum flow that we found.
Other cuts will have a bigger capacity, like the capacity between $\{s, A\}$ and $\{B, C, D, t\}$ is $4 + 3 + 5 = 12$.
-
+
+
+ 
+
A minimum cut can be found after performing a maximum flow computation using the Ford-Fulkerson method.
One possible minimum cut is the following:
diff --git a/src/graph/euler_path.md b/src/graph/euler_path.md
index f13e943d2..a54906253 100644
--- a/src/graph/euler_path.md
+++ b/src/graph/euler_path.md
@@ -72,7 +72,7 @@ Finally, the program takes into account that there can be isolated vertices in t
Notice that we use an adjacency matrix in this problem.
Also this implementation handles finding the next with brute-force, which requires to iterate over the complete row in the matrix over and over.
A better way would be to store the graph as an adjacency list, and remove edges in $O(1)$ and mark the reversed edges in separate list.
-This way we can archive a $O(N)$ algorithm.
+This way we can achieve an $O(N)$ algorithm.
```cpp
int main() {
diff --git a/src/graph/finding-negative-cycle-in-graph.md b/src/graph/finding-negative-cycle-in-graph.md
index 63d5c464f..a9b87c7f9 100644
--- a/src/graph/finding-negative-cycle-in-graph.md
+++ b/src/graph/finding-negative-cycle-in-graph.md
@@ -30,16 +30,16 @@ Do $N$ iterations of Bellman-Ford algorithm. If there were no changes on the las
struct Edge {
int a, b, cost;
};
-
-int n, m;
+
+int n;
vector
+
+ 
+
## Sample problems
@@ -183,3 +185,8 @@ int query(int a, int b) {
## Practice problems
- [SPOJ - QTREE - Query on a tree](https://www.spoj.com/problems/QTREE/)
+- [CSES - Path Queries II](https://cses.fi/problemset/task/2134)
+- [Codeforces - Subway Lines](https://codeforces.com/gym/101908/problem/L)
+- [Codeforces - Tree Queries](https://codeforces.com/contest/1254/problem/D)
+- [Codeforces - Tree or not Tree](https://codeforces.com/contest/117/problem/E)
+- [Codeforces - The Tree](https://codeforces.com/contest/1017/problem/G)
diff --git a/src/graph/lca.md b/src/graph/lca.md
index db36c18a0..f577d4b2f 100644
--- a/src/graph/lca.md
+++ b/src/graph/lca.md
@@ -30,7 +30,9 @@ So the $\text{LCA}(v_1, v_2)$ can be uniquely determined by finding the vertex w
Let's illustrate this idea.
Consider the following graph and the Euler tour with the corresponding heights:
-
+
+ 
+
$$\begin{array}{|l|c|c|c|c|c|c|c|c|c|c|c|c|c|}
\hline
diff --git a/src/graph/lca_farachcoltonbender.md b/src/graph/lca_farachcoltonbender.md
index f67365511..506509359 100644
--- a/src/graph/lca_farachcoltonbender.md
+++ b/src/graph/lca_farachcoltonbender.md
@@ -22,7 +22,9 @@ The LCA of two nodes $u$ and $v$ is the node between the occurrences of $u$ and
In the following picture you can see a possible Euler-Tour of a graph and in the list below you can see the visited nodes and their heights.
-
+
+
+
$$\begin{array}{|l|c|c|c|c|c|c|c|c|c|c|c|c|c|}
\hline
diff --git a/src/graph/mst_prim.md b/src/graph/mst_prim.md
index d8c3789db..8815a2630 100644
--- a/src/graph/mst_prim.md
+++ b/src/graph/mst_prim.md
@@ -13,7 +13,10 @@ The spanning tree with the least weight is called a minimum spanning tree.
In the left image you can see a weighted undirected graph, and in the right image you can see the corresponding minimum spanning tree.
-
+
+ 
+ 
+
It is easy to see that any spanning tree will necessarily contain $n-1$ edges.
@@ -144,7 +147,7 @@ void prim() {
```
The adjacency matrix `adj[][]` of size $n \times n$ stores the weights of the edges, and it uses the weight `INF` if there doesn't exist an edge between two vertices.
-The algorithm uses two arrays: the flag `selected[]`, which indicates which vertices we already have selected, and the array `min_e[]` which stores the edge with minimal weight to an selected vertex for each not-yet-selected vertex (it stores the weight and the end vertex).
+The algorithm uses two arrays: the flag `selected[]`, which indicates which vertices we already have selected, and the array `min_e[]` which stores the edge with minimal weight to a selected vertex for each not-yet-selected vertex (it stores the weight and the end vertex).
The algorithm does $n$ steps, in each iteration the vertex with the smallest edge weight is selected, and the `min_e[]` of all other vertices gets updated.
### Sparse graphs: $O(m \log n)$
diff --git a/src/graph/rmq_linear.md b/src/graph/rmq_linear.md
index 9ce17f341..ab0ae216a 100644
--- a/src/graph/rmq_linear.md
+++ b/src/graph/rmq_linear.md
@@ -24,7 +24,9 @@ The array `A` will be partitioned into 3 parts: the prefix of the array up to th
The root of the tree will be a node corresponding to the minimum element of the array `A`, the left subtree will be the Cartesian tree of the prefix, and the right subtree will be a Cartesian tree of the suffix.
In the following image you can see one array of length 10 and the corresponding Cartesian tree.
-
+
+
+ 
+
The range minimum query `[l, r]` is equivalent to the lowest common ancestor query `[l', r']`, where `l'` is the node corresponding to the element `A[l]` and `r'` the node corresponding to the element `A[r]`.
Indeed the node corresponding to the smallest element in the range has to be an ancestor of all nodes in the range, therefor also from `l'` and `r'`.
@@ -33,7 +35,9 @@ And is also has to be the lowest ancestor, because otherwise `l'` and `r'` would
In the following image you can see the LCA queries for the RMQ queries `[1, 3]` and `[5, 9]`.
In the first query the LCA of the nodes `A[1]` and `A[3]` is the node corresponding to `A[2]` which has the value 2, and in the second query the LCA of `A[5]` and `A[9]` is the node corresponding to `A[8]` which has the value 3.
-
+
+ 
+
Such a tree can be built in $O(N)$ time and the Farach-Colton and Benders algorithm can preprocess the tree in $O(N)$ and find the LCA in $O(1)$.
diff --git a/src/graph/second_best_mst.md b/src/graph/second_best_mst.md
index 5e9c82246..3a68ee34a 100644
--- a/src/graph/second_best_mst.md
+++ b/src/graph/second_best_mst.md
@@ -53,10 +53,13 @@ The final time complexity of this approach is $O(E \log V)$.
For example:
-
++
+ 
+ 
+
*In the image left is the MST and right is the second best MST.* - +
In the given graph suppose we root the MST at the blue vertex on the top, and then run our algorithm by start picking the edges not in MST.
diff --git a/src/graph/strong-orientation.md b/src/graph/strong-orientation.md
index 50397b287..69a7b37d9 100644
--- a/src/graph/strong-orientation.md
+++ b/src/graph/strong-orientation.md
@@ -78,7 +78,7 @@ void find_bridges(int v) {
bridge_cnt++;
}
} else {
- low[v] = min(low[v], low[nv]);
+ low[v] = min(low[v], tin[nv]);
}
}
}
diff --git a/src/graph/strongly-connected-components-tikzpicture/.gitignore b/src/graph/strongly-connected-components-tikzpicture/.gitignore
new file mode 100644
index 000000000..8164e021b
--- /dev/null
+++ b/src/graph/strongly-connected-components-tikzpicture/.gitignore
@@ -0,0 +1,3 @@
+*.log
+*.aux
+*.pdf
diff --git a/src/graph/strongly-connected-components-tikzpicture/cond_graph.svg b/src/graph/strongly-connected-components-tikzpicture/cond_graph.svg
new file mode 100644
index 000000000..507c1a071
--- /dev/null
+++ b/src/graph/strongly-connected-components-tikzpicture/cond_graph.svg
@@ -0,0 +1,138 @@
+
+
diff --git a/src/graph/strongly-connected-components-tikzpicture/cond_graph.tex b/src/graph/strongly-connected-components-tikzpicture/cond_graph.tex
new file mode 100644
index 000000000..3a62e5248
--- /dev/null
+++ b/src/graph/strongly-connected-components-tikzpicture/cond_graph.tex
@@ -0,0 +1,22 @@
+\documentclass[tikz]{standalone}
+\usepackage{xcolor}
+\usetikzlibrary{arrows,positioning,quotes,backgrounds,arrows.meta,bending,positioning,shapes,shapes.geometric}
+\begin{document}
+\begin{tikzpicture}
+ [scale=2.5,very thick,every node/.style={draw,inner sep=0.18cm,outer sep=1.5mm}, every path/.style={->}]
+
+ %\draw[help lines] (-1,-2) grid (7,2);
+ \node[rectangle,green,fill=green!20] (0) at (0,0) {\color{black}\textbf{\{0,7\}}};
+ \node[rectangle,red,fill=red!20] (1) at (1,0.5) {\color{black}\textbf{\{1,2,3,5,6\}}};
+ \node[rectangle,blue,fill=blue!20] (4) at (2,0) {\color{black}\textbf{\{4,9\}}};
+ \node[rectangle,yellow,fill=yellow!20] (8) at (1,-0.3) {\color{black}\textbf{\{8\}}};
+
+ \path (0) edge (1);
+ \path (0) edge (8);
+ \path (1) edge (4);
+ \path (8) edge (1);
+ \path (8) edge (4);
+
+\end{tikzpicture}
+
+\end{document}
diff --git a/src/graph/strongly-connected-components-tikzpicture/graph.svg b/src/graph/strongly-connected-components-tikzpicture/graph.svg
new file mode 100644
index 000000000..6dc60d3de
--- /dev/null
+++ b/src/graph/strongly-connected-components-tikzpicture/graph.svg
@@ -0,0 +1,166 @@
+
+
diff --git a/src/graph/strongly-connected-components-tikzpicture/graph.tex b/src/graph/strongly-connected-components-tikzpicture/graph.tex
new file mode 100644
index 000000000..c33dccec6
--- /dev/null
+++ b/src/graph/strongly-connected-components-tikzpicture/graph.tex
@@ -0,0 +1,50 @@
+\documentclass[tikz]{standalone}
+\usepackage{xcolor}
+\usetikzlibrary{arrows,positioning,quotes,backgrounds,arrows.meta,bending,positioning,shapes,shapes.geometric}
+\begin{document}
+\pgfdeclarelayer{background}
+\pgfsetlayers{background,main}
+\begin{tikzpicture}
+ [scale=1.3,very thick,every circle node/.style={draw,inner sep=0.18cm,outer sep=1.1mm,fill=brown!30}, every path/.style={->}]
+
+ %\draw[help lines] (-1,-2) grid (7,2);
+ \node[circle] (0) at (0,0) {\textbf0};
+ \node[circle] (1) at (1,1) {\textbf1};
+ \node[circle] (2) at (3,1) {\textbf2};
+ \node[circle] (3) at (5,1) {\textbf3};
+ \node[circle] (4) at (6,0) {\textbf4};
+ \node[circle] (5) at (4,0) {\textbf5};
+ \node[circle] (6) at (2,0) {\textbf6};
+ \node[circle] (7) at (1,-1) {\textbf7};
+ \node[circle] (8) at (3,-1) {\textbf8};
+ \node[circle] (9) at (5,-1) {\textbf9};
+
+ \path (0) edge (1);
+ \path (0) edge[bend left=20] (7);
+ \path (1) edge[loop below] (1);
+ \path (1) edge[bend left=20] (2);
+ \path (2) edge[bend left=20] (1);
+ \path (2) edge (5);
+ \path (3) edge (2);
+ \path (3) edge (4);
+ \path (4) edge[bend left=20] (9);
+ \path (5) edge (3);
+ \path (5) edge (6);
+ \path (5) edge (9);
+ \path (6) edge (2);
+ \path (7) edge[bend left=20] (0);
+ \path (7) edge (6);
+ \path (7) edge (8);
+ \path (8) edge (6);
+ \path (8) edge (9);
+ \path (9) edge[bend left=20] (4);
+
+ \begin{pgfonlayer}{background}
+ \draw[thick, red, fill=red!20!white] plot [smooth cycle,tension=0.65] coordinates{(0.65,1.3)(4.7,1.52)(5.4,0.7)(4.25,-.4)(3,-.33)(1.5,-.4)};
+ \draw[thick, green, fill=green!20!white] plot [smooth cycle,tension=0.7] coordinates{(0.2,0.4)(1.5,-0.9)(.9,-1.5)(-.45,-.1)};
+ \draw[thick, blue, fill=blue!20!white] plot [smooth cycle,tension=0.7] coordinates{(5.8,0.5)(4.45,-0.8)(5.1,-1.5)(6.6,-.1)};
+ \draw[thick, yellow, fill=yellow!20!white] plot [smooth cycle,tension=0.9] coordinates{(3,-0.5)(3.6,-1)(3,-1.5)(2.4,-1)};
+ \end{pgfonlayer}
+\end{tikzpicture}
+
+\end{document}
diff --git a/src/graph/strongly-connected-components-tikzpicture/info.txt b/src/graph/strongly-connected-components-tikzpicture/info.txt
new file mode 100644
index 000000000..8165f78ac
--- /dev/null
+++ b/src/graph/strongly-connected-components-tikzpicture/info.txt
@@ -0,0 +1,5 @@
+These are the pictures (graphs) used in the article about Strongly Connected Components and the Condensation graph.
+
+Compile the .tex file with pdflatex, and then use a command line tool like pdf2svg to convert the compiled pdf into an svg file. We want svg because it is scalable, i.e. still looks good when the user zooms in far.
+
+This svg can than be directly included in the markdown.
diff --git a/src/graph/strongly-connected-components.md b/src/graph/strongly-connected-components.md
index a09b36464..5fd7a525b 100644
--- a/src/graph/strongly-connected-components.md
+++ b/src/graph/strongly-connected-components.md
@@ -4,151 +4,143 @@ tags:
e_maxx_link: strong_connected_components
---
-# Finding strongly connected components / Building condensation graph
+# Strongly connected components and the condensation graph
## Definitions
-You are given a directed graph $G$ with vertices $V$ and edges $E$. It is possible that there are loops and multiple edges. Let's denote $n$ as number of vertices and $m$ as number of edges in $G$.
+Let $G=(V,E)$ be a directed graph with vertices $V$ and edges $E \subseteq V \times V$. We denote with $n=|V|$ the number of vertices and with $m=|E|$ the number of edges in $G$. It is easy to extend all definitions in this article to multigraphs, but we will not focus on that.
-**Strongly connected component** is a maximal subset of vertices $C$ such that any two vertices of this subset are reachable from each other, i.e. for any $u, v \in C$:
+A subset of vertices $C \subseteq V$ is called a **strongly connected component** if the following conditions hold:
-$$u \mapsto v, v \mapsto u$$
+- for all $u,v\in C$, if $u \neq v$ there exists a path from $u$ to $v$ and a path from $v$ to $u$, and
+- $C$ is maximal, in the sense that no vertex can be added without violating the above condition.
-where $\mapsto$ means reachability, i.e. existence of the path from first vertex to the second.
+We denote with $\text{SCC}(G)$ the set of strongly connected components of $G$. These strongly connected components do not intersect with each other, and cover all vertices in the graph. Thus, the set $\text{SCC}(G)$ is a partition of $V$.
-It is obvious, that strongly connected components do not intersect each other, i.e. this is a partition of all graph vertices. Thus we can give a definition of condensation graph $G^{SCC}$ as a graph containing every strongly connected component as one vertex. Each vertex of the condensation graph corresponds to the strongly connected component of graph $G$. There is an oriented edge between two vertices $C_i$ and $C_j$ of the condensation graph if and only if there are two vertices $u \in C_i, v \in C_j$ such that there is an edge in initial graph, i.e. $(u, v) \in E$.
+Consider this graph $G_\text{example}$, in which the strongly connected components are highlighted:
-The most important property of the condensation graph is that it is **acyclic**. Indeed, suppose that there is an edge between $C$ and $C'$, let's prove that there is no edge from $C'$ to $C$. Suppose that $C' \mapsto C$. Then there are two vertices $u' \in C$ and $v' \in C'$ such that $v' \mapsto u'$. But since $u$ and $u'$ are in the same strongly connected component then there is a path between them; the same for $v$ and $v'$. As a result, if we join these paths we have that $v \mapsto u$ and at the same time $u \mapsto v$. Therefore $u$ and $v$ should be at the same strongly connected component, so this is contradiction. This completes the proof.
+
+
+ *In the image left is the MST and right is the second best MST.* - +
+ 
+ 
+
Topological order can be **non-unique** (for example, if there exist three vertices $a$, $b$, $c$ for which there exist paths from $a$ to $b$ and from $a$ to $c$ but not paths from $b$ to $c$ or from $c$ to $b$).
The example graph also has multiple topological orders, a second topological order is the following:
-
+
+
+ 
+
A Topological order may **not exist** at all.
It only exists, if the directed graph contains no cycles.
-Otherwise because there is a contradiction: if there is a cycle containing the vertices $a$ and $b$, then $a$ needs to have a smaller index than $b$ (since you can reach $b$ from $a$) and also a bigger one (as you can reach $a$ from $b$).
+Otherwise, there is a contradiction: if there is a cycle containing the vertices $a$ and $b$, then $a$ needs to have a smaller index than $b$ (since you can reach $b$ from $a$) and also a bigger one (as you can reach $a$ from $b$).
The algorithm described in this article also shows by construction, that every acyclic directed graph contains at least one topological order.
-A common problem in which topological sorting occurs is the following. There are $n$ variables with unknown values. For some variables we know that one of them is less than the other. You have to check whether these constraints are contradictory, and if not, output the variables in ascending order (if several answers are possible, output any of them). It is easy to notice that this is exactly the problem of finding topological order of a graph with $n$ vertices.
+A common problem in which topological sorting occurs is the following. There are $n$ variables with unknown values. For some variables, we know that one of them is less than the other. You have to check whether these constraints are contradictory, and if not, output the variables in ascending order (if several answers are possible, output any of them). It is easy to notice that this is exactly the problem of finding the topological order of a graph with $n$ vertices.
## The Algorithm
-To solve this problem we will use [depth-first search](depth-first-search.md).
+To solve this problem, we will use [depth-first search](depth-first-search.md).
Let's assume that the graph is acyclic. What does the depth-first search do?
@@ -65,8 +65,9 @@ vector
+
++A visual representation of simulated annealing, searching for the maxima of this function with multiple local maxima. +
+
+ 
+
## Proofs
@@ -181,7 +183,7 @@ $$
\frac{p_{k+1}}{q_{k+1}} = \frac{p_{k-1} + a_k p_k}{q_{k-1} + a_k q_k},
$$
-where $a_k$ is a positive integer number. If you're familiar with [continued fractions](), you would recognize that the sequence $\frac{p_i}{q_i}$ is the sequence of the convergent fractions of $\frac{p}{q}$ and the sequence $[a_1; a_2, \dots, a_{n}, 1]$ represents the continued fraction of $\frac{p}{q}$.
+where $a_k$ is a positive integer number. If you're familiar with [continued fractions](../algebra/continued-fractions.md), you would recognize that the sequence $\frac{p_i}{q_i}$ is the sequence of the convergent fractions of $\frac{p}{q}$ and the sequence $[a_1; a_2, \dots, a_{n}, 1]$ represents the continued fraction of $\frac{p}{q}$.
This allows to find the run-length encoding of the path to $\frac{p}{q}$ in the manner which follows the algorithm for computing continued fraction representation of the fraction $\frac{p}{q}$:
diff --git a/src/others/tortoise_and_hare.md b/src/others/tortoise_and_hare.md
index 385ca69f4..783185542 100644
--- a/src/others/tortoise_and_hare.md
+++ b/src/others/tortoise_and_hare.md
@@ -7,7 +7,9 @@ tags:
Given a linked list where the starting point of that linked list is denoted by **head**, and there may or may not be a cycle present. For instance:
-
+
+ 
+
Here we need to find out the point **C**, i.e the starting point of the cycle.
@@ -27,7 +29,9 @@ So, it involved two steps:
6. If they point to any same node at any point of their journey, it would indicate that the cycle indeed exists in the linked list.
7. If we get null, it would indicate that the linked list has no cycle.
-
+
+ 
+
Now, that we have figured out that there is a cycle present in the linked list, for the next step we need to find out the starting point of cycle, i.e., **C**.
### Step 2: Starting point of the cycle
@@ -81,7 +85,9 @@ When the slow pointer has moved $k \cdot L$ steps, and the fast pointer has cove
Lets try to calculate the distance covered by both of the pointers till they point they met within the cycle.
-
+
+ 
+
$slowDist = a + xL + b$ , $x\ge0$
@@ -110,5 +116,6 @@ And since we let the slow pointer start at the start of the linked list, after $
# Problems:
- [Linked List Cycle (EASY)](https://leetcode.com/problems/linked-list-cycle/)
+- [Happy Number (Easy)](https://leetcode.com/problems/happy-number/)
- [Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/)
diff --git a/src/sequences/k-th.md b/src/sequences/k-th.md
index f58db037a..0f588c5cb 100644
--- a/src/sequences/k-th.md
+++ b/src/sequences/k-th.md
@@ -68,9 +68,9 @@ T order_statistics (std::vector
+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: