LeetCode50题第六天

LeetCode第43题: 字符串相乘

解法一

1. 使用python内置函数

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        return str(int(num1) * int(num2))

解法二

1. 采用常规算法, 逐位相乘, 最后处理进位

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        if num2 == "0" or num1 == "0":
            return "0"
        lenght1 = len(num1)
        lenght2 = len(num2)
        ans = [0] * (lenght1 + lenght2)
        for i in range(lenght1 - 1, -1, -1):
            x = int(num1[i])
            for j in range(lenght2 - 1, -1, -1):
                ans[i + j + 1] += x * int(num2[j])
        # print(ans)
        curr = 0
        for i in range(lenght1 + lenght2 - 1, -1, -1):
            ans[i] += curr
            curr = ans[i] // 10
            ans[i] = ans[i] % 10
        index = 1 if ans[0] == 0 else 0
        ans = "".join(str(x) for x in ans[index:])
        return ans

LeetCode第46题: 全排列

1. 使用深度优先遍历的方法, 类似于图的遍历
2. 本算法难点在于回溯时要状态重置, 保证下一层深度遍历不会影响到上一层

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        length = len(nums)
        mid = [False] * length
        path = []
        result = []
        self.dfs(nums, length, 0, path, mid, result)
        return result
    
    def dfs(self, nums, length, depth, path, mid, result):
        if depth == length:
            result.append(path[:])
            return
        for i in range(0, length):
            if mid[i]:
                continue;
            path.append(nums[i])
            mid[i] = True
            self.dfs(nums, length, depth + 1, path, mid, result)
            path.pop()
            mid[i] = False

LeetCode53题: 最大子序和

1. 使用动态规划
2. 对于最大连续序列, 如果当前和为负, 那么下一个元素如果是正, 那么就不应该包括在当前序列

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