一枚菜鸟的leetcode刷题笔记 - Day6

415 - 字符串相加

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。
提示：
num1 和num2 的长度都小于 5100
num1 和num2 都只包含数字 0-9
num1 和num2 都不包含任何前导零
你不能使用任何內建 BigInteger 库， 也不能直接将输入的字符串转换为整数形式

class Solution:
    def str2num(self, s):
        num = 0
        for i in range(len(s)):
            num = num * 10 + int(s[i])
        return num
    
    def num2str(self, n):
        if n == 0:
            return '0'
        l = []
        while n != 0:
            l.append(n%10)
            n = n//10
        string = ''
        while l:
            string += str(l.pop())
        return string
    
    def addStrings(self, num1: str, num2: str) -> str:
        ans = self.str2num(num1) + self.str2num(num2)
        return self.num2str(ans)

定义两个函数str2num和num2str分别实现数字转字符串和字符串转数字。

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        #定义两个指针分别指向num1和num2的最后一位
        p1, p2 = len(num1)-1, len(num2)-1
        ans = []
        remainder = 0   #维护的是相加后进位的部分
        while p1 >= 0 or p2 >= 0 or remainder != 0:
            x1 = int(num1[p1]) if p1 >= 0 else 0
            x2 = int(num2[p2]) if p2 >= 0 else 0
            ans.append(str((x1+x2+remainder)%10))
            remainder = (x1+x2+remainder)//10
            p1, p2 = p1-1, p2-1
        return ''.join(ans[::-1])   #ans[::-1]实现的是倒序数组

43 - 字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

class Solution:
    def convertNum(self, numStr):
        num = 0
        for i in range(len(numStr)):
            num = num * 10 + int(numStr[i])
        return num

    def multiply(self, num1: str, num2: str) -> str:
        n1, n2 = self.convertNum(num1), self.convertNum(num2)
        ansNum = n1 * n2
        return str(ansNum)

这题显然不是要这种解法，我只是试试，居然通过了哈哈。
就是先把字符串转数字，相乘后再转回字符串。

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        #定义两个指针分别指向num1和num2的最后一位
        p1, p2 = len(num1)-1, len(num2)-1
        ans = []
        remainder = 0   #维护的是相加后进位的部分
        while p1 >= 0 or p2 >= 0 or remainder != 0:
            x1 = int(num1[p1]) if p1 >= 0 else 0
            x2 = int(num2[p2]) if p2 >= 0 else 0
            ans.append(str((x1+x2+remainder)%10))
            remainder = (x1+x2+remainder)//10
            p1, p2 = p1-1, p2-1
        return ''.join(ans[::-1])   #ans[::-1]实现的是倒序数组
    

    def multiply(self, num1: str, num2: str) -> str:
        if num1 == '0' or num2 == '0':
            return '0'
        
        n1, n2 = len(num1)-1, len(num2)-1
        ans = '0'   #初始化ans
        for j in range(n2, -1, -1):
            remainder = 0
            curr = ['0'] * (n2 - j)
            for i in range(n1, -1, -1):
                prod = int(num2[j]) * int(num1[i]) + remainder
                curr.append(str(prod % 10))
                remainder = prod // 10
            if remainder > 0:
                curr.append(str(remainder))
            curr = ''.join(curr[::-1])
            ans = self.addStrings(ans, curr)
        return ans

参考了官方答案
其实就是在复现竖式乘法的规则。
其中相加的部分用函数addStrings实现。

46 - 全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        n = len(nums)
        ans = []

        def backtrack(p=0):
            if p == n:
                ans.append(nums[:])     #为什么用ans.append(nums)不行？
            for i in range(p, n):
                nums[p], nums[i] = nums[i], nums[p]
                backtrack(p+1)
                nums[p], nums[i] = nums[i], nums[p]  #要记得换回来，这是回溯法的关键
        
        backtrack()
        return ans

第一次接触回溯算法（通常用递归实现），官方解答
动态划分数组这个想法太棒了，简单又好实现。

补充：关于python列表的拷贝
python中直接通过等号赋值实际上只是引用地址的传递，如：

a = [1,2,3,4,5]
b=a

上述方式当a的值改变时，b的值也会随之改变，如果希望b和a没有关系，可以通过下面的方法：

a = [1,2,3,4,5]
b=a[:]

这样a和b就是两个完全独立的数组，互相不会影响。

现在可以回答为什么用ans.append(nums)不行？

• 因为nums只是一个标签，所有的标签指向了同一块内存地址，当回溯法结束时，nums又变回原来的数组了，因此若用ans.append(nums)，会造成最终返回的ans里面的数组全部一样。
• 但是ans.append(nums[:])不同，因为nums[:]相当于对当时nums的拷贝，不和nums共享内存地址。

53 - 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        for i in range(1, len(nums)):
            nums[i] = max(nums[i-1] + nums[i], nums[i])
        return max(nums)

完全参考了最大子序和python3动态规划题解 👍

为了解决这道题目，我们需要一个数组 f(i)，用来存储以 i 位置为结尾的连续子数组的最大和。在已知 f(i-1) 的情况下，f(i) 要么是 f(i-1)+nums[i], 要么是 nums[i]，也即 f(i-1) 是正数时为前者，否则为后者。最后得到整个 f(i)，然后找出其中最大值即可。以 i 为尾节点是为了更好写状态转移方程。

这是我遇到的第二道动态规划题目，我觉得我还没理解动态规划的精髓。比如这题的状态转移方程我想了很久才明白怎么回事。