2021-09-12

递归

斐波那契数

斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给你 n ，请计算 F(n) 。

class Solution:
    def fib(self, n: int) -> int:
        #########递归 自顶向下###########
        # if n==0:
        #     return 0
        # if n==1:
        #     return 1
        # else:
        #     return self.fib(n-1)+self.fib(n-2)
        ##########动态规划 自底向上##############
        if n<2:
            return n
        p,q=0,1
        for i in range(1,n):
            r=p+q
            p=q
            q=r
        return r

路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。
叶子节点 是指没有子节点的节点。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root==None:
            return False
        if root.left==None and root.right==None and targetSum!=root.val:
            return False
        if root.left==None and root.right==None and targetSum==root.val:
            return True
        # res1,res2=False,False
        # if root.left!=None:
        #     res1 = self.hasPathSum(root.left,targetSum-root.val)
        # if root.right!=None:
        #     res2 = self.hasPathSum(root.right,targetSum-root.val)
        # return res1 or res2
        return self.hasPathSum(root.left,targetSum-root.val) or self.hasPathSum(root.right,targetSum-root.val)

分治

169.多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        #分治法
        def fenzhi(l,r):
            if l==r:                #不断二分，直到只剩一个数时返回该数
                return nums[l]
            mid = (l+r)//2          #二分的中点
            left=fenzhi(l,mid)      #返回左侧众数
            right=fenzhi(mid+1,r)   #右侧众数
            if left == right:       #左右侧众数相等则返回该众数
                return left
            else:                   #不等，则在整个区间内分别统计左右众数出现次数，返回次数大的
                lcount=0
                rcount=0
                for i in nums[l:r+1]:
                    if i==left:
                        lcount+=1
                    if i==right:
                        rcount+=1
                return left if lcount>rcount else right
        return fenzhi(0,len(nums)-1)
        #投票法
        # count=0
        # for num in nums:
        #     if count==0:
        #         res=num
        #         count+=1
        #     elif res!=num:
        #         count-=1
        #     else:
        #         count+=1
        # return res

动态规划

爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。

class Solution:
    def climbStairs(self, n: int) -> int:
        if n<=2:
            return n
        dp0=1
        dp1=2
        for i in range(2,n):
            dpi=dp0+dp1
            dp0=dp1
            dp1=dpi
        return dpi

hw笔试复盘

1.给你一个矩阵，求最大子矩阵和

nums=[[0,-2,-7,0],[9,2,-6,2],[-4,1,-4,1],[-1,8,0,-2]]
def maxsum(nums):
    if nums==None or nums==[] or nums[0]==[]:
        return 0
    res=nums[0][0]
    cur=0
    arr=[]
    for i in range(0,len(nums)):   #上边界
        arr=[0 for _ in range(len(nums[0]))]
        for j in range(i,len(nums)):   #下边界  从i到n-1
            cur=0
            for k in range(0,len(nums[0])):   #每一列
                arr[k]=arr[k]+nums[j][k]    #每一列之和，行数从1开始累加  
                cur+=arr[k]
                res=max(res,cur)
                if cur<0:   #前几列和为负，删去
                    cur=0
    return res


print(maxsum(nums))