一枚菜鸟的leetcode刷题笔记 - Day8

最新推荐文章于 2024-11-14 15:56:18 发布

Joyeeee.

最新推荐文章于 2024-11-14 15:56:18 发布

阅读量432

点赞数 1

分类专栏： leetcode 文章标签：算法数据结构动态规划 leetcode

本文链接：https://blog.csdn.net/Joye_BNU/article/details/112848152

版权

leetcode 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

文章目录

62 - 不同路径

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？

解法一：递归

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if n == 1 or m == 1:
            return 1

        return self.uniquePaths(m-1, n) + self.uniquePaths(m, n-1)

很不幸超时了，超时样例是m=23,n=12.

递归的思路很简单，机器人从(1,1)走到(m,n)的不同路径数 = 机器人从(1,1)走到(m-1,n)的不同路径数 + 机器人从(1,1)走到(m,n-1)的不同路径数。而递归的base情况就是 m=1 或者 n=1. 因为此时只需要一直向右走或者一直向下走就可以了，都是只有一种情况，所以返回 1.

动态规划

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        #维护一个表格table，table的第(i,j)个位置记录了机器人走到当前位置的不同路径数
        table = [[0 for _ in range(n)] for _ in range(m)]
        #先把第一行和第一列填好，因为这些位置的路径数都是1
        for i in range(m):
            table[i][0] = 1
        for j in range(1, n):
            table[0][j] = 1
        #开始填表格
        for i in range(1, m):
            for j in range(1, n):
                table[i][j] = table[i-1][j] + table[i][j-1]
        
        return table[m-1][n-1]

动态规划其实和递归的想法是一样的，核心点都在于想清楚：机器人从(1,1)走到(m,n)的不同路径数 = 机器人从(1,1)走到(m-1,n)的不同路径数 + 机器人从(1,1)走到(m,n-1)的不同路径数。这就是状态转移方程：table[i][j] = table[i-1][j] + table[i][j-1]. 不同在于递归是倒着往回推，动态规划是从初始情况往后推。注意 table[i-1][j] 和 table[i][j-1] 都要在 table[i][j] 前被遍历到。

70 - 爬楼梯

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

class Solution:
    def climbStairs(self, n: int) -> int:
        if n == 1:
            return 1
        if n == 2:
            return 2
        return self.climbStairs(n-1) + self.climbStairs(n-2)

因为一次可以走1或2步，因此 n级台阶的走法 = n-1级台阶的走法(最后走一步) + n-2级台阶的走法(最后走两步)
递归超时了。因为递归比循环慢很多，下面改写成循环的解法。

class Solution:
    def climbStairs(self, n: int) -> int:
        s1 = 1
        s2 = 2
        for i in range(3, n+1):
            if s1 < s2:
                s1 = s1 + s2
            else:
                s2 = s1 + s2
        if n == 1:
            return 1
        elif n == 2:
            return 2
        else:
            return max(s1, s2)

注意返回时分情况讨论。

78 - 子集

给你一个整数数组 nums ，返回该数组所有可能的子集（幂集）。解集不能包含重复的子集。

示例一：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例二：
输入：nums = [0]
输出：[[],[0]]

分析：
这一题和全排列不同，数组元素的顺序不能换，不然就会导致重复的情况。

本题解法参考了简单问题细致分析，两种DFS回溯思路

解法一：定义递归函数找到当前index开始的数组的所有子集

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        ans = []

        def backtrack(index, tmp):
            ans.append(tmp)
            for i in range(index, len(nums)):
                backtrack(i+1, tmp + [nums[i]])

        backtrack(0, [])
        return ans

这个递归比较有意思的是，没有一个显式定义的出口，而是通过循环控制递归结束。即 for 循环完成，当前层次的递归就结束了。回溯还是通过递归完成的，因为递归完成一次相当于入栈出栈一次，出栈即回溯了。

那么此处的递归函数backtrack到底是什么意思呢，它实现了以当前index为开头的所有情况，即数组 nums[index, len(nums)] 的所有子集。

以[1,2,3]为例，此解法元素的添加顺序是：[], [1], [1,2], [1,2,3], [1,3], [2], [2,3], [3]

解法二：对数组的每个元素考虑选或不选

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        ans = []

        def backtrack(index, tmp):
            if index == len(nums):
            #定义了递归的base情况，当nums中的所有数字都被考虑过一遍时，return
                return ans.append(tmp)
            #子集中选择当前nums[index]
            backtrack(index+1, tmp + [nums[index]])
            #子集中不选择当前nums[index]
            backtrack(index+1, tmp)
        
        backtrack(0, [])
        return ans