Merge branch 'main' into master

izanbf1803 · web-flow · commit e3fe98e884f8 · 2025-08-27T01:30:06.000+02:00
diff --git a/src/combinatorics/burnside.md b/src/combinatorics/burnside.md
@@ -280,3 +280,4 @@ int solve(int n, int m) {
 * [SPOJ - Sorting Machine](https://www.spoj.com/problems/SRTMACH/)
 * [Project Euler - Pizza Toppings](https://projecteuler.net/problem=281)
 * [ICPC 2011 SERCP - Alphabet Soup](https://basecamp.eolymp.com/tr/problems/3064)
+* [GCPC 2017 - Buildings](https://basecamp.eolymp.com/en/problems/11615)
diff --git a/src/dynamic_programming/intro-to-dp.md b/src/dynamic_programming/intro-to-dp.md
@@ -132,9 +132,9 @@ One of the tricks to getting better at dynamic programming is to study some of t
 ## Classic Dynamic Programming Problems
 | Name                                           | Description/Example                                                                                                                                                                                                            |
 | ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| 0-1 Knapsack                                   | Given $W$, $N$, and $N$ items with weights $w_i$ and values $v_i$, what is the maximum $\sum_{i=1}^{k} v_i$ for each subset of items of size $k$ ($1 \le k \le N$) while ensuring $\sum_{i=1}^{k} w_i \le W$?                  |
+| [0-1 Knapsack](../dynamic_programming/knapsack.md)                                   | 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.                                                       |
+| [Longest Increasing Subsequence (LIS)](../dynamic_programming/longest_increasing_subsequence.md)           | 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).                                                                                                                                                                      |
@@ -143,7 +143,7 @@ One of the tricks to getting better at dynamic programming is to study some of t
 | 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
+* [Bitmask Dynamic Programming](../dynamic_programming/profile-dynamics.md)
 * Digit Dynamic Programming
 * Dynamic Programming on Trees
 
diff --git a/src/dynamic_programming/longest_increasing_subsequence.md b/src/dynamic_programming/longest_increasing_subsequence.md
diff --git a/src/geometry/enclosing-circle.md b/src/geometry/enclosing-circle.md
@@ -13,19 +13,19 @@ Consider the following problem:
 
     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.
+Here, by the minimum enclosing circle (MEC) we mean a circle with minimum possible radius that contains all the $n$ points, 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.
+    Consider the following setup: Let $r$ be the radius of the MEC. We draw a circle of radius $r$ around each of the points $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.
+    Alternatively, we can also assume that there are two MECs, and then notice that their intersection (which contains the points $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
 
diff --git a/src/geometry/point-in-convex-polygon.md b/src/geometry/point-in-convex-polygon.md
@@ -120,5 +120,6 @@ bool pointInConvexPolygon(pt point) {
 ```
 
 ## Problems
-[SGU253 Theodore Roosevelt](https://codeforces.com/problemsets/acmsguru/problem/99999/253)
-[Codeforces 55E Very simple problem](https://codeforces.com/contest/55/problem/E)
+* [SGU253 Theodore Roosevelt](https://codeforces.com/problemsets/acmsguru/problem/99999/253)
+* [Codeforces 55E Very simple problem](https://codeforces.com/contest/55/problem/E)
+* [Codeforces 166B Polygons](https://codeforces.com/problemset/problem/166/B)
diff --git a/src/graph/bridge-searching.md b/src/graph/bridge-searching.md
@@ -22,7 +22,7 @@ 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 $\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:
+So, let $\mathtt{tin}[v]$ denote entry time for node $v$. We introduce an array $\mathtt{low}$ which will let us store the earliest entry time of the node 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:
 
 $$\mathtt{low}[v] = \min \left\{ 
     \begin{array}{l}
diff --git a/src/navigation.md b/src/navigation.md
@@ -63,6 +63,7 @@ search:
 - Dynamic Programming
     - [Introduction to Dynamic Programming](dynamic_programming/intro-to-dp.md)
     - [Knapsack Problem](dynamic_programming/knapsack.md)
+    - [Longest increasing subsequence](dynamic_programming/longest_increasing_subsequence.md)
     - DP optimizations
         - [Divide and Conquer DP](dynamic_programming/divide-and-conquer-dp.md)
         - [Knuth's Optimization](dynamic_programming/knuth-optimization.md)
@@ -205,7 +206,6 @@ search:
 - Miscellaneous
     - Sequences
         - [RMQ task (Range Minimum Query - the smallest element in an interval)](sequences/rmq.md)
-        - [Longest increasing subsequence](sequences/longest_increasing_subsequence.md)
         - [Search the subsegment with the maximum/minimum sum](others/maximum_average_segment.md)
         - [K-th order statistic in O(N)](sequences/k-th.md)
         - [MEX task (Minimal Excluded element in an array)](sequences/mex.md)
diff --git a/src/sequences/longest_increasing_subsequence.md b/src/sequences/longest_increasing_subsequence.md
diff --git a/src/string/z-function.md b/src/string/z-function.md
