Array 的子序列计数，乘积的最后一位为 K

在计算机科学中，有一些有趣而实用的算法，其中之一是计算数组中的子序列数量，并找到这些子序列的乘积的最后一位。这个问题有多种解决方案，每种方案都有自己的优点和缺点。

问题描述

给定一个包含 n 个正整数的数组，我们要找到该数组中 k 的倍数的子序列的数量，同时计算这些子序列的乘积的最后一位。例如，给定数组 [2，4，6] 和 k = 4，则可以形成以下子序列：

• [2]，[4]，[6]
• [2，4]，[4，6]
• [2，4，6]

在这个子序列中，只有 [2，4] 和 [2，4，6] 是 4 的倍数。乘积 [2，4] 应为 8，因此其最后一位为 8 mod 10 = 8。同样，乘积 [2，4，6] 应为 48，因此其最后一位为 48 mod 10 = 8。

解决方案

暴力算法

暴力算法是最直接的解决方案，它通过枚举数组的所有子序列来解决问题。然后，计算每个子序列的乘积，并确定它是否是 k 的倍数。时间复杂度为 O(2^n * n)。这个算法的缺点是时间复杂度太高，对于大型数组，它会非常慢。

def count_subsequences(nums, k):
    count = 0
    for i in range(1, 1 << len(nums)):
        product = 1
        for j in range(len(nums)):
            if i >> j & 1:
                product *= nums[j]
        if product % k == 0:
            count += 1
    return count

哈希表

哈希表是解决这个问题的另一种方法。我们可以在读取数组时计算出每个前缀的余数，并使用这些余数在哈希表中进行计数。如果我们找到一个前缀的余数与另一个前缀的余数之差是 k 的倍数，那么就将计数器增加到哈希表中保存的数量。

时间复杂度为 O(n)。这里是一个 Python 实现：

def count_subsequences(nums, k):
    count = 0
    prefix_count = {0: 1}
    prefix_sum = 0
    for num in nums:
        prefix_sum = (prefix_sum + num) % k
        count += prefix_count.get(prefix_sum, 0)
        prefix_count[prefix_sum] = prefix_count.get(prefix_sum, 0) + 1
    return count

总结

以上是两种解决这个问题的方法。由于哈希表的时间复杂度更低，因此它可能是更好的选择，特别是在处理大量数据时。然而，暴力算法的代码更简单，因此对于小数组，它可能会更容易实现。