动态规划中等题

34. 在排序数组中查找元素的第一个和最后一个位置

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        if not nums:
            return [-1,-1]
        first_index = self.firstK(nums,target)
        last_index= self.lastK(nums,target)
        if first_index > len(nums) - 1 or nums[first_index]!=target:
            first_index = -1
        if last_index <= 0 or nums[last_index-1]!=target:
            last_index = 0
        return [first_index,last_index-1]

    def firstK(self,nums,target):
        left = 0
        right = len(nums)
        while left < right:
            mid = (left + right)//2
            if nums[mid] < target:
                left = mid + 1
            else:
                right = mid
        return left

    def lastK(self,nums,target):
        left = 0
        right = len(nums)
        while left < right:
            mid = (left + right)//2
            if nums[mid] <= target:
                left = mid + 1
            else:
                right = mid
        return left

55. 跳跃游戏
    思路：一直更新能跳到的最大长度即可。

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        if not nums:
            return
        
        k = 0
        for i in range(len(nums)):
            if i > k or k >= len(nums) - 1:
                break
            if nums[i] + i > k:
                k = nums[i] + i
        
        if k >= len(nums) - 1:
            return True
        else:
            return False

62. 不同路径
    dp[i][j] = dp[i-1][j] + dp[i][j-1]

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if m <= 0 or n <= 0:
            return 0
        
        if m == 1 or n == 1:
            return 1
        
        pre_row = [1] * (m - 1)
        pre_col = 1

        for i in range(1,n):
            for j in range(m - 1):
                pre_row[j] = pre_col + pre_row[j]
                pre_col = pre_row[j]
            pre_col = 1
        return pre_row[m-2]

关键是思考，想清楚关系，看是否能空间度也能达到最优

300. 最长上升子序列

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        if not nums:
            return 0
        dp = []
        for i in range(len(nums)):
            dp.append(1)
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
        return max(dp)

时间复杂度优化，动态规划加二分查找