杨子爽得剑指OF python版

1、2020 08/16

在一个 n * m
的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 matrix 如下：

[ [1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 16,
22], [10, 13, 14, 17, 24], [18, 21, 23, 26, 30] ] 给定 target = 5，返回
true。

给定 target = 20，返回 false。

class Solution(object):
    def findNumberIn2DArray(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """
        if len(matrix) == 0 or len(matrix[0]) == 0:   # 空集或者每个元素都是空时
            return False 
        # 从右上角看就是个二叉搜索树
        row = 0 # 行数
        col = len(matrix[0]) - 1   # 列数
        while row < len(matrix) and col >= 0:
            if matrix[row][col] == target:
                return True
            elif matrix[row][col] > target:
                col = col - 1
            elif matrix[row][col] < target:
                row = row + 1
        return False

从右上角往后看 这就是个二叉排序树。左边大，右边小。

2、2020 08/17

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = “We are happy.” 输出：“We%20are%20happy.”

题目过于简单，但是想要提升速度要想一下。
如果用正则re.sub或者字符串的replace都可以，这里用的先用空格分，在用%20连接

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """
        return "%20".join(s.split(" "))

3、2020 08/17

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如，给出
前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树：
3
/
9 20
/
15 7
限制：

0 <= 节点个数 <= 5000

在这里插入代码片

4、2020 08/19
###递归题 ，多康康

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的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 示例 2：

输入：board = [[“a”,“b”],[“c”,“d”]], word = “abcd” 输出：false 提示：

1 <= board.length <= 200 1 <= board[i].length <= 200

class Solution(object):
    def exist(self, board, word):
        """
        :type board: List[List[str]]
        :type word: str
        :rtype: bool
        """
        # 按照上下左右递归，越界或者不等则递归终止，返回false，
        # 只要有一个方向True就行，所以是or
        # 定义递归函数
        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]  替换成一个tag防止二次访问
            tmp = board[i][j]
            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)
            # 每次递归都只是移动一个小格，所以每次递归只需要复原当前被置换为tag的就行了，这样所有的递归执行完都又置换回去了，再遍历word重新递归
            board[i][j] = tmp
            return res

        for i in range(len(board)):
            for j in range(len(board[0])):
                # 只需要有一次成功匹配就够了
                if dfs(i,j,0):
                    return True
        return False

5、2020 08/20 递归题

##深度遍历

地上有一个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 示例 2：

输入：m = 3, n = 1, k = 0 输出：1 提示：

1 <= n,m <= 100 0 <= k <= 20

这道题的关键在于找到递归终止条件、回溯返回值、位数和的计算方式

class Solution(object):
    def movingCount(self, m, n, k):
        """
        :type m: int
        :type n: int
        :type k: int
        :rtype: int
        """
        # 递归函数
        def dfs(i, j, si, sj):  # si是行位数和，sj是列位数和
            # 递归终止条件
            if i >= m or j >= n or k < si + sj or (i, j) in visited: 
                return 0
            # 如果里面已经存在，是添加不进去滴
            visited.add((i,j))
            return 1 + dfs(i + 1, j, si + 1 if (i + 1) % 10 else si - 8, sj) + dfs(i, j + 1, si, sj + 1 if (j + 1) % 10 else sj - 8)

        visited = set()
        return dfs(0, 0, 0, 0)

终止条件：行列越界、位数和大于k、某点走过了，三个条件返回值都为0，表示不计入走的步数。

递归式：1 + dfs(i + 1, j, si + 1 if (i + 1) % 10 else si - 8, sj) + dfs(i, j + 1, si, sj + 1 if (j + 1) % 10 else sj - 8)
其中1表示每次递归如果不返回零就代表走了一步，最后每次都加起来就是最后的值。两个遍历代表只往下或者往右走，每个方向都是走到吐，也就是深度遍历了。

##广度遍历
广度通常使用的队列实现

class Solution(object):
    def movingCount(self, m, n, k):
        """
        :type m: int
        :type n: int
        :type k: int
        :rtype: int
        """
        queue, visited,  = [(0, 0, 0, 0)], set()
        while queue:
            i, j, si, sj = queue.pop(0)
            if i >= m or j >= n or k < si + sj or (i, j) in visited: continue
            visited.add((i,j))
            queue.append((i + 1, j, si + 1 if (i + 1) % 10 else si - 8, sj))
            queue.append((i, j + 1, si, sj + 1 if (j + 1) % 10 else sj - 8))
        return len(visited)

