leetcode 数组：简单题 第四页

53.最大子序和（着重看的简单题）

思路：贪心（重要思想）cur_sum存储局部的最大子序列和，ans存储全局中的最大子序列和。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        ans = float('-inf')
        cur_sum = float('-inf')
        for num in nums:
            cur_sum = max(cur_sum + num, num) 
            ans = max(ans,cur_sum)
        return ans

628.三个数的最大乘积

解法一
次优解。时间复杂度O(NlogN)
排序后分情况讨论

class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        nums = sorted(nums)
        ans = float('-inf')
        if nums[1] <= 0 and nums[-1] >= 0:             #两个负数一个正数
            ans = max(ans , nums[0]*nums[1]*nums[-1])
        if nums[-3] >= 0 or nums[-1] <= 0:                                # 三个正数
            ans = max(ans , nums[-3]*nums[-2]*nums[-1])
        if nums[-1] >= 0 and nums[-2] <= 0:
            ans = max(ans , nums[-3]*nums[-2]*nums[-1])
            if len(nums) > 3:
                ans = max(ans,nums[-4]*nums[-3]*nums[-2])
        return ans

解法二
最优解：时间复杂度O(N)。
一次遍历，分别用五个遍历记录两个最小值和三个最大值。

class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        min1 ,min2 = float('inf') , float('inf')
        max1,max2,max3 = float('-inf'),float('-inf'),float('-inf')
        for num in nums:
            if num < min1:
                min1,min2 = num,min1
            elif num < min2:
                min2 = num
            if num > max1:
                max1,max2,max3 = num,max1,max2
            elif num > max2:
                max2,max3 = num,max2
            elif num > max3:
                max3 = num
        return max(min1*min2*max1,max1*max2*max3)

26.删除排序数组中的重复项

思路：遍历过程中用快慢指针来记录即可。

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        index,cur_num = 0,float('inf')
        for num in nums:
            if num != cur_num:
                nums[index] = num
                cur_num = num
                index += 1
        nums = nums[:index]
        return len(nums)

1.两数之和

思路：一次遍历即可，因为要求两数之和，所以遍历到一个数字的时候便查找其另一半是否在哈希表中，若在则结束，若不在则将其加入哈希表。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        Hash = {}
        for i in range(len(nums)):
            if target-nums[i] in Hash:
                return[Hash[target-nums[i]],i]
            else:
                Hash[nums[i]] = i

746.使用最小花费爬楼梯

思路：动态规划，f中存储如果经过此楼梯所需要的最小花费，走完后只可能从最后一层或者最后两层上去，所以min(f[-1],f[-2])即可。

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        f = [0]*len(cost)
        f[0] = cost[0]
        f[1] = cost[1]
        for i in range(2,len(cost)):
            f[i] = min(f[i-1] + cost[i],f[i-2] + cost[i])
        return min(f[-1],f[-2])

88.合并两个有序数组

这个题有机会可以多看下，不难，但是过程中被卡了好久，还是思维不够灵活

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        i = m-1
        j = n-1
        k = m+n-1
        while i >= 0 and j >= 0:
            if nums1[i] > nums2[j]:
                nums1[k] = nums1[i]
                i -= 1
            else:
                nums1[k] = nums2[j]
                j -= 1
            k -= 1
        nums1[:j+1] = nums2[:j+1]

717.1比特与2比特字符

解法一：
线性扫描即可

class Solution:
    def isOneBitCharacter(self, bits: List[int]) -> bool:
        index = 0
        n = len(bits)
        while True:
            if bits[index] == 1:
                if index == n-2:
                    return False
                index += 2
            else:
                if index == n-1:
                    return True
                index += 1

解法二：
因为最后一位必为0，所以他是1还是2字符只与其左侧连续1出现的个数有关，当有奇数个连续1时，其为2字符，有偶数个连续1时，为1字符。

830.较大分组的位置

比较简单的思路了，双指针。

class Solution:
    def largeGroupPositions(self, S: str) -> List[List[int]]:
        ans = []
        index = 0
        for i in range(len(S)):
            if S[i] != S[index]:
                if i-index >= 3:
                    ans.append([index,i-1])
                index = i
        if len(S)-index >= 3:
            ans.append([index,len(S)-1])
        return ans

35.搜索插入位置

