[main] Added DP solution for longest increasing path in matrix and permutation solution as well

Author: cthacker-udel

pythonProblems/longestIncreasingPath/longestIncreasingPathInMatrix.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from typing import List, Optional
+
+
+class Solution:
+    def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
+        base_len = len(matrix)
+        col_len = len(matrix[0])
+        range_base = range(base_len)
+        range_col = range(col_len)
+        longest_paths = [[1] * col_len for x in range_base]
+        for i in range(len(matrix)):
+            for j in range(len(matrix[0])):
+                self.find_longest_path(matrix, longest_paths, i, j)
+        max_len = 1
+        for each_row in longest_paths:
+            max_len = max(max_len, max(each_row))
+        return max_len
+
+    def find_longest_path(
+        self,
+        matrix: List[List[int]],
+        dfs_table: List[List[int]],
+        row: int,
+        col: int,
+        current_length: int = 1,
+    ) -> None:
+        if row != -1 and col != -1 and row < len(matrix) and col < len(matrix[0]):
+            current_element = matrix[row][col]
+            left_element = matrix[row][col - 1] if col > 0 else 1
+            right_element = matrix[row][col + 1] if col < len(matrix[0]) - 1 else 1
+            bottom_element = matrix[row + 1][col] if row < len(matrix) - 1 else 1
+            top_element = matrix[row - 1][col] if row > 0 else 1
+
+            if dfs_table[row][col] != 1:
+                return
+
+            if top_element > current_element:
+                self.find_longest_path(
+                    matrix, dfs_table, row - 1, col, current_length + 1
+                )  # top
+            if bottom_element > current_element:
+                self.find_longest_path(
+                    matrix, dfs_table, row + 1, col, current_length + 1
+                )
+            if right_element > current_element:
+                self.find_longest_path(
+                    matrix, dfs_table, row, col + 1, current_length + 1
+                )
+            if left_element > current_element:
+                self.find_longest_path(
+                    matrix, dfs_table, row, col - 1, current_length + 1
+                )
+
+            dfs_left = (
+                dfs_table[row][col - 1]
+                if col > 0 and matrix[row][col - 1] > matrix[row][col]
+                else 0
+            )
+            dfs_right = (
+                dfs_table[row][col + 1]
+                if col < len(matrix[0]) - 1 and matrix[row][col + 1] > matrix[row][col]
+                else 0
+            )
+            dfs_bottom = (
+                dfs_table[row + 1][col]
+                if row < len(matrix) - 1 and matrix[row + 1][col] > matrix[row][col]
+                else 0
+            )
+            dfs_top = (
+                dfs_table[row - 1][col]
+                if row > 0 and matrix[row - 1][col] > matrix[row][col]
+                else 0
+            )
+            dfs_table[row][col] = (
+                max(dfs_left, max(dfs_right, max(dfs_bottom, dfs_top))) + 1
+            )
+
+
+if __name__ == "__main__":
+    sol = Solution()
+    a = [[9, 9, 4], [6, 6, 8], [2, 1, 1]]
+    b = [[3, 4, 5], [3, 2, 6], [2, 2, 1]]
+    c = [[1]]
+    print(sol.longestIncreasingPath(a))
+    print(sol.longestIncreasingPath(b))
+    print(sol.longestIncreasingPath(c))

pythonProblems/permute/permute.py

@@ -0,0 +1,36 @@
+from typing import List
+
+
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        permutations: List[int] = []
+        self.dfs(nums, len(nums), permutations)
+        return permutations
+
+    def dfs(
+        self,
+        nums: List[int],
+        permute_length: int,
+        permutations: List[List[int]],
+        current_permutation: List[int] = [],
+    ) -> None:
+        for index, each_number in enumerate(nums):
+            # Choice
+            new_permutation = current_permutation[:] + [each_number]
+            self.dfs(
+                nums[:index] + nums[index + 1 :],
+                permute_length,
+                permutations,
+                new_permutation,
+            )
+        if (
+            len(current_permutation) == permute_length
+            and current_permutation not in permutations
+        ):
+            permutations.append(current_permutation)
+
+
+if __name__ == "__main__":
+    sol = Solution()
+    nums = [1, 2, 3]
+    print(sol.permute(nums))

pythonProblems/solveSudoku/solveSudoku.py

@@ -0,0 +1,3 @@
+class Solution:
+    def solveSudoku(self, board: List[List[str]]) -> None:
+        return None