【剑指offer刷题记录】搜索与回溯+动态规划28-10-10-63

剑指28:对称的二叉树（简单）
问题描述：请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

思路：递归

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        def recur(A,B):
            if not A and not B:return True
            if not A or not B or A.val != B.val:return False
            return recur(A.left,B.right) and recur(A.right,B.left)
        return recur(root.left,root.right) if root else True

我写了一种简单粗暴的方法，先生成镜像树，再将原树与镜像树比较，但是一直出错，看了评论才改正。出错原因：树的变量只是一个入口，在进行操作时会对内存中的树也进行镜像，导致大家都是镜像后的树；可以只比较 root.left 和 root.right 是否对称，如果它们对称，则原树对称。

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        def mirror(root):
            if not root: return
            stack = [root]
            while stack:
                node = stack.pop()
                if node.left: stack.append(node.left)
                if node.right: stack.append(node.right)
                node.left, node.right = node.right, node.left
            return root


        def same(A:TreeNode,B:TreeNode):
            if not A and not B:return True
            elif not A or not B:return False
            
            return A.val == B.val and same(A.left, B.left) and same(A.right, B.right)
        
        if not root:
            return True

        return same(root.left,mirror(root.right))

剑指10:斐波那契数列（简单）
问题描述：写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

思路：动态数组

class Solution:
    def fib(self, n: int) -> int:
        MOD = 10 ** 9 + 7
        if n < 2:return n
        p,q,r = 0,0,1
        for i in range(2,n+1):
            p = q
            q = r
            r = p + q
            i+=1
        return r%MOD

剑指10:青蛙跳台阶（简单）
问题描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

思路：我用的排列组合。。用动态规划会好很多，这道题的本质是一个斐波那契数列。

排列组合
class Solution:
    def numWays(self, n: int) -> int:
        def func(m,n):
            a = b = result = 1
            if m < n:return 0
            else:
                MIN = min(n,m-n)
                for j in range(0,MIN):
                    a=a*(m-j)
                    b=b*(MIN-j)
                    result = a//b#注意这里如果是一个斜杠，最终返回的数值会带小数点
                return result

        a = n//2
        M = 1000000007
        cont = 0
        for i in range(0,a+1):
            j = n - 2*i
            cont = cont + func((i+j),i)
        return cont%M

动态规划
class Solution:
    def numWays(self, n: int) -> int:
        a, b = 1, 1
        for _ in range(n):
            a, b = b, a + b
        return a % 1000000007

剑指63:股票的最大利润（简单）
问题描述：假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

思路：动态规划

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        cost,profit = float("+inf"),0
        for price in prices:
            cost = min(cost,price)
            profit = max(profit,price - cost)
        return profit