LeetCode刷题记录

最新推荐文章于 2022-08-10 23:14:51 发布

原创

最新推荐文章于 2022-08-10 23:14:51 发布 · 611 阅读

0 ·

CC 4.0 BY-SA版权

递归方法和循环方法的对比
递归方法代码实现比较简洁，但是性能不如循环方法，还有可能出现栈溢出的问题。一般情况下优先考虑递归方法来实现！
搜索路径的题目：一般使用回溯法，回溯法很适合使用递归方法的代码来实现！当要求不能使用递归实现的时候，考虑使用栈模拟递归的过程
求某个问题的最优解时，并且该问题可以拆分为多个子问题时：可以尝试使用动态规划的方法！在使用自上而下的递归思路去分析动态规划问题时，会发现子问题之间存在重叠
的更小的子问题。为了避免不必要的重复计算，使用自下而上的循环代码来实现，即把子问题的最优解先计算出来并用数组保存下来，然后基于子问题的解计算大问题的解。
特殊情况：在分解子问题的时候存在某个特殊的选择，采用这个特殊的选择将一定那个得到最优解，则此题目可能适用于贪心算法！
典型题目的解题思路：在一个已经排好序的数组中查找一个数字或者统计某个数字出现的次数，可以尝试使用二分查找算法！
Q1:给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。注意：答案中不可以包含重复的三元组。
自己写的：暴力解决，时间复杂度太大

class Solution(object):
    def threeSum(self, nums):
        nums.sort()
        result = []
        temp = []
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                for k in range(j + 1, len(nums)):
                    if nums[i] + nums[j] + nums[k] == 0:
                        result.append([nums[i], nums[j], nums[k]])
        for i in range(len(result)):
            if result[i] not in temp:
                temp.append(result[i])
            else:
                continue
        return temp


if __name__ == "__main__":
    s = Solution()
    result = s.threeSum([-1, 0, 1, 2, -1, -4, 3, -5, -2, -3])
    print(result)

网上大神的解法：

class Solution:
    def threeSum(self, nums):
    # 存储结果列表
        result = []
        # 对nums列表进行排序，无返回值，排序直接改变nums顺序
        nums.sort()
        for i in range(len(nums)):
            # 因为是升序排列，如果排序后第一个数都大于0，则跳出循环，不可能有为0的三数之和
            if nums[i] > 0:
                break
            # 排序后相邻两数如果相等，则跳出当前循环继续下一次循环，相同的数只需要计算一次
            if i > 0 and nums[i] == nums[i-1]:
                continue
            # 记录i的下一个位置
            j = i + 1
            # 最后一个元素的位置
            k = len(nums) - 1
            while j < k:
                # 判断三数之和是否为0
                if nums[j] + nums[k] == -nums[i]:
                    # 把结果加入数组中
                    result.append([nums[i], nums[j], nums[k]])
                    # 判断j相邻元素是否相等，有的话跳过这个
                    while j < k and nums[j] == nums[j+1]: j += 1
                    # 判断后面k的相邻元素是否相等，是的话跳过
                    while j < k and nums[k] == nums[k-1]: k -= 1
                    # 没有相等则j+1，k-1，缩小范围
                    j += 1
                    k -= 1
                # 小于-nums[i]的话还能往后取
                elif nums[j] + nums[k] < -nums[i]:
                    j += 1
                else:
                    k -= 1
        return result

Q2:见下图

A2：

  class Solution:
  def romanToInt(self, s: str) -> int:
      d = {'M': 1000,'D': 500 ,'C': 100,'L': 50,'X': 10,'V': 5,'I': 1}
      result = 0
      s_len = len(s)
      for i in range(s_len-1):
          if d[s[i]] < d[s[i+1]]:
              result -= d[s[i]]
          else:
              result += d[s[i]]
      result += d[s[-1]]
      return result

Q3:编写一个函数来查找字符串数组中的最长公共前缀,如果不存在公共前缀，返回空字符串 “”。

A3：仅仅比较最长与最短的字符串，如果存在相同的前缀就返回；不存在就返回一个空字符串。重要的是如何从两个字符串中取相同位置的字符进行比较。

    def longest_str(strs):
        s1 = min(strs)  # 最短字符串
        s2 = max(strs) # 最长字符串
        for i, v in enumerate(s1):
            if v != s2[i]:
                return s2[:i]   # 当第一个字符就不相等时,返回s2[:0]=[],执行下面的if语句
        if not strs:
            return ""
    if  __name__ == "__main__":
        strs = ["dog", "racecar", "car"]
        strs1 = ["flower", "flow", "flight"]
        result = longest_str(strs)
        result1 = longest_str(strs1)
        print(result)
        print(result1)