刷题总结1：深度优先搜索DFS

深度优先算法实现伪代码：

def dfs(i,j):

　　#传入搜索坐标

　　if 非法条件:

　　#判断是否为非法条件，非法条件通常包括横纵坐标超出范围、已搜索过的坐标、不满足题目

　　　　return 0 or False

　　grid[i][j] = 0

　　#标记访问过的坐标

　　for m,n in [[0,1],[0,-1],[1,0],[-1,0]]:

　　　　next_i = i+m

　　　　next_j = j+n

　　　　# 向下、上、右、左接着进行搜索

　　　　ans = dfs(next_i,next_j)

　　　　# 返回答案

　　# 视情况而定，需不要将标记还原

for i in range(m):

　　for j in range(n):

　　　　if dfs(i,j):

　　　　　　return ans

#进行网格搜索。最终返回需要得到的答案。

《剑指OFFER》第12题：矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[["a","b","c","e"],
["s","f","c","s"],
["a","d","e","e"]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

示例1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

思路：本题将利用深度优先搜索和非法情况剪枝。深度优先搜索，即对于满足条件的，一路走到底进行搜索，不满足条件，对上一步进行回溯再进行搜索，是一种升级版的暴力搜索，可以利用非法情况剪枝进行优化，这里的非法情况包括搜索横纵坐标越界、该位置字符与进行对比的给定字符串不相同，判断为False退出。由于不能重复搜索，所以需要对已搜索的格子进行标记。

代码：

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        def dfs(i,j,k):
            #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
            tmp = board[i][j]
            board[i][j] = 0
            #将board[i][j]置为0，防止重复搜索
            if dfs(i,j+1,k+1) or dfs(i,j-1,k+1) or dfs(i+1,j,k+1) or dfs(i-1,j,k+1):
                return True
            board[i][j] = tmp
            # 如果不满足返回真的条件，则将其还原，开始下一次搜索
        for i in range(len(board)):
            for j in range(len(board[0])):
                if dfs(i,j,0):
                    return True
        return False

leetcode 第695题：岛屿的最大面积

给定一个包含了一些 0 和 1 的非空二维数组 grid 。

一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

示例 1:

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]

对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1 。

思路：这道题同样适用深度优先算法进行搜索，以及非法条件剪枝。如果岛屿为1，则继续进行递归，并且面积更新加一，如果不为1，则面积不加1，最终返回该次搜索的最大面积。非法条件包括搜索横纵坐标越界。该方法同样需要将搜索过的岛屿置为0，以防重复搜索，由于本题求解的是最大面积，并不需要如上一题进行字符串比对，所以并不需要将岛屿还原。

代码：

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        def dfs(i,j):
            if not 0<=i<len(grid) or not 0<=j<len(grid[0]) or not grid[i][j]:
                return 0
            grid[i][j] = 0
            #将走过的路标记为0，防止重复计算
            max_area = 1
            # 最大面积
            for m,n in [[0,1],[0,-1],[1,0],[-1,0]]:
                next_i = i+m
                next_j = j+n
                max_area += dfs(next_i,next_j)
                # 累计面积
            return max_area
        
        MaxArea = 0
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                MaxArea=max(dfs(i,j),MaxArea)
        return MaxArea

 《剑指OFFER》面试题13：机器人的运动范围

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

示例 1：

输入：m = 2, n = 3, k = 1
输出：3

这道题我们依然使用深度优先算法，不同的是，由于没有给出具体的二维表格，所以需要新建一个m行n列方格来存放是否访问过的标记。所以空间复杂度为O（m*n)。
增加了一个求数位之和的函数，将其写到判断非法条件语句中，其实现思路与上文的题目相同。机器人从[0,0]坐标开始移动，所以只需要搜索[0,0]的到达路径的格子数即可。
代码：

class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        visited = [[False]*n for _ in range(m)]
        #初始化访问坐标的标记
        def sums(x):
            #求数位之和
            s = 0
            while x:
                s += x % 10
                x = x // 10
            return s

        def dfs(i,j):
            if not 0<=i<m or not 0<=j<n or sums(i)+sums(j) > k or visited[i][j] == True:
                return 0
            visited[i][j] = True
            #标记访问过的坐标
            ans = 1
            for x,y in [[0,1],[0,-1],[1,0],[-1,0]]:
                next_i = i+x
                next_j = j+y
                ans += dfs(next_i,next_j)
            return ans
        return dfs(0,0)