从零开始刷Leetcode——数组（581.605.628）

581. 最短无序连续子数组

给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

你找到的子数组应是最短的，请输出它的长度。

1.排序

class Solution:
    def findUnsortedSubarray(self, nums: List[int]) -> int:
        num1 = sorted(nums)
        left =float("inf")
        right = 0
        for i in range(len(num1)):
            if num1[i] != nums[i]:
                left = min(left, i)
                right = max(right, i)
        if right - left + 1 > 0:
            return right - left + 1
        else:
            return 0

将排序后的数组和原数组对比，第一个不同的值与最后一个不同值的差即所得解。296ms，15.1MB

2.两次遍历

class Solution:
    def findUnsortedSubarray(self, nums: List[int]) -> int:
        n=len(nums)
        max_num=nums[0]
        right=0
        for i in range(n):
            if(nums[i]>=max_num):
                max_num=nums[i]
            else:
                right=i
        left=n
        min_num=nums[-1]
        for i in range(n-1,-1,-1):
            if(nums[i]<=min_num):
                min_num=nums[i]
            else:
                left=i
        return right-left+1 if(right-left+1 >0) else 0

244ms，14.9MB

605.种花问题

假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花？能则返回True，不能则返回False。

1.贪心查找

class Solution:
    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
        if n == 0:
            return True
        flowerbed.insert(0, 0)
        flowerbed.append(0)
        for i in range(1, len(flowerbed)-1):
            if flowerbed[i-1] != 1 and flowerbed[i+1] != 1 and flowerbed[i] == 0:
                n -= 1
                flowerbed[i] = 1
            if n == 0:
                return True
        return False

前后各插入一个0可以让计算更容易，然后遍历即可。200ms，14.1MB

2.判断是否三个0连续

class Solution:
    def canPlaceFlowers(self, f: List[int], n: int) -> bool:
        sums = 0
        i = 0
        f.insert(0,0)
        f.insert(len(f),0)
        while i in range(len(f) - 2):
            if f[i] == 0 and f[i + 1] == 0 and f[i + 2] == 0:
                sums += 1
                i += 1
            i += 1
        if n <= sums:
            return True
        else:
            return False

依旧收尾加0，有三个0连续代表可以种花。296ms，13.9MB

628. 三个数的最大乘积

给定一个整型数组，在数组中找出由三个数组成的最大乘积，并输出这个乘积。

1.排序

class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        nums.sort()
        return max(nums[0]*nums[1]*nums[-1], nums[-1]*nums[-2]*nums[-3])

一共两种情况，最大的三个正数的乘积、最大的正数和最小的两个负数的乘积，排序后比较即可。
364ms，14.6MB

一次遍历得到上述五个值速度快点，但是代码较长不写了。