add Levinstein distance with Dynamic Programming: up -> down approach
diff --git a/dynamic_programming/min_distance_up_bottom.py b/dynamic_programming/min_distance_up_bottom.py
new file mode 100644
index 000000000000..49c361f24d45
--- /dev/null
+++ b/dynamic_programming/min_distance_up_bottom.py
@@ -0,0 +1,55 @@
+"""
+Author  : Alexander Pantyukhin
+Date    : October 14, 2022
+This is implementation Dynamic Programming up bottom approach
+to find edit distance.
+The aim is to demonstate up bottom approach for solving the task.
+The implementation was tested on the
+leetcode: https://leetcode.com/problems/edit-distance/
+"""
+
+"""
+Levinstein distance
+Dynamic Programming: up -> down.
+"""
+
+
+def min_distance_up_bottom(word1: str, word2: str) -> int:
+    """
+    >>> min_distance_up_bottom("intention", "execution")
+    5
+    >>> min_distance_up_bottom("intention", "")
+    9
+    >>> min_distance_up_bottom("", "")
+    0
+    >>> min_distance_up_bottom("zooicoarchaeologist", "zoologist")
+    10
+    """
+
+    from functools import lru_cache
+
+    len_word1 = len(word1)
+    len_word2 = len(word2)
+
+    @lru_cache(maxsize=None)
+    def min_distance(index1: int, index2: int) -> int:
+        # if first word index is overflow - delete all from the second word
+        if index1 >= len_word1:
+            return len_word2 - index2
+        # if second word index is overflow - delete all from the first word
+        if index2 >= len_word2:
+            return len_word1 - index1
+        diff = int(word1[index1] != word2[index2])  # current letters not identical
+        return min(
+            1 + min_distance(index1 + 1, index2),
+            1 + min_distance(index1, index2 + 1),
+            diff + min_distance(index1 + 1, index2 + 1),
+        )
+
+    return min_distance(0, 0)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

### Describe your change:
Levinstein distance with Dynamic Programming: up -> down approach. some tests are copied from https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py#L61 .

* [x] Add an algorithm?
* [ ] Fix a bug or typo in an existing algorithm?
* [ ] Documentation change?

### Checklist:
* [x] I have read [CONTRIBUTING.md](https://github.com/TheAlgorithms/Python/blob/master/CONTRIBUTING.md).
* [x] This pull request is all my own work -- I have not plagiarized.
* [x] I know that pull requests will not be merged if they fail the automated tests.
* [x] This PR only changes one algorithm file.  To ease review, please open separate PRs for separate algorithms.
* [x] All new Python files are placed inside an existing directory.
* [x] All filenames are in all lowercase characters with no spaces or dashes.
* [x] All functions and variable names follow Python naming conventions.
* [x] All function parameters and return values are annotated with Python [type hints](https://docs.python.org/3/library/typing.html).
* [x] All functions have [doctests](https://docs.python.org/3/library/doctest.html) that pass the automated testing.
* [ ] All new algorithms have a URL in its comments that points to Wikipedia or other similar explanation.
* [x] If this pull request resolves one or more open issues then the commit message contains `Fixes: #{$ISSUE_NO}`.
