刷题记录-day8 （连续子数组的最大和、跳台阶、斐波那契数列）

1. 连续子数组的最大和

class Solution:
    def FindGreatestSumOfSubArray(self , array: List[int]) -> int:
        # write code here
        # 动态规划解法 时间复杂度为 O(n)O(n)，空间复杂度为 O(n)O(n)
        # 新建dp数组，用于存放 以每个index为结尾的最大和子数组的最大和
        # 注意for循环要以1开始，因为从0开始的话没有dp[0-1]
        lenth = len(array)
        if lenth == 0:
            return 0
        dp = [array[0]]*(lenth)
        for i in range(1, lenth):
            dp[i] = max(array[i], array[i] + dp[i-1])
        return max(dp)
        
        # 两个变量的方法 时间复杂度为 O(n)O(n)，空间复杂度为 O(1)O(1)
        # 一个变量用于去尝试做加法，看看加了array[i]是不是变大了，如果拖累了array[i]，就把它前面的舍弃，只要array[i]
        # 一个变量用于计算当前的累计最大值，相当于使用sum来表示dp数组的最大值
        sum, res = 0, array[0]
        for i in range(len(array)):
            sum += array[i]
            if array[i] > sum:
                sum = array[i]
            res = max(res,sum)
        return res
            
        # 跟上面的方法很类似，不同点在于，把上述array[i] > sum的判断条件换成了s<0
        # 上面的方法是从当前元素的角度看待问题，这个方法是从下一步的角度看待问题
        # 如果s<0说明目前的总和是负数，会拖累下一步的array[i+1]值，因此赶快把它置为0以不影响下一步
        s,res = 0,array[0]
        for num in array:
            s += num
            if res<s:
                res = s
            if s<0:
                s = 0
        return res   
    
        # 也是用两个变量，但需要额外限制数字大小的下限
        # 这是一种更好理解的方法，如果前一步的总和now<0, 就舍弃掉，直接把now再次设为当前值
        now=0
        ans=-1000000000
        for i in array:#此处i即代表array里面的第i个元素的值
            if now<0 :
                now=i#now<0,则舍去前面的
            else :
                now+=i
            ans=max(ans,now)#更新ans
        return ans

2.跳台阶

class Solution:
    def jumpFloor(self , number: int) -> int:
        # write code here
        # 根据动态规划的思想，我们可以将跳上n级台阶有多少种跳法转换成：
        # n-1级台阶有多少种跳法   +   n-2级台阶有多少种跳法
        # 因为从n-1级到n级只有一种固定跳法，从n-2级到n级也只有一种固定跳法（为什么呢？）
            # n-2级到n级虽然有两种跳法，但是如果使用一阶一阶跳，那么这种情况已经包含在了n-1级台阶有多少种跳法中了，
            # 因为n-1级台阶有多少种跳法包含n-2到n-1跳一阶，n-1到n肯定也是一阶
        # 因此按照这个思路，我们定义dp_0为n-2级台阶有多少种跳法； dp_1为n-1级台阶有多少种跳法
        # 要计算n阶，就dp_0 + dp_1，然后我们把这个n阶又作为下一次迭代的n-1级，即dp_1，显然之前的n-1阶就成了n-2阶了，因此dp_0=dp_1
        dp_0 = 0
        dp_1 = 1
        for i in range(number):
            temp = dp_1
            dp_1 = dp_0 + dp_1
            dp_0 = temp
        return dp_1

3.斐波那契数列

class Solution:
    def Fibonacci(self , n: int) -> int:
        # write code here
        # 跟跳台阶很相似
        dp_1, dp_2, res = 1, 1, 1
        for i in range(3, n+1):
            res = dp_1 + dp_2
            dp_2 = dp_1
            dp_1 = res
        return res