剑指offer系列之栈和队列、回溯法(p64-66)

64. 滑动窗口的最大值

题目描述

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

思路

思路一：直接求解

这种方法比较简单，直接遍历数组每个元素值，并在遍历每个元素时找出对应窗口的最大值。时间复杂度为$O(mn)$，其中$m,n$分别为数组的长度和窗口的大小；空间复杂度为$O(1)$.这种情况存在重复遍历的情况，即一个元素被重复多次访问。

# -*- coding:utf-8 -*-
class Solution:
    def maxInWindows(self, num, size):
        # write code here
        max_num = []
        if len(num) < size or len(num) == 0 or size < 1:
            return []
        for i in range(len(num) - size + 1):
            cur_max_num = num[i]
            for j in range(1, size):
                if num[i + j] > cur_max_num:
                    cur_max_num = num[i + j]
            max_num.append(cur_max_num)
        return max_num

思路二：双端队列

这种方法借助双端队列来保存访问过的元素的索引，并且保证队首元素一定是当前窗口的最大值。这种方法利用了空间来换取时间，时间复杂度为$O(n)$,空间复杂度为$O(m),m$为窗口大小。具体做法如下：
顺序遍历数组：

• 对数组中的每个元素都和队尾元素比较，从队尾依次弹出小于当前元素的值，这样可以保证队首元素一定是当前窗口中的最大值；
• 判断队首元素是否已经过期，即队首元素是否和当前元素的索引相差已经超过了一个窗口的大小，如果过期了就要删掉，这也是为了保证队首元素一定是当前窗口中的最大值；
• 将当前元素加入到队列中；若已经遍历过的元素已经大于一个窗口了，则把当前的队首元素对应的值加入到结果中。

# -*- coding:utf-8 -*-
class Solution:
    def maxInWindows(self, num, size):
        # write code here
        # dqueue是一个双端队列，保存索引
        res, dqueue = [], []
        for i in range(len(num)):
            # 当前值如果大于等于队尾值，则弹出队尾元素，确保队头元素一定是当前窗口的最大值
            while len(dqueue) > 0 and num[i] >= num[dqueue[-1]]:
                dqueue.pop(-1)
            # 若队头元素已经超出了当前位置的窗口范围，则弹出队头元素
            while len(dqueue) > 0 and i - dqueue[0] + 1 > size:
                dqueue.pop(0)
            dqueue.append(i)
            # 需要走size步后才能确定第一个窗口最大值
            if size and i + 1 >= size:
                res.append(num[dqueue[0]])
        return res

65. 矩阵中的路径

题目描述

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

思路

该题可以使用回溯法解决。
把矩阵中的每一个点都当做起点去寻找路径，如果在某点找到一条完整路径，则直接返回True。
寻找路径的过程如下：
当前查找出现以下三种情况之一就直接表示此路不通：索引越界、当前矩阵值跟要寻找的路径中第k个值不同、当前矩阵值已经被遍历过，此时直接返回False；若没有出现上述情况，则说明当前点满足条件，首先判断有没有到达路径终点，如果到达终点直接返回True，否则需要标记该点已经被访问过，然后继续递归地向上下左右寻找满足条件的k+1及之后的点，如果找到则直接返回True，如果没有找到则把当前矩阵值标记为未访问状态，返回False。

# -*- coding:utf-8 -*-
class Solution:
    def hasPath(self, matrix, rows, cols, path):
        # write code here
        # 设定一个标记矩阵用来判断某个位置是否已经访问过
        flag = [False] * len(matrix)
        # 遍历矩阵寻找起点
        for i in range(rows):
            for j in range(cols):
                if self.judge(matrix, i, j, rows, cols, flag, path, 0):
                    return True
        return False
    
    def judge(self, matrix, i, j, rows, cols, flag, path, k):
        index = i * cols + j
        # 越界、值不等、已经访问过
        if i < 0 or j < 0 or i >= rows or j >= cols or matrix[index] != path[k] or flag[index] == True:
            return False
        # 已经遍历到终点
        if k == len(path) - 1:
            return True
        # 当前点已经被访问过
        flag[index] = True
        # 判断上下左右是否有出路
        if self.judge(matrix, i - 1, j, rows, cols, flag, path, k + 1) or self.judge(matrix, i + 1, j, rows, cols, flag, path, k + 1) or self.judge(matrix, i, j - 1, rows, cols, flag, path, k + 1) or self.judge(matrix, i, j + 1, rows, cols, flag, path, k + 1):
            return True
        # 当前点失败了，需要把标记重置为未访问状态
        flag[index] = False
        return False

66. 机器人的运动范围

题目描述

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

思路

构造一个和方格形状一样的一个标记矩阵，初始值全为1，遍历方格并将遍历到的点的值置0并把计数器的值加1. 在遍历函数中，遇到以下三种情况直接退出函数：索引越界、不满足阈值条件、当前值已经被访问过了(也就是已经对计数器贡献过一次了)。其他情况类似于65题。
以下为牛客网评论。

思路：将地图全部置1，遍历能够到达的点，将遍历的点置0并令计数+1.这个思路在找前后左右相连的点很有用，比如leetcode中的海岛个数问题/最大海岛问题都可以用这种方法来求解。

# -*- coding:utf-8 -*-
class Solution:
    def movingCount(self, threshold, rows, cols):
        # write code here
        self.count = 0
        # 注意是先cols后rows
        flag = [[1 for i in range(cols)] for j in range(rows)]
        self.findway(0, 0, flag, threshold)
        return self.count
    
    def findway(self, i, j, flag, k):
        # 越界
        if i < 0 or j < 0 or i >= len(flag) or j >= len(flag[0]):
            return
        sum_i = sum(map(int, list(str(i))))
        sum_j = sum(map(int, list(str(j))))
        # 总和大于阈值或者该点已经被遍历过了
        if sum_i + sum_j > k or flag[i][j] == 0:
            return
        # 当前点被遍历过置0且计数器＋1
        flag[i][j] = 0
        self.count += 1
        # 遍历其上下左右节点
        self.findway(i - 1, j, flag, k)
        self.findway(i + 1, j, flag, k)
        self.findway(i, j - 1, flag, k)
        self.findway(i, j + 1, flag, k)