Copyright © 2014 - 2022 by https://github.com/cp-algorithms +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://polyfill.io/v3/polyfill.min.js?features=es6 + - https://cdnjs.cloudflare.com/polyfill/v3/polyfill.min.js?features=es6 - https://unpkg.com/mathjax@3/es5/tex-mml-chtml.js extra_css: - stylesheets/extra.css @@ -56,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: @@ -73,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/bit-manipulation.md b/src/algebra/bit-manipulation.md index 0a3b3434e..f29810323 100644 --- a/src/algebra/bit-manipulation.md +++ b/src/algebra/bit-manipulation.md @@ -152,7 +152,7 @@ bool isPowerOfTwo(unsigned int n) { } ``` -### Clear the most-right set bit +### Clear the right-most set bit The expression $n ~\&~ (n-1)$ can be used to turn off the rightmost set bit of a number $n$. This works because the expression $n-1$ flips all bits after the rightmost set bit of $n$, including the rightmost set bit. @@ -186,6 +186,44 @@ int countSetBits(int n) } ``` +### Count set bits upto $n$ +To count the number of set bits of all numbers upto the number $n$ (inclusive), we can run the Brian Kernighan's algorithm on all numbers upto $n$. But this will result in a "Time Limit Exceeded" in contest submissions. + +We can use the fact that for numbers upto $2^x$ (i.e. from $1$ to $2^x - 1$) there are $x \cdot 2^{x-1}$ set bits. This can be visualised as follows. +``` +0 -> 0 0 0 0 +1 -> 0 0 0 1 +2 -> 0 0 1 0 +3 -> 0 0 1 1 +4 -> 0 1 0 0 +5 -> 0 1 0 1 +6 -> 0 1 1 0 +7 -> 0 1 1 1 +8 -> 1 0 0 0 +``` + +We can see that the all the columns except the leftmost have $4$ (i.e. $2^2$) set bits each, i.e. upto the number $2^3 - 1$, the number of set bits is $3 \cdot 2^{3-1}$. + +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 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$. + +```cpp +int countSetBits(int n) { + int count = 0; + while (n > 0) { + int x = std::bit_width(n) - 1; + count += x << (x - 1); + n -= 1 << x; + count += n + 1; + } + return count; +} +``` + ### Additional tricks - $n ~\&~ (n + 1)$ clears all trailing ones: $0011~0111_2 \rightarrow 0011~0000_2$. diff --git a/src/algebra/euclid-algorithm.md b/src/algebra/euclid-algorithm.md index 18638a74c..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 @@ -126,3 +126,4 @@ E.g. C++17 has such a function `std::gcd` in the `numeric` header. ## Practice Problems - [CSAcademy - Greatest Common Divisor](https://csacademy.com/contest/archive/task/gcd/) +- [Codeforces 1916B - Two Divisors](https://codeforces.com/contest/1916/problem/B) 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 c7527feae..14715605f 100644 --- a/src/algebra/factorization.md +++ b/src/algebra/factorization.md @@ -5,22 +5,22 @@ tags: # Integer factorization -In this article we list several algorithms for factorizing integers, each of them can be both fast and also slow (some slower than others) depending on their input. +In this article we list several algorithms for the factorization of integers, each of which can be either fast or varying levels of slow depending on their input. -Notice, if the number that you want to factorize is actually a prime number, most of the algorithms, especially Fermat's factorization algorithm, Pollard's p-1, Pollard's rho algorithm will run very slow. -So it makes sense to perform a probabilistic (or a fast deterministic) [primality test](primality_tests.md) before trying to factorize the number. +Notice, if the number that you want to factorize is actually a prime number, most of the algorithms will run very slowly. This is especially true for Fermat's, Pollard's p-1 and Pollard's rho factorization algorithms. +Therefore, it makes the most sense to perform a probabilistic (or a fast deterministic) [primality test](primality_tests.md) before trying to factorize the number. ## Trial division This is the most basic algorithm to find a prime factorization. We divide by each possible divisor $d$. -We can notice, that it is impossible that all prime factors of a composite number $n$ are bigger than $\sqrt{n}$. +It can be observed that it is impossible for all prime factors of a composite number $n$ to be bigger than $\sqrt{n}$. Therefore, we only need to test the divisors $2 \le d \le \sqrt{n}$, which gives us the prime factorization in $O(\sqrt{n})$. (This is [pseudo-polynomial time](https://en.wikipedia.org/wiki/Pseudo-polynomial_time), i.e. polynomial in the value of the input but exponential in the number of bits of the input.) -The smallest divisor has to be a prime number. -We remove the factor from the number, and repeat the process. +The smallest divisor must be a prime number. +We remove the factored number, and continue the process. If we cannot find any divisor in the range $[2; \sqrt{n}]$, then the number itself has to be prime. ```{.cpp file=factorization_trial_division1} @@ -41,10 +41,9 @@ vector
+ 
+
-There is still one big open question.
-We don't know $p$ yet, so how can we argue about the sequence $\{x_i \bmod p\}$?
+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?
It's actually quite easy.
There is a cycle in the sequence $\{x_i \bmod p\}_{i \le j}$ if and only if there are two indices $s, t \le j$ such that $x_s \equiv x_t \bmod p$.
This equation can be rewritten as $x_s - x_t \equiv 0 \bmod p$ which is the same as $p ~|~ \gcd(x_s - x_t, n)$.
Therefore, if we find two indices $s$ and $t$ with $g = \gcd(x_s - x_t, n) > 1$, we have found a cycle and also a factor $g$ of $n$.
-Notice that it is possible that $g = n$.
-In this case we haven't found a proper factor, and we have to repeat the algorithm with different parameter (different starting value $x_0$, different constant $c$ in the polynomial function $f$).
+It is possible that $g = n$.
+In this case we haven't found a proper factor, so we must repeat the algorithm with a different parameter (different starting value $x_0$, different constant $c$ in the polynomial function $f$).
To find the cycle, we can use any common cycle detection algorithm.
### Floyd's cycle-finding algorithm
-This algorithm finds a cycle by using two pointers.
-These pointers move over the sequence at different speeds.
-In each iteration the first pointer advances to the next element, but the second pointer advances two elements.
-It's not hard to see, that if there exists a cycle, the second pointer will make at least one full cycle and then meet the first pointer during the next few cycle loops.
+This algorithm finds a cycle by using two pointers moving over the sequence at differing speeds.
+During each iteration, the first pointer will advance one element over, while the second pointer advances to every other element.
+Using this idea it is easy to observe that if there is a cycle, at some point the second pointer will come around to meet the first one during the loops.
If the cycle length is $\lambda$ and the $\mu$ is the first index at which the cycle starts, then the algorithm will run in $O(\lambda + \mu)$ time.
-This algorithm is also known as the [Tortoise and Hare algorithm](../others/tortoise_and_hare.md), based on the tale in which a tortoise (here a slow pointer) and a hare (here a faster pointer) make a race.
+This algorithm is also known as the [Tortoise and Hare algorithm](../others/tortoise_and_hare.md), based on the tale in which a tortoise (the slow pointer) and a hare (the faster pointer) have a race.
-It is actually possible to determine the parameter $\lambda$ and $\mu$ using this algorithm (also in $O(\lambda + \mu)$ time and $O(1)$ space), but here is just the simplified version for finding the cycle at all.
-The algorithm and returns true as soon as it detects a cycle.
-If the sequence doesn't have a cycle, then the function will never stop.
-However this cannot happen during Pollard's rho algorithm.
+It is actually possible to determine the parameter $\lambda$ and $\mu$ using this algorithm (also in $O(\lambda + \mu)$ time and $O(1)$ space).
+When a cycle is detected, the algorithm will return 'True'.
+If the sequence doesn't have a cycle, then the function will loop endlessly.
+However, using Pollard's Rho Algorithm, this can be prevented.
```text
function floyd(f, x0):
@@ -290,8 +288,8 @@ function floyd(f, x0):
### Implementation
-First here is a implementation using the **Floyd's cycle-finding algorithm**.
-The algorithm runs (usually) in $O(\sqrt[4]{n} \log(n))$ time.
+First, here is an implementation using the **Floyd's cycle-finding algorithm**.
+The algorithm generally runs in $O(\sqrt[4]{n} \log(n))$ time.
```{.cpp file=pollard_rho}
long long mult(long long a, long long b, long long mod) {
@@ -353,16 +351,15 @@ long long mult(long long a, long long b, long long mod) {
Alternatively you can also implement the [Montgomery multiplication](montgomery_multiplication.md).
-As already noticed above: if $n$ is composite and the algorithm returns $n$ as factor, you have to repeat the procedure with different parameter $x_0$ and $c$.
+As stated previously, if $n$ is composite and the algorithm returns $n$ as factor, you have to repeat the procedure with different parameters $x_0$ and $c$.
E.g. the choice $x_0 = c = 1$ will not factor $25 = 5 \cdot 5$.
-The algorithm will just return $25$.
-However the choice $x_0 = 1$, $c = 2$ will factor it.
+The algorithm will return $25$.
+However, the choice $x_0 = 1$, $c = 2$ will factor it.
### Brent's algorithm
-Brent uses a similar algorithm as Floyd.
-It also uses two pointer.
-But instead of advancing the pointers by one and two respectably, we advance them in powers of two.
+Brent implements a similar method to Floyd, using two pointers.
+The difference being that instead of advancing the pointers by one and two places respectively, they are advanced by powers of two.
As soon as $2^i$ is greater than $\lambda$ and $\mu$, we will find the cycle.
```text
@@ -380,12 +377,12 @@ function floyd(f, x0):
return true
```
-Brent's algorithm also runs in linear time, but is usually faster than Floyd's algorithm, since it uses less evaluations of the function $f$.
+Brent's algorithm also runs in linear time, but is generally faster than Floyd's, since it uses less evaluations of the function $f$.
### Implementation
-The straightforward implementation using Brent's algorithms can be speeded up by noticing, that we can omit the terms $x_l - x_k$ if $k < \frac{3 \cdot l}{2}$.
-Also, instead of performing the $\gcd$ computation at every step, we multiply the terms and do it every few steps and backtrack if we overshoot.
+The straightforward implementation of Brent's algorithm can be sped up by omitting the terms $x_l - x_k$ if $k < \frac{3 \cdot l}{2}$.
+In addition, instead of performing the $\gcd$ computation at every step, we multiply the terms and only actually check $\gcd$ every few steps and backtrack if overshot.
```{.cpp file=pollard_rho_brent}
long long brent(long long n, long long x0=2, long long c=1) {
@@ -422,7 +419,7 @@ long long brent(long long n, long long x0=2, long long c=1) {
}
```
-The combination of a trial division for small prime numbers together with Brent's version of Pollard's rho algorithm will make a very powerful factorization algorithm.
+The combination of a trial division for small prime numbers together with Brent's version of Pollard's rho algorithm makes a very powerful factorization algorithm.
## Practice Problems
diff --git a/src/algebra/fft.md b/src/algebra/fft.md
index c77d81a1d..38ed620a5 100644
--- a/src/algebra/fft.md
+++ b/src/algebra/fft.md
@@ -15,8 +15,7 @@ Some researchers attribute the discovery of the FFT to Runge and König in 1924.
But actually Gauss developed such a method already in 1805, but never published it.
Notice, that the FFT algorithm presented here runs in $O(n \log n)$ time, but it doesn't work for multiplying arbitrary big polynomials with arbitrary large coefficients or for multiplying arbitrary big integers.
-It can easily handle polynomials of size $10^5$ with small coefficients, or multiplying two numbers of size $10^6$, but at some point the range and the precision of the used floating point numbers will not no longer be enough to give accurate results.
-That is usually enough for solving competitive programming problems, but there are also more complex variations that can perform arbitrary large polynomial/integer multiplications.
+It can easily handle polynomials of size $10^5$ with small coefficients, or multiplying two numbers of size $10^6$, which is usually enough for solving competitive programming problems. Beyond the scale of multiplying numbers with $10^6$ bits, the range and precision of the floating point numbers used during the computation will not be enough to give accurate final results, though there are more complex variations that can perform arbitrary large polynomial/integer multiplications.
E.g. in 1971 Schönhage and Strasser developed a variation for multiplying arbitrary large numbers that applies the FFT recursively in rings structures running in $O(n \log n \log \log n)$.
And recently (in 2019) Harvey and van der Hoeven published an algorithm that runs in true $O(n \log n)$.
@@ -98,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 1aa88294b..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
@@ -220,3 +226,4 @@ If $a < b$, we need to select smallest possible value of $k$. If $a > b$, we nee
* [Codeforces - Ebony and Ivory](http://codeforces.com/contest/633/problem/A)
* [Codechef - Get AC in one go](https://www.codechef.com/problems/COPR16G)
* [LightOj - Solutions to an equation](http://www.lightoj.com/volume_showproblem.php?problem=1306)
+* [Atcoder - F - S = 1](https://atcoder.jp/contests/abc340/tasks/abc340_f)
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/polynomial.md b/src/algebra/polynomial.md
index afa8e505f..cd0de655f 100644
--- a/src/algebra/polynomial.md
+++ b/src/algebra/polynomial.md
@@ -140,7 +140,7 @@ Polynomial long division is useful because of its many important properties:
Note that long division can't be properly defined for formal power series. Instead, for any $A(x)$ such that $a_0 \neq 0$, it is possible to define an inverse formal power series $A^{-1}(x)$, such that $A(x) A^{-1}(x) = 1$. This fact, in turn, can be used to compute the result of long division for polynomials.
## Basic implementation
-[Here](https://cp-algorithms.github.io/cp-algorithms-aux/cp-algo/algebra/poly.hpp) you can find the basic implementation of polynomial algebra.
+[Here](https://cp-algorithms.github.io/cp-algorithms-aux/cp-algo/math/poly.hpp) you can find the basic implementation of polynomial algebra.
It supports all trivial operations and some other useful methods. The main class is `poly
+
+ 
+
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/bracket_sequences.md b/src/combinatorics/bracket_sequences.md
index ce8aa9542..e24a18cb0 100644
--- a/src/combinatorics/bracket_sequences.md
+++ b/src/combinatorics/bracket_sequences.md
@@ -32,7 +32,7 @@ We iterate over all character of the string, if the current bracket character is
If at any time the variable $\text{depth}$ gets negative, or at the end it is different from $0$, then the string is not a balanced sequence.
Otherwise it is.
-If there are several bracket types involved, then the algorithm needs to be changes.
+If there are several bracket types involved, then the algorithm needs to be changed.
Instead of a counter $\text{depth}$ we create a stack, in which we will store all opening brackets that we meet.
If the current bracket character is an opening one, we put it onto the stack.
If it is a closing one, then we check if the stack is non-empty, and if the top element of the stack is of the same type as the current closing bracket.
@@ -49,7 +49,7 @@ The number of balanced bracket sequences of length $2n$ ($n$ pairs of brackets)
$$\frac{1}{n+1} \binom{2n}{n}$$
-If we allow $k$ types of brackets, then each pair be of any of the $k$ types (independently of the others), thus the number of balanced bracket sequences is:
+If we allow $k$ types of brackets, then each pair can be of any of the $k$ types (independently of the others), thus the number of balanced bracket sequences is:
$$\frac{1}{n+1} \binom{2n}{n} k^n$$
@@ -82,7 +82,7 @@ When we meet an opening brackets, we will decrement $\text{depth}$, and when we
If we are at some point meet an opening bracket, and the balance after processing this symbol is positive, then we have found the rightmost position that we can change.
We change the symbol, compute the number of opening and closing brackets that we have to add to the right side, and arrange them in the lexicographically minimal way.
-If we find do suitable position, then this sequence is already the maximal possible one, and there is no answer.
+If we don't find a suitable position, then this sequence is already the maximal possible one, and there is no answer.
```{.cpp file=next_balanced_brackets_sequence}
bool next_balanced_sequence(string & s) {
@@ -117,7 +117,7 @@ To generate then, we can start with the lexicographically smallest sequence $((\
However, if the length of the sequence is not very long (e.g. $n$ smaller than $12$), then we can also generate all permutations conveniently with the C++ STL function `next_permutation`, and check each one for balanceness.
-Also they can be generate using the ideas we used for counting all sequences with dynamic programming.
+Also they can be generated using the ideas we used for counting all sequences with dynamic programming.
We will discuss the ideas in the next two sections.
## Sequence index
@@ -142,19 +142,19 @@ Thus we can compute this array in $O(n^2)$.
Now let us generate the index for a given sequence.
First let there be only one type of brackets.
-We will us the counter $\text{depth}$ which tells us how nested we currently are, and iterate over the characters of the sequence.
+We will use the counter $\text{depth}$ which tells us how nested we currently are, and iterate over the characters of the sequence.
If the current character $s[i]$ is equal to $($, then we increment $\text{depth}$.
If the current character $s[i]$ is equal to $)$, then we must add $d[2n-i-1][\text{depth}+1]$ to the answer, taking all possible endings starting with a $($ into account (which are lexicographically smaller sequences), and then decrement $\text{depth}$.
New let there be $k$ different bracket types.
-Thus, when we look at the current character $s[i]$ before recomputing $\text{depth}$, we have to go through all bracket types that are smaller than the current character, and try to put this bracket into the current position (obtaining a new balance $\text{ndepth} = \text{depth} \pm 1$), and add the number of ways to finish the sequence (length $2n-i-1$, balance $ndepth$) to the answer:
+Thus, when we look at the current character $s[i]$ before recomputing $\text{depth}$, we have to go through all bracket types that are smaller than the current character, and try to place this bracket into the current position (obtaining a new balance $\text{ndepth} = \text{depth} \pm 1$), and add the number of ways to finish the sequence (length $2n-i-1$, balance $ndepth$) to the answer:
$$d[2n - i - 1][\text{ndepth}] \cdot k^{\frac{2n - i - 1 - ndepth}{2}}$$
This formula can be derived as follows:
First we "forget" that there are multiple bracket types, and just take the answer $d[2n - i - 1][\text{ndepth}]$.
-Now we consider how the answer will change is we have $k$ types of brackets.
+Now we consider how the answer will change if we have $k$ types of brackets.
We have $2n - i - 1$ undefined positions, of which $\text{ndepth}$ are already predetermined because of the opening brackets.
But all the other brackets ($(2n - i - 1 - \text{ndepth})/2$ pairs) can be of any type, therefore we multiply the number by such a power of $k$.
@@ -169,10 +169,9 @@ First, we start with only one bracket type.
We will iterate over the characters in the string we want to generate.
As in the previous problem we store a counter $\text{depth}$, the current nesting depth.
-In each position we have to decide if we use an opening of a closing bracket.
-To have to put an opening bracket character, it $d[2n - i - 1][\text{depth}+1] \ge k$.
-We increment the counter $\text{depth}$, and move on to the next character.
-Otherwise we decrement $k$ by $d[2n - i - 1][\text{depth}+1]$, put a closing bracket and move on.
+At each position, we have to decide whether to place an opening or a closing bracket. To place an opening bracket, $d[2n - i - 1][\text{depth}+1] \ge k$ must be true.
+If so, we increment the counter $\text{depth}$, and move on to the next character.
+Otherwise, we decrement $k$ by $d[2n - i - 1][\text{depth}+1]$, place a closing bracket, and move on.
```{.cpp file=kth_balances_bracket}
string kth_balanced(int n, int k) {
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 7ec990792..ed6767216 100644
--- a/src/combinatorics/inclusion-exclusion.md
+++ b/src/combinatorics/inclusion-exclusion.md
@@ -153,7 +153,7 @@ we want to break a sequence of $20$ units into $6$ groups, which is the same as
$$N_0 = \binom{25}{5}$$
-We will now calculate the number of "bad" solutions with the inclusion-exclusion principle. The "bad" solutions will be those in which one or more $x_i$ are greater than $9$.
+We will now calculate the number of "bad" solutions with the inclusion-exclusion principle. The "bad" solutions will be those in which one or more $x_i$ are greater than or equal to $9$.
Denote by $A_k ~ (k = 1,2\ldots 6)$ the set of solutions where $x_k \ge 9$, and all other $x_i \ge 0 ~ (i \ne k)$ (they may be $\ge 9$ or not). To calculate the size of $A_k$, note that we have essentially the same combinatorial problem that was solved in the two paragraphs above, but now $9$ of the units are excluded from the slots and definitely belong to the first group. Thus:
@@ -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/combinatorics/stars_and_bars.md b/src/combinatorics/stars_and_bars.md
index aa88108c1..a8e5c395f 100644
--- a/src/combinatorics/stars_and_bars.md
+++ b/src/combinatorics/stars_and_bars.md
@@ -77,4 +77,6 @@ See the [Number of upper-bound integer sums](./inclusion-exclusion.md#number-of-
* [Codeforces - Array](https://codeforces.com/contest/57/problem/C)
* [Codeforces - Kyoya and Coloured Balls](https://codeforces.com/problemset/problem/553/A)
-
+* [Codeforces - Colorful Bricks](https://codeforces.com/contest/1081/problem/C)
+* [Codeforces - Two Arrays](https://codeforces.com/problemset/problem/1288/C)
+* [Codeforces - One-Dimensional Puzzle](https://codeforces.com/contest/1931/problem/G)
diff --git a/src/data_structures/disjoint_set_union.md b/src/data_structures/disjoint_set_union.md
index 96c41ab0c..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:
@@ -375,7 +375,7 @@ If we add an edge $(a, b)$ that connects two connected components into one, then
Let's derive a formula, which computes the parity issued to the leader of the set that will get attached to another set.
Let $x$ be the parity of the path length from vertex $a$ up to its leader $A$, and $y$ as the parity of the path length from vertex $b$ up to its leader $B$, and $t$ the desired parity that we have to assign to $B$ after the merge.
-The path contains the of the three parts:
+The path consists of the three parts:
from $B$ to $b$, from $b$ to $a$, which is connected by one edge and therefore has parity $1$, and from $a$ to $A$.
Therefore we receive the formula ($\oplus$ denotes the XOR operation):
diff --git a/src/data_structures/fenwick.md b/src/data_structures/fenwick.md
index b6548d291..439885b83 100644
--- a/src/data_structures/fenwick.md
+++ b/src/data_structures/fenwick.md
@@ -6,44 +6,48 @@ e_maxx_link: fenwick_tree
# Fenwick Tree
-Let, $f$ be some group operation (binary associative function over a set with identity element and inverse elements) and $A$ be an array of integers of length $N$.
+Let $f$ be some group operation (a binary associative function over a set with an identity element and inverse elements) and $A$ be an array of integers of length $N$.
+Denote $f$'s infix notation as $*$; that is, $f(x,y) = x*y$ for arbitrary integers $x,y$.
+(Since this is associative, we will omit parentheses for order of application of $f$ when using infix notation.)
-Fenwick tree is a data structure which:
+The Fenwick tree is a data structure which:
-* calculates the value of function $f$ in the given range $[l, r]$ (i.e. $f(A_l, A_{l+1}, \dots, A_r)$) in $O(\log N)$ time;
-* updates the value of an element of $A$ in $O(\log N)$ time;
-* requires $O(N)$ memory, or in other words, exactly the same memory required for $A$;
-* is easy to use and code, especially, in the case of multidimensional arrays.
+* calculates the value of function $f$ in the given range $[l, r]$ (i.e. $A_l * A_{l+1} * \dots * A_r$) in $O(\log N)$ time
+* updates the value of an element of $A$ in $O(\log N)$ time
+* requires $O(N)$ memory (the same amount required for $A$)
+* is easy to use and code, especially in the case of multidimensional arrays
-The most common application of Fenwick tree is _calculating the sum of a range_ (i.e. using addition over the set of integers $\mathbb{Z}$: $f(A_1, A_2, \dots, A_k) = A_1 + A_2 + \dots + A_k$).
+The most common application of a Fenwick tree is _calculating the sum of a range_.
+For example, using addition over the set of integers as the group operation, i.e. $f(x,y) = x + y$: the binary operation, $*$, is $+$ in this case, so $A_l * A_{l+1} * \dots * A_r = A_l + A_{l+1} + \dots + A_{r}$.
-Fenwick tree is also called **Binary Indexed Tree**, or just **BIT** abbreviated.
-
-Fenwick tree was first described in a paper titled "A new data structure for cumulative frequency tables" (Peter M. Fenwick, 1994).
+The Fenwick tree is also called a **Binary Indexed Tree** (BIT).
+It was first described in a paper titled "A new data structure for cumulative frequency tables" (Peter M. Fenwick, 1994).
## Description
### Overview
-For the sake of simplicity, we will assume that function $f$ is just a *sum function*.
+For the sake of simplicity, we will assume that function $f$ is defined as $f(x,y) = x + y$ over the integers.
-Given an array of integers $A[0 \dots N-1]$.
-A Fenwick tree is just an array $T[0 \dots N-1]$, where each of its elements is equal to the sum of elements of $A$ in some range $[g(i), i]$:
+Suppose we are given an array of integers, $A[0 \dots N-1]$.
+(Note that we are using zero-based indexing.)
+A Fenwick tree is just an array, $T[0 \dots N-1]$, where each element is equal to the sum of elements of $A$ in some range, $[g(i), i]$:
-$$T_i = \sum_{j = g(i)}^{i}{A_j},$$
+$$T_i = \sum_{j = g(i)}^{i}{A_j}$$
where $g$ is some function that satisfies $0 \le g(i) \le i$.
-We will define the function in the next few paragraphs.
+We will define $g$ in the next few paragraphs.
-The data structure is called tree, because there is a nice representation of the data structure as tree, although we don't need to model an actual tree with nodes and edges.
-We will only need to maintain the array $T$ to handle all queries.
+The data structure is called a tree because there is a nice representation of it in the form of a tree, although we don't need to model an actual tree with nodes and edges.
+We only need to maintain the array $T$ to handle all queries.
**Note:** The Fenwick tree presented here uses zero-based indexing.
-Many people will actually use a version of the Fenwick tree that uses one-based indexing.
-Therefore you will also find an alternative implementation using one-based indexing in the implementation section.
+Many people use a version of the Fenwick tree that uses one-based indexing.
+As such, you will also find an alternative implementation which uses one-based indexing in the implementation section.
Both versions are equivalent in terms of time and memory complexity.
-Now we can write some pseudo-code for the two operations mentioned above - get the sum of elements of $A$ in the range $[0, r]$ and update (increase) some element $A_i$:
+Now we can write some pseudo-code for the two operations mentioned above.
+Below, we get the sum of elements of $A$ in the range $[0, r]$ and update (increase) some element $A_i$:
```python
def sum(int r):
@@ -60,20 +64,21 @@ def increase(int i, int delta):
The function `sum` works as follows:
-1. first, it adds the sum of the range $[g(r), r]$ (i.e. $T[r]$) to the `result`
-2. then, it "jumps" to the range $[g(g(r)-1), g(r)-1]$, and adds this range's sum to the `result`
-3. and so on, until it "jumps" from $[0, g(g( \dots g(r)-1 \dots -1)-1)]$ to $[g(-1), -1]$; that is where the `sum` function stops jumping.
+1. First, it adds the sum of the range $[g(r), r]$ (i.e. $T[r]$) to the `result`.
+2. Then, it "jumps" to the range $[g(g(r)-1), g(r)-1]$ and adds this range's sum to the `result`.
+3. This continues until it "jumps" from $[0, g(g( \dots g(r)-1 \dots -1)-1)]$ to $[g(-1), -1]$; this is where the `sum` function stops jumping.
-The function `increase` works with the same analogy, but "jumps" in the direction of increasing indices:
+The function `increase` works with the same analogy, but it "jumps" in the direction of increasing indices:
-1. sums of the ranges $[g(j), j]$ that satisfy the condition $g(j) \le i \le j$ are increased by `delta` , that is `t[j] += delta`. Therefore we updated all elements in $T$ that correspond to ranges in which $A_i$ lies.
+1. The sum for each range of the form $[g(j), j]$ which satisfies the condition $g(j) \le i \le j$ is increased by `delta`; that is, `t[j] += delta`.
+Therefore, it updates all elements in $T$ that correspond to ranges in which $A_i$ lies.
-It is obvious that the complexity of both `sum` and `increase` depend on the function $g$.
-There are lots of ways to choose the function $g$, as long as $0 \le g(i) \le i$ for all $i$.
-For instance the function $g(i) = i$ works, which results just in $T = A$, and therefore summation queries are slow.
-We can also take the function $g(i) = 0$.
-This will correspond to prefix sum arrays, which means that finding the sum of the range $[0, i]$ will only take constant time, but updates are slow.
-The clever part of the Fenwick algorithm is, that there it uses a special definition of the function $g$ that can handle both operations in $O(\log N)$ time.
+The complexity of both `sum` and `increase` depend on the function $g$.
+There are many ways to choose the function $g$ such that $0 \le g(i) \le i$ for all $i$.
+For instance, the function $g(i) = i$ works, which yields $T = A$ (in which case, the summation queries are slow).
+We could also take the function $g(i) = 0$.
+This would correspond to prefix sum arrays (in which case, finding the sum of the range $[0, i]$ will only take constant time; however, updates are slow).
+The clever part of the algorithm for Fenwick trees is how it uses a special definition of the function $g$ which can handle both operations in $O(\log N)$ time.
### Definition of $g(i)$ { data-toc-label='Definition of ' }
@@ -116,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
@@ -380,7 +387,7 @@ int point_query(int idx) {
Note: of course it is also possible to increase a single point $A[i]$ with `range_add(i, i, val)`.
-### 3. Range Updates and Range Queries
+### 3. Range Update and Range Query
To support both range updates and range queries we will use two BITs namely $B_1[]$ and $B_2[]$, initialized with zeros.
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/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 d2d1867f4..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:
@@ -81,14 +81,14 @@ $$\text{work per subproblem} * \text{number of subproblems}$$
Using a binary search tree (map in C++) to save states will technically result in $O(n \log n)$ as each lookup and insertion will take $O(\log n)$ work and with $O(n)$ unique subproblems we have $O(n \log n)$ time.
-This approach is called top-down, as we can call the function with a query value and the calculation starts going from the top (queried value) down to the bottom (base cases of the recursion), and makes shortcuts via memorization on the way.
+This approach is called top-down, as we can call the function with a query value and the calculation starts going from the top (queried value) down to the bottom (base cases of the recursion), and makes shortcuts via memoization on the way.
## 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 programing 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,26 +123,29 @@ 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
-- 0-1 Knapsack
-- Subset Sum
-- Longest Increasing Subsequence
-- Counting all possible paths from top left to bottom right corner of a matrix
-- Longest Common Subsequence
-- Longest Path in a Directed Acyclic Graph (DAG)
-- Coin Change
-- Longest Palindromic Subsequence
-- Rod Cutting
-- Edit Distance
-- Bitmask Dynamic Programming
-- Digit Dynamic Programming
-- Dynamic Programming on Trees
+| 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$? |
+| 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 (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. |
+| Rod Cutting | Given a rod of length $n$ units, Given an integer array cuts where cuts[i] denotes a position you should perform a cut at. The cost of one cut is the length of the rod to be cut. What is the minimum total cost of the cuts. |
+| Edit Distance | The edit distance between two strings is the minimum number of operations required to transform one string into the other. Operations are ["Add", "Remove", "Replace"] |
+
+## Related Topics
+* Bitmask Dynamic Programming
+* Digit Dynamic Programming
+* Dynamic Programming on Trees
Of course, the most important trick is to practice.
@@ -150,4 +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
+* [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
new file mode 100644
index 000000000..9f73d173c
--- /dev/null
+++ b/src/dynamic_programming/knapsack.md
@@ -0,0 +1,184 @@
+---
+tags:
+ - Original
+---
+
+# Knapsack Problem
+Prerequisite knowledge: [Introduction to Dynamic Programming](https://cp-algorithms.com/dynamic_programming/intro-to-dp.html)
+
+## Introduction
+Consider the following example:
+
+### [[USACO07 Dec] Charm Bracelet](https://www.acmicpc.net/problem/6144)
+There are $n$ distinct items and a knapsack of capacity $W$. Each item has 2 attributes, weight ($w_{i}$) and value ($v_{i}$).
+You have to select a subset of items to put into the knapsack such that the total weight does not exceed the capacity $W$ and the total value is maximized.
+
+In the example above, each object has only two possible states (taken or not taken),
+corresponding to binary 0 and 1. Thus, this type of problem is called "0-1 knapsack problem".
+
+## 0-1 Knapsack
+
+### Explanation
+
+In the example above, the input to the problem is the following: the weight of $i^{th}$ item $w_{i}$, the value of $i^{th}$ item $v_{i}$, and the total capacity of the knapsack $W$.
+
+Let $f_{i, j}$ be the dynamic programming state holding the maximum total value the knapsack can carry with capacity $j$, when only the first $i$ items are considered.
+
+Assuming that all states of the first $i-1$ items have been processed, what are the options for the $i^{th}$ item?
+
+- When it is not put into the knapsack, the remaining capacity remains unchanged and total value does not change. Therefore, the maximum value in this case is $f_{i-1, j}$
+- When it is put into the knapsack, the remaining capacity decreases by $w_{i}$ and the total value increases by $v_{i}$,
+so the maximum value in this case is $f_{i-1, j-w_i} + v_i$
+
+From this we can derive the dp transition equation:
+
+$$f_{i, j} = \max(f_{i-1, j}, f_{i-1, j-w_i} + v_i)$$
+
+Further, as $f_{i}$ is only dependent on $f_{i-1}$, we can remove the first dimension. We obtain the transition rule
+
+$$f_j \gets \max(f_j, f_{j-w_i}+v_i)$$
+
+that should be executed in the **decreasing** order of $j$ (so that $f_{j-w_i}$ implicitly corresponds to $f_{i-1,j-w_i}$ and not $f_{i,j-w_i}$).
+
+**It is important to understand this transition rule, because most of the transitions for knapsack problems are derived in a similar way.**
+
+### Implementation
+
+The algorithm described can be implemented in $O(nW)$ as:
+
+```.c++
+for (int i = 1; i <= n; i++)
+ for (int j = W; j >= w[i]; j--)
+ f[j] = max(f[j], f[j - w[i]] + v[i]);
+```
+
+Again, note the order of execution. It should be strictly followed to ensure the following invariant: Right before the pair $(i, j)$ is processed, $f_k$ corresponds to $f_{i,k}$ for $k > j$, but to $f_{i-1,k}$ for $k < j$. This ensures that $f_{j-w_i}$ is taken from the $(i-1)$-th step, rather than from the $i$-th one.
+
+## Complete Knapsack
+
+The complete knapsack model is similar to the 0-1 knapsack, the only difference from the 0-1 knapsack is that an item can be selected an unlimited number of times instead of only once.
+
+We can refer to the idea of 0-1 knapsack to define the state: $f_{i, j}$, the maximum value the knapsack can obtain using the first $i$ items with maximum capacity $j$.
+
+It should be noted that although the state definition is similar to that of a 0-1 knapsack, its transition rule is different from that of a 0-1 knapsack.
+
+### Explanation
+
+The trivial approach is, for the first $i$ items, enumerate how many times each item is to be taken. The time complexity of this is $O(n^2W)$.
+
+This yields the following transition equation:
+
+$$f_{i, j} = \max\limits_{k=0}^{\infty}(f_{i-1, j-k\cdot w_i} + k\cdot v_i)$$
+
+At the same time, it simplifies into a "flat" equation:
+
+$$f_{i, j} = \max(f_{i-1, j},f_{i, j-w_i} + v_i)$$
+
+The reason this works is that $f_{i, j-w_i}$ has already been updated by $f_{i, j-2\cdot w_i}$ and so on.
+
+Similar to the 0-1 knapsack, we can remove the first dimension to optimize the space complexity. This gives us the same transition rule as 0-1 knapsack.
+
+$$f_j \gets \max(f_j, f_{j-w_i}+v_i)$$
+
+### Implementation
+
+The algorithm described can be implemented in $O(nW)$ as:
+
+```.c++
+for (int i = 1; i <= n; i++)
+ for (int j = w[i]; j <= W; j++)
+ f[j] = max(f[j], f[j - w[i]] + v[i]);
+```
+
+Despite having the same transition rule, the code above is incorrect for 0-1 knapsack.
+
+Observing the code carefully, we see that for the currently processed item $i$ and the current state $f_{i,j}$,
+when $j\geqslant w_{i}$, $f_{i,j}$ will be affected by $f_{i,j-w_{i}}$.
+This is equivalent to being able to put item $i$ into the backpack multiple times, which is consistent with the complete knapsack problem and not the 0-1 knapsack problem.
+
+## Multiple Knapsack
+
+Multiple knapsack is also a variant of 0-1 knapsack. The main difference is that there are $k_i$ of each item instead of just $1$.
+
+### Explanation
+
+A very simple idea is: "choose each item $k_i$ times" is equivalent to "$k_i$ of the same item is selected one by one". Thus converting it to a 0-1 knapsack model, which can be described by the transition function:
+
+$$f_{i, j} = \max_{k=0}^{k_i}(f_{i-1,j-k\cdot w_i} + k\cdot v_i)$$
+
+The time complexity of this process is $O(W\sum\limits_{i=1}^{n}k_i)$
+
+### Binary Grouping Optimization
+
+We still consider converting the multiple knapsack model into a 0-1 knapsack model for optimization. The time complexity $O(Wn)$ can not be further optimized with the approach above, so we focus on $O(\sum k_i)$ component.
+
+Let $A_{i, j}$ denote the $j^{th}$ item split from the $i^{th}$ item. In the trivial approach discussed above, $A_{i, j}$ represents the same item for all $j \leq k_i$. The main reason for our low efficiency is that we are doing a lot of repetetive work. For example, consider selecting $\{A_{i, 1},A_{i, 2}\}$, and selecting $\{A_{i, 2}, A_{i, 3}\}$. These two situations are completely equivalent. Thus optimizing the splitting method will greatly reduce the time complexity.
+
+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.
+
+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.
+
+This optimization gives us a time complexity of $O(W\sum\limits_{i=1}^{n}\log k_i)$.
+
+### Implementation
+
+```c++
+index = 0;
+for (int i = 1; i <= n; i++) {
+ int c = 1, p, h, k;
+ cin >> p >> h >> k;
+ while (k > c) {
+ k -= c;
+ list[++index].w = c * p;
+ list[index].v = c * h;
+ c *= 2;
+ }
+ list[++index].w = p * k;
+ list[index].v = h * k;
+}
+```
+
+### Monotone Queue Optimization
+
+In this optimization, we aim to convert the knapsack problem into a [maximum queue](https://cp-algorithms.com/data_structures/stack_queue_modification.html) one.
+
+For convenience of description, let $g_{x, y} = f_{i, x \cdot w_i + y} ,\space g'_{x, y} = f_{i-1, x \cdot w_i + y}$. Then the transition rule can be written as:
+
+$$g_{x, y} = \max_{k=0}^{k_i}(g'_{x-k, y} + v_i \cdot k)$$
+
+Further, let $G_{x, y} = g'_{x, y} - v_i \cdot x$. Then the transition rule can be expressed as:
+
+$$g_{x, y} \gets \max_{k=0}^{k_i}(G_{x-k, y}) + v_i \cdot x$$
+
+This transforms into a classic monotone queue optimization form. $G_{x, y}$ can be calculated in $O(1)$, so for a fixed $y$, we can calculate $g_{x, y}$ in $O(\lfloor \frac{W}{w_i} \rfloor)$ time.
+Therefore, the complexity of finding all $g_{x, y}$ is $O(\lfloor \frac{W}{w_i} \rfloor) \times O(w_i) = O(W)$.
+In this way, the total complexity of the algorithm is reduced to $O(nW)$.
+
+## Mixed Knapsack
+
+The mixed knapsack problem involves a combination of the three problems described above. That is, some items can only be taken once, some can be taken infinitely, and some can be taken atmost $k$ times.
+
+The problem may seem daunting, but as long as you understand the core ideas of the previous knapsack problems and combine them together, you can do it. The pseudo code for the solution is as:
+
+```c++
+for (each item) {
+ if (0-1 knapsack)
+ Apply 0-1 knapsack code;
+ else if (complete knapsack)
+ Apply complete knapsack code;
+ else if (multiple knapsack)
+ Apply multiple knapsack code;
+}
+```
+
+## Practise Problems
+
+- [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 c2d4da2bb..f74061d37 100644
--- a/src/geometry/convex-hull.md
+++ b/src/geometry/convex-hull.md
@@ -47,6 +47,9 @@ of the algorithm, otherwise you wouldn't get the smallest convex hull.
```{.cpp file=graham_scan}
struct pt {
double x, y;
+ bool operator == (pt const& t) const {
+ return x == t.x && y == t.y;
+ }
};
int orientation(pt a, pt b, pt c) {
@@ -86,6 +89,9 @@ 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 77416975b..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:
@@ -162,7 +168,7 @@ pair
+
+ 
+
- $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 ac8b83446..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.
@@ -102,64 +106,81 @@ Below is the implementation of the solution of the 2-SAT problem for the already
In the graph the vertices with indices $2k$ and $2k+1$ are the two vertices corresponding to variable $k$ with $2k+1$ corresponding to the negated variable.
```{.cpp file=2sat}
-int n;
-vector
+**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/bridge-searching-online.md b/src/graph/bridge-searching-online.md index 702dc5a88..80ed25ead 100644 --- a/src/graph/bridge-searching-online.md +++ b/src/graph/bridge-searching-online.md @@ -174,7 +174,6 @@ int find_cc(int v) { } void make_root(int v) { - v = find_2ecc(v); int root = v; int child = -1; while (v != -1) { diff --git a/src/graph/bridge-searching.md b/src/graph/bridge-searching.md index 2d6596878..48a52c1f6 100644 --- a/src/graph/bridge-searching.md +++ b/src/graph/bridge-searching.md @@ -22,25 +22,34 @@ Pick an arbitrary vertex of the graph $root$ and run [depth first search](depth- Now we have to learn to check this fact for each vertex efficiently. We'll use "time of entry into node" computed by the depth first search. -So, let $tin[v]$ denote entry time for node $v$. We introduce an array $low$ which will let us check the fact for each vertex $v$. $low[v]$ is the minimum of $tin[v]$, the entry times $tin[p]$ for each node $p$ that is connected to node $v$ via a back-edge $(v, p)$ and the values of $low[to]$ for each vertex $to$ which is a direct descendant of $v$ in the DFS tree: +So, let $\mathtt{tin}[v]$ denote entry time for node $v$. We introduce an array $\mathtt{low}$ which will let us store the node with earliest entry time found in the DFS search that a node $v$ can reach with a single edge from itself or its descendants. $\mathtt{low}[v]$ is the minimum of $\mathtt{tin}[v]$, the entry times $\mathtt{tin}[p]$ for each node $p$ that is connected to node $v$ via a back-edge $(v, p)$ and the values of $\mathtt{low}[to]$ for each vertex $to$ which is a direct descendant of $v$ in the DFS tree: -$$low[v] = \min \begin{cases} tin[v] \\ tin[p]& \text{ for all }p\text{ for which }(v, p)\text{ is a back edge} \\ low[to]& \text{ for all }to\text{ for which }(v, to)\text{ is a tree edge} \end{cases}$$ +$$\mathtt{low}[v] = \min \left\{ + \begin{array}{l} + \mathtt{tin}[v] \\ + \mathtt{tin}[p] &\text{ for all }p\text{ for which }(v, p)\text{ is a back edge} \\ + \mathtt{low}[to] &\text{ for all }to\text{ for which }(v, to)\text{ is a tree edge} + \end{array} +\right\}$$ -Now, there is a back edge from vertex $v$ or one of its descendants to one of its ancestors if and only if vertex $v$ has a child $to$ for which $low[to] \leq tin[v]$. If $low[to] = tin[v]$, the back edge comes directly to $v$, otherwise it comes to one of the ancestors of $v$. +Now, there is a back edge from vertex $v$ or one of its descendants to one of its ancestors if and only if vertex $v$ has a child $to$ for which $\mathtt{low}[to] \leq \mathtt{tin}[v]$. If $\mathtt{low}[to] = \mathtt{tin}[v]$, the back edge comes directly to $v$, otherwise it comes to one of the ancestors of $v$. -Thus, the current edge $(v, to)$ in the DFS tree is a bridge if and only if $low[to] > tin[v]$. +Thus, the current edge $(v, to)$ in the DFS tree is a bridge if and only if $\mathtt{low}[to] > \mathtt{tin}[v]$. ## Implementation The implementation needs to distinguish three cases: when we go down the edge in DFS tree, when we find a back edge to an ancestor of the vertex and when we return to a parent of the vertex. These are the cases: -- $visited[to] = false$ - the edge is part of DFS tree; -- $visited[to] = true$ && $to \neq parent$ - the edge is back edge to one of the ancestors; +- $\mathtt{visited}[to] = false$ - the edge is part of DFS tree; +- $\mathtt{visited}[to] = true$ && $to \neq parent$ - the edge is back edge to one of the ancestors; - $to = parent$ - the edge leads back to parent in DFS tree. To implement this, we need a depth first search function which accepts the parent vertex of the current node. -```cpp +For the cases of multiple edges, we need to be careful when ignoring the edge from the parent. To solve this issue, we can add a flag `parent_skipped` which will ensure we only skip the parent once. + +```{.cpp file=bridge_searching_offline} +void IS_BRIDGE(int v,int to); // some function to process the found bridge int n; // number of nodes vector
+ 
+
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
@@ -66,7 +70,7 @@ We can create a **residual network** from all these edges, which is just a netwo
The Ford-Fulkerson method works as follows.
First, we set the flow of each edge to zero.
Then we look for an **augmenting path** from $s$ to $t$.
-An augmenting path is a simple path in the residual graph, i.e. along the edges whose residual capacity is positive.
+An augmenting path is a simple path in the residual graph where residual capacity is positive for all the edges along that path.
If such a path is found, then we can increase the flow along these edges.
We keep on searching for augmenting paths and increasing the flow.
Once an augmenting path doesn't exist anymore, the flow is maximal.
@@ -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-cycle.md b/src/graph/finding-cycle.md
index d629d2feb..af0ebda9f 100644
--- a/src/graph/finding-cycle.md
+++ b/src/graph/finding-cycle.md
@@ -129,5 +129,6 @@ void find_cycle() {
```
### Practice problems:
+- [AtCoder : Reachability in Functional Graph](https://atcoder.jp/contests/abc357/tasks/abc357_e)
- [CSES : Round Trip](https://cses.fi/problemset/task/1669)
- [CSES : Round Trip II](https://cses.fi/problemset/task/1678/)
diff --git a/src/graph/finding-negative-cycle-in-graph.md b/src/graph/finding-negative-cycle-in-graph.md
index 1c981ab99..a9b87c7f9 100644
--- a/src/graph/finding-negative-cycle-in-graph.md
+++ b/src/graph/finding-negative-cycle-in-graph.md
@@ -19,6 +19,9 @@ Bellman-Ford algorithm allows you to check whether there exists a cycle of negat
The details of the algorithm are described in the article on the [Bellman-Ford](bellman_ford.md) algorithm.
Here we'll describe only its application to this problem.
+The standard implementation of Bellman-Ford looks for a negative cycle reachable from some starting vertex $v$ ; however, the algorithm can be modified to just looking for any negative cycle in the graph.
+For this we need to put all the distance $d[i]$ to zero and not infinity — as if we are looking for the shortest path from all vertices simultaneously; the validity of the detection of a negative cycle is not affected.
+
Do $N$ iterations of Bellman-Ford algorithm. If there were no changes on the last iteration, there is no cycle of negative weight in the graph. Otherwise take a vertex the distance to which has changed, and go from it via its ancestors until a cycle is found. This cycle will be the desired cycle of negative weight.
### Implementation
@@ -27,35 +30,33 @@ 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/min_cost_flow.md b/src/graph/min_cost_flow.md
index 1d15210af..b13716d40 100644
--- a/src/graph/min_cost_flow.md
+++ b/src/graph/min_cost_flow.md
@@ -160,3 +160,9 @@ int min_cost_flow(int N, vector
+
+ 
+ 
+
It is easy to see that any spanning tree will necessarily contain $n-1$ edges.
diff --git a/src/graph/push-relabel-faster.md b/src/graph/push-relabel-faster.md
index 0c000d207..24b9e0ce4 100644
--- a/src/graph/push-relabel-faster.md
+++ b/src/graph/push-relabel-faster.md
@@ -91,9 +91,6 @@ int max_flow(int s, int t)
}
}
- int max_flow = 0;
- for (int i = 0; i < n; i++)
- max_flow += flow[i][t];
- return max_flow;
+ return excess[t];
}
```
diff --git a/src/graph/push-relabel.md b/src/graph/push-relabel.md
index c1e75b83c..569a1198a 100644
--- a/src/graph/push-relabel.md
+++ b/src/graph/push-relabel.md
@@ -101,8 +101,7 @@ vector
+
+
+ 
+
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/search-for-connected-components.md b/src/graph/search-for-connected-components.md
index e96391d11..cfc0f27ac 100644
--- a/src/graph/search-for-connected-components.md
+++ b/src/graph/search-for-connected-components.md
@@ -102,7 +102,6 @@ void find_comps() {
```
## Practice Problems
- - [SPOJ: CCOMPS](http://www.spoj.com/problems/CCOMPS/)
- [SPOJ: CT23E](http://www.spoj.com/problems/CT23E/)
- [CODECHEF: GERALD07](https://www.codechef.com/MARCH14/problems/GERALD07)
- [CSES : Building Roads](https://cses.fi/problemset/task/1666)
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/overrides/partials/content.html b/src/overrides/partials/content.html
index 853a4201a..babde6339 100644
--- a/src/overrides/partials/content.html
+++ b/src/overrides/partials/content.html
@@ -1,9 +1,9 @@
+