leetcode题解python版：66-70

66、加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
解：先对n-1项+1，然后从右向左遍历，同时记录进位值。遍历完如果还剩1就插到最前面。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        n=len(digits)
        jump=0
        digits[n-1]=digits[n-1]+1
        for i in range(n-1,-1,-1):
            digits[i]=digits[i]+jump
            jump=digits[i]//10
            digits[i]=digits[i]%10
            if jump==0:
                break
        if jump==1:
            digits.insert(0,1)
        return digits

执行用时：36 ms, 击败了88.31%的用户
内存消耗：13.4 MB, 击败了97.14%的用户

67、二进制求和
给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。
解：与上题方法相同,只是要对两个str谁大的问题分类讨论

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        m=len(a)
        n=len(b)
        s=""
        i=0
        jump=0
        while i<n and i<m:
            cur=int(a[m-1-i])+int(b[n-1-i])+jump
            jump=cur//2
            cur=cur%2
            s=str(cur)+s
            i=i+1
        if m>n:
            if jump==1:
                while i<m:
                    cur=int(a[m-1-i])+jump
                    jump=cur//2
                    cur=cur%2
                    s=str(cur)+s
                    i=i+1
                if jump==1:
                    s="1"+s
            else:
                s=a[:m-i]+s
        elif m<n:
            if jump==1:
                while i<n:
                    cur=int(b[n-1-i])+jump
                    jump=cur//2
                    cur=cur%2
                    s=str(cur)+s
                    i=i+1
                if jump==1:
                    s="1"+s
            else:
                s=b[:n-i]+s
        else:
            if jump==1:
                s="1"+s
        return s

执行用时：44 ms, 击败了68.50%的用户
内存消耗：13.7 MB, 击败了54.80%的用户

68、文本左右对齐
给定一个单词数组和一个长度 maxWidth，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。
你应该使用“贪心算法”来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ’ ’ 填充，使得每行恰好有 maxWidth 个字符。
要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。
文本的最后一行应为左对齐，且单词之间不插入额外的空格。
说明:
单词是指由非空格字符组成的字符序列。
每个单词的长度大于 0，小于等于 maxWidth。
输入单词数组 words 至少包含一个单词。
解:需要满足的要求：
同行单词间必须有空格，且空格数量要尽可能均匀，无法分匀时则左多又少，这决定了如何放非最后一行的单词。
最后一行单词靠左，且每个单词间只空一格。判断最后一行则是剩余单词数为n时，n-1+sum(len)<=16
注：本问题中容易忽略的就是words中的元素只能组成一行，只是在是否需要换行的时候要考虑i!=0，在更新下一行的时候也要有i!=0的前提

class Solution:
    def fullJustify(self, words: List[str], maxWidth: int) -> List[str]:
        n=len(words)
        lenList=[]
        ans=[]
        for i in range(n):
            lenList.append(len(words[i]))
        rowsum=0
        currow=[]
        for i in range(n):
            if rowsum+lenList[i]<=maxWidth and i!=0:#判断是否要换行。i!=0很关键，因为words可能一行就结束了
                rowsum=rowsum+lenList[i]+1#稍微超出一个也没关系，因为下一次循环会判断是否换行
                currow.append(i)
            else:#需要换行时
                if i!=0:
                    s=""
                    m=len(currow)#先把上一行安放好
                    rowsum=rowsum-m
                    if m==1:
                        s=s+words[currow[0]]+" "*(maxWidth-rowsum)
                    else:
                        avg=(maxWidth-rowsum)//(m-1)#平均放置空格数
                        rest=(maxWidth-rowsum)%(m-1)#剩余空格数
                        for j in range(m-1):
                            if j<=rest-1:
                                s=s+words[currow[j]]+" "*(avg+1)
                            else:
                                s=s+words[currow[j]]+" "*avg
                        s=s+words[currow[m-1]]
                    ans.append(s)
                    rowsum=0
                    currow=[]
                if sum(lenList[i:])+n-i-1<=maxWidth:#判断是否为最后一行了
                    s=""
                    k=maxWidth-sum(lenList[i:])-(n-i-1)
                    for j in range(i,n-1):
                        s=s+words[j]+" "
                    s=s+words[n-1]+" "*k
                    ans.append(s)
                    break
                else:
                    rowsum=rowsum+lenList[i]+1
                    currow.append(i)
        return ans

执行用时：40 ms, 在所有 Python3 提交中击败了70.02%的用户
内存消耗：13.7 MB, 在所有 Python3 提交中击败了44.26%的用户

69、 x 的平方根
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
解：用二分法求解即可

class Solution:
    def mySqrt(self, x: int) -> int:
        if x==0:
            return 0
        if x==2 or x==1 or x==3:
            return 1
        left=1
        right=x-1
        while right-left>=1:
            mid=(left+right)//2
            if mid*mid<=x and (mid+1)*(mid+1)>x:
                return mid
            elif mid*mid>x:
                right=mid
            else:
                left=mid+1
        return left

执行用时：48 ms, 在所有 Python3 提交中击败了69.87%的用户
内存消耗：13.5 MB, 在所有 Python3 提交中击败了90.34%的用户

70、爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
解：用递归法
f(n)=f(n-1)+f(n-2)
其中f(1)=1,f(2)=2
同时为了加快运行速度可以考虑保存中间结果。

class Solution:
    def climbStairs(self, n: int) -> int:
        ans=[]
        for i in range(1,n+1):
            self.memory(i,ans)
        return ans[n-1]
        
    def memory(self,n,ans):
        if n==1:
            ans.append(1)
            return
        if n==2:
            ans.append(2)
            return
        a=ans[n-3]+ans[n-2]
        ans.append(a)
        return 

执行用时：
32 ms, 在所有 Python3 提交中击败了95.42%的用户
内存消耗：13.7 MB, 在所有 Python3 提交中击败了55.56%的用户