【LeetCode】902. 最大为 N 的数字组合

题目

902. 最大为 N 的数字组合

给定一个按 非递减顺序 排列的数字数组 digits 。你可以用任意次数 digits[i] 来写的数字。例如，如果 digits = ['1','3','5']，我们可以写数字，如 '13', '551', 和 '1351315'。

返回 可以生成的小于或等于给定整数 n 的正整数的个数 。

示例 1：

输入：digits = ["1","3","5","7"], n = 100
输出：20
解释：
可写出的 20 个数字是：
1, 3, 5, 7, 11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57, 71, 73, 75, 77.

示例 2：

输入：digits = ["1","4","9"], n = 1000000000
输出：29523
解释：
我们可以写 3 个一位数字，9 个两位数字，27 个三位数字，
81 个四位数字，243 个五位数字，729 个六位数字，
2187 个七位数字，6561 个八位数字和 19683 个九位数字。
总共，可以使用D中的数字写出 29523 个整数。

示例 3:

输入：digits = ["7"], n = 8
输出：1

提示：

• 1 <= digits.length <= 9
• digits[i].length == 1
• digits[i] 是从 '1' 到 '9' 的数
• digits 中的所有值都 不同
• digits 按 非递减顺序 排列
• 1 <= n <= 109

题解1(TLE)

思路

• 回溯所有情况，若当前值小于n则结果+1

代码

class Solution:
    def atMostNGivenDigitSet(self, digits: List[str], n: int) -> int:
        ret = 0
        def backtrack(cur: int):
            nonlocal ret
            for digit in digits:
                new = cur*10 + int(digit)
                if new > n: return
                ret += 1
                backtrack(new)
        backtrack(0)
        return ret

复杂度

• 时间复杂度：$O(n)$
• 空间复杂度：$O(lengt{h}_{digits})$

题解2

思路

• 找到由digits组成的最接近n的数字closest，所有位都小于或等于closest的数均符合题意 不能全为0，但可以有前导0
• 找到closest可以通过贪心思路，每一次都寻找最接近n位的最小值，若digits中的值小于当前值，后面全部补齐digits中的最大值，若等于则继续向下搜索，若大于则不断向上搜索直到某一位可以减小，若均不可以减小则第一位补0剩下的全为digits中的最大值
• 找到最接近的数字closest后，所有小于closest中的值后面可以接任何digits中的值，否则只能接小于closest中该位的值；这个值通过一个数组count保存
• 由上述可以获得状态转移方程：$dp[i]=(dp[i-1-1)\ast lengt{h}_{digits}+count[closest[i]]+1$
• 因为最后一位不能为0所以最后返回：$(dp-1)*length_{digits} + count[closest[-1]] $

代码

class Solution:
    def atMostNGivenDigitSet(self, digits: List[str], n: int) -> int:
        closest = 0
        invertedIndex = {v:k for k,v in enumerate(digits)}
        count = [0] * 10
        idx = i = 0
        while i < 10 and idx < len(digits):
            if i<=int(digits[idx]):
                count[i] = idx+1
                i+=1
            else:
                idx += 1
        for i in str(n):
            idx = bisect.bisect_right(digits, i)
            if idx == 0:
                s = list(str(closest))
                changed = False
                for i in range(len(s)-1, -1, -1):
                    if s[i] > digits[0]:
                        s[i] = digits[invertedIndex[s[i]]-1]
                        changed = True
                        break
                if changed:
                    while int("".join(s)) < n:
                        s.append(digits[-1])
                    closest = int("".join(s[:-1]))
                else:
                    s = s[1:]
                    if len(s) == 0: s.append("0")
                    while int("".join(s)) < n:
                        s.append(digits[-1])
                    closest = int("".join(s[:-1]))
                break
            else:
                closest = closest*10 + int(digits[idx-1])
                if digits[idx-1] < i:
                    s = list(str(closest))
                    while int("".join(s)) < n:
                        s.append(digits[-1])
                    closest = int("".join(s[:-1]))
                    break
        dp = 1
        for sn in str(closest)[:-1]:
            dp = (dp-1)*len(digits) + count[int(sn)] + 1
        return (dp-1)*len(digits) + count[int(str(closest)[-1])]      

复杂度

• 时间复杂度：$O(\log n+lengt{h}_{digits})$
• 空间复杂度：$O(\log n+lengt{h}_{digits})$