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

给定两个整数N和K，该任务是找到长度K的序列的从区间[1，N]，使得每个第(i + 1)^个序列中的元件是由它的前面的I整除组成值的数量^第一个元素。

例子：

Input: N = 3, K = 2 
Output: 5 
Explanation: 
The 5 sequence are [1, 1], [2, 2], [3, 3], [1, 2], [1, 3]

Input: N = 6 K= 4 
Output: 39 
 

方法：
请按照以下步骤解决问题：

1. 初始化矩阵fct[][]并将i的因子存储在fct[i]行中，其中 i 位于[1, N]范围内。
2. 初始化一个矩阵dp[][] ，该矩阵在dp[i][j]处存储长度为i 的以j结尾的序列的数量。
3. 如果^第i^个索引具有j ，则第(i – 1)^个索引应由factor(j) 组成。类似地，第(i – 2)^个索引应该由一个factor(factor(j)) 组成。
4. 因此， dp[i][j]应该包含所有可能的 (i – 1) 长度序列，以因子 j 结尾。
5. 因此， dp[i][j]等于所有可能的dp[i – 1][fct[j][k]] 之和，其中dp[i – 1][fct[j][k]]表示以j 的^第k^个因子结尾的长度为i – 1的总序列的计数。
6. 最后，从1<=j<=N 中找出所有dp[K][j]的总和并返回总和。

下面是上述方法的实现：

C++14

// C++ Program to implement the
// above approach
 
#include 
using namespace std;
 
#define ll long long
 
// Stores the factors of i-th
// element in v[i]
vector vp[2009];
 
// Function to find all the
// factors of N
void finding_factors(ll int n)
{
    ll int i, a;
 
    // Iterate upto sqrt(N)
    for (i = 1; i * i <= n; i++) {
 
        if (n % i == 0) {
 
            if (i * i == n) {
                vp[n].push_back(i);
            }
 
            else {
                vp[n].push_back(i);
                vp[n].push_back(n / i);
            }
        }
    }
}
 
// Function to return the count of
// sequences of length K having
// all terms divisible by its
// preceding term
ll int countSeq(ll int N, ll int K)
{
    ll int i, j, k;
 
    ll int dp[109][109] = { 0 };
 
    for (i = 1; i <= N; i++) {
 
        // Calculate factors of i
        finding_factors(i);
 
        // Initialize dp[0][i] = 0: No
        // subsequence of length 0 ending
        // with i-th element exists
        dp[0][i] = 0;
 
        // Initialize dp[0][i] = 1: Only 1
        // subsequence of length 1 ending
        // with i-th element exists
        dp[1][i] = 1;
    }
 
    // Iterate [2, K] to obtain sequences
    // of each length
    for (i = 2; i <= K; i++) {
 
        for (j = 1; j <= N; j++) {
 
            // Calculate sum of
            // all dp[i-1][vp[j][k]]
 
            ll int sum = 0;
 
            for (k = 0; k < vp[j].size(); k++) {
 
                // vp[j][k] stores all factors
                // of j
                sum = (sum + dp[i - 1][vp[j][k]]);
            }
 
            // Store the sum in A[i][j]
            dp[i][j] = sum;
        }
    }
 
    ll int ans = 0;
    for (j = 1; j <= N; j++) {
 
        // Sum of all dp[K][j] obtain all
        // K length sequences ending with j
        ans = (ans + dp[K][j]);
    }
    return ans;
}
 
// Driver code
int main()
{
 
    ll int N, K;
    N = 3;
    K = 2;
 
    cout << countSeq(N, K) << endl;
    return 0;
}

Java

// Java program to implement the
// above approach
import java.util.*;
 
