每日一题——8行Python代码实现PAT乙级1029 旧键盘（举一反三+思想解读+逐步优化）五千字好文

最新推荐文章于 2024-07-22 15:15:29 发布

用哲学编程

最新推荐文章于 2024-07-22 15:15:29 发布

阅读量919

点赞数 16

分类专栏：每日一题文章标签： python 开发语言 leetcode 算法数据结构

本文链接：https://blog.csdn.net/weixin_44915521/article/details/139790426

版权

每日一题专栏收录该内容

83 篇文章 0 订阅

订阅专栏

一个认为一切根源都是“自己不够强”的INTJ

个人主页：用哲学编程-CSDN博客
专栏：每日一题——举一反三
 Python编程学习
 Python内置函数

1. 原地算法（In-Place Algorithm）

2. 迭代（Iteration）

3. 递归（Recursion）

4. 双指针（Two Pointers）

5. 分治法（Divide and Conquer）

6. 优化（Optimization）

7. 简洁性（Simplicity）

举一反三

1. 原地算法（In-Place Algorithm）

2. 迭代（Iteration）

3. 递归（Recursion）

4. 双指针（Two Pointers）

5. 分治法（Divide and Conquer）

我的写法

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        str_num=''
        for digit in digits:
            str_num+=str(digit)
        
        return [int(digit) for digit in str(int(str_num)+1)]

这段代码定义了一个名为 Solution 的类，其中包含一个方法 plusOne，该方法接受一个整数列表 digits 作为输入，并返回一个新的整数列表。这个方法的目的是将列表中的数字视为一个整数，然后加1，最后将结果转换回整数列表。

代码分析

字符串拼接：首先，代码通过遍历输入的整数列表 digits，将每个整数转换为字符串，并拼接成一个完整的字符串 str_num。
整数加法：接着，将字符串 str_num 转换为整数，加1，然后再转换回字符串。
列表生成：最后，使用列表推导式将字符串中的每个字符转换为整数，并返回这个整数列表。

时间复杂度分析

字符串拼接：遍历整个 digits 列表，时间复杂度为 O(n)，其中 n 是列表的长度。
整数加法和转换：这部分操作的时间复杂度可以视为常数 O(1)。
列表生成：再次遍历字符串，时间复杂度为 O(n)。

因此，总的时间复杂度为 O(n) + O(1) + O(n) = O(n)。

空间复杂度分析

字符串 str_num：需要额外的空间来存储字符串，空间复杂度为 O(n)。
中间变量：整数加法和转换过程中使用的中间变量空间复杂度为 O(1)。
结果列表：最终生成的列表空间复杂度为 O(n)。

因此，总的空间复杂度为 O(n) + O(1) + O(n) = O(n)。

改进建议

这段代码虽然实现了功能，但可以通过更直接的方式来优化，避免不必要的字符串转换和拼接。例如，可以直接在整数列表上进行操作，通过模拟进位的方式来实现加1的操作，这样可以减少空间的使用，并且可能提高执行效率。

这种方法的时间复杂度仍然是 O(n)，但空间复杂度优化到了 O(1)，因为它避免了额外的字符串和列表生成。

我要更强

对于这个问题，直接将整数列表视为一个大整数加1，并不需要复杂的操作。最有效的方法依然是逐位处理进位，虽然时间复杂度已经是最优的 O(n)，但可以在空间上再做优化。下面我会给出几种不同的优化方法，尽量降低空间复杂度和时间复杂度。

方法 1：原地修改法

这是通过原地修改输入列表来实现加1操作，同时确保空间复杂度保持在 O(1)。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        n = len(digits)
        for i in range(n - 1, -1, -1):
            if digits[i] < 9:
                digits[i] += 1
                return digits
            digits[i] = 0
        
        # 处理进位到新的最高位
        return [1] + [0] * n

分析

时间复杂度：O(n)
空间复杂度：O(1)（不考虑输入和输出空间）

方法 2：使用双指针

双指针的方法可以避免不必要的遍历，但在这种特定问题上，双指针的优化空间不大。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        left, right = 0, len(digits) - 1
        
        while right >= 0:
            if digits[right] < 9:
                digits[right] += 1
                return digits
            digits[right] = 0
            right -= 1
        
        return [1] + [0] * len(digits)

分析

时间复杂度：O(n)
空间复杂度：O(1)（不考虑输入和输出空间）

方法 3：递归法

递归法可以优雅地处理进位问题，但在空间上会因为递归深度而增加。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        def helper(index):
            if index < 0:
                return [1] + digits
            
            if digits[index] < 9:
                digits[index] += 1
                return digits
            
            digits[index] = 0
            return helper(index - 1)
        
        return helper(len(digits) - 1)

分析

时间复杂度：O(n)
空间复杂度：O(n)（由于递归调用栈）

方法 4：迭代法

迭代法是最为常见且高效的方法。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for i in range(len(digits) - 1, -1, -1):
            if digits[i] < 9:
                digits[i] += 1
                return digits
            digits[i] = 0
        
        return [1] + [0] * len(digits)