在 [1, N] 范围内长度为 K 的序列的计数

有时候我们需要统计在给定范围内的序列中，长度为 K 的序列的数量。当每个元素都是其前一个元素的倍数时，我们可以进行一些优化来计算这个数量。

方法一：暴力求解

首先，我们可以使用暴力求解的方法来计算这个数量。我们可以使用嵌套循环来生成所有可能的序列组合，并检查其中的每个序列是否符合条件。这种方法的时间复杂度为 O(N^K)，不适用于大规模的输入。

def count_sequences(N: int, K: int) -> int:
    count = 0
    for i in range(1, N + 1):
        # 以 i 作为序列的起始元素
        seq = [i]
        for j in range(K - 1):
            # 计算序列的下一个元素
            next_num = seq[-1] * 2
            if next_num > N:
                break
            seq.append(next_num)
        if len(seq) == K:
            count += 1
    return count

方法二：动态规划

我们可以使用动态规划的方法来优化解决方案。我们可以定义一个二维数组 dp，其中 dp[i][j] 表示从 1 到 i 的范围内，长度为 j 的序列的数量。初始时，dp[i][1] 的值都为 1，因为任何数的长度为 1 的序列都只有一种可能。

然后，我们可以通过以下递推关系来计算 dp[i][j] 的值：

dp[i][j] = dp[k][j-1]，其中 k 是 i 的因子

最终，我们只需要返回 dp[N][K]，即为在 [1, N] 范围内长度为 K 的序列的数量。

def count_sequences(N: int, K: int) -> int:
    dp = [[0] * (K + 1) for _ in range(N + 1)]
    for i in range(1, N + 1):
        dp[i][1] = 1
    for i in range(1, N + 1):
        for j in range(2, K + 1):
            for k in range(1, i + 1):
                if i % k == 0:
                    dp[i][j] += dp[k][j - 1]
    return dp[N][K]

方法三：递归

我们还可以使用递归的方法来解决这个问题。我们可以定义一个辅助函数 count_sequences_recursive，该函数将递归地计算在 [start, N] 范围内长度为 K 的序列的数量。

def count_sequences_recursive(start: int, N: int, K: int) -> int:
    if K == 1:
        return 1
    count = 0
    for i in range(start, N + 1):
        if N % i == 0:
            count += count_sequences_recursive(i, N // i, K - 1)
    return count

def count_sequences(N: int, K: int) -> int:
    count = 0
    for i in range(1, N + 1):
        count += count_sequences_recursive(i, N, K)
    return count

以上是三种解决方法，你可以根据具体情况选择最适合的方法来计算在 [1, N] 范围内长度为 K 的序列的数量。