力扣刷题笔记2023.12.03（前缀后缀问题）

14. 最长公共前缀 - 力扣（LeetCode）

我的题解：

1.首先找到最小的字符串长度minlen，最长前缀一定小于minlen

2.将字符串数组看做一个二维数组，对于每个字符串j位置的元素，选一个参照s看一下是否和参照相同，若相同则继续遍历，不同则跳出循环，输出答案。

评价：比较笨，看下大佬们咋做的吧，待补充

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        answer=""
        flag=1
        minlen=200
        for i in range(len(strs)): #找到最小的字符串长度
            if(len(strs[i])<=minlen):
                minlen=len(strs[i])
        x=0
        for j in range(minlen):#对于每个字符串里的元素0-minlen
            s=strs[0][x]
            flag=1
            for i in range(len(strs)):#遍历所有字符串找相同
                if(strs[i][j]!=s):
                    flag=0
                    break
            if(flag==1):
                answer+=s
            if(flag==0):
                break
            x=x+1
        return answer
        

 238. 除自身以外数组的乘积 - 力扣（LeetCode）

除法解法

本憨憨最开始还是使用了除法，解法思想如下：

分情况讨论

1.数组里没有0，将所有元素相乘，针对每个元素再除以它自己即可得到答案

2.数组里有1个0，输出结果中，只有0元素位置的结果不为0，其余元素位置全部为0

3.数组里有多个0，输出结果全为0

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        len_=len(nums)
        s=1
        flag=0 #数组里是否有0，是的话flag置1
        mylist1 = [0 for i in range(len_)]
        mylist2 = [1 for i in range(len_)]
        for x in range(0,len_):#数组里有零
            if(nums[x]==0):
                flag+=1
        if(flag==0): #数组里没有零
            for x in range(len_):
                s*=nums[x]
            for x in range(len_):
                mylist2[x]=int(s/nums[x])
            return mylist2
        elif(flag==1):#数组里有零的情况
            for x in range(len_):
                if(nums[x]!=0):
                    s*=nums[x]
            for x in range(len_):
                if(nums[x]!=0):
                    mylist1[x]=0
                else:
                    mylist1[x]=int(s)
            return mylist1
        elif(flag>1):
            return mylist1

 

前缀和和后缀和解法（优雅太优雅了）

算法

初始化两个空数组 L 和 R。对于给定索引 i，L[i] 代表的是 i 左侧所有数字的乘积，R[i] 代表的是 i 右侧所有数字的乘积。
我们需要用两个循环来填充 L 和 R 数组的值。对于数组 L，L[0] 应该是 1，因为第一个元素的左边没有元素。对于其他元素：L[i] = L[i-1] * nums[i-1]。
同理，对于数组 R，R[length-1] 应为 1。length 指的是输入数组的大小。其他元素：R[i] = R[i+1] * nums[i+1]。
当 R 和 L 数组填充完成，我们只需要在输入数组上迭代，且索引 i 处的值为：L[i] * R[i]。

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        length = len(nums)
        
        # L 和 R 分别表示左右两侧的乘积列表
        L, R, answer = [0]*length, [0]*length, [0]*length
        
        # L[i] 为索引 i 左侧所有元素的乘积
        # 对于索引为 '0' 的元素，因为左侧没有元素，所以 L[0] = 1
        L[0] = 1
        for i in range(1, length):
            L[i] = nums[i - 1] * L[i - 1]
        
        # R[i] 为索引 i 右侧所有元素的乘积
        # 对于索引为 'length-1' 的元素，因为右侧没有元素，所以 R[length-1] = 1
        R[length - 1] = 1
        for i in reversed(range(length - 1)):
            R[i] = nums[i + 1] * R[i + 1]

        # 对于索引 i，除 nums[i] 之外其余各元素的乘积就是左侧所有元素的乘积乘以右侧所有元素的乘积
        for i in range(length):
            answer[i] = L[i] * R[i]
        
        return answer