From 21299e74b39389acb6bf8ad257d65cc1875ffa93 Mon Sep 17 00:00:00 2001 From: Michael Hayter Date: Mon, 14 Apr 2025 22:32:08 -0400 Subject: [PATCH] add_script updates? --- src/algebra/factorization.md | 4 +++- src/algebra/sieve-of-eratosthenes.md | 4 +++- src/data_structures/fenwick.md | 4 +++- src/geometry/basic-geometry.md | 16 ++++++++++++---- src/geometry/convex_hull_trick.md | 8 ++++++-- src/geometry/delaunay.md | 4 +++- src/geometry/intersecting_segments.md | 12 +++++++++--- src/geometry/lattice-points.md | 8 ++++++-- src/geometry/manhattan-distance.md | 8 ++++++-- src/geometry/minkowski.md | 4 +++- src/geometry/planar.md | 8 ++++++-- src/geometry/point-location.md | 8 ++++++-- src/geometry/tangents-to-two-circles.md | 4 +++- src/geometry/vertical_decomposition.md | 4 +++- src/graph/2SAT.md | 8 ++++++-- src/graph/edmonds_karp.md | 16 ++++++++++++---- src/graph/hld.md | 4 +++- src/graph/lca.md | 4 +++- src/graph/lca_farachcoltonbender.md | 4 +++- src/graph/rmq_linear.md | 8 ++++++-- src/graph/topological-sort.md | 6 +++--- src/others/stern_brocot_tree_farey_sequences.md | 4 +++- src/others/tortoise_and_hare.md | 12 +++++++++--- 23 files changed, 120 insertions(+), 42 deletions(-) diff --git a/src/algebra/factorization.md b/src/algebra/factorization.md index 58a43b961..11bf4049c 100644 --- a/src/algebra/factorization.md +++ b/src/algebra/factorization.md @@ -246,7 +246,9 @@ If $p$ is smaller than $\sqrt{n}$, the repetition will likely start in $O(\sqrt[ Here is a visualization of such a sequence $\{x_i \bmod p\}$ with $n = 2206637$, $p = 317$, $x_0 = 2$ and $f(x) = x^2 + 1$. From the form of the sequence you can see very clearly why the algorithm is called Pollard's $\rho$ algorithm. -
![Pollard's rho visualization](pollard_rho.png)
+
+ Pollard's rho visualization +
Yet, there is still an open question. How can we exploit the properties of the sequence $\{x_i \bmod p\}$ to our advantage without even knowing the number $p$ itself? diff --git a/src/algebra/sieve-of-eratosthenes.md b/src/algebra/sieve-of-eratosthenes.md index a07e6dc02..560d176e7 100644 --- a/src/algebra/sieve-of-eratosthenes.md +++ b/src/algebra/sieve-of-eratosthenes.md @@ -19,7 +19,9 @@ And we continue this procedure until we have processed all numbers in the row. In the following image you can see a visualization of the algorithm for computing all prime numbers in the range $[1; 16]$. It can be seen, that quite often we mark numbers as composite multiple times. -
![Sieve of Eratosthenes](sieve_eratosthenes.png)
+
+ Sieve of Eratosthenes +
The idea behind is this: A number is prime, if none of the smaller prime numbers divides it. diff --git a/src/data_structures/fenwick.md b/src/data_structures/fenwick.md index 82755b452..439885b83 100644 --- a/src/data_structures/fenwick.md +++ b/src/data_structures/fenwick.md @@ -128,7 +128,9 @@ 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. -
![Binary Indexed Tree](binary_indexed_tree.png)
+
+ Binary Indexed Tree +
## Implementation 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|$. -
![](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3e/Dot_Product.svg/300px-Dot_Product.svg.png)
+
+ +
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: -
![Vectors having same dot product with a](https://i.imgur.com/eyO7St4.png)
+
+ Vectors having same dot product with a +
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: -
![Three vectors](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3e/Parallelepiped_volume.svg/240px-Parallelepiped_volume.svg.png)
+
+ Three vectors +
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). -
![cross product](https://upload.wikimedia.org/wikipedia/commons/thumb/b/b0/Cross_product_vector.svg/250px-Cross_product_vector.svg.png)
+
+ cross product +
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/convex_hull_trick.md b/src/geometry/convex_hull_trick.md index f9c938fb1..052073e2c 100644 --- a/src/geometry/convex_hull_trick.md +++ b/src/geometry/convex_hull_trick.md @@ -17,7 +17,9 @@ The idea of this approach is to maintain a lower convex hull of linear functions Actually it would be a bit more convenient to consider them not as linear functions, but as points $(k;b)$ on the plane such that we will have to find the point which has the least dot product with a given point $(x;1)$, that is, for this point $kx+b$ is minimized which is the same as initial problem. Such minimum will necessarily be on lower convex envelope of these points as can be seen below: -
![lower convex hull](convex_hull_trick.png)
+
+ lower convex hull +
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: -
![Li Chao Tree vertex](li_chao_vertex.png)
+
+ Li Chao Tree vertex +
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: -
![Quad-Edge](quad-edge.png)
+
+ Quad-Edge +
In the algorithm we will use the following functions on edges: diff --git a/src/geometry/intersecting_segments.md b/src/geometry/intersecting_segments.md index a5eba5f6b..ac26c8fd5 100644 --- a/src/geometry/intersecting_segments.md +++ b/src/geometry/intersecting_segments.md @@ -16,18 +16,24 @@ The naive solution algorithm is to iterate over all pairs of segments in $O(n^2) Let's draw a vertical line $x = -\infty$ mentally and start moving this line to the right. In the course of its movement, this line will meet with segments, and at each time a segment intersect with our line it intersects in exactly one point (we will assume that there are no vertical segments). -
![sweep line and line segment intersection](sweep_line_1.png)
+
+ sweep line and line segment intersection +
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. -
![relative order of the segments across sweep line](sweep_line_2.png)
+
+ relative order of the segments across sweep line +
This order is interesting because intersecting segments will have the same $y$-coordinate at least at one time: -
![intersection point having same y-coordinate](sweep_line_3.png)
+
+ intersection point having same y-coordinate +
We formulate key statements: diff --git a/src/geometry/lattice-points.md b/src/geometry/lattice-points.md index 8bd9db346..e3d6faf7e 100644 --- a/src/geometry/lattice-points.md +++ b/src/geometry/lattice-points.md @@ -38,7 +38,9 @@ We have two cases: This amount is the same as the number of points such that $0 < y \leq (k - \lfloor k \rfloor) \cdot x + (b - \lfloor b \rfloor)$. So we reduced our problem to $k'= k - \lfloor k \rfloor$, $b' = b - \lfloor b \rfloor$ and both $k'$ and $b'$ less than $1$ now. Here is a picture, we just summed up blue points and subtracted the blue linear function from the black one to reduce problem to smaller values for $k$ and $b$: -
![Subtracting floored linear function](lattice.png)
+
+ Subtracting floored linear function +
- $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: -
![New reference and axes](mirror.png)
+
+ New reference and axes +
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 index 2aeb746af..4c725626e 100644 --- a/src/geometry/manhattan-distance.md +++ b/src/geometry/manhattan-distance.md @@ -12,7 +12,9 @@ $$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: -
![Manhattan Distance](https://upload.wikimedia.org/wikipedia/commons/thumb/0/08/Manhattan_distance.svg/220px-Manhattan_distance.svg.png)
+
+ Manhattan Distance +
This images show some of the smallest paths from one black point to the other, all of them with length $12$. @@ -77,7 +79,9 @@ Also, we may realize that $\alpha$ is a [spiral similarity](https://en.wikipedia Here's an image to help visualizing the transformation: -
![Chebyshev transformation](chebyshev-transformation.png)
+
+ Chebyshev transformation +
## Manhattan Minimum Spanning Tree diff --git a/src/geometry/minkowski.md b/src/geometry/minkowski.md index d3fd93d5d..f2661d867 100644 --- a/src/geometry/minkowski.md +++ b/src/geometry/minkowski.md @@ -41,7 +41,9 @@ We repeat the following steps while $i < |P|$ or $j < |Q|$. Here is a nice visualization, which may help you understand what is going on. -
![Visual](minkowski.gif)
+
+ Visual +
## 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/planar.md b/src/geometry/planar.md index 017399a7c..2cfc81282 100644 --- a/src/geometry/planar.md +++ b/src/geometry/planar.md @@ -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. -
![Planar graph with holes](planar_hole.png)
+
+ Planar graph with holes +
## Implementation The following implementation returns a vector of vertices for each face, outer face goes first. @@ -147,7 +149,9 @@ std::vector> find_faces(std::vector vertices, std::ve Sometimes you are not given a graph explicitly, but rather as a set of line segments on a plane, and the actual graph is formed by intersecting those segments, as shown in the picture below. In this case you have to build the graph manually. The easiest way to do so is as follows. Fix a segment and intersect it with all other segments. Then sort all intersection points together with the two endpoints of the segment lexicographically and add them to the graph as vertices. Also link each two adjacent vertices in lexicographical order by an edge. After doing this procedure for all edges we will obtain the graph. Of course, we should ensure that two equal intersection points will always correspond to the same vertex. The easiest way to do this is to store the points in a map by their coordinates, regarding points whose coordinates differ by a small number (say, less than $10^{-9}$) as equal. This algorithm works in $O(n^2 \log n)$. -
![Implicitly defined graph](planar_implicit.png)
+
+ Implicitly defined graph +
## 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. -
![Image of Goal](point_location_goal.png)
+
+ Image of Goal +
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. -
![Image of Events](point_location_events.png)
+
+ Image of Events +
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. -
!["Different cases of tangents common to two circles"](tangents-to-two-circles.png)
+
+ +
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. -
![Visual](triangle_union.png)
+
+ Visual +
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/2SAT.md b/src/graph/2SAT.md index b66316bbe..fbd1a6a35 100644 --- a/src/graph/2SAT.md +++ b/src/graph/2SAT.md @@ -39,7 +39,9 @@ b \Rightarrow a & \lnot b \Rightarrow \lnot a & b \Rightarrow \lnot a & c \Right You can see the implication graph in the following image: -
!["Implication Graph of 2-SAT example"](2SAT.png)
+
+ +
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. -
!["Strongly Connected Components of the 2-SAT example"](2SAT_SCC.png)
+
+ +
Now we construct the algorithm for finding the solution of the 2-SAT problem on the assumption that the solution exists. diff --git a/src/graph/edmonds_karp.md b/src/graph/edmonds_karp.md index ef844f970..a86a475f9 100644 --- a/src/graph/edmonds_karp.md +++ b/src/graph/edmonds_karp.md @@ -43,7 +43,9 @@ The source $s$ is origin of all the water, and the water can only drain in the s The following image shows a flow network. The first value of each edge represents the flow, which is initially 0, and the second value represents the capacity. -
![Flow network](Flow1.png)
+
+ Flow network +
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. -
![Maximal flow](Flow9.png)
+
+ Maximal flow +
## Ford-Fulkerson method @@ -79,7 +83,9 @@ 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. -
![Flow network](Flow1.png)
+
+ Flow network +
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. @@ -200,7 +206,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$. -
![Minimum cut](Cut.png)
+
+ Minimum cut +
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/hld.md b/src/graph/hld.md index bd56798fd..36caf852e 100644 --- a/src/graph/hld.md +++ b/src/graph/hld.md @@ -53,7 +53,9 @@ Since we can move from one heavy path to another only through a light edge (each The following image illustrates the decomposition of a sample tree. The heavy edges are thicker than the light edges. The heavy paths are marked by dotted boundaries. -
![Image of HLD](hld.png)
+
+ Image of HLD +
## Sample problems 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: -
![LCA_Euler_Tour](LCA_Euler.png)
+
+ LCA_Euler_Tour +
$$\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. -
![LCA_Euler_Tour](LCA_Euler.png)
+
+ LCA_Euler_Tour +
$$\begin{array}{|l|c|c|c|c|c|c|c|c|c|c|c|c|c|} \hline diff --git a/src/graph/rmq_linear.md b/src/graph/rmq_linear.md index 9ce17f341..ab0ae216a 100644 --- a/src/graph/rmq_linear.md +++ b/src/graph/rmq_linear.md @@ -24,7 +24,9 @@ The array `A` will be partitioned into 3 parts: the prefix of the array up to th The root of the tree will be a node corresponding to the minimum element of the array `A`, the left subtree will be the Cartesian tree of the prefix, and the right subtree will be a Cartesian tree of the suffix. In the following image you can see one array of length 10 and the corresponding Cartesian tree. -
![Image of Cartesian Tree](CartesianTree.png)
+
+ Image of Cartesian Tree +
The range minimum query `[l, r]` is equivalent to the lowest common ancestor query `[l', r']`, where `l'` is the node corresponding to the element `A[l]` and `r'` the node corresponding to the element `A[r]`. Indeed the node corresponding to the smallest element in the range has to be an ancestor of all nodes in the range, therefor also from `l'` and `r'`. @@ -33,7 +35,9 @@ And is also has to be the lowest ancestor, because otherwise `l'` and `r'` would In the following image you can see the LCA queries for the RMQ queries `[1, 3]` and `[5, 9]`. In the first query the LCA of the nodes `A[1]` and `A[3]` is the node corresponding to `A[2]` which has the value 2, and in the second query the LCA of `A[5]` and `A[9]` is the node corresponding to `A[8]` which has the value 3. -
![LCA queries in the Cartesian Tree](CartesianTreeLCA.png)
+
+ LCA queries in the Cartesian Tree +
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/topological-sort.md b/src/graph/topological-sort.md index acfad5331..909e40652 100644 --- a/src/graph/topological-sort.md +++ b/src/graph/topological-sort.md @@ -20,9 +20,9 @@ Here is one given graph together with its topological order: 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: -
-![second topological order](topological_3.png) -
+
+ second topological order +
A Topological order may **not exist** at all. It only exists, if the directed graph contains no cycles. diff --git a/src/others/stern_brocot_tree_farey_sequences.md b/src/others/stern_brocot_tree_farey_sequences.md index bb9dfd725..f725de53b 100644 --- a/src/others/stern_brocot_tree_farey_sequences.md +++ b/src/others/stern_brocot_tree_farey_sequences.md @@ -34,7 +34,9 @@ Continuing this process to infinity this covers *all* positive fractions. Additi Before proving these properties, let us actually show a visualization of the Stern-Brocot tree, rather than the list representation. Every fraction in the tree has two children. Each child is the mediant of the closest ancestor on the left and closest ancestor to the right. -
![Stern-Brocot tree](https://upload.wikimedia.org/wikipedia/commons/thumb/3/37/SternBrocotTree.svg/1024px-SternBrocotTree.svg.png)
+
+ Stern-Brocot tree +
## Proofs diff --git a/src/others/tortoise_and_hare.md b/src/others/tortoise_and_hare.md index 9d2ba0a96..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: -
!["Linked list with cycle"](tortoise_hare_algo.png)
+
+ +
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. -
!["Found cycle"](tortoise_hare_cycle_found.png)
+
+ +
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. -
!["Proof"](tortoise_hare_proof.png)
+
+ +
$slowDist = a + xL + b$ , $x\ge0$