剑指 Offer 17. 打印从1到最大的n位数

最新推荐文章于 2024-09-12 19:02:20 发布

cool_coder_han

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量190

点赞数

分类专栏： leetcode 文章标签：算法 python

本文链接：https://blog.csdn.net/Hanfeige/article/details/108195036

版权

leetcode 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

剑指 Offer 17. 打印从1到最大的n位数

题目描述：

输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

示例：
输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]

说明：
1.用返回一个整数列表来代替打印
2.n 为正整数

# solo
# 解题思路：根据n来确定列表的最大值9的个数为n个。如n=2，输出列表最后一个数即最大值是99
class Solution:
    def printNumbers(self, n: int) -> List[int]:
        while n !=0:
            max=0
            for i in range(n): # 找出最大的数即9的个数
                max=max*10+9
            result = list(range(1, max+1)) #排除掉0，加上1因为range（n）不包括n
            return result

# good
"""
最大的 nn 位数（记为 endend ）和位数 nn 的关系： 例如最大的 11 位数是 99 ，最大的 22 位数是 9999 ，最大的 33 位数是 999999
则可推出公式：end=10*n-1  #比9的个数方法简单多了。

"""
class Solution:
    def printNumbers(self, n: int) -> List[int]:
        res = [] # 建立空列表的两种方式：1.res=list() 注意是（）不是[]  2. res=[]
        for i in range(1, 10 ** n):
            res.append(i)
        return res

大数打印解法：
实际上，本题的主要考点是大数越界情况下的打印。需要解决以下三个问题：

表示大数的变量类型：
无论是 short / int / long … 任意变量类型，数字的取值范围都是有限的。因此，大数的表示应用字符串 String 类型。
生成数字的字符串集：
使用 int 类型时，每轮可通过 +1+1 生成下个数字，而此方法无法应用至 String 类型。并且， String 类型的数字的进位操作效率较低，例如 “9999” 至 “10000” 需要从个位到千位循环判断，进位 4 次。

观察可知，生成的列表实际上是 n 位 0 - 9 的全排列，因此可避开进位操作，通过递归生成数字的 String 列表。

递归生成全排列：
基于分治算法的思想，先固定高位，向低位递归，当个位已被固定时，添加数字的字符串。例如当 n=2 时（数字范围 1 - 99），固定十位为 0 - 9 ，按顺序依次开启递归，固定个位 0 - 9 ，终止递归并添加数字字符串。

根据以上方法，可初步编写全排列代码：

class Solution:
    def printNumbers(self, n: int) -> [int]:
        def dfs(x):
            if x == n: # 终止条件：已固定完所有位
                res.append(''.join(num)) # 拼接 num 并添加至 res 尾部
                return
            for i in range(10): # 遍历 0 - 9
                num[x] = str(i) # 固定第 x 位为 i
                dfs(x + 1) # 开启固定第 x + 1 位
        
        num = ['0'] * n # 起始数字定义为 n 个 0 组成的字符列表
        res = [] # 数字字符串列表
        dfs(0) # 开启全排列递归
        return ','.join(res)  # 拼接所有数字字符串，使用逗号隔开，并返回

在此方法下，各数字字符串被逗号隔开，共同组成长字符串。返回的数字集字符串如下所示：

输入：n = 1
输出："0,1,2,3,4,5,6,7,8,9"

输入：n = 2
输出："00,01,02,...,10,11,12,...,97,98,99"

输入：n = 3
输出："000,001,002,...,100,101,102,...,997,998,999"

观察可知，当前的生成方法仍有以下问题：

1.诸如 00, 01, 02,⋯ 应显示为 0, 1, 2,⋯ ，即应删除高位多余的 0 ;
2.此方法从 0 开始生成，而题目要求列表从 1 开始；

以上两个问题的解决方法如下：

删除高位多余的 0 ：
字符串左边界定义：声明变量start 规定字符串的左边界，以保证添加的数字字符串 num[start:] 中无高位多余的 00 。例如当 n = 2时， 1 - 91−9 时 start = 1 ， 10 - 9910−99 时 start = 0 。

左边界 start 变化规律：观察可知，当输出数字的所有位都是 99 时，则下个数字需要向更高位进 11 ，此时左边界 start 需要减 1 （即高位多余的 0 减少一个）。例如n=3 （数字范围 1−999 ）时，左边界 start 需要减 1 的情况有： “009” 进位至 “010” ， “099” 进位至 “100” 。设数字各位中 99 的数量为nine ，所有位都为 99 的判断条件可用以下公式表示：

n - start = nine
n−start=nine

统计 nine 的方法：固定第 x 位时，当i=9 则执行 nine=nine+1 ，并在回溯前恢复nine=nine−1 。

列表从 1 开始：
在以上方法的基础上，添加数字字符串前判断其是否为 “0” ，若为 “0” 则直接跳过。

复杂度分析：
时间复杂度 O(10^n)

递归的生成的排列的数量为 10^n

空间复杂度 O(n) ：字符列表 num 使用线性大小的额外空间。
代码：
为正确表示大数，以下代码的返回值为数字字符串集拼接而成的长字符串。

class Solution:
    def printNumbers(self, n: int) -> [int]:
        def dfs(x):
            if x == n:
                s = ''.join(num[self.start:])
                if s != '0': res.append(s)
                if n - self.start == self.nine: self.start -= 1
                return
            for i in range(10):
                if i == 9: self.nine += 1
                num[x] = str(i)
                dfs(x + 1)
            self.nine -= 1
        
        num, res = ['0'] * n, []
        self.nine = 0
        self.start = n - 1
        dfs(0)
        return ','.join(res)

本题要求输出 int 类型数组。为运行通过，可在添加数字字符串 s 前，将其转化为 int 类型。代码如下所示：

class Solution:
    def printNumbers(self, n: int) -> [int]:
        def dfs(x):
            if x == n:
                s = ''.join(num[self.start:])
                if s != '0': res.append(int(s))
                if n - self.start == self.nine: self.start -= 1
                return
            for i in range(10):
                if i == 9: self.nine += 1
                num[x] = str(i)
                dfs(x + 1)
            self.nine -= 1
        
        num, res = ['0'] * n, []
        self.nine = 0
        self.start = n - 1
        dfs(0)
        return res

、