upd

content/tracks/algorithms-101/leetcode/easy/141.en.md

@@ -13,13 +13,10 @@ weight: 141
 
 [LeetCode problem 141](https://leetcode.com/problems/linked-list-cycle/)
 
-
-
 ## Problem Statement
 
 The problem asks us to determine if a given linked list contains a cycle. A cycle in a linked list occurs when a node's `next` pointer points back to a previous node in the list, causing an infinite loop.
 
-
 ## Hints & Tips
 
 In this problem, you can take advantage of the Floyd's "Tortoise and Hare" cycle detection algorithm. This algorithm allows you to detect a cycle in O(1) space and O(n) time complexity, where n is the number of nodes.
@@ -34,8 +31,6 @@ In this problem, you can take advantage of the Floyd's "Tortoise and Hare" cycle
 - **Step 2:** Move `slow` one step and `fast` two steps in a loop.
 - **Step 3:** If `fast` and `slow` meet at any point, return `True`. If `fast` reaches the end, return `False`.
 
-
-
 ## Solution | Pointers
 
 Here's the Python code for this algorithm, commented for clarity:
@@ -75,4 +70,3 @@ class Solution:
             visited.add(cur)
         return False
 ```
-

content/tracks/algorithms-101/leetcode/easy/206/index.en.md

@@ -13,7 +13,6 @@ weight: 206
 
 [LeetCode problem 206](https://leetcode.com/problems/reverse-linked-list/description/)
 
-
 ## Problem Statement
 
 Reverse a given singly linked list and return its head. A singly linked list is a data structure consisting of nodes, where each node has a value and a reference to the next node in the sequence.
@@ -23,17 +22,17 @@ Reverse a given singly linked list and return its head. A singly linked list is
 A naive approach could be to traverse the entire linked list once to read all its elements into an array. Then, we could reverse the array and construct a new linked list from it. This would work, but it takes up additional space for the array.
 
 ![LeetCode 206. Reverse Linked List | Python solution](https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg)
+
 ## Hints & Tips
 
 An efficient way to approach this problem is by using pointers to reverse the links between the nodes directly within the linked list, without using additional space.
 
-
 We will discuss two approaches to solve this problem: Iterative and Recursive.
 
-
 ## Iterative
 
 ### Approach
+
 1. Initialize three pointers: `prev` as `None`, `current` as the head of the linked list, and `next` as `None`.
 2. Traverse the linked list, reversing the `next` pointers of each node to point to its previous node.
 
@@ -62,15 +61,15 @@ class Solution:
         return prev
 ```
 
-
 ## Recursive
-###  Approach
+
+### Approach
+
 1. Traverse to the end of the list.
 2. As the recursion stack unwinds, change the `next` pointers to create the reversed list.
 
+### Steps
 
-
-###  Steps
 1. Base case: If the `head` or `head.next` is `None`, return `head`.
 2. Recursively reverse the rest of the list.
 3. Change the next-next pointer to reverse the list.

content/tracks/algorithms-101/leetcode/easy/206/index.ru.md

@@ -44,8 +44,6 @@ weight: 206
    4. current = next (2)
    5. После данных перестановок текущий указатель смотрит на 2, следующий по счету узел.
 
-
-
 ## Алгоритм
 
 1. **Инициализация**: Инициализируем два указателя — один (`curr`) для текущего элемента и другой (`prev`) для предыдущего. Изначально `prev` будет `None`.
@@ -57,7 +55,6 @@ weight: 206
 
 3. **Возврат результата**: В конце `prev` будет указывать на новую голову списка.
 
-
 ## Решение
 
 ```python

content/tracks/algorithms-101/leetcode/medium/1448/index.ru.md

@@ -6,7 +6,7 @@ toc: true
 tags: [Binary Tree, DFS, Medium]
 categories: [Algorithms, Medium, LeetCode]
 date: 2023-08-28
-lastmod: 2023-08-28
+lastMod: 2023-09-05
 weight: 1448
 ---
 
@@ -18,16 +18,25 @@ weight: 1448
 
 ## Подсказки
 
-Используйте метод обхода в глубину (DFS) для решения этой задачи.
+"Хороший" узел в дереве — это узел, для которого все узлы на пути от корня до этого узла имеют значение не больше, чем значение этого узла.
+
+Использовать метод обхода в глубину (DFS) для решения этой задачи.
 
 ## Подход
 
+Идея решения задачи заключается в рекурсивном обходе дерева с сохранением максимального значения на пути от корня к текущему узлу. На каждом этапе, когда мы доходим до нового узла, мы сравниваем его значение с максимальным значением на пути. Если значение узла не меньше максимального, значит, это "хороший" узел.
+
+Этот метод обеспечивает простой и понятный способ решения задачи, хотя и может быть не самым оптимальным по времени и памяти.
+
 1. **Обход в глубину (DFS)**: Используйте рекурсивный метод для обхода дерева.
 2. **Текущий максимум**: На каждом шаге рекурсии передавайте текущее максимальное значение на пути от корня.
 3. **Сравнение узлов**: Сравните значение текущего узла с текущим максимумом. Если значение узла больше или равно, увеличьте счетчик "хороших" узлов.
 
 ## Алгоритм
 
+1. Рекурсивно обходить дерево, начиная с корня.
+2. В процессе обхода обновлять максимальное значение на пути и считать "хорошие" узлы.
+
 1. Инициализируйте счетчик "хороших" узлов как 0.
 2. Запустите рекурсивный DFS, начиная с корня дерева и передавая значение корня как текущий максимум.
 3. В рекурсивной функции сравните значение текущего узла с переданным максимумом.

content/tracks/algorithms-101/leetcode/medium/437/index.ru.md

@@ -4,31 +4,41 @@ seoTitle: LeetCode 437. Path Sum III | Решение на Python.
 description: LeetCode 437. Найти количество всех путей в бинарном дереве, которые суммируются в определенное число. Разбор задачи.
 toc: true
 tags: [Binary Tree, DFS, Easy]
-categories: [Algorithms, Easy, LeetCode]
+categories: [Algorithms, Easy, LeetCodeTop75]
 date: 2023-08-28
-lastmod: 2023-08-28
+lastmod: 2023-09-05
 featuredImage: https://picsum.photos/700/241?grayscale
-weight: 210
+weight: 437
 ---
 
 [LeetCode задача 437](<https://leetcode.com/problems/path-sum-iii/>)
 
 ## Задача
 
-Вы должны вернуть количество путей в данном бинарном дереве, которые суммируются в определенное число. Путь не обязан начинаться или заканчиваться на корне или листьях, но он должен двигаться вниз (с родителя на потомка).
+Дан корень бинарного дерева, в котором каждый узел содержит целочисленное значение. Найти количество путей в этом дереве, в которых сумма значений узлов равна заданному числу `sum`.
+
+Путь может начинаться и заканчиваться на любом узле, но он должен идти вниз (с родителя к потомку).
 
 ## Подсказки
 
-Используйте Depth-First Search (DFS) для решения задачи.
+Задачу можно решить, используя рекурсивный обход дерева. (Depth-First Search (DFS)).
 
 ## Подход
 
+Идея заключается в рекурсивном обходе каждого узла и подсчете всех возможных путей с заданной суммой, начиная с этого узла. После этого нужно агрегировать эти значения для всех узлов.
+
+Одним из наиболее простых способов решения является рекурсивный обход дерева и проверка каждого возможного пути. Это можно сделать, запустив рекурсию для каждого узла в дереве, начиная с корня, и для каждого из них рекурсивно проверять все возможные пути вниз по дереву.
+
+## Алгоритм
+
 1. **DFS с "памятью"**: Мы можем использовать DFS, чтобы пройти по всем путям в дереве, и на каждом этапе проверить, сколько путей можно завершить в этом узле с нужной суммой.
 2. **Хранение промежуточных сумм**: По мере движения вниз по дереву, мы можем хранить сумму всех узлов в текущем пути. Это позволит нам быстро проверить, можно ли создать подпуть с нужной суммой.
 3. **Обновление ответа**: Когда мы достигаем листа, мы можем проверить, создает ли текущий путь нужную сумму. Если да, увеличьте счетчик.
 4. **Возврат результата**: В конечном итоге верните количество всех подходящих путей.
 
-## Алгоритм
+1. Начните с корня дерева и рекурсивно обходите все узлы.
+2. Для каждого узла запустите еще одну рекурсию, чтобы проверить все пути, начинающиеся с этого узла.
+3. Подсчитайте количество путей, которые дают заданную сумму.
 
 1. Инициализируйте переменную для подсчета количества путей.
 2. Запустите DFS с корня дерева.

content/tracks/algorithms-101/leetcode75.en.md

@@ -95,8 +95,8 @@ weight: 16
 | :---: | ---------------------------------------------------------------------- | ---------- |
 |  33   | [104. Maximum Depth of Binary Tree](../leetcode/easy/104)              | Easy       |
 |  34   | [872. Leaf-Similar Trees](../leetcode/easy/872)                        | Easy       |
-|  35   | [1448.Count Good Nodes in Binary Tree](../leetcode/medium/1448)        | Medium     |
-|  36   | [437.Path Sum III](../leetcode/medium/437)                             | Medium     |
+|  35   | [1448. Count Good Nodes in Binary Tree](../leetcode/medium/1448)       | Medium     |
+|  36   | [437. Path Sum III](../leetcode/medium/437)                            | Medium     |
 |  37   | [1372. Longest ZigZag Path in a Binary Tree](../leetcode/medium/1372)  | Medium     |
 |  38   | [236. Lowest Common Ancestor of a Binary Tree](../leetcode/medium/236) | Medium     |