力扣每日一题(五十一——考试的最大困扰数）

仅以此纪录每日LeetCode所刷题目。

题目描述：

示例：

思路：

这道题可以使用滑动窗口，只需要遍历一遍字符串。遍历字符串时我们统计‘T’、‘F’的个数，当他们两个同时大于k得时候，此时已经不满足题意了，这就意味着我们转换字母得个数大于k。这个时候我们就应该缩小窗口，将最左面的字符以及对应的字符个数剔除，继续遍历。最后返回最大的窗口长度值。

代码：

class Solution:
    def maxConsecutiveAnswers(self, answerKey: str, k: int) -> int:
        ans = left = cnts_t = cnts_f = 0
        for right, c in enumerate(answerKey):
            cnts_t += c == 'T'
            cnts_f += c == 'F'
            # 当前区间内的t和f的个数不能都大于k，我们只能变k次
            while cnts_t > k and cnts_f > k:
                # 超过最大变动次数了，当前指针的区间最左要向右移动
                cnts_t -= answerKey[left] == 'T'
                cnts_f -= answerKey[left] == 'F'
                left += 1
            ans = max(ans, right - left + 1)
        return ans

题目描述：

示例：

思路：

这道题和上一道题如出一辙，我们也可以使用滑动窗口，同时遍历的时候统计1和0的个数。我们在判断的时候只需要判断0的个数是否大于k，如果大于k将滑动窗口左下标+1，同时也要更改1和0的个数，继续遍历。返回最大的窗口值。

代码：

class Solution:
    def longestOnes(self, nums: List[int], k: int) -> int:
        ans = count_1 = count_0 = left = 0
        for right , t in enumerate(nums):
            count_0 += t == 0
            count_1 += t == 1
            while count_0 > k :
                count_0 -= nums[left] == 0
                count_1 -= nums[left] == 1
                left += 1
            ans = max(right - left + 1,ans)
        return ans

题目描述：

示例：

思路：

这道题使用深度优先搜索，双循环遍历，因此矩阵中的任何坐标都可以当作起点。分别向四个方向进行搜索，为了防止单词搜索使用的字母是重复的，遍历过的字母改成空字符，遍历结束之后再修改回来，不影响下次搜索。

代码：

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)
            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):
                    return True
        return False

题目描述：

示例：

 

思路：

这道题和上一道题差不多，也可以使用深度优先搜索，思路就不讲了，但是我写的时间复杂度和空间复杂度都很高，不是很理想。之后就贴一段别人的代码，很简洁也很好用，但是我不太确定这个方法叫什么...

代码：

class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        def sums(x):
            ans = 0
            while x:
                ans += x % 10
                x = x // 10
            return ans
        res = set([(0,0)])
        for i in range(m):
            for j in range(n):
                if sums(i) + sums(j) <= k and ((i-1,j) in res or (i, j-1) in res):
                    res.add((i,j))
        return len(res)

class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        arr =[ [0 for i in range(n)] for j in range(m)]
        count = 0
        def sum(i,j):
            a = i % 10
            a += (i - a) // 10
            c = j % 10
            c += (j - c) // 10
            return a+c
        def dfs(i,j):
            if not 0 <= i < m or not 0 <= j < n or sum(i,j) > k or arr[i][j] == 1:
                return False
            arr[i][j] = 1
            dfs(i + 1,j)
            dfs(i - 1,j)
            dfs(i,j + 1)
            dfs(i,j - 1)
        dfs(0,0)
        for i in range(len(arr)):
            for j in range(len(arr[0])):
                if arr[i][j] == 1:
                    count += 1
        return count

 

题目描述：

 

示例：

 

思路：

这道题我便利了[left,right]的数组，首先排除含有0的数字(将数字先转化成字符，之后判断是否有‘0’)，之后根据题意判断即可，也是将数字转化成字符，之后遍历字符，将单字符转化成数字，当然也可以使用取余求出个位百位千位，但是我没有使用这种方法。最后返回符合要求的数的列表。

代码：

class Solution:
    def selfDividingNumbers(self, left: int, right: int) -> List[int]:
        list1 = []
        for i in range(left,right+1):
            a = str(i)
            if '0' in a:
                continue
            for j in range(len(a)):
                b = int(a[j])
                if i % b != 0:
                    break
                if j == len(a) - 1:
                    list1.append(i)
        return list1