【2021/4/13 刷题笔记】Leetcode之容易等级题

#2021/4/13

目录

最大子序和

【题目】

【我的方法】

执行结果：

小技巧之空间压缩：

【进阶方法之分治】

删除有序数组中的重复项

【题目】

【我的方法】

执行结果：

【优化】

执行结果：

---

 

最大子序和

【题目】

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：

输入：nums = [1]
输出：1
示例 3：

输入：nums = [0]
输出：0
示例 4：

输入：nums = [-1]
输出：-1

提示：

1 <= nums.length <= 3 * 104
-105 <= nums[i] <= 105

进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

【我的方法】

没有头绪，偷看了评论，借鉴动态规划的思想写出来：

1、dp[i]代表以下标 i 结尾的连续子数组的最大和，则显然只需要返回max(dp)即可

2、重点在于如何求dp[i]，我们可以考虑nums[i]单独成为子数组还是加入到dp[i-1]的子数组中，所以dp[i] = max(dp[i-1]+nums[i], nums[i])。

3、时间和空间复杂度：O(n)

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

执行结果：

执行用时：40 ms, 在所有 Python3 提交中击败了93.39%的用户

内存消耗：15.3 MB, 在所有 Python3 提交中击败了50.77%的用户

小技巧之空间压缩：

考虑到 f(i) 只和 f(i−1) 相关，于是我们可以只用一个变量 pre 来维护对于当前 f(i) 的 f(i−1) 的值是多少，从而让空间复杂度降低到 O(1)，这有点类似「滚动数组」的思想。

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

# 执行用时：48 ms, 在所有 Python3 提交中击败了61.14%的用户
# 内存消耗：15.1 MB, 在所有 Python3 提交中击败了98.37%的用户

【进阶方法之分治】

其实就是它的最大子序和要么在左半边，要么在右半边，要么是穿过中间，对于左右边的序列，情况也是一样，因此可以用递归处理。中间部分的则可以直接计算出来，时间复杂度应该是 O(nlogn)。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        #递归终止条件
        if n == 1:
            return nums[0]
        else:
            #递归计算左半边最大子序和
            max_left = self.maxSubArray(nums[0:len(nums) // 2])
            #递归计算右半边最大子序和
            max_right = self.maxSubArray(nums[len(nums) // 2:len(nums)])
        
        #计算中间的最大子序和，从右到左计算左边的最大子序和，从左到右计算右边的最大子序和，再相加
        max_l = nums[len(nums) // 2 - 1]
        tmp = 0
        for i in range(len(nums) // 2 - 1, -1, -1):
            tmp += nums[i]
            max_l = max(tmp, max_l)
        max_r = nums[len(nums) // 2]
        tmp = 0
        for i in range(len(nums) // 2, len(nums)):
            tmp += nums[i]
            max_r = max(tmp, max_r)
        #返回三个中的最大值
        return max(max_right,max_left,max_l+max_r)

作者：pandawakaka
链接：https://leetcode-cn.com/problems/maximum-subarray/solution/bao-li-qiu-jie-by-pandawakaka/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

详见 https://leetcode-cn.com/problems/maximum-subarray/solution/zui-da-zi-xu-he-by-leetcode-solution/

和https://leetcode-cn.com/problems/maximum-subarray/solution/bao-li-qiu-jie-by-pandawakaka/

---

删除有序数组中的重复项

【题目】

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}
 
示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

0 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按升序排列

【我的方法】

如果遍历到新的数，则直接覆盖到前面。

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

执行结果：

执行用时：1200 ms, 在所有 Python3 提交中击败了6.47%的用户

内存消耗：15.8 MB, 在所有 Python3 提交中击败了51.39%的用户

【优化】

后来决定从提示“nums 已按升序排列”入手优化，不判断是否存在，而是判断是否大于。

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

执行结果：

执行用时：44 ms, 在所有 Python3 提交中击败了79.48%的用户

内存消耗：15.5 MB, 在所有 Python3 提交中击败了99.63%的用户