6-10题

6、跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。跟斐波那契数列类似

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n==0:
            return 0
        elif n==1:
            return 1
        elif n==2:
            return 2
        else:
            memory = [1, 2]
            for i in range(2, n):
                memory.append(memory[i-1]+memory[i-2])
            return memory[-1]

7、变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

class Solution(object):
    def climbStairs(self, n):
        if n==0:
            return 0
        elif n==1:
            return 1
        else:
            memory = [1]
            for i in range(1,n):
                memory.append(sum(memory)+1)
            return memory[-1]

8、矩形覆盖
我们可以用2 * 1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2n的大矩形，总共有多少种方法？
不会做，上网查了下结果也是个斐波那契数列。

class Solution:
    def rectCover(self, number):
        if number<=2:
            return number
        dp = [1,2]
        for i in range(number-2):
            dp.append(dp[-1]+dp[-2])
        return dp[-1]

9、把字符串转换成整数
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0 。
不能用字符串转换整数的库函数，第一反应是用eval函数，不知道算不算字符串转整数的库函数。

class Solution:
    def StrToInt(self, s):
        if (s[0].isdigit()) or (s[0] in ['-', '+']):
            for i in s[1:]:
                if not i.isdigit():
                    return 0
                    break
            else:
                return eval(s)
        else:
            return 0

10、平衡二叉树的判断
判断一个二叉树是否平衡二叉树。平衡二叉树的定义：平衡二叉树是一颗空树或者它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def maxdepth(root):
            if not root:
                return 0
            else:
                ldepth = 1 + maxdepth(root.left)
                rdepth = 1 + maxdepth(root.right) 
                return max(ldepth, rdepth)
        
        if not root:
            return True
        else:
            if abs(maxdepth(root.right)-maxdepth(root.left)) > 1:
                return False
            return self.isBalanced(root.left) and self.isBalanced(root.right)