feat: add articles to hard challenges

Author: IbatoLionDev

3-HARD/Python/1-travelling-salesman-bitmasking/article.md

@@ -0,0 +1,89 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Implement a solution for the travelling salesman problem using dynamic programming with bitmasking. This challenge requires optimizing the search in an exponential state space. Use object-oriented programming and follow the DRY principle.
+
+### Code Explanation
+The `TravellingSalesman` class uses dynamic programming with bitmasking to solve the problem efficiently. It keeps track of visited cities using a bitmask and memoizes results to avoid redundant calculations.
+
+The `tsp` method recursively explores all unvisited cities, calculating the minimum cost to complete the tour and return to the start.
+
+### Relevant Code Snippet
+
+```python
+from typing import List
+
+class TravellingSalesman:
+    def __init__(self, graph: List[List[int]]):
+        self.graph = graph
+        self.n = len(graph)
+        self.ALL_VISITED = (1 << self.n) - 1
+        self.memo = [[-1] * (1 << self.n) for _ in range(self.n)]
+
+    def tsp(self, pos: int, visited: int) -> int:
+        if visited == self.ALL_VISITED:
+            return self.graph[pos][0]  # return to start
+
+        if self.memo[pos][visited] != -1:
+            return self.memo[pos][visited]
+
+        ans = float('inf')
+        for city in range(self.n):
+            if (visited >> city) & 1 == 0:
+                new_visited = visited | (1 << city)
+                cost = self.graph[pos][city] + self.tsp(city, new_visited)
+                ans = min(ans, cost)
+
+        self.memo[pos][visited] = ans
+        return ans
+```
+
+### Historical Context
+The travelling salesman problem (TSP) is a classic NP-hard problem in combinatorial optimization. Dynamic programming with bitmasking is a well-known approach to solve small instances efficiently by representing subsets of cities as bitmasks.
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Implementa una solución para el problema del viajante de comercio usando programación dinámica con bitmasking. Este reto requiere optimizar la búsqueda en un espacio de estados exponencial. Usa programación orientada a objetos y sigue el principio DRY.
+
+### Explicación del Código
+La clase `TravellingSalesman` usa programación dinámica con bitmasking para resolver el problema eficientemente. Lleva un registro de las ciudades visitadas usando un bitmask y memoiza resultados para evitar cálculos redundantes.
+
+El método `tsp` explora recursivamente todas las ciudades no visitadas, calculando el costo mínimo para completar el recorrido y regresar al inicio.
+
+### Fragmento de Código Relevante
+
+```python
+from typing import List
+
+class TravellingSalesman:
+    def __init__(self, graph: List[List[int]]):
+        self.graph = graph
+        self.n = len(graph)
+        self.ALL_VISITED = (1 << self.n) - 1
+        self.memo = [[-1] * (1 << self.n) for _ in range(self.n)]
+
+    def tsp(self, pos: int, visited: int) -> int:
+        if visited == self.ALL_VISITED:
+            return self.graph[pos][0]  # regresar al inicio
+
+        if self.memo[pos][visited] != -1:
+            return self.memo[pos][visited]
+
+        ans = float('inf')
+        for city in range(self.n):
+            if (visited >> city) & 1 == 0:
+                new_visited = visited | (1 << city)
+                cost = self.graph[pos][city] + self.tsp(city, new_visited)
+                ans = min(ans, cost)
+
+        self.memo[pos][visited] = ans
+        return ans
+```
+
+### Contexto Histórico
+El problema del viajante de comercio (TSP) es un problema clásico NP-hard en optimización combinatoria. La programación dinámica con bitmasking es un enfoque conocido para resolver instancias pequeñas eficientemente representando subconjuntos de ciudades como bitmasks.

3-HARD/Python/10-word-break/article.md

