LeetCode 中等题解（4）

40 组合总和 II

Question

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,

所求解集为:

[

  [1, 7],

  [1, 2, 5],

  [2, 6],

  [1, 1, 6]

]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,

所求解集为:

[

  [1,2,2],

  [5]

]

Answer

#

# @lc app=leetcode.cn id=40 lang=python3

#

# [40] 组合总和 II

#

# @lc code=start

class Solution:

    def combinationSum2(self, candidates: List[int],

                        target: int) -> List[List[int]]:

        if (not candidates):

            return []

        n = len(candidates)

        candidates.sort()

        res = []

        def helper(i, tmp, target):

            if (target == 0):

                res.append(tmp)

                return

            if (i == n or target < candidates[i]):

                return

            for j in range(i, n):

                if (j > i and candidates[j] == candidates[j - 1]):

                    continue

                helper(j + 1, tmp + [candidates[j]], target - candidates[j])

        helper(0, [], target)

        return res

# @lc code=end

43 字符串相乘

Question

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

示例 1:

输入: num1 = "2", num2 = "3"

输出: "6"

示例 2:

输入: num1 = "123", num2 = "456"

输出: "56088"

说明：

num1 和 num2 的长度小于110。
num1 和 num2 只包含数字 0-9。
num1 和 num2 均不以零开头，除非是数字 0 本身。
不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。

Answer

#

# @lc app=leetcode.cn id=43 lang=python3

#

# [43] 字符串相乘

#

# @lc code=start

class Solution:

    def multiply(self, num1: str, num2: str) -> str:

        if num1 == "0" or num2 == "0":

            return "0"

        nums1_list = [int(i) for i in num1]

        nums2_list = [int(i) for i in num2]

        result_sum = [0]

        for i in range(1, len(nums1_list) + 1):

            _result = [nums1_list[-i] * x for x in nums2_list]

            d = 0

            for j in range(1, len(_result) + 1):

                if (_result[-j] + d) // 10 > 0:

                    _d = d

                    d = (_result[-j] + d) // 10

                    _result[-j] = (_result[-j] + _d) % 10

                else:

                    _result[-j] += d

                    d = 0

            if d > 0:

                _result.insert(0, d)

            for j in range(i - 1):

                _result.append(0)

            result = _result if len(_result) > len(result_sum) else result_sum

            length = min(len(_result), len(result_sum))

            for j in range(1, length + 1):

                result[-j] = result_sum[-j] + _result[-j]

            result_sum = result

        d = 0

        for i in range(1, len(result_sum) + 1):

            if (result_sum[-i] + d) // 10 > 0:

                _d = d

                d = (result_sum[-i] + d) // 10

                result_sum[-i] = (result_sum[-i] + _d) % 10

            else:

                result_sum[-i] += d

                d = 0

        if d > 0:

            result_sum.insert(0, d)

        result_str = ""

        for i in range(len(result_sum)):

            result_str += str(result_sum[i])

        return result_str

# @lc code=end

46 全排列

Question

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

示例:

输入: [1,2,3]

输出:

[

  [1,2,3],

  [1,3,2],

  [2,1,3],

  [2,3,1],

  [3,1,2],

  [3,2,1]

]

Answer

#

# @lc app=leetcode.cn id=46 lang=python3

#

# [46] 全排列

#

# @lc code=start

class Solution:

    def permute(self, nums: List[int]) -> List[List[int]]:

        result = []

        def perm(res_nums, cur_result):

            if len(res_nums) == 1:

                result.append(cur_result + res_nums)

                return

            for i in range(len(res_nums)):

                perm(res_nums[:i]+res_nums[i+1:], cur_result + [res_nums[i]])

        perm(nums, [])

        return result

# @lc code=end

47 全排列 II

Question

给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

输入: [1,1,2]

输出:

[

  [1,1,2],

  [1,2,1],

  [2,1,1]

]

Answer

#

# @lc app=leetcode.cn id=47 lang=python3

#

