秋招 hot 100 刷题记录【9】

1.买卖股票的最佳时期

• 代码链接

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        # 时间复杂度 O(N) ： 其中 N 为数组 prices 长度。遍历 prices 使用线性时间。
        # 空间复杂度 O(1) ： profit 使用 O(1) 空间。

        # 1.贪心算法
        # 思路：卖出去的股票一定是卖出股票的左边
        ans = 0
        minPrice = prices[0]
        for i in range(len(prices)):
            minPrice = min(minPrice, prices[i])
            ans = max(ans, prices[i] - minPrice)
        return ans

2.跳跃游戏

• 代码链接

class Solution(object):
    def canJump(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        # 时间复杂度 O(n)，空间复杂度 O(1)
        # 1. 贪心算法 
        # 思路：每一个位置能到达 那么一定能到达它前面的所有位置
        # 所以记录下能够到达的最远位置并且每次到达新位置后都要去遍历一次
        max_i = 0 # 一开始位于第一个下标
        for i in range(len(nums)):
            if max_i >= i and max_i < i+nums[i]:
                max_i = i + nums[i]
        return max_i >= len(nums)-1

3.跳跃游戏II

• 代码链接

class Solution(object):
    def jump(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # 思路：每次寻找能够跳跃到达的最大边界
        # 每次在上次能跳到的范围（end）内选择一个能跳的最远的位置（也就是能跳到max_far位置的点）作为下次的起跳点
        n = len(nums)
        maxPos, end, step = 0, 0, 0
        # 注意这里不考虑最后一个元素
        for i in range(n - 1):
            if maxPos >= i:
                maxPos = max(maxPos, i + nums[i])
                if i == end:
                    end = maxPos
                    step += 1
        return step

4.划分字母区间

• 代码链接

class Solution(object):
    def partitionLabels(self, s):
        """
        :type s: str
        :rtype: List[int]
        """
        # 用字典存储数组中出现的字符串最新的位置
        # 思路跟前面的跳跃游戏类似
        last = {}
        for i in range(len(s)):
            last[s[i]] = i
        res = []
        start, end = 0, 0
        for i in range(len(s)):
            end = max(end, last[s[i]]) # end应该更新为该字符最后一次出现的位置最大的地方
            if i == end:
                res.append(end - start + 1) # 存储当前的长度
                start = end + 1 # 更新起始位置
        return res

        

5.爬楼梯

• 代码链接

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        # 思路： 动态规划方法
        # 考虑的是dp[i] 指代到达n阶楼梯所有的方法

        dp = [0] * (n + 1)
        dp[0] = 1 #思考 dp[2]的情况
        dp[1] = 1
        for i in range(2, len(dp)):
            # 到当前第i阶楼梯的方法树 = 在i-1的阶梯的方法树爬1层 + 在i-2的阶梯的方法树爬2层
            dp[i] = dp[i - 1] + dp[i - 2]
        
        return dp[n]

6.杨辉三角形

• 代码链接
• 注意这里的问题是动态规划的矩阵不是我们要返回结果的答案

class Solution(object):
    def generate(self, numRows):
        """
        :type numRows: int
        :rtype: List[List[int]]
        """
        if numRows == 1: return [[1]]
        
        dp = [ [1] * numRows for _ in range(numRows)]
        # 初始化杨辉三角形矩阵
        res = []
        res.append([1])
        for i in range(1, numRows):
            level = [1]
            for j in range(1,i):
                dp[i][j] = dp[i-1][j-1] + dp[i-1][j]
                level.append(dp[i][j])
            level.append(1)
            res.append(level)
        return res

        

7.打家劫舍

• 代码链接

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # 思路：动态规划 dp[i] 指代第i个房屋能偷到的最高价格
        if len(nums) == 1: return nums[0]
        dp = [0] * len(nums)

        # 特殊值初始化
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])
        for i in range(2, len(nums)):
            dp[i] = max(dp[i-1], dp[i-2] + nums[i])
            # 考虑是否偷 这里偷的话就是考虑其中前两天的操作
        
        return dp[-1]