Problem:
Score : 600 points

Problem Statement

Find the number of sequences of length K consisting of positive integers such that the product of any two adjacent elements is at most N, modulo 10^9+7.

Constraints

1\leq N\leq 10^9

1 2\leq K\leq 100 (fixed at 21:33 JST)

N and K are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the number of sequences, modulo 10^9+7.

Sample Input 1

3 2

Sample Output 1

5

(1,1), (1,2), (1,3), (2,1), and (3,1) satisfy the condition.

Sample Input 2

10 3

Sample Output 2

147

Sample Input 3

314159265 35

Sample Output 3

457397712

Solution in Rust (1.15.1) (judge verdict: Accepted)

fn read_stdin() -> String {
    use std::io::Read;
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input).unwrap();
    input
}

fn scan<'a, I: Iterator<Item = &'a str>, T: std::str::FromStr>(tokens: &mut I) -> T {
    tokens.next().unwrap().parse().ok().unwrap()
}

const MODULO: usize = 1_000_000_007;

fn main() {
    let input = read_stdin();
    let tokens = &mut input.split_whitespace();
    let n: usize = scan(tokens);
    let k: usize = scan(tokens);
    if n == 1 {
        println!("1");
        return;
    }
    let mut r = 0;
    while r * r <= n {
        r += 1;
    }
    r -= 1;
    let mut c: Vec<usize> = vec![1; 2 * r + 1];
    for i in 1..r {
        c[2 * r + 1 - i] = n / i - n / (i + 1);
    }
    c[r + 1] = n / r - r;
    let mut dp: Vec<Vec<usize>> = vec![vec![1; 2 * r + 1]; 2];
    for i in 2..k + 1 {
        dp[i & 1][2 * r] = dp[(i - 1) & 1][1] * c[1] % MODULO;
        for j in 2..2 * r + 1 {
            dp[i & 1][2 * r + 1 - j] =
                (dp[i & 1][2 * r + 1 - j + 1] + dp[(i - 1) & 1][j] * c[j]) % MODULO;
        }
    }
    let mut ans: usize = 0;
    for i in 1..2 * r + 1 {
        ans = (ans + dp[k & 1][i] * c[i]) % MODULO;
    }
    println!("{}", ans);
}