Runtime: 2506 ms (Top 21.4%) | Memory: 118.67 MB (Top 7.1%)

Author: AnasImloul

scripts/algorithms/N/Number of Increasing Paths in a Grid/Number of Increasing Paths in a Grid.py

@@ -1,30 +1,29 @@
-from functools import lru_cache
-class Solution:
-    def countPaths(self, grid: List[List[int]]) -> int:
-        
-        
-        row = len(grid)
-        col = len(grid[0])
-        
-        @lru_cache(None)
-        def helper(i, j):
-            
-            drs = [(-1,0),(1,0),(0,-1),(0,1)]
-            t = 0
-            for x,y in drs:
-                if  0 <= i+x < row and 0 <= j+y < col and grid[i+x][j+y] > grid[i][j]:
-                    t += 1+helper(i+x, j+y)
-            return t
-                    
+# Runtime: 2506 ms (Top 21.4%) | Memory: 118.67 MB (Top 7.1%)
 
-        
-        m = (10**9) + 7
-        ans = row*col%m
-        
-        for i in range(row):
-            for j in range(col):
-                ans += helper(i, j)%m
-                ans %= m
-                
-                
+class Solution:
+    def __init__(self):
+        self.dp = None
+        self.di = [0, 0, -1, 1]
+        self.dj = [-1, 1, 0, 0]
+        self.mod = 1000000007
+    
+    def countPaths(self, grid):
+        n = len(grid)
+        m = len(grid[0])
+        self.dp = [[0] * m for _ in range(n)]
+        ans = 0
+        for i in range(n):
+            for j in range(m):
+                ans = (ans + self.dfs(grid, i, j, -1)) % self.mod
         return ans
+    
+    def dfs(self, grid, i, j, prev):
+        if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]) or grid[i][j] <= prev:
+            return 0
+        if self.dp[i][j] != 0:
+            return self.dp[i][j]
+        self.dp[i][j] = 1
+        for k in range(4):
+            self.dp[i][j] += self.dfs(grid, i + self.di[k], j + self.dj[k], grid[i][j])
+            self.dp[i][j] %= self.mod
+        return self.dp[i][j] % self.mod