剑指OFFER DAY14

第 14 天

搜索与回溯算法

---

剑指 Offer 12. 矩阵中的路径

本题使用深度优先搜索DFS加上剪枝的方法，当搜索时搜索四个方向上的格子

当遇到一下情况时进行剪枝（直接返回上一个情况）：

1、位置在矩阵之外

2、格子存储的字符不符合要求

3、刚刚遍历过的格子

比较精妙的方法是把刚刚遍历过的格子设为空，这样2，3的判断条件就可以使用一个，如果最后发现为死路，再把刚刚设为空的格子设为word[k]

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        
        def dfs(i,j,k):
            if not 0<=i<len(board) or not 0<=j<len(board[0]) or board[i][j]!=word[k]:
                return False
            if k == len(word)-1:
                return True
            board[i][j] = ''
            res = dfs(i+1,j,k+1) or dfs(i-1,j,k+1) or dfs(i,j-1,k+1) or dfs(i,j+1,k+1)
            if res == False:
                board[i][j] = word[k]
            return res
        
        for i in range(len(board)):
            for j in range(len(board[0])):
                if dfs(i,j,0) == True:
                    return True
        return False

---

剑指 Offer 13. 机器人的运动范围

 

暴力解法，遍历每一个方格，如果它的坐标和小于k，并且它周围有存在已经遍历过符合要求的点，则res+1.

class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        def sum_loc(x, y):
            x = [int(i) for i in str(x)]
            y = [int(i) for i in str(y)]
            sum = 0
            for i in x:
                sum += i
            for j in y:
                sum += j
            return sum
        def find_neighbor(i, j, m, n, stack):
            neighbors = []
            if 0 <= i + 1 < m:
                neighbors.append([i + 1, j])
            if 0 <= i - 1 < m:
                neighbors.append([i - 1, j])
            if 0 <= j + 1 < n:
                neighbors.append([i, j + 1])
            if 0 <= j - 1 < n:
                neighbors.append([i, j - 1])
            for q in neighbors:
                if q in stack:
                    return True
            return False

        stack = [[0,0]]
        for i in range(m):
            for j in range(n):
                if sum_loc(i,j)<=k and find_neighbor(i,j,m,n,stack)==True and [i,j]!=[0,0]:
                    stack.append([i,j])
        return len(stack)

---

 DFS

class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        def sum_loc(x, y):
            x = [int(i) for i in str(x)]
            y = [int(i) for i in str(y)]
            sum = 0
            for i in x:
                sum += i
            for j in y:
                sum += j
            return sum
        def dfs(i,j):
            if i >= m or j >= n or k < sum_loc(i,j) or (i, j) in visited: return 0
            visited.add((i,j))
            return 1 + dfs(i + 1, j) + dfs(i, j + 1)
        
        visited = set()
        return dfs(0, 0)

---

BFS

class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        def sum_loc(x, y):
            x = [int(i) for i in str(x)]
            y = [int(i) for i in str(y)]
            sum = 0
            for i in x:
                sum += i
            for j in y:
                sum += j
            return sum
        queue, visited = [(0, 0)], set()
        while queue:
            i, j = queue.pop(0)
            if i >= m or j >= n or k < sum_loc(i,j) or (i, j) in visited: continue
            visited.add((i,j))
            queue.append((i + 1, j))
            queue.append((i, j + 1))
        return len(visited)