LeetCode总结（第53 58 66 67题）

53. 最大子序和（第53题）
    方法一：

class Solution:
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        
        l = len(nums)
        results = nums[0]
        i = 0
        
        while i < l:
            temp = 0
            for j in range(i,l):
                temp += nums[j]
                if results < temp:
                    results = temp
            i += 1
        return results

注：执行结果超出了时间限制，这里时间复杂度是O(n**2)

方法二：

class Solution:
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        
        sums = 0
        maxsum = nums[0]
        
        for c in nums:
            if sums + c >= 0:
                sums = sums + c
                if sums > maxsum:
                    maxsum = sums
            else:
                sums = 0
                if c > maxsum:
                    maxsum = c
        return maxsum

注：方法二可以过审，也可以了解一下另外一种分治法求解

58. 最后一个单词的长度（第53题）

class Solution:
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        
        s_list = s.strip().split(" ")
        last_str  = s_list[-1]
        
        return len(last_str)

注：三行搞定，好舒服啊

66. 加一（第66题）

class Solution:
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        
        str_digits = ""
        for c in digits:
            str_digits = str_digits + str(c)
        int_digits = int(str_digits)
        digits_plus_one = int_digits + 1
        
        results = []
        for c in str(digits_plus_one):
            results.append(int(c))
        
        return results

67. 二进制求和（第67题）
    我的方法：

class Solution:
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        
        #将a b 两个数补充到一样长，前面补0
        len_ab = 0
        if len(a) <= len(b):
            a = a.zfill(len(b))
            len_ab = len(b)
        if len(a) > len(b):
            b = b.zfill(len(a))
            len_ab = len(a)
        
        results = ""
        carry_flag = 0
        
        for i in range(len_ab):
            sums = int(a[len_ab - i - 1]) + int(b[len_ab - i - 1]) + carry_flag
            if sums < 2:
                results = results + str(sums)
                carry_flag = 0
            else:
                results = results + str(sums - 2)
                carry_flag = 1
         
        if carry_flag == 1:
            results = results + str(carry_flag)
            
        results_reverse = results[::-1] #因为我们是从后往前加的，结果需要逆序输出
        
        return results_reverse

别人的方法：

class Solution:
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        
        a_dec = int(a,2) #将字符串表示的数转化成10进制
        b_dec = int(b,2)
        sums_dec = a_dec + b_dec #十进制相加
        result = bin(sums_dec)  #将十进制转换成二进制
        
        return result[2:] #上面转换成的二进制数是以0b开头的，所以返回从2开始

69. X的平方根（第69题）

class Solution:
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        
        import math
        
        x_sqrt = x ** 0.5
        result = math.floor(x_sqrt) #向下取整
        
        return result

70. 爬楼梯（第70题）

反着考虑，有几种方案到第i阶楼梯，答案是2种：反着考虑，有几种方案到第i阶楼梯，答案是2种：反着考虑，有几种方案到第i阶楼梯，答案是2种：反着考虑，有几种方案到第i阶楼梯，答案是2种：
第i-1阶楼梯经过一步
第i-2阶楼梯经过两步

或者可以递推，递推之后发现，就是和Fibonacci数列一样

class Solution:
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        
        if n == 1:
            return 1
        
        result = [1,2]
        
        for i in range(2,n):
            result.append(0) #先给result这个列表添加一个元素再赋值
            result[i] = result[i-1] + result[i-2]
            
        return result[-1]