@@ -0,0 +1,95 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Given a string and a dictionary, return all possible valid sentences that can be formed. This challenge requires recursion with memoization to avoid redundant solutions and explore multiple paths. Use object-oriented programming and follow the DRY principle.
+
+### Code Explanation
+The `WordBreak` class uses recursion with memoization to find all valid sentences that can be formed from the input string using words from the dictionary.
+
+Key points:
+- The `word_break` method recursively explores all substrings starting from the current index.
+- Memoization stores results for each start index to avoid redundant computations.
+- Sentences are constructed by concatenating valid words with results from recursive calls.
+
+### Relevant Code Snippet
+
+```python
+from typing import List, Set, Dict
+
+class WordBreak:
+    def __init__(self, s: str, word_dict: Set[str]):
+        self.s = s
+        self.word_dict = word_dict
+        self.memo: Dict[int, List[str]] = {}
+
+    def word_break(self, start: int = 0) -> List[str]:
+        if start == len(self.s):
+            return [""]
+
+        if start in self.memo:
+            return self.memo[start]
+
+        sentences = []
+        for end in range(start + 1, len(self.s) + 1):
+            word = self.s[start:end]
+            if word in self.word_dict:
+                for subsentence in self.word_break(end):
+                    sentence = word + (" " + subsentence if subsentence else "")
+                    sentences.append(sentence)
+
+        self.memo[start] = sentences
+        return sentences
+```
+
+### Historical Context
+The word break problem is a classic example of recursion with memoization, commonly used in natural language processing and text segmentation tasks. It efficiently explores multiple segmentation paths while avoiding redundant computations.
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Dada una cadena y un diccionario, devuelve todas las posibles oraciones válidas que se pueden formar. Este reto requiere recursión con memoización para evitar soluciones redundantes y explorar múltiples caminos. Usa programación orientada a objetos y sigue el principio DRY.
+
+### Explicación del Código
+La clase `WordBreak` usa recursión con memoización para encontrar todas las oraciones válidas que se pueden formar a partir de la cadena de entrada usando palabras del diccionario.
+
+Puntos clave:
+- El método `word_break` explora recursivamente todos los subcadenas desde el índice actual.
+- La memoización almacena resultados para cada índice de inicio para evitar cálculos redundantes.
+- Las oraciones se construyen concatenando palabras válidas con resultados de llamadas recursivas.
+
+### Fragmento de Código Relevante
+
+```python
+from typing import List, Set, Dict
+
+class WordBreak:
+    def __init__(self, s: str, word_dict: Set[str]):
+        self.s = s
+        self.word_dict = word_dict
+        self.memo: Dict[int, List[str]] = {}
+
+    def word_break(self, start: int = 0) -> List[str]:
+        if start == len(self.s):
+            return [""]
+
+        if start in self.memo:
+            return self.memo[start]
+
+        sentences = []
+        for end in range(start + 1, len(self.s) + 1):
+            word = self.s[start:end]
+            if word in self.word_dict:
+                for subsentence in self.word_break(end):
+                    sentence = word + (" " + subsentence if subsentence else "")
+                    sentences.append(sentence)
+
+        self.memo[start] = sentences
+        return sentences
+```
+
+### Contexto Histórico
+El problema de segmentación de palabras es un ejemplo clásico de recursión con memoización, comúnmente usado en procesamiento de lenguaje natural y tareas de segmentación de texto. Explora eficientemente múltiples caminos de segmentación evitando cálculos redundantes.

3-HARD/Python/2-maximum-flow-edmonds-karp/article.md

