力扣日刷251117

昨天其实也想写，但是一上午写一题没写完。但是今天看了题解恍然大悟哈哈哈!

第一题：

第一题昨天我想的太复杂了，其实很简单，只要当左边为正数的时候，将左边的值加到右边去，然后再找寻数组中的最大值就可以知道结果了！

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

上面的是动态规划的思路，还有一种就是贪心算法的思路，就是当我数组当前和小于0的时候我将当前数组抛弃。

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

        if len(nums) == 1:
            return nums[0]
        
        return res

贪心算法没有上面的直接加算法的简洁，并且时间复杂度也是稍微高一点的！

第二题：

第二题题解的思路与我的思路其实大致一致，都是先对左端点进行排序，然后当右端点大于排序后的左端点便将两者合并，右端点的值为合并前两者的最大值。

下面是题解的实现：

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key=lambda x: x[0])

        merged = []
        for interval in intervals:
            # 如果列表为空，或者当前区间与上一区间不重合，直接添加
            if not merged or merged[-1][1] < interval[0]:
                merged.append(interval)
            else:
                # 否则的话，我们就可以与上一区间进行合并
                merged[-1][1] = max(merged[-1][1], interval[1])

        return merged

下面是我自己的实现： 哈哈哈跟题解完全一致，这题学到了如何对数组进行排序的方法：

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key = lambda x: x[0])

        res =  []

        for interval in intervals:
            if res == [] or res[-1][1] < interval[0]:
                res.append(interval)
            else :
                res[-1][1] = max(res[-1][1],interval[1])
        return res

排序：intervals.sort(key = lambda x:x0)

第三题：

这题如题目所示，是一个轮转数组的题目到底怎么轮转呢？下面是灵哥的题解：

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        def reverse(i: int, j: int) -> None:
            while i < j:
                nums[i], nums[j] = nums[j], nums[i]
                i += 1
                j -= 1

        n = len(nums)
        k %= n  # 轮转 k 次等于轮转 k % n 次
        reverse(0, n - 1)
        reverse(0, k - 1)
        reverse(k, n - 1)

其中有个函数实现了旋转功能，我们完成这项任务需要实现三次旋转，一次是整体的旋转，第二是分块的旋转。

下面是我自己的题解：其中k%=n 这个很关键，用于去获取等效轮转的次数

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        def rot(i,j):
            while i < j :
                nums[i] , nums[j] = nums[j] , nums[i]
                i +=1
                j -=1
        k %=len(nums)
        rot(0,len(nums)-1)
        rot(0,k-1)
        rot(k,len(nums)-1)
        return nums

第四题：

这题主要的思路是：换成左边乘右边的模式。左边有一个累乘和，右边有一个累乘和。

中间的值就是左边与右边的乘积即可。

官方题解如下：

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

下面是我的题解：

我的大致思路与题解一样，主要的不同的之处在于，我使用的L与R是全1数组而且我使用的会比原来的多一个。多一个的目的是为了方便启动（这里不好理解）我自己也绕进去了。

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        
        n = len(nums)

        L = [1] * (n+1)
        R = [1] * (n+1)
        ans = [0] * n

        for i in range(n):
            L [i+1] = L[i] * nums[i]
        
        for i in reversed(range(n)):
            R [i] = R[i+1] * nums[i]
        
        for i in range(n):
            ans[i] = R[i+1] *L[i]

        return ans

不过代码跟人有一个能跑就行是不哈哈哈哈！这篇回家发的，暂时逃避一下学校的风波。