问题描述

给定一个只包含 2, 5 和 6 的一维列表，代表了每个单位数字所需的最小数字计数。单位数字 X 需要使用 A 个 2, B 个 5 和 C 个 6，即 X = 2^A * 5^B * 6^C。现在给定总和 N，你需要计算需要至少多少个数字才能得到总和 N，注意同一个数字只能被计算一次。

解题思路

这道题考察了一个对数学知识的广泛运用，需要我们从数字的因式分解的角度去思考。

我们可以把数字拆分成一个一个的质因数，如数字 500 就可以拆分成 2^2 * 5^3。因此，我们可以考虑将列表中的数值拆分成质因数，然后通过数字的因式分解，来计算最终数字的组合方式。

为了避免重复，我们可以使用动态规划的算法来计算。

我们可以用 dp[i][j] 表示通过前 i 个质因数，能够拼凑出的数字总和为 j 的最少的数字个数。对于每个质因数，我们都有选或不选两种情况：

• 如果我们选择这个质因数，那么当前数字的总和就会加上这个质因数的值。
• 如果我们不选这个质因数，那么当前数字的总和不变。

我们可以将每个质因数看作一个物品，将它们按照质因数的值从小到大排列。然后对于每一个质因数，我们依次求出 dp[i][j]，再求 dp[i + 1][j]。

在求 dp[i + 1][j] 时，对于第 i + 1 个质因数，我们有两种情况：

• 不选第 i + 1个质因数，此时 dp[i + 1][j] 就等于 dp[i][j]。
• 选第 i + 1 个质因数，此时需要满足 j 大于等于当前质因数的值，即 j >= primes[i + 1]。此时 dp[i + 1][j] 就等于 dp[i + 1][j - primes[i + 1]] + 1。

最终我们可以返回 dp[len(primes) - 1][N] 的值，即使用前 len(primes) 个质因数可以拼凑出的总和为 N 的最小数字个数。

复杂度分析

该算法使用了动态规划的思想，时间复杂度取决于状态转移的次数，即 O(N * len(primes))。空间复杂度为 O(N * len(primes))。

代码实现

def minCount(primes, N):
    """
    :type primes: List[int]
    :type N: int
    :rtype: int
    """
    # 对质因数列表按照值从小到大排序
    primes = sorted(primes)
    
    # 初始化动态规划矩阵，全部为无穷大
    dp = [[float("inf")] * (N + 1) for _ in range(len(primes))]
    
    # 对第一个质因数进行初始化
    for i in range(N + 1):
        if i % primes[0] == 0:
            dp[0][i] = i // primes[0]
    
    # 对每个质因数进行状态转移
    for i in range(1, len(primes)):
        for j in range(N + 1):
            # 不选第 i 个质因数
            dp[i][j] = dp[i - 1][j]
            
            # 选第 i 个质因数
            if j >= primes[i]:
                dp[i][j] = min(dp[i][j], dp[i][j - primes[i]] + 1)
    
    # 返回最终结果
    return dp[len(primes) - 1][N]

参考资料

王道考研机试指南 - 第 5 章：动态规划（下）