因为是最后是计算集合的长度，所以到达终止条件是continue。
往visit里面添加行列对，循环条件是队列不空，每次广度遍历把符合条件的点都添加到队列里面，然后不停的循环pop队列，添加，再循环再pop，再添加。。。直到队列空了，就结束，最后计算集合的长度。

2020 08/24
p1.

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为
k[0],k[1]…k[m-1] 。请问 k[0]k[1]…*k[m-1]
可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

示例 1：

输入: 2 输出: 1 解释: 2 = 1 + 1, 1 × 1 = 1 示例 2: 输入: 10 输出: 36 解释: 10 = 3 +
3 + 4, 3 × 3 × 4 = 36 提示： 2 <= n <= 58

class Solution(object):
    def cuttingRope(self, n):
        """
        :type n: int
        :rtype: int
        """
        # 分析知越分成3相乘的得到的越多
        if n == 4:
            return 4
        elif n == 3 :
            return 2
        elif n == 2:
            return 1

        elif n > 4:
            num = n // 3  # 可以有多少个3连乘
            left = n % 3  # 余数
            if left == 0:
                return pow(3,num)
            elif left == 1:
                return pow(3,num-1)*2*2
            elif left == 2:
                return pow(3,num) * 2

p2.

请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入
9，则该函数输出 2。

示例 1：

输入：00000000000000000000000000001011 输出：3 解释：输入的二进制串
00000000000000000000000000001011 中，共有三位为 ‘1’。 示例 2：

输入：00000000000000000000000010000000 输出：1 解释：输入的二进制串
00000000000000000000000010000000 中，共有一位为 ‘1’。 示例 3：

输入：11111111111111111111111111111101 输出：31 解释：输入的二进制串
11111111111111111111111111111101 中，共有 31 位为 ‘1’。

class Solution(object):
    def hammingWeight(self, n):
        """
        :type n: int
        :rtype: int
        """
        # 减一相与，可以把最靠右的那个1变成0，以此将所有1变成0
        count = 0
        while n:
            n = n & (n-1)
            count += 1
        return count

2020 08/25

实现函数double Power(double base, int
exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。

示例 1:

输入: 2.00000, 10 输出: 1024.00000 示例 2:

输入: 2.10000, 3 输出: 9.26100 示例 3:

输入: 2.00000, -2 输出: 0.25000 解释: 2-2 = 1/22 = 1/4 = 0.25

class Solution(object):
    def myPow(self, x, n):
        """
        :type x: float
        :type n: int
        :rtype: float
        """
        if n == 0 or x == 1:
            return 1
        elif x == -1:
            if n%2 == 0:
                return 1
            else:
                return -1
        elif n > 0:
            num = x
            while n-1 >0:
                num = num * x
                if num < 0.00000001 and -num <0.00000001:
                    num = 0
                    break
                n = n - 1
            return num
        elif n < 0:
            num = x
            while n+1<0:
                num = num * x
                if num > 100000000:
                    return 0
                    
                n = n + 1
            return 1/(num)
            

当时就觉得直接连乘比较easy，试了下，结果发现情况挺多的，比较蠢，时间复杂度O(n)，后来看了下答案，豁然开朗。

class Solution:
    def myPow(self, x: float, n: int):
        if x == 0: 
            return 0
        res = 1
        elif n < 0: 
            x, n = 1 / x, -n
        while n:
            if n & 1: 
                res *= x
            x *= x
            n >>= 1
        return res

2020 08/26

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。 示例 2:

给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for (int
i = 0; i < len; i++) {
print(nums[i]); }

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums[:] = list(sorted(set(nums)))
        return len(nums)

这里需要注意的是，对于python而言，我一开始是写了nums = xxx，这样的话相当于是另一个列表，改了指向，并没有实现真正的原地修改，正确做法是nums[:] =xxx这样才是正经的原地修改之前的列表。还有一点，就是对于python的set（）函数而言，他是会正负数分开的集合，所以要进行一下sorted重新恢复成有序。