class GFG{
 
// Stores the factors of i-th
// element in v[i]
@SuppressWarnings("unchecked")
static Vector []vp = new Vector[2009];
 
// Function to find all the
// factors of N
static void finding_factors(int n)
{
    int i, a;
 
    // Iterate upto Math.sqrt(N)
    for(i = 1; i * i <= n; i++)
    {
        if (n % i == 0)
        {
            if (i * i == n)
            {
                vp[n].add(i);
            }
            else
            {
                vp[n].add(i);
                vp[n].add(n / i);
            }
        }
    }
}
 
// Function to return the count of
// sequences of length K having
// aint terms divisible by its
// preceding term
static int countSeq(int N, int K)
{
    int i, j, k;
 
    int dp[][] = new int[109][109];
 
    for(i = 1; i <= N; i++)
    {
 
        // Calculate factors of i
        finding_factors(i);
 
        // Initialize dp[0][i] = 0: No
        // subsequence of length 0 ending
        // with i-th element exists
        dp[0][i] = 0;
 
        // Initialize dp[0][i] = 1: Only 1
        // subsequence of length 1 ending
        // with i-th element exists
        dp[1][i] = 1;
    }
 
    // Iterate [2, K] to obtain sequences
    // of each length
    for(i = 2; i <= K; i++)
    {
        for(j = 1; j <= N; j++)
        {
 
            // Calculate sum of
            // aint dp[i-1][vp[j][k]]
            int sum = 0;
 
            for(k = 0; k < vp[j].size(); k++)
            {
 
                // vp[j][k] stores aint factors
                // of j
                sum = (sum + dp[i - 1][vp[j].get(k)]);
            }
 
            // Store the sum in A[i][j]
            dp[i][j] = sum;
        }
    }
 
    int ans = 0;
    for(j = 1; j <= N; j++)
    {
 
        // Sum of aint dp[K][j] obtain all
        // K length sequences ending with j
        ans = (ans + dp[K][j]);
    }
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int N, K;
    N = 3;
    K = 2;
     
    for(int i = 0; i < vp.length; i++)
        vp[i] = new Vector();
         
    System.out.print(countSeq(N, K) + "\n");
}
}
 
// This code is contributed by gauravrajput1

Python3

# Python3 program to implement the
# above approach
 
# Stores the factors of i-th
# element in v[i]
vp = [[] for i in range(2009)]
 
# Function to find all the
# factors of N
def finding_factors(n):
     
    i = 1
    a = 0
     
    global vp
 
    # Iterate upto sqrt(N)
    while (i * i <= n):
        if (n % i == 0):
            if (i * i == n):
                vp[n].append(i)
            else:
                vp[n].append(i)
                vp[n].append(int(n / i))
                 
        i += 1
 
# Function to return the count of
# sequences of length K having
# all terms divisible by its
# preceding term
def countSeq(N, K):
     
    i = 0
    j = 0
    k = 0
 
    dp = [[0 for i in range(109)]
             for j in range(109)]
 
    for i in range(1, N + 1):
         
        # Calculate factors of i
        finding_factors(i)
 
        # Initialize dp[0][i] = 0: No
        # subsequence of length 0 ending
        # with i-th element exists
        dp[0][i] = 0
         
        # Initialize dp[0][i] = 1: Only 1
        # subsequence of length 1 ending
        # with i-th element exists
        dp[1][i] = 1
 
    # Iterate [2, K] to obtain sequences
    # of each length
    for i in range(2, K + 1):
        for j in range(1, N + 1):
             
            # Calculate sum of
            # all dp[i-1][vp[j][k]]
            Sum = 0
 
            for k in range(len(vp[j])):
                 
                # vp[j][k] stores all factors
                # of j
                Sum += dp[i - 1][vp[j][k]]
                 
            # Store the sum in A[i][j]
            dp[i][j] = Sum
 
    ans = 0
    for j in range(1, N + 1):
         
        # Sum of all dp[K][j] obtain all
        # K length sequences ending with j
        ans += dp[K][j]
 
    return ans
 
# Driver code
N = 3
K = 2
 
print(countSeq(N, K))
 
# This code is contributed by avanitrachhadiya2155

C#

// C# program to implement the
// above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Stores the factors of i-th
// element in v[i]
static List []vp = new List[2009];
 
// Function to find all the
// factors of N
static void finding_factors(int n)
{
    int i ;
 
    // Iterate upto Math.Sqrt(N)
    for(i = 1; i * i <= n; i++)
    {
        if (n % i == 0)
        {
            if (i * i == n)
            {
                vp[n].Add(i);
            }
            else
            {
                vp[n].Add(i);
                vp[n].Add(n / i);
            }
        }
    }
}
 
