Backtracking-3

problem1.py

@@ -0,0 +1,66 @@
+# Space Complexity: N^2 (Grid memory)
+# Time Complexity: N! due to the is_safe function
+
+class Solution:
+    def solveNQueens(self, n: int) -> List[List[str]]:
+        res = []
+        grid = [[False for _ in range(n)] for _ in range(n)]
+
+        def is_safe(grid, r, c, n):
+
+            # column up
+            for i in range(0, r):
+                if grid[i][c]: 
+                    return False
+
+            # diag left up
+            i=r
+            j=c
+
+            while i >=0 and j >= 0: 
+                if grid[i][j]:
+                    return False
+                i-=1
+                j-=1
+
+            # diag right up
+            i=r
+            j=c
+
+            while i>=0 and j < n: 
+                if grid[i][j]:
+                    return False
+                i-=1
+                j+=1
+
+            return True
+
+        def backtrack(grid, res, r, n):
+            # Base
+            li = []
+            if r == n: 
+                # Valid Solution 
+                for i in range(n): 
+                    st = []
+                    for j in range(n):
+                        if grid[i][j]:
+                            st.append('Q')
+
+                        else:
+                            st.append('.')
+
+                    li.append(''.join(st))
+                res.append(li)
+
+            # Logic
+            for c in range(0, n):
+                if is_safe(grid, r, c, n):
+                    # Action
+                    grid[r][c] = True
+                    # Recurse
+                    backtrack(grid, res, r+1, n)
+                    #Backtrack
+                    grid[r][c] = False
+
+        backtrack(grid, res, 0, n)
+        return res

problem2.py

@@ -0,0 +1,61 @@
+# Space Complexity: O(n) 
+# Time Complexity: O(3 ^ n)
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+
+        m,n = len(board), len(board[0])
+        dirs = [(-1,0), (1,0), (0,-1), (0,1)]
+
+        def backtrack(board, word, r, c, idx, dirs):
+
+            # Base Case
+            if idx == len(word):
+                return True
+
+            if r < 0 or c < 0 or r == len(board) or c == len(board[0]):
+                return False
+
+            # Logic
+            if board[r][c] == word[idx]:
+
+                # Action
+                board[r][c] = '#'
+
+                # Recurse
+                # check for neighbours
+
+                for dx, dy in dirs: 
+                    nr = r + dx
+                    nc = c + dy
+
+                    if backtrack(board, word, nr, nc, idx+1, dirs):
+                        return True
+
+                # Backtrack
+                board[r][c] = word[idx]
+
+            return False
+
+        for i in range(m):
+            for j in range(n):
+                if backtrack(board, word, i, j, 0, dirs):
+                    return True
+        return False
+
+
+
+
+
+
+
+
+
+
+        for i in range(m): 
+            for j in range(n):
+                if board[i][j] == word[0]:
+                    if backtrack(board, word, i, j, 0, dirs):
+                        return True
+        return False
+
+