# [47] 全排列 II

#

# @lc code=start

class Solution:

    def permuteUnique(self, nums: List[int]) -> List[List[int]]:

        result = []

        nums.sort()

        def perm(res_nums, cur_result):

            if len(res_nums) == 1:

                result.append(cur_result + res_nums)

                return

            for i in range(len(res_nums)):

                if i < len(res_nums) - 1 and res_nums[i] == res_nums[i + 1]:

                    continue

                perm(res_nums[:i] + res_nums[i + 1:],

                     cur_result + [res_nums[i]])

        perm(nums, [])

        return result

# @lc code=end

48 旋转图像

Question

给定一个 n × n 的二维矩阵表示一个图像。

将图像顺时针旋转 90 度。

说明：

你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

示例 1:

给定 matrix =

[

  [1,2,3],

  [4,5,6],

  [7,8,9]

],

原地旋转输入矩阵，使其变为:

[

  [7,4,1],

  [8,5,2],

  [9,6,3]

]

示例 2:

给定 matrix =

[

  [ 5, 1, 9,11],

  [ 2, 4, 8,10],

  [13, 3, 6, 7],

  [15,14,12,16]

], 

原地旋转输入矩阵，使其变为:

[

  [15,13, 2, 5],

  [14, 3, 4, 1],

  [12, 6, 8, 9],

  [16, 7,10,11]

]

Answer

#

# @lc app=leetcode.cn id=48 lang=python3

#

# [48] 旋转图像

#

# @lc code=start

class Solution:

    def rotate(self, matrix: List[List[int]]) -> None:

        """

        Do not return anything, modify matrix in-place instead.

        """

        n = len(matrix)

        for i in range(n):

            for j in range(i, n):

                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

        for i in matrix:

            i.reverse()

# @lc code=end

49 字母异位词分组

Question

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"],

输出:

[

  ["ate","eat","tea"],

  ["nat","tan"],

  ["bat"]

]

说明：

所有输入均为小写字母。
不考虑答案输出的顺序。

Answer

#

# @lc app=leetcode.cn id=49 lang=python3

#

# [49] 字母异位词分组

#

# @lc code=start

class Solution:

    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:

        result = {}

        for str_i in strs:

            _ = sorted(str_i)

            strs_key = ""

            for i in _:

                strs_key += i

            if strs_key not in result.keys():

                result[strs_key] = [str_i]

            else:

                result[strs_key].append(str_i)

        total_result = []

        for key in result.keys():

            total_result.append(result[key])

        return total_result

# @lc code=end

50 Pow(x, n)

Question

实现 pow(x, n) ，即计算 x 的 n 次幂函数。

示例 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

说明:

-100.0 < x < 100.0
n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。

Answer

#

# @lc app=leetcode.cn id=50 lang=python3

#

# [50] Pow(x, n)

#

# @lc code=start

class Solution:

    def myPow(self, x: float, n: int) -> float:

        judge = True

        if n < 0:

            n = -n

            judge = False

        final = 1

        while n > 0:

            if n & 1:  #代表是奇数

                final *= x

            x *= x

            n >>= 1  # 右移一位

        return final if judge else 1 / final

# @lc code=end

54 螺旋矩阵

Question

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例 1:

输入:

[

 [ 1, 2, 3 ],

 [ 4, 5, 6 ],

 [ 7, 8, 9 ]

]

输出: [1,2,3,6,9,8,7,4,5]

示例 2:

输入:

[

  [1, 2, 3, 4],

  [5, 6, 7, 8],

  [9,10,11,12]

]

输出: [1,2,3,4,8,12,11,10,9,5,6,7]

Answer

#

# @lc app=leetcode.cn id=54 lang=python3

#

# [54] 螺旋矩阵

#

# @lc code=start