@@ -0,0 +1,127 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Develop the Edmonds-Karp algorithm to calculate the maximum flow in a network. This challenge deepens advanced graph handling and data structures to improve efficiency. Use object-oriented programming and follow the DRY principle.
+
+### Code Explanation
+The `EdmondsKarp` class implements the Edmonds-Karp algorithm using a residual graph and BFS to find augmenting paths. The `max_flow` method repeatedly finds paths from source to sink with available capacity, updates the residual graph, and accumulates the flow until no more augmenting paths exist.
+
+### Relevant Code Snippet
+
+```python
+from collections import deque
+from typing import List
+
+class EdmondsKarp:
+    def __init__(self, graph: List[List[int]]):
+        self.graph = graph
+        self.n = len(graph)
+        self.residual_graph = [row[:] for row in graph]
+
+    def bfs(self, source: int, sink: int, parent: List[int]) -> bool:
+        visited = [False] * self.n
+        queue = deque([source])
+        visited[source] = True
+
+        while queue:
+            u = queue.popleft()
+            for v, capacity in enumerate(self.residual_graph[u]):
+                if not visited[v] and capacity > 0:
+                    queue.append(v)
+                    visited[v] = True
+                    parent[v] = u
+                    if v == sink:
+                        return True
+        return False
+
+    def max_flow(self, source: int, sink: int) -> int:
+        parent = [-1] * self.n
+        max_flow = 0
+
+        while self.bfs(source, sink, parent):
+            path_flow = float('inf')
+            s = sink
+            while s != source:
+                path_flow = min(path_flow, self.residual_graph[parent[s]][s])
+                s = parent[s]
+
+            max_flow += path_flow
+
+            v = sink
+            while v != source:
+                u = parent[v]
+                self.residual_graph[u][v] -= path_flow
+                self.residual_graph[v][u] += path_flow
+                v = parent[v]
+
+        return max_flow
+```
+
+### Historical Context
+The Edmonds-Karp algorithm is an implementation of the Ford-Fulkerson method for computing the maximum flow in a flow network. It uses BFS to find shortest augmenting paths, improving efficiency and guaranteeing polynomial time complexity.
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Desarrolla el algoritmo de Edmonds-Karp para calcular el flujo máximo en una red. Este reto profundiza en el manejo avanzado de grafos y estructuras de datos para mejorar la eficiencia. Usa programación orientada a objetos y sigue el principio DRY.
+
+### Explicación del Código
+La clase `EdmondsKarp` implementa el algoritmo de Edmonds-Karp usando un grafo residual y BFS para encontrar caminos aumentantes. El método `max_flow` encuentra repetidamente caminos desde la fuente al sumidero con capacidad disponible, actualiza el grafo residual y acumula el flujo hasta que no existan más caminos aumentantes.
+
+### Fragmento de Código Relevante
+
+```python
+from collections import deque
+from typing import List
+
+class EdmondsKarp:
+    def __init__(self, graph: List[List[int]]):
+        self.graph = graph
+        self.n = len(graph)
+        self.residual_graph = [row[:] for row in graph]
+
+    def bfs(self, source: int, sink: int, parent: List[int]) -> bool:
+        visited = [False] * self.n
+        queue = deque([source])
+        visited[source] = True
+
+        while queue:
+            u = queue.popleft()
+            for v, capacity in enumerate(self.residual_graph[u]):
+                if not visited[v] and capacity > 0:
+                    queue.append(v)
+                    visited[v] = True
+                    parent[v] = u
+                    if v == sink:
+                        return True
+        return False
+
+    def max_flow(self, source: int, sink: int) -> int:
+        parent = [-1] * self.n
+        max_flow = 0
+
+        while self.bfs(source, sink, parent):
+            path_flow = float('inf')
+            s = sink
+            while s != source:
+                path_flow = min(path_flow, self.residual_graph[parent[s]][s])
+                s = parent[s]
+
+            max_flow += path_flow
+
+            v = sink
+            while v != source:
+                u = parent[v]
+                self.residual_graph[u][v] -= path_flow
+                self.residual_graph[v][u] += path_flow
+                v = parent[v]
+
+        return max_flow
+```
+
+### Contexto Histórico
+El algoritmo de Edmonds-Karp es una implementación del método de Ford-Fulkerson para calcular el flujo máximo en una red de flujo. Usa BFS para encontrar los caminos aumentantes más cortos, mejorando la eficiencia y garantizando complejidad polinómica.