最基本的二分查找，需要注意的是left和right的+1和-1问题，left变为mid+1，right变为mid即可。

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        if target > nums[-1]:
            return len(nums)
        left,right = 0,len(nums)-1
        while left != right:
            mid = (left + right)//2
            if nums[mid] == target:
                return mid
            if nums[mid] > target:
                right = mid
            elif nums[mid] < target:
                left = mid +1
        return left

1018.可被5整除的二进制前缀

常规题，遍历一次就可，为了防止内存溢出，每一次求和都计算一次余数就好。

class Solution:
    def prefixesDivBy5(self, A: List[int]) -> List[bool]:
        Sum = 0
        ans = []
        for num in A:
            Sum = Sum * 2 + num
            if Sum % 5 == 0:
                ans.append(True)
            else:ans.append(False)
        return ans

674.最长连续递增序列

滑动窗口的典型题目，可以多总结一下这类题目。

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        left,right = 0,0
        ans = 0
        for i in range(1,len(nums)):
            if nums[i] <= nums[i-1]:
                ans = max(ans,i - left)
                left = i
        ans = max(ans,len(nums) - left)
        return ans

989.数组形式的整数加法

记住这个做数组加法的小技巧：

class Solution(object):
    def addToArrayForm(self, A, K):
        A = A[::-1]
        A[0] += K
        for i in range(len(A)-1):
            if A[i] > 9:
                A[i+1] += A[i] //10
                A[i] = A[i] % 10
        while A[-1] > 9:
            A.append(A[-1]//10)
            A[-2] = A[-2] % 10
        return A[::-1] 

1010.总持续时间可被60整除的歌曲

用哈希表存储目前已经出现的相同长度（除60的余数）的歌曲数目，总共遍历一次即可，注意歌曲长度为0和30的情况比较特殊。

class Solution:
    def numPairsDivisibleBy60(self, time: List[int]) -> int:
        Hash = {}
        ans = 0
        for t in time:
            t = t % 60
            if t == 0 or t == 30:
                if t in Hash:
                    ans += Hash[t]
                    Hash[t] += 1
                else: Hash[t] = 1
            else:
                if t in Hash:
                    Hash[t] += 1
                else:Hash[t] = 1
                if (60-t) in Hash:
                    ans += Hash[60-t]
        return ans

66.加一

上上个题989题的简化版

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        ans = digits[::-1]
        ans[0] += 1
        for i in range(len(ans)-1):
            if ans[i] > 9:
                ans[i+1] += 1
                ans[i] -= 10
            else:return ans[::-1]
        while ans[-1] > 9:
            ans.append(1)
            ans[-2] -= 10
        return ans[::-1]

1128.等价多米诺骨牌对的数量

挺简单的题目，哈希表遍历一次即可，时间复杂度O(n),空间复杂度O(n)。

class Solution:
    def numEquivDominoPairs(self, dominoes: List[List[int]]) -> int:
        Hash = {}
        ans = 0
        for i,j in dominoes:
            num1 = i*10+j
            num2 = j*10+i
            if num1 in Hash:
                ans += Hash[num1]
                Hash[num1] += 1
            elif num2 in Hash:
                ans += Hash[num2]
                Hash[num2] += 1
            else:
                Hash[num1] = 1
        return ans

1346.检查整数及其两倍数是否存在

哈希表遍历即可

class Solution:
    def checkIfExist(self, arr: List[int]) -> bool:
        Hash = {}
        for num in arr:
            if num/2 in Hash or num*2 in Hash:
                return True
            Hash[num] = 1
        return False

189.旋转数组

数组元素向后循环平移k个位置，只需将数组全部求逆，之后求前k个元素的逆和后n-k的元素的逆。

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        k = k % n
        if k == 0:
            return
        for m in range(n):
            if m >= n-m-1:
                break
            nums[m],nums[n-1-m] = nums[n-1-m],nums[m]
        for i in range(k):
            if i >= (k-1)/2:
                break
            nums[i],nums[k-1-i] = nums[k-1-i],nums[i]
        for j in range(k,n):
            if j >= (k+n-1)/2:
                break
            nums[j],nums[n+k-1-j]=nums[n+k-1-j],nums[j]

849.到最近的人的最大距离

只需要注意两侧的特殊情况即可

class Solution:
    def maxDistToClosest(self, seats: List[int]) -> int:
        ans,cur = 0,0
        for num in seats:
            if num == 1:
                break
            ans += 1
        for num in seats:
            if num == 0:
                cur += 1
            else:
                ans = max(ans,(cur+1)//2)
                cur = 0
        ans = max(ans,cur)
        return ans