二刷 leetcode（11）

88. 合并两个有序数组

给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

• 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
• 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

输出: [1,2,2,3,5,6]

代码：

class Solution:
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        #### the first method
        # nums1[m:m+n] = nums2[:]
        # nums1.sort()
        
        #### the second method
        
        while m > 0 and n > 0:
            if nums1[m-1] >= nums2[n-1]:
                nums1[m+n-1] = nums1[m-1]
                m = m -1
            else:
                nums1[m+n-1] = nums2[n-1]
                n = n-1
        if n > 0:
            nums1[:n] = nums2[:n]
        

278. 第一个错误的版本

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例:

给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true

所以，4 是第一个错误的版本。 

代码：

class Solution:
    def firstBadVersion(self, n):
        """
        :type n: int
        :rtype: int
        """
        left, right = 1, n
        while left < right:
            mid = left + (right - left) // 2
            if isBadVersion(mid) == True:
                right = mid
            else:
                left = mid + 1
        return left

53. 最大子序和

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

示例:

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

代码：

class Solution:
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #### the first method
        # sum = 0
        # for i in range(1,len(nums)):
        #     sum = max((nums[i] + nums[i-1]), nums[i])
        #     nums[i] = sum
        # return max(nums)
        
        #### the second method
#         result = []
#         sum = 0
#         for num in nums:
#             sum = sum + num if sum > 0 else num
#             result.append(sum)
                
#         return max(result)

        #### the third method 
        max_num = nums[0]
        sum = 0
        for num in nums:
            if sum < 0:
                sum = 0
            sum += num
            if max_num < sum:
                max_num = sum
        return max_num
       

70 .  爬楼梯（实则是一个求斐波拉契数列的问题）

假设你正在爬楼梯。需要 n 步你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 步 + 1 步
2.  2 步

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 步 + 1 步 + 1 步
2.  1 步 + 2 步
3.  2 步 + 1 步

代码：

class Solution:
    global f
    f = collections.defaultdict(int)
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        #### the first method
#         step = [1,2]
#         for i in range(2, n):
#             step.append(step[i-1] + step[i-2])
        
#         return step[n-1]
        
        #### the second method
        
        if  n < 0:
            return 0
        if n == 0:
            return 1
        if n in f.keys():
            return f[n]
        one_steps = self.climbStairs(n-1)
        two_steps = self.climbStairs(n-2)
        f[n] = one_steps + two_steps
        return f[n]
       

198. 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例 1:

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 2:

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

代码：

class Solution:
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #### the first method 
        if len(nums) == 0:
            return 0
        if len(nums) == 1:
            return nums[0]
        rob = [0] * len(nums)
        rob[0] = nums[0]
        rob[1] = max(nums[0], nums[1])
        for i in range(2, len(nums)):
            rob[i] = max(rob[i-1], rob[i-2] + nums[i])
        return rob[-1]

        #### the second method
        cur=pre1=pre2=pre3= 0
        for i in range(len(nums)):
            cur, pre1, pre2, pre3 = max(pre1, pre2)+nums[i], cur, pre1, pre2
    
        return max(cur, pre1)