fix some absolute links

jakobkogler · jakobkogler · commit 7935df482fb2 · 2023-09-24T19:42:01.000+02:00
diff --git a/src/data_structures/sqrt-tree.md b/src/data_structures/sqrt-tree.md
@@ -17,7 +17,7 @@ Sqrt Tree can process such queries in $O(1)$ time with $O(n \cdot \log \log n)$
 
 ### Building sqrt decomposition
 
-Let's make a [sqrt decomposition](/data_structures/sqrt_decomposition.html). We divide our array in $\sqrt{n}$ blocks, each block has size $\sqrt{n}$. For each block, we compute:
+Let's make a [sqrt decomposition](sqrt_decomposition.md). We divide our array in $\sqrt{n}$ blocks, each block has size $\sqrt{n}$. For each block, we compute:
 
 1. Answers to the queries that lie in the block and begin at the beginning of the block ($\text{prefixOp}$)
 2. Answers to the queries that lie in the block and end at the end of the block ($\text{suffixOp}$)
diff --git a/src/others/josephus_problem.md b/src/others/josephus_problem.md
@@ -18,7 +18,7 @@ It is required to find the last number.
 This task was set by **Flavius Josephus** in the 1st century (though in a somewhat narrower formulation: for $k = 2$).
 
 This problem can be solved by modeling the procedure.
-Brute force modeling will work $O(n^{2})$. Using a [Segment Tree](/data_structures/segment_tree.html), we can improve it to $O(n \log n)$.
+Brute force modeling will work $O(n^{2})$. Using a [Segment Tree](../data_structures/segment_tree.md), we can improve it to $O(n \log n)$.
 We want something better though.
 
 ## Modeling a $O(n)$ solution
diff --git a/src/string/manacher.md b/src/string/manacher.md
@@ -32,7 +32,7 @@ It's a surprising fact that there is an algorithm, which is simple enough, that
 
 ## Solution
 
-In general, this problem has many solutions: with [String Hashing](/string/string-hashing.html) it can be solved in $O(n\cdot \log n)$, and with [Suffix Trees](/string/suffix-tree-ukkonen.html) and fast LCA this problem can be solved in $O(n)$.
+In general, this problem has many solutions: with [String Hashing](string-hashing.md) it can be solved in $O(n\cdot \log n)$, and with [Suffix Trees](suffix-tree-ukkonen.md) and fast LCA this problem can be solved in $O(n)$.
 
 But the method described here is **sufficiently** simpler and has less hidden constant in time and memory complexity. This algorithm was discovered by **Glenn K. Manacher** in 1975.
 
@@ -124,7 +124,7 @@ Again, we should not forget to update the values $(l, r)$ after calculating each
 
 At the first glance it's not obvious that this algorithm has linear time complexity, because we often run the naive algorithm while searching the answer for a particular position.
 
-However, a more careful analysis shows that the algorithm is linear. In fact, [Z-function building algorithm](/string/z-function.html), which looks similar to this algorithm, also works in linear time.
+However, a more careful analysis shows that the algorithm is linear. In fact, [Z-function building algorithm](z-function.md), which looks similar to this algorithm, also works in linear time.
 
 We can notice that every iteration of trivial algorithm increases $r$ by one. Also $r$ cannot be decreased during the algorithm. So, trivial algorithm will make $O(n)$ iterations in total.
 
