计数长度为 K 的序列，其中每一项都可以被其前一项整除

本题考察的是对递归和动态规划算法的理解以及应用。给出一些算法思路以及代码实现供参考。

题目描述

给定整数 n 和 k，计算所有长度为 k 的可能序列，其中每个数字都可以被前面的数字整除。

算法思路

方法一：递归

如果我们可以找到一个一般的递归方法来解决这个问题，那么我们可以非常容易地得到我们所需的答案。假设 F(i,j) 表示所有由 i 开头且长度为 j 的序列数量，那么有：

• F(i,j) = Sigma(F(i*m, j-1))，其中 m 为 i 的因子。

这样我们就可以得到一个简单的递归解决方案，但是这种方法的复杂度是指数级别的，因此这不是一个可行的方案。

方法二：动态规划

使用动态规划算法，我们可以在多项式时间内计算出正确的结果。首先我们定义一个二维数组 dp，其中 dp(i,j) 表示以 i 为结尾且长度为 j 的序列数量。有以下递推公式：

• dp(i,j) = Sigma(dp(i/m, j-1))，其中 m 为 i 的因数。

公式的意思是，对于以 i 为结尾且长度为 j 的序列，我们需要找到 i 的所有因子，然后将它们分别作为下一个数字，长度为 j-1 的序列的结尾。我们可以在 O(√n) 的时间内找到一个数的因子。最终答案是所有以 1 到 n 为结尾且长度为 k 的序列数量的和。

伪代码如下：

Initialize dp(i,j)=0 for all (i,j)
for i = 1 to n
    dp(i,1) = 1
for j = 2 to k
    for i = 1 to n
        for m = 1 to sqrt(i)
            if i % m == 0:
                dp(i,j) += dp(m,j-1)
                if m != sqrt(i):
                    dp(i,j) += dp(i/m,j-1)
count = 0
for i = 1 to n
    count += dp(i,k)
return count

代码实现

Python

def countSequences(n: int, k: int) -> int:
    dp = [[0] * (k + 1) for i in range(n + 1)]
    for i in range(1, n + 1):
        dp[i][1] = 1
    for j in range(2, k + 1):
        for i in range(1, n + 1):
            for m in range(1, int(i**0.5) + 1):
                if i % m == 0:
                    dp[i][j] += dp[m][j-1]
                    if m != i//m:
                        dp[i][j] += dp[i//m][j-1]
    count = 0
    for i in range(1, n + 1):
        count += dp[i][k]
    return count

Java

public static int countSequences(int n, int k) {
    int[][] dp = new int[n + 1][k + 1];
    for (int i = 1; i <= n; i++) {
        dp[i][1] = 1;
    }
    for (int j = 2; j <= k; j++) {
        for (int i = 1; i <= n; i++) {
            for (int m = 1; m <= (int) Math.sqrt(i); m++) {
                if (i % m == 0) {
                    dp[i][j] += dp[m][j-1];
                    if (m != i/m) {
                        dp[i][j] += dp[i/m][j-1];
                    }
                }
            }
        }
    }
    int count = 0;
    for (int i = 1; i <= n; i++) {
        count += dp[i][k];
    }
    return count;
}

总结

本题考察了递归和动态规划两种算法。递归虽然比较直观，但其复杂度是指数级别的，不适合用于实际的计算。动态规划算法可以在多项式时间内计算出解，是一个比较实用的算法。这也说明了动态规划算法可以用于解决更复杂的问题。