// Function to return the count of
// sequences of length K having
// aint terms divisible by its
// preceding term
static int countSeq(int N, int K)
{
    int i, j, k;
 
    int [,]dp = new int[109, 109];
 
    for(i = 1; i <= N; i++)
    {
 
        // Calculate factors of i
        finding_factors(i);
 
        // Initialize dp[0,i] = 0: No
        // subsequence of length 0 ending
        // with i-th element exists
        dp[0, i] = 0;
 
        // Initialize dp[0,i] = 1: Only 1
        // subsequence of length 1 ending
        // with i-th element exists
        dp[1, i] = 1;
    }
 
    // Iterate [2, K] to obtain sequences
    // of each length
    for(i = 2; i <= K; i++)
    {
        for(j = 1; j <= N; j++)
        {
 
            // Calculate sum of
            // aint dp[i-1,vp[j,k]]
            int sum = 0;
 
            for(k = 0; k < vp[j].Count; k++)
            {
 
                // vp[j,k] stores aint factors
                // of j
                sum = (sum + dp[i - 1, vp[j][k]]);
            }
 
            // Store the sum in A[i,j]
            dp[i,j] = sum;
        }
    }
 
    int ans = 0;
    for(j = 1; j <= N; j++)
    {
 
        // Sum of aint dp[K,j] obtain all
        // K length sequences ending with j
        ans = (ans + dp[K, j]);
    }
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int N, K;
    N = 3;
    K = 2;
     
    for(int i = 0; i < vp.Length; i++)
        vp[i] = new List();
         
    Console.Write(countSeq(N, K) + "\n");
}
}
 
// This code is contributed by Rohit_ranjan

Javascript

 
// JavaScript program to implement the
// above approach
 
// Stores the factors of i-th
// element in v[i]
let vp =  new Array(2009);
 
// Function to find all the
// factors of N
function finding_factors(n)
{
    let i, a;
 
    // Iterate upto Math.sqrt(N)
    for(i = 1; i * i <= n; i++)
    {
        if (n % i == 0)
        {
            if (i * i == n)
            {
                vp[n].push(i);
            }
            else
            {
                vp[n].push(i);
                vp[n].push(n / i);
            }
        }
    }
}
 
// Function to return the count of
// sequences of length K having
// alet terms divisible by its
// preceding term
function countSeq(N, K)
{
    let i, j, k;
 
    let dp = new Array(109);
    // Loop to create 2D array using 1D array
    for (let i = 0; i < dp.length; i++) {
        dp[i] = new Array(2);
    }   
 
    for(i = 1; i <= N; i++)
    {
 
        // Calculate factors of i
        finding_factors(i);
 
        // Initialize dp[0][i] = 0: No
        // subsequence of length 0 ending
        // with i-th element exists
        dp[0][i] = 0;
 
        // Initialize dp[0][i] = 1: Only 1
        // subsequence of length 1 ending
        // with i-th element exists
        dp[1][i] = 1;
    }
 
    // Iterate [2, K] to obtain sequences
    // of each length
    for(i = 2; i <= K; i++)
    {
        for(j = 1; j <= N; j++)
        {
 
            // Calculate sum of
            // alet dp[i-1][vp[j][k]]
            let sum = 0;
 
            for(k = 0; k < vp[j].length; k++)
            {
 
                // vp[j][k] stores alet factors
                // of j
                sum = (sum + dp[i - 1][vp[j][k]]);
            }
 
            // Store the sum in A[i][j]
            dp[i][j] = sum;
        }
    }
 
    let ans = 0;
    for(j = 1; j <= N; j++)
    {
 
        // Sum of alet dp[K][j] obtain all
        // K length sequences ending with j
        ans = (ans + dp[K][j]);
    }
    return ans;
}
// Driver Code
 
    let N, K;
    N = 3;
    K = 2;
     
    for(let i = 0; i < vp.length; i++)
        vp[i] = [];
         
    document.write(countSeq(N, K) + "\n");
 

输出：

5

时间复杂度： O (K * N ^3/2 )
辅助空间： O (N ² )