Fix

Author: MaximSmolskiy

dynamic_programming/knapsack.py

@@ -108,7 +108,8 @@ def _construct_solution(dp: list, wt: list, i: int, j: int, optimal_set: set):
     Parameters
     ----------
 
-    * `dp`: list of list, the table of a solved integer weight dynamic programming problem
+    * `dp`: list of list, the table of a solved integer weight dynamic programming
+      problem
     * `wt`: list or tuple, the vector of weights of the items
     * `i`: int, the index of the item under consideration
     * `j`: int, the current possible maximum weight

dynamic_programming/matrix_chain_multiplication.py

@@ -17,13 +17,13 @@
 
   python -m doctest -v matrix_chain_multiply.py
 
-Given a sequence ``arr[]`` that represents chain of 2D matrices such that the dimension of
-the ``i`` th matrix is ``arr[i-1]*arr[i]``.
+Given a sequence ``arr[]`` that represents chain of 2D matrices such that the dimension
+of the ``i`` th matrix is ``arr[i-1]*arr[i]``.
 So suppose ``arr = [40, 20, 30, 10, 30]`` means we have ``4`` matrices of dimensions
 ``40*20``, ``20*30``, ``30*10`` and ``10*30``.
 
-``matrix_chain_multiply()`` returns an integer denoting minimum number of multiplications to
-multiply the chain.
+``matrix_chain_multiply()`` returns an integer denoting minimum number of
+multiplications to multiply the chain.
 
 We do not need to perform actual multiplication here.
 We only need to decide the order in which to perform the multiplication.
@@ -32,7 +32,8 @@
   1. Number of multiplications (ie cost) to multiply ``2`` matrices
      of size ``m*p`` and ``p*n`` is ``m*p*n``.
   2. Cost of matrix multiplication is not associative ie ``(M1*M2)*M3 != M1*(M2*M3)``
-  3. Matrix multiplication is not commutative. So, ``M1*M2`` does not mean ``M2*M1`` can be done.
+  3. Matrix multiplication is not commutative. So, ``M1*M2`` does not mean ``M2*M1``
+     can be done.
   4. To determine the required order, we can try different combinations.
 
 So, this problem has overlapping sub-problems and can be solved using recursion.

dynamic_programming/regex_match.py

@@ -11,7 +11,7 @@
 
 
 def recursive_match(text: str, pattern: str) -> bool:
-    """
+    r"""
     Recursive matching algorithm.
 
     | Time complexity: O(2^(\|text\| + \|pattern\|))
@@ -50,7 +50,7 @@ def recursive_match(text: str, pattern: str) -> bool:
 
 
 def dp_match(text: str, pattern: str) -> bool:
-    """
+    r"""
     Dynamic programming matching algorithm.
 
     | Time complexity: O(\|text\| * \|pattern\|)

dynamic_programming/rod_cutting.py

@@ -69,8 +69,8 @@ def top_down_cut_rod(n: int, prices: list):
       price for a rod of length ``i``
 
     .. note::
-      For convenience and because Python's lists using ``0``-indexing, ``length(max_rev) =
-      n + 1``, to accommodate for the revenue obtainable from a rod of length ``0```.
+      For convenience and because Python's lists using ``0``-indexing, ``length(max_rev)
+      = n + 1``, to accommodate for the revenue obtainable from a rod of length ``0``.
 
     Returns
     -------