Leetcode笔记

14.最长公共前缀

题目

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1：

输入：strs = [“flower”,“flow”,“flight”] 输出：“fl”
示例 2：
输入：strs = [“dog”,“racecar”,“car”] 输出："" 解释：输入不存在公共前缀。

提示：

0 <= strs.length <= 200 0 <= strs[i].length <= 200 strs[i] 仅由小写英文字母组成

我的解法

def longestCommonPrefix(strs):
    """
    :type strs: List[str]
    :rtype: str
    """
    publicPrefix = []
    if strs == []:
        return ''
    elif len(strs) == 1:
        return str(strs[0])
    oneslice = list(strs[0])
    for x in strs[1:]:
        if x == "":
            publicPrefix = []
            break
        elif not publicPrefix:
            for idx in range(len(x)):
                if idx > len(oneslice)-1:
                    break
                elif x[idx] != oneslice[idx]:
                    if idx == 0:
                        return ''
                    else:
                        break
                elif x[idx] == oneslice[idx]:
                    publicPrefix.append(x[idx])
        else:
            for idx in range(len(x)):
                if idx > len(publicPrefix)-1:
                    break
                elif x[idx] == publicPrefix[idx]:
                    continue
                elif x[idx] !=publicPrefix[idx]:
                    if idx > 0:
                        publicPrefix = publicPrefix[:idx]
                    elif idx == 0:
                        publicPrefix = []
                        break
                else:
                    break
    return ''.join(str(i)for i in publicPrefix)
print(longestCommonPrefix(["ac","ac","a","a"]))

优化解法

1. 横向扫描

class Solution:
    def longestCommonPrefix(self,strs):#List[str]) #-> str:
        if not strs:
            return ''
        prefix,length = strs[0],len(strs)
        for x in strs[1:]:
            prefix = self.commonprefix(prefix,x)
            if not prefix:
                return ''
        return prefix

    def commonprefix(self,prefix,x):
        #-->str
        #两个字符串的公共前缀
        length = min(len(prefix),len(x))
        index = 0
        while index < length and prefix[index] == x[index]:
            index += 1
        return prefix[:index]

1. 复杂度分析

时间复杂度：O(mn)O(mn)，其中 mm 是字符串数组中的字符串的平均长度，nn
是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次。

空间复杂度：O(1)O(1)。使用的额外空间复杂度为常数。

2. 纵向扫描

class Solution:
    def longestCommonPrefix(self,strs):#List[str]) #-> str:
        if not strs:
            return ''

        count = len(strs[0])
        prefix = []
        for j in range(count):
            c = strs[0][j]
            for i in range(1,len(strs)):
                if any(i == len(strs[j])) or strs[0][j] != strs[i][j]:
                    return strs[0][:j]
        return strs[0]

4. 分治法
5. 二分查找

204. 计数质数

题目

统计所有小于非负整数 n 的质数的数量。

示例 1：

输入：n = 10 输出：4 解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。 示例 2：

输入：n = 0 输出：0 示例 3：

输入：n = 1 输出：0

疯狂超时版本

class Solution(object):
    def countPrimes(self, n):
        """
        :type n: int
        :rtype: int
        """
        count = 0
        for x in range(2,n):
            if Solution().isPrime(x):
                count += 1
        return count
    
    def isPrime(self,x):
        sqrtx = int(sqrt(x)) + 1
        for i in range(2,sqrtx):
            if x % i == 0:
                return False
        return True

大神解法

• 厄拉多塞筛法：

#厄拉多塞筛法
#求20以内质数的个数,首先0,1不是质数.2是第一个质数,
# 然后把20以内所有2的倍数划去.2后面紧跟的数即为下一个质数3,
# 然后把3所有的倍数划去.3后面紧跟的数即为下一个质数5,
# 再把5所有的倍数划去.以此类推.
class Solution(object):
    def countPrimes(self, n):
        """
        :type n: int
        :rtype: int
        """
        l = [1] * n
        l[0],l[1] = 0,0
        for x in range(2,int(n**0.5)+1):
            if l[x] == 1:
                l[2*x:n:x] = [0]*len(l[2*x:n:x]) #注意倍数的表达，不用递归
                #注意切片之后该片切片后的列表，改变的是原列表
        return sum(l)
print(Solution().countPrimes(10))

198.打家劫舍（动态规划）

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。 示例 2：

输入：[2,7,9,3,1] 输出：12 解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5
号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：

0 <= nums.length <= 100 0 <= nums[i] <= 400

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        if len(nums) == 1:
            return nums[0]
        knowlist = [0]*len(nums)
        knowlist[0] =  nums[0]
        knowlist[1]  = max(nums[:2])
        for i in range(2,len(nums)):
            knowlist[i] = max(knowlist[i-1],knowlist[i-2]+nums[i])
        return knowlist[-1]

• 动态规划+数组

119. 杨辉三角 II

给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 3 输出: [1,3,3,1] 进阶：

你可以优化你的算法到 O(k) 空间复杂度吗？

• 动态规划

class Solution:
    def getRow(self, rowIndex) :
        cur_row = []
        next_row = [1]
        for x in range(rowIndex):
            cur_row = next_row
            next_row = [0]*(len(next_row)+1)
            for i in range(len(next_row)):
                if i == 0 or i == len(next_row)-1:
                    next_row[i] = 1
                else:
                    next_row[i] = cur_row[i] + cur_row[i-1]
        return next_row