class Solution:

    # def spiralOrder(self, matrix: List[List[int]]) -> List[int]:

    def spiralOrder(self, matrix):

        result = []

        if matrix == []:

            return result

        m, n = len(matrix), len(matrix[0])

        state = [[0 for _ in range(n)] for _ in range(m)]

        i, j = 0, 0

        result.append(matrix[i][j])

        state[i][j] = 1

        count = m * n - 1

        while (count):

            while (j < n - 1 and state[i][j + 1] == 0):

                j += 1

                result.append(matrix[i][j])

                state[i][j] = 1

                count -= 1

            while (i < m - 1 and state[i + 1][j] == 0):

                i += 1

                result.append(matrix[i][j])

                state[i][j] = 1

                count -= 1

            while (j > 0 and state[i][j - 1] == 0):

                j -= 1

                result.append(matrix[i][j])

                state[i][j] = 1

                count -= 1

            while (i > 0 and state[i - 1][j] == 0):

                i -= 1

                result.append(matrix[i][j])

                state[i][j] = 1

                count -= 1

        return result

# @lc code=end

55 跳跃游戏

Question

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个位置。

示例 1:

输入: [2,3,1,1,4]

输出: true

解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。

示例 2:

输入: [3,2,1,0,4]

输出: false

解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

Answer

#

# @lc app=leetcode.cn id=55 lang=python3

#

# [55] 跳跃游戏

#

# @lc code=start

class Solution:

    # def canJump(self, nums: List[int]) -> bool:

    def canJump(self, nums):

        nums_len = len(nums)

        state = [0 for _ in range(nums_len)]

        state[-1] = 1

        if nums_len == 1:

            return True

        i = nums_len - 2

        while (i != -1):

            max_pos = min(i + 1 + nums[i], nums_len)

            if 1 in state[i + 1:max_pos]:

                state[i] = 1

            i -= 1

        if state[0] == 0:

            return False

        else:

            return True

# @lc code=end

56 合并区间

Question

给出一个区间的集合，请合并所有重叠的区间。

示例 1:

输入: [[1,3],[2,6],[8,10],[15,18]]

输出: [[1,6],[8,10],[15,18]]

解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2:

输入: [[1,4],[4,5]]

输出: [[1,5]]

解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

Answer

#

# @lc app=leetcode.cn id=56 lang=python3

#

# [56] 合并区间

#

# @lc code=start

class Solution:

    def merge(self, intervals: List[List[int]]) -> List[List[int]]:

        intervals = sorted(intervals)

        p = 1

        while (p < len(intervals)):

            if intervals[p][0] >= intervals[

                    p - 1][0] and intervals[p][0] <= intervals[p - 1][1]:

                if intervals[p][1] <= intervals[p - 1][1]:

                    intervals.remove(intervals[p])

                else:

                    intervals[p - 1] = [intervals[p - 1][0], intervals[p][1]]

                    intervals.remove(intervals[p])

            else:

                p += 1

        return intervals

# @lc code=end

59 螺旋矩阵 II

Question

给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

输入: 3

输出:

[

 [ 1, 2, 3 ],

 [ 8, 9, 4 ],

 [ 7, 6, 5 ]

]

Answer

#

# @lc app=leetcode.cn id=59 lang=python3

#

# [59] 螺旋矩阵 II

#

# @lc code=start

class Solution:

    def generateMatrix(self, n: int) -> List[List[int]]:

        state = [[0 for _ in range(n)] for _ in range(n)]

        i, j = 0, 0

        state[i][j] = 1

        count = n**2 - 1

        while (count):

            while (j < n - 1 and state[i][j + 1] == 0):

                j += 1

                state[i][j] = n**2 - count + 1

                count -= 1

            while (i < n - 1 and state[i + 1][j] == 0):

                i += 1

                state[i][j] = n**2 - count + 1

                count -= 1

            while (j > 0 and state[i][j - 1] == 0):

                j -= 1

                state[i][j] = n**2 - count + 1

                count -= 1

            while (i > 0 and state[i - 1][j] == 0):

                i -= 1

                state[i][j] = n**2 - count + 1

                count -= 1

        return state

# @lc code=end