diff --git a/src/geometry/enclosing-circle.md b/src/geometry/enclosing-circle.md
new file mode 100644
index 000000000..accef58e5
--- /dev/null
+++ b/src/geometry/enclosing-circle.md
@@ -0,0 +1,209 @@
+---
+tags:
+ - Original
+---
+
+# Minimum Enclosing Circle
+
+Consider the following problem:
+
+!!! example "[Library Checker - Minimum Enclosing Circle](https://judge.yosupo.jp/problem/minimum_enclosing_circle)"
+
+ You're given $n \leq 10^5$ points $p_i=(x_i, y_i)$.
+
+ For each $p_i$, find whether it lies on the circumference of the minimum enclosing circle of $\{p_1,\dots,p_n\}$.
+
+Here, by the minimum enclosing circle (MEC) we mean a circle with minimum possible radius that contains all the $n$ p, inside the circle or on its boundary. This problem has a simple randomized solution that, on first glance, looks like it would run in $O(n^3)$, but actually works in $O(n)$ expected time.
+
+To better understand the reasoning below, we should immediately note that the solution to the problem is unique:
+
+??? question "Why is the MEC unique?"
+
+ Consider the following setup: Let $r$ be the radius of the MEC. We draw a circle of radius $r$ around each of the p $p_1,\dots,p_n$. Geometrically, the centers of circles that have radius $r$ and cover all the points $p_1,\dots,p_n$ form the intersection of all $n$ circles.
+
+ Now, if the intersection is just a single point, this already proves that it is unique. Otherwise, the intersection is a shape of non-zero area, so we can reduce $r$ by a tiny bit, and still have non-empty intersection, which contradicts the assumption that $r$ was the minimum possible radius of the enclosing circle.
+
+ With a similar logic, we can also show the uniqueness of the MEC if we additionally demand that it passes through a given specific point $p_i$ or two points $p_i$ and $p_j$ (it is also unique because its radius uniquely defines it).
+
+ Alternatively, we can also assume that there are two MECs, and then notice that their intersection (which contains p $p_1,\dots,p_n$ already) must have a smaller diameter than initial circles, and thus can be covered with a smaller circle.
+
+## Welzl's algorithm
+
+For brevity, let's denote $\operatorname{mec}(p_1,\dots,p_n)$ to be the MEC of $\{p_1,\dots,p_n\}$, and let $P_i = \{p_1,\dots,p_i\}$.
+
+The algorithm, initially [proposed](https://doi.org/10.1007/BFb0038202) by Welzl in 1991, goes as follows:
+
+1. Apply a random permutation to the input sequence of points.
+2. Maintain the current candidate to be the MEC $C$, starting with $C = \operatorname{mec}(p_1, p_2)$.
+3. Iterate over $i=3..n$ and check if $p_i \in C$.
+ 1. If $p_i \in C$ it means that $C$ is the MEC of $P_i$.
+ 2. Otherwise, assign $C = \operatorname{mec}(p_i, p_1)$ and iterate over $j=2..i$ and check if $p_j \in C$.
+ 1. If $p_j \in C$, then $C$ is the MEC of $P_j$ among circles that pass through $p_i$.
+ 2. Otherwise, assign $C=\operatorname{mec}(p_i, p_j)$ and iterate over $k=1..j$ and check if $p_k \in C$.
+ 1. If $p_k \in C$, then $C$ is the MEC of $P_k$ among circles that pass through $p_i$ and $p_j$.
+ 2. Otherwise, $C=\operatorname{mec}(p_i,p_j,p_k)$ is the MEC of $P_k$ among circles that pass through $p_i$ and $p_j$.
+
+We can see that each level of nestedness here has an invariant to maintain (that $C$ is the MEC among circles that also pass through additionally given $0$, $1$ or $2$ points), and whenever the inner loop closes, its invariant becomes equivalent to the invariant of the current iteration of its parent loop. This, in turn, ensures the _correctness_ of the algorithm as a whole.
+
+Omitting some technical details, for now, the whole algorithm can be implemented in C++ as follows:
+
+```cpp
+struct point {...};
+
+// Is represented by 2 or 3 points on its circumference
+struct mec {...};
+
+bool inside(mec const& C, point p) {
+ return ...;
+}
+
+// Choose some good generator of randomness for the shuffle
+mt19937_64 gen(...);
+mec enclosing_circle(vector
&p) {
+ ranges::shuffle(p, gen);
+ auto C = mec{p[0], p[1]};
+ for(int i = 0; i < n; i++) {
+ if(!inside(C, p[i])) {
+ C = mec{p[i], p[0]};
+ for(int j = 0; j < i; j++) {
+ if(!inside(C, p[j])) {
+ C = mec{p[i], p[j]};
+ for(int k = 0; k < j; k++) {
+ if(!inside(C, p[k])) {
+ C = mec{p[i], p[j], p[k]};
+ }
+ }
+ }
+ }
+ }
+ }
+ return C;
+}
+```
+
+Now, it is to be expected that checking that a point $p_i$ is inside the MEC of $2$ or $3$ points can be done in $O(1)$ (we will discuss this later on). But even then, the algorithm above looks as if it would take $O(n^3)$ in the worst case just because of all the nested loops. So, how come we claimed the linear expected runtime? Let's figure out!
+
+### Complexity analysis
+
+For the inner-most loop (over $k$), clearly its expected runtime is $O(j)$ operations. What about the loop over $j$?
+
+It only triggers the next loop if $p_j$ is on the boundary of the MEC of $P_j$ that also passes through point $i$, _and removing $p_j$ would further shrink the circle_. Of all points in $P_j$ there can only be at most $2$ points with such property, because if there are more than $2$ points from $P_j$ on the boundary, it means that after removing any of them, there will still be at least $3$ points on the boundary, sufficient to uniquely define the circle.
+
+In other words, after initial random shuffle, there is at most $\frac{2}{j}$ probability that we get one of the at most two unlucky points as $p_j$. Summing it up over all $j$ from $1$ to $i$, we get the expected runtime of
+
+$$
+\sum\limits_{j=1}^i \frac{2}{j} \cdot O(j) = O(i).
+$$
+
+In exactly same fashion we can now also prove that the outermost loop has expected runtime of $O(n)$.
+
+### Checking that a point is in the MEC of 2 or 3 points
+
+Let's now figure out the implementation detail of `point` and `mec`. In this problem, it turns out to be particularly useful to use [std::complex](https://codeforces.com/blog/entry/22175) as a class for points:
+
+```cpp
+using ftype = int64_t;
+using point = complex;
+```
+
+As a reminder, a complex number is a number of type $x+yi$, where $i^2=-1$ and $x, y \in \mathbb R$. In C++, such complex number is represented by a 2-dimensional point $(x, y)$. Complex numbers already implement basic component-wise linear operations (addition, multiplication by a real number), but also their multiplication and division carry certain geometric meaning.
+
+Without going in too much detail, we will note the most important property for this particular task: Multiplying two complex numbers adds up their polar angles (counted from $Ox$ counter-clockwise), and taking a conjugate (i.e. changing $z=x+yi$ into $\overline{z} = x-yi$) multiplies the polar angle with $-1$. This allows us to formulate some very simple criteria for whether a point $z$ is inside the MEC of $2$ or $3$ specific points.
+
+#### MEC of 2 points
+
+For $2$ points $a$ and $b$, their MEC is simply the circle centered at $\frac{a+b}{2}$ with the radius $\frac{|a-b|}{2}$, in other words the circle that has $ab$ as a diameter. To check if $z$ is inside this circle we simply need to check that the angle between $za$ and $zb$ is not acute.
+
+
+
+
+Inner angles are obtuse, external angles are acute and angles on the circumference are right
+
+
+Equivalently, we need to check that
+
+$$
+I_0=(b-z)\overline{(a-z)}
+$$
+
+doesn't have a positive real coordinate (corresponding to points that have a polar angle between $-90^\circ$ and $90^\circ$).
+
+#### MEC of 3 points
+
+Adding $z$ to the triangle $abc$ will make it a quadrilateral. Consider the following expression:
+
+$$
+\angle azb + \angle bca
+$$
+
+In a [cyclic quadrilateral](https://en.wikipedia.org/wiki/Cyclic_quadrilateral), if $c$ and $z$ are from the same side of $ab$, then the angles are equal, and will ad up to $0^\circ$ when summed up signed (i.e. positive if counter-clockwise and negative if clockwise). Correspondingly, if $c$ and $z$ are on the opposite sides, the angles will add up to $180^\circ$.
+
+
+
+
+Adjacent inscribed angles are same, opposing angles complement to 180 degrees
+
+
+In terms of complex numbers, we can note that $\angle azb$ is the polar angle of $(b-z)\overline{(a-z)}$ and $\angle bca$ is the polar angle of $(a-c)\overline{(b-c)}$. Thus, we can conclude that $\angle azb + \angle bca$ is the polar angle of
+
+$$
+I_1 = (b-z) \overline{(a-z)} (a-c) \overline{(b-c)}
+$$
+
+If the angle is $0^\circ$ or $180^\circ$, it means that the imaginary part of $I_1$ is $0$, otherwise we can deduce whether $z$ is inside or outside of the enclosing circle of $abc$ by checking the sign of the imaginary part of $I_1$. Positive imaginary part corresponds to positive angles, and negative imaginary part corresponds to negative angles.
+
+But which one of them means that $z$ is inside or outside of the circle? As we already noticed, having $z$ inside the circle generally increases the magnitude of $\angle azb$, while having it outside the circle decreases it. As such, we have the following 4 cases:
+
+1. $\angle bca > 0^\circ$, $c$ on the same side of $ab$ as $z$. Then, $\angle azb < 0^\circ$, and $\angle azb + \angle bca < 0^\circ$ for points inside the circle.
+3. $\angle bca < 0^\circ$, $c$ on the same side of $ab$ as $z$. Then, $\angle azb > 0^\circ$, and $\angle azb + \angle bca > 0^\circ$ for points inside the circle.
+2. $\angle bca > 0^\circ$, $c$ on the opposite side of $ab$ to $z$. Then, $\angle azb > 0^\circ$ and $\angle azb + \angle bca > 180^\circ$ for points inside the circle.
+4. $\angle bca < 0^\circ$, $c$ on the opposite side of $ab$ to $z$. Then, $\angle azb < 0^\circ$ and $\angle azb + \angle bca < 180^\circ$ for points inside the circle.
+
+In other words, if $\angle bca$ is positive, points inside the circle will have $\angle azb + \angle bca < 0^\circ$, otherwise they will have $\angle azb + \angle bca > 0^\circ$, assuming that we normalize the angles between $-180^\circ$ and $180^\circ$. This, in turn, can be checked by the signs of imaginary parts of $I_2=(a-c)\overline{(b-c)}$ and $I_1 = I_0 I_2$.
+
+**Note**: As we multiply four complex numbers to get $I_1$, the intermediate coefficients can be as large as $O(A^4)$, where $A$ is the largest coordinate magnitude in the input. On the bright side, if the input is integer, both checks above can be done fully in integers.
+
+#### Implementation
+
+Now, to actually implement the check, we should first decide how to represent the MEC. As our criteria work with the points directly, a natural and efficient way to do this is to say that MEC is directly represented as a pair or triple of points that defines it:
+
+```cpp
+using mec = variant<
+ array,
+ array
+>;
+```
+
+Now, we can use `std::visit` to efficiently deal with both cases in accordance with criteria above:
+
+```cpp
+/* I < 0 if z inside C,
+ I > 0 if z outside C,
+ I = 0 if z on the circumference of C */
+ftype indicator(mec const& C, point z) {
+ return visit([&](auto &&C) {
+ point a = C[0], b = C[1];
+ point I0 = (b - z) * conj(a - z);
+ if constexpr (size(C) == 2) {
+ return real(I0);
+ } else {
+ point c = C[2];
+ point I2 = (a - c) * conj(b - c);
+ point I1 = I0 * I2;
+ return imag(I2) < 0 ? -imag(I1) : imag(I1);
+ }
+ }, C);
+}
+
+bool inside(mec const& C, point p) {
+ return indicator(C, p) <= 0;
+}
+
+```
+
+Now, we can finally ensure that everything works by submitting the problem to the Library Checker: [#308668](https://judge.yosupo.jp/submission/308668).
+
+## Practice problems
+
+- [Library Checker - Minimum Enclosing Circle](https://judge.yosupo.jp/problem/minimum_enclosing_circle)
+- [BOI 2002 - Aliens](https://www.spoj.com/problems/ALIENS)
\ No newline at end of file
diff --git a/src/geometry/manhattan-distance.md b/src/geometry/manhattan-distance.md
index 4c725626e..86e1d0485 100644
--- a/src/geometry/manhattan-distance.md
+++ b/src/geometry/manhattan-distance.md
@@ -67,11 +67,11 @@ To prove this, we just need to analyze the signs of $m$ and $n$. And it's left a
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)|).$$
+$$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)|, |(y_1 - x_1) - (y_2 - x_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
+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, y_1 - x_1)$ and $(x_2 + y_2, y_2 - x_2)$. This means that, after applying the transformation
-$$\alpha : (x, y) \to (x + y, x - y),$$
+$$\alpha : (x, y) \to (x + y, y - x),$$
the Manhattan distance between the points $p$ and $q$ turns into the Chebyshev distance between $\alpha(p)$ and $\alpha(q)$.
@@ -88,17 +88,19 @@ Here's an image to help visualizing the transformation:
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 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*
+
+
+ *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.*
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
*In the image left is the MST and right is the second best MST.*
-
+
+
+
+
Binary search of the value $7$ in an array.
-The image by [AlwaysAngry](https://commons.wikimedia.org/wiki/User:AlwaysAngry) is distributed under CC BY-SA 4.0 license.
+The image by AlwaysAngry is distributed under CC BY-SA 4.0 license.
Now assume that we know two indices $L < R$ such that $A_L \leq k \leq A_R$. Because the array is sorted, we can deduce that $k$ either occurs among $A_L, A_{L+1}, \dots, A_R$ or doesn't occur in the array at all. If we pick an arbitrary index $M$ such that $L < M < R$ and check whether $k$ is less or greater than $A_M$. We have two possible cases:
diff --git a/src/num_methods/simulated_annealing.md b/src/num_methods/simulated_annealing.md
new file mode 100644
index 000000000..bd0dd6ed2
--- /dev/null
+++ b/src/num_methods/simulated_annealing.md
@@ -0,0 +1,203 @@
+---
+tags:
+ - Original
+---
+
+# Simulated Annealing
+
+**Simulated Annealing (SA)** is a randomized algorithm, which approximates the global optimum of a function. It's called a randomized algorithm, because it employs a certain amount of randomness in its search and thus its output can vary for the same input.
+
+## The problem
+
+We are given a function $E(s)$, which calculates the energy of the state $s$. We are tasked with finding the state $s_{best}$ at which $E(s)$ is minimized. **SA** is suited for problems where the states are discrete and $E(s)$ has multiple local minima. We'll take the example of the [Travelling Salesman Problem (TSP)](https://en.wikipedia.org/wiki/Travelling_salesman_problem).
+
+### Travelling Salesman Problem (TSP)
+
+You are given a set of nodes in 2 dimensional space. Each node is characterised by its $x$ and $y$ coordinates. Your task is to find an ordering of the nodes, which will minimise the distance to be travelled when visiting these nodes in that order.
+
+## Motivation
+Annealing is a metallurgical process, wherein a material is heated up and allowed to cool, in order to allow the atoms inside to rearrange themselves in an arrangement with minimal internal energy, which in turn causes the material to have different properties. The state is the arrangement of atoms and the internal energy is the function being minimised. We can think of the original state of the atoms, as a local minima for its internal energy. To make the material rearrange its atoms, we need to motivate it to go across a region where its internal energy is not minimised in order to reach the global minima. This motivation is given by heating the material to a higher temperature.
+
+Simulated annealing, literally, simulates this process. We start off with some random state (material) and set a high temperature (heat it up). Now, the algorithm is ready to accept states which have a higher energy than the current state, as it is motivated by the high temperature. This prevents the algorithm from getting stuck inside local minimas and move towards the global minima. As time progresses, the algorithm cools down and refuses the states with higher energy and moves into the closest minima it has found.
+
+### The energy function E(s)
+
+$E(s)$ is the function which needs to be minimised (or maximised). It maps every state to a real number. In the case of TSP, $E(s)$ returns the distance of travelling one full circle in the order of nodes in the state.
+
+### State
+
+The state space is the domain of the energy function, $E(s)$, and a state is any element which belongs to the state space. In the case of TSP, all possible paths that we can take to visit all the nodes is the state space, and any single one of these paths can be considered as a state.
+
+### Neighbouring state
+
+It is a state in the state space which is close to the previous state. This usually means that we can obtain the neighbouring state from the original state using a simple transform. In the case of the Travelling Salesman Problem, a neighbouring state is obtained by randomly choosing 2 nodes, and swapping their positions in the current state.
+
+## Algorithm
+
+We start with a random state $s$. In every step, we choose a neighbouring state $s_{next}$ of the current state $s$. If $E(s_{next}) < E(s)$, then we update $s = s_{next}$. Otherwise, we use a probability acceptance function $P(E(s),E(s_{next}),T)$ which decides whether we should move to $s_{next}$ or stay at $s$. T here is the temperature, which is initially set to a high value and decays slowly with every step. The higher the temperature, the more likely it is to move to $s_{next}$.
+At the same time we also keep a track of the best state $s_{best}$ across all iterations. Proceeding till convergence or time runs out.
+
+
+
+
+
+A visual representation of simulated annealing, searching for the maxima of this function with multiple local maxima.
+
+
+
+### Temperature(T) and decay(u)
+
+The temperature of the system quantifies the willingness of the algorithm to accept a state with a higher energy. The decay is a constant which quantifies the "cooling rate" of the algorithm. A slow cooling rate (larger $u$) is known to give better results.
+
+## Probability Acceptance Function(PAF)
+
+$P(E,E_{next},T) =
+ \begin{cases}
+ \text{True} &\quad\text{if } \mathcal{U}_{[0,1]} \le \exp(-\frac{E_{next}-E}{T}) \\
+ \text{False} &\quad\text{otherwise}\\
+ \end{cases}$
+
+Here, $\mathcal{U}_{[0,1]}$ is a continuous uniform random value on $[0,1]$. This function takes in the current state, the next state and the temperature, returning a boolean value, which tells our search whether it should move to $s_{next}$ or stay at $s$. Note that for $E_{next} < E$ , this function will always return True, otherwise it can still make the move with probability $\exp(-\frac{E_{next}-E}{T})$, which corresponds to the [Gibbs measure](https://en.wikipedia.org/wiki/Gibbs_measure).
+
+```cpp
+bool P(double E,double E_next,double T,mt19937 rng){
+ double prob = exp(-(E_next-E)/T);
+ if(prob > 1) return true;
+ else{
+ bernoulli_distribution d(prob);
+ return d(rng);
+ }
+}
+```
+## Code Template
+
+```cpp
+class state {
+ public:
+ state() {
+ // Generate the initial state
+ }
+ state next() {
+ state s_next;
+ // Modify s_next to a random neighboring state
+ return s_next;
+ }
+ double E() {
+ // Implement the energy function here
+ };
+};
+
+
+pair simAnneal() {
+ state s = state();
+ state best = s;
+ double T = 10000; // Initial temperature
+ double u = 0.995; // decay rate
+ double E = s.E();
+ double E_next;
+ double E_best = E;
+ mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+ while (T > 1) {
+ state next = s.next();
+ E_next = next.E();
+ if (P(E, E_next, T, rng)) {
+ s = next;
+ if (E_next < E_best) {
+ best = s;
+ E_best = E_next;
+ }
+ E = E_next;
+ }
+ T *= u;
+ }
+ return {E_best, best};
+}
+
+```
+## How to use:
+Fill in the state class functions as appropriate. If you are trying to find a global maxima and not a minima, ensure that the $E()$ function returns negative of the function you are maximizing and print $-E_{best}$ in the end. Set the below parameters as per your need.
+
+### Parameters
+- $T$ : Initial temperature. Set it to a higher value if you want the search to run for a longer time.
+- $u$ : Decay. Decides the rate of cooling. A slower cooling rate (larger value of u) usually gives better results, at the cost of running for a longer time. Ensure $u < 1$.
+
+The number of iterations the loop will run for is given by the expression
+
+$N = \lceil -\log_{u}{T} \rceil$
+
+Tips for choosing $T$ and $u$ : If there are many local minimas and a wide state space, set $u = 0.999$, for a slow cooling rate, which will allow the algorithm to explore more possibilities. On the other hand, if the state space is narrower, $u = 0.99$ should suffice. If you are not sure, play it safe by setting $u = 0.998$ or higher. Calculate the time complexity of a single iteration of the algorithm, and use this to approximate a value of $N$ which will prevent TLE, then use the below formula to obtain $T$.
+
+$T = u^{-N}$
+
+### Example implementation for TSP
+```cpp
+
+class state {
+ public:
+ vector> points;
+ std::mt19937 mt{ static_cast(
+ std::chrono::steady_clock::now().time_since_epoch().count()
+ ) };
+ state() {
+ points = {%raw%} {{0,0},{2,2},{0,2},{2,0},{0,1},{1,2},{2,1},{1,0}} {%endraw%};
+ }
+ state next() {
+ state s_next;
+ s_next.points = points;
+ uniform_int_distribution<> choose(0, points.size()-1);
+ int a = choose(mt);
+ int b = choose(mt);
+ s_next.points[a].swap(s_next.points[b]);
+ return s_next;
+ }
+
+ double euclidean(pair a, pair b) {
+ return hypot(a.first - b.first, a.second - b.second);
+ }
+
+ double E() {
+ double dist = 0;
+ int n = points.size();
+ for (int i = 0;i < n; i++)
+ dist += euclidean(points[i], points[(i+1)%n]);
+ return dist;
+ };
+};
+
+int main() {
+ pair res;
+ res = simAnneal();
+ double E_best = res.first;
+ state best = res.second;
+ cout << "Lenght of shortest path found : " << E_best << "\n";
+ cout << "Order of points in shortest path : \n";
+ for(auto x: best.points) {
+ cout << x.first << " " << x.second << "\n";
+ }
+}
+```
+
+## Further modifications to the algorithm:
+
+- Add a time based exit condition to the while loop to prevent TLE
+- The decay implemented above is an exponential decay. You can always replace this with a decay function as per your needs.
+- The Probability acceptance function given above, prefers accepting states which are lower in energy because of the $E_{next} - E$ factor in the numerator of the exponent. You can simply remove this factor, to make the PAF independent of the difference in energies.
+- The effect of the difference in energies, $E_{next} - E$, on the PAF can be increased/decreased by increasing/decreasing the base of the exponent as shown below:
+```cpp
+bool P(double E, double E_next, double T, mt19937 rng) {
+ double e = 2; // set e to any real number greater than 1
+ double prob = pow(e,-(E_next-E)/T);
+ if (prob > 1)
+ return true;
+ else {
+ bernoulli_distribution d(prob);
+ return d(rng);
+ }
+}
+```
+
+## Problems
+
+- [USACO Jan 2017 - Subsequence Reversal](https://usaco.org/index.php?page=viewproblem2&cpid=698)
+- [Deltix Summer 2021 - DIY Tree](https://codeforces.com/contest/1556/problem/H)
+- [AtCoder Contest Scheduling](https://atcoder.jp/contests/intro-heuristics/tasks/intro_heuristics_a)
diff --git a/src/overrides/partials/header.html b/src/overrides/partials/header.html
index 967330642..ab875aef1 100644
--- a/src/overrides/partials/header.html
+++ b/src/overrides/partials/header.html
@@ -87,14 +87,24 @@
-
-
- {% endif %}
+
+
+
{% if "navigation.tabs.sticky" in features %}
{% if "navigation.tabs" in features %}
diff --git a/src/sequences/longest_increasing_subsequence.md b/src/sequences/longest_increasing_subsequence.md
index a4c8f0fe4..dca4f020b 100644
--- a/src/sequences/longest_increasing_subsequence.md
+++ b/src/sequences/longest_increasing_subsequence.md
@@ -174,7 +174,7 @@ We will again gradually process the numbers, first $a[0]$, then $a[1]$, etc, and
$$
When we process $a[i]$, we can ask ourselves.
-What have the conditions to be, that we write the current number $a[i]$ into the $d[0 \dots n]$ array?
+Under what conditions should we write the current number $a[i]$ into the $d[0 \dots n]$ array?
We set $d[l] = a[i]$, if there is a longest increasing sequence of length $l$ that ends in $a[i]$, and there is no longest increasing sequence of length $l$ that ends in a smaller number.
Similar to the previous approach, if we remove the number $a[i]$ from the longest increasing sequence of length $l$, we get another longest increasing sequence of length $l -1$.
diff --git a/src/string/aho_corasick.md b/src/string/aho_corasick.md
index df0998713..36ec40c7d 100644
--- a/src/string/aho_corasick.md
+++ b/src/string/aho_corasick.md
@@ -209,7 +209,7 @@ Assume that at the moment we stand in a vertex $v$ and consider a character $c$.
1. $go[v][c] = -1$. In this case, we may assign $go[v][c] = go[u][c]$, which is already known by the induction hypothesis;
2. $go[v][c] = w \neq -1$. In this case, we may assign $link[w] = go[u][c]$.
-In this way, we spend $O(1)$ time per each pair of a vertex and a character, making the running time $O(mk)$. The major overhead here is that we copy a lot of transitions from $u$ in the first case, while the transitions of the second case form the trie and sum up to $m$ over all vertices. To avoid the copying of $go[u][c]$, we may use a persistent array data structure, using which we initially copy $go[u]$ into $go[v]$ and then only update values for characters in which the transition would differ. This leads to the $O(n \log k)$ algorithm.
+In this way, we spend $O(1)$ time per each pair of a vertex and a character, making the running time $O(nk)$. The major overhead here is that we copy a lot of transitions from $u$ in the first case, while the transitions of the second case form the trie and sum up to $n$ over all vertices. To avoid the copying of $go[u][c]$, we may use a persistent array data structure, using which we initially copy $go[u]$ into $go[v]$ and then only update values for characters in which the transition would differ. This leads to the $O(n \log k)$ algorithm.
## Applications
diff --git a/src/string/manacher.md b/src/string/manacher.md
index 0c8bd5928..26589b83c 100644
--- a/src/string/manacher.md
+++ b/src/string/manacher.md
@@ -147,7 +147,7 @@ vector manacher_odd(string s) {
vector p(n + 2);
int l = 0, r = 1;
for(int i = 1; i <= n; i++) {
- p[i] = max(0, min(r - i, p[l + (r - i)]));
+ p[i] = min(r - i, p[l + (r - i)]);
while(s[i - p[i]] == s[i + p[i]]) {
p[i]++;
}
diff --git a/src/stylesheets/extra.css b/src/stylesheets/extra.css
index d40c3e65f..b63b3c9a9 100644
--- a/src/stylesheets/extra.css
+++ b/src/stylesheets/extra.css
@@ -54,4 +54,39 @@ body[dir=rtl] .metadata.page-metadata .contributors-text{
.arithmatex{
overflow-y: hidden !important;
-}
\ No newline at end of file
+}
+
+/* Donation banner */
+#donation-banner {
+ margin: 0.75rem 0.75rem 0;
+}
+
+.donation-banner {
+ display: flex;
+
+ background: #fff9c4;
+ border: 1px solid #f0e68c;
+ color: #2b2b2b;
+
+ padding: 0.5rem 0.5rem;
+ border-radius: 8px;
+ font-size: 0.75rem;
+}
+
+.donation-text { margin: 0; }
+.donation-link {
+ color: revert;
+ text-decoration: underline;
+}
+
+.donation-close {
+ margin-left: auto;
+ font-size: 1rem;
+ cursor: pointer;
+}
+
+[data-md-color-scheme="slate"] .donation-banner {
+ background: #3b3200;
+ border-color: #665c1e;
+ color: #fff7b3;
+}
-Implementation of **Erase ($X$)** is also clear. First we descend in the tree (as in a regular binary search tree by $X$), looking for the element we want to delete. Once the node is found, we call **Merge** on it children and put the return value of the operation in the place of the element we're deleting.
+Implementation of **Erase ($X$)** is also clear. First we descend in the tree (as in a regular binary search tree by $X$), looking for the element we want to delete. Once the node is found, we call **Merge** on its children and put the return value of the operation in the place of the element we're deleting.
Alternatively, we can factor out the subtree holding $X$ with $2$ split operations and merge the remaining treaps (see the picture).
diff --git a/src/geometry/basic-geometry.md b/src/geometry/basic-geometry.md
index 89acb1642..afd44b315 100644
--- a/src/geometry/basic-geometry.md
+++ b/src/geometry/basic-geometry.md
@@ -180,7 +180,7 @@ double angle(point2d a, point2d b) {
```
To see the next important property we should take a look at the set of points $\mathbf r$ for which $\mathbf r\cdot \mathbf a = C$ for some fixed constant $C$.
-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 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| ^ 2}$ 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:
